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.186 by sf-exg, Wed Dec 28 11:11:25 2011 UTC vs.
Revision 1.218 by sf-exg, Mon May 21 12:29:22 2012 UTC

…		…
3	*----------------------------------------------------------------------*	3	*----------------------------------------------------------------------*
4	*	4	*
5	* All portions of code are copyright by their respective author/s.	5	* All portions of code are copyright by their respective author/s.
6	* Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>	6	* Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>
7	* Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>	7	* Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
8	* Copyright (c) 2010 Emanuele Giaquinta <e.giaquinta@glauco.it>	8	* Copyright (c) 2010-2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
9	*	9	*
10	* This program is free software; you can redistribute it and/or modify	10	* This program is free software; you can redistribute it and/or modify
11	* it under the terms of the GNU General Public License as published by	11	* it under the terms of the GNU General Public License as published by
12	* the Free Software Foundation; either version 2 of the License, or	12	* the Free Software Foundation; either version 2 of the License, or
13	* (at your option) any later version.	13	* (at your option) any later version.
…		…
20	* You should have received a copy of the GNU General Public License	20	* You should have received a copy of the GNU General Public License
21	* along with this program; if not, write to the Free Software	21	* along with this program; if not, write to the Free Software
22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23	*---------------------------------------------------------------------*/	23	*---------------------------------------------------------------------*/
24		24
25	#include <cmath>	25	#include <math.h>
26	#include "../config.h" /* NECESSARY */	26	#include "../config.h" /* NECESSARY */
27	#include "rxvt.h" /* NECESSARY */	27	#include "rxvt.h" /* NECESSARY */
28		28
29	#if XRENDER	29	#if XRENDER
30	# include <X11/extensions/Xrender.h>	30	# include <X11/extensions/Xrender.h>
…		…
32		32
33	#ifndef FilterConvolution	33	#ifndef FilterConvolution
34	#define FilterConvolution "convolution"	34	#define FilterConvolution "convolution"
35	#endif	35	#endif
36		36
		37	#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
