[ViewVC] Diff of: cvs/rxvt-unicode/src/background.C

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.192 by sf-exg, Fri Dec 30 12:45:56 2011 UTC vs.
Revision 1.211 by sf-exg, Sun May 13 15:28:44 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>
31	#endif	31	#endif
32		32
33	#ifndef FilterConvolution	33	#ifndef FilterConvolution
34	#define FilterConvolution "convolution"	34	#define FilterConvolution "convolution"
		35	#endif
		36
		37	#ifndef RepeatPad
		38	#define RepeatPad True
35	#endif	39	#endif
36		40
37	#ifdef HAVE_BG_PIXMAP	41	#ifdef HAVE_BG_PIXMAP
38	# if XRENDER	42	# if XRENDER
39	static Picture	43	static Picture
…		…
54	# endif	58	# endif
55		59
56	void	60	void
57	rxvt_term::bg_destroy ()	61	rxvt_term::bg_destroy ()
58	{	62	{
59	#ifdef HAVE_AFTERIMAGE
60	if (original_asim)
61	safe_asimage_destroy (original_asim);
62	if (asv)
63	destroy_asvisual (asv, 0);
64	if (asimman)
65	destroy_image_manager (asimman, 0);
66	#endif
67
68	#ifdef HAVE_PIXBUF	63	#ifdef HAVE_PIXBUF
69	if (pixbuf)	64	if (pixbuf)
70	g_object_unref (pixbuf);	65	g_object_unref (pixbuf);
71	#endif	66	#endif
72		67
…		…
125		120
126	return false;	121	return false;
127	}	122	}
128		123
129	# ifdef BG_IMAGE_FROM_FILE	124	# ifdef BG_IMAGE_FROM_FILE
130	static inline bool
131	check_set_scale_value (int geom_flags, int flag, unsigned int &scale, unsigned int new_value)
132	{
133	if (geom_flags & flag)
134	{
135	if (new_value > 1000)
136	new_value = 1000;
137	if (new_value != scale)
138	{
139	scale = new_value;
140	return true;
141	}
142	}
143	return false;
144	}
145
146	static inline bool
147	check_set_align_value (int geom_flags, int flag, int &align, int new_value)
148	{
149	if (geom_flags & flag)
150	{
151	if (new_value < -100)
152	new_value = -100;
153	else if (new_value > 200)
154	new_value = 200;
155	if (new_value != align)
156	{
157	align = new_value;
158	return true;
159	}
160	}
161	return false;
162	}
163
164	static inline int	125	static inline int
165	make_align_position (int align, int window_size, int image_size)	126	make_align_position (int align, int window_size, int image_size)
166	{	127	{
167	int diff = window_size - image_size;
168	int smaller = min (image_size, window_size);
169
170	if (align >= 0 && align <= 100)	128	if (align >= 0 && align <= 100)
171	return diff * align / 100;	129	return lerp (0, window_size - image_size, align);
172	else if (align > 100 && align <= 200)	130	else if (align > 100)
173	return (align - 100) * smaller / 100 + window_size - smaller;	131	return lerp (window_size - image_size, window_size, align - 100);
174	else if (align >= -100 && align < 0)	132	else
175	return (align + 100) * smaller / 100 - image_size;	133	return lerp (-image_size, 0, align + 100);
176	return 0;
177	}	134	}
178		135
179	static inline int	136	static inline int
180	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	137	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
181	{	138	{
…		…
187	src_pos = -pos;	144	src_pos = -pos;
188	dst_pos = 0;	145	dst_pos = 0;
189	dst_size += pos;	146	dst_size += pos;
190	}	147	}
191		148
192	if (dst_pos + dst_size > target_size)
193	dst_size = target_size - dst_pos;	149	min_it (dst_size, target_size - dst_pos);
194	return src_pos;	150	return src_pos;
195	}	151	}
196		152
197	bool	153	bool
198	rxvt_term::bg_set_geometry (const char *geom, bool update)	154	rxvt_term::bg_set_geometry (const char *geom, bool update)
199	{	155	{
200	bool changed = false;	156	bool changed = false;
201	int geom_flags = 0;	157	int geom_flags = 0;
202	int x = 0, y = 0;	158	int x = h_align;
		159	int y = v_align;
203	unsigned int w = 0, h = 0;	160	unsigned int w = h_scale;
		161	unsigned int h = v_scale;
204	unsigned long new_flags = 0;	162	unsigned long new_flags = 0;
205		163
206	if (geom == NULL)	164	if (geom == NULL)
207	return false;	165	return false;
208		166
…		…
317	w = h = defaultScale;	275	w = h = defaultScale;
318	else if (!(geom_flags & HeightValue))	276	else if (!(geom_flags & HeightValue))
319	h = w;	277	h = w;
320	else if (!(geom_flags & WidthValue))	278	else if (!(geom_flags & WidthValue))
321	w = h;	279	w = h;
322
323	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
324	}	280	}
325		281
326	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;	282	min_it (w, 1000);
327	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;	283	min_it (h, 1000);
328	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;	284	clamp_it (x, -100, 200);
329	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;	285	clamp_it (y, -100, 200);
330		286
331	if (new_flags != bg_flags)	287	if (bg_flags != new_flags
		288	\|\| h_scale != w
		289	\|\| v_scale != h
		290	\|\| h_align != x
		291	\|\| v_align != y)
