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

Diff Legend

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