ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/rxvt-unicode/src/background.C

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

Diff Legend

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