ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/rxvt-unicode/src/background.C

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.42 by sf-exg, Sun Aug 29 13:24:30 2010 UTC vs.
Revision 1.82 by sf-exg, Thu Oct 14 16:01:28 2010 UTC

…		…
19	* You should have received a copy of the GNU General Public License	19	* You should have received a copy of the GNU General Public License
20	* along with this program; if not, write to the Free Software	20	* along with this program; if not, write to the Free Software
21	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	21	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22	*---------------------------------------------------------------------*/	22	*---------------------------------------------------------------------*/
23		23
		24	#include <cmath>
24	#include "../config.h" /* NECESSARY */	25	#include "../config.h" /* NECESSARY */
25	#include "rxvt.h" /* NECESSARY */	26	#include "rxvt.h" /* NECESSARY */
26		27
27	#define DO_TIMING_TEST 0	28	#define DO_TIMING_TEST 0
28		29
…		…
52	* adjustment and may optionally be followed by a colon and one or more	53	* adjustment and may optionally be followed by a colon and one or more
53	* colon-delimited pixmap operations.	54	* colon-delimited pixmap operations.
54	* The following table shows the valid geometry strings and their	55	* The following table shows the valid geometry strings and their
55	* effects on the background image :	56	* effects on the background image :
56	*	57	*
57	* WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.	58	* WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
58	* W and H are percentages of the terminal window size.	59	* W and H are percentages of the terminal window size.
59	* X and Y are also percentages; e.g., +50+50 centers	60	* X and Y are also percentages; e.g., +50+50 centers
60	* the image in the window.	61	* the image in the window.
61	* WxH+X Assumes Y == X	62	* WxH+X Assumes Y == X
62	* WxH Assumes Y == X == 50 (centers the image)	63	* WxH Assumes Y == X == 50 (centers the image)
63	* W+X+Y Assumes H == W	64	* W+X+Y Assumes H == W
64	* W+X Assumes H == W and Y == X	65	* W+X Assumes H == W and Y == X
65	* W Assumes H == W and Y == X == 50	66	* W Assumes H == W and Y == X == 50
66	*	67	*
67	* Adjusting position only :	68	* Adjusting position only :
68	* =+X+Y Set position to X% by Y% (absolute).	69	* =+X+Y Set position to X% by Y% (absolute).
69	* =+X Set position to X% by X%.	70	* =+X Set position to X% by X%.
70	* +X+Y Adjust position horizontally X% and vertically Y%	71	* +X+Y Adjust position horizontally X% and vertically Y%
71	* from current position (relative).	72	* from current position (relative).
72	* +X Adjust position horizontally X% and vertically X%	73	* +X Adjust position horizontally X% and vertically X%
73	* from current position.	74	* from current position.
74	*	75	*
75	* Adjusting scale only :	76	* Adjusting scale only :
76	* Wx0 Multiply horizontal scaling factor by W%	77	* Wx0 Multiply horizontal scaling factor by W%
77	* 0xH Multiply vertical scaling factor by H%	78	* 0xH Multiply vertical scaling factor by H%
78	* 0x0 No scaling (show image at normal size).	79	* 0x0 No scaling (show image at normal size).
79	*	80	*
80	* Pixmap Operations : (should be prepended by a colon)	81	* Pixmap Operations : (should be prepended by a colon)
81	* tile Tile image. Scaling/position modifiers above will affect	82	* tile Tile image. Scaling/position modifiers above will affect
82	* the tile size and origin.	83	* the tile size and origin.
83	* propscale When scaling, scale proportionally. That is, maintain the	84	* propscale When scaling, scale proportionally. That is, maintain the
84	* proper aspect ratio for the image. Any portion of the	85	* proper aspect ratio for the image. Any portion of the
85	* background not covered by the image is filled with the	86	* background not covered by the image is filled with the
86	* current background color.	87	* current background color.
87	* hscale Scale horizontally, tile vertically ?	88	* hscale Scale horizontally, tile vertically ?
88	* vscale Tile horizontally, scale vertically ?	89	* vscale Tile horizontally, scale vertically ?
…		…
96	// this is basically redundant as bgPixmap_t is only used in	97	// this is basically redundant as bgPixmap_t is only used in
97	// zero_initialised-derived structs	98	// zero_initialised-derived structs
98	#ifdef HAVE_AFTERIMAGE	99	#ifdef HAVE_AFTERIMAGE
99	original_asim = NULL;	100	original_asim = NULL;
100	#endif	101	#endif
		102	#ifdef HAVE_PIXBUF
		103	pixbuf = NULL;
		104	#endif
101	#ifdef BG_IMAGE_FROM_FILE	105	#ifdef BG_IMAGE_FROM_FILE
		106	have_image = false;
102	h_scale = v_scale = 0;	107	h_scale = v_scale = 0;
103	h_align = v_align = 0;	108	h_align = v_align = 0;
		109	#endif
		110	#ifdef ENABLE_TRANSPARENCY
		111	shade = 100;
104	#endif	112	#endif
105	flags = 0;	113	flags = 0;
106	pixmap = None;	114	pixmap = None;
107	valid_since = invalid_since = 0;	115	valid_since = invalid_since = 0;
108	target = 0;	116	target = 0;
…		…
114	#ifdef HAVE_AFTERIMAGE	122	#ifdef HAVE_AFTERIMAGE
115	if (original_asim)	123	if (original_asim)
116	safe_asimage_destroy (original_asim);	124	safe_asimage_destroy (original_asim);
117	#endif	125	#endif
118		126
		127	#ifdef HAVE_PIXBUF
		128	if (pixbuf)
		129	g_object_unref (pixbuf);
		130	#endif
		131
