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.123 by sf-exg, Tue Nov 23 08:37:37 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::render_image (unsigned long background_flags)	621	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
		622	int src_x, int src_y, int dst_x, int dst_y,
		623	unsigned int width, unsigned int height)
663	{	624	{
664	if (target == NULL)	625	XImage *ximage;
		626	char *data, *line;
		627	int bytes_per_pixel;
		628	int width_r, width_g, width_b;
		629	int sh_r, sh_g, sh_b;
		630	int rowstride;
		631	int channels;
		632	unsigned char *row;
		633
		634	if (visual->c_class != TrueColor)
665	return false;	635	return false;
666		636
		637	if (depth == 24 || depth == 32)
		638	bytes_per_pixel = 4;
		639	else if (depth == 15 || depth == 16)
		640	bytes_per_pixel = 2;
		641	else
		642	return false;
		643
		644	width_r = ecb_popcount32 (visual->red_mask);
		645	width_g = ecb_popcount32 (visual->green_mask);
		646	width_b = ecb_popcount32 (visual->blue_mask);
		647
		648	if (width_r > 8 || width_g > 8 || width_b > 8)
		649	return false;
		650
		651	sh_r = ecb_ctz32 (visual->red_mask);
		652	sh_g = ecb_ctz32 (visual->green_mask);
		653	sh_b = ecb_ctz32 (visual->blue_mask);
		654
		655	if (width > INT_MAX / height / bytes_per_pixel)
		656	return false;
		657
		658	data = (char *)malloc (width * height * bytes_per_pixel);
		659	if (!data)
		660	return false;
		661
		662	ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, data,
		663	width, height, bytes_per_pixel * 8, 0);
		664	if (!ximage)
		665	{
		666	free (data);
		667	return false;
		668	}
		669
		670	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
		671
		672	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
		673	channels = gdk_pixbuf_get_n_channels (pixbuf);
		674	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
		675	line = data;
		676
		677	for (int y = 0; y < height; y++)
		678	{
		679	for (int x = 0; x < width; x++)
		680	{
		681	unsigned char *pixel = row + x * channels;
		682	uint32_t value;
		683
		684	value = ((pixel[0] >> (8 - width_r)) << sh_r)
		685	| ((pixel[1] >> (8 - width_g)) << sh_g)
		686	| ((pixel[2] >> (8 - width_b)) << sh_b);
		687
		688	if (bytes_per_pixel == 4)
		689	((uint32_t *)line)[x] = value;
		690	else
		691	((uint16_t *)line)[x] = value;
		692	}
		693
		694	row += rowstride;
		695	line += ximage->bytes_per_line;
		696	}
		697
		698	XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
		699	XDestroyImage (ximage);
		700	return true;
		701	}
		702
		703	bool
		704	rxvt_term::render_image (unsigned long tr_flags)
		705	{
667	if (!pixbuf)	706	if (!pixbuf)
668	return false;	707	return false;
669		708
670	if (background_flags	709	if (tr_flags
671	&& !(flags & HAS_RENDER))	710	&& !(bg_flags & BG_HAS_RENDER))
672	return false;	711	return false;
673		712
674	GdkPixbuf *result;	713	GdkPixbuf *result;
675		714
676	int image_width = gdk_pixbuf_get_width (pixbuf);	715	int image_width = gdk_pixbuf_get_width (pixbuf);
677	int image_height = gdk_pixbuf_get_height (pixbuf);	716	int image_height = gdk_pixbuf_get_height (pixbuf);
678		717
679	int target_width = target->szHint.width;	718	int target_width = szHint.width;
680	int target_height = target->szHint.height;	719	int target_height = szHint.height;
681	int new_pmap_width = target_width;	720	int new_pmap_width = target_width;
682	int new_pmap_height = target_height;	721	int new_pmap_height = target_height;
683		722
684	int x = 0;	723	int x = 0;
685	int y = 0;	724	int y = 0;
686	int w = 0;	725	int w = 0;
687	int h = 0;	726	int h = 0;
688		727
689	get_image_geometry (image_width, image_height, w, h, x, y);	728	get_image_geometry (image_width, image_height, w, h, x, y);
690		729
691	if (!(flags & rootAlign)	730	if (!(bg_flags & BG_ROOT_ALIGN)
692	&& (x >= target_width	731	&& (x >= target_width
693	|| y >= target_height	732	|| y >= target_height
694	|| (x + w <= 0)	733	|| x + w <= 0
695	|| (y + h <= 0)))	734	|| y + h <= 0))
696	return false;	735	return false;
697		736
698	result = pixbuf;	737	result = pixbuf;
699		738
700	if ((w != image_width)	739	if (w != image_width
701	|| (h != image_height))	740	|| h != image_height)
702	{	741	{
703	result = gdk_pixbuf_scale_simple (pixbuf,	742	result = gdk_pixbuf_scale_simple (pixbuf,
704	w, h,	743	w, h,
705	GDK_INTERP_BILINEAR);	744	GDK_INTERP_BILINEAR);
706	}	745	}
707		746
		747	if (!result)
		748	return false;
		749
708	bool ret = false;	750	bool ret = false;
709		751
710	if (result)
711	{
712	XGCValues gcv;	752	XGCValues gcv;
713	GC gc;	753	GC gc;
714	Pixmap root_pmap;	754	Pixmap root_pmap;
715		755
716	image_width = gdk_pixbuf_get_width (result);	756	image_width = gdk_pixbuf_get_width (result);
717	image_height = gdk_pixbuf_get_height (result);	757	image_height = gdk_pixbuf_get_height (result);
718		758
719	if (background_flags)	759	if (tr_flags)
720	{	760	{
721	root_pmap = pixmap;	761	root_pmap = bg_pixmap;
722	pixmap = None;	762	bg_pixmap = None;
		763	}
		764	else
		765	{
		766	if (bg_flags & BG_TILE)
723	}	767	{
724	else
725	{
726	if (h_scale == 0 || v_scale == 0)
727	{
728	new_pmap_width = min (image_width, target_width);	768	new_pmap_width = min (image_width, target_width);
729	new_pmap_height = min (image_height, target_height);	769	new_pmap_height = min (image_height, target_height);
730	}	770	}
731	}	771	}
732		772
733	if (pixmap == None	773	if (bg_pixmap == None
734	|| pmap_width != new_pmap_width	774	|| bg_pmap_width != new_pmap_width
735	|| pmap_height != new_pmap_height	775	|| bg_pmap_height != new_pmap_height)
736	|| pmap_depth != target->depth)	776	{
737	{
738	if (pixmap)	777	if (bg_pixmap)
739	XFreePixmap (target->dpy, pixmap);	778	XFreePixmap (dpy, bg_pixmap);
740	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);	779	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
741	pmap_width = new_pmap_width;	780	bg_pmap_width = new_pmap_width;
742	pmap_height = new_pmap_height;	781	bg_pmap_height = new_pmap_height;
743	pmap_depth = target->depth;	782	}
		783
		784	gcv.foreground = pix_colors[Color_bg];
		785	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
		786
		787	if (gc)
		788	{
		789	if (bg_flags & BG_TILE)
744	}	790	{
745
746	gcv.foreground = target->pix_colors[Color_bg];
747	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
748
749	if (h_scale == 0 || v_scale == 0)
750	{
751	Pixmap tile = XCreatePixmap (target->dpy, target->vt, image_width, image_height, target->depth);	791	Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);
752	gdk_pixbuf_xlib_render_to_drawable (result, tile, gc,	792	pixbuf_to_pixmap (result, tile, gc,
753	0, 0,	793	0, 0,
754	0, 0,	794	0, 0,
755	image_width, image_height,	795	image_width, image_height);
756	XLIB_RGB_DITHER_NONE,
757	0, 0);
758		796
759	gcv.tile = tile;	797	gcv.tile = tile;
760	gcv.fill_style = FillTiled;	798	gcv.fill_style = FillTiled;
761	gcv.ts_x_origin = x;	799	gcv.ts_x_origin = x;
762	gcv.ts_y_origin = y;	800	gcv.ts_y_origin = y;
763	XChangeGC (target->dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	801	XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
764		802
765	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	803	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
766	XFreePixmap (target->dpy, tile);	804	XFreePixmap (dpy, tile);
767	}	805	}
768	else	806	else
769	{	807	{
770	int src_x, src_y, dst_x, dst_y;	808	int src_x, src_y, dst_x, dst_y;
771	int dst_width, dst_height;	809	int dst_width, dst_height;
…		…
774	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);	812	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
775		813
776	if (dst_x > 0 || dst_y > 0	814	if (dst_x > 0 || dst_y > 0
777	|| dst_x + dst_width < new_pmap_width	815	|| dst_x + dst_width < new_pmap_width
778	|| dst_y + dst_height < new_pmap_height)	816	|| dst_y + dst_height < new_pmap_height)
779	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	817	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
780		818
781	if (dst_x < new_pmap_width && dst_y < new_pmap_height)	819	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
782	gdk_pixbuf_xlib_render_to_drawable (result, pixmap, gc,	820	pixbuf_to_pixmap (result, bg_pixmap, gc,
783	src_x, src_y,	821	src_x, src_y,
784	dst_x, dst_y,	822	dst_x, dst_y,
785	dst_width, dst_height,	823	dst_width, dst_height);
786	XLIB_RGB_DITHER_NONE,
787	0, 0);
788	}	824	}
789		825
790	#if XRENDER	826	#if XRENDER
791	if (background_flags)	827	if (tr_flags)
792	{	828	{
793	Display *dpy = target->dpy;
794	XRenderPictureAttributes pa;
795
796	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, target->visual);	829	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		830
797	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	831	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
798		832
799	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);
800	Picture dst = XRenderCreatePicture (dpy, pixmap, dst_format, 0, &pa);	833	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
801		834
802	pa.repeat = True;	835	Picture mask = create_xrender_mask (dpy, vt, False, False);
803	Pixmap mask_pmap = XCreatePixmap (dpy, target->vt, 1, 1, 8);
804	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
805	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
806	XFreePixmap (dpy, mask_pmap);
807		836
808	if (src && dst && mask)
809	{
810	XRenderColor mask_c;	837	XRenderColor mask_c;
811		838
812	mask_c.alpha = 0x8000;	839	mask_c.alpha = 0x8000;
813	mask_c.red = 0;	840	mask_c.red =
814	mask_c.green = 0;	841	mask_c.green =
815	mask_c.blue = 0;	842	mask_c.blue = 0;
816	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	843	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		844
817	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	845	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
818	}
819		846
820	XRenderFreePicture (dpy, src);	847	XRenderFreePicture (dpy, src);
821	XRenderFreePicture (dpy, dst);	848	XRenderFreePicture (dpy, dst);
822	XRenderFreePicture (dpy, mask);	849	XRenderFreePicture (dpy, mask);
823
824	XFreePixmap (dpy, root_pmap);
825	}	850	}
826	#endif	851	#endif
827		852
828	if (result != pixbuf)
829	g_object_unref (result);
830
831	XFreeGC (target->dpy, gc);	853	XFreeGC (dpy, gc);
832		854
833	ret = true;	855	ret = true;
834	}	856	}
835		857
		858	if (result != pixbuf)
		859	g_object_unref (result);
		860
		861	if (tr_flags)
		862	XFreePixmap (dpy, root_pmap);
		863
