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

Diff Legend

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