119	if (pixmap && target)	132	if (pixmap && target)
120	XFreePixmap (target->dpy, pixmap);	133	XFreePixmap (target->dpy, pixmap);
121	}	134	}
122		135
123	bool	136	bool
…		…
127	if (flags & isTransparent)	140	if (flags & isTransparent)
128	return true;	141	return true;
129	# endif	142	# endif
130		143
131	# ifdef BG_IMAGE_FROM_FILE	144	# ifdef BG_IMAGE_FROM_FILE
132	# ifdef HAVE_AFTERIMAGE	145	if (have_image)
133	if (original_asim)
134	# endif
135	{	146	{
136	if (h_scale != 0 || v_scale != 0	147	if (flags & sizeSensitive)
137	|| h_align != 0 || v_align != 0)
138	return true;	148	return true;
139	}	149	}
140	# endif	150	# endif
141		151
142	return false;	152	return false;
…		…
149	if (flags & isTransparent)	159	if (flags & isTransparent)
150	return true;	160	return true;
151	# endif	161	# endif
152		162
153	# ifdef BG_IMAGE_FROM_FILE	163	# ifdef BG_IMAGE_FROM_FILE
154	# ifdef HAVE_AFTERIMAGE	164	if (have_image)
155	if (original_asim)
156	# endif
157	{	165	{
158	if (h_align == rootAlign || v_align == rootAlign)	166	if (flags & rootAlign)
159	return true;	167	return true;
160	}	168	}
161	# endif	169	# endif
162		170
163	return false;	171	return false;
…		…
170	return true;	178	return true;
171	# endif	179	# endif
172	# ifdef ENABLE_TRANSPARENCY	180	# ifdef ENABLE_TRANSPARENCY
173	if (flags & isTransparent)	181	if (flags & isTransparent)
174	{	182	{
175	# ifdef HAVE_AFTERIMAGE // can't blur without libAI anyways	183	# ifdef HAVE_AFTERIMAGE
176	if ((flags & blurNeeded) && !(flags & blurServerSide))	184	if ((flags & blurNeeded) && !(flags & blurServerSide))
177	return true;	185	return true;
178	# endif	186	# endif
179	if ((flags & tintNeeded) && !(flags & tintServerSide))	187	if ((flags & tintNeeded) && !(flags & tintServerSide))
180	return true;	188	return true;
…		…
203	static inline bool	211	static inline bool
204	check_set_align_value (int geom_flags, int flag, int &align, int new_value)	212	check_set_align_value (int geom_flags, int flag, int &align, int new_value)
205	{	213	{
206	if (geom_flags & flag)	214	if (geom_flags & flag)
207	{	215	{
208	if (new_value != bgPixmap_t::rootAlign)
209	{
210	if (new_value < -100)	216	if (new_value < -100)
211	new_value = -100;	217	new_value = -100;
212	else if (new_value > 200)	218	else if (new_value > 200)
213	new_value = 200;	219	new_value = 200;
214	}
215	if (new_value != align)	220	if (new_value != align)
216	{	221	{
217	align = new_value;	222	align = new_value;
218	return true;	223	return true;
219	}	224	}
…		…
223		228
224	static inline int	229	static inline int
225	make_align_position (int align, int window_size, int image_size)	230	make_align_position (int align, int window_size, int image_size)
226	{	231	{
227	int diff = window_size - image_size;	232	int diff = window_size - image_size;
228	int smaller = MIN (image_size,window_size);	233	int smaller = min (image_size, window_size);
229		234
230	if (align >= 0 && align <= 50)	235	if (align >= 0 && align <= 100)
231	return diff * align / 100;	236	return diff * align / 100;
232	else if (align > 50 && align <= 100)
233	return window_size - image_size - diff * (100 - align) / 100;
234	else if (align > 100 && align <= 200 )	237	else if (align > 100 && align <= 200 )
235	return ((align - 100) * smaller / 100) + window_size - smaller;	238	return ((align - 100) * smaller / 100) + window_size - smaller;
236	else if (align > -100 && align < 0)	239	else if (align >= -100 && align < 0)
237	return ((align + 100) * smaller / 100) - image_size;	240	return ((align + 100) * smaller / 100) - image_size;
238	return 0;	241	return 0;
239	}	242	}
240		243
241	static inline int	244	static inline int
242	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	245	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
243	{	246	{
244	int src_pos = 0;	247	int src_pos = 0;
245	dst_pos = 0;	248	dst_pos = pos;
246	dst_size = size;	249	dst_size = size;
247	if (pos < 0 && size > target_size)	250	if (pos < 0)
248	{	251	{
249	src_pos = -pos;	252	src_pos = -pos;
		253	dst_pos = 0;
250	dst_size += pos;	254	dst_size += pos;
251	}	255	}
252	else if (pos > 0)
253	dst_pos = pos;
254		256
255	if (dst_pos + dst_size > target_size)	257	if (dst_pos + dst_size > target_size)
256	dst_size = target_size - dst_pos;	258	dst_size = target_size - dst_pos;
257	return src_pos;	259	return src_pos;
258	}	260	}
…		…
383	w = h = noScale;	385	w = h = noScale;
384	geom_flags |= WidthValue|HeightValue;	386	geom_flags |= WidthValue|HeightValue;
385	}	387	}
386	else if (CHECK_GEOM_OPS ("propscale"))	388	else if (CHECK_GEOM_OPS ("propscale"))
387	{	389	{
388	if (w == 0 && h == 0)
389	{
390	w = windowScale;
391	geom_flags |= WidthValue;
392	}
393	new_flags |= propScale;	390	new_flags |= propScale;
394	}	391	}
395	else if (CHECK_GEOM_OPS ("hscale"))	392	else if (CHECK_GEOM_OPS ("hscale"))
396	{	393	{
397	if (w == 0) w = windowScale;	394	if (w == 0) w = windowScale;
…		…
419	x = y = centerAlign;	416	x = y = centerAlign;
420	geom_flags |= WidthValue|HeightValue|XValue|YValue;	417	geom_flags |= WidthValue|HeightValue|XValue|YValue;
421	}	418	}
422	else if (CHECK_GEOM_OPS ("root"))	419	else if (CHECK_GEOM_OPS ("root"))
423	{	420	{
		421	new_flags |= rootAlign;
424	w = h = noScale;	422	w = h = noScale;
425	x = y = rootAlign;
426	geom_flags |= WidthValue|HeightValue|XValue|YValue;	423	geom_flags |= WidthValue|HeightValue;
427	}	424	}
428	# undef CHECK_GEOM_OPS	425	# undef CHECK_GEOM_OPS
429		426
430	while (*ops != ':' && *ops != '\0') ++ops;	427	while (*ops != ':' && *ops != '\0') ++ops;
431	} /* done parsing ops */	428	} /* done parsing ops */
…		…
441	{	438	{
442	flags = new_flags;	439	flags = new_flags;
443	changed++;	440	changed++;
444	}	441	}
445		442
446	//fprintf (stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",	443	//fprintf (stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
447	// flags, h_scale, v_scale, h_align, v_align);	444	// flags, h_scale, v_scale, h_align, v_align);
448	return (changed > 0);	445	return (changed > 0);
		446	}
		447
		448	void
		449	bgPixmap_t::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
		450	{
		451	int target_width = target->szHint.width;
		452	int target_height = target->szHint.height;
		453
		454	if (flags & propScale)
		455	{
		456	float scale = (float)target_width / image_width;
		457	min_it (scale, (float)target_height / image_height);
		458	w = image_width * scale + 0.5;
		459	h = image_height * scale + 0.5;
		460	}
		461	else
		462	{
		463	w = h_scale * target_width / 100;
		464	h = v_scale * target_height / 100;
		465	}
		466
		467	if (!w) w = image_width;
		468	if (!h) h = image_height;
		469
		470	if (flags & rootAlign)
		471	{
		472	target->get_window_origin (x, y);
		473	x = -x;
		474	y = -y;
		475	}
		476	else
		477	{
		478	x = make_align_position (h_align, target_width, w);
		479	y = make_align_position (v_align, target_height, h);
		480	}
		481
		482	flags &= ~sizeSensitive;
		483	if (h_scale != 0 || v_scale != 0
		484	|| h_align != 0 || v_align != 0
		485	|| w > target_width || h > target_height)
		486	flags |= sizeSensitive;
449	}	487	}
450		488
451	# ifdef HAVE_AFTERIMAGE	489	# ifdef HAVE_AFTERIMAGE
452	bool	490	bool
453	bgPixmap_t::render_asim (ASImage *background, ARGB32 background_tint)	491	bgPixmap_t::render_image (unsigned long background_flags)
454	{	492	{
455	if (target == NULL)	493	if (target == NULL)
456	return false;	494	return false;
457		495
458	target->init_asv ();	496	target->init_asv ();
		497
		498	ASImage *background = NULL;
		499	ARGB32 background_tint = TINT_LEAVE_SAME;
		500
		501	# ifdef ENABLE_TRANSPARENCY
		502	if (background_flags)
		503	background = pixmap2ximage (target->asv, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, 100);
		504
		505	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
		506	{
		507	ShadingInfo as_shade;
		508	as_shade.shading = shade;
		509
		510	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
		511	if (flags & tintSet)
		512	tint.get (c);
		513	as_shade.tintColor.red = c.r;
		514	as_shade.tintColor.green = c.g;
		515	as_shade.tintColor.blue = c.b;
		516
		517	background_tint = shading2tint32 (&as_shade);
		518	}
		519
		520	if (!(background_flags & transpPmapBlurred) && (flags & blurNeeded) && background != NULL)
		521	{
		522	ASImage *tmp = blur_asimage_gauss (target->asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
		523	(original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,
		524	100, ASIMAGE_QUALITY_DEFAULT);
		525	if (tmp)
		526	{
		527	destroy_asimage (&background);
		528	background = tmp;
		529	}
		530	}
		531	# endif
459		532
460	ASImage *result = 0;	533	ASImage *result = 0;
461		534
462	int target_width = target->szHint.width;	535	int target_width = target->szHint.width;
463	int target_height = target->szHint.height;	536	int target_height = target->szHint.height;
464	int new_pmap_width = target_width;	537	int new_pmap_width = target_width;
465	int new_pmap_height = target_height;	538	int new_pmap_height = target_height;
466		539
467	int x = 0;	540	int x = 0;
468	int y = 0;	541	int y = 0;
469	int w = h_scale * target_width / 100;	542	int w = 0;
470	int h = v_scale * target_height / 100;	543	int h = 0;
471		544
472	TIMING_TEST_START (asim);	545	TIMING_TEST_START (asim);
473		546
474	if (original_asim)	547	if (original_asim)
475	{	548	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
476	if (h_align == rootAlign || v_align == rootAlign)
477	{
478	target->get_window_origin(x, y);
479	x = -x;
480	y = -y;
481	}
482
483	if (h_align != rootAlign)
484	x = make_align_position (h_align, target_width, w > 0 ? w : (int)original_asim->width);
485
486	if (v_align != rootAlign)
487	y = make_align_position (v_align, target_height, h > 0 ? h : (int)original_asim->height);
488	}
489		549
490	if (!original_asim	550	if (!original_asim
		551	|| (!(flags & rootAlign)
491	|| x >= target_width	552	&& (x >= target_width
492	|| y >= target_height	553	|| y >= target_height
493	|| (w > 0 && x + w <= 0)	554	|| (x + w <= 0)
494	|| (h > 0 && y + h <= 0))	555	|| (y + h <= 0))))
495	{	556	{
496	if (background)	557	if (background)
497	{	558	{
498	new_pmap_width = background->width;	559	new_pmap_width = background->width;
499	new_pmap_height = background->height;	560	new_pmap_height = background->height;
…		…
513	}	574	}
514	else	575	else
515	{	576	{
516	result = original_asim;	577	result = original_asim;
517		578
518	if ((w > 0 && w != original_asim->width)	579	if ((w != original_asim->width)
519	|| (h > 0 && h != original_asim->height))	580	|| (h != original_asim->height))
520	{	581	{
521	result = scale_asimage (target->asv, original_asim,	582	result = scale_asimage (target->asv, original_asim,
522	w > 0 ? w : original_asim->width,	583	w, h,
523	h > 0 ? h : original_asim->height,
524	background ? ASA_ASImage : ASA_XImage,	584	background ? ASA_ASImage : ASA_XImage,
525	100, ASIMAGE_QUALITY_DEFAULT);	585	100, ASIMAGE_QUALITY_DEFAULT);
526	}	586	}
527		587
528	if (background == NULL)	588	if (background == NULL)
529	{	589	{
530	/* if tiling - pixmap has to be sized exactly as the image,
531	but there is no need to make it bigger than the window! */
532	if (h_scale == 0)
533	new_pmap_width = min (result->width, target_width);
534	if (v_scale == 0)
535	new_pmap_height = min (result->height, target_height);
536	/* we also need to tile our image in one or both directions */
537	if (h_scale == 0 || v_scale == 0)	590	if (h_scale == 0 || v_scale == 0)
538	{	591	{
		592	/* if tiling - pixmap has to be sized exactly as the image,
		593	but there is no need to make it bigger than the window! */
		594	new_pmap_width = min (result->width, target_width);
		595	new_pmap_height = min (result->height, target_height);
		596
		597	/* we also need to tile our image in both directions */
539	ASImage *tmp = tile_asimage (target->asv, result,	598	ASImage *tmp = tile_asimage (target->asv, result,
540	(h_scale > 0) ? 0 : (int)result->width - x,	599	(int)result->width - x,
541	(v_scale > 0) ? 0 : (int)result->height - y,	600	(int)result->height - y,
542	new_pmap_width,	601	new_pmap_width,
543	new_pmap_height,	602	new_pmap_height,
544	TINT_LEAVE_SAME, ASA_XImage,	603	TINT_LEAVE_SAME, ASA_XImage,
545	100, ASIMAGE_QUALITY_DEFAULT);	604	100, ASIMAGE_QUALITY_DEFAULT);
546	if (tmp)	605	if (tmp)
…		…
561	layers[0].clip_width = target_width;	620	layers[0].clip_width = target_width;
562	layers[0].clip_height = target_height;	621	layers[0].clip_height = target_height;
563	layers[0].tint = background_tint;	622	layers[0].tint = background_tint;
564	layers[1].im = result;	623	layers[1].im = result;
565		624
566	if (w <= 0)	625	if (h_scale == 0 || v_scale == 0)
567	{	626	{
568	/* tile horizontally */	627	/* tile horizontally */
569	while (x > 0) x -= (int)result->width;	628	while (x > 0) x -= (int)result->width;
570	layers[1].dst_x = x;	629	layers[1].dst_x = x;
571	layers[1].clip_width = result->width+target_width;	630	layers[1].clip_width = result->width+target_width;
…		…
575	/* clip horizontally */	634	/* clip horizontally */
576	layers[1].dst_x = x;	635	layers[1].dst_x = x;
577	layers[1].clip_width = result->width;	636	layers[1].clip_width = result->width;
578	}	637	}
579		638
580	if (h <= 0)	639	if (h_scale == 0 || v_scale == 0)
581	{	640	{
582	while (y > 0) y -= (int)result->height;	641	while (y > 0) y -= (int)result->height;
583	layers[1].dst_y = y;	642	layers[1].dst_y = y;
584	layers[1].clip_height = result->height + target_height;	643	layers[1].clip_height = result->height + target_height;
585	}	644	}
…		…
610	free (layers);	669	free (layers);
611	}	670	}
612	}	671	}
613	TIMING_TEST_PRINT_RESULT (asim);	672	TIMING_TEST_PRINT_RESULT (asim);
614		673
615	if (pixmap)	674	bool ret = false;
616	{
617	if (result == NULL
618	|| pmap_width != new_pmap_width
619	|| pmap_height != new_pmap_height
620	|| pmap_depth != target->depth)
621	{
622	XFreePixmap (target->dpy, pixmap);
623	pixmap = None;
624	}
625	}
626		675
627	if (result)	676	if (result)
628	{	677	{
629	XGCValues gcv;	678	XGCValues gcv;
630	GC gc;	679	GC gc;
		680
		681	if (pixmap)
		682	{
		683	if (pmap_width != new_pmap_width
		684	|| pmap_height != new_pmap_height
		685	|| pmap_depth != target->depth)
		686	{
		687	XFreePixmap (target->dpy, pixmap);
		688	pixmap = None;
		689	}
		690	}
631		691
632	/* create Pixmap */	692	/* create Pixmap */
633	if (pixmap == None)	693	if (pixmap == None)
634	{	694	{
635	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);	695	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
636	pmap_width = new_pmap_width;	696	pmap_width = new_pmap_width;
637	pmap_height = new_pmap_height;	697	pmap_height = new_pmap_height;
638	pmap_depth = target->depth;	698	pmap_depth = target->depth;
639	}	699	}
640	/* fill with background color ( if result's not completely overlapping it)*/	700	/* fill with background color (if result's not completely overlapping it) */
641	gcv.foreground = target->pix_colors[Color_bg];	701	gcv.foreground = target->pix_colors[Color_bg];
642	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);	702	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
643		703
644	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;	704	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
645	int dst_width = result->width, dst_height = result->height;	705	int dst_width = result->width, dst_height = result->height;
646	if (background == NULL)	706	if (background == NULL)
647	{	707	{
		708	if (!(h_scale == 0 || v_scale == 0))
		709	{
648	if (h_scale > 0) src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );	710	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
649	if (v_scale > 0) src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);	711	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
		712	}
650		713
651	if (dst_x > 0 || dst_y > 0	714	if (dst_x > 0 || dst_y > 0
652	|| dst_x + dst_width < new_pmap_width	715	|| dst_x + dst_width < new_pmap_width
653	|| dst_y + dst_height < new_pmap_height)	716	|| dst_y + dst_height < new_pmap_height)
654	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	717	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
…		…
661	if (result != background && result != original_asim)	724	if (result != background && result != original_asim)
662	destroy_asimage (&result);	725	destroy_asimage (&result);
663		726
664	XFreeGC (target->dpy, gc);	727	XFreeGC (target->dpy, gc);
665	TIMING_TEST_PRINT_RESULT (asim);	728	TIMING_TEST_PRINT_RESULT (asim);
666	}
667		729
		730	ret = true;
		731	}
		732
		733	if (background)
		734	destroy_asimage (&background);
		735
668	return true;	736	return ret;
669	}	737	}
670	# endif /* HAVE_AFTERIMAGE */	738	# endif /* HAVE_AFTERIMAGE */
		739
		740	# ifdef HAVE_PIXBUF
		741	bool
		742	bgPixmap_t::render_image (unsigned long background_flags)
		743	{
		744	if (target == NULL)
		745	return false;
		746
		747	if (!pixbuf)
		748	return false;
		749
		750	#if !XFT
		751	if (background_flags)
		752	return false;
		753	#endif
		754
		755	GdkPixbuf *result;
		756
		757	int image_width = gdk_pixbuf_get_width (pixbuf);
		758	int image_height = gdk_pixbuf_get_height (pixbuf);
		759
		760	int target_width = target->szHint.width;
		761	int target_height = target->szHint.height;
		762	int new_pmap_width = target_width;
		763	int new_pmap_height = target_height;
		764
		765	int x = 0;
		766	int y = 0;
		767	int w = 0;
		768	int h = 0;
		769
		770	get_image_geometry (image_width, image_height, w, h, x, y);
		771
		772	if (!(flags & rootAlign)
		773	&& (x >= target_width
		774	|| y >= target_height
		775	|| (x + w <= 0)
		776	|| (y + h <= 0)))
		777	return false;
		778
		779	result = pixbuf;
		780
		781	if ((w != image_width)
		782	|| (h != image_height))
		783	{
		784	result = gdk_pixbuf_scale_simple (pixbuf,
		785	w, h,
		786	GDK_INTERP_BILINEAR);
		787	}
		788
		789	bool ret = false;
		790
		791	if (result)
		792	{
		793	XGCValues gcv;
		794	GC gc;
		795	Pixmap root_pmap;
		796
		797	image_width = gdk_pixbuf_get_width (result);
		798	image_height = gdk_pixbuf_get_height (result);
		799
		800	if (background_flags)
		801	{
		802	root_pmap = pixmap;
		803	pixmap = None;
		804	}
		805	else
		806	{
		807	if (h_scale == 0 || v_scale == 0)
		808	{
		809	new_pmap_width = min (image_width, target_width);
		810	new_pmap_height = min (image_height, target_height);
		811	}
		812	}
		813
		814	if (pixmap)
		815	{
		816	if (pmap_width != new_pmap_width
		817	|| pmap_height != new_pmap_height
		818	|| pmap_depth != target->depth)
		819	{
		820	XFreePixmap (target->dpy, pixmap);
		821	pixmap = None;
		822	}
		823	}
		824
		825	if (pixmap == None)
		826	{
		827	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
		828	pmap_width = new_pmap_width;
		829	pmap_height = new_pmap_height;
		830	pmap_depth = target->depth;
		831	}
		832
		833	gcv.foreground = target->pix_colors[Color_bg];
		834	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
		835
		836	if (h_scale == 0 || v_scale == 0)
		837	{
		838	Pixmap tile = XCreatePixmap (target->dpy, target->vt, image_width, image_height, target->depth);
		839	gdk_pixbuf_xlib_render_to_drawable (result, tile, gc,
		840	0, 0,
		841	0, 0,
		842	image_width, image_height,
		843	XLIB_RGB_DITHER_NONE,
		844	0, 0);
		845
		846	gcv.tile = tile;
		847	gcv.fill_style = FillTiled;
		848	gcv.ts_x_origin = x;
		849	gcv.ts_y_origin = y;
		850	XChangeGC (target->dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
		851
		852	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
		853	XFreePixmap (target->dpy, tile);
		854	}
		855	else
		856	{
		857	int src_x, src_y, dst_x, dst_y;
		858	int dst_width, dst_height;
		859
		860	src_x = make_clip_rectangle (x, image_width , new_pmap_width , dst_x, dst_width );
		861	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
		862
		863	if (dst_x > 0 || dst_y > 0
		864	|| dst_x + dst_width < new_pmap_width
		865	|| dst_y + dst_height < new_pmap_height)
		866	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
		867
		868	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
		869	gdk_pixbuf_xlib_render_to_drawable (result, pixmap, gc,
		870	src_x, src_y,
		871	dst_x, dst_y,
		872	dst_width, dst_height,
		873	XLIB_RGB_DITHER_NONE,
		874	0, 0);
		875	}
		876
		877	#if XFT
		878	if (background_flags)
		879	{
		880	Display *dpy = target->dpy;
		881	XRenderPictureAttributes pa;
		882
		883	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, target->display->screen));
		884	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);
		885
		886	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
		887	Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa);
		888
		889	pa.repeat = True;
		890	Pixmap mask_pmap = XCreatePixmap (dpy, target->vt, 1, 1, 8);
		891	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
		892	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
		893	XFreePixmap (dpy, mask_pmap);
		894
		895	if (src && dst && mask)
		896	{
		897	XRenderColor mask_c;
		898
		899	mask_c.alpha = 0x8000;
		900	mask_c.red = 0;
		901	mask_c.green = 0;
		902	mask_c.blue = 0;
		903	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		904	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
		905	}
		906
		907	XRenderFreePicture (dpy, src);
		908	XRenderFreePicture (dpy, dst);
		909	XRenderFreePicture (dpy, mask);
		910
		911	XFreePixmap (dpy, root_pmap);
		912	}
		913	#endif
		914
		915	if (result != pixbuf)
		916	g_object_unref (result);
		917
		918	XFreeGC (target->dpy, gc);
		919
		920	ret = true;
		921	}
		922
		923	return ret;
		924	}
		925	# endif /* HAVE_PIXBUF */
