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.131 by sf-exg, Mon Jan 10 19:58:24 2011 UTC vs.
Revision 1.196 by sf-exg, Tue Jan 10 18:50:14 2012 UTC

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

Diff Legend

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