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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.156 by sf-exg, Tue Aug 9 18:41:31 2011 UTC vs.
Revision 1.198 by sf-exg, Wed Jan 11 13:51:07 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	* tile Tile image. Scaling/position modifiers above will affect
52	* the tile size and origin.
53	* propscale When scaling, scale proportionally. That is, maintain the
54	* proper aspect ratio for the image. Any portion of the
55	* background not covered by the image is filled with the
56	* current background color.
57	* hscale Scale horizontally, tile vertically ?
58	* vscale Tile horizontally, scale vertically ?
59	* scale Scale both up and down
60	* auto Same as 100x100+50+50
61	*/
62		40
63	#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
64	void	60	void
65	rxvt_term::bg_destroy ()	61	rxvt_term::bg_destroy ()
66	{	62	{
67	#ifdef HAVE_AFTERIMAGE	63	#ifdef HAVE_AFTERIMAGE
68	if (original_asim)	64	if (original_asim)
…		…
133		129
134	return false;	130	return false;
135	}	131	}
136		132
137	# ifdef BG_IMAGE_FROM_FILE	133	# ifdef BG_IMAGE_FROM_FILE
138	static inline bool
139	check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
140	{
141	if (geom_flags & flag)
142	{
143	if (new_value > 1000)
144	new_value = 1000;
145	if (new_value != scale)
146	{
147	scale = new_value;
148	return true;
149	}
150	}
151	return false;
152	}
153
154	static inline bool
155	check_set_align_value (int geom_flags, int flag, int &align, int new_value)
156	{
157	if (geom_flags & flag)
158	{
159	if (new_value < -100)
160	new_value = -100;
161	else if (new_value > 200)
162	new_value = 200;
163	if (new_value != align)
164	{
165	align = new_value;
166	return true;
167	}
168	}
169	return false;
170	}
171
172	static inline int	134	static inline int
173	make_align_position (int align, int window_size, int image_size)	135	make_align_position (int align, int window_size, int image_size)
174	{	136	{
175	int diff = window_size - image_size;	137	int diff = window_size - image_size;
176	int smaller = min (image_size, window_size);	138	int smaller = min (image_size, window_size);
177		139
178	if (align >= 0 && align <= 100)	140	if (align >= 0 && align <= 100)
179	return diff * align / 100;	141	return diff * align / 100;
180	else if (align > 100 && align <= 200)	142	else if (align > 100 && align <= 200)
181	return ((align - 100) * smaller / 100) + window_size - smaller;	143	return (align - 100) * smaller / 100 + window_size - smaller;
182	else if (align >= -100 && align < 0)	144	else if (align >= -100 && align < 0)
183	return ((align + 100) * smaller / 100) - image_size;	145	return (align + 100) * smaller / 100 - image_size;
184	return 0;	146	return 0;
185	}	147	}
186		148
187	static inline int	149	static inline int
188	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	150	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
…		…
195	src_pos = -pos;	157	src_pos = -pos;
196	dst_pos = 0;	158	dst_pos = 0;
197	dst_size += pos;	159	dst_size += pos;
198	}	160	}
199		161
200	if (dst_pos + dst_size > target_size)
201	dst_size = target_size - dst_pos;	162	min_it (dst_size, target_size - dst_pos);
202	return src_pos;	163	return src_pos;
203	}	164	}
204		165
205	bool	166	bool
206	rxvt_term::bg_set_geometry (const char *geom, bool update)	167	rxvt_term::bg_set_geometry (const char *geom, bool update)
207	{	168	{
208	bool changed = false;	169	bool changed = false;
209	int geom_flags = 0;	170	int geom_flags = 0;
210	int x = 0, y = 0;	171	int x = h_align;
		172	int y = v_align;
211	unsigned int w = 0, h = 0;	173	unsigned int w = h_scale;
212	unsigned int n;	174	unsigned int h = v_scale;
213	unsigned long new_flags = (bg_flags & (~BG_GEOMETRY_FLAGS));	175	unsigned long new_flags = 0;
214	const char *ops;
215		176
216	if (geom == NULL)	177	if (geom == NULL)
217	return false;	178	return false;
218		179
219	char str[256];	180	if (geom[0])
220
221	ops = strchr (geom, ':');
222	if (ops == NULL)
223	n = strlen (geom);
224	else
225	n = ops - geom;
226
227	if (n >= sizeof (str))
228	return false;
229
230	memcpy (str, geom, n);
231	str[n] = '\0';
232	rxvt_strtrim (str);
233
234	if (str[0])
235	{	181	{
236	/* we have geometry string - let's handle it prior to applying ops */	182	char **arr = rxvt_strsplit (':', geom);
		183
		184	for (int i = 0; arr[i]; i++)
		185	{
		186	if (!strcasecmp (arr[i], "style=tiled"))
		187	{
		188	new_flags = BG_TILE;
		189	w = h = noScale;
		190	x = y = 0;
		191	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
		192	}
		193	else if (!strcasecmp (arr[i], "style=aspect-stretched"))
		194	{
		195	new_flags = BG_KEEP_ASPECT;
		196	w = h = windowScale;
		197	x = y = centerAlign;
		198	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
		199	}
		200	else if (!strcasecmp (arr[i], "style=stretched"))
		201	{
		202	new_flags = 0;
		203	w = h = windowScale;
		204	geom_flags = WidthValue\|HeightValue;
		205	}
		206	else if (!strcasecmp (arr[i], "style=centered"))
		207	{
		208	new_flags = 0;
		209	w = h = noScale;
		210	x = y = centerAlign;
		211	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
		212	}
		213	else if (!strcasecmp (arr[i], "style=root-tiled"))
		214	{
		215	new_flags = BG_TILE\|BG_ROOT_ALIGN;
		216	w = h = noScale;
		217	geom_flags = WidthValue\|HeightValue;
		218	}
		219	else if (!strcasecmp (arr[i], "op=tile"))
		220	new_flags \|= BG_TILE;
		221	else if (!strcasecmp (arr[i], "op=keep-aspect"))
		222	new_flags \|= BG_KEEP_ASPECT;
		223	else if (!strcasecmp (arr[i], "op=root-align"))
		224	new_flags \|= BG_ROOT_ALIGN;
		225
		226	// deprecated
		227	else if (!strcasecmp (arr[i], "tile"))
		228	{
		229	new_flags \|= BG_TILE;
		230	w = h = noScale;
		231	geom_flags \|= WidthValue\|HeightValue;
		232	}
		233	else if (!strcasecmp (arr[i], "propscale"))
		234	{
		235	new_flags \|= BG_KEEP_ASPECT;
		236	w = h = windowScale;
		237	geom_flags \|= WidthValue\|HeightValue;
		238	}
		239	else if (!strcasecmp (arr[i], "hscale"))
		240	{
		241	new_flags \|= BG_TILE;
		242	w = windowScale;
		243	h = noScale;
		244	geom_flags \|= WidthValue\|HeightValue;
		245	}
		246	else if (!strcasecmp (arr[i], "vscale"))
		247	{
		248	new_flags \|= BG_TILE;
		249	h = windowScale;
		250	w = noScale;
		251	geom_flags \|= WidthValue\|HeightValue;
		252	}
		253	else if (!strcasecmp (arr[i], "scale"))
		254	{
		255	w = h = windowScale;
		256	geom_flags \|= WidthValue\|HeightValue;
		257	}
		258	else if (!strcasecmp (arr[i], "auto"))
		259	{
		260	w = h = windowScale;
		261	x = y = centerAlign;
		262	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
		263	}
		264	else if (!strcasecmp (arr[i], "root"))
		265	{
		266	new_flags \|= BG_TILE\|BG_ROOT_ALIGN;
		267	w = h = noScale;
		268	geom_flags \|= WidthValue\|HeightValue;
		269	}
		270
		271	else
237	geom_flags = XParseGeometry (str, &x, &y, &w, &h);	272	geom_flags \|= XParseGeometry (arr[i], &x, &y, &w, &h);
238	} /* done parsing geometry string */	273	} /* done parsing ops */
		274
		275	rxvt_free_strsplit (arr);
		276	}
		277
		278	new_flags \|= bg_flags & ~BG_GEOMETRY_FLAGS;
239		279
240	if (!update)	280	if (!update)
241	{	281	{
242	if (!(geom_flags & XValue))	282	if (!(geom_flags & XValue))
243	x = y = defaultAlign;	283	x = y = defaultAlign;
…		…
248	w = h = defaultScale;	288	w = h = defaultScale;
249	else if (!(geom_flags & HeightValue))	289	else if (!(geom_flags & HeightValue))
250	h = w;	290	h = w;
251	else if (!(geom_flags & WidthValue))	291	else if (!(geom_flags & WidthValue))
252	w = h;	292	w = h;
253
254	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
255	}
256
257	if (ops)
258	{	293	}
259	char **arr = rxvt_strsplit (':', ops + 1);
260		294
261	for (int i = 0; arr[i]; i++)	295	min_it (w, 1000);
262	{	296	min_it (h, 1000);
263	if (!strcasecmp (arr[i], "tile"))	297	clamp_it (x, -100, 200);
264	{	298	clamp_it (y, -100, 200);
265	new_flags \|= BG_TILE;
266	w = h = noScale;
267	geom_flags \|= WidthValue\|HeightValue;
268	}
269	else if (!strcasecmp (arr[i], "propscale"))
270	{
271	new_flags \|= BG_PROP_SCALE;
272	}
273	else if (!strcasecmp (arr[i], "hscale"))
274	{
275	if (w == 0) w = windowScale;
276		299
277	h = noScale;	300	if (bg_flags != new_flags
278	geom_flags \|= WidthValue\|HeightValue;	301	\|\| h_scale != w
279	}	302	\|\| v_scale != h
280	else if (!strcasecmp (arr[i], "vscale"))	303	\|\| h_align != x
281	{	304	\|\| v_align != y)
282	if (h == 0) h = windowScale;
283
284	w = noScale;
285	geom_flags \|= WidthValue\|HeightValue;
286	}
287	else if (!strcasecmp (arr[i], "scale"))
288	{
289	if (h == 0) h = windowScale;
290	if (w == 0) w = windowScale;
291
292	geom_flags \|= WidthValue\|HeightValue;
293	}
294	else if (!strcasecmp (arr[i], "auto"))
295	{
296	w = h = windowScale;
297	x = y = centerAlign;
298	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
299	}
300	else if (!strcasecmp (arr[i], "root"))
301	{
302	new_flags \|= BG_TILE\|BG_ROOT_ALIGN;
303	w = h = noScale;
304	geom_flags \|= WidthValue\|HeightValue;
305	}
306	} /* done parsing ops */
307
308	rxvt_free_strsplit (arr);
309	}
310
311	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
312	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
313	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
314	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
315
316	if (new_flags != bg_flags)
317	{	305	{
318	bg_flags = new_flags;	306	bg_flags = new_flags;
		307	h_scale = w;
		308	v_scale = h;
		309	h_align = x;
		310	v_align = y;
319	changed = true;	311	changed = true;
320	}	312	}
321		313
322	return changed;	314	return changed;
323	}	315	}
…		…
326	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)	318	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
327	{	319	{
328	int target_width = szHint.width;	320	int target_width = szHint.width;
329	int target_height = szHint.height;	321	int target_height = szHint.height;
330		322
		323	w = h_scale * target_width / 100;
		324	h = v_scale * target_height / 100;
		325
331	if (bg_flags & BG_PROP_SCALE)	326	if (bg_flags & BG_KEEP_ASPECT)
332	{	327	{
333	float scale = (float)target_width / image_width;	328	float scale = (float)w / image_width;
334	min_it (scale, (float)target_height / image_height);	329	min_it (scale, (float)h / image_height);
335	w = image_width * scale + 0.5;	330	w = image_width * scale + 0.5;
336	h = image_height * scale + 0.5;	331	h = image_height * scale + 0.5;
337	}	332	}
338	else
339	{
340	w = h_scale * target_width / 100;
341	h = v_scale * target_height / 100;
342	}
343		333
344	if (!w) w = image_width;	334	if (!w) w = image_width;
345	if (!h) h = image_height;	335	if (!h) h = image_height;
346		336
347	if (bg_flags & BG_ROOT_ALIGN)	337	if (bg_flags & BG_ROOT_ALIGN)
…		…
355	y = make_align_position (v_align, target_height, h);	345	y = make_align_position (v_align, target_height, h);
356	}	346	}
357		347
358	bg_flags &= ~BG_IS_SIZE_SENSITIVE;	348	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
359	if (!(bg_flags & BG_TILE)	349	if (!(bg_flags & BG_TILE)
360	\|\| (bg_flags & BG_PROP_SCALE) \|\| h_scale \|\| v_scale	350	\|\| h_scale \|\| v_scale
361	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	351	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
362	\|\| w > target_width \|\| h > target_height)	352	\|\| w > target_width \|\| h > target_height)
363	bg_flags \|= BG_IS_SIZE_SENSITIVE;	353	bg_flags \|= BG_IS_SIZE_SENSITIVE;
364	}	354	}
365		355
…		…
392	}	382	}
393		383
394	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)	384	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
395	{	385	{
396	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,	386	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
397	(original_asim == NULL \|\| tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,	387	ASA_XImage,
398	100, ASIMAGE_QUALITY_DEFAULT);	388	100, ASIMAGE_QUALITY_DEFAULT);
399	if (tmp)	389	if (tmp)
400	{	390	{
401	destroy_asimage (&background);	391	destroy_asimage (&background);
402	background = tmp;	392	background = tmp;
…		…
421		411
422	if (!original_asim	412	if (!original_asim
423	\|\| (!(bg_flags & BG_ROOT_ALIGN)	413	\|\| (!(bg_flags & BG_ROOT_ALIGN)
424	&& (x >= target_width	414	&& (x >= target_width
425	\|\| y >= target_height	415	\|\| y >= target_height
426	\|\| (x + w <= 0)	416	\|\| x + w <= 0
427	\|\| (y + h <= 0))))	417	\|\| y + h <= 0)))
428	{	418	{
429	if (background)	419	if (background)
430	{	420	{
431	new_pmap_width = background->width;	421	new_pmap_width = background->width;
432	new_pmap_height = background->height;	422	new_pmap_height = background->height;
…		…
446	}	436	}
447	else	437	else
448	{	438	{
449	result = original_asim;	439	result = original_asim;
450		440
451	if ((w != original_asim->width)	441	if (w != original_asim->width
452	\|\| (h != original_asim->height))	442	\|\| h != original_asim->height)
453	{	443	{
454	result = scale_asimage (asv, original_asim,	444	result = scale_asimage (asv, original_asim,
455	w, h,	445	w, h,
456	background ? ASA_ASImage : ASA_XImage,	446	ASA_XImage,
457	100, ASIMAGE_QUALITY_DEFAULT);	447	100, ASIMAGE_QUALITY_DEFAULT);
458	}	448	}
459		449
460	if (background == NULL)	450	if (background == NULL)
461	{	451	{
…		…
711	get_image_geometry (image_width, image_height, w, h, x, y);	701	get_image_geometry (image_width, image_height, w, h, x, y);
712		702
713	if (!(bg_flags & BG_ROOT_ALIGN)	703	if (!(bg_flags & BG_ROOT_ALIGN)
714	&& (x >= target_width	704	&& (x >= target_width
715	\|\| y >= target_height	705	\|\| y >= target_height
716	\|\| (x + w <= 0)	706	\|\| x + w <= 0
717	\|\| (y + h <= 0)))	707	\|\| y + h <= 0))
718	return false;	708	return false;
719		709
720	result = pixbuf;	710	result = pixbuf;
721		711
722	if ((w != image_width)	712	if (w != image_width
723	\|\| (h != image_height))	713	\|\| h != image_height)
724	{	714	{
725	result = gdk_pixbuf_scale_simple (pixbuf,	715	result = gdk_pixbuf_scale_simple (pixbuf,
726	w, h,	716	w, h,
727	GDK_INTERP_BILINEAR);	717	GDK_INTERP_BILINEAR);
728	}	718	}
…		…
807	}	797	}
808		798
809	#if XRENDER	799	#if XRENDER
810	if (tr_flags)	800	if (tr_flags)
811	{	801	{
812	XRenderPictureAttributes pa;
813
814	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	802	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		803
815	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	804	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
816		805
817	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
818	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	806	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
819		807
820	pa.repeat = True;	808	Picture mask = create_xrender_mask (dpy, vt, False, False);
821	Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
822	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
823	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
824	XFreePixmap (dpy, mask_pmap);
825		809
826	XRenderColor mask_c;	810	XRenderColor mask_c;
827		811
828	mask_c.alpha = 0x8000;	812	mask_c.alpha = 0x8000;
829	mask_c.red = 0;	813	mask_c.red =
830	mask_c.green = 0;	814	mask_c.green =
831	mask_c.blue = 0;	815	mask_c.blue = 0;
832	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	816	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		817
833	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	818	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
834		819
835	XRenderFreePicture (dpy, src);	820	XRenderFreePicture (dpy, src);
836	XRenderFreePicture (dpy, dst);	821	XRenderFreePicture (dpy, dst);
837	XRenderFreePicture (dpy, mask);	822	XRenderFreePicture (dpy, mask);
…		…
857	rxvt_term::bg_set_file (const char *file)	842	rxvt_term::bg_set_file (const char *file)
858	{	843	{
859	if (!file \|\| !*file)	844	if (!file \|\| !*file)
860	return false;	845	return false;
861		846
		847	bool ret = false;
862	if (const char *p = strchr (file, ';'))	848	const char *p = strchr (file, ';');
		849
		850	if (p)
863	{	851	{
864	size_t len = p - file;	852	size_t len = p - file;
865	char *f = rxvt_temp_buf<char> (len + 1);	853	char *f = rxvt_temp_buf<char> (len + 1);
866	memcpy (f, file, len);	854	memcpy (f, file, len);
867	f[len] = '\0';	855	f[len] = '\0';
…		…
876	{	864	{
877	if (original_asim)	865	if (original_asim)
878	safe_asimage_destroy (original_asim);	866	safe_asimage_destroy (original_asim);
879	original_asim = image;	867	original_asim = image;
880	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;	868	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;
881	return true;	869	ret = true;
882	}	870	}
883	# endif	871	# endif
884		872
885	# ifdef HAVE_PIXBUF	873	# ifdef HAVE_PIXBUF
886	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	874	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
…		…
888	{	876	{
889	if (pixbuf)	877	if (pixbuf)
890	g_object_unref (pixbuf);	878	g_object_unref (pixbuf);
891	pixbuf = image;	879	pixbuf = image;
892	bg_flags \|= BG_IS_FROM_FILE;	880	bg_flags \|= BG_IS_FROM_FILE;
893	return true;	881	ret = true;
894	}	882	}
895	# endif	883	# endif
896		884
		885	if (ret)
		886	{
		887	if (p)
		888	bg_set_geometry (p + 1);
		889	else
		890	bg_set_default_geometry ();
		891	}
		892
897	return false;	893	return ret;
898	}	894	}
899		895
900	# endif /* BG_IMAGE_FROM_FILE */	896	# endif /* BG_IMAGE_FROM_FILE */
901		897
902	# ifdef ENABLE_TRANSPARENCY	898	# ifdef ENABLE_TRANSPARENCY
…		…
938	{	934	{
939	changed = true;	935	changed = true;
940	v_blurRadius = vr;	936	v_blurRadius = vr;
941	}	937	}
942		938
943	if (v_blurRadius == 0 && h_blurRadius == 0)	939	if (h_blurRadius == 0 \|\| v_blurRadius == 0)
944	bg_flags &= ~BG_NEEDS_BLUR;	940	bg_flags &= ~BG_NEEDS_BLUR;
945	else	941	else
946	bg_flags \|= BG_NEEDS_BLUR;	942	bg_flags \|= BG_NEEDS_BLUR;
947		943
948	return changed;	944	return changed;
949	}	945	}
950		946
951	void	947	void
952	rxvt_term::set_tint_shade_flags ()	948	rxvt_term::set_tint_shade_flags ()
953	{	949	{
954	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	950	rgba c;
955	bool has_shade = shade != 100;	951	bool has_shade = shade != 100;
956		952
957	bg_flags &= ~BG_TINT_FLAGS;	953	bg_flags &= ~BG_TINT_FLAGS;
958		954
959	if (bg_flags & BG_TINT_SET)	955	if (bg_flags & BG_TINT_SET)
…		…
985	}	981	}
986		982
987	bool	983	bool
988	rxvt_term::bg_set_shade (const char *shade_str)	984	rxvt_term::bg_set_shade (const char *shade_str)
989	{	985	{
990	int new_shade = (shade_str) ? atoi (shade_str) : 100;	986	int new_shade = atoi (shade_str);
991		987
992	clamp_it (new_shade, -100, 200);	988	clamp_it (new_shade, -100, 200);
993	if (new_shade < 0)	989	if (new_shade < 0)
994	new_shade = 200 - (100 + new_shade);	990	new_shade = 200 - (100 + new_shade);
995		991
…		…
1025	params[i+2] = XDoubleToFixed (kernel[i] / sum);	1021	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1026	}	1022	}
1027	#endif	1023	#endif
1028		1024
1029	bool	1025	bool
1030	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	1026	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1031	{	1027	{
1032	bool ret = false;	1028	bool ret = false;
1033	#if XRENDER	1029	#if XRENDER
		1030	if (!(bg_flags & BG_HAS_RENDER_CONV))
		1031	return false;
		1032
1034	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	1033	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1035	double kernel = (double )malloc (size * sizeof (double));	1034	double kernel = (double )malloc (size * sizeof (double));
1036	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	1035	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1037		1036
1038	XRenderPictureAttributes pa;	1037	XRenderPictureAttributes pa;
1039	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1038	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1040		1039
		1040	pa.repeat = RepeatPad;
1041	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1041	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		1042	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1042	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1043	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		1044	XFreePixmap (dpy, tmp);
1043		1045
1044	if (kernel && params)	1046	if (kernel && params)
1045	{	1047	{
1046	if (h_blurRadius)
1047	{
1048	size = h_blurRadius * 2 + 1;	1048	size = h_blurRadius * 2 + 1;
1049	get_gaussian_kernel (h_blurRadius, size, kernel, params);	1049	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1050		1050
1051	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1051	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1052	XRenderComposite (dpy,	1052	XRenderComposite (dpy,
1053	PictOpSrc,	1053	PictOpSrc,
1054	src,	1054	src,
1055	None,	1055	None,
1056	dst,	1056	dst,
1057	0, 0,	1057	0, 0,
1058	0, 0,	1058	0, 0,
1059	0, 0,	1059	0, 0,
1060	width, height);	1060	width, height);
1061	}
1062		1061
1063	if (v_blurRadius)	1062	::swap (src, dst);
1064	{	1063
1065	size = v_blurRadius * 2 + 1;	1064	size = v_blurRadius * 2 + 1;
1066	get_gaussian_kernel (v_blurRadius, size, kernel, params);	1065	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1067	::swap (params[0], params[1]);	1066	::swap (params[0], params[1]);
1068		1067
1069	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1068	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1070	XRenderComposite (dpy,	1069	XRenderComposite (dpy,
1071	PictOpSrc,	1070	PictOpSrc,
1072	src,	1071	src,
1073	None,	1072	None,
1074	dst,	1073	dst,
1075	0, 0,	1074	0, 0,
1076	0, 0,	1075	0, 0,
1077	0, 0,	1076	0, 0,
1078	width, height);	1077	width, height);
1079	}
1080		1078
1081	ret = true;	1079	ret = true;
1082	}	1080	}
1083		1081
1084	free (kernel);	1082	free (kernel);
…		…
1111	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	1109	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1112	ret = true;	1110	ret = true;
1113	XFreeGC (dpy, gc);	1111	XFreeGC (dpy, gc);
1114	}	1112	}
1115	}	1113	}
1116	else
1117	{
1118	# if XRENDER	1114	# if XRENDER
		1115	else if (bg_flags & BG_HAS_RENDER)
		1116	{
1119	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);	1117	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1120		1118
1121	if (bg_flags & BG_TINT_SET)	1119	if (bg_flags & BG_TINT_SET)
1122	tint.get (c);	1120	tint.get (c);
1123		1121
…		…
1132	c.r = c.r * (200 - shade) / 100;	1130	c.r = c.r * (200 - shade) / 100;
1133	c.g = c.g * (200 - shade) / 100;	1131	c.g = c.g * (200 - shade) / 100;
1134	c.b = c.b * (200 - shade) / 100;	1132	c.b = c.b * (200 - shade) / 100;
1135	}	1133	}
1136		1134
1137	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1138	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1135	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1139	XRenderPictureAttributes pa;
1140		1136
1141	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1137	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1142		1138
1143	pa.repeat = True;	1139	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1144		1140
1145	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	1141	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1146	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1147	XFreePixmap (dpy, overlay_pmap);
1148
1149	pa.component_alpha = True;
1150	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1151	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat \| CPComponentAlpha, &pa);
1152	XFreePixmap (dpy, mask_pmap);
1153		1142
1154	XRenderColor mask_c;	1143	XRenderColor mask_c;
1155		1144
1156	mask_c.alpha = 0xffff;	1145	mask_c.alpha = 0xffff;
1157	mask_c.red =	1146	mask_c.red =
…		…
1162	mask_c.alpha = 0;	1151	mask_c.alpha = 0;
1163	mask_c.red = 0xffff - c.r;	1152	mask_c.red = 0xffff - c.r;
1164	mask_c.green = 0xffff - c.g;	1153	mask_c.green = 0xffff - c.g;
1165	mask_c.blue = 0xffff - c.b;	1154	mask_c.blue = 0xffff - c.b;
1166	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	1155	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		1156
1167	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);	1157	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1168		1158
1169	if (shade > 100)	1159	if (shade > 100)
1170	{	1160	{
1171	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1172	mask_c.alpha = 0;	1161	mask_c.alpha = 0;
		1162	mask_c.red =
		1163	mask_c.green =
		1164	mask_c.blue = 0xffff * (shade - 100) / 100;
1173	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	1165	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1174		1166
1175	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);	1167	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1176	}	1168	}
1177		1169
1178	ret = true;	1170	ret = true;
1179		1171
1180	XRenderFreePicture (dpy, mask_pic);	1172	XRenderFreePicture (dpy, mask_pic);
1181	XRenderFreePicture (dpy, overlay_pic);	1173	XRenderFreePicture (dpy, overlay_pic);
1182	XRenderFreePicture (dpy, back_pic);	1174	XRenderFreePicture (dpy, back_pic);
		1175	}
1183	# endif	1176	# endif
1184	}
1185		1177
1186	return ret;	1178	return ret;
1187	}	1179	}
1188		1180
1189	/*	1181	/*
…		…
1240	#if XRENDER	1232	#if XRENDER
1241	if (bg_flags & BG_HAS_RENDER)	1233	if (bg_flags & BG_HAS_RENDER)
1242	{	1234	{
1243	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);	1235	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1244		1236
1245	XRenderPictureAttributes pa;
1246
1247	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	1237	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1248	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	1238	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1249		1239
1250	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	1240	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1251	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	1241	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1252		1242
1253	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	1243	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1254		1244
1255	XRenderFreePicture (dpy, src);	1245	XRenderFreePicture (dpy, src);
1256	XRenderFreePicture (dpy, dst);	1246	XRenderFreePicture (dpy, dst);
…		…
1273	bg_pmap_width = window_width;	1263	bg_pmap_width = window_width;
1274	bg_pmap_height = window_height;	1264	bg_pmap_height = window_height;
1275	}	1265	}
1276		1266
1277	/* straightforward pixmap copy */	1267	/* straightforward pixmap copy */
1278	while (sx < 0) sx += root_width;	1268	while (sx < 0) sx += root_pmap_width;
1279	while (sy < 0) sy += root_height;	1269	while (sy < 0) sy += root_pmap_height;
1280		1270
1281	gcv.tile = recoded_root_pmap;	1271	gcv.tile = recoded_root_pmap;
1282	gcv.fill_style = FillTiled;	1272	gcv.fill_style = FillTiled;
1283	gcv.ts_x_origin = -sx;	1273	gcv.ts_x_origin = -sx;
1284	gcv.ts_y_origin = -sy;	1274	gcv.ts_y_origin = -sy;
…		…
1286		1276
1287	if (gc)	1277	if (gc)
1288	{	1278	{
1289	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1279	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1290	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1280	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);
1291	XFreeGC (dpy, gc);
1292		1281
1293	if (!(bg_flags & BG_CLIENT_RENDER))	1282	if (!(bg_flags & BG_CLIENT_RENDER))
1294	{	1283	{
1295	if ((bg_flags & BG_NEEDS_BLUR)	1284	if (bg_flags & BG_NEEDS_BLUR)
1296	&& (bg_flags & BG_HAS_RENDER_CONV))
1297	{	1285	{
1298	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))	1286	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1299	result &= ~BG_NEEDS_BLUR;	1287	result &= ~BG_NEEDS_BLUR;
1300	}	1288	}
1301	if ((bg_flags & BG_NEEDS_TINT)	1289	if (bg_flags & BG_NEEDS_TINT)
1302	&& (bg_flags & (BG_TINT_BITAND \| BG_HAS_RENDER)))
1303	{	1290	{
1304	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))	1291	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1305	result &= ~BG_NEEDS_TINT;	1292	result &= ~BG_NEEDS_TINT;
1306	}	1293	}
		1294	# ifndef HAVE_AFTERIMAGE
		1295	if (result & BG_NEEDS_TINT)
		1296	{
		1297	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1298	if (ximage)
		1299	{
		1300	/* our own client-side tinting */
		1301	tint_ximage (DefaultVisual (dpy, display->screen), ximage);
		1302
		1303	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1304	XDestroyImage (ximage);
		1305	}
		1306	}
		1307	# endif
