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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.161 by sf-exg, Thu Aug 11 08:39:10 2011 UTC vs.
Revision 1.199 by sf-exg, Tue Jan 17 19:51:30 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	w = windowScale;
306	h = noScale;
307	geom_flags \|= WidthValue\|HeightValue;
308	}
309	else if (!strcasecmp (arr[i], "vscale"))
310	{
311	h = windowScale;
312	w = noScale;
313	geom_flags \|= WidthValue\|HeightValue;
314	}
315	else if (!strcasecmp (arr[i], "scale"))
316	{
317	w = h = windowScale;
318	geom_flags \|= WidthValue\|HeightValue;
319	}
320	else if (!strcasecmp (arr[i], "auto"))
321	{
322	w = h = windowScale;
323	x = y = centerAlign;
324	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
325	}
326	else if (!strcasecmp (arr[i], "root"))
327	{
328	new_flags \|= BG_TILE\|BG_ROOT_ALIGN;
329	w = h = noScale;
330	geom_flags \|= WidthValue\|HeightValue;
331	}
332	} /* done parsing ops */
333
334	rxvt_free_strsplit (arr);
335	}
336
337	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
338	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
339	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
340	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
341
342	if (new_flags != bg_flags)
343	{	305	{
344	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;
345	changed = true;	311	changed = true;
346	}	312	}
347		313
348	return changed;	314	return changed;
349	}	315	}
…		…
352	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)
353	{	319	{
354	int target_width = szHint.width;	320	int target_width = szHint.width;
355	int target_height = szHint.height;	321	int target_height = szHint.height;
356		322
		323	w = h_scale * target_width / 100;
		324	h = v_scale * target_height / 100;
		325
357	if (bg_flags & BG_PROP_SCALE)	326	if (bg_flags & BG_KEEP_ASPECT)
358	{	327	{
359	float scale = (float)target_width / image_width;	328	float scale = (float)w / image_width;
360	min_it (scale, (float)target_height / image_height);	329	min_it (scale, (float)h / image_height);
361	w = image_width * scale + 0.5;	330	w = image_width * scale + 0.5;
362	h = image_height * scale + 0.5;	331	h = image_height * scale + 0.5;
363	}	332	}
364	else
365	{
366	w = h_scale * target_width / 100;
367	h = v_scale * target_height / 100;
368	}
369		333
370	if (!w) w = image_width;	334	if (!w) w = image_width;
371	if (!h) h = image_height;	335	if (!h) h = image_height;
372		336
373	if (bg_flags & BG_ROOT_ALIGN)	337	if (bg_flags & BG_ROOT_ALIGN)
…		…
381	y = make_align_position (v_align, target_height, h);	345	y = make_align_position (v_align, target_height, h);
382	}	346	}
383		347
384	bg_flags &= ~BG_IS_SIZE_SENSITIVE;	348	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
385	if (!(bg_flags & BG_TILE)	349	if (!(bg_flags & BG_TILE)
386	\|\| (bg_flags & BG_PROP_SCALE) \|\| h_scale \|\| v_scale	350	\|\| h_scale \|\| v_scale
387	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	351	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
388	\|\| w > target_width \|\| h > target_height)	352	\|\| w > target_width \|\| h > target_height)
389	bg_flags \|= BG_IS_SIZE_SENSITIVE;	353	bg_flags \|= BG_IS_SIZE_SENSITIVE;
390	}	354	}
391		355
…		…
418	}	382	}
419		383
420	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)	384	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
421	{	385	{
422	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,
423	(original_asim == NULL \|\| tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,	387	ASA_XImage,
424	100, ASIMAGE_QUALITY_DEFAULT);	388	100, ASIMAGE_QUALITY_DEFAULT);
425	if (tmp)	389	if (tmp)
426	{	390	{
427	destroy_asimage (&background);	391	destroy_asimage (&background);
428	background = tmp;	392	background = tmp;
…		…
447		411
448	if (!original_asim	412	if (!original_asim
449	\|\| (!(bg_flags & BG_ROOT_ALIGN)	413	\|\| (!(bg_flags & BG_ROOT_ALIGN)
450	&& (x >= target_width	414	&& (x >= target_width
451	\|\| y >= target_height	415	\|\| y >= target_height
452	\|\| (x + w <= 0)	416	\|\| x + w <= 0
453	\|\| (y + h <= 0))))	417	\|\| y + h <= 0)))
454	{	418	{
455	if (background)	419	if (background)
456	{	420	{
457	new_pmap_width = background->width;	421	new_pmap_width = background->width;
458	new_pmap_height = background->height;	422	new_pmap_height = background->height;
…		…
472	}	436	}
473	else	437	else
474	{	438	{
475	result = original_asim;	439	result = original_asim;
476		440
477	if ((w != original_asim->width)	441	if (w != original_asim->width
478	\|\| (h != original_asim->height))	442	\|\| h != original_asim->height)
479	{	443	{
480	result = scale_asimage (asv, original_asim,	444	result = scale_asimage (asv, original_asim,
481	w, h,	445	w, h,
482	background ? ASA_ASImage : ASA_XImage,	446	ASA_XImage,
483	100, ASIMAGE_QUALITY_DEFAULT);	447	100, ASIMAGE_QUALITY_DEFAULT);
484	}	448	}
485		449
486	if (background == NULL)	450	if (background == NULL)
487	{	451	{
…		…
737	get_image_geometry (image_width, image_height, w, h, x, y);	701	get_image_geometry (image_width, image_height, w, h, x, y);
738		702
739	if (!(bg_flags & BG_ROOT_ALIGN)	703	if (!(bg_flags & BG_ROOT_ALIGN)
740	&& (x >= target_width	704	&& (x >= target_width
741	\|\| y >= target_height	705	\|\| y >= target_height
742	\|\| (x + w <= 0)	706	\|\| x + w <= 0
743	\|\| (y + h <= 0)))	707	\|\| y + h <= 0))
744	return false;	708	return false;
745		709
746	result = pixbuf;	710	result = pixbuf;
747		711
748	if ((w != image_width)	712	if (w != image_width
749	\|\| (h != image_height))	713	\|\| h != image_height)
750	{	714	{
751	result = gdk_pixbuf_scale_simple (pixbuf,	715	result = gdk_pixbuf_scale_simple (pixbuf,
752	w, h,	716	w, h,
753	GDK_INTERP_BILINEAR);	717	GDK_INTERP_BILINEAR);
754	}	718	}
…		…
833	}	797	}
834		798
835	#if XRENDER	799	#if XRENDER
836	if (tr_flags)	800	if (tr_flags)
837	{	801	{
838	XRenderPictureAttributes pa;
839
840	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	802	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		803
841	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	804	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
842		805
843	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
844	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	806	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
845		807
846	pa.repeat = True;	808	Picture mask = create_xrender_mask (dpy, vt, False, False);
847	Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
848	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
849	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
850	XFreePixmap (dpy, mask_pmap);
851		809
852	XRenderColor mask_c;	810	XRenderColor mask_c;
853		811
854	mask_c.alpha = 0x8000;	812	mask_c.alpha = 0x8000;
855	mask_c.red = 0;	813	mask_c.red =
856	mask_c.green = 0;	814	mask_c.green =
857	mask_c.blue = 0;	815	mask_c.blue = 0;
858	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	816	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		817
859	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);
860		819
861	XRenderFreePicture (dpy, src);	820	XRenderFreePicture (dpy, src);
862	XRenderFreePicture (dpy, dst);	821	XRenderFreePicture (dpy, dst);
863	XRenderFreePicture (dpy, mask);	822	XRenderFreePicture (dpy, mask);
…		…
883	rxvt_term::bg_set_file (const char *file)	842	rxvt_term::bg_set_file (const char *file)
884	{	843	{
885	if (!file \|\| !*file)	844	if (!file \|\| !*file)
886	return false;	845	return false;
887		846
		847	bool ret = false;
888	if (const char *p = strchr (file, ';'))	848	const char *p = strchr (file, ';');
		849
		850	if (p)
889	{	851	{
890	size_t len = p - file;	852	size_t len = p - file;
891	char *f = rxvt_temp_buf<char> (len + 1);	853	char *f = rxvt_temp_buf<char> (len + 1);
892	memcpy (f, file, len);	854	memcpy (f, file, len);
893	f[len] = '\0';	855	f[len] = '\0';
…		…
902	{	864	{
903	if (original_asim)	865	if (original_asim)
904	safe_asimage_destroy (original_asim);	866	safe_asimage_destroy (original_asim);
905	original_asim = image;	867	original_asim = image;
906	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;	868	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;
907	return true;	869	ret = true;
908	}	870	}
909	# endif	871	# endif
910		872
911	# ifdef HAVE_PIXBUF	873	# ifdef HAVE_PIXBUF
912	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	874	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
…		…
914	{	876	{
915	if (pixbuf)	877	if (pixbuf)
916	g_object_unref (pixbuf);	878	g_object_unref (pixbuf);
917	pixbuf = image;	879	pixbuf = image;
918	bg_flags \|= BG_IS_FROM_FILE;	880	bg_flags \|= BG_IS_FROM_FILE;
919	return true;	881	ret = true;
920	}	882	}
921	# endif	883	# endif
922		884
		885	if (ret)
		886	{
		887	if (p)
		888	bg_set_geometry (p + 1);
		889	else
		890	bg_set_default_geometry ();
		891	}
		892
923	return false;	893	return ret;
924	}	894	}
925		895
926	# endif /* BG_IMAGE_FROM_FILE */	896	# endif /* BG_IMAGE_FROM_FILE */
927		897
928	# ifdef ENABLE_TRANSPARENCY	898	# ifdef ENABLE_TRANSPARENCY
…		…
964	{	934	{
965	changed = true;	935	changed = true;
966	v_blurRadius = vr;	936	v_blurRadius = vr;
967	}	937	}
968		938
969	if (v_blurRadius == 0 && h_blurRadius == 0)	939	if (h_blurRadius == 0 \|\| v_blurRadius == 0)
970	bg_flags &= ~BG_NEEDS_BLUR;	940	bg_flags &= ~BG_NEEDS_BLUR;
971	else	941	else
972	bg_flags \|= BG_NEEDS_BLUR;	942	bg_flags \|= BG_NEEDS_BLUR;
973		943
974	return changed;	944	return changed;
975	}	945	}
976		946
977	void	947	void
978	rxvt_term::set_tint_shade_flags ()	948	rxvt_term::set_tint_shade_flags ()
979	{	949	{
980	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	950	rgba c;
981	bool has_shade = shade != 100;	951	bool has_shade = shade != 100;
982		952
983	bg_flags &= ~BG_TINT_FLAGS;	953	bg_flags &= ~BG_TINT_FLAGS;
984		954
985	if (bg_flags & BG_TINT_SET)	955	if (bg_flags & BG_TINT_SET)
…		…
1011	}	981	}
1012		982
1013	bool	983	bool
1014	rxvt_term::bg_set_shade (const char *shade_str)	984	rxvt_term::bg_set_shade (const char *shade_str)
1015	{	985	{
1016	int new_shade = (shade_str) ? atoi (shade_str) : 100;	986	int new_shade = atoi (shade_str);
1017		987
1018	clamp_it (new_shade, -100, 200);	988	clamp_it (new_shade, -100, 200);
1019	if (new_shade < 0)	989	if (new_shade < 0)
1020	new_shade = 200 - (100 + new_shade);	990	new_shade = 200 - (100 + new_shade);
1021		991
…		…
1051	params[i+2] = XDoubleToFixed (kernel[i] / sum);	1021	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1052	}	1022	}
1053	#endif	1023	#endif
1054		1024
1055	bool	1025	bool
1056	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)
1057	{	1027	{
1058	bool ret = false;	1028	bool ret = false;
1059	#if XRENDER	1029	#if XRENDER
		1030	if (!(bg_flags & BG_HAS_RENDER_CONV))
		1031	return false;
		1032
1060	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	1033	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1061	double kernel = (double )malloc (size * sizeof (double));	1034	double kernel = (double )malloc (size * sizeof (double));
1062	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	1035	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1063		1036
1064	XRenderPictureAttributes pa;	1037	XRenderPictureAttributes pa;
1065	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1038	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1066		1039
		1040	pa.repeat = RepeatPad;
1067	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);
1068	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1043	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		1044	XFreePixmap (dpy, tmp);
1069		1045
1070	if (kernel && params)	1046	if (kernel && params)
1071	{	1047	{
1072	if (h_blurRadius)
1073	{
1074	size = h_blurRadius * 2 + 1;	1048	size = h_blurRadius * 2 + 1;
1075	get_gaussian_kernel (h_blurRadius, size, kernel, params);	1049	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1076		1050
1077	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1051	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1078	XRenderComposite (dpy,	1052	XRenderComposite (dpy,
1079	PictOpSrc,	1053	PictOpSrc,
1080	src,	1054	src,
1081	None,	1055	None,
1082	dst,	1056	dst,
1083	0, 0,	1057	0, 0,
1084	0, 0,	1058	0, 0,
1085	0, 0,	1059	0, 0,
1086	width, height);	1060	width, height);
1087	}
1088		1061
1089	if (v_blurRadius)	1062	::swap (src, dst);
1090	{	1063
1091	size = v_blurRadius * 2 + 1;	1064	size = v_blurRadius * 2 + 1;
1092	get_gaussian_kernel (v_blurRadius, size, kernel, params);	1065	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1093	::swap (params[0], params[1]);	1066	::swap (params[0], params[1]);
1094		1067
1095	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1068	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1096	XRenderComposite (dpy,	1069	XRenderComposite (dpy,
1097	PictOpSrc,	1070	PictOpSrc,
1098	src,	1071	src,
1099	None,	1072	None,
1100	dst,	1073	dst,
1101	0, 0,	1074	0, 0,
1102	0, 0,	1075	0, 0,
1103	0, 0,	1076	0, 0,
1104	width, height);	1077	width, height);
1105	}
1106		1078
1107	ret = true;	1079	ret = true;
1108	}	1080	}
1109		1081
1110	free (kernel);	1082	free (kernel);
…		…
1137	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	1109	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1138	ret = true;	1110	ret = true;
1139	XFreeGC (dpy, gc);	1111	XFreeGC (dpy, gc);
1140	}	1112	}
1141	}	1113	}
1142	else
1143	{
1144	# if XRENDER	1114	# if XRENDER
		1115	else if (bg_flags & BG_HAS_RENDER)
		1116	{
1145	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);	1117	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1146		1118
1147	if (bg_flags & BG_TINT_SET)	1119	if (bg_flags & BG_TINT_SET)
1148	tint.get (c);	1120	tint.get (c);
1149		1121
…		…
1158	c.r = c.r * (200 - shade) / 100;	1130	c.r = c.r * (200 - shade) / 100;
1159	c.g = c.g * (200 - shade) / 100;	1131	c.g = c.g * (200 - shade) / 100;
1160	c.b = c.b * (200 - shade) / 100;	1132	c.b = c.b * (200 - shade) / 100;
1161	}	1133	}
1162		1134
1163	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1164	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1135	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1165	XRenderPictureAttributes pa;
1166		1136
1167	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1137	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1168		1138
1169	pa.repeat = True;	1139	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1170		1140
1171	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	1141	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1172	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1173	XFreePixmap (dpy, overlay_pmap);
1174
1175	pa.component_alpha = True;
1176	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1177	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat \| CPComponentAlpha, &pa);
1178	XFreePixmap (dpy, mask_pmap);
1179		1142
1180	XRenderColor mask_c;	1143	XRenderColor mask_c;
1181		1144
1182	mask_c.alpha = 0xffff;	1145	mask_c.alpha = 0xffff;
1183	mask_c.red =	1146	mask_c.red =
…		…
1188	mask_c.alpha = 0;	1151	mask_c.alpha = 0;
1189	mask_c.red = 0xffff - c.r;	1152	mask_c.red = 0xffff - c.r;
1190	mask_c.green = 0xffff - c.g;	1153	mask_c.green = 0xffff - c.g;
1191	mask_c.blue = 0xffff - c.b;	1154	mask_c.blue = 0xffff - c.b;
1192	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	1155	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		1156
1193	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);
1194		1158
1195	if (shade > 100)	1159	if (shade > 100)
1196	{	1160	{
1197	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1198	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;
1199	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	1165	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1200		1166
1201	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);
1202	}	1168	}
1203		1169
1204	ret = true;	1170	ret = true;
1205		1171
1206	XRenderFreePicture (dpy, mask_pic);	1172	XRenderFreePicture (dpy, mask_pic);
1207	XRenderFreePicture (dpy, overlay_pic);	1173	XRenderFreePicture (dpy, overlay_pic);
1208	XRenderFreePicture (dpy, back_pic);	1174	XRenderFreePicture (dpy, back_pic);
		1175	}
