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.123 by sf-exg, Tue Nov 23 08:37:37 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 || tint)
955	flags |= bgPixmap_t::tintNeeded;
956
957	return flags;
958	}
959
960	bool
961	bgPixmap_t::set_tint (rxvt_color &new_tint)
962	{
963	if (!(flags & tintSet) || tint != new_tint)
964	{
965	unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
966	tint = new_tint;	793	tint = new_tint;
967	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
968	return true;	805	return true;
969	}	806	}
970		807
971	return false;	808	return false;
972	}	809	}
973		810
974	bool	811	bool
975	bgPixmap_t::unset_tint ()
976	{
977	unsigned long new_flags = compute_tint_shade_flags (NULL, shade);
978
979	if (new_flags != (flags & tintFlags))
980	{
981	flags = (flags & ~tintFlags) | new_flags;
982	return true;
983	}
984
985	return false;
986	}
987
988	bool
989	bgPixmap_t::set_shade (const char *shade_str)	812	rxvt_term::bg_set_shade (const char *shade_str)
990	{	813	{
991	int new_shade = (shade_str) ? atoi (shade_str) : 100;	814	int new_shade = atoi (shade_str);
992		815
993	clamp_it (new_shade, -100, 200);	816	clamp_it (new_shade, -100, 200);
994	if (new_shade < 0)	817	if (new_shade < 0)
995	new_shade = 200 - (100 + new_shade);	818	new_shade = 200 - (100 + new_shade);
996		819
997	if (new_shade != shade)	820	if (new_shade != shade)
998	{	821	{
999	unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
1000	shade = new_shade;	822	shade = new_shade;
1001	flags = (flags & (~tintFlags | tintSet)) | new_flags;
1002	return true;	823	return true;
1003	}	824	}
1004		825
1005	return false;	826	return false;
1006	}	827	}
…		…
1027	params[i+2] = XDoubleToFixed (kernel[i] / sum);	848	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1028	}	849	}
1029	#endif	850	#endif
1030		851
1031	bool	852	bool
1032	bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	853	rxvt_term::blur_pixmap (Pixmap pixmap, int width, int height)
1033	{	854	{
1034	bool ret = false;	855	bool ret = false;
1035	#if XRENDER	856	#if XRENDER
		857	if (!(bg_flags & BG_HAS_RENDER_CONV))
		858	return false;
		859
1036	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	860	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1037	double *kernel = (double *)malloc (size * sizeof (double));	861	double *kernel = (double *)malloc (size * sizeof (double));
1038	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));	862	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1039		863
1040	Display *dpy = target->dpy;
1041	XRenderPictureAttributes pa;	864	XRenderPictureAttributes pa;
1042	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	865	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1043		866
		867	pa.repeat = RepeatPad;
