[ViewVC] Diff of: cvs/rxvt-unicode/src/xpm.C

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.56 by sasha, Fri Aug 3 22:40:10 2007 UTC vs.
Revision 1.61 by ayin, Tue Aug 7 15:23:11 2007 UTC

…		…
47	* Adjusting position only :	47	* Adjusting position only :
48	* =+X+Y Set position to X% by Y% (absolute).	48	* =+X+Y Set position to X% by Y% (absolute).
49	* =+X Set position to X% by X%.	49	* =+X Set position to X% by X%.
50	* +X+Y Adjust position horizontally X% and vertically Y%	50	* +X+Y Adjust position horizontally X% and vertically Y%
51	* from current position (relative).	51	* from current position (relative).
52	* +X+X Adjust position horizontally X% and vertically X%	52	* +X Adjust position horizontally X% and vertically X%
53	* from current position.	53	* from current position.
54	*	54	*
55	* Adjusting scale only :	55	* Adjusting scale only :
56	* Wx0 Multiply horizontal scaling factor by W%	56	* Wx0 Multiply horizontal scaling factor by W%
57	* 0xH Multiply vertical scaling factor by H%	57	* 0xH Multiply vertical scaling factor by H%
…		…
72		72
73	#ifdef HAVE_BG_PIXMAP	73	#ifdef HAVE_BG_PIXMAP
74	bool	74	bool
75	bgPixmap_t::window_size_sensitive ()	75	bgPixmap_t::window_size_sensitive ()
76	{	76	{
77	return (flags&(bgPmap_Scale\|bgPmap_Transparent));	77	#ifdef XPM_BACKGROUND
		78	#ifdef HAVE_AFTERIMAGE
		79	if (original_asim != NULL)
		80	#endif
		81	{
		82	if (h_scale != 0 \|\| v_scale != 0)
		83	return true;
		84	}
		85	#endif
		86	#ifdef ENABLE_TRANSPARENCY
		87	if (flags & bgPmap_Transparent)
		88	return true;
		89	#endif
		90	return false;
78	}	91	}
79		92
80	#ifdef XPM_BACKGROUND	93	#ifdef XPM_BACKGROUND
		94	static inline bool
		95	check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
		96	{
		97	if (geom_flags & flag)
		98	{
		99	if (new_value > 1000)
		100	new_value = 1000;
		101	if (new_value != scale)
		102	{
		103	scale = new_value;
		104	return true;
		105	}
		106	}
		107	return false;
		108	}
		109
		110	static inline bool
		111	check_set_align_value (int geom_flags, int flag, int &align, int new_value)
		112	{
		113	if (geom_flags & flag)
		114	{
		115	if (new_value < -100)
		116	new_value = -100;
		117	else if (new_value > 200)
		118	new_value = 200;
		119	if (new_value != align)
		120	{
		121	align = new_value;
		122	return true;
		123	}
		124	}
		125	return false;
		126	}
		127
		128	static inline int
		129	make_align_position (int align, int window_size, int image_size)
		130	{
		131	int diff = window_size - image_size;
		132	int smaller = MIN (image_size,window_size);
		133
		134	if (align >= 0 && align <= 50)
		135	return diff * align / 100;
		136	else if (align > 50 && align <= 100)
		137	return window_size - image_size + diff * align / 100;
		138	else if (align > 100 && align <= 200 )
		139	return ((align - 100) * smaller / 100) + window_size - smaller;
		140	else if (align > -100 && align < 0)
		141	return ((align + 100) * smaller / 100) - image_size;
		142	return 0;
		143	}
		144
		145	static inline void
		146	make_clip_rectangle (int pos, int size, int target_size, int &clip_pos, int &clip_size)
		147	{
		148	if (size <= 0)
		149	{ /* special case - tiling */
		150	clip_pos = pos;
		151	clip_size = target_size;
		152	}
		153	else if (pos < 0)
		154	{
		155	clip_pos = 0;
		156	clip_size = MIN (target_size, size + pos);
		157	}
		158	else
		159	{
		160	clip_pos = pos;
		161	clip_size = size;
		162	if (pos < target_size && (int)clip_size > target_size - pos)
		163	clip_pos = target_size - pos;
		164	}
		165	}
		166