671		926
672	bool	927	bool
673	bgPixmap_t::set_file (const char *file)	928	bgPixmap_t::set_file (const char *file)
674	{	929	{
675	assert (file);	930	assert (file);
676		931
677	if (*file)	932	if (*file)
678	{	933	{
		934	if (const char *p = strchr (file, ';'))
		935	{
		936	size_t len = p - file;
		937	char *f = rxvt_temp_buf<char> (len + 1);
		938	memcpy (f, file, len);
		939	f[len] = '\0';
		940	file = f;
		941	}
		942
679	# ifdef HAVE_AFTERIMAGE	943	# ifdef HAVE_AFTERIMAGE
680	if (!target->asimman)	944	if (!target->asimman)
681	target->asimman = create_generic_imageman (target->rs[Rs_path]);	945	target->asimman = create_generic_imageman (target->rs[Rs_path]);
682
683	if (const char *p = strchr (file, ';'))
684	{
685	size_t len = p - file;
686	char *f = (char *)malloc (len + 1);
687	memcpy (f, file, len);
688	f[len] = '\0';
689	original_asim = get_asimage (target->asimman, f, 0xFFFFFFFF, 100);	946	ASImage *image = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);
690	free (f);	947	if (image)
691	}	948	{
692	else	949	if (original_asim)
693	original_asim = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);	950	safe_asimage_destroy (original_asim);
		951	original_asim = image;
		952	have_image = true;
		953	return true;
		954	}
		955	# endif
694		956
695	return original_asim;	957	# ifdef HAVE_PIXBUF
		958	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
		959	if (image)
		960	{
		961	if (pixbuf)
		962	g_object_unref (pixbuf);
		963	pixbuf = image;
		964	have_image = true;
		965	return true;
		966	}
696	# endif	967	# endif
697	}	968	}
698		969
699	return false;	970	return false;
700	}	971	}
…		…
720	int changed = 0;	991	int changed = 0;
721	unsigned int hr, vr;	992	unsigned int hr, vr;
722	int junk;	993	int junk;
723	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);	994	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
724		995
725	if (!(geom_flags&WidthValue))	996	if (!(geom_flags & WidthValue))
726	hr = 1;	997	hr = 1;
727	if (!(geom_flags&HeightValue))	998	if (!(geom_flags & HeightValue))
728	vr = hr;	999	vr = hr;
		1000
		1001	min_it (hr, 128);
		1002	min_it (vr, 128);
