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

Diff Legend

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