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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.175 by sf-exg, Mon Dec 5 18:17:17 2011 UTC vs.
Revision 1.206 by sf-exg, Thu Apr 12 10:22:50 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;
150	int smaller = min (image_size, window_size);
151
152	if (align >= 0 && align <= 100)	128	if (align >= 0 && align <= 100)
153	return diff * align / 100;	129	return lerp (0, window_size - image_size, align);
154	else if (align > 100 && align <= 200)	130	else if (align > 100)
155	return (align - 100) * smaller / 100 + window_size - smaller;	131	return lerp (window_size - image_size, window_size, align - 100);
156	else if (align >= -100 && align < 0)	132	else
157	return (align + 100) * smaller / 100 - image_size;	133	return lerp (-image_size, 0, align + 100);
158	return 0;
159	}	134	}
160		135
161	static inline int	136	static inline int
162	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	137	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
163	{	138	{
…		…
169	src_pos = -pos;	144	src_pos = -pos;
170	dst_pos = 0;	145	dst_pos = 0;
171	dst_size += pos;	146	dst_size += pos;
172	}	147	}
173		148
174	if (dst_pos + dst_size > target_size)
175	dst_size = target_size - dst_pos;	149	min_it (dst_size, target_size - dst_pos);
176	return src_pos;	150	return src_pos;
177	}	151	}
178		152
179	bool	153	bool
180	rxvt_term::bg_set_geometry (const char *geom, bool update)	154	rxvt_term::bg_set_geometry (const char *geom, bool update)
181	{	155	{
182	bool changed = false;	156	bool changed = false;
183	int geom_flags = 0;	157	int geom_flags = 0;
184	int x = 0, y = 0;	158	int x = h_align;
		159	int y = v_align;
185	unsigned int w = 0, h = 0;	160	unsigned int w = h_scale;
186	unsigned long new_flags = bg_flags & ~BG_GEOMETRY_FLAGS;	161	unsigned int h = v_scale;
		162	unsigned long new_flags = 0;
187		163
188	if (geom == NULL)	164	if (geom == NULL)
189	return false;	165	return false;
190		166
191	if (geom[0])	167	if (geom[0])
…		…
201	x = y = 0;	177	x = y = 0;
202	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;	178	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
203	}	179	}
204	else if (!strcasecmp (arr[i], "style=aspect-stretched"))	180	else if (!strcasecmp (arr[i], "style=aspect-stretched"))
205	{	181	{
206	new_flags = BG_PROP_SCALE;	182	new_flags = BG_KEEP_ASPECT;
207	w = h = windowScale;	183	w = h = windowScale;
208	x = y = centerAlign;	184	x = y = centerAlign;
209	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;	185	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
210	}	186	}
211	else if (!strcasecmp (arr[i], "style=stretched"))	187	else if (!strcasecmp (arr[i], "style=stretched"))
…		…
227	w = h = noScale;	203	w = h = noScale;
228	geom_flags = WidthValue\|HeightValue;	204	geom_flags = WidthValue\|HeightValue;
229	}	205	}
230	else if (!strcasecmp (arr[i], "op=tile"))	206	else if (!strcasecmp (arr[i], "op=tile"))
231	new_flags \|= BG_TILE;	207	new_flags \|= BG_TILE;
232	else if (!strcasecmp (arr[i], "op=pscale"))	208	else if (!strcasecmp (arr[i], "op=keep-aspect"))
233	new_flags \|= BG_PROP_SCALE;	209	new_flags \|= BG_KEEP_ASPECT;
234	else if (!strcasecmp (arr[i], "op=root"))	210	else if (!strcasecmp (arr[i], "op=root-align"))
235	new_flags \|= BG_ROOT_ALIGN;	211	new_flags \|= BG_ROOT_ALIGN;
236		212
237	// deprecated	213	// deprecated
238	else if (!strcasecmp (arr[i], "tile"))	214	else if (!strcasecmp (arr[i], "tile"))
239	{	215	{
…		…
241	w = h = noScale;	217	w = h = noScale;
242	geom_flags \|= WidthValue\|HeightValue;	218	geom_flags \|= WidthValue\|HeightValue;
243	}	219	}
244	else if (!strcasecmp (arr[i], "propscale"))	220	else if (!strcasecmp (arr[i], "propscale"))
245	{	221	{
246	new_flags \|= BG_PROP_SCALE;	222	new_flags \|= BG_KEEP_ASPECT;
		223	w = h = windowScale;
		224	geom_flags \|= WidthValue\|HeightValue;
247	}	225	}
248	else if (!strcasecmp (arr[i], "hscale"))	226	else if (!strcasecmp (arr[i], "hscale"))
249	{	227	{
250	new_flags \|= BG_TILE;	228	new_flags \|= BG_TILE;
251	w = windowScale;	229	w = windowScale;
…		…
281	geom_flags \|= XParseGeometry (arr[i], &x, &y, &w, &h);	259	geom_flags \|= XParseGeometry (arr[i], &x, &y, &w, &h);
282	} /* done parsing ops */	260	} /* done parsing ops */
283		261
284	rxvt_free_strsplit (arr);	262	rxvt_free_strsplit (arr);
285	}	263	}
		264
		265	new_flags \|= bg_flags & ~BG_GEOMETRY_FLAGS;