729		1003
730	if (h_blurRadius != hr)	1004	if (h_blurRadius != hr)
731	{	1005	{
732	++changed;	1006	++changed;
733	h_blurRadius = hr;	1007	h_blurRadius = hr;
…		…
742	if (v_blurRadius == 0 && h_blurRadius == 0)	1016	if (v_blurRadius == 0 && h_blurRadius == 0)
743	flags &= ~blurNeeded;	1017	flags &= ~blurNeeded;
744	else	1018	else
745	flags |= blurNeeded;	1019	flags |= blurNeeded;
746		1020
		1021	#if XFT
		1022	XFilters *filters = XRenderQueryFilters (target->dpy, target->display->root);
		1023	if (filters)
		1024	{
		1025	for (int i = 0; i < filters->nfilter; i++)
		1026	if (!strcmp (filters->filter[i], FilterConvolution))
		1027	flags |= bgPixmap_t::blurServerSide;
		1028
		1029	XFree (filters);
		1030	}
		1031	#endif
		1032
747	return (changed>0);	1033	return (changed > 0);
748	}	1034	}
749		1035
750	static inline unsigned long	1036	static inline unsigned long
751	compute_tint_shade_flags (rxvt_color *tint, int shade)	1037	compute_tint_shade_flags (rxvt_color *tint, int shade)
752	{	1038	{
753	unsigned long flags = 0;	1039	unsigned long flags = 0;
754	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	1040	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
755	bool has_shade = (shade > 0 && shade < 100) || (shade > 100 && shade < 200);	1041	bool has_shade = shade != 100;
756		1042
757	if (tint)	1043	if (tint)
758	{	1044	{
759	tint->get (c);	1045	tint->get (c);
760	# define IS_COMPONENT_WHOLESOME(cmp) ((cmp) <= 0x000700 || (cmp) >= 0x00f700)	1046	# define IS_COMPONENT_WHOLESOME(cmp) ((cmp) <= 0x000700 || (cmp) >= 0x00f700)
…		…
769	flags |= bgPixmap_t::tintNeeded;	1055	flags |= bgPixmap_t::tintNeeded;
770	else if (tint)	1056	else if (tint)
771	{	1057	{
772	if ((c.r > 0x000700 || c.g > 0x000700 || c.b > 0x000700)	1058	if ((c.r > 0x000700 || c.g > 0x000700 || c.b > 0x000700)
773	&& (c.r < 0x00f700 || c.g < 0x00f700 || c.b < 0x00f700))	1059	&& (c.r < 0x00f700 || c.g < 0x00f700 || c.b < 0x00f700))
774	{	1060	{
775	flags |= bgPixmap_t::tintNeeded;	1061	flags |= bgPixmap_t::tintNeeded;
776	}	1062	}
777	}	1063	}
778		1064
779	if (flags & bgPixmap_t::tintNeeded)	1065	if (flags & bgPixmap_t::tintNeeded)
780	{	1066	{
781	if (flags & bgPixmap_t::tintWholesome)	1067	if (flags & bgPixmap_t::tintWholesome)
…		…
792	}	1078	}
793		1079
794	bool	1080	bool
795	bgPixmap_t::set_tint (rxvt_color &new_tint)	1081	bgPixmap_t::set_tint (rxvt_color &new_tint)
796	{	1082	{
797	if (tint != new_tint)	1083	if (!(flags & tintSet) || tint != new_tint)
798	{	1084	{
799	unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);	1085	unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
800	tint = new_tint;	1086	tint = new_tint;
801	flags = (flags & ~tintFlags) | new_flags | tintSet;	1087	flags = (flags & ~tintFlags) | new_flags | tintSet;
802	return true;	1088	return true;
…		…
810	{	1096	{
811	unsigned long new_flags = compute_tint_shade_flags (NULL, shade);	1097	unsigned long new_flags = compute_tint_shade_flags (NULL, shade);
812		1098
813	if (new_flags != (flags & tintFlags))	1099	if (new_flags != (flags & tintFlags))
814	{	1100	{
815	flags = (flags&~tintFlags)|new_flags;	1101	flags = (flags & ~tintFlags) | new_flags;
816	return true;	1102	return true;
817	}	1103	}
818		1104
819	return false;	1105	return false;
820	}	1106	}
821		1107
822	bool	1108	bool
823	bgPixmap_t::set_shade (const char *shade_str)	1109	bgPixmap_t::set_shade (const char *shade_str)
824	{	1110	{
825	int new_shade = (shade_str) ? atoi (shade_str) : 0;	1111	int new_shade = (shade_str) ? atoi (shade_str) : 100;
826		1112
827	if (new_shade < 0 && new_shade > -100)	1113	clamp_it (new_shade, -100, 200);
		1114	if (new_shade < 0)
828	new_shade = 200 - (100 + new_shade);	1115	new_shade = 200 - (100 + new_shade);
829	else if (new_shade == 100)
830	new_shade = 0;
831		1116
832	if (new_shade != shade)	1117	if (new_shade != shade)
833	{	1118	{
834	unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);	1119	unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
835	shade = new_shade;	1120	shade = new_shade;
836	flags = (flags & (~tintFlags | tintSet)) | new_flags;	1121	flags = (flags & (~tintFlags | tintSet)) | new_flags;
837	return true;	1122	return true;
838	}	1123	}
839		1124
840	return false;	1125	return false;
		1126	}
		1127
		1128	static void
		1129	get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params)
		1130	{
		1131	double sigma = radius / 2.0;
		1132	double scale = sqrt (2.0 * M_PI) * sigma;
		1133	double sum = 0.0;
		1134
		1135	for (int i = 0; i < width; i++)
		1136	{
		1137	double x = i - width / 2;
		1138	kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;
		1139	sum += kernel[i];
		1140	}
		1141
		1142	params[0] = XDoubleToFixed (width);
		1143	params[1] = XDoubleToFixed (1);
		1144
		1145	for (int i = 0; i < width; i++)
		1146	params[i+2] = XDoubleToFixed (kernel[i] / sum);
		1147	}
		1148
		1149	bool
		1150	bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
		1151	{
		1152	bool ret = false;
		1153	#if XFT
		1154	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
		1155	double *kernel = (double *)malloc (size * sizeof (double));
		1156	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
		1157
		1158	Display *dpy = target->dpy;
		1159	XRenderPictureAttributes pa;
		1160	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, target->visual);
		1161
		1162	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);
		1163	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);
		1164
		1165	if (kernel && params && src && dst)
		1166	{
		1167	if (h_blurRadius)
		1168	{
		1169	size = h_blurRadius * 2 + 1;
		1170	get_gaussian_kernel (h_blurRadius, size, kernel, params);
		1171
		1172	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
		1173	XRenderComposite (dpy,
		1174	PictOpSrc,
		1175	src,
		1176	None,
		1177	dst,
		1178	0, 0,
		1179	0, 0,
		1180	0, 0,
		1181	width, height);
		1182	}
		1183
		1184	if (v_blurRadius)
		1185	{
		1186	size = v_blurRadius * 2 + 1;
		1187	get_gaussian_kernel (v_blurRadius, size, kernel, params);
		1188	swap (params[0], params[1]);
		1189
		1190	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
		1191	XRenderComposite (dpy,
		1192	PictOpSrc,
		1193	src,
		1194	None,
		1195	dst,
		1196	0, 0,
		1197	0, 0,
		1198	0, 0,
		1199	width, height);
		1200	}
		1201
		1202	ret = true;
		1203	}
		1204
		1205	free (kernel);
		1206	free (params);
		1207	XRenderFreePicture (dpy, src);
		1208	XRenderFreePicture (dpy, dst);
		1209	#endif
		1210	return ret;
		1211	}
		1212
		1213	bool
		1214	bgPixmap_t::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
		1215	{
		1216	Display *dpy = target->dpy;
		1217	bool ret = false;
		1218
		1219	if (flags & tintWholesome)
		1220	{
		1221	XGCValues gcv;
		1222	GC gc;
		1223
		1224	/* In this case we can tint image server-side getting significant
		1225	* performance improvements, as we eliminate XImage transfer
		1226	*/
		1227	gcv.foreground = Pixel (tint);
		1228	gcv.function = GXand;
		1229	gcv.fill_style = FillSolid;
		1230	gc = XCreateGC (dpy, pixmap, GCFillStyle | GCForeground | GCFunction, &gcv);
		1231	if (gc)
		1232	{
		1233	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
		1234	ret = true;
		1235	XFreeGC (dpy, gc);
		1236	}
		1237	}
		1238	else
		1239	{
		1240	# if XFT
		1241	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
		1242
		1243	if (flags & tintSet)
		1244	tint.get (c);
		1245
		1246	if (shade <= 100)
		1247	{
		1248	c.r = (c.r * shade) / 100;
		1249	c.g = (c.g * shade) / 100;
		1250	c.b = (c.b * shade) / 100;
		1251	}
		1252	else
		1253	{
		1254	c.r = ((0xffff - c.r) * (200 - shade)) / 100;
		1255	c.g = ((0xffff - c.g) * (200 - shade)) / 100;
		1256	c.b = ((0xffff - c.b) * (200 - shade)) / 100;
		1257	}
		1258
		1259	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
		1260	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		1261	XRenderPictureAttributes pa;
		1262
		1263	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);
		1264
		1265	pa.repeat = True;
		1266
		1267	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
		1268	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
		1269	XFreePixmap (dpy, overlay_pmap);
		1270
		1271	pa.component_alpha = True;
		1272	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
		1273	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
		1274	XFreePixmap (dpy, mask_pmap);
		1275
		1276	if (mask_pic && overlay_pic && back_pic)
		1277	{
		1278	XRenderColor mask_c;
		1279
		1280	memset (&mask_c, (shade > 100) ? 0xFF : 0x0, sizeof (mask_c));
		1281	mask_c.alpha = 0xffff;
		1282	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
		1283
		1284	mask_c.alpha = 0;
		1285	mask_c.red = 0xffff - c.r;
		1286	mask_c.green = 0xffff - c.g;
		1287	mask_c.blue = 0xffff - c.b;
		1288	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		1289	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
		1290	ret = true;
		1291	}
		1292
		1293	XRenderFreePicture (dpy, mask_pic);
		1294	XRenderFreePicture (dpy, overlay_pic);
		1295	XRenderFreePicture (dpy, back_pic);
		1296	# if DO_TIMING_TEST
		1297	XSync (dpy, False);
		1298	# endif
		1299	# endif
		1300	}
		1301
		1302	return ret;
841	}	1303	}
842		1304
843	/* make_transparency_pixmap()	1305	/* make_transparency_pixmap()
844	* Builds a pixmap sized the same as terminal window, with depth same as the root window	1306	* Builds a pixmap sized the same as terminal window, with depth same as the root window
845	* that pixmap contains tiled portion of the root pixmap that is supposed to be covered by	1307	* that pixmap contains tiled portion of the root pixmap that is supposed to be covered by
…		…
864	unsigned int root_pmap_width, root_pmap_height;	1326	unsigned int root_pmap_width, root_pmap_height;
865	int window_width = target->szHint.width;	1327	int window_width = target->szHint.width;
866	int window_height = target->szHint.height;	1328	int window_height = target->szHint.height;
867	int sx, sy;	1329	int sx, sy;
868	XGCValues gcv;	1330	XGCValues gcv;
		1331	GC gc;
869		1332
870	TIMING_TEST_START (tp);	1333	TIMING_TEST_START (tp);
871	target->get_window_origin (sx, sy);	1334	target->get_window_origin (sx, sy);
872		1335
873	/* check if we are outside of the visible part of the virtual screen : */	1336	/* check if we are outside of the visible part of the virtual screen : */
…		…
875	|| sx >= root_width || sy >= root_height)	1338	|| sx >= root_width || sy >= root_height)
876	return 0;	1339	return 0;
877		1340
878	if (root_pixmap != None)	1341	if (root_pixmap != None)
879	{	1342	{
880	/* we want to validate the pixmap and get it's size at the same time : */	1343	/* we want to validate the pixmap and get its size at the same time : */
881	int junk;	1344	int junk;
882	unsigned int ujunk;	1345	unsigned int ujunk;
883	/* root pixmap may be bad - allow a error */	1346	/* root pixmap may be bad - allow a error */
884	target->allowedxerror = -1;	1347	target->allowedxerror = -1;
885		1348
…		…
887	root_pixmap = None;	1350	root_pixmap = None;
888		1351
889	target->allowedxerror = 0;	1352	target->allowedxerror = 0;
890	}	1353	}
891		1354
		1355	if (root_pixmap == None)
		1356	return 0;
		1357
