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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.85 by sf-exg, Mon Oct 18 08:19:03 2010 UTC vs.
Revision 1.121 by sf-exg, Fri Nov 19 23:29:30 2010 UTC

…		…
24		24
25	#include <cmath>	25	#include <cmath>
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
		30	# include <X11/extensions/Xrender.h>
		31	#endif
		32
		33	#ifndef FilterConvolution
		34	#define FilterConvolution "convolution"
		35	#endif
		36
29	#define DO_TIMING_TEST 0	37	#define DO_TIMING_TEST 0
30		38
31	#if DO_TIMING_TEST	39	#if DO_TIMING_TEST
32	# include <sys/time.h>	40	# include <sys/time.h>
33	#define TIMING_TEST_START(id) \	41	#define TIMING_TEST_START(id) \
…		…
58	*	66	*
59	* WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.	67	* WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
60	* W and H are percentages of the terminal window size.	68	* W and H are percentages of the terminal window size.
61	* X and Y are also percentages; e.g., +50+50 centers	69	* X and Y are also percentages; e.g., +50+50 centers
62	* the image in the window.	70	* the image in the window.
63	* WxH+X Assumes Y == X
64	* WxH Assumes Y == X == 50 (centers the image)
65	* W+X+Y Assumes H == W
66	* W+X Assumes H == W and Y == X
67	* W Assumes H == W and Y == X == 50
68	*
69	* Adjusting position only :
70	* =+X+Y Set position to X% by Y% (absolute).
71	* =+X Set position to X% by X%.
72	* +X+Y Adjust position horizontally X% and vertically Y%
73	* from current position (relative).
74	* +X Adjust position horizontally X% and vertically X%
75	* from current position.
76	*
77	* Adjusting scale only :
78	* Wx0 Multiply horizontal scaling factor by W%
79	* 0xH Multiply vertical scaling factor by H%
80	* 0x0 No scaling (show image at normal size).
81	*	71	*
82	* Pixmap Operations : (should be prepended by a colon)	72	* Pixmap Operations : (should be prepended by a colon)
83	* tile Tile image. Scaling/position modifiers above will affect	73	* tile Tile image. Scaling/position modifiers above will affect
84	* the tile size and origin.	74	* the tile size and origin.
85	* propscale When scaling, scale proportionally. That is, maintain the	75	* propscale When scaling, scale proportionally. That is, maintain the
…		…
113	#endif	103	#endif
114	flags = 0;	104	flags = 0;
115	pixmap = None;	105	pixmap = None;
116	valid_since = invalid_since = 0;	106	valid_since = invalid_since = 0;
117	target = 0;	107	target = 0;
		108	target_x = target_y = 0;
118	}	109	}
119		110
120	void	111	void
121	bgPixmap_t::destroy ()	112	bgPixmap_t::destroy ()
122	{	113	{
…		…
133	if (pixmap && target)	124	if (pixmap && target)
134	XFreePixmap (target->dpy, pixmap);	125	XFreePixmap (target->dpy, pixmap);
135	}	126	}
136		127
137	bool	128	bool
		129	bgPixmap_t::set_position (int x, int y)
		130	{
		131
		132	if (target_x != x
		133	\|\| target_y != y)
		134	{
		135	target_x = x;
		136	target_y = y;
		137	return true;
		138	}
		139	return false;
		140	}
		141
		142	bool
