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.204 by sf-exg, Tue Apr 10 15:19:22 2012 UTC vs.
Revision 1.247 by sf-exg, Sat Dec 29 18:12:53 2012 UTC

1	/*----------------------------------------------------------------------*	1	/*----------------------------------------------------------------------*
2	* File: background.C - former xpm.C	2	* File: background.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 <schmorp@schmorp.de>	6	* Copyright (c) 2005-2008 Marc Lehmann <schmorp@schmorp.de>
7	* Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>	7	* Copyright (c) 2007 Sasha Vasko <sasha@aftercode.net>
8	* Copyright (c) 2010 Emanuele Giaquinta <e.giaquinta@glauco.it>	8	* Copyright (c) 2010-2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
9	*	9	*
10	* This program is free software; you can redistribute it and/or modify	10	* This program is free software; you can redistribute it and/or modify
11	* it under the terms of the GNU General Public License as published by	11	* it under the terms of the GNU General Public License as published by
12	* the Free Software Foundation; either version 2 of the License, or	12	* the Free Software Foundation; either version 2 of the License, or
13	* (at your option) any later version.	13	* (at your option) any later version.
…		…
20	* You should have received a copy of the GNU General Public License	20	* You should have received a copy of the GNU General Public License
21	* along with this program; if not, write to the Free Software	21	* along with this program; if not, write to the Free Software
22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	22	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23	*---------------------------------------------------------------------*/	23	*---------------------------------------------------------------------*/
24		24
25	#include <math.h>
26	#include "../config.h" /* NECESSARY */	25	#include "../config.h" /* NECESSARY */
27	#include "rxvt.h" /* NECESSARY */	26	#include "rxvt.h" /* NECESSARY */
28		27
29	#if XRENDER
30	# include <X11/extensions/Xrender.h>
31	#endif
32
33	#ifndef FilterConvolution
34	#define FilterConvolution "convolution"
35	#endif
36
37	#ifndef RepeatPad
38	#define RepeatPad True
39	#endif
40
41	#ifdef HAVE_BG_PIXMAP	28	#ifdef HAVE_BG_PIXMAP
42	# if XRENDER
43	static Picture
44	create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
45	{
46	Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
47
48	XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
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	}
58	# endif
59		29
60	void	30	void
61	rxvt_term::bg_destroy ()	31	rxvt_term::bg_destroy ()
62	{	32	{
63	#ifdef HAVE_PIXBUF	33	# if BG_IMAGE_FROM_ROOT
64	if (pixbuf)	34	delete root_img;
65	g_object_unref (pixbuf);	35	root_img = 0;
66	#endif	36	# endif
67		37
68	if (bg_pixmap)	38	# if BG_IMAGE_FROM_FILE
69	XFreePixmap (dpy, bg_pixmap);	39	fimage.destroy ();
70	}	40	# endif
71		41
72	bool	42	delete bg_img;
73	rxvt_term::bg_set_position (int x, int y)	43	bg_img = 0;
74	{	44	}
75		45
76	if (target_x != x	46	bool
77	|| target_y != y)	47	rxvt_term::bg_window_size_sensitive ()
		48	{
		49	# if BG_IMAGE_FROM_ROOT
		50	if (option (Opt_transparent))
		51	return true;
		52	# endif
		53
		54	# if BG_IMAGE_FROM_FILE
		55	if (fimage.img)
78	{	56	{
79	target_x = x;	57	if ((fimage.flags & IM_IS_SIZE_SENSITIVE)
80	target_y = y;	58	|| fimage.img->w > szHint.width
		59	|| fimage.img->h > szHint.height)
81	return true;	60	return true;
82	}	61	}
		62	# endif
		63
83	return false;	64	return false;
84	}	65	}
85		66
86	bool	67	bool
87	rxvt_term::bg_window_size_sensitive ()	68	rxvt_term::bg_window_position_sensitive ()
88	{	69	{
89	# ifdef ENABLE_TRANSPARENCY	70	# if BG_IMAGE_FROM_ROOT
90	if (bg_flags & BG_IS_TRANSPARENT)	71	if (option (Opt_transparent))
91	return true;	72	return true;
92	# endif	73	# endif
93		74
94	# ifdef BG_IMAGE_FROM_FILE	75	# if BG_IMAGE_FROM_FILE
95	if (bg_flags & BG_IS_FROM_FILE)	76	if (fimage.img)
96	{	77	{
97	if (bg_flags & BG_IS_SIZE_SENSITIVE)	78	if (fimage.flags & IM_ROOT_ALIGN)
98	return true;	79	return true;
99	}	80	}
100	# endif	81	# endif
101		82
102	return false;	83	return false;
103	}	84	}
104		85
105	bool
106	rxvt_term::bg_window_position_sensitive ()
107	{
108	# ifdef ENABLE_TRANSPARENCY
109	if (bg_flags & BG_IS_TRANSPARENT)
110	return true;
111	# endif
112
113	# ifdef BG_IMAGE_FROM_FILE	86	# if BG_IMAGE_FROM_FILE
114	if (bg_flags & BG_IS_FROM_FILE)
115	{
116	if (bg_flags & BG_ROOT_ALIGN)
117	return true;
118	}
119	# endif
120
121	return false;
122	}
123
124	# ifdef BG_IMAGE_FROM_FILE
125	static inline int	87	static inline int
126	make_align_position (int align, int window_size, int image_size)	88	make_align_position (int align, int window_size, int image_size)
127	{	89	{
128	int diff = window_size - image_size;
129	int smaller = min (image_size, window_size);
130
131	if (align >= 0 && align <= 100)	90	if (align >= 0 && align <= 100)
132	return diff * align / 100;	91	return lerp (0, window_size - image_size, align);
133	else if (align > 100 && align <= 200)	92	else if (align > 100)
134	return (align - 100) * smaller / 100 + window_size - smaller;	93	return lerp (window_size - image_size, window_size, align - 100);
135	else if (align >= -100 && align < 0)	94	else
136	return (align + 100) * smaller / 100 - image_size;	95	return lerp (-image_size, 0, align + 100);
137	return 0;
138	}	96	}
139		97
140	static inline int	98	static void
141	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	99	parse_style (const char *style, int &x, int &y, unsigned int &w, unsigned int &h, uint8_t &flags)
142	{	100	{
143	int src_pos = 0;	101	if (!strcasecmp (style, "tiled"))
144	dst_pos = pos;
145	dst_size = size;
146	if (pos < 0)
147	{
148	src_pos = -pos;
149	dst_pos = 0;
150	dst_size += pos;
151	}	102	{
152		103	flags = IM_TILE;
153	min_it (dst_size, target_size - dst_pos);	104	w = h = noScale;
154	return src_pos;	105	x = y = 0;
		106	}
		107	else if (!strcasecmp (style, "aspect-stretched"))
		108	{
		109	flags = IM_KEEP_ASPECT;
		110	w = h = windowScale;
		111	x = y = centerAlign;
		112	}
		113	else if (!strcasecmp (style, "stretched"))
		114	{
		115	flags = 0;
		116	w = h = windowScale;
		117	x = y = centerAlign;
		118	}
		119	else if (!strcasecmp (style, "centered"))
		120	{
		121	flags = 0;
		122	w = h = noScale;
		123	x = y = centerAlign;
		124	}
		125	else if (!strcasecmp (style, "root-tiled"))
		126	{
		127	flags = IM_TILE|IM_ROOT_ALIGN;
		128	w = h = noScale;
		129	x = y = 0;
		130	}
155	}	131	}
156		132
157	bool	133	bool
158	rxvt_term::bg_set_geometry (const char *geom, bool update)	134	rxvt_image::set_geometry (const char *geom, bool update)
159	{	135	{
160	bool changed = false;	136	bool changed = false;
161	int geom_flags = 0;	137	int geom_flags = 0;
162	int x = h_align;	138	int x = h_align;
163	int y = v_align;	139	int y = v_align;
164	unsigned int w = h_scale;	140	unsigned int w = h_scale;
165	unsigned int h = v_scale;	141	unsigned int h = v_scale;
166	unsigned long new_flags = 0;	142	uint8_t new_flags = 0;
167		143
168	if (geom == NULL)	144	if (geom == NULL)
169	return false;	145	return false;
170		146
171	if (geom[0])	147	if (geom[0])
172	{	148	{
173	char **arr = rxvt_strsplit (':', geom);	149	char **arr = rxvt_strsplit (':', geom);
174		150
175	for (int i = 0; arr[i]; i++)	151	for (int i = 0; arr[i]; i++)
176	{	152	{
177	if (!strcasecmp (arr[i], "style=tiled"))	153	if (!strncasecmp (arr[i], "style=", 6))
178	{	154	{
179	new_flags = BG_TILE;	155	parse_style (arr[i] + 6, x, y, w, h, new_flags);
180	w = h = noScale;
181	x = y = 0;
182	geom_flags = WidthValue|HeightValue|XValue|YValue;	156	geom_flags = WidthValue|HeightValue|XValue|YValue;
183	}	157	}
184	else if (!strcasecmp (arr[i], "style=aspect-stretched"))
185	{
186	new_flags = BG_KEEP_ASPECT;
187	w = h = windowScale;
188	x = y = centerAlign;
189	geom_flags = WidthValue|HeightValue|XValue|YValue;
190	}
191	else if (!strcasecmp (arr[i], "style=stretched"))
192	{
193	new_flags = 0;
194	w = h = windowScale;
195	geom_flags = WidthValue|HeightValue;
196	}
197	else if (!strcasecmp (arr[i], "style=centered"))
198	{
199	new_flags = 0;
200	w = h = noScale;
201	x = y = centerAlign;
202	geom_flags = WidthValue|HeightValue|XValue|YValue;
203	}
204	else if (!strcasecmp (arr[i], "style=root-tiled"))
205	{
206	new_flags = BG_TILE|BG_ROOT_ALIGN;
207	w = h = noScale;
208	geom_flags = WidthValue|HeightValue;
209	}
210	else if (!strcasecmp (arr[i], "op=tile"))	158	else if (!strcasecmp (arr[i], "op=tile"))
211	new_flags |= BG_TILE;	159	new_flags |= IM_TILE;
212	else if (!strcasecmp (arr[i], "op=keep-aspect"))	160	else if (!strcasecmp (arr[i], "op=keep-aspect"))
213	new_flags |= BG_KEEP_ASPECT;	161	new_flags |= IM_KEEP_ASPECT;
214	else if (!strcasecmp (arr[i], "op=root-align"))	162	else if (!strcasecmp (arr[i], "op=root-align"))
215	new_flags |= BG_ROOT_ALIGN;	163	new_flags |= IM_ROOT_ALIGN;
216		164
217	// deprecated	165	// deprecated
218	else if (!strcasecmp (arr[i], "tile"))	166	else if (!strcasecmp (arr[i], "tile"))
219	{	167	{
220	new_flags |= BG_TILE;	168	new_flags |= IM_TILE;
221	w = h = noScale;	169	w = h = noScale;
222	geom_flags |= WidthValue|HeightValue;	170	geom_flags |= WidthValue|HeightValue;
223	}	171	}
224	else if (!strcasecmp (arr[i], "propscale"))	172	else if (!strcasecmp (arr[i], "propscale"))
225	{	173	{
226	new_flags |= BG_KEEP_ASPECT;	174	new_flags |= IM_KEEP_ASPECT;
227	w = h = windowScale;	175	w = h = windowScale;
228	geom_flags |= WidthValue|HeightValue;	176	geom_flags |= WidthValue|HeightValue;
229	}	177	}
230	else if (!strcasecmp (arr[i], "hscale"))	178	else if (!strcasecmp (arr[i], "hscale"))
231	{	179	{
232	new_flags |= BG_TILE;	180	new_flags |= IM_TILE;
233	w = windowScale;	181	w = windowScale;
234	h = noScale;	182	h = noScale;
235	geom_flags |= WidthValue|HeightValue;	183	geom_flags |= WidthValue|HeightValue;
236	}	184	}
237	else if (!strcasecmp (arr[i], "vscale"))	185	else if (!strcasecmp (arr[i], "vscale"))
238	{	186	{
239	new_flags |= BG_TILE;	187	new_flags |= IM_TILE;
240	h = windowScale;	188	h = windowScale;
241	w = noScale;	189	w = noScale;
242	geom_flags |= WidthValue|HeightValue;	190	geom_flags |= WidthValue|HeightValue;
243	}	191	}
244	else if (!strcasecmp (arr[i], "scale"))	192	else if (!strcasecmp (arr[i], "scale"))
…		…
252	x = y = centerAlign;	200	x = y = centerAlign;
253	geom_flags |= WidthValue|HeightValue|XValue|YValue;	201	geom_flags |= WidthValue|HeightValue|XValue|YValue;
254	}	202	}
255	else if (!strcasecmp (arr[i], "root"))	203	else if (!strcasecmp (arr[i], "root"))
256	{	204	{
257	new_flags |= BG_TILE|BG_ROOT_ALIGN;	205	new_flags |= IM_TILE|IM_ROOT_ALIGN;
258	w = h = noScale;	206	w = h = noScale;
259	geom_flags |= WidthValue|HeightValue;	207	geom_flags |= WidthValue|HeightValue;
260	}	208	}
261		209
262	else	210	else
…		…
264	} /* done parsing ops */	212	} /* done parsing ops */
265		213
266	rxvt_free_strsplit (arr);	214	rxvt_free_strsplit (arr);
267	}	215	}
268		216
269	new_flags |= bg_flags & ~BG_GEOMETRY_FLAGS;	217	new_flags |= flags & ~IM_GEOMETRY_FLAGS;
270		218
271	if (!update)	219	if (!update)
272	{	220	{
273	if (!(geom_flags & XValue))	221	if (!(geom_flags & XValue))
274	x = y = defaultAlign;	222	x = y = defaultAlign;
…		…
281	h = w;	229	h = w;
282	else if (!(geom_flags & WidthValue))	230	else if (!(geom_flags & WidthValue))
283	w = h;	231	w = h;
284	}	232	}
285		233
286	min_it (w, 1000);
287	min_it (h, 1000);
288	clamp_it (x, -100, 200);	234	clamp_it (x, -100, 200);
289	clamp_it (y, -100, 200);	235	clamp_it (y, -100, 200);
290		236
291	if (bg_flags != new_flags	237	if (flags != new_flags
292	|| h_scale != w	238	|| h_scale != w
293	|| v_scale != h	239	|| v_scale != h
294	|| h_align != x	240	|| h_align != x
295	|| v_align != y)	241	|| v_align != y)
296	{	242	{
297	bg_flags = new_flags;	243	flags = new_flags;
298	h_scale = w;	244	h_scale = w;
299	v_scale = h;	245	v_scale = h;
300	h_align = x;	246	h_align = x;
301	v_align = y;	247	v_align = y;
302	changed = true;	248	changed = true;
303	}	249	}
304		250
		251	if (is_size_sensitive ())
		252	flags |= IM_IS_SIZE_SENSITIVE;
		253	else
		254	flags &= ~IM_IS_SIZE_SENSITIVE;
		255