42	if (original_asim)
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
49
50	#ifdef HAVE_PIXBUF
51	if (pixbuf)
52	g_object_unref (pixbuf);
53	#endif
54
55	if (bg_pixmap)	63	if (bg_pixmap)
56	XFreePixmap (dpy, bg_pixmap);	64	XFreePixmap (dpy, bg_pixmap);
57	}	65	}
58		66
59	bool	67	bool
…		…
77	if (bg_flags & BG_IS_TRANSPARENT)	85	if (bg_flags & BG_IS_TRANSPARENT)
78	return true;	86	return true;
79	# endif	87	# endif
80		88
81	# ifdef BG_IMAGE_FROM_FILE	89	# ifdef BG_IMAGE_FROM_FILE
82	if (bg_flags & BG_IS_FROM_FILE)	90	if (bg_image.flags & IM_IS_SET)
83	{	91	{
84	if (bg_flags & BG_IS_SIZE_SENSITIVE)	92	if ((bg_image.flags & IM_IS_SIZE_SENSITIVE)
		93	|| bg_image.width () > szHint.width
		94	|| bg_image.height () > szHint.height)
85	return true;	95	return true;
86	}	96	}
87	# endif	97	# endif
88		98
89	return false;	99	return false;
…		…
96	if (bg_flags & BG_IS_TRANSPARENT)	106	if (bg_flags & BG_IS_TRANSPARENT)
97	return true;	107	return true;
98	# endif	108	# endif
99		109
100	# ifdef BG_IMAGE_FROM_FILE	110	# ifdef BG_IMAGE_FROM_FILE
101	if (bg_flags & BG_IS_FROM_FILE)	111	if (bg_image.flags & IM_IS_SET)
102	{	112	{
103	if (bg_flags & BG_ROOT_ALIGN)	113	if (bg_image.flags & IM_ROOT_ALIGN)
104	return true;	114	return true;
105	}	115	}
106	# endif	116	# endif
107		117
108	return false;	118	return false;
109	}	119	}
110		120
111	# ifdef BG_IMAGE_FROM_FILE	121	# ifdef 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	122	static inline int
147	make_align_position (int align, int window_size, int image_size)	123	make_align_position (int align, int window_size, int image_size)
148	{	124	{
149	int diff = window_size - image_size;
150	int smaller = min (image_size, window_size);
151
152	if (align >= 0 && align <= 100)	125	if (align >= 0 && align <= 100)
153	return diff * align / 100;	126	return lerp (0, window_size - image_size, align);
154	else if (align > 100 && align <= 200)	127	else if (align > 100)
155	return (align - 100) * smaller / 100 + window_size - smaller;	128	return lerp (window_size - image_size, window_size, align - 100);
156	else if (align >= -100 && align < 0)	129	else
157	return (align + 100) * smaller / 100 - image_size;	130	return lerp (-image_size, 0, align + 100);
158	return 0;
159	}	131	}
160		132
161	static inline int	133	static inline int
162	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	134	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
163	{	135	{
…		…
169	src_pos = -pos;	141	src_pos = -pos;
170	dst_pos = 0;	142	dst_pos = 0;
171	dst_size += pos;	143	dst_size += pos;
172	}	144	}
173		145
174	if (dst_pos + dst_size > target_size)
175	dst_size = target_size - dst_pos;	146	min_it (dst_size, target_size - dst_pos);
176	return src_pos;	147	return src_pos;
177	}	148	}
178		149
179	bool	150	bool
180	rxvt_term::bg_set_geometry (const char *geom, bool update)	151	rxvt_image::set_geometry (const char *geom, bool update)
181	{	152	{
182	bool changed = false;	153	bool changed = false;
183	int geom_flags = 0;	154	int geom_flags = 0;
184	int x = 0, y = 0;	155	int x = h_align;
		156	int y = v_align;
185	unsigned int w = 0, h = 0;	157	unsigned int w = h_scale;
		158	unsigned int h = v_scale;
186	unsigned long new_flags = 0;	159	unsigned long new_flags = 0;
187		160
188	if (geom == NULL)	161	if (geom == NULL)
189	return false;	162	return false;
190		163
…		…
194		167
195	for (int i = 0; arr[i]; i++)	168	for (int i = 0; arr[i]; i++)
196	{	169	{
197	if (!strcasecmp (arr[i], "style=tiled"))	170	if (!strcasecmp (arr[i], "style=tiled"))
198	{	171	{
199	new_flags = BG_TILE;	172	new_flags = IM_TILE;
200	w = h = noScale;	173	w = h = noScale;
201	x = y = 0;	174	x = y = 0;
202	geom_flags = WidthValue|HeightValue|XValue|YValue;	175	geom_flags = WidthValue|HeightValue|XValue|YValue;
203	}	176	}
204	else if (!strcasecmp (arr[i], "style=aspect-stretched"))	177	else if (!strcasecmp (arr[i], "style=aspect-stretched"))
205	{	178	{
206	new_flags = BG_KEEP_ASPECT;	179	new_flags = IM_KEEP_ASPECT;
207	w = h = windowScale;	180	w = h = windowScale;
208	x = y = centerAlign;	181	x = y = centerAlign;
209	geom_flags = WidthValue|HeightValue|XValue|YValue;	182	geom_flags = WidthValue|HeightValue|XValue|YValue;
210	}	183	}
211	else if (!strcasecmp (arr[i], "style=stretched"))	184	else if (!strcasecmp (arr[i], "style=stretched"))
…		…
221	x = y = centerAlign;	194	x = y = centerAlign;
222	geom_flags = WidthValue|HeightValue|XValue|YValue;	195	geom_flags = WidthValue|HeightValue|XValue|YValue;
223	}	196	}
224	else if (!strcasecmp (arr[i], "style=root-tiled"))	197	else if (!strcasecmp (arr[i], "style=root-tiled"))
225	{	198	{
226	new_flags = BG_TILE|BG_ROOT_ALIGN;	199	new_flags = IM_TILE|IM_ROOT_ALIGN;
227	w = h = noScale;	200	w = h = noScale;
228	geom_flags = WidthValue|HeightValue;	201	geom_flags = WidthValue|HeightValue;
229	}	202	}
230	else if (!strcasecmp (arr[i], "op=tile"))	203	else if (!strcasecmp (arr[i], "op=tile"))
231	new_flags |= BG_TILE;	204	new_flags |= IM_TILE;
232	else if (!strcasecmp (arr[i], "op=keep-aspect"))	205	else if (!strcasecmp (arr[i], "op=keep-aspect"))
233	new_flags |= BG_KEEP_ASPECT;	206	new_flags |= IM_KEEP_ASPECT;
234	else if (!strcasecmp (arr[i], "op=root-align"))	207	else if (!strcasecmp (arr[i], "op=root-align"))
235	new_flags |= BG_ROOT_ALIGN;	208	new_flags |= IM_ROOT_ALIGN;
236		209
237	// deprecated	210	// deprecated
238	else if (!strcasecmp (arr[i], "tile"))	211	else if (!strcasecmp (arr[i], "tile"))
239	{	212	{
240	new_flags |= BG_TILE;	213	new_flags |= IM_TILE;
241	w = h = noScale;	214	w = h = noScale;
242	geom_flags |= WidthValue|HeightValue;	215	geom_flags |= WidthValue|HeightValue;
243	}	216	}
244	else if (!strcasecmp (arr[i], "propscale"))	217	else if (!strcasecmp (arr[i], "propscale"))
245	{	218	{
246	new_flags |= BG_KEEP_ASPECT;	219	new_flags |= IM_KEEP_ASPECT;
247	w = h = windowScale;	220	w = h = windowScale;
248	geom_flags |= WidthValue|HeightValue;	221	geom_flags |= WidthValue|HeightValue;
249	}	222	}
250	else if (!strcasecmp (arr[i], "hscale"))	223	else if (!strcasecmp (arr[i], "hscale"))
251	{	224	{
252	new_flags |= BG_TILE;	225	new_flags |= IM_TILE;
253	w = windowScale;	226	w = windowScale;
254	h = noScale;	227	h = noScale;
255	geom_flags |= WidthValue|HeightValue;	228	geom_flags |= WidthValue|HeightValue;
256	}	229	}
257	else if (!strcasecmp (arr[i], "vscale"))	230	else if (!strcasecmp (arr[i], "vscale"))
258	{	231	{
259	new_flags |= BG_TILE;	232	new_flags |= IM_TILE;
260	h = windowScale;	233	h = windowScale;
261	w = noScale;	234	w = noScale;
262	geom_flags |= WidthValue|HeightValue;	235	geom_flags |= WidthValue|HeightValue;
263	}	236	}
264	else if (!strcasecmp (arr[i], "scale"))	237	else if (!strcasecmp (arr[i], "scale"))
…		…
272	x = y = centerAlign;	245	x = y = centerAlign;
273	geom_flags |= WidthValue|HeightValue|XValue|YValue;	246	geom_flags |= WidthValue|HeightValue|XValue|YValue;
274	}	247	}
275	else if (!strcasecmp (arr[i], "root"))	248	else if (!strcasecmp (arr[i], "root"))
276	{	249	{
277	new_flags |= BG_TILE|BG_ROOT_ALIGN;	250	new_flags |= IM_TILE|IM_ROOT_ALIGN;
278	w = h = noScale;	251	w = h = noScale;
279	geom_flags |= WidthValue|HeightValue;	252	geom_flags |= WidthValue|HeightValue;
280	}	253	}
281		254
282	else	255	else
…		…
284	} /* done parsing ops */	257	} /* done parsing ops */
285		258
286	rxvt_free_strsplit (arr);	259	rxvt_free_strsplit (arr);
287	}	260	}
288		261
289	new_flags |= bg_flags & ~BG_GEOMETRY_FLAGS;	262	new_flags |= flags & ~IM_GEOMETRY_FLAGS;
290		263
291	if (!update)	264	if (!update)
292	{	265	{
293	if (!(geom_flags & XValue))	266	if (!(geom_flags & XValue))
294	x = y = defaultAlign;	267	x = y = defaultAlign;
…		…
299	w = h = defaultScale;	272	w = h = defaultScale;
300	else if (!(geom_flags & HeightValue))	273	else if (!(geom_flags & HeightValue))
301	h = w;	274	h = w;
302	else if (!(geom_flags & WidthValue))	275	else if (!(geom_flags & WidthValue))
303	w = h;	276	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	{	277	}
		278
		279	clamp_it (x, -100, 200);
		280	clamp_it (y, -100, 200);
		281
		282	if (flags != new_flags
		283	|| h_scale != w
		284	|| v_scale != h
		285	|| h_align != x
		286	|| v_align != y)
		287	{
315	bg_flags = new_flags;	288	flags = new_flags;
		289	h_scale = w;
		290	v_scale = h;
		291	h_align = x;
		292	v_align = y;
316	changed = true;	293	changed = true;
317	}	294	}
318		295
		296	if (!(flags & IM_TILE)
		297	|| h_scale || v_scale
		298	|| (!(flags & IM_ROOT_ALIGN) && (h_align || v_align)))
		299	flags |= IM_IS_SIZE_SENSITIVE;
		300	else
		301	flags &= ~IM_IS_SIZE_SENSITIVE;
		302
319	return changed;	303	return changed;
320	}	304	}
321		305
322	void	306	void
323	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)	307	rxvt_term::get_image_geometry (rxvt_image &image, int &w, int &h, int &x, int &y)
324	{	308	{
		309	int image_width = image.width ();
		310	int image_height = image.height ();
325	int target_width = szHint.width;	311	int target_width = szHint.width;
326	int target_height = szHint.height;	312	int target_height = szHint.height;
		313	int h_scale = min (image.h_scale, 32767 * 100 / target_width);
		314	int v_scale = min (image.v_scale, 32767 * 100 / target_height);
327		315
328	w = h_scale * target_width / 100;	316	w = h_scale * target_width / 100;
329	h = v_scale * target_height / 100;	317	h = v_scale * target_height / 100;
330		318
331	if (bg_flags & BG_KEEP_ASPECT)	319	if (image.flags & IM_KEEP_ASPECT)
332	{	320	{
333	float scale = (float)w / image_width;	321	float scale = (float)w / image_width;
334	min_it (scale, (float)h / image_height);	322	min_it (scale, (float)h / image_height);
335	w = image_width * scale + 0.5;	323	w = image_width * scale + 0.5;
336	h = image_height * scale + 0.5;	324	h = image_height * scale + 0.5;
337	}	325	}
338		326
339	if (!w) w = image_width;	327	if (!w) w = image_width;
340	if (!h) h = image_height;	328	if (!h) h = image_height;
341		329
342	if (bg_flags & BG_ROOT_ALIGN)	330	if (image.flags & IM_ROOT_ALIGN)
343	{	331	{
344	x = -target_x;	332	x = -target_x;
345	y = -target_y;	333	y = -target_y;
346	}	334	}
347	else	335	else
348	{	336	{
349	x = make_align_position (h_align, target_width, w);	337	x = make_align_position (image.h_align, target_width, w);
350	y = make_align_position (v_align, target_height, h);	338	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	{	339	}
376	ShadingInfo as_shade;	340	}
377	as_shade.shading = shade;
378		341
379	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	342	# ifdef HAVE_PIXBUF
380	if (bg_flags & BG_TINT_SET)	343	bool
381	tint.get (c);	344	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
382	as_shade.tintColor.red = c.r;	345	int src_x, int src_y, int dst_x, int dst_y,
383	as_shade.tintColor.green = c.g;	346	unsigned int width, unsigned int height, bool argb)
384	as_shade.tintColor.blue = c.b;	347	{
		348	XImage *ximage;
		349	char *line;
		350	int width_r, width_g, width_b, width_a;
		351	int sh_r, sh_g, sh_b, sh_a;
		352	uint32_t red_mask, green_mask, blue_mask, alpha_mask;
		353	int rowstride;
		354	int channels;
		355	unsigned char *row;
385		356
386	background_tint = shading2tint32 (&as_shade);	357	if (visual->c_class != TrueColor)
		358	return false;
		359
		360	if (argb)
387	}	361	{
388		362	red_mask = 0xff << 16;
389	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)	363	green_mask = 0xff << 8;
		364	blue_mask = 0xff;
		365	alpha_mask = 0xff << 24;
390	{	366	}
391	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,	367	else
392	ASA_XImage,	368	{
393	100, ASIMAGE_QUALITY_DEFAULT);	369	red_mask = visual->red_mask;
		370	green_mask = visual->green_mask;
		371	blue_mask = visual->blue_mask;
		372	#if XRENDER
		373	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
394	if (tmp)	374	if (format)
		375	alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
		376	else
		377	#endif
		378	alpha_mask = 0;
		379	}
		380
		381	width_r = ecb_popcount32 (red_mask);
		382	width_g = ecb_popcount32 (green_mask);
		383	width_b = ecb_popcount32 (blue_mask);
		384	width_a = ecb_popcount32 (alpha_mask);
		385
		386	if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
		387	return false;
		388
		389	sh_r = ecb_ctz32 (red_mask);
		390	sh_g = ecb_ctz32 (green_mask);
		391	sh_b = ecb_ctz32 (blue_mask);
		392	sh_a = ecb_ctz32 (alpha_mask);
		393
		394	if (width > 32767 || height > 32767)
		395	return false;
		396
		397	ximage = XCreateImage (dpy, visual, argb ? 32 : depth, ZPixmap, 0, 0,
		398	width, height, 32, 0);
		399	if (!ximage)
		400	return false;
		401
		402	if (height > INT_MAX / ximage->bytes_per_line
		403	|| !(ximage->data = (char *)malloc (height * ximage->bytes_per_line)))
		404	{
		405	XDestroyImage (ximage);
		406	return false;
		407	}
		408
		409	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
		410
		411	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
		412	channels = gdk_pixbuf_get_n_channels (pixbuf);
		413	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
		414	line = ximage->data;
		415
		416	rgba c (0, 0, 0);
		417
		418	if (channels == 4 && alpha_mask == 0)
		419	{
		420	pix_colors[Color_bg].get (c);
		421	c.r >>= 8;
		422	c.g >>= 8;
		423	c.b >>= 8;
		424	}
		425
		426	for (int y = 0; y < height; y++)
		427	{
		428	for (int x = 0; x < width; x++)
		429	{
		430	unsigned char *pixel = row + x * channels;
		431	uint32_t value;
		432	unsigned char r, g, b, a;
		433
		434	if (channels == 4)
395	{	435	{
396	destroy_asimage (&background);	436	a = pixel[3];
397	background = tmp;	437	r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
		438	g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
		439	b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
		440	}
		441	else
		442	{
		443	a = 0xff;
		444	r = pixel[0];
		445	g = pixel[1];
		446	b = pixel[2];
		447	}
		448
		449	value = ((r >> (8 - width_r)) << sh_r)
		450	| ((g >> (8 - width_g)) << sh_g)
		451	| ((b >> (8 - width_b)) << sh_b)
		452	| ((a >> (8 - width_a)) << sh_a);
		453
		454	if (ximage->bits_per_pixel == 32)
		455	((uint32_t *)line)[x] = value;
		456	else
		457	XPutPixel (ximage, x, y, value);
398	}	458	}
399	}
400	# endif
401		459
402	ASImage *result = 0;	460	row += rowstride;
		461	line += ximage->bytes_per_line;
		462	}
		463
		464	XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
		465	XDestroyImage (ximage);
		466	return true;
		467	}
		468
		469	bool
		470	rxvt_term::render_image (rxvt_image &image)
		471	{
		472	GdkPixbuf *pixbuf = image.pixbuf;
		473	if (!pixbuf)
		474	return false;
		475
		476	bool need_blend = bg_flags & BG_IS_VALID;
		477
		478	if (need_blend
		479	&& !(bg_flags & BG_HAS_RENDER))
		480	return false;
		481
		482	GdkPixbuf *result;
		483
		484	int image_width = gdk_pixbuf_get_width (pixbuf);
		485	int image_height = gdk_pixbuf_get_height (pixbuf);
403		486
404	int target_width = szHint.width;	487	int target_width = szHint.width;
405	int target_height = szHint.height;	488	int target_height = szHint.height;
406	int new_pmap_width = target_width;	489	int new_pmap_width = target_width;
407	int new_pmap_height = target_height;	490	int new_pmap_height = target_height;
…		…
409	int x = 0;	492	int x = 0;
410	int y = 0;	493	int y = 0;
411	int w = 0;	494	int w = 0;
412	int h = 0;	495	int h = 0;
413		496
414	if (original_asim)	497	get_image_geometry (image, w, h, x, y);
415	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
416		498
417	if (!original_asim	499	if (!(image.flags & IM_ROOT_ALIGN)
418	|| (!(bg_flags & BG_ROOT_ALIGN)
419	&& (x >= target_width	500	&& (x >= target_width
420	|| y >= target_height	501	|| y >= target_height
421	|| x + w <= 0	502	|| x + w <= 0
422	|| y + h <= 0)))	503	|| y + h <= 0))
		504	return false;
		505
		506	result = pixbuf;
		507
		508	if (w != image_width
		509	|| h != image_height)
		510	{
		511	result = gdk_pixbuf_scale_simple (pixbuf,
		512	w, h,
		513	GDK_INTERP_BILINEAR);
423	{	514	}
424	if (background)
425	{
426	new_pmap_width = background->width;
427	new_pmap_height = background->height;
428	result = background;
429		515
430	if (background_tint != TINT_LEAVE_SAME)	516	if (!result)
		517	return false;
		518
		519	bool ret = false;
		520
		521	XGCValues gcv;
		522	GC gc;
		523	Pixmap tmp_pixmap;
		524
		525	image_width = gdk_pixbuf_get_width (result);
		526	image_height = gdk_pixbuf_get_height (result);
		527
		528	if (need_blend)
		529	tmp_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, 32);
		530	else
		531	{
		532	if (image.flags & IM_TILE)
431	{	533	{
432	ASImage *tmp = tile_asimage (asv, background, 0, 0,	534	new_pmap_width = min (image_width, target_width);
433	target_width, target_height, background_tint,	535	new_pmap_height = min (image_height, target_height);
434	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
435	if (tmp)
436	result = tmp;
437	}
438	}	536	}
439	else
440	new_pmap_width = new_pmap_height = 0;
441	}
442	else
443	{
444	result = original_asim;
445		537
446	if (w != original_asim->width
447	|| h != original_asim->height)
448	{
449	result = scale_asimage (asv, original_asim,
450	w, h,
451	ASA_XImage,
452	100, ASIMAGE_QUALITY_DEFAULT);
453	}
454
455	if (background == NULL)
456	{
457	if (bg_flags & BG_TILE)
458	{
459	/* if tiling - pixmap has to be sized exactly as the image,
460	but there is no need to make it bigger than the window! */
461	new_pmap_width = min (result->width, target_width);
462	new_pmap_height = min (result->height, target_height);
463
464	/* we also need to tile our image in both directions */
465	ASImage *tmp = tile_asimage (asv, result,
466	(int)result->width - x,
467	(int)result->height - y,
468	new_pmap_width,
469	new_pmap_height,
470	TINT_LEAVE_SAME, ASA_XImage,
471	100, ASIMAGE_QUALITY_DEFAULT);
472	if (tmp)
473	{
474	if (result != original_asim)
475	destroy_asimage (&result);
476
477	result = tmp;
478	}
479	}
480	}
481	else
482	{
483	/* if blending background and image - pixmap has to be sized same as target window */
484	ASImageLayer *layers = create_image_layers (2);
485
486	layers[0].im = background;
487	layers[0].clip_width = target_width;
488	layers[0].clip_height = target_height;
489	layers[0].tint = background_tint;
490	layers[1].im = result;
491
492	if (bg_flags & BG_TILE)
493	{
494	/* tile horizontally */
495	while (x > 0) x -= (int)result->width;
496	layers[1].dst_x = x;
497	layers[1].clip_width = result->width+target_width;
498	}
499	else
500	{
501	/* clip horizontally */
502	layers[1].dst_x = x;
503	layers[1].clip_width = result->width;
504	}
505
506	if (bg_flags & BG_TILE)
507	{
508	while (y > 0) y -= (int)result->height;
509	layers[1].dst_y = y;
510	layers[1].clip_height = result->height + target_height;
511	}
512	else
513	{
514	layers[1].dst_y = y;
515	layers[1].clip_height = result->height;
516	}
517
518	if (rs[Rs_blendtype])
519	{
520	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
521	if (layers[1].merge_scanlines == NULL)
522	layers[1].merge_scanlines = alphablend_scanlines;
523	}
524
525	ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
526	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
527
528	if (tmp)
529	{
530	if (result != original_asim)
531	destroy_asimage (&result);
532
533	result = tmp;
534	}
535
536	free (layers);
537	}
538	}
539
540	bool ret = false;
541
542	if (result)
543	{
544	XGCValues gcv;
545	GC gc;
546
547	/* create Pixmap */
548	if (bg_pixmap == None	538	if (bg_pixmap == None
549	|| bg_pmap_width != new_pmap_width	539	|| bg_pmap_width != new_pmap_width
550	|| bg_pmap_height != new_pmap_height)	540	|| bg_pmap_height != new_pmap_height)
551	{	541	{
552	if (bg_pixmap)	542	if (bg_pixmap)
553	XFreePixmap (dpy, bg_pixmap);	543	XFreePixmap (dpy, bg_pixmap);
554	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);	544	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
555	bg_pmap_width = new_pmap_width;	545	bg_pmap_width = new_pmap_width;
556	bg_pmap_height = new_pmap_height;	546	bg_pmap_height = new_pmap_height;
557	}	547	}
558	/* fill with background color (if result's not completely overlapping it) */
559	gcv.foreground = pix_colors[Color_bg];
560	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
561		548
562	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
563	int dst_width = result->width, dst_height = result->height;
564	if (background == NULL)
565	{
566	if (!(bg_flags & BG_TILE))
567	{
568	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
569	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
570	}
571
572	if (dst_x > 0 || dst_y > 0
573	|| dst_x + dst_width < new_pmap_width
574	|| dst_y + dst_height < new_pmap_height)
575	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
576	}
577
578	/* put result on pixmap */
579	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
580	asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
581
582	if (result != background && result != original_asim)
583	destroy_asimage (&result);
584
585	XFreeGC (dpy, gc);
586
587	ret = true;
588	}
589
590	if (background)
591	destroy_asimage (&background);
592
593	return ret;
594	}
595	# endif /* HAVE_AFTERIMAGE */
596
597	# ifdef HAVE_PIXBUF
598	bool
599	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
600	int src_x, int src_y, int dst_x, int dst_y,
601	unsigned int width, unsigned int height)
602	{
603	XImage *ximage;
604	char *data, *line;
605	int bytes_per_pixel;
606	int width_r, width_g, width_b;
607	int sh_r, sh_g, sh_b;
608	int rowstride;
609	int channels;
610	unsigned char *row;
611
612	if (visual->c_class != TrueColor)
613	return false;
614
615	if (depth == 24 || depth == 32)
616	bytes_per_pixel = 4;
617	else if (depth == 15 || depth == 16)
618	bytes_per_pixel = 2;
619	else
620	return false;
621
622	width_r = ecb_popcount32 (visual->red_mask);
623	width_g = ecb_popcount32 (visual->green_mask);
624	width_b = ecb_popcount32 (visual->blue_mask);
625
626	if (width_r > 8 || width_g > 8 || width_b > 8)
627	return false;
628
629	sh_r = ecb_ctz32 (visual->red_mask);
630	sh_g = ecb_ctz32 (visual->green_mask);
631	sh_b = ecb_ctz32 (visual->blue_mask);
632
633	if (width > INT_MAX / height / bytes_per_pixel)
634	return false;
635
636	data = (char *)malloc (width * height * bytes_per_pixel);
637	if (!data)
638	return false;
639
640	ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, data,
641	width, height, bytes_per_pixel * 8, 0);
642	if (!ximage)
643	{
644	free (data);
645	return false;
646	}
647
648	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
649
650	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
651	channels = gdk_pixbuf_get_n_channels (pixbuf);
652	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
653	line = data;
654
655	for (int y = 0; y < height; y++)
656	{
657	for (int x = 0; x < width; x++)
658	{
659	unsigned char *pixel = row + x * channels;
660	uint32_t value;
661
662	value = ((pixel[0] >> (8 - width_r)) << sh_r)
663	| ((pixel[1] >> (8 - width_g)) << sh_g)
664	| ((pixel[2] >> (8 - width_b)) << sh_b);
665
666	if (bytes_per_pixel == 4)
667	((uint32_t *)line)[x] = value;
668	else
669	((uint16_t *)line)[x] = value;
670	}
671
672	row += rowstride;
673	line += ximage->bytes_per_line;
674	}
675
676	XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
677	XDestroyImage (ximage);
678	return true;
679	}
680
681	bool
682	rxvt_term::render_image (unsigned long tr_flags)
683	{
684	if (!pixbuf)
685	return false;
686
687	if (tr_flags
688	&& !(bg_flags & BG_HAS_RENDER))
689	return false;
690
691	GdkPixbuf *result;
692
693	int image_width = gdk_pixbuf_get_width (pixbuf);
694	int image_height = gdk_pixbuf_get_height (pixbuf);
695
696	int target_width = szHint.width;
697	int target_height = szHint.height;
698	int new_pmap_width = target_width;
699	int new_pmap_height = target_height;
700
701	int x = 0;
702	int y = 0;
703	int w = 0;
704	int h = 0;
705
706	get_image_geometry (image_width, image_height, w, h, x, y);
707
708	if (!(bg_flags & BG_ROOT_ALIGN)
709	&& (x >= target_width
710	|| y >= target_height
711	|| x + w <= 0
712	|| y + h <= 0))
713	return false;
714
715	result = pixbuf;
716
717	if (w != image_width
718	|| h != image_height)
719	{
720	result = gdk_pixbuf_scale_simple (pixbuf,
721	w, h,
722	GDK_INTERP_BILINEAR);
723	}
724
725	if (!result)
726	return false;
727
728	bool ret = false;
729
730	XGCValues gcv;
731	GC gc;
732	Pixmap root_pmap;
733
734	image_width = gdk_pixbuf_get_width (result);
735	image_height = gdk_pixbuf_get_height (result);
736
737	if (tr_flags)
738	{
739	root_pmap = bg_pixmap;	549	tmp_pixmap = bg_pixmap;
740	bg_pixmap = None;
741	}
742	else
743	{
744	if (bg_flags & BG_TILE)
745	{
746	new_pmap_width = min (image_width, target_width);
747	new_pmap_height = min (image_height, target_height);
748	}
749	}
750
751	if (bg_pixmap == None
752	|| bg_pmap_width != new_pmap_width
753	|| bg_pmap_height != new_pmap_height)
754	{
755	if (bg_pixmap)
756	XFreePixmap (dpy, bg_pixmap);
757	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
758	bg_pmap_width = new_pmap_width;
759	bg_pmap_height = new_pmap_height;
760	}	550	}
761		551
762	gcv.foreground = pix_colors[Color_bg];	552	gcv.foreground = pix_colors[Color_bg];
763	gc = XCreateGC (dpy, vt, GCForeground, &gcv);	553	gc = XCreateGC (dpy, tmp_pixmap, GCForeground, &gcv);
764		554
765	if (gc)	555	if (gc)
766	{	556	{
767	if (bg_flags & BG_TILE)	557	if (image.flags & IM_TILE)
768	{	558	{
769	Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);	559	Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, need_blend ? 32 : depth);
770	pixbuf_to_pixmap (result, tile, gc,	560	pixbuf_to_pixmap (result, tile, gc,
771	0, 0,	561	0, 0,
772	0, 0,	562	0, 0,
773	image_width, image_height);	563	image_width, image_height, need_blend);
774		564
775	gcv.tile = tile;	565	gcv.tile = tile;
776	gcv.fill_style = FillTiled;	566	gcv.fill_style = FillTiled;
777	gcv.ts_x_origin = x;	567	gcv.ts_x_origin = x;
778	gcv.ts_y_origin = y;	568	gcv.ts_y_origin = y;
779	XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	569	XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
780		570
781	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	571	XFillRectangle (dpy, tmp_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
782	XFreePixmap (dpy, tile);	572	XFreePixmap (dpy, tile);
783	}	573	}
784	else	574	else
785	{	575	{
786	int src_x, src_y, dst_x, dst_y;	576	int src_x, src_y, dst_x, dst_y;
…		…
790	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);	580	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
791		581
792	if (dst_x > 0 || dst_y > 0	582	if (dst_x > 0 || dst_y > 0
793	|| dst_x + dst_width < new_pmap_width	583	|| dst_x + dst_width < new_pmap_width
794	|| dst_y + dst_height < new_pmap_height)	584	|| dst_y + dst_height < new_pmap_height)
795	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	585	XFillRectangle (dpy, tmp_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
796		586
797	if (dst_x < new_pmap_width && dst_y < new_pmap_height)	587	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
798	pixbuf_to_pixmap (result, bg_pixmap, gc,	588	pixbuf_to_pixmap (result, tmp_pixmap, gc,
799	src_x, src_y,	589	src_x, src_y,
800	dst_x, dst_y,	590	dst_x, dst_y,
801	dst_width, dst_height);	591	dst_width, dst_height, need_blend);
802	}	592	}
803		593
804	#if XRENDER	594	#if XRENDER
805	if (tr_flags)	595	if (need_blend)
806	{	596	{
807	XRenderPictureAttributes pa;	597	XRenderPictFormat *argb_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
808
809	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	598	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		599
810	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	600	Picture src = XRenderCreatePicture (dpy, tmp_pixmap, argb_format, 0, 0);
811		601
812	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
813	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	602	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
814		603
815	pa.repeat = True;	604	Picture mask = create_xrender_mask (dpy, vt, False, False);
816	Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
817	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
818	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
819	XFreePixmap (dpy, mask_pmap);
820		605
821	XRenderColor mask_c;	606	XRenderColor mask_c;
822		607
823	mask_c.alpha = 0x8000;	608	mask_c.alpha = 0x8000;
824	mask_c.red = 0;	609	mask_c.red =
825	mask_c.green = 0;	610	mask_c.green =
826	mask_c.blue = 0;	611	mask_c.blue = 0;
827	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	612	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		613
828	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	614	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
829		615
830	XRenderFreePicture (dpy, src);	616	XRenderFreePicture (dpy, src);
831	XRenderFreePicture (dpy, dst);	617	XRenderFreePicture (dpy, dst);
832	XRenderFreePicture (dpy, mask);	618	XRenderFreePicture (dpy, mask);
…		…
839	}	625	}
840		626
841	if (result != pixbuf)	627	if (result != pixbuf)
842	g_object_unref (result);	628	g_object_unref (result);
843		629
844	if (tr_flags)	630	if (need_blend)
845	XFreePixmap (dpy, root_pmap);	631	XFreePixmap (dpy, tmp_pixmap);
846		632
847	return ret;	633	return ret;
848	}	634	}
849	# endif /* HAVE_PIXBUF */	635	# endif /* HAVE_PIXBUF */
850		636
851	bool	637	bool
852	rxvt_term::bg_set_file (const char *file)	638	rxvt_image::set_file (const char *file)
853	{	639	{
854	if (!file || !*file)	640	if (!file || !*file)
855	return false;	641	return false;
856		642
857	bool ret = false;	643	bool ret = false;
…		…
864	memcpy (f, file, len);	650	memcpy (f, file, len);
865	f[len] = '\0';	651	f[len] = '\0';
866	file = f;	652	file = f;
867	}	653	}
868		654
869	# ifdef HAVE_AFTERIMAGE
870	if (!asimman)
871	asimman = create_generic_imageman (rs[Rs_path]);
872	ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
873	if (image)
874	{
875	if (original_asim)
876	safe_asimage_destroy (original_asim);
877	original_asim = image;
878	bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
879	ret = true;
880	}
881	# endif
882
883	# ifdef HAVE_PIXBUF	655	# ifdef HAVE_PIXBUF
884	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	656	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
885	if (image)	657	if (image)
886	{	658	{
887	if (pixbuf)	659	if (pixbuf)
888	g_object_unref (pixbuf);	660	g_object_unref (pixbuf);
889	pixbuf = image;	661	pixbuf = image;
890	bg_flags |= BG_IS_FROM_FILE;
891	ret = true;	662	ret = true;
892	}	663	}
893	# endif	664	# endif
894		665
895	if (ret)	666	if (ret)
896	{	667	{
		668	flags = IM_IS_SET | IM_IS_SIZE_SENSITIVE;
		669	h_scale = v_scale = defaultScale;
		670	h_align = v_align = defaultAlign;
		671
897	if (p)	672	if (p)
898	bg_set_geometry (p + 1);	673	set_geometry (p + 1);
899	else
900	bg_set_default_geometry ();
901	}	674	}
902		675
903	return ret;	676	return ret;
904	}	677	}
905		678
906	# endif /* BG_IMAGE_FROM_FILE */	679	# endif /* BG_IMAGE_FROM_FILE */
907		680
908	# ifdef ENABLE_TRANSPARENCY	681	# ifdef ENABLE_TRANSPARENCY
909	bool
910	rxvt_term::bg_set_transparent ()
911	{
912	if (!(bg_flags & BG_IS_TRANSPARENT))
913	{
914	bg_flags |= BG_IS_TRANSPARENT;
915	return true;
916	}
917
918	return false;
919	}
920
921	bool	682	bool
922	rxvt_term::bg_set_blur (const char *geom)	683	rxvt_term::bg_set_blur (const char *geom)
923	{	684	{
924	bool changed = false;	685	bool changed = false;
925	unsigned int hr, vr;	686	unsigned int hr, vr;
…		…
944	{	705	{
945	changed = true;	706	changed = true;
946	v_blurRadius = vr;	707	v_blurRadius = vr;
947	}	708	}
948		709
949	if (v_blurRadius == 0 && h_blurRadius == 0)
950	bg_flags &= ~BG_NEEDS_BLUR;
951	else
952	bg_flags |= BG_NEEDS_BLUR;
953
954	return changed;	710	return changed;
955	}	711	}
956		712
957	void	713	bool
958	rxvt_term::set_tint_shade_flags ()	714	rxvt_term::bg_set_tint (rxvt_color &new_tint)
959	{	715	{
		716	if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
		717	{
		718	tint = new_tint;
		719	bg_flags |= BG_TINT_SET;
		720
960	rgba c;	721	rgba c;
961	bool has_shade = shade != 100;
962
963	bg_flags &= ~BG_TINT_FLAGS;
964
965	if (bg_flags & BG_TINT_SET)
966	{
967	tint.get (c);	722	tint.get (c);
968	if (!has_shade
969	&& (c.r <= 0x00ff || c.r >= 0xff00)	723	if ((c.r <= 0x00ff || c.r >= 0xff00)
970	&& (c.g <= 0x00ff || c.g >= 0xff00)	724	&& (c.g <= 0x00ff || c.g >= 0xff00)
971	&& (c.b <= 0x00ff || c.b >= 0xff00))	725	&& (c.b <= 0x00ff || c.b >= 0xff00))
972	bg_flags |= BG_TINT_BITAND;	726	bg_flags |= BG_TINT_BITAND;
973	}	727	else
974
975	if (has_shade || (bg_flags & BG_TINT_SET))
976	bg_flags |= BG_NEEDS_TINT;
977	}
978
979	bool
980	rxvt_term::bg_set_tint (rxvt_color &new_tint)
981	{
982	if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
983	{
984	tint = new_tint;
985	bg_flags |= BG_TINT_SET;	728	bg_flags &= ~BG_TINT_BITAND;
986	set_tint_shade_flags ();	729
987	return true;	730	return true;
988	}	731	}
989		732
990	return false;	733	return false;
991	}	734	}
…		…
1000	new_shade = 200 - (100 + new_shade);	743	new_shade = 200 - (100 + new_shade);
1001		744
1002	if (new_shade != shade)	745	if (new_shade != shade)
1003	{	746	{
1004	shade = new_shade;	747	shade = new_shade;
1005	set_tint_shade_flags ();
1006	return true;	748	return true;
1007	}	749	}
1008		750
1009	return false;	751	return false;
1010	}	752	}
…		…
1031	params[i+2] = XDoubleToFixed (kernel[i] / sum);	773	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1032	}	774	}
1033	#endif	775	#endif
1034		776
1035	bool	777	bool
1036	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	778	rxvt_term::blur_pixmap (Pixmap pixmap, int width, int height)
1037	{	779	{
1038	bool ret = false;	780	bool ret = false;
1039	#if XRENDER	781	#if XRENDER
1040	if (!(bg_flags & BG_HAS_RENDER_CONV))	782	if (!(bg_flags & BG_HAS_RENDER_CONV))
1041	return false;	783	return false;
…		…
1045	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));	787	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1046		788
1047	XRenderPictureAttributes pa;	789	XRenderPictureAttributes pa;
1048	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	790	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1049		791
		792	pa.repeat = RepeatPad;
