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.83 by sf-exg, Thu Oct 14 17:39:42 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
…		…
222	int diff = window_size - image_size;	171	int diff = window_size - image_size;
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	//fprintf (stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
434	// flags, h_scale, v_scale, h_align, v_align);
435	return (changed > 0);	341	return changed;
436	}	342	}
437		343
438	void	344	void
439	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)
440	{	346	{
441	int target_width = target->szHint.width;	347	int target_width = szHint.width;
442	int target_height = target->szHint.height;	348	int target_height = szHint.height;
443		349
444	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)
445	{	354	{
446	float scale = (float)target_width / image_width;	355	float scale = (float)w / image_width;
447	min_it (scale, (float)target_height / image_height);	356	min_it (scale, (float)h / image_height);
448	w = image_width * scale + 0.5;	357	w = image_width * scale + 0.5;
449	h = image_height * scale + 0.5;	358	h = image_height * scale + 0.5;
450	}	359	}
451	else
452	{
453	w = h_scale * target_width / 100;
454	h = v_scale * target_height / 100;
455	}
456		360
457	if (!w) w = image_width;	361	if (!w) w = image_width;
458	if (!h) h = image_height;	362	if (!h) h = image_height;
459		363
460	if (flags & rootAlign)	364	if (bg_flags & BG_ROOT_ALIGN)
461	{	365	{
462	target->get_window_origin (x, y);
463	x = -x;	366	x = -target_x;
464	y = -y;	367	y = -target_y;
465	}	368	}
466	else	369	else
467	{	370	{
468	x = make_align_position (h_align, target_width, w);	371	x = make_align_position (h_align, target_width, w);
469	y = make_align_position (v_align, target_height, h);	372	y = make_align_position (v_align, target_height, h);
470	}	373	}
471		374
472	flags &= ~sizeSensitive;	375	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
473	if (h_scale != 0 || v_scale != 0	376	if (!(bg_flags & BG_TILE)
474	|| h_align != 0 || v_align != 0	377	|| h_scale || v_scale
		378	|| (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
475	|| w > target_width || h > target_height)	379	|| w > target_width || h > target_height)
476	flags |= sizeSensitive;	380	bg_flags |= BG_IS_SIZE_SENSITIVE;
477	}	381	}
478		382
479	# ifdef HAVE_AFTERIMAGE	383	# ifdef HAVE_AFTERIMAGE
480	bool	384	bool
481	bgPixmap_t::render_image (unsigned long background_flags)	385	rxvt_term::render_image (unsigned long tr_flags)
482	{	386	{
483	if (target == NULL)
484	return false;
485
486	target->init_asv ();	387	init_asv ();
487		388
488	ASImage *background = NULL;	389	ASImage *background = NULL;
489	ARGB32 background_tint = TINT_LEAVE_SAME;	390	ARGB32 background_tint = TINT_LEAVE_SAME;
490		391
491	# ifdef ENABLE_TRANSPARENCY	392	# ifdef ENABLE_TRANSPARENCY
492	if (background_flags)	393	if (tr_flags)
493	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);
494		395
495	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))	396	if (tr_flags & BG_NEEDS_TINT)
496	{	397	{
497	ShadingInfo as_shade;	398	ShadingInfo as_shade;
498	as_shade.shading = shade;	399	as_shade.shading = shade;
499		400
500	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	401	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
501	if (flags & tintSet)	402	if (bg_flags & BG_TINT_SET)
502	tint.get (c);	403	tint.get (c);
503	as_shade.tintColor.red = c.r;	404	as_shade.tintColor.red = c.r;
504	as_shade.tintColor.green = c.g;	405	as_shade.tintColor.green = c.g;
505	as_shade.tintColor.blue = c.b;	406	as_shade.tintColor.blue = c.b;
506		407
507	background_tint = shading2tint32 (&as_shade);	408	background_tint = shading2tint32 (&as_shade);
508	}	409	}
509		410
510	if (!(background_flags & transpPmapBlurred) && (flags & blurNeeded) && background != NULL)	411	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
511	{	412	{
512	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,
513	(original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,	414	ASA_XImage,
514	100, ASIMAGE_QUALITY_DEFAULT);	415	100, ASIMAGE_QUALITY_DEFAULT);
515	if (tmp)	416	if (tmp)
516	{	417	{
517	destroy_asimage (&background);	418	destroy_asimage (&background);
518	background = tmp;	419	background = tmp;
…		…
520	}	421	}
521	# endif	422	# endif
522		423
523	ASImage *result = 0;	424	ASImage *result = 0;
524		425
525	int target_width = target->szHint.width;	426	int target_width = szHint.width;
526	int target_height = target->szHint.height;	427	int target_height = szHint.height;
527	int new_pmap_width = target_width;	428	int new_pmap_width = target_width;
528	int new_pmap_height = target_height;	429	int new_pmap_height = target_height;
529		430
530	int x = 0;	431	int x = 0;
531	int y = 0;	432	int y = 0;
532	int w = 0;	433	int w = 0;
533	int h = 0;	434	int h = 0;
534		435
535	TIMING_TEST_START (asim);
536
537	if (original_asim)	436	if (original_asim)
538	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);
539		438
540	if (!original_asim	439	if (!original_asim
541	|| (!(flags & rootAlign)	440	|| (!(bg_flags & BG_ROOT_ALIGN)
542	&& (x >= target_width	441	&& (x >= target_width
543	|| y >= target_height	442	|| y >= target_height
544	|| (x + w <= 0)	443	|| x + w <= 0
545	|| (y + h <= 0))))	444	|| y + h <= 0)))
546	{	445	{
547	if (background)	446	if (background)
548	{	447	{
549	new_pmap_width = background->width;	448	new_pmap_width = background->width;
550	new_pmap_height = background->height;	449	new_pmap_height = background->height;
551	result = background;	450	result = background;
552		451
553	if (background_tint != TINT_LEAVE_SAME)	452	if (background_tint != TINT_LEAVE_SAME)
554	{	453	{
555	ASImage *tmp = tile_asimage (target->asv, background, 0, 0,	454	ASImage *tmp = tile_asimage (asv, background, 0, 0,
556	target_width, target_height, background_tint,	455	target_width, target_height, background_tint,
557	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);	456	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
558	if (tmp)	457	if (tmp)
559	result = tmp;	458	result = tmp;
560	}	459	}
…		…
564	}	463	}
565	else	464	else
566	{	465	{
567	result = original_asim;	466	result = original_asim;
568		467
569	if ((w != original_asim->width)	468	if (w != original_asim->width
570	|| (h != original_asim->height))	469	|| h != original_asim->height)
571	{	470	{
572	result = scale_asimage (target->asv, original_asim,	471	result = scale_asimage (asv, original_asim,
573	w, h,	472	w, h,
574	background ? ASA_ASImage : ASA_XImage,	473	ASA_XImage,
575	100, ASIMAGE_QUALITY_DEFAULT);	474	100, ASIMAGE_QUALITY_DEFAULT);
576	}	475	}
577		476
578	if (background == NULL)	477	if (background == NULL)
579	{	478	{
580	if (h_scale == 0 || v_scale == 0)	479	if (bg_flags & BG_TILE)
581	{	480	{
582	/* if tiling - pixmap has to be sized exactly as the image,	481	/* if tiling - pixmap has to be sized exactly as the image,
583	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! */
584	new_pmap_width = min (result->width, target_width);	483	new_pmap_width = min (result->width, target_width);
585	new_pmap_height = min (result->height, target_height);	484	new_pmap_height = min (result->height, target_height);
586		485
587	/* we also need to tile our image in both directions */	486	/* we also need to tile our image in both directions */
588	ASImage *tmp = tile_asimage (target->asv, result,	487	ASImage *tmp = tile_asimage (asv, result,
589	(int)result->width - x,	488	(int)result->width - x,
590	(int)result->height - y,	489	(int)result->height - y,
591	new_pmap_width,	490	new_pmap_width,
592	new_pmap_height,	491	new_pmap_height,
593	TINT_LEAVE_SAME, ASA_XImage,	492	TINT_LEAVE_SAME, ASA_XImage,
…		…
610	layers[0].clip_width = target_width;	509	layers[0].clip_width = target_width;
611	layers[0].clip_height = target_height;	510	layers[0].clip_height = target_height;
612	layers[0].tint = background_tint;	511	layers[0].tint = background_tint;
613	layers[1].im = result;	512	layers[1].im = result;
614		513
615	if (h_scale == 0 || v_scale == 0)	514	if (bg_flags & BG_TILE)
616	{	515	{
617	/* tile horizontally */	516	/* tile horizontally */
618	while (x > 0) x -= (int)result->width;	517	while (x > 0) x -= (int)result->width;
619	layers[1].dst_x = x;	518	layers[1].dst_x = x;
620	layers[1].clip_width = result->width+target_width;	519	layers[1].clip_width = result->width+target_width;
…		…
624	/* clip horizontally */	523	/* clip horizontally */
625	layers[1].dst_x = x;	524	layers[1].dst_x = x;
626	layers[1].clip_width = result->width;	525	layers[1].clip_width = result->width;
627	}	526	}
628		527
629	if (h_scale == 0 || v_scale == 0)	528	if (bg_flags & BG_TILE)
630	{	529	{
631	while (y > 0) y -= (int)result->height;	530	while (y > 0) y -= (int)result->height;
632	layers[1].dst_y = y;	531	layers[1].dst_y = y;
633	layers[1].clip_height = result->height + target_height;	532	layers[1].clip_height = result->height + target_height;
634	}	533	}
…		…
636	{	535	{
637	layers[1].dst_y = y;	536	layers[1].dst_y = y;
638	layers[1].clip_height = result->height;	537	layers[1].clip_height = result->height;
639	}	538	}
640		539
641	if (target->rs[Rs_blendtype])	540	if (rs[Rs_blendtype])
642	{	541	{
643	layers[1].merge_scanlines = blend_scanlines_name2func (target->rs[Rs_blendtype]);	542	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
644	if (layers[1].merge_scanlines == NULL)	543	if (layers[1].merge_scanlines == NULL)
645	layers[1].merge_scanlines = alphablend_scanlines;	544	layers[1].merge_scanlines = alphablend_scanlines;
646	}	545	}
647		546
648	ASImage *tmp = merge_layers (target->asv, layers, 2, target_width, target_height,	547	ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
649	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);	548	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
650		549
651	if (tmp)	550	if (tmp)
652	{	551	{
653	if (result != original_asim)	552	if (result != original_asim)
…		…
657	}	556	}
658		557
659	free (layers);	558	free (layers);
660	}	559	}
661	}	560	}
662	TIMING_TEST_PRINT_RESULT (asim);
663		561
664	bool ret = false;	562	bool ret = false;
665		563
666	if (result)	564	if (result)
667	{	565	{
668	XGCValues gcv;	566	XGCValues gcv;
669	GC gc;	567	GC gc;
670		568
671	if (pixmap)
672	{
673	if (pmap_width != new_pmap_width
674	|| pmap_height != new_pmap_height
675	|| pmap_depth != target->depth)
676	{
677	XFreePixmap (target->dpy, pixmap);
678	pixmap = None;
679	}
680	}
681
682	/* create Pixmap */	569	/* create Pixmap */
683	if (pixmap == None)	570	if (bg_pixmap == None
		571	|| bg_pmap_width != new_pmap_width
		572	|| bg_pmap_height != new_pmap_height)
684	{	573	{
		574	if (bg_pixmap)
		575	XFreePixmap (dpy, bg_pixmap);
685	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);
686	pmap_width = new_pmap_width;	577	bg_pmap_width = new_pmap_width;
687	pmap_height = new_pmap_height;	578	bg_pmap_height = new_pmap_height;
688	pmap_depth = target->depth;
689	}	579	}
690	/* fill with background color (if result's not completely overlapping it) */	580	/* fill with background color (if result's not completely overlapping it) */
691	gcv.foreground = target->pix_colors[Color_bg];	581	gcv.foreground = pix_colors[Color_bg];
692	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);	582	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
693		583
694	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;
695	int dst_width = result->width, dst_height = result->height;	585	int dst_width = result->width, dst_height = result->height;
696	if (background == NULL)	586	if (background == NULL)
697	{	587	{
698	if (!(h_scale == 0 || v_scale == 0))	588	if (!(bg_flags & BG_TILE))
699	{	589	{
700	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 );
701	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);
702	}	592	}
703		593
704	if (dst_x > 0 || dst_y > 0	594	if (dst_x > 0 || dst_y > 0
705	|| dst_x + dst_width < new_pmap_width	595	|| dst_x + dst_width < new_pmap_width
706	|| dst_y + dst_height < new_pmap_height)	596	|| dst_y + dst_height < new_pmap_height)
707	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);
708	}	598	}
709		599
710	/* put result on pixmap */	600	/* put result on pixmap */
711	if (dst_x < new_pmap_width && dst_y < new_pmap_height)	601	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
712	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);
713		603
714	if (result != background && result != original_asim)	604	if (result != background && result != original_asim)
715	destroy_asimage (&result);	605	destroy_asimage (&result);
716		606
717	XFreeGC (target->dpy, gc);	607	XFreeGC (dpy, gc);
718	TIMING_TEST_PRINT_RESULT (asim);
719		608
720	ret = true;	609	ret = true;
721	}	610	}
722		611
723	if (background)	612	if (background)
…		…
727	}	616	}
728	# endif /* HAVE_AFTERIMAGE */	617	# endif /* HAVE_AFTERIMAGE */
729		618
730	# ifdef HAVE_PIXBUF	619	# ifdef HAVE_PIXBUF
731	bool	620	bool
732	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)
733	{	624	{
734	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)
735	return false;	635	return false;
736		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	{
737	if (!pixbuf)	706	if (!pixbuf)
738	return false;	707	return false;
739		708
740	#if !XFT	709	if (tr_flags
741	if (background_flags)	710	&& !(bg_flags & BG_HAS_RENDER))
742	return false;	711	return false;
743	#endif
744		712
745	GdkPixbuf *result;	713	GdkPixbuf *result;
746		714
747	int image_width = gdk_pixbuf_get_width (pixbuf);	715	int image_width = gdk_pixbuf_get_width (pixbuf);
748	int image_height = gdk_pixbuf_get_height (pixbuf);	716	int image_height = gdk_pixbuf_get_height (pixbuf);
749		717
750	int target_width = target->szHint.width;	718	int target_width = szHint.width;
751	int target_height = target->szHint.height;	719	int target_height = szHint.height;
752	int new_pmap_width = target_width;	720	int new_pmap_width = target_width;
753	int new_pmap_height = target_height;	721	int new_pmap_height = target_height;
754		722
755	int x = 0;	723	int x = 0;
756	int y = 0;	724	int y = 0;
757	int w = 0;	725	int w = 0;
758	int h = 0;	726	int h = 0;
759		727
760	get_image_geometry (image_width, image_height, w, h, x, y);	728	get_image_geometry (image_width, image_height, w, h, x, y);
761		729
762	if (!(flags & rootAlign)	730	if (!(bg_flags & BG_ROOT_ALIGN)
763	&& (x >= target_width	731	&& (x >= target_width
764	|| y >= target_height	732	|| y >= target_height
765	|| (x + w <= 0)	733	|| x + w <= 0
766	|| (y + h <= 0)))	734	|| y + h <= 0))
767	return false;	735	return false;
768		736
769	result = pixbuf;	737	result = pixbuf;
770		738
771	if ((w != image_width)	739	if (w != image_width
772	|| (h != image_height))	740	|| h != image_height)
773	{	741	{
774	result = gdk_pixbuf_scale_simple (pixbuf,	742	result = gdk_pixbuf_scale_simple (pixbuf,
775	w, h,	743	w, h,
776	GDK_INTERP_BILINEAR);	744	GDK_INTERP_BILINEAR);
777	}	745	}
778		746
		747	if (!result)
		748	return false;
		749
779	bool ret = false;	750	bool ret = false;
780		751
781	if (result)
782	{
783	XGCValues gcv;	752	XGCValues gcv;
784	GC gc;	753	GC gc;
785	Pixmap root_pmap;	754	Pixmap root_pmap;
786		755
787	image_width = gdk_pixbuf_get_width (result);	756	image_width = gdk_pixbuf_get_width (result);
788	image_height = gdk_pixbuf_get_height (result);	757	image_height = gdk_pixbuf_get_height (result);
789		758
790	if (background_flags)	759	if (tr_flags)
791	{	760	{
792	root_pmap = pixmap;	761	root_pmap = bg_pixmap;
793	pixmap = None;	762	bg_pixmap = None;
		763	}
		764	else
		765	{
		766	if (bg_flags & BG_TILE)
794	}	767	{
795	else
796	{
797	if (h_scale == 0 || v_scale == 0)
798	{
799	new_pmap_width = min (image_width, target_width);	768	new_pmap_width = min (image_width, target_width);
800	new_pmap_height = min (image_height, target_height);	769	new_pmap_height = min (image_height, target_height);
801	}	770	}
802	}	771	}
803		772
		773	if (bg_pixmap == None
		774	|| bg_pmap_width != new_pmap_width
		775	|| bg_pmap_height != new_pmap_height)
		776	{
804	if (pixmap)	777	if (bg_pixmap)
805	{
806	if (pmap_width != new_pmap_width
807	|| pmap_height != new_pmap_height
808	|| pmap_depth != target->depth)
809	{
810	XFreePixmap (target->dpy, pixmap);	778	XFreePixmap (dpy, bg_pixmap);
811	pixmap = None;
812	}
813	}
814
815	if (pixmap == None)
816	{
817	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);	779	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
818	pmap_width = new_pmap_width;	780	bg_pmap_width = new_pmap_width;
819	pmap_height = new_pmap_height;	781	bg_pmap_height = new_pmap_height;
820	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)
821	}	790	{
822
823	gcv.foreground = target->pix_colors[Color_bg];
824	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
825
826	if (h_scale == 0 || v_scale == 0)
827	{
828	Pixmap tile = XCreatePixmap (target->dpy, target->vt, image_width, image_height, target->depth);	791	Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);
829	gdk_pixbuf_xlib_render_to_drawable (result, tile, gc,	792	pixbuf_to_pixmap (result, tile, gc,
830	0, 0,	793	0, 0,
831	0, 0,	794	0, 0,
832	image_width, image_height,	795	image_width, image_height);
833	XLIB_RGB_DITHER_NONE,
834	0, 0);
835		796
836	gcv.tile = tile;	797	gcv.tile = tile;
837	gcv.fill_style = FillTiled;	798	gcv.fill_style = FillTiled;
838	gcv.ts_x_origin = x;	799	gcv.ts_x_origin = x;
839	gcv.ts_y_origin = y;	800	gcv.ts_y_origin = y;
840	XChangeGC (target->dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	801	XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
841		802
842	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);
843	XFreePixmap (target->dpy, tile);	804	XFreePixmap (dpy, tile);
844	}	805	}
845	else	806	else
846	{	807	{
847	int src_x, src_y, dst_x, dst_y;	808	int src_x, src_y, dst_x, dst_y;
848	int dst_width, dst_height;	809	int dst_width, dst_height;
…		…
851	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);
852		813
853	if (dst_x > 0 || dst_y > 0	814	if (dst_x > 0 || dst_y > 0
854	|| dst_x + dst_width < new_pmap_width	815	|| dst_x + dst_width < new_pmap_width
855	|| dst_y + dst_height < new_pmap_height)	816	|| dst_y + dst_height < new_pmap_height)
856	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);
857		818
858	if (dst_x < new_pmap_width && dst_y < new_pmap_height)	819	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
859	gdk_pixbuf_xlib_render_to_drawable (result, pixmap, gc,	820	pixbuf_to_pixmap (result, bg_pixmap, gc,
860	src_x, src_y,	821	src_x, src_y,
861	dst_x, dst_y,	822	dst_x, dst_y,
862	dst_width, dst_height,	823	dst_width, dst_height);
863	XLIB_RGB_DITHER_NONE,
864	0, 0);
865	}
866
867	#if XFT
868	if (background_flags)
869	{	824	}
870	Display *dpy = target->dpy;
871	XRenderPictureAttributes pa;
872		825
		826	#if XRENDER
		827	if (tr_flags)
		828	{
873	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, target->display->screen));	829	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		830
874	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	831	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
875		832
876	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
877	Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa);	833	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
878		834
879	pa.repeat = True;	835	Picture mask = create_xrender_mask (dpy, vt, False, False);
880	Pixmap mask_pmap = XCreatePixmap (dpy, target->vt, 1, 1, 8);
881	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
882	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
883	XFreePixmap (dpy, mask_pmap);
884		836
885	if (src && dst && mask)
886	{
887	XRenderColor mask_c;	837	XRenderColor mask_c;
888		838
889	mask_c.alpha = 0x8000;	839	mask_c.alpha = 0x8000;
890	mask_c.red = 0;	840	mask_c.red =
891	mask_c.green = 0;	841	mask_c.green =
892	mask_c.blue = 0;	842	mask_c.blue = 0;
893	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	843	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		844
894	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);
895	}
896		846
897	XRenderFreePicture (dpy, src);	847	XRenderFreePicture (dpy, src);
898	XRenderFreePicture (dpy, dst);	848	XRenderFreePicture (dpy, dst);
899	XRenderFreePicture (dpy, mask);	849	XRenderFreePicture (dpy, mask);
900
901	XFreePixmap (dpy, root_pmap);
902	}	850	}
903	#endif	851	#endif
904		852
905	if (result != pixbuf)
906	g_object_unref (result);
907
908	XFreeGC (target->dpy, gc);	853	XFreeGC (dpy, gc);
909		854
910	ret = true;	855	ret = true;
911	}	856	}
912		857
		858	if (result != pixbuf)
		859	g_object_unref (result);
		860
		861	if (tr_flags)
		862	XFreePixmap (dpy, root_pmap);
		863
