[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.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	*/
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)
…		…
123		129
124	return false;	130	return false;
125	}	131	}
126		132
127	# ifdef BG_IMAGE_FROM_FILE	133	# ifdef BG_IMAGE_FROM_FILE
128	static inline bool
129	check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
130	{
131	if (geom_flags & flag)
132	{
133	if (new_value > 1000)
134	new_value = 1000;
135	if (new_value != scale)
136	{
137	scale = new_value;
138	return true;
139	}
140	}
141	return false;
142	}
143
144	static inline bool
145	check_set_align_value (int geom_flags, int flag, int &align, int new_value)
146	{
147	if (geom_flags & flag)
148	{
149	if (new_value < -100)
150	new_value = -100;
151	else if (new_value > 200)
152	new_value = 200;
153	if (new_value != align)
154	{
155	align = new_value;
156	return true;
157	}
158	}
159	return false;
160	}
161
162	static inline int	134	static inline int
163	make_align_position (int align, int window_size, int image_size)	135	make_align_position (int align, int window_size, int image_size)
164	{	136	{
165	int diff = window_size - image_size;	137	int diff = window_size - image_size;
166	int smaller = min (image_size, window_size);	138	int smaller = min (image_size, window_size);
167		139
168	if (align >= 0 && align <= 100)	140	if (align >= 0 && align <= 100)
169	return diff * align / 100;	141	return diff * align / 100;
170	else if (align > 100 && align <= 200)	142	else if (align > 100 && align <= 200)
171	return ((align - 100) * smaller / 100) + window_size - smaller;	143	return (align - 100) * smaller / 100 + window_size - smaller;
172	else if (align >= -100 && align < 0)	144	else if (align >= -100 && align < 0)
173	return ((align + 100) * smaller / 100) - image_size;	145	return (align + 100) * smaller / 100 - image_size;
174	return 0;	146	return 0;
175	}	147	}
176		148
177	static inline int	149	static inline int
178	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)
…		…
185	src_pos = -pos;	157	src_pos = -pos;
186	dst_pos = 0;	158	dst_pos = 0;
187	dst_size += pos;	159	dst_size += pos;
188	}	160	}
189		161
190	if (dst_pos + dst_size > target_size)
191	dst_size = target_size - dst_pos;	162	min_it (dst_size, target_size - dst_pos);
192	return src_pos;	163	return src_pos;
193	}	164	}
194		165
195	bool	166	bool
196	rxvt_term::bg_set_geometry (const char *geom, bool update)	167	rxvt_term::bg_set_geometry (const char *geom, bool update)
197	{	168	{
198	bool changed = false;	169	bool changed = false;
199	int geom_flags = 0;	170	int geom_flags = 0;
200	int x = 0, y = 0;	171	int x = h_align;
		172	int y = v_align;
201	unsigned int w = 0, h = 0;	173	unsigned int w = h_scale;
202	unsigned int n;	174	unsigned int h = v_scale;
203	unsigned long new_flags = (bg_flags & (~BG_GEOMETRY_FLAGS));	175	unsigned long new_flags = 0;
204	const char *ops;
205		176
206	if (geom == NULL)	177	if (geom == NULL)
207	return false;	178	return false;
208		179
209	char str[256];	180	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	{	181	{
226	/* 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
227	geom_flags = XParseGeometry (str, &x, &y, &w, &h);	272	geom_flags \|= XParseGeometry (arr[i], &x, &y, &w, &h);
228	} /* done parsing geometry string */	273	} /* done parsing ops */
		274
		275	rxvt_free_strsplit (arr);
		276	}
		277
		278	new_flags \|= bg_flags & ~BG_GEOMETRY_FLAGS;
229		279
230	if (!update)	280	if (!update)
231	{	281	{
232	if (!(geom_flags & XValue))	282	if (!(geom_flags & XValue))
233	x = y = defaultAlign;	283	x = y = defaultAlign;
…		…
238	w = h = defaultScale;	288	w = h = defaultScale;
239	else if (!(geom_flags & HeightValue))	289	else if (!(geom_flags & HeightValue))
240	h = w;	290	h = w;
241	else if (!(geom_flags & WidthValue))	291	else if (!(geom_flags & WidthValue))
242	w = h;	292	w = h;
243
244	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
245	}
246
247	if (ops)
248	{	293	}
249	char **arr = rxvt_strsplit (':', ops + 1);
250		294
251	for (int i = 0; arr[i]; i++)	295	min_it (w, 1000);
252	{	296	min_it (h, 1000);
253	if (!strcasecmp (arr[i], "style=tiled"))	297	clamp_it (x, -100, 200);
254	{	298	clamp_it (y, -100, 200);
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		299
292	// deprecated	300	if (bg_flags != new_flags
293	else if (!strcasecmp (arr[i], "tile"))	301	\|\| h_scale != w
294	{	302	\|\| v_scale != h
295	new_flags \|= BG_TILE;	303	\|\| h_align != x
296	w = h = noScale;	304	\|\| v_align != y)
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;
340	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;
342	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
343
344	if (new_flags != bg_flags)
345	{	305	{
346	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;
347	changed = true;	311	changed = true;
348	}	312	}
349		313
350	return changed;	314	return changed;
351	}	315	}
…		…
354	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)
355	{	319	{
356	int target_width = szHint.width;	320	int target_width = szHint.width;
357	int target_height = szHint.height;	321	int target_height = szHint.height;
358		322
		323	w = h_scale * target_width / 100;
		324	h = v_scale * target_height / 100;
		325
359	if (bg_flags & BG_PROP_SCALE)	326	if (bg_flags & BG_KEEP_ASPECT)
360	{	327	{
361	float scale = (float)target_width / image_width;	328	float scale = (float)w / image_width;
362	min_it (scale, (float)target_height / image_height);	329	min_it (scale, (float)h / image_height);
363	w = image_width * scale + 0.5;	330	w = image_width * scale + 0.5;
364	h = image_height * scale + 0.5;	331	h = image_height * scale + 0.5;
365	}	332	}
366	else
367	{
368	w = h_scale * target_width / 100;
369	h = v_scale * target_height / 100;
370	}
371		333
372	if (!w) w = image_width;	334	if (!w) w = image_width;
373	if (!h) h = image_height;	335	if (!h) h = image_height;
374		336
375	if (bg_flags & BG_ROOT_ALIGN)	337	if (bg_flags & BG_ROOT_ALIGN)
…		…
383	y = make_align_position (v_align, target_height, h);	345	y = make_align_position (v_align, target_height, h);
384	}	346	}
385		347
386	bg_flags &= ~BG_IS_SIZE_SENSITIVE;	348	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
387	if (!(bg_flags & BG_TILE)	349	if (!(bg_flags & BG_TILE)
388	\|\| (bg_flags & BG_PROP_SCALE) \|\| h_scale \|\| v_scale	350	\|\| h_scale \|\| v_scale
389	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	351	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
390	\|\| w > target_width \|\| h > target_height)	352	\|\| w > target_width \|\| h > target_height)
391	bg_flags \|= BG_IS_SIZE_SENSITIVE;	353	bg_flags \|= BG_IS_SIZE_SENSITIVE;
392	}	354	}
393		355
…		…
420	}	382	}
421		383
422	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)	384	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
423	{	385	{
424	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,
425	(original_asim == NULL \|\| tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,	387	ASA_XImage,
426	100, ASIMAGE_QUALITY_DEFAULT);	388	100, ASIMAGE_QUALITY_DEFAULT);
427	if (tmp)	389	if (tmp)
428	{	390	{
429	destroy_asimage (&background);	391	destroy_asimage (&background);
430	background = tmp;	392	background = tmp;
…		…
449		411
450	if (!original_asim	412	if (!original_asim
451	\|\| (!(bg_flags & BG_ROOT_ALIGN)	413	\|\| (!(bg_flags & BG_ROOT_ALIGN)
452	&& (x >= target_width	414	&& (x >= target_width
453	\|\| y >= target_height	415	\|\| y >= target_height
454	\|\| (x + w <= 0)	416	\|\| x + w <= 0
455	\|\| (y + h <= 0))))	417	\|\| y + h <= 0)))
456	{	418	{
457	if (background)	419	if (background)
458	{	420	{
459	new_pmap_width = background->width;	421	new_pmap_width = background->width;
460	new_pmap_height = background->height;	422	new_pmap_height = background->height;
…		…
474	}	436	}
475	else	437	else
476	{	438	{
477	result = original_asim;	439	result = original_asim;
478		440
479	if ((w != original_asim->width)	441	if (w != original_asim->width
480	\|\| (h != original_asim->height))	442	\|\| h != original_asim->height)
481	{	443	{
482	result = scale_asimage (asv, original_asim,	444	result = scale_asimage (asv, original_asim,
483	w, h,	445	w, h,
484	background ? ASA_ASImage : ASA_XImage,	446	ASA_XImage,
485	100, ASIMAGE_QUALITY_DEFAULT);	447	100, ASIMAGE_QUALITY_DEFAULT);
486	}	448	}
487		449
488	if (background == NULL)	450	if (background == NULL)
489	{	451	{
…		…
739	get_image_geometry (image_width, image_height, w, h, x, y);	701	get_image_geometry (image_width, image_height, w, h, x, y);
740		702
741	if (!(bg_flags & BG_ROOT_ALIGN)	703	if (!(bg_flags & BG_ROOT_ALIGN)
742	&& (x >= target_width	704	&& (x >= target_width
743	\|\| y >= target_height	705	\|\| y >= target_height
744	\|\| (x + w <= 0)	706	\|\| x + w <= 0
745	\|\| (y + h <= 0)))	707	\|\| y + h <= 0))
746	return false;	708	return false;
747		709
748	result = pixbuf;	710	result = pixbuf;
749		711
750	if ((w != image_width)	712	if (w != image_width
751	\|\| (h != image_height))	713	\|\| h != image_height)
752	{	714	{
753	result = gdk_pixbuf_scale_simple (pixbuf,	715	result = gdk_pixbuf_scale_simple (pixbuf,
754	w, h,	716	w, h,
755	GDK_INTERP_BILINEAR);	717	GDK_INTERP_BILINEAR);
756	}	718	}
…		…
835	}	797	}
836		798
837	#if XRENDER	799	#if XRENDER
838	if (tr_flags)	800	if (tr_flags)
839	{	801	{
840	XRenderPictureAttributes pa;
841
842	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	802	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		803
843	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	804	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
844		805
845	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
846	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	806	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
847		807
848	pa.repeat = True;	808	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		809
854	XRenderColor mask_c;	810	XRenderColor mask_c;
855		811
856	mask_c.alpha = 0x8000;	812	mask_c.alpha = 0x8000;
857	mask_c.red = 0;	813	mask_c.red =
858	mask_c.green = 0;	814	mask_c.green =
859	mask_c.blue = 0;	815	mask_c.blue = 0;
860	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	816	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		817
861	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);
862		819
863	XRenderFreePicture (dpy, src);	820	XRenderFreePicture (dpy, src);
864	XRenderFreePicture (dpy, dst);	821	XRenderFreePicture (dpy, dst);
865	XRenderFreePicture (dpy, mask);	822	XRenderFreePicture (dpy, mask);
…		…
885	rxvt_term::bg_set_file (const char *file)	842	rxvt_term::bg_set_file (const char *file)
886	{	843	{
887	if (!file \|\| !*file)	844	if (!file \|\| !*file)
888	return false;	845	return false;
889		846
		847	bool ret = false;
890	if (const char *p = strchr (file, ';'))	848	const char *p = strchr (file, ';');
		849
		850	if (p)
891	{	851	{
892	size_t len = p - file;	852	size_t len = p - file;
893	char *f = rxvt_temp_buf<char> (len + 1);	853	char *f = rxvt_temp_buf<char> (len + 1);
894	memcpy (f, file, len);	854	memcpy (f, file, len);
895	f[len] = '\0';	855	f[len] = '\0';
…		…
904	{	864	{
905	if (original_asim)	865	if (original_asim)
906	safe_asimage_destroy (original_asim);	866	safe_asimage_destroy (original_asim);
907	original_asim = image;	867	original_asim = image;
908	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;	868	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;
909	return true;	869	ret = true;
910	}	870	}
911	# endif	871	# endif
912		872
913	# ifdef HAVE_PIXBUF	873	# ifdef HAVE_PIXBUF
914	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	874	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
…		…
916	{	876	{
917	if (pixbuf)	877	if (pixbuf)
918	g_object_unref (pixbuf);	878	g_object_unref (pixbuf);
919	pixbuf = image;	879	pixbuf = image;
920	bg_flags \|= BG_IS_FROM_FILE;	880	bg_flags \|= BG_IS_FROM_FILE;
921	return true;	881	ret = true;
922	}	882	}
923	# endif	883	# endif
924		884
		885	if (ret)
		886	{
		887	if (p)
		888	bg_set_geometry (p + 1);
		889	else
		890	bg_set_default_geometry ();
		891	}
		892
925	return false;	893	return ret;
926	}	894	}
927		895
928	# endif /* BG_IMAGE_FROM_FILE */	896	# endif /* BG_IMAGE_FROM_FILE */
929		897
930	# ifdef ENABLE_TRANSPARENCY	898	# ifdef ENABLE_TRANSPARENCY
…		…
966	{	934	{
967	changed = true;	935	changed = true;
968	v_blurRadius = vr;	936	v_blurRadius = vr;
969	}	937	}
970		938
971	if (v_blurRadius == 0 && h_blurRadius == 0)	939	if (h_blurRadius == 0 \|\| v_blurRadius == 0)
972	bg_flags &= ~BG_NEEDS_BLUR;	940	bg_flags &= ~BG_NEEDS_BLUR;
973	else	941	else
974	bg_flags \|= BG_NEEDS_BLUR;	942	bg_flags \|= BG_NEEDS_BLUR;
975		943
976	return changed;	944	return changed;
977	}	945	}
978		946
979	void	947	void
980	rxvt_term::set_tint_shade_flags ()	948	rxvt_term::set_tint_shade_flags ()
981	{	949	{
982	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	950	rgba c;
983	bool has_shade = shade != 100;	951	bool has_shade = shade != 100;
984		952
985	bg_flags &= ~BG_TINT_FLAGS;	953	bg_flags &= ~BG_TINT_FLAGS;
986		954
987	if (bg_flags & BG_TINT_SET)	955	if (bg_flags & BG_TINT_SET)
…		…
1013	}	981	}
1014		982
1015	bool	983	bool
1016	rxvt_term::bg_set_shade (const char *shade_str)	984	rxvt_term::bg_set_shade (const char *shade_str)
1017	{	985	{
1018	int new_shade = (shade_str) ? atoi (shade_str) : 100;	986	int new_shade = atoi (shade_str);
1019		987
1020	clamp_it (new_shade, -100, 200);	988	clamp_it (new_shade, -100, 200);
1021	if (new_shade < 0)	989	if (new_shade < 0)
1022	new_shade = 200 - (100 + new_shade);	990	new_shade = 200 - (100 + new_shade);
1023		991
…		…
1053	params[i+2] = XDoubleToFixed (kernel[i] / sum);	1021	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1054	}	1022	}
1055	#endif	1023	#endif
1056		1024
1057	bool	1025	bool
1058	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)
1059	{	1027	{
1060	bool ret = false;	1028	bool ret = false;
1061	#if XRENDER	1029	#if XRENDER
		1030	if (!(bg_flags & BG_HAS_RENDER_CONV))
		1031	return false;
		1032
1062	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	1033	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1063	double kernel = (double )malloc (size * sizeof (double));	1034	double kernel = (double )malloc (size * sizeof (double));
1064	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	1035	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1065		1036
1066	XRenderPictureAttributes pa;	1037	XRenderPictureAttributes pa;
1067	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1038	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1068		1039
		1040	pa.repeat = RepeatPad;
1069	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);
1070	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1043	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		1044	XFreePixmap (dpy, tmp);
1071		1045
1072	if (kernel && params)	1046	if (kernel && params)
1073	{	1047	{
1074	if (h_blurRadius)
1075	{
1076	size = h_blurRadius * 2 + 1;	1048	size = h_blurRadius * 2 + 1;
1077	get_gaussian_kernel (h_blurRadius, size, kernel, params);	1049	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1078		1050
1079	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1051	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1080	XRenderComposite (dpy,	1052	XRenderComposite (dpy,
1081	PictOpSrc,	1053	PictOpSrc,
1082	src,	1054	src,
1083	None,	1055	None,
1084	dst,	1056	dst,
1085	0, 0,	1057	0, 0,
1086	0, 0,	1058	0, 0,
1087	0, 0,	1059	0, 0,
1088	width, height);	1060	width, height);
1089	}
1090		1061
1091	if (v_blurRadius)	1062	::swap (src, dst);
1092	{	1063
1093	size = v_blurRadius * 2 + 1;	1064	size = v_blurRadius * 2 + 1;
1094	get_gaussian_kernel (v_blurRadius, size, kernel, params);	1065	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1095	::swap (params[0], params[1]);	1066	::swap (params[0], params[1]);
1096		1067
1097	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1068	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1098	XRenderComposite (dpy,	1069	XRenderComposite (dpy,
1099	PictOpSrc,	1070	PictOpSrc,
1100	src,	1071	src,
1101	None,	1072	None,
1102	dst,	1073	dst,
1103	0, 0,	1074	0, 0,
1104	0, 0,	1075	0, 0,
1105	0, 0,	1076	0, 0,
1106	width, height);	1077	width, height);
1107	}
1108		1078
1109	ret = true;	1079	ret = true;
1110	}	1080	}
1111		1081
1112	free (kernel);	1082	free (kernel);
…		…
1139	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	1109	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1140	ret = true;	1110	ret = true;
1141	XFreeGC (dpy, gc);	1111	XFreeGC (dpy, gc);
1142	}	1112	}
1143	}	1113	}
1144	else
1145	{
1146	# if XRENDER	1114	# if XRENDER
		1115	else if (bg_flags & BG_HAS_RENDER)
		1116	{
1147	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);	1117	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1148		1118
1149	if (bg_flags & BG_TINT_SET)	1119	if (bg_flags & BG_TINT_SET)
1150	tint.get (c);	1120	tint.get (c);
1151		1121
…		…
1160	c.r = c.r * (200 - shade) / 100;	1130	c.r = c.r * (200 - shade) / 100;
1161	c.g = c.g * (200 - shade) / 100;	1131	c.g = c.g * (200 - shade) / 100;
1162	c.b = c.b * (200 - shade) / 100;	1132	c.b = c.b * (200 - shade) / 100;
1163	}	1133	}
1164		1134
1165	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1166	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1135	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1167	XRenderPictureAttributes pa;
1168		1136
1169	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1137	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1170		1138
1171	pa.repeat = True;	1139	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1172		1140
1173	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	1141	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		1142
1182	XRenderColor mask_c;	1143	XRenderColor mask_c;
1183		1144
1184	mask_c.alpha = 0xffff;	1145	mask_c.alpha = 0xffff;
1185	mask_c.red =	1146	mask_c.red =
…		…
1190	mask_c.alpha = 0;	1151	mask_c.alpha = 0;
1191	mask_c.red = 0xffff - c.r;	1152	mask_c.red = 0xffff - c.r;
1192	mask_c.green = 0xffff - c.g;	1153	mask_c.green = 0xffff - c.g;
1193	mask_c.blue = 0xffff - c.b;	1154	mask_c.blue = 0xffff - c.b;
1194	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	1155	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		1156
1195	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);
1196		1158
1197	if (shade > 100)	1159	if (shade > 100)
1198	{	1160	{
1199	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1200	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;
1201	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	1165	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1202		1166
1203	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);
1204	}	1168	}
1205		1169
1206	ret = true;	1170	ret = true;
1207		1171
1208	XRenderFreePicture (dpy, mask_pic);	1172	XRenderFreePicture (dpy, mask_pic);
1209	XRenderFreePicture (dpy, overlay_pic);	1173	XRenderFreePicture (dpy, overlay_pic);
1210	XRenderFreePicture (dpy, back_pic);	1174	XRenderFreePicture (dpy, back_pic);
		1175	}
