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.227 by sf-exg, Thu May 31 14:02:17 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	# ifdef BG_IMAGE_FROM_FILE
132	if (original_asim)	64	for (vector<rxvt_image>::iterator bg_image = image_vec.begin (); bg_image < image_vec.end (); bg_image++)
133	safe_asimage_destroy (original_asim);	65	bg_image->destroy ();
134	#endif	66	# endif
135		67
136	#ifdef HAVE_PIXBUF	68	if (bg_pixmap)
137	if (pixbuf)
138	g_object_unref (pixbuf);
139	#endif
140
141	if (pixmap && target)
142	XFreePixmap (target->dpy, pixmap);	69	XFreePixmap (dpy, bg_pixmap);
143	}	70	}
144		71
145	bool	72	bool
146	bgPixmap_t::window_size_sensitive ()	73	rxvt_term::bg_set_position (int x, int y)
		74	{
		75
		76	if (target_x != x
		77	|| target_y != y)
		78	{
		79	target_x = x;
		80	target_y = y;
		81	return true;
		82	}
		83	return false;
		84	}
		85
		86	bool
		87	rxvt_term::bg_window_size_sensitive ()
147	{	88	{
148	# ifdef ENABLE_TRANSPARENCY	89	# ifdef ENABLE_TRANSPARENCY
149	if (flags & isTransparent)	90	if (bg_flags & BG_IS_TRANSPARENT)
150	return true;	91	return true;
151	# endif	92	# endif
152		93
153	# ifdef BG_IMAGE_FROM_FILE	94	# ifdef BG_IMAGE_FROM_FILE
154	if (have_image)	95	for (vector<rxvt_image>::iterator bg_image = image_vec.begin (); bg_image < image_vec.end (); bg_image++)
155	{	96	{
156	if (flags & sizeSensitive)	97	if ((bg_image->flags & IM_IS_SIZE_SENSITIVE)
		98	|| bg_image->width () > szHint.width
		99	|| bg_image->height () > szHint.height)
157	return true;	100	return true;
158	}	101	}
159	# endif	102	# endif
160		103
161	return false;	104	return false;
162	}	105	}
163		106
164	bool	107	bool
165	bgPixmap_t::window_position_sensitive ()	108	rxvt_term::bg_window_position_sensitive ()
166	{	109	{
167	# ifdef ENABLE_TRANSPARENCY	110	# ifdef ENABLE_TRANSPARENCY
168	if (flags & isTransparent)	111	if (bg_flags & BG_IS_TRANSPARENT)
169	return true;	112	return true;
170	# endif	113	# endif
171		114
172	# ifdef BG_IMAGE_FROM_FILE	115	# ifdef BG_IMAGE_FROM_FILE
173	if (have_image)	116	for (vector<rxvt_image>::iterator bg_image = image_vec.begin (); bg_image < image_vec.end (); bg_image++)
174	{	117	{
175	if (flags & rootAlign)	118	if (bg_image->flags & IM_ROOT_ALIGN)
176	return true;	119	return true;
177	}	120	}
178	# endif	121	# endif
179		122
180	return false;	123	return false;
181	}	124	}
182		125
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	126	# 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	127	static inline int
228	make_align_position (int align, int window_size, int image_size)	128	make_align_position (int align, int window_size, int image_size)
229	{	129	{
230	int diff = window_size - image_size;
231	int smaller = min (image_size, window_size);
232
233	if (align >= 0 && align <= 100)	130	if (align >= 0 && align <= 100)
234	return diff * align / 100;	131	return lerp (0, window_size - image_size, align);
235	else if (align > 100 && align <= 200)	132	else if (align > 100)
236	return ((align - 100) * smaller / 100) + window_size - smaller;	133	return lerp (window_size - image_size, window_size, align - 100);
237	else if (align >= -100 && align < 0)	134	else
238	return ((align + 100) * smaller / 100) - image_size;	135	return lerp (-image_size, 0, align + 100);
239	return 0;
240	}	136	}
241		137
242	static inline int	138	static inline int
243	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)
244	{	140	{
…		…
250	src_pos = -pos;	146	src_pos = -pos;
251	dst_pos = 0;	147	dst_pos = 0;
252	dst_size += pos;	148	dst_size += pos;
253	}	149	}
254		150
255	if (dst_pos + dst_size > target_size)
256	dst_size = target_size - dst_pos;	151	min_it (dst_size, target_size - dst_pos);
257	return src_pos;	152	return src_pos;
258	}	153	}
259		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
260	bool	190	bool
261	bgPixmap_t::set_geometry (const char *geom)	191	rxvt_image::set_geometry (const char *geom, bool update)
262	{	192	{
263	bool changed = false;	193	bool changed = false;
264	int geom_flags = 0;	194	int geom_flags = 0;
265	int x = 0, y = 0;	195	int x = h_align;
		196	int y = v_align;
266	unsigned int w = 0, h = 0;	197	unsigned int w = h_scale;
267	unsigned int n;	198	unsigned int h = v_scale;
268	unsigned long new_flags = (flags & (~geometryFlags));	199	uint8_t new_flags = 0;
269	const char *p;
270	# define MAXLEN_GEOM 256 /* could be longer than regular geometry string */
271		200
272	if (geom == NULL)	201	if (geom == NULL)
273	return false;	202	return false;
274		203
275	char str[MAXLEN_GEOM];	204	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	{	205	{
284	char *ops;	206	char **arr = rxvt_strsplit (':', geom);
285	new_flags |= geometrySet;
286		207
287	memcpy (str, geom, n);	208	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	{	209	{
295	char *tmp;	210	if (!strncasecmp (arr[i], "style=", 6))
296	ops = strchr (str, ':');
297	if (ops != NULL)
298	{	211	{
299	for (tmp = ops-1; tmp >= str && isspace(*tmp); --tmp);	212	parse_style (arr[i] + 6, x, y, w, h, new_flags);
300	*(++tmp) = '\0';	213	geom_flags = WidthValue|HeightValue|XValue|YValue;
301	if (ops == tmp) ++ops;
302	}	214	}
303	}	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;
304		221
305	if (ops > str || ops == NULL)	222	// deprecated
306	{	223	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	{	224	{
312	y = x;	225	new_flags |= IM_TILE;
		226	w = h = noScale;
313	geom_flags |= YValue;	227	geom_flags |= WidthValue|HeightValue;
314	}	228	}
315		229	else if (!strcasecmp (arr[i], "propscale"))
316	if (flags & geometrySet)
317	{	230	{
318	/* new geometry is an adjustment to the old one ! */	231	new_flags |= IM_KEEP_ASPECT;
		232	w = h = windowScale;
319	if ((geom_flags & WidthValue) && (geom_flags & HeightValue))	233	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	}	234	}
341	else /* setting up geometry from scratch */	235	else if (!strcasecmp (arr[i], "hscale"))
342	{	236	{
343	if (!(geom_flags & XValue))	237	new_flags |= IM_TILE;
344	{	238	w = windowScale;
345	/* use default geometry - centered */
346	x = y = defaultAlign;
347	}
348	else if (!(geom_flags & YValue))
349	y = x;	239	h = noScale;
350
351	if ((geom_flags & (WidthValue|HeightValue)) == 0)	240	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	}	241	}
364	} /* done parsing geometry string */	242	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	{	243	{
379	while (*ops == ':' || isspace(*ops)) ++ops;	244	new_flags |= IM_TILE;
380		245	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;	246	w = noScale;
385	geom_flags |= WidthValue|HeightValue;	247	geom_flags |= WidthValue|HeightValue;
386	}	248	}
387	else if (CHECK_GEOM_OPS ("propscale"))	249	else if (!strcasecmp (arr[i], "scale"))
388	{	250	{
389	new_flags |= propScale;
390	}
391	else if (CHECK_GEOM_OPS ("hscale"))
392	{
393	if (w == 0) w = windowScale;
394
395	h = noScale;	251	w = h = windowScale;
396	geom_flags |= WidthValue|HeightValue;	252	geom_flags |= WidthValue|HeightValue;
397	}	253	}
398	else if (CHECK_GEOM_OPS ("vscale"))	254	else if (!strcasecmp (arr[i], "auto"))
399	{	255	{
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;	256	w = h = windowScale;
415	x = y = centerAlign;	257	x = y = centerAlign;
416	geom_flags |= WidthValue|HeightValue|XValue|YValue;	258	geom_flags |= WidthValue|HeightValue|XValue|YValue;
417	}	259	}
418	else if (CHECK_GEOM_OPS ("root"))	260	else if (!strcasecmp (arr[i], "root"))
419	{	261	{
420	new_flags |= rootAlign;	262	new_flags |= IM_TILE|IM_ROOT_ALIGN;
421	w = h = noScale;	263	w = h = noScale;
422	geom_flags |= WidthValue|HeightValue;	264	geom_flags |= WidthValue|HeightValue;
423	}	265	}
424	# undef CHECK_GEOM_OPS
425		266
426	while (*ops != ':' && *ops != '\0') ++ops;	267	else
		268	geom_flags |= XParseGeometry (arr[i], &x, &y, &w, &h);
427	} /* done parsing ops */	269	} /* done parsing ops */
428	}
429		270
430	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;	271	rxvt_free_strsplit (arr);
431	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;	272	}
432	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;	273
433	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;	274	new_flags |= flags & ~IM_GEOMETRY_FLAGS;
		275
		276	if (!update)
434	}	277	{
		278	if (!(geom_flags & XValue))
		279	x = y = defaultAlign;
		280	else if (!(geom_flags & YValue))
		281	y = x;
435		282
436	if (new_flags != flags)	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;
		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)
