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.218 by sf-exg, Mon May 21 12:29:22 2012 UTC

…		…
3	*----------------------------------------------------------------------*	3	*----------------------------------------------------------------------*
4	*	4	*
5	* All portions of code are copyright by their respective author/s.	5	* All portions of code are copyright by their respective author/s.
6	* Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>	6	* Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>
7	* Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>	7	* Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
8	* Copyright (c) 2010 Emanuele Giaquinta <e.giaquinta@glauco.it>	8	* Copyright (c) 2010-2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
9	*	9	*
10	* This program is free software; you can redistribute it and/or modify	10	* This program is free software; you can redistribute it and/or modify
11	* it under the terms of the GNU General Public License as published by	11	* it under the terms of the GNU General Public License as published by
12	* the Free Software Foundation; either version 2 of the License, or	12	* the Free Software Foundation; either version 2 of the License, or
13	* (at your option) any later version.	13	* (at your option) any later version.
…		…
20	* You should have received a copy of the GNU General Public License	20	* You should have received a copy of the GNU General Public License
21	* along with this program; if not, write to the Free Software	21	* along with this program; if not, write to the Free Software
22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23	*---------------------------------------------------------------------*/	23	*---------------------------------------------------------------------*/
24		24
25	#include <cmath>	25	#include <math.h>
26	#include "../config.h" /* NECESSARY */	26	#include "../config.h" /* NECESSARY */
27	#include "rxvt.h" /* NECESSARY */	27	#include "rxvt.h" /* NECESSARY */
28		28
29	#if XRENDER	29	#if XRENDER
30	# include <X11/extensions/Xrender.h>	30	# include <X11/extensions/Xrender.h>
…		…
32		32
33	#ifndef FilterConvolution	33	#ifndef FilterConvolution
34	#define FilterConvolution "convolution"	34	#define FilterConvolution "convolution"
35	#endif	35	#endif
36		36
37	/*	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	clamp_it (x, -100, 200);
261	{	280	clamp_it (y, -100, 200);
262	if (!strcasecmp (arr[i], "tile"))
263	{
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		281
276	h = noScale;	282	if (flags != new_flags
277	geom_flags |= WidthValue|HeightValue;	283	|| h_scale != w
278	}	284	|| v_scale != h
279	else if (!strcasecmp (arr[i], "vscale"))	285	|| h_align != x
280	{	286	|| 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	}	287	{
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;	288	flags = new_flags;
		289	h_scale = w;
		290	v_scale = h;
		291	h_align = x;
		292	v_align = y;
312	changed = true;	293	changed = true;
313	}	294	}
314		295
		296	if (!(flags & IM_TILE)
		297	|| h_scale || v_scale
		298	|| (!(flags & IM_ROOT_ALIGN) && (h_align || v_align)))
		299	flags |= IM_IS_SIZE_SENSITIVE;
		300	else
		301	flags &= ~IM_IS_SIZE_SENSITIVE;
		302
315	return changed;	303	return changed;
316	}	304	}
317		305
318	void	306	void
319	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)	307	rxvt_term::get_image_geometry (rxvt_image &image, int &w, int &h, int &x, int &y)
320	{	308	{
		309	int image_width = image.width ();
		310	int image_height = image.height ();
321	int target_width = szHint.width;	311	int target_width = szHint.width;
322	int target_height = szHint.height;	312	int target_height = szHint.height;
		313	int h_scale = min (image.h_scale, 32767 * 100 / target_width);
		314	int v_scale = min (image.v_scale, 32767 * 100 / target_height);
323		315
324	if (bg_flags & BG_PROP_SCALE)	316	w = h_scale * target_width / 100;
		317	h = 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, bool argb)
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 red_mask, green_mask, blue_mask, 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 (argb)
385	}	361	{
386		362	red_mask = 0xff << 16;
387	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)	363	green_mask = 0xff << 8;
		364	blue_mask = 0xff;
		365	alpha_mask = 0xff << 24;
388	{	366	}
389	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,	367	else
390	(original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,	368	{
391	100, ASIMAGE_QUALITY_DEFAULT);	369	red_mask = visual->red_mask;
		370	green_mask = visual->green_mask;
		371	blue_mask = visual->blue_mask;
		372	#if XRENDER
		373	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
392	if (tmp)	374	if (format)
		375	alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
		376	else
		377	#endif
		378	alpha_mask = 0;
		379	}
		380
		381	width_r = ecb_popcount32 (red_mask);
		382	width_g = ecb_popcount32 (green_mask);
		383	width_b = ecb_popcount32 (blue_mask);
		384	width_a = ecb_popcount32 (alpha_mask);
		385
		386	if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
		387	return false;
		388
		389	sh_r = ecb_ctz32 (red_mask);
		390	sh_g = ecb_ctz32 (green_mask);
		391	sh_b = ecb_ctz32 (blue_mask);
		392	sh_a = ecb_ctz32 (alpha_mask);
		393
		394	if (width > 32767 || height > 32767)
		395	return false;
		396
		397	ximage = XCreateImage (dpy, visual, argb ? 32 : depth, ZPixmap, 0, 0,
		398	width, height, 32, 0);
		399	if (!ximage)
		400	return false;
		401
		402	if (height > INT_MAX / ximage->bytes_per_line
		403	|| !(ximage->data = (char *)malloc (height * ximage->bytes_per_line)))
		404	{
		405	XDestroyImage (ximage);
		406	return false;
		407	}
		408
		409	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
		410
		411	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
		412	channels = gdk_pixbuf_get_n_channels (pixbuf);
		413	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
		414	line = ximage->data;
		415
		416	rgba c (0, 0, 0);
		417
		418	if (channels == 4 && alpha_mask == 0)
		419	{
		420	pix_colors[Color_bg].get (c);
		421	c.r >>= 8;
		422	c.g >>= 8;
		423	c.b >>= 8;
		424	}
		425
		426	for (int y = 0; y < height; y++)
		427	{
		428	for (int x = 0; x < width; x++)
		429	{
		430	unsigned char *pixel = row + x * channels;
		431	uint32_t value;
		432	unsigned char r, g, b, a;
		433
		434	if (channels == 4)
393	{	435	{
394	destroy_asimage (&background);	436	a = pixel[3];
395	background = tmp;	437	r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
		438	g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
		439	b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
		440	}
		441	else
		442	{
		443	a = 0xff;
		444	r = pixel[0];
		445	g = pixel[1];
		446	b = pixel[2];
		447	}
		448
		449	value = ((r >> (8 - width_r)) << sh_r)
		450	| ((g >> (8 - width_g)) << sh_g)
		451	| ((b >> (8 - width_b)) << sh_b)
		452	| ((a >> (8 - width_a)) << sh_a);
		453
		454	if (ximage->bits_per_pixel == 32)
		455	((uint32_t *)line)[x] = value;
		456	else
		457	XPutPixel (ximage, x, y, value);
396	}	458	}
397	}
398	# endif
399		459
400	ASImage *result = 0;	460	row += rowstride;
		461	line += ximage->bytes_per_line;
		462	}
		463
		464	XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
		465	XDestroyImage (ximage);
		466	return true;
		467	}
		468
		469	bool
		470	rxvt_term::render_image (rxvt_image &image)
		471	{
		472	GdkPixbuf *pixbuf = image.pixbuf;
		473	if (!pixbuf)
		474	return false;
		475
		476	bool need_blend = bg_flags & BG_IS_VALID;
		477
		478	if (need_blend
		479	&& !(bg_flags & BG_HAS_RENDER))
		480	return false;
		481
		482	GdkPixbuf *result;
		483
		484	int image_width = gdk_pixbuf_get_width (pixbuf);
		485	int image_height = gdk_pixbuf_get_height (pixbuf);
401		486
402	int target_width = szHint.width;	487	int target_width = szHint.width;
403	int target_height = szHint.height;	488	int target_height = szHint.height;
404	int new_pmap_width = target_width;	489	int new_pmap_width = target_width;
405	int new_pmap_height = target_height;	490	int new_pmap_height = target_height;
…		…
407	int x = 0;	492	int x = 0;
408	int y = 0;	493	int y = 0;
409	int w = 0;	494	int w = 0;
410	int h = 0;	495	int h = 0;
411		496
412	if (original_asim)	497	get_image_geometry (image, w, h, x, y);
413	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
414		498
415	if (!original_asim	499	if (!(image.flags & IM_ROOT_ALIGN)
416	|| (!(bg_flags & BG_ROOT_ALIGN)
417	&& (x >= target_width	500	&& (x >= target_width
418	|| y >= target_height	501	|| y >= target_height
419	|| (x + w <= 0)	502	|| x + w <= 0
420	|| (y + h <= 0))))	503	|| y + h <= 0))
		504	return false;
		505
		506	result = pixbuf;
		507
		508	if (w != image_width
		509	|| h != image_height)
		510	{
		511	result = gdk_pixbuf_scale_simple (pixbuf,
		512	w, h,
		513	GDK_INTERP_BILINEAR);
421	{	514	}
422	if (background)
423	{
424	new_pmap_width = background->width;
425	new_pmap_height = background->height;
426	result = background;
427		515
428	if (background_tint != TINT_LEAVE_SAME)	516	if (!result)
		517	return false;
		518
		519	bool ret = false;
		520
		521	XGCValues gcv;
		522	GC gc;
		523	Pixmap tmp_pixmap;
		524
		525	image_width = gdk_pixbuf_get_width (result);
		526	image_height = gdk_pixbuf_get_height (result);
		527
		528	if (need_blend)
		529	tmp_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, 32);
		530	else
		531	{
		532	if (image.flags & IM_TILE)
429	{	533	{
430	ASImage *tmp = tile_asimage (asv, background, 0, 0,	534	new_pmap_width = min (image_width, target_width);
431	target_width, target_height, background_tint,	535	new_pmap_height = min (image_height, target_height);
432	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
433	if (tmp)
434	result = tmp;
435	}
436	}	536	}
437	else
438	new_pmap_width = new_pmap_height = 0;
439	}
440	else
441	{
442	result = original_asim;
443		537
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	538	if (bg_pixmap == None
547	|| bg_pmap_width != new_pmap_width	539	|| bg_pmap_width != new_pmap_width
548	|| bg_pmap_height != new_pmap_height)	540	|| bg_pmap_height != new_pmap_height)
549	{	541	{
550	if (bg_pixmap)	542	if (bg_pixmap)
551	XFreePixmap (dpy, bg_pixmap);	543	XFreePixmap (dpy, bg_pixmap);
552	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);	544	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
553	bg_pmap_width = new_pmap_width;	545	bg_pmap_width = new_pmap_width;
554	bg_pmap_height = new_pmap_height;	546	bg_pmap_height = new_pmap_height;
555	}	547	}
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		548
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)
707	&& (x >= target_width
708	|| y >= target_height
709	|| (x + w <= 0)
710	|| (y + h <= 0)))
711	return false;
712
713	result = pixbuf;
714
715	if ((w != image_width)
716	|| (h != image_height))
717	{
718	result = gdk_pixbuf_scale_simple (pixbuf,
719	w, h,
720	GDK_INTERP_BILINEAR);
721	}
722
723	if (!result)
724	return false;
725
726	bool ret = false;
727
728	XGCValues gcv;
729	GC gc;
730	Pixmap root_pmap;
731
732	image_width = gdk_pixbuf_get_width (result);
733	image_height = gdk_pixbuf_get_height (result);
734
735	if (tr_flags)
736	{
737	root_pmap = bg_pixmap;	549	tmp_pixmap = bg_pixmap;
738	bg_pixmap = None;
739	}
740	else
741	{
742	if (bg_flags & BG_TILE)
743	{
744	new_pmap_width = min (image_width, target_width);
745	new_pmap_height = min (image_height, target_height);
746	}
747	}
748
749	if (bg_pixmap == None
750	|| bg_pmap_width != new_pmap_width
751	|| bg_pmap_height != new_pmap_height)
752	{
753	if (bg_pixmap)
754	XFreePixmap (dpy, bg_pixmap);
755	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
756	bg_pmap_width = new_pmap_width;
757	bg_pmap_height = new_pmap_height;
758	}	550	}
759		551
760	gcv.foreground = pix_colors[Color_bg];	552	gcv.foreground = pix_colors[Color_bg];
761	gc = XCreateGC (dpy, vt, GCForeground, &gcv);	553	gc = XCreateGC (dpy, tmp_pixmap, GCForeground, &gcv);
762		554
763	if (gc)	555	if (gc)
764	{	556	{
765	if (bg_flags & BG_TILE)	557	if (image.flags & IM_TILE)
766	{	558	{
767	Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);	559	Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, need_blend ? 32 : depth);
768	pixbuf_to_pixmap (result, tile, gc,	560	pixbuf_to_pixmap (result, tile, gc,
769	0, 0,	561	0, 0,
770	0, 0,	562	0, 0,
771	image_width, image_height);	563	image_width, image_height, need_blend);
772		564
773	gcv.tile = tile;	565	gcv.tile = tile;
774	gcv.fill_style = FillTiled;	566	gcv.fill_style = FillTiled;
775	gcv.ts_x_origin = x;	567	gcv.ts_x_origin = x;
776	gcv.ts_y_origin = y;	568	gcv.ts_y_origin = y;
777	XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	569	XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
778		570
779	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	571	XFillRectangle (dpy, tmp_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
780	XFreePixmap (dpy, tile);	572	XFreePixmap (dpy, tile);
781	}	573	}
782	else	574	else
783	{	575	{
784	int src_x, src_y, dst_x, dst_y;	576	int src_x, src_y, dst_x, dst_y;
…		…
788	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);	580	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
789		581
790	if (dst_x > 0 || dst_y > 0	582	if (dst_x > 0 || dst_y > 0
791	|| dst_x + dst_width < new_pmap_width	583	|| dst_x + dst_width < new_pmap_width
792	|| dst_y + dst_height < new_pmap_height)	584	|| dst_y + dst_height < new_pmap_height)
793	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	585	XFillRectangle (dpy, tmp_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
794		586
795	if (dst_x < new_pmap_width && dst_y < new_pmap_height)	587	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
796	pixbuf_to_pixmap (result, bg_pixmap, gc,	588	pixbuf_to_pixmap (result, tmp_pixmap, gc,
797	src_x, src_y,	589	src_x, src_y,
798	dst_x, dst_y,	590	dst_x, dst_y,
799	dst_width, dst_height);	591	dst_width, dst_height, need_blend);
800	}	592	}
801		593
802	#if XRENDER	594	#if XRENDER
803	if (tr_flags)	595	if (need_blend)
804	{	596	{
805	XRenderPictureAttributes pa;	597	XRenderPictFormat *argb_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
806
807	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	598	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		599
808	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	600	Picture src = XRenderCreatePicture (dpy, tmp_pixmap, argb_format, 0, 0);
809		601
810	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
811	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	602	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
812		603
813	pa.repeat = True;	604	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		605
819	XRenderColor mask_c;	606	XRenderColor mask_c;
820		607
821	mask_c.alpha = 0x8000;	608	mask_c.alpha = 0x8000;
822	mask_c.red = 0;	609	mask_c.red =
823	mask_c.green = 0;	610	mask_c.green =
824	mask_c.blue = 0;	611	mask_c.blue = 0;
825	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	612	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		613
826	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	614	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
827		615
828	XRenderFreePicture (dpy, src);	616	XRenderFreePicture (dpy, src);
829	XRenderFreePicture (dpy, dst);	617	XRenderFreePicture (dpy, dst);
830	XRenderFreePicture (dpy, mask);	618	XRenderFreePicture (dpy, mask);
…		…
837	}	625	}
838		626
839	if (result != pixbuf)	627	if (result != pixbuf)
840	g_object_unref (result);	628	g_object_unref (result);
841		629
842	if (tr_flags)	630	if (need_blend)
843	XFreePixmap (dpy, root_pmap);	631	XFreePixmap (dpy, tmp_pixmap);
844		632
845	return ret;	633	return ret;
846	}	634	}
847	# endif /* HAVE_PIXBUF */	635	# endif /* HAVE_PIXBUF */
848		636
849	bool	637	bool
850	rxvt_term::bg_set_file (const char *file)	638	rxvt_image::set_file (const char *file)
851	{	639	{
852	if (!file || !*file)	640	if (!file || !*file)
853	return false;	641	return false;
854		642
		643	bool ret = false;
855	if (const char *p = strchr (file, ';'))	644	const char *p = strchr (file, ';');
		645
		646	if (p)
856	{	647	{
857	size_t len = p - file;	648	size_t len = p - file;
858	char *f = rxvt_temp_buf<char> (len + 1);	649	char *f = rxvt_temp_buf<char> (len + 1);
859	memcpy (f, file, len);	650	memcpy (f, file, len);
860	f[len] = '\0';	651	f[len] = '\0';
861	file = f;	652	file = f;
862	}	653	}
863		654
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	655	# ifdef HAVE_PIXBUF
879	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	656	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
880	if (image)	657	if (image)
881	{	658	{
882	if (pixbuf)	659	if (pixbuf)
883	g_object_unref (pixbuf);	660	g_object_unref (pixbuf);
884	pixbuf = image;	661	pixbuf = image;
885	bg_flags |= BG_IS_FROM_FILE;
886	return true;	662	ret = true;
887	}	663	}
888	# endif	664	# endif
889		665
		666	if (ret)
		667	{
		668	flags = IM_IS_SET | IM_IS_SIZE_SENSITIVE;
		669	h_scale = v_scale = defaultScale;
		670	h_align = v_align = defaultAlign;
		671
		672	if (p)
		673	set_geometry (p + 1);
		674	}
		675
890	return false;	676	return ret;
891	}	677	}
892		678
893	# endif /* BG_IMAGE_FROM_FILE */	679	# endif /* BG_IMAGE_FROM_FILE */
894		680
895	# ifdef ENABLE_TRANSPARENCY	681	# 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	682	bool
909	rxvt_term::bg_set_blur (const char *geom)	683	rxvt_term::bg_set_blur (const char *geom)
910	{	684	{
911	bool changed = false;	685	bool changed = false;
912	unsigned int hr, vr;	686	unsigned int hr, vr;
…		…
931	{	705	{
932	changed = true;	706	changed = true;
933	v_blurRadius = vr;	707	v_blurRadius = vr;
934	}	708	}
935		709
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;	710	return changed;
942	}	711	}
943		712
944	void	713	bool
945	rxvt_term::set_tint_shade_flags ()	714	rxvt_term::bg_set_tint (rxvt_color &new_tint)
946	{	715	{
947	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	716	if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
948	bool has_shade = shade != 100;	717	{
949		718	tint = new_tint;
950	bg_flags &= ~BG_TINT_FLAGS;	719	bg_flags |= BG_TINT_SET;
951		720
952	if (bg_flags & BG_TINT_SET)	721	rgba c;
953	{
954	tint.get (c);	722	tint.get (c);
955	if (!has_shade
956	&& (c.r <= 0x00ff || c.r >= 0xff00)	723	if ((c.r <= 0x00ff || c.r >= 0xff00)
957	&& (c.g <= 0x00ff || c.g >= 0xff00)	724	&& (c.g <= 0x00ff || c.g >= 0xff00)
958	&& (c.b <= 0x00ff || c.b >= 0xff00))	725	&& (c.b <= 0x00ff || c.b >= 0xff00))
959	bg_flags |= BG_TINT_BITAND;	726	bg_flags |= BG_TINT_BITAND;
960	}	727	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;	728	bg_flags &= ~BG_TINT_BITAND;
973	set_tint_shade_flags ();	729
974	return true;	730	return true;
975	}	731	}
976		732
977	return false;	733	return false;
978	}	734	}
979		735
980	bool	736	bool
981	rxvt_term::bg_set_shade (const char *shade_str)	737	rxvt_term::bg_set_shade (const char *shade_str)
982	{	738	{
983	int new_shade = (shade_str) ? atoi (shade_str) : 100;	739	int new_shade = atoi (shade_str);
984		740
985	clamp_it (new_shade, -100, 200);	741	clamp_it (new_shade, -100, 200);
986	if (new_shade < 0)	742	if (new_shade < 0)
987	new_shade = 200 - (100 + new_shade);	743	new_shade = 200 - (100 + new_shade);
988		744
989	if (new_shade != shade)	745	if (new_shade != shade)
990	{	746	{
991	shade = new_shade;	747	shade = new_shade;
992	set_tint_shade_flags ();
993	return true;	748	return true;
994	}	749	}
995		750
996	return false;	751	return false;
997	}	752	}
…		…
1018	params[i+2] = XDoubleToFixed (kernel[i] / sum);	773	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1019	}	774	}
1020	#endif	775	#endif
1021		776
1022	bool	777	bool
1023	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	778	rxvt_term::blur_pixmap (Pixmap pixmap, int width, int height)
1024	{	779	{
1025	bool ret = false;	780	bool ret = false;
1026	#if XRENDER	781	#if XRENDER
		782	if (!(bg_flags & BG_HAS_RENDER_CONV))
		783	return false;
		784
1027	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	785	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1028	double *kernel = (double *)malloc (size * sizeof (double));	786	double *kernel = (double *)malloc (size * sizeof (double));
1029	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));	787	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1030		788
1031	XRenderPictureAttributes pa;	789	XRenderPictureAttributes pa;
1032	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	790	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1033		791
		792	pa.repeat = RepeatPad;
