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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.162 by sf-exg, Thu Aug 11 12:27:26 2011 UTC vs.
Revision 1.196 by sf-exg, Tue Jan 10 18:50:14 2012 UTC

…		…
32		32
33	#ifndef FilterConvolution	33	#ifndef FilterConvolution
34	#define FilterConvolution "convolution"	34	#define FilterConvolution "convolution"
35	#endif	35	#endif
36		36
37	/*	37	#ifndef RepeatPad
38	* Pixmap geometry string interpretation :	38	#define RepeatPad True
39	* Each geometry string contains zero or one scale/position	39	#endif
40	* adjustment and may optionally be followed by a colon and one or more
41	* colon-delimited pixmap operations.
42	* The following table shows the valid geometry strings and their
43	* effects on the background image :
44	*
45	* WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
46	* W and H are percentages of the terminal window size.
47	* X and Y are also percentages; e.g., +50+50 centers
48	* the image in the window.
49	*
50	* Pixmap Operations : (should be prepended by a colon)
51	*/
52		40
53	#ifdef HAVE_BG_PIXMAP	41	#ifdef HAVE_BG_PIXMAP
		42	# if XRENDER
		43	static Picture
		44	create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
		45	{
		46	Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
		47
		48	XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
		49	XRenderPictureAttributes pa;
		50	pa.repeat = True;
		51	pa.component_alpha = component_alpha;
		52	Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat \| CPComponentAlpha, &pa);
		53
		54	XFreePixmap (dpy, pixmap);
		55
		56	return mask;
		57	}
		58	# endif
		59
