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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.193 by sf-exg, Sun Jan 1 14:31:29 2012 UTC vs.
Revision 1.201 by sf-exg, Sat Feb 4 21:47:06 2012 UTC

…		…
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;	128	int diff = window_size - image_size;
168	int smaller = min (image_size, window_size);	129	int smaller = min (image_size, window_size);
…		…
187	src_pos = -pos;	148	src_pos = -pos;
188	dst_pos = 0;	149	dst_pos = 0;
189	dst_size += pos;	150	dst_size += pos;
190	}	151	}
191		152
192	if (dst_pos + dst_size > target_size)
193	dst_size = target_size - dst_pos;	153	min_it (dst_size, target_size - dst_pos);
194	return src_pos;	154	return src_pos;
195	}	155	}
196		156
197	bool	157	bool
198	rxvt_term::bg_set_geometry (const char *geom, bool update)	158	rxvt_term::bg_set_geometry (const char *geom, bool update)
199	{	159	{
200	bool changed = false;	160	bool changed = false;
201	int geom_flags = 0;	161	int geom_flags = 0;
202	int x = 0, y = 0;	162	int x = h_align;
		163	int y = v_align;
203	unsigned int w = 0, h = 0;	164	unsigned int w = h_scale;
		165	unsigned int h = v_scale;
204	unsigned long new_flags = 0;	166	unsigned long new_flags = 0;
205		167
206	if (geom == NULL)	168	if (geom == NULL)
207	return false;	169	return false;
208		170
…		…
317	w = h = defaultScale;	279	w = h = defaultScale;
318	else if (!(geom_flags & HeightValue))	280	else if (!(geom_flags & HeightValue))
319	h = w;	281	h = w;
320	else if (!(geom_flags & WidthValue))	282	else if (!(geom_flags & WidthValue))
321	w = h;	283	w = h;
322
323	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
324	}	284	}
325		285
326	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;	286	min_it (w, 1000);
327	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;	287	min_it (h, 1000);
328	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;	288	clamp_it (x, -100, 200);
329	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;	289	clamp_it (y, -100, 200);
330		290
331	if (new_flags != bg_flags)	291	if (bg_flags != new_flags
		292	\|\| h_scale != w
		293	\|\| v_scale != h
		294	\|\| h_align != x
		295	\|\| v_align != y)
332	{	296	{
333	bg_flags = new_flags;	297	bg_flags = new_flags;
		298	h_scale = w;
		299	v_scale = h;
		300	h_align = x;
		301	v_align = y;
334	changed = true;	302	changed = true;
335	}	303	}
336		304
337	return changed;	305	return changed;
338	}	306	}
…		…
373	\|\| h_scale \|\| v_scale	341	\|\| h_scale \|\| v_scale
374	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	342	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
375	\|\| w > target_width \|\| h > target_height)	343	\|\| w > target_width \|\| h > target_height)
376	bg_flags \|= BG_IS_SIZE_SENSITIVE;	344	bg_flags \|= BG_IS_SIZE_SENSITIVE;
377	}	345	}
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
460	{
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	}
612	# endif /* HAVE_AFTERIMAGE */
613		346
614	# ifdef HAVE_PIXBUF	347	# ifdef HAVE_PIXBUF
615	bool	348	bool
616	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,	349	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
617	int src_x, int src_y, int dst_x, int dst_y,	350	int src_x, int src_y, int dst_x, int dst_y,
…		…
876	memcpy (f, file, len);	609	memcpy (f, file, len);
877	f[len] = '\0';	610	f[len] = '\0';
878	file = f;	611	file = f;
879	}	612	}
880		613
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	614	# ifdef HAVE_PIXBUF
896	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	615	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
897	if (image)	616	if (image)
898	{	617	{
899	if (pixbuf)	618	if (pixbuf)
…		…
972	rgba c;	691	rgba c;
973	bool has_shade = shade != 100;	692	bool has_shade = shade != 100;
974		693
975	bg_flags &= ~BG_TINT_FLAGS;	694	bg_flags &= ~BG_TINT_FLAGS;
976		695
		696	if (bg_flags & BG_TINT_SET)
		697	{
977	tint.get (c);	698	tint.get (c);
978
979	if (!has_shade	699	if (!has_shade
980	&& (c.r <= 0x00ff \|\| c.r >= 0xff00)	700	&& (c.r <= 0x00ff \|\| c.r >= 0xff00)
981	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)	701	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)
982	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))	702	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))
983	bg_flags \|= BG_TINT_BITAND;	703	bg_flags \|= BG_TINT_BITAND;
		704	}
