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

Diff Legend

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