437	{	299	{
438	flags = new_flags;	300	flags = new_flags;
		301	h_scale = w;
		302	v_scale = h;
		303	h_align = x;
		304	v_align = y;
439	changed = true;	305	changed = true;
440	}	306	}
441		307
		308	if (is_size_sensitive ())
		309	flags |= IM_IS_SIZE_SENSITIVE;
		310	else
		311	flags &= ~IM_IS_SIZE_SENSITIVE;
		312
442	return changed;	313	return changed;
443	}	314	}
444		315
445	void	316	void
446	bgPixmap_t::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)	317	rxvt_term::get_image_geometry (rxvt_image &image, int &w, int &h, int &x, int &y)
447	{	318	{
		319	int image_width = image.width ();
		320	int image_height = image.height ();
448	int target_width = target->szHint.width;	321	int target_width = szHint.width;
449	int target_height = target->szHint.height;	322	int target_height = szHint.height;
		323	int h_scale = min (image.h_scale, 32767 * 100 / target_width);
		324	int v_scale = min (image.v_scale, 32767 * 100 / target_height);
450		325
451	if (flags & propScale)	326	w = h_scale * target_width / 100;
		327	h = v_scale * target_height / 100;
		328
		329	if (image.flags & IM_KEEP_ASPECT)
452	{	330	{
453	float scale = (float)target_width / image_width;	331	float scale = (float)w / image_width;
454	min_it (scale, (float)target_height / image_height);	332	min_it (scale, (float)h / image_height);
455	w = image_width * scale + 0.5;	333	w = image_width * scale + 0.5;
456	h = image_height * scale + 0.5;	334	h = image_height * scale + 0.5;
457	}	335	}
458	else
459	{
460	w = h_scale * target_width / 100;
461	h = v_scale * target_height / 100;
462	}
463		336
464	if (!w) w = image_width;	337	if (!w) w = image_width;
465	if (!h) h = image_height;	338	if (!h) h = image_height;
466		339
467	if (flags & rootAlign)	340	if (image.flags & IM_ROOT_ALIGN)
468	{	341	{
469	target->get_window_origin (x, y);
470	x = -x;	342	x = -target_x;
471	y = -y;	343	y = -target_y;
472	}	344	}
473	else	345	else
474	{	346	{
475	x = make_align_position (h_align, target_width, w);	347	x = make_align_position (image.h_align, target_width, w);
476	y = make_align_position (v_align, target_height, h);	348	y = make_align_position (image.v_align, target_height, h);
477	}	349	}
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	}	350	}
485		351
486	# ifdef HAVE_AFTERIMAGE	352	# ifdef HAVE_PIXBUF
487	bool	353	bool
488	bgPixmap_t::render_image (unsigned long background_flags)	354	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
		355	int src_x, int src_y, int dst_x, int dst_y,
		356	unsigned int width, unsigned int height, bool argb)
