[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.203 by sf-exg, Tue Apr 10 15:08: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;
954	}	686	}
955		687
956	void	688	void
957	rxvt_term::set_tint_shade_flags ()	689	rxvt_term::set_tint_shade_flags ()
958	{	690	{
959	rgba c;	691	if (shade != 100 \|\| (bg_flags & BG_TINT_SET))
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;	692	bg_flags \|= BG_NEEDS_TINT;
		693	else
		694	bg_flags &= ~BG_NEEDS_TINT;
977	}	695	}
978		696
979	bool	697	bool
980	rxvt_term::bg_set_tint (rxvt_color &new_tint)	698	rxvt_term::bg_set_tint (rxvt_color &new_tint)
981	{	699	{
982	if (tint != new_tint)	700	if (!(bg_flags & BG_TINT_SET) \|\| tint != new_tint)
983	{	701	{
984	tint = new_tint;	702	tint = new_tint;
		703	bg_flags \|= BG_TINT_SET;
		704
		705	rgba c;
		706	tint.get (c);
		707	if ((c.r <= 0x00ff \|\| c.r >= 0xff00)
		708	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)
		709	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))
		710	bg_flags \|= BG_TINT_BITAND;
		711	else
		712	bg_flags &= ~BG_TINT_BITAND;
		713
985	set_tint_shade_flags ();	714	set_tint_shade_flags ();
986	return true;	715	return true;
987	}	716	}
988		717
989	return false;	718	return false;
…		…
1030	params[i+2] = XDoubleToFixed (kernel[i] / sum);	759	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1031	}	760	}
1032	#endif	761	#endif
1033		762
1034	bool	763	bool
1035	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	764	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1036	{	765	{
1037	bool ret = false;	766	bool ret = false;
1038	#if XRENDER	767	#if XRENDER
1039	if (!(bg_flags & BG_HAS_RENDER_CONV))	768	if (!(bg_flags & BG_HAS_RENDER_CONV))
1040	return false;	769	return false;
…		…
1044	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	773	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1045		774
1046	XRenderPictureAttributes pa;	775	XRenderPictureAttributes pa;
1047	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	776	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1048		777
		778	pa.repeat = RepeatPad;
1049	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	779	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		780	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1050	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	781	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		782	XFreePixmap (dpy, tmp);
1051		783
1052	if (kernel && params)	784	if (kernel && params)
1053	{	785	{
1054	if (h_blurRadius)
1055	{
1056	size = h_blurRadius * 2 + 1;	786	size = h_blurRadius * 2 + 1;
1057	get_gaussian_kernel (h_blurRadius, size, kernel, params);	787	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1058		788
1059	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	789	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1060	XRenderComposite (dpy,	790	XRenderComposite (dpy,
1061	PictOpSrc,	791	PictOpSrc,
1062	src,	792	src,
1063	None,	793	None,
1064	dst,	794	dst,
1065	0, 0,	795	0, 0,
1066	0, 0,	796	0, 0,
1067	0, 0,	797	0, 0,
1068	width, height);	798	width, height);
1069	}
1070		799
1071	if (v_blurRadius)	800	::swap (src, dst);
1072	{	801
1073	size = v_blurRadius * 2 + 1;	802	size = v_blurRadius * 2 + 1;
1074	get_gaussian_kernel (v_blurRadius, size, kernel, params);	803	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1075	::swap (params[0], params[1]);	804	::swap (params[0], params[1]);
1076		805
1077	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	806	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1078	XRenderComposite (dpy,	807	XRenderComposite (dpy,
1079	PictOpSrc,	808	PictOpSrc,
1080	src,	809	src,
1081	None,	810	None,
1082	dst,	811	dst,
1083	0, 0,	812	0, 0,
1084	0, 0,	813	0, 0,
1085	0, 0,	814	0, 0,
1086	width, height);	815	width, height);
1087	}
1088		816
1089	ret = true;	817	ret = true;
1090	}	818	}
1091		819
1092	free (kernel);	820	free (kernel);
…		…
1100	bool	828	bool
1101	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	829	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1102	{	830	{
1103	bool ret = false;	831	bool ret = false;
1104		832
1105	if (bg_flags & BG_TINT_BITAND)	833	if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1106	{	834	{
1107	XGCValues gcv;	835	XGCValues gcv;
1108	GC gc;	836	GC gc;
1109		837
1110	/* In this case we can tint image server-side getting significant	838	/* In this case we can tint image server-side getting significant
…		…
1122	}	850	}
1123	}	851	}
1124	# if XRENDER	852	# if XRENDER
1125	else if (bg_flags & BG_HAS_RENDER)	853	else if (bg_flags & BG_HAS_RENDER)
1126	{	854	{
1127	rgba c;	855	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1128		856
		857	if (bg_flags & BG_TINT_SET)
1129	tint.get (c);	858	tint.get (c);
1130		859
1131	if (shade <= 100)	860	if (shade <= 100)
1132	{	861	{
1133	c.r = c.r * shade / 100;	862	c.r = c.r * shade / 100;
1134	c.g = c.g * shade / 100;	863	c.g = c.g * shade / 100;
…		…
1139	c.r = c.r * (200 - shade) / 100;	868	c.r = c.r * (200 - shade) / 100;
1140	c.g = c.g * (200 - shade) / 100;	869	c.g = c.g * (200 - shade) / 100;
1141	c.b = c.b * (200 - shade) / 100;	870	c.b = c.b * (200 - shade) / 100;
1142	}	871	}
1143		872
1144	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1145	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	873	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1146	XRenderPictureAttributes pa;
1147		874
1148	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	875	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1149		876
1150	pa.repeat = True;	877	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1151		878
1152	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	879	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		880
1161	XRenderColor mask_c;	881	XRenderColor mask_c;
1162		882
1163	mask_c.alpha = 0xffff;	883	mask_c.alpha = 0xffff;
1164	mask_c.red =	884	mask_c.red =
…		…
1169	mask_c.alpha = 0;	889	mask_c.alpha = 0;
1170	mask_c.red = 0xffff - c.r;	890	mask_c.red = 0xffff - c.r;
1171	mask_c.green = 0xffff - c.g;	891	mask_c.green = 0xffff - c.g;
1172	mask_c.blue = 0xffff - c.b;	892	mask_c.blue = 0xffff - c.b;
1173	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	893	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		894
1174	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);	895	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1175		896
1176	if (shade > 100)	897	if (shade > 100)
1177	{	898	{
1178	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1179	mask_c.alpha = 0;	899	mask_c.alpha = 0;
		900	mask_c.red =
		901	mask_c.green =
		902	mask_c.blue = 0xffff * (shade - 100) / 100;
1180	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	903	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1181		904
1182	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);	905	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1183	}	906	}
1184		907
…		…
1196	/*	919	/*
1197	* Builds a pixmap of the same size as the terminal window that contains	920	* 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	921	* the tiled portion of the root pixmap that is supposed to be covered by
1199	* our window.	922	* our window.
1200	*/	923	*/
1201	unsigned long	924	bool
1202	rxvt_term::make_transparency_pixmap ()	925	rxvt_term::make_transparency_pixmap ()
1203	{	926	{
1204	unsigned long result = 0;	927	bool ret = false;
1205		928
1206	/* root dimensions may change from call to call - but Display structure should	929	/* root dimensions may change from call to call - but Display structure should
1207	* be always up-to-date, so let's use it :	930	* be always up-to-date, so let's use it :
1208	*/	931	*/
1209	int screen = display->screen;	932	int screen = display->screen;
…		…
1247	#if XRENDER	970	#if XRENDER
1248	if (bg_flags & BG_HAS_RENDER)	971	if (bg_flags & BG_HAS_RENDER)
1249	{	972	{
1250	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);	973	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1251		974
1252	XRenderPictureAttributes pa;
1253
1254	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	975	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1255	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	976	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1256		977
1257	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	978	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1258	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	979	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1259		980
1260	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	981	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1261		982
1262	XRenderFreePicture (dpy, src);	983	XRenderFreePicture (dpy, src);
1263	XRenderFreePicture (dpy, dst);	984	XRenderFreePicture (dpy, dst);
…		…
1292	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);	1013	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);
1293		1014
1294	if (gc)	1015	if (gc)
1295	{	1016	{
1296	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1017	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1297	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1018	ret = true;
		1019	unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
		1020
		1021	if (!(bg_flags & BG_CLIENT_RENDER))
		1022	{
		1023	if (bg_flags & BG_NEEDS_BLUR)
		1024	{
		1025	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
		1026	tr_flags &= ~BG_NEEDS_BLUR;
		1027	}
		1028	if (bg_flags & BG_NEEDS_TINT)
		1029	{
		1030	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
		1031	tr_flags &= ~BG_NEEDS_TINT;
		1032	}
		1033	if (tr_flags & BG_NEEDS_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 (DefaultVisual (dpy, display->screen), 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	{
…		…
1516	break;	1219	break;
1517	default:	1220	default:
1518	return; /* we do not support this color depth */	1221	return; /* we do not support this color depth */
1519	}	1222	}
1520		1223
1521	rgba c;	1224	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1522		1225
		1226	if (bg_flags & BG_TINT_SET)
1523	tint.get (c);	1227	tint.get (c);
1524		1228
1525	/* prepare limits for color transformation (each channel is handled separately) */	1229	/* prepare limits for color transformation (each channel is handled separately) */
1526	if (shade > 100)	1230	if (shade > 100)
1527	{	1231	{
1528	c.r = c.r * (200 - shade) / 100;	1232	c.r = c.r * (200 - shade) / 100;
…		…
1581	}	1285	}
1582	}	1286	}
1583		1287
1584	free (lookup);	1288	free (lookup);
1585	}	1289	}
1586	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1290	#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.203 by sf-exg, Tue Apr 10 15:08: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.203 by sf-exg, Tue Apr 10 15:08:47 2012 UTC