138	bgPixmap_t::window_size_sensitive ()	143	bgPixmap_t::window_size_sensitive ()
139	{	144	{
140	# ifdef ENABLE_TRANSPARENCY	145	# ifdef ENABLE_TRANSPARENCY
141	if (flags & isTransparent)	146	if (flags & isTransparent)
142	return true;	147	return true;
…		…
168	return true;	173	return true;
169	}	174	}
170	# endif	175	# endif
171		176
172	return false;	177	return false;
173	};	178	}
174		179
175	bool bgPixmap_t::need_client_side_rendering ()	180	bool bgPixmap_t::need_client_side_rendering ()
176	{	181	{
177	# ifdef HAVE_AFTERIMAGE	182	# ifdef HAVE_AFTERIMAGE
178	if (original_asim)	183	if (original_asim)
…		…
222	int diff = window_size - image_size;	227	int diff = window_size - image_size;
223	int smaller = min (image_size, window_size);	228	int smaller = min (image_size, window_size);
224		229
225	if (align >= 0 && align <= 100)	230	if (align >= 0 && align <= 100)
226	return diff * align / 100;	231	return diff * align / 100;
227	else if (align > 100 && align <= 200 )	232	else if (align > 100 && align <= 200)
228	return ((align - 100) * smaller / 100) + window_size - smaller;	233	return ((align - 100) * smaller / 100) + window_size - smaller;
229	else if (align >= -100 && align < 0)	234	else if (align >= -100 && align < 0)
230	return ((align + 100) * smaller / 100) - image_size;	235	return ((align + 100) * smaller / 100) - image_size;
231	return 0;	236	return 0;
232	}	237	}
…		…
248	dst_size = target_size - dst_pos;	253	dst_size = target_size - dst_pos;
249	return src_pos;	254	return src_pos;
250	}	255	}
251		256
252	bool	257	bool
253	bgPixmap_t::set_geometry (const char *geom)	258	bgPixmap_t::set_geometry (const char *geom, bool update)
254	{	259	{
		260	bool changed = false;
255	int geom_flags = 0, changed = 0;	261	int geom_flags = 0;
256	int x = 0, y = 0;	262	int x = 0, y = 0;
257	unsigned int w = 0, h = 0;	263	unsigned int w = 0, h = 0;
258	unsigned int n;	264	unsigned int n;
259	unsigned long new_flags = (flags & (~geometryFlags));	265	unsigned long new_flags = (flags & (~geometryFlags));
260	const char *p;	266	const char *ops;
261	# define MAXLEN_GEOM 256 /* could be longer than regular geometry string */	267	# define MAXLEN_GEOM 256 /* could be longer than regular geometry string */
262		268
263	if (geom == NULL)	269	if (geom == NULL)
264	return false;	270	return false;
265		271
266	char str[MAXLEN_GEOM];	272	char str[MAXLEN_GEOM];
267		273
268	while (isspace(*geom)) ++geom;
269	if ((p = strchr (geom, ';')) == NULL)
270	p = strchr (geom, '\0');	274	ops = strchr (geom, ':');
271		275	if (ops == NULL)
		276	n = strlen (geom);
		277	else
272	n = (p - geom);	278	n = ops - geom;
		279
273	if (n < MAXLEN_GEOM)	280	if (n < MAXLEN_GEOM)
274	{	281	{
275	char *ops;
276	new_flags \|= geometrySet;
277
278	memcpy (str, geom, n);	282	memcpy (str, geom, n);
279	str[n] = '\0';	283	str[n] = '\0';
		284	rxvt_strtrim (str);
		285
280	if (str[0] == ':')	286	if (str[0])
281	ops = &str[0];
282	else if (str[0] != 'x' && str[0] != 'X' && isalpha(str[0]))
283	ops = &str[0];
284	else
285	{
286	char *tmp;
287	ops = strchr (str, ':');
288	if (ops != NULL)
289	{
290	for (tmp = ops-1; tmp >= str && isspace(*tmp); --tmp);
291	*(++tmp) = '\0';
292	if (ops == tmp) ++ops;
293	}
294	}
295
296	if (ops > str \|\| ops == NULL)
297	{	287	{
298	/* we have geometry string - let's handle it prior to applying ops */	288	/* we have geometry string - let's handle it prior to applying ops */
299	geom_flags = XParseGeometry (str, &x, &y, &w, &h);	289	geom_flags = XParseGeometry (str, &x, &y, &w, &h);
300
301	if ((geom_flags & XValue) && !(geom_flags & YValue))
302	{
303	y = x;
304	geom_flags \|= YValue;
305	}
306
307	if (flags & geometrySet)
308	{
309	/* new geometry is an adjustment to the old one ! */
310	if ((geom_flags & WidthValue) && (geom_flags & HeightValue))
311	{
312	if (w == 0 && h != 0)
313	{
314	w = h_scale;
315	h = (v_scale * h) / 100;
316	}
317	else if (h == 0 && w != 0)
318	{
319	w = (h_scale * w) / 100;
320	h = v_scale;
321	}
322	}
323	if (geom_flags & XValue)
324	{
325	if (str[0] != '=')
326	{
327	y += v_align;
328	x += h_align;
329	}
330	}
331	}
332	else /* setting up geometry from scratch */
333	{
334	if (!(geom_flags & XValue))
335	{
336	/* use default geometry - centered */
337	x = y = defaultAlign;
338	}
339	else if (!(geom_flags & YValue))
340	y = x;
341
342	if ((geom_flags & (WidthValue\|HeightValue)) == 0)
343	{
344	/* use default geometry - scaled */
345	w = h = defaultScale;
346	}
347	else if (geom_flags & WidthValue)
348	{
349	if (!(geom_flags & HeightValue))
350	h = w;
351	}
352	else
353	w = h;
354	}
355	} /* done parsing geometry string */	290	} /* done parsing geometry string */
356	else if (!(flags & geometrySet))	291
		292	if (!update)
357	{	293	{
358	/* default geometry - scaled and centered */	294	if (!(geom_flags & XValue))
359	x = y = defaultAlign;	295	x = y = defaultAlign;
		296	else if (!(geom_flags & YValue))
		297	y = x;
		298
		299	if (!(geom_flags & (WidthValue\|HeightValue)))
360	w = h = defaultScale;	300	w = h = defaultScale;
361	}	301	else if (!(geom_flags & HeightValue))
		302	h = w;
		303	else if (!(geom_flags & WidthValue))
		304	w = h;
362		305
363	if (!(flags & geometrySet))
364	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;	306	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
		307	}
365		308
366	if (ops)	309	if (ops)
367	{	310	{
368	while (*ops)	311	while (*ops)
369	{	312	{
…		…
416		359
417	while (ops != ':' && ops != '\0') ++ops;	360	while (ops != ':' && ops != '\0') ++ops;
418	} /* done parsing ops */	361	} /* done parsing ops */
419	}	362	}
420		363
421	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) ++changed;	364	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
422	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) ++changed;	365	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
423	if (check_set_align_value (geom_flags, XValue, h_align, x)) ++changed;	366	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
424	if (check_set_align_value (geom_flags, YValue, v_align, y)) ++changed;	367	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
425	}	368	}
426		369
427	if (new_flags != flags)	370	if (new_flags != flags)
428	{	371	{
429	flags = new_flags;	372	flags = new_flags;
430	changed++;	373	changed = true;
431	}	374	}
432		375
433	//fprintf (stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
434	// flags, h_scale, v_scale, h_align, v_align);
435	return (changed > 0);	376	return changed;
436	}	377	}
437		378
438	void	379	void
439	bgPixmap_t::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)	380	bgPixmap_t::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
440	{	381	{
…		…
457	if (!w) w = image_width;	398	if (!w) w = image_width;
458	if (!h) h = image_height;	399	if (!h) h = image_height;
459		400
460	if (flags & rootAlign)	401	if (flags & rootAlign)
461	{	402	{
462	target->get_window_origin (x, y);
463	x = -x;	403	x = -target_x;
464	y = -y;	404	y = -target_y;
465	}	405	}
466	else	406	else
467	{	407	{
468	x = make_align_position (h_align, target_width, w);	408	x = make_align_position (h_align, target_width, w);
469	y = make_align_position (v_align, target_height, h);	409	y = make_align_position (v_align, target_height, h);
…		…
529		469
530	int x = 0;	470	int x = 0;
531	int y = 0;	471	int y = 0;
532	int w = 0;	472	int w = 0;
533	int h = 0;	473	int h = 0;
534
535	TIMING_TEST_START (asim);
536		474
537	if (original_asim)	475	if (original_asim)
538	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);	476	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
539		477
540	if (!original_asim	478	if (!original_asim
…		…
657	}	595	}
658		596
659	free (layers);	597	free (layers);
660	}	598	}
661	}	599	}
662	TIMING_TEST_PRINT_RESULT (asim);
663		600
664	bool ret = false;	601	bool ret = false;
665		602
666	if (result)	603	if (result)
667	{	604	{
668	XGCValues gcv;	605	XGCValues gcv;
669	GC gc;	606	GC gc;
670		607
671	if (pixmap)
672	{
673	if (pmap_width != new_pmap_width
674	\|\| pmap_height != new_pmap_height
675	\|\| pmap_depth != target->depth)
676	{
677	XFreePixmap (target->dpy, pixmap);
678	pixmap = None;
679	}
680	}
681
682	/* create Pixmap */	608	/* create Pixmap */
683	if (pixmap == None)	609	if (pixmap == None
		610	\|\| pmap_width != new_pmap_width
		611	\|\| pmap_height != new_pmap_height
		612	\|\| pmap_depth != target->depth)
684	{	613	{
		614	if (pixmap)
		615	XFreePixmap (target->dpy, pixmap);
685	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);	616	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
686	pmap_width = new_pmap_width;	617	pmap_width = new_pmap_width;
687	pmap_height = new_pmap_height;	618	pmap_height = new_pmap_height;
688	pmap_depth = target->depth;	619	pmap_depth = target->depth;
689	}	620	}
…		…
713		644
714	if (result != background && result != original_asim)	645	if (result != background && result != original_asim)
715	destroy_asimage (&result);	646	destroy_asimage (&result);
716		647
717	XFreeGC (target->dpy, gc);	648	XFreeGC (target->dpy, gc);
718	TIMING_TEST_PRINT_RESULT (asim);
719		649
720	ret = true;	650	ret = true;
721	}	651	}
722		652
723	if (background)	653	if (background)
…		…
735	return false;	665	return false;
736		666
737	if (!pixbuf)	667	if (!pixbuf)
738	return false;	668	return false;
739		669
740	#if !XFT
741	if (background_flags)	670	if (background_flags
		671	&& !(flags & HAS_RENDER))
742	return false;	672	return false;
743	#endif
744		673
745	GdkPixbuf *result;	674	GdkPixbuf *result;
746		675
747	int image_width = gdk_pixbuf_get_width (pixbuf);	676	int image_width = gdk_pixbuf_get_width (pixbuf);
748	int image_height = gdk_pixbuf_get_height (pixbuf);	677	int image_height = gdk_pixbuf_get_height (pixbuf);
…		…
799	new_pmap_width = min (image_width, target_width);	728	new_pmap_width = min (image_width, target_width);
800	new_pmap_height = min (image_height, target_height);	729	new_pmap_height = min (image_height, target_height);
801	}	730	}
802	}	731	}
803		732
804	if (pixmap)
805	{
806	if (pmap_width != new_pmap_width
807	\|\| pmap_height != new_pmap_height
808	\|\| pmap_depth != target->depth)
809	{
810	XFreePixmap (target->dpy, pixmap);
811	pixmap = None;
812	}
813	}
814
815	if (pixmap == None)	733	if (pixmap == None
		734	\|\| pmap_width != new_pmap_width
		735	\|\| pmap_height != new_pmap_height
		736	\|\| pmap_depth != target->depth)
