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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.169 by sf-exg, Fri Aug 19 18:04:01 2011 UTC vs.
Revision 1.201 by sf-exg, Sat Feb 4 21:47:06 2012 UTC

…		…
20	* You should have received a copy of the GNU General Public License	20	* You should have received a copy of the GNU General Public License
21	* along with this program; if not, write to the Free Software	21	* along with this program; if not, write to the Free Software
22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23	---------------------------------------------------------------------/	23	---------------------------------------------------------------------/
24		24
25	#include <cmath>	25	#include <math.h>
26	#include "../config.h" /* NECESSARY */	26	#include "../config.h" /* NECESSARY */
27	#include "rxvt.h" /* NECESSARY */	27	#include "rxvt.h" /* NECESSARY */
28		28
29	#if XRENDER	29	#if XRENDER
30	# include <X11/extensions/Xrender.h>	30	# include <X11/extensions/Xrender.h>
…		…
32		32
33	#ifndef FilterConvolution	33	#ifndef FilterConvolution
34	#define FilterConvolution "convolution"	34	#define FilterConvolution "convolution"
35	#endif	35	#endif
36		36
		37	#ifndef RepeatPad
		38	#define RepeatPad True
		39	#endif
		40
37	#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
38	void	60	void
39	rxvt_term::bg_destroy ()	61	rxvt_term::bg_destroy ()
40	{	62	{
41	#ifdef HAVE_AFTERIMAGE
42	if (original_asim)
43	safe_asimage_destroy (original_asim);
44	if (asv)
45	destroy_asvisual (asv, 0);
46	if (asimman)
47	destroy_image_manager (asimman, 0);
48	#endif
49
50	#ifdef HAVE_PIXBUF	63	#ifdef HAVE_PIXBUF
51	if (pixbuf)	64	if (pixbuf)
52	g_object_unref (pixbuf);	65	g_object_unref (pixbuf);
53	#endif	66	#endif
54		67
…		…
107		120
108	return false;	121	return false;
109	}	122	}
110		123
111	# ifdef BG_IMAGE_FROM_FILE	124	# ifdef BG_IMAGE_FROM_FILE
112	static inline bool
113	check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
114	{
115	if (geom_flags & flag)
116	{
117	if (new_value > 1000)
118	new_value = 1000;
119	if (new_value != scale)
120	{
121	scale = new_value;
122	return true;
123	}
124	}
125	return false;
126	}
127
128	static inline bool
129	check_set_align_value (int geom_flags, int flag, int &align, int new_value)
130	{
131	if (geom_flags & flag)
132	{
133	if (new_value < -100)
134	new_value = -100;
135	else if (new_value > 200)
136	new_value = 200;
137	if (new_value != align)
138	{
139	align = new_value;
140	return true;
141	}
142	}
143	return false;
144	}
145
146	static inline int	125	static inline int
147	make_align_position (int align, int window_size, int image_size)	126	make_align_position (int align, int window_size, int image_size)
148	{	127	{
149	int diff = window_size - image_size;	128	int diff = window_size - image_size;
150	int smaller = min (image_size, window_size);	129	int smaller = min (image_size, window_size);
151		130
152	if (align >= 0 && align <= 100)	131	if (align >= 0 && align <= 100)
153	return diff * align / 100;	132	return diff * align / 100;
154	else if (align > 100 && align <= 200)	133	else if (align > 100 && align <= 200)
155	return ((align - 100) * smaller / 100) + window_size - smaller;	134	return (align - 100) * smaller / 100 + window_size - smaller;
156	else if (align >= -100 && align < 0)	135	else if (align >= -100 && align < 0)
157	return ((align + 100) * smaller / 100) - image_size;	136	return (align + 100) * smaller / 100 - image_size;
158	return 0;	137	return 0;
159	}	138	}
160		139
161	static inline int	140	static inline int
162	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	141	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
…		…
169	src_pos = -pos;	148	src_pos = -pos;
170	dst_pos = 0;	149	dst_pos = 0;
171	dst_size += pos;	150	dst_size += pos;
172	}	151	}
173		152
174	if (dst_pos + dst_size > target_size)
175	dst_size = target_size - dst_pos;	153	min_it (dst_size, target_size - dst_pos);
176	return src_pos;	154	return src_pos;
177	}	155	}
178		156
179	bool	157	bool
180	rxvt_term::bg_set_geometry (const char *geom, bool update)	158	rxvt_term::bg_set_geometry (const char *geom, bool update)
181	{	159	{
182	bool changed = false;	160	bool changed = false;
183	int geom_flags = 0;	161	int geom_flags = 0;
184	int x = 0, y = 0;	162	int x = h_align;
		163	int y = v_align;
185	unsigned int w = 0, h = 0;	164	unsigned int w = h_scale;
186	unsigned long new_flags = (bg_flags & (~BG_GEOMETRY_FLAGS));	165	unsigned int h = v_scale;
		166	unsigned long new_flags = 0;
187		167
188	if (geom == NULL)	168	if (geom == NULL)
189	return false;	169	return false;
190		170
191	if (geom[0])	171	if (geom[0])
192	{	172	{
193	char **arr = rxvt_strsplit (':', geom);	173	char **arr = rxvt_strsplit (':', geom);
194		174
195	for (int i = 0; arr[i]; i++)	175	for (int i = 0; arr[i]; i++)
196	{	176	{
197	if (!strcasecmp (arr[i], "style=tiled"))	177	if (!strcasecmp (arr[i], "style=tiled"))
198	{	178	{
199	new_flags = BG_TILE;	179	new_flags = BG_TILE;
200	w = h = noScale;	180	w = h = noScale;
201	x = y = 0;	181	x = y = 0;
202	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;	182	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
203	}	183	}
204	else if (!strcasecmp (arr[i], "style=aspect-stretched"))	184	else if (!strcasecmp (arr[i], "style=aspect-stretched"))
205	{	185	{
206	new_flags = BG_PROP_SCALE;	186	new_flags = BG_KEEP_ASPECT;
207	w = h = windowScale;	187	w = h = windowScale;
208	x = y = centerAlign;	188	x = y = centerAlign;
209	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;	189	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
210	}	190	}
211	else if (!strcasecmp (arr[i], "style=stretched"))	191	else if (!strcasecmp (arr[i], "style=stretched"))
…		…
227	w = h = noScale;	207	w = h = noScale;
228	geom_flags = WidthValue\|HeightValue;	208	geom_flags = WidthValue\|HeightValue;
229	}	209	}
230	else if (!strcasecmp (arr[i], "op=tile"))	210	else if (!strcasecmp (arr[i], "op=tile"))
231	new_flags \|= BG_TILE;	211	new_flags \|= BG_TILE;
232	else if (!strcasecmp (arr[i], "op=pscale"))	212	else if (!strcasecmp (arr[i], "op=keep-aspect"))
233	new_flags \|= BG_PROP_SCALE;	213	new_flags \|= BG_KEEP_ASPECT;
234	else if (!strcasecmp (arr[i], "op=root"))	214	else if (!strcasecmp (arr[i], "op=root-align"))
235	new_flags \|= BG_ROOT_ALIGN;	215	new_flags \|= BG_ROOT_ALIGN;
236		216
237	// deprecated	217	// deprecated
238	else if (!strcasecmp (arr[i], "tile"))	218	else if (!strcasecmp (arr[i], "tile"))
239	{	219	{
…		…
241	w = h = noScale;	221	w = h = noScale;
242	geom_flags \|= WidthValue\|HeightValue;	222	geom_flags \|= WidthValue\|HeightValue;
243	}	223	}
244	else if (!strcasecmp (arr[i], "propscale"))	224	else if (!strcasecmp (arr[i], "propscale"))
245	{	225	{
246	new_flags \|= BG_PROP_SCALE;	226	new_flags \|= BG_KEEP_ASPECT;
		227	w = h = windowScale;
		228	geom_flags \|= WidthValue\|HeightValue;
247	}	229	}
248	else if (!strcasecmp (arr[i], "hscale"))	230	else if (!strcasecmp (arr[i], "hscale"))
249	{	231	{
250	new_flags \|= BG_TILE;	232	new_flags \|= BG_TILE;
251	w = windowScale;	233	w = windowScale;
…		…
281	geom_flags \|= XParseGeometry (arr[i], &x, &y, &w, &h);	263	geom_flags \|= XParseGeometry (arr[i], &x, &y, &w, &h);
282	} /* done parsing ops */	264	} /* done parsing ops */
283		265
284	rxvt_free_strsplit (arr);	266	rxvt_free_strsplit (arr);
285	}	267	}
		268
		269	new_flags \|= bg_flags & ~BG_GEOMETRY_FLAGS;
286		270
287	if (!update)	271	if (!update)
288	{	272	{
289	if (!(geom_flags & XValue))	273	if (!(geom_flags & XValue))
290	x = y = defaultAlign;	274	x = y = defaultAlign;
…		…
295	w = h = defaultScale;	279	w = h = defaultScale;
296	else if (!(geom_flags & HeightValue))	280	else if (!(geom_flags & HeightValue))
297	h = w;	281	h = w;
298	else if (!(geom_flags & WidthValue))	282	else if (!(geom_flags & WidthValue))
299	w = h;	283	w = h;
300
301	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
302	}	284	}
303		285
304	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;	286	min_it (w, 1000);
305	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;	287	min_it (h, 1000);
306	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;	288	clamp_it (x, -100, 200);
307	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;	289	clamp_it (y, -100, 200);
308		290
309	if (new_flags != bg_flags)	291	if (bg_flags != new_flags
		292	\|\| h_scale != w
		293	\|\| v_scale != h
		294	\|\| h_align != x
		295	\|\| v_align != y)
310	{	296	{
311	bg_flags = new_flags;	297	bg_flags = new_flags;
		298	h_scale = w;
		299	v_scale = h;
		300	h_align = x;
		301	v_align = y;
312	changed = true;	302	changed = true;
313	}	303	}
314		304
315	return changed;	305	return changed;
316	}	306	}
…		…
322	int target_height = szHint.height;	312	int target_height = szHint.height;
323		313
324	w = h_scale * target_width / 100;	314	w = h_scale * target_width / 100;
325	h = v_scale * target_height / 100;	315	h = v_scale * target_height / 100;
326		316
327	if (bg_flags & BG_PROP_SCALE)	317	if (bg_flags & BG_KEEP_ASPECT)
328	{	318	{
329	float scale = (float)w / image_width;	319	float scale = (float)w / image_width;
330	min_it (scale, (float)h / image_height);	320	min_it (scale, (float)h / image_height);
331	w = image_width * scale + 0.5;	321	w = image_width * scale + 0.5;
332	h = image_height * scale + 0.5;	322	h = image_height * scale + 0.5;
…		…
351	\|\| h_scale \|\| v_scale	341	\|\| h_scale \|\| v_scale
352	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	342	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
353	\|\| w > target_width \|\| h > target_height)	343	\|\| w > target_width \|\| h > target_height)
354	bg_flags \|= BG_IS_SIZE_SENSITIVE;	344	bg_flags \|= BG_IS_SIZE_SENSITIVE;
355	}	345	}
356
357	# ifdef HAVE_AFTERIMAGE
358	bool
359	rxvt_term::render_image (unsigned long tr_flags)
360	{
361	init_asv ();
362
363	ASImage *background = NULL;
364	ARGB32 background_tint = TINT_LEAVE_SAME;
365
366	# ifdef ENABLE_TRANSPARENCY
367	if (tr_flags)
368	background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
369
370	if (tr_flags & BG_NEEDS_TINT)
371	{
372	ShadingInfo as_shade;
373	as_shade.shading = shade;
374
375	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
376	if (bg_flags & BG_TINT_SET)
377	tint.get (c);
378	as_shade.tintColor.red = c.r;
379	as_shade.tintColor.green = c.g;
380	as_shade.tintColor.blue = c.b;
381
382	background_tint = shading2tint32 (&as_shade);
383	}
384
385	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
386	{
387	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
388	(original_asim == NULL \|\| tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,
389	100, ASIMAGE_QUALITY_DEFAULT);
390	if (tmp)
391	{
392	destroy_asimage (&background);
393	background = tmp;
394	}
395	}
396	# endif
397
398	ASImage *result = 0;
399
400	int target_width = szHint.width;
401	int target_height = szHint.height;
402	int new_pmap_width = target_width;
403	int new_pmap_height = target_height;
404
405	int x = 0;
406	int y = 0;
407	int w = 0;
408	int h = 0;
409
410	if (original_asim)
411	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
412
413	if (!original_asim
414	\|\| (!(bg_flags & BG_ROOT_ALIGN)
415	&& (x >= target_width
416	\|\| y >= target_height
417	\|\| (x + w <= 0)
418	\|\| (y + h <= 0))))
419	{
420	if (background)
421	{
422	new_pmap_width = background->width;
423	new_pmap_height = background->height;
424	result = background;
425
426	if (background_tint != TINT_LEAVE_SAME)
427	{
428	ASImage *tmp = tile_asimage (asv, background, 0, 0,
429	target_width, target_height, background_tint,
430	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
431	if (tmp)
432	result = tmp;
433	}
434	}
435	else
436	new_pmap_width = new_pmap_height = 0;
437	}
438	else
439	{
440	result = original_asim;
441
442	if ((w != original_asim->width)
443	\|\| (h != original_asim->height))
444	{
445	result = scale_asimage (asv, original_asim,
446	w, h,
447	background ? ASA_ASImage : ASA_XImage,
448	100, ASIMAGE_QUALITY_DEFAULT);
449	}
450
451	if (background == NULL)
452	{
453	if (bg_flags & BG_TILE)
454	{
455	/* if tiling - pixmap has to be sized exactly as the image,
456	but there is no need to make it bigger than the window! */
457	new_pmap_width = min (result->width, target_width);
458	new_pmap_height = min (result->height, target_height);
459
460	/* we also need to tile our image in both directions */
461	ASImage *tmp = tile_asimage (asv, result,
462	(int)result->width - x,
463	(int)result->height - y,
464	new_pmap_width,
465	new_pmap_height,
466	TINT_LEAVE_SAME, ASA_XImage,
467	100, ASIMAGE_QUALITY_DEFAULT);
468	if (tmp)
469	{
470	if (result != original_asim)
471	destroy_asimage (&result);
472
473	result = tmp;
474	}
475	}
476	}
477	else
478	{
479	/* if blending background and image - pixmap has to be sized same as target window */
480	ASImageLayer *layers = create_image_layers (2);
481
482	layers[0].im = background;
483	layers[0].clip_width = target_width;
484	layers[0].clip_height = target_height;
485	layers[0].tint = background_tint;
486	layers[1].im = result;
487
488	if (bg_flags & BG_TILE)
489	{
490	/* tile horizontally */
491	while (x > 0) x -= (int)result->width;
492	layers[1].dst_x = x;
493	layers[1].clip_width = result->width+target_width;
494	}
495	else
496	{
497	/* clip horizontally */
498	layers[1].dst_x = x;
499	layers[1].clip_width = result->width;
500	}
501
502	if (bg_flags & BG_TILE)
503	{
504	while (y > 0) y -= (int)result->height;
505	layers[1].dst_y = y;
506	layers[1].clip_height = result->height + target_height;
507	}
508	else
509	{
510	layers[1].dst_y = y;
511	layers[1].clip_height = result->height;
512	}
513
514	if (rs[Rs_blendtype])
515	{
516	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
517	if (layers[1].merge_scanlines == NULL)
518	layers[1].merge_scanlines = alphablend_scanlines;
519	}
520
521	ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
522	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
523
524	if (tmp)
525	{
526	if (result != original_asim)
527	destroy_asimage (&result);
528
529	result = tmp;
530	}
531
532	free (layers);
533	}
534	}
535
536	bool ret = false;
537
538	if (result)
539	{
540	XGCValues gcv;
541	GC gc;
542
543	/* create Pixmap */
544	if (bg_pixmap == None
545	\|\| bg_pmap_width != new_pmap_width
546	\|\| bg_pmap_height != new_pmap_height)
547	{
548	if (bg_pixmap)
549	XFreePixmap (dpy, bg_pixmap);
550	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
551	bg_pmap_width = new_pmap_width;
552	bg_pmap_height = new_pmap_height;
553	}
554	/* fill with background color (if result's not completely overlapping it) */
555	gcv.foreground = pix_colors[Color_bg];
556	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
557
558	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
559	int dst_width = result->width, dst_height = result->height;
560	if (background == NULL)
561	{
562	if (!(bg_flags & BG_TILE))
563	{
564	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
565	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
566	}
567
568	if (dst_x > 0 \|\| dst_y > 0
569	\|\| dst_x + dst_width < new_pmap_width
570	\|\| dst_y + dst_height < new_pmap_height)
571	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
572	}
573
574	/* put result on pixmap */
575	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
576	asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
577
578	if (result != background && result != original_asim)
579	destroy_asimage (&result);
580
581	XFreeGC (dpy, gc);
582
583	ret = true;
584	}
585
586	if (background)
587	destroy_asimage (&background);
588
589	return ret;
590	}
591	# endif /* HAVE_AFTERIMAGE */
592		346
593	# ifdef HAVE_PIXBUF	347	# ifdef HAVE_PIXBUF
594	bool	348	bool
595	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,	349	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
596	int src_x, int src_y, int dst_x, int dst_y,	350	int src_x, int src_y, int dst_x, int dst_y,
…		…
702	get_image_geometry (image_width, image_height, w, h, x, y);	456	get_image_geometry (image_width, image_height, w, h, x, y);
703		457
704	if (!(bg_flags & BG_ROOT_ALIGN)	458	if (!(bg_flags & BG_ROOT_ALIGN)
705	&& (x >= target_width	459	&& (x >= target_width
706	\|\| y >= target_height	460	\|\| y >= target_height
707	\|\| (x + w <= 0)	461	\|\| x + w <= 0
708	\|\| (y + h <= 0)))	462	\|\| y + h <= 0))
709	return false;	463	return false;
710		464
711	result = pixbuf;	465	result = pixbuf;
712		466
713	if ((w != image_width)	467	if (w != image_width
714	\|\| (h != image_height))	468	\|\| h != image_height)
715	{	469	{
716	result = gdk_pixbuf_scale_simple (pixbuf,	470	result = gdk_pixbuf_scale_simple (pixbuf,
717	w, h,	471	w, h,
718	GDK_INTERP_BILINEAR);	472	GDK_INTERP_BILINEAR);
719	}	473	}
…		…
798	}	552	}
799		553
800	#if XRENDER	554	#if XRENDER
801	if (tr_flags)	555	if (tr_flags)
802	{	556	{
803	XRenderPictureAttributes pa;
804
805	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	557	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		558
806	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	559	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
807		560
808	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
809	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	561	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
810		562
811	pa.repeat = True;	563	Picture mask = create_xrender_mask (dpy, vt, False, False);
812	Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
813	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
814	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
815	XFreePixmap (dpy, mask_pmap);
816		564
817	XRenderColor mask_c;	565	XRenderColor mask_c;
818		566
819	mask_c.alpha = 0x8000;	567	mask_c.alpha = 0x8000;
820	mask_c.red = 0;	568	mask_c.red =
821	mask_c.green = 0;	569	mask_c.green =
822	mask_c.blue = 0;	570	mask_c.blue = 0;
823	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	571	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		572
824	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	573	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
825		574
826	XRenderFreePicture (dpy, src);	575	XRenderFreePicture (dpy, src);
827	XRenderFreePicture (dpy, dst);	576	XRenderFreePicture (dpy, dst);
828	XRenderFreePicture (dpy, mask);	577	XRenderFreePicture (dpy, mask);
…		…
860	memcpy (f, file, len);	609	memcpy (f, file, len);
861	f[len] = '\0';	610	f[len] = '\0';
862	file = f;	611	file = f;
863	}	612	}
864		613
865	# ifdef HAVE_AFTERIMAGE
866	if (!asimman)
867	asimman = create_generic_imageman (rs[Rs_path]);
868	ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
869	if (image)
870	{
871	if (original_asim)
872	safe_asimage_destroy (original_asim);
873	original_asim = image;
874	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;
875	ret = true;
876	}
877	# endif
878
879	# ifdef HAVE_PIXBUF	614	# ifdef HAVE_PIXBUF
880	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	615	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
881	if (image)	616	if (image)
882	{	617	{
883	if (pixbuf)	618	if (pixbuf)
…		…
940	{	675	{
941	changed = true;	676	changed = true;
942	v_blurRadius = vr;	677	v_blurRadius = vr;
943	}	678	}
944		679
945	if (v_blurRadius == 0 && h_blurRadius == 0)	680	if (h_blurRadius == 0 \|\| v_blurRadius == 0)
946	bg_flags &= ~BG_NEEDS_BLUR;	681	bg_flags &= ~BG_NEEDS_BLUR;
947	else	682	else
948	bg_flags \|= BG_NEEDS_BLUR;	683	bg_flags \|= BG_NEEDS_BLUR;
949		684
950	return changed;	685	return changed;
951	}	686	}
952		687
953	void	688	void
954	rxvt_term::set_tint_shade_flags ()	689	rxvt_term::set_tint_shade_flags ()
955	{	690	{
956	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	691	rgba c;
957	bool has_shade = shade != 100;	692	bool has_shade = shade != 100;
958		693
959	bg_flags &= ~BG_TINT_FLAGS;	694	bg_flags &= ~BG_TINT_FLAGS;
960		695
961	if (bg_flags & BG_TINT_SET)	696	if (bg_flags & BG_TINT_SET)
…		…
987	}	722	}
988		723
989	bool	724	bool
990	rxvt_term::bg_set_shade (const char *shade_str)	725	rxvt_term::bg_set_shade (const char *shade_str)
991	{	726	{
992	int new_shade = (shade_str) ? atoi (shade_str) : 100;	727	int new_shade = atoi (shade_str);
993		728
994	clamp_it (new_shade, -100, 200);	729	clamp_it (new_shade, -100, 200);
995	if (new_shade < 0)	730	if (new_shade < 0)
996	new_shade = 200 - (100 + new_shade);	731	new_shade = 200 - (100 + new_shade);
997		732
…		…
1027	params[i+2] = XDoubleToFixed (kernel[i] / sum);	762	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1028	}	763	}
1029	#endif	764	#endif
1030		765
1031	bool	766	bool
1032	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	767	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1033	{	768	{
1034	bool ret = false;	769	bool ret = false;
1035	#if XRENDER	770	#if XRENDER
		771	if (!(bg_flags & BG_HAS_RENDER_CONV))
		772	return false;
		773
1036	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	774	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1037	double kernel = (double )malloc (size * sizeof (double));	775	double kernel = (double )malloc (size * sizeof (double));
1038	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	776	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1039		777
1040	XRenderPictureAttributes pa;	778	XRenderPictureAttributes pa;
1041	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	779	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1042		780
		781	pa.repeat = RepeatPad;
1043	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	782	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		783	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1044	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	784	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		785	XFreePixmap (dpy, tmp);
1045		786
1046	if (kernel && params)	787	if (kernel && params)
1047	{	788	{
1048	if (h_blurRadius)
1049	{
1050	size = h_blurRadius * 2 + 1;	789	size = h_blurRadius * 2 + 1;
1051	get_gaussian_kernel (h_blurRadius, size, kernel, params);	790	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1052		791
1053	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	792	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1054	XRenderComposite (dpy,	793	XRenderComposite (dpy,
1055	PictOpSrc,	794	PictOpSrc,
1056	src,	795	src,
1057	None,	796	None,
1058	dst,	797	dst,
1059	0, 0,	798	0, 0,
1060	0, 0,	799	0, 0,
1061	0, 0,	800	0, 0,
1062	width, height);	801	width, height);
1063	}
1064		802
1065	if (v_blurRadius)	803	::swap (src, dst);
1066	{	804
1067	size = v_blurRadius * 2 + 1;	805	size = v_blurRadius * 2 + 1;
1068	get_gaussian_kernel (v_blurRadius, size, kernel, params);	806	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1069	::swap (params[0], params[1]);	807	::swap (params[0], params[1]);
1070		808
1071	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	809	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1072	XRenderComposite (dpy,	810	XRenderComposite (dpy,
1073	PictOpSrc,	811	PictOpSrc,
1074	src,	812	src,
1075	None,	813	None,
1076	dst,	814	dst,
1077	0, 0,	815	0, 0,
1078	0, 0,	816	0, 0,
1079	0, 0,	817	0, 0,
1080	width, height);	818	width, height);
1081	}
1082		819
1083	ret = true;	820	ret = true;
1084	}	821	}
1085		822
1086	free (kernel);	823	free (kernel);
…		…
1113	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	850	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1114	ret = true;	851	ret = true;
1115	XFreeGC (dpy, gc);	852	XFreeGC (dpy, gc);
1116	}	853	}
1117	}	854	}
1118	else
1119	{
1120	# if XRENDER	855	# if XRENDER
		856	else if (bg_flags & BG_HAS_RENDER)
		857	{
1121	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);	858	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1122		859
1123	if (bg_flags & BG_TINT_SET)	860	if (bg_flags & BG_TINT_SET)
1124	tint.get (c);	861	tint.get (c);
1125		862
…		…
1134	c.r = c.r * (200 - shade) / 100;	871	c.r = c.r * (200 - shade) / 100;
1135	c.g = c.g * (200 - shade) / 100;	872	c.g = c.g * (200 - shade) / 100;
1136	c.b = c.b * (200 - shade) / 100;	873	c.b = c.b * (200 - shade) / 100;
1137	}	874	}
1138		875
1139	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1140	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	876	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1141	XRenderPictureAttributes pa;
1142		877
1143	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	878	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1144		879
1145	pa.repeat = True;	880	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1146		881
1147	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	882	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1148	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1149	XFreePixmap (dpy, overlay_pmap);
1150
1151	pa.component_alpha = True;
1152	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1153	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat \| CPComponentAlpha, &pa);
1154	XFreePixmap (dpy, mask_pmap);
1155		883
1156	XRenderColor mask_c;	884	XRenderColor mask_c;
1157		885
1158	mask_c.alpha = 0xffff;	886	mask_c.alpha = 0xffff;
1159	mask_c.red =	887	mask_c.red =
…		…
1164	mask_c.alpha = 0;	892	mask_c.alpha = 0;
1165	mask_c.red = 0xffff - c.r;	893	mask_c.red = 0xffff - c.r;
1166	mask_c.green = 0xffff - c.g;	894	mask_c.green = 0xffff - c.g;
1167	mask_c.blue = 0xffff - c.b;	895	mask_c.blue = 0xffff - c.b;
1168	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	896	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		897
1169	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);	898	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1170		899
1171	if (shade > 100)	900	if (shade > 100)
1172	{	901	{
1173	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1174	mask_c.alpha = 0;	902	mask_c.alpha = 0;
		903	mask_c.red =
		904	mask_c.green =
		905	mask_c.blue = 0xffff * (shade - 100) / 100;
1175	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	906	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1176		907
1177	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);	908	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1178	}	909	}
1179		910
1180	ret = true;	911	ret = true;
1181		912
1182	XRenderFreePicture (dpy, mask_pic);	913	XRenderFreePicture (dpy, mask_pic);
1183	XRenderFreePicture (dpy, overlay_pic);	914	XRenderFreePicture (dpy, overlay_pic);
1184	XRenderFreePicture (dpy, back_pic);	915	XRenderFreePicture (dpy, back_pic);
		916	}