54	void	60	void
55	rxvt_term::bg_destroy ()	61	rxvt_term::bg_destroy ()
56	{	62	{
57	#ifdef HAVE_AFTERIMAGE	63	#ifdef HAVE_AFTERIMAGE
58	if (original_asim)	64	if (original_asim)
…		…
166	int smaller = min (image_size, window_size);	172	int smaller = min (image_size, window_size);
167		173
168	if (align >= 0 && align <= 100)	174	if (align >= 0 && align <= 100)
169	return diff * align / 100;	175	return diff * align / 100;
170	else if (align > 100 && align <= 200)	176	else if (align > 100 && align <= 200)
171	return ((align - 100) * smaller / 100) + window_size - smaller;	177	return (align - 100) * smaller / 100 + window_size - smaller;
172	else if (align >= -100 && align < 0)	178	else if (align >= -100 && align < 0)
173	return ((align + 100) * smaller / 100) - image_size;	179	return (align + 100) * smaller / 100 - image_size;
174	return 0;	180	return 0;
175	}	181	}
176		182
177	static inline int	183	static inline int
178	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	184	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
…		…
197	{	203	{
198	bool changed = false;	204	bool changed = false;
199	int geom_flags = 0;	205	int geom_flags = 0;
200	int x = 0, y = 0;	206	int x = 0, y = 0;
201	unsigned int w = 0, h = 0;	207	unsigned int w = 0, h = 0;
202	unsigned int n;	208	unsigned long new_flags = 0;
203	unsigned long new_flags = (bg_flags & (~BG_GEOMETRY_FLAGS));
204	const char *ops;
205		209
206	if (geom == NULL)	210	if (geom == NULL)
207	return false;	211	return false;
208		212
209	char str[256];	213	if (geom[0])
210
211	ops = strchr (geom, ':');
212	if (ops == NULL)
213	n = strlen (geom);
214	else
215	n = ops - geom;
216
217	if (n >= sizeof (str))
218	return false;
219
220	memcpy (str, geom, n);
221	str[n] = '\0';
222	rxvt_strtrim (str);
223
224	if (str[0])
225	{	214	{
226	/* we have geometry string - let's handle it prior to applying ops */	215	char **arr = rxvt_strsplit (':', geom);
		216
		217	for (int i = 0; arr[i]; i++)
		218	{
		219	if (!strcasecmp (arr[i], "style=tiled"))
		220	{
		221	new_flags = BG_TILE;
		222	w = h = noScale;
		223	x = y = 0;
		224	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
		225	}
		226	else if (!strcasecmp (arr[i], "style=aspect-stretched"))
		227	{
		228	new_flags = BG_KEEP_ASPECT;
		229	w = h = windowScale;
		230	x = y = centerAlign;
		231	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
		232	}
		233	else if (!strcasecmp (arr[i], "style=stretched"))
		234	{
		235	new_flags = 0;
		236	w = h = windowScale;
		237	geom_flags = WidthValue\|HeightValue;
		238	}
		239	else if (!strcasecmp (arr[i], "style=centered"))
		240	{
		241	new_flags = 0;
		242	w = h = noScale;
		243	x = y = centerAlign;
		244	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
		245	}
		246	else if (!strcasecmp (arr[i], "style=root-tiled"))
		247	{
		248	new_flags = BG_TILE\|BG_ROOT_ALIGN;
		249	w = h = noScale;
		250	geom_flags = WidthValue\|HeightValue;
		251	}
		252	else if (!strcasecmp (arr[i], "op=tile"))
		253	new_flags \|= BG_TILE;
		254	else if (!strcasecmp (arr[i], "op=keep-aspect"))
		255	new_flags \|= BG_KEEP_ASPECT;
		256	else if (!strcasecmp (arr[i], "op=root-align"))
		257	new_flags \|= BG_ROOT_ALIGN;
		258
		259	// deprecated
		260	else if (!strcasecmp (arr[i], "tile"))
		261	{
		262	new_flags \|= BG_TILE;
		263	w = h = noScale;
		264	geom_flags \|= WidthValue\|HeightValue;
		265	}
		266	else if (!strcasecmp (arr[i], "propscale"))
		267	{
		268	new_flags \|= BG_KEEP_ASPECT;
		269	w = h = windowScale;
		270	geom_flags \|= WidthValue\|HeightValue;
		271	}
		272	else if (!strcasecmp (arr[i], "hscale"))
		273	{
		274	new_flags \|= BG_TILE;
		275	w = windowScale;
		276	h = noScale;
		277	geom_flags \|= WidthValue\|HeightValue;
		278	}
		279	else if (!strcasecmp (arr[i], "vscale"))
		280	{
		281	new_flags \|= BG_TILE;
		282	h = windowScale;
		283	w = noScale;
		284	geom_flags \|= WidthValue\|HeightValue;
		285	}
		286	else if (!strcasecmp (arr[i], "scale"))
		287	{
		288	w = h = windowScale;
		289	geom_flags \|= WidthValue\|HeightValue;
		290	}
		291	else if (!strcasecmp (arr[i], "auto"))
		292	{
		293	w = h = windowScale;
		294	x = y = centerAlign;
		295	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
		296	}
		297	else if (!strcasecmp (arr[i], "root"))
		298	{
		299	new_flags \|= BG_TILE\|BG_ROOT_ALIGN;
		300	w = h = noScale;
		301	geom_flags \|= WidthValue\|HeightValue;
		302	}
		303
		304	else
227	geom_flags = XParseGeometry (str, &x, &y, &w, &h);	305	geom_flags \|= XParseGeometry (arr[i], &x, &y, &w, &h);
228	} /* done parsing geometry string */	306	} /* done parsing ops */
		307
		308	rxvt_free_strsplit (arr);
		309	}
		310
		311	new_flags \|= bg_flags & ~BG_GEOMETRY_FLAGS;
229		312
230	if (!update)	313	if (!update)
231	{	314	{
232	if (!(geom_flags & XValue))	315	if (!(geom_flags & XValue))
233	x = y = defaultAlign;	316	x = y = defaultAlign;
…		…
242	w = h;	325	w = h;
243		326
244	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;	327	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
245	}	328	}
246		329
247	if (ops)
248	{
249	char **arr = rxvt_strsplit (':', ops + 1);
250
251	for (int i = 0; arr[i]; i++)
252	{
253	if (!strcasecmp (arr[i], "style=tiled"))
254	{
255	new_flags = BG_TILE;
256	w = h = noScale;
257	x = y = 0;
258	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
259	}
260	else if (!strcasecmp (arr[i], "style=aspect-stretched"))
261	{
262	new_flags = BG_PROP_SCALE;
263	x = y = centerAlign;
264	geom_flags = XValue\|YValue;
265	}
266	else if (!strcasecmp (arr[i], "style=stretched"))
267	{
268	new_flags = 0;
269	w = h = windowScale;
270	geom_flags = WidthValue\|HeightValue;
271	}
272	else if (!strcasecmp (arr[i], "style=centered"))
273	{
274	new_flags = 0;
275	w = h = noScale;
276	x = y = centerAlign;
277	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
278	}
279	else if (!strcasecmp (arr[i], "style=root-tiled"))
280	{
281	new_flags = BG_TILE\|BG_ROOT_ALIGN;
282	w = h = noScale;
283	geom_flags = WidthValue\|HeightValue;
284	}
285	else if (!strcasecmp (arr[i], "op=tile"))
286	new_flags \|= BG_TILE;
287	else if (!strcasecmp (arr[i], "op=pscale"))
288	new_flags \|= BG_PROP_SCALE;
289	else if (!strcasecmp (arr[i], "op=root"))
290	new_flags \|= BG_ROOT_ALIGN;
291
292	// deprecated
293	else if (!strcasecmp (arr[i], "tile"))
294	{
295	new_flags \|= BG_TILE;
296	w = h = noScale;
297	geom_flags \|= WidthValue\|HeightValue;
298	}
299	else if (!strcasecmp (arr[i], "propscale"))
300	{
301	new_flags \|= BG_PROP_SCALE;
302	}
303	else if (!strcasecmp (arr[i], "hscale"))
304	{
305	new_flags \|= BG_TILE;
306	w = windowScale;
307	h = noScale;
308	geom_flags \|= WidthValue\|HeightValue;
309	}
310	else if (!strcasecmp (arr[i], "vscale"))
311	{
312	new_flags \|= BG_TILE;
313	h = windowScale;
314	w = noScale;
315	geom_flags \|= WidthValue\|HeightValue;
316	}
317	else if (!strcasecmp (arr[i], "scale"))
318	{
319	w = h = windowScale;
320	geom_flags \|= WidthValue\|HeightValue;
321	}
322	else if (!strcasecmp (arr[i], "auto"))
323	{
324	w = h = windowScale;
325	x = y = centerAlign;
326	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
327	}
328	else if (!strcasecmp (arr[i], "root"))
329	{
330	new_flags \|= BG_TILE\|BG_ROOT_ALIGN;
331	w = h = noScale;
332	geom_flags \|= WidthValue\|HeightValue;
333	}
334	} /* done parsing ops */
335
336	rxvt_free_strsplit (arr);
337	}
338
339	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;	330	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
340	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;	331	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
341	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;	332	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
342	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;	333	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
343		334
…		…
354	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)	345	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
355	{	346	{
356	int target_width = szHint.width;	347	int target_width = szHint.width;
357	int target_height = szHint.height;	348	int target_height = szHint.height;
358		349
		350	w = h_scale * target_width / 100;
		351	h = v_scale * target_height / 100;
		352
359	if (bg_flags & BG_PROP_SCALE)	353	if (bg_flags & BG_KEEP_ASPECT)
360	{	354	{
361	float scale = (float)target_width / image_width;	355	float scale = (float)w / image_width;
362	min_it (scale, (float)target_height / image_height);	356	min_it (scale, (float)h / image_height);
363	w = image_width * scale + 0.5;	357	w = image_width * scale + 0.5;
364	h = image_height * scale + 0.5;	358	h = image_height * scale + 0.5;
365	}	359	}
366	else
367	{
368	w = h_scale * target_width / 100;
369	h = v_scale * target_height / 100;
370	}
371		360
372	if (!w) w = image_width;	361	if (!w) w = image_width;
373	if (!h) h = image_height;	362	if (!h) h = image_height;
374		363
375	if (bg_flags & BG_ROOT_ALIGN)	364	if (bg_flags & BG_ROOT_ALIGN)
…		…
383	y = make_align_position (v_align, target_height, h);	372	y = make_align_position (v_align, target_height, h);
384	}	373	}
385		374
386	bg_flags &= ~BG_IS_SIZE_SENSITIVE;	375	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
387	if (!(bg_flags & BG_TILE)	376	if (!(bg_flags & BG_TILE)
388	\|\| (bg_flags & BG_PROP_SCALE) \|\| h_scale \|\| v_scale	377	\|\| h_scale \|\| v_scale
389	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	378	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
390	\|\| w > target_width \|\| h > target_height)	379	\|\| w > target_width \|\| h > target_height)
391	bg_flags \|= BG_IS_SIZE_SENSITIVE;	380	bg_flags \|= BG_IS_SIZE_SENSITIVE;
392	}	381	}
393		382
…		…
420	}	409	}
421		410
422	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)	411	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
423	{	412	{
424	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,	413	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
425	(original_asim == NULL \|\| tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,	414	ASA_XImage,
426	100, ASIMAGE_QUALITY_DEFAULT);	415	100, ASIMAGE_QUALITY_DEFAULT);
427	if (tmp)	416	if (tmp)
428	{	417	{
429	destroy_asimage (&background);	418	destroy_asimage (&background);
430	background = tmp;	419	background = tmp;
…		…
449		438
450	if (!original_asim	439	if (!original_asim
451	\|\| (!(bg_flags & BG_ROOT_ALIGN)	440	\|\| (!(bg_flags & BG_ROOT_ALIGN)
452	&& (x >= target_width	441	&& (x >= target_width
453	\|\| y >= target_height	442	\|\| y >= target_height
454	\|\| (x + w <= 0)	443	\|\| x + w <= 0
455	\|\| (y + h <= 0))))	444	\|\| y + h <= 0)))
456	{	445	{
457	if (background)	446	if (background)
458	{	447	{
459	new_pmap_width = background->width;	448	new_pmap_width = background->width;
460	new_pmap_height = background->height;	449	new_pmap_height = background->height;
…		…
474	}	463	}
475	else	464	else
476	{	465	{
477	result = original_asim;	466	result = original_asim;
478		467
479	if ((w != original_asim->width)	468	if (w != original_asim->width
480	\|\| (h != original_asim->height))	469	\|\| h != original_asim->height)
481	{	470	{
482	result = scale_asimage (asv, original_asim,	471	result = scale_asimage (asv, original_asim,
483	w, h,	472	w, h,
484	background ? ASA_ASImage : ASA_XImage,	473	ASA_XImage,
485	100, ASIMAGE_QUALITY_DEFAULT);	474	100, ASIMAGE_QUALITY_DEFAULT);
486	}	475	}
487		476
488	if (background == NULL)	477	if (background == NULL)
489	{	478	{
…		…
739	get_image_geometry (image_width, image_height, w, h, x, y);	728	get_image_geometry (image_width, image_height, w, h, x, y);
740		729
741	if (!(bg_flags & BG_ROOT_ALIGN)	730	if (!(bg_flags & BG_ROOT_ALIGN)
742	&& (x >= target_width	731	&& (x >= target_width
743	\|\| y >= target_height	732	\|\| y >= target_height
744	\|\| (x + w <= 0)	733	\|\| x + w <= 0
745	\|\| (y + h <= 0)))	734	\|\| y + h <= 0))
746	return false;	735	return false;
747		736
748	result = pixbuf;	737	result = pixbuf;
749		738
750	if ((w != image_width)	739	if (w != image_width
751	\|\| (h != image_height))	740	\|\| h != image_height)
752	{	741	{
753	result = gdk_pixbuf_scale_simple (pixbuf,	742	result = gdk_pixbuf_scale_simple (pixbuf,
754	w, h,	743	w, h,
755	GDK_INTERP_BILINEAR);	744	GDK_INTERP_BILINEAR);
756	}	745	}
…		…
835	}	824	}
836		825
837	#if XRENDER	826	#if XRENDER
838	if (tr_flags)	827	if (tr_flags)
839	{	828	{
840	XRenderPictureAttributes pa;
841
842	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	829	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		830
843	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	831	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
844		832
845	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
846	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	833	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
847		834
848	pa.repeat = True;	835	Picture mask = create_xrender_mask (dpy, vt, False, False);
849	Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
850	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
851	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
852	XFreePixmap (dpy, mask_pmap);
853		836
854	XRenderColor mask_c;	837	XRenderColor mask_c;
855		838
856	mask_c.alpha = 0x8000;	839	mask_c.alpha = 0x8000;
857	mask_c.red = 0;	840	mask_c.red =
858	mask_c.green = 0;	841	mask_c.green =
859	mask_c.blue = 0;	842	mask_c.blue = 0;
860	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	843	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		844
861	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	845	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
862		846
863	XRenderFreePicture (dpy, src);	847	XRenderFreePicture (dpy, src);
864	XRenderFreePicture (dpy, dst);	848	XRenderFreePicture (dpy, dst);
865	XRenderFreePicture (dpy, mask);	849	XRenderFreePicture (dpy, mask);
…		…
885	rxvt_term::bg_set_file (const char *file)	869	rxvt_term::bg_set_file (const char *file)
886	{	870	{
887	if (!file \|\| !*file)	871	if (!file \|\| !*file)
888	return false;	872	return false;
889		873
		874	bool ret = false;
890	if (const char *p = strchr (file, ';'))	875	const char *p = strchr (file, ';');
		876
		877	if (p)
891	{	878	{
892	size_t len = p - file;	879	size_t len = p - file;
893	char *f = rxvt_temp_buf<char> (len + 1);	880	char *f = rxvt_temp_buf<char> (len + 1);
894	memcpy (f, file, len);	881	memcpy (f, file, len);
895	f[len] = '\0';	882	f[len] = '\0';
…		…
904	{	891	{
905	if (original_asim)	892	if (original_asim)
906	safe_asimage_destroy (original_asim);	893	safe_asimage_destroy (original_asim);
907	original_asim = image;	894	original_asim = image;
908	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;	895	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;
909	return true;	896	ret = true;
910	}	897	}
911	# endif	898	# endif
912		899
913	# ifdef HAVE_PIXBUF	900	# ifdef HAVE_PIXBUF
914	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	901	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
…		…
916	{	903	{
917	if (pixbuf)	904	if (pixbuf)
918	g_object_unref (pixbuf);	905	g_object_unref (pixbuf);
919	pixbuf = image;	906	pixbuf = image;
920	bg_flags \|= BG_IS_FROM_FILE;	907	bg_flags \|= BG_IS_FROM_FILE;
921	return true;	908	ret = true;
922	}	909	}
923	# endif	910	# endif
924		911
		912	if (ret)
		913	{
		914	if (p)
		915	bg_set_geometry (p + 1);
		916	else
		917	bg_set_default_geometry ();
		918	}
		919
925	return false;	920	return ret;
926	}	921	}
927		922
928	# endif /* BG_IMAGE_FROM_FILE */	923	# endif /* BG_IMAGE_FROM_FILE */
929		924
930	# ifdef ENABLE_TRANSPARENCY	925	# ifdef ENABLE_TRANSPARENCY
…		…
966	{	961	{
967	changed = true;	962	changed = true;
968	v_blurRadius = vr;	963	v_blurRadius = vr;
969	}	964	}
970		965
971	if (v_blurRadius == 0 && h_blurRadius == 0)	966	if (h_blurRadius == 0 \|\| v_blurRadius == 0)
972	bg_flags &= ~BG_NEEDS_BLUR;	967	bg_flags &= ~BG_NEEDS_BLUR;
973	else	968	else
974	bg_flags \|= BG_NEEDS_BLUR;	969	bg_flags \|= BG_NEEDS_BLUR;
975		970
976	return changed;	971	return changed;
977	}	972	}
978		973
979	void	974	void
980	rxvt_term::set_tint_shade_flags ()	975	rxvt_term::set_tint_shade_flags ()
981	{	976	{
982	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	977	rgba c;
983	bool has_shade = shade != 100;	978	bool has_shade = shade != 100;
984		979
985	bg_flags &= ~BG_TINT_FLAGS;	980	bg_flags &= ~BG_TINT_FLAGS;
986		981
987	if (bg_flags & BG_TINT_SET)	982	if (bg_flags & BG_TINT_SET)
…		…
1013	}	1008	}
1014		1009
1015	bool	1010	bool
1016	rxvt_term::bg_set_shade (const char *shade_str)	1011	rxvt_term::bg_set_shade (const char *shade_str)
1017	{	1012	{
1018	int new_shade = (shade_str) ? atoi (shade_str) : 100;	1013	int new_shade = atoi (shade_str);
1019		1014
1020	clamp_it (new_shade, -100, 200);	1015	clamp_it (new_shade, -100, 200);
1021	if (new_shade < 0)	1016	if (new_shade < 0)
1022	new_shade = 200 - (100 + new_shade);	1017	new_shade = 200 - (100 + new_shade);
1023		1018
…		…
1053	params[i+2] = XDoubleToFixed (kernel[i] / sum);	1048	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1054	}	1049	}
1055	#endif	1050	#endif
1056		1051
1057	bool	1052	bool
1058	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	1053	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1059	{	1054	{
1060	bool ret = false;	1055	bool ret = false;
1061	#if XRENDER	1056	#if XRENDER
		1057	if (!(bg_flags & BG_HAS_RENDER_CONV))
		1058	return false;
		1059
1062	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	1060	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1063	double kernel = (double )malloc (size * sizeof (double));	1061	double kernel = (double )malloc (size * sizeof (double));
1064	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	1062	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1065		1063
1066	XRenderPictureAttributes pa;	1064	XRenderPictureAttributes pa;
1067	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1065	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1068		1066
		1067	pa.repeat = RepeatPad;
1069	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1068	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		1069	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1070	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1070	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		1071	XFreePixmap (dpy, tmp);
1071		1072
1072	if (kernel && params)	1073	if (kernel && params)
1073	{	1074	{
1074	if (h_blurRadius)
1075	{
1076	size = h_blurRadius * 2 + 1;	1075	size = h_blurRadius * 2 + 1;
1077	get_gaussian_kernel (h_blurRadius, size, kernel, params);	1076	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1078		1077
1079	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1078	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1080	XRenderComposite (dpy,	1079	XRenderComposite (dpy,
1081	PictOpSrc,	1080	PictOpSrc,
1082	src,	1081	src,
1083	None,	1082	None,
1084	dst,	1083	dst,
1085	0, 0,	1084	0, 0,
1086	0, 0,	1085	0, 0,
1087	0, 0,	1086	0, 0,
1088	width, height);	1087	width, height);
1089	}
1090		1088
1091	if (v_blurRadius)	1089	::swap (src, dst);
1092	{	1090
1093	size = v_blurRadius * 2 + 1;	1091	size = v_blurRadius * 2 + 1;
1094	get_gaussian_kernel (v_blurRadius, size, kernel, params);	1092	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1095	::swap (params[0], params[1]);	1093	::swap (params[0], params[1]);
1096		1094
1097	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1095	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1098	XRenderComposite (dpy,	1096	XRenderComposite (dpy,
1099	PictOpSrc,	1097	PictOpSrc,
1100	src,	1098	src,
1101	None,	1099	None,
1102	dst,	1100	dst,
1103	0, 0,	1101	0, 0,
1104	0, 0,	1102	0, 0,
1105	0, 0,	1103	0, 0,
1106	width, height);	1104	width, height);
1107	}
1108		1105
1109	ret = true;	1106	ret = true;
1110	}	1107	}
1111		1108
1112	free (kernel);	1109	free (kernel);
…		…
1139	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	1136	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1140	ret = true;	1137	ret = true;
1141	XFreeGC (dpy, gc);	1138	XFreeGC (dpy, gc);
1142	}	1139	}
1143	}	1140	}
1144	else
1145	{
1146	# if XRENDER	1141	# if XRENDER
		1142	else if (bg_flags & BG_HAS_RENDER)
		1143	{
1147	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);	1144	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1148		1145
1149	if (bg_flags & BG_TINT_SET)	1146	if (bg_flags & BG_TINT_SET)
1150	tint.get (c);	1147	tint.get (c);
1151		1148
…		…
1160	c.r = c.r * (200 - shade) / 100;	1157	c.r = c.r * (200 - shade) / 100;
1161	c.g = c.g * (200 - shade) / 100;	1158	c.g = c.g * (200 - shade) / 100;
1162	c.b = c.b * (200 - shade) / 100;	1159	c.b = c.b * (200 - shade) / 100;
1163	}	1160	}
1164		1161
1165	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1166	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1162	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1167	XRenderPictureAttributes pa;
1168		1163
1169	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1164	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1170		1165
1171	pa.repeat = True;	1166	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1172		1167
1173	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	1168	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1174	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1175	XFreePixmap (dpy, overlay_pmap);
1176
1177	pa.component_alpha = True;
1178	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1179	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat \| CPComponentAlpha, &pa);
1180	XFreePixmap (dpy, mask_pmap);
1181		1169
1182	XRenderColor mask_c;	1170	XRenderColor mask_c;
1183		1171
1184	mask_c.alpha = 0xffff;	1172	mask_c.alpha = 0xffff;
1185	mask_c.red =	1173	mask_c.red =
…		…
1190	mask_c.alpha = 0;	1178	mask_c.alpha = 0;
1191	mask_c.red = 0xffff - c.r;	1179	mask_c.red = 0xffff - c.r;
1192	mask_c.green = 0xffff - c.g;	1180	mask_c.green = 0xffff - c.g;
1193	mask_c.blue = 0xffff - c.b;	1181	mask_c.blue = 0xffff - c.b;
1194	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	1182	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		1183
1195	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);	1184	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1196		1185
1197	if (shade > 100)	1186	if (shade > 100)
1198	{	1187	{
1199	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1200	mask_c.alpha = 0;	1188	mask_c.alpha = 0;
		1189	mask_c.red =
		1190	mask_c.green =
		1191	mask_c.blue = 0xffff * (shade - 100) / 100;
1201	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	1192	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1202		1193
1203	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);	1194	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1204	}	1195	}
1205		1196
1206	ret = true;	1197	ret = true;
1207		1198
1208	XRenderFreePicture (dpy, mask_pic);	1199	XRenderFreePicture (dpy, mask_pic);
1209	XRenderFreePicture (dpy, overlay_pic);	1200	XRenderFreePicture (dpy, overlay_pic);
1210	XRenderFreePicture (dpy, back_pic);	1201	XRenderFreePicture (dpy, back_pic);
		1202	}
1211	# endif	1203	# endif
1212	}
1213		1204
1214	return ret;	1205	return ret;
1215	}	1206	}
1216		1207
1217	/*	1208	/*
…		…
1268	#if XRENDER	1259	#if XRENDER
1269	if (bg_flags & BG_HAS_RENDER)	1260	if (bg_flags & BG_HAS_RENDER)
1270	{	1261	{
1271	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);	1262	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1272		1263
1273	XRenderPictureAttributes pa;
1274
1275	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	1264	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1276	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	1265	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1277		1266
1278	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	1267	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1279	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	1268	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1280		1269
1281	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	1270	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1282		1271
1283	XRenderFreePicture (dpy, src);	1272	XRenderFreePicture (dpy, src);
1284	XRenderFreePicture (dpy, dst);	1273	XRenderFreePicture (dpy, dst);
…		…
1301	bg_pmap_width = window_width;	1290	bg_pmap_width = window_width;
1302	bg_pmap_height = window_height;	1291	bg_pmap_height = window_height;
1303	}	1292	}
1304		1293
1305	/* straightforward pixmap copy */	1294	/* straightforward pixmap copy */
1306	while (sx < 0) sx += root_width;	1295	while (sx < 0) sx += root_pmap_width;
1307	while (sy < 0) sy += root_height;	1296	while (sy < 0) sy += root_pmap_height;
1308		1297
1309	gcv.tile = recoded_root_pmap;	1298	gcv.tile = recoded_root_pmap;
1310	gcv.fill_style = FillTiled;	1299	gcv.fill_style = FillTiled;
1311	gcv.ts_x_origin = -sx;	1300	gcv.ts_x_origin = -sx;
1312	gcv.ts_y_origin = -sy;	1301	gcv.ts_y_origin = -sy;
…		…
1314		1303
1315	if (gc)	1304	if (gc)
1316	{	1305	{
1317	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1306	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1318	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1307	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);
1319	XFreeGC (dpy, gc);
1320		1308
1321	if (!(bg_flags & BG_CLIENT_RENDER))	1309	if (!(bg_flags & BG_CLIENT_RENDER))
1322	{	1310	{
1323	if ((bg_flags & BG_NEEDS_BLUR)	1311	if (bg_flags & BG_NEEDS_BLUR)
1324	&& (bg_flags & BG_HAS_RENDER_CONV))
1325	{	1312	{
1326	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))	1313	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1327	result &= ~BG_NEEDS_BLUR;	1314	result &= ~BG_NEEDS_BLUR;
1328	}	1315	}
1329	if ((bg_flags & BG_NEEDS_TINT)	1316	if (bg_flags & BG_NEEDS_TINT)
1330	&& (bg_flags & (BG_TINT_BITAND \| BG_HAS_RENDER)))
1331	{	1317	{
1332	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))	1318	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1333	result &= ~BG_NEEDS_TINT;	1319	result &= ~BG_NEEDS_TINT;
1334	}	1320	}
		1321	# ifndef HAVE_AFTERIMAGE
		1322	if (result & BG_NEEDS_TINT)
		1323	{
		1324	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1325	if (ximage)
		1326	{
		1327	/* our own client-side tinting */
		1328	tint_ximage (DefaultVisual (dpy, display->screen), ximage);
		1329
		1330	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1331	XDestroyImage (ximage);
		1332	}
		1333	}
		1334	# endif
