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

Diff Legend

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