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.142 by sf-exg, Thu Jan 27 17:37:18 2011 UTC vs.
Revision 1.219 by sf-exg, Thu May 24 16:17:33 2012 UTC

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

Diff Legend

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