305	return changed;	256	return changed;
306	}	257	}
307		258
308	void	259	void
309	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)	260	rxvt_term::get_image_geometry (rxvt_image &image, int &w, int &h, int &x, int &y)
310	{	261	{
		262	int image_width = image.img->w;
		263	int image_height = image.img->h;
311	int target_width = szHint.width;	264	int parent_width = szHint.width;
312	int target_height = szHint.height;	265	int parent_height = szHint.height;
		266	int h_scale = min (image.h_scale, 32767 * 100 / parent_width);
		267	int v_scale = min (image.v_scale, 32767 * 100 / parent_height);
313		268
314	w = h_scale * target_width / 100;	269	w = h_scale * parent_width / 100;
315	h = v_scale * target_height / 100;	270	h = v_scale * parent_height / 100;
316		271
317	if (bg_flags & BG_KEEP_ASPECT)	272	if (image.flags & IM_KEEP_ASPECT)
318	{	273	{
319	float scale = (float)w / image_width;	274	float scale = (float)w / image_width;
320	min_it (scale, (float)h / image_height);	275	min_it (scale, (float)h / image_height);
321	w = image_width * scale + 0.5;	276	w = image_width * scale + 0.5;
322	h = image_height * scale + 0.5;	277	h = image_height * scale + 0.5;
323	}	278	}
324		279
325	if (!w) w = image_width;	280	if (!w) w = image_width;
326	if (!h) h = image_height;	281	if (!h) h = image_height;
327		282
328	if (bg_flags & BG_ROOT_ALIGN)	283	if (image.flags & IM_ROOT_ALIGN)
329	{	284	{
330	x = -target_x;	285	x = -parent_x;
331	y = -target_y;	286	y = -parent_y;
332	}	287	}
333	else	288	else
334	{	289	{
335	x = make_align_position (h_align, target_width, w);	290	x = make_align_position (image.h_align, parent_width, w);
336	y = make_align_position (v_align, target_height, h);	291	y = make_align_position (image.v_align, parent_height, h);
337	}
338
339	if (!(bg_flags & BG_TILE)
340	|| h_scale || v_scale
341	|| (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
342	|| image_width > target_width || image_height > target_height)
343	bg_flags |= BG_IS_SIZE_SENSITIVE;
344	else
345	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
346	}
347
348	# ifdef HAVE_PIXBUF
349	bool
350	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
351	int src_x, int src_y, int dst_x, int dst_y,
352	unsigned int width, unsigned int height)
353	{
354	XImage *ximage;
355	char *data, *line;
356	int bytes_per_pixel;
357	int width_r, width_g, width_b;
358	int sh_r, sh_g, sh_b;
359	int rowstride;
360	int channels;
361	unsigned char *row;
362
363	if (visual->c_class != TrueColor)
364	return false;
365
366	if (depth == 24 || depth == 32)
367	bytes_per_pixel = 4;
368	else if (depth == 15 || depth == 16)
369	bytes_per_pixel = 2;
370	else
371	return false;
372
373	width_r = ecb_popcount32 (visual->red_mask);
374	width_g = ecb_popcount32 (visual->green_mask);
375	width_b = ecb_popcount32 (visual->blue_mask);
376
377	if (width_r > 8 || width_g > 8 || width_b > 8)
378	return false;
379
380	sh_r = ecb_ctz32 (visual->red_mask);
381	sh_g = ecb_ctz32 (visual->green_mask);
382	sh_b = ecb_ctz32 (visual->blue_mask);
383
384	if (width > INT_MAX / height / bytes_per_pixel)
385	return false;
386
387	data = (char *)malloc (width * height * bytes_per_pixel);
388	if (!data)
389	return false;
390
391	ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, data,
392	width, height, bytes_per_pixel * 8, 0);
393	if (!ximage)
394	{	292	}
395	free (data);
396	return false;
397	}
398
399	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
400
401	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
402	channels = gdk_pixbuf_get_n_channels (pixbuf);
403	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
404	line = data;
405
406	for (int y = 0; y < height; y++)
407	{
408	for (int x = 0; x < width; x++)
409	{
410	unsigned char *pixel = row + x * channels;
411	uint32_t value;
412
413	value = ((pixel[0] >> (8 - width_r)) << sh_r)
414	| ((pixel[1] >> (8 - width_g)) << sh_g)
415	| ((pixel[2] >> (8 - width_b)) << sh_b);
416
417	if (bytes_per_pixel == 4)
418	((uint32_t *)line)[x] = value;
419	else
420	((uint16_t *)line)[x] = value;
421	}
422
423	row += rowstride;
424	line += ximage->bytes_per_line;
425	}
426
427	XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
428	XDestroyImage (ximage);
429	return true;
430	}	293	}
431		294
432	bool	295	bool
433	rxvt_term::render_image (bool transparent)	296	rxvt_term::render_image (rxvt_image &image)
434	{	297	{
435	if (!pixbuf)
436	return false;
437
438	if (transparent
439	&& !(bg_flags & BG_HAS_RENDER))
440	return false;
441
442	GdkPixbuf *result;
443
444	int image_width = gdk_pixbuf_get_width (pixbuf);
445	int image_height = gdk_pixbuf_get_height (pixbuf);
446
447	int target_width = szHint.width;	298	int parent_width = szHint.width;
448	int target_height = szHint.height;	299	int parent_height = szHint.height;
449	int new_pmap_width = target_width;
450	int new_pmap_height = target_height;
451		300
452	int x = 0;	301	int x = 0;
453	int y = 0;	302	int y = 0;
454	int w = 0;	303	int w = 0;
455	int h = 0;	304	int h = 0;
456		305
457	get_image_geometry (image_width, image_height, w, h, x, y);	306	get_image_geometry (image, w, h, x, y);
458		307
459	if (!(bg_flags & BG_ROOT_ALIGN)	308	if (!(image.flags & IM_ROOT_ALIGN)
460	&& (x >= target_width	309	&& (x >= parent_width
461	|| y >= target_height	310	|| y >= parent_height
462	|| x + w <= 0	311	|| x + w <= 0
463	|| y + h <= 0))	312	|| y + h <= 0))
464	return false;	313	return false;
465		314
466	result = pixbuf;	315	rxvt_img *img = image.img->scale (w, h);
467		316
468	if (w != image_width	317	if (image.flags & IM_TILE)
469	|| h != image_height)	318	img->repeat_mode (RepeatNormal);
470	{
471	result = gdk_pixbuf_scale_simple (pixbuf,
472	w, h,
473	GDK_INTERP_BILINEAR);
474	}
475
476	if (!result)
477	return false;
478
479	bool ret = false;
480
481	XGCValues gcv;
482	GC gc;
483	Pixmap root_pmap;
484
485	image_width = gdk_pixbuf_get_width (result);
486	image_height = gdk_pixbuf_get_height (result);
487
488	if (transparent)
489	{
490	root_pmap = bg_pixmap;
491	bg_pixmap = None;
492	}
493	else	319	else
494	{	320	img->repeat_mode (RepeatNone);
		321	img->sub_rect (-x, -y, parent_width, parent_height)->replace (img);
		322
495	if (bg_flags & BG_TILE)	323	if (bg_flags & BG_IS_VALID)
496	{	324	img->draw (bg_img, PictOpOver, image.alpha * 1. / 0xffff);
497	new_pmap_width = min (image_width, target_width);
498	new_pmap_height = min (image_height, target_height);
499	}
500	}
501		325
502	if (bg_pixmap == None
503	|| bg_pmap_width != new_pmap_width
504	|| bg_pmap_height != new_pmap_height)
505	{
506	if (bg_pixmap)
507	XFreePixmap (dpy, bg_pixmap);
508	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
509	bg_pmap_width = new_pmap_width;
510	bg_pmap_height = new_pmap_height;
511	}
512
513	gcv.foreground = pix_colors[Color_bg];
514	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
515
516	if (gc)
517	{
518	if (bg_flags & BG_TILE)
519	{
520	Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);
521	pixbuf_to_pixmap (result, tile, gc,
522	0, 0,
523	0, 0,
524	image_width, image_height);
525
526	gcv.tile = tile;
527	gcv.fill_style = FillTiled;
528	gcv.ts_x_origin = x;
529	gcv.ts_y_origin = y;
530	XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
531
532	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
533	XFreePixmap (dpy, tile);
534	}
535	else
536	{
537	int src_x, src_y, dst_x, dst_y;
538	int dst_width, dst_height;
539
540	src_x = make_clip_rectangle (x, image_width , new_pmap_width , dst_x, dst_width );
541	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
542
543	if (dst_x > 0 || dst_y > 0
544	|| dst_x + dst_width < new_pmap_width
545	|| dst_y + dst_height < new_pmap_height)
546	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
547
548	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
549	pixbuf_to_pixmap (result, bg_pixmap, gc,
550	src_x, src_y,
551	dst_x, dst_y,
552	dst_width, dst_height);
553	}
554
555	#if XRENDER
556	if (transparent)
557	{
558	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	326	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		327	img->convert_format (format, pix_colors [Color_bg])->replace (img);
559		328
560	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);	329	delete bg_img;
		330	bg_img = img;
561		331
562	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
563
564	Picture mask = create_xrender_mask (dpy, vt, False, False);
565
566	XRenderColor mask_c;
567
568	mask_c.alpha = 0x8000;
569	mask_c.red =
570	mask_c.green =
571	mask_c.blue = 0;
572	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
573
574	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
575
576	XRenderFreePicture (dpy, src);
577	XRenderFreePicture (dpy, dst);
578	XRenderFreePicture (dpy, mask);
579	}
580	#endif
581
582	XFreeGC (dpy, gc);
583
584	ret = true;
585	}
586
587	if (result != pixbuf)
588	g_object_unref (result);
589
590	if (transparent)
591	XFreePixmap (dpy, root_pmap);
592
593	return ret;	332	return true;
594	}	333	}
595	# endif /* HAVE_PIXBUF */
596		334
597	bool	335	rxvt_image::rxvt_image ()
598	rxvt_term::bg_set_file (const char *file)	336	{
		337	alpha = 0xffff;
		338	flags = 0;
		339	h_scale =
		340	v_scale = defaultScale;
		341	h_align =
		342	v_align = defaultAlign;
		343
		344	img = 0;
		345	}
		346
		347	void
		348	rxvt_image::set_file_geometry (rxvt_screen *s, const char *file)