816	{	737	{
		738	if (pixmap)
		739	XFreePixmap (target->dpy, pixmap);
817	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);	740	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
818	pmap_width = new_pmap_width;	741	pmap_width = new_pmap_width;
819	pmap_height = new_pmap_height;	742	pmap_height = new_pmap_height;
820	pmap_depth = target->depth;	743	pmap_depth = target->depth;
821	}	744	}
…		…
862	dst_width, dst_height,	785	dst_width, dst_height,
863	XLIB_RGB_DITHER_NONE,	786	XLIB_RGB_DITHER_NONE,
864	0, 0);	787	0, 0);
865	}	788	}
866		789
867	#if XFT	790	#if XRENDER
868	if (background_flags)	791	if (background_flags)
869	{	792	{
870	Display *dpy = target->dpy;	793	Display *dpy = target->dpy;
871	XRenderPictureAttributes pa;	794	XRenderPictureAttributes pa;
872		795
873	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, target->display->screen));	796	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, target->visual);
874	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	797	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);
875		798
876	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);	799	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
877	Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa);	800	Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa);
878		801
…		…
915	# endif /* HAVE_PIXBUF */	838	# endif /* HAVE_PIXBUF */
916		839
917	bool	840	bool
918	bgPixmap_t::set_file (const char *file)	841	bgPixmap_t::set_file (const char *file)
919	{	842	{
920	assert (file);	843	if (!file \|\| !*file)
		844	return false;
921		845
922	if (*file)
923	{
924	if (const char *p = strchr (file, ';'))	846	if (const char *p = strchr (file, ';'))
925	{	847	{
926	size_t len = p - file;	848	size_t len = p - file;
927	char *f = rxvt_temp_buf<char> (len + 1);	849	char *f = rxvt_temp_buf<char> (len + 1);
928	memcpy (f, file, len);	850	memcpy (f, file, len);
929	f[len] = '\0';	851	f[len] = '\0';
930	file = f;	852	file = f;
931	}	853	}
932		854
933	# ifdef HAVE_AFTERIMAGE	855	# ifdef HAVE_AFTERIMAGE
934	if (!target->asimman)	856	if (!target->asimman)
935	target->asimman = create_generic_imageman (target->rs[Rs_path]);	857	target->asimman = create_generic_imageman (target->rs[Rs_path]);
936	ASImage *image = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);	858	ASImage *image = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);
937	if (image)	859	if (image)
938	{	860	{
939	if (original_asim)	861	if (original_asim)
940	safe_asimage_destroy (original_asim);	862	safe_asimage_destroy (original_asim);
941	original_asim = image;	863	original_asim = image;
942	have_image = true;	864	have_image = true;
943	return true;	865	return true;
944	}	866	}
945	# endif	867	# endif
946		868
947	# ifdef HAVE_PIXBUF	869	# ifdef HAVE_PIXBUF
948	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	870	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
949	if (image)	871	if (image)
950	{	872	{
951	if (pixbuf)	873	if (pixbuf)
952	g_object_unref (pixbuf);	874	g_object_unref (pixbuf);
953	pixbuf = image;	875	pixbuf = image;
954	have_image = true;	876	have_image = true;
955	return true;	877	return true;
956	}	878	}
957	# endif	879	# endif
958	}
959		880
960	return false;	881	return false;
961	}	882	}
962		883
963	# endif /* BG_IMAGE_FROM_FILE */	884	# endif /* BG_IMAGE_FROM_FILE */
…		…
976	}	897	}
977		898
978	bool	899	bool
979	bgPixmap_t::set_blur_radius (const char *geom)	900	bgPixmap_t::set_blur_radius (const char *geom)
980	{	901	{
981	int changed = 0;	902	bool changed = false;
982	unsigned int hr, vr;	903	unsigned int hr, vr;
983	int junk;	904	int junk;
984	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);	905	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
985		906
986	if (!(geom_flags & WidthValue))	907	if (!(geom_flags & WidthValue))
…		…
991	min_it (hr, 128);	912	min_it (hr, 128);
992	min_it (vr, 128);	913	min_it (vr, 128);
993		914
994	if (h_blurRadius != hr)	915	if (h_blurRadius != hr)
995	{	916	{
996	++changed;	917	changed = true;
997	h_blurRadius = hr;	918	h_blurRadius = hr;
998	}	919	}
999		920
1000	if (v_blurRadius != vr)	921	if (v_blurRadius != vr)
1001	{	922	{
1002	++changed;	923	changed = true;
1003	v_blurRadius = vr;	924	v_blurRadius = vr;
1004	}	925	}
1005		926
1006	if (v_blurRadius == 0 && h_blurRadius == 0)	927	if (v_blurRadius == 0 && h_blurRadius == 0)
1007	flags &= ~blurNeeded;	928	flags &= ~blurNeeded;
1008	else	929	else
1009	flags \|= blurNeeded;	930	flags \|= blurNeeded;
1010		931
1011	#if XFT
1012	XFilters *filters = XRenderQueryFilters (target->dpy, target->display->root);
1013	if (filters)
1014	{
1015	for (int i = 0; i < filters->nfilter; i++)
1016	if (!strcmp (filters->filter[i], FilterConvolution))
1017	flags \|= bgPixmap_t::blurServerSide;
1018
1019	XFree (filters);
1020	}
1021	#endif
1022
1023	return (changed > 0);	932	return changed;
1024	}	933	}
1025		934
1026	static inline unsigned long	935	static inline unsigned long
1027	compute_tint_shade_flags (rxvt_color *tint, int shade)	936	compute_tint_shade_flags (rxvt_color *tint, int shade)
1028	{	937	{
…		…
1050	{	959	{
1051	flags \|= bgPixmap_t::tintNeeded;	960	flags \|= bgPixmap_t::tintNeeded;
1052	}	961	}
1053	}	962	}
1054		963
1055	if (flags & bgPixmap_t::tintNeeded)
1056	{
1057	if (flags & bgPixmap_t::tintWholesome)
1058	flags \|= bgPixmap_t::tintServerSide;
1059	else
1060	{
1061	#if XFT
1062	flags \|= bgPixmap_t::tintServerSide;
1063	#endif
1064	}
1065	}
1066
1067	return flags;	964	return flags;
1068	}	965	}
1069		966
1070	bool	967	bool
1071	bgPixmap_t::set_tint (rxvt_color &new_tint)	968	bgPixmap_t::set_tint (rxvt_color &new_tint)
…		…
1113	}	1010	}
1114		1011
1115	return false;	1012	return false;
1116	}	1013	}
1117		1014
1118	#if XFT	1015	#if XRENDER
1119	static void	1016	static void
1120	get_gaussian_kernel (int radius, int width, double kernel, XFixed params)	1017	get_gaussian_kernel (int radius, int width, double kernel, XFixed params)
1121	{	1018	{
1122	double sigma = radius / 2.0;	1019	double sigma = radius / 2.0;
1123	double scale = sqrt (2.0 * M_PI) * sigma;	1020	double scale = sqrt (2.0 * M_PI) * sigma;
1124	double sum = 0.0;	1021	double sum = 0.0;
1125		1022
1126	for (int i = 0; i < width; i++)	1023	for (int i = 0; i < width; i++)
1127	{	1024	{
1128	double x = i - width / 2;	1025	double x = i - width / 2;
1129	kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;	1026	kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;
1130	sum += kernel[i];	1027	sum += kernel[i];
1131	}	1028	}
1132		1029
1133	params[0] = XDoubleToFixed (width);	1030	params[0] = XDoubleToFixed (width);
1134	params[1] = XDoubleToFixed (1);	1031	params[1] = XDoubleToFixed (1);
1135		1032
1136	for (int i = 0; i < width; i++)	1033	for (int i = 0; i < width; i++)
1137	params[i+2] = XDoubleToFixed (kernel[i] / sum);	1034	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1138	}	1035	}
1139	#endif	1036	#endif
1140		1037
1141	bool	1038	bool
1142	bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	1039	bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1143	{	1040	{
1144	bool ret = false;	1041	bool ret = false;
1145	#if XFT	1042	#if XRENDER
1146	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	1043	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1147	double kernel = (double )malloc (size * sizeof (double));	1044	double kernel = (double )malloc (size * sizeof (double));
1148	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	1045	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1149		1046
1150	Display *dpy = target->dpy;	1047	Display *dpy = target->dpy;
1151	XRenderPictureAttributes pa;	1048	XRenderPictureAttributes pa;
1152	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, target->visual);	1049	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1153		1050
1154	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1051	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);
1155	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1052	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);
1156		1053
1157	if (kernel && params && src && dst)	1054	if (kernel && params && src && dst)
…		…
1227	XFreeGC (dpy, gc);	1124	XFreeGC (dpy, gc);
1228	}	1125	}
1229	}	1126	}
1230	else	1127	else
1231	{	1128	{
1232	# if XFT	1129	# if XRENDER
1233	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	1130	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1234		1131
1235	if (flags & tintSet)	1132	if (flags & tintSet)
1236	tint.get (c);	1133	tint.get (c);
1237		1134
…		…
1267		1164
1268	if (mask_pic && overlay_pic && back_pic)	1165	if (mask_pic && overlay_pic && back_pic)
1269	{	1166	{
1270	XRenderColor mask_c;	1167	XRenderColor mask_c;
1271		1168
1272	memset (&mask_c, (shade > 100) ? 0xFF : 0x0, sizeof (mask_c));	1169	mask_c.red = mask_c.green = mask_c.blue = shade > 100 ? 0xffff : 0;
1273	mask_c.alpha = 0xffff;	1170	mask_c.alpha = 0xffff;
1274	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	1171	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1275		1172
1276	mask_c.alpha = 0;	1173	mask_c.alpha = 0;
1277	mask_c.red = 0xffff - c.r;	1174	mask_c.red = 0xffff - c.r;
…		…
1283	}	1180	}
1284		1181
1285	XRenderFreePicture (dpy, mask_pic);	1182	XRenderFreePicture (dpy, mask_pic);
1286	XRenderFreePicture (dpy, overlay_pic);	1183	XRenderFreePicture (dpy, overlay_pic);
1287	XRenderFreePicture (dpy, back_pic);	1184	XRenderFreePicture (dpy, back_pic);
1288	# if DO_TIMING_TEST
1289	XSync (dpy, False);
1290	# endif
1291	# endif	1185	# endif
1292	}	1186	}
1293		1187
1294	return ret;	1188	return ret;
1295	}	1189	}
1296		1190
1297	/* make_transparency_pixmap()	1191	/* make_transparency_pixmap()
1298	* Builds a pixmap sized the same as terminal window, with depth same as the root window	1192	* Builds a pixmap of the same size as the terminal window that contains
1299	* that pixmap contains tiled portion of the root pixmap that is supposed to be covered by	1193	* the tiled portion of the root pixmap that is supposed to be covered by
1300	* our window.	1194	* our window.
1301	*/	1195	*/
1302	unsigned long	1196	unsigned long
1303	bgPixmap_t::make_transparency_pixmap ()	1197	bgPixmap_t::make_transparency_pixmap ()
1304	{	1198	{
…		…
1308	return 0;	1202	return 0;
1309		1203
1310	/* root dimensions may change from call to call - but Display structure should	1204	/* root dimensions may change from call to call - but Display structure should
1311	* be always up-to-date, so let's use it :	1205	* be always up-to-date, so let's use it :
1312	*/	1206	*/
1313	Window root = target->display->root;
1314	int screen = target->display->screen;	1207	int screen = target->display->screen;
1315	Display *dpy = target->dpy;	1208	Display *dpy = target->dpy;
		1209	int root_depth = DefaultDepth (dpy, screen);
1316	int root_width = DisplayWidth (dpy, screen);	1210	int root_width = DisplayWidth (dpy, screen);
1317	int root_height = DisplayHeight (dpy, screen);	1211	int root_height = DisplayHeight (dpy, screen);
1318	unsigned int root_pmap_width, root_pmap_height;	1212	unsigned int root_pmap_width, root_pmap_height;
1319	int window_width = target->szHint.width;	1213	int window_width = target->szHint.width;
1320	int window_height = target->szHint.height;	1214	int window_height = target->szHint.height;
1321	int sx, sy;	1215	int sx, sy;
1322	XGCValues gcv;	1216	XGCValues gcv;
1323	GC gc;	1217	GC gc;
1324		1218
1325	TIMING_TEST_START (tp);	1219	sx = target_x;
1326	target->get_window_origin (sx, sy);	1220	sy = target_y;
1327		1221
1328	/* check if we are outside of the visible part of the virtual screen : */	1222	/* check if we are outside of the visible part of the virtual screen : */
1329	if (sx + window_width <= 0 \|\| sy + window_height <= 0	1223	if (sx + window_width <= 0 \|\| sy + window_height <= 0
1330	\|\| sx >= root_width \|\| sy >= root_height)	1224	\|\| sx >= root_width \|\| sy >= root_height)
1331	return 0;	1225	return 0;
1332		1226
		1227	// validate root pixmap and get its size
1333	if (root_pixmap != None)	1228	if (root_pixmap != None)
1334	{	1229	{
1335	/* we want to validate the pixmap and get its size at the same time : */	1230	Window wdummy;
1336	int junk;	1231	int idummy;
1337	unsigned int ujunk;	1232	unsigned int udummy;
1338	/* root pixmap may be bad - allow a error */	1233
1339	target->allowedxerror = -1;	1234	target->allowedxerror = -1;
1340		1235
1341	if (!XGetGeometry (dpy, root_pixmap, &root, &junk, &junk, &root_pmap_width, &root_pmap_height, &ujunk, &ujunk))	1236	if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))
1342	root_pixmap = None;	1237	root_pixmap = None;
1343		1238
1344	target->allowedxerror = 0;	1239	target->allowedxerror = 0;
		1240	}
		1241
		1242	Pixmap recoded_root_pmap = root_pixmap;
		1243
		1244	if (root_pixmap != None && root_depth != target->depth)
		1245	{
		1246	#if XRENDER
		1247	if (flags & HAS_RENDER)
		1248	{
		1249	XRenderPictureAttributes pa;
		1250
		1251	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
		1252	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);
		1253
		1254	recoded_root_pmap = XCreatePixmap (dpy, target->vt, root_pmap_width, root_pmap_height, target->depth);
		1255	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
		1256	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);
		1257
		1258	if (src && dst)
		1259	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
		1260	else
		1261	{
		1262	XFreePixmap (dpy, recoded_root_pmap);
		1263	root_pixmap = None;
		1264	}
		1265
		1266	XRenderFreePicture (dpy, src);
		1267	XRenderFreePicture (dpy, dst);
		1268	}
		1269	else
		1270	#endif
		1271	root_pixmap = None;