1209	# endif	1176	# endif
1210	}
1211		1177
1212	return ret;	1178	return ret;
1213	}	1179	}
1214		1180
1215	/*	1181	/*
…		…
1266	#if XRENDER	1232	#if XRENDER
1267	if (bg_flags & BG_HAS_RENDER)	1233	if (bg_flags & BG_HAS_RENDER)
1268	{	1234	{
1269	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);
1270		1236
1271	XRenderPictureAttributes pa;
1272
1273	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	1237	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1274	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	1238	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1275		1239
1276	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	1240	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1277	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	1241	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1278		1242
1279	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);
1280		1244
1281	XRenderFreePicture (dpy, src);	1245	XRenderFreePicture (dpy, src);
1282	XRenderFreePicture (dpy, dst);	1246	XRenderFreePicture (dpy, dst);
…		…
1299	bg_pmap_width = window_width;	1263	bg_pmap_width = window_width;
1300	bg_pmap_height = window_height;	1264	bg_pmap_height = window_height;
1301	}	1265	}
1302		1266
1303	/* straightforward pixmap copy */	1267	/* straightforward pixmap copy */
1304	while (sx < 0) sx += root_width;	1268	while (sx < 0) sx += root_pmap_width;
1305	while (sy < 0) sy += root_height;	1269	while (sy < 0) sy += root_pmap_height;
1306		1270
1307	gcv.tile = recoded_root_pmap;	1271	gcv.tile = recoded_root_pmap;
1308	gcv.fill_style = FillTiled;	1272	gcv.fill_style = FillTiled;
1309	gcv.ts_x_origin = -sx;	1273	gcv.ts_x_origin = -sx;
1310	gcv.ts_y_origin = -sy;	1274	gcv.ts_y_origin = -sy;
…		…
1312		1276
1313	if (gc)	1277	if (gc)
1314	{	1278	{
1315	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1279	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1316	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1280	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);
1317	XFreeGC (dpy, gc);
1318		1281
1319	if (!(bg_flags & BG_CLIENT_RENDER))	1282	if (!(bg_flags & BG_CLIENT_RENDER))
1320	{	1283	{
1321	if ((bg_flags & BG_NEEDS_BLUR)	1284	if (bg_flags & BG_NEEDS_BLUR)
1322	&& (bg_flags & BG_HAS_RENDER_CONV))
1323	{	1285	{
1324	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))	1286	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1325	result &= ~BG_NEEDS_BLUR;	1287	result &= ~BG_NEEDS_BLUR;
1326	}	1288	}
1327	if ((bg_flags & BG_NEEDS_TINT)	1289	if (bg_flags & BG_NEEDS_TINT)
1328	&& (bg_flags & (BG_TINT_BITAND \| BG_HAS_RENDER)))
1329	{	1290	{
1330	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))	1291	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1331	result &= ~BG_NEEDS_TINT;	1292	result &= ~BG_NEEDS_TINT;
1332	}	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
1333	} /* server side rendering completed */	1308	} /* server side rendering completed */
		1309
		1310	XFreeGC (dpy, gc);
