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

Diff Legend

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