286		266
287	if (!update)	267	if (!update)
288	{	268	{
289	if (!(geom_flags & XValue))	269	if (!(geom_flags & XValue))
290	x = y = defaultAlign;	270	x = y = defaultAlign;
…		…
295	w = h = defaultScale;	275	w = h = defaultScale;
296	else if (!(geom_flags & HeightValue))	276	else if (!(geom_flags & HeightValue))
297	h = w;	277	h = w;
298	else if (!(geom_flags & WidthValue))	278	else if (!(geom_flags & WidthValue))
299	w = h;	279	w = h;
300
301	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
302	}	280	}
303		281
304	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;	282	min_it (w, 1000);
305	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;	283	min_it (h, 1000);
306	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;	284	clamp_it (x, -100, 200);
307	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;	285	clamp_it (y, -100, 200);
308		286
309	if (new_flags != bg_flags)	287	if (bg_flags != new_flags
		288	\|\| h_scale != w
		289	\|\| v_scale != h
		290	\|\| h_align != x
		291	\|\| v_align != y)
310	{	292	{
311	bg_flags = new_flags;	293	bg_flags = new_flags;
		294	h_scale = w;
		295	v_scale = h;
		296	h_align = x;
		297	v_align = y;
312	changed = true;	298	changed = true;
313	}	299	}
314		300
315	return changed;	301	return changed;
316	}	302	}
…		…
322	int target_height = szHint.height;	308	int target_height = szHint.height;
323		309
324	w = h_scale * target_width / 100;	310	w = h_scale * target_width / 100;
325	h = v_scale * target_height / 100;	311	h = v_scale * target_height / 100;
326		312
327	if (bg_flags & BG_PROP_SCALE)	313	if (bg_flags & BG_KEEP_ASPECT)
328	{	314	{
329	float scale = (float)w / image_width;	315	float scale = (float)w / image_width;
330	min_it (scale, (float)h / image_height);	316	min_it (scale, (float)h / image_height);
331	w = image_width * scale + 0.5;	317	w = image_width * scale + 0.5;
332	h = image_height * scale + 0.5;	318	h = image_height * scale + 0.5;
…		…
344	{	330	{
345	x = make_align_position (h_align, target_width, w);	331	x = make_align_position (h_align, target_width, w);
346	y = make_align_position (v_align, target_height, h);	332	y = make_align_position (v_align, target_height, h);
347	}	333	}
348		334
349	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
350	if (!(bg_flags & BG_TILE)	335	if (!(bg_flags & BG_TILE)
351	\|\| h_scale \|\| v_scale	336	\|\| h_scale \|\| v_scale
352	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	337	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
353	\|\| w > target_width \|\| h > target_height)	338	\|\| image_width > target_width \|\| image_height > target_height)
354	bg_flags \|= BG_IS_SIZE_SENSITIVE;	339	bg_flags \|= BG_IS_SIZE_SENSITIVE;
355	}
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	ASA_XImage,
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	340	else
439	{	341	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
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	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	}	342	}
591	# endif /* HAVE_AFTERIMAGE */
592		343
593	# ifdef HAVE_PIXBUF	344	# ifdef HAVE_PIXBUF
594	bool	345	bool
595	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,	346	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
596	int src_x, int src_y, int dst_x, int dst_y,	347	int src_x, int src_y, int dst_x, int dst_y,
…		…
673	XDestroyImage (ximage);	424	XDestroyImage (ximage);
674	return true;	425	return true;
675	}	426	}
676		427
677	bool	428	bool
678	rxvt_term::render_image (unsigned long tr_flags)	429	rxvt_term::render_image (bool transparent)
679	{	430	{
680	if (!pixbuf)	431	if (!pixbuf)
681	return false;	432	return false;
682		433
683	if (tr_flags	434	if (transparent
684	&& !(bg_flags & BG_HAS_RENDER))	435	&& !(bg_flags & BG_HAS_RENDER))
685	return false;	436	return false;
686		437
687	GdkPixbuf *result;	438	GdkPixbuf *result;
688		439
…		…
728	Pixmap root_pmap;	479	Pixmap root_pmap;
729		480
730	image_width = gdk_pixbuf_get_width (result);	481	image_width = gdk_pixbuf_get_width (result);
731	image_height = gdk_pixbuf_get_height (result);	482	image_height = gdk_pixbuf_get_height (result);
732		483
733	if (tr_flags)	484	if (transparent)
734	{	485	{
735	root_pmap = bg_pixmap;	486	root_pmap = bg_pixmap;
736	bg_pixmap = None;	487	bg_pixmap = None;
737	}	488	}
738	else	489	else
…		…
796	dst_x, dst_y,	547	dst_x, dst_y,
797	dst_width, dst_height);	548	dst_width, dst_height);
798	}	549	}
799		550
800	#if XRENDER	551	#if XRENDER
801	if (tr_flags)	552	if (transparent)
802	{	553	{
803	XRenderPictureAttributes pa;
804
805	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	554	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		555
806	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	556	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
807		557
808	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
809	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	558	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
810		559
811	pa.repeat = True;	560	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		561
817	XRenderColor mask_c;	562	XRenderColor mask_c;
818		563
819	mask_c.alpha = 0x8000;	564	mask_c.alpha = 0x8000;
820	mask_c.red = 0;	565	mask_c.red =
821	mask_c.green = 0;	566	mask_c.green =
822	mask_c.blue = 0;	567	mask_c.blue = 0;
823	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	568	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		569
824	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	570	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
825		571
826	XRenderFreePicture (dpy, src);	572	XRenderFreePicture (dpy, src);
827	XRenderFreePicture (dpy, dst);	573	XRenderFreePicture (dpy, dst);
828	XRenderFreePicture (dpy, mask);	574	XRenderFreePicture (dpy, mask);
…		…
835	}	581	}
836		582
837	if (result != pixbuf)	583	if (result != pixbuf)
838	g_object_unref (result);	584	g_object_unref (result);
839		585
840	if (tr_flags)	586	if (transparent)
841	XFreePixmap (dpy, root_pmap);	587	XFreePixmap (dpy, root_pmap);
842		588
843	return ret;	589	return ret;
844	}	590	}
845	# endif /* HAVE_PIXBUF */	591	# endif /* HAVE_PIXBUF */
…		…
860	memcpy (f, file, len);	606	memcpy (f, file, len);
861	f[len] = '\0';	607	f[len] = '\0';
862	file = f;	608	file = f;
863	}	609	}
864		610
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	611	# ifdef HAVE_PIXBUF
880	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	612	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
881	if (image)	613	if (image)
882	{	614	{
883	if (pixbuf)	615	if (pixbuf)
…		…
940	{	672	{
941	changed = true;	673	changed = true;
942	v_blurRadius = vr;	674	v_blurRadius = vr;
943	}	675	}
944		676
945	if (v_blurRadius == 0 && h_blurRadius == 0)	677	if (h_blurRadius && v_blurRadius)
		678	bg_flags \|= BG_NEEDS_BLUR;
		679	else
946	bg_flags &= ~BG_NEEDS_BLUR;	680	bg_flags &= ~BG_NEEDS_BLUR;
947	else
948	bg_flags \|= BG_NEEDS_BLUR;
949		681
950	return changed;	682	return changed;
951	}	683	}
952		684
953	void	685	void
954	rxvt_term::set_tint_shade_flags ()	686	rxvt_term::set_tint_shade_flags ()
955	{	687	{
956	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	688	if (shade != 100 \|\| (bg_flags & BG_TINT_SET))
957	bool has_shade = shade != 100;	689	bg_flags \|= BG_NEEDS_TINT;
		690	else
		691	bg_flags &= ~BG_NEEDS_TINT;
		692	}
958		693
		694	bool
		695	rxvt_term::bg_set_tint (rxvt_color &new_tint)
		696	{
		697	if (!(bg_flags & BG_TINT_SET) \|\| tint != new_tint)
		698	{
		699	tint = new_tint;
959	bg_flags &= ~BG_TINT_FLAGS;	700	bg_flags \|= BG_TINT_SET;
960		701
961	if (bg_flags & BG_TINT_SET)	702	rgba c;
962	{
963	tint.get (c);	703	tint.get (c);
964	if (!has_shade
965	&& (c.r <= 0x00ff \|\| c.r >= 0xff00)	704	if ((c.r <= 0x00ff \|\| c.r >= 0xff00)
966	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)	705	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)
967	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))	706	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))
968	bg_flags \|= BG_TINT_BITAND;	707	bg_flags \|= BG_TINT_BITAND;
969	}	708	else
970
971	if (has_shade \|\| (bg_flags & BG_TINT_SET))
972	bg_flags \|= BG_NEEDS_TINT;
973	}
974
975	bool
976	rxvt_term::bg_set_tint (rxvt_color &new_tint)
977	{
978	if (!(bg_flags & BG_TINT_SET) \|\| tint != new_tint)
979	{
980	tint = new_tint;
981	bg_flags \|= BG_TINT_SET;	709	bg_flags &= ~BG_TINT_BITAND;
		710
982	set_tint_shade_flags ();	711	set_tint_shade_flags ();
983	return true;	712	return true;
984	}	713	}
985		714
986	return false;	715	return false;
987	}	716	}
988		717
989	bool	718	bool
990	rxvt_term::bg_set_shade (const char *shade_str)	719	rxvt_term::bg_set_shade (const char *shade_str)
991	{	720	{
992	int new_shade = (shade_str) ? atoi (shade_str) : 100;	721	int new_shade = atoi (shade_str);
993		722
994	clamp_it (new_shade, -100, 200);	723	clamp_it (new_shade, -100, 200);
995	if (new_shade < 0)	724	if (new_shade < 0)
996	new_shade = 200 - (100 + new_shade);	725	new_shade = 200 - (100 + new_shade);
997		726
…		…
1027	params[i+2] = XDoubleToFixed (kernel[i] / sum);	756	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1028	}	757	}
1029	#endif	758	#endif
1030		759
1031	bool	760	bool
1032	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	761	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1033	{	762	{
1034	bool ret = false;	763	bool ret = false;
1035	#if XRENDER	764	#if XRENDER
		765	if (!(bg_flags & BG_HAS_RENDER_CONV))
		766	return false;
		767
1036	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	768	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1037	double kernel = (double )malloc (size * sizeof (double));	769	double kernel = (double )malloc (size * sizeof (double));
1038	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	770	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1039		771
1040	XRenderPictureAttributes pa;	772	XRenderPictureAttributes pa;
1041	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	773	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1042		774
		775	pa.repeat = RepeatPad;
1043	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	776	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		777	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1044	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	778	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		779	XFreePixmap (dpy, tmp);
1045		780
1046	if (kernel && params)	781	if (kernel && params)
1047	{	782	{
1048	if (h_blurRadius)
1049	{
1050	size = h_blurRadius * 2 + 1;	783	size = h_blurRadius * 2 + 1;
1051	get_gaussian_kernel (h_blurRadius, size, kernel, params);	784	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1052		785
1053	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	786	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1054	XRenderComposite (dpy,	787	XRenderComposite (dpy,
1055	PictOpSrc,	788	PictOpSrc,
1056	src,	789	src,
1057	None,	790	None,
1058	dst,	791	dst,
1059	0, 0,	792	0, 0,
1060	0, 0,	793	0, 0,
1061	0, 0,	794	0, 0,
1062	width, height);	795	width, height);
1063	}
1064		796
1065	if (v_blurRadius)	797	::swap (src, dst);
1066	{	798
1067	size = v_blurRadius * 2 + 1;	799	size = v_blurRadius * 2 + 1;
1068	get_gaussian_kernel (v_blurRadius, size, kernel, params);	800	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1069	::swap (params[0], params[1]);	801	::swap (params[0], params[1]);
1070		802
1071	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	803	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1072	XRenderComposite (dpy,	804	XRenderComposite (dpy,
1073	PictOpSrc,	805	PictOpSrc,
1074	src,	806	src,
1075	None,	807	None,
1076	dst,	808	dst,
1077	0, 0,	809	0, 0,
1078	0, 0,	810	0, 0,
1079	0, 0,	811	0, 0,
1080	width, height);	812	width, height);
1081	}
1082		813
1083	ret = true;	814	ret = true;
1084	}	815	}
1085		816
1086	free (kernel);	817	free (kernel);
…		…
1094	bool	825	bool
1095	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	826	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1096	{	827	{
1097	bool ret = false;	828	bool ret = false;
1098		829
1099	if (bg_flags & BG_TINT_BITAND)	830	if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1100	{	831	{
1101	XGCValues gcv;	832	XGCValues gcv;
1102	GC gc;	833	GC gc;
1103		834
1104	/* In this case we can tint image server-side getting significant	835	/* In this case we can tint image server-side getting significant
…		…
1113	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	844	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1114	ret = true;	845	ret = true;
1115	XFreeGC (dpy, gc);	846	XFreeGC (dpy, gc);
1116	}	847	}
1117	}	848	}
1118	else
1119	{
1120	# if XRENDER	849	# if XRENDER
		850	else if (bg_flags & BG_HAS_RENDER)
		851	{
1121	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);	852	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1122		853
1123	if (bg_flags & BG_TINT_SET)	854	if (bg_flags & BG_TINT_SET)
1124	tint.get (c);	855	tint.get (c);
1125		856
…		…
1134	c.r = c.r * (200 - shade) / 100;	865	c.r = c.r * (200 - shade) / 100;
1135	c.g = c.g * (200 - shade) / 100;	866	c.g = c.g * (200 - shade) / 100;
1136	c.b = c.b * (200 - shade) / 100;	867	c.b = c.b * (200 - shade) / 100;
1137	}	868	}
1138		869
1139	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1140	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	870	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1141	XRenderPictureAttributes pa;
1142		871
1143	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	872	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1144		873
1145	pa.repeat = True;	874	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1146		875
1147	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	876	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		877
1156	XRenderColor mask_c;	878	XRenderColor mask_c;
1157		879
1158	mask_c.alpha = 0xffff;	880	mask_c.alpha = 0xffff;
1159	mask_c.red =	881	mask_c.red =
…		…
1164	mask_c.alpha = 0;	886	mask_c.alpha = 0;
1165	mask_c.red = 0xffff - c.r;	887	mask_c.red = 0xffff - c.r;
1166	mask_c.green = 0xffff - c.g;	888	mask_c.green = 0xffff - c.g;
1167	mask_c.blue = 0xffff - c.b;	889	mask_c.blue = 0xffff - c.b;
1168	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	890	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		891
1169	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);	892	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1170		893
1171	if (shade > 100)	894	if (shade > 100)
1172	{	895	{
1173	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1174	mask_c.alpha = 0;	896	mask_c.alpha = 0;
		897	mask_c.red =
		898	mask_c.green =
		899	mask_c.blue = 0xffff * (shade - 100) / 100;
1175	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	900	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1176		901
1177	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);	902	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1178	}	903	}
1179		904
1180	ret = true;	905	ret = true;
1181		906
1182	XRenderFreePicture (dpy, mask_pic);	907	XRenderFreePicture (dpy, mask_pic);
1183	XRenderFreePicture (dpy, overlay_pic);	908	XRenderFreePicture (dpy, overlay_pic);
1184	XRenderFreePicture (dpy, back_pic);	909	XRenderFreePicture (dpy, back_pic);
		910	}
1185	# endif	911	# endif
1186	}
1187		912
1188	return ret;	913	return ret;
1189	}	914	}
1190		915
1191	/*	916	/*
1192	* Builds a pixmap of the same size as the terminal window that contains	917	* Builds a pixmap of the same size as the terminal window that contains
1193	* the tiled portion of the root pixmap that is supposed to be covered by	918	* the tiled portion of the root pixmap that is supposed to be covered by
1194	* our window.	919	* our window.
1195	*/	920	*/
1196	unsigned long	921	bool
1197	rxvt_term::make_transparency_pixmap ()	922	rxvt_term::make_transparency_pixmap ()
1198	{	923	{
1199	unsigned long result = 0;	924	bool ret = false;
1200		925
1201	/* root dimensions may change from call to call - but Display structure should	926	/* root dimensions may change from call to call - but Display structure should
1202	* be always up-to-date, so let's use it :	927	* be always up-to-date, so let's use it :
1203	*/	928	*/
1204	int screen = display->screen;	929	int screen = display->screen;
…		…
1242	#if XRENDER	967	#if XRENDER
1243	if (bg_flags & BG_HAS_RENDER)	968	if (bg_flags & BG_HAS_RENDER)
1244	{	969	{
1245	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);	970	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1246		971
1247	XRenderPictureAttributes pa;
1248
1249	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	972	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1250	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	973	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1251		974
1252	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	975	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1253	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	976	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1254		977
1255	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	978	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1256		979
1257	XRenderFreePicture (dpy, src);	980	XRenderFreePicture (dpy, src);
1258	XRenderFreePicture (dpy, dst);	981	XRenderFreePicture (dpy, dst);
…		…
1275	bg_pmap_width = window_width;	998	bg_pmap_width = window_width;
1276	bg_pmap_height = window_height;	999	bg_pmap_height = window_height;
1277	}	1000	}
1278		1001
1279	/* straightforward pixmap copy */	1002	/* straightforward pixmap copy */
1280	while (sx < 0) sx += root_width;	1003	while (sx < 0) sx += root_pmap_width;
1281	while (sy < 0) sy += root_height;	1004	while (sy < 0) sy += root_pmap_height;
1282		1005
1283	gcv.tile = recoded_root_pmap;	1006	gcv.tile = recoded_root_pmap;
1284	gcv.fill_style = FillTiled;	1007	gcv.fill_style = FillTiled;
1285	gcv.ts_x_origin = -sx;	1008	gcv.ts_x_origin = -sx;
1286	gcv.ts_y_origin = -sy;	1009	gcv.ts_y_origin = -sy;
1287	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);	1010	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);
1288		1011
1289	if (gc)	1012	if (gc)
1290	{	1013	{
1291	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1014	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1292	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1015	ret = true;
		1016	unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
		1017
		1018	if (!(bg_flags & BG_CLIENT_RENDER))
		1019	{
		1020	if (bg_flags & BG_NEEDS_BLUR)
		1021	{
		1022	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
		1023	tr_flags &= ~BG_NEEDS_BLUR;
		1024	}
		1025	if (bg_flags & BG_NEEDS_TINT)
		1026	{
		1027	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
		1028	tr_flags &= ~BG_NEEDS_TINT;
		1029	}
		1030	if (tr_flags & BG_NEEDS_TINT)
		1031	{
		1032	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1033	if (ximage)
		1034	{
		1035	/* our own client-side tinting */
		1036	tint_ximage (DefaultVisual (dpy, display->screen), ximage);
		1037
		1038	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1039	XDestroyImage (ximage);
		1040	}
		1041	}
		1042	} /* server side rendering completed */
		1043
1293	XFreeGC (dpy, gc);	1044	XFreeGC (dpy, gc);
1294
1295	if (!(bg_flags & BG_CLIENT_RENDER))
1296	{
1297	if ((bg_flags & BG_NEEDS_BLUR)
1298	&& (bg_flags & BG_HAS_RENDER_CONV))
1299	{
1300	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
1301	result &= ~BG_NEEDS_BLUR;
1302	}
1303	if ((bg_flags & BG_NEEDS_TINT)
1304	&& (bg_flags & (BG_TINT_BITAND \| BG_HAS_RENDER)))
1305	{
1306	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1307	result &= ~BG_NEEDS_TINT;
1308	}
1309	} /* server side rendering completed */
1310	}	1045	}
1311		1046
1312	if (recoded_root_pmap != root_pixmap)	1047	if (recoded_root_pmap != root_pixmap)
1313	XFreePixmap (dpy, recoded_root_pmap);	1048	XFreePixmap (dpy, recoded_root_pmap);
1314		1049
1315	return result;	1050	return ret;
1316	}	1051	}
1317		1052
1318	void	1053	void
1319	rxvt_term::bg_set_root_pixmap ()	1054	rxvt_term::bg_set_root_pixmap ()
1320	{	1055	{
…		…
1324		1059
1325	root_pixmap = new_root_pixmap;	1060	root_pixmap = new_root_pixmap;
1326	}	1061	}
1327	# endif /* ENABLE_TRANSPARENCY */	1062	# endif /* ENABLE_TRANSPARENCY */
1328		1063
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	1064	bool
1334	rxvt_term::bg_render ()	1065	rxvt_term::bg_render ()
1335	{	1066	{
1336	unsigned long tr_flags = 0;	1067	bool transparent = false;
1337		1068
1338	bg_invalidate ();	1069	bg_invalidate ();
1339	# ifdef ENABLE_TRANSPARENCY	1070	# ifdef ENABLE_TRANSPARENCY
1340	if (bg_flags & BG_IS_TRANSPARENT)	1071	if (bg_flags & BG_IS_TRANSPARENT)
1341	{	1072	{
1342	/* we need to re-generate transparency pixmap in that case ! */	1073	/* we need to re-generate transparency pixmap in that case ! */
1343	tr_flags = make_transparency_pixmap ();	1074	transparent = make_transparency_pixmap ();
1344	if (tr_flags == 0)	1075	if (transparent)
1345	return false;
1346	bg_flags \|= BG_IS_VALID;	1076	bg_flags \|= BG_IS_VALID;
1347	}	1077	}
1348	# endif	1078	# endif
1349		1079
1350	# ifdef BG_IMAGE_FROM_FILE	1080	# ifdef BG_IMAGE_FROM_FILE
1351	if ((bg_flags & BG_IS_FROM_FILE)	1081	if (bg_flags & BG_IS_FROM_FILE)
1352	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1353	{	1082	{
1354	if (render_image (tr_flags))	1083	if (render_image (transparent))
1355	bg_flags \|= BG_IS_VALID;	1084	bg_flags \|= BG_IS_VALID;
1356	}
1357	# endif
1358
1359	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1360	XImage *result = NULL;
1361
1362	if (tr_flags & BG_NEEDS_TINT)
1363	{
1364	result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1365	}
1366
1367	if (result)
1368	{
1369	/* our own client-side tinting */
1370	//if (tr_flags & BG_NEEDS_TINT)
1371	if (1)
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	}
1387
1388	XDestroyImage (result);
1389	}	1085	}
1390	# endif	1086	# endif
1391		1087
1392	if (!(bg_flags & BG_IS_VALID))	1088	if (!(bg_flags & BG_IS_VALID))
1393	{	1089	{
…		…
1430	#endif	1126	#endif
1431	}	1127	}
1432		1128
1433	#endif /* HAVE_BG_PIXMAP */	1129	#endif /* HAVE_BG_PIXMAP */
1434		1130
1435	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1131	#ifdef ENABLE_TRANSPARENCY
1436	/* based on code from aterm-0.4.2 */	1132	/* based on code from aterm-0.4.2 */
1437		1133
1438	static void	1134	static inline void
1439	shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c)	1135	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
		1136	{
		1137	for (int i = 0; i <= mask >> sh; i++)
		1138	{
		1139	uint32_t tmp;
		1140	tmp = i * high;
		1141	tmp += (mask >> sh) * low;
		1142	lookup[i] = (tmp / 0xffff) << sh;
		1143	}
		1144	}
		1145
		1146	void
		1147	rxvt_term::tint_ximage (Visual visual, XImage ximage)
1440	{	1148	{
1441	int sh_r, sh_g, sh_b;	1149	int sh_r, sh_g, sh_b;
1442	uint32_t mask_r, mask_g, mask_b;	1150	uint32_t mask_r, mask_g, mask_b;
1443	uint32_t lookup, lookup_r, lookup_g, lookup_b;	1151	uint32_t lookup, lookup_r, lookup_g, lookup_b;
1444	rgba low;	1152	unsigned short low;
1445	rgba high;
1446	int i;
1447	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	1153	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1448		1154
1449	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;	1155	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;
1450		1156
1451	/* for convenience */	1157	/* for convenience */
…		…
1510	break;	1216	break;
1511	default:	1217	default:
1512	return; /* we do not support this color depth */	1218	return; /* we do not support this color depth */
1513	}	1219	}
1514		1220
		1221	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
		1222
		1223	if (bg_flags & BG_TINT_SET)
		1224	tint.get (c);
		1225
1515	/* prepare limits for color transformation (each channel is handled separately) */	1226	/* prepare limits for color transformation (each channel is handled separately) */
1516	if (shade > 100)	1227	if (shade > 100)
1517	{	1228	{
1518	shade = 200 - shade;
1519
1520	high.r = c.r * shade / 100;
1521	high.g = c.g * shade / 100;
1522	high.b = c.b * shade / 100;
1523
1524	low.r = 65535 * (100 - shade) / 100;	1229	c.r = c.r * (200 - shade) / 100;
1525	low.g = 65535 * (100 - shade) / 100;	1230	c.g = c.g * (200 - shade) / 100;
1526	low.b = 65535 * (100 - shade) / 100;	1231	c.b = c.b * (200 - shade) / 100;
		1232
		1233	low = 0xffff * (shade - 100) / 100;
1527	}	1234	}
1528	else	1235	else
1529	{	1236	{
1530	high.r = c.r * shade / 100;	1237	c.r = c.r * shade / 100;
1531	high.g = c.g * shade / 100;	1238	c.g = c.g * shade / 100;
1532	high.b = c.b * shade / 100;	1239	c.b = c.b * shade / 100;
1533		1240
1534	low.r = low.g = low.b = 0;	1241	low = 0;
1535	}	1242	}
1536		1243
1537	/* fill our lookup tables */	1244	/* fill our lookup tables */
1538	for (i = 0; i <= mask_r>>sh_r; i++)	1245	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1539	{	1246	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1540	uint32_t tmp;	1247	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1541	tmp = i * high.r;
1542	tmp += (mask_r>>sh_r) * low.r;
1543	lookup_r[i] = (tmp/65535)<<sh_r;
1544	}
1545	for (i = 0; i <= mask_g>>sh_g; i++)
1546	{
1547	uint32_t tmp;
1548	tmp = i * high.g;
1549	tmp += (mask_g>>sh_g) * low.g;
1550	lookup_g[i] = (tmp/65535)<<sh_g;
1551	}
1552	for (i = 0; i <= mask_b>>sh_b; i++)
1553	{
1554	uint32_t tmp;
1555	tmp = i * high.b;
1556	tmp += (mask_b>>sh_b) * low.b;
1557	lookup_b[i] = (tmp/65535)<<sh_b;
1558	}
1559		1248
1560	/* apply table to input image (replacing colors by newly calculated ones) */	1249	/* apply table to input image (replacing colors by newly calculated ones) */
1561	if (ximage->bits_per_pixel == 32	1250	if (ximage->bits_per_pixel == 32
1562	&& (ximage->depth == 24 \|\| ximage->depth == 32)	1251	&& (ximage->depth == 24 \|\| ximage->depth == 32)
1563	&& ximage->byte_order == host_byte_order)	1252	&& ximage->byte_order == host_byte_order)
…		…
1593	}	1282	}
1594	}	1283	}
1595		1284
1596	free (lookup);	1285	free (lookup);
1597	}	1286	}
1598	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1287	#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.175 by sf-exg, Mon Dec 5 18:17:17 2011 UTC vs. Revision 1.206 by sf-exg, Thu Apr 12 10:22:50 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.175 by sf-exg, Mon Dec 5 18:17:17 2011 UTC vs.
Revision 1.206 by sf-exg, Thu Apr 12 10:22:50 2012 UTC