1050	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	793	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		794	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1051	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	795	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		796	XFreePixmap (dpy, tmp);
1052		797
1053	if (kernel && params)	798	if (kernel && params)
1054	{	799	{
1055	if (h_blurRadius)
1056	{
1057	size = h_blurRadius * 2 + 1;	800	size = h_blurRadius * 2 + 1;
1058	get_gaussian_kernel (h_blurRadius, size, kernel, params);	801	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1059		802
1060	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	803	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1061	XRenderComposite (dpy,	804	XRenderComposite (dpy,
1062	PictOpSrc,	805	PictOpSrc,
1063	src,	806	src,
1064	None,	807	None,
1065	dst,	808	dst,
1066	0, 0,	809	0, 0,
1067	0, 0,	810	0, 0,
1068	0, 0,	811	0, 0,
1069	width, height);	812	width, height);
1070	}
1071		813
1072	if (v_blurRadius)	814	::swap (src, dst);
1073	{	815
1074	size = v_blurRadius * 2 + 1;	816	size = v_blurRadius * 2 + 1;
1075	get_gaussian_kernel (v_blurRadius, size, kernel, params);	817	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1076	::swap (params[0], params[1]);	818	::swap (params[0], params[1]);
1077		819
1078	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	820	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1079	XRenderComposite (dpy,	821	XRenderComposite (dpy,
1080	PictOpSrc,	822	PictOpSrc,
1081	src,	823	src,
1082	None,	824	None,
1083	dst,	825	dst,
1084	0, 0,	826	0, 0,
1085	0, 0,	827	0, 0,
1086	0, 0,	828	0, 0,
1087	width, height);	829	width, height);
1088	}
1089		830
1090	ret = true;	831	ret = true;
1091	}	832	}
1092		833
1093	free (kernel);	834	free (kernel);
…		…
1097	#endif	838	#endif
1098	return ret;	839	return ret;
1099	}	840	}
1100		841
1101	bool	842	bool
1102	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	843	rxvt_term::tint_pixmap (Pixmap pixmap, int width, int height)
1103	{	844	{
1104	bool ret = false;	845	bool ret = false;
1105		846
1106	if (bg_flags & BG_TINT_BITAND)	847	if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1107	{	848	{
1108	XGCValues gcv;	849	XGCValues gcv;
1109	GC gc;	850	GC gc;
1110		851
1111	/* In this case we can tint image server-side getting significant	852	/* In this case we can tint image server-side getting significant
…		…
1141	c.r = c.r * (200 - shade) / 100;	882	c.r = c.r * (200 - shade) / 100;
1142	c.g = c.g * (200 - shade) / 100;	883	c.g = c.g * (200 - shade) / 100;
1143	c.b = c.b * (200 - shade) / 100;	884	c.b = c.b * (200 - shade) / 100;
1144	}	885	}
1145		886
1146	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1147	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	887	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1148	XRenderPictureAttributes pa;
1149		888
1150	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	889	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1151		890
1152	pa.repeat = True;	891	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1153		892
1154	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	893	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1155	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1156	XFreePixmap (dpy, overlay_pmap);
1157
1158	pa.component_alpha = True;
1159	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1160	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat | CPComponentAlpha, &pa);
1161	XFreePixmap (dpy, mask_pmap);
1162		894
1163	XRenderColor mask_c;	895	XRenderColor mask_c;
1164		896
1165	mask_c.alpha = 0xffff;	897	mask_c.alpha = 0xffff;
1166	mask_c.red =	898	mask_c.red =
…		…
1171	mask_c.alpha = 0;	903	mask_c.alpha = 0;
1172	mask_c.red = 0xffff - c.r;	904	mask_c.red = 0xffff - c.r;
1173	mask_c.green = 0xffff - c.g;	905	mask_c.green = 0xffff - c.g;
1174	mask_c.blue = 0xffff - c.b;	906	mask_c.blue = 0xffff - c.b;
1175	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	907	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		908
1176	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);	909	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1177		910
1178	if (shade > 100)	911	if (shade > 100)
1179	{	912	{
1180	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1181	mask_c.alpha = 0;	913	mask_c.alpha = 0;
		914	mask_c.red =
		915	mask_c.green =
		916	mask_c.blue = 0xffff * (shade - 100) / 100;
1182	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	917	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1183		918
1184	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);	919	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1185	}	920	}
1186		921
…		…
1198	/*	933	/*
1199	* Builds a pixmap of the same size as the terminal window that contains	934	* Builds a pixmap of the same size as the terminal window that contains
1200	* the tiled portion of the root pixmap that is supposed to be covered by	935	* the tiled portion of the root pixmap that is supposed to be covered by
1201	* our window.	936	* our window.
1202	*/	937	*/
1203	unsigned long	938	bool
1204	rxvt_term::make_transparency_pixmap ()	939	rxvt_term::make_transparency_pixmap ()
1205	{	940	{
1206	unsigned long result = 0;	941	bool ret = false;
1207		942
1208	/* root dimensions may change from call to call - but Display structure should	943	/* root dimensions may change from call to call - but Display structure should
1209	* be always up-to-date, so let's use it :	944	* be always up-to-date, so let's use it :
1210	*/	945	*/
1211	int screen = display->screen;	946	int screen = display->screen;
…		…
1249	#if XRENDER	984	#if XRENDER
1250	if (bg_flags & BG_HAS_RENDER)	985	if (bg_flags & BG_HAS_RENDER)
1251	{	986	{
1252	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);	987	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1253		988
1254	XRenderPictureAttributes pa;
1255
1256	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	989	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1257	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	990	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1258		991
1259	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	992	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1260	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	993	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1261		994
1262	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	995	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1263		996
1264	XRenderFreePicture (dpy, src);	997	XRenderFreePicture (dpy, src);
1265	XRenderFreePicture (dpy, dst);	998	XRenderFreePicture (dpy, dst);
…		…
1294	gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	1027	gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1295		1028
1296	if (gc)	1029	if (gc)
1297	{	1030	{
1298	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1031	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1299	result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS);	1032	ret = true;
		1033	bool need_blur = h_blurRadius && v_blurRadius;
		1034	bool need_tint = shade != 100 || (bg_flags & BG_TINT_SET);
		1035
		1036	if (!(bg_flags & BG_CLIENT_RENDER))
		1037	{
		1038	if (need_blur)
		1039	{
		1040	if (blur_pixmap (bg_pixmap, window_width, window_height))
		1041	need_blur = false;
		1042	}
		1043	if (need_tint)
		1044	{
		1045	if (tint_pixmap (bg_pixmap, window_width, window_height))
		1046	need_tint = false;
		1047	}
		1048	if (need_tint)
		1049	{
		1050	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1051	if (ximage)
		1052	{
		1053	/* our own client-side tinting */
		1054	tint_ximage (ximage);
		1055
		1056	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1057	XDestroyImage (ximage);
		1058	}
		1059	}
		1060	} /* server side rendering completed */
		1061
1300	XFreeGC (dpy, gc);	1062	XFreeGC (dpy, gc);
1301
1302	if (!(bg_flags & BG_CLIENT_RENDER))
1303	{
1304	if (bg_flags & BG_NEEDS_BLUR)
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	{
1311	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1312	result &= ~BG_NEEDS_TINT;
1313	}
1314	} /* server side rendering completed */
1315	}	1063	}
1316		1064
1317	if (recoded_root_pmap != root_pixmap)	1065	if (recoded_root_pmap != root_pixmap)
1318	XFreePixmap (dpy, recoded_root_pmap);	1066	XFreePixmap (dpy, recoded_root_pmap);
1319		1067
1320	return result;	1068	return ret;
1321	}	1069	}
1322		1070
1323	void	1071	void
1324	rxvt_term::bg_set_root_pixmap ()	1072	rxvt_term::bg_set_root_pixmap ()
1325	{	1073	{
…		…
1332	# endif /* ENABLE_TRANSPARENCY */	1080	# endif /* ENABLE_TRANSPARENCY */
1333		1081
1334	bool	1082	bool
1335	rxvt_term::bg_render ()	1083	rxvt_term::bg_render ()
1336	{	1084	{
1337	unsigned long tr_flags = 0;
1338
1339	bg_invalidate ();	1085	bg_invalidate ();
1340	# ifdef ENABLE_TRANSPARENCY	1086	# ifdef ENABLE_TRANSPARENCY
1341	if (bg_flags & BG_IS_TRANSPARENT)	1087	if (bg_flags & BG_IS_TRANSPARENT)
1342	{	1088	{
1343	/* we need to re-generate transparency pixmap in that case ! */	1089	/* we need to re-generate transparency pixmap in that case ! */
1344	tr_flags = make_transparency_pixmap ();	1090	if (make_transparency_pixmap ())
1345	if (tr_flags == 0)
1346	return false;
1347	bg_flags |= BG_IS_VALID;	1091	bg_flags |= BG_IS_VALID;
1348	}	1092	}
1349	# endif	1093	# endif
1350		1094
1351	# ifdef BG_IMAGE_FROM_FILE	1095	# ifdef BG_IMAGE_FROM_FILE
1352	if ((bg_flags & BG_IS_FROM_FILE)	1096	if (bg_image.flags & IM_IS_SET)
1353	|| (tr_flags & BG_EFFECTS_FLAGS))
1354	{	1097	{
1355	if (render_image (tr_flags))	1098	if (render_image (bg_image))
1356	bg_flags |= BG_IS_VALID;	1099	bg_flags |= BG_IS_VALID;
1357	}
1358	# endif
1359
1360	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1361	XImage *result = NULL;
1362
1363	if (tr_flags & BG_NEEDS_TINT)
1364	{
1365	result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1366	}
1367
1368	if (result)
1369	{
1370	/* our own client-side tinting */
1371	//if (tr_flags & BG_NEEDS_TINT)
1372	if (1)
1373	tint_ximage (DefaultVisual (dpy, display->screen), result);
1374
1375	GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1376
1377	if (gc)
1378	{
1379	XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1380
1381	XFreeGC (dpy, gc);
1382	}
1383
1384	XDestroyImage (result);
1385	}	1100	}
1386	# endif	1101	# endif
1387		1102
1388	if (!(bg_flags & BG_IS_VALID))	1103	if (!(bg_flags & BG_IS_VALID))
1389	{	1104	{
…		…
1426	#endif	1141	#endif
1427	}	1142	}
1428		1143
1429	#endif /* HAVE_BG_PIXMAP */	1144	#endif /* HAVE_BG_PIXMAP */
1430		1145
1431	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1146	#ifdef ENABLE_TRANSPARENCY
1432	/* based on code from aterm-0.4.2 */	1147	/* based on code from aterm-0.4.2 */
1433		1148
1434	static inline void	1149	static inline void
1435	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)	1150	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1436	{	1151	{
…		…
1442	lookup[i] = (tmp / 0xffff) << sh;	1157	lookup[i] = (tmp / 0xffff) << sh;
1443	}	1158	}
1444	}	1159	}
1445		1160
1446	void	1161	void
1447	rxvt_term::tint_ximage (Visual *visual, XImage *ximage)	1162	rxvt_term::tint_ximage (XImage *ximage)
1448	{	1163	{
		1164	unsigned int size_r, size_g, size_b;
1449	int sh_r, sh_g, sh_b;	1165	int sh_r, sh_g, sh_b;
1450	uint32_t mask_r, mask_g, mask_b;	1166	uint32_t mask_r, mask_g, mask_b;
1451	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;	1167	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1452	unsigned short low;	1168	unsigned short low;
1453	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	1169	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
…		…
1458	mask_r = visual->red_mask;	1174	mask_r = visual->red_mask;
1459	mask_g = visual->green_mask;	1175	mask_g = visual->green_mask;
1460	mask_b = visual->blue_mask;	1176	mask_b = visual->blue_mask;
1461		1177
1462	/* boring lookup table pre-initialization */	1178	/* boring lookup table pre-initialization */
1463	switch (ximage->depth)	1179	sh_r = ecb_ctz32 (mask_r);
1464	{	1180	sh_g = ecb_ctz32 (mask_g);
1465	case 15:	1181	sh_b = ecb_ctz32 (mask_b);
1466	if ((mask_r != 0x7c00) ||	1182
1467	(mask_g != 0x03e0) ||	1183	size_r = mask_r >> sh_r;
1468	(mask_b != 0x001f))	1184	size_g = mask_g >> sh_g;
		1185	size_b = mask_b >> sh_b;
		1186
		1187	if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1469	return;	1188	return;
1470	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32));	1189
		1190	lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1471	lookup_r = lookup;	1191	lookup_r = lookup;
1472	lookup_g = lookup+32;	1192	lookup_g = lookup + size_r;
1473	lookup_b = lookup+32+32;	1193	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		1194
1521	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);	1195	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1522		1196
1523	if (bg_flags & BG_TINT_SET)	1197	if (bg_flags & BG_TINT_SET)
1524	tint.get (c);	1198	tint.get (c);
…		…
1546	fill_lut (lookup_g, mask_g, sh_g, low, c.g);	1220	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1547	fill_lut (lookup_b, mask_b, sh_b, low, c.b);	1221	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1548		1222
1549	/* apply table to input image (replacing colors by newly calculated ones) */	1223	/* apply table to input image (replacing colors by newly calculated ones) */
1550	if (ximage->bits_per_pixel == 32	1224	if (ximage->bits_per_pixel == 32
1551	&& (ximage->depth == 24 || ximage->depth == 32)
1552	&& ximage->byte_order == host_byte_order)	1225	&& ximage->byte_order == host_byte_order)
1553	{	1226	{
1554	uint32_t *p1, *pf, *p, *pl;	1227	char *line = ximage->data;
1555	p1 = (uint32_t *) ximage->data;
1556	pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1557		1228
1558	while (p1 < pf)	1229	for (int y = 0; y < ximage->height; y++)
1559	{
1560	p = p1;
1561	pl = p1 + ximage->width;
1562	for (; p < pl; p++)
1563	{	1230	{
1564	*p = lookup_r[(*p & 0xff0000) >> 16] |	1231	uint32_t *p = (uint32_t *)line;
1565	lookup_g[(*p & 0x00ff00) >> 8] |	1232	for (int x = 0; x < ximage->width; x++)
1566	lookup_b[(*p & 0x0000ff)] |
1567	(*p & 0xff000000);
1568	}	1233	{
1569	p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line);	1234	*p = lookup_r[(*p & mask_r) >> sh_r] |
		1235	lookup_g[(*p & mask_g) >> sh_g] |
		1236	lookup_b[(*p & mask_b) >> sh_b];
		1237	p++;
		1238	}
		1239	line += ximage->bytes_per_line;
1570	}	1240	}
1571	}	1241	}
1572	else	1242	else
1573	{	1243	{
1574	for (int y = 0; y < ximage->height; y++)	1244	for (int y = 0; y < ximage->height; y++)
…		…
1582	}	1252	}
1583	}	1253	}
1584		1254
1585	free (lookup);	1255	free (lookup);
1586	}	1256	}
1587	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1257	#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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