913	return ret;	864	return ret;
914	}	865	}
915	# endif /* HAVE_PIXBUF */	866	# endif /* HAVE_PIXBUF */
916		867
917	bool	868	bool
918	bgPixmap_t::set_file (const char *file)	869	rxvt_term::bg_set_file (const char *file)
919	{	870	{
920	assert (file);	871	if (!file || !*file)
		872	return false;
921		873
922	if (*file)	874	bool ret = false;
923	{
924	if (const char *p = strchr (file, ';'))	875	const char *p = strchr (file, ';');
925	{	876
		877	if (p)
		878	{
926	size_t len = p - file;	879	size_t len = p - file;
927	char *f = rxvt_temp_buf<char> (len + 1);	880	char *f = rxvt_temp_buf<char> (len + 1);
928	memcpy (f, file, len);	881	memcpy (f, file, len);
929	f[len] = '\0';	882	f[len] = '\0';
930	file = f;	883	file = f;
931	}	884	}
932		885
933	# ifdef HAVE_AFTERIMAGE	886	# ifdef HAVE_AFTERIMAGE
934	if (!target->asimman)	887	if (!asimman)
935	target->asimman = create_generic_imageman (target->rs[Rs_path]);	888	asimman = create_generic_imageman (rs[Rs_path]);
936	ASImage *image = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);	889	ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
937	if (image)	890	if (image)
938	{	891	{
939	if (original_asim)	892	if (original_asim)
940	safe_asimage_destroy (original_asim);	893	safe_asimage_destroy (original_asim);
941	original_asim = image;	894	original_asim = image;
942	have_image = true;	895	bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
943	return true;	896	ret = true;
944	}	897	}
945	# endif	898	# endif
946		899
947	# ifdef HAVE_PIXBUF	900	# ifdef HAVE_PIXBUF
948	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	901	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
949	if (image)	902	if (image)
950	{	903	{
951	if (pixbuf)	904	if (pixbuf)
952	g_object_unref (pixbuf);	905	g_object_unref (pixbuf);
953	pixbuf = image;	906	pixbuf = image;
954	have_image = true;	907	bg_flags |= BG_IS_FROM_FILE;
955	return true;	908	ret = true;
956	}	909	}
957	# endif	910	# endif
		911
		912	if (ret)
958	}	913	{
		914	if (p)
		915	bg_set_geometry (p + 1);
		916	else
		917	bg_set_default_geometry ();
		918	}
959		919
960	return false;	920	return ret;
961	}	921	}
962		922
963	# endif /* BG_IMAGE_FROM_FILE */	923	# endif /* BG_IMAGE_FROM_FILE */
964		924
965	# ifdef ENABLE_TRANSPARENCY	925	# ifdef ENABLE_TRANSPARENCY
966	bool	926	bool
967	bgPixmap_t::set_transparent ()	927	rxvt_term::bg_set_transparent ()
968	{	928	{
969	if (!(flags & isTransparent))	929	if (!(bg_flags & BG_IS_TRANSPARENT))
970	{	930	{
971	flags |= isTransparent;	931	bg_flags |= BG_IS_TRANSPARENT;
972	return true;	932	return true;
973	}	933	}
974		934
975	return false;	935	return false;
976	}	936	}
977		937
978	bool	938	bool
979	bgPixmap_t::set_blur_radius (const char *geom)	939	rxvt_term::bg_set_blur (const char *geom)
980	{	940	{
981	int changed = 0;	941	bool changed = false;
982	unsigned int hr, vr;	942	unsigned int hr, vr;
983	int junk;	943	int junk;
984	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);	944	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
985		945
986	if (!(geom_flags & WidthValue))	946	if (!(geom_flags & WidthValue))
…		…
991	min_it (hr, 128);	951	min_it (hr, 128);
992	min_it (vr, 128);	952	min_it (vr, 128);
993		953
994	if (h_blurRadius != hr)	954	if (h_blurRadius != hr)
995	{	955	{
996	++changed;	956	changed = true;
997	h_blurRadius = hr;	957	h_blurRadius = hr;
998	}	958	}
999		959
1000	if (v_blurRadius != vr)	960	if (v_blurRadius != vr)
1001	{	961	{
1002	++changed;	962	changed = true;
1003	v_blurRadius = vr;	963	v_blurRadius = vr;
1004	}	964	}
1005		965
1006	if (v_blurRadius == 0 && h_blurRadius == 0)	966	if (h_blurRadius == 0 || v_blurRadius == 0)
1007	flags &= ~blurNeeded;	967	bg_flags &= ~BG_NEEDS_BLUR;
1008	else	968	else
1009	flags |= blurNeeded;	969	bg_flags |= BG_NEEDS_BLUR;
1010		970
1011	#if XFT
1012	XFilters *filters = XRenderQueryFilters (target->dpy, target->display->root);
1013	if (filters)
1014	{
1015	for (int i = 0; i < filters->nfilter; i++)
1016	if (!strcmp (filters->filter[i], FilterConvolution))
1017	flags |= bgPixmap_t::blurServerSide;
1018
1019	XFree (filters);
1020	}
1021	#endif
1022
1023	return (changed > 0);	971	return changed;
1024	}	972	}
1025		973
1026	static inline unsigned long	974	void
1027	compute_tint_shade_flags (rxvt_color *tint, int shade)	975	rxvt_term::set_tint_shade_flags ()
1028	{	976	{
1029	unsigned long flags = 0;	977	rgba c;
1030	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1031	bool has_shade = shade != 100;	978	bool has_shade = shade != 100;
1032		979
1033	if (tint)	980	bg_flags &= ~BG_TINT_FLAGS;
		981
		982	if (bg_flags & BG_TINT_SET)
1034	{	983	{
1035	tint->get (c);	984	tint.get (c);
1036	# define IS_COMPONENT_WHOLESOME(cmp) ((cmp) <= 0x000700 || (cmp) >= 0x00f700)
1037	if (!has_shade && IS_COMPONENT_WHOLESOME (c.r)
1038	&& IS_COMPONENT_WHOLESOME (c.g)
1039	&& IS_COMPONENT_WHOLESOME (c.b))
1040	flags |= bgPixmap_t::tintWholesome;
1041	# undef IS_COMPONENT_WHOLESOME
1042	}
1043
1044	if (has_shade)	985	if (!has_shade
1045	flags |= bgPixmap_t::tintNeeded;	986	&& (c.r <= 0x00ff || c.r >= 0xff00)
1046	else if (tint)	987	&& (c.g <= 0x00ff || c.g >= 0xff00)
		988	&& (c.b <= 0x00ff || c.b >= 0xff00))
		989	bg_flags |= BG_TINT_BITAND;
1047	{	990	}
1048	if ((c.r > 0x000700 || c.g > 0x000700 || c.b > 0x000700)
1049	&& (c.r < 0x00f700 || c.g < 0x00f700 || c.b < 0x00f700))
1050	{
1051	flags |= bgPixmap_t::tintNeeded;
1052	}
1053	}
1054		991
1055	if (flags & bgPixmap_t::tintNeeded)	992	if (has_shade || (bg_flags & BG_TINT_SET))
1056	{	993	bg_flags |= BG_NEEDS_TINT;
1057	if (flags & bgPixmap_t::tintWholesome)
1058	flags |= bgPixmap_t::tintServerSide;
1059	else
1060	{
1061	#if XFT
1062	flags |= bgPixmap_t::tintServerSide;
1063	#endif
1064	}
1065	}
1066
1067	return flags;
1068	}	994	}
1069		995
1070	bool	996	bool
1071	bgPixmap_t::set_tint (rxvt_color &new_tint)	997	rxvt_term::bg_set_tint (rxvt_color &new_tint)
1072	{	998	{
1073	if (!(flags & tintSet) || tint != new_tint)	999	if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
1074	{	1000	{
1075	unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
1076	tint = new_tint;	1001	tint = new_tint;
1077	flags = (flags & ~tintFlags) | new_flags | tintSet;	1002	bg_flags |= BG_TINT_SET;
		1003	set_tint_shade_flags ();
1078	return true;	1004	return true;
1079	}	1005	}
1080		1006
1081	return false;	1007	return false;
1082	}	1008	}
1083		1009
1084	bool	1010	bool
1085	bgPixmap_t::unset_tint ()
1086	{
1087	unsigned long new_flags = compute_tint_shade_flags (NULL, shade);
1088
1089	if (new_flags != (flags & tintFlags))
1090	{
1091	flags = (flags & ~tintFlags) | new_flags;
1092	return true;
1093	}
1094
1095	return false;
1096	}
1097
1098	bool
1099	bgPixmap_t::set_shade (const char *shade_str)	1011	rxvt_term::bg_set_shade (const char *shade_str)
1100	{	1012	{
1101	int new_shade = (shade_str) ? atoi (shade_str) : 100;	1013	int new_shade = atoi (shade_str);
1102		1014
1103	clamp_it (new_shade, -100, 200);	1015	clamp_it (new_shade, -100, 200);
1104	if (new_shade < 0)	1016	if (new_shade < 0)
1105	new_shade = 200 - (100 + new_shade);	1017	new_shade = 200 - (100 + new_shade);
1106		1018
1107	if (new_shade != shade)	1019	if (new_shade != shade)
1108	{	1020	{
1109	unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
1110	shade = new_shade;	1021	shade = new_shade;
1111	flags = (flags & (~tintFlags | tintSet)) | new_flags;	1022	set_tint_shade_flags ();
1112	return true;	1023	return true;
1113	}	1024	}
1114		1025
1115	return false;	1026	return false;
1116	}	1027	}
1117		1028
		1029	#if XRENDER
