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.186 by sf-exg, Wed Dec 28 11:11:25 2011 UTC vs.
Revision 1.220 by sf-exg, Fri May 25 08:27:47 2012 UTC

…		…
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 <cmath>	25	#include <math.h>
26	#include "../config.h" /* NECESSARY */	26	#include "../config.h" /* NECESSARY */
27	#include "rxvt.h" /* NECESSARY */	27	#include "rxvt.h" /* NECESSARY */
28		28
29	#if XRENDER	29	#if XRENDER
30	# include <X11/extensions/Xrender.h>	30	# include <X11/extensions/Xrender.h>
…		…
32		32
33	#ifndef FilterConvolution	33	#ifndef FilterConvolution
34	#define FilterConvolution "convolution"	34	#define FilterConvolution "convolution"
35	#endif	35	#endif
36		36
		37	#ifndef RepeatPad
		38	#define RepeatPad True
		39	#endif
		40
37	#ifdef HAVE_BG_PIXMAP	41	#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
38	void	60	void
39	rxvt_term::bg_destroy ()	61	rxvt_term::bg_destroy ()
40	{	62	{
41	#ifdef HAVE_AFTERIMAGE
42	if (original_asim)
43	safe_asimage_destroy (original_asim);
44	if (asv)
45	destroy_asvisual (asv, 0);
46	if (asimman)
47	destroy_image_manager (asimman, 0);
48	#endif
49
50	#ifdef HAVE_PIXBUF
51	if (pixbuf)
52	g_object_unref (pixbuf);
53	#endif
54
55	if (bg_pixmap)	63	if (bg_pixmap)
56	XFreePixmap (dpy, bg_pixmap);	64	XFreePixmap (dpy, bg_pixmap);
57	}	65	}
58		66
59	bool	67	bool
…		…
77	if (bg_flags & BG_IS_TRANSPARENT)	85	if (bg_flags & BG_IS_TRANSPARENT)
78	return true;	86	return true;
79	# endif	87	# endif
80		88
81	# ifdef BG_IMAGE_FROM_FILE	89	# ifdef BG_IMAGE_FROM_FILE
82	if (bg_flags & BG_IS_FROM_FILE)	90	for (vector<rxvt_image>::iterator bg_image = image_vec.begin (); bg_image < image_vec.end (); bg_image++)
83	{	91	{
84	if (bg_flags & BG_IS_SIZE_SENSITIVE)	92	if ((bg_image->flags & IM_IS_SIZE_SENSITIVE)
		93	|| bg_image->width () > szHint.width
		94	|| bg_image->height () > szHint.height)
85	return true;	95	return true;
86	}	96	}
87	# endif	97	# endif
88		98
89	return false;	99	return false;
…		…
96	if (bg_flags & BG_IS_TRANSPARENT)	106	if (bg_flags & BG_IS_TRANSPARENT)
97	return true;	107	return true;
98	# endif	108	# endif
99		109
100	# ifdef BG_IMAGE_FROM_FILE	110	# ifdef BG_IMAGE_FROM_FILE
101	if (bg_flags & BG_IS_FROM_FILE)	111	for (vector<rxvt_image>::iterator bg_image = image_vec.begin (); bg_image < image_vec.end (); bg_image++)
102	{	112	{
103	if (bg_flags & BG_ROOT_ALIGN)	113	if (bg_image->flags & IM_ROOT_ALIGN)
104	return true;	114	return true;
105	}	115	}
106	# endif	116	# endif
107		117
108	return false;	118	return false;
109	}	119	}
110		120
111	# ifdef BG_IMAGE_FROM_FILE	121	# ifdef BG_IMAGE_FROM_FILE
112	static inline bool
113	check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
114	{
115	if (geom_flags & flag)
116	{
117	if (new_value > 1000)
118	new_value = 1000;
119	if (new_value != scale)
120	{
121	scale = new_value;
122	return true;
123	}
124	}
125	return false;
126	}
127
128	static inline bool
129	check_set_align_value (int geom_flags, int flag, int &align, int new_value)
130	{
131	if (geom_flags & flag)
132	{
133	if (new_value < -100)
134	new_value = -100;
135	else if (new_value > 200)
136	new_value = 200;
137	if (new_value != align)
138	{
139	align = new_value;
140	return true;
141	}
142	}
143	return false;
144	}
145
146	static inline int	122	static inline int
147	make_align_position (int align, int window_size, int image_size)	123	make_align_position (int align, int window_size, int image_size)
148	{	124	{
149	int diff = window_size - image_size;
150	int smaller = min (image_size, window_size);
151
152	if (align >= 0 && align <= 100)	125	if (align >= 0 && align <= 100)
153	return diff * align / 100;	126	return lerp (0, window_size - image_size, align);
154	else if (align > 100 && align <= 200)	127	else if (align > 100)
155	return (align - 100) * smaller / 100 + window_size - smaller;	128	return lerp (window_size - image_size, window_size, align - 100);
156	else if (align >= -100 && align < 0)	129	else
157	return (align + 100) * smaller / 100 - image_size;	130	return lerp (-image_size, 0, align + 100);
158	return 0;
159	}	131	}
160		132
161	static inline int	133	static inline int
162	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	134	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
163	{	135	{
…		…
169	src_pos = -pos;	141	src_pos = -pos;
170	dst_pos = 0;	142	dst_pos = 0;
171	dst_size += pos;	143	dst_size += pos;
172	}	144	}
173		145
174	if (dst_pos + dst_size > target_size)
175	dst_size = target_size - dst_pos;	146	min_it (dst_size, target_size - dst_pos);
176	return src_pos;	147	return src_pos;
177	}	148	}
178		149
		150	static void
		151	parse_style (const char *style, int &x, int &y, unsigned int &w, unsigned int &h, uint8_t &flags)
		152	{
		153	if (!strcasecmp (style, "tiled"))
		154	{
		155	flags = IM_TILE;
		156	w = h = noScale;
		157	x = y = 0;
		158	}
		159	else if (!strcasecmp (style, "aspect-stretched"))
		160	{
		161	flags = IM_KEEP_ASPECT;
		162	w = h = windowScale;
		163	x = y = centerAlign;
		164	}
		165	else if (!strcasecmp (style, "stretched"))
		166	{
		167	flags = 0;
		168	w = h = windowScale;
		169	x = y = centerAlign;
		170	}
		171	else if (!strcasecmp (style, "centered"))
		172	{
		173	flags = 0;
		174	w = h = noScale;
		175	x = y = centerAlign;
		176	}
		177	else if (!strcasecmp (style, "root-tiled"))
		178	{
		179	flags = IM_TILE|IM_ROOT_ALIGN;
		180	w = h = noScale;
		181	x = y = 0;
		182	}
		183	}
		184
