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.196 by sf-exg, Tue Jan 10 18:50:14 2012 UTC

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

Diff Legend

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