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.133 by sf-exg, Tue Jan 11 09:21:14 2011 UTC vs.
Revision 1.200 by sf-exg, Thu Jan 19 13:33:43 2012 UTC

1	/*----------------------------------------------------------------------*	1	/*----------------------------------------------------------------------*
2	* File: background.C - former xpm.C	2	* File: background.C - former xpm.C
3	*----------------------------------------------------------------------*	3	*----------------------------------------------------------------------*
4	*	4	*
5	* All portions of code are copyright by their respective author/s.	5	* All portions of code are copyright by their respective author/s.
6	* Copyright (c) 2005-2008 Marc Lehmann <pcg@goof.com>	6	* Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>
7	* Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>	7	* Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
8	* Copyright (c) 2010 Emanuele Giaquinta <e.giaquinta@glauco.it>	8	* Copyright (c) 2010 Emanuele Giaquinta <e.giaquinta@glauco.it>
9	*	9	*
10	* This program is free software; you can redistribute it and/or modify	10	* This program is free software; you can redistribute it and/or modify
11	* it under the terms of the GNU General Public License as published by	11	* it under the terms of the GNU General Public License as published by
…		…
20	* You should have received a copy of the GNU General Public License	20	* You should have received a copy of the GNU General Public License
21	* along with this program; if not, write to the Free Software	21	* along with this program; if not, write to the Free Software
22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23	*---------------------------------------------------------------------*/	23	*---------------------------------------------------------------------*/
24		24
25	#include <cmath>	25	#include <math.h>
26	#include "../config.h" /* NECESSARY */	26	#include "../config.h" /* NECESSARY */
27	#include "rxvt.h" /* NECESSARY */	27	#include "rxvt.h" /* NECESSARY */
28		28
29	#if XRENDER	29	#if XRENDER
30	# include <X11/extensions/Xrender.h>	30	# include <X11/extensions/Xrender.h>
…		…
32		32
33	#ifndef FilterConvolution	33	#ifndef FilterConvolution
34	#define FilterConvolution "convolution"	34	#define FilterConvolution "convolution"
35	#endif	35	#endif
36		36
37	#define DO_TIMING_TEST 0	37	#ifndef RepeatPad
38		38	#define RepeatPad True
39	#if DO_TIMING_TEST
40	# include <sys/time.h>
41	#define TIMING_TEST_START(id) \
42	struct timeval timing_test_##id##_stv; \
43	gettimeofday (&timing_test_##id##_stv, NULL);
44
45	#define TIMING_TEST_PRINT_RESULT(id) \
46	do { \
47	struct timeval tv; \
48	gettimeofday (&tv, NULL); \
49	tv.tv_sec -= (timing_test_##id##_stv).tv_sec; \
50	fprintf (stderr, "%s: %s: %d: elapsed %ld usec\n", #id, __FILE__, __LINE__, \
51	tv.tv_sec * 1000000 + tv.tv_usec - (timing_test_##id##_stv).tv_usec); \
52	} while (0)
53
54	#else
55	#define TIMING_TEST_START(id) do {} while (0)
56	#define TIMING_TEST_PRINT_RESULT(id) do {} while (0)
57	#endif	39	#endif
58		40
59	/*
60	* Pixmap geometry string interpretation :
61	* Each geometry string contains zero or one scale/position
62	* adjustment and may optionally be followed by a colon and one or more
63	* colon-delimited pixmap operations.
64	* The following table shows the valid geometry strings and their
65	* effects on the background image :
66	*
67	* WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
68	* W and H are percentages of the terminal window size.
69	* X and Y are also percentages; e.g., +50+50 centers
70	* the image in the window.
71	*
72	* Pixmap Operations : (should be prepended by a colon)
73	* tile Tile image. Scaling/position modifiers above will affect
74	* the tile size and origin.
75	* propscale When scaling, scale proportionally. That is, maintain the
76	* proper aspect ratio for the image. Any portion of the
77	* background not covered by the image is filled with the
78	* current background color.
79	* hscale Scale horizontally, tile vertically ?
80	* vscale Tile horizontally, scale vertically ?
81	* scale Scale both up and down
82	* auto Same as 100x100+50+50
83	*/
84
85	#ifdef HAVE_BG_PIXMAP	41	#ifdef HAVE_BG_PIXMAP
86	bgPixmap_t::bgPixmap_t ()	42	# if XRENDER
		43	static Picture
		44	create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
87	{	45	{
88	// this is basically redundant as bgPixmap_t is only used in	46	Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
89	// zero_initialised-derived structs	47
90	#ifdef HAVE_AFTERIMAGE	48	XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
91	original_asim = NULL;	49	XRenderPictureAttributes pa;
		50	pa.repeat = True;
		51	pa.component_alpha = component_alpha;
		52	Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat | CPComponentAlpha, &pa);
		53
		54	XFreePixmap (dpy, pixmap);
		55
		56	return mask;
		57	}
92	#endif	58	# endif
93	#ifdef HAVE_PIXBUF
94	pixbuf = NULL;
95	#endif
96	#ifdef BG_IMAGE_FROM_FILE
97	have_image = false;
98	h_scale = v_scale = 0;
99	h_align = v_align = 0;
100	#endif
101	#ifdef ENABLE_TRANSPARENCY
102	shade = 100;
103	#endif
104	flags = 0;
105	pixmap = None;
106	valid_since = invalid_since = 0;
107	target = 0;
108	target_x = target_y = 0;
109	}
110		59
111	void	60	void
112	bgPixmap_t::destroy ()	61	rxvt_term::bg_destroy ()
113	{	62	{
114	#ifdef HAVE_AFTERIMAGE	63	#ifdef HAVE_AFTERIMAGE
115	if (original_asim)	64	if (original_asim)
116	safe_asimage_destroy (original_asim);	65	safe_asimage_destroy (original_asim);
		66	if (asv)
		67	destroy_asvisual (asv, 0);
		68	if (asimman)
		69	destroy_image_manager (asimman, 0);
117	#endif	70	#endif
118		71
119	#ifdef HAVE_PIXBUF	72	#ifdef HAVE_PIXBUF
120	if (pixbuf)	73	if (pixbuf)
121	g_object_unref (pixbuf);	74	g_object_unref (pixbuf);
122	#endif	75	#endif
123		76
124	if (pixmap && target)	77	if (bg_pixmap)
125	XFreePixmap (target->dpy, pixmap);	78	XFreePixmap (dpy, bg_pixmap);
126	}	79	}
127		80
128	bool	81	bool
129	bgPixmap_t::set_position (int x, int y)	82	rxvt_term::bg_set_position (int x, int y)
130	{	83	{
131		84
132	if (target_x != x	85	if (target_x != x
133	|| target_y != y)	86	|| target_y != y)
134	{	87	{
…		…
138	}	91	}
139	return false;	92	return false;
140	}	93	}
141		94
142	bool	95	bool
143	bgPixmap_t::window_size_sensitive ()	96	rxvt_term::bg_window_size_sensitive ()
144	{	97	{
145	# ifdef ENABLE_TRANSPARENCY	98	# ifdef ENABLE_TRANSPARENCY
146	if (flags & isTransparent)	99	if (bg_flags & BG_IS_TRANSPARENT)
147	return true;	100	return true;
148	# endif	101	# endif
149		102
150	# ifdef BG_IMAGE_FROM_FILE	103	# ifdef BG_IMAGE_FROM_FILE
151	if (have_image)	104	if (bg_flags & BG_IS_FROM_FILE)
152	{	105	{
153	if (flags & sizeSensitive)	106	if (bg_flags & BG_IS_SIZE_SENSITIVE)
154	return true;	107	return true;
155	}	108	}
156	# endif	109	# endif
157		110
158	return false;	111	return false;
159	}	112	}
160		113
161	bool	114	bool
162	bgPixmap_t::window_position_sensitive ()	115	rxvt_term::bg_window_position_sensitive ()
163	{	116	{
164	# ifdef ENABLE_TRANSPARENCY	117	# ifdef ENABLE_TRANSPARENCY
165	if (flags & isTransparent)	118	if (bg_flags & BG_IS_TRANSPARENT)
166	return true;	119	return true;
167	# endif	120	# endif
168		121
169	# ifdef BG_IMAGE_FROM_FILE	122	# ifdef BG_IMAGE_FROM_FILE
170	if (have_image)	123	if (bg_flags & BG_IS_FROM_FILE)
171	{	124	{
172	if (flags & rootAlign)	125	if (bg_flags & BG_ROOT_ALIGN)
173	return true;	126	return true;
174	}	127	}
175	# endif	128	# endif
176		129
177	return false;	130	return false;
178	}	131	}
179		132
180	# ifdef BG_IMAGE_FROM_FILE	133	# ifdef BG_IMAGE_FROM_FILE
181	static inline bool
182	check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
183	{
184	if (geom_flags & flag)
185	{
186	if (new_value > 1000)
187	new_value = 1000;
188	if (new_value != scale)
189	{
190	scale = new_value;
191	return true;
192	}
193	}
194	return false;
195	}
196
197	static inline bool
198	check_set_align_value (int geom_flags, int flag, int &align, int new_value)
199	{
200	if (geom_flags & flag)
201	{
202	if (new_value < -100)
203	new_value = -100;
204	else if (new_value > 200)
205	new_value = 200;
206	if (new_value != align)
207	{
208	align = new_value;
209	return true;
210	}
211	}
212	return false;
213	}
214
215	static inline int	134	static inline int
216	make_align_position (int align, int window_size, int image_size)	135	make_align_position (int align, int window_size, int image_size)
217	{	136	{
218	int diff = window_size - image_size;	137	int diff = window_size - image_size;
219	int smaller = min (image_size, window_size);	138	int smaller = min (image_size, window_size);
220		139
221	if (align >= 0 && align <= 100)	140	if (align >= 0 && align <= 100)
222	return diff * align / 100;	141	return diff * align / 100;
223	else if (align > 100 && align <= 200)	142	else if (align > 100 && align <= 200)
224	return ((align - 100) * smaller / 100) + window_size - smaller;	143	return (align - 100) * smaller / 100 + window_size - smaller;
225	else if (align >= -100 && align < 0)	144	else if (align >= -100 && align < 0)
226	return ((align + 100) * smaller / 100) - image_size;	145	return (align + 100) * smaller / 100 - image_size;
227	return 0;	146	return 0;
228	}	147	}
229		148
230	static inline int	149	static inline int
231	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	150	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
…		…
238	src_pos = -pos;	157	src_pos = -pos;
239	dst_pos = 0;	158	dst_pos = 0;
240	dst_size += pos;	159	dst_size += pos;
241	}	160	}
242		161
243	if (dst_pos + dst_size > target_size)
244	dst_size = target_size - dst_pos;	162	min_it (dst_size, target_size - dst_pos);
245	return src_pos;	163	return src_pos;
246	}	164	}
247		165
248	bool	166	bool
249	bgPixmap_t::set_geometry (const char *geom, bool update)	167	rxvt_term::bg_set_geometry (const char *geom, bool update)
250	{	168	{
251	bool changed = false;	169	bool changed = false;
252	int geom_flags = 0;	170	int geom_flags = 0;
253	int x = 0, y = 0;	171	int x = h_align;
		172	int y = v_align;
254	unsigned int w = 0, h = 0;	173	unsigned int w = h_scale;
255	unsigned int n;	174	unsigned int h = v_scale;
256	unsigned long new_flags = (flags & (~geometryFlags));	175	unsigned long new_flags = 0;
257	const char *ops;
258		176
259	if (geom == NULL)	177	if (geom == NULL)
260	return false;	178	return false;
261		179
262	char str[256];	180	if (geom[0])
263
264	ops = strchr (geom, ':');
265	if (ops == NULL)
266	n = strlen (geom);
267	else
268	n = ops - geom;
269
270	if (n >= sizeof (str))
271	return false;
272
273	memcpy (str, geom, n);
274	str[n] = '\0';
275	rxvt_strtrim (str);
276
277	if (str[0])
278	{	181	{
279	/* we have geometry string - let's handle it prior to applying ops */	182	char **arr = rxvt_strsplit (':', geom);
		183
		184	for (int i = 0; arr[i]; i++)
		185	{
		186	if (!strcasecmp (arr[i], "style=tiled"))
		187	{
		188	new_flags = BG_TILE;
		189	w = h = noScale;
		190	x = y = 0;
		191	geom_flags = WidthValue|HeightValue|XValue|YValue;
		192	}
		193	else if (!strcasecmp (arr[i], "style=aspect-stretched"))
		194	{
		195	new_flags = BG_KEEP_ASPECT;
		196	w = h = windowScale;
		197	x = y = centerAlign;
		198	geom_flags = WidthValue|HeightValue|XValue|YValue;
		199	}
		200	else if (!strcasecmp (arr[i], "style=stretched"))
		201	{
		202	new_flags = 0;
		203	w = h = windowScale;
		204	geom_flags = WidthValue|HeightValue;
		205	}
		206	else if (!strcasecmp (arr[i], "style=centered"))
		207	{
		208	new_flags = 0;
		209	w = h = noScale;
		210	x = y = centerAlign;
		211	geom_flags = WidthValue|HeightValue|XValue|YValue;
		212	}
		213	else if (!strcasecmp (arr[i], "style=root-tiled"))
		214	{
		215	new_flags = BG_TILE|BG_ROOT_ALIGN;
		216	w = h = noScale;
		217	geom_flags = WidthValue|HeightValue;
		218	}
		219	else if (!strcasecmp (arr[i], "op=tile"))
		220	new_flags |= BG_TILE;
		221	else if (!strcasecmp (arr[i], "op=keep-aspect"))
		222	new_flags |= BG_KEEP_ASPECT;
		223	else if (!strcasecmp (arr[i], "op=root-align"))
		224	new_flags |= BG_ROOT_ALIGN;
		225
		226	// deprecated
		227	else if (!strcasecmp (arr[i], "tile"))
		228	{
		229	new_flags |= BG_TILE;
		230	w = h = noScale;
		231	geom_flags |= WidthValue|HeightValue;
		232	}
		233	else if (!strcasecmp (arr[i], "propscale"))
		234	{
		235	new_flags |= BG_KEEP_ASPECT;
		236	w = h = windowScale;
		237	geom_flags |= WidthValue|HeightValue;
		238	}
		239	else if (!strcasecmp (arr[i], "hscale"))
		240	{
		241	new_flags |= BG_TILE;
		242	w = windowScale;
		243	h = noScale;
		244	geom_flags |= WidthValue|HeightValue;
		245	}
		246	else if (!strcasecmp (arr[i], "vscale"))
		247	{
		248	new_flags |= BG_TILE;
		249	h = windowScale;
		250	w = noScale;
		251	geom_flags |= WidthValue|HeightValue;
		252	}
		253	else if (!strcasecmp (arr[i], "scale"))
		254	{
		255	w = h = windowScale;
		256	geom_flags |= WidthValue|HeightValue;
		257	}
		258	else if (!strcasecmp (arr[i], "auto"))
		259	{
		260	w = h = windowScale;
		261	x = y = centerAlign;
		262	geom_flags |= WidthValue|HeightValue|XValue|YValue;
		263	}
		264	else if (!strcasecmp (arr[i], "root"))
		265	{
		266	new_flags |= BG_TILE|BG_ROOT_ALIGN;
		267	w = h = noScale;
		268	geom_flags |= WidthValue|HeightValue;
		269	}
		270
		271	else
280	geom_flags = XParseGeometry (str, &x, &y, &w, &h);	272	geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h);
281	} /* done parsing geometry string */	273	} /* done parsing ops */
		274
		275	rxvt_free_strsplit (arr);
		276	}
		277
		278	new_flags |= bg_flags & ~BG_GEOMETRY_FLAGS;
282		279
283	if (!update)	280	if (!update)
284	{	281	{
285	if (!(geom_flags & XValue))	282	if (!(geom_flags & XValue))
286	x = y = defaultAlign;	283	x = y = defaultAlign;
…		…
291	w = h = defaultScale;	288	w = h = defaultScale;
292	else if (!(geom_flags & HeightValue))	289	else if (!(geom_flags & HeightValue))
293	h = w;	290	h = w;
294	else if (!(geom_flags & WidthValue))	291	else if (!(geom_flags & WidthValue))
295	w = h;	292	w = h;
296
297	geom_flags |= WidthValue|HeightValue|XValue|YValue;
298	}
299
300	if (ops)
301	{	293	}
302	char **arr = rxvt_strsplit (':', ops + 1);
303		294
304	for (int i = 0; arr[i]; i++)	295	min_it (w, 1000);
305	{	296	min_it (h, 1000);
306	if (!strcasecmp (arr[i], "tile"))	297	clamp_it (x, -100, 200);
307	{	298	clamp_it (y, -100, 200);
308	w = h = noScale;
309	geom_flags |= WidthValue|HeightValue;
310	}
311	else if (!strcasecmp (arr[i], "propscale"))
312	{
313	new_flags |= propScale;
314	}
315	else if (!strcasecmp (arr[i], "hscale"))
316	{
317	if (w == 0) w = windowScale;
318		299
319	h = noScale;	300	if (bg_flags != new_flags
320	geom_flags |= WidthValue|HeightValue;	301	|| h_scale != w
321	}	302	|| v_scale != h
322	else if (!strcasecmp (arr[i], "vscale"))	303	|| h_align != x
323	{	304	|| v_align != y)
324	if (h == 0) h = windowScale;
325
326	w = noScale;
327	geom_flags |= WidthValue|HeightValue;
328	}
329	else if (!strcasecmp (arr[i], "scale"))
330	{
331	if (h == 0) h = windowScale;
332	if (w == 0) w = windowScale;
333
334	geom_flags |= WidthValue|HeightValue;
335	}
336	else if (!strcasecmp (arr[i], "auto"))
337	{
338	w = h = windowScale;
339	x = y = centerAlign;
340	geom_flags |= WidthValue|HeightValue|XValue|YValue;
341	}
342	else if (!strcasecmp (arr[i], "root"))
343	{
344	new_flags |= rootAlign;
345	w = h = noScale;
346	geom_flags |= WidthValue|HeightValue;
347	}
348	} /* done parsing ops */
349
350	rxvt_free_strsplit (arr);
351	}	305	{
352
353	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
354	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
355	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
356	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
357
358	if (new_flags != flags)
359	{
360	flags = new_flags;	306	bg_flags = new_flags;
		307	h_scale = w;
		308	v_scale = h;
		309	h_align = x;
		310	v_align = y;
361	changed = true;	311	changed = true;
362	}	312	}
363		313
364	return changed;	314	return changed;
365	}	315	}
366		316
367	void	317	void
368	bgPixmap_t::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)	318	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
369	{	319	{
370	int target_width = target->szHint.width;	320	int target_width = szHint.width;
371	int target_height = target->szHint.height;	321	int target_height = szHint.height;
372		322
373	if (flags & propScale)	323	w = h_scale * target_width / 100;
		324	h = v_scale * target_height / 100;
		325
		326	if (bg_flags & BG_KEEP_ASPECT)
374	{	327	{
375	float scale = (float)target_width / image_width;	328	float scale = (float)w / image_width;
376	min_it (scale, (float)target_height / image_height);	329	min_it (scale, (float)h / image_height);
377	w = image_width * scale + 0.5;	330	w = image_width * scale + 0.5;
378	h = image_height * scale + 0.5;	331	h = image_height * scale + 0.5;
379	}	332	}
380	else
381	{
382	w = h_scale * target_width / 100;
383	h = v_scale * target_height / 100;
384	}
385		333
386	if (!w) w = image_width;	334	if (!w) w = image_width;
387	if (!h) h = image_height;	335	if (!h) h = image_height;
388		336
389	if (flags & rootAlign)	337	if (bg_flags & BG_ROOT_ALIGN)
390	{	338	{
391	x = -target_x;	339	x = -target_x;
392	y = -target_y;	340	y = -target_y;
393	}	341	}
394	else	342	else
395	{	343	{
396	x = make_align_position (h_align, target_width, w);	344	x = make_align_position (h_align, target_width, w);
397	y = make_align_position (v_align, target_height, h);	345	y = make_align_position (v_align, target_height, h);
398	}	346	}
399		347
400	flags &= ~sizeSensitive;	348	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
401	if ((flags & propScale) || h_scale || v_scale	349	if (!(bg_flags & BG_TILE)
		350	|| h_scale || v_scale
402	|| (!(flags & rootAlign) && (h_align || v_align))	351	|| (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
403	|| w > target_width || h > target_height)	352	|| w > target_width || h > target_height)
404	flags |= sizeSensitive;	353	bg_flags |= BG_IS_SIZE_SENSITIVE;
405	}	354	}
406		355
407	# ifdef HAVE_AFTERIMAGE	356	# ifdef HAVE_AFTERIMAGE
408	bool	357	bool
409	bgPixmap_t::render_image (unsigned long background_flags)	358	rxvt_term::render_image (unsigned long tr_flags)
410	{	359	{
411	if (target == NULL)
412	return false;
413
414	target->init_asv ();	360	init_asv ();
415		361
416	ASImage *background = NULL;	362	ASImage *background = NULL;
417	ARGB32 background_tint = TINT_LEAVE_SAME;	363	ARGB32 background_tint = TINT_LEAVE_SAME;
418		364
419	# ifdef ENABLE_TRANSPARENCY	365	# ifdef ENABLE_TRANSPARENCY
420	if (background_flags)	366	if (tr_flags)
421	background = pixmap2ximage (target->asv, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, 100);	367	background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
422		368
423	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))	369	if (tr_flags & BG_NEEDS_TINT)
424	{	370	{
425	ShadingInfo as_shade;	371	ShadingInfo as_shade;
426	as_shade.shading = shade;	372	as_shade.shading = shade;
427		373
428	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	374	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
429	if (flags & tintSet)	375	if (bg_flags & BG_TINT_SET)
430	tint.get (c);	376	tint.get (c);
431	as_shade.tintColor.red = c.r;	377	as_shade.tintColor.red = c.r;
432	as_shade.tintColor.green = c.g;	378	as_shade.tintColor.green = c.g;
433	as_shade.tintColor.blue = c.b;	379	as_shade.tintColor.blue = c.b;
434		380
435	background_tint = shading2tint32 (&as_shade);	381	background_tint = shading2tint32 (&as_shade);
436	}	382	}
437		383
438	if (!(background_flags & transpPmapBlurred) && (flags & blurNeeded) && background != NULL)	384	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
439	{	385	{
440	ASImage *tmp = blur_asimage_gauss (target->asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,	386	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
441	(original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,	387	ASA_XImage,
442	100, ASIMAGE_QUALITY_DEFAULT);	388	100, ASIMAGE_QUALITY_DEFAULT);
443	if (tmp)	389	if (tmp)
444	{	390	{
445	destroy_asimage (&background);	391	destroy_asimage (&background);
446	background = tmp;	392	background = tmp;
…		…
448	}	394	}
449	# endif	395	# endif
450		396
451	ASImage *result = 0;	397	ASImage *result = 0;
452		398
453	int target_width = target->szHint.width;	399	int target_width = szHint.width;
454	int target_height = target->szHint.height;	400	int target_height = szHint.height;
455	int new_pmap_width = target_width;	401	int new_pmap_width = target_width;
456	int new_pmap_height = target_height;	402	int new_pmap_height = target_height;
457		403
458	int x = 0;	404	int x = 0;
459	int y = 0;	405	int y = 0;
…		…
462		408
463	if (original_asim)	409	if (original_asim)
464	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);	410	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
465		411
466	if (!original_asim	412	if (!original_asim
467	|| (!(flags & rootAlign)	413	|| (!(bg_flags & BG_ROOT_ALIGN)
468	&& (x >= target_width	414	&& (x >= target_width
469	|| y >= target_height	415	|| y >= target_height
470	|| (x + w <= 0)	416	|| x + w <= 0
471	|| (y + h <= 0))))	417	|| y + h <= 0)))
472	{	418	{
473	if (background)	419	if (background)
474	{	420	{
475	new_pmap_width = background->width;	421	new_pmap_width = background->width;
476	new_pmap_height = background->height;	422	new_pmap_height = background->height;
477	result = background;	423	result = background;
478		424
479	if (background_tint != TINT_LEAVE_SAME)	425	if (background_tint != TINT_LEAVE_SAME)
480	{	426	{
481	ASImage *tmp = tile_asimage (target->asv, background, 0, 0,	427	ASImage *tmp = tile_asimage (asv, background, 0, 0,
482	target_width, target_height, background_tint,	428	target_width, target_height, background_tint,
483	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);	429	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
484	if (tmp)	430	if (tmp)
485	result = tmp;	431	result = tmp;
486	}	432	}
…		…
490	}	436	}
491	else	437	else
492	{	438	{
493	result = original_asim;	439	result = original_asim;
494		440
495	if ((w != original_asim->width)	441	if (w != original_asim->width
496	|| (h != original_asim->height))	442	|| h != original_asim->height)
497	{	443	{
498	result = scale_asimage (target->asv, original_asim,	444	result = scale_asimage (asv, original_asim,
499	w, h,	445	w, h,
500	background ? ASA_ASImage : ASA_XImage,	446	ASA_XImage,
501	100, ASIMAGE_QUALITY_DEFAULT);	447	100, ASIMAGE_QUALITY_DEFAULT);
502	}	448	}
503		449
504	if (background == NULL)	450	if (background == NULL)
505	{	451	{
506	if (h_scale == 0 || v_scale == 0)	452	if (bg_flags & BG_TILE)
507	{	453	{
508	/* if tiling - pixmap has to be sized exactly as the image,	454	/* if tiling - pixmap has to be sized exactly as the image,
509	but there is no need to make it bigger than the window! */	455	but there is no need to make it bigger than the window! */
510	new_pmap_width = min (result->width, target_width);	456	new_pmap_width = min (result->width, target_width);
511	new_pmap_height = min (result->height, target_height);	457	new_pmap_height = min (result->height, target_height);
512		458
513	/* we also need to tile our image in both directions */	459	/* we also need to tile our image in both directions */
514	ASImage *tmp = tile_asimage (target->asv, result,	460	ASImage *tmp = tile_asimage (asv, result,
515	(int)result->width - x,	461	(int)result->width - x,
516	(int)result->height - y,	462	(int)result->height - y,
517	new_pmap_width,	463	new_pmap_width,
518	new_pmap_height,	464	new_pmap_height,
519	TINT_LEAVE_SAME, ASA_XImage,	465	TINT_LEAVE_SAME, ASA_XImage,
…		…
536	layers[0].clip_width = target_width;	482	layers[0].clip_width = target_width;
537	layers[0].clip_height = target_height;	483	layers[0].clip_height = target_height;
538	layers[0].tint = background_tint;	484	layers[0].tint = background_tint;
539	layers[1].im = result;	485	layers[1].im = result;
540		486
541	if (h_scale == 0 || v_scale == 0)	487	if (bg_flags & BG_TILE)
542	{	488	{
543	/* tile horizontally */	489	/* tile horizontally */
544	while (x > 0) x -= (int)result->width;	490	while (x > 0) x -= (int)result->width;
545	layers[1].dst_x = x;	491	layers[1].dst_x = x;
546	layers[1].clip_width = result->width+target_width;	492	layers[1].clip_width = result->width+target_width;
…		…
550	/* clip horizontally */	496	/* clip horizontally */
551	layers[1].dst_x = x;	497	layers[1].dst_x = x;
552	layers[1].clip_width = result->width;	498	layers[1].clip_width = result->width;
553	}	499	}
554		500
555	if (h_scale == 0 || v_scale == 0)	501	if (bg_flags & BG_TILE)
556	{	502	{
557	while (y > 0) y -= (int)result->height;	503	while (y > 0) y -= (int)result->height;
558	layers[1].dst_y = y;	504	layers[1].dst_y = y;
559	layers[1].clip_height = result->height + target_height;	505	layers[1].clip_height = result->height + target_height;
560	}	506	}
…		…
562	{	508	{
563	layers[1].dst_y = y;	509	layers[1].dst_y = y;
564	layers[1].clip_height = result->height;	510	layers[1].clip_height = result->height;
565	}	511	}
566		512
567	if (target->rs[Rs_blendtype])	513	if (rs[Rs_blendtype])
568	{	514	{
569	layers[1].merge_scanlines = blend_scanlines_name2func (target->rs[Rs_blendtype]);	515	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
570	if (layers[1].merge_scanlines == NULL)	516	if (layers[1].merge_scanlines == NULL)
571	layers[1].merge_scanlines = alphablend_scanlines;	517	layers[1].merge_scanlines = alphablend_scanlines;
572	}	518	}
573		519
574	ASImage *tmp = merge_layers (target->asv, layers, 2, target_width, target_height,	520	ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
575	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);	521	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
576		522
577	if (tmp)	523	if (tmp)
578	{	524	{
579	if (result != original_asim)	525	if (result != original_asim)
…		…
592	{	538	{
593	XGCValues gcv;	539	XGCValues gcv;
594	GC gc;	540	GC gc;
595		541
596	/* create Pixmap */	542	/* create Pixmap */
597	if (pixmap == None	543	if (bg_pixmap == None
598	|| pmap_width != new_pmap_width	544	|| bg_pmap_width != new_pmap_width
599	|| pmap_height != new_pmap_height	545	|| bg_pmap_height != new_pmap_height)
600	|| pmap_depth != target->depth)
601	{	546	{
602	if (pixmap)	547	if (bg_pixmap)
603	XFreePixmap (target->dpy, pixmap);	548	XFreePixmap (dpy, bg_pixmap);
604	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);	549	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
605	pmap_width = new_pmap_width;	550	bg_pmap_width = new_pmap_width;
606	pmap_height = new_pmap_height;	551	bg_pmap_height = new_pmap_height;
607	pmap_depth = target->depth;
608	}	552	}
609	/* fill with background color (if result's not completely overlapping it) */	553	/* fill with background color (if result's not completely overlapping it) */
610	gcv.foreground = target->pix_colors[Color_bg];	554	gcv.foreground = pix_colors[Color_bg];
611	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);	555	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
612		556
613	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;	557	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
614	int dst_width = result->width, dst_height = result->height;	558	int dst_width = result->width, dst_height = result->height;
615	if (background == NULL)	559	if (background == NULL)
616	{	560	{
617	if (!(h_scale == 0 || v_scale == 0))	561	if (!(bg_flags & BG_TILE))
618	{	562	{
619	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );	563	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
620	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);	564	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
621	}	565	}
622		566
623	if (dst_x > 0 || dst_y > 0	567	if (dst_x > 0 || dst_y > 0
624	|| dst_x + dst_width < new_pmap_width	568	|| dst_x + dst_width < new_pmap_width
625	|| dst_y + dst_height < new_pmap_height)	569	|| dst_y + dst_height < new_pmap_height)
626	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	570	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
627	}	571	}
628		572
629	/* put result on pixmap */	573	/* put result on pixmap */
630	if (dst_x < new_pmap_width && dst_y < new_pmap_height)	574	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
631	asimage2drawable (target->asv, pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);	575	asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
632		576
633	if (result != background && result != original_asim)	577	if (result != background && result != original_asim)
634	destroy_asimage (&result);	578	destroy_asimage (&result);
635		579
636	XFreeGC (target->dpy, gc);	580	XFreeGC (dpy, gc);
637		581
638	ret = true;	582	ret = true;
639	}	583	}
640		584
641	if (background)	585	if (background)
…		…
645	}	589	}
646	# endif /* HAVE_AFTERIMAGE */	590	# endif /* HAVE_AFTERIMAGE */
647		591
648	# ifdef HAVE_PIXBUF	592	# ifdef HAVE_PIXBUF
649	bool	593	bool
650	bgPixmap_t::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,	594	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
651	int src_x, int src_y, int dst_x, int dst_y,	595	int src_x, int src_y, int dst_x, int dst_y,
652	unsigned int width, unsigned int height)	596	unsigned int width, unsigned int height)
653	{	597	{
654	XImage *ximage;	598	XImage *ximage;
655	char *data, *line;	599	char *data, *line;
656	int bytes_per_pixel;	600	int bytes_per_pixel;
657	int width_r, width_g, width_b;	601	int width_r, width_g, width_b;
658	int sh_r, sh_g, sh_b;	602	int sh_r, sh_g, sh_b;
659	int rowstride;	603	int rowstride;
660	int channels;	604	int channels;
661	unsigned char *row;	605	unsigned char *row;
662	Visual *visual = target->visual;
663	int depth = target->depth;
664		606
665	if (visual->c_class != TrueColor)	607	if (visual->c_class != TrueColor)
666	return false;	608	return false;
667		609
668	if (depth == 24 || depth == 32)	610	if (depth == 24 || depth == 32)
…		…
670	else if (depth == 15 || depth == 16)	612	else if (depth == 15 || depth == 16)
671	bytes_per_pixel = 2;	613	bytes_per_pixel = 2;
672	else	614	else
673	return false;	615	return false;
674		616
675	width_r = rxvt_popcount (visual->red_mask);	617	width_r = ecb_popcount32 (visual->red_mask);
676	width_g = rxvt_popcount (visual->green_mask);	618	width_g = ecb_popcount32 (visual->green_mask);
677	width_b = rxvt_popcount (visual->blue_mask);	619	width_b = ecb_popcount32 (visual->blue_mask);
678		620
679	if (width_r > 8 || width_g > 8 || width_b > 8)	621	if (width_r > 8 || width_g > 8 || width_b > 8)
680	return false;	622	return false;
681		623
682	sh_r = rxvt_ctz (visual->red_mask);	624	sh_r = ecb_ctz32 (visual->red_mask);
683	sh_g = rxvt_ctz (visual->green_mask);	625	sh_g = ecb_ctz32 (visual->green_mask);
684	sh_b = rxvt_ctz (visual->blue_mask);	626	sh_b = ecb_ctz32 (visual->blue_mask);
685		627
686	if (width > INT_MAX / height / bytes_per_pixel)	628	if (width > INT_MAX / height / bytes_per_pixel)
687	return false;	629	return false;
688		630
689	data = (char *)malloc (width * height * bytes_per_pixel);	631	data = (char *)malloc (width * height * bytes_per_pixel);
690	if (!data)	632	if (!data)
691	return false;	633	return false;
692		634
693	ximage = XCreateImage (target->dpy, visual, depth, ZPixmap, 0, data,	635	ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, data,
694	width, height, bytes_per_pixel * 8, 0);	636	width, height, bytes_per_pixel * 8, 0);
695	if (!ximage)	637	if (!ximage)
696	{	638	{
697	free (data);	639	free (data);
698	return false;	640	return false;
699	}	641	}
700		642
701	ximage->byte_order = byteorder::big_endian () ? MSBFirst : LSBFirst;	643	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
702		644
703	rowstride = gdk_pixbuf_get_rowstride (pixbuf);	645	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
704	channels = gdk_pixbuf_get_n_channels (pixbuf);	646	channels = gdk_pixbuf_get_n_channels (pixbuf);
705	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;	647	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
706	line = data;	648	line = data;
…		…
724		666
725	row += rowstride;	667	row += rowstride;
726	line += ximage->bytes_per_line;	668	line += ximage->bytes_per_line;
727	}	669	}
728		670
729	XPutImage (target->dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);	671	XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
730	XDestroyImage (ximage);	672	XDestroyImage (ximage);
731	return true;	673	return true;
732	}	674	}
733		675
734	bool	676	bool
735	bgPixmap_t::render_image (unsigned long background_flags)	677	rxvt_term::render_image (unsigned long tr_flags)
736	{	678	{
737	if (target == NULL)
738	return false;
739
740	if (!pixbuf)	679	if (!pixbuf)
741	return false;	680	return false;
742		681
743	if (background_flags	682	if (tr_flags
744	&& !(flags & HAS_RENDER))	683	&& !(bg_flags & BG_HAS_RENDER))
745	return false;	684	return false;
746		685
747	GdkPixbuf *result;	686	GdkPixbuf *result;
748		687
749	int image_width = gdk_pixbuf_get_width (pixbuf);	688	int image_width = gdk_pixbuf_get_width (pixbuf);
750	int image_height = gdk_pixbuf_get_height (pixbuf);	689	int image_height = gdk_pixbuf_get_height (pixbuf);
751		690
752	int target_width = target->szHint.width;	691	int target_width = szHint.width;
753	int target_height = target->szHint.height;	692	int target_height = szHint.height;
754	int new_pmap_width = target_width;	693	int new_pmap_width = target_width;
755	int new_pmap_height = target_height;	694	int new_pmap_height = target_height;
756		695
757	int x = 0;	696	int x = 0;
758	int y = 0;	697	int y = 0;
759	int w = 0;	698	int w = 0;
760	int h = 0;	699	int h = 0;
761		700
762	get_image_geometry (image_width, image_height, w, h, x, y);	701	get_image_geometry (image_width, image_height, w, h, x, y);
763		702
764	if (!(flags & rootAlign)	703	if (!(bg_flags & BG_ROOT_ALIGN)
765	&& (x >= target_width	704	&& (x >= target_width
766	|| y >= target_height	705	|| y >= target_height
767	|| (x + w <= 0)	706	|| x + w <= 0
768	|| (y + h <= 0)))	707	|| y + h <= 0))
769	return false;	708	return false;
770		709
771	result = pixbuf;	710	result = pixbuf;
772		711
773	if ((w != image_width)	712	if (w != image_width
774	|| (h != image_height))	713	|| h != image_height)
775	{	714	{
776	result = gdk_pixbuf_scale_simple (pixbuf,	715	result = gdk_pixbuf_scale_simple (pixbuf,
777	w, h,	716	w, h,
778	GDK_INTERP_BILINEAR);	717	GDK_INTERP_BILINEAR);
779	}	718	}
780		719
		720	if (!result)
		721	return false;
		722
781	bool ret = false;	723	bool ret = false;
782		724
783	if (result)
784	{
785	XGCValues gcv;	725	XGCValues gcv;
786	GC gc;	726	GC gc;
787	Pixmap root_pmap;	727	Pixmap root_pmap;
788		728
789	image_width = gdk_pixbuf_get_width (result);	729	image_width = gdk_pixbuf_get_width (result);
790	image_height = gdk_pixbuf_get_height (result);	730	image_height = gdk_pixbuf_get_height (result);
791		731
792	if (background_flags)	732	if (tr_flags)
793	{	733	{
794	root_pmap = pixmap;	734	root_pmap = bg_pixmap;
795	pixmap = None;	735	bg_pixmap = None;
		736	}
		737	else
		738	{
		739	if (bg_flags & BG_TILE)
796	}	740	{
797	else
798	{
799	if (h_scale == 0 || v_scale == 0)
800	{
801	new_pmap_width = min (image_width, target_width);	741	new_pmap_width = min (image_width, target_width);
802	new_pmap_height = min (image_height, target_height);	742	new_pmap_height = min (image_height, target_height);
803	}	743	}
804	}	744	}
805		745
806	if (pixmap == None	746	if (bg_pixmap == None
807	|| pmap_width != new_pmap_width	747	|| bg_pmap_width != new_pmap_width
808	|| pmap_height != new_pmap_height	748	|| bg_pmap_height != new_pmap_height)
809	|| pmap_depth != target->depth)	749	{
810	{
811	if (pixmap)	750	if (bg_pixmap)
812	XFreePixmap (target->dpy, pixmap);	751	XFreePixmap (dpy, bg_pixmap);
813	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);	752	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
814	pmap_width = new_pmap_width;	753	bg_pmap_width = new_pmap_width;
815	pmap_height = new_pmap_height;	754	bg_pmap_height = new_pmap_height;
816	pmap_depth = target->depth;	755	}
		756
		757	gcv.foreground = pix_colors[Color_bg];
		758	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
		759
		760	if (gc)
		761	{
		762	if (bg_flags & BG_TILE)
817	}	763	{
818
819	gcv.foreground = target->pix_colors[Color_bg];
820	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
821
822	if (h_scale == 0 || v_scale == 0)
823	{
824	Pixmap tile = XCreatePixmap (target->dpy, target->vt, image_width, image_height, target->depth);	764	Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);
825	pixbuf_to_pixmap (result, tile, gc,	765	pixbuf_to_pixmap (result, tile, gc,
826	0, 0,	766	0, 0,
827	0, 0,	767	0, 0,
828	image_width, image_height);	768	image_width, image_height);
829		769
830	gcv.tile = tile;	770	gcv.tile = tile;
831	gcv.fill_style = FillTiled;	771	gcv.fill_style = FillTiled;
832	gcv.ts_x_origin = x;	772	gcv.ts_x_origin = x;
833	gcv.ts_y_origin = y;	773	gcv.ts_y_origin = y;
834	XChangeGC (target->dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	774	XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
835		775
836	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	776	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
837	XFreePixmap (target->dpy, tile);	777	XFreePixmap (dpy, tile);
838	}	778	}
839	else	779	else
840	{	780	{
841	int src_x, src_y, dst_x, dst_y;	781	int src_x, src_y, dst_x, dst_y;
842	int dst_width, dst_height;	782	int dst_width, dst_height;
…		…
845	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);	785	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
846		786
847	if (dst_x > 0 || dst_y > 0	787	if (dst_x > 0 || dst_y > 0
848	|| dst_x + dst_width < new_pmap_width	788	|| dst_x + dst_width < new_pmap_width
849	|| dst_y + dst_height < new_pmap_height)	789	|| dst_y + dst_height < new_pmap_height)
850	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	790	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
851		791
852	if (dst_x < new_pmap_width && dst_y < new_pmap_height)	792	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
853	pixbuf_to_pixmap (result, pixmap, gc,	793	pixbuf_to_pixmap (result, bg_pixmap, gc,
854	src_x, src_y,	794	src_x, src_y,
855	dst_x, dst_y,	795	dst_x, dst_y,
856	dst_width, dst_height);	796	dst_width, dst_height);
857	}	797	}
858		798
859	#if XRENDER	799	#if XRENDER
860	if (background_flags)	800	if (tr_flags)
861	{	801	{
862	Display *dpy = target->dpy;
863	XRenderPictureAttributes pa;
864
865	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, target->visual);	802	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		803
866	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	804	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
867		805
868	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
869	Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa);	806	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
870		807
871	pa.repeat = True;	808	Picture mask = create_xrender_mask (dpy, vt, False, False);
872	Pixmap mask_pmap = XCreatePixmap (dpy, target->vt, 1, 1, 8);
873	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
874	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
875	XFreePixmap (dpy, mask_pmap);
876		809
877	if (src && dst && mask)
878	{
879	XRenderColor mask_c;	810	XRenderColor mask_c;
880		811
881	mask_c.alpha = 0x8000;	812	mask_c.alpha = 0x8000;
882	mask_c.red = 0;	813	mask_c.red =
883	mask_c.green = 0;	814	mask_c.green =
884	mask_c.blue = 0;	815	mask_c.blue = 0;
885	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	816	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		817
886	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	818	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
887	}
888		819
889	XRenderFreePicture (dpy, src);	820	XRenderFreePicture (dpy, src);
890	XRenderFreePicture (dpy, dst);	821	XRenderFreePicture (dpy, dst);
891	XRenderFreePicture (dpy, mask);	822	XRenderFreePicture (dpy, mask);
892
893	XFreePixmap (dpy, root_pmap);
894	}	823	}
895	#endif	824	#endif
896		825
897	if (result != pixbuf)
898	g_object_unref (result);
899
900	XFreeGC (target->dpy, gc);	826	XFreeGC (dpy, gc);
901		827
902	ret = true;	828	ret = true;
903	}	829	}
904		830
		831	if (result != pixbuf)
		832	g_object_unref (result);
		833
		834	if (tr_flags)
		835	XFreePixmap (dpy, root_pmap);
		836
905	return ret;	837	return ret;
906	}	838	}
907	# endif /* HAVE_PIXBUF */	839	# endif /* HAVE_PIXBUF */
908		840
909	bool	841	bool
910	bgPixmap_t::set_file (const char *file)	842	rxvt_term::bg_set_file (const char *file)
911	{	843	{
912	if (!file || !*file)	844	if (!file || !*file)
913	return false;	845	return false;
914		846
		847	bool ret = false;
915	if (const char *p = strchr (file, ';'))	848	const char *p = strchr (file, ';');
		849
		850	if (p)
916	{	851	{
917	size_t len = p - file;	852	size_t len = p - file;
918	char *f = rxvt_temp_buf<char> (len + 1);	853	char *f = rxvt_temp_buf<char> (len + 1);
919	memcpy (f, file, len);	854	memcpy (f, file, len);
920	f[len] = '\0';	855	f[len] = '\0';
921	file = f;	856	file = f;
922	}	857	}
923		858
924	# ifdef HAVE_AFTERIMAGE	859	# ifdef HAVE_AFTERIMAGE
925	if (!target->asimman)	860	if (!asimman)
926	target->asimman = create_generic_imageman (target->rs[Rs_path]);	861	asimman = create_generic_imageman (rs[Rs_path]);
927	ASImage *image = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);	862	ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
928	if (image)	863	if (image)
929	{	864	{
930	if (original_asim)	865	if (original_asim)
931	safe_asimage_destroy (original_asim);	866	safe_asimage_destroy (original_asim);
932	original_asim = image;	867	original_asim = image;
933	flags |= CLIENT_RENDER;	868	bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
934	have_image = true;
935	return true;	869	ret = true;
936	}	870	}
937	# endif	871	# endif
938		872
939	# ifdef HAVE_PIXBUF	873	# ifdef HAVE_PIXBUF
940	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	874	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
941	if (image)	875	if (image)
942	{	876	{
943	if (pixbuf)	877	if (pixbuf)
944	g_object_unref (pixbuf);	878	g_object_unref (pixbuf);
945	pixbuf = image;	879	pixbuf = image;
946	have_image = true;	880	bg_flags |= BG_IS_FROM_FILE;
947	return true;	881	ret = true;
948	}	882	}
949	# endif	883	# endif
950		884
		885	if (ret)
		886	{
		887	if (p)
		888	bg_set_geometry (p + 1);
		889	else
		890	bg_set_default_geometry ();
		891	}
		892
951	return false;	893	return ret;
952	}	894	}
953		895
954	# endif /* BG_IMAGE_FROM_FILE */	896	# endif /* BG_IMAGE_FROM_FILE */
955		897
956	# ifdef ENABLE_TRANSPARENCY	898	# ifdef ENABLE_TRANSPARENCY
957	bool	899	bool
958	bgPixmap_t::set_transparent ()	900	rxvt_term::bg_set_transparent ()
959	{	901	{
960	if (!(flags & isTransparent))	902	if (!(bg_flags & BG_IS_TRANSPARENT))
961	{	903	{
962	flags |= isTransparent;	904	bg_flags |= BG_IS_TRANSPARENT;
963	return true;	905	return true;
964	}	906	}
965		907
966	return false;	908	return false;
967	}	909	}
968		910
969	bool	911	bool
970	bgPixmap_t::set_blur_radius (const char *geom)	912	rxvt_term::bg_set_blur (const char *geom)
971	{	913	{
972	bool changed = false;	914	bool changed = false;
973	unsigned int hr, vr;	915	unsigned int hr, vr;
974	int junk;	916	int junk;
975	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);	917	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
…		…
992	{	934	{
993	changed = true;	935	changed = true;
994	v_blurRadius = vr;	936	v_blurRadius = vr;
995	}	937	}
996		938
997	if (v_blurRadius == 0 && h_blurRadius == 0)	939	if (h_blurRadius == 0 || v_blurRadius == 0)
998	flags &= ~blurNeeded;	940	bg_flags &= ~BG_NEEDS_BLUR;
999	else	941	else
1000	flags |= blurNeeded;	942	bg_flags |= BG_NEEDS_BLUR;
1001		943
1002	return changed;	944	return changed;
1003	}	945	}
1004		946
1005	static inline unsigned long	947	void
1006	compute_tint_shade_flags (rxvt_color *tint, int shade)	948	rxvt_term::set_tint_shade_flags ()
1007	{	949	{
1008	unsigned long flags = 0;	950	rgba c;
1009	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1010	bool has_shade = shade != 100;	951	bool has_shade = shade != 100;
1011		952
1012	if (tint)	953	bg_flags &= ~BG_TINT_FLAGS;
		954
		955	if (bg_flags & BG_TINT_SET)
1013	{	956	{
1014	tint->get (c);	957	tint.get (c);
1015	if (!has_shade	958	if (!has_shade
1016	&& (c.r <= 0x00ff || c.r >= 0xff00)	959	&& (c.r <= 0x00ff || c.r >= 0xff00)
1017	&& (c.g <= 0x00ff || c.g >= 0xff00)	960	&& (c.g <= 0x00ff || c.g >= 0xff00)
1018	&& (c.b <= 0x00ff || c.b >= 0xff00))	961	&& (c.b <= 0x00ff || c.b >= 0xff00))
1019	flags |= bgPixmap_t::tintWholesome;	962	bg_flags |= BG_TINT_BITAND;
1020	}	963	}
1021		964
1022	if (has_shade || tint)	965	if (has_shade || (bg_flags & BG_TINT_SET))
1023	flags |= bgPixmap_t::tintNeeded;	966	bg_flags |= BG_NEEDS_TINT;
1024
1025	return flags;
1026	}	967	}
1027		968
1028	bool	969	bool
1029	bgPixmap_t::set_tint (rxvt_color &new_tint)	970	rxvt_term::bg_set_tint (rxvt_color &new_tint)
1030	{	971	{
1031	if (!(flags & tintSet) || tint != new_tint)	972	if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
1032	{	973	{
1033	unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
1034	tint = new_tint;	974	tint = new_tint;
1035	flags = (flags & ~tintFlags) | new_flags | tintSet;	975	bg_flags |= BG_TINT_SET;
		976	set_tint_shade_flags ();
1036	return true;	977	return true;
1037	}	978	}
1038		979
1039	return false;	980	return false;
1040	}	981	}
1041		982
1042	bool	983	bool
1043	bgPixmap_t::set_shade (const char *shade_str)	984	rxvt_term::bg_set_shade (const char *shade_str)
1044	{	985	{
1045	int new_shade = (shade_str) ? atoi (shade_str) : 100;	986	int new_shade = atoi (shade_str);
1046		987
1047	clamp_it (new_shade, -100, 200);	988	clamp_it (new_shade, -100, 200);
1048	if (new_shade < 0)	989	if (new_shade < 0)
1049	new_shade = 200 - (100 + new_shade);	990	new_shade = 200 - (100 + new_shade);
1050		991
1051	if (new_shade != shade)	992	if (new_shade != shade)
1052	{	993	{
1053	unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
1054	shade = new_shade;	994	shade = new_shade;
1055	flags = (flags & (~tintFlags | tintSet)) | new_flags;	995	set_tint_shade_flags ();
1056	return true;	996	return true;
1057	}	997	}
1058		998
1059	return false;	999	return false;
1060	}	1000	}
…		…
1081	params[i+2] = XDoubleToFixed (kernel[i] / sum);	1021	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1082	}	1022	}
1083	#endif	1023	#endif
1084		1024
1085	bool	1025	bool
1086	bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	1026	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1087	{	1027	{
1088	bool ret = false;	1028	bool ret = false;
1089	#if XRENDER	1029	#if XRENDER
		1030	if (!(bg_flags & BG_HAS_RENDER_CONV))
		1031	return false;
		1032
1090	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	1033	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1091	double *kernel = (double *)malloc (size * sizeof (double));	1034	double *kernel = (double *)malloc (size * sizeof (double));
1092	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));	1035	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1093		1036
1094	Display *dpy = target->dpy;
1095	XRenderPictureAttributes pa;	1037	XRenderPictureAttributes pa;
1096	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1038	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1097		1039
		1040	pa.repeat = RepeatPad;