1345	}	1272	}
1346		1273
1347	if (root_pixmap == None)	1274	if (root_pixmap == None)
1348	return 0;	1275	return 0;
1349		1276
1350	Pixmap tiled_root_pmap = XCreatePixmap (dpy, root, window_width, window_height, root_depth);	1277	Pixmap tiled_root_pmap = XCreatePixmap (dpy, target->vt, window_width, window_height, target->depth);
1351		1278
1352	if (tiled_root_pmap == None) /* something really bad happened - abort */	1279	if (tiled_root_pmap == None) /* something really bad happened - abort */
1353	return 0;	1280	return 0;
1354		1281
1355	/* straightforward pixmap copy */	1282	/* straightforward pixmap copy */
1356	gcv.tile = root_pixmap;	1283	gcv.tile = recoded_root_pmap;
1357	gcv.fill_style = FillTiled;	1284	gcv.fill_style = FillTiled;
1358		1285
1359	while (sx < 0) sx += (int)root_width;	1286	while (sx < 0) sx += (int)root_width;
1360	while (sy < 0) sy += (int)root_height;	1287	while (sy < 0) sy += (int)root_height;
1361		1288
1362	gcv.ts_x_origin = -sx;	1289	gcv.ts_x_origin = -sx;
1363	gcv.ts_y_origin = -sy;	1290	gcv.ts_y_origin = -sy;
1364	gc = XCreateGC (dpy, root, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);	1291	gc = XCreateGC (dpy, target->vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);
1365		1292
1366	if (gc)	1293	if (gc)
1367	{	1294	{
1368	XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);	1295	XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);
1369	result \|= transpPmapTiled;	1296	result \|= transpPmapTiled;
1370	XFreeGC (dpy, gc);	1297	XFreeGC (dpy, gc);
1371	}
1372	TIMING_TEST_PRINT_RESULT (tp);
1373		1298
1374	if (tiled_root_pmap != None)
1375	{
1376	if (!need_client_side_rendering ())	1299	if (!need_client_side_rendering ())
1377	{	1300	{
1378	if (flags & (blurNeeded \| blurServerSide))	1301	if ((flags & blurNeeded)
		1302	&& (flags & HAS_RENDER_CONV))
1379	{	1303	{
1380	if (blur_pixmap (tiled_root_pmap, DefaultVisual (dpy, target->display->screen), window_width, window_height))	1304	if (blur_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1381	result \|= transpPmapBlurred;	1305	result \|= transpPmapBlurred;
1382	}	1306	}
1383	if (flags & (tintNeeded \| tintServerSide))	1307	if ((flags & tintNeeded)
		1308	&& (flags & (tintWholesome \| HAS_RENDER)))
1384	{	1309	{
1385	if (tint_pixmap (tiled_root_pmap, DefaultVisual (dpy, target->display->screen), window_width, window_height))	1310	if (tint_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1386	result \|= transpPmapTinted;	1311	result \|= transpPmapTinted;
1387	}	1312	}
1388	} /* server side rendering completed */	1313	} /* server side rendering completed */
1389		1314
1390	if (pixmap)	1315	if (pixmap)
1391	XFreePixmap (dpy, pixmap);	1316	XFreePixmap (dpy, pixmap);
1392		1317
1393	pixmap = tiled_root_pmap;	1318	pixmap = tiled_root_pmap;
1394	pmap_width = window_width;	1319	pmap_width = window_width;
1395	pmap_height = window_height;	1320	pmap_height = window_height;
1396	pmap_depth = root_depth;	1321	pmap_depth = target->depth;
1397	}	1322	}
		1323	else
		1324	XFreePixmap (dpy, tiled_root_pmap);
1398		1325
1399	TIMING_TEST_PRINT_RESULT (tp);	1326	if (recoded_root_pmap != root_pixmap)
		1327	XFreePixmap (dpy, recoded_root_pmap);
1400		1328
1401	return result;	1329	return result;
1402	}	1330	}
1403		1331
1404	bool	1332	void
1405	bgPixmap_t::set_root_pixmap ()	1333	bgPixmap_t::set_root_pixmap ()
1406	{	1334	{
1407	Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);	1335	Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);
1408	if (new_root_pixmap == None)	1336	if (new_root_pixmap == None)
1409	new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);	1337	new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);
1410		1338
1411	if (new_root_pixmap != root_pixmap)
1412	{
1413	root_pixmap = new_root_pixmap;	1339	root_pixmap = new_root_pixmap;
1414	return true;
1415	}
1416
1417	return false;
1418	}	1340	}
1419	# endif /* ENABLE_TRANSPARENCY */	1341	# endif /* ENABLE_TRANSPARENCY */
1420		1342
1421	# ifndef HAVE_AFTERIMAGE	1343	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1422	static void ShadeXImage(rxvt_term term, XImage srcImage, int shade, int rm, int gm, int bm);	1344	static void ShadeXImage(Visual visual, XImage srcImage, int shade, const rgba &c);
1423	# endif	1345	# endif
1424		1346
1425	bool	1347	bool
1426	bgPixmap_t::render ()	1348	bgPixmap_t::render ()
1427	{	1349	{
1428	unsigned long background_flags = 0;	1350	unsigned long background_flags = 0;
1429		1351
1430	if (target == NULL)	1352	if (target == NULL)
1431	return false;	1353	return false;
1432
1433	TIMING_TEST_START (tp);
1434		1354
1435	invalidate ();	1355	invalidate ();
1436	# ifdef ENABLE_TRANSPARENCY	1356	# ifdef ENABLE_TRANSPARENCY
1437	if (flags & isTransparent)	1357	if (flags & isTransparent)
1438	{	1358	{
1439	/* we need to re-generate transparency pixmap in that case ! */	1359	/* we need to re-generate transparency pixmap in that case ! */
1440	background_flags = make_transparency_pixmap ();	1360	background_flags = make_transparency_pixmap ();
1441	if (background_flags == 0)	1361	if (background_flags == 0)
1442	return false;	1362	return false;
1443	else if ((background_flags & transpTransformations) == (flags & transpTransformations)	1363	else if ((background_flags & transpTransformations) == (flags & transpTransformations))
1444	&& pmap_depth == target->depth)
1445	flags = flags & ~isInvalid;	1364	flags = flags & ~isInvalid;
1446	}	1365	}
1447	# endif	1366	# endif
1448		1367
1449	# ifdef BG_IMAGE_FROM_FILE	1368	# ifdef BG_IMAGE_FROM_FILE
…		…
1453	if (render_image (background_flags))	1372	if (render_image (background_flags))
1454	flags = flags & ~isInvalid;	1373	flags = flags & ~isInvalid;
1455	}	1374	}
1456	# endif	1375	# endif
1457		1376
		1377	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1458	XImage *result = NULL;	1378	XImage *result = NULL;
