ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

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

Diff Legend

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