1118	static void	1030	static void
1119	get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params)	1031	get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params)
1120	{	1032	{
1121	double sigma = radius / 2.0;	1033	double sigma = radius / 2.0;
1122	double scale = sqrt (2.0 * M_PI) * sigma;	1034	double scale = sqrt (2.0 * M_PI) * sigma;
1123	double sum = 0.0;	1035	double sum = 0.0;
1124		1036
1125	for (int i = 0; i < width; i++)	1037	for (int i = 0; i < width; i++)
1126	{	1038	{
1127	double x = i - width / 2;	1039	double x = i - width / 2;
1128	kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;	1040	kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;
1129	sum += kernel[i];	1041	sum += kernel[i];
1130	}	1042	}
1131		1043
1132	params[0] = XDoubleToFixed (width);	1044	params[0] = XDoubleToFixed (width);
1133	params[1] = XDoubleToFixed (1);	1045	params[1] = XDoubleToFixed (1);
1134		1046
1135	for (int i = 0; i < width; i++)	1047	for (int i = 0; i < width; i++)
1136	params[i+2] = XDoubleToFixed (kernel[i] / sum);	1048	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1137	}	1049	}
		1050	#endif
1138		1051
1139	bool	1052	bool
1140	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)
1141	{	1054	{
1142	bool ret = false;	1055	bool ret = false;
1143	#if XFT	1056	#if XRENDER
		1057	if (!(bg_flags & BG_HAS_RENDER_CONV))
		1058	return false;
		1059
1144	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	1060	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1145	double *kernel = (double *)malloc (size * sizeof (double));	1061	double *kernel = (double *)malloc (size * sizeof (double));
1146	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));	1062	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1147		1063
1148	Display *dpy = target->dpy;
1149	XRenderPictureAttributes pa;	1064	XRenderPictureAttributes pa;
1150	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, target->visual);	1065	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1151		1066
		1067	pa.repeat = RepeatPad;