489	{	357	{
490	if (target == NULL)	358	XImage *ximage;
		359	char *line;
		360	int width_r, width_g, width_b, width_a;
		361	int sh_r, sh_g, sh_b, sh_a;
		362	uint32_t red_mask, green_mask, blue_mask, alpha_mask;
		363	int rowstride;
		364	int channels;
		365	unsigned char *row;
		366
		367	if (visual->c_class != TrueColor)
491	return false;	368	return false;
492		369
493	target->init_asv ();	370	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	}	371	{
516		372	red_mask = 0xff << 16;
517	if (!(background_flags & transpPmapBlurred) && (flags & blurNeeded) && background != NULL)	373	green_mask = 0xff << 8;
		374	blue_mask = 0xff;
		375	alpha_mask = 0xff << 24;
518	{	376	}
519	ASImage *tmp = blur_asimage_gauss (target->asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,	377	else
520	(original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,	378	{
521	100, ASIMAGE_QUALITY_DEFAULT);	379	red_mask = visual->red_mask;
		380	green_mask = visual->green_mask;
		381	blue_mask = visual->blue_mask;
		382	#if XRENDER
		383	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
522	if (tmp)	384	if (format)
523	{	385	alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
524	destroy_asimage (&background);	386	else
525	background = tmp;	387	#endif
		388	alpha_mask = 0;
		389	}
		390
		391	width_r = ecb_popcount32 (red_mask);
		392	width_g = ecb_popcount32 (green_mask);
		393	width_b = ecb_popcount32 (blue_mask);
		394	width_a = ecb_popcount32 (alpha_mask);
		395
		396	if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
		397	return false;
		398
		399	sh_r = ecb_ctz32 (red_mask);
		400	sh_g = ecb_ctz32 (green_mask);
		401	sh_b = ecb_ctz32 (blue_mask);
		402	sh_a = ecb_ctz32 (alpha_mask);
		403
		404	if (width > 32767 || height > 32767)
		405	return false;
		406
		407	ximage = XCreateImage (dpy, visual, argb ? 32 : depth, ZPixmap, 0, 0,
		408	width, height, 32, 0);
		409	if (!ximage)
		410	return false;
		411
		412	if (height > INT_MAX / ximage->bytes_per_line
		413	|| !(ximage->data = (char *)malloc (height * ximage->bytes_per_line)))
		414	{
		415	XDestroyImage (ximage);
		416	return false;
		417	}
		418
		419	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
		420
		421	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
		422	channels = gdk_pixbuf_get_n_channels (pixbuf);
		423	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
		424	line = ximage->data;
		425
		426	rgba c (0, 0, 0);
		427
		428	if (channels == 4 && alpha_mask == 0)
		429	{
		430	pix_colors[Color_bg].get (c);
		431	c.r >>= 8;
		432	c.g >>= 8;
		433	c.b >>= 8;
		434	}
		435
		436	for (int y = 0; y < height; y++)
		437	{
		438	for (int x = 0; x < width; x++)
526	}	439	{
527	}	440	unsigned char *pixel = row + x * channels;
528	# endif	441	uint32_t value;
		442	unsigned char r, g, b, a;
529		443
530	ASImage *result = 0;	444	if (channels == 4)
		445	{
		446	a = pixel[3];
		447	r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
		448	g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
		449	b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
		450	}
		451	else
		452	{
		453	a = 0xff;
		454	r = pixel[0];
		455	g = pixel[1];
		456	b = pixel[2];
		457	}
531		458
		459	value = ((r >> (8 - width_r)) << sh_r)
		460	| ((g >> (8 - width_g)) << sh_g)
		461	| ((b >> (8 - width_b)) << sh_b)
		462	| ((a >> (8 - width_a)) << sh_a);
		463
		464	if (ximage->bits_per_pixel == 32)
		465	((uint32_t *)line)[x] = value;
		466	else
		467	XPutPixel (ximage, x, y, value);
		468	}
		469
		470	row += rowstride;
		471	line += ximage->bytes_per_line;
		472	}
		473
		474	XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
		475	XDestroyImage (ximage);
		476	return true;
		477	}
		478
		479	bool
		480	rxvt_term::render_image (rxvt_image &image)
		481	{
		482	GdkPixbuf *pixbuf = image.pixbuf;
		483	if (!pixbuf)
		484	return false;
		485
		486	bool need_blend = bg_flags & BG_IS_VALID;
		487
		488	if (need_blend
		489	&& !(bg_flags & BG_HAS_RENDER))
		490	return false;
		491
		492	GdkPixbuf *result;
		493
		494	int image_width = gdk_pixbuf_get_width (pixbuf);
		495	int image_height = gdk_pixbuf_get_height (pixbuf);
		496
532	int target_width = target->szHint.width;	497	int target_width = szHint.width;
533	int target_height = target->szHint.height;	498	int target_height = szHint.height;
534	int new_pmap_width = target_width;	499	int new_pmap_width = target_width;
535	int new_pmap_height = target_height;	500	int new_pmap_height = target_height;
536		501
537	int x = 0;	502	int x = 0;
538	int y = 0;	503	int y = 0;
539	int w = 0;	504	int w = 0;
540	int h = 0;	505	int h = 0;
541		506
542	if (original_asim)	507	get_image_geometry (image, w, h, x, y);
543	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
544		508
545	if (!original_asim	509	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	510	&& (x >= target_width
760	|| y >= target_height	511	|| y >= target_height
761	|| (x + w <= 0)	512	|| x + w <= 0
762	|| (y + h <= 0)))	513	|| y + h <= 0))
763	return false;	514	return false;
764		515
765	result = pixbuf;	516	result = pixbuf;
766		517
767	if ((w != image_width)	518	if (w != image_width
768	|| (h != image_height))	519	|| h != image_height)
769	{	520	{
770	result = gdk_pixbuf_scale_simple (pixbuf,	521	result = gdk_pixbuf_scale_simple (pixbuf,
771	w, h,	522	w, h,
772	GDK_INTERP_BILINEAR);	523	GDK_INTERP_BILINEAR);
773	}	524	}
774		525
		526	if (!result)
		527	return false;
		528