179	bool	185	bool
180	rxvt_term::bg_set_geometry (const char *geom, bool update)	186	rxvt_image::set_geometry (const char *geom, bool update)
181	{	187	{
182	bool changed = false;	188	bool changed = false;
183	int geom_flags = 0;	189	int geom_flags = 0;
184	int x = 0, y = 0;	190	int x = h_align;
		191	int y = v_align;
185	unsigned int w = 0, h = 0;	192	unsigned int w = h_scale;
186	unsigned long new_flags = 0;	193	unsigned int h = v_scale;
		194	uint8_t new_flags = 0;
187		195
188	if (geom == NULL)	196	if (geom == NULL)
189	return false;	197	return false;
190		198
191	if (geom[0])	199	if (geom[0])
192	{	200	{
193	char **arr = rxvt_strsplit (':', geom);	201	char **arr = rxvt_strsplit (':', geom);
194		202
195	for (int i = 0; arr[i]; i++)	203	for (int i = 0; arr[i]; i++)
196	{	204	{
197	if (!strcasecmp (arr[i], "style=tiled"))	205	if (!strncasecmp (arr[i], "style=", 6))
198	{	206	{
199	new_flags = BG_TILE;	207	parse_style (arr[i] + 6, x, y, w, h, new_flags);
200	w = h = noScale;
201	x = y = 0;
202	geom_flags = WidthValue|HeightValue|XValue|YValue;	208	geom_flags = WidthValue|HeightValue|XValue|YValue;
203	}	209	}
204	else if (!strcasecmp (arr[i], "style=aspect-stretched"))
205	{
206	new_flags = BG_KEEP_ASPECT;
207	w = h = windowScale;
208	x = y = centerAlign;
209	geom_flags = WidthValue|HeightValue|XValue|YValue;
210	}
211	else if (!strcasecmp (arr[i], "style=stretched"))
212	{
213	new_flags = 0;
214	w = h = windowScale;
215	geom_flags = WidthValue|HeightValue;
216	}
217	else if (!strcasecmp (arr[i], "style=centered"))
218	{
219	new_flags = 0;
220	w = h = noScale;
221	x = y = centerAlign;
222	geom_flags = WidthValue|HeightValue|XValue|YValue;
223	}
224	else if (!strcasecmp (arr[i], "style=root-tiled"))
225	{
226	new_flags = BG_TILE|BG_ROOT_ALIGN;
227	w = h = noScale;
228	geom_flags = WidthValue|HeightValue;
229	}
230	else if (!strcasecmp (arr[i], "op=tile"))	210	else if (!strcasecmp (arr[i], "op=tile"))
231	new_flags |= BG_TILE;	211	new_flags |= IM_TILE;
232	else if (!strcasecmp (arr[i], "op=keep-aspect"))	212	else if (!strcasecmp (arr[i], "op=keep-aspect"))
233	new_flags |= BG_KEEP_ASPECT;	213	new_flags |= IM_KEEP_ASPECT;
234	else if (!strcasecmp (arr[i], "op=root-align"))	214	else if (!strcasecmp (arr[i], "op=root-align"))
235	new_flags |= BG_ROOT_ALIGN;	215	new_flags |= IM_ROOT_ALIGN;
236		216
237	// deprecated	217	// deprecated
238	else if (!strcasecmp (arr[i], "tile"))	218	else if (!strcasecmp (arr[i], "tile"))
239	{	219	{
240	new_flags |= BG_TILE;	220	new_flags |= IM_TILE;
241	w = h = noScale;	221	w = h = noScale;
242	geom_flags |= WidthValue|HeightValue;	222	geom_flags |= WidthValue|HeightValue;
243	}	223	}
244	else if (!strcasecmp (arr[i], "propscale"))	224	else if (!strcasecmp (arr[i], "propscale"))
245	{	225	{
246	new_flags |= BG_KEEP_ASPECT;	226	new_flags |= IM_KEEP_ASPECT;
247	w = h = windowScale;	227	w = h = windowScale;
248	geom_flags |= WidthValue|HeightValue;	228	geom_flags |= WidthValue|HeightValue;
249	}	229	}
250	else if (!strcasecmp (arr[i], "hscale"))	230	else if (!strcasecmp (arr[i], "hscale"))
251	{	231	{
252	new_flags |= BG_TILE;	232	new_flags |= IM_TILE;
253	w = windowScale;	233	w = windowScale;
254	h = noScale;	234	h = noScale;
255	geom_flags |= WidthValue|HeightValue;	235	geom_flags |= WidthValue|HeightValue;
256	}	236	}
257	else if (!strcasecmp (arr[i], "vscale"))	237	else if (!strcasecmp (arr[i], "vscale"))
258	{	238	{
259	new_flags |= BG_TILE;	239	new_flags |= IM_TILE;
260	h = windowScale;	240	h = windowScale;
261	w = noScale;	241	w = noScale;
262	geom_flags |= WidthValue|HeightValue;	242	geom_flags |= WidthValue|HeightValue;
263	}	243	}
264	else if (!strcasecmp (arr[i], "scale"))	244	else if (!strcasecmp (arr[i], "scale"))
…		…
272	x = y = centerAlign;	252	x = y = centerAlign;
273	geom_flags |= WidthValue|HeightValue|XValue|YValue;	253	geom_flags |= WidthValue|HeightValue|XValue|YValue;
274	}	254	}
275	else if (!strcasecmp (arr[i], "root"))	255	else if (!strcasecmp (arr[i], "root"))
276	{	256	{
277	new_flags |= BG_TILE|BG_ROOT_ALIGN;	257	new_flags |= IM_TILE|IM_ROOT_ALIGN;
278	w = h = noScale;	258	w = h = noScale;
279	geom_flags |= WidthValue|HeightValue;	259	geom_flags |= WidthValue|HeightValue;
280	}	260	}
281		261
282	else	262	else
…		…
284	} /* done parsing ops */	264	} /* done parsing ops */
285		265
286	rxvt_free_strsplit (arr);	266	rxvt_free_strsplit (arr);
287	}	267	}
288		268
289	new_flags |= bg_flags & ~BG_GEOMETRY_FLAGS;	269	new_flags |= flags & ~IM_GEOMETRY_FLAGS;
290		270
291	if (!update)	271	if (!update)
292	{	272	{
293	if (!(geom_flags & XValue))	273	if (!(geom_flags & XValue))
294	x = y = defaultAlign;	274	x = y = defaultAlign;
…		…
299	w = h = defaultScale;	279	w = h = defaultScale;
300	else if (!(geom_flags & HeightValue))	280	else if (!(geom_flags & HeightValue))
301	h = w;	281	h = w;
302	else if (!(geom_flags & WidthValue))	282	else if (!(geom_flags & WidthValue))
303	w = h;	283	w = h;
304
305	geom_flags |= WidthValue|HeightValue|XValue|YValue;
306	}
307
308	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
309	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
310	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
311	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
312
313	if (new_flags != bg_flags)
314	{	284	}
		285
		286	clamp_it (x, -100, 200);
		287	clamp_it (y, -100, 200);
		288
		289	if (flags != new_flags
		290	|| h_scale != w
		291	|| v_scale != h
		292	|| h_align != x
		293	|| v_align != y)
		294	{
315	bg_flags = new_flags;	295	flags = new_flags;
		296	h_scale = w;
		297	v_scale = h;
		298	h_align = x;
		299	v_align = y;
316	changed = true;	300	changed = true;
317	}	301	}
318		302
		303	if (!(flags & IM_TILE)
		304	|| h_scale || v_scale
		305	|| (!(flags & IM_ROOT_ALIGN) && (h_align || v_align)))
		306	flags |= IM_IS_SIZE_SENSITIVE;
		307	else
		308	flags &= ~IM_IS_SIZE_SENSITIVE;
		309