1152	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1068	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
1153	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1069	Picture dst = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
1154		1070
1155	if (kernel && params && src && dst)	1071	if (kernel && params)
1156	{	1072	{
1157	if (h_blurRadius)
1158	{
1159	size = h_blurRadius * 2 + 1;	1073	size = h_blurRadius * 2 + 1;
1160	get_gaussian_kernel (h_blurRadius, size, kernel, params);	1074	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1161		1075
1162	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1076	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1163	XRenderComposite (dpy,	1077	XRenderComposite (dpy,
1164	PictOpSrc,	1078	PictOpSrc,
1165	src,	1079	src,
1166	None,	1080	None,
1167	dst,	1081	dst,
1168	0, 0,	1082	0, 0,
1169	0, 0,	1083	0, 0,
1170	0, 0,	1084	0, 0,
1171	width, height);	1085	width, height);
1172	}
1173		1086
1174	if (v_blurRadius)
1175	{
1176	size = v_blurRadius * 2 + 1;	1087	size = v_blurRadius * 2 + 1;
1177	get_gaussian_kernel (v_blurRadius, size, kernel, params);	1088	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1178	swap (params[0], params[1]);	1089	::swap (params[0], params[1]);
1179		1090
1180	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1091	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1181	XRenderComposite (dpy,	1092	XRenderComposite (dpy,
1182	PictOpSrc,	1093	PictOpSrc,
1183	src,	1094	src,
1184	None,	1095	None,
1185	dst,	1096	dst,
1186	0, 0,	1097	0, 0,
1187	0, 0,	1098	0, 0,
1188	0, 0,	1099	0, 0,
1189	width, height);	1100	width, height);
1190	}
1191		1101
1192	ret = true;	1102	ret = true;
1193	}	1103	}
1194		1104
1195	free (kernel);	1105	free (kernel);
…		…
1199	#endif	1109	#endif
1200	return ret;	1110	return ret;
1201	}	1111	}
1202		1112
1203	bool	1113	bool
1204	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)
1205	{	1115	{
1206	Display *dpy = target->dpy;
1207	bool ret = false;	1116	bool ret = false;
1208		1117
1209	if (flags & tintWholesome)	1118	if (bg_flags & BG_TINT_BITAND)
1210	{	1119	{
1211	XGCValues gcv;	1120	XGCValues gcv;
1212	GC gc;	1121	GC gc;
1213		1122
1214	/* In this case we can tint image server-side getting significant	1123	/* In this case we can tint image server-side getting significant
…		…
1223	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	1132	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1224	ret = true;	1133	ret = true;
1225	XFreeGC (dpy, gc);	1134	XFreeGC (dpy, gc);
1226	}	1135	}
1227	}	1136	}
1228	else	1137	# if XRENDER
		1138	else if (bg_flags & BG_HAS_RENDER)
1229	{	1139	{
1230	# if XFT
1231	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	1140	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1232		1141
1233	if (flags & tintSet)	1142	if (bg_flags & BG_TINT_SET)
1234	tint.get (c);	1143	tint.get (c);
1235		1144
1236	if (shade <= 100)	1145	if (shade <= 100)
1237	{	1146	{
1238	c.r = (c.r * shade) / 100;	1147	c.r = c.r * shade / 100;
1239	c.g = (c.g * shade) / 100;	1148	c.g = c.g * shade / 100;
1240	c.b = (c.b * shade) / 100;	1149	c.b = c.b * shade / 100;
1241	}	1150	}
1242	else	1151	else
1243	{	1152	{
1244	c.r = ((0xffff - c.r) * (200 - shade)) / 100;	1153	c.r = c.r * (200 - shade) / 100;
1245	c.g = ((0xffff - c.g) * (200 - shade)) / 100;	1154	c.g = c.g * (200 - shade) / 100;
1246	c.b = ((0xffff - c.b) * (200 - shade)) / 100;	1155	c.b = c.b * (200 - shade) / 100;
1247	}	1156	}
1248		1157
1249	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1250	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1158	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1251	XRenderPictureAttributes pa;
1252		1159
1253	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1160	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1254		1161
1255	pa.repeat = True;	1162	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1256		1163
1257	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	1164	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1258	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1259	XFreePixmap (dpy, overlay_pmap);
1260		1165
1261	pa.component_alpha = True;
1262	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1263	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
1264	XFreePixmap (dpy, mask_pmap);
1265
1266	if (mask_pic && overlay_pic && back_pic)
1267	{
1268	XRenderColor mask_c;	1166	XRenderColor mask_c;
1269		1167
1270	memset (&mask_c, (shade > 100) ? 0xFF : 0x0, sizeof (mask_c));
1271	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;
1272	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	1188	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1273		1189
1274	mask_c.alpha = 0;
1275	mask_c.red = 0xffff - c.r;
1276	mask_c.green = 0xffff - c.g;
1277	mask_c.blue = 0xffff - c.b;
1278	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1279	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
1280	ret = true;	1193	ret = true;
1281	}
1282		1194
1283	XRenderFreePicture (dpy, mask_pic);	1195	XRenderFreePicture (dpy, mask_pic);
1284	XRenderFreePicture (dpy, overlay_pic);	1196	XRenderFreePicture (dpy, overlay_pic);
1285	XRenderFreePicture (dpy, back_pic);	1197	XRenderFreePicture (dpy, back_pic);
1286	# if DO_TIMING_TEST	1198	}
1287	XSync (dpy, False);
1288	# endif
1289	# endif	1199	# endif
1290	}
1291		1200
1292	return ret;	1201	return ret;
1293	}	1202	}
1294		1203
1295	/* make_transparency_pixmap()	1204	/*
1296	* Builds a pixmap sized the same as terminal window, with depth same as the root window	1205	* Builds a pixmap of the same size as the terminal window that contains
1297	* that pixmap contains 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
1298	* our window.	1207	* our window.
1299	*/	1208	*/
1300	unsigned long	1209	unsigned long
1301	bgPixmap_t::make_transparency_pixmap ()	1210	rxvt_term::make_transparency_pixmap ()
1302	{	1211	{
1303	unsigned long result = 0;	1212	unsigned long result = 0;
1304
1305	if (target == NULL)
1306	return 0;
1307		1213
1308	/* 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
1309	* be always up-to-date, so let's use it :	1215	* be always up-to-date, so let's use it :
1310	*/	1216	*/
1311	Window root = target->display->root;
1312	int screen = target->display->screen;	1217	int screen = display->screen;
1313	Display *dpy = target->dpy;	1218	int root_depth = DefaultDepth (dpy, screen);
1314	int root_width = DisplayWidth (dpy, screen);	1219	int root_width = DisplayWidth (dpy, screen);
1315	int root_height = DisplayHeight (dpy, screen);	1220	int root_height = DisplayHeight (dpy, screen);
1316	unsigned int root_pmap_width, root_pmap_height;	1221	unsigned int root_pmap_width, root_pmap_height;
1317	int window_width = target->szHint.width;	1222	int window_width = szHint.width;
1318	int window_height = target->szHint.height;	1223	int window_height = szHint.height;
1319	int sx, sy;	1224	int sx, sy;
1320	XGCValues gcv;	1225	XGCValues gcv;
1321	GC gc;	1226	GC gc;
1322		1227
1323	TIMING_TEST_START (tp);	1228	sx = target_x;
1324	target->get_window_origin (sx, sy);	1229	sy = target_y;
1325		1230
1326	/* 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 : */
1327	if (sx + window_width <= 0 || sy + window_height <= 0	1232	if (sx + window_width <= 0 || sy + window_height <= 0
1328	|| sx >= root_width || sy >= root_height)	1233	|| sx >= root_width || sy >= root_height)
1329	return 0;	1234	return 0;
1330		1235
		1236	// validate root pixmap and get its size
1331	if (root_pixmap != None)	1237	if (root_pixmap != None)
1332	{	1238	{
1333	/* we want to validate the pixmap and get its size at the same time : */	1239	Window wdummy;
1334	int junk;	1240	int idummy;
1335	unsigned int ujunk;	1241	unsigned int udummy;
1336	/* root pixmap may be bad - allow a error */	1242
1337	target->allowedxerror = -1;	1243	allowedxerror = -1;
1338		1244
1339	if (!XGetGeometry (dpy, root_pixmap, &root, &junk, &junk, &root_pmap_width, &root_pmap_height, &ujunk, &ujunk))	1245	if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))
1340	root_pixmap = None;	1246	root_pixmap = None;
1341		1247
1342	target->allowedxerror = 0;	1248	allowedxerror = 0;
		1249	}
		1250
		1251	Pixmap recoded_root_pmap = root_pixmap;
		1252
		1253	if (root_pixmap != None && root_depth != depth)
1343	}	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);
1344		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
1345	if (root_pixmap == None)	1276	if (recoded_root_pmap == None)
1346	return 0;	1277	return 0;
1347		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);
1348	Pixmap tiled_root_pmap = XCreatePixmap (dpy, root, window_width, window_height, root_depth);	1285	bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
1349		1286	bg_pmap_width = window_width;
1350	if (tiled_root_pmap == None) /* something really bad happened - abort */	1287	bg_pmap_height = window_height;
1351	return 0;	1288	}
1352		1289
1353	/* straightforward pixmap copy */	1290	/* straightforward pixmap copy */
		1291	while (sx < 0) sx += root_pmap_width;
		1292	while (sy < 0) sy += root_pmap_height;
		1293
1354	gcv.tile = root_pixmap;	1294	gcv.tile = recoded_root_pmap;
1355	gcv.fill_style = FillTiled;	1295	gcv.fill_style = FillTiled;
1356
1357	while (sx < 0) sx += (int)root_width;
1358	while (sy < 0) sy += (int)root_height;
1359
1360	gcv.ts_x_origin = -sx;	1296	gcv.ts_x_origin = -sx;
1361	gcv.ts_y_origin = -sy;	1297	gcv.ts_y_origin = -sy;
1362	gc = XCreateGC (dpy, root, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	1298	gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1363		1299
1364	if (gc)	1300	if (gc)
1365	{	1301	{
1366	XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);	1302	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1367	result |= transpPmapTiled;	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
1368	XFreeGC (dpy, gc);	1333	XFreeGC (dpy, gc);
1369	}	1334	}
1370	TIMING_TEST_PRINT_RESULT (tp);
1371		1335
1372	if (tiled_root_pmap != None)	1336	if (recoded_root_pmap != root_pixmap)
1373	{	1337	XFreePixmap (dpy, recoded_root_pmap);
1374	if (!need_client_side_rendering ())
1375	{
1376	if (flags & (blurNeeded | blurServerSide))
1377	{
1378	if (blur_pixmap (tiled_root_pmap, DefaultVisual (dpy, target->display->screen), window_width, window_height))
1379	result |= transpPmapBlurred;
1380	}
1381	if (flags & (tintNeeded | tintServerSide))
1382	{
1383	if (tint_pixmap (tiled_root_pmap, DefaultVisual (dpy, target->display->screen), window_width, window_height))
1384	result |= transpPmapTinted;
1385	}
1386	} /* server side rendering completed */
1387
1388	if (pixmap)
1389	XFreePixmap (dpy, pixmap);
1390
1391	pixmap = tiled_root_pmap;
1392	pmap_width = window_width;
1393	pmap_height = window_height;
1394	pmap_depth = root_depth;
1395	}
1396
1397	TIMING_TEST_PRINT_RESULT (tp);
1398		1338
1399	return result;	1339	return result;
1400	}	1340	}
1401		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;
		1350	}
		1351	# endif /* ENABLE_TRANSPARENCY */
		1352