775	bool ret = false;	529	bool ret = false;
776		530
777	if (result)
778	{
779	XGCValues gcv;	531	XGCValues gcv;
780	GC gc;	532	GC gc;
781	Pixmap root_pmap;	533	Pixmap tmp_pixmap;
782		534
783	image_width = gdk_pixbuf_get_width (result);	535	image_width = gdk_pixbuf_get_width (result);
784	image_height = gdk_pixbuf_get_height (result);	536	image_height = gdk_pixbuf_get_height (result);
785		537
786	if (background_flags)	538	if (need_blend)
787	{	539	tmp_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, 32);
788	root_pmap = pixmap;	540	else
789	pixmap = None;	541	{
		542	// optimise bg pixmap size when tiling, but only if there are no
		543	// other pixbufs to render. Otherwise, the bg pixmap size must
		544	// be equal to the window size.
		545	if ((image.flags & IM_TILE)
		546	&& image_vec.size () == 1)
790	}	547	{
791	else
792	{
793	if (h_scale == 0 || v_scale == 0)
794	{
795	new_pmap_width = min (image_width, target_width);	548	new_pmap_width = min (image_width, target_width);
796	new_pmap_height = min (image_height, target_height);	549	new_pmap_height = min (image_height, target_height);
797	}	550	}
798	}
799		551
800	if (pixmap == None	552	if (bg_pixmap == None
801	|| pmap_width != new_pmap_width	553	|| bg_pmap_width != new_pmap_width
802	|| pmap_height != new_pmap_height	554	|| bg_pmap_height != new_pmap_height)
803	|| pmap_depth != target->depth)
804	{	555	{
805	if (pixmap)	556	if (bg_pixmap)
806	XFreePixmap (target->dpy, pixmap);	557	XFreePixmap (dpy, bg_pixmap);
807	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);	558	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
808	pmap_width = new_pmap_width;	559	bg_pmap_width = new_pmap_width;
809	pmap_height = new_pmap_height;	560	bg_pmap_height = new_pmap_height;
810	pmap_depth = target->depth;
811	}
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	{	561	}
		562
		563	tmp_pixmap = bg_pixmap;
		564	}
		565
		566	gcv.foreground = pix_colors[Color_bg];
		567	gc = XCreateGC (dpy, tmp_pixmap, GCForeground, &gcv);
		568
		569	if (gc)
		570	{
		571	if (image.flags & IM_TILE)
		572	{
818	Pixmap tile = XCreatePixmap (target->dpy, target->vt, image_width, image_height, target->depth);	573	Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, need_blend ? 32 : depth);
819	gdk_pixbuf_xlib_render_to_drawable (result, tile, gc,	574	pixbuf_to_pixmap (result, tile, gc,
820	0, 0,	575	0, 0,
821	0, 0,	576	0, 0,
822	image_width, image_height,	577	image_width, image_height, need_blend);
823	XLIB_RGB_DITHER_NONE,
824	0, 0);
825		578
826	gcv.tile = tile;	579	gcv.tile = tile;
827	gcv.fill_style = FillTiled;	580	gcv.fill_style = FillTiled;
828	gcv.ts_x_origin = x;	581	gcv.ts_x_origin = x;
829	gcv.ts_y_origin = y;	582	gcv.ts_y_origin = y;
830	XChangeGC (target->dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	583	XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
831		584
832	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	585	XFillRectangle (dpy, tmp_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
833	XFreePixmap (target->dpy, tile);	586	XFreePixmap (dpy, tile);
834	}	587	}
835	else	588	else
836	{	589	{
837	int src_x, src_y, dst_x, dst_y;	590	int src_x, src_y, dst_x, dst_y;
838	int dst_width, dst_height;	591	int dst_width, dst_height;
…		…
841	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);	594	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
842		595
843	if (dst_x > 0 || dst_y > 0	596	if (dst_x > 0 || dst_y > 0
844	|| dst_x + dst_width < new_pmap_width	597	|| dst_x + dst_width < new_pmap_width
845	|| dst_y + dst_height < new_pmap_height)	598	|| dst_y + dst_height < new_pmap_height)
846	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	599	XFillRectangle (dpy, tmp_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
847		600
848	if (dst_x < new_pmap_width && dst_y < new_pmap_height)	601	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
849	gdk_pixbuf_xlib_render_to_drawable (result, pixmap, gc,	602	pixbuf_to_pixmap (result, tmp_pixmap, gc,
850	src_x, src_y,	603	src_x, src_y,
851	dst_x, dst_y,	604	dst_x, dst_y,
852	dst_width, dst_height,	605	dst_width, dst_height, need_blend);
853	XLIB_RGB_DITHER_NONE,
854	0, 0);
855	}	606	}
		607
		608	if (image.need_blur ())
		609	blur_pixmap (tmp_pixmap, new_pmap_width, new_pmap_height, need_blend, image.h_blurRadius, image.v_blurRadius);
		610	if (image.need_tint ())
		611	tint_pixmap (tmp_pixmap, new_pmap_width, new_pmap_height, need_blend, image.tint, image.tint_set, image.shade);
856		612
857	#if XRENDER	613	#if XRENDER
858	if (background_flags)	614	if (need_blend)
859	{	615	{
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);	616	XRenderPictFormat *argb_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
		617	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		618
872	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);	619	Picture src = XRenderCreatePicture (dpy, tmp_pixmap, argb_format, 0, 0);
873	XFreePixmap (dpy, mask_pmap);
874		620
875	if (src && dst && mask)	621	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
876	{	622
		623	Picture mask = create_xrender_mask (dpy, vt, False, False);
		624
877	XRenderColor mask_c;	625	XRenderColor mask_c;
878		626
879	mask_c.alpha = 0x8000;	627	mask_c.alpha = image.alpha;
880	mask_c.red = 0;	628	mask_c.red =
881	mask_c.green = 0;	629	mask_c.green =
882	mask_c.blue = 0;	630	mask_c.blue = 0;
883	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	631	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		632
884	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	633	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
885	}
886		634
887	XRenderFreePicture (dpy, src);	635	XRenderFreePicture (dpy, src);
888	XRenderFreePicture (dpy, dst);	636	XRenderFreePicture (dpy, dst);
889	XRenderFreePicture (dpy, mask);	637	XRenderFreePicture (dpy, mask);
890
891	XFreePixmap (dpy, root_pmap);
892	}	638	}
893	#endif	639	#endif
894		640
895	if (result != pixbuf)
896	g_object_unref (result);
897
898	XFreeGC (target->dpy, gc);	641	XFreeGC (dpy, gc);
899		642
900	ret = true;	643	ret = true;
901	}	644	}
902		645
		646	if (result != pixbuf)
		647	g_object_unref (result);
		648
		649	if (need_blend)
		650	XFreePixmap (dpy, tmp_pixmap);
		651
903	return ret;	652	return ret;
904	}	653	}
905	# endif /* HAVE_PIXBUF */	654	# endif /* HAVE_PIXBUF */
906		655
		656	# ifndef NO_RESOURCES
		657	static int
		658	rxvt_define_image (XrmDatabase *database ecb_unused,
		659	XrmBindingList bindings ecb_unused,
		660	XrmQuarkList quarks,
		661	XrmRepresentation *type ecb_unused,
		662	XrmValue *value,
		663	XPointer closure ecb_unused)
		664	{
		665	int size;
		666
		667	for (size = 0; quarks[size] != NULLQUARK; size++)
		668	;
		669
		670	if (size >= 2)
		671	{
		672	int id = strtol (XrmQuarkToString (quarks[size-2]), 0, 0);
		673	if (id >= 1)
		674	GET_R->parse_image (id, XrmQuarkToString (quarks[size-1]), (char *)value->addr);
		675	}
		676	return False;
		677	}
		678
		679	void
		680	rxvt_term::parse_image (int id, const char *type, const char *arg)
		681	{
		682	if (image_vec.size () < id + 1)
		683	image_vec.resize (id + 1);
		684
		685	rxvt_image *image = &image_vec[id];
		686	}
		687	# endif
		688
		689	rxvt_image::rxvt_image ()
		690	{
		691	alpha = 0xffff;
		692	flags = 0;
		693	h_scale =
		694	v_scale = defaultScale;
		695	h_align =
		696	v_align = defaultAlign;
		697
		698	# ifdef HAVE_PIXBUF
		699	pixbuf = 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)
925	ASImage *image = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);	723	set_geometry (p ? 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 = image;
943	have_image = true;
944	return true;	739	ret = true;
945	}	740	}
946	# endif	741	# endif
947		742
		743	if (ret)
		744	flags |= IM_IS_SET;
		745
