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

Diff Legend

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