1402	bool	1353	bool
1403	bgPixmap_t::set_root_pixmap ()	1354	rxvt_term::bg_render ()
1404	{	1355	{
1405	Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);	1356	unsigned long tr_flags = 0;
1406	if (new_root_pixmap == None)
1407	new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);
1408		1357
1409	if (new_root_pixmap != root_pixmap)	1358	bg_invalidate ();
1410	{	1359	# ifdef ENABLE_TRANSPARENCY
1411	root_pixmap = new_root_pixmap;	1360	if (bg_flags & BG_IS_TRANSPARENT)
1412	return true;
1413	}	1361	{
1414		1362	/* we need to re-generate transparency pixmap in that case ! */
		1363	tr_flags = make_transparency_pixmap ();
		1364	if (tr_flags == 0)
1415	return false;	1365	return false;
1416	}	1366	bg_flags |= BG_IS_VALID;
1417	# endif /* ENABLE_TRANSPARENCY */	1367	}
1418
1419	# ifndef HAVE_AFTERIMAGE
1420	static void ShadeXImage(rxvt_term *term, XImage *srcImage, int shade, int rm, int gm, int bm);
1421	# endif	1368	# endif
1422		1369
1423	bool	1370	# ifdef BG_IMAGE_FROM_FILE
1424	bgPixmap_t::render ()	1371	if ((bg_flags & BG_IS_FROM_FILE)
1425	{	1372	|| (tr_flags & BG_EFFECTS_FLAGS))
1426	unsigned long background_flags = 0;
1427
1428	if (target == NULL)
1429	return false;
1430
1431	TIMING_TEST_START (tp);
1432
1433	invalidate ();
1434	# ifdef ENABLE_TRANSPARENCY
1435	if (flags & isTransparent)
1436	{	1373	{
1437	/* we need to re-generate transparency pixmap in that case ! */	1374	if (render_image (tr_flags))
1438	background_flags = make_transparency_pixmap ();	1375	bg_flags |= BG_IS_VALID;
1439	if (background_flags == 0)
1440	return false;
1441	else if ((background_flags & transpTransformations) == (flags & transpTransformations)
1442	&& pmap_depth == target->depth)
1443	flags = flags & ~isInvalid;
1444	}	1376	}
1445	# endif	1377	# endif
1446		1378
1447	# ifdef BG_IMAGE_FROM_FILE	1379	if (!(bg_flags & BG_IS_VALID))
1448	if (have_image
1449	|| (background_flags & transpTransformations) != (flags & transpTransformations))
1450	{
1451	if (render_image (background_flags))
1452	flags = flags & ~isInvalid;
1453	}	1380	{
1454	# endif
1455
1456	XImage *result = NULL;
1457
1458	if (background_flags && (flags & isInvalid))
1459	{
1460	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1461	}
1462
1463	if (result)
1464	{
1465	# if !defined(HAVE_AFTERIMAGE) && !XFT
1466	/* our own client-side tinting */
1467	/* ATTENTION: We ASSUME that XFT will let us do all the tinting necessary server-side.
1468	This may need to be changed in need_client_side_rendering() logic is altered !!! */
1469	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1470	{
1471	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1472	if (flags & tintSet)
1473	tint.get (c);
1474	ShadeXImage (target, result, shade, c.r, c.g, c.b);
1475	}
1476	# endif
1477
1478	GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1479
1480	if (gc)
1481	{
1482	if (/*pmap_depth != target->depth &&*/ pixmap != None)
1483	{
1484	XFreePixmap (target->dpy, pixmap);
1485	pixmap = None;
1486	}
1487
1488	if (pixmap == None)
1489	{
1490	pixmap = XCreatePixmap (target->dpy, target->vt, result->width, result->height, target->depth);
1491	pmap_width = result->width;
1492	pmap_height = result->height;
1493	pmap_depth = target->depth;
1494	}
1495
1496	if (pmap_depth != result->depth)
1497	{
1498	/* Bad Match error will ensue ! stupid X !!!! */
1499	if (result->depth == 24 && pmap_depth == 32)
1500	result->depth = 32;
1501	else if (result->depth == 32 && pmap_depth == 24)
1502	result->depth = 24;
1503	else
1504	{
1505	/* TODO: implement image recoding */
1506	}
1507	}
1508
1509	if (pmap_depth == result->depth)
1510	XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1511
1512	XFreeGC (target->dpy, gc);
1513	flags = flags & ~isInvalid;
1514	}
1515
1516	XDestroyImage (result);
1517	}
1518
1519	if (flags & isInvalid)
1520	{
1521	if (pixmap != None)	1381	if (bg_pixmap != None)
1522	{	1382	{
1523	XFreePixmap (target->dpy, pixmap);	1383	XFreePixmap (dpy, bg_pixmap);
1524	pixmap = None;	1384	bg_pixmap = None;
1525	}	1385	}
1526	}	1386	}
1527		1387
1528	apply ();	1388	scr_recolour (false);
		1389	bg_flags |= BG_NEEDS_REFRESH;
1529		1390
1530	XSync (target->dpy, False);
1531	valid_since = ev::now ();	1391	bg_valid_since = ev::now ();
1532
1533	TIMING_TEST_PRINT_RESULT (tp);
1534		1392
1535	return true;	1393	return true;
1536	}	1394	}
1537		1395
1538	bool
1539	bgPixmap_t::set_target (rxvt_term *new_target)
1540	{
1541	if (new_target)
1542	if (target != new_target)
1543	{
1544	target = new_target;
1545	# ifdef ENABLE_TRANSPARENCY
1546	root_depth = DefaultDepthOfScreen (ScreenOfDisplay (target->dpy, target->display->screen));
1547	# endif
1548	return true;
1549	}
1550
1551	return false;
1552	}
1553
1554	void	1396	void
1555	bgPixmap_t::apply ()	1397	rxvt_term::bg_init ()
1556	{	1398	{
1557	if (target)
1558	{
1559	flags &= ~isVtOrigin;
1560
1561	if (pixmap != None)
1562	{
1563	/* set target's background to pixmap */
1564	# ifdef ENABLE_TRANSPARENCY	1399	#ifdef ENABLE_TRANSPARENCY
1565	if (flags & isTransparent)	1400	shade = 100;
1566	{
1567	XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
1568	XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
1569
1570	if (target->scrollBar.win)
1571	XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1572	}
1573	else
1574	# endif	1401	#endif
1575	{
1576	flags |= isVtOrigin;
1577	/* force old pixmap dereference in case it was transparent before :*/
1578	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1579	XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1580	/* do we also need to set scrollbar's background here ? */
1581		1402
1582	if (target->scrollBar.win)	1403	bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1583	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);	1404	#if XRENDER
1584	}	1405	int major, minor;
1585	}	1406	if (XRenderQueryVersion (dpy, &major, &minor))
1586	else	1407	bg_flags |= BG_HAS_RENDER;
1587	{	1408	XFilters *filters = XRenderQueryFilters (dpy, vt);
1588	/* set target background to a pixel */	1409	if (filters)
1589	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1590	XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
1591	/* do we also need to set scrollbar's background here ? */
1592	if (target->scrollBar.win)
1593	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1594	}
1595
1596	/* don't want Expose on the parent or vt. It is better to use
1597	scr_touch or we get a great deal of flicker otherwise: */
1598	XClearWindow (target->dpy, target->parent[0]);
1599
1600	if (target->scrollBar.state && target->scrollBar.win)
1601	{
1602	target->scrollBar.state = STATE_IDLE;
1603	target->scrollBar.show (0);
1604	}
1605
1606	target->want_refresh = 1;
1607	flags |= hasChanged;
1608	}	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
1609	}	1418	}
1610		1419
1611	#endif /* HAVE_BG_PIXMAP */	1420	#endif /* HAVE_BG_PIXMAP */
1612		1421
1613	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XFT	1422	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1614	/* taken from aterm-0.4.2 */	1423	/* based on code from aterm-0.4.2 */
1615		1424
1616	typedef uint32_t RUINT32T;
1617
1618	static void	1425	static inline void
1619	ShadeXImage(rxvt_term *term, 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)
1620	{	1439	{
1621	int sh_r, sh_g, sh_b;	1440	int sh_r, sh_g, sh_b;
1622	RUINT32T mask_r, mask_g, mask_b;	1441	uint32_t mask_r, mask_g, mask_b;
1623	RUINT32T *lookup, *lookup_r, *lookup_g, *lookup_b;	1442	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1624	unsigned int lower_lim_r, lower_lim_g, lower_lim_b;	1443	unsigned short low;
1625	unsigned int upper_lim_r, upper_lim_g, upper_lim_b;	1444	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1626	int i;
1627		1445
1628	Visual *visual = term->visual;
1629
1630	if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return ;	1446	if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1631		1447
1632	/* for convenience */	1448	/* for convenience */
1633	mask_r = visual->red_mask;	1449	mask_r = visual->red_mask;
1634	mask_g = visual->green_mask;	1450	mask_g = visual->green_mask;
1635	mask_b = visual->blue_mask;	1451	mask_b = visual->blue_mask;
1636		1452
1637	/* boring lookup table pre-initialization */	1453	/* boring lookup table pre-initialization */
1638	switch (srcImage->bits_per_pixel) {	1454	switch (ximage->depth)
		1455	{
1639	case 15:	1456	case 15:
1640	if ((mask_r != 0x7c00) ||	1457	if ((mask_r != 0x7c00) ||
1641	(mask_g != 0x03e0) ||	1458	(mask_g != 0x03e0) ||
1642	(mask_b != 0x001f))	1459	(mask_b != 0x001f))
1643	return;	1460	return;
1644	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+32+32));	1461	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32));
1645	lookup_r = lookup;	1462	lookup_r = lookup;
1646	lookup_g = lookup+32;	1463	lookup_g = lookup+32;
1647	lookup_b = lookup+32+32;	1464	lookup_b = lookup+32+32;
1648	sh_r = 10;	1465	sh_r = 10;
1649	sh_g = 5;	1466	sh_g = 5;
1650	sh_b = 0;	1467	sh_b = 0;
1651	break;	1468	break;
1652	case 16:	1469	case 16:
1653	if ((mask_r != 0xf800) ||	1470	if ((mask_r != 0xf800) ||
1654	(mask_g != 0x07e0) ||	1471	(mask_g != 0x07e0) ||
1655	(mask_b != 0x001f))	1472	(mask_b != 0x001f))
1656	return;	1473	return;
1657	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+64+32));	1474	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+64+32));
1658	lookup_r = lookup;	1475	lookup_r = lookup;
1659	lookup_g = lookup+32;	1476	lookup_g = lookup+32;
1660	lookup_b = lookup+32+64;	1477	lookup_b = lookup+32+64;
1661	sh_r = 11;	1478	sh_r = 11;
1662	sh_g = 5;	1479	sh_g = 5;
1663	sh_b = 0;	1480	sh_b = 0;
1664	break;	1481	break;
1665	case 24:	1482	case 24:
1666	if ((mask_r != 0xff0000) ||	1483	if ((mask_r != 0xff0000) ||
1667	(mask_g != 0x00ff00) ||	1484	(mask_g != 0x00ff00) ||
1668	(mask_b != 0x0000ff))	1485	(mask_b != 0x0000ff))
1669	return;	1486	return;
1670	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));	1487	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1671	lookup_r = lookup;	1488	lookup_r = lookup;
1672	lookup_g = lookup+256;	1489	lookup_g = lookup+256;
1673	lookup_b = lookup+256+256;	1490	lookup_b = lookup+256+256;
1674	sh_r = 16;	1491	sh_r = 16;
1675	sh_g = 8;	1492	sh_g = 8;
1676	sh_b = 0;	1493	sh_b = 0;
1677	break;	1494	break;
1678	case 32:	1495	case 32:
1679	if ((mask_r != 0xff0000) ||	1496	if ((mask_r != 0xff0000) ||
1680	(mask_g != 0x00ff00) ||	1497	(mask_g != 0x00ff00) ||
1681	(mask_b != 0x0000ff))	1498	(mask_b != 0x0000ff))
1682	return;	1499	return;
1683	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));	1500	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1684	lookup_r = lookup;	1501	lookup_r = lookup;
1685	lookup_g = lookup+256;	1502	lookup_g = lookup+256;
1686	lookup_b = lookup+256+256;	1503	lookup_b = lookup+256+256;
1687	sh_r = 16;	1504	sh_r = 16;
1688	sh_g = 8;	1505	sh_g = 8;
1689	sh_b = 0;	1506	sh_b = 0;
1690	break;	1507	break;
1691	default:	1508	default:
1692	return; /* we do not support this color depth */	1509	return; /* we do not support this color depth */
1693	}	1510	}
		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);