892	Pixmap tiled_root_pmap = XCreatePixmap (dpy, root, window_width, window_height, root_depth);	1358	Pixmap tiled_root_pmap = XCreatePixmap (dpy, root, window_width, window_height, root_depth);
893	GC gc = NULL;
894		1359
895	if (tiled_root_pmap == None) /* something really bad happened - abort */	1360	if (tiled_root_pmap == None) /* something really bad happened - abort */
896	return 0;	1361	return 0;
897		1362
898	if (root_pixmap == None)
899	{
900	/* use tricks to obtain the root background image :*/
901	/* we want to create Overrideredirect window overlapping out window
902	with background type of Parent Relative and then grab it */
903	XSetWindowAttributes attr;
904	Window src;
905	bool success = false;
906
907	attr.background_pixmap = ParentRelative;
908	attr.backing_store = Always;
909	attr.event_mask = ExposureMask;
910	attr.override_redirect = True;
911	src = XCreateWindow (dpy, root, sx, sy, window_width, window_height, 0,
912	CopyFromParent, CopyFromParent, CopyFromParent,
913	CWBackPixmap|CWBackingStore|CWOverrideRedirect|CWEventMask,
914	&attr);
915
916	if (src != None)
917	{
918	XEvent event;
919	int ev_count = 0;
920	XGrabServer (dpy);
921	XMapRaised (dpy, src);
922	XSync (dpy, False);
923
924	/* XSync should get window where it's properly exposed,
925	* but to be on the safe side - let's check for the actual event to arrive : */
926	while (XCheckWindowEvent (dpy, src, ExposureMask, &event))
927	++ev_count;
928
929	if (ev_count > 0);
930	{
931	/* hooray! - we can grab the image! */
932	gc = XCreateGC (dpy, root, 0, NULL);
933	if (gc)
934	{
935	XCopyArea (dpy, src, tiled_root_pmap, gc, 0, 0, window_width, window_height, 0, 0);
936	success = true;
937	}
938	}
939
940	XDestroyWindow (dpy, src);
941	XUngrabServer (dpy);
942	//fprintf (stderr, "%s:%d: ev_count = %d\n", __FUNCTION__, __LINE__, ev_count);
943	}
944
945	if (!success)
946	{
947	XFreePixmap (dpy, tiled_root_pmap);
948	tiled_root_pmap = None;
949	}
950	else
951	result |= transpPmapTiled;
952	}
953	else
954	{
955	/* straightforward pixmap copy */	1363	/* straightforward pixmap copy */
956	gcv.tile = root_pixmap;	1364	gcv.tile = root_pixmap;
957	gcv.fill_style = FillTiled;	1365	gcv.fill_style = FillTiled;
958		1366
959	while (sx < 0) sx += (int)root_width;	1367	while (sx < 0) sx += (int)root_width;
960	while (sy < 0) sy += (int)root_height;	1368	while (sy < 0) sy += (int)root_height;
961		1369
962	gcv.ts_x_origin = -sx;	1370	gcv.ts_x_origin = -sx;
963	gcv.ts_y_origin = -sy;	1371	gcv.ts_y_origin = -sy;
964	gc = XCreateGC (dpy, root, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	1372	gc = XCreateGC (dpy, root, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
965		1373
966	if (gc)	1374	if (gc)
967	{	1375	{
968	XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);	1376	XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);
969	result |= transpPmapTiled;	1377	result |= transpPmapTiled;
970	}	1378	XFreeGC (dpy, gc);
971	}	1379	}
972	TIMING_TEST_PRINT_RESULT (tp);	1380	TIMING_TEST_PRINT_RESULT (tp);
973		1381
974	if (tiled_root_pmap != None)	1382	if (tiled_root_pmap != None)
975	{	1383	{
976	if (!need_client_side_rendering ())	1384	if (!need_client_side_rendering ())
977	{	1385	{
		1386	if ((flags & blurNeeded))
		1387	{
		1388	if (blur_pixmap (tiled_root_pmap, DefaultVisual (dpy, target->display->screen), window_width, window_height))
		1389	result |= transpPmapBlurred;
		1390	}
978	if ((flags & tintNeeded))	1391	if ((flags & tintNeeded))
979	{	1392	{
980	if (flags & tintWholesome)	1393	if (tint_pixmap (tiled_root_pmap, DefaultVisual (dpy, target->display->screen), window_width, window_height))
981	{
982	/* In this case we can tint image server-side getting significant
983	* performance improvements, as we eliminate XImage transfer
984	*/
985	gcv.foreground = Pixel (tint);
986	gcv.function = GXand;
987	gcv.fill_style = FillSolid;
988	if (gc)
989	XChangeGC (dpy, gc, GCFillStyle | GCForeground | GCFunction, &gcv);
990	else
991	gc = XCreateGC (dpy, root, GCFillStyle | GCForeground | GCFunction, &gcv);
992	if (gc)
993	{
994	XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);
995	result |= transpPmapTinted;	1394	result |= transpPmapTinted;
996	}
997	}
998	else
999	{
1000	# if XFT
1001	Picture back_pic = 0;
1002	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1003
1004	if (flags & tintSet)
1005	tint.get (c);
1006
1007	if (shade > 0 && shade < 100)
1008	{
1009	c.r = (c.r * shade) / 100;
1010	c.g = (c.g * shade) / 100;
1011	c.b = (c.b * shade) / 100;
1012	}
1013	else if (shade > 100 && shade < 200)
1014	{
1015	c.r = (c.r * (200 - shade)) / 100;
1016	c.g = (c.g * (200 - shade)) / 100;
1017	c.b = (c.b * (200 - shade)) / 100;
1018	}
1019
1020	XRenderPictFormat pf;
1021	pf.type = PictTypeDirect;
1022	pf.depth = 32;
1023	pf.direct.redMask = 0xff;
1024	pf.direct.greenMask = 0xff;
1025	pf.direct.blueMask = 0xff;
1026	pf.direct.alphaMask = 0xff;
1027
1028	XRenderPictFormat *solid_format = XRenderFindFormat (dpy,
1029	(PictFormatType|
1030	PictFormatDepth|
1031	PictFormatRedMask|
1032	PictFormatGreenMask|
1033	PictFormatBlueMask|
1034	PictFormatAlphaMask),
1035	&pf,
1036	0);
1037	XRenderPictFormat *root_format = XRenderFindVisualFormat (dpy, DefaultVisualOfScreen (ScreenOfDisplay (dpy, target->display->screen)));
1038	XRenderPictureAttributes pa ;
1039
1040	back_pic = XRenderCreatePicture (dpy, tiled_root_pmap, root_format, 0, &pa);
1041
1042	pa.repeat = True;
1043
1044	Pixmap overlay_pmap = XCreatePixmap (dpy, root, 1, 1, 32);
1045	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1046	XFreePixmap (dpy, overlay_pmap);
1047
1048	pa.component_alpha = True;
1049	Pixmap mask_pmap = XCreatePixmap (dpy, root, 1, 1, 32);
1050	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
1051	XFreePixmap (dpy, mask_pmap);
1052
1053	if (mask_pic && overlay_pic && back_pic)
1054	{
1055	XRenderColor mask_c;
1056
1057	memset (&mask_c, (shade > 100) ? 0xFF : 0x0, sizeof (mask_c));
1058	mask_c.alpha = 0xffff;
1059	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1060
1061	mask_c.alpha = 0;
1062	mask_c.red = 0xffff - c.r;
1063	mask_c.green = 0xffff - c.g;
1064	mask_c.blue = 0xffff - c.b;
1065	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1066	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, window_width, window_height);
1067	result |= transpPmapTinted;
1068	}
1069
1070	XRenderFreePicture (dpy, mask_pic);
1071	XRenderFreePicture (dpy, overlay_pic);
1072	XRenderFreePicture (dpy, back_pic);
1073	# if DO_TIMING_TEST
1074	XSync (dpy, False);
1075	# endif
1076	# endif
1077	}
1078	}	1395	}
1079	} /* server side rendering completed */	1396	} /* server side rendering completed */
1080		1397
1081	if (pixmap)	1398	if (pixmap)
1082	XFreePixmap (dpy, pixmap);	1399	XFreePixmap (dpy, pixmap);
1083		1400
1084	pixmap = tiled_root_pmap;	1401	pixmap = tiled_root_pmap;
1085	pmap_width = window_width;	1402	pmap_width = window_width;
1086	pmap_height = window_height;	1403	pmap_height = window_height;
1087	pmap_depth = root_depth;	1404	pmap_depth = root_depth;
1088	}	1405	}
1089
1090	if (gc)
1091	XFreeGC (dpy, gc);
1092		1406
1093	TIMING_TEST_PRINT_RESULT (tp);	1407	TIMING_TEST_PRINT_RESULT (tp);
1094		1408
1095	return result;	1409	return result;
1096	}	1410	}
…		…
1133	/* we need to re-generate transparency pixmap in that case ! */	1447	/* we need to re-generate transparency pixmap in that case ! */
1134	background_flags = make_transparency_pixmap ();	1448	background_flags = make_transparency_pixmap ();
1135	if (background_flags == 0)	1449	if (background_flags == 0)
1136	return false;	1450	return false;
1137	else if ((background_flags & transpTransformations) == (flags & transpTransformations)	1451	else if ((background_flags & transpTransformations) == (flags & transpTransformations)
1138	&& pmap_depth == target->depth)	1452	&& pmap_depth == target->depth)
1139	flags = flags & ~isInvalid;	1453	flags = flags & ~isInvalid;
1140	}	1454	}
1141	# endif	1455	# endif
1142		1456
		1457	# ifdef BG_IMAGE_FROM_FILE
		1458	if (have_image
		1459	|| (background_flags & transpTransformations) != (flags & transpTransformations))
		1460	{
		1461	if (render_image (background_flags))
		1462	flags = flags & ~isInvalid;
		1463	}
		1464	# endif
		1465
