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

Diff Legend

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