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

Diff Legend

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