1694		1516
1695	/* prepare limits for color transformation (each channel is handled separately) */	1517	/* prepare limits for color transformation (each channel is handled separately) */
1696	if (shade > 100) {	1518	if (shade > 100)
1697	shade = 200 - shade;
1698
1699	lower_lim_r = 65535-rm;
1700	lower_lim_g = 65535-gm;
1701	lower_lim_b = 65535-bm;
1702
1703	lower_lim_r = 65535-(unsigned int)(((RUINT32T)lower_lim_r)*((RUINT32T)shade)/100);
1704	lower_lim_g = 65535-(unsigned int)(((RUINT32T)lower_lim_g)*((RUINT32T)shade)/100);
1705	lower_lim_b = 65535-(unsigned int)(((RUINT32T)lower_lim_b)*((RUINT32T)shade)/100);
1706
1707	upper_lim_r = upper_lim_g = upper_lim_b = 65535;
1708	} else {
1709
1710	lower_lim_r = lower_lim_g = lower_lim_b = 0;
1711
1712	upper_lim_r = (unsigned int)((((RUINT32T)rm)*((RUINT32T)shade))/100);
1713	upper_lim_g = (unsigned int)((((RUINT32T)gm)*((RUINT32T)shade))/100);
1714	upper_lim_b = (unsigned int)((((RUINT32T)bm)*((RUINT32T)shade))/100);
1715	}
1716
1717	/* switch red and blue bytes if necessary, we need it for some weird XServers like XFree86 3.3.3.1 */
1718	if ((srcImage->bits_per_pixel == 24) && (mask_r >= 0xFF0000 ))
1719	{	1519	{
1720	unsigned int tmp;	1520	c.r = c.r * (200 - shade) / 100;
		1521	c.g = c.g * (200 - shade) / 100;
		1522	c.b = c.b * (200 - shade) / 100;
1721		1523
1722	tmp = lower_lim_r;	1524	low = 0xffff * (shade - 100) / 100;
1723	lower_lim_r = lower_lim_b;
1724	lower_lim_b = tmp;
1725
1726	tmp = upper_lim_r;
1727	upper_lim_r = upper_lim_b;
1728	upper_lim_b = tmp;
1729	}	1525	}
		1526	else
		1527	{
		1528	c.r = c.r * shade / 100;
		1529	c.g = c.g * shade / 100;
		1530	c.b = c.b * shade / 100;
		1531
		1532	low = 0;
		1533	}
