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

Diff Legend

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