948	return false;	746	return ret;
949	}	747	}
950		748
951	# endif /* BG_IMAGE_FROM_FILE */	749	# endif /* BG_IMAGE_FROM_FILE */
952		750
953	# ifdef ENABLE_TRANSPARENCY
954	bool	751	bool
955	bgPixmap_t::set_transparent ()
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)	752	image_effects::set_blur (const char *geom)
968	{	753	{
969	bool changed = false;	754	bool changed = false;
970	unsigned int hr, vr;	755	unsigned int hr, vr;
971	int junk;	756	int junk;
972	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);	757	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
…		…
989	{	774	{
990	changed = true;	775	changed = true;
991	v_blurRadius = vr;	776	v_blurRadius = vr;
992	}	777	}
993		778
994	if (v_blurRadius == 0 && h_blurRadius == 0)
995	flags &= ~blurNeeded;
996	else
997	flags |= blurNeeded;
998
999	return changed;	779	return changed;
1000	}	780	}
1001		781
1002	static inline unsigned long
1003	compute_tint_shade_flags (rxvt_color *tint, int shade)
1004	{
1005	unsigned long flags = 0;
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	}
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	782	bool
1035	bgPixmap_t::set_tint (rxvt_color &new_tint)	783	image_effects::set_tint (const rxvt_color &new_tint)
1036	{	784	{
1037	if (!(flags & tintSet) || tint != new_tint)	785	if (!tint_set || tint != new_tint)
1038	{	786	{
1039	unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
1040	tint = new_tint;	787	tint = new_tint;
1041	flags = (flags & ~tintFlags) | new_flags | tintSet;	788	tint_set = true;
		789
1042	return true;	790	return true;
1043	}	791	}
1044		792
1045	return false;	793	return false;
1046	}	794	}
1047		795
1048	bool	796	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)	797	image_effects::set_shade (const char *shade_str)
1064	{	798	{
1065	int new_shade = (shade_str) ? atoi (shade_str) : 100;	799	int new_shade = atoi (shade_str);
1066		800
1067	clamp_it (new_shade, -100, 200);	801	clamp_it (new_shade, -100, 200);
1068	if (new_shade < 0)	802	if (new_shade < 0)
1069	new_shade = 200 - (100 + new_shade);	803	new_shade = 200 - (100 + new_shade);
1070		804
1071	if (new_shade != shade)	805	if (new_shade != shade)
1072	{	806	{
1073	unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
1074	shade = new_shade;	807	shade = new_shade;
1075	flags = (flags & (~tintFlags | tintSet)) | new_flags;
1076	return true;	808	return true;
1077	}	809	}
1078		810
1079	return false;	811	return false;
1080	}	812	}
…		…
1101	params[i+2] = XDoubleToFixed (kernel[i] / sum);	833	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1102	}	834	}
1103	#endif	835	#endif
1104		836
1105	bool	837	bool
1106	bgPixmap_t::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	838	rxvt_term::blur_pixmap (Pixmap pixmap, int width, int height, bool argb, int h_blurRadius, int v_blurRadius)
1107	{	839	{
1108	bool ret = false;	840	bool ret = false;
1109	#if XRENDER	841	#if XRENDER
		842	if (!(bg_flags & BG_HAS_RENDER_CONV))
		843	return false;
		844
1110	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	845	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1111	double *kernel = (double *)malloc (size * sizeof (double));	846	double *kernel = (double *)malloc (size * sizeof (double));
1112	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));	847	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1113		848
1114	Display *dpy = target->dpy;
1115	XRenderPictureAttributes pa;	849	XRenderPictureAttributes pa;
1116	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	850	XRenderPictFormat *format = argb ? XRenderFindStandardFormat (dpy, PictStandardARGB32)
		851	: XRenderFindVisualFormat (dpy, visual);
1117		852
		853	pa.repeat = RepeatPad;