1098	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1041	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		1042	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1099	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1043	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		1044	XFreePixmap (dpy, tmp);
1100		1045
1101	if (kernel && params && src && dst)	1046	if (kernel && params)
1102	{	1047	{
1103	if (h_blurRadius)
1104	{
1105	size = h_blurRadius * 2 + 1;	1048	size = h_blurRadius * 2 + 1;
1106	get_gaussian_kernel (h_blurRadius, size, kernel, params);	1049	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1107		1050
1108	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1051	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1109	XRenderComposite (dpy,	1052	XRenderComposite (dpy,
1110	PictOpSrc,	1053	PictOpSrc,
1111	src,	1054	src,
1112	None,	1055	None,
1113	dst,	1056	dst,
1114	0, 0,	1057	0, 0,
1115	0, 0,	1058	0, 0,
1116	0, 0,	1059	0, 0,
1117	width, height);	1060	width, height);
1118	}
1119		1061
1120	if (v_blurRadius)	1062	::swap (src, dst);
1121	{	1063
1122	size = v_blurRadius * 2 + 1;	1064	size = v_blurRadius * 2 + 1;
1123	get_gaussian_kernel (v_blurRadius, size, kernel, params);	1065	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1124	swap (params[0], params[1]);	1066	::swap (params[0], params[1]);
1125		1067
1126	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1068	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1127	XRenderComposite (dpy,	1069	XRenderComposite (dpy,
1128	PictOpSrc,	1070	PictOpSrc,
1129	src,	1071	src,
1130	None,	1072	None,
1131	dst,	1073	dst,
1132	0, 0,	1074	0, 0,
1133	0, 0,	1075	0, 0,
1134	0, 0,	1076	0, 0,
1135	width, height);	1077	width, height);
1136	}
1137		1078
1138	ret = true;	1079	ret = true;
1139	}	1080	}
1140		1081
1141	free (kernel);	1082	free (kernel);
…		…
1145	#endif	1086	#endif
1146	return ret;	1087	return ret;
1147	}	1088	}
1148		1089
1149	bool	1090	bool
1150	bgPixmap_t::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	1091	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1151	{	1092	{
1152	Display *dpy = target->dpy;
1153	bool ret = false;	1093	bool ret = false;
1154		1094
1155	if (flags & tintWholesome)	1095	if (bg_flags & BG_TINT_BITAND)
1156	{	1096	{
1157	XGCValues gcv;	1097	XGCValues gcv;
1158	GC gc;	1098	GC gc;
1159		1099
1160	/* In this case we can tint image server-side getting significant	1100	/* In this case we can tint image server-side getting significant
…		…
1169	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	1109	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1170	ret = true;	1110	ret = true;
1171	XFreeGC (dpy, gc);	1111	XFreeGC (dpy, gc);
1172	}	1112	}
1173	}	1113	}
1174	else
1175	{
1176	# if XRENDER	1114	# if XRENDER
		1115	else if (bg_flags & BG_HAS_RENDER)
		1116	{
1177	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	1117	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1178		1118
1179	if (flags & tintSet)	1119	if (bg_flags & BG_TINT_SET)
1180	tint.get (c);	1120	tint.get (c);
1181		1121
1182	if (shade <= 100)	1122	if (shade <= 100)
1183	{	1123	{
1184	c.r = (c.r * shade) / 100;	1124	c.r = c.r * shade / 100;
1185	c.g = (c.g * shade) / 100;	1125	c.g = c.g * shade / 100;
1186	c.b = (c.b * shade) / 100;	1126	c.b = c.b * shade / 100;
1187	}	1127	}
1188	else	1128	else
1189	{	1129	{
1190	c.r = (c.r * (200 - shade)) / 100;	1130	c.r = c.r * (200 - shade) / 100;
1191	c.g = (c.g * (200 - shade)) / 100;	1131	c.g = c.g * (200 - shade) / 100;
1192	c.b = (c.b * (200 - shade)) / 100;	1132	c.b = c.b * (200 - shade) / 100;
1193	}	1133	}
1194		1134
1195	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1196	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1135	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1197	XRenderPictureAttributes pa;
1198		1136
1199	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1137	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1200		1138
1201	pa.repeat = True;	1139	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1202		1140
1203	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	1141	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1204	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1205	XFreePixmap (dpy, overlay_pmap);
1206		1142
1207	pa.component_alpha = True;
1208	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1209	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
1210	XFreePixmap (dpy, mask_pmap);
1211
1212	if (mask_pic && overlay_pic && back_pic)
1213	{
1214	XRenderColor mask_c;	1143	XRenderColor mask_c;
1215		1144
1216	mask_c.red = mask_c.green = mask_c.blue = 0;
1217	mask_c.alpha = 0xffff;	1145	mask_c.alpha = 0xffff;
		1146	mask_c.red =
		1147	mask_c.green =
		1148	mask_c.blue = 0;
		1149	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
		1150
		1151	mask_c.alpha = 0;
		1152	mask_c.red = 0xffff - c.r;
		1153	mask_c.green = 0xffff - c.g;
		1154	mask_c.blue = 0xffff - c.b;
		1155	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		1156
		1157	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
		1158
		1159	if (shade > 100)
		1160	{
		1161	mask_c.alpha = 0;
		1162	mask_c.red =
		1163	mask_c.green =
		1164	mask_c.blue = 0xffff * (shade - 100) / 100;
1218	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	1165	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1219		1166
1220	mask_c.alpha = 0;
1221	mask_c.red = 0xffff - c.r;
1222	mask_c.green = 0xffff - c.g;
1223	mask_c.blue = 0xffff - c.b;
1224	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1225	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1226
1227	if (shade > 100)
1228	{
1229	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1230	mask_c.alpha = 0;
1231	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1232
1233	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);	1167	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1234	}	1168	}
1235		1169
1236	ret = true;	1170	ret = true;
1237	}
1238		1171
1239	XRenderFreePicture (dpy, mask_pic);	1172	XRenderFreePicture (dpy, mask_pic);
1240	XRenderFreePicture (dpy, overlay_pic);	1173	XRenderFreePicture (dpy, overlay_pic);
1241	XRenderFreePicture (dpy, back_pic);	1174	XRenderFreePicture (dpy, back_pic);
		1175	}
1242	# endif	1176	# endif
1243	}
1244		1177
1245	return ret;	1178	return ret;
1246	}	1179	}
1247		1180
1248	/* make_transparency_pixmap()	1181	/*
1249	* Builds a pixmap of the same size as the terminal window that contains	1182	* Builds a pixmap of the same size as the terminal window that contains
1250	* the tiled portion of the root pixmap that is supposed to be covered by	1183	* the tiled portion of the root pixmap that is supposed to be covered by
1251	* our window.	1184	* our window.
1252	*/	1185	*/
1253	unsigned long	1186	unsigned long
1254	bgPixmap_t::make_transparency_pixmap ()	1187	rxvt_term::make_transparency_pixmap ()
1255	{	1188	{
1256	unsigned long result = 0;	1189	unsigned long result = 0;
1257
1258	if (target == NULL)
1259	return 0;
1260		1190
1261	/* root dimensions may change from call to call - but Display structure should	1191	/* root dimensions may change from call to call - but Display structure should
1262	* be always up-to-date, so let's use it :	1192	* be always up-to-date, so let's use it :
1263	*/	1193	*/
1264	int screen = target->display->screen;	1194	int screen = display->screen;
1265	Display *dpy = target->dpy;
1266	int root_depth = DefaultDepth (dpy, screen);	1195	int root_depth = DefaultDepth (dpy, screen);
1267	int root_width = DisplayWidth (dpy, screen);	1196	int root_width = DisplayWidth (dpy, screen);
1268	int root_height = DisplayHeight (dpy, screen);	1197	int root_height = DisplayHeight (dpy, screen);
1269	unsigned int root_pmap_width, root_pmap_height;	1198	unsigned int root_pmap_width, root_pmap_height;
1270	int window_width = target->szHint.width;	1199	int window_width = szHint.width;
1271	int window_height = target->szHint.height;	1200	int window_height = szHint.height;
1272	int sx, sy;	1201	int sx, sy;
1273	XGCValues gcv;	1202	XGCValues gcv;
1274	GC gc;	1203	GC gc;
1275		1204
1276	sx = target_x;	1205	sx = target_x;
…		…
1286	{	1215	{
1287	Window wdummy;	1216	Window wdummy;
1288	int idummy;	1217	int idummy;
1289	unsigned int udummy;	1218	unsigned int udummy;
1290		1219
1291	target->allowedxerror = -1;	1220	allowedxerror = -1;
1292		1221
1293	if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))	1222	if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))
1294	root_pixmap = None;	1223	root_pixmap = None;
1295		1224
1296	target->allowedxerror = 0;	1225	allowedxerror = 0;
1297	}	1226	}
1298		1227
1299	Pixmap recoded_root_pmap = root_pixmap;	1228	Pixmap recoded_root_pmap = root_pixmap;
1300		1229
1301	if (root_pixmap != None && root_depth != target->depth)	1230	if (root_pixmap != None && root_depth != depth)
1302	{	1231	{
1303	#if XRENDER	1232	#if XRENDER
1304	if (flags & HAS_RENDER)	1233	if (bg_flags & BG_HAS_RENDER)
1305	{	1234	{
1306	XRenderPictureAttributes pa;	1235	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1307		1236
1308	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	1237	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1309	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	1238	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1310		1239
1311	recoded_root_pmap = XCreatePixmap (dpy, target->vt, root_pmap_width, root_pmap_height, target->depth);
1312	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);	1240	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1313	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	1241	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1314		1242
1315	if (src && dst)
1316	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	1243	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1317	else
1318	{
1319	XFreePixmap (dpy, recoded_root_pmap);
1320	root_pixmap = None;
1321	}
1322		1244
1323	XRenderFreePicture (dpy, src);	1245	XRenderFreePicture (dpy, src);
1324	XRenderFreePicture (dpy, dst);	1246	XRenderFreePicture (dpy, dst);
1325	}	1247	}
1326	else	1248	else
1327	#endif	1249	#endif
1328	root_pixmap = None;	1250	recoded_root_pmap = None;
1329	}	1251	}
1330		1252
1331	if (root_pixmap == None)	1253	if (recoded_root_pmap == None)
1332	return 0;	1254	return 0;
1333		1255
		1256	if (bg_pixmap == None
		1257	|| bg_pmap_width != window_width
		1258	|| bg_pmap_height != window_height)
		1259	{
		1260	if (bg_pixmap)
		1261	XFreePixmap (dpy, bg_pixmap);
1334	Pixmap tiled_root_pmap = XCreatePixmap (dpy, target->vt, window_width, window_height, target->depth);	1262	bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
1335		1263	bg_pmap_width = window_width;
1336	if (tiled_root_pmap == None) /* something really bad happened - abort */	1264	bg_pmap_height = window_height;
1337	return 0;	1265	}
1338		1266
1339	/* straightforward pixmap copy */	1267	/* straightforward pixmap copy */
1340	while (sx < 0) sx += (int)root_width;	1268	while (sx < 0) sx += root_pmap_width;
1341	while (sy < 0) sy += (int)root_height;	1269	while (sy < 0) sy += root_pmap_height;
1342		1270
1343	gcv.tile = recoded_root_pmap;	1271	gcv.tile = recoded_root_pmap;
1344	gcv.fill_style = FillTiled;	1272	gcv.fill_style = FillTiled;
1345	gcv.ts_x_origin = -sx;	1273	gcv.ts_x_origin = -sx;
1346	gcv.ts_y_origin = -sy;	1274	gcv.ts_y_origin = -sy;
1347	gc = XCreateGC (dpy, target->vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	1275	gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1348		1276
1349	if (gc)	1277	if (gc)
1350	{	1278	{
1351	XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);	1279	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1352	result |= transpPmapTiled;	1280	result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS);
		1281
		1282	if (!(bg_flags & BG_CLIENT_RENDER))
		1283	{
		1284	if (bg_flags & BG_NEEDS_BLUR)
		1285	{
		1286	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
		1287	result &= ~BG_NEEDS_BLUR;
		1288	}
		1289	if (bg_flags & BG_NEEDS_TINT)
		1290	{
		1291	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
		1292	result &= ~BG_NEEDS_TINT;
		1293	}
		1294	# ifndef HAVE_AFTERIMAGE
		1295	if (result & BG_NEEDS_TINT)
		1296	{
		1297	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1298	if (ximage)
		1299	{
		1300	/* our own client-side tinting */
		1301	tint_ximage (DefaultVisual (dpy, display->screen), ximage);
		1302
		1303	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1304	XDestroyImage (ximage);
		1305	}
		1306	}
		1307	# endif
		1308	} /* server side rendering completed */
		1309
1353	XFreeGC (dpy, gc);	1310	XFreeGC (dpy, gc);
1354
1355	if (!(flags & CLIENT_RENDER))
1356	{
1357	if ((flags & blurNeeded)
1358	&& (flags & HAS_RENDER_CONV))
1359	{
1360	if (blur_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1361	result |= transpPmapBlurred;
1362	}
1363	if ((flags & tintNeeded)
1364	&& (flags & (tintWholesome | HAS_RENDER)))
1365	{
1366	if (tint_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1367	result |= transpPmapTinted;
1368	}
1369	} /* server side rendering completed */
1370
1371	if (pixmap)
1372	XFreePixmap (dpy, pixmap);
1373
1374	pixmap = tiled_root_pmap;
1375	pmap_width = window_width;
1376	pmap_height = window_height;
1377	pmap_depth = target->depth;
1378	}	1311	}
1379	else
1380	XFreePixmap (dpy, tiled_root_pmap);
1381		1312
1382	if (recoded_root_pmap != root_pixmap)	1313	if (recoded_root_pmap != root_pixmap)
1383	XFreePixmap (dpy, recoded_root_pmap);	1314	XFreePixmap (dpy, recoded_root_pmap);
1384		1315
1385	return result;	1316	return result;
1386	}	1317	}
1387		1318
1388	void	1319	void
1389	bgPixmap_t::set_root_pixmap ()	1320	rxvt_term::bg_set_root_pixmap ()
1390	{	1321	{
1391	Pixmap new_root_pixmap = target->get_pixmap_property (target->xa[XA_XROOTPMAP_ID]);	1322	Pixmap new_root_pixmap = get_pixmap_property (xa[XA_XROOTPMAP_ID]);
1392	if (new_root_pixmap == None)	1323	if (new_root_pixmap == None)
1393	new_root_pixmap = target->get_pixmap_property (target->xa[XA_ESETROOT_PMAP_ID]);	1324	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1394		1325
1395	root_pixmap = new_root_pixmap;	1326	root_pixmap = new_root_pixmap;
1396	}	1327	}
1397	# endif /* ENABLE_TRANSPARENCY */	1328	# endif /* ENABLE_TRANSPARENCY */
1398		1329
1399	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1330	bool
1400	static void shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c);	1331	rxvt_term::bg_render ()
		1332	{
		1333	unsigned long tr_flags = 0;
		1334
		1335	bg_invalidate ();
		1336	# ifdef ENABLE_TRANSPARENCY
		1337	if (bg_flags & BG_IS_TRANSPARENT)
		1338	{
		1339	/* we need to re-generate transparency pixmap in that case ! */
		1340	tr_flags = make_transparency_pixmap ();
		1341	if (tr_flags)
		1342	bg_flags |= BG_IS_VALID;
		1343	}
1401	# endif	1344	# endif
1402		1345
1403	bool	1346	# ifdef BG_IMAGE_FROM_FILE
1404	bgPixmap_t::render ()	1347	if ((bg_flags & BG_IS_FROM_FILE)
1405	{	1348	|| (tr_flags & BG_EFFECTS_FLAGS))
1406	unsigned long background_flags = 0;
1407
1408	if (target == NULL)
1409	return false;
1410
1411	invalidate ();
1412	# ifdef ENABLE_TRANSPARENCY
1413	if (flags & isTransparent)
1414	{	1349	{
1415	/* we need to re-generate transparency pixmap in that case ! */	1350	if (render_image (tr_flags))
1416	background_flags = make_transparency_pixmap ();	1351	bg_flags |= BG_IS_VALID;
1417	if (background_flags == 0)
1418	return false;
1419	else if ((background_flags & transpTransformations) == (flags & transpTransformations))
1420	flags &= ~isInvalid;
1421	}	1352	}
1422	# endif	1353	# endif
1423		1354
1424	# ifdef BG_IMAGE_FROM_FILE	1355	if (!(bg_flags & BG_IS_VALID))
1425	if (have_image
1426	|| (background_flags & transpTransformations) != (flags & transpTransformations))
1427	{
1428	if (render_image (background_flags))
1429	flags &= ~isInvalid;
1430	}	1356	{
1431	# endif
1432
1433	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1434	XImage *result = NULL;
1435
1436	if (background_flags && (flags & isInvalid))
1437	{
1438	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1439	}
1440
1441	if (result)
1442	{
1443	/* our own client-side tinting */
1444	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1445	{
1446	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1447	if (flags & tintSet)
1448	tint.get (c);
1449	shade_ximage (DefaultVisual (target->dpy, target->display->screen), result, shade, c);
1450	}
1451
1452	GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1453
1454	if (gc)
1455	{
1456	XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1457
1458	XFreeGC (target->dpy, gc);
1459	flags &= ~isInvalid;
1460	}
1461
1462	XDestroyImage (result);
1463	}
1464	# endif
1465
1466	if (flags & isInvalid)
1467	{
1468	if (pixmap != None)	1357	if (bg_pixmap != None)
1469	{	1358	{
1470	XFreePixmap (target->dpy, pixmap);	1359	XFreePixmap (dpy, bg_pixmap);
1471	pixmap = None;	1360	bg_pixmap = None;
1472	}	1361	}
1473	}	1362	}
1474		1363
1475	apply ();	1364	scr_recolour (false);
		1365	bg_flags |= BG_NEEDS_REFRESH;
1476		1366
1477	valid_since = ev::now ();	1367	bg_valid_since = ev::now ();
1478		1368
1479	return true;	1369	return true;
1480	}	1370	}
1481		1371
1482	void	1372	void
1483	bgPixmap_t::set_target (rxvt_term *new_target)	1373	rxvt_term::bg_init ()
1484	{	1374	{
1485	target = new_target;	1375	#ifdef ENABLE_TRANSPARENCY
		1376	shade = 100;
		1377	#endif
1486		1378
1487	flags &= ~(HAS_RENDER | HAS_RENDER_CONV);	1379	bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1488	#if XRENDER	1380	#if XRENDER
1489	int major, minor;	1381	int major, minor;
1490	if (XRenderQueryVersion (target->dpy, &major, &minor))	1382	if (XRenderQueryVersion (dpy, &major, &minor))
1491	flags |= HAS_RENDER;	1383	bg_flags |= BG_HAS_RENDER;
1492	XFilters *filters = XRenderQueryFilters (target->dpy, target->vt);	1384	XFilters *filters = XRenderQueryFilters (dpy, vt);
1493	if (filters)	1385	if (filters)
1494	{	1386	{
1495	for (int i = 0; i < filters->nfilter; i++)	1387	for (int i = 0; i < filters->nfilter; i++)
1496	if (!strcmp (filters->filter[i], FilterConvolution))	1388	if (!strcmp (filters->filter[i], FilterConvolution))
1497	flags |= HAS_RENDER_CONV;	1389	bg_flags |= BG_HAS_RENDER_CONV;
1498		1390
1499	XFree (filters);	1391	XFree (filters);
1500	}	1392	}
1501	#endif	1393	#endif
1502	}	1394	}
1503		1395
		1396	#endif /* HAVE_BG_PIXMAP */
		1397
		1398	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
		1399	/* based on code from aterm-0.4.2 */
		1400
		1401	static inline void
		1402	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
		1403	{
		1404	for (int i = 0; i <= mask >> sh; i++)
		1405	{
		1406	uint32_t tmp;
		1407	tmp = i * high;
		1408	tmp += (mask >> sh) * low;
		1409	lookup[i] = (tmp / 0xffff) << sh;
		1410	}
		1411	}
		1412
