[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.202 by sf-exg, Sat Feb 25 22:20:47 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>
…		…
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;	128	int diff = window_size - image_size;
150	int smaller = min (image_size, window_size);	129	int smaller = min (image_size, window_size);
…		…
169	src_pos = -pos;	148	src_pos = -pos;
170	dst_pos = 0;	149	dst_pos = 0;
171	dst_size += pos;	150	dst_size += pos;
172	}	151	}
173		152
174	if (dst_pos + dst_size > target_size)
175	dst_size = target_size - dst_pos;	153	min_it (dst_size, target_size - dst_pos);
176	return src_pos;	154	return src_pos;
177	}	155	}
178		156
179	bool	157	bool
180	rxvt_term::bg_set_geometry (const char *geom, bool update)	158	rxvt_term::bg_set_geometry (const char *geom, bool update)
181	{	159	{
182	bool changed = false;	160	bool changed = false;
183	int geom_flags = 0;	161	int geom_flags = 0;
184	int x = 0, y = 0;	162	int x = h_align;
		163	int y = v_align;
185	unsigned int w = 0, h = 0;	164	unsigned int w = h_scale;
		165	unsigned int h = v_scale;
186	unsigned long new_flags = 0;	166	unsigned long new_flags = 0;
187		167
188	if (geom == NULL)	168	if (geom == NULL)
189	return false;	169	return false;
190		170
…		…
299	w = h = defaultScale;	279	w = h = defaultScale;
300	else if (!(geom_flags & HeightValue))	280	else if (!(geom_flags & HeightValue))
301	h = w;	281	h = w;
302	else if (!(geom_flags & WidthValue))	282	else if (!(geom_flags & WidthValue))
303	w = h;	283	w = h;
304
305	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
306	}	284	}
307		285
308	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;	286	min_it (w, 1000);
309	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;	287	min_it (h, 1000);
310	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;	288	clamp_it (x, -100, 200);
311	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;	289	clamp_it (y, -100, 200);
312		290
313	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)
314	{	296	{
315	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;
316	changed = true;	302	changed = true;
317	}	303	}
318		304
319	return changed;	305	return changed;
320	}	306	}
…		…
355	\|\| h_scale \|\| v_scale	341	\|\| h_scale \|\| v_scale
356	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	342	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
357	\|\| w > target_width \|\| h > target_height)	343	\|\| w > target_width \|\| h > target_height)
358	bg_flags \|= BG_IS_SIZE_SENSITIVE;	344	bg_flags \|= BG_IS_SIZE_SENSITIVE;
359	}	345	}
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
442	{
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	}
594	# endif /* HAVE_AFTERIMAGE */
595		346
596	# ifdef HAVE_PIXBUF	347	# ifdef HAVE_PIXBUF
597	bool	348	bool
598	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,	349	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
599	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,
…		…
676	XDestroyImage (ximage);	427	XDestroyImage (ximage);
677	return true;	428	return true;
678	}	429	}
679		430
680	bool	431	bool
681	rxvt_term::render_image (unsigned long tr_flags)	432	rxvt_term::render_image (bool transparent)
682	{	433	{
683	if (!pixbuf)	434	if (!pixbuf)
684	return false;	435	return false;
685		436
686	if (tr_flags	437	if (transparent
687	&& !(bg_flags & BG_HAS_RENDER))	438	&& !(bg_flags & BG_HAS_RENDER))
688	return false;	439	return false;
689		440
690	GdkPixbuf *result;	441	GdkPixbuf *result;
691		442
…		…
731	Pixmap root_pmap;	482	Pixmap root_pmap;
732		483
733	image_width = gdk_pixbuf_get_width (result);	484	image_width = gdk_pixbuf_get_width (result);
734	image_height = gdk_pixbuf_get_height (result);	485	image_height = gdk_pixbuf_get_height (result);
735		486
736	if (tr_flags)	487	if (transparent)
737	{	488	{
738	root_pmap = bg_pixmap;	489	root_pmap = bg_pixmap;
739	bg_pixmap = None;	490	bg_pixmap = None;
740	}	491	}
741	else	492	else
…		…
799	dst_x, dst_y,	550	dst_x, dst_y,
800	dst_width, dst_height);	551	dst_width, dst_height);
801	}	552	}
802		553
803	#if XRENDER	554	#if XRENDER
804	if (tr_flags)	555	if (transparent)
805	{	556	{
806	XRenderPictureAttributes pa;
807
808	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	557	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		558
809	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	559	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
810		560
811	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
812	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	561	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
813		562
814	pa.repeat = True;	563	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		564
820	XRenderColor mask_c;	565	XRenderColor mask_c;
821		566
822	mask_c.alpha = 0x8000;	567	mask_c.alpha = 0x8000;
823	mask_c.red = 0;	568	mask_c.red =
824	mask_c.green = 0;	569	mask_c.green =
825	mask_c.blue = 0;	570	mask_c.blue = 0;
826	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	571	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		572
827	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	573	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
828		574
829	XRenderFreePicture (dpy, src);	575	XRenderFreePicture (dpy, src);
830	XRenderFreePicture (dpy, dst);	576	XRenderFreePicture (dpy, dst);
831	XRenderFreePicture (dpy, mask);	577	XRenderFreePicture (dpy, mask);
…		…
838	}	584	}
839		585
840	if (result != pixbuf)	586	if (result != pixbuf)
841	g_object_unref (result);	587	g_object_unref (result);
842		588
843	if (tr_flags)	589	if (transparent)
844	XFreePixmap (dpy, root_pmap);	590	XFreePixmap (dpy, root_pmap);
845		591
846	return ret;	592	return ret;
847	}	593	}
848	# endif /* HAVE_PIXBUF */	594	# endif /* HAVE_PIXBUF */
…		…
863	memcpy (f, file, len);	609	memcpy (f, file, len);
864	f[len] = '\0';	610	f[len] = '\0';
865	file = f;	611	file = f;
866	}	612	}
867		613
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	614	# ifdef HAVE_PIXBUF
883	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	615	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
884	if (image)	616	if (image)
885	{	617	{
886	if (pixbuf)	618	if (pixbuf)
…		…
943	{	675	{
944	changed = true;	676	changed = true;
945	v_blurRadius = vr;	677	v_blurRadius = vr;
946	}	678	}
947		679
948	if (v_blurRadius == 0 && h_blurRadius == 0)	680	if (h_blurRadius == 0 \|\| v_blurRadius == 0)
949	bg_flags &= ~BG_NEEDS_BLUR;	681	bg_flags &= ~BG_NEEDS_BLUR;
950	else	682	else
951	bg_flags \|= BG_NEEDS_BLUR;	683	bg_flags \|= BG_NEEDS_BLUR;
952		684
953	return changed;	685	return changed;
…		…
959	rgba c;	691	rgba c;
960	bool has_shade = shade != 100;	692	bool has_shade = shade != 100;
961		693
962	bg_flags &= ~BG_TINT_FLAGS;	694	bg_flags &= ~BG_TINT_FLAGS;
963		695
		696	if (bg_flags & BG_TINT_SET)
		697	{
964	tint.get (c);	698	tint.get (c);
965
966	if (!has_shade	699	if (!has_shade
967	&& (c.r <= 0x00ff \|\| c.r >= 0xff00)	700	&& (c.r <= 0x00ff \|\| c.r >= 0xff00)
968	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)	701	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)
969	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))	702	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))
970	bg_flags \|= BG_TINT_BITAND;	703	bg_flags \|= BG_TINT_BITAND;
		704	}