984		705
985	if (has_shade	706	if (has_shade \|\| (bg_flags & BG_TINT_SET))
986	\|\| c.r < 0xff00
987	\|\| c.g < 0xff00
988	\|\| c.b < 0xff00)
989	bg_flags \|= BG_NEEDS_TINT;	707	bg_flags \|= BG_NEEDS_TINT;
990	}	708	}
991		709
992	bool	710	bool
993	rxvt_term::bg_set_tint (rxvt_color &new_tint)	711	rxvt_term::bg_set_tint (rxvt_color &new_tint)
994	{	712	{
995	if (tint != new_tint)	713	if (!(bg_flags & BG_TINT_SET) \|\| tint != new_tint)
996	{	714	{
997	tint = new_tint;	715	tint = new_tint;
		716	bg_flags \|= BG_TINT_SET;
998	set_tint_shade_flags ();	717	set_tint_shade_flags ();
999	return true;	718	return true;
1000	}	719	}
1001		720
1002	return false;	721	return false;
…		…
1043	params[i+2] = XDoubleToFixed (kernel[i] / sum);	762	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1044	}	763	}
1045	#endif	764	#endif
1046		765
1047	bool	766	bool
1048	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	767	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1049	{	768	{
1050	bool ret = false;	769	bool ret = false;
1051	#if XRENDER	770	#if XRENDER
1052	if (!(bg_flags & BG_HAS_RENDER_CONV))	771	if (!(bg_flags & BG_HAS_RENDER_CONV))
1053	return false;	772	return false;
1054		773
1055	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	774	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1056	double kernel = (double )malloc (size * sizeof (double));	775	double kernel = (double )malloc (size * sizeof (double));
1057	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	776	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1058		777
		778	XRenderPictureAttributes pa;
1059	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	779	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1060		780
		781	pa.repeat = RepeatPad;
1061	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, 0);	782	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		783	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1062	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, 0);	784	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		785	XFreePixmap (dpy, tmp);
1063		786
1064	if (kernel && params)	787	if (kernel && params)
1065	{	788	{
1066	size = h_blurRadius * 2 + 1;	789	size = h_blurRadius * 2 + 1;
1067	get_gaussian_kernel (h_blurRadius, size, kernel, params);	790	get_gaussian_kernel (h_blurRadius, size, kernel, params);
…		…
1075	0, 0,	798	0, 0,
1076	0, 0,	799	0, 0,
1077	0, 0,	800	0, 0,
1078	width, height);	801	width, height);
1079		802
		803	::swap (src, dst);
		804