1335	} /* server side rendering completed */	1335	} /* server side rendering completed */
		1336
		1337	XFreeGC (dpy, gc);
1336	}	1338	}
1337		1339
1338	if (recoded_root_pmap != root_pixmap)	1340	if (recoded_root_pmap != root_pixmap)
1339	XFreePixmap (dpy, recoded_root_pmap);	1341	XFreePixmap (dpy, recoded_root_pmap);
1340		1342
…		…
1349	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);	1351	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1350		1352
1351	root_pixmap = new_root_pixmap;	1353	root_pixmap = new_root_pixmap;
1352	}	1354	}
1353	# endif /* ENABLE_TRANSPARENCY */	1355	# endif /* ENABLE_TRANSPARENCY */
1354
1355	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1356	static void shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c);
1357	# endif
1358		1356
1359	bool	1357	bool
1360	rxvt_term::bg_render ()	1358	rxvt_term::bg_render ()
1361	{	1359	{
1362	unsigned long tr_flags = 0;	1360	unsigned long tr_flags = 0;
…		…
1367	{	1365	{
1368	/* we need to re-generate transparency pixmap in that case ! */	1366	/* we need to re-generate transparency pixmap in that case ! */
1369	tr_flags = make_transparency_pixmap ();	1367	tr_flags = make_transparency_pixmap ();
1370	if (tr_flags == 0)	1368	if (tr_flags == 0)
1371	return false;	1369	return false;
1372	else if (!(tr_flags & BG_EFFECTS_FLAGS))
1373	bg_flags \|= BG_IS_VALID;	1370	bg_flags \|= BG_IS_VALID;
1374	}	1371	}
1375	# endif	1372	# endif
1376		1373
1377	# ifdef BG_IMAGE_FROM_FILE	1374	# ifdef BG_IMAGE_FROM_FILE
1378	if ((bg_flags & BG_IS_FROM_FILE)	1375	if ((bg_flags & BG_IS_FROM_FILE)
1379	\|\| (tr_flags & BG_EFFECTS_FLAGS))	1376	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1380	{	1377	{
1381	if (render_image (tr_flags))	1378	if (render_image (tr_flags))
1382	bg_flags \|= BG_IS_VALID;	1379	bg_flags \|= BG_IS_VALID;
1383	}
1384	# endif
1385
1386	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1387	XImage *result = NULL;
1388
1389	if (tr_flags && !(bg_flags & BG_IS_VALID))
1390	{
1391	result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1392	}
1393
1394	if (result)
1395	{
1396	/* our own client-side tinting */
1397	if (tr_flags & BG_NEEDS_TINT)
1398	{
1399	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1400	if (bg_flags & BG_TINT_SET)
1401	tint.get (c);
1402	shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1403	}
1404
1405	GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1406
1407	if (gc)
1408	{
1409	XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1410
1411	XFreeGC (dpy, gc);
1412	bg_flags \|= BG_IS_VALID;
1413	}
1414
1415	XDestroyImage (result);
1416	}	1380	}
1417	# endif	1381	# endif
1418		1382
1419	if (!(bg_flags & BG_IS_VALID))	1383	if (!(bg_flags & BG_IS_VALID))
1420	{	1384	{
…		…
1458	}	1422	}
1459		1423
1460	#endif /* HAVE_BG_PIXMAP */	1424	#endif /* HAVE_BG_PIXMAP */
1461		1425
1462	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1426	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1463	/* taken from aterm-0.4.2 */	1427	/* based on code from aterm-0.4.2 */
1464		1428
1465	static void	1429	static inline void
1466	shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c)	1430	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
		1431	{
		1432	for (int i = 0; i <= mask >> sh; i++)
		1433	{
		1434	uint32_t tmp;
		1435	tmp = i * high;
		1436	tmp += (mask >> sh) * low;
		1437	lookup[i] = (tmp / 0xffff) << sh;
		1438	}
		1439	}
		1440
		1441	void
		1442	rxvt_term::tint_ximage (Visual visual, XImage ximage)
1467	{	1443	{
1468	int sh_r, sh_g, sh_b;	1444	int sh_r, sh_g, sh_b;
1469	uint32_t mask_r, mask_g, mask_b;	1445	uint32_t mask_r, mask_g, mask_b;
1470	uint32_t lookup, lookup_r, lookup_g, lookup_b;	1446	uint32_t lookup, lookup_r, lookup_g, lookup_b;
1471	rgba low;	1447	unsigned short low;
1472	rgba high;
1473	int i;
1474	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	1448	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1475		1449
1476	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;	1450	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;
1477		1451
1478	/* for convenience */	1452	/* for convenience */
…		…
1537	break;	1511	break;
1538	default:	1512	default:
1539	return; /* we do not support this color depth */	1513	return; /* we do not support this color depth */
1540	}	1514	}
1541		1515
		1516	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
		1517
		1518	if (bg_flags & BG_TINT_SET)
		1519	tint.get (c);
		1520
1542	/* prepare limits for color transformation (each channel is handled separately) */	1521	/* prepare limits for color transformation (each channel is handled separately) */
1543	if (shade > 100)	1522	if (shade > 100)
1544	{	1523	{
1545	shade = 200 - shade;
1546
1547	high.r = c.r * shade / 100;
1548	high.g = c.g * shade / 100;
1549	high.b = c.b * shade / 100;
1550
1551	low.r = 65535 * (100 - shade) / 100;	1524	c.r = c.r * (200 - shade) / 100;
1552	low.g = 65535 * (100 - shade) / 100;	1525	c.g = c.g * (200 - shade) / 100;
1553	low.b = 65535 * (100 - shade) / 100;	1526	c.b = c.b * (200 - shade) / 100;
		1527
		1528	low = 0xffff * (shade - 100) / 100;
1554	}	1529	}
1555	else	1530	else
1556	{	1531	{
1557	high.r = c.r * shade / 100;	1532	c.r = c.r * shade / 100;
1558	high.g = c.g * shade / 100;	1533	c.g = c.g * shade / 100;
1559	high.b = c.b * shade / 100;	1534	c.b = c.b * shade / 100;
1560		1535
1561	low.r = low.g = low.b = 0;	1536	low = 0;
1562	}	1537	}
1563		1538
1564	/* fill our lookup tables */	1539	/* fill our lookup tables */
1565	for (i = 0; i <= mask_r>>sh_r; i++)	1540	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1566	{	1541	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1567	uint32_t tmp;	1542	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1568	tmp = i * high.r;
1569	tmp += (mask_r>>sh_r) * low.r;
1570	lookup_r[i] = (tmp/65535)<<sh_r;
1571	}
1572	for (i = 0; i <= mask_g>>sh_g; i++)
1573	{
1574	uint32_t tmp;
1575	tmp = i * high.g;
1576	tmp += (mask_g>>sh_g) * low.g;
1577	lookup_g[i] = (tmp/65535)<<sh_g;
1578	}
1579	for (i = 0; i <= mask_b>>sh_b; i++)
1580	{
1581	uint32_t tmp;
1582	tmp = i * high.b;
1583	tmp += (mask_b>>sh_b) * low.b;
1584	lookup_b[i] = (tmp/65535)<<sh_b;
1585	}
1586		1543
1587	/* apply table to input image (replacing colors by newly calculated ones) */	1544	/* apply table to input image (replacing colors by newly calculated ones) */
1588	if (ximage->bits_per_pixel == 32	1545	if (ximage->bits_per_pixel == 32
1589	&& (ximage->depth == 24 \|\| ximage->depth == 32)	1546	&& (ximage->depth == 24 \|\| ximage->depth == 32)
1590	&& ximage->byte_order == host_byte_order)	1547	&& ximage->byte_order == host_byte_order)

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.162 by sf-exg, Thu Aug 11 12:27:26 2011 UTC vs. Revision 1.196 by sf-exg, Tue Jan 10 18:50:14 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.162 by sf-exg, Thu Aug 11 12:27:26 2011 UTC vs.
Revision 1.196 by sf-exg, Tue Jan 10 18:50:14 2012 UTC