599	{	349	{
600	if (!file || !*file)	350	if (!file || !*file)
601	return false;	351	return;
602		352
603	bool ret = false;
604	const char *p = strchr (file, ';');	353	const char *p = strchr (file, ';');
605		354
606	if (p)	355	if (p)
607	{	356	{
608	size_t len = p - file;	357	size_t len = p - file;
…		…
610	memcpy (f, file, len);	359	memcpy (f, file, len);
611	f[len] = '\0';	360	f[len] = '\0';
612	file = f;	361	file = f;
613	}	362	}
614		363
615	# ifdef HAVE_PIXBUF	364	set_file (s, file);
616	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	365	alpha = 0x8000;
617	if (image)	366	set_geometry (p ? p + 1 : "");
618	{	367	}
619	if (pixbuf)
620	g_object_unref (pixbuf);
621	pixbuf = image;
622	bg_flags |= BG_IS_FROM_FILE;
623	ret = true;
624	}
625	# endif
626		368
627	if (ret)	369	void
628	{	370	rxvt_image::set_file (rxvt_screen *s, const char *file)
629	if (p)	371	{
630	bg_set_geometry (p + 1);	372	rxvt_img *img2 = rxvt_img::new_from_file (s, file);
631	else	373	delete img;
632	bg_set_default_geometry ();	374	img = img2;
633	}
634
635	return ret;
636	}	375	}
637		376
638	# endif /* BG_IMAGE_FROM_FILE */	377	# endif /* BG_IMAGE_FROM_FILE */
639		378
640	# ifdef ENABLE_TRANSPARENCY
641	bool	379	bool
642	rxvt_term::bg_set_transparent ()	380	image_effects::set_blur (const char *geom)
643	{
644	if (!(bg_flags & BG_IS_TRANSPARENT))
645	{
646	bg_flags |= BG_IS_TRANSPARENT;
647	return true;
648	}
649
650	return false;
651	}
652
653	bool
654	rxvt_term::bg_set_blur (const char *geom)
655	{	381	{
656	bool changed = false;	382	bool changed = false;
657	unsigned int hr, vr;	383	unsigned int hr, vr;
658	int junk;	384	int junk;
659	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);	385	int geom_flags = XParseGeometry (geom, &junk, &junk, &hr, &vr);
…		…
676	{	402	{
677	changed = true;	403	changed = true;
678	v_blurRadius = vr;	404	v_blurRadius = vr;
679	}	405	}
680		406
681	if (h_blurRadius && v_blurRadius)
682	bg_flags |= BG_NEEDS_BLUR;
683	else
684	bg_flags &= ~BG_NEEDS_BLUR;
685
686	return changed;	407	return changed;
687	}	408	}
688		409
689	void
690	rxvt_term::set_tint_shade_flags ()
691	{
692	if (shade != 100 || (bg_flags & BG_TINT_SET))
693	bg_flags |= BG_NEEDS_TINT;
694	else
695	bg_flags &= ~BG_NEEDS_TINT;
696	}
697
698	bool	410	bool
699	rxvt_term::bg_set_tint (rxvt_color &new_tint)	411	image_effects::set_tint (const rxvt_color &new_tint)
700	{	412	{
701	if (!(bg_flags & BG_TINT_SET) || tint != new_tint)	413	if (!tint_set || tint != new_tint)
702	{	414	{
703	tint = new_tint;	415	tint = new_tint;
704	bg_flags |= BG_TINT_SET;	416	tint_set = true;
705		417
706	rgba c;
707	tint.get (c);
708	if ((c.r <= 0x00ff || c.r >= 0xff00)
709	&& (c.g <= 0x00ff || c.g >= 0xff00)
710	&& (c.b <= 0x00ff || c.b >= 0xff00))
711	bg_flags |= BG_TINT_BITAND;
712	else
713	bg_flags &= ~BG_TINT_BITAND;
714
715	set_tint_shade_flags ();
716	return true;	418	return true;
717	}	419	}
718		420
719	return false;	421	return false;
720	}	422	}
721		423
722	bool	424	bool
723	rxvt_term::bg_set_shade (const char *shade_str)	425	image_effects::set_shade (const char *shade_str)
724	{	426	{
725	int new_shade = atoi (shade_str);	427	int new_shade = atoi (shade_str);
726		428
727	clamp_it (new_shade, -100, 200);	429	clamp_it (new_shade, -100, 200);
728	if (new_shade < 0)	430	if (new_shade < 0)
729	new_shade = 200 - (100 + new_shade);	431	new_shade = 200 - (100 + new_shade);
730		432
731	if (new_shade != shade)	433	if (new_shade != shade)
732	{	434	{
733	shade = new_shade;	435	shade = new_shade;
734	set_tint_shade_flags ();
735	return true;	436	return true;
736	}	437	}
737		438
738	return false;	439	return false;
739	}	440	}
740		441
741	#if XRENDER	442	# if BG_IMAGE_FROM_ROOT
742	static void
743	get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params)
744	{
745	double sigma = radius / 2.0;
746	double scale = sqrt (2.0 * M_PI) * sigma;
747	double sum = 0.0;
748
749	for (int i = 0; i < width; i++)
750	{
751	double x = i - width / 2;
752	kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;
753	sum += kernel[i];
754	}
755
756	params[0] = XDoubleToFixed (width);
757	params[1] = XDoubleToFixed (1);
758
759	for (int i = 0; i < width; i++)
760	params[i+2] = XDoubleToFixed (kernel[i] / sum);
761	}
762	#endif
763
764	bool
765	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
766	{
767	bool ret = false;
768	#if XRENDER
769	if (!(bg_flags & BG_HAS_RENDER_CONV))
770	return false;
771
772	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
773	double *kernel = (double *)malloc (size * sizeof (double));
774	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
775
776	XRenderPictureAttributes pa;
777	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
778
779	pa.repeat = RepeatPad;
780	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
781	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
782	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
783	XFreePixmap (dpy, tmp);
784
785	if (kernel && params)
786	{
787	size = h_blurRadius * 2 + 1;
788	get_gaussian_kernel (h_blurRadius, size, kernel, params);
789
790	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
791	XRenderComposite (dpy,
792	PictOpSrc,
793	src,
794	None,
795	dst,
796	0, 0,
797	0, 0,
798	0, 0,
799	width, height);
800
801	::swap (src, dst);
802
803	size = v_blurRadius * 2 + 1;
804	get_gaussian_kernel (v_blurRadius, size, kernel, params);
805	::swap (params[0], params[1]);
806
807	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
808	XRenderComposite (dpy,
809	PictOpSrc,
810	src,
811	None,
812	dst,
813	0, 0,
814	0, 0,
815	0, 0,
816	width, height);
817
818	ret = true;
819	}
820
821	free (kernel);
822	free (params);
823	XRenderFreePicture (dpy, src);
824	XRenderFreePicture (dpy, dst);
825	#endif
826	return ret;
827	}
828
829	bool
830	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
831	{
832	bool ret = false;
833
834	if (shade == 100 && (bg_flags & BG_TINT_BITAND))
835	{
836	XGCValues gcv;
837	GC gc;
838
839	/* In this case we can tint image server-side getting significant
840	* performance improvements, as we eliminate XImage transfer
841	*/
842	gcv.foreground = Pixel (tint);
843	gcv.function = GXand;
844	gcv.fill_style = FillSolid;
845	gc = XCreateGC (dpy, pixmap, GCFillStyle | GCForeground | GCFunction, &gcv);
846	if (gc)
847	{
848	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
849	ret = true;
850	XFreeGC (dpy, gc);
851	}
852	}
853	# if XRENDER
854	else if (bg_flags & BG_HAS_RENDER)
855	{
856	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
857
858	if (bg_flags & BG_TINT_SET)
859	tint.get (c);
860
861	if (shade <= 100)
862	{
863	c.r = c.r * shade / 100;
864	c.g = c.g * shade / 100;
865	c.b = c.b * shade / 100;
866	}
867	else
868	{
869	c.r = c.r * (200 - shade) / 100;
870	c.g = c.g * (200 - shade) / 100;
871	c.b = c.b * (200 - shade) / 100;
872	}
873
874	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
875
876	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
877
878	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
879
880	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
881
882	XRenderColor mask_c;
883
884	mask_c.alpha = 0xffff;
885	mask_c.red =
886	mask_c.green =
887	mask_c.blue = 0;
888	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
889
890	mask_c.alpha = 0;
891	mask_c.red = 0xffff - c.r;
892	mask_c.green = 0xffff - c.g;
893	mask_c.blue = 0xffff - c.b;
894	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
895
896	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
897
898	if (shade > 100)
899	{
900	mask_c.alpha = 0;
901	mask_c.red =
902	mask_c.green =
903	mask_c.blue = 0xffff * (shade - 100) / 100;
904	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
905
906	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
907	}
908
909	ret = true;
910
911	XRenderFreePicture (dpy, mask_pic);
912	XRenderFreePicture (dpy, overlay_pic);
913	XRenderFreePicture (dpy, back_pic);
914	}
915	# endif
916
917	return ret;
918	}
919
920	/*	443	/*
921	* Builds a pixmap of the same size as the terminal window that contains	444	* Builds a pixmap of the same size as the terminal window that contains
922	* the tiled portion of the root pixmap that is supposed to be covered by	445	* the tiled portion of the root pixmap that is supposed to be covered by
923	* our window.	446	* our window.
924	*/	447	*/
925	bool	448	bool
926	rxvt_term::make_transparency_pixmap ()	449	rxvt_term::render_root_image ()
927	{	450	{
928	bool ret = false;
929
930	/* root dimensions may change from call to call - but Display structure should	451	/* root dimensions may change from call to call - but Display structure should
931	* be always up-to-date, so let's use it :	452	* be always up-to-date, so let's use it :
932	*/	453	*/
933	int screen = display->screen;	454	int screen = display->screen;
934	int root_depth = DefaultDepth (dpy, screen);
935	int root_width = DisplayWidth (dpy, screen);	455	int root_width = DisplayWidth (dpy, screen);
936	int root_height = DisplayHeight (dpy, screen);	456	int root_height = DisplayHeight (dpy, screen);
937	unsigned int root_pmap_width, root_pmap_height;
938	int window_width = szHint.width;	457	int parent_width = szHint.width;
939	int window_height = szHint.height;	458	int parent_height = szHint.height;
940	int sx, sy;	459	int sx, sy;
941	XGCValues gcv;
942	GC gc;
943		460
944	sx = target_x;	461	sx = parent_x;
945	sy = target_y;	462	sy = parent_y;
		463
		464	if (!root_img)
		465	return false;
946		466
947	/* check if we are outside of the visible part of the virtual screen : */	467	/* check if we are outside of the visible part of the virtual screen : */
948	if (sx + window_width <= 0 || sy + window_height <= 0	468	if (sx + parent_width <= 0 || sy + parent_height <= 0
949	|| sx >= root_width || sy >= root_height)	469	|| sx >= root_width || sy >= root_height)
950	return 0;	470	return 0;
951		471
952	// validate root pixmap and get its size	472	while (sx < 0) sx += root_img->w;
953	if (root_pixmap != None)	473	while (sy < 0) sy += root_img->h;
954	{
955	Window wdummy;
956	int idummy;
957	unsigned int udummy;
958		474
959	allowedxerror = -1;	475	rxvt_img *img = root_img->sub_rect (sx, sy, parent_width, parent_height);
960		476
961	if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pmap_width, &root_pmap_height, &udummy, &udummy))	477	if (root_effects.need_blur ())
962	root_pixmap = None;	478	img->blur (root_effects.h_blurRadius, root_effects.v_blurRadius)->replace (img);
963		479
964	allowedxerror = 0;	480	if (root_effects.need_tint ())
965	}	481	tint_image (img, root_effects.tint, root_effects.tint_set, root_effects.shade);
966		482
967	Pixmap recoded_root_pmap = root_pixmap;
968
969	if (root_pixmap != None && root_depth != depth)
970	{
971	#if XRENDER
972	if (bg_flags & BG_HAS_RENDER)
973	{
974	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
975
976	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
977	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
978
979	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	483	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
980	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);	484	img->convert_format (format, pix_colors [Color_bg])->replace (img);
981		485
982	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	486	delete bg_img;
		487	bg_img = img;
983		488
984	XRenderFreePicture (dpy, src);
985	XRenderFreePicture (dpy, dst);
986	}
987	else
988	#endif
989	recoded_root_pmap = None;
990	}
991
992	if (recoded_root_pmap == None)
993	return 0;
994
995	if (bg_pixmap == None
996	|| bg_pmap_width != window_width
997	|| bg_pmap_height != window_height)
998	{
999	if (bg_pixmap)
1000	XFreePixmap (dpy, bg_pixmap);
1001	bg_pixmap = XCreatePixmap (dpy, vt, window_width, window_height, depth);
1002	bg_pmap_width = window_width;
1003	bg_pmap_height = window_height;
1004	}
1005
1006	/* straightforward pixmap copy */
1007	while (sx < 0) sx += root_pmap_width;
1008	while (sy < 0) sy += root_pmap_height;
1009
1010	gcv.tile = recoded_root_pmap;
1011	gcv.fill_style = FillTiled;
1012	gcv.ts_x_origin = -sx;
1013	gcv.ts_y_origin = -sy;
1014	gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1015
1016	if (gc)
1017	{
1018	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1019	ret = true;
1020	unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
1021
1022	if (!(bg_flags & BG_CLIENT_RENDER))
1023	{
1024	if (bg_flags & BG_NEEDS_BLUR)
1025	{
1026	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1027	tr_flags &= ~BG_NEEDS_BLUR;
1028	}
1029	if (bg_flags & BG_NEEDS_TINT)
1030	{
1031	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1032	tr_flags &= ~BG_NEEDS_TINT;
1033	}
1034	if (tr_flags & BG_NEEDS_TINT)
1035	{
1036	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1037	if (ximage)
1038	{
1039	/* our own client-side tinting */
1040	tint_ximage (DefaultVisual (dpy, display->screen), ximage);
1041
1042	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1043	XDestroyImage (ximage);
1044	}
1045	}
1046	} /* server side rendering completed */
1047
1048	XFreeGC (dpy, gc);
1049	}
1050
1051	if (recoded_root_pmap != root_pixmap)
1052	XFreePixmap (dpy, recoded_root_pmap);
1053
1054	return ret;	489	return true;
1055	}	490	}
1056		491
1057	void	492	void
1058	rxvt_term::bg_set_root_pixmap ()	493	rxvt_term::bg_set_root_pixmap ()
1059	{	494	{
1060	Pixmap new_root_pixmap = get_pixmap_property (xa[XA_XROOTPMAP_ID]);	495	delete root_img;
1061	if (new_root_pixmap == None)	496	root_img = rxvt_img::new_from_root (this);
1062	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1063
1064	root_pixmap = new_root_pixmap;
1065	}	497	}
1066	# endif /* ENABLE_TRANSPARENCY */	498	# endif /* BG_IMAGE_FROM_ROOT */
1067		499
1068	bool	500	void
1069	rxvt_term::bg_render ()	501	rxvt_term::bg_render ()
1070	{	502	{
1071	bool transparent = false;	503	if (bg_flags & BG_INHIBIT_RENDER)
		504	return;
1072		505
1073	bg_invalidate ();	506	bg_invalidate ();
1074	# ifdef ENABLE_TRANSPARENCY	507	# if BG_IMAGE_FROM_ROOT
1075	if (bg_flags & BG_IS_TRANSPARENT)	508	if (option (Opt_transparent))
1076	{	509	{
1077	/* we need to re-generate transparency pixmap in that case ! */	510	/* we need to re-generate transparency pixmap in that case ! */
1078	transparent = make_transparency_pixmap ();	511	if (render_root_image ())
1079	if (transparent)	512	bg_flags |= BG_IS_VALID | BG_IS_TRANSPARENT;
		513	}
		514	# endif
		515
		516	# if BG_IMAGE_FROM_FILE
		517	if (fimage.img)
		518	{
		519	if (render_image (fimage))
1080	bg_flags |= BG_IS_VALID;	520	bg_flags |= BG_IS_VALID;
1081	}	521	}
1082	# endif	522	# endif
1083		523
1084	# ifdef BG_IMAGE_FROM_FILE
1085	if (bg_flags & BG_IS_FROM_FILE)
1086	{
1087	if (render_image (transparent))
1088	bg_flags |= BG_IS_VALID;
1089	}
1090	# endif
1091
1092	if (!(bg_flags & BG_IS_VALID))	524	if (!(bg_flags & BG_IS_VALID))
1093	{	525	{
1094	if (bg_pixmap != None)	526	delete bg_img;
1095	{	527	bg_img = 0;
1096	XFreePixmap (dpy, bg_pixmap);
1097	bg_pixmap = None;
1098	}
1099	}	528	}
1100		529
1101	scr_recolour (false);	530	scr_recolour (false);
1102	bg_flags |= BG_NEEDS_REFRESH;	531	bg_flags |= BG_NEEDS_REFRESH;
1103		532
1104	bg_valid_since = ev::now ();	533	bg_valid_since = ev::now ();
1105
1106	return true;
1107	}	534	}
1108		535
1109	void	536	void
1110	rxvt_term::bg_init ()	537	rxvt_term::bg_init ()
1111	{	538	{
1112	#ifdef ENABLE_TRANSPARENCY	539	#if BG_IMAGE_FROM_ROOT
1113	shade = 100;	540	if (option (Opt_transparent))
		541	{
		542	if (rs [Rs_blurradius])
		543	root_effects.set_blur (rs [Rs_blurradius]);
		544
		545	if (ISSET_PIXCOLOR (Color_tint))
		546	root_effects.set_tint (pix_colors_focused [Color_tint]);
		547
		548	if (rs [Rs_shade])
		549	root_effects.set_shade (rs [Rs_shade]);
		550
		551	bg_set_root_pixmap ();
		552	XSelectInput (dpy, display->root, PropertyChangeMask);
		553	rootwin_ev.start (display, display->root);
		554	}
1114	#endif	555	#endif
1115		556
1116	bg_flags &= ~(BG_HAS_RENDER | BG_HAS_RENDER_CONV);	557	#if BG_IMAGE_FROM_FILE
1117	#if XRENDER	558	if (rs[Rs_backgroundPixmap])
1118	int major, minor;
1119	if (XRenderQueryVersion (dpy, &major, &minor))
1120	bg_flags |= BG_HAS_RENDER;
1121	XFilters *filters = XRenderQueryFilters (dpy, vt);
1122	if (filters)
1123	{	559	{
1124	for (int i = 0; i < filters->nfilter; i++)	560	fimage.set_file_geometry (this, rs[Rs_backgroundPixmap]);
1125	if (!strcmp (filters->filter[i], FilterConvolution))	561	if (!bg_window_position_sensitive ())
1126	bg_flags |= BG_HAS_RENDER_CONV;	562	update_background ();
1127
1128	XFree (filters);
1129	}	563	}
1130	#endif	564	#endif
1131	}	565	}
1132		566
1133	#endif /* HAVE_BG_PIXMAP */
1134
1135	#ifdef ENABLE_TRANSPARENCY
1136	/* based on code from aterm-0.4.2 */
1137
1138	static inline void
1139	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1140	{
1141	for (int i = 0; i <= mask >> sh; i++)
1142	{
1143	uint32_t tmp;
1144	tmp = i * high;
1145	tmp += (mask >> sh) * low;
1146	lookup[i] = (tmp / 0xffff) << sh;
1147	}
1148	}
1149
1150	void	567	void
1151	rxvt_term::tint_ximage (Visual *visual, XImage *ximage)	568	rxvt_term::tint_image (rxvt_img *img, rxvt_color &tint, bool tint_set, int shade)
1152	{	569	{
1153	int sh_r, sh_g, sh_b;
1154	uint32_t mask_r, mask_g, mask_b;
1155	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1156	unsigned short low;
1157	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1158
1159	if (visual->c_class != TrueColor || ximage->format != ZPixmap) return;
1160
1161	/* for convenience */
1162	mask_r = visual->red_mask;
1163	mask_g = visual->green_mask;
1164	mask_b = visual->blue_mask;
1165
1166	/* boring lookup table pre-initialization */
1167	switch (ximage->depth)
1168	{
1169	case 15:
1170	if ((mask_r != 0x7c00) ||
1171	(mask_g != 0x03e0) ||
1172	(mask_b != 0x001f))
1173	return;
1174	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32));
1175	lookup_r = lookup;
1176	lookup_g = lookup+32;
1177	lookup_b = lookup+32+32;
1178	sh_r = 10;
1179	sh_g = 5;
1180	sh_b = 0;
1181	break;
1182	case 16:
1183	if ((mask_r != 0xf800) ||
1184	(mask_g != 0x07e0) ||
1185	(mask_b != 0x001f))
1186	return;
1187	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+64+32));
1188	lookup_r = lookup;
1189	lookup_g = lookup+32;
1190	lookup_b = lookup+32+64;
1191	sh_r = 11;
1192	sh_g = 5;
1193	sh_b = 0;
1194	break;
1195	case 24:
1196	if ((mask_r != 0xff0000) ||
1197	(mask_g != 0x00ff00) ||
1198	(mask_b != 0x0000ff))
1199	return;
1200	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1201	lookup_r = lookup;
1202	lookup_g = lookup+256;
1203	lookup_b = lookup+256+256;
1204	sh_r = 16;
1205	sh_g = 8;
1206	sh_b = 0;
1207	break;
1208	case 32:
1209	if ((mask_r != 0xff0000) ||
1210	(mask_g != 0x00ff00) ||
1211	(mask_b != 0x0000ff))
1212	return;
1213	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1214	lookup_r = lookup;
1215	lookup_g = lookup+256;
1216	lookup_b = lookup+256+256;
1217	sh_r = 16;
1218	sh_g = 8;
1219	sh_b = 0;
1220	break;
1221	default:
1222	return; /* we do not support this color depth */
1223	}
1224
1225	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);	570	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1226		571
1227	if (bg_flags & BG_TINT_SET)	572	if (tint_set)
1228	tint.get (c);	573	tint.get (c);
1229		574
1230	/* prepare limits for color transformation (each channel is handled separately) */
1231	if (shade > 100)	575	if (shade > 100)
1232	{	576	{
1233	c.r = c.r * (200 - shade) / 100;	577	c.r = c.r * (200 - shade) / 100;
1234	c.g = c.g * (200 - shade) / 100;	578	c.g = c.g * (200 - shade) / 100;
1235	c.b = c.b * (200 - shade) / 100;	579	c.b = c.b * (200 - shade) / 100;
1236
1237	low = 0xffff * (shade - 100) / 100;
1238	}	580	}
1239	else	581	else
1240	{	582	{
1241	c.r = c.r * shade / 100;	583	c.r = c.r * shade / 100;
1242	c.g = c.g * shade / 100;	584	c.g = c.g * shade / 100;
1243	c.b = c.b * shade / 100;	585	c.b = c.b * shade / 100;
1244
1245	low = 0;
1246	}
1247
1248	/* fill our lookup tables */
1249	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1250	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1251	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1252
1253	/* apply table to input image (replacing colors by newly calculated ones) */
1254	if (ximage->bits_per_pixel == 32
1255	&& (ximage->depth == 24 || ximage->depth == 32)
1256	&& ximage->byte_order == host_byte_order)
1257	{	586	}
1258	uint32_t *p1, *pf, *p, *pl;
1259	p1 = (uint32_t *) ximage->data;
1260	pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1261		587
1262	while (p1 < pf)	588	img->contrast (c.r, c.g, c.b, c.a);
1263	{	589
1264	p = p1;	590	if (shade > 100)
1265	pl = p1 + ximage->width;
1266	for (; p < pl; p++)
1267	{
1268	*p = lookup_r[(*p & 0xff0000) >> 16] |
1269	lookup_g[(*p & 0x00ff00) >> 8] |
1270	lookup_b[(*p & 0x0000ff)] |
1271	(*p & 0xff000000);
1272	}
1273	p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line);
1274	}
1275	}	591	{
1276	else	592	c.a = 0xffff;
		593	c.r =
		594	c.g =
		595	c.b = 0xffff * (shade - 100) / 100;
		596	img->brightness (c.r, c.g, c.b, c.a);
1277	{	597	}
1278	for (int y = 0; y < ximage->height; y++)
1279	for (int x = 0; x < ximage->width; x++)
1280	{
1281	unsigned long pixel = XGetPixel (ximage, x, y);
1282	pixel = lookup_r[(pixel & mask_r) >> sh_r] |
1283	lookup_g[(pixel & mask_g) >> sh_g] |
1284	lookup_b[(pixel & mask_b) >> sh_b];
1285	XPutPixel (ximage, x, y, pixel);
1286	}
1287	}
1288
1289	free (lookup);
1290	}	598	}
1291	#endif /* ENABLE_TRANSPARENCY */	599
		600	#endif /* HAVE_BG_PIXMAP */

Diff Legend

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