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.5 by sasha, Tue Sep 18 22:01:36 2007 UTC vs.
Revision 1.57 by sf-exg, Fri Sep 3 22:43:22 2010 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) 1997 Carsten Haitzler <raster@zip.com.au>
7	* Copyright (c) 1997,1998 Oezguer Kesim <kesim@math.fu-berlin.de>
8	* Copyright (c) 1998-2001 Geoff Wing <gcw@pobox.com>
9	* Copyright (c) 2005-2006 Marc Lehmann <pcg@goof.com>	6	* Copyright (c) 2005-2008 Marc Lehmann <pcg@goof.com>
10	* Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>	7	* Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
11	*	8	*
12	* This program is free software; you can redistribute it and/or modify	9	* This program is free software; you can redistribute it and/or modify
13	* it under the terms of the GNU General Public License as published by	10	* it under the terms of the GNU General Public License as published by
14	* the Free Software Foundation; either version 2 of the License, or	11	* the Free Software Foundation; either version 2 of the License, or
…		…
28	#include "rxvt.h" /* NECESSARY */	25	#include "rxvt.h" /* NECESSARY */
29		26
30	#define DO_TIMING_TEST 0	27	#define DO_TIMING_TEST 0
31		28
32	#if DO_TIMING_TEST	29	#if DO_TIMING_TEST
		30	# include <sys/time.h>
