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

Diff Legend

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