1459		1379
1460	if (background_flags && (flags & isInvalid))	1380	if (background_flags && (flags & isInvalid))
1461	{	1381	{
1462	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);	1382	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1463	}	1383	}
1464		1384
1465	if (result)	1385	if (result)
1466	{	1386	{
1467	# if !defined(HAVE_AFTERIMAGE) && !XFT
1468	/* our own client-side tinting */	1387	/* our own client-side tinting */
1469	/* ATTENTION: We ASSUME that XFT will let us do all the tinting necessary server-side.
1470	This may need to be changed in need_client_side_rendering() logic is altered !!! */
1471	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))	1388	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1472	{	1389	{
1473	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	1390	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1474	if (flags & tintSet)	1391	if (flags & tintSet)
1475	tint.get (c);	1392	tint.get (c);
1476	ShadeXImage (target, result, shade, c.r, c.g, c.b);	1393	ShadeXImage (DefaultVisual (target->dpy, target->display->screen), result, shade, c);
1477	}	1394	}
1478	# endif
1479		1395
1480	GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);	1396	GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1481		1397
1482	if (gc)	1398	if (gc)
1483	{	1399	{
1484	if (/pmap_depth != target->depth &&/ pixmap != None)
1485	{
1486	XFreePixmap (target->dpy, pixmap);
1487	pixmap = None;
1488	}
1489
1490	if (pixmap == None)
1491	{
1492	pixmap = XCreatePixmap (target->dpy, target->vt, result->width, result->height, target->depth);
1493	pmap_width = result->width;
1494	pmap_height = result->height;
1495	pmap_depth = target->depth;
1496	}
1497
1498	if (pmap_depth != result->depth)
1499	{
1500	/* Bad Match error will ensue ! stupid X !!!! */
1501	if (result->depth == 24 && pmap_depth == 32)
1502	result->depth = 32;
1503	else if (result->depth == 32 && pmap_depth == 24)
1504	result->depth = 24;
1505	else
1506	{
1507	/* TODO: implement image recoding */
1508	}
1509	}
1510
1511	if (pmap_depth == result->depth)
1512	XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);	1400	XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1513		1401
1514	XFreeGC (target->dpy, gc);	1402	XFreeGC (target->dpy, gc);
1515	flags = flags & ~isInvalid;	1403	flags = flags & ~isInvalid;
1516	}	1404	}
1517		1405
1518	XDestroyImage (result);	1406	XDestroyImage (result);
1519	}	1407	}
		1408	# endif