319	return changed;	310	return changed;
320	}	311	}
321		312
322	void	313	void
323	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)	314	rxvt_term::get_image_geometry (rxvt_image &image, int &w, int &h, int &x, int &y)
324	{	315	{
		316	int image_width = image.width ();
		317	int image_height = image.height ();
325	int target_width = szHint.width;	318	int target_width = szHint.width;
326	int target_height = szHint.height;	319	int target_height = szHint.height;
		320	int h_scale = min (image.h_scale, 32767 * 100 / target_width);
		321	int v_scale = min (image.v_scale, 32767 * 100 / target_height);
327		322
328	w = h_scale * target_width / 100;	323	w = h_scale * target_width / 100;
329	h = v_scale * target_height / 100;	324	h = v_scale * target_height / 100;
330		325
331	if (bg_flags & BG_KEEP_ASPECT)	326	if (image.flags & IM_KEEP_ASPECT)
332	{	327	{
333	float scale = (float)w / image_width;	328	float scale = (float)w / image_width;
334	min_it (scale, (float)h / image_height);	329	min_it (scale, (float)h / image_height);
335	w = image_width * scale + 0.5;	330	w = image_width * scale + 0.5;
336	h = image_height * scale + 0.5;	331	h = image_height * scale + 0.5;
337	}	332	}
338		333
339	if (!w) w = image_width;	334	if (!w) w = image_width;
340	if (!h) h = image_height;	335	if (!h) h = image_height;
341		336
342	if (bg_flags & BG_ROOT_ALIGN)	337	if (image.flags & IM_ROOT_ALIGN)
343	{	338	{
344	x = -target_x;	339	x = -target_x;
345	y = -target_y;	340	y = -target_y;
346	}	341	}
347	else	342	else
348	{	343	{
349	x = make_align_position (h_align, target_width, w);	344	x = make_align_position (image.h_align, target_width, w);
350	y = make_align_position (v_align, target_height, h);	345	y = make_align_position (image.v_align, target_height, h);
351	}
352
353	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
354	if (!(bg_flags & BG_TILE)
355	|| h_scale || v_scale
356	|| (!(bg_flags & BG_ROOT_ALIGN) && (h_align || v_align))
357	|| w > target_width || h > target_height)
358	bg_flags |= BG_IS_SIZE_SENSITIVE;
359	}
360
361	# ifdef HAVE_AFTERIMAGE
362	bool
363	rxvt_term::render_image (unsigned long tr_flags)
364	{
365	init_asv ();
366
367	ASImage *background = NULL;
368	ARGB32 background_tint = TINT_LEAVE_SAME;
369
370	# ifdef ENABLE_TRANSPARENCY
371	if (tr_flags)
372	background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
373
374	if (tr_flags & BG_NEEDS_TINT)
375	{	346	}
376	ShadingInfo as_shade;	347	}
377	as_shade.shading = shade;
378		348
379	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	349	# ifdef HAVE_PIXBUF
380	if (bg_flags & BG_TINT_SET)	350	bool
381	tint.get (c);	351	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
382	as_shade.tintColor.red = c.r;	352	int src_x, int src_y, int dst_x, int dst_y,
383	as_shade.tintColor.green = c.g;	353	unsigned int width, unsigned int height, bool argb)
384	as_shade.tintColor.blue = c.b;	354	{
		355	XImage *ximage;
		356	char *line;
		357	int width_r, width_g, width_b, width_a;
		358	int sh_r, sh_g, sh_b, sh_a;
		359	uint32_t red_mask, green_mask, blue_mask, alpha_mask;
		360	int rowstride;
		361	int channels;
		362	unsigned char *row;
385		363
386	background_tint = shading2tint32 (&as_shade);	364	if (visual->c_class != TrueColor)
		365	return false;
		366
		367	if (argb)
387	}	368	{
388		369	red_mask = 0xff << 16;
389	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)	370	green_mask = 0xff << 8;
		371	blue_mask = 0xff;
		372	alpha_mask = 0xff << 24;
390	{	373	}
391	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,	374	else
392	ASA_XImage,	375	{
393	100, ASIMAGE_QUALITY_DEFAULT);	376	red_mask = visual->red_mask;
		377	green_mask = visual->green_mask;
		378	blue_mask = visual->blue_mask;
		379	#if XRENDER
		380	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
394	if (tmp)	381	if (format)
		382	alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
		383	else
		384	#endif
		385	alpha_mask = 0;
		386	}
		387
		388	width_r = ecb_popcount32 (red_mask);
		389	width_g = ecb_popcount32 (green_mask);
		390	width_b = ecb_popcount32 (blue_mask);
		391	width_a = ecb_popcount32 (alpha_mask);
		392
		393	if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
		394	return false;
		395
		396	sh_r = ecb_ctz32 (red_mask);
		397	sh_g = ecb_ctz32 (green_mask);
		398	sh_b = ecb_ctz32 (blue_mask);
		399	sh_a = ecb_ctz32 (alpha_mask);
		400
		401	if (width > 32767 || height > 32767)
		402	return false;
		403
		404	ximage = XCreateImage (dpy, visual, argb ? 32 : depth, ZPixmap, 0, 0,
		405	width, height, 32, 0);
		406	if (!ximage)
		407	return false;
		408
		409	if (height > INT_MAX / ximage->bytes_per_line
		410	|| !(ximage->data = (char *)malloc (height * ximage->bytes_per_line)))
		411	{
		412	XDestroyImage (ximage);
		413	return false;
		414	}
		415
		416	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
		417
		418	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
		419	channels = gdk_pixbuf_get_n_channels (pixbuf);
		420	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
		421	line = ximage->data;
		422
		423	rgba c (0, 0, 0);
		424
		425	if (channels == 4 && alpha_mask == 0)
		426	{
		427	pix_colors[Color_bg].get (c);
		428	c.r >>= 8;
		429	c.g >>= 8;
		430	c.b >>= 8;
		431	}
		432
		433	for (int y = 0; y < height; y++)
		434	{
		435	for (int x = 0; x < width; x++)
		436	{
		437	unsigned char *pixel = row + x * channels;
		438	uint32_t value;
		439	unsigned char r, g, b, a;
		440
		441	if (channels == 4)
395	{	442	{
396	destroy_asimage (&background);	443	a = pixel[3];
397	background = tmp;	444	r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
		445	g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
		446	b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
		447	}
		448	else
		449	{
		450	a = 0xff;
		451	r = pixel[0];
		452	g = pixel[1];
		453	b = pixel[2];
		454	}
		455
		456	value = ((r >> (8 - width_r)) << sh_r)
		457	| ((g >> (8 - width_g)) << sh_g)
		458	| ((b >> (8 - width_b)) << sh_b)
		459	| ((a >> (8 - width_a)) << sh_a);
		460
		461	if (ximage->bits_per_pixel == 32)
		462	((uint32_t *)line)[x] = value;
		463	else
		464	XPutPixel (ximage, x, y, value);
398	}	465	}
399	}
400	# endif
401		466
402	ASImage *result = 0;	467	row += rowstride;
		468	line += ximage->bytes_per_line;
		469	}
		470
		471	XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
		472	XDestroyImage (ximage);
		473	return true;
		474	}
		475
		476	bool
		477	rxvt_term::render_image (rxvt_image &image)
		478	{
		479	GdkPixbuf *pixbuf = image.pixbuf;
		480	if (!pixbuf)
		481	return false;
		482
		483	bool need_blend = bg_flags & BG_IS_VALID;
		484
		485	if (need_blend
		486	&& !(bg_flags & BG_HAS_RENDER))
		487	return false;
		488
		489	GdkPixbuf *result;
		490
		491	int image_width = gdk_pixbuf_get_width (pixbuf);
		492	int image_height = gdk_pixbuf_get_height (pixbuf);
403		493
404	int target_width = szHint.width;	494	int target_width = szHint.width;
405	int target_height = szHint.height;	495	int target_height = szHint.height;
406	int new_pmap_width = target_width;	496	int new_pmap_width = target_width;
407	int new_pmap_height = target_height;	497	int new_pmap_height = target_height;
…		…
409	int x = 0;	499	int x = 0;
410	int y = 0;	500	int y = 0;
411	int w = 0;	501	int w = 0;
412	int h = 0;	502	int h = 0;
413		503
414	if (original_asim)	504	get_image_geometry (image, w, h, x, y);
415	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
416		505
417	if (!original_asim	506	if (!(image.flags & IM_ROOT_ALIGN)
418	|| (!(bg_flags & BG_ROOT_ALIGN)
419	&& (x >= target_width	507	&& (x >= target_width
420	|| y >= target_height	508	|| y >= target_height
421	|| x + w <= 0	509	|| x + w <= 0
422	|| y + h <= 0)))	510	|| y + h <= 0))
		511	return false;
		512
		513	result = pixbuf;
		514
		515	if (w != image_width
		516	|| h != image_height)
		517	{
		518	result = gdk_pixbuf_scale_simple (pixbuf,
		519	w, h,
		520	GDK_INTERP_BILINEAR);
423	{	521	}
424	if (background)
425	{
426	new_pmap_width = background->width;
427	new_pmap_height = background->height;
428	result = background;
429		522
430	if (background_tint != TINT_LEAVE_SAME)	523	if (!result)
		524	return false;
		525
		526	bool ret = false;
		527
		528	XGCValues gcv;
		529	GC gc;
		530	Pixmap tmp_pixmap;
		531
		532	image_width = gdk_pixbuf_get_width (result);
		533	image_height = gdk_pixbuf_get_height (result);
		534
		535	if (need_blend)
		536	tmp_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, 32);
		537	else
		538	{
		539	// optimise bg pixmap size when tiling, but only if there are no
		540	// other pixbufs to render. Otherwise, the bg pixmap size must
		541	// be equal to the window size.
		542	if ((image.flags & IM_TILE)
		543	&& image_vec.size () == 1)
431	{	544	{
432	ASImage *tmp = tile_asimage (asv, background, 0, 0,	545	new_pmap_width = min (image_width, target_width);
433	target_width, target_height, background_tint,	546	new_pmap_height = min (image_height, target_height);
434	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
435	if (tmp)
436	result = tmp;
437	}
438	}	547	}
439	else
440	new_pmap_width = new_pmap_height = 0;
441	}
442	else
443	{
444	result = original_asim;
445		548
446	if (w != original_asim->width
447	|| h != original_asim->height)
448	{
449	result = scale_asimage (asv, original_asim,
450	w, h,
451	ASA_XImage,
452	100, ASIMAGE_QUALITY_DEFAULT);
453	}
454
455	if (background == NULL)
456	{
457	if (bg_flags & BG_TILE)
458	{
459	/* if tiling - pixmap has to be sized exactly as the image,
460	but there is no need to make it bigger than the window! */
461	new_pmap_width = min (result->width, target_width);
462	new_pmap_height = min (result->height, target_height);
463
464	/* we also need to tile our image in both directions */
465	ASImage *tmp = tile_asimage (asv, result,
466	(int)result->width - x,
467	(int)result->height - y,
468	new_pmap_width,
469	new_pmap_height,
470	TINT_LEAVE_SAME, ASA_XImage,
471	100, ASIMAGE_QUALITY_DEFAULT);
472	if (tmp)
473	{
474	if (result != original_asim)
475	destroy_asimage (&result);
476
477	result = tmp;
478	}
479	}
480	}
481	else
482	{
483	/* if blending background and image - pixmap has to be sized same as target window */
484	ASImageLayer *layers = create_image_layers (2);
485
486	layers[0].im = background;
487	layers[0].clip_width = target_width;
488	layers[0].clip_height = target_height;
489	layers[0].tint = background_tint;
490	layers[1].im = result;
491
492	if (bg_flags & BG_TILE)
493	{
494	/* tile horizontally */
495	while (x > 0) x -= (int)result->width;
496	layers[1].dst_x = x;
497	layers[1].clip_width = result->width+target_width;
498	}
499	else
500	{
501	/* clip horizontally */
502	layers[1].dst_x = x;
503	layers[1].clip_width = result->width;
504	}
505
506	if (bg_flags & BG_TILE)
507	{
508	while (y > 0) y -= (int)result->height;
509	layers[1].dst_y = y;
510	layers[1].clip_height = result->height + target_height;
511	}
512	else
513	{
514	layers[1].dst_y = y;
515	layers[1].clip_height = result->height;
516	}
517
518	if (rs[Rs_blendtype])
519	{
520	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
521	if (layers[1].merge_scanlines == NULL)
522	layers[1].merge_scanlines = alphablend_scanlines;
523	}
524
525	ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
526	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
527
528	if (tmp)
529	{
530	if (result != original_asim)
531	destroy_asimage (&result);
532
533	result = tmp;
534	}
535
536	free (layers);
537	}
538	}
539
540	bool ret = false;
541
542	if (result)
543	{
544	XGCValues gcv;
545	GC gc;
546
547	/* create Pixmap */
548	if (bg_pixmap == None	549	if (bg_pixmap == None
549	|| bg_pmap_width != new_pmap_width	550	|| bg_pmap_width != new_pmap_width
550	|| bg_pmap_height != new_pmap_height)	551	|| bg_pmap_height != new_pmap_height)
551	{	552	{
552	if (bg_pixmap)	553	if (bg_pixmap)
553	XFreePixmap (dpy, bg_pixmap);	554	XFreePixmap (dpy, bg_pixmap);
554	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);	555	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
555	bg_pmap_width = new_pmap_width;	556	bg_pmap_width = new_pmap_width;
556	bg_pmap_height = new_pmap_height;	557	bg_pmap_height = new_pmap_height;
557	}	558	}
558	/* fill with background color (if result's not completely overlapping it) */
559	gcv.foreground = pix_colors[Color_bg];
560	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
561		559
562	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
563	int dst_width = result->width, dst_height = result->height;
564	if (background == NULL)
565	{
566	if (!(bg_flags & BG_TILE))
567	{
568	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
569	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
570	}
571
572	if (dst_x > 0 || dst_y > 0
573	|| dst_x + dst_width < new_pmap_width
574	|| dst_y + dst_height < new_pmap_height)
575	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
576	}
577
578	/* put result on pixmap */
579	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
580	asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
581
582	if (result != background && result != original_asim)
583	destroy_asimage (&result);
584
585	XFreeGC (dpy, gc);
586
587	ret = true;
588	}
589
590	if (background)
591	destroy_asimage (&background);
592
593	return ret;
594	}
595	# endif /* HAVE_AFTERIMAGE */
596
597	# ifdef HAVE_PIXBUF
598	bool
599	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
600	int src_x, int src_y, int dst_x, int dst_y,
601	unsigned int width, unsigned int height)
602	{
603	XImage *ximage;
604	char *data, *line;
605	int bytes_per_pixel;
606	int width_r, width_g, width_b;
607	int sh_r, sh_g, sh_b;
608	int rowstride;
609	int channels;
610	unsigned char *row;
611
612	if (visual->c_class != TrueColor)
613	return false;
614
615	if (depth == 24 || depth == 32)
616	bytes_per_pixel = 4;
617	else if (depth == 15 || depth == 16)
618	bytes_per_pixel = 2;
619	else
620	return false;
621
622	width_r = ecb_popcount32 (visual->red_mask);
623	width_g = ecb_popcount32 (visual->green_mask);
624	width_b = ecb_popcount32 (visual->blue_mask);
625
626	if (width_r > 8 || width_g > 8 || width_b > 8)
627	return false;
628
629	sh_r = ecb_ctz32 (visual->red_mask);
630	sh_g = ecb_ctz32 (visual->green_mask);
631	sh_b = ecb_ctz32 (visual->blue_mask);
632
633	if (width > INT_MAX / height / bytes_per_pixel)
634	return false;
635
636	data = (char *)malloc (width * height * bytes_per_pixel);
637	if (!data)
638	return false;
639
640	ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, data,
641	width, height, bytes_per_pixel * 8, 0);
642	if (!ximage)
643	{
644	free (data);
645	return false;
646	}
647
648	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
649
650	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
651	channels = gdk_pixbuf_get_n_channels (pixbuf);
652	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
653	line = data;
654
655	for (int y = 0; y < height; y++)
656	{
657	for (int x = 0; x < width; x++)
658	{
659	unsigned char *pixel = row + x * channels;
660	uint32_t value;
661
662	value = ((pixel[0] >> (8 - width_r)) << sh_r)
663	| ((pixel[1] >> (8 - width_g)) << sh_g)
664	| ((pixel[2] >> (8 - width_b)) << sh_b);
665
666	if (bytes_per_pixel == 4)
667	((uint32_t *)line)[x] = value;
668	else
669	((uint16_t *)line)[x] = value;
670	}
671
672	row += rowstride;
673	line += ximage->bytes_per_line;
674	}
675
676	XPutImage (dpy, pixmap, gc, ximage, 0, 0, dst_x, dst_y, width, height);
677	XDestroyImage (ximage);
678	return true;
679	}
680
681	bool
682	rxvt_term::render_image (unsigned long tr_flags)
683	{
684	if (!pixbuf)
685	return false;
686
687	if (tr_flags
688	&& !(bg_flags & BG_HAS_RENDER))
689	return false;
690
691	GdkPixbuf *result;
692
693	int image_width = gdk_pixbuf_get_width (pixbuf);
694	int image_height = gdk_pixbuf_get_height (pixbuf);
695
696	int target_width = szHint.width;
697	int target_height = szHint.height;
698	int new_pmap_width = target_width;
699	int new_pmap_height = target_height;
700
701	int x = 0;
702	int y = 0;
703	int w = 0;
704	int h = 0;
705
706	get_image_geometry (image_width, image_height, w, h, x, y);
707
708	if (!(bg_flags & BG_ROOT_ALIGN)
709	&& (x >= target_width
710	|| y >= target_height
711	|| x + w <= 0
712	|| y + h <= 0))
713	return false;
714
715	result = pixbuf;
716
717	if (w != image_width
718	|| h != image_height)
719	{
720	result = gdk_pixbuf_scale_simple (pixbuf,
721	w, h,
722	GDK_INTERP_BILINEAR);
723	}
724
725	if (!result)
726	return false;
727
728	bool ret = false;
729
730	XGCValues gcv;
731	GC gc;
732	Pixmap root_pmap;
733
734	image_width = gdk_pixbuf_get_width (result);
735	image_height = gdk_pixbuf_get_height (result);
736
737	if (tr_flags)
738	{
739	root_pmap = bg_pixmap;	560	tmp_pixmap = bg_pixmap;
740	bg_pixmap = None;
741	}
742	else
743	{
744	if (bg_flags & BG_TILE)
745	{
746	new_pmap_width = min (image_width, target_width);
747	new_pmap_height = min (image_height, target_height);
748	}
749	}
750
751	if (bg_pixmap == None
752	|| bg_pmap_width != new_pmap_width
753	|| bg_pmap_height != new_pmap_height)
754	{
755	if (bg_pixmap)
756	XFreePixmap (dpy, bg_pixmap);
757	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
758	bg_pmap_width = new_pmap_width;
759	bg_pmap_height = new_pmap_height;
760	}	561	}
761		562
762	gcv.foreground = pix_colors[Color_bg];	563	gcv.foreground = pix_colors[Color_bg];
763	gc = XCreateGC (dpy, vt, GCForeground, &gcv);	564	gc = XCreateGC (dpy, tmp_pixmap, GCForeground, &gcv);
764		565
765	if (gc)	566	if (gc)
766	{	567	{
767	if (bg_flags & BG_TILE)	568	if (image.flags & IM_TILE)
768	{	569	{
769	Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, depth);	570	Pixmap tile = XCreatePixmap (dpy, vt, image_width, image_height, need_blend ? 32 : depth);
770	pixbuf_to_pixmap (result, tile, gc,	571	pixbuf_to_pixmap (result, tile, gc,
771	0, 0,	572	0, 0,
772	0, 0,	573	0, 0,
773	image_width, image_height);	574	image_width, image_height, need_blend);
774		575
775	gcv.tile = tile;	576	gcv.tile = tile;
776	gcv.fill_style = FillTiled;	577	gcv.fill_style = FillTiled;
777	gcv.ts_x_origin = x;	578	gcv.ts_x_origin = x;
778	gcv.ts_y_origin = y;	579	gcv.ts_y_origin = y;
779	XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	580	XChangeGC (dpy, gc, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
780		581
781	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	582	XFillRectangle (dpy, tmp_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
782	XFreePixmap (dpy, tile);	583	XFreePixmap (dpy, tile);
783	}	584	}
784	else	585	else
785	{	586	{
786	int src_x, src_y, dst_x, dst_y;	587	int src_x, src_y, dst_x, dst_y;
…		…
790	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);	591	src_y = make_clip_rectangle (y, image_height, new_pmap_height, dst_y, dst_height);
791		592
792	if (dst_x > 0 || dst_y > 0	593	if (dst_x > 0 || dst_y > 0
793	|| dst_x + dst_width < new_pmap_width	594	|| dst_x + dst_width < new_pmap_width
794	|| dst_y + dst_height < new_pmap_height)	595	|| dst_y + dst_height < new_pmap_height)
795	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);	596	XFillRectangle (dpy, tmp_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
796		597
797	if (dst_x < new_pmap_width && dst_y < new_pmap_height)	598	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
798	pixbuf_to_pixmap (result, bg_pixmap, gc,	599	pixbuf_to_pixmap (result, tmp_pixmap, gc,
799	src_x, src_y,	600	src_x, src_y,
800	dst_x, dst_y,	601	dst_x, dst_y,
801	dst_width, dst_height);	602	dst_width, dst_height, need_blend);
802	}	603	}
803		604
804	#if XRENDER	605	#if XRENDER
805	if (tr_flags)	606	if (need_blend)
806	{	607	{
807	XRenderPictureAttributes pa;	608	XRenderPictFormat *argb_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
808
809	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	609	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		610
810	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	611	Picture src = XRenderCreatePicture (dpy, tmp_pixmap, argb_format, 0, 0);
811		612
812	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
813	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	613	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
814		614
815	pa.repeat = True;	615	Picture mask = create_xrender_mask (dpy, vt, False, False);
816	Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
817	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
818	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
819	XFreePixmap (dpy, mask_pmap);
820		616
821	XRenderColor mask_c;	617	XRenderColor mask_c;
822		618
823	mask_c.alpha = 0x8000;	619	mask_c.alpha = gdk_pixbuf_get_has_alpha (image.pixbuf) ? 0xffff : image.alpha;
824	mask_c.red = 0;	620	mask_c.red =
825	mask_c.green = 0;	621	mask_c.green =
826	mask_c.blue = 0;	622	mask_c.blue = 0;
827	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	623	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		624
828	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	625	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
829		626
830	XRenderFreePicture (dpy, src);	627	XRenderFreePicture (dpy, src);
831	XRenderFreePicture (dpy, dst);	628	XRenderFreePicture (dpy, dst);
832	XRenderFreePicture (dpy, mask);	629	XRenderFreePicture (dpy, mask);
…		…
839	}	636	}
840		637
841	if (result != pixbuf)	638	if (result != pixbuf)
842	g_object_unref (result);	639	g_object_unref (result);
843		640
844	if (tr_flags)	641	if (need_blend)
845	XFreePixmap (dpy, root_pmap);	642	XFreePixmap (dpy, tmp_pixmap);
846		643
847	return ret;	644	return ret;
848	}	645	}
849	# endif /* HAVE_PIXBUF */	646	# endif /* HAVE_PIXBUF */
850		647
		648	# ifndef NO_RESOURCES
		649	static int
		650	rxvt_define_image (XrmDatabase *database ecb_unused,
		651	XrmBindingList bindings ecb_unused,
		652	XrmQuarkList quarks,
		653	XrmRepresentation *type ecb_unused,
		654	XrmValue *value,
		655	XPointer closure ecb_unused)
		656	{
		657	int size;
		658
		659	for (size = 0; quarks[size] != NULLQUARK; size++)
		660	;
		661
		662	if (size >= 2)
		663	{
		664	int id = strtol (XrmQuarkToString (quarks[size-2]), 0, 0);
		665	if (id >= 1)
		666	GET_R->parse_image (id, XrmQuarkToString (quarks[size-1]), (char *)value->addr);
		667	}
		668	return False;
		669	}
		670
		671	void
		672	rxvt_term::parse_image (int id, const char *type, const char *arg)
		673	{
		674	rxvt_image *image;
		675
		676	for (image = image_vec.begin (); image < image_vec.end (); image++)
		677	if (image->id == id)
		678	break;
		679
		680	if (image == image_vec.end ())
		681	{
		682	image = new_image ();
		683	image->id = id;
		684	}
		685	}
		686	# endif
		687
		688	rxvt_image::rxvt_image ()
		689	{
		690	id =
		691	alpha =
		692	flags =
		693	h_scale =
		694	v_scale =
		695	h_align =
		696	v_align = 0;
		697
		698	# ifdef HAVE_PIXBUF
		699	pixbuf.reset (0);
		700	# endif
		701	}
		702
