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

Diff Legend

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