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.127 by sf-exg, Thu Dec 2 11:02:16 2010 UTC vs.
Revision 1.196 by sf-exg, Tue Jan 10 18:50:14 2012 UTC

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

Diff Legend

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