836	return ret;	864	return ret;
837	}	865	}
838	# endif /* HAVE_PIXBUF */	866	# endif /* HAVE_PIXBUF */
839		867
840	bool	868	bool
841	bgPixmap_t::set_file (const char *file)	869	rxvt_term::bg_set_file (const char *file)
842	{	870	{
843	if (!file || !*file)	871	if (!file || !*file)
844	return false;	872	return false;
845		873
		874	bool ret = false;
846	if (const char *p = strchr (file, ';'))	875	const char *p = strchr (file, ';');
		876
		877	if (p)
847	{	878	{
848	size_t len = p - file;	879	size_t len = p - file;
849	char *f = rxvt_temp_buf<char> (len + 1);	880	char *f = rxvt_temp_buf<char> (len + 1);
850	memcpy (f, file, len);	881	memcpy (f, file, len);
851	f[len] = '\0';	882	f[len] = '\0';
852	file = f;	883	file = f;
853	}	884	}
854		885
855	# ifdef HAVE_AFTERIMAGE	886	# ifdef HAVE_AFTERIMAGE
856	if (!target->asimman)	887	if (!asimman)
857	target->asimman = create_generic_imageman (target->rs[Rs_path]);	888	asimman = create_generic_imageman (rs[Rs_path]);
858	ASImage *image = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);	889	ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
859	if (image)	890	if (image)
860	{	891	{
861	if (original_asim)	892	if (original_asim)
862	safe_asimage_destroy (original_asim);	893	safe_asimage_destroy (original_asim);
863	original_asim = image;	894	original_asim = image;
864	have_image = true;	895	bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;
865	return true;	896	ret = true;
866	}	897	}
867	# endif	898	# endif
868		899
869	# ifdef HAVE_PIXBUF	900	# ifdef HAVE_PIXBUF
870	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	901	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
871	if (image)	902	if (image)
872	{	903	{
873	if (pixbuf)	904	if (pixbuf)
874	g_object_unref (pixbuf);	905	g_object_unref (pixbuf);
875	pixbuf = image;	906	pixbuf = image;
876	have_image = true;	907	bg_flags |= BG_IS_FROM_FILE;
877	return true;	908	ret = true;
878	}	909	}
879	# endif	910	# endif
880		911
		912	if (ret)
		913	{
		914	if (p)
		915	bg_set_geometry (p + 1);
		916	else
		917	bg_set_default_geometry ();
		918	}
		919
881	return false;	920	return ret;
882	}	921	}
883		922
884	# endif /* BG_IMAGE_FROM_FILE */	923	# endif /* BG_IMAGE_FROM_FILE */
885		924
886	# ifdef ENABLE_TRANSPARENCY	925	# ifdef ENABLE_TRANSPARENCY
887	bool	926	bool
888	bgPixmap_t::set_transparent ()	927	rxvt_term::bg_set_transparent ()
889	{	928	{
890	if (!(flags & isTransparent))	929	if (!(bg_flags & BG_IS_TRANSPARENT))
891	{	930	{
892	flags |= isTransparent;	931	bg_flags |= BG_IS_TRANSPARENT;
893	return true;	932	return true;
894	}	933	}
895		934
896	return false;	935	return false;
897	}	936	}
898		937
899	bool	938	bool
900	bgPixmap_t::set_blur_radius (const char *geom)	939	rxvt_term::bg_set_blur (const char *geom)
901	{	940	{
902	bool changed = false;	941	bool changed = false;
903	unsigned int hr, vr;	942	unsigned int hr, vr;
904	int junk;	943	int junk;
905	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);	944	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
…		…
922	{	961	{
923	changed = true;	962	changed = true;
924	v_blurRadius = vr;	963	v_blurRadius = vr;
925	}	964	}
926		965
927	if (v_blurRadius == 0 && h_blurRadius == 0)	966	if (h_blurRadius == 0 || v_blurRadius == 0)
928	flags &= ~blurNeeded;	967	bg_flags &= ~BG_NEEDS_BLUR;
929	else	968	else
930	flags |= blurNeeded;	969	bg_flags |= BG_NEEDS_BLUR;
931		970
932	return changed;	971	return changed;
933	}	972	}
934		973
935	static inline unsigned long	974	void
936	compute_tint_shade_flags (rxvt_color *tint, int shade)	975	rxvt_term::set_tint_shade_flags ()
937	{	976	{
938	unsigned long flags = 0;	977	rgba c;
939	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
940	bool has_shade = shade != 100;	978	bool has_shade = shade != 100;
941		979
942	if (tint)	980	bg_flags &= ~BG_TINT_FLAGS;
		981
		982	if (bg_flags & BG_TINT_SET)
943	{	983	{
944	tint->get (c);	984	tint.get (c);
945	# define IS_COMPONENT_WHOLESOME(cmp) ((cmp) <= 0x000700 || (cmp) >= 0x00f700)
946	if (!has_shade	985	if (!has_shade
947	&& IS_COMPONENT_WHOLESOME (c.r)	986	&& (c.r <= 0x00ff || c.r >= 0xff00)
948	&& IS_COMPONENT_WHOLESOME (c.g)	987	&& (c.g <= 0x00ff || c.g >= 0xff00)
949	&& IS_COMPONENT_WHOLESOME (c.b))	988	&& (c.b <= 0x00ff || c.b >= 0xff00))
950	flags |= bgPixmap_t::tintWholesome;	989	bg_flags |= BG_TINT_BITAND;
951	# undef IS_COMPONENT_WHOLESOME
952	}	990	}
953		991
954	if (has_shade || tint)	992	if (has_shade || (bg_flags & BG_TINT_SET))
955	flags |= bgPixmap_t::tintNeeded;	993	bg_flags |= BG_NEEDS_TINT;
956
957	return flags;
958	}	994	}
959		995
960	bool	996	bool
961	bgPixmap_t::set_tint (rxvt_color &new_tint)	997	rxvt_term::bg_set_tint (rxvt_color &new_tint)
962	{	998	{
963	if (!(flags & tintSet) || tint != new_tint)	999	if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
964	{	1000	{
965	unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
966	tint = new_tint;	1001	tint = new_tint;
967	flags = (flags & ~tintFlags) | new_flags | tintSet;	1002	bg_flags |= BG_TINT_SET;
		1003	set_tint_shade_flags ();
968	return true;	1004	return true;
969	}	1005	}
970		1006
971	return false;	1007	return false;
972	}	1008	}
973		1009
974	bool	1010	bool
975	bgPixmap_t::unset_tint ()
976	{
977	unsigned long new_flags = compute_tint_shade_flags (NULL, shade);
978
979	if (new_flags != (flags & tintFlags))
980	{
981	flags = (flags & ~tintFlags) | new_flags;
982	return true;
983	}
984
985	return false;
986	}
987
988	bool
989	bgPixmap_t::set_shade (const char *shade_str)	1011	rxvt_term::bg_set_shade (const char *shade_str)
990	{	1012	{
991	int new_shade = (shade_str) ? atoi (shade_str) : 100;	1013	int new_shade = atoi (shade_str);
992		1014
993	clamp_it (new_shade, -100, 200);	1015	clamp_it (new_shade, -100, 200);
994	if (new_shade < 0)	1016	if (new_shade < 0)
995	new_shade = 200 - (100 + new_shade);	1017	new_shade = 200 - (100 + new_shade);
996		1018
997	if (new_shade != shade)	1019	if (new_shade != shade)
998	{	1020	{
999	unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
1000	shade = new_shade;	1021	shade = new_shade;
1001	flags = (flags & (~tintFlags | tintSet)) | new_flags;	1022	set_tint_shade_flags ();
1002	return true;	1023	return true;
1003	}	1024	}
1004		1025
1005	return false;	1026	return false;
1006	}	1027	}
…		…
1027	params[i+2] = XDoubleToFixed (kernel[i] / sum);	1048	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1028	}	1049	}
1029	#endif	1050	#endif
1030		1051
1031	bool	1052	bool
1032	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)
1033	{	1054	{
1034	bool ret = false;	1055	bool ret = false;
1035	#if XRENDER	1056	#if XRENDER
		1057	if (!(bg_flags & BG_HAS_RENDER_CONV))
		1058	return false;
		1059
1036	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	1060	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1037	double *kernel = (double *)malloc (size * sizeof (double));	1061	double *kernel = (double *)malloc (size * sizeof (double));
1038	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));	1062	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1039		1063
1040	Display *dpy = target->dpy;
1041	XRenderPictureAttributes pa;	1064	XRenderPictureAttributes pa;
1042	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1065	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1043		1066
		1067	pa.repeat = RepeatPad;