81	bool	167	bool
82	bgPixmap_t::handle_geometry (const char *geom)	168	bgPixmap_t::handle_geometry (const char *geom)
83	{	169	{
84	int geom_flags, changed = 0;	170	int geom_flags = 0, changed = 0;
85	int x = 0, y = 0;	171	int x = 0, y = 0;
86	unsigned int w = 0, h = 0;	172	unsigned int w = 0, h = 0;
87	unsigned int n;	173	unsigned int n;
88	unsigned long new_flags = (flags&(~bgPmap_geometryFlags)) ;	174	unsigned long new_flags = (flags&(~bgPmap_geometryFlags));
89	char *p;	175	char *p;
90	#define MAXLEN_GEOM sizeof("[10000x10000+10000+10000]")	176	#define MAXLEN_GEOM 256 /* could be longer then regular geometry string */
91		177
92	if (geom == NULL)	178	if (geom == NULL)
93	return false;	179	return false;
94		180
95	char str[MAXLEN_GEOM];	181	char str[MAXLEN_GEOM];
…		…
102	min (h_align, 32767), min (v_align, 32767));	188	min (h_align, 32767), min (v_align, 32767));
103	process_xterm_seq (XTerm_title, str, CHAR_ST);	189	process_xterm_seq (XTerm_title, str, CHAR_ST);
104	#endif	190	#endif
105	return false;	191	return false;
106	}	192	}
107		193	while (isspace(*geom)) ++geom;
108	if ((p = strchr (geom, ';')) == NULL)	194	if ((p = strchr (geom, ';')) == NULL)
109	p = strchr (geom, '\0');	195	p = strchr (geom, '\0');
110		196
111	n = (p - geom);	197	n = (p - geom);
112	if (n < MAXLEN_GEOM)	198	if (n < MAXLEN_GEOM)
113	{	199	{
		200	char *ops;
114	new_flags \|= bgPmap_geometrySet;	201	new_flags \|= bgPmap_geometrySet;
115		202
116	strncpy (str, geom, n);	203	strncpy (str, geom, n);
117	str[n] = '\0';	204	str[n] = '\0';
118		205	if (str[0] == ':')
119	if (strcmp(str, "auto") == 0)	206	ops = &str[0];
120	{	207	else if (str[0] != 'x' && str[0] != 'X' && isalpha(str[0]))
121	w = h = 100;	208	ops = &str[0];
122	geom_flags = WidthValue\|HeightValue ;
123	}
124	else	209	else
125	{	210	{
		211	char *tmp;
		212	ops = strchr (str, ':');
		213	if (ops != NULL)
		214	{
		215	for (tmp = ops-1; tmp >= str && isspace(*tmp); --tmp);
		216	*(++tmp) = '\0';
		217	if (ops == tmp) ++ops;
		218	}
		219	}
		220
		221	if (ops > str \|\| ops == NULL)
		222	{
		223	/* we have geometry string - let's handle it prior to applying ops */
126	geom_flags = XParseGeometry (str, &x, &y, &w, &h);	224	geom_flags = XParseGeometry (str, &x, &y, &w, &h);
127	}
128	/* code below is garbage and needs to be rewritten */
129	if (!geom_flags)
130	{
131	geom_flags \|= WidthValue;
132	w = 0;
133	} /* default is tile */
134		225
135	if (geom_flags & WidthValue)	226	if ((geom_flags & XValue) && !(geom_flags & YValue))
136	{
137	if (!(geom_flags & XValue))
138	x = 50;
139
140	if (!(geom_flags & HeightValue))
141	h = w;
142
143	if (w && !h)
144	{	227	{
145	w = (h_scale * w) / 100;
146	h = v_scale;	228	y = x;
		229	geom_flags \|= YValue;
147	}	230	}
148	else if (h && !w)	231
		232	if (flags & bgPmap_geometrySet)
		233	{/* new geometry is an adjustment to the old one ! */
		234	if ((geom_flags & WidthValue) && (geom_flags & HeightValue))
		235	{
		236	if (w == 0 && h != 0)
		237	{
		238	w = h_scale;
		239	h = (v_scale * h) / 100;
		240	}
		241	else if (h == 0 && w != 0)
		242	{
		243	w = (h_scale * w) / 100;
		244	h = v_scale;
		245	}
		246	}
		247	if (geom_flags & XValue)
		248	{
		249	if (str[0] != '=')
		250	{
		251	y += v_align;
		252	x += h_align;
		253	}
		254	}
		255	}
		256	else /* setting up geometry from scratch */
149	{	257	{
		258	if (!(geom_flags & XValue))
		259	{/* use default geometry - centered */
		260	x = y = bgPmap_defaultAlign;
		261	}
		262	else if (!(geom_flags & YValue))
		263	y = x;
		264
		265	if ((geom_flags & (WidthValue\|HeightValue)) == 0)
		266	{/* use default geometry - scaled */
		267	w = h = bgPmap_defaultScale;
		268	}
		269	else if (geom_flags & WidthValue)
		270	{
		271	if (!(geom_flags & HeightValue))
		272	h = w;
		273	}
		274	else
150	w = h_scale;	275	w = h;
151	h = (v_scale * h) / 100;
152	}	276	}
		277	} /* done parsing geometry string */
		278	else if (!(flags & bgPmap_geometrySet))
		279	{ /* default geometry - scaled and centered */
		280	x = y = bgPmap_defaultAlign;
		281	w = h = bgPmap_defaultScale;
		282	}
		283
		284	if (!(flags & bgPmap_geometrySet))
		285	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
153		286
154	min_it (w, 32767);	287	if (ops)
155	min_it (h, 32767);	288	{
156		289	while (*ops)
157	if (h_scale != w)
158	{	290	{
159	h_scale = w;	291	while (ops == ':' \|\| isspace(ops)) ++ops;
160	changed++;	292	#define CHECK_GEOM_OPS(op_str) (strncasecmp (ops, (op_str), sizeof(op_str)-1) == 0)
161	}	293	if (CHECK_GEOM_OPS("tile"))
162
163	if (v_scale != h)
164	{	294	{
165	v_scale = h;	295	w = h = 0;
166	changed++;	296	geom_flags \|= WidthValue\|HeightValue;
167	}	297	}
168	}	298	else if (CHECK_GEOM_OPS("propscale"))
169	if (!(geom_flags & YValue))	299	{
		300	if (w == 0 && h == 0)
		301	{
		302	w = 100;
		303	geom_flags \|= WidthValue;
		304	}
		305	new_flags \|= bgPmap_propScale;
		306	}
		307	else if (CHECK_GEOM_OPS("hscale"))
		308	{
		309	if (w == 0)
		310	w = 100;
		311	h = 0;
		312	geom_flags \|= WidthValue\|HeightValue;
		313	}
		314	else if (CHECK_GEOM_OPS("vscale"))
		315	{
		316	if (h == 0)
		317	h = 100;
		318	w = 0;
		319	geom_flags \|= WidthValue\|HeightValue;
		320	}
		321	else if (CHECK_GEOM_OPS("scale"))
		322	{
		323	if (h == 0)
		324	h = 100;
		325	if (w == 0)
		326	w = 100;
		327	geom_flags \|= WidthValue\|HeightValue;
		328	}
		329	else if (CHECK_GEOM_OPS("auto"))
		330	{
		331	w = h = 100;
		332	x = y = 50;
		333	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
		334	}
		335	#undef CHECK_GEOM_OPS
		336	while (ops != ':' && ops != '\0') ++ops;
		337	} /* done parsing ops */
170	{	338	}
171	if (geom_flags & XNegative)
172	geom_flags \|= YNegative;
173		339
174	y = x;	340	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w))
175	}
176
177	if (!(geom_flags & WidthValue) && geom[0] != '=')
178	{
179	x += h_align;
180	y += v_align;
181	}
182
183	if (h_align != x)
184	{
185	h_align = x;
186	changed++;	341	++changed;
187	}	342	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h))
188
189	if (v_align != y)
190	{
191	v_align = y;
192	changed++;	343	++changed;
193	}	344	if (check_set_align_value (geom_flags, XValue, h_align, x))
194		345	++changed;
195	if (h_scale != 0)	346	if (check_set_align_value (geom_flags, YValue, v_align, y))
196	new_flags \|= bgPmap_hScale;	347	++changed;
197	if (v_scale != 0)
198	new_flags \|= bgPmap_vScale;
199	}	348	}
200		349
201	if (new_flags != flags)	350	if (new_flags != flags)
202	{	351	{
203	flags = new_flags;	352	flags = new_flags;
204	changed++;	353	changed++;
205	}	354	}
		355	//fprintf( stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
		356	// flags, h_scale, v_scale, h_align, v_align);
