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

Diff Legend

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