1143	XImage *result = NULL;	1466	XImage *result = NULL;
1144	# ifdef HAVE_AFTERIMAGE	1467
1145	if (original_asim	1468	if (background_flags && (flags & isInvalid))
1146	|| (background_flags & transpTransformations) != (flags & transpTransformations))	1469	{
		1470	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1147	{	1471	}
1148	target->init_asv ();
1149		1472
1150	ASImage *background = NULL;	1473	if (result)
1151	ARGB32 as_tint = TINT_LEAVE_SAME;	1474	{
1152	if (background_flags)	1475	# if !defined(HAVE_AFTERIMAGE) && !XFT
1153	background = pixmap2ximage (target->asv, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, 100);	1476	/* our own client-side tinting */
1154		1477	/* ATTENTION: We ASSUME that XFT will let us do all the tinting necessary server-side.
1155	# ifdef ENABLE_TRANSPARENCY	1478	This may need to be changed in need_client_side_rendering() logic is altered !!! */
1156	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))	1479	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1157	{
1158	ShadingInfo as_shade;
1159	as_shade.shading = (shade == 0) ? 100 : shade;
1160
1161	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1162	if (flags & tintSet)
1163	tint.get (c);
1164	as_shade.tintColor.red = c.r;
1165	as_shade.tintColor.green = c.g;
1166	as_shade.tintColor.blue = c.b;
1167
1168	as_tint = shading2tint32 (&as_shade);
1169	}
1170
1171	if (!(background_flags & transpPmapBlured) && (flags & blurNeeded) && background != NULL)
1172	{
1173	ASImage *tmp = blur_asimage_gauss (target->asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
1174	(original_asim == NULL || tint == TINT_LEAVE_SAME)?ASA_XImage:ASA_ASImage,
1175	100, ASIMAGE_QUALITY_DEFAULT);
1176	if (tmp)
1177	{
1178	destroy_asimage (&background);
1179	background = tmp;
1180	}
1181	}
1182	# endif
1183
1184	if (render_asim (background, as_tint))
1185	flags = flags & ~isInvalid;
1186	if (background)
1187	destroy_asimage (&background);
1188	}
1189	else if (background_flags && pmap_depth != target->depth)
1190	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1191
1192	# elif !XFT /* our own client-side tinting */
1193
1194	/* ATTENTION: We ASSUME that XFT will let us do all the tinting necessary server-side.
1195	This may need to be changed in need_client_side_rendering() logic is altered !!! */
1196
1197	if (background_flags && (flags & isInvalid))
1198	{
1199	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1200
1201	if (result != NULL && !(background_flags & transpPmapTinted) && (flags & tintNeeded))
1202	{	1480	{
1203	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	1481	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1204	if (flags & tintSet)	1482	if (flags & tintSet)
1205	tint.get (c);	1483	tint.get (c);
1206	ShadeXImage (target, result, shade, c.r, c.g, c.b);	1484	ShadeXImage (target, result, shade, c.r, c.g, c.b);
1207	}	1485	}
1208	}	1486	# endif
1209	# endif /* HAVE_AFTERIMAGE */
1210		1487
1211	if (result)
1212	{
1213	GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);	1488	GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1214		1489
1215	if (gc)	1490	if (gc)
1216	{	1491	{
1217	if (/*pmap_depth != target->depth &&*/ pixmap != None)	1492	if (/*pmap_depth != target->depth &&*/ pixmap != None)
…		…
1246		1521
1247	XFreeGC (target->dpy, gc);	1522	XFreeGC (target->dpy, gc);
1248	flags = flags & ~isInvalid;	1523	flags = flags & ~isInvalid;
1249	}	1524	}
1250		1525
1251	XDestroyImage (result);	1526	XDestroyImage (result);
1252	}	1527	}
1253		1528
1254	if (flags & isInvalid)	1529	if (flags & isInvalid)
1255	{	1530	{
1256	if (pixmap != None)	1531	if (pixmap != None)
…		…
1361	int i;	1636	int i;
1362		1637
1363	Visual *visual = term->visual;	1638	Visual *visual = term->visual;
1364		1639
1365	if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return ;	1640	if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return ;
1366
1367	if (shade == 0)
1368	shade = 100;
1369		1641
1370	/* for convenience */	1642	/* for convenience */
1371	mask_r = visual->red_mask;	1643	mask_r = visual->red_mask;
1372	mask_g = visual->green_mask;	1644	mask_g = visual->green_mask;
1373	mask_b = visual->blue_mask;	1645	mask_b = visual->blue_mask;
…		…
1429	default:	1701	default:
1430	return; /* we do not support this color depth */	1702	return; /* we do not support this color depth */
1431	}	1703	}
1432		1704
1433	/* prepare limits for color transformation (each channel is handled separately) */	1705	/* prepare limits for color transformation (each channel is handled separately) */
1434	if (shade < 0) {	1706	if (shade > 100) {
1435	shade = -shade;	1707	shade = 200 - shade;
1436	if (shade < 0) shade = 0;
1437	if (shade > 100) shade = 100;
1438		1708
1439	lower_lim_r = 65535-rm;	1709	lower_lim_r = 65535-rm;
1440	lower_lim_g = 65535-gm;	1710	lower_lim_g = 65535-gm;
1441	lower_lim_b = 65535-bm;	1711	lower_lim_b = 65535-bm;
1442		1712
…		…
1444	lower_lim_g = 65535-(unsigned int)(((RUINT32T)lower_lim_g)*((RUINT32T)shade)/100);	1714	lower_lim_g = 65535-(unsigned int)(((RUINT32T)lower_lim_g)*((RUINT32T)shade)/100);
1445	lower_lim_b = 65535-(unsigned int)(((RUINT32T)lower_lim_b)*((RUINT32T)shade)/100);	1715	lower_lim_b = 65535-(unsigned int)(((RUINT32T)lower_lim_b)*((RUINT32T)shade)/100);
1446		1716
1447	upper_lim_r = upper_lim_g = upper_lim_b = 65535;	1717	upper_lim_r = upper_lim_g = upper_lim_b = 65535;
1448	} else {	1718	} else {
1449	if (shade < 0) shade = 0;
1450	if (shade > 100) shade = 100;
1451		1719
1452	lower_lim_r = lower_lim_g = lower_lim_b = 0;	1720	lower_lim_r = lower_lim_g = lower_lim_b = 0;
1453		1721
1454	upper_lim_r = (unsigned int)((((RUINT32T)rm)*((RUINT32T)shade))/100);	1722	upper_lim_r = (unsigned int)((((RUINT32T)rm)*((RUINT32T)shade))/100);
1455	upper_lim_g = (unsigned int)((((RUINT32T)gm)*((RUINT32T)shade))/100);	1723	upper_lim_g = (unsigned int)((((RUINT32T)gm)*((RUINT32T)shade))/100);

Diff Legend

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