332	{	292	{
333	bg_flags = new_flags;	293	bg_flags = new_flags;
		294	h_scale = w;
		295	v_scale = h;
		296	h_align = x;
		297	v_align = y;
334	changed = true;	298	changed = true;
335	}	299	}
336		300
337	return changed;	301	return changed;
338	}	302	}
…		…
366	{	330	{
367	x = make_align_position (h_align, target_width, w);	331	x = make_align_position (h_align, target_width, w);
368	y = make_align_position (v_align, target_height, h);	332	y = make_align_position (v_align, target_height, h);
369	}	333	}
370		334
371	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
372	if (!(bg_flags & BG_TILE)	335	if (!(bg_flags & BG_TILE)
373	\|\| h_scale \|\| v_scale	336	\|\| h_scale \|\| v_scale
374	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	337	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
375	\|\| w > target_width \|\| h > target_height)	338	\|\| image_width > target_width \|\| image_height > target_height)
376	bg_flags \|= BG_IS_SIZE_SENSITIVE;	339	bg_flags \|= BG_IS_SIZE_SENSITIVE;
377	}
378
379	# ifdef HAVE_AFTERIMAGE
380	bool
381	rxvt_term::render_image (unsigned long tr_flags)
382	{
383	init_asv ();
384
385	ASImage *background = NULL;
386	ARGB32 background_tint = TINT_LEAVE_SAME;
387
388	# ifdef ENABLE_TRANSPARENCY
389	if (tr_flags)
390	background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
391
392	if (tr_flags & BG_NEEDS_TINT)
393	{
394	ShadingInfo as_shade;
395	as_shade.shading = shade;
396
397	rgba c;
398	tint.get (c);
399	as_shade.tintColor.red = c.r;
400	as_shade.tintColor.green = c.g;
401	as_shade.tintColor.blue = c.b;
402
403	background_tint = shading2tint32 (&as_shade);
404	}
405
406	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
407	{
408	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
409	ASA_XImage,
410	100, ASIMAGE_QUALITY_DEFAULT);
411	if (tmp)
412	{
413	destroy_asimage (&background);
414	background = tmp;
415	}
416	}
417	# endif
418
419	ASImage *result = 0;
420
421	int target_width = szHint.width;
422	int target_height = szHint.height;
423	int new_pmap_width = target_width;
424	int new_pmap_height = target_height;
425
426	int x = 0;
427	int y = 0;
428	int w = 0;
429	int h = 0;
430
431	if (original_asim)
432	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
433
434	if (!original_asim
435	\|\| (!(bg_flags & BG_ROOT_ALIGN)
436	&& (x >= target_width
437	\|\| y >= target_height
438	\|\| x + w <= 0
439	\|\| y + h <= 0)))
440	{
441	if (background)
442	{
443	new_pmap_width = background->width;
444	new_pmap_height = background->height;
445	result = background;
446
447	if (background_tint != TINT_LEAVE_SAME)
448	{
449	ASImage *tmp = tile_asimage (asv, background, 0, 0,
450	target_width, target_height, background_tint,
451	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
452	if (tmp)
453	result = tmp;
454	}
455	}
456	else
457	new_pmap_width = new_pmap_height = 0;
458	}
459	else	340	else
460	{	341	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
461	result = original_asim;
462
463	if (w != original_asim->width
464	\|\| h != original_asim->height)
465	{
466	result = scale_asimage (asv, original_asim,
467	w, h,
468	ASA_XImage,
469	100, ASIMAGE_QUALITY_DEFAULT);
470	}
471
472	if (background == NULL)
473	{
474	if (bg_flags & BG_TILE)
475	{
476	/* if tiling - pixmap has to be sized exactly as the image,
477	but there is no need to make it bigger than the window! */
478	new_pmap_width = min (result->width, target_width);
479	new_pmap_height = min (result->height, target_height);
480
481	/* we also need to tile our image in both directions */
482	ASImage *tmp = tile_asimage (asv, result,
483	(int)result->width - x,
484	(int)result->height - y,
485	new_pmap_width,
486	new_pmap_height,
487	TINT_LEAVE_SAME, ASA_XImage,
488	100, ASIMAGE_QUALITY_DEFAULT);
489	if (tmp)
490	{
491	if (result != original_asim)
492	destroy_asimage (&result);
493
494	result = tmp;
495	}
496	}
497	}
498	else
499	{
500	/* if blending background and image - pixmap has to be sized same as target window */
501	ASImageLayer *layers = create_image_layers (2);
502
503	layers[0].im = background;
504	layers[0].clip_width = target_width;
505	layers[0].clip_height = target_height;
506	layers[0].tint = background_tint;
507	layers[1].im = result;
508
509	if (bg_flags & BG_TILE)
510	{
511	/* tile horizontally */
512	while (x > 0) x -= (int)result->width;
513	layers[1].dst_x = x;
514	layers[1].clip_width = result->width+target_width;
515	}
516	else
517	{
518	/* clip horizontally */
519	layers[1].dst_x = x;
520	layers[1].clip_width = result->width;
521	}
522
523	if (bg_flags & BG_TILE)
524	{
525	while (y > 0) y -= (int)result->height;
526	layers[1].dst_y = y;
527	layers[1].clip_height = result->height + target_height;
528	}
529	else
530	{
531	layers[1].dst_y = y;
532	layers[1].clip_height = result->height;
533	}
534
535	if (rs[Rs_blendtype])
536	{
537	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
538	if (layers[1].merge_scanlines == NULL)
539	layers[1].merge_scanlines = alphablend_scanlines;
540	}
541
542	ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
543	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
544
545	if (tmp)
546	{
547	if (result != original_asim)
548	destroy_asimage (&result);
549
550	result = tmp;
551	}
552
553	free (layers);
554	}
555	}
556
557	bool ret = false;
558
559	if (result)
560	{
561	XGCValues gcv;
562	GC gc;
563
564	/* create Pixmap */
565	if (bg_pixmap == None
566	\|\| bg_pmap_width != new_pmap_width
567	\|\| bg_pmap_height != new_pmap_height)
568	{
569	if (bg_pixmap)
570	XFreePixmap (dpy, bg_pixmap);
571	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
572	bg_pmap_width = new_pmap_width;
573	bg_pmap_height = new_pmap_height;
574	}
575	/* fill with background color (if result's not completely overlapping it) */
576	gcv.foreground = pix_colors[Color_bg];
577	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
578
579	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
580	int dst_width = result->width, dst_height = result->height;
581	if (background == NULL)
582	{
583	if (!(bg_flags & BG_TILE))
584	{
585	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
586	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
587	}
588
589	if (dst_x > 0 \|\| dst_y > 0
590	\|\| dst_x + dst_width < new_pmap_width
591	\|\| dst_y + dst_height < new_pmap_height)
592	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
593	}
594
595	/* put result on pixmap */
596	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
597	asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
598
599	if (result != background && result != original_asim)
600	destroy_asimage (&result);
601
602	XFreeGC (dpy, gc);
603
604	ret = true;
605	}
606
607	if (background)
608	destroy_asimage (&background);
609
610	return ret;
611	}	342	}
612	# endif /* HAVE_AFTERIMAGE */
613		343
614	# ifdef HAVE_PIXBUF	344	# ifdef HAVE_PIXBUF
615	bool	345	bool
616	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,	346	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
617	int src_x, int src_y, int dst_x, int dst_y,	347	int src_x, int src_y, int dst_x, int dst_y,
618	unsigned int width, unsigned int height)	348	unsigned int width, unsigned int height)
619	{	349	{
620	XImage *ximage;	350	XImage *ximage;
621	char data, line;	351	char *line;
622	int bytes_per_pixel;
623	int width_r, width_g, width_b;	352	int width_r, width_g, width_b, width_a;
624	int sh_r, sh_g, sh_b;	353	int sh_r, sh_g, sh_b, sh_a;
		354	uint32_t alpha_mask;
625	int rowstride;	355	int rowstride;
626	int channels;	356	int channels;
627	unsigned char *row;	357	unsigned char *row;
628		358
629	if (visual->c_class != TrueColor)	359	if (visual->c_class != TrueColor)
630	return false;	360	return false;
631		361
632	if (depth == 24 \|\| depth == 32)	362	#if XRENDER
633	bytes_per_pixel = 4;	363	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
634	else if (depth == 15 \|\| depth == 16)	364	if (format)
635	bytes_per_pixel = 2;	365	alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
636	else	366	else
637	return false;	367	#endif
		368	alpha_mask = 0;
638		369
639	width_r = ecb_popcount32 (visual->red_mask);	370	width_r = ecb_popcount32 (visual->red_mask);
640	width_g = ecb_popcount32 (visual->green_mask);	371	width_g = ecb_popcount32 (visual->green_mask);
641	width_b = ecb_popcount32 (visual->blue_mask);	372	width_b = ecb_popcount32 (visual->blue_mask);
		373	width_a = ecb_popcount32 (alpha_mask);
642		374
643	if (width_r > 8 \|\| width_g > 8 \|\| width_b > 8)	375	if (width_r > 8 \|\| width_g > 8 \|\| width_b > 8 \|\| width_a > 8)
644	return false;	376	return false;
645		377
646	sh_r = ecb_ctz32 (visual->red_mask);	378	sh_r = ecb_ctz32 (visual->red_mask);
647	sh_g = ecb_ctz32 (visual->green_mask);	379	sh_g = ecb_ctz32 (visual->green_mask);
648	sh_b = ecb_ctz32 (visual->blue_mask);	380	sh_b = ecb_ctz32 (visual->blue_mask);
		381	sh_a = ecb_ctz32 (alpha_mask);
649		382
650	if (width > INT_MAX / height / bytes_per_pixel)	383	if (width > 32767 \|\| height > 32767)
651	return false;	384	return false;
652		385
653	data = (char )malloc (width height * bytes_per_pixel);	386	ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, 0,
654	if (!data)	387	width, height, 32, 0);
		388	if (!ximage)
655	return false;	389	return false;
656		390
657	ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, data,	391	if (height > INT_MAX / ximage->bytes_per_line
658	width, height, bytes_per_pixel * 8, 0);	392	\|\| !(ximage->data = (char )malloc (height ximage->bytes_per_line)))
659	if (!ximage)
660	{	393	{
661	free (data);	394	XDestroyImage (ximage);
662	return false;	395	return false;
663	}	396	}
664		397
665	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	398	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
666		399
667	rowstride = gdk_pixbuf_get_rowstride (pixbuf);	400	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
668	channels = gdk_pixbuf_get_n_channels (pixbuf);	401	channels = gdk_pixbuf_get_n_channels (pixbuf);
669	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;	402	row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
670	line = data;	403	line = ximage->data;
		404
		405	rgba c (0, 0, 0);
		406
		407	if (channels == 4 && alpha_mask == 0)
		408	{
		409	pix_colors[Color_bg].get (c);
		410	c.r >>= 8;
		411	c.g >>= 8;
		412	c.b >>= 8;
		413	}
