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.123 by sf-exg, Tue Nov 23 08:37:37 2010 UTC vs.
Revision 1.206 by sf-exg, Thu Apr 12 10:22:50 2012 UTC

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

Diff Legend

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