1504	void	1413	void
1505	bgPixmap_t::apply ()	1414	rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1506	{
1507	if (target == NULL)
1508	return;
1509
1510	if (pixmap != None)
1511	{
1512	/* set target's background to pixmap */
1513	# ifdef ENABLE_TRANSPARENCY
1514	if (flags & isTransparent)
1515	{
1516	XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
1517	XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
1518
1519	if (target->scrollBar.win)
1520	XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1521	}
1522	else
1523	# endif
1524	{
1525	/* force old pixmap dereference in case it was transparent before :*/
1526	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1527	XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1528	/* do we also need to set scrollbar's background here ? */
1529
1530	if (target->scrollBar.win)
1531	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1532	}
1533	}
1534	else
1535	{
1536	/* set target background to a pixel */
1537	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1538	XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
1539	/* do we also need to set scrollbar's background here ? */
1540	if (target->scrollBar.win)
1541	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1542	}
1543
1544	/* don't want Expose on the parent or vt. It is better to use
1545	scr_touch or we get a great deal of flicker otherwise: */
1546	XClearWindow (target->dpy, target->parent[0]);
1547
1548	if (target->scrollBar.state && target->scrollBar.win)
1549	{
1550	target->scrollBar.state = STATE_IDLE;
1551	target->scrollBar.show (0);
1552	}
1553
1554	target->want_refresh = 1;
1555	flags |= hasChanged;
1556	}
1557
1558	#endif /* HAVE_BG_PIXMAP */
1559
1560	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1561	/* taken from aterm-0.4.2 */
1562
1563	static void
1564	shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c)
1565	{	1415	{
1566	int sh_r, sh_g, sh_b;	1416	int sh_r, sh_g, sh_b;
1567	uint32_t mask_r, mask_g, mask_b;	1417	uint32_t mask_r, mask_g, mask_b;
1568	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;	1418	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1569	rgba low;	1419	unsigned short low;
1570	rgba high;
1571	int i;
1572	int host_byte_order = byteorder::big_endian () ? MSBFirst : LSBFirst;	1420	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1573		1421
1574	if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;	1422	if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1575		1423
1576	/* for convenience */	1424	/* for convenience */
1577	mask_r = visual->red_mask;	1425	mask_r = visual->red_mask;
…		…
1635	break;	1483	break;
1636	default:	1484	default:
1637	return; /* we do not support this color depth */	1485	return; /* we do not support this color depth */
1638	}	1486	}
1639		1487
		1488	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
		1489
		1490	if (bg_flags & BG_TINT_SET)
		1491	tint.get (c);
		1492
