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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.187 by sf-exg, Wed Dec 28 13:13:33 2011 UTC vs.
Revision 1.213 by sf-exg, Sun May 13 21:12:01 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	63	#ifdef HAVE_PIXBUF
51	if (pixbuf)	64	if (pixbuf)
52	g_object_unref (pixbuf);	65	g_object_unref (pixbuf);
53	#endif	66	#endif
54		67
…		…
107		120
108	return false;	121	return false;
109	}	122	}
110		123
111	# ifdef BG_IMAGE_FROM_FILE	124	# 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	125	static inline int
147	make_align_position (int align, int window_size, int image_size)	126	make_align_position (int align, int window_size, int image_size)
148	{	127	{
149	int diff = window_size - image_size;
150	int smaller = min (image_size, window_size);
151
152	if (align >= 0 && align <= 100)	128	if (align >= 0 && align <= 100)
153	return diff * align / 100;	129	return lerp (0, window_size - image_size, align);
154	else if (align > 100 && align <= 200)	130	else if (align > 100)
155	return (align - 100) * smaller / 100 + window_size - smaller;	131	return lerp (window_size - image_size, window_size, align - 100);
156	else if (align >= -100 && align < 0)	132	else
157	return (align + 100) * smaller / 100 - image_size;	133	return lerp (-image_size, 0, align + 100);
158	return 0;
159	}	134	}
160		135
161	static inline int	136	static inline int
162	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)
163	{	138	{
…		…
169	src_pos = -pos;	144	src_pos = -pos;
170	dst_pos = 0;	145	dst_pos = 0;
171	dst_size += pos;	146	dst_size += pos;
172	}	147	}
173		148
174	if (dst_pos + dst_size > target_size)
175	dst_size = target_size - dst_pos;	149	min_it (dst_size, target_size - dst_pos);
176	return src_pos;	150	return src_pos;
177	}	151	}
178		152
179	bool	153	bool
180	rxvt_term::bg_set_geometry (const char *geom, bool update)	154	rxvt_term::bg_set_geometry (const char *geom, bool update)
181	{	155	{
182	bool changed = false;	156	bool changed = false;
183	int geom_flags = 0;	157	int geom_flags = 0;
184	int x = 0, y = 0;	158	int x = h_align;
		159	int y = v_align;
185	unsigned int w = 0, h = 0;	160	unsigned int w = h_scale;
		161	unsigned int h = v_scale;
186	unsigned long new_flags = 0;	162	unsigned long new_flags = 0;
187		163
188	if (geom == NULL)	164	if (geom == NULL)
189	return false;	165	return false;
190		166
…		…
299	w = h = defaultScale;	275	w = h = defaultScale;
300	else if (!(geom_flags & HeightValue))	276	else if (!(geom_flags & HeightValue))
301	h = w;	277	h = w;
302	else if (!(geom_flags & WidthValue))	278	else if (!(geom_flags & WidthValue))
303	w = h;	279	w = h;
304
305	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
306	}	280	}
307		281
308	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;	282	min_it (w, 1000);
309	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;	283	min_it (h, 1000);
310	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;	284	clamp_it (x, -100, 200);
311	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;	285	clamp_it (y, -100, 200);
312		286
313	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)
314	{	292	{
315	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;
316	changed = true;	298	changed = true;
317	}	299	}
318		300
319	return changed;	301	return changed;
320	}	302	}
…		…
348	{	330	{
349	x = make_align_position (h_align, target_width, w);	331	x = make_align_position (h_align, target_width, w);
350	y = make_align_position (v_align, target_height, h);	332	y = make_align_position (v_align, target_height, h);
351	}	333	}
352		334
353	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
354	if (!(bg_flags & BG_TILE)	335	if (!(bg_flags & BG_TILE)
355	\|\| h_scale \|\| v_scale	336	\|\| h_scale \|\| v_scale
356	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	337	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
357	\|\| w > target_width \|\| h > target_height)	338	\|\| image_width > target_width \|\| image_height > target_height)
358	bg_flags \|= BG_IS_SIZE_SENSITIVE;	339	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	{
376	ShadingInfo as_shade;
377	as_shade.shading = shade;
378
379	rgba c;
380	tint.get (c);
381	as_shade.tintColor.red = c.r;
382	as_shade.tintColor.green = c.g;
383	as_shade.tintColor.blue = c.b;
384
385	background_tint = shading2tint32 (&as_shade);
386	}
387
388	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
389	{
390	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
391	ASA_XImage,
392	100, ASIMAGE_QUALITY_DEFAULT);
393	if (tmp)
394	{
395	destroy_asimage (&background);
396	background = tmp;
397	}
398	}
399	# endif
400
401	ASImage *result = 0;
402
403	int target_width = szHint.width;
404	int target_height = szHint.height;
405	int new_pmap_width = target_width;
406	int new_pmap_height = target_height;
407
408	int x = 0;
409	int y = 0;
410	int w = 0;
411	int h = 0;
412
413	if (original_asim)
414	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
415
416	if (!original_asim
417	\|\| (!(bg_flags & BG_ROOT_ALIGN)
418	&& (x >= target_width
419	\|\| y >= target_height
420	\|\| x + w <= 0
421	\|\| y + h <= 0)))
422	{
423	if (background)
424	{
425	new_pmap_width = background->width;
426	new_pmap_height = background->height;
427	result = background;
428
429	if (background_tint != TINT_LEAVE_SAME)
430	{
431	ASImage *tmp = tile_asimage (asv, background, 0, 0,
432	target_width, target_height, background_tint,
433	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
434	if (tmp)
435	result = tmp;
436	}
437	}
438	else
439	new_pmap_width = new_pmap_height = 0;
440	}
441	else	340	else
442	{	341	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
443	result = original_asim;
444
445	if (w != original_asim->width
446	\|\| h != original_asim->height)
447	{
448	result = scale_asimage (asv, original_asim,
449	w, h,
450	ASA_XImage,
451	100, ASIMAGE_QUALITY_DEFAULT);
452	}
453
454	if (background == NULL)
455	{
456	if (bg_flags & BG_TILE)
457	{
458	/* if tiling - pixmap has to be sized exactly as the image,
459	but there is no need to make it bigger than the window! */
460	new_pmap_width = min (result->width, target_width);
461	new_pmap_height = min (result->height, target_height);
462
463	/* we also need to tile our image in both directions */
464	ASImage *tmp = tile_asimage (asv, result,
465	(int)result->width - x,
466	(int)result->height - y,
467	new_pmap_width,
468	new_pmap_height,
469	TINT_LEAVE_SAME, ASA_XImage,
470	100, ASIMAGE_QUALITY_DEFAULT);
471	if (tmp)
472	{
473	if (result != original_asim)
474	destroy_asimage (&result);
475
476	result = tmp;
477	}
478	}
479	}
480	else
481	{
482	/* if blending background and image - pixmap has to be sized same as target window */
483	ASImageLayer *layers = create_image_layers (2);
484
485	layers[0].im = background;
486	layers[0].clip_width = target_width;
487	layers[0].clip_height = target_height;
488	layers[0].tint = background_tint;
489	layers[1].im = result;
490
491	if (bg_flags & BG_TILE)
492	{
493	/* tile horizontally */
494	while (x > 0) x -= (int)result->width;
495	layers[1].dst_x = x;
496	layers[1].clip_width = result->width+target_width;
497	}
498	else
499	{
500	/* clip horizontally */
501	layers[1].dst_x = x;
502	layers[1].clip_width = result->width;
503	}
504
505	if (bg_flags & BG_TILE)
506	{
507	while (y > 0) y -= (int)result->height;
508	layers[1].dst_y = y;
509	layers[1].clip_height = result->height + target_height;
510	}
511	else
512	{
513	layers[1].dst_y = y;
514	layers[1].clip_height = result->height;
515	}
516
517	if (rs[Rs_blendtype])
518	{
519	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
520	if (layers[1].merge_scanlines == NULL)
521	layers[1].merge_scanlines = alphablend_scanlines;
522	}
523
524	ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
525	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
526
527	if (tmp)
528	{
529	if (result != original_asim)
530	destroy_asimage (&result);
531
532	result = tmp;
533	}
534
535	free (layers);
536	}
537	}
538
539	bool ret = false;
540
541	if (result)
542	{
543	XGCValues gcv;
544	GC gc;
545
546	/* create Pixmap */
547	if (bg_pixmap == None
548	\|\| bg_pmap_width != new_pmap_width
549	\|\| bg_pmap_height != new_pmap_height)
550	{
551	if (bg_pixmap)
552	XFreePixmap (dpy, bg_pixmap);
553	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
554	bg_pmap_width = new_pmap_width;
555	bg_pmap_height = new_pmap_height;
556	}
557	/* fill with background color (if result's not completely overlapping it) */
558	gcv.foreground = pix_colors[Color_bg];
559	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
560
561	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
562	int dst_width = result->width, dst_height = result->height;
563	if (background == NULL)
564	{
565	if (!(bg_flags & BG_TILE))
566	{
567	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
568	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
569	}
570
571	if (dst_x > 0 \|\| dst_y > 0
572	\|\| dst_x + dst_width < new_pmap_width
573	\|\| dst_y + dst_height < new_pmap_height)
574	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
575	}
576
577	/* put result on pixmap */
578	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
579	asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
580
581	if (result != background && result != original_asim)
582	destroy_asimage (&result);
583
584	XFreeGC (dpy, gc);
585
586	ret = true;
587	}
588
589	if (background)
590	destroy_asimage (&background);
591
592	return ret;
593	}	342	}
594	# endif /* HAVE_AFTERIMAGE */
595		343
596	# ifdef HAVE_PIXBUF	344	# ifdef HAVE_PIXBUF
597	bool	345	bool
598	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,	346	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
599	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,
600	unsigned int width, unsigned int height)	348	unsigned int width, unsigned int height)
601	{	349	{
602	XImage *ximage;	350	XImage *ximage;
603	char data, line;	351	char *line;
604	int bytes_per_pixel;
605	int width_r, width_g, width_b;	352	int width_r, width_g, width_b, width_a;
606	int sh_r, sh_g, sh_b;	353	int sh_r, sh_g, sh_b, sh_a;
		354	uint32_t alpha_mask;
607	int rowstride;	355	int rowstride;
608	int channels;	356	int channels;
609	unsigned char *row;	357	unsigned char *row;
610		358
611	if (visual->c_class != TrueColor)	359	if (visual->c_class != TrueColor)
612	return false;	360	return false;
613		361
614	if (depth == 24 \|\| depth == 32)	362	#if XRENDER
615	bytes_per_pixel = 4;	363	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
616	else if (depth == 15 \|\| depth == 16)	364	if (format)
617	bytes_per_pixel = 2;	365	alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
618	else	366	else
619	return false;	367	#endif
		368	alpha_mask = 0;
620		369
621	width_r = ecb_popcount32 (visual->red_mask);	370	width_r = ecb_popcount32 (visual->red_mask);
622	width_g = ecb_popcount32 (visual->green_mask);	371	width_g = ecb_popcount32 (visual->green_mask);
623	width_b = ecb_popcount32 (visual->blue_mask);	372	width_b = ecb_popcount32 (visual->blue_mask);
		373	width_a = ecb_popcount32 (alpha_mask);
624		374
625	if (width_r > 8 \|\| width_g > 8 \|\| width_b > 8)	375	if (width_r > 8 \|\| width_g > 8 \|\| width_b > 8 \|\| width_a > 8)
626	return false;	376	return false;
627		377
628	sh_r = ecb_ctz32 (visual->red_mask);	378	sh_r = ecb_ctz32 (visual->red_mask);
629	sh_g = ecb_ctz32 (visual->green_mask);	379	sh_g = ecb_ctz32 (visual->green_mask);
630	sh_b = ecb_ctz32 (visual->blue_mask);	380	sh_b = ecb_ctz32 (visual->blue_mask);
		381	sh_a = ecb_ctz32 (alpha_mask);
631		382
632	if (width > INT_MAX / height / bytes_per_pixel)	383	if (width > 32767 \|\| height > 32767)
633	return false;	384	return false;
634		385
635	data = (char )malloc (width height * bytes_per_pixel);	386	ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, 0,
636	if (!data)	387	width, height, 32, 0);
		388	if (!ximage)
637	return false;	389	return false;
638		390
639	ximage = XCreateImage (dpy, visual, depth, ZPixmap, 0, data,	391	if (height > INT_MAX / ximage->bytes_per_line
640	width, height, bytes_per_pixel * 8, 0);	392	\|\| !(ximage->data = (char )malloc (height ximage->bytes_per_line)))
641	if (!ximage)
642	{	393	{
643	free (data);	394	XDestroyImage (ximage);
644	return false;	395	return false;
645	}	396	}
646		397
647	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	398	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
648		399
649	rowstride = gdk_pixbuf_get_rowstride (pixbuf);	400	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
650	channels = gdk_pixbuf_get_n_channels (pixbuf);	401	channels = gdk_pixbuf_get_n_channels (pixbuf);
651	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;
652	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	}
653		414
654	for (int y = 0; y < height; y++)	415	for (int y = 0; y < height; y++)
655	{	416	{
656	for (int x = 0; x < width; x++)	417	for (int x = 0; x < width; x++)
657	{	418	{
658	unsigned char pixel = row + x channels;	419	unsigned char pixel = row + x channels;
659	uint32_t value;	420	uint32_t value;
		421	unsigned char r, g, b, a;
660		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
661	value = ((pixel[0] >> (8 - width_r)) << sh_r)	438	value = ((r >> (8 - width_r)) << sh_r)
662	\| ((pixel[1] >> (8 - width_g)) << sh_g)	439	\| ((g >> (8 - width_g)) << sh_g)
663	\| ((pixel[2] >> (8 - width_b)) << sh_b);	440	\| ((b >> (8 - width_b)) << sh_b)
		441	\| ((a >> (8 - width_a)) << sh_a);
664		442
665	if (bytes_per_pixel == 4)	443	if (ximage->bits_per_pixel == 32)
666	((uint32_t *)line)[x] = value;	444	((uint32_t *)line)[x] = value;
667	else	445	else
668	((uint16_t *)line)[x] = value;	446	XPutPixel (ximage, x, y, value);
669	}	447	}
670		448
671	row += rowstride;	449	row += rowstride;
672	line += ximage->bytes_per_line;	450	line += ximage->bytes_per_line;
673	}	451	}
…		…
676	XDestroyImage (ximage);	454	XDestroyImage (ximage);
677	return true;	455	return true;
678	}	456	}
679		457
680	bool	458	bool
681	rxvt_term::render_image (unsigned long tr_flags)	459	rxvt_term::render_image (bool transparent)
682	{	460	{
683	if (!pixbuf)	461	if (!pixbuf)
684	return false;	462	return false;
685		463
686	if (tr_flags	464	if (transparent
687	&& !(bg_flags & BG_HAS_RENDER))	465	&& !(bg_flags & BG_HAS_RENDER))
688	return false;	466	return false;
689		467
690	GdkPixbuf *result;	468	GdkPixbuf *result;
691		469
…		…
731	Pixmap root_pmap;	509	Pixmap root_pmap;
732		510
733	image_width = gdk_pixbuf_get_width (result);	511	image_width = gdk_pixbuf_get_width (result);
734	image_height = gdk_pixbuf_get_height (result);	512	image_height = gdk_pixbuf_get_height (result);
735		513
736	if (tr_flags)	514	if (transparent)
737	{	515	{
738	root_pmap = bg_pixmap;	516	root_pmap = bg_pixmap;
739	bg_pixmap = None;	517	bg_pixmap = None;
740	}	518	}
741	else	519	else
…		…
799	dst_x, dst_y,	577	dst_x, dst_y,
800	dst_width, dst_height);	578	dst_width, dst_height);
801	}	579	}
802		580
803	#if XRENDER	581	#if XRENDER
804	if (tr_flags)	582	if (transparent)
805	{	583	{
806	XRenderPictureAttributes pa;
807
808	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	584	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		585
809	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	586	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
810		587
811	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
812	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	588	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
813		589
814	pa.repeat = True;	590	Picture mask = create_xrender_mask (dpy, vt, False, False);
815	Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
816	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
817	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
818	XFreePixmap (dpy, mask_pmap);
819		591
820	XRenderColor mask_c;	592	XRenderColor mask_c;
821		593
822	mask_c.alpha = 0x8000;	594	mask_c.alpha = 0x8000;
823	mask_c.red = 0;	595	mask_c.red =
824	mask_c.green = 0;	596	mask_c.green =
825	mask_c.blue = 0;	597	mask_c.blue = 0;
826	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	598	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		599
827	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	600	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
828		601
829	XRenderFreePicture (dpy, src);	602	XRenderFreePicture (dpy, src);
830	XRenderFreePicture (dpy, dst);	603	XRenderFreePicture (dpy, dst);
831	XRenderFreePicture (dpy, mask);	604	XRenderFreePicture (dpy, mask);
…		…
838	}	611	}
839		612
840	if (result != pixbuf)	613	if (result != pixbuf)
841	g_object_unref (result);	614	g_object_unref (result);
842		615
843	if (tr_flags)	616	if (transparent)
844	XFreePixmap (dpy, root_pmap);	617	XFreePixmap (dpy, root_pmap);
845		618
846	return ret;	619	return ret;
847	}	620	}
848	# endif /* HAVE_PIXBUF */	621	# endif /* HAVE_PIXBUF */
…		…
863	memcpy (f, file, len);	636	memcpy (f, file, len);
864	f[len] = '\0';	637	f[len] = '\0';
865	file = f;	638	file = f;
866	}	639	}
867		640
868	# ifdef HAVE_AFTERIMAGE
869	if (!asimman)
870	asimman = create_generic_imageman (rs[Rs_path]);
871	ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
872	if (image)
873	{
874	if (original_asim)
875	safe_asimage_destroy (original_asim);
876	original_asim = image;
877	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;
878	ret = true;
879	}
880	# endif
881
882	# ifdef HAVE_PIXBUF	641	# ifdef HAVE_PIXBUF
883	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	642	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
884	if (image)	643	if (image)
885	{	644	{
886	if (pixbuf)	645	if (pixbuf)
…		…
904		663
905	# endif /* BG_IMAGE_FROM_FILE */	664	# endif /* BG_IMAGE_FROM_FILE */
906		665
907	# ifdef ENABLE_TRANSPARENCY	666	# ifdef ENABLE_TRANSPARENCY
908	bool	667	bool
909	rxvt_term::bg_set_transparent ()
910	{
911	if (!(bg_flags & BG_IS_TRANSPARENT))
912	{
913	bg_flags \|= BG_IS_TRANSPARENT;
914	return true;
915	}
916
917	return false;
918	}
919
920	bool
921	rxvt_term::bg_set_blur (const char *geom)	668	rxvt_term::bg_set_blur (const char *geom)
922	{	669	{
923	bool changed = false;	670	bool changed = false;
924	unsigned int hr, vr;	671	unsigned int hr, vr;
925	int junk;	672	int junk;
…		…
943	{	690	{
944	changed = true;	691	changed = true;
945	v_blurRadius = vr;	692	v_blurRadius = vr;
946	}	693	}
947		694
948	if (v_blurRadius == 0 && h_blurRadius == 0)
949	bg_flags &= ~BG_NEEDS_BLUR;
950	else
951	bg_flags \|= BG_NEEDS_BLUR;
952
953	return changed;	695	return changed;
954	}	696	}
955		697
956	void
957	rxvt_term::set_tint_shade_flags ()
958	{
959	rgba c;
960	bool has_shade = shade != 100;
961
962	bg_flags &= ~BG_TINT_FLAGS;
963
964	tint.get (c);
965
966	if (!has_shade
967	&& (c.r <= 0x00ff \|\| c.r >= 0xff00)
968	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)
969	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))
970	bg_flags \|= BG_TINT_BITAND;
971
972	if (has_shade
973	\|\| c.r < 0xff00
974	\|\| c.g < 0xff00
975	\|\| c.b < 0xff00)
976	bg_flags \|= BG_NEEDS_TINT;
977	}
978
979	bool	698	bool
980	rxvt_term::bg_set_tint (rxvt_color &new_tint)	699	rxvt_term::bg_set_tint (rxvt_color &new_tint)
981	{	700	{
982	if (tint != new_tint)	701	if (!(bg_flags & BG_TINT_SET) \|\| tint != new_tint)
983	{	702	{
984	tint = new_tint;	703	tint = new_tint;
985	set_tint_shade_flags ();	704	bg_flags \|= BG_TINT_SET;
		705
		706	rgba c;
		707	tint.get (c);
		708	if ((c.r <= 0x00ff \|\| c.r >= 0xff00)
		709	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)
		710	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))
		711	bg_flags \|= BG_TINT_BITAND;
		712	else
		713	bg_flags &= ~BG_TINT_BITAND;
		714
986	return true;	715	return true;
987	}	716	}
988		717
989	return false;	718	return false;
990	}	719	}
…		…
999	new_shade = 200 - (100 + new_shade);	728	new_shade = 200 - (100 + new_shade);
1000		729
1001	if (new_shade != shade)	730	if (new_shade != shade)
1002	{	731	{
1003	shade = new_shade;	732	shade = new_shade;
1004	set_tint_shade_flags ();
1005	return true;	733	return true;
1006	}	734	}
1007		735
1008	return false;	736	return false;
1009	}	737	}
…		…
1030	params[i+2] = XDoubleToFixed (kernel[i] / sum);	758	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1031	}	759	}
1032	#endif	760	#endif
1033		761
1034	bool	762	bool
1035	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	763	rxvt_term::blur_pixmap (Pixmap pixmap, int width, int height)
1036	{	764	{
1037	bool ret = false;	765	bool ret = false;
1038	#if XRENDER	766	#if XRENDER
1039	if (!(bg_flags & BG_HAS_RENDER_CONV))	767	if (!(bg_flags & BG_HAS_RENDER_CONV))
1040	return false;	768	return false;
…		…
1044	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	772	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1045		773
1046	XRenderPictureAttributes pa;	774	XRenderPictureAttributes pa;
1047	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	775	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1048		776
		777	pa.repeat = RepeatPad;
1049	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	778	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		779	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1050	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	780	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		781	XFreePixmap (dpy, tmp);
1051		782
1052	if (kernel && params)	783	if (kernel && params)
1053	{	784	{
1054	if (h_blurRadius)
1055	{
1056	size = h_blurRadius * 2 + 1;	785	size = h_blurRadius * 2 + 1;
1057	get_gaussian_kernel (h_blurRadius, size, kernel, params);	786	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1058		787
1059	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	788	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1060	XRenderComposite (dpy,	789	XRenderComposite (dpy,
1061	PictOpSrc,	790	PictOpSrc,
1062	src,	791	src,
1063	None,	792	None,
1064	dst,	793	dst,
1065	0, 0,	794	0, 0,
1066	0, 0,	795	0, 0,
1067	0, 0,	796	0, 0,
1068	width, height);	797	width, height);
1069	}
1070		798
1071	if (v_blurRadius)	799	::swap (src, dst);
1072	{	800
1073	size = v_blurRadius * 2 + 1;	801	size = v_blurRadius * 2 + 1;
1074	get_gaussian_kernel (v_blurRadius, size, kernel, params);	802	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1075	::swap (params[0], params[1]);	803	::swap (params[0], params[1]);
1076		804
1077	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	805	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1078	XRenderComposite (dpy,	806	XRenderComposite (dpy,
1079	PictOpSrc,	807	PictOpSrc,
1080	src,	808	src,
1081	None,	809	None,
1082	dst,	810	dst,
1083	0, 0,	811	0, 0,
1084	0, 0,	812	0, 0,
1085	0, 0,	813	0, 0,
1086	width, height);	814	width, height);
1087	}
1088		815
1089	ret = true;	816	ret = true;
1090	}	817	}
1091		818
1092	free (kernel);	819	free (kernel);
…		…
1096	#endif	823	#endif
1097	return ret;	824	return ret;
1098	}	825	}
1099		826
1100	bool	827	bool
1101	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	828	rxvt_term::tint_pixmap (Pixmap pixmap, int width, int height)
1102	{	829	{
1103	bool ret = false;	830	bool ret = false;
1104		831
1105	if (bg_flags & BG_TINT_BITAND)	832	if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1106	{	833	{
1107	XGCValues gcv;	834	XGCValues gcv;
1108	GC gc;	835	GC gc;
1109		836
1110	/* In this case we can tint image server-side getting significant	837	/* In this case we can tint image server-side getting significant
…		…
1122	}	849	}
1123	}	850	}
1124	# if XRENDER	851	# if XRENDER
1125	else if (bg_flags & BG_HAS_RENDER)	852	else if (bg_flags & BG_HAS_RENDER)
1126	{	853	{
1127	rgba c;	854	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1128		855
		856	if (bg_flags & BG_TINT_SET)
1129	tint.get (c);	857	tint.get (c);
1130		858
1131	if (shade <= 100)	859	if (shade <= 100)
1132	{	860	{
1133	c.r = c.r * shade / 100;	861	c.r = c.r * shade / 100;
1134	c.g = c.g * shade / 100;	862	c.g = c.g * shade / 100;
…		…
1139	c.r = c.r * (200 - shade) / 100;	867	c.r = c.r * (200 - shade) / 100;
1140	c.g = c.g * (200 - shade) / 100;	868	c.g = c.g * (200 - shade) / 100;
1141	c.b = c.b * (200 - shade) / 100;	869	c.b = c.b * (200 - shade) / 100;
1142	}	870	}
1143		871
1144	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1145	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	872	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1146	XRenderPictureAttributes pa;
1147		873
1148	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	874	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1149		875
1150	pa.repeat = True;	876	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1151		877
1152	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	878	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1153	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1154	XFreePixmap (dpy, overlay_pmap);
1155
1156	pa.component_alpha = True;
1157	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1158	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat \| CPComponentAlpha, &pa);
1159	XFreePixmap (dpy, mask_pmap);
1160		879
1161	XRenderColor mask_c;	880	XRenderColor mask_c;
1162		881
1163	mask_c.alpha = 0xffff;	882	mask_c.alpha = 0xffff;
1164	mask_c.red =	883	mask_c.red =
…		…
1169	mask_c.alpha = 0;	888	mask_c.alpha = 0;
1170	mask_c.red = 0xffff - c.r;	889	mask_c.red = 0xffff - c.r;
1171	mask_c.green = 0xffff - c.g;	890	mask_c.green = 0xffff - c.g;
1172	mask_c.blue = 0xffff - c.b;	891	mask_c.blue = 0xffff - c.b;
1173	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	892	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		893
1174	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);	894	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1175		895
1176	if (shade > 100)	896	if (shade > 100)
1177	{	897	{
1178	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1179	mask_c.alpha = 0;	898	mask_c.alpha = 0;
		899	mask_c.red =
		900	mask_c.green =
		901	mask_c.blue = 0xffff * (shade - 100) / 100;
1180	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	902	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1181		903
1182	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);	904	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1183	}	905	}
1184		906
…		…
1196	/*	918	/*
1197	* Builds a pixmap of the same size as the terminal window that contains	919	* Builds a pixmap of the same size as the terminal window that contains
1198	* the tiled portion of the root pixmap that is supposed to be covered by	920	* the tiled portion of the root pixmap that is supposed to be covered by
1199	* our window.	921	* our window.
1200	*/	922	*/
1201	unsigned long	923	bool
1202	rxvt_term::make_transparency_pixmap ()	924	rxvt_term::make_transparency_pixmap ()
1203	{	925	{
1204	unsigned long result = 0;	926	bool ret = false;
1205		927
1206	/* root dimensions may change from call to call - but Display structure should	928	/* root dimensions may change from call to call - but Display structure should
1207	* be always up-to-date, so let's use it :	929	* be always up-to-date, so let's use it :
1208	*/	930	*/
1209	int screen = display->screen;	931	int screen = display->screen;
…		…
1247	#if XRENDER	969	#if XRENDER
1248	if (bg_flags & BG_HAS_RENDER)	970	if (bg_flags & BG_HAS_RENDER)
1249	{	971	{
1250	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);	972	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1251		973
1252	XRenderPictureAttributes pa;
1253
1254	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	974	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1255	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	975	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1256		976
1257	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	977	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1258	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	978	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1259		979
1260	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	980	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1261		981
1262	XRenderFreePicture (dpy, src);	982	XRenderFreePicture (dpy, src);
1263	XRenderFreePicture (dpy, dst);	983	XRenderFreePicture (dpy, dst);
…		…
1292	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);	1012	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);
1293		1013
1294	if (gc)	1014	if (gc)
1295	{	1015	{
1296	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1016	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1297	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1017	ret = true;
		1018	bool need_blur = h_blurRadius && v_blurRadius;
		1019	bool need_tint = shade != 100 \|\| (bg_flags & BG_TINT_SET);
		1020
		1021	if (!(bg_flags & BG_CLIENT_RENDER))
		1022	{
		1023	if (need_blur)
		1024	{
		1025	if (blur_pixmap (bg_pixmap, window_width, window_height))
		1026	need_blur = false;
		1027	}
		1028	if (need_tint)
		1029	{
		1030	if (tint_pixmap (bg_pixmap, window_width, window_height))
		1031	need_tint = false;
		1032	}
		1033	if (need_tint)
		1034	{
		1035	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1036	if (ximage)
		1037	{
		1038	/* our own client-side tinting */
		1039	tint_ximage (ximage);
		1040
		1041	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1042	XDestroyImage (ximage);
		1043	}
		1044	}
		1045	} /* server side rendering completed */
		1046
1298	XFreeGC (dpy, gc);	1047	XFreeGC (dpy, gc);
1299
1300	if (!(bg_flags & BG_CLIENT_RENDER))
1301	{
1302	if (bg_flags & BG_NEEDS_BLUR)
1303	{
1304	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
1305	result &= ~BG_NEEDS_BLUR;
1306	}
1307	if (bg_flags & BG_NEEDS_TINT)
1308	{
1309	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1310	result &= ~BG_NEEDS_TINT;
1311	}
1312	} /* server side rendering completed */
1313	}	1048	}
1314		1049
1315	if (recoded_root_pmap != root_pixmap)	1050	if (recoded_root_pmap != root_pixmap)
1316	XFreePixmap (dpy, recoded_root_pmap);	1051	XFreePixmap (dpy, recoded_root_pmap);
1317		1052
1318	return result;	1053	return ret;
1319	}	1054	}
1320		1055
1321	void	1056	void
1322	rxvt_term::bg_set_root_pixmap ()	1057	rxvt_term::bg_set_root_pixmap ()
1323	{	1058	{
…		…
1330	# endif /* ENABLE_TRANSPARENCY */	1065	# endif /* ENABLE_TRANSPARENCY */
1331		1066
1332	bool	1067	bool
1333	rxvt_term::bg_render ()	1068	rxvt_term::bg_render ()
1334	{	1069	{
1335	unsigned long tr_flags = 0;	1070	bool transparent = false;
1336		1071
1337	bg_invalidate ();	1072	bg_invalidate ();
1338	# ifdef ENABLE_TRANSPARENCY	1073	# ifdef ENABLE_TRANSPARENCY
1339	if (bg_flags & BG_IS_TRANSPARENT)	1074	if (bg_flags & BG_IS_TRANSPARENT)
1340	{	1075	{
1341	/* we need to re-generate transparency pixmap in that case ! */	1076	/* we need to re-generate transparency pixmap in that case ! */
1342	tr_flags = make_transparency_pixmap ();	1077	transparent = make_transparency_pixmap ();
1343	if (tr_flags == 0)	1078	if (transparent)
1344	return false;
1345	bg_flags \|= BG_IS_VALID;	1079	bg_flags \|= BG_IS_VALID;
1346	}	1080	}
1347	# endif	1081	# endif
1348		1082
1349	# ifdef BG_IMAGE_FROM_FILE	1083	# ifdef BG_IMAGE_FROM_FILE
1350	if ((bg_flags & BG_IS_FROM_FILE)	1084	if (bg_flags & BG_IS_FROM_FILE)
1351	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1352	{	1085	{
1353	if (render_image (tr_flags))	1086	if (render_image (transparent))
1354	bg_flags \|= BG_IS_VALID;	1087	bg_flags \|= BG_IS_VALID;
1355	}
1356	# endif
1357
1358	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1359	XImage *result = NULL;
1360
1361	if (tr_flags & BG_NEEDS_TINT)
1362	{
1363	result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1364	}
1365
1366	if (result)
1367	{
1368	/* our own client-side tinting */
1369	//if (tr_flags & BG_NEEDS_TINT)
1370	if (1)
1371	tint_ximage (DefaultVisual (dpy, display->screen), result);
1372
1373	GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1374
1375	if (gc)
1376	{
1377	XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1378
1379	XFreeGC (dpy, gc);
1380	}
1381
1382	XDestroyImage (result);
1383	}	1088	}
1384	# endif	1089	# endif
1385		1090
1386	if (!(bg_flags & BG_IS_VALID))	1091	if (!(bg_flags & BG_IS_VALID))
1387	{	1092	{
…		…
1402		1107
1403	void	1108	void
1404	rxvt_term::bg_init ()	1109	rxvt_term::bg_init ()
1405	{	1110	{
1406	#ifdef ENABLE_TRANSPARENCY	1111	#ifdef ENABLE_TRANSPARENCY
1407	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1408	tint.set (this, c);
1409	shade = 100;	1112	shade = 100;
1410	#endif	1113	#endif
1411		1114
1412	bg_flags &= ~(BG_HAS_RENDER \| BG_HAS_RENDER_CONV);	1115	bg_flags &= ~(BG_HAS_RENDER \| BG_HAS_RENDER_CONV);
1413	#if XRENDER	1116	#if XRENDER
…		…
1426	#endif	1129	#endif
1427	}	1130	}
1428		1131
1429	#endif /* HAVE_BG_PIXMAP */	1132	#endif /* HAVE_BG_PIXMAP */
1430		1133
1431	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1134	#ifdef ENABLE_TRANSPARENCY
1432	/* based on code from aterm-0.4.2 */	1135	/* based on code from aterm-0.4.2 */
1433		1136
1434	static inline void	1137	static inline void
1435	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)	1138	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1436	{	1139	{
…		…
1442	lookup[i] = (tmp / 0xffff) << sh;	1145	lookup[i] = (tmp / 0xffff) << sh;
1443	}	1146	}
1444	}	1147	}
1445		1148
1446	void	1149	void
1447	rxvt_term::tint_ximage (Visual visual, XImage ximage)	1150	rxvt_term::tint_ximage (XImage *ximage)
1448	{	1151	{
		1152	unsigned int size_r, size_g, size_b;
1449	int sh_r, sh_g, sh_b;	1153	int sh_r, sh_g, sh_b;
1450	uint32_t mask_r, mask_g, mask_b;	1154	uint32_t mask_r, mask_g, mask_b;
1451	uint32_t lookup, lookup_r, lookup_g, lookup_b;	1155	uint32_t lookup, lookup_r, lookup_g, lookup_b;
1452	unsigned short low;	1156	unsigned short low;
1453	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	1157	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
…		…
1458	mask_r = visual->red_mask;	1162	mask_r = visual->red_mask;
1459	mask_g = visual->green_mask;	1163	mask_g = visual->green_mask;
1460	mask_b = visual->blue_mask;	1164	mask_b = visual->blue_mask;
1461		1165
1462	/* boring lookup table pre-initialization */	1166	/* boring lookup table pre-initialization */
1463	switch (ximage->depth)	1167	sh_r = ecb_ctz32 (mask_r);
1464	{	1168	sh_g = ecb_ctz32 (mask_g);
1465	case 15:	1169	sh_b = ecb_ctz32 (mask_b);
1466	if ((mask_r != 0x7c00) \|\|	1170
1467	(mask_g != 0x03e0) \|\|	1171	size_r = mask_r >> sh_r;
1468	(mask_b != 0x001f))	1172	size_g = mask_g >> sh_g;
		1173	size_b = mask_b >> sh_b;
		1174
		1175	if (size_r++ > 255 \|\| size_g++ > 255 \|\| size_b++ > 255)
1469	return;	1176	return;
1470	lookup = (uint32_t ) malloc (sizeof (uint32_t)(32+32+32));	1177
		1178	lookup = (uint32_t )malloc (sizeof (uint32_t) (size_r + size_g + size_b));
1471	lookup_r = lookup;	1179	lookup_r = lookup;
1472	lookup_g = lookup+32;	1180	lookup_g = lookup + size_r;
1473	lookup_b = lookup+32+32;	1181	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		1182
1521	rgba c;	1183	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1522		1184
		1185	if (bg_flags & BG_TINT_SET)
1523	tint.get (c);	1186	tint.get (c);
1524		1187
1525	/* prepare limits for color transformation (each channel is handled separately) */	1188	/* prepare limits for color transformation (each channel is handled separately) */
1526	if (shade > 100)	1189	if (shade > 100)
1527	{	1190	{
1528	c.r = c.r * (200 - shade) / 100;	1191	c.r = c.r * (200 - shade) / 100;
…		…
1545	fill_lut (lookup_g, mask_g, sh_g, low, c.g);	1208	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1546	fill_lut (lookup_b, mask_b, sh_b, low, c.b);	1209	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1547		1210
1548	/* apply table to input image (replacing colors by newly calculated ones) */	1211	/* apply table to input image (replacing colors by newly calculated ones) */
1549	if (ximage->bits_per_pixel == 32	1212	if (ximage->bits_per_pixel == 32
1550	&& (ximage->depth == 24 \|\| ximage->depth == 32)
1551	&& ximage->byte_order == host_byte_order)	1213	&& ximage->byte_order == host_byte_order)
1552	{	1214	{
1553	uint32_t p1, pf, p, pl;	1215	char *line = ximage->data;
1554	p1 = (uint32_t *) ximage->data;
1555	pf = (uint32_t ) (ximage->data + ximage->height ximage->bytes_per_line);
1556		1216
1557	while (p1 < pf)	1217	for (int y = 0; y < ximage->height; y++)
1558	{
1559	p = p1;
1560	pl = p1 + ximage->width;
1561	for (; p < pl; p++)
1562	{	1218	{
1563	p = lookup_r[(p & 0xff0000) >> 16] \|	1219	uint32_t p = (uint32_t )line;
1564	lookup_g[(*p & 0x00ff00) >> 8] \|	1220	for (int x = 0; x < ximage->width; x++)
1565	lookup_b[(*p & 0x0000ff)] \|
1566	(*p & 0xff000000);
1567	}	1221	{
1568	p1 = (uint32_t ) ((char ) p1 + ximage->bytes_per_line);	1222	p = lookup_r[(p & mask_r) >> sh_r] \|
		1223	lookup_g[(*p & mask_g) >> sh_g] \|
		1224	lookup_b[(*p & mask_b) >> sh_b];
		1225	p++;
		1226	}
		1227	line += ximage->bytes_per_line;
1569	}	1228	}
1570	}	1229	}
1571	else	1230	else
1572	{	1231	{
1573	for (int y = 0; y < ximage->height; y++)	1232	for (int y = 0; y < ximage->height; y++)
…		…
1581	}	1240	}
1582	}	1241	}
1583		1242
1584	free (lookup);	1243	free (lookup);
1585	}	1244	}
1586	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1245	#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.187 by sf-exg, Wed Dec 28 13:13:33 2011 UTC vs. Revision 1.213 by sf-exg, Sun May 13 21:12:01 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.187 by sf-exg, Wed Dec 28 13:13:33 2011 UTC vs.
Revision 1.213 by sf-exg, Sun May 13 21:12:01 2012 UTC