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.101 by sf-exg, Sun Oct 31 08:28:04 2010 UTC vs.
Revision 1.195 by sf-exg, Mon Jan 2 19:31:00 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, DefaultVisual (dpy, target->display->screen));	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->display->root);
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)
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);
1149	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1069	Picture dst = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
1150		1070
1151	if (kernel && params && src && dst)	1071	if (kernel && params)
1152	{	1072	{
1153	if (h_blurRadius)
1154	{
1155	size = h_blurRadius * 2 + 1;	1073	size = h_blurRadius * 2 + 1;
1156	get_gaussian_kernel (h_blurRadius, size, kernel, params);	1074	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1157		1075
1158	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1076	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1159	XRenderComposite (dpy,	1077	XRenderComposite (dpy,
1160	PictOpSrc,	1078	PictOpSrc,
1161	src,	1079	src,
1162	None,	1080	None,
1163	dst,	1081	dst,
1164	0, 0,	1082	0, 0,
1165	0, 0,	1083	0, 0,
1166	0, 0,	1084	0, 0,
1167	width, height);	1085	width, height);
1168	}
1169		1086
1170	if (v_blurRadius)
1171	{
1172	size = v_blurRadius * 2 + 1;	1087	size = v_blurRadius * 2 + 1;
1173	get_gaussian_kernel (v_blurRadius, size, kernel, params);	1088	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1174	swap (params[0], params[1]);	1089	::swap (params[0], params[1]);
1175		1090
1176	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1091	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1177	XRenderComposite (dpy,	1092	XRenderComposite (dpy,
1178	PictOpSrc,	1093	PictOpSrc,
1179	src,	1094	src,
1180	None,	1095	None,
1181	dst,	1096	dst,
1182	0, 0,	1097	0, 0,
1183	0, 0,	1098	0, 0,
1184	0, 0,	1099	0, 0,
1185	width, height);	1100	width, height);
1186	}
1187		1101
1188	ret = true;	1102	ret = true;
1189	}	1103	}
1190		1104
1191	free (kernel);	1105	free (kernel);
…		…
1195	#endif	1109	#endif
1196	return ret;	1110	return ret;
1197	}	1111	}
1198		1112
1199	bool	1113	bool
1200	bgPixmap_t::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	1114	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1201	{	1115	{
1202	Display *dpy = target->dpy;
1203	bool ret = false;	1116	bool ret = false;
1204		1117
1205	if (flags & tintWholesome)	1118	if (bg_flags & BG_TINT_BITAND)
1206	{	1119	{
1207	XGCValues gcv;	1120	XGCValues gcv;
1208	GC gc;	1121	GC gc;
1209		1122
1210	/* In this case we can tint image server-side getting significant	1123	/* In this case we can tint image server-side getting significant
…		…
1219	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	1132	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1220	ret = true;	1133	ret = true;
1221	XFreeGC (dpy, gc);	1134	XFreeGC (dpy, gc);
1222	}	1135	}
1223	}	1136	}
1224	else
1225	{
1226	# if XRENDER	1137	# if XRENDER
		1138	else if (bg_flags & BG_HAS_RENDER)
		1139	{
1227	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	1140	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1228		1141
1229	if (flags & tintSet)	1142	if (bg_flags & BG_TINT_SET)
1230	tint.get (c);	1143	tint.get (c);
1231		1144
1232	if (shade <= 100)	1145	if (shade <= 100)
1233	{	1146	{
1234	c.r = (c.r * shade) / 100;	1147	c.r = c.r * shade / 100;
1235	c.g = (c.g * shade) / 100;	1148	c.g = c.g * shade / 100;
1236	c.b = (c.b * shade) / 100;	1149	c.b = c.b * shade / 100;
1237	}	1150	}
1238	else	1151	else
1239	{	1152	{
1240	c.r = ((0xffff - c.r) * (200 - shade)) / 100;	1153	c.r = c.r * (200 - shade) / 100;
1241	c.g = ((0xffff - c.g) * (200 - shade)) / 100;	1154	c.g = c.g * (200 - shade) / 100;
1242	c.b = ((0xffff - c.b) * (200 - shade)) / 100;	1155	c.b = c.b * (200 - shade) / 100;
1243	}	1156	}
1244		1157
1245	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1246	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1158	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1247	XRenderPictureAttributes pa;
1248		1159
1249	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1160	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1250		1161
1251	pa.repeat = True;	1162	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1252		1163
1253	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	1164	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		1165
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;	1166	XRenderColor mask_c;
1265		1167
1266	memset (&mask_c, (shade > 100) ? 0xFF : 0x0, sizeof (mask_c));
1267	mask_c.alpha = 0xffff;	1168	mask_c.alpha = 0xffff;
		1169	mask_c.red =
		1170	mask_c.green =
		1171	mask_c.blue = 0;
		1172	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
		1173
		1174	mask_c.alpha = 0;
		1175	mask_c.red = 0xffff - c.r;
		1176	mask_c.green = 0xffff - c.g;
		1177	mask_c.blue = 0xffff - c.b;
		1178	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		1179
		1180	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
		1181
		1182	if (shade > 100)
		1183	{
		1184	mask_c.alpha = 0;
		1185	mask_c.red =
		1186	mask_c.green =
		1187	mask_c.blue = 0xffff * (shade - 100) / 100;
1268	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	1188	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1269		1189
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);	1190	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
		1191	}
		1192
1276	ret = true;	1193	ret = true;
1277	}
1278		1194
1279	XRenderFreePicture (dpy, mask_pic);	1195	XRenderFreePicture (dpy, mask_pic);
1280	XRenderFreePicture (dpy, overlay_pic);	1196	XRenderFreePicture (dpy, overlay_pic);
1281	XRenderFreePicture (dpy, back_pic);	1197	XRenderFreePicture (dpy, back_pic);
		1198	}
1282	# endif	1199	# endif
1283	}
1284		1200
1285	return ret;	1201	return ret;
1286	}	1202	}
1287		1203
1288	/* make_transparency_pixmap()	1204	/*
1289	* Builds a pixmap of the same size as the terminal window that contains	1205	* 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	1206	* the tiled portion of the root pixmap that is supposed to be covered by
1291	* our window.	1207	* our window.
1292	*/	1208	*/
1293	unsigned long	1209	unsigned long
1294	bgPixmap_t::make_transparency_pixmap ()	1210	rxvt_term::make_transparency_pixmap ()
1295	{	1211	{
1296	unsigned long result = 0;	1212	unsigned long result = 0;
1297
1298	if (target == NULL)
1299	return 0;
1300		1213
1301	/* root dimensions may change from call to call - but Display structure should	1214	/* root dimensions may change from call to call - but Display structure should
1302	* be always up-to-date, so let's use it :	1215	* be always up-to-date, so let's use it :
1303	*/	1216	*/
1304	Window root = target->display->root;
1305	int screen = target->display->screen;	1217	int screen = display->screen;
1306	Display *dpy = target->dpy;	1218	int root_depth = DefaultDepth (dpy, screen);
1307	int root_width = DisplayWidth (dpy, screen);	1219	int root_width = DisplayWidth (dpy, screen);
1308	int root_height = DisplayHeight (dpy, screen);	1220	int root_height = DisplayHeight (dpy, screen);
		1221	unsigned int root_pmap_width, root_pmap_height;
1309	int window_width = target->szHint.width;	1222	int window_width = szHint.width;
1310	int window_height = target->szHint.height;	1223	int window_height = szHint.height;
1311	int sx, sy;	1224	int sx, sy;
1312	XGCValues gcv;	1225	XGCValues gcv;
1313	GC gc;	1226	GC gc;
1314		1227
1315	target->get_window_origin (sx, sy);	1228	sx = target_x;
		1229	sy = target_y;
1316		1230
1317	/* check if we are outside of the visible part of the virtual screen : */	1231	/* check if we are outside of the visible part of the virtual screen : */
1318	if (sx + window_width <= 0 || sy + window_height <= 0	1232	if (sx + window_width <= 0 || sy + window_height <= 0
1319	|| sx >= root_width || sy >= root_height)	1233	|| sx >= root_width || sy >= root_height)
1320	return 0;	1234	return 0;
1321		1235
1322	if (root_pixmap == None)	1236	// validate root pixmap and get its size
1323	return 0;
1324
1325	Pixmap tiled_root_pmap = XCreatePixmap (dpy, root, window_width, window_height, root_depth);
1326
1327	if (tiled_root_pmap == None) /* something really bad happened - abort */
1328	return 0;
1329
1330	/* straightforward pixmap copy */
1331	gcv.tile = root_pixmap;
1332	gcv.fill_style = FillTiled;
1333
1334	while (sx < 0) sx += (int)root_width;
1335	while (sy < 0) sy += (int)root_height;
1336
1337	gcv.ts_x_origin = -sx;
1338	gcv.ts_y_origin = -sy;
1339	gc = XCreateGC (dpy, root, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1340
1341	if (gc)
1342	{
1343	XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);
1344	result |= transpPmapTiled;
1345	XFreeGC (dpy, gc);
1346	}
1347
1348	if (tiled_root_pmap != None)
1349	{
1350	if (!need_client_side_rendering ())
1351	{
1352	if (flags & (blurNeeded | blurServerSide))
1353	{
1354	if (blur_pixmap (tiled_root_pmap, DefaultVisual (dpy, screen), window_width, window_height))
1355	result |= transpPmapBlurred;
1356	}
1357	if (flags & (tintNeeded | tintServerSide))
1358	{
1359	if (tint_pixmap (tiled_root_pmap, DefaultVisual (dpy, screen), window_width, window_height))
1360	result |= transpPmapTinted;
1361	}
1362	} /* server side rendering completed */
1363
1364	if (pixmap)
1365	XFreePixmap (dpy, pixmap);
1366
1367	pixmap = tiled_root_pmap;
1368	pmap_width = window_width;
1369	pmap_height = window_height;
1370	pmap_depth = root_depth;
1371	}
1372
1373	return result;
1374	}
1375
1376	void
1377	bgPixmap_t::set_root_pixmap ()
1378	{
1379	Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);
1380	if (new_root_pixmap == None)
1381	new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);
1382
1383	root_pixmap = new_root_pixmap;
1384
1385	// validate root pixmap
1386	if (root_pixmap != None)	1237	if (root_pixmap != None)
1387	{	1238	{
1388	unsigned int width, height;
1389	Window wdummy;	1239	Window wdummy;
1390	int idummy;	1240	int idummy;
1391	unsigned int udummy;	1241	unsigned int udummy;
1392		1242
1393	target->allowedxerror = -1;	1243	allowedxerror = -1;
1394		1244
1395	if (!XGetGeometry (target->dpy, root_pixmap, &wdummy, &idummy, &idummy, &width, &height, &udummy, &udummy))	1245	if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))
1396	root_pixmap = None;	1246	root_pixmap = None;
1397		1247
1398	target->allowedxerror = 0;	1248	allowedxerror = 0;
		1249	}
		1250
		1251	Pixmap recoded_root_pmap = root_pixmap;
		1252
		1253	if (root_pixmap != None && root_depth != depth)
1399	}	1254	{
		1255	#if XRENDER
		1256	if (bg_flags & BG_HAS_RENDER)
		1257	{
		1258	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
		1259
		1260	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
		1261	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
		1262
		1263	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
		1264	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
		1265
		1266	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
		1267
		1268	XRenderFreePicture (dpy, src);
		1269	XRenderFreePicture (dpy, dst);
		1270	}
		1271	else
		1272	#endif
		1273	recoded_root_pmap = None;
		1274	}
		1275
		1276	if (recoded_root_pmap == None)
		1277	return 0;
		1278
		1279	if (bg_pixmap == None
		1280	|| bg_pmap_width != window_width
		1281	|| bg_pmap_height != window_height)
		1282	{
		1283	if (bg_pixmap)
		1284	XFreePixmap (dpy, bg_pixmap);
		1285	bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
		1286	bg_pmap_width = window_width;
		1287	bg_pmap_height = window_height;
		1288	}
		1289
		1290	/* straightforward pixmap copy */
		1291	while (sx < 0) sx += root_pmap_width;
		1292	while (sy < 0) sy += root_pmap_height;
		1293
		1294	gcv.tile = recoded_root_pmap;
		1295	gcv.fill_style = FillTiled;
		1296	gcv.ts_x_origin = -sx;
		1297	gcv.ts_y_origin = -sy;
		1298	gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
		1299
		1300	if (gc)
		1301	{
		1302	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
		1303	result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS);
		1304
		1305	if (!(bg_flags & BG_CLIENT_RENDER))
		1306	{
		1307	if (bg_flags & BG_NEEDS_BLUR)
		1308	{
		1309	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
		1310	result &= ~BG_NEEDS_BLUR;
		1311	}
		1312	if (bg_flags & BG_NEEDS_TINT)
		1313	{
		1314	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
		1315	result &= ~BG_NEEDS_TINT;
		1316	}
		1317	# ifndef HAVE_AFTERIMAGE
		1318	if (result & BG_NEEDS_TINT)
		1319	{
		1320	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1321	if (ximage)
		1322	{
		1323	/* our own client-side tinting */
		1324	tint_ximage (DefaultVisual (dpy, display->screen), ximage);
		1325
		1326	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1327	XDestroyImage (ximage);
		1328	}
		1329	}
		1330	# endif
		1331	} /* server side rendering completed */
		1332
		1333	XFreeGC (dpy, gc);
		1334	}
		1335
		1336	if (recoded_root_pmap != root_pixmap)
		1337	XFreePixmap (dpy, recoded_root_pmap);
		1338
		1339	return result;
		1340	}
		1341
		1342	void
		1343	rxvt_term::bg_set_root_pixmap ()
		1344	{
		1345	Pixmap new_root_pixmap = get_pixmap_property (xa[XA_XROOTPMAP_ID]);
		1346	if (new_root_pixmap == None)
		1347	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
		1348
		1349	root_pixmap = new_root_pixmap;
1400	}	1350	}
1401	# endif /* ENABLE_TRANSPARENCY */	1351	# endif /* ENABLE_TRANSPARENCY */
1402		1352
1403	# ifndef HAVE_AFTERIMAGE	1353	bool
1404	static void ShadeXImage(Visual *visual, XImage *srcImage, int shade, int rm, int gm, int bm);	1354	rxvt_term::bg_render ()
		1355	{
		1356	unsigned long tr_flags = 0;
		1357
		1358	bg_invalidate ();
		1359	# ifdef ENABLE_TRANSPARENCY
		1360	if (bg_flags & BG_IS_TRANSPARENT)
		1361	{
		1362	/* we need to re-generate transparency pixmap in that case ! */
		1363	tr_flags = make_transparency_pixmap ();
		1364	if (tr_flags == 0)
		1365	return false;
		1366	bg_flags |= BG_IS_VALID;
		1367	}
1405	# endif	1368	# endif
1406		1369
1407	bool	1370	# ifdef BG_IMAGE_FROM_FILE
1408	bgPixmap_t::render ()	1371	if ((bg_flags & BG_IS_FROM_FILE)
1409	{	1372	|| (tr_flags & BG_EFFECTS_FLAGS))
1410	unsigned long background_flags = 0;
1411
1412	if (target == NULL)
1413	return false;
1414
1415	invalidate ();
1416	# ifdef ENABLE_TRANSPARENCY
1417	if (flags & isTransparent)
1418	{	1373	{
1419	/* we need to re-generate transparency pixmap in that case ! */	1374	if (render_image (tr_flags))
1420	background_flags = make_transparency_pixmap ();	1375	bg_flags |= BG_IS_VALID;
1421	if (background_flags == 0)
1422	return false;
1423	else if ((background_flags & transpTransformations) == (flags & transpTransformations)
1424	&& pmap_depth == target->depth)
1425	flags = flags & ~isInvalid;
1426	}	1376	}
1427	# endif	1377	# endif
1428		1378
1429	# ifdef BG_IMAGE_FROM_FILE	1379	if (!(bg_flags & BG_IS_VALID))
1430	if (have_image
1431	|| (background_flags & transpTransformations) != (flags & transpTransformations))
1432	{
1433	if (render_image (background_flags))
1434	flags = flags & ~isInvalid;
1435	}	1380	{
1436	# endif
1437
1438	XImage *result = NULL;
1439
1440	if (background_flags && (flags & isInvalid))
1441	{
1442	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1443	}
1444
1445	if (result)
1446	{
1447	# if !defined(HAVE_AFTERIMAGE) && !XRENDER
1448	/* our own client-side tinting */
1449	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1450	{
1451	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1452	if (flags & tintSet)
1453	tint.get (c);
1454	ShadeXImage (DefaultVisual (target->dpy, target->display->screen), result, shade, c.r, c.g, c.b);
1455	}
1456	# endif
1457
1458	GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1459
1460	if (gc)
1461	{
1462	if (/*pmap_depth != target->depth &&*/ pixmap != None)
1463	{
1464	XFreePixmap (target->dpy, pixmap);
1465	pixmap = None;
1466	}
1467
1468	if (pixmap == None)
1469	{
1470	pixmap = XCreatePixmap (target->dpy, target->vt, result->width, result->height, target->depth);
1471	pmap_width = result->width;
1472	pmap_height = result->height;
1473	pmap_depth = target->depth;
1474	}
1475
1476	if (pmap_depth != result->depth)
1477	{
1478	/* Bad Match error will ensue ! stupid X !!!! */
1479	if (result->depth == 24 && pmap_depth == 32)
1480	result->depth = 32;
1481	else if (result->depth == 32 && pmap_depth == 24)
1482	result->depth = 24;
1483	else
1484	{
1485	/* TODO: implement image recoding */
1486	}
1487	}
1488
1489	if (pmap_depth == result->depth)
1490	XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1491
1492	XFreeGC (target->dpy, gc);
1493	flags = flags & ~isInvalid;
1494	}
1495
1496	XDestroyImage (result);
1497	}
1498
1499	if (flags & isInvalid)
1500	{
1501	if (pixmap != None)	1381	if (bg_pixmap != None)
1502	{	1382	{
1503	XFreePixmap (target->dpy, pixmap);	1383	XFreePixmap (dpy, bg_pixmap);
1504	pixmap = None;	1384	bg_pixmap = None;
1505	}	1385	}
1506	}	1386	}
1507		1387
1508	apply ();	1388	scr_recolour (false);
		1389	bg_flags |= BG_NEEDS_REFRESH;
1509		1390
1510	valid_since = ev::now ();	1391	bg_valid_since = ev::now ();
1511		1392
1512	return true;	1393	return true;
1513	}	1394	}
1514		1395
1515	bool
1516	bgPixmap_t::set_target (rxvt_term *new_target)
1517	{
1518	if (new_target)
1519	if (target != new_target)
1520	{
1521	target = new_target;
1522	# ifdef ENABLE_TRANSPARENCY
1523	root_depth = DefaultDepthOfScreen (ScreenOfDisplay (target->dpy, target->display->screen));
1524	# endif
1525	return true;
1526	}
1527
1528	return false;
1529	}
1530
1531	void	1396	void
1532	bgPixmap_t::apply ()	1397	rxvt_term::bg_init ()
1533	{	1398	{
1534	if (target)
1535	{
1536	if (pixmap != None)
1537	{
1538	/* set target's background to pixmap */
1539	# ifdef ENABLE_TRANSPARENCY	1399	#ifdef ENABLE_TRANSPARENCY
1540	if (flags & isTransparent)	1400	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	1401	#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		1402
1556	if (target->scrollBar.win)	1403	bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1557	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);	1404	#if XRENDER
1558	}	1405	int major, minor;
1559	}	1406	if (XRenderQueryVersion (dpy, &major, &minor))
1560	else	1407	bg_flags |= BG_HAS_RENDER;
1561	{	1408	XFilters *filters = XRenderQueryFilters (dpy, vt);
1562	/* set target background to a pixel */	1409	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	}	1410	{
		1411	for (int i = 0; i < filters->nfilter; i++)
		1412	if (!strcmp (filters->filter[i], FilterConvolution))
		1413	bg_flags |= BG_HAS_RENDER_CONV;
		1414
		1415	XFree (filters);
		1416	}
		1417	#endif
1583	}	1418	}
1584		1419
1585	#endif /* HAVE_BG_PIXMAP */	1420	#endif /* HAVE_BG_PIXMAP */
1586		1421
1587	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XRENDER	1422	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1588	/* taken from aterm-0.4.2 */	1423	/* based on code from aterm-0.4.2 */
1589		1424
1590	static void	1425	static inline void
1591	ShadeXImage(Visual *visual, XImage *srcImage, int shade, int rm, int gm, int bm)	1426	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
		1427	{
		1428	for (int i = 0; i <= mask >> sh; i++)
		1429	{
		1430	uint32_t tmp;
		1431	tmp = i * high;
		1432	tmp += (mask >> sh) * low;
		1433	lookup[i] = (tmp / 0xffff) << sh;
		1434	}
		1435	}
		1436
		1437	void
		1438	rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1592	{	1439	{
1593	int sh_r, sh_g, sh_b;	1440	int sh_r, sh_g, sh_b;
1594	uint32_t mask_r, mask_g, mask_b;	1441	uint32_t mask_r, mask_g, mask_b;
1595	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;	1442	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1596	unsigned int lower_lim_r, lower_lim_g, lower_lim_b;	1443	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;	1444	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1600		1445
1601	if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return;	1446	if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1602		1447
1603	/* for convenience */	1448	/* for convenience */
1604	mask_r = visual->red_mask;	1449	mask_r = visual->red_mask;
1605	mask_g = visual->green_mask;	1450	mask_g = visual->green_mask;
1606	mask_b = visual->blue_mask;	1451	mask_b = visual->blue_mask;
1607		1452
1608	/* boring lookup table pre-initialization */	1453	/* boring lookup table pre-initialization */
1609	switch (srcImage->depth)	1454	switch (ximage->depth)
1610	{	1455	{
1611	case 15:	1456	case 15:
1612	if ((mask_r != 0x7c00) ||	1457	if ((mask_r != 0x7c00) ||
1613	(mask_g != 0x03e0) ||	1458	(mask_g != 0x03e0) ||
1614	(mask_b != 0x001f))	1459	(mask_b != 0x001f))
…		…
1662	break;	1507	break;
1663	default:	1508	default:
1664	return; /* we do not support this color depth */	1509	return; /* we do not support this color depth */
1665	}	1510	}
1666		1511
		1512	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
		1513
		1514	if (bg_flags & BG_TINT_SET)
		1515	tint.get (c);
		1516
1667	/* prepare limits for color transformation (each channel is handled separately) */	1517	/* prepare limits for color transformation (each channel is handled separately) */
1668	if (shade > 100)	1518	if (shade > 100)
1669	{	1519	{
1670	shade = 200 - shade;	1520	c.r = c.r * (200 - shade) / 100;
		1521	c.g = c.g * (200 - shade) / 100;
		1522	c.b = c.b * (200 - shade) / 100;
1671		1523
1672	lower_lim_r = 65535-rm;	1524	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	}	1525	}
1682	else	1526	else
1683	{	1527	{
		1528	c.r = c.r * shade / 100;
		1529	c.g = c.g * shade / 100;
		1530	c.b = c.b * shade / 100;
1684		1531
1685	lower_lim_r = lower_lim_g = lower_lim_b = 0;	1532	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	}	1533	}
1691		1534
1692	/* fill our lookup tables */	1535	/* fill our lookup tables */
1693	for (i = 0; i <= mask_r>>sh_r; i++)	1536	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1694	{	1537	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1695	uint32_t tmp;	1538	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		1539
1715	/* apply table to input image (replacing colors by newly calculated ones) */	1540	/* apply table to input image (replacing colors by newly calculated ones) */
1716	if (srcImage->bits_per_pixel == 32	1541	if (ximage->bits_per_pixel == 32
1717	&& (srcImage->depth == 24 || srcImage->depth == 32)	1542	&& (ximage->depth == 24 || ximage->depth == 32)
1718	&& srcImage->byte_order == host_byte_order)	1543	&& ximage->byte_order == host_byte_order)
1719	{	1544	{
1720	uint32_t *p1, *pf, *p, *pl;	1545	uint32_t *p1, *pf, *p, *pl;
1721	p1 = (uint32_t *) srcImage->data;	1546	p1 = (uint32_t *) ximage->data;
1722	pf = (uint32_t *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);	1547	pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1723		1548
1724	while (p1 < pf)	1549	while (p1 < pf)
1725	{	1550	{
1726	p = p1;	1551	p = p1;
1727	pl = p1 + srcImage->width;	1552	pl = p1 + ximage->width;
1728	for (; p < pl; p++)	1553	for (; p < pl; p++)
1729	{	1554	{
1730	*p = lookup_r[(*p & 0xff0000) >> 16] |	1555	*p = lookup_r[(*p & 0xff0000) >> 16] |
1731	lookup_g[(*p & 0x00ff00) >> 8] |	1556	lookup_g[(*p & 0x00ff00) >> 8] |
1732	lookup_b[(*p & 0x0000ff)] |	1557	lookup_b[(*p & 0x0000ff)] |
1733	(*p & 0xff000000);	1558	(*p & 0xff000000);
1734	}	1559	}
1735	p1 = (uint32_t *) ((char *) p1 + srcImage->bytes_per_line);	1560	p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line);
1736	}	1561	}
1737	}	1562	}
1738	else	1563	else
1739	{	1564	{
1740	for (int y = 0; y < srcImage->height; y++)	1565	for (int y = 0; y < ximage->height; y++)
1741	for (int x = 0; x < srcImage->width; x++)	1566	for (int x = 0; x < ximage->width; x++)
1742	{	1567	{
1743	unsigned long pixel = XGetPixel (srcImage, x, y);	1568	unsigned long pixel = XGetPixel (ximage, x, y);
1744	pixel = lookup_r[(pixel & mask_r) >> sh_r] |	1569	pixel = lookup_r[(pixel & mask_r) >> sh_r] |
1745	lookup_g[(pixel & mask_g) >> sh_g] |	1570	lookup_g[(pixel & mask_g) >> sh_g] |
1746	lookup_b[(pixel & mask_b) >> sh_b];	1571	lookup_b[(pixel & mask_b) >> sh_b];
1747	XPutPixel (srcImage, x, y, pixel);	1572	XPutPixel (ximage, x, y, pixel);
1748	}	1573	}
1749	}	1574	}
1750		1575
1751	free (lookup);	1576	free (lookup);
1752	}	1577	}

Diff Legend

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