1044	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);
1045	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	870	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		871	XFreePixmap (dpy, tmp);
1046		872
1047	if (kernel && params && src && dst)	873	if (kernel && params)
1048	{	874	{
1049	if (h_blurRadius)
1050	{
1051	size = h_blurRadius * 2 + 1;	875	size = h_blurRadius * 2 + 1;
1052	get_gaussian_kernel (h_blurRadius, size, kernel, params);	876	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1053		877
1054	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	878	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1055	XRenderComposite (dpy,	879	XRenderComposite (dpy,
1056	PictOpSrc,	880	PictOpSrc,
1057	src,	881	src,
1058	None,	882	None,
1059	dst,	883	dst,
1060	0, 0,	884	0, 0,
1061	0, 0,	885	0, 0,
1062	0, 0,	886	0, 0,
1063	width, height);	887	width, height);
1064	}
1065		888
1066	if (v_blurRadius)	889	::swap (src, dst);
1067	{	890
1068	size = v_blurRadius * 2 + 1;	891	size = v_blurRadius * 2 + 1;
1069	get_gaussian_kernel (v_blurRadius, size, kernel, params);	892	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1070	swap (params[0], params[1]);	893	::swap (params[0], params[1]);
1071		894
1072	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	895	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1073	XRenderComposite (dpy,	896	XRenderComposite (dpy,
1074	PictOpSrc,	897	PictOpSrc,
1075	src,	898	src,
1076	None,	899	None,
1077	dst,	900	dst,
1078	0, 0,	901	0, 0,
1079	0, 0,	902	0, 0,
1080	0, 0,	903	0, 0,
1081	width, height);	904	width, height);
1082	}
1083		905
1084	ret = true;	906	ret = true;
1085	}	907	}
1086		908
1087	free (kernel);	909	free (kernel);
…		…
1091	#endif	913	#endif
1092	return ret;	914	return ret;
1093	}	915	}
1094		916
1095	bool	917	bool
1096	bgPixmap_t::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	918	rxvt_term::tint_pixmap (Pixmap pixmap, int width, int height)
1097	{	919	{
1098	Display *dpy = target->dpy;
1099	bool ret = false;	920	bool ret = false;
1100		921
1101	if (flags & tintWholesome)	922	if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1102	{	923	{
1103	XGCValues gcv;	924	XGCValues gcv;
1104	GC gc;	925	GC gc;
1105		926
1106	/* In this case we can tint image server-side getting significant	927	/* In this case we can tint image server-side getting significant
…		…
1115	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	936	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1116	ret = true;	937	ret = true;
1117	XFreeGC (dpy, gc);	938	XFreeGC (dpy, gc);
1118	}	939	}
1119	}	940	}
1120	else
1121	{
1122	# if XRENDER	941	# if XRENDER
		942	else if (bg_flags & BG_HAS_RENDER)
		943	{
1123	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	944	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1124		945
1125	if (flags & tintSet)	946	if (bg_flags & BG_TINT_SET)
1126	tint.get (c);	947	tint.get (c);
1127		948
1128	if (shade <= 100)	949	if (shade <= 100)
1129	{	950	{
1130	c.r = (c.r * shade) / 100;	951	c.r = c.r * shade / 100;
1131	c.g = (c.g * shade) / 100;	952	c.g = c.g * shade / 100;
1132	c.b = (c.b * shade) / 100;	953	c.b = c.b * shade / 100;
1133	}	954	}
1134	else	955	else
1135	{	956	{
1136	c.r = ((0xffff - c.r) * (200 - shade)) / 100;	957	c.r = c.r * (200 - shade) / 100;
1137	c.g = ((0xffff - c.g) * (200 - shade)) / 100;	958	c.g = c.g * (200 - shade) / 100;
1138	c.b = ((0xffff - c.b) * (200 - shade)) / 100;	959	c.b = c.b * (200 - shade) / 100;
1139	}	960	}
1140		961
1141	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1142	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	962	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1143	XRenderPictureAttributes pa;
1144		963
1145	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	964	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1146		965
1147	pa.repeat = True;	966	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1148		967
1149	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	968	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1150	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1151	XFreePixmap (dpy, overlay_pmap);
1152		969
1153	pa.component_alpha = True;
1154	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1155	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
1156	XFreePixmap (dpy, mask_pmap);
1157
1158	if (mask_pic && overlay_pic && back_pic)
1159	{
1160	XRenderColor mask_c;	970	XRenderColor mask_c;
1161		971
1162	mask_c.red = mask_c.green = mask_c.blue = shade > 100 ? 0xffff : 0;
1163	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;
1164	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	992	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1165		993
1166	mask_c.alpha = 0;
1167	mask_c.red = 0xffff - c.r;
1168	mask_c.green = 0xffff - c.g;
1169	mask_c.blue = 0xffff - c.b;
1170	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1171	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);
1172	ret = true;
1173	}	995	}
		996
		997	ret = true;
1174		998
1175	XRenderFreePicture (dpy, mask_pic);	999	XRenderFreePicture (dpy, mask_pic);
1176	XRenderFreePicture (dpy, overlay_pic);	1000	XRenderFreePicture (dpy, overlay_pic);
1177	XRenderFreePicture (dpy, back_pic);	1001	XRenderFreePicture (dpy, back_pic);
		1002	}
1178	# endif	1003	# endif
1179	}
1180		1004
1181	return ret;	1005	return ret;
1182	}	1006	}
1183		1007
1184	/* make_transparency_pixmap()	1008	/*
1185	* 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
1186	* 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
1187	* our window.	1011	* our window.
1188	*/	1012	*/
1189	unsigned long	1013	bool
1190	bgPixmap_t::make_transparency_pixmap ()	1014	rxvt_term::make_transparency_pixmap ()
1191	{	1015	{
1192	unsigned long result = 0;	1016	bool ret = false;
1193
1194	if (target == NULL)
1195	return 0;
1196		1017
1197	/* 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
1198	* be always up-to-date, so let's use it :	1019	* be always up-to-date, so let's use it :
1199	*/	1020	*/
1200	int screen = target->display->screen;	1021	int screen = display->screen;
1201	Display *dpy = target->dpy;
1202	int root_depth = DefaultDepth (dpy, screen);	1022	int root_depth = DefaultDepth (dpy, screen);
1203	int root_width = DisplayWidth (dpy, screen);	1023	int root_width = DisplayWidth (dpy, screen);
1204	int root_height = DisplayHeight (dpy, screen);	1024	int root_height = DisplayHeight (dpy, screen);
1205	unsigned int root_pmap_width, root_pmap_height;	1025	unsigned int root_pmap_width, root_pmap_height;
1206	int window_width = target->szHint.width;	1026	int window_width = szHint.width;
1207	int window_height = target->szHint.height;	1027	int window_height = szHint.height;
1208	int sx, sy;	1028	int sx, sy;
1209	XGCValues gcv;	1029	XGCValues gcv;
1210	GC gc;	1030	GC gc;
1211		1031
1212	sx = target_x;	1032	sx = target_x;
…		…
1222	{	1042	{
1223	Window wdummy;	1043	Window wdummy;
1224	int idummy;	1044	int idummy;
1225	unsigned int udummy;	1045	unsigned int udummy;
1226		1046
1227	target->allowedxerror = -1;	1047	allowedxerror = -1;
1228		1048
1229	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))
1230	root_pixmap = None;	1050	root_pixmap = None;
1231		1051
1232	target->allowedxerror = 0;	1052	allowedxerror = 0;
1233	}	1053	}
1234		1054
1235	Pixmap recoded_root_pmap = root_pixmap;	1055	Pixmap recoded_root_pmap = root_pixmap;
1236		1056
1237	if (root_pixmap != None && root_depth != target->depth)	1057	if (root_pixmap != None && root_depth != depth)
1238	{	1058	{
1239	#if XRENDER	1059	#if XRENDER
1240	if (flags & HAS_RENDER)	1060	if (bg_flags & BG_HAS_RENDER)
1241	{	1061	{
1242	XRenderPictureAttributes pa;	1062	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1243		1063
1244	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	1064	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1245	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	1065	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1246		1066
1247	recoded_root_pmap = XCreatePixmap (dpy, target->vt, root_pmap_width, root_pmap_height, target->depth);
1248	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);	1067	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1249	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	1068	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1250		1069
1251	if (src && dst)
1252	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);
1253	else
1254	{
1255	XFreePixmap (dpy, recoded_root_pmap);
1256	root_pixmap = None;
1257	}
1258		1071
1259	XRenderFreePicture (dpy, src);	1072	XRenderFreePicture (dpy, src);
1260	XRenderFreePicture (dpy, dst);	1073	XRenderFreePicture (dpy, dst);
1261	}	1074	}
1262	else	1075	else
1263	#endif	1076	#endif
1264	root_pixmap = None;	1077	recoded_root_pmap = None;
1265	}	1078	}
1266		1079
1267	if (root_pixmap == None)	1080	if (recoded_root_pmap == None)
1268	return 0;	1081	return 0;
1269		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);
1270	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);
1271		1090	bg_pmap_width = window_width;
1272	if (tiled_root_pmap == None) /* something really bad happened - abort */	1091	bg_pmap_height = window_height;
1273	return 0;	1092	}
1274		1093
1275	/* straightforward pixmap copy */	1094	/* straightforward pixmap copy */
1276	while (sx < 0) sx += (int)root_width;	1095	while (sx < 0) sx += root_pmap_width;
1277	while (sy < 0) sy += (int)root_height;	1096	while (sy < 0) sy += root_pmap_height;
1278		1097
1279	gcv.tile = recoded_root_pmap;	1098	gcv.tile = recoded_root_pmap;
1280	gcv.fill_style = FillTiled;	1099	gcv.fill_style = FillTiled;
1281	gcv.ts_x_origin = -sx;	1100	gcv.ts_x_origin = -sx;
1282	gcv.ts_y_origin = -sy;	1101	gcv.ts_y_origin = -sy;
1283	gc = XCreateGC (dpy, target->vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	1102	gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1284		1103
1285	if (gc)	1104	if (gc)
1286	{	1105	{
1287	XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);	1106	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1288	result |= transpPmapTiled;	1107	ret = true;
1289	XFreeGC (dpy, gc);	1108	bool need_blur = h_blurRadius && v_blurRadius;
		1109	bool need_tint = shade != 100 || (bg_flags & BG_TINT_SET);
1290		1110
1291	if (!need_client_side_rendering ())	1111	if (!(bg_flags & BG_CLIENT_RENDER))
1292	{	1112	{
1293	if ((flags & blurNeeded)	1113	if (need_blur)
1294	&& (flags & HAS_RENDER_CONV))
1295	{	1114	{
1296	if (blur_pixmap (tiled_root_pmap, target->visual, window_width, window_height))	1115	if (blur_pixmap (bg_pixmap, window_width, window_height))
1297	result |= transpPmapBlurred;	1116	need_blur = false;
1298	}	1117	}
1299	if ((flags & tintNeeded)	1118	if (need_tint)
1300	&& (flags & (tintWholesome | HAS_RENDER)))
1301	{	1119	{
1302	if (tint_pixmap (tiled_root_pmap, target->visual, window_width, window_height))	1120	if (tint_pixmap (bg_pixmap, window_width, window_height))
1303	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	}
1304	}	1134	}
1305	} /* server side rendering completed */	1135	} /* server side rendering completed */
1306		1136
1307	if (pixmap)	1137	XFreeGC (dpy, gc);
1308	XFreePixmap (dpy, pixmap);
1309
1310	pixmap = tiled_root_pmap;
1311	pmap_width = window_width;
1312	pmap_height = window_height;
1313	pmap_depth = target->depth;
1314	}	1138	}
1315	else
1316	XFreePixmap (dpy, tiled_root_pmap);
1317		1139
1318	if (recoded_root_pmap != root_pixmap)	1140	if (recoded_root_pmap != root_pixmap)
1319	XFreePixmap (dpy, recoded_root_pmap);	1141	XFreePixmap (dpy, recoded_root_pmap);
1320		1142
1321	return result;	1143	return ret;
1322	}	1144	}
1323		1145
1324	void	1146	void
1325	bgPixmap_t::set_root_pixmap ()	1147	rxvt_term::bg_set_root_pixmap ()
1326	{	1148	{
1327	Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);	1149	Pixmap new_root_pixmap = get_pixmap_property (xa[XA_XROOTPMAP_ID]);
1328	if (new_root_pixmap == None)	1150	if (new_root_pixmap == None)
1329	new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);	1151	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1330		1152
1331	root_pixmap = new_root_pixmap;	1153	root_pixmap = new_root_pixmap;
1332	}	1154	}
1333	# endif /* ENABLE_TRANSPARENCY */	1155	# endif /* ENABLE_TRANSPARENCY */
1334		1156
1335	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1157	bool
1336	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	}
1337	# endif	1168	# endif
1338		1169
1339	bool	1170	# ifdef BG_IMAGE_FROM_FILE
1340	bgPixmap_t::render ()	1171	for (vector<rxvt_image>::iterator bg_image = image_vec.begin (); bg_image < image_vec.end (); bg_image++)
1341	{
1342	unsigned long background_flags = 0;
1343
1344	if (target == NULL)
1345	return false;
1346
1347	invalidate ();
1348	# ifdef ENABLE_TRANSPARENCY
1349	if (flags & isTransparent)
1350	{	1172	{
1351	/* we need to re-generate transparency pixmap in that case ! */	1173	if (render_image (*bg_image))
1352	background_flags = make_transparency_pixmap ();	1174	bg_flags |= BG_IS_VALID;
1353	if (background_flags == 0)
1354	return false;
1355	else if ((background_flags & transpTransformations) == (flags & transpTransformations))
1356	flags &= ~isInvalid;
1357	}	1175	}
1358	# endif	1176	# endif
1359		1177
1360	# ifdef BG_IMAGE_FROM_FILE	1178	if (!(bg_flags & BG_IS_VALID))
1361	if (have_image
1362	|| (background_flags & transpTransformations) != (flags & transpTransformations))
1363	{
1364	if (render_image (background_flags))
1365	flags &= ~isInvalid;
1366	}	1179	{
1367	# endif	1180	if (bg_pixmap != None)
1368
1369	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1370	XImage *result = NULL;
1371
1372	if (background_flags && (flags & isInvalid))
1373	{
1374	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1375	}
1376
1377	if (result)
1378	{
1379	/* our own client-side tinting */
1380	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1381	{	1181	{
1382	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	1182	XFreePixmap (dpy, bg_pixmap);
1383	if (flags & tintSet)	1183	bg_pixmap = None;
1384	tint.get (c);
1385	ShadeXImage (DefaultVisual (target->dpy, target->display->screen), result, shade, c);
1386	}	1184	}
1387
1388	GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1389
1390	if (gc)
1391	{
1392	XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1393
1394	XFreeGC (target->dpy, gc);
1395	flags &= ~isInvalid;
1396	}
1397
1398	XDestroyImage (result);
1399	}
1400	# endif
1401
1402	if (flags & isInvalid)
1403	{	1185	}
1404	if (pixmap != None)
1405	{
1406	XFreePixmap (target->dpy, pixmap);
1407	pixmap = None;
1408	}
1409	}
1410		1186
1411	apply ();	1187	scr_recolour (false);
		1188	bg_flags |= BG_NEEDS_REFRESH;
1412		1189
1413	valid_since = ev::now ();	1190	bg_valid_since = ev::now ();
1414		1191
1415	return true;	1192	return true;
1416	}	1193	}
1417		1194
1418	void	1195	void
1419	bgPixmap_t::set_target (rxvt_term *new_target)	1196	rxvt_term::bg_init ()
1420	{	1197	{
1421	target = new_target;	1198	#ifdef ENABLE_TRANSPARENCY
		1199	shade = 100;
		1200	#endif
1422		1201
1423	flags &= ~(HAS_RENDER | HAS_RENDER_CONV);	1202	bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1424	#if XRENDER	1203	#if XRENDER
1425	int major, minor;	1204	int major, minor;
1426	if (XRenderQueryVersion (target->dpy, &major, &minor))	1205	if (XRenderQueryVersion (dpy, &major, &minor))
1427	flags |= HAS_RENDER;	1206	bg_flags |= BG_HAS_RENDER;
1428	XFilters *filters = XRenderQueryFilters (target->dpy, target->vt);	1207	XFilters *filters = XRenderQueryFilters (dpy, vt);
1429	if (filters)	1208	if (filters)
1430	{	1209	{
1431	for (int i = 0; i < filters->nfilter; i++)	1210	for (int i = 0; i < filters->nfilter; i++)
1432	if (!strcmp (filters->filter[i], FilterConvolution))	1211	if (!strcmp (filters->filter[i], FilterConvolution))
1433	flags |= HAS_RENDER_CONV;	1212	bg_flags |= BG_HAS_RENDER_CONV;
1434		1213
1435	XFree (filters);	1214	XFree (filters);
1436	}	1215	}
1437	#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	}
1438	}	1259	}
1439		1260
1440	void	1261	void
1441	bgPixmap_t::apply ()	1262	rxvt_term::tint_ximage (XImage *ximage)
1442	{	1263	{
1443	if (target == NULL)	1264	unsigned int size_r, size_g, size_b;
1444	return;
1445
1446	if (pixmap != None)
1447	{
1448	/* set target's background to pixmap */
1449	# ifdef ENABLE_TRANSPARENCY
1450	if (flags & isTransparent)
1451	{
1452	XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
1453	XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
1454
1455	if (target->scrollBar.win)
1456	XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1457	}
1458	else
1459	# endif
1460	{
1461	/* force old pixmap dereference in case it was transparent before :*/
1462	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1463	XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1464	/* do we also need to set scrollbar's background here ? */
1465
1466	if (target->scrollBar.win)
1467	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1468	}
1469	}
1470	else
1471	{
1472	/* set target background to a pixel */
1473	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1474	XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
1475	/* do we also need to set scrollbar's background here ? */
1476	if (target->scrollBar.win)
1477	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1478	}
1479
1480	/* don't want Expose on the parent or vt. It is better to use
1481	scr_touch or we get a great deal of flicker otherwise: */
1482	XClearWindow (target->dpy, target->parent[0]);
1483
1484	if (target->scrollBar.state && target->scrollBar.win)
1485	{
1486	target->scrollBar.state = STATE_IDLE;
1487	target->scrollBar.show (0);
1488	}
1489
1490	target->want_refresh = 1;
1491	flags |= hasChanged;
1492	}
1493
1494	#endif /* HAVE_BG_PIXMAP */
1495
1496	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1497	/* taken from aterm-0.4.2 */
1498
1499	static void
1500	ShadeXImage(Visual *visual, XImage *srcImage, int shade, const rgba &c)
1501	{
1502	int sh_r, sh_g, sh_b;	1265	int sh_r, sh_g, sh_b;
1503	uint32_t mask_r, mask_g, mask_b;	1266	uint32_t mask_r, mask_g, mask_b;
1504	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;	1267	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1505	rgba low;	1268	unsigned short low;
1506	rgba high;
1507	int i;
1508	int host_byte_order = byteorder.big_endian () ? MSBFirst : LSBFirst;	1269	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1509		1270
1510	if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return;	1271	if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1511		1272
1512	/* for convenience */	1273	/* for convenience */
1513	mask_r = visual->red_mask;	1274	mask_r = visual->red_mask;
1514	mask_g = visual->green_mask;	1275	mask_g = visual->green_mask;
1515	mask_b = visual->blue_mask;	1276	mask_b = visual->blue_mask;
1516		1277
1517	/* boring lookup table pre-initialization */	1278	/* boring lookup table pre-initialization */
1518	switch (srcImage->depth)	1279	sh_r = ecb_ctz32 (mask_r);
1519	{	1280	sh_g = ecb_ctz32 (mask_g);
1520	case 15:	1281	sh_b = ecb_ctz32 (mask_b);
1521	if ((mask_r != 0x7c00) ||	1282
1522	(mask_g != 0x03e0) ||	1283	size_r = mask_r >> sh_r;
1523	(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)
1524	return;	1288	return;
1525	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));
1526	lookup_r = lookup;	1291	lookup_r = lookup;
1527	lookup_g = lookup+32;	1292	lookup_g = lookup + size_r;
1528	lookup_b = lookup+32+32;	1293	lookup_b = lookup + size_r + size_g;
1529	sh_r = 10;	1294
1530	sh_g = 5;	1295	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1531	sh_b = 0;	1296
1532	break;	1297	if (bg_flags & BG_TINT_SET)
1533	case 16:	1298	tint.get (c);
1534	if ((mask_r != 0xf800) ||
1535	(mask_g != 0x07e0) ||
1536	(mask_b != 0x001f))
1537	return;
1538	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+64+32));
1539	lookup_r = lookup;
1540	lookup_g = lookup+32;
1541	lookup_b = lookup+32+64;
1542	sh_r = 11;
1543	sh_g = 5;
1544	sh_b = 0;
1545	break;
1546	case 24:
1547	if ((mask_r != 0xff0000) ||
1548	(mask_g != 0x00ff00) ||
1549	(mask_b != 0x0000ff))
1550	return;
1551	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1552	lookup_r = lookup;
1553	lookup_g = lookup+256;
1554	lookup_b = lookup+256+256;
1555	sh_r = 16;
1556	sh_g = 8;
1557	sh_b = 0;
1558	break;
1559	case 32:
1560	if ((mask_r != 0xff0000) ||
1561	(mask_g != 0x00ff00) ||
1562	(mask_b != 0x0000ff))
1563	return;
1564	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1565	lookup_r = lookup;
1566	lookup_g = lookup+256;
1567	lookup_b = lookup+256+256;
1568	sh_r = 16;
1569	sh_g = 8;
1570	sh_b = 0;
1571	break;
1572	default:
1573	return; /* we do not support this color depth */
1574	}
1575		1299
1576	/* prepare limits for color transformation (each channel is handled separately) */	1300	/* prepare limits for color transformation (each channel is handled separately) */
1577	if (shade > 100)	1301	if (shade > 100)
1578	{	1302	{
1579	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;
1580		1306
1581	high.r = (65535 - c.r) * shade / 100;	1307	low = 0xffff * (shade - 100) / 100;
1582	high.g = (65535 - c.g) * shade / 100;
1583	high.b = (65535 - c.b) * shade / 100;
1584
1585	low.r = 65535 - high.r;
1586	low.g = 65535 - high.g;
1587	low.b = 65535 - high.b;
1588	}	1308	}
1589	else	1309	else
1590	{	1310	{
1591	high.r = c.r * shade / 100;	1311	c.r = c.r * shade / 100;
1592	high.g = c.g * shade / 100;	1312	c.g = c.g * shade / 100;
1593	high.b = c.b * shade / 100;	1313	c.b = c.b * shade / 100;
1594		1314
1595	low.r = low.g = low.b = 0;	1315	low = 0;
1596	}	1316	}
1597		1317
1598	/* fill our lookup tables */	1318	/* fill our lookup tables */
1599	for (i = 0; i <= mask_r>>sh_r; i++)	1319	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1600	{	1320	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1601	uint32_t tmp;	1321	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1602	tmp = i * high.r;
1603	tmp += (mask_r>>sh_r) * low.r;
1604	lookup_r[i] = (tmp/65535)<<sh_r;
1605	}
1606	for (i = 0; i <= mask_g>>sh_g; i++)
1607	{
1608	uint32_t tmp;
1609	tmp = i * high.g;
1610	tmp += (mask_g>>sh_g) * low.g;
1611	lookup_g[i] = (tmp/65535)<<sh_g;
1612	}
1613	for (i = 0; i <= mask_b>>sh_b; i++)
1614	{
1615	uint32_t tmp;
1616	tmp = i * high.b;
1617	tmp += (mask_b>>sh_b) * low.b;
1618	lookup_b[i] = (tmp/65535)<<sh_b;
1619	}
1620		1322
1621	/* apply table to input image (replacing colors by newly calculated ones) */	1323	/* apply table to input image (replacing colors by newly calculated ones) */
1622	if (srcImage->bits_per_pixel == 32	1324	if (ximage->bits_per_pixel == 32
1623	&& (srcImage->depth == 24 || srcImage->depth == 32)
1624	&& srcImage->byte_order == host_byte_order)	1325	&& ximage->byte_order == host_byte_order)
1625	{	1326	{
1626	uint32_t *p1, *pf, *p, *pl;	1327	char *line = ximage->data;
1627	p1 = (uint32_t *) srcImage->data;
1628	pf = (uint32_t *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1629		1328
1630	while (p1 < pf)	1329	for (int y = 0; y < ximage->height; y++)
1631	{	1330	{
1632	p = p1;	1331	uint32_t *p = (uint32_t *)line;
1633	pl = p1 + srcImage->width;	1332	for (int x = 0; x < ximage->width; x++)
1634	for (; p < pl; p++)
1635	{	1333	{
1636	*p = lookup_r[(*p & 0xff0000) >> 16] |	1334	*p = lookup_r[(*p & mask_r) >> sh_r] |
1637	lookup_g[(*p & 0x00ff00) >> 8] |	1335	lookup_g[(*p & mask_g) >> sh_g] |
1638	lookup_b[(*p & 0x0000ff)] |	1336	lookup_b[(*p & mask_b) >> sh_b];
1639	(*p & 0xff000000);	1337	p++;
1640	}	1338	}
1641	p1 = (uint32_t *) ((char *) p1 + srcImage->bytes_per_line);	1339	line += ximage->bytes_per_line;
1642	}	1340	}
1643	}	1341	}
1644	else	1342	else
1645	{	1343	{
1646	for (int y = 0; y < srcImage->height; y++)	1344	for (int y = 0; y < ximage->height; y++)
1647	for (int x = 0; x < srcImage->width; x++)	1345	for (int x = 0; x < ximage->width; x++)
1648	{	1346	{
1649	unsigned long pixel = XGetPixel (srcImage, x, y);	1347	unsigned long pixel = XGetPixel (ximage, x, y);
1650	pixel = lookup_r[(pixel & mask_r) >> sh_r] |	1348	pixel = lookup_r[(pixel & mask_r) >> sh_r] |
1651	lookup_g[(pixel & mask_g) >> sh_g] |	1349	lookup_g[(pixel & mask_g) >> sh_g] |
1652	lookup_b[(pixel & mask_b) >> sh_b];	1350	lookup_b[(pixel & mask_b) >> sh_b];
1653	XPutPixel (srcImage, x, y, pixel);	1351	XPutPixel (ximage, x, y, pixel);
1654	}	1352	}
1655	}	1353	}
1656		1354
1657	free (lookup);	1355	free (lookup);
1658	}	1356	}
1659	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1357	#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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