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

Diff Legend

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