1334	}	1311	}
1335		1312
1336	if (recoded_root_pmap != root_pixmap)	1313	if (recoded_root_pmap != root_pixmap)
1337	XFreePixmap (dpy, recoded_root_pmap);	1314	XFreePixmap (dpy, recoded_root_pmap);
1338		1315
…		…
1348		1325
1349	root_pixmap = new_root_pixmap;	1326	root_pixmap = new_root_pixmap;
1350	}	1327	}
1351	# endif /* ENABLE_TRANSPARENCY */	1328	# endif /* ENABLE_TRANSPARENCY */
1352		1329
1353	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1354	static void shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c);
1355	# endif
1356
1357	bool	1330	bool
1358	rxvt_term::bg_render ()	1331	rxvt_term::bg_render ()
1359	{	1332	{
1360	unsigned long tr_flags = 0;	1333	unsigned long tr_flags = 0;
1361		1334
…		…
1363	# ifdef ENABLE_TRANSPARENCY	1336	# ifdef ENABLE_TRANSPARENCY
1364	if (bg_flags & BG_IS_TRANSPARENT)	1337	if (bg_flags & BG_IS_TRANSPARENT)
1365	{	1338	{
1366	/* we need to re-generate transparency pixmap in that case ! */	1339	/* we need to re-generate transparency pixmap in that case ! */
1367	tr_flags = make_transparency_pixmap ();	1340	tr_flags = make_transparency_pixmap ();
1368	if (tr_flags == 0)	1341	if (tr_flags)
1369	return false;
1370	else if (!(tr_flags & BG_EFFECTS_FLAGS))
1371	bg_flags \|= BG_IS_VALID;	1342	bg_flags \|= BG_IS_VALID;
1372	}	1343	}
1373	# endif	1344	# endif
1374		1345
1375	# ifdef BG_IMAGE_FROM_FILE	1346	# ifdef BG_IMAGE_FROM_FILE
1376	if ((bg_flags & BG_IS_FROM_FILE)	1347	if ((bg_flags & BG_IS_FROM_FILE)
1377	\|\| (tr_flags & BG_EFFECTS_FLAGS))	1348	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1378	{	1349	{
1379	if (render_image (tr_flags))	1350	if (render_image (tr_flags))
1380	bg_flags \|= BG_IS_VALID;	1351	bg_flags \|= BG_IS_VALID;
1381	}
1382	# endif
1383
1384	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1385	XImage *result = NULL;
1386
1387	if (tr_flags && !(bg_flags & BG_IS_VALID))
1388	{
1389	result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1390	}
1391
1392	if (result)
1393	{
1394	/* our own client-side tinting */
1395	if (tr_flags & BG_NEEDS_TINT)
1396	{
1397	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1398	if (bg_flags & BG_TINT_SET)
1399	tint.get (c);
1400	shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1401	}
1402
1403	GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1404
1405	if (gc)
1406	{
1407	XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1408
1409	XFreeGC (dpy, gc);
1410	bg_flags \|= BG_IS_VALID;
1411	}
1412
1413	XDestroyImage (result);
1414	}	1352	}
1415	# endif	1353	# endif
1416		1354
1417	if (!(bg_flags & BG_IS_VALID))	1355	if (!(bg_flags & BG_IS_VALID))
1418	{	1356	{
…		…
1456	}	1394	}
1457		1395
1458	#endif /* HAVE_BG_PIXMAP */	1396	#endif /* HAVE_BG_PIXMAP */
1459		1397
1460	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1398	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1461	/* taken from aterm-0.4.2 */	1399	/* based on code from aterm-0.4.2 */
1462		1400
1463	static void	1401	static inline void
1464	shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c)	1402	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
		1403	{
		1404	for (int i = 0; i <= mask >> sh; i++)
		1405	{
		1406	uint32_t tmp;
		1407	tmp = i * high;
		1408	tmp += (mask >> sh) * low;
		1409	lookup[i] = (tmp / 0xffff) << sh;
		1410	}
		1411	}
		1412
		1413	void
		1414	rxvt_term::tint_ximage (Visual visual, XImage ximage)
1465	{	1415	{
1466	int sh_r, sh_g, sh_b;	1416	int sh_r, sh_g, sh_b;
1467	uint32_t mask_r, mask_g, mask_b;	1417	uint32_t mask_r, mask_g, mask_b;
1468	uint32_t lookup, lookup_r, lookup_g, lookup_b;	1418	uint32_t lookup, lookup_r, lookup_g, lookup_b;
1469	rgba low;	1419	unsigned short low;
1470	rgba high;
1471	int i;
1472	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	1420	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1473		1421
1474	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;	1422	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;
1475		1423
1476	/* for convenience */	1424	/* for convenience */
…		…
1535	break;	1483	break;
1536	default:	1484	default:
1537	return; /* we do not support this color depth */	1485	return; /* we do not support this color depth */
1538	}	1486	}
1539		1487
		1488	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
		1489
		1490	if (bg_flags & BG_TINT_SET)
		1491	tint.get (c);
		1492
1540	/* prepare limits for color transformation (each channel is handled separately) */	1493	/* prepare limits for color transformation (each channel is handled separately) */
1541	if (shade > 100)	1494	if (shade > 100)
1542	{	1495	{
1543	shade = 200 - shade;
1544
1545	high.r = c.r * shade / 100;
1546	high.g = c.g * shade / 100;
1547	high.b = c.b * shade / 100;
1548
1549	low.r = 65535 * (100 - shade) / 100;	1496	c.r = c.r * (200 - shade) / 100;
1550	low.g = 65535 * (100 - shade) / 100;	1497	c.g = c.g * (200 - shade) / 100;
1551	low.b = 65535 * (100 - shade) / 100;	1498	c.b = c.b * (200 - shade) / 100;
		1499
		1500	low = 0xffff * (shade - 100) / 100;
1552	}	1501	}
1553	else	1502	else
1554	{	1503	{
1555	high.r = c.r * shade / 100;	1504	c.r = c.r * shade / 100;
1556	high.g = c.g * shade / 100;	1505	c.g = c.g * shade / 100;
1557	high.b = c.b * shade / 100;	1506	c.b = c.b * shade / 100;
1558		1507
1559	low.r = low.g = low.b = 0;	1508	low = 0;
1560	}	1509	}
1561		1510
1562	/* fill our lookup tables */	1511	/* fill our lookup tables */
1563	for (i = 0; i <= mask_r>>sh_r; i++)	1512	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1564	{	1513	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1565	uint32_t tmp;	1514	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1566	tmp = i * high.r;
1567	tmp += (mask_r>>sh_r) * low.r;
1568	lookup_r[i] = (tmp/65535)<<sh_r;
1569	}
1570	for (i = 0; i <= mask_g>>sh_g; i++)
1571	{
1572	uint32_t tmp;
1573	tmp = i * high.g;
1574	tmp += (mask_g>>sh_g) * low.g;
1575	lookup_g[i] = (tmp/65535)<<sh_g;
1576	}
1577	for (i = 0; i <= mask_b>>sh_b; i++)
1578	{
1579	uint32_t tmp;
1580	tmp = i * high.b;
1581	tmp += (mask_b>>sh_b) * low.b;
1582	lookup_b[i] = (tmp/65535)<<sh_b;
1583	}
1584		1515
1585	/* apply table to input image (replacing colors by newly calculated ones) */	1516	/* apply table to input image (replacing colors by newly calculated ones) */
1586	if (ximage->bits_per_pixel == 32	1517	if (ximage->bits_per_pixel == 32
1587	&& (ximage->depth == 24 \|\| ximage->depth == 32)	1518	&& (ximage->depth == 24 \|\| ximage->depth == 32)
1588	&& ximage->byte_order == host_byte_order)	1519	&& 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.161 by sf-exg, Thu Aug 11 08:39:10 2011 UTC vs. Revision 1.199 by sf-exg, Tue Jan 17 19:51:30 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.161 by sf-exg, Thu Aug 11 08:39:10 2011 UTC vs.
Revision 1.199 by sf-exg, Tue Jan 17 19:51:30 2012 UTC