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.118 by sf-exg, Tue Nov 16 15:49:56 2010 UTC vs.
Revision 1.220 by sf-exg, Fri May 25 08:27:47 2012 UTC

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

Diff Legend

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