1080	size = v_blurRadius * 2 + 1;	805	size = v_blurRadius * 2 + 1;
1081	get_gaussian_kernel (v_blurRadius, size, kernel, params);	806	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1082	::swap (params[0], params[1]);	807	::swap (params[0], params[1]);
1083		808
1084	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	809	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
…		…
1128	}	853	}
1129	}	854	}
1130	# if XRENDER	855	# if XRENDER
1131	else if (bg_flags & BG_HAS_RENDER)	856	else if (bg_flags & BG_HAS_RENDER)
1132	{	857	{
1133	rgba c;	858	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1134		859
		860	if (bg_flags & BG_TINT_SET)
1135	tint.get (c);	861	tint.get (c);
1136		862
1137	if (shade <= 100)	863	if (shade <= 100)
1138	{	864	{
1139	c.r = c.r * shade / 100;	865	c.r = c.r * shade / 100;
1140	c.g = c.g * shade / 100;	866	c.g = c.g * shade / 100;
…		…
1296		1022
1297	if (!(bg_flags & BG_CLIENT_RENDER))	1023	if (!(bg_flags & BG_CLIENT_RENDER))
1298	{	1024	{
1299	if (bg_flags & BG_NEEDS_BLUR)	1025	if (bg_flags & BG_NEEDS_BLUR)
1300	{	1026	{
1301	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))	1027	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1302	result &= ~BG_NEEDS_BLUR;	1028	result &= ~BG_NEEDS_BLUR;
1303	}	1029	}
1304	if (bg_flags & BG_NEEDS_TINT)	1030	if (bg_flags & BG_NEEDS_TINT)
1305	{	1031	{
1306	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))	1032	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1307	result &= ~BG_NEEDS_TINT;	1033	result &= ~BG_NEEDS_TINT;
1308	}	1034	}
1309	# ifndef HAVE_AFTERIMAGE
1310	if (result & BG_NEEDS_TINT)	1035	if (result & BG_NEEDS_TINT)
1311	{	1036	{
1312	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);	1037	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1313	if (ximage)	1038	if (ximage)
1314	{	1039	{
…		…
1317		1042
1318	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);	1043	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
1319	XDestroyImage (ximage);	1044	XDestroyImage (ximage);
1320	}	1045	}
1321	}	1046	}
1322	# endif
1323	} /* server side rendering completed */	1047	} /* server side rendering completed */
1324		1048
1325	XFreeGC (dpy, gc);	1049	XFreeGC (dpy, gc);
1326	}	1050	}
1327		1051
…		…
1351	# ifdef ENABLE_TRANSPARENCY	1075	# ifdef ENABLE_TRANSPARENCY
1352	if (bg_flags & BG_IS_TRANSPARENT)	1076	if (bg_flags & BG_IS_TRANSPARENT)
1353	{	1077	{
1354	/* we need to re-generate transparency pixmap in that case ! */	1078	/* we need to re-generate transparency pixmap in that case ! */
1355	tr_flags = make_transparency_pixmap ();	1079	tr_flags = make_transparency_pixmap ();
1356	if (tr_flags == 0)	1080	if (tr_flags)
1357	return false;
1358	bg_flags \|= BG_IS_VALID;	1081	bg_flags \|= BG_IS_VALID;
1359	}	1082	}
1360	# endif	1083	# endif
1361		1084
1362	# ifdef BG_IMAGE_FROM_FILE	1085	# ifdef BG_IMAGE_FROM_FILE
1363	if ((bg_flags & BG_IS_FROM_FILE)	1086	if ((bg_flags & BG_IS_FROM_FILE)
…		…
1387		1110
1388	void	1111	void
1389	rxvt_term::bg_init ()	1112	rxvt_term::bg_init ()
1390	{	1113	{
1391	#ifdef ENABLE_TRANSPARENCY	1114	#ifdef ENABLE_TRANSPARENCY
1392	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1393	tint.set (this, c);
1394	shade = 100;	1115	shade = 100;
1395	#endif	1116	#endif
1396		1117
1397	bg_flags &= ~(BG_HAS_RENDER \| BG_HAS_RENDER_CONV);	1118	bg_flags &= ~(BG_HAS_RENDER \| BG_HAS_RENDER_CONV);
1398	#if XRENDER	1119	#if XRENDER
…		…
1411	#endif	1132	#endif
1412	}	1133	}
1413		1134
1414	#endif /* HAVE_BG_PIXMAP */	1135	#endif /* HAVE_BG_PIXMAP */
1415		1136
1416	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1137	#ifdef ENABLE_TRANSPARENCY
1417	/* based on code from aterm-0.4.2 */	1138	/* based on code from aterm-0.4.2 */
1418		1139
1419	static inline void	1140	static inline void
1420	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)	1141	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1421	{	1142	{
…		…
1501	break;	1222	break;
1502	default:	1223	default:
1503	return; /* we do not support this color depth */	1224	return; /* we do not support this color depth */
1504	}	1225	}
1505		1226
1506	rgba c;	1227	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1507		1228
		1229	if (bg_flags & BG_TINT_SET)
1508	tint.get (c);	1230	tint.get (c);
1509		1231
1510	/* prepare limits for color transformation (each channel is handled separately) */	1232	/* prepare limits for color transformation (each channel is handled separately) */
1511	if (shade > 100)	1233	if (shade > 100)
1512	{	1234	{
1513	c.r = c.r * (200 - shade) / 100;	1235	c.r = c.r * (200 - shade) / 100;
…		…
1566	}	1288	}
1567	}	1289	}
1568		1290
1569	free (lookup);	1291	free (lookup);
1570	}	1292	}
1571	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1293	#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.193 by sf-exg, Sun Jan 1 14:31:29 2012 UTC vs. Revision 1.201 by sf-exg, Sat Feb 4 21:47:06 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.193 by sf-exg, Sun Jan 1 14:31:29 2012 UTC vs.
Revision 1.201 by sf-exg, Sat Feb 4 21:47:06 2012 UTC