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.159 by sf-exg, Wed Aug 10 07:34:35 2011 UTC vs.
Revision 1.214 by sf-exg, Thu May 17 10:18:32 2012 UTC

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

Diff Legend

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