1730		1534
1731	/* fill our lookup tables */	1535	/* fill our lookup tables */
1732	for (i = 0; i <= mask_r>>sh_r; i++)	1536	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1733	{	1537	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1734	RUINT32T tmp;	1538	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1735	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_r-lower_lim_r));
1736	tmp += ((RUINT32T)(mask_r>>sh_r))*((RUINT32T)lower_lim_r);
1737	lookup_r[i] = (tmp/65535)<<sh_r;
1738	}
1739	for (i = 0; i <= mask_g>>sh_g; i++)
1740	{
1741	RUINT32T tmp;
1742	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_g-lower_lim_g));
1743	tmp += ((RUINT32T)(mask_g>>sh_g))*((RUINT32T)lower_lim_g);
1744	lookup_g[i] = (tmp/65535)<<sh_g;
1745	}
1746	for (i = 0; i <= mask_b>>sh_b; i++)
1747	{
1748	RUINT32T tmp;
1749	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_b-lower_lim_b));
1750	tmp += ((RUINT32T)(mask_b>>sh_b))*((RUINT32T)lower_lim_b);
1751	lookup_b[i] = (tmp/65535)<<sh_b;
1752	}
1753		1539
1754	/* apply table to input image (replacing colors by newly calculated ones) */	1540	/* apply table to input image (replacing colors by newly calculated ones) */
1755	switch (srcImage->bits_per_pixel)	1541	if (ximage->bits_per_pixel == 32
		1542	&& (ximage->depth == 24 || ximage->depth == 32)
		1543	&& ximage->byte_order == host_byte_order)
