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

Diff Legend

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