851	bool	703	bool
852	rxvt_term::bg_set_file (const char *file)	704	rxvt_image::set_file_geometry (const char *file)
853	{	705	{
854	if (!file || !*file)	706	if (!file || !*file)
855	return false;	707	return false;
856		708
857	bool ret = false;
858	const char *p = strchr (file, ';');	709	const char *p = strchr (file, ';');
859		710
860	if (p)	711	if (p)
861	{	712	{
862	size_t len = p - file;	713	size_t len = p - file;
…		…
864	memcpy (f, file, len);	715	memcpy (f, file, len);
865	f[len] = '\0';	716	f[len] = '\0';
866	file = f;	717	file = f;
867	}	718	}
868		719
869	# ifdef HAVE_AFTERIMAGE	720	bool ret = set_file (file);
870	if (!asimman)	721	alpha = 0x8000;
871	asimman = create_generic_imageman (rs[Rs_path]);	722	if (ret && p)
872	ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);	723	set_geometry (p + 1);
873	if (image)	724	return ret;
874	{	725	}
875	if (original_asim)	726
876	safe_asimage_destroy (original_asim);	727	bool
877	original_asim = image;	728	rxvt_image::set_file (const char *file)
878	bg_flags |= BG_IS_FROM_FILE | BG_CLIENT_RENDER;	729	{
879	ret = true;	730	bool ret = false;
880	}
881	# endif
882		731
883	# ifdef HAVE_PIXBUF	732	# ifdef HAVE_PIXBUF
884	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	733	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
885	if (image)	734	if (image)
886	{	735	{
887	if (pixbuf)	736	if (pixbuf)
888	g_object_unref (pixbuf);	737	g_object_unref (pixbuf);
889	pixbuf = image;	738	pixbuf.reset (image);
890	bg_flags |= BG_IS_FROM_FILE;
891	ret = true;	739	ret = true;
892	}	740	}
893	# endif	741	# endif
894		742
895	if (ret)	743	if (ret)
896	{	744	{
897	if (p)	745	alpha = 0xffff;
898	bg_set_geometry (p + 1);	746	flags = IM_IS_SET | IM_IS_SIZE_SENSITIVE;
899	else	747	h_scale = v_scale = defaultScale;
900	bg_set_default_geometry ();	748	h_align = v_align = defaultAlign;
901	}	749	}
902		750
903	return ret;	751	return ret;
904	}	752	}
905		753
906	# endif /* BG_IMAGE_FROM_FILE */	754	# endif /* BG_IMAGE_FROM_FILE */
907		755
908	# ifdef ENABLE_TRANSPARENCY	756	# ifdef ENABLE_TRANSPARENCY
909	bool
910	rxvt_term::bg_set_transparent ()
911	{
912	if (!(bg_flags & BG_IS_TRANSPARENT))
913	{
914	bg_flags |= BG_IS_TRANSPARENT;
915	return true;
916	}
917
918	return false;
919	}
920
921	bool	757	bool
922	rxvt_term::bg_set_blur (const char *geom)	758	rxvt_term::bg_set_blur (const char *geom)
923	{	759	{
924	bool changed = false;	760	bool changed = false;
925	unsigned int hr, vr;	761	unsigned int hr, vr;
…		…
944	{	780	{
945	changed = true;	781	changed = true;
946	v_blurRadius = vr;	782	v_blurRadius = vr;
947	}	783	}
948		784
949	if (v_blurRadius == 0 && h_blurRadius == 0)
950	bg_flags &= ~BG_NEEDS_BLUR;
951	else
952	bg_flags |= BG_NEEDS_BLUR;
953
954	return changed;	785	return changed;
955	}	786	}
956		787
957	void	788	bool
958	rxvt_term::set_tint_shade_flags ()	789	rxvt_term::bg_set_tint (rxvt_color &new_tint)
959	{	790	{
		791	if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
		792	{
		793	tint = new_tint;
		794	bg_flags |= BG_TINT_SET;
		795
960	rgba c;	796	rgba c;
961	bool has_shade = shade != 100;
962
963	bg_flags &= ~BG_TINT_FLAGS;
964
965	if (bg_flags & BG_TINT_SET)
966	{
967	tint.get (c);	797	tint.get (c);
968	if (!has_shade
969	&& (c.r <= 0x00ff || c.r >= 0xff00)	798	if ((c.r <= 0x00ff || c.r >= 0xff00)
970	&& (c.g <= 0x00ff || c.g >= 0xff00)	799	&& (c.g <= 0x00ff || c.g >= 0xff00)
971	&& (c.b <= 0x00ff || c.b >= 0xff00))	800	&& (c.b <= 0x00ff || c.b >= 0xff00))
972	bg_flags |= BG_TINT_BITAND;	801	bg_flags |= BG_TINT_BITAND;
973	}	802	else
974
975	if (has_shade || (bg_flags & BG_TINT_SET))
976	bg_flags |= BG_NEEDS_TINT;
977	}
978
979	bool
980	rxvt_term::bg_set_tint (rxvt_color &new_tint)
981	{
982	if (!(bg_flags & BG_TINT_SET) || tint != new_tint)
983	{
984	tint = new_tint;
985	bg_flags |= BG_TINT_SET;	803	bg_flags &= ~BG_TINT_BITAND;
986	set_tint_shade_flags ();	804
987	return true;	805	return true;
988	}	806	}
989		807
990	return false;	808	return false;
991	}	809	}
…		…
1000	new_shade = 200 - (100 + new_shade);	818	new_shade = 200 - (100 + new_shade);
1001		819
1002	if (new_shade != shade)	820	if (new_shade != shade)
1003	{	821	{
1004	shade = new_shade;	822	shade = new_shade;
1005	set_tint_shade_flags ();
1006	return true;	823	return true;
1007	}	824	}
1008		825
1009	return false;	826	return false;
1010	}	827	}
…		…
1031	params[i+2] = XDoubleToFixed (kernel[i] / sum);	848	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1032	}	849	}
1033	#endif	850	#endif
1034		851
1035	bool	852	bool
1036	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	853	rxvt_term::blur_pixmap (Pixmap pixmap, int width, int height)
1037	{	854	{
1038	bool ret = false;	855	bool ret = false;
1039	#if XRENDER	856	#if XRENDER
1040	if (!(bg_flags & BG_HAS_RENDER_CONV))	857	if (!(bg_flags & BG_HAS_RENDER_CONV))
1041	return false;	858	return false;
…		…
1045	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));	862	XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
1046		863
1047	XRenderPictureAttributes pa;	864	XRenderPictureAttributes pa;
1048	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	865	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1049		866
		867	pa.repeat = RepeatPad;