1520		1409
1521	if (flags & isInvalid)	1410	if (flags & isInvalid)
1522	{	1411	{
1523	if (pixmap != None)	1412	if (pixmap != None)
1524	{	1413	{
…		…
1527	}	1416	}
1528	}	1417	}
1529		1418
1530	apply ();	1419	apply ();
1531		1420
1532	XSync (target->dpy, False);
1533	valid_since = ev::now ();	1421	valid_since = ev::now ();
1534		1422
1535	TIMING_TEST_PRINT_RESULT (tp);
1536
1537	return true;	1423	return true;
1538	}	1424	}
1539		1425
1540	bool	1426	void
1541	bgPixmap_t::set_target (rxvt_term *new_target)	1427	bgPixmap_t::set_target (rxvt_term *new_target)
1542	{	1428	{
1543	if (new_target)
1544	if (target != new_target)
1545	{
1546	target = new_target;	1429	target = new_target;
1547	# ifdef ENABLE_TRANSPARENCY	1430
1548	root_depth = DefaultDepthOfScreen (ScreenOfDisplay (target->dpy, target->display->screen));	1431	flags &= ~(HAS_RENDER \| HAS_RENDER_CONV);
		1432	#if XRENDER
		1433	int major, minor;
		1434	if (XRenderQueryVersion (target->dpy, &major, &minor))
		1435	flags \|= HAS_RENDER;
		1436	XFilters *filters = XRenderQueryFilters (target->dpy, target->vt);
		1437	if (filters)
		1438	{
		1439	for (int i = 0; i < filters->nfilter; i++)
		1440	if (!strcmp (filters->filter[i], FilterConvolution))
		1441	flags \|= HAS_RENDER_CONV;
		1442
		1443	XFree (filters);
		1444	}
1549	# endif	1445	#endif
1550	return true;
1551	}
1552
1553	return false;
1554	}	1446	}
1555		1447
1556	void	1448	void
1557	bgPixmap_t::apply ()	1449	bgPixmap_t::apply ()
1558	{	1450	{
1559	if (target)	1451	if (target == NULL)
1560	{	1452	return;
1561	flags &= ~isVtOrigin;
1562		1453
1563	if (pixmap != None)	1454	if (pixmap != None)
1564	{	1455	{
1565	/* set target's background to pixmap */	1456	/* set target's background to pixmap */
1566	# ifdef ENABLE_TRANSPARENCY	1457	# ifdef ENABLE_TRANSPARENCY
1567	if (flags & isTransparent)	1458	if (flags & isTransparent)
1568	{	1459	{
1569	XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);	1460	XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
1570	XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);	1461	XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
1571		1462
1572	if (target->scrollBar.win)	1463	if (target->scrollBar.win)
1573	XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);	1464	XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1574	}	1465	}
1575	else	1466	else
1576	# endif	1467	# endif
1577	{	1468	{
1578	flags \|= isVtOrigin;
1579	/* force old pixmap dereference in case it was transparent before :*/	1469	/* force old pixmap dereference in case it was transparent before :*/
1580	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1581	XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1582	/* do we also need to set scrollbar's background here ? */
1583
1584	if (target->scrollBar.win)
1585	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1586	}
1587	}
1588	else
1589	{
1590	/* set target background to a pixel */
1591	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);	1470	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1592	XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);	1471	XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1593	/* do we also need to set scrollbar's background here ? */	1472	/* do we also need to set scrollbar's background here ? */
		1473
1594	if (target->scrollBar.win)	1474	if (target->scrollBar.win)
1595	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);	1475	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1596	}	1476	}
		1477	}
		1478	else
		1479	{
		1480	/* set target background to a pixel */
		1481	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
		1482	XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
		1483	/* do we also need to set scrollbar's background here ? */
		1484	if (target->scrollBar.win)
		1485	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
		1486	}