971		705
972	if (has_shade	706	if (has_shade \|\| (bg_flags & BG_TINT_SET))
973	\|\| c.r < 0xff00
974	\|\| c.g < 0xff00
975	\|\| c.b < 0xff00)
976	bg_flags \|= BG_NEEDS_TINT;	707	bg_flags \|= BG_NEEDS_TINT;
977	}	708	}
978		709
979	bool	710	bool
980	rxvt_term::bg_set_tint (rxvt_color &new_tint)	711	rxvt_term::bg_set_tint (rxvt_color &new_tint)
981	{	712	{
982	if (tint != new_tint)	713	if (!(bg_flags & BG_TINT_SET) \|\| tint != new_tint)
983	{	714	{
984	tint = new_tint;	715	tint = new_tint;
		716	bg_flags \|= BG_TINT_SET;
985	set_tint_shade_flags ();	717	set_tint_shade_flags ();
986	return true;	718	return true;
987	}	719	}
988		720
989	return false;	721	return false;
…		…
1030	params[i+2] = XDoubleToFixed (kernel[i] / sum);	762	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1031	}	763	}
1032	#endif	764	#endif
1033		765
1034	bool	766	bool
1035	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)
1036	{	768	{
1037	bool ret = false;	769	bool ret = false;
1038	#if XRENDER	770	#if XRENDER
1039	if (!(bg_flags & BG_HAS_RENDER_CONV))	771	if (!(bg_flags & BG_HAS_RENDER_CONV))
1040	return false;	772	return false;
…		…
1044	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	776	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1045		777
1046	XRenderPictureAttributes pa;	778	XRenderPictureAttributes pa;
1047	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	779	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1048		780
		781	pa.repeat = RepeatPad;
1049	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	782	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		783	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1050	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	784	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		785	XFreePixmap (dpy, tmp);
1051		786
1052	if (kernel && params)	787	if (kernel && params)
1053	{	788	{
1054	if (h_blurRadius)
1055	{
1056	size = h_blurRadius * 2 + 1;	789	size = h_blurRadius * 2 + 1;
1057	get_gaussian_kernel (h_blurRadius, size, kernel, params);	790	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1058		791
1059	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	792	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1060	XRenderComposite (dpy,	793	XRenderComposite (dpy,
1061	PictOpSrc,	794	PictOpSrc,
1062	src,	795	src,
1063	None,	796	None,
1064	dst,	797	dst,
1065	0, 0,	798	0, 0,
1066	0, 0,	799	0, 0,
1067	0, 0,	800	0, 0,
1068	width, height);	801	width, height);
1069	}
1070		802
1071	if (v_blurRadius)	803	::swap (src, dst);
1072	{	804
1073	size = v_blurRadius * 2 + 1;	805	size = v_blurRadius * 2 + 1;
1074	get_gaussian_kernel (v_blurRadius, size, kernel, params);	806	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1075	::swap (params[0], params[1]);	807	::swap (params[0], params[1]);
1076		808
1077	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	809	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1078	XRenderComposite (dpy,	810	XRenderComposite (dpy,
1079	PictOpSrc,	811	PictOpSrc,
1080	src,	812	src,
1081	None,	813	None,
1082	dst,	814	dst,
1083	0, 0,	815	0, 0,
1084	0, 0,	816	0, 0,
1085	0, 0,	817	0, 0,
1086	width, height);	818	width, height);
1087	}
1088		819
1089	ret = true;	820	ret = true;
1090	}	821	}
1091		822
1092	free (kernel);	823	free (kernel);
…		…
1122	}	853	}
1123	}	854	}
1124	# if XRENDER	855	# if XRENDER
1125	else if (bg_flags & BG_HAS_RENDER)	856	else if (bg_flags & BG_HAS_RENDER)
1126	{	857	{
1127	rgba c;	858	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1128		859
		860	if (bg_flags & BG_TINT_SET)
1129	tint.get (c);	861	tint.get (c);
1130		862
1131	if (shade <= 100)	863	if (shade <= 100)
1132	{	864	{
1133	c.r = c.r * shade / 100;	865	c.r = c.r * shade / 100;
1134	c.g = c.g * shade / 100;	866	c.g = c.g * shade / 100;
…		…
1139	c.r = c.r * (200 - shade) / 100;	871	c.r = c.r * (200 - shade) / 100;
1140	c.g = c.g * (200 - shade) / 100;	872	c.g = c.g * (200 - shade) / 100;
1141	c.b = c.b * (200 - shade) / 100;	873	c.b = c.b * (200 - shade) / 100;
1142	}	874	}
1143		875
1144	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1145	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	876	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1146	XRenderPictureAttributes pa;
1147		877
1148	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	878	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1149		879
1150	pa.repeat = True;	880	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1151		881
1152	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	882	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		883
1161	XRenderColor mask_c;	884	XRenderColor mask_c;
1162		885
1163	mask_c.alpha = 0xffff;	886	mask_c.alpha = 0xffff;
1164	mask_c.red =	887	mask_c.red =
…		…
1169	mask_c.alpha = 0;	892	mask_c.alpha = 0;
1170	mask_c.red = 0xffff - c.r;	893	mask_c.red = 0xffff - c.r;
1171	mask_c.green = 0xffff - c.g;	894	mask_c.green = 0xffff - c.g;
1172	mask_c.blue = 0xffff - c.b;	895	mask_c.blue = 0xffff - c.b;
1173	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	896	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		897
1174	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);	898	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1175		899
1176	if (shade > 100)	900	if (shade > 100)
1177	{	901	{
1178	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1179	mask_c.alpha = 0;	902	mask_c.alpha = 0;
		903	mask_c.red =
		904	mask_c.green =
		905	mask_c.blue = 0xffff * (shade - 100) / 100;
1180	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	906	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1181		907
1182	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);	908	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1183	}	909	}
1184		910
…		…
1196	/*	922	/*
1197	* Builds a pixmap of the same size as the terminal window that contains	923	* 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	924	* the tiled portion of the root pixmap that is supposed to be covered by
1199	* our window.	925	* our window.
1200	*/	926	*/
1201	unsigned long	927	bool
1202	rxvt_term::make_transparency_pixmap ()	928	rxvt_term::make_transparency_pixmap ()
1203	{	929	{
1204	unsigned long result = 0;	930	bool ret = false;
1205		931
1206	/* root dimensions may change from call to call - but Display structure should	932	/* root dimensions may change from call to call - but Display structure should
1207	* be always up-to-date, so let's use it :	933	* be always up-to-date, so let's use it :
1208	*/	934	*/
1209	int screen = display->screen;	935	int screen = display->screen;
…		…
1247	#if XRENDER	973	#if XRENDER
1248	if (bg_flags & BG_HAS_RENDER)	974	if (bg_flags & BG_HAS_RENDER)
1249	{	975	{
1250	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);	976	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1251		977
1252	XRenderPictureAttributes pa;
1253
1254	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	978	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1255	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	979	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1256		980
1257	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	981	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1258	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	982	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1259		983
1260	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	984	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1261		985
1262	XRenderFreePicture (dpy, src);	986	XRenderFreePicture (dpy, src);
1263	XRenderFreePicture (dpy, dst);	987	XRenderFreePicture (dpy, dst);
…		…
1292	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);	1016	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);
1293		1017
1294	if (gc)	1018	if (gc)
1295	{	1019	{
1296	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1020	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1297	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1021	ret = true;
		1022	unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
		1023
		1024	if (!(bg_flags & BG_CLIENT_RENDER))
		1025	{
		1026	if (bg_flags & BG_NEEDS_BLUR)
		1027	{
		1028	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
		1029	tr_flags &= ~BG_NEEDS_BLUR;
		1030	}
		1031	if (bg_flags & BG_NEEDS_TINT)
		1032	{
		1033	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
		1034	tr_flags &= ~BG_NEEDS_TINT;
		1035	}
		1036	if (tr_flags & BG_NEEDS_TINT)
		1037	{
		1038	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1039	if (ximage)
		1040	{
		1041	/* our own client-side tinting */
		1042	tint_ximage (DefaultVisual (dpy, display->screen), ximage);
		1043
		1044	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1045	XDestroyImage (ximage);
		1046	}
		1047	}
		1048	} /* server side rendering completed */
		1049
1298	XFreeGC (dpy, gc);	1050	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	}	1051	}
1314		1052
1315	if (recoded_root_pmap != root_pixmap)	1053	if (recoded_root_pmap != root_pixmap)
1316	XFreePixmap (dpy, recoded_root_pmap);	1054	XFreePixmap (dpy, recoded_root_pmap);
1317		1055
1318	return result;	1056	return ret;
1319	}	1057	}
1320		1058
1321	void	1059	void
1322	rxvt_term::bg_set_root_pixmap ()	1060	rxvt_term::bg_set_root_pixmap ()
1323	{	1061	{
…		…
1330	# endif /* ENABLE_TRANSPARENCY */	1068	# endif /* ENABLE_TRANSPARENCY */
1331		1069
1332	bool	1070	bool
1333	rxvt_term::bg_render ()	1071	rxvt_term::bg_render ()
1334	{	1072	{
1335	unsigned long tr_flags = 0;	1073	bool transparent = false;
1336		1074
1337	bg_invalidate ();	1075	bg_invalidate ();
1338	# ifdef ENABLE_TRANSPARENCY	1076	# ifdef ENABLE_TRANSPARENCY
1339	if (bg_flags & BG_IS_TRANSPARENT)	1077	if (bg_flags & BG_IS_TRANSPARENT)
1340	{	1078	{
1341	/* we need to re-generate transparency pixmap in that case ! */	1079	/* we need to re-generate transparency pixmap in that case ! */
1342	tr_flags = make_transparency_pixmap ();	1080	transparent = make_transparency_pixmap ();
1343	if (tr_flags == 0)	1081	if (transparent)
1344	return false;
1345	bg_flags \|= BG_IS_VALID;	1082	bg_flags \|= BG_IS_VALID;
1346	}	1083	}
1347	# endif	1084	# endif
1348		1085
1349	# ifdef BG_IMAGE_FROM_FILE	1086	# ifdef BG_IMAGE_FROM_FILE
1350	if ((bg_flags & BG_IS_FROM_FILE)	1087	if (bg_flags & BG_IS_FROM_FILE)
1351	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1352	{	1088	{
1353	if (render_image (tr_flags))	1089	if (render_image (transparent))
1354	bg_flags \|= BG_IS_VALID;	1090	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	}	1091	}
1384	# endif	1092	# endif
1385		1093
1386	if (!(bg_flags & BG_IS_VALID))	1094	if (!(bg_flags & BG_IS_VALID))
1387	{	1095	{
…		…
1402		1110
1403	void	1111	void
1404	rxvt_term::bg_init ()	1112	rxvt_term::bg_init ()
1405	{	1113	{
1406	#ifdef ENABLE_TRANSPARENCY	1114	#ifdef ENABLE_TRANSPARENCY
1407	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1408	tint.set (this, c);
1409	shade = 100;	1115	shade = 100;
1410	#endif	1116	#endif
1411		1117
1412	bg_flags &= ~(BG_HAS_RENDER \| BG_HAS_RENDER_CONV);	1118	bg_flags &= ~(BG_HAS_RENDER \| BG_HAS_RENDER_CONV);
1413	#if XRENDER	1119	#if XRENDER
…		…
1426	#endif	1132	#endif
1427	}	1133	}
1428		1134
1429	#endif /* HAVE_BG_PIXMAP */	1135	#endif /* HAVE_BG_PIXMAP */
1430		1136
1431	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1137	#ifdef ENABLE_TRANSPARENCY
1432	/* based on code from aterm-0.4.2 */	1138	/* based on code from aterm-0.4.2 */
1433		1139
1434	static inline void	1140	static inline void
1435	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)
1436	{	1142	{
…		…
1516	break;	1222	break;
1517	default:	1223	default:
1518	return; /* we do not support this color depth */	1224	return; /* we do not support this color depth */
1519	}	1225	}
1520		1226
1521	rgba c;	1227	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1522		1228
		1229	if (bg_flags & BG_TINT_SET)
1523	tint.get (c);	1230	tint.get (c);
1524		1231
1525	/* prepare limits for color transformation (each channel is handled separately) */	1232	/* prepare limits for color transformation (each channel is handled separately) */
1526	if (shade > 100)	1233	if (shade > 100)
1527	{	1234	{
1528	c.r = c.r * (200 - shade) / 100;	1235	c.r = c.r * (200 - shade) / 100;
…		…
1581	}	1288	}
1582	}	1289	}
1583		1290
1584	free (lookup);	1291	free (lookup);
1585	}	1292	}
1586	#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.187 by sf-exg, Wed Dec 28 13:13:33 2011 UTC vs. Revision 1.202 by sf-exg, Sat Feb 25 22:20:47 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.202 by sf-exg, Sat Feb 25 22:20:47 2012 UTC