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

Diff Legend

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