206	return (changed > 0);	357	return (changed > 0);
207	}	358	}
		359
		360	#ifdef HAVE_AFTERIMAGE
		361	bool
		362	bgPixmap_t::render_asim (rxvt_term target, ASImage background, ARGB32 background_tint)
		363	{
		364	if (target == NULL)
		365	return false;
		366
		367	int target_width = (int)target->szHint.width;
		368	int target_height = (int)target->szHint.height;
		369	int new_pmap_width = target_width, new_pmap_height = target_height;
		370	ASImage *result = NULL;
		371
		372	int x = 0;
		373	int y = 0;
		374	int w = h_scale * target_width / 100;
		375	int h = v_scale * target_height / 100;
		376
		377	if (original_asim)
		378	{
		379	x = make_align_position (h_align, target_width, w > 0 ? w : (int)original_asim->width);
		380	y = make_align_position (v_align, target_height, h > 0 ? h : (int)original_asim->height);
		381	}
		382
		383	int dst_x, dst_y;
		384	int clip_width, clip_height;
		385
		386	make_clip_rectangle (x, w, target_width, dst_x, clip_width);
		387	make_clip_rectangle (y, h, target_height, dst_y, clip_height);
		388
		389	/* TODO : actuall scaling code :) */
		390	if (dst_x >= target_width \|\| dst_y >= target_height
		391	\|\| clip_width <= 0 \|\| clip_height <= 0 \|\| original_asim == NULL)
		392	{
		393	result = background;
		394	dst_x = dst_y = 0;
		395	if (background)
		396	{
		397	new_pmap_width = clip_width = background->width;
		398	new_pmap_height = clip_height = background->height;
		399	}
		400	else
		401	new_pmap_width = new_pmap_height = 0;
		402	}
		403	else
		404	{
		405	result = original_asim;
		406	if ((w > 0 && w != original_asim->width)
		407	\|\| (h > 0 && h != original_asim->height))
		408	{
		409	result = scale_asimage (target->asv, original_asim,
		410	w > 0 ? w : original_asim->width,
		411	h > 0 ? h : original_asim->height,
		412	background ? ASA_ASImage : ASA_XImage,
		413	100, ASIMAGE_QUALITY_DEFAULT);
		414	}
		415	if (background == NULL)
		416	{/* if tiling - pixmap has to be sized exactly as the image */
		417	if (h_scale == 0)
		418	new_pmap_width = result->width;
		419	if (v_scale == 0)
		420	new_pmap_height = result->height;
		421	}
		422	else
		423	{/* if blending background and image - pixmap has to be sized same as target window */
		424	ASImageLayer *layers = create_image_layers (2);
		425	ASImage *merged_im = NULL;
		426
		427	layers[0].im = background;
		428	layers[0].clip_width = target_width;
		429	layers[0].clip_height = target_height;
		430	layers[0].tint = background_tint;
		431	layers[1].im = result;
		432	if (w <= 0)
		433	{/* tile horizontally */
		434	layers[1].dst_x = dst_x - (int)result->width;
		435	layers[1].clip_width = result->width;
		436	}
		437	else
		438	{/* clip horizontally */
		439	layers[1].dst_x = dst_x;
		440	layers[1].clip_width = clip_width;
		441	}
		442	if (h <= 0)
		443	{
		444	layers[1].dst_y = dst_y - (int)result->height;
		445	layers[1].clip_height = result->height;
		446	}
		447	else
		448	{
		449	layers[1].dst_y = dst_y;
		450	layers[1].clip_height = clip_height;
		451	}
		452	if (target->rs[Rs_blendtype])
		453	{
		454	layers[1].merge_scanlines = blend_scanlines_name2func (target->rs[Rs_blendtype]);
		455	if (layers[1].merge_scanlines == NULL)
		456	layers[1].merge_scanlines = alphablend_scanlines;
		457	}
		458	ASImage *tmp = merge_layers (target->asv, layers, 2, target_width, target_height,
		459	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
		460	if (tmp)
		461	{
		462	if (result != original_asim)
		463	destroy_asimage (&result);
		464	result = tmp;
		465	dst_x = dst_y = 0;
		466	clip_width = target_width;
		467	clip_height = target_height;
		468	}
		469	free (layers);
		470	}
		471	}
		472
		473	if (pixmap)
		474	{
		475	if (result == NULL
		476	\|\| pmap_width != new_pmap_width
		477	\|\| pmap_height != new_pmap_height
		478	\|\| pmap_depth != target->depth)
		479	{
		480	XFreePixmap (target->dpy, pixmap);
		481	pixmap = None;
		482	}
		483	}
		484
		485	if (result)
		486	{
		487	XGCValues gcv;
		488	GC gc;
		489
		490	/* create Pixmap */
		491	if (pixmap == None)
		492	{
		493	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
		494	pmap_width = new_pmap_width;
		495	pmap_height = new_pmap_height;
		496	pmap_depth = target->depth;
		497	}
		498	/* fill with background color ( if result's not completely overlapping it)*/
		499	gcv.foreground = target->pix_colors[Color_bg];
		500	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
		501
		502	if (dst_x > 0 \|\| dst_y > 0
		503	\|\| dst_x + clip_width < new_pmap_width
		504	\|\| dst_y + clip_height < new_pmap_height)
		505	{
		506	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
		507	}
		508	/* put result on pixmap */
		509	asimage2drawable (target->asv, pixmap, result, gc, 0, 0, dst_x, dst_y, clip_width, clip_height, True);
		510
		511	/* set target's background to pixmap */
		512	XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
		513
		514	XFreeGC (target->dpy, gc);
		515	}
		516	else
		517	{
		518	/* set target background to a pixel */
		519	XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
		520	}
		521
		522	return true;
		523	}
		524	#endif
208		525
209	void	526	void
210	rxvt_term::resize_pixmap ()	527	rxvt_term::resize_pixmap ()
211	{	528	{
212	XGCValues gcvalue;	529	XGCValues gcvalue;
…		…
328		645
329	#endif /* XPM_BACKGROUND */	646	#endif /* XPM_BACKGROUND */
330	#endif /* HAVE_BG_PIXMAP */	647	#endif /* HAVE_BG_PIXMAP */
331		648
332	#ifdef ENABLE_TRANSPARENCY	649	#ifdef ENABLE_TRANSPARENCY
333	#if TINTING && !defined(HAVE_AFTERIMAGE)	650	#ifndef HAVE_AFTERIMAGE
334	/* taken from aterm-0.4.2 */	651	/* taken from aterm-0.4.2 */
335		652
336	typedef uint32_t RUINT32T;	653	typedef uint32_t RUINT32T;
337		654
338	static void	655	static void
…		…
644	i = (xa[XA_ESETROOT_PMAP_ID]	961	i = (xa[XA_ESETROOT_PMAP_ID]
645	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],	962	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],
646	0L, 1L, False, XA_PIXMAP, &atype, &aformat,	963	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
647	&nitems, &bytes_after, &prop) == Success);	964	&nitems, &bytes_after, &prop) == Success);
648		965
649	/* TODO: the below logic needs to be cleaned up */
650	if (!i \|\| prop == NULL	966	if (!i \|\| prop == NULL)
651	#if TINTING
652	\|\| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL
653	#ifdef HAVE_AFTERIMAGE
654	&& bgPixmap.original_asim == NULL && rs[Rs_blurradius] == NULL
655	#endif
656	)
657	#endif
658	)
659	rootpixmap = None;	967	rootpixmap = None;
660	else	968	else
661	{	969	{
662	int junk;	970	int junk;
663	unsigned int ujunk;	971	unsigned int ujunk;
…		…
682	Bool whole_tint = False, no_tint = True;	990	Bool whole_tint = False, no_tint = True;
683		991
684	while (sx < 0) sx += (int)wrootattr.width;	992	while (sx < 0) sx += (int)wrootattr.width;
685	while (sy < 0) sy += (int)wrootattr.height;	993	while (sy < 0) sy += (int)wrootattr.height;
686		994
687	#if TINTING
688	if (rs[Rs_shade])	995	if (rs[Rs_shade])
689	shade = atoi (rs[Rs_shade]);	996	shade = atoi (rs[Rs_shade]);
690	if (ISSET_PIXCOLOR (Color_tint))	997	if (ISSET_PIXCOLOR (Color_tint))
691	pix_colors_focused [Color_tint].get (c);	998	pix_colors_focused [Color_tint].get (c);
692	#define IS_COMPONENT_WHOLESOME(c) ((c) <=0x000700 \|\| (c)>=0x00f700)	999	#define IS_COMPONENT_WHOLESOME(c) ((c) <=0x000700 \|\| (c)>=0x00f700)
…		…
694	whole_tint = (IS_COMPONENT_WHOLESOME(c.r)	1001	whole_tint = (IS_COMPONENT_WHOLESOME(c.r)
695	&& IS_COMPONENT_WHOLESOME(c.g)	1002	&& IS_COMPONENT_WHOLESOME(c.g)
696	&& IS_COMPONENT_WHOLESOME(c.b));	1003	&& IS_COMPONENT_WHOLESOME(c.b));
697	no_tint = (c.r >= 0x00f700 && c.g >= 0x00f700 && c.b >= 0x00f700);	1004	no_tint = (c.r >= 0x00f700 && c.g >= 0x00f700 && c.b >= 0x00f700);
698	#undef IS_COMPONENT_WHOLESOME	1005	#undef IS_COMPONENT_WHOLESOME
699	#endif /* TINTING */
700	/* theer are no performance advantages to reusing same pixmap */	1006	/* theer are no performance advantages to reusing same pixmap */
701	if (bgPixmap.pixmap != None)	1007	if (bgPixmap.pixmap != None)
702	XFreePixmap (dpy, bgPixmap.pixmap);	1008	XFreePixmap (dpy, bgPixmap.pixmap);
703	bgPixmap.pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);	1009	bgPixmap.pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);
704	bgPixmap.pmap_width = szHint.width;	1010	bgPixmap.pmap_width = szHint.width;
…		…
719	gcvalue.ts_x_origin = -sx;	1025	gcvalue.ts_x_origin = -sx;
720	gcvalue.ts_y_origin = -sy;	1026	gcvalue.ts_y_origin = -sy;
721	gc = XCreateGC (dpy, rootpixmap, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcvalue);	1027	gc = XCreateGC (dpy, rootpixmap, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcvalue);
722	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);	1028	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);
723		1029
724	#if TINTING
725	if (whole_tint && !no_tint)	1030	if (whole_tint && !no_tint)
726	{	1031	{
727	/* In this case we can tint image server-side getting significant	1032	/* In this case we can tint image server-side getting significant
728	* performance improvements, as we eliminate XImage transfer	1033	* performance improvements, as we eliminate XImage transfer
729	*/	1034	*/
…		…
731	gcvalue.function = GXand;	1036	gcvalue.function = GXand;
732	gcvalue.fill_style = FillSolid;	1037	gcvalue.fill_style = FillSolid;
733	XChangeGC (dpy, gc, GCFillStyle \| GCForeground \| GCFunction, &gcvalue);	1038	XChangeGC (dpy, gc, GCFillStyle \| GCForeground \| GCFunction, &gcvalue);
734	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);	1039	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);
735	}	1040	}
736	#endif
737	success = True;	1041	success = True;
738	#ifdef HAVE_AFTERIMAGE	1042	#ifdef HAVE_AFTERIMAGE
739	if (rs[Rs_blurradius] \|\| bgPixmap.original_asim != NULL \|\| (!whole_tint && (!no_tint \|\| shade !=100)))	1043	if (rs[Rs_blurradius] \|\| bgPixmap.original_asim != NULL \|\| (!whole_tint && (!no_tint \|\| shade !=100)))
740	{	1044	{
741	ARGB32 tint = TINT_LEAVE_SAME;	1045	ARGB32 tint = TINT_LEAVE_SAME;
…		…
836	} /* back_im != NULL */	1140	} /* back_im != NULL */
837	else	1141	else
838	success = False;	1142	success = False;
839	}	1143	}
840	#else /* HAVE_AFTERIMAGE */	1144	#else /* HAVE_AFTERIMAGE */
841	#if TINTING
842	if (!whole_tint && (!no_tint \|\| shade !=100))	1145	if (!whole_tint && (!no_tint \|\| shade !=100))
843	{	1146	{
844	XImage *image = XGetImage (dpy, bgPixmap.pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);	1147	XImage *image = XGetImage (dpy, bgPixmap.pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);
845	success = False;	1148	success = False;
846	if (image != NULL)	1149	if (image != NULL)
…		…
853	XPutImage (dpy, bgPixmap.pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);	1156	XPutImage (dpy, bgPixmap.pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);
854	XDestroyImage (image);	1157	XDestroyImage (image);
855	success = True;	1158	success = True;
856	}	1159	}
857	}	1160	}
858	#endif
859	#endif /* HAVE_AFTERIMAGE */	1161	#endif /* HAVE_AFTERIMAGE */
860	PRINT_BACKGROUND_OP_TIME;	1162	PRINT_BACKGROUND_OP_TIME;
861		1163
862	if (gc != NULL)	1164	if (gc != NULL)
863	XFreeGC (dpy, gc);	1165	XFreeGC (dpy, gc);
…		…
889	} /* rootpixmap != None */	1191	} /* rootpixmap != None */
890		1192
891	if (am_pixmap_trans)	1193	if (am_pixmap_trans)
892	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);	1194	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
893	else	1195	else
894	{	1196	return;
895	unsigned int n;
896	/*
897	* InheritPixmap transparency
898	*/
899	for (i = 1; i < (int) (sizeof (parent) / sizeof (Window)); i++)
900	{
901	oldp = parent[i];
902	XQueryTree (dpy, parent[i - 1], &root, &parent[i], &list, &n);
903	XFree (list);
904
905	if (parent[i] == display->root)
906	{
907	if (oldp != None)
908	pchanged = 1;
909
910	break;
911	}
912
913	if (oldp != parent[i])
914	pchanged = 1;
915	}
916
917	n = 0;
918
919	if (pchanged)
920	for (; n < (unsigned int)i; n++)
921	{
922	XGetWindowAttributes (dpy, parent[n], &wattr);
923
924	if (wattr.depth != rootdepth \|\| wattr.c_class == InputOnly)
925	{
926	n = (int) (sizeof (parent) / sizeof (Window)) + 1;
927	break;
928	}
929	}
930
931	if (n > (sizeof (parent) / sizeof (parent[0])))
932	{
933	XSetWindowBackground (dpy, parent[0], pix_colors_focused[Color_border]);
934	XSetWindowBackground (dpy, vt, pix_colors_focused[Color_bg]);
935	am_transparent = 0;
936	/* XXX: also turn off Opt_transparent? */
937	}
938	else
939	{
940	for (n = 0; n < (unsigned int)i; n++)
941	{
942	XSetWindowBackgroundPixmap (dpy, parent[n], ParentRelative);
943	XClearWindow (dpy, parent[n]);
944	}
945
946	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
947	am_transparent = 1;
948	}
949
950	for (; i < (int) (sizeof (parent) / sizeof (Window)); i++)
951	parent[i] = None;
952	}
953		1197
954	if (scrollBar.win)	1198	if (scrollBar.win)
955	{	1199	{
956	XSetWindowBackgroundPixmap (dpy, scrollBar.win, ParentRelative);	1200	XSetWindowBackgroundPixmap (dpy, scrollBar.win, ParentRelative);
957	scrollBar.setIdle ();	1201	scrollBar.setIdle ();

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing rxvt-unicode/src/xpm.C (file contents): Revision 1.56 by sasha, Fri Aug 3 22:40:10 2007 UTC vs. Revision 1.61 by ayin, Tue Aug 7 15:23:11 2007 UTC

Diff Legend

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.56 by sasha, Fri Aug 3 22:40:10 2007 UTC vs.
Revision 1.61 by ayin, Tue Aug 7 15:23:11 2007 UTC