1597		1487
1598	/* don't want Expose on the parent or vt. It is better to use	1488	/* don't want Expose on the parent or vt. It is better to use
1599	scr_touch or we get a great deal of flicker otherwise: */	1489	scr_touch or we get a great deal of flicker otherwise: */
1600	XClearWindow (target->dpy, target->parent[0]);	1490	XClearWindow (target->dpy, target->parent[0]);
1601		1491
1602	if (target->scrollBar.state && target->scrollBar.win)	1492	if (target->scrollBar.state && target->scrollBar.win)
1603	{	1493	{
1604	target->scrollBar.state = STATE_IDLE;	1494	target->scrollBar.state = STATE_IDLE;
1605	target->scrollBar.show (0);	1495	target->scrollBar.show (0);
1606	}	1496	}
1607		1497
1608	target->want_refresh = 1;	1498	target->want_refresh = 1;
1609	flags \|= hasChanged;	1499	flags \|= hasChanged;
1610	}
1611	}	1500	}
1612		1501
1613	#endif /* HAVE_BG_PIXMAP */	1502	#endif /* HAVE_BG_PIXMAP */
1614		1503
1615	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XFT	1504	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1616	/* taken from aterm-0.4.2 */	1505	/* taken from aterm-0.4.2 */
1617		1506
1618	typedef uint32_t RUINT32T;
1619
1620	static void	1507	static void
1621	ShadeXImage(rxvt_term term, XImage srcImage, int shade, int rm, int gm, int bm)	1508	ShadeXImage(Visual visual, XImage srcImage, int shade, const rgba &c)
1622	{	1509	{
1623	int sh_r, sh_g, sh_b;	1510	int sh_r, sh_g, sh_b;
1624	RUINT32T mask_r, mask_g, mask_b;	1511	uint32_t mask_r, mask_g, mask_b;
1625	RUINT32T lookup, lookup_r, lookup_g, lookup_b;	1512	uint32_t lookup, lookup_r, lookup_g, lookup_b;
1626	unsigned int lower_lim_r, lower_lim_g, lower_lim_b;	1513	rgba low;
1627	unsigned int upper_lim_r, upper_lim_g, upper_lim_b;	1514	rgba high;
1628	int i;	1515	int i;
		1516	int host_byte_order = byteorder.big_endian () ? MSBFirst : LSBFirst;
1629		1517
1630	Visual *visual = term->visual;
1631
1632	if (visual->c_class != TrueColor \|\| srcImage->format != ZPixmap) return ;	1518	if (visual->c_class != TrueColor \|\| srcImage->format != ZPixmap) return;
1633		1519
1634	/* for convenience */	1520	/* for convenience */
1635	mask_r = visual->red_mask;	1521	mask_r = visual->red_mask;
1636	mask_g = visual->green_mask;	1522	mask_g = visual->green_mask;
1637	mask_b = visual->blue_mask;	1523	mask_b = visual->blue_mask;
1638		1524
1639	/* boring lookup table pre-initialization */	1525	/* boring lookup table pre-initialization */
1640	switch (srcImage->bits_per_pixel) {	1526	switch (srcImage->depth)
		1527	{
1641	case 15:	1528	case 15:
1642	if ((mask_r != 0x7c00) \|\|	1529	if ((mask_r != 0x7c00) \|\|
1643	(mask_g != 0x03e0) \|\|	1530	(mask_g != 0x03e0) \|\|
1644	(mask_b != 0x001f))	1531	(mask_b != 0x001f))
1645	return;	1532	return;
1646	lookup = (RUINT32T ) malloc (sizeof (RUINT32T)(32+32+32));	1533	lookup = (uint32_t ) malloc (sizeof (uint32_t)(32+32+32));
1647	lookup_r = lookup;	1534	lookup_r = lookup;
1648	lookup_g = lookup+32;	1535	lookup_g = lookup+32;
1649	lookup_b = lookup+32+32;	1536	lookup_b = lookup+32+32;
1650	sh_r = 10;	1537	sh_r = 10;
1651	sh_g = 5;	1538	sh_g = 5;
1652	sh_b = 0;	1539	sh_b = 0;
1653	break;	1540	break;
1654	case 16:	1541	case 16:
1655	if ((mask_r != 0xf800) \|\|	1542	if ((mask_r != 0xf800) \|\|
1656	(mask_g != 0x07e0) \|\|	1543	(mask_g != 0x07e0) \|\|
1657	(mask_b != 0x001f))	1544	(mask_b != 0x001f))
1658	return;	1545	return;
1659	lookup = (RUINT32T ) malloc (sizeof (RUINT32T)(32+64+32));	1546	lookup = (uint32_t ) malloc (sizeof (uint32_t)(32+64+32));
1660	lookup_r = lookup;	1547	lookup_r = lookup;
1661	lookup_g = lookup+32;	1548	lookup_g = lookup+32;
1662	lookup_b = lookup+32+64;	1549	lookup_b = lookup+32+64;
1663	sh_r = 11;	1550	sh_r = 11;
1664	sh_g = 5;	1551	sh_g = 5;
1665	sh_b = 0;	1552	sh_b = 0;
1666	break;	1553	break;
1667	case 24:	1554	case 24:
1668	if ((mask_r != 0xff0000) \|\|	1555	if ((mask_r != 0xff0000) \|\|
1669	(mask_g != 0x00ff00) \|\|	1556	(mask_g != 0x00ff00) \|\|
1670	(mask_b != 0x0000ff))	1557	(mask_b != 0x0000ff))
1671	return;	1558	return;
1672	lookup = (RUINT32T ) malloc (sizeof (RUINT32T)(256+256+256));	1559	lookup = (uint32_t ) malloc (sizeof (uint32_t)(256+256+256));
1673	lookup_r = lookup;	1560	lookup_r = lookup;
1674	lookup_g = lookup+256;	1561	lookup_g = lookup+256;
1675	lookup_b = lookup+256+256;	1562	lookup_b = lookup+256+256;
1676	sh_r = 16;	1563	sh_r = 16;
1677	sh_g = 8;	1564	sh_g = 8;
1678	sh_b = 0;	1565	sh_b = 0;
1679	break;	1566	break;
1680	case 32:	1567	case 32:
1681	if ((mask_r != 0xff0000) \|\|	1568	if ((mask_r != 0xff0000) \|\|
1682	(mask_g != 0x00ff00) \|\|	1569	(mask_g != 0x00ff00) \|\|
1683	(mask_b != 0x0000ff))	1570	(mask_b != 0x0000ff))
1684	return;	1571	return;
1685	lookup = (RUINT32T ) malloc (sizeof (RUINT32T)(256+256+256));	1572	lookup = (uint32_t ) malloc (sizeof (uint32_t)(256+256+256));
1686	lookup_r = lookup;	1573	lookup_r = lookup;
1687	lookup_g = lookup+256;	1574	lookup_g = lookup+256;
1688	lookup_b = lookup+256+256;	1575	lookup_b = lookup+256+256;
1689	sh_r = 16;	1576	sh_r = 16;
1690	sh_g = 8;	1577	sh_g = 8;
1691	sh_b = 0;	1578	sh_b = 0;
1692	break;	1579	break;
1693	default:	1580	default:
1694	return; /* we do not support this color depth */	1581	return; /* we do not support this color depth */
1695	}	1582	}
1696		1583
1697	/* prepare limits for color transformation (each channel is handled separately) */	1584	/* prepare limits for color transformation (each channel is handled separately) */
1698	if (shade > 100) {	1585	if (shade > 100)
		1586	{
1699	shade = 200 - shade;	1587	shade = 200 - shade;
1700		1588
1701	lower_lim_r = 65535-rm;	1589	high.r = (65535 - c.r) * shade / 100;
1702	lower_lim_g = 65535-gm;	1590	high.g = (65535 - c.g) * shade / 100;
1703	lower_lim_b = 65535-bm;	1591	high.b = (65535 - c.b) * shade / 100;
1704		1592
1705	lower_lim_r = 65535-(unsigned int)(((RUINT32T)lower_lim_r)*((RUINT32T)shade)/100);	1593	low.r = 65535 - high.r;
1706	lower_lim_g = 65535-(unsigned int)(((RUINT32T)lower_lim_g)*((RUINT32T)shade)/100);	1594	low.g = 65535 - high.g;
1707	lower_lim_b = 65535-(unsigned int)(((RUINT32T)lower_lim_b)*((RUINT32T)shade)/100);	1595	low.b = 65535 - high.b;
1708
1709	upper_lim_r = upper_lim_g = upper_lim_b = 65535;
1710	} else {
1711
1712	lower_lim_r = lower_lim_g = lower_lim_b = 0;
1713
1714	upper_lim_r = (unsigned int)((((RUINT32T)rm)*((RUINT32T)shade))/100);
1715	upper_lim_g = (unsigned int)((((RUINT32T)gm)*((RUINT32T)shade))/100);
1716	upper_lim_b = (unsigned int)((((RUINT32T)bm)*((RUINT32T)shade))/100);
1717	}	1596	}
1718		1597	else
1719	/* switch red and blue bytes if necessary, we need it for some weird XServers like XFree86 3.3.3.1 */
1720	if ((srcImage->bits_per_pixel == 24) && (mask_r >= 0xFF0000 ))
1721	{	1598	{
1722	unsigned int tmp;	1599	high.r = c.r * shade / 100;
		1600	high.g = c.g * shade / 100;
		1601	high.b = c.b * shade / 100;
1723		1602
1724	tmp = lower_lim_r;	1603	low.r = low.g = low.b = 0;
1725	lower_lim_r = lower_lim_b;
1726	lower_lim_b = tmp;
1727
1728	tmp = upper_lim_r;
1729	upper_lim_r = upper_lim_b;
1730	upper_lim_b = tmp;
1731	}	1604	}
1732		1605
1733	/* fill our lookup tables */	1606	/* fill our lookup tables */
1734	for (i = 0; i <= mask_r>>sh_r; i++)	1607	for (i = 0; i <= mask_r>>sh_r; i++)
1735	{	1608	{
1736	RUINT32T tmp;	1609	uint32_t tmp;
1737	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_r-lower_lim_r));	1610	tmp = i * high.r;
1738	tmp += ((RUINT32T)(mask_r>>sh_r))*((RUINT32T)lower_lim_r);	1611	tmp += (mask_r>>sh_r) * low.r;
1739	lookup_r[i] = (tmp/65535)<<sh_r;	1612	lookup_r[i] = (tmp/65535)<<sh_r;
1740	}	1613	}
1741	for (i = 0; i <= mask_g>>sh_g; i++)	1614	for (i = 0; i <= mask_g>>sh_g; i++)
1742	{	1615	{
1743	RUINT32T tmp;	1616	uint32_t tmp;
1744	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_g-lower_lim_g));	1617	tmp = i * high.g;
1745	tmp += ((RUINT32T)(mask_g>>sh_g))*((RUINT32T)lower_lim_g);	1618	tmp += (mask_g>>sh_g) * low.g;
1746	lookup_g[i] = (tmp/65535)<<sh_g;	1619	lookup_g[i] = (tmp/65535)<<sh_g;
1747	}	1620	}
1748	for (i = 0; i <= mask_b>>sh_b; i++)	1621	for (i = 0; i <= mask_b>>sh_b; i++)
1749	{	1622	{
1750	RUINT32T tmp;	1623	uint32_t tmp;
1751	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_b-lower_lim_b));	1624	tmp = i * high.b;
1752	tmp += ((RUINT32T)(mask_b>>sh_b))*((RUINT32T)lower_lim_b);	1625	tmp += (mask_b>>sh_b) * low.b;
1753	lookup_b[i] = (tmp/65535)<<sh_b;	1626	lookup_b[i] = (tmp/65535)<<sh_b;
1754	}	1627	}
1755		1628
1756	/* apply table to input image (replacing colors by newly calculated ones) */	1629	/* apply table to input image (replacing colors by newly calculated ones) */
1757	switch (srcImage->bits_per_pixel)	1630	if (srcImage->bits_per_pixel == 32
		1631	&& (srcImage->depth == 24 \|\| srcImage->depth == 32)
		1632	&& srcImage->byte_order == host_byte_order)