33	#define TIMING_TEST_START(id) \	31	#define TIMING_TEST_START(id) \
34	struct timeval timing_test_##id##_stv;\	32	struct timeval timing_test_##id##_stv; \
35	gettimeofday (&timing_test_##id##_stv, NULL);	33	gettimeofday (&timing_test_##id##_stv, NULL);
36		34
37	#define TIMING_TEST_PRINT_RESULT(id) \	35	#define TIMING_TEST_PRINT_RESULT(id) \
38	do{ struct timeval tv;gettimeofday (&tv, NULL); tv.tv_sec -= (timing_test_##id##_stv).tv_sec;\	36	do { \
		37	struct timeval tv; \
		38	gettimeofday (&tv, NULL); \
		39	tv.tv_sec -= (timing_test_##id##_stv).tv_sec; \
39	fprintf (stderr, "%s: %s: %d: elapsed %ld usec\n", #id, __FILE__, __LINE__,\	40	fprintf (stderr, "%s: %s: %d: elapsed %ld usec\n", #id, __FILE__, __LINE__, \
40	tv.tv_sec * 1000000 + tv.tv_usec - (timing_test_##id##_stv).tv_usec);}while (0)	41	tv.tv_sec * 1000000 + tv.tv_usec - (timing_test_##id##_stv).tv_usec); \
		42	} while (0)
41		43
42	#else	44	#else
43	#define TIMING_TEST_START(id) do{}while (0)	45	#define TIMING_TEST_START(id) do {} while (0)
44	#define TIMING_TEST_PRINT_RESULT(id) do{}while (0)	46	#define TIMING_TEST_PRINT_RESULT(id) do {} while (0)
45	#endif	47	#endif
46		48
47	/*	49	/*
48	* Pixmap geometry string interpretation :	50	* Pixmap geometry string interpretation :
49	* Each geometry string contains zero or one scale/position	51	* Each geometry string contains zero or one scale/position
50	* adjustment and may optionally be followed by a colon and one or more	52	* adjustment and may optionally be followed by a colon and one or more
51	* colon-delimited pixmap operations.	53	* colon-delimited pixmap operations.
52	* The following table shows the valid geometry strings and their	54	* The following table shows the valid geometry strings and their
53	* affects on the background image :	55	* effects on the background image :
54	*	56	*
55	* WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.	57	* WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
56	* W and H are percentages of the terminal window size.	58	* W and H are percentages of the terminal window size.
57	* X and Y are also percentages; e.g., +50+50 centers	59	* X and Y are also percentages; e.g., +50+50 centers
58	* the image in the window.	60	* the image in the window.
59	* WxH+X Assumes Y == X	61	* WxH+X Assumes Y == X
60	* WxH Assumes Y == X == 50 (centers the image)	62	* WxH Assumes Y == X == 50 (centers the image)
61	* W+X+Y Assumes H == W	63	* W+X+Y Assumes H == W
62	* W+X Assumes H == W and Y == X	64	* W+X Assumes H == W and Y == X
63	* W Assumes H == W and Y == X == 50	65	* W Assumes H == W and Y == X == 50
64	*	66	*
65	* Adjusting position only :	67	* Adjusting position only :
66	* =+X+Y Set position to X% by Y% (absolute).	68	* =+X+Y Set position to X% by Y% (absolute).
67	* =+X Set position to X% by X%.	69	* =+X Set position to X% by X%.
68	* +X+Y Adjust position horizontally X% and vertically Y%	70	* +X+Y Adjust position horizontally X% and vertically Y%
69	* from current position (relative).	71	* from current position (relative).
70	* +X Adjust position horizontally X% and vertically X%	72	* +X Adjust position horizontally X% and vertically X%
71	* from current position.	73	* from current position.
72	*	74	*
73	* Adjusting scale only :	75	* Adjusting scale only :
74	* Wx0 Multiply horizontal scaling factor by W%	76	* Wx0 Multiply horizontal scaling factor by W%
75	* 0xH Multiply vertical scaling factor by H%	77	* 0xH Multiply vertical scaling factor by H%
76	* 0x0 No scaling (show image at normal size).	78	* 0x0 No scaling (show image at normal size).
77	*	79	*
78	* Pixmap Operations : (should be prepended by a colon)	80	* Pixmap Operations : (should be prepended by a colon)
79	* tile Tile image. Scaling/position modifiers above will affect	81	* tile Tile image. Scaling/position modifiers above will affect
80	* the tile size and origin.	82	* the tile size and origin.
81	* propscale When scaling, scale proportionally. That is, maintain the	83	* propscale When scaling, scale proportionally. That is, maintain the
82	* proper aspect ratio for the image. Any portion of the	84	* proper aspect ratio for the image. Any portion of the
83	* background not covered by the image is filled with the	85	* background not covered by the image is filled with the
84	* current background color.	86	* current background color.
85	* hscale Scale horizontally, tile vertically ?	87	* hscale Scale horizontally, tile vertically ?
86	* vscale Tile horizontally, scale vertically ?	88	* vscale Tile horizontally, scale vertically ?
87	* scale Scale both up and down	89	* scale Scale both up and down
88	* auto Same as 100x100+50+50	90	* auto Same as 100x100+50+50
89	*/	91	*/
90		92
91	#ifdef HAVE_BG_PIXMAP	93	#ifdef HAVE_BG_PIXMAP
92	bgPixmap_t::bgPixmap_t()	94	bgPixmap_t::bgPixmap_t ()
93	{	95	{
		96	// this is basically redundant as bgPixmap_t is only used in
		97	// zero_initialised-derived structs
94	#ifdef HAVE_AFTERIMAGE	98	#ifdef HAVE_AFTERIMAGE
95	original_asim = NULL;	99	original_asim = NULL;
96	#endif	100	#endif
		101	#ifdef HAVE_PIXBUF
		102	pixbuf = NULL;
		103	#endif
97	#ifdef BG_IMAGE_FROM_FILE	104	#ifdef BG_IMAGE_FROM_FILE
		105	have_image = false;
98	h_scale = v_scale = 0;	106	h_scale = v_scale = 0;
99	h_align = v_align = 0;	107	h_align = v_align = 0;
100	#endif	108	#endif
101	flags = 0;	109	flags = 0;
102	pixmap = None;	110	pixmap = None;
		111	valid_since = invalid_since = 0;
		112	target = 0;
103	}	113	}
104		114
		115	void
		116	bgPixmap_t::destroy ()
		117	{
		118	#ifdef HAVE_AFTERIMAGE
		119	if (original_asim)
		120	safe_asimage_destroy (original_asim);
		121	#endif
		122
		123	#ifdef HAVE_PIXBUF
		124	if (pixbuf)
		125	g_object_unref (pixbuf);
		126	#endif
		127
		128	if (pixmap && target)
		129	XFreePixmap (target->dpy, pixmap);
		130	}
105		131
106	bool	132	bool
107	bgPixmap_t::window_size_sensitive ()	133	bgPixmap_t::window_size_sensitive ()
108	{	134	{
109	# ifdef BG_IMAGE_FROM_FILE
110	# ifdef HAVE_AFTERIMAGE
111	if (original_asim != NULL)
112	# endif
113	{
114	if (h_scale != 0 || v_scale != 0
115	|| h_align != 0 || v_align != 0)
116	return true;
117	}
118	# endif
119	# ifdef ENABLE_TRANSPARENCY	135	# ifdef ENABLE_TRANSPARENCY
120	if (flags & isTransparent)	136	if (flags & isTransparent)
121	return true;	137	return true;
122	# endif	138	# endif
		139
		140	# ifdef BG_IMAGE_FROM_FILE
		141	if (have_image)
		142	{
		143	if (h_scale != 0 || v_scale != 0
		144	|| h_align != 0 || v_align != 0)
		145	return true;
		146	}
		147	# endif
		148
123	return false;	149	return false;
124	}	150	}
125		151
		152	bool
		153	bgPixmap_t::window_position_sensitive ()
		154	{
		155	# ifdef ENABLE_TRANSPARENCY
		156	if (flags & isTransparent)
		157	return true;
		158	# endif
		159
		160	# ifdef BG_IMAGE_FROM_FILE
		161	if (have_image)
		162	{
		163	if (h_align == rootAlign || v_align == rootAlign)
		164	return true;
		165	}
		166	# endif
		167
		168	return false;
		169	};
		170
126	bool bgPixmap_t::need_client_side_rendering ()	171	bool bgPixmap_t::need_client_side_rendering ()
127	{	172	{
128	# ifdef HAVE_AFTERIMAGE	173	# ifdef HAVE_AFTERIMAGE
129	if (original_asim != NULL)	174	if (original_asim)
130	return true;	175	return true;
131	# endif	176	# endif
132	# ifdef ENABLE_TRANSPARENCY	177	# ifdef ENABLE_TRANSPARENCY
133	if (flags & isTransparent)	178	if (flags & isTransparent)
134	{	179	{
		180	# ifdef HAVE_AFTERIMAGE // can't blur without libAI anyways
135	if (((flags & blurNeeded) && !(flags & blurServerSide))	181	if ((flags & blurNeeded) && !(flags & blurServerSide))
		182	return true;
		183	# endif
136	|| ((flags & tintNeeded) && !(flags & tintServerSide)))	184	if ((flags & tintNeeded) && !(flags & tintServerSide))
137	return true;	185	return true;
138	}	186	}
139	# endif	187	# endif
140	return false;	188	return false;
141	}	189	}
142		190
…		…
160	static inline bool	208	static inline bool
161	check_set_align_value (int geom_flags, int flag, int &align, int new_value)	209	check_set_align_value (int geom_flags, int flag, int &align, int new_value)
162	{	210	{
163	if (geom_flags & flag)	211	if (geom_flags & flag)
164	{	212	{
		213	if (new_value != bgPixmap_t::rootAlign)
		214	{
165	if (new_value < -100)	215	if (new_value < -100)
166	new_value = -100;	216	new_value = -100;
167	else if (new_value > 200)	217	else if (new_value > 200)
168	new_value = 200;	218	new_value = 200;
		219	}
169	if (new_value != align)	220	if (new_value != align)
170	{	221	{
171	align = new_value;	222	align = new_value;
172	return true;	223	return true;
173	}	224	}
…		…
177		228
178	static inline int	229	static inline int
179	make_align_position (int align, int window_size, int image_size)	230	make_align_position (int align, int window_size, int image_size)
180	{	231	{
181	int diff = window_size - image_size;	232	int diff = window_size - image_size;
182	int smaller = MIN (image_size,window_size);	233	int smaller = min (image_size, window_size);
183		234
184	if (align >= 0 && align <= 50)	235	if (align >= 0 && align <= 50)
185	return diff * align / 100;	236	return diff * align / 100;
186	else if (align > 50 && align <= 100)	237	else if (align > 50 && align <= 100)
187	return window_size - image_size - diff * (100 - align) / 100;	238	return window_size - image_size - diff * (100 - align) / 100;
…		…
217	int geom_flags = 0, changed = 0;	268	int geom_flags = 0, changed = 0;
218	int x = 0, y = 0;	269	int x = 0, y = 0;
219	unsigned int w = 0, h = 0;	270	unsigned int w = 0, h = 0;
220	unsigned int n;	271	unsigned int n;
221	unsigned long new_flags = (flags & (~geometryFlags));	272	unsigned long new_flags = (flags & (~geometryFlags));
222	char *p;	273	const char *p;
223	# define MAXLEN_GEOM 256 /* could be longer then regular geometry string */	274	# define MAXLEN_GEOM 256 /* could be longer than regular geometry string */
224		275
225	if (geom == NULL)	276	if (geom == NULL)
226	return false;	277	return false;
227		278
228	char str[MAXLEN_GEOM];	279	char str[MAXLEN_GEOM];
…		…
235	if (n < MAXLEN_GEOM)	286	if (n < MAXLEN_GEOM)
236	{	287	{
237	char *ops;	288	char *ops;
238	new_flags |= geometrySet;	289	new_flags |= geometrySet;
239		290
240	strncpy (str, geom, n);	291	memcpy (str, geom, n);
241	str[n] = '\0';	292	str[n] = '\0';
242	if (str[0] == ':')	293	if (str[0] == ':')
243	ops = &str[0];	294	ops = &str[0];
244	else if (str[0] != 'x' && str[0] != 'X' && isalpha(str[0]))	295	else if (str[0] != 'x' && str[0] != 'X' && isalpha(str[0]))
245	ops = &str[0];	296	ops = &str[0];
…		…
265	y = x;	316	y = x;
266	geom_flags |= YValue;	317	geom_flags |= YValue;
267	}	318	}
268		319
269	if (flags & geometrySet)	320	if (flags & geometrySet)
		321	{
270	{/* new geometry is an adjustment to the old one ! */	322	/* new geometry is an adjustment to the old one ! */
271	if ((geom_flags & WidthValue) && (geom_flags & HeightValue))	323	if ((geom_flags & WidthValue) && (geom_flags & HeightValue))
272	{	324	{
273	if (w == 0 && h != 0)	325	if (w == 0 && h != 0)
274	{	326	{
275	w = h_scale;	327	w = h_scale;
…		…
291	}	343	}
292	}	344	}
293	else /* setting up geometry from scratch */	345	else /* setting up geometry from scratch */
294	{	346	{
295	if (!(geom_flags & XValue))	347	if (!(geom_flags & XValue))
		348	{
296	{/* use default geometry - centered */	349	/* use default geometry - centered */
297	x = y = defaultAlign;	350	x = y = defaultAlign;
298	}	351	}
299	else if (!(geom_flags & YValue))	352	else if (!(geom_flags & YValue))
300	y = x;	353	y = x;
301		354
302	if ((geom_flags & (WidthValue|HeightValue)) == 0)	355	if ((geom_flags & (WidthValue|HeightValue)) == 0)
		356	{
303	{/* use default geometry - scaled */	357	/* use default geometry - scaled */
304	w = h = defaultScale;	358	w = h = defaultScale;
305	}	359	}
306	else if (geom_flags & WidthValue)	360	else if (geom_flags & WidthValue)
307	{	361	{
308	if (!(geom_flags & HeightValue))	362	if (!(geom_flags & HeightValue))
…		…
311	else	365	else
312	w = h;	366	w = h;
313	}	367	}
314	} /* done parsing geometry string */	368	} /* done parsing geometry string */
315	else if (!(flags & geometrySet))	369	else if (!(flags & geometrySet))
		370	{
316	{ /* default geometry - scaled and centered */	371	/* default geometry - scaled and centered */
317	x = y = defaultAlign;	372	x = y = defaultAlign;
318	w = h = defaultScale;	373	w = h = defaultScale;
319	}	374	}
320		375
321	if (!(flags & geometrySet))	376	if (!(flags & geometrySet))
322	geom_flags |= WidthValue|HeightValue|XValue|YValue;	377	geom_flags |= WidthValue|HeightValue|XValue|YValue;
323		378
324	if (ops)	379	if (ops)
325	{	380	{
326	while (*ops)	381	while (*ops)
327	{	382	{
328	while (*ops == ':' || isspace(*ops)) ++ops;	383	while (*ops == ':' || isspace(*ops)) ++ops;
		384
329	# define CHECK_GEOM_OPS(op_str) (strncasecmp (ops, (op_str), sizeof(op_str)-1) == 0)	385	# define CHECK_GEOM_OPS(op_str) (strncasecmp (ops, (op_str), sizeof (op_str) - 1) == 0)
330	if (CHECK_GEOM_OPS("tile"))	386	if (CHECK_GEOM_OPS ("tile"))
331	{	387	{
332	w = h = 0;	388	w = h = noScale;
333	geom_flags |= WidthValue|HeightValue;	389	geom_flags |= WidthValue|HeightValue;
334	}	390	}
335	else if (CHECK_GEOM_OPS("propscale"))	391	else if (CHECK_GEOM_OPS ("propscale"))
336	{	392	{
337	if (w == 0 && h == 0)	393	if (w == 0 && h == 0)
338	{	394	{
339	w = 100;	395	w = windowScale;
340	geom_flags |= WidthValue;	396	geom_flags |= WidthValue;
341	}	397	}
342	new_flags |= propScale;	398	new_flags |= propScale;
343	}	399	}
344	else if (CHECK_GEOM_OPS("hscale"))	400	else if (CHECK_GEOM_OPS ("hscale"))
345	{	401	{
346	if (w == 0)	402	if (w == 0) w = windowScale;
347	w = 100;	403
348	h = 0;	404	h = noScale;
349	geom_flags |= WidthValue|HeightValue;	405	geom_flags |= WidthValue|HeightValue;
350	}	406	}
351	else if (CHECK_GEOM_OPS("vscale"))	407	else if (CHECK_GEOM_OPS ("vscale"))
352	{	408	{
353	if (h == 0)	409	if (h == 0) h = windowScale;
354	h = 100;	410
355	w = 0;	411	w = noScale;
356	geom_flags |= WidthValue|HeightValue;	412	geom_flags |= WidthValue|HeightValue;
357	}	413	}
358	else if (CHECK_GEOM_OPS("scale"))	414	else if (CHECK_GEOM_OPS ("scale"))
359	{	415	{
360	if (h == 0)	416	if (h == 0) h = windowScale;
361	h = 100;
362	if (w == 0)	417	if (w == 0) w = windowScale;
363	w = 100;	418
364	geom_flags |= WidthValue|HeightValue;	419	geom_flags |= WidthValue|HeightValue;
365	}	420	}
366	else if (CHECK_GEOM_OPS("auto"))	421	else if (CHECK_GEOM_OPS ("auto"))
367	{	422	{
		423	w = h = windowScale;
		424	x = y = centerAlign;
		425	geom_flags |= WidthValue|HeightValue|XValue|YValue;
		426	}
		427	else if (CHECK_GEOM_OPS ("root"))
		428	{
368	w = h = 100;	429	w = h = noScale;
369	x = y = 50;	430	x = y = rootAlign;
370	geom_flags |= WidthValue|HeightValue|XValue|YValue;	431	geom_flags |= WidthValue|HeightValue|XValue|YValue;
371	}	432	}
372	# undef CHECK_GEOM_OPS	433	# undef CHECK_GEOM_OPS
		434
373	while (*ops != ':' && *ops != '\0') ++ops;	435	while (*ops != ':' && *ops != '\0') ++ops;
374	} /* done parsing ops */	436	} /* done parsing ops */
375	}	437	}
376		438
377	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w))	439	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) ++changed;
378	++changed;
379	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h))	440	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) ++changed;
380	++changed;
381	if (check_set_align_value (geom_flags, XValue, h_align, x))	441	if (check_set_align_value (geom_flags, XValue, h_align, x)) ++changed;
382	++changed;
383	if (check_set_align_value (geom_flags, YValue, v_align, y))	442	if (check_set_align_value (geom_flags, YValue, v_align, y)) ++changed;
384	++changed;
385	}	443	}
386		444
387	if (new_flags != flags)	445	if (new_flags != flags)
388	{	446	{
389	flags = new_flags;	447	flags = new_flags;
390	changed++;	448	changed++;
391	}	449	}
		450
392	//fprintf( stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",	451	//fprintf (stderr, "flags = %lX, scale = %ux%u, align=%+d%+d\n",
393	// flags, h_scale, v_scale, h_align, v_align);	452	// flags, h_scale, v_scale, h_align, v_align);
394	return (changed > 0);	453	return (changed > 0);
395	}	454	}
396		455
397	# ifdef HAVE_AFTERIMAGE	456	# ifdef HAVE_AFTERIMAGE
398	bool	457	bool
399	bgPixmap_t::render_asim (ASImage *background, ARGB32 background_tint)	458	bgPixmap_t::render_image (unsigned long background_flags)
400	{	459	{
401	if (target == NULL)	460	if (target == NULL)
402	return false;	461	return false;
403		462
		463	target->init_asv ();
		464
		465	ASImage *background = NULL;
		466	ARGB32 background_tint = TINT_LEAVE_SAME;
		467
		468	# ifdef ENABLE_TRANSPARENCY
		469	if (background_flags)
		470	background = pixmap2ximage (target->asv, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, 100);
		471
		472	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
		473	{
		474	ShadingInfo as_shade;
		475	as_shade.shading = (shade == 0) ? 100 : shade;
		476
		477	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
		478	if (flags & tintSet)
		479	tint.get (c);
		480	as_shade.tintColor.red = c.r;
		481	as_shade.tintColor.green = c.g;
		482	as_shade.tintColor.blue = c.b;
		483
		484	background_tint = shading2tint32 (&as_shade);
		485	}
		486
		487	if (!(background_flags & transpPmapBlured) && (flags & blurNeeded) && background != NULL)
		488	{
		489	ASImage *tmp = blur_asimage_gauss (target->asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
		490	(original_asim == NULL || tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,
		491	100, ASIMAGE_QUALITY_DEFAULT);
		492	if (tmp)
		493	{
		494	destroy_asimage (&background);
		495	background = tmp;
		496	}
		497	}
		498	# endif
		499
		500	ASImage *result = 0;
		501
404	int target_width = (int)target->szHint.width;	502	int target_width = target->szHint.width;
405	int target_height = (int)target->szHint.height;	503	int target_height = target->szHint.height;
406	int new_pmap_width = target_width, new_pmap_height = target_height;	504	int new_pmap_width = target_width;
407	ASImage *result = NULL;	505	int new_pmap_height = target_height;
408		506
409	int x = 0;	507	int x = 0;
410	int y = 0;	508	int y = 0;
411	int w = h_scale * target_width / 100;	509	int w = h_scale * target_width / 100;
412	int h = v_scale * target_height / 100;	510	int h = v_scale * target_height / 100;
413		511
414	TIMING_TEST_START (asim);	512	TIMING_TEST_START (asim);
415		513
416	if (original_asim)	514	if (original_asim)
417	{	515	{
		516	if (h_align == rootAlign || v_align == rootAlign)
		517	{
		518	target->get_window_origin (x, y);
		519	x = -x;
		520	y = -y;
		521	}
		522
		523	if (h_align != rootAlign)
418	x = make_align_position (h_align, target_width, w > 0 ? w : (int)original_asim->width);	524	x = make_align_position (h_align, target_width, w > 0 ? w : (int)original_asim->width);
		525
		526	if (v_align != rootAlign)
419	y = make_align_position (v_align, target_height, h > 0 ? h : (int)original_asim->height);	527	y = make_align_position (v_align, target_height, h > 0 ? h : (int)original_asim->height);
420	}	528	}
421		529
422	if (original_asim == NULL	530	if (!original_asim
423	|| x >= target_width	531	|| x >= target_width
424	|| y >= target_height	532	|| y >= target_height
425	|| (w > 0 && x + w <= 0)	533	|| (w > 0 && x + w <= 0)
426	|| (h > 0 && y + h <= 0))	534	|| (h > 0 && y + h <= 0))
427	{	535	{
428	if (background)	536	if (background)
429	{	537	{
430	new_pmap_width = background->width;	538	new_pmap_width = background->width;
431	new_pmap_height = background->height;	539	new_pmap_height = background->height;
432	result = background;	540	result = background;
		541
433	if (background_tint != TINT_LEAVE_SAME)	542	if (background_tint != TINT_LEAVE_SAME)
434	{	543	{
435	ASImage* tmp = tile_asimage (target->asv, background, 0, 0,	544	ASImage *tmp = tile_asimage (target->asv, background, 0, 0,
436	target_width, target_height, background_tint,	545	target_width, target_height, background_tint,
437	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);	546	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
438	if (tmp)	547	if (tmp)
439	result = tmp;	548	result = tmp;
440	}	549	}
…		…
443	new_pmap_width = new_pmap_height = 0;	552	new_pmap_width = new_pmap_height = 0;
444	}	553	}
445	else	554	else
446	{	555	{
447	result = original_asim;	556	result = original_asim;
		557
448	if ((w > 0 && w != original_asim->width)	558	if ((w > 0 && w != original_asim->width)
449	|| (h > 0 && h != original_asim->height))	559	|| (h > 0 && h != original_asim->height))
450	{	560	{
451	result = scale_asimage (target->asv, original_asim,	561	result = scale_asimage (target->asv, original_asim,
452	w > 0 ? w : original_asim->width,	562	w > 0 ? w : original_asim->width,
453	h > 0 ? h : original_asim->height,	563	h > 0 ? h : original_asim->height,
454	background ? ASA_ASImage : ASA_XImage,	564	background ? ASA_ASImage : ASA_XImage,
455	100, ASIMAGE_QUALITY_DEFAULT);	565	100, ASIMAGE_QUALITY_DEFAULT);
456	}	566	}
		567
457	if (background == NULL)	568	if (background == NULL)
458	{/* if tiling - pixmap has to be sized exactly as the image */	569	{
459	if (h_scale == 0)
460	new_pmap_width = result->width;
461	if (v_scale == 0)
462	new_pmap_height = result->height;
463	/* we also need to tile our image in one or both directions */
464	if (h_scale == 0 || v_scale == 0)	570	if (h_scale == 0 || v_scale == 0)
465	{	571	{
		572	/* if tiling - pixmap has to be sized exactly as the image,
		573	but there is no need to make it bigger than the window! */
		574	new_pmap_width = min (result->width, target_width);
		575	new_pmap_height = min (result->height, target_height);
		576
		577	/* we also need to tile our image in both directions */
466	ASImage *tmp = tile_asimage (target->asv, result,	578	ASImage *tmp = tile_asimage (target->asv, result,
467	(h_scale > 0) ? 0 : (int)result->width - x,	579	(int)result->width - x,
468	(v_scale > 0) ? 0 : (int)result->height - y,	580	(int)result->height - y,
		581	new_pmap_width,
469	result->width, result->height,	582	new_pmap_height,
470	TINT_LEAVE_SAME, ASA_XImage,	583	TINT_LEAVE_SAME, ASA_XImage,
471	100, ASIMAGE_QUALITY_DEFAULT);	584	100, ASIMAGE_QUALITY_DEFAULT);
472	if (tmp)	585	if (tmp)
473	{	586	{
474	if (result != original_asim)	587	if (result != original_asim)
475	destroy_asimage (&result);	588	destroy_asimage (&result);
		589
476	result = tmp;	590	result = tmp;
477	}	591	}
478	}	592	}
479	}	593	}
480	else	594	else
		595	{
481	{/* if blending background and image - pixmap has to be sized same as target window */	596	/* if blending background and image - pixmap has to be sized same as target window */
482	ASImageLayer *layers = create_image_layers (2);	597	ASImageLayer *layers = create_image_layers (2);
483	ASImage *merged_im = NULL;
484		598
485	layers[0].im = background;	599	layers[0].im = background;
486	layers[0].clip_width = target_width;	600	layers[0].clip_width = target_width;
487	layers[0].clip_height = target_height;	601	layers[0].clip_height = target_height;
488	layers[0].tint = background_tint;	602	layers[0].tint = background_tint;
489	layers[1].im = result;	603	layers[1].im = result;
		604
490	if (w <= 0)	605	if (w <= 0)
		606	{
491	{/* tile horizontally */	607	/* tile horizontally */
492	while (x > 0) x -= (int)result->width;	608	while (x > 0) x -= (int)result->width;
493	layers[1].dst_x = x;	609	layers[1].dst_x = x;
494	layers[1].clip_width = result->width+target_width;	610	layers[1].clip_width = result->width+target_width;
495	}	611	}
496	else	612	else
		613	{
497	{/* clip horizontally */	614	/* clip horizontally */
498	layers[1].dst_x = x;	615	layers[1].dst_x = x;
499	layers[1].clip_width = result->width;	616	layers[1].clip_width = result->width;
500	}	617	}
		618
501	if (h <= 0)	619	if (h <= 0)
502	{	620	{
503	while (y > 0) y -= (int)result->height;	621	while (y > 0) y -= (int)result->height;
504	layers[1].dst_y = y;	622	layers[1].dst_y = y;
505	layers[1].clip_height = result->height + target_height;	623	layers[1].clip_height = result->height + target_height;
…		…
507	else	625	else
508	{	626	{
509	layers[1].dst_y = y;	627	layers[1].dst_y = y;
510	layers[1].clip_height = result->height;	628	layers[1].clip_height = result->height;
511	}	629	}
		630
512	if (target->rs[Rs_blendtype])	631	if (target->rs[Rs_blendtype])
513	{	632	{
514	layers[1].merge_scanlines = blend_scanlines_name2func (target->rs[Rs_blendtype]);	633	layers[1].merge_scanlines = blend_scanlines_name2func (target->rs[Rs_blendtype]);
515	if (layers[1].merge_scanlines == NULL)	634	if (layers[1].merge_scanlines == NULL)
516	layers[1].merge_scanlines = alphablend_scanlines;	635	layers[1].merge_scanlines = alphablend_scanlines;
517	}	636	}
		637
518	ASImage *tmp = merge_layers (target->asv, layers, 2, target_width, target_height,	638	ASImage *tmp = merge_layers (target->asv, layers, 2, target_width, target_height,
519	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);	639	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
		640
520	if (tmp)	641	if (tmp)
521	{	642	{
522	if (result != original_asim)	643	if (result != original_asim)
523	destroy_asimage (&result);	644	destroy_asimage (&result);
		645
524	result = tmp;	646	result = tmp;
525	}	647	}
		648
526	free (layers);	649	free (layers);
527	}	650	}
528	}	651	}
529	TIMING_TEST_PRINT_RESULT (asim);	652	TIMING_TEST_PRINT_RESULT (asim);
530		653
531	if (pixmap)	654	bool ret = false;
532	{
533	if (result == NULL
534	|| pmap_width != new_pmap_width
535	|| pmap_height != new_pmap_height
536	|| pmap_depth != target->depth)
537	{
538	XFreePixmap (target->dpy, pixmap);
539	pixmap = None;
540	}
541	}
542		655
543	if (result)	656	if (result)
544	{	657	{
545	XGCValues gcv;	658	XGCValues gcv;
546	GC gc;	659	GC gc;
		660
		661	if (pixmap)
		662	{
		663	if (pmap_width != new_pmap_width
		664	|| pmap_height != new_pmap_height
		665	|| pmap_depth != target->depth)
		666	{
		667	XFreePixmap (target->dpy, pixmap);
		668	pixmap = None;
		669	}
		670	}
547		671
548	/* create Pixmap */	672	/* create Pixmap */
549	if (pixmap == None)	673	if (pixmap == None)
550	{	674	{
551	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);	675	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
552	pmap_width = new_pmap_width;	676	pmap_width = new_pmap_width;
553	pmap_height = new_pmap_height;	677	pmap_height = new_pmap_height;
554	pmap_depth = target->depth;	678	pmap_depth = target->depth;
555	}	679	}
556	/* fill with background color ( if result's not completely overlapping it)*/	680	/* fill with background color (if result's not completely overlapping it) */
557	gcv.foreground = target->pix_colors[Color_bg];	681	gcv.foreground = target->pix_colors[Color_bg];
558	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);	682	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
559		683
560	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;	684	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
561	int dst_width = result->width, dst_height = result->height;	685	int dst_width = result->width, dst_height = result->height;
562	if (background == NULL)	686	if (background == NULL)
563	{	687	{
564	if (h_scale > 0)	688	if (!(h_scale == 0 || v_scale == 0))
		689	{
565	src_x = make_clip_rectangle (x, result->width, new_pmap_width, dst_x, dst_width);	690	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
566	if (v_scale > 0)
567	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);	691	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
		692	}
568		693
569	if (dst_x > 0 || dst_y > 0	694	if (dst_x > 0 || dst_y > 0
570	|| dst_x + dst_width < new_pmap_width	695	|| dst_x + dst_width < new_pmap_width
571	|| dst_y + dst_height < new_pmap_height)	696	|| dst_y + dst_height < new_pmap_height)
572	{
573	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	697	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
574	}
575	}	698	}
576		699
577	/* put result on pixmap */	700	/* put result on pixmap */
578	if (dst_x < new_pmap_width && dst_y < new_pmap_height)	701	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
579	asimage2drawable (target->asv, pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);	702	asimage2drawable (target->asv, pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
580		703
581	if (result != background && result != original_asim)	704	if (result != background && result != original_asim)
582	destroy_asimage (&result);	705	destroy_asimage (&result);
583		706
584	XFreeGC (target->dpy, gc);	707	XFreeGC (target->dpy, gc);
585	TIMING_TEST_PRINT_RESULT (asim);	708	TIMING_TEST_PRINT_RESULT (asim);
586	}
587		709
		710	ret = true;
		711	}
		712
		713	if (background)
		714	destroy_asimage (&background);
		715
588	return true;	716	return ret;
589	}	717	}
590	# endif /* HAVE_AFTERIMAGE */	718	# endif /* HAVE_AFTERIMAGE */
		719
		720	# ifdef HAVE_PIXBUF
		721	bool
		722	bgPixmap_t::render_image (unsigned long background_flags)
		723	{
		724	if (target == NULL)
		725	return false;
		726
		727	if (!pixbuf)
		728	return false;
		729
		730	// TODO: add alpha blending
		731	if (background_flags)
		732	return false;
		733
		734	GdkPixbuf *result;
		735
		736	int image_width = gdk_pixbuf_get_width (pixbuf);
		737	int image_height = gdk_pixbuf_get_height (pixbuf);
		738
		739	int target_width = target->szHint.width;
		740	int target_height = target->szHint.height;
		741	int new_pmap_width = target_width;
		742	int new_pmap_height = target_height;
		743
		744	int x = 0;
		745	int y = 0;
		746	int w = h_scale * target_width / 100;
		747	int h = v_scale * target_height / 100;
		748
		749	if (h_align == rootAlign || v_align == rootAlign)
		750	{
		751	target->get_window_origin (x, y);
		752	x = -x;
		753	y = -y;
		754	}
		755
		756	if (h_align != rootAlign)
		757	x = make_align_position (h_align, target_width, w > 0 ? w : image_width);
		758
		759	if (v_align != rootAlign)
		760	y = make_align_position (v_align, target_height, h > 0 ? h : image_height);
		761
		762	if (x >= target_width
		763	|| y >= target_height
		764	|| (w > 0 && x + w <= 0)
		765	|| (h > 0 && y + h <= 0))
		766	return false;
		767
		768	result = pixbuf;
		769
		770	if ((w > 0 && w != image_width)
		771	|| (h > 0 && h != image_height))
		772	{
		773	result = gdk_pixbuf_scale_simple (pixbuf,
		774	w > 0 ? w : image_width,
		775	h > 0 ? h : image_height,
		776	GDK_INTERP_BILINEAR);
		777	}
		778
		779	bool ret = false;
		780
		781	if (result)
		782	{
		783	XGCValues gcv;
		784	GC gc;
		785
		786	image_width = gdk_pixbuf_get_width (result);
		787	image_height = gdk_pixbuf_get_height (result);
		788
		789	if (h_scale == 0)
		790	new_pmap_width = min (image_width, target_width);
		791	if (v_scale == 0)
		792	new_pmap_height = min (image_height, target_height);
		793
		794	if (pixmap)
		795	{
		796	if (pmap_width != new_pmap_width
		797	|| pmap_height != new_pmap_height
		798	|| pmap_depth != target->depth)
		799	{
		800	XFreePixmap (target->dpy, pixmap);
		801	pixmap = None;
		802	}
		803	}
		804
		805	if (pixmap == None)
		806	{
		807	pixmap = XCreatePixmap (target->dpy, target->vt, new_pmap_width, new_pmap_height, target->depth);
		808	pmap_width = new_pmap_width;
		809	pmap_height = new_pmap_height;
		810	pmap_depth = target->depth;
		811	}
		812
		813	gcv.foreground = target->pix_colors[Color_bg];
		814	gc = XCreateGC (target->dpy, target->vt, GCForeground, &gcv);
		815
		816	if (h_scale == 0 || v_scale == 0)
		817	{
		818	Pixmap tile = XCreatePixmap (target->dpy, target->vt, image_width, image_height, target->depth);
		819	gdk_pixbuf_xlib_render_to_drawable (result, tile, gc,
		820	0, 0,
		821	0, 0,
		822	image_width, image_height,
		823	XLIB_RGB_DITHER_NONE,
		824	0, 0);
		825
		826	gcv.tile = tile;
		827	gcv.fill_style = FillTiled;
		828	gcv.ts_x_origin = x;
		829	gcv.ts_y_origin = y;
		830	XChangeGC (target->dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
		831
		832	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
		833	XFreePixmap (target->dpy, tile);
		834	}
		835	else
		836	{
		837	int src_x, src_y, dst_x, dst_y;
		838	int dst_width, dst_height;
		839
		840	src_x = make_clip_rectangle (x, image_width , new_pmap_width , dst_x, dst_width );
		841	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
		842
		843	if (dst_x > 0 || dst_y > 0
		844	|| dst_x + dst_width < new_pmap_width
		845	|| dst_y + dst_height < new_pmap_height)
		846	XFillRectangle (target->dpy, pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
		847
		848	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
		849	gdk_pixbuf_xlib_render_to_drawable (result, pixmap, gc,
		850	src_x, src_y,
		851	dst_x, dst_y,
		852	dst_width, dst_height,
		853	XLIB_RGB_DITHER_NONE,
		854	0, 0);
		855	}
		856
		857	if (result != pixbuf)
		858	g_object_unref (result);
		859
		860	XFreeGC (target->dpy, gc);
		861
		862	ret = true;
		863	}
		864
		865	return ret;
		866	}
		867	# endif /* HAVE_PIXBUF */
591		868
592	bool	869	bool
593	bgPixmap_t::set_file (const char *file)	870	bgPixmap_t::set_file (const char *file)
594	{	871	{
595	char *f;
596
597	assert (file != NULL);	872	assert (file);
598		873
599	if (*file != '\0')	874	if (*file)
600	{	875	{
		876	if (const char *p = strchr (file, ';'))
		877	{
		878	size_t len = p - file;
		879	char *f = rxvt_temp_buf<char> (len + 1);
		880	memcpy (f, file, len);
		881	f[len] = '\0';
		882	file = f;
		883	}
		884
601	# ifdef HAVE_AFTERIMAGE	885	# ifdef HAVE_AFTERIMAGE
602	if (target->asimman == NULL)	886	if (!target->asimman)
603	target->asimman = create_generic_imageman (target->rs[Rs_path]);	887	target->asimman = create_generic_imageman (target->rs[Rs_path]);
604	if ((f = strchr (file, ';')) == NULL)
605	original_asim = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);	888	original_asim = get_asimage (target->asimman, file, 0xFFFFFFFF, 100);
606	else	889	if (original_asim)
607	{	890	have_image = true;
608	size_t len = f - file;	891	return have_image;
609	f = (char *)malloc (len + 1);
610	strncpy (f, file, len);
611	f[len] = '\0';
612	original_asim = get_asimage (target->asimman, f, 0xFFFFFFFF, 100);
613	free (f);
614	}
615	return (original_asim != NULL);
616	# endif	892	# endif
		893
		894	# ifdef HAVE_PIXBUF
		895	pixbuf = gdk_pixbuf_new_from_file (file, NULL);
		896	if (pixbuf)
		897	have_image = true;
		898	return have_image;
		899	# endif
617	}	900	}
		901
618	return false;	902	return false;
619	}	903	}
620		904
621	# endif /* BG_IMAGE_FROM_FILE */	905	# endif /* BG_IMAGE_FROM_FILE */
622		906
623	# ifdef ENABLE_TRANSPARENCY	907	# ifdef ENABLE_TRANSPARENCY
624	bool	908	bool
625	bgPixmap_t::set_transparent ()	909	bgPixmap_t::set_transparent ()
626	{	910	{
627	if (!(flags & isTransparent))	911	if (!(flags & isTransparent))
628	{	912	{
629	flags |= isTransparent;	913	flags |= isTransparent;
630	return true;	914	return true;
631	}	915	}
		916
632	return false;	917	return false;
633	}	918	}
634		919
635	bool	920	bool
636	bgPixmap_t::set_blur_radius (const char *geom)	921	bgPixmap_t::set_blur_radius (const char *geom)
…		…
638	int changed = 0;	923	int changed = 0;
639	unsigned int hr, vr;	924	unsigned int hr, vr;
640	int junk;	925	int junk;
641	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);	926	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
642		927
643	if (!(geom_flags&WidthValue))	928	if (!(geom_flags & WidthValue))
644	hr = 1;	929	hr = 1;
645	if (!(geom_flags&HeightValue))	930	if (!(geom_flags & HeightValue))
646	vr = hr;	931	vr = hr;
647		932
648	if (h_blurRadius != hr)	933	if (h_blurRadius != hr)
649	{	934	{
650	++changed;	935	++changed;
…		…
654	if (v_blurRadius != vr)	939	if (v_blurRadius != vr)
655	{	940	{
656	++changed;	941	++changed;
657	v_blurRadius = vr;	942	v_blurRadius = vr;
658	}	943	}
659		944
660	if (v_blurRadius == 0 && h_blurRadius == 0)	945	if (v_blurRadius == 0 && h_blurRadius == 0)
661	flags &= ~blurNeeded;	946	flags &= ~blurNeeded;
662	else	947	else
663	flags |= blurNeeded;	948	flags |= blurNeeded;
664		949
665	return (changed>0);	950	return (changed > 0);
666	}	951	}
667		952
668	static inline unsigned long	953	static inline unsigned long
669	compute_tint_shade_flags (rxvt_color *tint, int shade)	954	compute_tint_shade_flags (rxvt_color *tint, int shade)
670	{	955	{
…		…
687	flags |= bgPixmap_t::tintNeeded;	972	flags |= bgPixmap_t::tintNeeded;
688	else if (tint)	973	else if (tint)
689	{	974	{
690	if ((c.r > 0x000700 || c.g > 0x000700 || c.b > 0x000700)	975	if ((c.r > 0x000700 || c.g > 0x000700 || c.b > 0x000700)
691	&& (c.r < 0x00f700 || c.g < 0x00f700 || c.b < 0x00f700))	976	&& (c.r < 0x00f700 || c.g < 0x00f700 || c.b < 0x00f700))
692	{	977	{
693	flags |= bgPixmap_t::tintNeeded;	978	flags |= bgPixmap_t::tintNeeded;
694	}	979	}
695	}
696		980	}
		981
697	if (flags & bgPixmap_t::tintNeeded)	982	if (flags & bgPixmap_t::tintNeeded)
698	{	983	{
699	if (flags & bgPixmap_t::tintWholesome)	984	if (flags & bgPixmap_t::tintWholesome)
700	flags |= bgPixmap_t::tintServerSide;	985	flags |= bgPixmap_t::tintServerSide;
701	else	986	else
…		…
717	unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);	1002	unsigned long new_flags = compute_tint_shade_flags (&new_tint, shade);
718	tint = new_tint;	1003	tint = new_tint;
719	flags = (flags & ~tintFlags) | new_flags | tintSet;	1004	flags = (flags & ~tintFlags) | new_flags | tintSet;
720	return true;	1005	return true;
721	}	1006	}
		1007
722	return false;	1008	return false;
723	}	1009	}
724		1010
725	bool	1011	bool
726	bgPixmap_t::unset_tint ()	1012	bgPixmap_t::unset_tint ()
727	{	1013	{
728	unsigned long new_flags = compute_tint_shade_flags (NULL, shade);	1014	unsigned long new_flags = compute_tint_shade_flags (NULL, shade);
729		1015
730	if (new_flags != (flags & tintFlags))	1016	if (new_flags != (flags & tintFlags))
731	{	1017	{
732	flags = (flags&~tintFlags)|new_flags;	1018	flags = (flags & ~tintFlags) | new_flags;
733	return true;	1019	return true;
734	}	1020	}
		1021
735	return false;	1022	return false;
736	}	1023	}
737		1024
738	bool	1025	bool
739	bgPixmap_t::set_shade (const char *shade_str)	1026	bgPixmap_t::set_shade (const char *shade_str)
740	{	1027	{
741	int new_shade = (shade_str) ? atoi (shade_str) : 0;	1028	int new_shade = (shade_str) ? atoi (shade_str) : 0;
742		1029
		1030	if (new_shade < 0 && new_shade > -100)
		1031	new_shade = 200 - (100 + new_shade);
743	if (new_shade == 100)	1032	else if (new_shade == 100)
744	new_shade = 0;	1033	new_shade = 0;
745		1034
746	if (new_shade != shade)	1035	if (new_shade != shade)
747	{	1036	{
748	unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);	1037	unsigned long new_flags = compute_tint_shade_flags ((flags & tintSet) ? &tint : NULL, new_shade);
749	shade = new_shade;	1038	shade = new_shade;
750	flags = (flags & (~tintFlags | tintSet)) | new_flags;	1039	flags = (flags & (~tintFlags | tintSet)) | new_flags;
751	return true;	1040	return true;
752	}	1041	}
		1042
753	return false;	1043	return false;
754	}	1044	}
755		1045
756	/* make_transparency_pixmap()	1046	/* make_transparency_pixmap()
757	* Builds a pixmap sized the same as terminal window, with depth same as the root window	1047	* Builds a pixmap sized the same as terminal window, with depth same as the root window
758	* that pixmap contains tiled portion of the root pixmap that is supposed to be covered by	1048	* that pixmap contains tiled portion of the root pixmap that is supposed to be covered by
759	* our window.	1049	* our window.
760	*/	1050	*/
761	unsigned long	1051	unsigned long
762	bgPixmap_t::make_transparency_pixmap ()	1052	bgPixmap_t::make_transparency_pixmap ()
763	{	1053	{
764	unsigned long result = 0;	1054	unsigned long result = 0;
765		1055
766	if (target == NULL)	1056	if (target == NULL)
767	return 0;	1057	return 0;
768		1058
769	/* root dimentions may change from call to call - but Display structure should	1059	/* root dimensions may change from call to call - but Display structure should
770	* be always up-to-date, so let's use it :	1060	* be always up-to-date, so let's use it :
771	*/	1061	*/
772	Window root = target->display->root;	1062	Window root = target->display->root;
773	int screen = target->display->screen;	1063	int screen = target->display->screen;
774	Display *dpy = target->dpy;	1064	Display *dpy = target->dpy;
…		…
787	if (sx + window_width <= 0 || sy + window_height <= 0	1077	if (sx + window_width <= 0 || sy + window_height <= 0
788	|| sx >= root_width || sy >= root_height)	1078	|| sx >= root_width || sy >= root_height)
789	return 0;	1079	return 0;
790		1080
791	if (root_pixmap != None)	1081	if (root_pixmap != None)
		1082	{
792	{/* we want to validate the pixmap and get it's size at the same time : */	1083	/* we want to validate the pixmap and get it's size at the same time : */
793	int junk;	1084	int junk;
794	unsigned int ujunk;	1085	unsigned int ujunk;
795	/* root pixmap may be bad - allow a error */	1086	/* root pixmap may be bad - allow a error */
796	target->allowedxerror = -1;	1087	target->allowedxerror = -1;
797		1088
…		…
806		1097
807	if (tiled_root_pmap == None) /* something really bad happened - abort */	1098	if (tiled_root_pmap == None) /* something really bad happened - abort */
808	return 0;	1099	return 0;
809		1100
810	if (root_pixmap == None)	1101	if (root_pixmap == None)
		1102	{
811	{ /* use tricks to obtain the root background image :*/	1103	/* use tricks to obtain the root background image :*/
812	/* we want to create Overrideredirect window overlapping out window	1104	/* we want to create Overrideredirect window overlapping out window
813	with background type of Parent Relative and then grab it */	1105	with background type of Parent Relative and then grab it */
814	XSetWindowAttributes attr;	1106	XSetWindowAttributes attr;
815	Window src;	1107	Window src;
816	bool success = false;	1108	bool success = false;
817		1109
818	attr.background_pixmap = ParentRelative;	1110	attr.background_pixmap = ParentRelative;
819	attr.backing_store = Always;	1111	attr.backing_store = Always;
820	attr.event_mask = ExposureMask;	1112	attr.event_mask = ExposureMask;
821	attr.override_redirect = True;	1113	attr.override_redirect = True;
822	src = XCreateWindow (dpy, root, sx, sy, window_width, window_height, 0,	1114	src = XCreateWindow (dpy, root, sx, sy, window_width, window_height, 0,
823	CopyFromParent, CopyFromParent, CopyFromParent,	1115	CopyFromParent, CopyFromParent, CopyFromParent,
824	CWBackPixmap|CWBackingStore|CWOverrideRedirect|CWEventMask,	1116	CWBackPixmap|CWBackingStore|CWOverrideRedirect|CWEventMask,
825	&attr);	1117	&attr);
826		1118
827	if (src != None)	1119	if (src != None)
…		…
831	XGrabServer (dpy);	1123	XGrabServer (dpy);
832	XMapRaised (dpy, src);	1124	XMapRaised (dpy, src);
833	XSync (dpy, False);	1125	XSync (dpy, False);
834		1126
835	/* XSync should get window where it's properly exposed,	1127	/* XSync should get window where it's properly exposed,
836	* but to be on the safe side - let's check for the actuall event to arrive : */	1128	* but to be on the safe side - let's check for the actual event to arrive : */
837	while (XCheckWindowEvent (dpy, src, ExposureMask, &event))	1129	while (XCheckWindowEvent (dpy, src, ExposureMask, &event))
838	++ev_count;	1130	++ev_count;
839		1131
840	if (ev_count > 0);	1132	if (ev_count > 0);
		1133	{
841	{ /* hooray! - we can grab the image! */	1134	/* hooray! - we can grab the image! */
842	gc = XCreateGC (dpy, root, 0, NULL);	1135	gc = XCreateGC (dpy, root, 0, NULL);
843	if (gc)	1136	if (gc)
844	{	1137	{
845	XCopyArea (dpy, src, tiled_root_pmap, gc, 0, 0, window_width, window_height, 0, 0);	1138	XCopyArea (dpy, src, tiled_root_pmap, gc, 0, 0, window_width, window_height, 0, 0);
846	success = true;	1139	success = true;
847	}	1140	}
848	}	1141	}
		1142
849	XDestroyWindow (dpy, src);	1143	XDestroyWindow (dpy, src);
850	XUngrabServer (dpy);	1144	XUngrabServer (dpy);
851	//fprintf (stderr, "%s:%d: ev_count = %d\n", __FUNCTION__, __LINE__, ev_count);	1145	//fprintf (stderr, "%s:%d: ev_count = %d\n", __FUNCTION__, __LINE__, ev_count);
852	}	1146	}
853		1147
854	if (!success)	1148	if (!success)
855	{	1149	{
856	XFreePixmap (dpy, tiled_root_pmap);	1150	XFreePixmap (dpy, tiled_root_pmap);
857	tiled_root_pmap = None;	1151	tiled_root_pmap = None;
858	}	1152	}
859	else	1153	else
860	result |= transpPmapTiled;	1154	result |= transpPmapTiled;
861	}	1155	}
862	else	1156	else
		1157	{
863	{/* strightforward pixmap copy */	1158	/* straightforward pixmap copy */
864	gcv.tile = root_pixmap;	1159	gcv.tile = root_pixmap;
865	gcv.fill_style = FillTiled;	1160	gcv.fill_style = FillTiled;
866		1161
867	while (sx < 0) sx += (int)window_width;	1162	while (sx < 0) sx += (int)root_width;
868	while (sy < 0) sy += (int)window_height;	1163	while (sy < 0) sy += (int)root_height;
869		1164
870	gcv.ts_x_origin = -sx;	1165	gcv.ts_x_origin = -sx;
871	gcv.ts_y_origin = -sy;	1166	gcv.ts_y_origin = -sy;
872	gc = XCreateGC (dpy, root, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	1167	gc = XCreateGC (dpy, root, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
873		1168
…		…
879	}	1174	}
880	TIMING_TEST_PRINT_RESULT (tp);	1175	TIMING_TEST_PRINT_RESULT (tp);
881		1176
882	if (tiled_root_pmap != None)	1177	if (tiled_root_pmap != None)
883	{	1178	{
884	if (!need_client_side_rendering ())	1179	if (!need_client_side_rendering ())
885	{	1180	{
886	if ((flags & tintNeeded))	1181	if ((flags & tintNeeded))
887	{	1182	{
888	if (flags & tintWholesome)	1183	if (flags & tintWholesome)
889	{	1184	{
890	/* In this case we can tint image server-side getting significant	1185	/* In this case we can tint image server-side getting significant
891	* performance improvements, as we eliminate XImage transfer	1186	* performance improvements, as we eliminate XImage transfer
…		…
916	{	1211	{
917	c.r = (c.r * shade) / 100;	1212	c.r = (c.r * shade) / 100;
918	c.g = (c.g * shade) / 100;	1213	c.g = (c.g * shade) / 100;
919	c.b = (c.b * shade) / 100;	1214	c.b = (c.b * shade) / 100;
920	}	1215	}
921	else if( shade > 100 && shade < 200)	1216	else if (shade > 100 && shade < 200)
922	{	1217	{
923	c.r = (c.r * (200 - shade)) / 100;	1218	c.r = (c.r * (200 - shade)) / 100;
924	c.g = (c.g * (200 - shade)) / 100;	1219	c.g = (c.g * (200 - shade)) / 100;
925	c.b = (c.b * (200 - shade)) / 100;	1220	c.b = (c.b * (200 - shade)) / 100;
926	}	1221	}
…		…
932	pf.direct.greenMask = 0xff;	1227	pf.direct.greenMask = 0xff;
933	pf.direct.blueMask = 0xff;	1228	pf.direct.blueMask = 0xff;
934	pf.direct.alphaMask = 0xff;	1229	pf.direct.alphaMask = 0xff;
935		1230
936	XRenderPictFormat *solid_format = XRenderFindFormat (dpy,	1231	XRenderPictFormat *solid_format = XRenderFindFormat (dpy,
937	(PictFormatType|	1232	(PictFormatType|
938	PictFormatDepth|	1233	PictFormatDepth|
939	PictFormatRedMask|	1234	PictFormatRedMask|
940	PictFormatGreenMask|	1235	PictFormatGreenMask|
941	PictFormatBlueMask|	1236	PictFormatBlueMask|
942	PictFormatAlphaMask),	1237	PictFormatAlphaMask),
943	&pf,	1238	&pf,
944	0);	1239	0);
945	XRenderPictFormat *root_format = XRenderFindVisualFormat (dpy, DefaultVisualOfScreen (ScreenOfDisplay (dpy, target->display->screen)));	1240	XRenderPictFormat *root_format = XRenderFindVisualFormat (dpy, DefaultVisualOfScreen (ScreenOfDisplay (dpy, target->display->screen)));
946	XRenderPictureAttributes pa ;	1241	XRenderPictureAttributes pa ;
947		1242
948	back_pic = XRenderCreatePicture (dpy, tiled_root_pmap, root_format, 0, &pa);	1243	back_pic = XRenderCreatePicture (dpy, tiled_root_pmap, root_format, 0, &pa);
949		1244
…		…
951		1246
952	Pixmap overlay_pmap = XCreatePixmap (dpy, root, 1, 1, 32);	1247	Pixmap overlay_pmap = XCreatePixmap (dpy, root, 1, 1, 32);
953	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);	1248	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
954	XFreePixmap (dpy, overlay_pmap);	1249	XFreePixmap (dpy, overlay_pmap);
955		1250
956	pa.component_alpha = True;	1251	pa.component_alpha = True;
957	Pixmap mask_pmap = XCreatePixmap (dpy, root, 1, 1, 32);	1252	Pixmap mask_pmap = XCreatePixmap (dpy, root, 1, 1, 32);
958	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);	1253	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat|CPComponentAlpha, &pa);
959	XFreePixmap (dpy, mask_pmap);	1254	XFreePixmap (dpy, mask_pmap);
960		1255
961	if (mask_pic && overlay_pic && back_pic)	1256	if (mask_pic && overlay_pic && back_pic)
…		…
972	mask_c.blue = 0xffff - c.b;	1267	mask_c.blue = 0xffff - c.b;
973	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	1268	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
974	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, window_width, window_height);	1269	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, window_width, window_height);
975	result |= transpPmapTinted;	1270	result |= transpPmapTinted;
976	}	1271	}
		1272
977	XRenderFreePicture (dpy, mask_pic);	1273	XRenderFreePicture (dpy, mask_pic);
978	XRenderFreePicture (dpy, overlay_pic);	1274	XRenderFreePicture (dpy, overlay_pic);
979	XRenderFreePicture (dpy, back_pic);	1275	XRenderFreePicture (dpy, back_pic);
980	# if DO_TIMING_TEST	1276	# if DO_TIMING_TEST
981	XSync (dpy, False);	1277	XSync (dpy, False);
982	# endif	1278	# endif
983	# endif	1279	# endif
984	}	1280	}
985	}	1281	}
986	} /* server side rendering completed */	1282	} /* server side rendering completed */
987		1283
988	if (pixmap)	1284	if (pixmap)
989	XFreePixmap (dpy, pixmap);	1285	XFreePixmap (dpy, pixmap);
990		1286
991	pixmap = tiled_root_pmap;	1287	pixmap = tiled_root_pmap;
992	pmap_width = window_width;	1288	pmap_width = window_width;
993	pmap_height = window_height;	1289	pmap_height = window_height;
994	pmap_depth = root_depth;	1290	pmap_depth = root_depth;
995	}	1291	}
996		1292
997	if (gc)	1293	if (gc)
998	XFreeGC (dpy, gc);	1294	XFreeGC (dpy, gc);
999		1295
1000	TIMING_TEST_PRINT_RESULT (tp);	1296	TIMING_TEST_PRINT_RESULT (tp);
1001		1297
1002	return result;	1298	return result;
1003	}	1299	}
1004		1300
1005	bool	1301	bool
1006	bgPixmap_t::set_root_pixmap ()	1302	bgPixmap_t::set_root_pixmap ()
1007	{	1303	{
1008	Pixmap new_root_pixmap = None;
1009
1010	new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);	1304	Pixmap new_root_pixmap = target->get_pixmap_property (XA_XROOTPMAP_ID);
1011	if (new_root_pixmap == None)	1305	if (new_root_pixmap == None)
1012	new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);	1306	new_root_pixmap = target->get_pixmap_property (XA_ESETROOT_PMAP_ID);
1013		1307
1014	if (new_root_pixmap != root_pixmap)	1308	if (new_root_pixmap != root_pixmap)
1015	{	1309	{
1016	root_pixmap = new_root_pixmap;	1310	root_pixmap = new_root_pixmap;
1017	return true;	1311	return true;
1018	}	1312	}
		1313
1019	return false;	1314	return false;
1020	}	1315	}
1021	# endif /* ENABLE_TRANSPARENCY */	1316	# endif /* ENABLE_TRANSPARENCY */
1022		1317
1023	# ifndef HAVE_AFTERIMAGE	1318	# ifndef HAVE_AFTERIMAGE
1024	static void ShadeXImage(rxvt_term *term, XImage* srcImage, int shade, int rm, int gm, int bm);	1319	static void ShadeXImage(rxvt_term *term, XImage *srcImage, int shade, int rm, int gm, int bm);
1025	# endif	1320	# endif
1026
1027		1321
1028	bool	1322	bool
1029	bgPixmap_t::render ()	1323	bgPixmap_t::render ()
1030	{	1324	{
1031	unsigned long background_flags = 0;	1325	unsigned long background_flags = 0;
…		…
1033	if (target == NULL)	1327	if (target == NULL)
1034	return false;	1328	return false;
1035		1329
1036	TIMING_TEST_START (tp);	1330	TIMING_TEST_START (tp);
1037		1331
1038	invalidate();	1332	invalidate ();
1039	# ifdef ENABLE_TRANSPARENCY	1333	# ifdef ENABLE_TRANSPARENCY
1040	if (flags & isTransparent)	1334	if (flags & isTransparent)
1041	{	1335	{
1042	/* we need to re-generate transparency pixmap in that case ! */	1336	/* we need to re-generate transparency pixmap in that case ! */
1043	background_flags = make_transparency_pixmap ();	1337	background_flags = make_transparency_pixmap ();
1044	if (background_flags == 0)	1338	if (background_flags == 0)
1045	return false;	1339	return false;
1046	else if ((background_flags & transpTransformations) == (flags & transpTransformations)	1340	else if ((background_flags & transpTransformations) == (flags & transpTransformations)
1047	&& pmap_depth == target->depth)	1341	&& pmap_depth == target->depth)
1048	flags = flags & ~isInvalid;	1342	flags = flags & ~isInvalid;
1049	}	1343	}
1050	# endif	1344	# endif
1051		1345
		1346	# ifdef BG_IMAGE_FROM_FILE
		1347	if (have_image
		1348	|| (background_flags & transpTransformations) != (flags & transpTransformations))
		1349	{
		1350	if (render_image (background_flags))
		1351	flags = flags & ~isInvalid;
		1352	}
		1353	# endif
		1354
1052	XImage *result = NULL;	1355	XImage *result = NULL;
1053	# ifdef HAVE_AFTERIMAGE	1356
1054	if (original_asim	1357	if (background_flags && (flags & isInvalid))
1055	|| (background_flags & transpTransformations) != (flags & transpTransformations))	1358	{
		1359	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1056	{	1360	}
1057	ASImage *background = NULL;
1058	ARGB32 as_tint = TINT_LEAVE_SAME;
1059	if (background_flags)
1060	background = pixmap2ximage (target->asv, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, 100);
1061		1361
1062	# ifdef ENABLE_TRANSPARENCY	1362	if (result)
		1363	{
		1364	# if !defined(HAVE_AFTERIMAGE) && !XFT
		1365	/* our own client-side tinting */
		1366	/* ATTENTION: We ASSUME that XFT will let us do all the tinting necessary server-side.
		1367	This may need to be changed in need_client_side_rendering() logic is altered !!! */
1063	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))	1368	if (!(background_flags & transpPmapTinted) && (flags & tintNeeded))
1064	{
1065	ShadingInfo as_shade;
1066	as_shade.shading = (shade == 0) ? 100 : shade;
1067
1068	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1069	if (flags & tintSet)
1070	tint.get (c);
1071	as_shade.tintColor.red = c.r;
1072	as_shade.tintColor.green = c.g;
1073	as_shade.tintColor.blue = c.b;
1074
1075	as_tint = shading2tint32 (&as_shade);
1076	}
1077	if (!(background_flags & transpPmapBlured) && (flags & blurNeeded) && background != NULL)
1078	{
1079	ASImage* tmp = blur_asimage_gauss (target->asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
1080	(original_asim == NULL || tint == TINT_LEAVE_SAME)?ASA_XImage:ASA_ASImage,
1081	100, ASIMAGE_QUALITY_DEFAULT);
1082	if (tmp)
1083	{
1084	destroy_asimage (&background);
1085	background = tmp;
1086	}
1087	}
1088	# endif
1089
1090	if (render_asim (background, as_tint))
1091	flags = flags & ~isInvalid;
1092	if (background)
1093	destroy_asimage (&background);
1094	}
1095	else if (background_flags && pmap_depth != target->depth)
1096	{
1097	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1098	}
1099	# else /* our own client-side tinting */
1100	if (background_flags && (flags & isInvalid))
1101	{
1102	result = XGetImage (target->dpy, pixmap, 0, 0, pmap_width, pmap_height, AllPlanes, ZPixmap);
1103	if (result != NULL && !(background_flags & transpPmapTinted) && (flags & tintNeeded))
1104	{	1369	{
1105	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	1370	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1106	if (flags & tintSet)	1371	if (flags & tintSet)
1107	tint.get (c);	1372	tint.get (c);
1108	ShadeXImage (target, result, shade, c.r, c.g, c.b);	1373	ShadeXImage (target, result, shade, c.r, c.g, c.b);
1109	}	1374	}
1110	}	1375	# endif
1111	# endif /* HAVE_AFTERIMAGE */
1112		1376
1113	if (result != NULL)
1114	{
1115	GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);	1377	GC gc = XCreateGC (target->dpy, target->vt, 0UL, NULL);
		1378
1116	if (gc)	1379	if (gc)
1117	{	1380	{
1118	if (/*pmap_depth != target->depth &&*/ pixmap != None)	1381	if (/*pmap_depth != target->depth &&*/ pixmap != None)
1119	{	1382	{
1120	XFreePixmap (target->dpy, pixmap);	1383	XFreePixmap (target->dpy, pixmap);
1121	pixmap = None;	1384	pixmap = None;
1122	}	1385	}
		1386
1123	if (pixmap == None)	1387	if (pixmap == None)
1124	{	1388	{
1125	pixmap = XCreatePixmap (target->dpy, target->vt, result->width, result->height, target->depth);	1389	pixmap = XCreatePixmap (target->dpy, target->vt, result->width, result->height, target->depth);
1126	pmap_width = result->width;	1390	pmap_width = result->width;
1127	pmap_height = result->height;	1391	pmap_height = result->height;
1128	pmap_depth = target->depth;	1392	pmap_depth = target->depth;
1129	}	1393	}
		1394
1130	if (pmap_depth != result->depth)	1395	if (pmap_depth != result->depth)
		1396	{
1131	{ /* Bad Match error will ensue ! stupid X !!!! */	1397	/* Bad Match error will ensue ! stupid X !!!! */
1132	if( result->depth == 24 && pmap_depth == 32)	1398	if (result->depth == 24 && pmap_depth == 32)
1133	result->depth = 32;	1399	result->depth = 32;
1134	else if( result->depth == 32 && pmap_depth == 24)	1400	else if (result->depth == 32 && pmap_depth == 24)
1135	result->depth = 24;	1401	result->depth = 24;
1136	else	1402	else
1137	{	1403	{
1138	/* TODO: implement image recoding */	1404	/* TODO: implement image recoding */
1139	}	1405	}
1140	}	1406	}
		1407
1141	if (pmap_depth == result->depth)	1408	if (pmap_depth == result->depth)
1142	XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);	1409	XPutImage (target->dpy, pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
		1410
1143	XFreeGC (target->dpy, gc);	1411	XFreeGC (target->dpy, gc);
1144	flags = flags & ~isInvalid;	1412	flags = flags & ~isInvalid;
1145	}	1413	}
		1414
1146	XDestroyImage (result);	1415	XDestroyImage (result);
1147	}	1416	}
1148		1417
1149	if (flags & isInvalid)	1418	if (flags & isInvalid)
1150	{	1419	{
1151	if (pixmap != None)	1420	if (pixmap != None)
…		…
1155	}	1424	}
1156	}	1425	}
1157		1426
1158	apply ();	1427	apply ();
1159		1428
		1429	XSync (target->dpy, False);
		1430	valid_since = ev::now ();
		1431
1160	TIMING_TEST_PRINT_RESULT (tp);	1432	TIMING_TEST_PRINT_RESULT (tp);
1161		1433
1162	return true;	1434	return true;
1163	}	1435	}
1164		1436
1165	bool	1437	bool
1166	bgPixmap_t::set_target (rxvt_term *new_target)	1438	bgPixmap_t::set_target (rxvt_term *new_target)
1167	{	1439	{
1168	if (new_target)	1440	if (new_target)
1169	if (target != new_target)	1441	if (target != new_target)
1170	{	1442	{
…		…
1172	# ifdef ENABLE_TRANSPARENCY	1444	# ifdef ENABLE_TRANSPARENCY
1173	root_depth = DefaultDepthOfScreen (ScreenOfDisplay (target->dpy, target->display->screen));	1445	root_depth = DefaultDepthOfScreen (ScreenOfDisplay (target->dpy, target->display->screen));
1174	# endif	1446	# endif
1175	return true;	1447	return true;
1176	}	1448	}
		1449
1177	return false;	1450	return false;
1178	}	1451	}
1179		1452
1180	void	1453	void
1181	bgPixmap_t::apply()	1454	bgPixmap_t::apply ()
1182	{	1455	{
1183	if (target)	1456	if (target)
1184	{	1457	{
1185	flags &= ~isVtOrigin;	1458	flags &= ~isVtOrigin;
		1459
1186	if (pixmap != None)	1460	if (pixmap != None)
		1461	{
1187	{ /* set target's background to pixmap */	1462	/* set target's background to pixmap */
1188	# ifdef ENABLE_TRANSPARENCY	1463	# ifdef ENABLE_TRANSPARENCY
1189	if (flags & isTransparent)	1464	if (flags & isTransparent)
1190	{	1465	{
1191	XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);	1466	XSetWindowBackgroundPixmap (target->dpy, target->parent[0], pixmap);
1192	XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);	1467	XSetWindowBackgroundPixmap (target->dpy, target->vt, ParentRelative);
1193	# if HAVE_SCROLLBARS	1468
1194	if (target->scrollBar.win)	1469	if (target->scrollBar.win)
1195	XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);	1470	XSetWindowBackgroundPixmap (target->dpy, target->scrollBar.win, ParentRelative);
1196	# endif
1197	}	1471	}
1198	else	1472	else
1199	# endif	1473	# endif
1200	{	1474	{
1201	flags |= isVtOrigin;	1475	flags |= isVtOrigin;
1202	/* force old pixmap dereference in case it was transparent before :*/	1476	/* force old pixmap dereference in case it was transparent before :*/
1203	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);	1477	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1204	XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);	1478	XSetWindowBackgroundPixmap (target->dpy, target->vt, pixmap);
1205	/* do we also need to set scrollbar's background here ? */	1479	/* do we also need to set scrollbar's background here ? */
1206	# if HAVE_SCROLLBARS	1480
1207	if (target->scrollBar.win)	1481	if (target->scrollBar.win)
1208	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);	1482	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1209	# endif
1210	}	1483	}
1211	}	1484	}
1212	else	1485	else
		1486	{
1213	{ /* set target background to a pixel */	1487	/* set target background to a pixel */
1214	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);	1488	XSetWindowBackground (target->dpy, target->parent[0], target->pix_colors[Color_border]);
1215	XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);	1489	XSetWindowBackground (target->dpy, target->vt, target->pix_colors[Color_bg]);
1216	/* do we also need to set scrollbar's background here ? */	1490	/* do we also need to set scrollbar's background here ? */
1217	# if HAVE_SCROLLBARS
1218	if (target->scrollBar.win)	1491	if (target->scrollBar.win)
1219	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);	1492	XSetWindowBackground (target->dpy, target->scrollBar.win, target->pix_colors[Color_border]);
1220	# endif
1221	}	1493	}
		1494
1222	/* don't want Expose on the parent or vt. It is better to use	1495	/* don't want Expose on the parent or vt. It is better to use
1223	scr_touch or we get a great deal of flicker otherwise: */	1496	scr_touch or we get a great deal of flicker otherwise: */
1224	XClearWindow (target->dpy, target->parent[0]);	1497	XClearWindow (target->dpy, target->parent[0]);
1225		1498
1226	# if HAVE_SCROLLBARS	1499	if (target->scrollBar.state && target->scrollBar.win)
1227	if (target->scrollBar.win)
1228	{	1500	{
1229	target->scrollBar.setIdle ();	1501	target->scrollBar.state = STATE_IDLE;
1230	target->scrollbar_show (0);	1502	target->scrollBar.show (0);
1231	}	1503	}
1232	# endif
1233		1504
1234	target->want_refresh = 1;	1505	target->want_refresh = 1;
1235	flags |= hasChanged;	1506	flags |= hasChanged;
1236	}	1507	}
1237	}	1508	}
1238		1509
1239	#endif /* HAVE_BG_PIXMAP */	1510	#endif /* HAVE_BG_PIXMAP */
1240		1511
1241	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1512	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) && !XFT
1242	/* taken from aterm-0.4.2 */	1513	/* taken from aterm-0.4.2 */
1243		1514
1244	typedef uint32_t RUINT32T;	1515	typedef uint32_t RUINT32T;
1245		1516
1246	static void	1517	static void
1247	ShadeXImage(rxvt_term *term, XImage* srcImage, int shade, int rm, int gm, int bm)	1518	ShadeXImage(rxvt_term *term, XImage *srcImage, int shade, int rm, int gm, int bm)
1248	{	1519	{
1249	int sh_r, sh_g, sh_b;	1520	int sh_r, sh_g, sh_b;
1250	RUINT32T mask_r, mask_g, mask_b;	1521	RUINT32T mask_r, mask_g, mask_b;
1251	RUINT32T *lookup, *lookup_r, *lookup_g, *lookup_b;	1522	RUINT32T *lookup, *lookup_r, *lookup_g, *lookup_b;
1252	unsigned int lower_lim_r, lower_lim_g, lower_lim_b;	1523	unsigned int lower_lim_r, lower_lim_g, lower_lim_b;

Diff Legend

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