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

Diff Legend

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