1307	} /* server side rendering completed */	1308	} /* server side rendering completed */
		1309
		1310	XFreeGC (dpy, gc);
1308	}	1311	}
1309		1312
1310	if (recoded_root_pmap != root_pixmap)	1313	if (recoded_root_pmap != root_pixmap)
1311	XFreePixmap (dpy, recoded_root_pmap);	1314	XFreePixmap (dpy, recoded_root_pmap);
1312		1315
…		…
1321	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);	1324	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1322		1325
1323	root_pixmap = new_root_pixmap;	1326	root_pixmap = new_root_pixmap;
1324	}	1327	}
1325	# endif /* ENABLE_TRANSPARENCY */	1328	# endif /* ENABLE_TRANSPARENCY */
1326
1327	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1328	static void shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c);
1329	# endif
1330		1329
1331	bool	1330	bool
1332	rxvt_term::bg_render ()	1331	rxvt_term::bg_render ()
1333	{	1332	{
1334	unsigned long tr_flags = 0;	1333	unsigned long tr_flags = 0;
…		…
1339	{	1338	{
1340	/* we need to re-generate transparency pixmap in that case ! */	1339	/* we need to re-generate transparency pixmap in that case ! */
1341	tr_flags = make_transparency_pixmap ();	1340	tr_flags = make_transparency_pixmap ();
1342	if (tr_flags == 0)	1341	if (tr_flags == 0)
1343	return false;	1342	return false;
1344	else if (!(tr_flags & BG_EFFECTS_FLAGS))
1345	bg_flags \|= BG_IS_VALID;	1343	bg_flags \|= BG_IS_VALID;
1346	}	1344	}
1347	# endif	1345	# endif
1348		1346
1349	# ifdef BG_IMAGE_FROM_FILE	1347	# ifdef BG_IMAGE_FROM_FILE
1350	if ((bg_flags & BG_IS_FROM_FILE)	1348	if ((bg_flags & BG_IS_FROM_FILE)
1351	\|\| (tr_flags & BG_EFFECTS_FLAGS))	1349	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1352	{	1350	{
1353	if (render_image (tr_flags))	1351	if (render_image (tr_flags))
1354	bg_flags \|= BG_IS_VALID;	1352	bg_flags \|= BG_IS_VALID;
1355	}
1356	# endif
1357
1358	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1359	XImage *result = NULL;
1360
1361	if (tr_flags && !(bg_flags & BG_IS_VALID))
1362	{
1363	result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1364	}
1365
1366	if (result)
1367	{
1368	/* our own client-side tinting */
1369	if (tr_flags & BG_NEEDS_TINT)
1370	{
1371	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1372	if (bg_flags & BG_TINT_SET)
1373	tint.get (c);
1374	shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1375	}
1376
1377	GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1378
1379	if (gc)
1380	{
1381	XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1382
1383	XFreeGC (dpy, gc);
1384	bg_flags \|= BG_IS_VALID;
1385	}
1386
1387	XDestroyImage (result);
1388	}	1353	}
1389	# endif	1354	# endif
1390		1355
1391	if (!(bg_flags & BG_IS_VALID))	1356	if (!(bg_flags & BG_IS_VALID))
1392	{	1357	{
…		…
1430	}	1395	}
1431		1396
1432	#endif /* HAVE_BG_PIXMAP */	1397	#endif /* HAVE_BG_PIXMAP */
1433		1398
1434	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1399	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1435	/* taken from aterm-0.4.2 */	1400	/* based on code from aterm-0.4.2 */
1436		1401
1437	static void	1402	static inline void
1438	shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c)	1403	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
		1404	{
		1405	for (int i = 0; i <= mask >> sh; i++)
		1406	{
		1407	uint32_t tmp;
		1408	tmp = i * high;
		1409	tmp += (mask >> sh) * low;
		1410	lookup[i] = (tmp / 0xffff) << sh;
		1411	}
		1412	}
		1413
		1414	void
		1415	rxvt_term::tint_ximage (Visual visual, XImage ximage)
1439	{	1416	{
1440	int sh_r, sh_g, sh_b;	1417	int sh_r, sh_g, sh_b;
1441	uint32_t mask_r, mask_g, mask_b;	1418	uint32_t mask_r, mask_g, mask_b;
1442	uint32_t lookup, lookup_r, lookup_g, lookup_b;	1419	uint32_t lookup, lookup_r, lookup_g, lookup_b;
1443	rgba low;	1420	unsigned short low;
1444	rgba high;
1445	int i;
1446	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	1421	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1447		1422
1448	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;	1423	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;
1449		1424
1450	/* for convenience */	1425	/* for convenience */
…		…
1509	break;	1484	break;
1510	default:	1485	default:
1511	return; /* we do not support this color depth */	1486	return; /* we do not support this color depth */
1512	}	1487	}
1513		1488
		1489	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
		1490
		1491	if (bg_flags & BG_TINT_SET)
		1492	tint.get (c);
		1493
1514	/* prepare limits for color transformation (each channel is handled separately) */	1494	/* prepare limits for color transformation (each channel is handled separately) */
1515	if (shade > 100)	1495	if (shade > 100)
1516	{	1496	{
1517	shade = 200 - shade;
1518
1519	high.r = c.r * shade / 100;
1520	high.g = c.g * shade / 100;
1521	high.b = c.b * shade / 100;
1522
1523	low.r = 65535 * (100 - shade) / 100;	1497	c.r = c.r * (200 - shade) / 100;
1524	low.g = 65535 * (100 - shade) / 100;	1498	c.g = c.g * (200 - shade) / 100;
1525	low.b = 65535 * (100 - shade) / 100;	1499	c.b = c.b * (200 - shade) / 100;
		1500
		1501	low = 0xffff * (shade - 100) / 100;
1526	}	1502	}
1527	else	1503	else
1528	{	1504	{
1529	high.r = c.r * shade / 100;	1505	c.r = c.r * shade / 100;
1530	high.g = c.g * shade / 100;	1506	c.g = c.g * shade / 100;
1531	high.b = c.b * shade / 100;	1507	c.b = c.b * shade / 100;
1532		1508
1533	low.r = low.g = low.b = 0;	1509	low = 0;
1534	}	1510	}
1535		1511
1536	/* fill our lookup tables */	1512	/* fill our lookup tables */
1537	for (i = 0; i <= mask_r>>sh_r; i++)	1513	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1538	{	1514	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1539	uint32_t tmp;	1515	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1540	tmp = i * high.r;
1541	tmp += (mask_r>>sh_r) * low.r;
1542	lookup_r[i] = (tmp/65535)<<sh_r;
1543	}
1544	for (i = 0; i <= mask_g>>sh_g; i++)
1545	{
1546	uint32_t tmp;
1547	tmp = i * high.g;
1548	tmp += (mask_g>>sh_g) * low.g;
1549	lookup_g[i] = (tmp/65535)<<sh_g;
1550	}
1551	for (i = 0; i <= mask_b>>sh_b; i++)
1552	{
1553	uint32_t tmp;
1554	tmp = i * high.b;
1555	tmp += (mask_b>>sh_b) * low.b;
1556	lookup_b[i] = (tmp/65535)<<sh_b;
1557	}
1558		1516
1559	/* apply table to input image (replacing colors by newly calculated ones) */	1517	/* apply table to input image (replacing colors by newly calculated ones) */
1560	if (ximage->bits_per_pixel == 32	1518	if (ximage->bits_per_pixel == 32
1561	&& (ximage->depth == 24 \|\| ximage->depth == 32)	1519	&& (ximage->depth == 24 \|\| ximage->depth == 32)
1562	&& ximage->byte_order == host_byte_order)	1520	&& 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.156 by sf-exg, Tue Aug 9 18:41:31 2011 UTC vs. Revision 1.198 by sf-exg, Wed Jan 11 13:51:07 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.156 by sf-exg, Tue Aug 9 18:41:31 2011 UTC vs.
Revision 1.198 by sf-exg, Wed Jan 11 13:51:07 2012 UTC