1211	# endif	1176	# endif
1212	}
1213		1177
1214	return ret;	1178	return ret;
1215	}	1179	}
1216		1180
1217	/*	1181	/*
…		…
1268	#if XRENDER	1232	#if XRENDER
1269	if (bg_flags & BG_HAS_RENDER)	1233	if (bg_flags & BG_HAS_RENDER)
1270	{	1234	{
1271	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);
1272		1236
1273	XRenderPictureAttributes pa;
1274
1275	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	1237	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1276	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	1238	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1277		1239
1278	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	1240	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1279	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	1241	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1280		1242
1281	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);
1282		1244
1283	XRenderFreePicture (dpy, src);	1245	XRenderFreePicture (dpy, src);
1284	XRenderFreePicture (dpy, dst);	1246	XRenderFreePicture (dpy, dst);
…		…
1301	bg_pmap_width = window_width;	1263	bg_pmap_width = window_width;
1302	bg_pmap_height = window_height;	1264	bg_pmap_height = window_height;
1303	}	1265	}
1304		1266
1305	/* straightforward pixmap copy */	1267	/* straightforward pixmap copy */
1306	while (sx < 0) sx += root_width;	1268	while (sx < 0) sx += root_pmap_width;
1307	while (sy < 0) sy += root_height;	1269	while (sy < 0) sy += root_pmap_height;
1308		1270
1309	gcv.tile = recoded_root_pmap;	1271	gcv.tile = recoded_root_pmap;
1310	gcv.fill_style = FillTiled;	1272	gcv.fill_style = FillTiled;
1311	gcv.ts_x_origin = -sx;	1273	gcv.ts_x_origin = -sx;
1312	gcv.ts_y_origin = -sy;	1274	gcv.ts_y_origin = -sy;
…		…
1314		1276
1315	if (gc)	1277	if (gc)
1316	{	1278	{
1317	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1279	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1318	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1280	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);
1319	XFreeGC (dpy, gc);
1320		1281
1321	if (!(bg_flags & BG_CLIENT_RENDER))	1282	if (!(bg_flags & BG_CLIENT_RENDER))
1322	{	1283	{
1323	if ((bg_flags & BG_NEEDS_BLUR)	1284	if (bg_flags & BG_NEEDS_BLUR)
1324	&& (bg_flags & BG_HAS_RENDER_CONV))
1325	{	1285	{
1326	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))	1286	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1327	result &= ~BG_NEEDS_BLUR;	1287	result &= ~BG_NEEDS_BLUR;
1328	}	1288	}
1329	if ((bg_flags & BG_NEEDS_TINT)	1289	if (bg_flags & BG_NEEDS_TINT)
1330	&& (bg_flags & (BG_TINT_BITAND \| BG_HAS_RENDER)))
1331	{	1290	{
1332	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))	1291	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1333	result &= ~BG_NEEDS_TINT;	1292	result &= ~BG_NEEDS_TINT;
1334	}	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
1335	} /* server side rendering completed */	1308	} /* server side rendering completed */
		1309
		1310	XFreeGC (dpy, gc);
