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.120 by sf-exg, Thu Nov 18 17:29:25 2010 UTC vs.
Revision 1.217 by sf-exg, Sun May 20 16:34:42 2012 UTC

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

Diff Legend

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