1756	{	1544	{
1757	case 15:
1758	{
1759	unsigned short *p1, *pf, *p, *pl;	1545	uint32_t *p1, *pf, *p, *pl;
1760	p1 = (unsigned short *) srcImage->data;	1546	p1 = (uint32_t *) ximage->data;
1761	pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);	1547	pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
		1548
1762	while (p1 < pf)	1549	while (p1 < pf)
1763	{	1550	{
1764	p = p1;	1551	p = p1;
1765	pl = p1 + srcImage->width;	1552	pl = p1 + ximage->width;
1766	for (; p < pl; p++)	1553	for (; p < pl; p++)
1767	{	1554	{
1768	*p = lookup_r[(*p & 0x7c00)>>10] |
1769	lookup_g[(*p & 0x03e0)>> 5] |
1770	lookup_b[(*p & 0x001f)];
1771	}
1772	p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
1773	}
1774	break;
1775	}
1776	case 16:
1777	{
1778	unsigned short *p1, *pf, *p, *pl;
1779	p1 = (unsigned short *) srcImage->data;
1780	pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1781	while (p1 < pf)
1782	{
1783	p = p1;
1784	pl = p1 + srcImage->width;
1785	for (; p < pl; p++)
1786	{
1787	*p = lookup_r[(*p & 0xf800)>>11] |
1788	lookup_g[(*p & 0x07e0)>> 5] |
1789	lookup_b[(*p & 0x001f)];
1790	}
1791	p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
1792	}
1793	break;
1794	}
1795	case 24:
1796	{
1797	unsigned char *p1, *pf, *p, *pl;
1798	p1 = (unsigned char *) srcImage->data;
1799	pf = (unsigned char *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1800	while (p1 < pf)
1801	{
1802	p = p1;
1803	pl = p1 + srcImage->width * 3;
1804	for (; p < pl; p += 3)
1805	{
1806	p[0] = lookup_r[(p[0] & 0xff0000)>>16];
1807	p[1] = lookup_r[(p[1] & 0x00ff00)>> 8];
1808	p[2] = lookup_r[(p[2] & 0x0000ff)];
1809	}
1810	p1 = (unsigned char *) ((char *) p1 + srcImage->bytes_per_line);
1811	}
1812	break;
1813	}
1814	case 32:
1815	{
1816	RUINT32T *p1, *pf, *p, *pl;
1817	p1 = (RUINT32T *) srcImage->data;
1818	pf = (RUINT32T *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1819
1820	while (p1 < pf)
1821	{
1822	p = p1;
1823	pl = p1 + srcImage->width;
1824	for (; p < pl; p++)
1825	{
1826	*p = lookup_r[(*p & 0xff0000)>>16] |	1555	*p = lookup_r[(*p & 0xff0000) >> 16] |
1827	lookup_g[(*p & 0x00ff00)>> 8] |	1556	lookup_g[(*p & 0x00ff00) >> 8] |
1828	lookup_b[(*p & 0x0000ff)] |	1557	lookup_b[(*p & 0x0000ff)] |
1829	(*p & ~0xffffff);	1558	(*p & 0xff000000);
		1559	}
		1560	p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line);
		1561	}
		1562	}
		1563	else
		1564	{
		1565	for (int y = 0; y < ximage->height; y++)
		1566	for (int x = 0; x < ximage->width; x++)
		1567	{
		1568	unsigned long pixel = XGetPixel (ximage, x, y);
		1569	pixel = lookup_r[(pixel & mask_r) >> sh_r] |
		1570	lookup_g[(pixel & mask_g) >> sh_g] |
		1571	lookup_b[(pixel & mask_b) >> sh_b];
		1572	XPutPixel (ximage, x, y, pixel);
1830	}	1573	}
1831	p1 = (RUINT32T *) ((char *) p1 + srcImage->bytes_per_line);
1832	}	1574	}
1833	break;
1834	}
1835	}
1836		1575
1837	free (lookup);	1576	free (lookup);
1838	}	1577	}
1839	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1578	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */

Diff Legend

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