1336	}	1311	}
1337		1312
1338	if (recoded_root_pmap != root_pixmap)	1313	if (recoded_root_pmap != root_pixmap)
1339	XFreePixmap (dpy, recoded_root_pmap);	1314	XFreePixmap (dpy, recoded_root_pmap);
1340		1315
…		…
1349	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);	1324	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1350		1325
1351	root_pixmap = new_root_pixmap;	1326	root_pixmap = new_root_pixmap;
1352	}	1327	}
1353	# endif /* ENABLE_TRANSPARENCY */	1328	# 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		1329
1359	bool	1330	bool
1360	rxvt_term::bg_render ()	1331	rxvt_term::bg_render ()
1361	{	1332	{
1362	unsigned long tr_flags = 0;	1333	unsigned long tr_flags = 0;
…		…
1367	{	1338	{
1368	/* we need to re-generate transparency pixmap in that case ! */	1339	/* we need to re-generate transparency pixmap in that case ! */
1369	tr_flags = make_transparency_pixmap ();	1340	tr_flags = make_transparency_pixmap ();
1370	if (tr_flags == 0)	1341	if (tr_flags == 0)
1371	return false;	1342	return false;
1372	else if (!(tr_flags & BG_EFFECTS_FLAGS))
1373	bg_flags \|= BG_IS_VALID;	1343	bg_flags \|= BG_IS_VALID;
1374	}	1344	}
1375	# endif	1345	# endif
1376		1346
1377	# ifdef BG_IMAGE_FROM_FILE	1347	# ifdef BG_IMAGE_FROM_FILE
1378	if ((bg_flags & BG_IS_FROM_FILE)	1348	if ((bg_flags & BG_IS_FROM_FILE)
1379	\|\| (tr_flags & BG_EFFECTS_FLAGS))	1349	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1380	{	1350	{
1381	if (render_image (tr_flags))	1351	if (render_image (tr_flags))
1382	bg_flags \|= BG_IS_VALID;	1352	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	}	1353	}
1417	# endif	1354	# endif
1418		1355
1419	if (!(bg_flags & BG_IS_VALID))	1356	if (!(bg_flags & BG_IS_VALID))
1420	{	1357	{
…		…
1458	}	1395	}
1459		1396
1460	#endif /* HAVE_BG_PIXMAP */	1397	#endif /* HAVE_BG_PIXMAP */
1461		1398
1462	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1399	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1463	/* taken from aterm-0.4.2 */	1400	/* based on code from aterm-0.4.2 */
1464		1401
1465	static void	1402	static inline void
1466	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)
1467	{	1416	{
1468	int sh_r, sh_g, sh_b;	1417	int sh_r, sh_g, sh_b;
1469	uint32_t mask_r, mask_g, mask_b;	1418	uint32_t mask_r, mask_g, mask_b;
1470	uint32_t lookup, lookup_r, lookup_g, lookup_b;	1419	uint32_t lookup, lookup_r, lookup_g, lookup_b;
1471	rgba low;	1420	unsigned short low;
1472	rgba high;
1473	int i;
1474	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	1421	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1475		1422
1476	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;	1423	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;
1477		1424
1478	/* for convenience */	1425	/* for convenience */
…		…
1537	break;	1484	break;
1538	default:	1485	default:
1539	return; /* we do not support this color depth */	1486	return; /* we do not support this color depth */
1540	}	1487	}
1541		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
1542	/* prepare limits for color transformation (each channel is handled separately) */	1494	/* prepare limits for color transformation (each channel is handled separately) */
1543	if (shade > 100)	1495	if (shade > 100)
1544	{	1496	{
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;	1497	c.r = c.r * (200 - shade) / 100;
1552	low.g = 65535 * (100 - shade) / 100;	1498	c.g = c.g * (200 - shade) / 100;
1553	low.b = 65535 * (100 - shade) / 100;	1499	c.b = c.b * (200 - shade) / 100;
		1500
		1501	low = 0xffff * (shade - 100) / 100;
1554	}	1502	}
1555	else	1503	else
1556	{	1504	{
1557	high.r = c.r * shade / 100;	1505	c.r = c.r * shade / 100;
1558	high.g = c.g * shade / 100;	1506	c.g = c.g * shade / 100;
1559	high.b = c.b * shade / 100;	1507	c.b = c.b * shade / 100;
1560		1508
1561	low.r = low.g = low.b = 0;	1509	low = 0;
1562	}	1510	}
1563		1511
1564	/* fill our lookup tables */	1512	/* fill our lookup tables */
1565	for (i = 0; i <= mask_r>>sh_r; i++)	1513	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1566	{	1514	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1567	uint32_t tmp;	1515	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		1516
1587	/* apply table to input image (replacing colors by newly calculated ones) */	1517	/* apply table to input image (replacing colors by newly calculated ones) */
1588	if (ximage->bits_per_pixel == 32	1518	if (ximage->bits_per_pixel == 32
1589	&& (ximage->depth == 24 \|\| ximage->depth == 32)	1519	&& (ximage->depth == 24 \|\| ximage->depth == 32)
1590	&& 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.162 by sf-exg, Thu Aug 11 12:27:26 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.162 by sf-exg, Thu Aug 11 12:27:26 2011 UTC vs.
Revision 1.198 by sf-exg, Wed Jan 11 13:51:07 2012 UTC