1118	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	854	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		855	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1119	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	856	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		857	XFreePixmap (dpy, tmp);
1120		858
1121	if (kernel && params && src && dst)	859	if (kernel && params)
1122	{	860	{
1123	if (h_blurRadius)
1124	{
1125	size = h_blurRadius * 2 + 1;	861	size = h_blurRadius * 2 + 1;
1126	get_gaussian_kernel (h_blurRadius, size, kernel, params);	862	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1127		863
1128	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	864	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1129	XRenderComposite (dpy,	865	XRenderComposite (dpy,
1130	PictOpSrc,	866	PictOpSrc,
1131	src,	867	src,
1132	None,	868	None,
1133	dst,	869	dst,
1134	0, 0,	870	0, 0,
1135	0, 0,	871	0, 0,
1136	0, 0,	872	0, 0,
1137	width, height);	873	width, height);
1138	}
1139		874
1140	if (v_blurRadius)	875	::swap (src, dst);
1141	{	876
1142	size = v_blurRadius * 2 + 1;	877	size = v_blurRadius * 2 + 1;
1143	get_gaussian_kernel (v_blurRadius, size, kernel, params);	878	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1144	swap (params[0], params[1]);	879	::swap (params[0], params[1]);
1145		880
1146	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	881	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1147	XRenderComposite (dpy,	882	XRenderComposite (dpy,
1148	PictOpSrc,	883	PictOpSrc,
1149	src,	884	src,
1150	None,	885	None,
1151	dst,	886	dst,
1152	0, 0,	887	0, 0,
1153	0, 0,	888	0, 0,
1154	0, 0,	889	0, 0,
1155	width, height);	890	width, height);
1156	}
1157		891
1158	ret = true;	892	ret = true;
1159	}	893	}
1160		894
1161	free (kernel);	895	free (kernel);
…		…
1165	#endif	899	#endif
1166	return ret;	900	return ret;
1167	}	901	}
1168		902
1169	bool	903	bool
1170	bgPixmap_t::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	904	rxvt_term::tint_pixmap (Pixmap pixmap, int width, int height, bool argb, rxvt_color &tint, bool tint_set, int shade)
1171	{	905	{
1172	Display *dpy = target->dpy;
1173	bool ret = false;	906	bool ret = false;
1174		907
1175	if (flags & tintWholesome)	908	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
		909
		910	if (tint_set)
		911	tint.get (c);
		912
		913	if (shade == 100
		914	&& (c.r <= 0x00ff || c.r >= 0xff00)
		915	&& (c.g <= 0x00ff || c.g >= 0xff00)
		916	&& (c.b <= 0x00ff || c.b >= 0xff00))
1176	{	917	{
1177	XGCValues gcv;	918	XGCValues gcv;
1178	GC gc;	919	GC gc;
1179		920
1180	/* In this case we can tint image server-side getting significant	921	/* In this case we can tint image server-side getting significant
…		…
1189	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	930	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1190	ret = true;	931	ret = true;
1191	XFreeGC (dpy, gc);	932	XFreeGC (dpy, gc);
1192	}	933	}
1193	}	934	}
1194	else
1195	{
1196	# if XRENDER	935	# if XRENDER
1197	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	936	else if (bg_flags & BG_HAS_RENDER)
1198		937	{
1199	if (flags & tintSet)
1200	tint.get (c);
1201
1202	if (shade <= 100)	938	if (shade <= 100)
1203	{	939	{
1204	c.r = (c.r * shade) / 100;	940	c.r = c.r * shade / 100;
1205	c.g = (c.g * shade) / 100;	941	c.g = c.g * shade / 100;
1206	c.b = (c.b * shade) / 100;	942	c.b = c.b * shade / 100;
1207	}	943	}
1208	else	944	else
1209	{	945	{
1210	c.r = ((0xffff - c.r) * (200 - shade)) / 100;	946	c.r = c.r * (200 - shade) / 100;
1211	c.g = ((0xffff - c.g) * (200 - shade)) / 100;	947	c.g = c.g * (200 - shade) / 100;
1212	c.b = ((0xffff - c.b) * (200 - shade)) / 100;	948	c.b = c.b * (200 - shade) / 100;
1213	}	949	}
1214		950
1215	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);	951	XRenderPictFormat *format = argb ? XRenderFindStandardFormat (dpy, PictStandardARGB32)
1216	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	952	: XRenderFindVisualFormat (dpy, visual);
1217	XRenderPictureAttributes pa;
1218		953
1219	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	954	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1220		955
1221	pa.repeat = True;	956	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1222		957
1223	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	958	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		959
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;	960	XRenderColor mask_c;
1235		961
1236	mask_c.red = mask_c.green = mask_c.blue = shade > 100 ? 0xffff : 0;
1237	mask_c.alpha = 0xffff;	962	mask_c.alpha = 0xffff;
		963	mask_c.red =
		964	mask_c.green =
		965	mask_c.blue = 0;
		966	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
		967
		968	mask_c.alpha = 0;
		969	mask_c.red = 0xffff - c.r;
		970	mask_c.green = 0xffff - c.g;
		971	mask_c.blue = 0xffff - c.b;
		972	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		973
		974	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
		975
		976	if (shade > 100)
		977	{
		978	mask_c.alpha = 0;
		979	mask_c.red =
		980	mask_c.green =
		981	mask_c.blue = 0xffff * (shade - 100) / 100;
1238	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	982	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1239		983
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);	984	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
		985	}
		986
1246	ret = true;	987	ret = true;
1247	}
1248		988
1249	XRenderFreePicture (dpy, mask_pic);	989	XRenderFreePicture (dpy, mask_pic);
1250	XRenderFreePicture (dpy, overlay_pic);	990	XRenderFreePicture (dpy, overlay_pic);
1251	XRenderFreePicture (dpy, back_pic);	991	XRenderFreePicture (dpy, back_pic);
		992	}
1252	# endif	993	# endif
1253	}
1254		994
1255	return ret;	995	return ret;
1256	}	996	}
1257		997
1258	/* make_transparency_pixmap()	998	# ifdef ENABLE_TRANSPARENCY
		999	/*
1259	* Builds a pixmap of the same size as the terminal window that contains	1000	* 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	1001	* the tiled portion of the root pixmap that is supposed to be covered by
1261	* our window.	1002	* our window.
1262	*/	1003	*/
1263	unsigned long	1004	bool
1264	bgPixmap_t::make_transparency_pixmap ()	1005	rxvt_term::make_transparency_pixmap ()
1265	{	1006	{
1266	unsigned long result = 0;	1007	bool ret = false;
1267
1268	if (target == NULL)
1269	return 0;
1270		1008
1271	/* root dimensions may change from call to call - but Display structure should	1009	/* root dimensions may change from call to call - but Display structure should
1272	* be always up-to-date, so let's use it :	1010	* be always up-to-date, so let's use it :
1273	*/	1011	*/
1274	int screen = target->display->screen;	1012	int screen = display->screen;
1275	Display *dpy = target->dpy;
1276	int root_depth = DefaultDepth (dpy, screen);	1013	int root_depth = DefaultDepth (dpy, screen);
1277	int root_width = DisplayWidth (dpy, screen);	1014	int root_width = DisplayWidth (dpy, screen);
1278	int root_height = DisplayHeight (dpy, screen);	1015	int root_height = DisplayHeight (dpy, screen);
1279	unsigned int root_pmap_width, root_pmap_height;	1016	unsigned int root_pmap_width, root_pmap_height;
1280	int window_width = target->szHint.width;	1017	int window_width = szHint.width;
1281	int window_height = target->szHint.height;	1018	int window_height = szHint.height;
1282	int sx, sy;	1019	int sx, sy;
1283	XGCValues gcv;	1020	XGCValues gcv;
1284	GC gc;	1021	GC gc;
1285		1022
1286	target->get_window_origin (sx, sy);	1023	sx = target_x;
		1024	sy = target_y;
1287		1025
1288	/* check if we are outside of the visible part of the virtual screen : */	1026	/* check if we are outside of the visible part of the virtual screen : */
1289	if (sx + window_width <= 0 || sy + window_height <= 0	1027	if (sx + window_width <= 0 || sy + window_height <= 0
1290	|| sx >= root_width || sy >= root_height)	1028	|| sx >= root_width || sy >= root_height)
1291	return 0;	1029	return 0;
…		…
1295	{	1033	{
1296	Window wdummy;	1034	Window wdummy;
1297	int idummy;	1035	int idummy;
1298	unsigned int udummy;	1036	unsigned int udummy;
1299		1037
1300	target->allowedxerror = -1;	1038	allowedxerror = -1;
1301		1039
1302	if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))	1040	if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))
1303	root_pixmap = None;	1041	root_pixmap = None;
1304		1042
1305	target->allowedxerror = 0;	1043	allowedxerror = 0;
1306	}	1044	}
1307		1045
1308	Pixmap recoded_root_pmap = root_pixmap;	1046	Pixmap recoded_root_pmap = root_pixmap;
1309		1047
1310	if (root_pixmap != None && root_depth != target->depth)	1048	if (root_pixmap != None && root_depth != depth)
1311	{	1049	{
1312	#if XRENDER	1050	#if XRENDER
1313	if (flags & HAS_RENDER)	1051	if (bg_flags & BG_HAS_RENDER)
1314	{	1052	{
1315	XRenderPictureAttributes pa;	1053	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1316		1054
1317	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	1055	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1318	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	1056	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1319		1057
1320	recoded_root_pmap = XCreatePixmap (dpy, target->vt, root_pmap_width, root_pmap_height, target->depth);
1321	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);	1058	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1322	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	1059	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1323		1060
1324	if (src && dst)
1325	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	1061	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		1062
1332	XRenderFreePicture (dpy, src);	1063	XRenderFreePicture (dpy, src);
1333	XRenderFreePicture (dpy, dst);	1064	XRenderFreePicture (dpy, dst);
1334	}	1065	}
1335	else	1066	else
1336	#endif	1067	#endif
1337	root_pixmap = None;	1068	recoded_root_pmap = None;
1338	}	1069	}
1339		1070
1340	if (root_pixmap == None)	1071	if (recoded_root_pmap == None)
1341	return 0;	1072	return 0;
1342		1073
		1074	if (bg_pixmap == None
		1075	|| bg_pmap_width != window_width
		1076	|| bg_pmap_height != window_height)
		1077	{
		1078	if (bg_pixmap)
		1079	XFreePixmap (dpy, bg_pixmap);
1343	Pixmap tiled_root_pmap = XCreatePixmap (dpy, target->vt, window_width, window_height, target->depth);	1080	bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
1344		1081	bg_pmap_width = window_width;
1345	if (tiled_root_pmap == None) /* something really bad happened - abort */	1082	bg_pmap_height = window_height;
1346	return 0;	1083	}
1347		1084
1348	/* straightforward pixmap copy */	1085	/* straightforward pixmap copy */
		1086	while (sx < 0) sx += root_pmap_width;
		1087	while (sy < 0) sy += root_pmap_height;
		1088
1349	gcv.tile = recoded_root_pmap;	1089	gcv.tile = recoded_root_pmap;
1350	gcv.fill_style = FillTiled;	1090	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;	1091	gcv.ts_x_origin = -sx;
1356	gcv.ts_y_origin = -sy;	1092	gcv.ts_y_origin = -sy;
1357	gc = XCreateGC (dpy, target->vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	1093	gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1358		1094
1359	if (gc)	1095	if (gc)
1360	{	1096	{
1361	XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);	1097	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1362	result |= transpPmapTiled;	1098	ret = true;
		1099	bool need_blur = root_effects.need_blur ();
		1100	bool need_tint = root_effects.need_tint ();
		1101
		1102	if (need_blur)
		1103	{
		1104	if (blur_pixmap (bg_pixmap, window_width, window_height, false,
		1105	root_effects.h_blurRadius, root_effects.v_blurRadius))
		1106	need_blur = false;
		1107	}
		1108	if (need_tint)
		1109	{
		1110	if (tint_pixmap (bg_pixmap, window_width, window_height, false,
		1111	root_effects.tint, root_effects.tint_set, root_effects.shade))
		1112	need_tint = false;
		1113	}
		1114	if (need_tint)
		1115	{
		1116	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1117	if (ximage)
		1118	{
		1119	/* our own client-side tinting */
		1120	tint_ximage (ximage, root_effects.tint, root_effects.tint_set, root_effects.shade);
		1121
		1122	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1123	XDestroyImage (ximage);
		1124	}
		1125	}
		1126
1363	XFreeGC (dpy, gc);	1127	XFreeGC (dpy, gc);
1364
1365	if (!need_client_side_rendering ())
1366	{
1367	if ((flags & blurNeeded)
1368	&& (flags & HAS_RENDER_CONV))
1369	{
1370	if (blur_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1371	result |= transpPmapBlurred;
1372	}
1373	if ((flags & tintNeeded)
1374	&& (flags & (tintWholesome | HAS_RENDER)))
1375	{
1376	if (tint_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1377	result |= transpPmapTinted;
1378	}
1379	} /* server side rendering completed */
1380
1381	if (pixmap)
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	}	1128	}
1389	else
1390	XFreePixmap (dpy, tiled_root_pmap);
1391		1129
1392	if (recoded_root_pmap != root_pixmap)	1130	if (recoded_root_pmap != root_pixmap)
1393	XFreePixmap (dpy, recoded_root_pmap);	1131	XFreePixmap (dpy, recoded_root_pmap);
1394		1132
1395	return result;	1133	return ret;
1396	}	1134	}
1397		1135
1398	void	1136	void
1399	bgPixmap_t::set_root_pixmap ()	1137	rxvt_term::bg_set_root_pixmap ()
1400	{	1138	{
1401	Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);	1139	Pixmap new_root_pixmap = get_pixmap_property (xa[XA_XROOTPMAP_ID]);
1402	if (new_root_pixmap == None)	1140	if (new_root_pixmap == None)
1403	new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);	1141	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1404		1142
1405	root_pixmap = new_root_pixmap;	1143	root_pixmap = new_root_pixmap;
1406	}	1144	}
1407	# endif /* ENABLE_TRANSPARENCY */	1145	# endif /* ENABLE_TRANSPARENCY */
1408		1146
1409	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1147	bool
1410	static void ShadeXImage(Visual *visual, XImage *srcImage, int shade, const rgba &c);	1148	rxvt_term::bg_render ()
		1149	{
		1150	bg_invalidate ();
		1151	# ifdef ENABLE_TRANSPARENCY
		1152	if (bg_flags & BG_IS_TRANSPARENT)
		1153	{
		1154	/* we need to re-generate transparency pixmap in that case ! */
		1155	if (make_transparency_pixmap ())
		1156	bg_flags |= BG_IS_VALID;
		1157	}
1411	# endif	1158	# endif
1412		1159
1413	bool	1160	# ifdef BG_IMAGE_FROM_FILE
1414	bgPixmap_t::render ()	1161	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	{	1162	{
1425	/* we need to re-generate transparency pixmap in that case ! */	1163	if (render_image (*bg_image))
1426	background_flags = make_transparency_pixmap ();	1164	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	}	1165	}
1432	# endif	1166	# endif
1433		1167
1434	# ifdef BG_IMAGE_FROM_FILE	1168	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	}	1169	{
1441	# endif
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	{
1456	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1457	if (flags & tintSet)
1458	tint.get (c);
1459	ShadeXImage (DefaultVisual (target->dpy, target->display->screen), result, shade, c);
1460	}
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	{
1478	if (pixmap != None)	1170	if (bg_pixmap != None)
1479	{	1171	{
1480	XFreePixmap (target->dpy, pixmap);	1172	XFreePixmap (dpy, bg_pixmap);
1481	pixmap = None;	1173	bg_pixmap = None;
1482	}	1174	}
1483	}	1175	}
1484		1176
1485	apply ();	1177	scr_recolour (false);
		1178	bg_flags |= BG_NEEDS_REFRESH;
