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.160 by sf-exg, Thu Aug 11 08:37:17 2011 UTC vs.
Revision 1.230 by sf-exg, Sun Jun 3 15:50:22 2012 UTC

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

Diff Legend

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