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

Diff Legend

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