1486		1179
1487	valid_since = ev::now ();	1180	bg_valid_since = ev::now ();
1488		1181
1489	return true;	1182	return true;
1490	}	1183	}
1491		1184
1492	void	1185	void
1493	bgPixmap_t::set_target (rxvt_term *new_target)	1186	rxvt_term::bg_init ()
1494	{	1187	{
1495	target = new_target;
1496
1497	flags &= ~(HAS_RENDER | HAS_RENDER_CONV);	1188	bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1498	#if XRENDER	1189	#if XRENDER
1499	int major, minor;	1190	int major, minor;
1500	if (XRenderQueryVersion (target->dpy, &major, &minor))	1191	if (XRenderQueryVersion (dpy, &major, &minor))
1501	flags |= HAS_RENDER;	1192	bg_flags |= BG_HAS_RENDER;
1502	XFilters *filters = XRenderQueryFilters (target->dpy, target->vt);	1193	XFilters *filters = XRenderQueryFilters (dpy, vt);
1503	if (filters)	1194	if (filters)
1504	{	1195	{
1505	for (int i = 0; i < filters->nfilter; i++)	1196	for (int i = 0; i < filters->nfilter; i++)
1506	if (!strcmp (filters->filter[i], FilterConvolution))	1197	if (!strcmp (filters->filter[i], FilterConvolution))
1507	flags |= HAS_RENDER_CONV;	1198	bg_flags |= BG_HAS_RENDER_CONV;
1508		1199
1509	XFree (filters);	1200	XFree (filters);
1510	}	1201	}
1511	#endif	1202	#endif
		1203
		1204	#ifdef BG_IMAGE_FROM_FILE
		1205	if (rs[Rs_backgroundPixmap])
		1206	{
		1207	rxvt_image *image = new_image ();
		1208	if (!image->set_file_geometry (rs[Rs_backgroundPixmap]))
		1209	image_vec.pop_back ();
		1210	}
		1211
		1212	# ifndef NO_RESOURCES
		1213	find_resources ("image", "Image", XrmEnumAllLevels, rxvt_define_image);
		1214	vector<rxvt_image>::iterator bg_image = image_vec.begin ();
		1215	while (bg_image != image_vec.end ())
		1216	{
		1217	if (!(bg_image->flags & IM_IS_SET))
		1218	bg_image = image_vec.erase (bg_image);
		1219	else
		1220	{
		1221	if (bg_image->is_size_sensitive ())
		1222	bg_image->flags |= IM_IS_SIZE_SENSITIVE;
		1223
		1224	bg_image++;
		1225	}
		1226	}
		1227	# endif
		1228
		1229	if (image_vec.size () > 0
		1230	&& !bg_window_position_sensitive ())
		1231	update_background ();
		1232	#endif
		1233	}
		1234
		1235	/* based on code from aterm-0.4.2 */
		1236
		1237	static inline void
		1238	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
		1239	{
		1240	for (int i = 0; i <= mask >> sh; i++)
		1241	{
		1242	uint32_t tmp;
		1243	tmp = i * high;
		1244	tmp += (mask >> sh) * low;
		1245	lookup[i] = (tmp / 0xffff) << sh;
		1246	}
1512	}	1247	}
1513		1248
1514	void	1249	void
1515	bgPixmap_t::apply ()	1250	rxvt_term::tint_ximage (XImage *ximage, rxvt_color &tint, bool tint_set, int shade)
1516	{	1251	{
1517	if (target == NULL)	1252	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;	1253	int sh_r, sh_g, sh_b;
1577	uint32_t mask_r, mask_g, mask_b;	1254	uint32_t mask_r, mask_g, mask_b;
1578	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;	1255	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1579	rgba low;	1256	unsigned short low;
1580	rgba high;
1581	int i;
1582	int host_byte_order = byteorder.big_endian () ? MSBFirst : LSBFirst;	1257	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1583		1258
1584	if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return;	1259	if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1585		1260
1586	/* for convenience */	1261	/* for convenience */
1587	mask_r = visual->red_mask;	1262	mask_r = visual->red_mask;
1588	mask_g = visual->green_mask;	1263	mask_g = visual->green_mask;
1589	mask_b = visual->blue_mask;	1264	mask_b = visual->blue_mask;
1590		1265
1591	/* boring lookup table pre-initialization */	1266	/* boring lookup table pre-initialization */
1592	switch (srcImage->depth)	1267	sh_r = ecb_ctz32 (mask_r);
1593	{	1268	sh_g = ecb_ctz32 (mask_g);
1594	case 15:	1269	sh_b = ecb_ctz32 (mask_b);
1595	if ((mask_r != 0x7c00) ||	1270
1596	(mask_g != 0x03e0) ||	1271	size_r = mask_r >> sh_r;
1597	(mask_b != 0x001f))	1272	size_g = mask_g >> sh_g;
		1273	size_b = mask_b >> sh_b;
		1274
		1275	if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1598	return;	1276	return;
1599	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32));	1277
		1278	lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1600	lookup_r = lookup;	1279	lookup_r = lookup;
1601	lookup_g = lookup+32;	1280	lookup_g = lookup + size_r;
1602	lookup_b = lookup+32+32;	1281	lookup_b = lookup + size_r + size_g;
1603	sh_r = 10;	1282
1604	sh_g = 5;	1283	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1605	sh_b = 0;	1284
1606	break;	1285	if (tint_set)
1607	case 16:	1286	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		1287
1650	/* prepare limits for color transformation (each channel is handled separately) */	1288	/* prepare limits for color transformation (each channel is handled separately) */
1651	if (shade > 100)	1289	if (shade > 100)
1652	{	1290	{
1653	shade = 200 - shade;	1291	c.r = c.r * (200 - shade) / 100;
		1292	c.g = c.g * (200 - shade) / 100;
		1293	c.b = c.b * (200 - shade) / 100;
1654		1294
1655	high.r = (65535 - c.r) * shade / 100;	1295	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	}	1296	}
1663	else	1297	else
1664	{	1298	{
1665	high.r = c.r * shade / 100;	1299	c.r = c.r * shade / 100;
1666	high.g = c.g * shade / 100;	1300	c.g = c.g * shade / 100;
1667	high.b = c.b * shade / 100;	1301	c.b = c.b * shade / 100;
1668		1302
1669	low.r = low.g = low.b = 0;	1303	low = 0;
1670	}	1304	}
1671		1305
1672	/* fill our lookup tables */	1306	/* fill our lookup tables */
1673	for (i = 0; i <= mask_r>>sh_r; i++)	1307	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1674	{	1308	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1675	uint32_t tmp;	1309	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		1310
1695	/* apply table to input image (replacing colors by newly calculated ones) */	1311	/* apply table to input image (replacing colors by newly calculated ones) */
1696	if (srcImage->bits_per_pixel == 32	1312	if (ximage->bits_per_pixel == 32
1697	&& (srcImage->depth == 24 || srcImage->depth == 32)
1698	&& srcImage->byte_order == host_byte_order)	1313	&& ximage->byte_order == host_byte_order)
1699	{	1314	{
1700	uint32_t *p1, *pf, *p, *pl;	1315	char *line = ximage->data;
1701	p1 = (uint32_t *) srcImage->data;
1702	pf = (uint32_t *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1703		1316
1704	while (p1 < pf)	1317	for (int y = 0; y < ximage->height; y++)
1705	{	1318	{
1706	p = p1;	1319	uint32_t *p = (uint32_t *)line;
1707	pl = p1 + srcImage->width;	1320	for (int x = 0; x < ximage->width; x++)
1708	for (; p < pl; p++)
1709	{	1321	{
1710	*p = lookup_r[(*p & 0xff0000) >> 16] |	1322	*p = lookup_r[(*p & mask_r) >> sh_r] |
1711	lookup_g[(*p & 0x00ff00) >> 8] |	1323	lookup_g[(*p & mask_g) >> sh_g] |
1712	lookup_b[(*p & 0x0000ff)] |	1324	lookup_b[(*p & mask_b) >> sh_b];
1713	(*p & 0xff000000);	1325	p++;
1714	}	1326	}
1715	p1 = (uint32_t *) ((char *) p1 + srcImage->bytes_per_line);	1327	line += ximage->bytes_per_line;
1716	}	1328	}
1717	}	1329	}
1718	else	1330	else
1719	{	1331	{
1720	for (int y = 0; y < srcImage->height; y++)	1332	for (int y = 0; y < ximage->height; y++)
1721	for (int x = 0; x < srcImage->width; x++)	1333	for (int x = 0; x < ximage->width; x++)
1722	{	1334	{
1723	unsigned long pixel = XGetPixel (srcImage, x, y);	1335	unsigned long pixel = XGetPixel (ximage, x, y);
1724	pixel = lookup_r[(pixel & mask_r) >> sh_r] |	1336	pixel = lookup_r[(pixel & mask_r) >> sh_r] |
1725	lookup_g[(pixel & mask_g) >> sh_g] |	1337	lookup_g[(pixel & mask_g) >> sh_g] |
1726	lookup_b[(pixel & mask_b) >> sh_b];	1338	lookup_b[(pixel & mask_b) >> sh_b];
1727	XPutPixel (srcImage, x, y, pixel);	1339	XPutPixel (ximage, x, y, pixel);
1728	}	1340	}
1729	}	1341	}
1730		1342
1731	free (lookup);	1343	free (lookup);
1732	}	1344	}
1733	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1345
		1346	#endif /* HAVE_BG_PIXMAP */

Diff Legend

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