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.151 by sf-exg, Sun May 8 21:02:28 2011 UTC vs.
Revision 1.224 by sf-exg, Wed May 30 19:30:57 2012 UTC

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

Diff Legend

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