1185	# endif	917	# endif
1186	}
1187		918
1188	return ret;	919	return ret;
1189	}	920	}
1190		921
1191	/*	922	/*
…		…
1242	#if XRENDER	973	#if XRENDER
1243	if (bg_flags & BG_HAS_RENDER)	974	if (bg_flags & BG_HAS_RENDER)
1244	{	975	{
1245	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);	976	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1246		977
1247	XRenderPictureAttributes pa;
1248
1249	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	978	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1250	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	979	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1251		980
1252	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	981	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1253	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	982	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1254		983
1255	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	984	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1256		985
1257	XRenderFreePicture (dpy, src);	986	XRenderFreePicture (dpy, src);
1258	XRenderFreePicture (dpy, dst);	987	XRenderFreePicture (dpy, dst);
…		…
1275	bg_pmap_width = window_width;	1004	bg_pmap_width = window_width;
1276	bg_pmap_height = window_height;	1005	bg_pmap_height = window_height;
1277	}	1006	}
1278		1007
1279	/* straightforward pixmap copy */	1008	/* straightforward pixmap copy */
1280	while (sx < 0) sx += root_width;	1009	while (sx < 0) sx += root_pmap_width;
1281	while (sy < 0) sy += root_height;	1010	while (sy < 0) sy += root_pmap_height;
1282		1011
1283	gcv.tile = recoded_root_pmap;	1012	gcv.tile = recoded_root_pmap;
1284	gcv.fill_style = FillTiled;	1013	gcv.fill_style = FillTiled;
1285	gcv.ts_x_origin = -sx;	1014	gcv.ts_x_origin = -sx;
1286	gcv.ts_y_origin = -sy;	1015	gcv.ts_y_origin = -sy;
…		…
1288		1017
1289	if (gc)	1018	if (gc)
1290	{	1019	{
1291	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1020	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1292	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1021	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);
1293	XFreeGC (dpy, gc);
1294		1022
1295	if (!(bg_flags & BG_CLIENT_RENDER))	1023	if (!(bg_flags & BG_CLIENT_RENDER))
1296	{	1024	{
1297	if ((bg_flags & BG_NEEDS_BLUR)	1025	if (bg_flags & BG_NEEDS_BLUR)
1298	&& (bg_flags & BG_HAS_RENDER_CONV))
1299	{	1026	{
1300	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))	1027	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1301	result &= ~BG_NEEDS_BLUR;	1028	result &= ~BG_NEEDS_BLUR;
1302	}	1029	}
1303	if ((bg_flags & BG_NEEDS_TINT)	1030	if (bg_flags & BG_NEEDS_TINT)
1304	&& (bg_flags & (BG_TINT_BITAND \| BG_HAS_RENDER)))
1305	{	1031	{
1306	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))	1032	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1307	result &= ~BG_NEEDS_TINT;	1033	result &= ~BG_NEEDS_TINT;
1308	}	1034	}
		1035	if (result & BG_NEEDS_TINT)
		1036	{
		1037	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1038	if (ximage)
		1039	{
		1040	/* our own client-side tinting */
		1041	tint_ximage (DefaultVisual (dpy, display->screen), ximage);
		1042
		1043	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1044	XDestroyImage (ximage);
		1045	}
		1046	}