1758	{	1633	{
1759	case 15:
1760	{
1761	unsigned short p1, pf, p, pl;	1634	uint32_t p1, pf, p, pl;
1762	p1 = (unsigned short *) srcImage->data;	1635	p1 = (uint32_t *) srcImage->data;
1763	pf = (unsigned short ) (srcImage->data + srcImage->height srcImage->bytes_per_line);	1636	pf = (uint32_t ) (srcImage->data + srcImage->height srcImage->bytes_per_line);
		1637
1764	while (p1 < pf)	1638	while (p1 < pf)
1765	{	1639	{
1766	p = p1;	1640	p = p1;
1767	pl = p1 + srcImage->width;	1641	pl = p1 + srcImage->width;
1768	for (; p < pl; p++)	1642	for (; p < pl; p++)
1769	{	1643	{
1770	p = lookup_r[(p & 0x7c00)>>10] \|
1771	lookup_g[(*p & 0x03e0)>> 5] \|
1772	lookup_b[(*p & 0x001f)];
1773	}
1774	p1 = (unsigned short ) ((char ) p1 + srcImage->bytes_per_line);
1775	}
1776	break;
1777	}
1778	case 16:
1779	{
1780	unsigned short p1, pf, p, pl;
1781	p1 = (unsigned short *) srcImage->data;
1782	pf = (unsigned short ) (srcImage->data + srcImage->height srcImage->bytes_per_line);
1783	while (p1 < pf)
1784	{
1785	p = p1;
1786	pl = p1 + srcImage->width;
1787	for (; p < pl; p++)
1788	{
1789	p = lookup_r[(p & 0xf800)>>11] \|
1790	lookup_g[(*p & 0x07e0)>> 5] \|
1791	lookup_b[(*p & 0x001f)];
1792	}
1793	p1 = (unsigned short ) ((char ) p1 + srcImage->bytes_per_line);
1794	}
1795	break;
1796	}
1797	case 24:
1798	{
1799	unsigned char p1, pf, p, pl;
1800	p1 = (unsigned char *) srcImage->data;
1801	pf = (unsigned char ) (srcImage->data + srcImage->height srcImage->bytes_per_line);
1802	while (p1 < pf)
1803	{
1804	p = p1;
1805	pl = p1 + srcImage->width * 3;
1806	for (; p < pl; p += 3)
1807	{
1808	p[0] = lookup_r[(p[0] & 0xff0000)>>16];
1809	p[1] = lookup_r[(p[1] & 0x00ff00)>> 8];
1810	p[2] = lookup_r[(p[2] & 0x0000ff)];
1811	}
1812	p1 = (unsigned char ) ((char ) p1 + srcImage->bytes_per_line);
1813	}
1814	break;
1815	}
1816	case 32:
1817	{
1818	RUINT32T p1, pf, p, pl;
1819	p1 = (RUINT32T *) srcImage->data;
1820	pf = (RUINT32T ) (srcImage->data + srcImage->height srcImage->bytes_per_line);
1821
1822	while (p1 < pf)
1823	{
1824	p = p1;
1825	pl = p1 + srcImage->width;
1826	for (; p < pl; p++)
1827	{
1828	p = lookup_r[(p & 0xff0000)>>16] \|	1644	p = lookup_r[(p & 0xff0000) >> 16] \|
1829	lookup_g[(*p & 0x00ff00)>> 8] \|	1645	lookup_g[(*p & 0x00ff00) >> 8] \|
1830	lookup_b[(*p & 0x0000ff)] \|	1646	lookup_b[(*p & 0x0000ff)] \|
1831	(*p & ~0xffffff);	1647	(*p & 0xff000000);
		1648	}
		1649	p1 = (uint32_t ) ((char ) p1 + srcImage->bytes_per_line);
		1650	}
		1651	}
		1652	else
		1653	{
		1654	for (int y = 0; y < srcImage->height; y++)
		1655	for (int x = 0; x < srcImage->width; x++)
		1656	{
		1657	unsigned long pixel = XGetPixel (srcImage, x, y);
		1658	pixel = lookup_r[(pixel & mask_r) >> sh_r] \|
		1659	lookup_g[(pixel & mask_g) >> sh_g] \|
		1660	lookup_b[(pixel & mask_b) >> sh_b];
		1661	XPutPixel (srcImage, x, y, pixel);
1832	}	1662	}
1833	p1 = (RUINT32T ) ((char ) p1 + srcImage->bytes_per_line);
1834	}	1663	}
1835	break;
1836	}
1837	}
1838		1664
1839	free (lookup);	1665	free (lookup);
1840	}	1666	}
1841	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1667	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.85 by sf-exg, Mon Oct 18 08:19:03 2010 UTC vs. Revision 1.121 by sf-exg, Fri Nov 19 23:29:30 2010 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.85 by sf-exg, Mon Oct 18 08:19:03 2010 UTC vs.
Revision 1.121 by sf-exg, Fri Nov 19 23:29:30 2010 UTC