671		414
672	for (int y = 0; y < height; y++)	415	for (int y = 0; y < height; y++)
673	{	416	{
674	for (int x = 0; x < width; x++)	417	for (int x = 0; x < width; x++)
675	{	418	{
676	unsigned char pixel = row + x channels;	419	unsigned char pixel = row + x channels;
677	uint32_t value;	420	uint32_t value;
		421	unsigned char r, g, b, a;
678		422
		423	if (channels == 4)
		424	{
		425	a = pixel[3];
		426	r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
		427	g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
		428	b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
		429	}
		430	else
		431	{
		432	a = 0xff;
		433	r = pixel[0];
		434	g = pixel[1];
		435	b = pixel[2];
		436	}
		437
679	value = ((pixel[0] >> (8 - width_r)) << sh_r)	438	value = ((r >> (8 - width_r)) << sh_r)
680	\| ((pixel[1] >> (8 - width_g)) << sh_g)	439	\| ((g >> (8 - width_g)) << sh_g)
681	\| ((pixel[2] >> (8 - width_b)) << sh_b);	440	\| ((b >> (8 - width_b)) << sh_b)
		441	\| ((a >> (8 - width_a)) << sh_a);
682		442
683	if (bytes_per_pixel == 4)	443	if (ximage->bits_per_pixel == 32)
684	((uint32_t *)line)[x] = value;	444	((uint32_t *)line)[x] = value;
685	else	445	else
686	((uint16_t *)line)[x] = value;	446	XPutPixel (ximage, x, y, value);
687	}	447	}
688		448
689	row += rowstride;	449	row += rowstride;
690	line += ximage->bytes_per_line;	450	line += ximage->bytes_per_line;
691	}	451	}
…		…
694	XDestroyImage (ximage);	454	XDestroyImage (ximage);
695	return true;	455	return true;
696	}	456	}
697		457
698	bool	458	bool
699	rxvt_term::render_image (unsigned long tr_flags)	459	rxvt_term::render_image (bool transparent)
700	{	460	{
701	if (!pixbuf)	461	if (!pixbuf)
702	return false;	462	return false;
703		463
704	if (tr_flags	464	if (transparent
705	&& !(bg_flags & BG_HAS_RENDER))	465	&& !(bg_flags & BG_HAS_RENDER))
706	return false;	466	return false;
707		467
708	GdkPixbuf *result;	468	GdkPixbuf *result;
709		469
…		…
749	Pixmap root_pmap;	509	Pixmap root_pmap;
750		510
751	image_width = gdk_pixbuf_get_width (result);	511	image_width = gdk_pixbuf_get_width (result);
752	image_height = gdk_pixbuf_get_height (result);	512	image_height = gdk_pixbuf_get_height (result);
753		513
754	if (tr_flags)	514	if (transparent)
755	{	515	{
756	root_pmap = bg_pixmap;	516	root_pmap = bg_pixmap;
757	bg_pixmap = None;	517	bg_pixmap = None;
758	}	518	}
759	else	519	else
…		…
817	dst_x, dst_y,	577	dst_x, dst_y,
818	dst_width, dst_height);	578	dst_width, dst_height);
819	}	579	}
820		580
821	#if XRENDER	581	#if XRENDER
822	if (tr_flags)	582	if (transparent)
823	{	583	{
824	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	584	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
825		585
826	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);	586	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
827		587
…		…
851	}	611	}
852		612
853	if (result != pixbuf)	613	if (result != pixbuf)
854	g_object_unref (result);	614	g_object_unref (result);
855		615
856	if (tr_flags)	616	if (transparent)
857	XFreePixmap (dpy, root_pmap);	617	XFreePixmap (dpy, root_pmap);
858		618
859	return ret;	619	return ret;
860	}	620	}
861	# endif /* HAVE_PIXBUF */	621	# endif /* HAVE_PIXBUF */
…		…
876	memcpy (f, file, len);	636	memcpy (f, file, len);
877	f[len] = '\0';	637	f[len] = '\0';
878	file = f;	638	file = f;
879	}	639	}
880		640
881	# ifdef HAVE_AFTERIMAGE
882	if (!asimman)
883	asimman = create_generic_imageman (rs[Rs_path]);
884	ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
885	if (image)
886	{
887	if (original_asim)
888	safe_asimage_destroy (original_asim);
889	original_asim = image;
890	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;
891	ret = true;
892	}
893	# endif
894
895	# ifdef HAVE_PIXBUF	641	# ifdef HAVE_PIXBUF
896	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	642	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
897	if (image)	643	if (image)
898	{	644	{
899	if (pixbuf)	645	if (pixbuf)
…		…
917		663
918	# endif /* BG_IMAGE_FROM_FILE */	664	# endif /* BG_IMAGE_FROM_FILE */
919		665
920	# ifdef ENABLE_TRANSPARENCY	666	# ifdef ENABLE_TRANSPARENCY
921	bool	667	bool
922	rxvt_term::bg_set_transparent ()
923	{
924	if (!(bg_flags & BG_IS_TRANSPARENT))
925	{
926	bg_flags \|= BG_IS_TRANSPARENT;
927	return true;
928	}
929
930	return false;
931	}
932
933	bool
934	rxvt_term::bg_set_blur (const char *geom)	668	rxvt_term::bg_set_blur (const char *geom)
935	{	669	{
936	bool changed = false;	670	bool changed = false;
937	unsigned int hr, vr;	671	unsigned int hr, vr;
938	int junk;	672	int junk;
…		…
956	{	690	{
957	changed = true;	691	changed = true;
958	v_blurRadius = vr;	692	v_blurRadius = vr;
959	}	693	}
960		694
961	if (v_blurRadius == 0 && h_blurRadius == 0)	695	if (h_blurRadius && v_blurRadius)
		696	bg_flags \|= BG_NEEDS_BLUR;
		697	else
962	bg_flags &= ~BG_NEEDS_BLUR;	698	bg_flags &= ~BG_NEEDS_BLUR;
963	else
964	bg_flags \|= BG_NEEDS_BLUR;
965		699
966	return changed;	700	return changed;
967	}	701	}
968		702
969	void	703	void
970	rxvt_term::set_tint_shade_flags ()	704	rxvt_term::set_tint_shade_flags ()
971	{	705	{
972	rgba c;	706	if (shade != 100 \|\| (bg_flags & BG_TINT_SET))
973	bool has_shade = shade != 100;
974
975	bg_flags &= ~BG_TINT_FLAGS;
976
977	tint.get (c);
978
979	if (!has_shade
980	&& (c.r <= 0x00ff \|\| c.r >= 0xff00)
981	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)
982	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))
983	bg_flags \|= BG_TINT_BITAND;
984
985	if (has_shade
986	\|\| c.r < 0xff00
987	\|\| c.g < 0xff00
988	\|\| c.b < 0xff00)
989	bg_flags \|= BG_NEEDS_TINT;	707	bg_flags \|= BG_NEEDS_TINT;
		708	else
		709	bg_flags &= ~BG_NEEDS_TINT;
990	}	710	}
991		711
992	bool	712	bool
993	rxvt_term::bg_set_tint (rxvt_color &new_tint)	713	rxvt_term::bg_set_tint (rxvt_color &new_tint)
994	{	714	{
995	if (tint != new_tint)	715	if (!(bg_flags & BG_TINT_SET) \|\| tint != new_tint)
996	{	716	{
997	tint = new_tint;	717	tint = new_tint;
		718	bg_flags \|= BG_TINT_SET;
		719
		720	rgba c;
		721	tint.get (c);
		722	if ((c.r <= 0x00ff \|\| c.r >= 0xff00)
		723	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)
		724	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))
		725	bg_flags \|= BG_TINT_BITAND;
		726	else
		727	bg_flags &= ~BG_TINT_BITAND;
		728
998	set_tint_shade_flags ();	729	set_tint_shade_flags ();
999	return true;	730	return true;
1000	}	731	}
1001		732
1002	return false;	733	return false;
…		…
1043	params[i+2] = XDoubleToFixed (kernel[i] / sum);	774	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1044	}	775	}
1045	#endif	776	#endif
1046		777
1047	bool	778	bool
1048	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	779	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1049	{	780	{
1050	bool ret = false;	781	bool ret = false;
1051	#if XRENDER	782	#if XRENDER
1052	if (!(bg_flags & BG_HAS_RENDER_CONV))	783	if (!(bg_flags & BG_HAS_RENDER_CONV))
1053	return false;	784	return false;
1054		785
1055	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	786	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1056	double kernel = (double )malloc (size * sizeof (double));	787	double kernel = (double )malloc (size * sizeof (double));
1057	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	788	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1058		789
		790	XRenderPictureAttributes pa;
1059	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	791	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1060		792
		793	pa.repeat = RepeatPad;
1061	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, 0);	794	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		795	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1062	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, 0);	796	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		797	XFreePixmap (dpy, tmp);
1063		798
1064	if (kernel && params)	799	if (kernel && params)
1065	{	800	{
1066	if (h_blurRadius)
1067	{
1068	size = h_blurRadius * 2 + 1;	801	size = h_blurRadius * 2 + 1;
1069	get_gaussian_kernel (h_blurRadius, size, kernel, params);	802	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1070		803
1071	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	804	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1072	XRenderComposite (dpy,	805	XRenderComposite (dpy,
1073	PictOpSrc,	806	PictOpSrc,
1074	src,	807	src,
1075	None,	808	None,
1076	dst,	809	dst,
1077	0, 0,	810	0, 0,
1078	0, 0,	811	0, 0,
1079	0, 0,	812	0, 0,
1080	width, height);	813	width, height);
1081	}
1082		814
1083	if (v_blurRadius)	815	::swap (src, dst);
1084	{	816
1085	size = v_blurRadius * 2 + 1;	817	size = v_blurRadius * 2 + 1;
1086	get_gaussian_kernel (v_blurRadius, size, kernel, params);	818	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1087	::swap (params[0], params[1]);	819	::swap (params[0], params[1]);
1088		820
1089	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	821	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1090	XRenderComposite (dpy,	822	XRenderComposite (dpy,
1091	PictOpSrc,	823	PictOpSrc,
1092	src,	824	src,
1093	None,	825	None,
1094	dst,	826	dst,
1095	0, 0,	827	0, 0,
1096	0, 0,	828	0, 0,
1097	0, 0,	829	0, 0,
1098	width, height);	830	width, height);
1099	}
1100		831
1101	ret = true;	832	ret = true;
1102	}	833	}
1103		834
1104	free (kernel);	835	free (kernel);
…		…
1112	bool	843	bool
1113	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	844	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1114	{	845	{
1115	bool ret = false;	846	bool ret = false;
1116		847
1117	if (bg_flags & BG_TINT_BITAND)	848	if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1118	{	849	{
1119	XGCValues gcv;	850	XGCValues gcv;
1120	GC gc;	851	GC gc;
1121		852
1122	/* In this case we can tint image server-side getting significant	853	/* In this case we can tint image server-side getting significant
…		…
1134	}	865	}
1135	}	866	}
1136	# if XRENDER	867	# if XRENDER
1137	else if (bg_flags & BG_HAS_RENDER)	868	else if (bg_flags & BG_HAS_RENDER)
1138	{	869	{
1139	rgba c;	870	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1140		871
		872	if (bg_flags & BG_TINT_SET)
1141	tint.get (c);	873	tint.get (c);
1142		874
1143	if (shade <= 100)	875	if (shade <= 100)
1144	{	876	{
1145	c.r = c.r * shade / 100;	877	c.r = c.r * shade / 100;
1146	c.g = c.g * shade / 100;	878	c.g = c.g * shade / 100;
…		…
1202	/*	934	/*
1203	* Builds a pixmap of the same size as the terminal window that contains	935	* Builds a pixmap of the same size as the terminal window that contains
1204	* the tiled portion of the root pixmap that is supposed to be covered by	936	* the tiled portion of the root pixmap that is supposed to be covered by
1205	* our window.	937	* our window.
1206	*/	938	*/
1207	unsigned long	939	bool
1208	rxvt_term::make_transparency_pixmap ()	940	rxvt_term::make_transparency_pixmap ()
1209	{	941	{
1210	unsigned long result = 0;	942	bool ret = false;
1211		943
1212	/* root dimensions may change from call to call - but Display structure should	944	/* root dimensions may change from call to call - but Display structure should
1213	* be always up-to-date, so let's use it :	945	* be always up-to-date, so let's use it :
1214	*/	946	*/
1215	int screen = display->screen;	947	int screen = display->screen;
…		…
1296	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);	1028	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);
1297		1029
1298	if (gc)	1030	if (gc)
1299	{	1031	{
1300	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1032	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1301	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1033	ret = true;
		1034	unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
1302		1035
1303	if (!(bg_flags & BG_CLIENT_RENDER))	1036	if (!(bg_flags & BG_CLIENT_RENDER))
1304	{	1037	{
1305	if (bg_flags & BG_NEEDS_BLUR)	1038	if (bg_flags & BG_NEEDS_BLUR)
1306	{	1039	{
1307	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))	1040	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1308	result &= ~BG_NEEDS_BLUR;	1041	tr_flags &= ~BG_NEEDS_BLUR;
1309	}	1042	}
1310	if (bg_flags & BG_NEEDS_TINT)	1043	if (bg_flags & BG_NEEDS_TINT)
1311	{	1044	{
1312	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))	1045	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1313	result &= ~BG_NEEDS_TINT;	1046	tr_flags &= ~BG_NEEDS_TINT;
1314	}	1047	}
1315	# ifndef HAVE_AFTERIMAGE
1316	if (result & BG_NEEDS_TINT)	1048	if (tr_flags & BG_NEEDS_TINT)
1317	{	1049	{
1318	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);	1050	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1319	if (ximage)	1051	if (ximage)
1320	{	1052	{
1321	/* our own client-side tinting */	1053	/* our own client-side tinting */
…		…
1323		1055
1324	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);	1056	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1325	XDestroyImage (ximage);	1057	XDestroyImage (ximage);
1326	}	1058	}
1327	}	1059	}
1328	# endif
1329	} /* server side rendering completed */	1060	} /* server side rendering completed */
1330		1061
1331	XFreeGC (dpy, gc);	1062	XFreeGC (dpy, gc);
1332	}	1063	}
1333		1064
1334	if (recoded_root_pmap != root_pixmap)	1065	if (recoded_root_pmap != root_pixmap)
1335	XFreePixmap (dpy, recoded_root_pmap);	1066	XFreePixmap (dpy, recoded_root_pmap);
1336		1067
1337	return result;	1068	return ret;
1338	}	1069	}
1339		1070
1340	void	1071	void
1341	rxvt_term::bg_set_root_pixmap ()	1072	rxvt_term::bg_set_root_pixmap ()
1342	{	1073	{
…		…
1349	# endif /* ENABLE_TRANSPARENCY */	1080	# endif /* ENABLE_TRANSPARENCY */
1350		1081
1351	bool	1082	bool
1352	rxvt_term::bg_render ()	1083	rxvt_term::bg_render ()
1353	{	1084	{
1354	unsigned long tr_flags = 0;	1085	bool transparent = false;
1355		1086
1356	bg_invalidate ();	1087	bg_invalidate ();
1357	# ifdef ENABLE_TRANSPARENCY	1088	# ifdef ENABLE_TRANSPARENCY
1358	if (bg_flags & BG_IS_TRANSPARENT)	1089	if (bg_flags & BG_IS_TRANSPARENT)
1359	{	1090	{
1360	/* we need to re-generate transparency pixmap in that case ! */	1091	/* we need to re-generate transparency pixmap in that case ! */
1361	tr_flags = make_transparency_pixmap ();	1092	transparent = make_transparency_pixmap ();
1362	if (tr_flags == 0)	1093	if (transparent)
1363	return false;
1364	bg_flags \|= BG_IS_VALID;	1094	bg_flags \|= BG_IS_VALID;
1365	}	1095	}
1366	# endif	1096	# endif
1367		1097
1368	# ifdef BG_IMAGE_FROM_FILE	1098	# ifdef BG_IMAGE_FROM_FILE
1369	if ((bg_flags & BG_IS_FROM_FILE)	1099	if (bg_flags & BG_IS_FROM_FILE)
1370	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1371	{	1100	{
1372	if (render_image (tr_flags))	1101	if (render_image (transparent))
1373	bg_flags \|= BG_IS_VALID;	1102	bg_flags \|= BG_IS_VALID;
1374	}	1103	}
1375	# endif	1104	# endif
1376		1105
1377	if (!(bg_flags & BG_IS_VALID))	1106	if (!(bg_flags & BG_IS_VALID))
…		…
1393		1122
1394	void	1123	void
1395	rxvt_term::bg_init ()	1124	rxvt_term::bg_init ()
1396	{	1125	{
1397	#ifdef ENABLE_TRANSPARENCY	1126	#ifdef ENABLE_TRANSPARENCY
1398	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1399	tint.set (this, c);
1400	shade = 100;	1127	shade = 100;
1401	#endif	1128	#endif
1402		1129
1403	bg_flags &= ~(BG_HAS_RENDER \| BG_HAS_RENDER_CONV);	1130	bg_flags &= ~(BG_HAS_RENDER \| BG_HAS_RENDER_CONV);
1404	#if XRENDER	1131	#if XRENDER
…		…
1417	#endif	1144	#endif
1418	}	1145	}
1419		1146
1420	#endif /* HAVE_BG_PIXMAP */	1147	#endif /* HAVE_BG_PIXMAP */
1421		1148
1422	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1149	#ifdef ENABLE_TRANSPARENCY
1423	/* based on code from aterm-0.4.2 */	1150	/* based on code from aterm-0.4.2 */
1424		1151
1425	static inline void	1152	static inline void
1426	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)	1153	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1427	{	1154	{
…		…
1435	}	1162	}
1436		1163
1437	void	1164	void
1438	rxvt_term::tint_ximage (Visual visual, XImage ximage)	1165	rxvt_term::tint_ximage (Visual visual, XImage ximage)
1439	{	1166	{
		1167	unsigned int size_r, size_g, size_b;
1440	int sh_r, sh_g, sh_b;	1168	int sh_r, sh_g, sh_b;
1441	uint32_t mask_r, mask_g, mask_b;	1169	uint32_t mask_r, mask_g, mask_b;
1442	uint32_t lookup, lookup_r, lookup_g, lookup_b;	1170	uint32_t lookup, lookup_r, lookup_g, lookup_b;
1443	unsigned short low;	1171	unsigned short low;
1444	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	1172	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
…		…
1449	mask_r = visual->red_mask;	1177	mask_r = visual->red_mask;
1450	mask_g = visual->green_mask;	1178	mask_g = visual->green_mask;
1451	mask_b = visual->blue_mask;	1179	mask_b = visual->blue_mask;
1452		1180
1453	/* boring lookup table pre-initialization */	1181	/* boring lookup table pre-initialization */
1454	switch (ximage->depth)	1182	sh_r = ecb_ctz32 (mask_r);
1455	{	1183	sh_g = ecb_ctz32 (mask_g);
1456	case 15:	1184	sh_b = ecb_ctz32 (mask_b);
1457	if ((mask_r != 0x7c00) \|\|	1185
1458	(mask_g != 0x03e0) \|\|	1186	size_r = mask_r >> sh_r;
1459	(mask_b != 0x001f))	1187	size_g = mask_g >> sh_g;
		1188	size_b = mask_b >> sh_b;
		1189
		1190	if (size_r++ > 255 \|\| size_g++ > 255 \|\| size_b++ > 255)
1460	return;	1191	return;
1461	lookup = (uint32_t ) malloc (sizeof (uint32_t)(32+32+32));	1192
		1193	lookup = (uint32_t )malloc (sizeof (uint32_t) (size_r + size_g + size_b));
1462	lookup_r = lookup;	1194	lookup_r = lookup;
1463	lookup_g = lookup+32;	1195	lookup_g = lookup + size_r;
1464	lookup_b = lookup+32+32;	1196	lookup_b = lookup + size_r + size_g;
1465	sh_r = 10;
1466	sh_g = 5;
1467	sh_b = 0;
1468	break;
1469	case 16:
1470	if ((mask_r != 0xf800) \|\|
1471	(mask_g != 0x07e0) \|\|
1472	(mask_b != 0x001f))
1473	return;
1474	lookup = (uint32_t ) malloc (sizeof (uint32_t)(32+64+32));
1475	lookup_r = lookup;
1476	lookup_g = lookup+32;
1477	lookup_b = lookup+32+64;
1478	sh_r = 11;
1479	sh_g = 5;
1480	sh_b = 0;
1481	break;
1482	case 24:
1483	if ((mask_r != 0xff0000) \|\|
1484	(mask_g != 0x00ff00) \|\|
1485	(mask_b != 0x0000ff))
1486	return;
1487	lookup = (uint32_t ) malloc (sizeof (uint32_t)(256+256+256));
1488	lookup_r = lookup;
1489	lookup_g = lookup+256;
1490	lookup_b = lookup+256+256;
1491	sh_r = 16;
1492	sh_g = 8;
1493	sh_b = 0;
1494	break;
1495	case 32:
1496	if ((mask_r != 0xff0000) \|\|
1497	(mask_g != 0x00ff00) \|\|
1498	(mask_b != 0x0000ff))
1499	return;
1500	lookup = (uint32_t ) malloc (sizeof (uint32_t)(256+256+256));
1501	lookup_r = lookup;
1502	lookup_g = lookup+256;
1503	lookup_b = lookup+256+256;
1504	sh_r = 16;
1505	sh_g = 8;
1506	sh_b = 0;
1507	break;
1508	default:
1509	return; /* we do not support this color depth */
1510	}
1511		1197
1512	rgba c;	1198	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1513		1199
		1200	if (bg_flags & BG_TINT_SET)
1514	tint.get (c);	1201	tint.get (c);
1515		1202
1516	/* prepare limits for color transformation (each channel is handled separately) */	1203	/* prepare limits for color transformation (each channel is handled separately) */
1517	if (shade > 100)	1204	if (shade > 100)
1518	{	1205	{
1519	c.r = c.r * (200 - shade) / 100;	1206	c.r = c.r * (200 - shade) / 100;
…		…
1536	fill_lut (lookup_g, mask_g, sh_g, low, c.g);	1223	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1537	fill_lut (lookup_b, mask_b, sh_b, low, c.b);	1224	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1538		1225
1539	/* apply table to input image (replacing colors by newly calculated ones) */	1226	/* apply table to input image (replacing colors by newly calculated ones) */
1540	if (ximage->bits_per_pixel == 32	1227	if (ximage->bits_per_pixel == 32
1541	&& (ximage->depth == 24 \|\| ximage->depth == 32)
1542	&& ximage->byte_order == host_byte_order)	1228	&& ximage->byte_order == host_byte_order)
1543	{	1229	{
1544	uint32_t p1, pf, p, pl;	1230	char *line = ximage->data;
1545	p1 = (uint32_t *) ximage->data;
1546	pf = (uint32_t ) (ximage->data + ximage->height ximage->bytes_per_line);
1547		1231
1548	while (p1 < pf)	1232	for (int y = 0; y < ximage->height; y++)
1549	{
1550	p = p1;
1551	pl = p1 + ximage->width;
1552	for (; p < pl; p++)
1553	{	1233	{
1554	p = lookup_r[(p & 0xff0000) >> 16] \|	1234	uint32_t p = (uint32_t )line;
1555	lookup_g[(*p & 0x00ff00) >> 8] \|	1235	for (int x = 0; x < ximage->width; x++)
1556	lookup_b[(*p & 0x0000ff)] \|
1557	(*p & 0xff000000);
1558	}	1236	{
1559	p1 = (uint32_t ) ((char ) p1 + ximage->bytes_per_line);	1237	p = lookup_r[(p & mask_r) >> sh_r] \|
		1238	lookup_g[(*p & mask_g) >> sh_g] \|
		1239	lookup_b[(*p & mask_b) >> sh_b];
		1240	p++;
		1241	}
		1242	line += ximage->bytes_per_line;
1560	}	1243	}
1561	}	1244	}
1562	else	1245	else
1563	{	1246	{
1564	for (int y = 0; y < ximage->height; y++)	1247	for (int y = 0; y < ximage->height; y++)
…		…
1572	}	1255	}
1573	}	1256	}
1574		1257
1575	free (lookup);	1258	free (lookup);
1576	}	1259	}
1577	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1260	#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.192 by sf-exg, Fri Dec 30 12:45:56 2011 UTC vs. Revision 1.211 by sf-exg, Sun May 13 15:28:44 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.192 by sf-exg, Fri Dec 30 12:45:56 2011 UTC vs.
Revision 1.211 by sf-exg, Sun May 13 15:28:44 2012 UTC