ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/rxvt-unicode/src/background.C

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

Diff Legend

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