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.158 by sf-exg, Wed Aug 10 07:28:36 2011 UTC vs.
Revision 1.222 by sf-exg, Sat May 26 08:10:25 2012 UTC

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

Diff Legend

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