1050	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	868	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		869	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1051	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	870	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		871	XFreePixmap (dpy, tmp);
1052		872
1053	if (kernel && params)	873	if (kernel && params)
1054	{	874	{
1055	if (h_blurRadius)
1056	{
1057	size = h_blurRadius * 2 + 1;	875	size = h_blurRadius * 2 + 1;
1058	get_gaussian_kernel (h_blurRadius, size, kernel, params);	876	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1059		877
1060	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	878	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1061	XRenderComposite (dpy,	879	XRenderComposite (dpy,
1062	PictOpSrc,	880	PictOpSrc,
1063	src,	881	src,
1064	None,	882	None,
1065	dst,	883	dst,
1066	0, 0,	884	0, 0,
1067	0, 0,	885	0, 0,
1068	0, 0,	886	0, 0,
1069	width, height);	887	width, height);
1070	}
1071		888
1072	if (v_blurRadius)	889	::swap (src, dst);
1073	{	890
1074	size = v_blurRadius * 2 + 1;	891	size = v_blurRadius * 2 + 1;
1075	get_gaussian_kernel (v_blurRadius, size, kernel, params);	892	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1076	::swap (params[0], params[1]);	893	::swap (params[0], params[1]);
1077		894
1078	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	895	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1079	XRenderComposite (dpy,	896	XRenderComposite (dpy,
1080	PictOpSrc,	897	PictOpSrc,
1081	src,	898	src,
1082	None,	899	None,
1083	dst,	900	dst,
1084	0, 0,	901	0, 0,
1085	0, 0,	902	0, 0,
1086	0, 0,	903	0, 0,
1087	width, height);	904	width, height);
1088	}
1089		905
1090	ret = true;	906	ret = true;
1091	}	907	}
1092		908
1093	free (kernel);	909	free (kernel);
…		…
1097	#endif	913	#endif
1098	return ret;	914	return ret;
1099	}	915	}
1100		916
1101	bool	917	bool
1102	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	918	rxvt_term::tint_pixmap (Pixmap pixmap, int width, int height)
1103	{	919	{
1104	bool ret = false;	920	bool ret = false;
1105		921
1106	if (bg_flags & BG_TINT_BITAND)	922	if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1107	{	923	{
1108	XGCValues gcv;	924	XGCValues gcv;
1109	GC gc;	925	GC gc;
1110		926
1111	/* In this case we can tint image server-side getting significant	927	/* In this case we can tint image server-side getting significant
…		…
1141	c.r = c.r * (200 - shade) / 100;	957	c.r = c.r * (200 - shade) / 100;
1142	c.g = c.g * (200 - shade) / 100;	958	c.g = c.g * (200 - shade) / 100;
1143	c.b = c.b * (200 - shade) / 100;	959	c.b = c.b * (200 - shade) / 100;
1144	}	960	}
1145		961
1146	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1147	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	962	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1148	XRenderPictureAttributes pa;
1149		963
1150	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	964	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1151		965
1152	pa.repeat = True;	966	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1153		967
1154	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	968	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1155	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1156	XFreePixmap (dpy, overlay_pmap);
1157
1158	pa.component_alpha = True;
1159	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1160	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat | CPComponentAlpha, &pa);
1161	XFreePixmap (dpy, mask_pmap);
1162		969
1163	XRenderColor mask_c;	970	XRenderColor mask_c;
1164		971
1165	mask_c.alpha = 0xffff;	972	mask_c.alpha = 0xffff;
1166	mask_c.red =	973	mask_c.red =
…		…
1171	mask_c.alpha = 0;	978	mask_c.alpha = 0;
1172	mask_c.red = 0xffff - c.r;	979	mask_c.red = 0xffff - c.r;
1173	mask_c.green = 0xffff - c.g;	980	mask_c.green = 0xffff - c.g;
1174	mask_c.blue = 0xffff - c.b;	981	mask_c.blue = 0xffff - c.b;
1175	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	982	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		983
1176	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);	984	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1177		985
1178	if (shade > 100)	986	if (shade > 100)
1179	{	987	{
1180	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1181	mask_c.alpha = 0;	988	mask_c.alpha = 0;
		989	mask_c.red =
		990	mask_c.green =
		991	mask_c.blue = 0xffff * (shade - 100) / 100;
1182	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	992	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1183		993
1184	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);	994	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1185	}	995	}
1186		996
…		…
1198	/*	1008	/*
1199	* Builds a pixmap of the same size as the terminal window that contains	1009	* Builds a pixmap of the same size as the terminal window that contains
1200	* the tiled portion of the root pixmap that is supposed to be covered by	1010	* the tiled portion of the root pixmap that is supposed to be covered by
1201	* our window.	1011	* our window.
1202	*/	1012	*/
1203	unsigned long	1013	bool
1204	rxvt_term::make_transparency_pixmap ()	1014	rxvt_term::make_transparency_pixmap ()
1205	{	1015	{
1206	unsigned long result = 0;	1016	bool ret = false;
1207		1017
1208	/* root dimensions may change from call to call - but Display structure should	1018	/* root dimensions may change from call to call - but Display structure should
1209	* be always up-to-date, so let's use it :	1019	* be always up-to-date, so let's use it :
1210	*/	1020	*/
1211	int screen = display->screen;	1021	int screen = display->screen;
…		…
1249	#if XRENDER	1059	#if XRENDER
1250	if (bg_flags & BG_HAS_RENDER)	1060	if (bg_flags & BG_HAS_RENDER)
1251	{	1061	{
1252	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);	1062	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1253		1063
1254	XRenderPictureAttributes pa;
1255
1256	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	1064	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1257	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	1065	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1258		1066
1259	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	1067	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1260	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	1068	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1261		1069
1262	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	1070	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1263		1071
1264	XRenderFreePicture (dpy, src);	1072	XRenderFreePicture (dpy, src);
1265	XRenderFreePicture (dpy, dst);	1073	XRenderFreePicture (dpy, dst);
…		…
1294	gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);	1102	gc = XCreateGC (dpy, vt, GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin, &gcv);
1295		1103
1296	if (gc)	1104	if (gc)
1297	{	1105	{
1298	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1106	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1299	result |= BG_IS_VALID | (bg_flags & BG_EFFECTS_FLAGS);	1107	ret = true;
1300	XFreeGC (dpy, gc);	1108	bool need_blur = h_blurRadius && v_blurRadius;
		1109	bool need_tint = shade != 100 || (bg_flags & BG_TINT_SET);
1301		1110
1302	if (!(bg_flags & BG_CLIENT_RENDER))	1111	if (!(bg_flags & BG_CLIENT_RENDER))
1303	{	1112	{
1304	if (bg_flags & BG_NEEDS_BLUR)	1113	if (need_blur)
1305	{	1114	{
1306	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))	1115	if (blur_pixmap (bg_pixmap, window_width, window_height))
1307	result &= ~BG_NEEDS_BLUR;	1116	need_blur = false;
1308	}	1117	}
1309	if (bg_flags & BG_NEEDS_TINT)	1118	if (need_tint)
1310	{	1119	{
1311	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))	1120	if (tint_pixmap (bg_pixmap, window_width, window_height))
1312	result &= ~BG_NEEDS_TINT;	1121	need_tint = false;
		1122	}
		1123	if (need_tint)
		1124	{
		1125	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1126	if (ximage)
		1127	{
		1128	/* our own client-side tinting */
		1129	tint_ximage (ximage);
		1130
		1131	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1132	XDestroyImage (ximage);
		1133	}
1313	}	1134	}
1314	} /* server side rendering completed */	1135	} /* server side rendering completed */
		1136
		1137	XFreeGC (dpy, gc);
1315	}	1138	}
1316		1139
1317	if (recoded_root_pmap != root_pixmap)	1140	if (recoded_root_pmap != root_pixmap)
1318	XFreePixmap (dpy, recoded_root_pmap);	1141	XFreePixmap (dpy, recoded_root_pmap);
1319		1142
1320	return result;	1143	return ret;
1321	}	1144	}
1322		1145
1323	void	1146	void
1324	rxvt_term::bg_set_root_pixmap ()	1147	rxvt_term::bg_set_root_pixmap ()
1325	{	1148	{
…		…
1332	# endif /* ENABLE_TRANSPARENCY */	1155	# endif /* ENABLE_TRANSPARENCY */
1333		1156
1334	bool	1157	bool
1335	rxvt_term::bg_render ()	1158	rxvt_term::bg_render ()
1336	{	1159	{
1337	unsigned long tr_flags = 0;
1338
1339	bg_invalidate ();	1160	bg_invalidate ();
1340	# ifdef ENABLE_TRANSPARENCY	1161	# ifdef ENABLE_TRANSPARENCY
1341	if (bg_flags & BG_IS_TRANSPARENT)	1162	if (bg_flags & BG_IS_TRANSPARENT)
1342	{	1163	{
1343	/* we need to re-generate transparency pixmap in that case ! */	1164	/* we need to re-generate transparency pixmap in that case ! */
1344	tr_flags = make_transparency_pixmap ();	1165	if (make_transparency_pixmap ())
1345	if (tr_flags == 0)
1346	return false;
1347	bg_flags |= BG_IS_VALID;	1166	bg_flags |= BG_IS_VALID;
1348	}	1167	}
1349	# endif	1168	# endif
1350		1169
1351	# ifdef BG_IMAGE_FROM_FILE	1170	# ifdef BG_IMAGE_FROM_FILE
1352	if ((bg_flags & BG_IS_FROM_FILE)	1171	for (vector<rxvt_image>::iterator bg_image = image_vec.begin (); bg_image < image_vec.end (); bg_image++)
1353	|| (tr_flags & BG_EFFECTS_FLAGS))
1354	{	1172	{
1355	if (render_image (tr_flags))	1173	if (render_image (*bg_image))
1356	bg_flags |= BG_IS_VALID;	1174	bg_flags |= BG_IS_VALID;
1357	}
1358	# endif
1359
1360	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1361	XImage *result = NULL;
1362
1363	if (tr_flags & BG_NEEDS_TINT)
1364	{
1365	result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1366	}
1367
1368	if (result)
1369	{
1370	/* our own client-side tinting */
1371	//if (tr_flags & BG_NEEDS_TINT)
1372	if (1)
1373	tint_ximage (DefaultVisual (dpy, display->screen), result);
1374
1375	GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1376
1377	if (gc)
1378	{
1379	XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1380
1381	XFreeGC (dpy, gc);
1382	}
1383
1384	XDestroyImage (result);
1385	}	1175	}
1386	# endif	1176	# endif
1387		1177
1388	if (!(bg_flags & BG_IS_VALID))	1178	if (!(bg_flags & BG_IS_VALID))
1389	{	1179	{
…		…
1422	bg_flags |= BG_HAS_RENDER_CONV;	1212	bg_flags |= BG_HAS_RENDER_CONV;
1423		1213
1424	XFree (filters);	1214	XFree (filters);
1425	}	1215	}
1426	#endif	1216	#endif
		1217
		1218	#ifdef BG_IMAGE_FROM_FILE
		1219	if (rs[Rs_backgroundPixmap])
		1220	{
		1221	rxvt_image *image = new_image ();
		1222	if (!image->set_file_geometry (rs[Rs_backgroundPixmap]))
		1223	image_vec.pop_back ();
		1224	}
		1225
		1226	# ifndef NO_RESOURCES
		1227	find_resources ("image", "Image", XrmEnumAllLevels, rxvt_define_image);
		1228	vector<rxvt_image>::iterator bg_image = image_vec.begin ();
		1229	while (bg_image != image_vec.end ())
		1230	{
		1231	if (!(bg_image->flags & IM_IS_SET))
		1232	bg_image = image_vec.erase (bg_image);
		1233	else
		1234	bg_image++;
		1235	}
		1236	# endif
		1237
		1238	if (image_vec.size () > 0
		1239	&& !bg_window_position_sensitive ())
		1240	update_background ();
		1241	#endif
1427	}	1242	}
1428		1243
1429	#endif /* HAVE_BG_PIXMAP */	1244	#endif /* HAVE_BG_PIXMAP */
1430		1245
1431	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1246	#ifdef ENABLE_TRANSPARENCY
1432	/* based on code from aterm-0.4.2 */	1247	/* based on code from aterm-0.4.2 */
1433		1248
1434	static inline void	1249	static inline void
1435	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)	1250	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1436	{	1251	{
…		…
1442	lookup[i] = (tmp / 0xffff) << sh;	1257	lookup[i] = (tmp / 0xffff) << sh;
1443	}	1258	}
1444	}	1259	}
1445		1260
1446	void	1261	void
1447	rxvt_term::tint_ximage (Visual *visual, XImage *ximage)	1262	rxvt_term::tint_ximage (XImage *ximage)
1448	{	1263	{
		1264	unsigned int size_r, size_g, size_b;
1449	int sh_r, sh_g, sh_b;	1265	int sh_r, sh_g, sh_b;
1450	uint32_t mask_r, mask_g, mask_b;	1266	uint32_t mask_r, mask_g, mask_b;
1451	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;	1267	uint32_t *lookup, *lookup_r, *lookup_g, *lookup_b;
1452	unsigned short low;	1268	unsigned short low;
1453	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	1269	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
…		…
1458	mask_r = visual->red_mask;	1274	mask_r = visual->red_mask;
1459	mask_g = visual->green_mask;	1275	mask_g = visual->green_mask;
1460	mask_b = visual->blue_mask;	1276	mask_b = visual->blue_mask;
1461		1277
1462	/* boring lookup table pre-initialization */	1278	/* boring lookup table pre-initialization */
1463	switch (ximage->depth)	1279	sh_r = ecb_ctz32 (mask_r);
1464	{	1280	sh_g = ecb_ctz32 (mask_g);
1465	case 15:	1281	sh_b = ecb_ctz32 (mask_b);
1466	if ((mask_r != 0x7c00) ||	1282
1467	(mask_g != 0x03e0) ||	1283	size_r = mask_r >> sh_r;
1468	(mask_b != 0x001f))	1284	size_g = mask_g >> sh_g;
		1285	size_b = mask_b >> sh_b;
		1286
		1287	if (size_r++ > 255 || size_g++ > 255 || size_b++ > 255)
1469	return;	1288	return;
1470	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+32+32));	1289
		1290	lookup = (uint32_t *)malloc (sizeof (uint32_t) * (size_r + size_g + size_b));
1471	lookup_r = lookup;	1291	lookup_r = lookup;
1472	lookup_g = lookup+32;	1292	lookup_g = lookup + size_r;
1473	lookup_b = lookup+32+32;	1293	lookup_b = lookup + size_r + size_g;
1474	sh_r = 10;
1475	sh_g = 5;
1476	sh_b = 0;
1477	break;
1478	case 16:
1479	if ((mask_r != 0xf800) ||
1480	(mask_g != 0x07e0) ||
1481	(mask_b != 0x001f))
1482	return;
1483	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(32+64+32));
1484	lookup_r = lookup;
1485	lookup_g = lookup+32;
1486	lookup_b = lookup+32+64;
1487	sh_r = 11;
1488	sh_g = 5;
1489	sh_b = 0;
1490	break;
1491	case 24:
1492	if ((mask_r != 0xff0000) ||
1493	(mask_g != 0x00ff00) ||
1494	(mask_b != 0x0000ff))
1495	return;
1496	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1497	lookup_r = lookup;
1498	lookup_g = lookup+256;
1499	lookup_b = lookup+256+256;
1500	sh_r = 16;
1501	sh_g = 8;
1502	sh_b = 0;
1503	break;
1504	case 32:
1505	if ((mask_r != 0xff0000) ||
1506	(mask_g != 0x00ff00) ||
1507	(mask_b != 0x0000ff))
1508	return;
1509	lookup = (uint32_t *) malloc (sizeof (uint32_t)*(256+256+256));
1510	lookup_r = lookup;
1511	lookup_g = lookup+256;
1512	lookup_b = lookup+256+256;
1513	sh_r = 16;
1514	sh_g = 8;
1515	sh_b = 0;
1516	break;
1517	default:
1518	return; /* we do not support this color depth */
1519	}
1520		1294
1521	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);	1295	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1522		1296
1523	if (bg_flags & BG_TINT_SET)	1297	if (bg_flags & BG_TINT_SET)
1524	tint.get (c);	1298	tint.get (c);
…		…
1546	fill_lut (lookup_g, mask_g, sh_g, low, c.g);	1320	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1547	fill_lut (lookup_b, mask_b, sh_b, low, c.b);	1321	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1548		1322
1549	/* apply table to input image (replacing colors by newly calculated ones) */	1323	/* apply table to input image (replacing colors by newly calculated ones) */
1550	if (ximage->bits_per_pixel == 32	1324	if (ximage->bits_per_pixel == 32
1551	&& (ximage->depth == 24 || ximage->depth == 32)
1552	&& ximage->byte_order == host_byte_order)	1325	&& ximage->byte_order == host_byte_order)
1553	{	1326	{
1554	uint32_t *p1, *pf, *p, *pl;	1327	char *line = ximage->data;
1555	p1 = (uint32_t *) ximage->data;
1556	pf = (uint32_t *) (ximage->data + ximage->height * ximage->bytes_per_line);
1557		1328
1558	while (p1 < pf)	1329	for (int y = 0; y < ximage->height; y++)
1559	{	1330	{
1560	p = p1;	1331	uint32_t *p = (uint32_t *)line;
1561	pl = p1 + ximage->width;	1332	for (int x = 0; x < ximage->width; x++)
1562	for (; p < pl; p++)
1563	{	1333	{
1564	*p = lookup_r[(*p & 0xff0000) >> 16] |	1334	*p = lookup_r[(*p & mask_r) >> sh_r] |
1565	lookup_g[(*p & 0x00ff00) >> 8] |	1335	lookup_g[(*p & mask_g) >> sh_g] |
1566	lookup_b[(*p & 0x0000ff)] |	1336	lookup_b[(*p & mask_b) >> sh_b];
1567	(*p & 0xff000000);	1337	p++;
1568	}	1338	}
1569	p1 = (uint32_t *) ((char *) p1 + ximage->bytes_per_line);	1339	line += ximage->bytes_per_line;
1570	}	1340	}
1571	}	1341	}
1572	else	1342	else
1573	{	1343	{
1574	for (int y = 0; y < ximage->height; y++)	1344	for (int y = 0; y < ximage->height; y++)
…		…
1582	}	1352	}
1583	}	1353	}
1584		1354
1585	free (lookup);	1355	free (lookup);
1586	}	1356	}
1587	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1357	#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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