1034	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	793	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		794	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1035	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	795	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		796	XFreePixmap (dpy, tmp);
1036		797
1037	if (kernel && params)	798	if (kernel && params)
1038	{	799	{
1039	if (h_blurRadius)
1040	{
1041	size = h_blurRadius * 2 + 1;	800	size = h_blurRadius * 2 + 1;
1042	get_gaussian_kernel (h_blurRadius, size, kernel, params);	801	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1043		802
1044	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	803	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1045	XRenderComposite (dpy,	804	XRenderComposite (dpy,
1046	PictOpSrc,	805	PictOpSrc,
1047	src,	806	src,
1048	None,	807	None,
1049	dst,	808	dst,
1050	0, 0,	809	0, 0,
1051	0, 0,	810	0, 0,
1052	0, 0,	811	0, 0,
1053	width, height);	812	width, height);
1054	}
1055		813
1056	if (v_blurRadius)	814	::swap (src, dst);
1057	{	815
1058	size = v_blurRadius * 2 + 1;	816	size = v_blurRadius * 2 + 1;
1059	get_gaussian_kernel (v_blurRadius, size, kernel, params);	817	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1060	::swap (params[0], params[1]);	818	::swap (params[0], params[1]);
1061		819
1062	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	820	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1063	XRenderComposite (dpy,	821	XRenderComposite (dpy,
1064	PictOpSrc,	822	PictOpSrc,
1065	src,	823	src,
1066	None,	824	None,
1067	dst,	825	dst,
1068	0, 0,	826	0, 0,
1069	0, 0,	827	0, 0,
1070	0, 0,	828	0, 0,
1071	width, height);	829	width, height);
1072	}
1073		830
1074	ret = true;	831	ret = true;
1075	}	832	}
1076		833
1077	free (kernel);	834	free (kernel);
…		…
1081	#endif	838	#endif
1082	return ret;	839	return ret;
1083	}	840	}
1084		841
1085	bool	842	bool
1086	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	843	rxvt_term::tint_pixmap (Pixmap pixmap, int width, int height)
1087	{	844	{
1088	bool ret = false;	845	bool ret = false;
1089		846
1090	if (bg_flags & BG_TINT_BITAND)	847	if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1091	{	848	{
1092	XGCValues gcv;	849	XGCValues gcv;
1093	GC gc;	850	GC gc;
1094		851
1095	/* In this case we can tint image server-side getting significant	852	/* In this case we can tint image server-side getting significant
…		…
1104	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	861	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1105	ret = true;	862	ret = true;
1106	XFreeGC (dpy, gc);	863	XFreeGC (dpy, gc);
1107	}	864	}
1108	}	865	}
1109	else
1110	{
1111	# if XRENDER	866	# if XRENDER
		867	else if (bg_flags & BG_HAS_RENDER)
		868	{
1112	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);	869	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1113		870
1114	if (bg_flags & BG_TINT_SET)	871	if (bg_flags & BG_TINT_SET)
1115	tint.get (c);	872	tint.get (c);
1116		873
…		…
1125	c.r = c.r * (200 - shade) / 100;	882	c.r = c.r * (200 - shade) / 100;
1126	c.g = c.g * (200 - shade) / 100;	883	c.g = c.g * (200 - shade) / 100;
1127	c.b = c.b * (200 - shade) / 100;	884	c.b = c.b * (200 - shade) / 100;
1128	}	885	}
1129		886
1130	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1131	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	887	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1132	XRenderPictureAttributes pa;
1133		888
1134	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	889	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1135		890
1136	pa.repeat = True;	891	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1137		892
1138	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	893	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		894
1147	XRenderColor mask_c;	895	XRenderColor mask_c;
1148		896
1149	mask_c.alpha = 0xffff;	897	mask_c.alpha = 0xffff;
1150	mask_c.red =	898	mask_c.red =
…		…
1155	mask_c.alpha = 0;	903	mask_c.alpha = 0;
1156	mask_c.red = 0xffff - c.r;	904	mask_c.red = 0xffff - c.r;
1157	mask_c.green = 0xffff - c.g;	905	mask_c.green = 0xffff - c.g;
1158	mask_c.blue = 0xffff - c.b;	906	mask_c.blue = 0xffff - c.b;
1159	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	907	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		908
1160	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);	909	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1161		910
1162	if (shade > 100)	911	if (shade > 100)
1163	{	912	{
1164	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1165	mask_c.alpha = 0;	913	mask_c.alpha = 0;
		914	mask_c.red =
		915	mask_c.green =
		916	mask_c.blue = 0xffff * (shade - 100) / 100;
1166	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	917	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1167		918
1168	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);	919	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1169	}	920	}
1170		921
1171	ret = true;	922	ret = true;
1172		923
1173	XRenderFreePicture (dpy, mask_pic);	924	XRenderFreePicture (dpy, mask_pic);
1174	XRenderFreePicture (dpy, overlay_pic);	925	XRenderFreePicture (dpy, overlay_pic);
1175	XRenderFreePicture (dpy, back_pic);	926	XRenderFreePicture (dpy, back_pic);
		927	}
1176	# endif	928	# endif
1177	}
1178		929
1179	return ret;	930	return ret;
1180	}	931	}
1181		932
1182	/*	933	/*
1183	* Builds a pixmap of the same size as the terminal window that contains	934	* Builds a pixmap of the same size as the terminal window that contains
1184	* the tiled portion of the root pixmap that is supposed to be covered by	935	* the tiled portion of the root pixmap that is supposed to be covered by
1185	* our window.	936	* our window.
1186	*/	937	*/
1187	unsigned long	938	bool
1188	rxvt_term::make_transparency_pixmap ()	939	rxvt_term::make_transparency_pixmap ()
1189	{	940	{
1190	unsigned long result = 0;	941	bool ret = false;
1191		942
1192	/* root dimensions may change from call to call - but Display structure should	943	/* root dimensions may change from call to call - but Display structure should
1193	* be always up-to-date, so let's use it :	944	* be always up-to-date, so let's use it :
1194	*/	945	*/
1195	int screen = display->screen;	946	int screen = display->screen;
…		…
1233	#if XRENDER	984	#if XRENDER
1234	if (bg_flags & BG_HAS_RENDER)	985	if (bg_flags & BG_HAS_RENDER)
1235	{	986	{
1236	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);	987	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1237		988
1238	XRenderPictureAttributes pa;
1239
1240	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	989	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1241	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	990	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1242		991
1243	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	992	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1244	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	993	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1245		994
1246	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	995	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1247		996
1248	XRenderFreePicture (dpy, src);	997	XRenderFreePicture (dpy, src);
1249	XRenderFreePicture (dpy, dst);	998	XRenderFreePicture (dpy, dst);
…		…
1266	bg_pmap_width = window_width;	1015	bg_pmap_width = window_width;
1267	bg_pmap_height = window_height;	1016	bg_pmap_height = window_height;
1268	}	1017	}
1269		1018
1270	/* straightforward pixmap copy */	1019	/* straightforward pixmap copy */
1271	while (sx < 0) sx += root_width;	1020	while (sx < 0) sx += root_pmap_width;
1272	while (sy < 0) sy += root_height;	1021	while (sy < 0) sy += root_pmap_height;
1273		1022
1274	gcv.tile = recoded_root_pmap;	1023	gcv.tile = recoded_root_pmap;
1275	gcv.fill_style = FillTiled;	1024	gcv.fill_style = FillTiled;
1276	gcv.ts_x_origin = -sx;	1025	gcv.ts_x_origin = -sx;
1277	gcv.ts_y_origin = -sy;	1026	gcv.ts_y_origin = -sy;
1278	gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	1027	gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1279		1028
1280	if (gc)	1029	if (gc)
1281	{	1030	{
1282	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1031	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1283	result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS);	1032	ret = true;
		1033	bool need_blur = h_blurRadius && v_blurRadius;
		1034	bool need_tint = shade != 100 || (bg_flags & BG_TINT_SET);
		1035
		1036	if (!(bg_flags & BG_CLIENT_RENDER))
		1037	{
		1038	if (need_blur)
		1039	{
		1040	if (blur_pixmap (bg_pixmap, window_width, window_height))
		1041	need_blur = false;
		1042	}
		1043	if (need_tint)
		1044	{
		1045	if (tint_pixmap (bg_pixmap, window_width, window_height))
		1046	need_tint = false;
		1047	}
		1048	if (need_tint)
		1049	{
		1050	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1051	if (ximage)
		1052	{
		1053	/* our own client-side tinting */
		1054	tint_ximage (ximage);
		1055
		1056	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1057	XDestroyImage (ximage);
		1058	}
		1059	}
		1060	} /* server side rendering completed */
		1061
1284	XFreeGC (dpy, gc);	1062	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	}	1063	}
1302		1064
1303	if (recoded_root_pmap != root_pixmap)	1065	if (recoded_root_pmap != root_pixmap)
1304	XFreePixmap (dpy, recoded_root_pmap);	1066	XFreePixmap (dpy, recoded_root_pmap);
1305		1067
1306	return result;	1068	return ret;
1307	}	1069	}
1308		1070
1309	void	1071	void
1310	rxvt_term::bg_set_root_pixmap ()	1072	rxvt_term::bg_set_root_pixmap ()
1311	{	1073	{
…		…
1315		1077
1316	root_pixmap = new_root_pixmap;	1078	root_pixmap = new_root_pixmap;
1317	}	1079	}
1318	# endif /* ENABLE_TRANSPARENCY */	1080	# endif /* ENABLE_TRANSPARENCY */
1319		1081
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	1082	bool
1325	rxvt_term::bg_render ()	1083	rxvt_term::bg_render ()
1326	{	1084	{
1327	unsigned long tr_flags = 0;
1328
1329	bg_invalidate ();	1085	bg_invalidate ();
1330	# ifdef ENABLE_TRANSPARENCY	1086	# ifdef ENABLE_TRANSPARENCY
1331	if (bg_flags & BG_IS_TRANSPARENT)	1087	if (bg_flags & BG_IS_TRANSPARENT)
1332	{	1088	{
1333	/* we need to re-generate transparency pixmap in that case ! */	1089	/* we need to re-generate transparency pixmap in that case ! */
1334	tr_flags = make_transparency_pixmap ();	1090	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;	1091	bg_flags |= BG_IS_VALID;
1339	}	1092	}
1340	# endif	1093	# endif
1341		1094
1342	# ifdef BG_IMAGE_FROM_FILE	1095	# ifdef BG_IMAGE_FROM_FILE
1343	if ((bg_flags & BG_IS_FROM_FILE)	1096	if (bg_image.flags & IM_IS_SET)
1344	|| (tr_flags & BG_EFFECTS_FLAGS))
1345	{	1097	{
1346	if (render_image (tr_flags))	1098	if (render_image (bg_image))
1347	bg_flags |= BG_IS_VALID;	1099	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	}	1100	}
1382	# endif	1101	# endif
1383		1102
1384	if (!(bg_flags & BG_IS_VALID))	1103	if (!(bg_flags & BG_IS_VALID))
1385	{	1104	{
…		…
1422	#endif	1141	#endif
1423	}	1142	}
1424		1143
1425	#endif /* HAVE_BG_PIXMAP */	1144	#endif /* HAVE_BG_PIXMAP */
1426		1145
1427	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1146	#ifdef ENABLE_TRANSPARENCY
1428	/* taken from aterm-0.4.2 */	1147	/* based on code from aterm-0.4.2 */
1429		1148
1430	static void	1149	static inline void
1431	shade_ximage (Visual *visual, XImage *ximage, int shade, const rgba &c)	1150	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1432	{	1151	{
		1152	for (int i = 0; i <= mask >> sh; i++)
		1153	{
		1154	uint32_t tmp;
		1155	tmp = i * high;
		1156	tmp += (mask >> sh) * low;
		1157	lookup[i] = (tmp / 0xffff) << sh;
		1158	}
		1159	}
		1160
		1161	void
		1162	rxvt_term::tint_ximage (XImage *ximage)
		1163	{
		1164	unsigned int size_r, size_g, size_b;
1433	int sh_r, sh_g, sh_b;	1165	int sh_r, sh_g, sh_b;
1434	uint32_t mask_r, mask_g, mask_b;	1166	uint32_t mask_r, mask_g, mask_b;
1435	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;	1167	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1436	rgba low;	1168	unsigned short low;
1437	rgba high;
1438	int i;
1439	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	1169	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1440		1170
1441	if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;	1171	if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1442		1172
1443	/* for convenience */	1173	/* for convenience */
1444	mask_r = visual->red_mask;	1174	mask_r = visual->red_mask;
1445	mask_g = visual->green_mask;	1175	mask_g = visual->green_mask;
1446	mask_b = visual->blue_mask;	1176	mask_b = visual->blue_mask;
1447		1177
1448	/* boring lookup table pre-initialization */	1178	/* boring lookup table pre-initialization */
1449	switch (ximage->depth)	1179	sh_r = ecb_ctz32 (mask_r);
1450	{	1180	sh_g = ecb_ctz32 (mask_g);
1451	case 15:	1181	sh_b = ecb_ctz32 (mask_b);
1452	if ((mask_r != 0x7c00) ||	1182
1453	(mask_g != 0x03e0) ||	1183	size_r = mask_r >> sh_r;
1454	(mask_b != 0x001f))	1184	size_g = mask_g >> sh_g;
		1185	size_b = mask_b >> sh_b;
		1186
		1187	if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1455	return;	1188	return;
1456	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32));	1189
		1190	lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1457	lookup_r = lookup;	1191	lookup_r = lookup;
1458	lookup_g = lookup+32;	1192	lookup_g = lookup + size_r;
1459	lookup_b = lookup+32+32;	1193	lookup_b = lookup + size_r + size_g;
1460	sh_r = 10;	1194
1461	sh_g = 5;	1195	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1462	sh_b = 0;	1196
1463	break;	1197	if (bg_flags & BG_TINT_SET)
1464	case 16:	1198	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		1199
1507	/* prepare limits for color transformation (each channel is handled separately) */	1200	/* prepare limits for color transformation (each channel is handled separately) */
1508	if (shade > 100)	1201	if (shade > 100)
1509	{	1202	{
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;	1203	c.r = c.r * (200 - shade) / 100;
1517	low.g = 65535 * (100 - shade) / 100;	1204	c.g = c.g * (200 - shade) / 100;
1518	low.b = 65535 * (100 - shade) / 100;	1205	c.b = c.b * (200 - shade) / 100;
		1206
		1207	low = 0xffff * (shade - 100) / 100;
1519	}	1208	}
1520	else	1209	else
1521	{	1210	{
1522	high.r = c.r * shade / 100;	1211	c.r = c.r * shade / 100;
1523	high.g = c.g * shade / 100;	1212	c.g = c.g * shade / 100;
1524	high.b = c.b * shade / 100;	1213	c.b = c.b * shade / 100;
1525		1214
1526	low.r = low.g = low.b = 0;	1215	low = 0;
1527	}	1216	}
1528		1217
1529	/* fill our lookup tables */	1218	/* fill our lookup tables */
1530	for (i = 0; i <= mask_r>>sh_r; i++)	1219	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1531	{	1220	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1532	uint32_t tmp;	1221	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		1222
1552	/* apply table to input image (replacing colors by newly calculated ones) */	1223	/* apply table to input image (replacing colors by newly calculated ones) */
1553	if (ximage->bits_per_pixel == 32	1224	if (ximage->bits_per_pixel == 32
1554	&& (ximage->depth == 24 || ximage->depth == 32)
1555	&& ximage->byte_order == host_byte_order)	1225	&& ximage->byte_order == host_byte_order)
1556	{	1226	{
1557	uint32_t *p1, *pf, *p, *pl;	1227	char *line = ximage->data;
1558	p1 = (uint32_t *) ximage->data;
1559	pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1560		1228
1561	while (p1 < pf)	1229	for (int y = 0; y < ximage->height; y++)
1562	{
1563	p = p1;
1564	pl = p1 + ximage->width;
1565	for (; p < pl; p++)
1566	{	1230	{
1567	*p = lookup_r[(*p & 0xff0000) >> 16] |	1231	uint32_t *p = (uint32_t *)line;
1568	lookup_g[(*p & 0x00ff00) >> 8] |	1232	for (int x = 0; x < ximage->width; x++)
1569	lookup_b[(*p & 0x0000ff)] |
1570	(*p & 0xff000000);
1571	}	1233	{
1572	p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line);	1234	*p = lookup_r[(*p & mask_r) >> sh_r] |
		1235	lookup_g[(*p & mask_g) >> sh_g] |
		1236	lookup_b[(*p & mask_b) >> sh_b];
		1237	p++;
		1238	}
		1239	line += ximage->bytes_per_line;
1573	}	1240	}
1574	}	1241	}
1575	else	1242	else
1576	{	1243	{
1577	for (int y = 0; y < ximage->height; y++)	1244	for (int y = 0; y < ximage->height; y++)
…		…
1585	}	1252	}
1586	}	1253	}
1587		1254
1588	free (lookup);	1255	free (lookup);
1589	}	1256	}
1590	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1257	#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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