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

Diff Legend

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