1309	} /* server side rendering completed */	1047	} /* server side rendering completed */
		1048
		1049	XFreeGC (dpy, gc);
1310	}	1050	}
1311		1051
1312	if (recoded_root_pmap != root_pixmap)	1052	if (recoded_root_pmap != root_pixmap)
1313	XFreePixmap (dpy, recoded_root_pmap);	1053	XFreePixmap (dpy, recoded_root_pmap);
1314		1054
…		…
1324		1064
1325	root_pixmap = new_root_pixmap;	1065	root_pixmap = new_root_pixmap;
1326	}	1066	}
1327	# endif /* ENABLE_TRANSPARENCY */	1067	# endif /* ENABLE_TRANSPARENCY */
1328		1068
1329	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1330	static void shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c);
1331	# endif
1332
1333	bool	1069	bool
1334	rxvt_term::bg_render ()	1070	rxvt_term::bg_render ()
1335	{	1071	{
1336	unsigned long tr_flags = 0;	1072	unsigned long tr_flags = 0;
1337		1073
…		…
1339	# ifdef ENABLE_TRANSPARENCY	1075	# ifdef ENABLE_TRANSPARENCY
1340	if (bg_flags & BG_IS_TRANSPARENT)	1076	if (bg_flags & BG_IS_TRANSPARENT)
1341	{	1077	{
1342	/* we need to re-generate transparency pixmap in that case ! */	1078	/* we need to re-generate transparency pixmap in that case ! */
1343	tr_flags = make_transparency_pixmap ();	1079	tr_flags = make_transparency_pixmap ();
1344	if (tr_flags == 0)	1080	if (tr_flags)
1345	return false;
1346	else if (!(tr_flags & BG_EFFECTS_FLAGS))
1347	bg_flags \|= BG_IS_VALID;	1081	bg_flags \|= BG_IS_VALID;
1348	}	1082	}
1349	# endif	1083	# endif
1350		1084
1351	# ifdef BG_IMAGE_FROM_FILE	1085	# ifdef BG_IMAGE_FROM_FILE
1352	if ((bg_flags & BG_IS_FROM_FILE)	1086	if ((bg_flags & BG_IS_FROM_FILE)
1353	\|\| (tr_flags & BG_EFFECTS_FLAGS))	1087	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1354	{	1088	{
1355	if (render_image (tr_flags))	1089	if (render_image (tr_flags))
1356	bg_flags \|= BG_IS_VALID;	1090	bg_flags \|= BG_IS_VALID;
1357	}
1358	# endif
1359
1360	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1361	XImage *result = NULL;
1362
1363	if (tr_flags && !(bg_flags & BG_IS_VALID))
1364	{
1365	result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1366	}
1367
1368	if (result)
1369	{
1370	/* our own client-side tinting */
1371	if (tr_flags & BG_NEEDS_TINT)
1372	{
1373	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1374	if (bg_flags & BG_TINT_SET)
1375	tint.get (c);
1376	shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1377	}
1378
1379	GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1380
1381	if (gc)
1382	{
1383	XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1384
1385	XFreeGC (dpy, gc);
1386	bg_flags \|= BG_IS_VALID;
1387	}
1388
1389	XDestroyImage (result);
1390	}	1091	}
1391	# endif	1092	# endif
1392		1093
1393	if (!(bg_flags & BG_IS_VALID))	1094	if (!(bg_flags & BG_IS_VALID))
1394	{	1095	{
…		…
1431	#endif	1132	#endif
1432	}	1133	}
1433		1134
1434	#endif /* HAVE_BG_PIXMAP */	1135	#endif /* HAVE_BG_PIXMAP */
1435		1136
1436	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1137	#ifdef ENABLE_TRANSPARENCY
1437	/* based on code from aterm-0.4.2 */	1138	/* based on code from aterm-0.4.2 */
1438		1139
1439	static void	1140	static inline void
1440	shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c)	1141	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
		1142	{
		1143	for (int i = 0; i <= mask >> sh; i++)
		1144	{
		1145	uint32_t tmp;
		1146	tmp = i * high;
		1147	tmp += (mask >> sh) * low;
		1148	lookup[i] = (tmp / 0xffff) << sh;
		1149	}
		1150	}
		1151
		1152	void
		1153	rxvt_term::tint_ximage (Visual visual, XImage ximage)
1441	{	1154	{
1442	int sh_r, sh_g, sh_b;	1155	int sh_r, sh_g, sh_b;
1443	uint32_t mask_r, mask_g, mask_b;	1156	uint32_t mask_r, mask_g, mask_b;
1444	uint32_t lookup, lookup_r, lookup_g, lookup_b;	1157	uint32_t lookup, lookup_r, lookup_g, lookup_b;
1445	rgba low;	1158	unsigned short low;
1446	rgba high;
1447	int i;
1448	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	1159	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1449		1160
1450	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;	1161	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;
1451		1162
1452	/* for convenience */	1163	/* for convenience */
…		…
1511	break;	1222	break;
1512	default:	1223	default:
1513	return; /* we do not support this color depth */	1224	return; /* we do not support this color depth */
1514	}	1225	}
1515		1226
		1227	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
		1228
		1229	if (bg_flags & BG_TINT_SET)
		1230	tint.get (c);
		1231
1516	/* prepare limits for color transformation (each channel is handled separately) */	1232	/* prepare limits for color transformation (each channel is handled separately) */
1517	if (shade > 100)	1233	if (shade > 100)
1518	{	1234	{
1519	shade = 200 - shade;
1520
1521	high.r = c.r * shade / 100;
1522	high.g = c.g * shade / 100;
1523	high.b = c.b * shade / 100;
1524
1525	low.r = 65535 * (100 - shade) / 100;	1235	c.r = c.r * (200 - shade) / 100;
1526	low.g = 65535 * (100 - shade) / 100;	1236	c.g = c.g * (200 - shade) / 100;
1527	low.b = 65535 * (100 - shade) / 100;	1237	c.b = c.b * (200 - shade) / 100;
		1238
		1239	low = 0xffff * (shade - 100) / 100;
1528	}	1240	}
1529	else	1241	else
1530	{	1242	{
1531	high.r = c.r * shade / 100;	1243	c.r = c.r * shade / 100;
1532	high.g = c.g * shade / 100;	1244	c.g = c.g * shade / 100;
1533	high.b = c.b * shade / 100;	1245	c.b = c.b * shade / 100;
1534		1246
1535	low.r = low.g = low.b = 0;	1247	low = 0;
1536	}	1248	}
1537		1249
1538	/* fill our lookup tables */	1250	/* fill our lookup tables */
1539	for (i = 0; i <= mask_r>>sh_r; i++)	1251	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1540	{	1252	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1541	uint32_t tmp;	1253	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1542	tmp = i * high.r;
1543	tmp += (mask_r>>sh_r) * low.r;
1544	lookup_r[i] = (tmp/65535)<<sh_r;
1545	}
1546	for (i = 0; i <= mask_g>>sh_g; i++)
1547	{
1548	uint32_t tmp;
1549	tmp = i * high.g;
1550	tmp += (mask_g>>sh_g) * low.g;
1551	lookup_g[i] = (tmp/65535)<<sh_g;
1552	}
1553	for (i = 0; i <= mask_b>>sh_b; i++)
1554	{
1555	uint32_t tmp;
1556	tmp = i * high.b;
1557	tmp += (mask_b>>sh_b) * low.b;
1558	lookup_b[i] = (tmp/65535)<<sh_b;
1559	}
1560		1254
1561	/* apply table to input image (replacing colors by newly calculated ones) */	1255	/* apply table to input image (replacing colors by newly calculated ones) */
1562	if (ximage->bits_per_pixel == 32	1256	if (ximage->bits_per_pixel == 32
1563	&& (ximage->depth == 24 \|\| ximage->depth == 32)	1257	&& (ximage->depth == 24 \|\| ximage->depth == 32)
1564	&& ximage->byte_order == host_byte_order)	1258	&& ximage->byte_order == host_byte_order)
…		…
1594	}	1288	}
1595	}	1289	}
1596		1290
1597	free (lookup);	1291	free (lookup);
1598	}	1292	}
1599	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1293	#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.169 by sf-exg, Fri Aug 19 18:04:01 2011 UTC vs. Revision 1.201 by sf-exg, Sat Feb 4 21:47:06 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.169 by sf-exg, Fri Aug 19 18:04:01 2011 UTC vs.
Revision 1.201 by sf-exg, Sat Feb 4 21:47:06 2012 UTC