1640	/* prepare limits for color transformation (each channel is handled separately) */	1493	/* prepare limits for color transformation (each channel is handled separately) */
1641	if (shade > 100)	1494	if (shade > 100)
1642	{	1495	{
1643	shade = 200 - shade;
1644
1645	high.r = c.r * shade / 100;
1646	high.g = c.g * shade / 100;
1647	high.b = c.b * shade / 100;
1648
1649	low.r = 65535 * (100 - shade) / 100;	1496	c.r = c.r * (200 - shade) / 100;
1650	low.g = 65535 * (100 - shade) / 100;	1497	c.g = c.g * (200 - shade) / 100;
1651	low.b = 65535 * (100 - shade) / 100;	1498	c.b = c.b * (200 - shade) / 100;
		1499
		1500	low = 0xffff * (shade - 100) / 100;
1652	}	1501	}
1653	else	1502	else
1654	{	1503	{
1655	high.r = c.r * shade / 100;	1504	c.r = c.r * shade / 100;
1656	high.g = c.g * shade / 100;	1505	c.g = c.g * shade / 100;
1657	high.b = c.b * shade / 100;	1506	c.b = c.b * shade / 100;
1658		1507
1659	low.r = low.g = low.b = 0;	1508	low = 0;
1660	}	1509	}
1661		1510
1662	/* fill our lookup tables */	1511	/* fill our lookup tables */
1663	for (i = 0; i <= mask_r>>sh_r; i++)	1512	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1664	{	1513	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1665	uint32_t tmp;	1514	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1666	tmp = i * high.r;
1667	tmp += (mask_r>>sh_r) * low.r;
1668	lookup_r[i] = (tmp/65535)<<sh_r;
1669	}
1670	for (i = 0; i <= mask_g>>sh_g; i++)
1671	{
1672	uint32_t tmp;
1673	tmp = i * high.g;
1674	tmp += (mask_g>>sh_g) * low.g;
1675	lookup_g[i] = (tmp/65535)<<sh_g;
1676	}
1677	for (i = 0; i <= mask_b>>sh_b; i++)
1678	{
1679	uint32_t tmp;
1680	tmp = i * high.b;
1681	tmp += (mask_b>>sh_b) * low.b;
1682	lookup_b[i] = (tmp/65535)<<sh_b;
1683	}
1684		1515
1685	/* apply table to input image (replacing colors by newly calculated ones) */	1516	/* apply table to input image (replacing colors by newly calculated ones) */
1686	if (ximage->bits_per_pixel == 32	1517	if (ximage->bits_per_pixel == 32
1687	&& (ximage->depth == 24 || ximage->depth == 32)	1518	&& (ximage->depth == 24 || ximage->depth == 32)
1688	&& ximage->byte_order == host_byte_order)	1519	&& ximage->byte_order == host_byte_order)

Diff Legend

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