1044	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);
1045	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1070	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		1071	XFreePixmap (dpy, tmp);
1046		1072
1047	if (kernel && params && src && dst)	1073	if (kernel && params)
1048	{	1074	{
1049	if (h_blurRadius)
1050	{
1051	size = h_blurRadius * 2 + 1;	1075	size = h_blurRadius * 2 + 1;
1052	get_gaussian_kernel (h_blurRadius, size, kernel, params);	1076	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1053		1077
1054	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1078	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1055	XRenderComposite (dpy,	1079	XRenderComposite (dpy,
1056	PictOpSrc,	1080	PictOpSrc,
1057	src,	1081	src,
1058	None,	1082	None,
1059	dst,	1083	dst,
1060	0, 0,	1084	0, 0,
1061	0, 0,	1085	0, 0,
1062	0, 0,	1086	0, 0,
1063	width, height);	1087	width, height);
1064	}
1065		1088
1066	if (v_blurRadius)	1089	::swap (src, dst);
1067	{	1090
1068	size = v_blurRadius * 2 + 1;	1091	size = v_blurRadius * 2 + 1;
1069	get_gaussian_kernel (v_blurRadius, size, kernel, params);	1092	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1070	swap (params[0], params[1]);	1093	::swap (params[0], params[1]);
1071		1094
1072	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1095	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1073	XRenderComposite (dpy,	1096	XRenderComposite (dpy,
1074	PictOpSrc,	1097	PictOpSrc,
1075	src,	1098	src,
1076	None,	1099	None,
1077	dst,	1100	dst,
1078	0, 0,	1101	0, 0,
1079	0, 0,	1102	0, 0,
1080	0, 0,	1103	0, 0,
1081	width, height);	1104	width, height);
1082	}
1083		1105
1084	ret = true;	1106	ret = true;
1085	}	1107	}
1086		1108
1087	free (kernel);	1109	free (kernel);
…		…
1091	#endif	1113	#endif
1092	return ret;	1114	return ret;
1093	}	1115	}
1094		1116
1095	bool	1117	bool
1096	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)
1097	{	1119	{
1098	Display *dpy = target->dpy;
1099	bool ret = false;	1120	bool ret = false;
1100		1121
1101	if (flags & tintWholesome)	1122	if (bg_flags & BG_TINT_BITAND)
1102	{	1123	{
1103	XGCValues gcv;	1124	XGCValues gcv;
1104	GC gc;	1125	GC gc;
1105		1126
1106	/* In this case we can tint image server-side getting significant	1127	/* In this case we can tint image server-side getting significant
…		…
1115	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	1136	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1116	ret = true;	1137	ret = true;
1117	XFreeGC (dpy, gc);	1138	XFreeGC (dpy, gc);
1118	}	1139	}
1119	}	1140	}
1120	else
1121	{
1122	# if XRENDER	1141	# if XRENDER
		1142	else if (bg_flags & BG_HAS_RENDER)
		1143	{
1123	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	1144	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1124		1145
1125	if (flags & tintSet)	1146	if (bg_flags & BG_TINT_SET)
1126	tint.get (c);	1147	tint.get (c);
1127		1148
1128	if (shade <= 100)	1149	if (shade <= 100)
1129	{	1150	{
1130	c.r = (c.r * shade) / 100;	1151	c.r = c.r * shade / 100;
1131	c.g = (c.g * shade) / 100;	1152	c.g = c.g * shade / 100;
1132	c.b = (c.b * shade) / 100;	1153	c.b = c.b * shade / 100;
1133	}	1154	}
1134	else	1155	else
1135	{	1156	{
1136	c.r = ((0xffff - c.r) * (200 - shade)) / 100;	1157	c.r = c.r * (200 - shade) / 100;
1137	c.g = ((0xffff - c.g) * (200 - shade)) / 100;	1158	c.g = c.g * (200 - shade) / 100;
1138	c.b = ((0xffff - c.b) * (200 - shade)) / 100;	1159	c.b = c.b * (200 - shade) / 100;
1139	}	1160	}
1140		1161
1141	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1142	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1162	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1143	XRenderPictureAttributes pa;
1144		1163
1145	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1164	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1146		1165
1147	pa.repeat = True;	1166	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1148		1167
1149	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	1168	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1150	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1151	XFreePixmap (dpy, overlay_pmap);
1152		1169
1153	pa.component_alpha = True;
1154	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1155	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
1156	XFreePixmap (dpy, mask_pmap);
1157
1158	if (mask_pic && overlay_pic && back_pic)
1159	{
1160	XRenderColor mask_c;	1170	XRenderColor mask_c;
1161		1171
1162	mask_c.red = mask_c.green = mask_c.blue = shade > 100 ? 0xffff : 0;
1163	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;
1164	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	1192	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1165		1193
1166	mask_c.alpha = 0;
1167	mask_c.red = 0xffff - c.r;
1168	mask_c.green = 0xffff - c.g;
1169	mask_c.blue = 0xffff - c.b;
1170	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
1171	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);	1194	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
		1195	}
		1196
1172	ret = true;	1197	ret = true;
1173	}
1174		1198
1175	XRenderFreePicture (dpy, mask_pic);	1199	XRenderFreePicture (dpy, mask_pic);
1176	XRenderFreePicture (dpy, overlay_pic);	1200	XRenderFreePicture (dpy, overlay_pic);
1177	XRenderFreePicture (dpy, back_pic);	1201	XRenderFreePicture (dpy, back_pic);
		1202	}
1178	# endif	1203	# endif
1179	}
1180		1204
1181	return ret;	1205	return ret;
1182	}	1206	}
1183		1207
1184	/* make_transparency_pixmap()	1208	/*
1185	* 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
1186	* 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
1187	* our window.	1211	* our window.
1188	*/	1212	*/
1189	unsigned long	1213	unsigned long
1190	bgPixmap_t::make_transparency_pixmap ()	1214	rxvt_term::make_transparency_pixmap ()
1191	{	1215	{
1192	unsigned long result = 0;	1216	unsigned long result = 0;
1193
1194	if (target == NULL)
1195	return 0;
1196		1217
1197	/* 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
1198	* be always up-to-date, so let's use it :	1219	* be always up-to-date, so let's use it :
1199	*/	1220	*/
1200	int screen = target->display->screen;	1221	int screen = display->screen;
1201	Display *dpy = target->dpy;
1202	int root_depth = DefaultDepth (dpy, screen);	1222	int root_depth = DefaultDepth (dpy, screen);
1203	int root_width = DisplayWidth (dpy, screen);	1223	int root_width = DisplayWidth (dpy, screen);
1204	int root_height = DisplayHeight (dpy, screen);	1224	int root_height = DisplayHeight (dpy, screen);
1205	unsigned int root_pmap_width, root_pmap_height;	1225	unsigned int root_pmap_width, root_pmap_height;
1206	int window_width = target->szHint.width;	1226	int window_width = szHint.width;
1207	int window_height = target->szHint.height;	1227	int window_height = szHint.height;
1208	int sx, sy;	1228	int sx, sy;
1209	XGCValues gcv;	1229	XGCValues gcv;
1210	GC gc;	1230	GC gc;
1211		1231
1212	sx = target_x;	1232	sx = target_x;
…		…
1222	{	1242	{
1223	Window wdummy;	1243	Window wdummy;
1224	int idummy;	1244	int idummy;
1225	unsigned int udummy;	1245	unsigned int udummy;
1226		1246
1227	target->allowedxerror = -1;	1247	allowedxerror = -1;
1228		1248
1229	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))
1230	root_pixmap = None;	1250	root_pixmap = None;
1231		1251
1232	target->allowedxerror = 0;	1252	allowedxerror = 0;
1233	}	1253	}
1234		1254
1235	Pixmap recoded_root_pmap = root_pixmap;	1255	Pixmap recoded_root_pmap = root_pixmap;
1236		1256
1237	if (root_pixmap != None && root_depth != target->depth)	1257	if (root_pixmap != None && root_depth != depth)
1238	{	1258	{
1239	#if XRENDER	1259	#if XRENDER
1240	if (flags & HAS_RENDER)	1260	if (bg_flags & BG_HAS_RENDER)
1241	{	1261	{
1242	XRenderPictureAttributes pa;	1262	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1243		1263
1244	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	1264	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1245	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	1265	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1246		1266
1247	recoded_root_pmap = XCreatePixmap (dpy, target->vt, root_pmap_width, root_pmap_height, target->depth);
1248	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, target->visual);	1267	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1249	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	1268	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1250		1269
1251	if (src && dst)
1252	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);
1253	else
1254	{
1255	XFreePixmap (dpy, recoded_root_pmap);
1256	root_pixmap = None;
1257	}
1258		1271
1259	XRenderFreePicture (dpy, src);	1272	XRenderFreePicture (dpy, src);
1260	XRenderFreePicture (dpy, dst);	1273	XRenderFreePicture (dpy, dst);
1261	}	1274	}
1262	else	1275	else
1263	#endif	1276	#endif
1264	root_pixmap = None;	1277	recoded_root_pmap = None;
1265	}	1278	}
1266		1279
1267	if (root_pixmap == None)	1280	if (recoded_root_pmap == None)
1268	return 0;	1281	return 0;
1269		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);
1270	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);
1271		1290	bg_pmap_width = window_width;
1272	if (tiled_root_pmap == None) /* something really bad happened - abort */	1291	bg_pmap_height = window_height;
1273	return 0;	1292	}
1274		1293
1275	/* straightforward pixmap copy */	1294	/* straightforward pixmap copy */
1276	while (sx < 0) sx += (int)root_width;	1295	while (sx < 0) sx += root_pmap_width;
1277	while (sy < 0) sy += (int)root_height;	1296	while (sy < 0) sy += root_pmap_height;
1278		1297
1279	gcv.tile = recoded_root_pmap;	1298	gcv.tile = recoded_root_pmap;
1280	gcv.fill_style = FillTiled;	1299	gcv.fill_style = FillTiled;
1281	gcv.ts_x_origin = -sx;	1300	gcv.ts_x_origin = -sx;
1282	gcv.ts_y_origin = -sy;	1301	gcv.ts_y_origin = -sy;
1283	gc = XCreateGC (dpy, target->vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	1302	gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1284		1303
1285	if (gc)	1304	if (gc)
1286	{	1305	{
1287	XFillRectangle (dpy, tiled_root_pmap, gc, 0, 0, window_width, window_height);	1306	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1288	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
1289	XFreeGC (dpy, gc);	1337	XFreeGC (dpy, gc);
1290
1291	if (!need_client_side_rendering ())
1292	{
1293	if ((flags & blurNeeded)
1294	&& (flags & HAS_RENDER_CONV))
1295	{
1296	if (blur_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1297	result |= transpPmapBlurred;
1298	}
1299	if ((flags & tintNeeded)
1300	&& (flags & (tintWholesome | HAS_RENDER)))
1301	{
1302	if (tint_pixmap (tiled_root_pmap, target->visual, window_width, window_height))
1303	result |= transpPmapTinted;
1304	}
1305	} /* server side rendering completed */
1306
1307	if (pixmap)
1308	XFreePixmap (dpy, pixmap);
1309
1310	pixmap = tiled_root_pmap;
1311	pmap_width = window_width;
1312	pmap_height = window_height;
1313	pmap_depth = target->depth;
1314	}	1338	}
1315	else
1316	XFreePixmap (dpy, tiled_root_pmap);
1317		1339
1318	if (recoded_root_pmap != root_pixmap)	1340	if (recoded_root_pmap != root_pixmap)
1319	XFreePixmap (dpy, recoded_root_pmap);	1341	XFreePixmap (dpy, recoded_root_pmap);
1320		1342
1321	return result;	1343	return result;
1322	}	1344	}
1323		1345
1324	void	1346	void
1325	bgPixmap_t::set_root_pixmap ()	1347	rxvt_term::bg_set_root_pixmap ()
1326	{	1348	{
1327	Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);	1349	Pixmap new_root_pixmap = get_pixmap_property (xa[XA_XROOTPMAP_ID]);
1328	if (new_root_pixmap == None)	1350	if (new_root_pixmap == None)
1329	new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);	1351	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1330		1352
1331	root_pixmap = new_root_pixmap;	1353	root_pixmap = new_root_pixmap;
1332	}	1354	}
1333	# endif /* ENABLE_TRANSPARENCY */	1355	# endif /* ENABLE_TRANSPARENCY */
1334		1356
1335	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1357	bool
1336	static void ShadeXImage(Visual *visual, XImage *srcImage, int shade, const rgba &c);	1358	rxvt_term::bg_render ()
		1359	{
		1360	unsigned long tr_flags = 0;
		1361
		1362	bg_invalidate ();
		1363	# ifdef ENABLE_TRANSPARENCY
		1364	if (bg_flags & BG_IS_TRANSPARENT)
		1365	{
		1366	/* we need to re-generate transparency pixmap in that case ! */
		1367	tr_flags = make_transparency_pixmap ();
		1368	if (tr_flags == 0)
		1369	return false;
		1370	bg_flags |= BG_IS_VALID;
		1371	}
1337	# endif	1372	# endif
1338		1373
1339	bool	1374	# ifdef BG_IMAGE_FROM_FILE
1340	bgPixmap_t::render ()	1375	if ((bg_flags & BG_IS_FROM_FILE)
1341	{	1376	|| (tr_flags & BG_EFFECTS_FLAGS))
1342	unsigned long background_flags = 0;
1343
1344	if (target == NULL)
1345	return false;
1346
1347	invalidate ();
1348	# ifdef ENABLE_TRANSPARENCY
1349	if (flags & isTransparent)
1350	{	1377	{
1351	/* we need to re-generate transparency pixmap in that case ! */	1378	if (render_image (tr_flags))
1352	background_flags = make_transparency_pixmap ();	1379	bg_flags |= BG_IS_VALID;
1353	if (background_flags == 0)
1354	return false;
1355	else if ((background_flags & transpTransformations) == (flags & transpTransformations))
1356	flags &= ~isInvalid;
1357	}	1380	}
1358	# endif	1381	# endif
1359		1382
1360	# ifdef BG_IMAGE_FROM_FILE	1383	if (!(bg_flags & BG_IS_VALID))
1361	if (have_image
1362	|| (background_flags & transpTransformations) != (flags & transpTransformations))
1363	{
1364	if (render_image (background_flags))
1365	flags &= ~isInvalid;
1366	}	1384	{
1367	# endif
1368
1369	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1370	XImage *result = NULL;
1371
1372	if (background_flags && (flags & isInvalid))
1373	{
1374	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1375	}
1376
1377	if (result)
1378	{
1379	/* our own client-side tinting */
1380	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1381	{
1382	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1383	if (flags & tintSet)
1384	tint.get (c);
1385	ShadeXImage (DefaultVisual (target->dpy, target->display->screen), result, shade, c);
1386	}
1387
1388	GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
1389
1390	if (gc)
1391	{
1392	XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1393
1394	XFreeGC (target->dpy, gc);
1395	flags &= ~isInvalid;
1396	}
1397
1398	XDestroyImage (result);
1399	}
1400	# endif
1401
1402	if (flags & isInvalid)
1403	{
1404	if (pixmap != None)	1385	if (bg_pixmap != None)
1405	{	1386	{
1406	XFreePixmap (target->dpy, pixmap);	1387	XFreePixmap (dpy, bg_pixmap);
1407	pixmap = None;	1388	bg_pixmap = None;
1408	}	1389	}
1409	}	1390	}
1410		1391
1411	apply ();	1392	scr_recolour (false);
		1393	bg_flags |= BG_NEEDS_REFRESH;
1412		1394
1413	valid_since = ev::now ();	1395	bg_valid_since = ev::now ();
1414		1396
1415	return true;	1397	return true;
1416	}	1398	}
1417		1399
1418	void	1400	void
1419	bgPixmap_t::set_target (rxvt_term *new_target)	1401	rxvt_term::bg_init ()
1420	{	1402	{
1421	target = new_target;	1403	#ifdef ENABLE_TRANSPARENCY
		1404	shade = 100;
		1405	#endif
1422		1406
1423	flags &= ~(HAS_RENDER | HAS_RENDER_CONV);	1407	bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);
1424	#if XRENDER	1408	#if XRENDER
1425	int major, minor;	1409	int major, minor;
1426	if (XRenderQueryVersion (target->dpy, &major, &minor))	1410	if (XRenderQueryVersion (dpy, &major, &minor))
1427	flags |= HAS_RENDER;	1411	bg_flags |= BG_HAS_RENDER;
1428	XFilters *filters = XRenderQueryFilters (target->dpy, target->vt);	1412	XFilters *filters = XRenderQueryFilters (dpy, vt);
1429	if (filters)	1413	if (filters)
1430	{	1414	{
1431	for (int i = 0; i < filters->nfilter; i++)	1415	for (int i = 0; i < filters->nfilter; i++)
1432	if (!strcmp (filters->filter[i], FilterConvolution))	1416	if (!strcmp (filters->filter[i], FilterConvolution))
1433	flags |= HAS_RENDER_CONV;	1417	bg_flags |= BG_HAS_RENDER_CONV;
1434		1418
1435	XFree (filters);	1419	XFree (filters);
1436	}	1420	}
1437	#endif	1421	#endif
1438	}	1422	}
1439		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
1440	void	1441	void
1441	bgPixmap_t::apply ()	1442	rxvt_term::tint_ximage (Visual *visual, XImage *ximage)
1442	{
1443	if (target == NULL)
1444	return;
1445
1446	if (pixmap != None)
1447	{
1448	/* set target's background to pixmap */
1449	# ifdef ENABLE_TRANSPARENCY
1450	if (flags & isTransparent)
1451	{
1452	XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
1453	XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
1454
1455	if (target->scrollBar.win)
1456	XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1457	}
1458	else
1459	# endif
1460	{
1461	/* force old pixmap dereference in case it was transparent before :*/
1462	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1463	XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1464	/* do we also need to set scrollbar's background here ? */
1465
1466	if (target->scrollBar.win)
1467	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1468	}
1469	}
1470	else
1471	{
1472	/* set target background to a pixel */
1473	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1474	XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
1475	/* do we also need to set scrollbar's background here ? */
1476	if (target->scrollBar.win)
1477	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1478	}
1479
1480	/* don't want Expose on the parent or vt. It is better to use
1481	scr_touch or we get a great deal of flicker otherwise: */
1482	XClearWindow (target->dpy, target->parent[0]);
1483
1484	if (target->scrollBar.state && target->scrollBar.win)
1485	{
1486	target->scrollBar.state = STATE_IDLE;
1487	target->scrollBar.show (0);
1488	}
1489
1490	target->want_refresh = 1;
1491	flags |= hasChanged;
1492	}
1493
1494	#endif /* HAVE_BG_PIXMAP */
1495
1496	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1497	/* taken from aterm-0.4.2 */
1498
1499	static void
1500	ShadeXImage(Visual *visual, XImage *srcImage, int shade, const rgba &c)
1501	{	1443	{
1502	int sh_r, sh_g, sh_b;	1444	int sh_r, sh_g, sh_b;
1503	uint32_t mask_r, mask_g, mask_b;	1445	uint32_t mask_r, mask_g, mask_b;
1504	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;	1446	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1505	rgba low;	1447	unsigned short low;
1506	rgba high;
1507	int i;
1508	int host_byte_order = byteorder.big_endian () ? MSBFirst : LSBFirst;	1448	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1509		1449
1510	if (visual->c_class != TrueColor || srcImage->format != ZPixmap) return;	1450	if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1511		1451
1512	/* for convenience */	1452	/* for convenience */
1513	mask_r = visual->red_mask;	1453	mask_r = visual->red_mask;
1514	mask_g = visual->green_mask;	1454	mask_g = visual->green_mask;
1515	mask_b = visual->blue_mask;	1455	mask_b = visual->blue_mask;
1516		1456
1517	/* boring lookup table pre-initialization */	1457	/* boring lookup table pre-initialization */
1518	switch (srcImage->depth)	1458	switch (ximage->depth)
1519	{	1459	{
1520	case 15:	1460	case 15:
1521	if ((mask_r != 0x7c00) ||	1461	if ((mask_r != 0x7c00) ||
1522	(mask_g != 0x03e0) ||	1462	(mask_g != 0x03e0) ||
1523	(mask_b != 0x001f))	1463	(mask_b != 0x001f))
…		…
1571	break;	1511	break;
1572	default:	1512	default:
1573	return; /* we do not support this color depth */	1513	return; /* we do not support this color depth */
1574	}	1514	}
1575		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
1576	/* prepare limits for color transformation (each channel is handled separately) */	1521	/* prepare limits for color transformation (each channel is handled separately) */
1577	if (shade > 100)	1522	if (shade > 100)
1578	{	1523	{
1579	shade = 200 - shade;	1524	c.r = c.r * (200 - shade) / 100;
		1525	c.g = c.g * (200 - shade) / 100;
		1526	c.b = c.b * (200 - shade) / 100;
1580		1527
1581	high.r = (65535 - c.r) * shade / 100;	1528	low = 0xffff * (shade - 100) / 100;
1582	high.g = (65535 - c.g) * shade / 100;
1583	high.b = (65535 - c.b) * shade / 100;
1584
1585	low.r = 65535 - high.r;
1586	low.g = 65535 - high.g;
1587	low.b = 65535 - high.b;
1588	}	1529	}
1589	else	1530	else
1590	{	1531	{
1591	high.r = c.r * shade / 100;	1532	c.r = c.r * shade / 100;
1592	high.g = c.g * shade / 100;	1533	c.g = c.g * shade / 100;
1593	high.b = c.b * shade / 100;	1534	c.b = c.b * shade / 100;
1594		1535
1595	low.r = low.g = low.b = 0;	1536	low = 0;
1596	}	1537	}
1597		1538
1598	/* fill our lookup tables */	1539	/* fill our lookup tables */
1599	for (i = 0; i <= mask_r>>sh_r; i++)	1540	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1600	{	1541	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1601	uint32_t tmp;	1542	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1602	tmp = i * high.r;
1603	tmp += (mask_r>>sh_r) * low.r;
1604	lookup_r[i] = (tmp/65535)<<sh_r;
1605	}
1606	for (i = 0; i <= mask_g>>sh_g; i++)
1607	{
1608	uint32_t tmp;
1609	tmp = i * high.g;
1610	tmp += (mask_g>>sh_g) * low.g;
1611	lookup_g[i] = (tmp/65535)<<sh_g;
1612	}
1613	for (i = 0; i <= mask_b>>sh_b; i++)
1614	{
1615	uint32_t tmp;
1616	tmp = i * high.b;
1617	tmp += (mask_b>>sh_b) * low.b;
1618	lookup_b[i] = (tmp/65535)<<sh_b;
1619	}
1620		1543
1621	/* apply table to input image (replacing colors by newly calculated ones) */	1544	/* apply table to input image (replacing colors by newly calculated ones) */
1622	if (srcImage->bits_per_pixel == 32	1545	if (ximage->bits_per_pixel == 32
1623	&& (srcImage->depth == 24 || srcImage->depth == 32)	1546	&& (ximage->depth == 24 || ximage->depth == 32)
1624	&& srcImage->byte_order == host_byte_order)	1547	&& ximage->byte_order == host_byte_order)
1625	{	1548	{
1626	uint32_t *p1, *pf, *p, *pl;	1549	uint32_t *p1, *pf, *p, *pl;
1627	p1 = (uint32_t *) srcImage->data;	1550	p1 = (uint32_t *) ximage->data;
1628	pf = (uint32_t *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);	1551	pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1629		1552
1630	while (p1 < pf)	1553	while (p1 < pf)
1631	{	1554	{
1632	p = p1;	1555	p = p1;
1633	pl = p1 + srcImage->width;	1556	pl = p1 + ximage->width;
1634	for (; p < pl; p++)	1557	for (; p < pl; p++)
1635	{	1558	{
1636	*p = lookup_r[(*p & 0xff0000) >> 16] |	1559	*p = lookup_r[(*p & 0xff0000) >> 16] |
1637	lookup_g[(*p & 0x00ff00) >> 8] |	1560	lookup_g[(*p & 0x00ff00) >> 8] |
1638	lookup_b[(*p & 0x0000ff)] |	1561	lookup_b[(*p & 0x0000ff)] |
1639	(*p & 0xff000000);	1562	(*p & 0xff000000);
1640	}	1563	}
1641	p1 = (uint32_t *) ((char *) p1 + srcImage->bytes_per_line);	1564	p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line);
1642	}	1565	}
1643	}	1566	}
1644	else	1567	else
1645	{	1568	{
1646	for (int y = 0; y < srcImage->height; y++)	1569	for (int y = 0; y < ximage->height; y++)
1647	for (int x = 0; x < srcImage->width; x++)	1570	for (int x = 0; x < ximage->width; x++)
1648	{	1571	{
1649	unsigned long pixel = XGetPixel (srcImage, x, y);	1572	unsigned long pixel = XGetPixel (ximage, x, y);
1650	pixel = lookup_r[(pixel & mask_r) >> sh_r] |	1573	pixel = lookup_r[(pixel & mask_r) >> sh_r] |
1651	lookup_g[(pixel & mask_g) >> sh_g] |	1574	lookup_g[(pixel & mask_g) >> sh_g] |
1652	lookup_b[(pixel & mask_b) >> sh_b];	1575	lookup_b[(pixel & mask_b) >> sh_b];
1653	XPutPixel (srcImage, x, y, pixel);	1576	XPutPixel (ximage, x, y, pixel);
1654	}	1577	}
1655	}	1578	}
1656		1579
1657	free (lookup);	1580	free (lookup);
1658	}	1581	}

Diff Legend

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