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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.186 by sf-exg, Wed Dec 28 11:11:25 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 (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
380	if (bg_flags & BG_TINT_SET)
381	tint.get (c);
382	as_shade.tintColor.red = c.r;
383	as_shade.tintColor.green = c.g;
384	as_shade.tintColor.blue = c.b;
385
386	background_tint = shading2tint32 (&as_shade);
387	}
388
389	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
390	{
391	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
392	ASA_XImage,
393	100, ASIMAGE_QUALITY_DEFAULT);
394	if (tmp)
395	{
396	destroy_asimage (&background);
397	background = tmp;
398	}
399	}
400	# endif
401
402	ASImage *result = 0;
403
404	int target_width = szHint.width;
405	int target_height = szHint.height;
406	int new_pmap_width = target_width;
407	int new_pmap_height = target_height;
408
409	int x = 0;
410	int y = 0;
411	int w = 0;
412	int h = 0;
413
414	if (original_asim)
415	get_image_geometry (original_asim->width, original_asim->height, w, h, x, y);
416
417	if (!original_asim
418	\|\| (!(bg_flags & BG_ROOT_ALIGN)
419	&& (x >= target_width
420	\|\| y >= target_height
421	\|\| x + w <= 0
422	\|\| y + h <= 0)))
423	{
424	if (background)
425	{
426	new_pmap_width = background->width;
427	new_pmap_height = background->height;
428	result = background;
429
430	if (background_tint != TINT_LEAVE_SAME)
431	{
432	ASImage *tmp = tile_asimage (asv, background, 0, 0,
433	target_width, target_height, background_tint,
434	ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
435	if (tmp)
436	result = tmp;
437	}
438	}
439	else
440	new_pmap_width = new_pmap_height = 0;
441	}
442	else
443	{
444	result = original_asim;
445
446	if (w != original_asim->width
447	\|\| h != original_asim->height)
448	{
449	result = scale_asimage (asv, original_asim,
450	w, h,
451	ASA_XImage,
452	100, ASIMAGE_QUALITY_DEFAULT);
453	}
454
455	if (background == NULL)
456	{
457	if (bg_flags & BG_TILE)
458	{
459	/* if tiling - pixmap has to be sized exactly as the image,
460	but there is no need to make it bigger than the window! */
461	new_pmap_width = min (result->width, target_width);
462	new_pmap_height = min (result->height, target_height);
463
464	/* we also need to tile our image in both directions */
465	ASImage *tmp = tile_asimage (asv, result,
466	(int)result->width - x,
467	(int)result->height - y,
468	new_pmap_width,
469	new_pmap_height,
470	TINT_LEAVE_SAME, ASA_XImage,
471	100, ASIMAGE_QUALITY_DEFAULT);
472	if (tmp)
473	{
474	if (result != original_asim)
475	destroy_asimage (&result);
476
477	result = tmp;
478	}
479	}
480	}
481	else
482	{
483	/* if blending background and image - pixmap has to be sized same as target window */
484	ASImageLayer *layers = create_image_layers (2);
485
486	layers[0].im = background;
487	layers[0].clip_width = target_width;
488	layers[0].clip_height = target_height;
489	layers[0].tint = background_tint;
490	layers[1].im = result;
491
492	if (bg_flags & BG_TILE)
493	{
494	/* tile horizontally */
495	while (x > 0) x -= (int)result->width;
496	layers[1].dst_x = x;
497	layers[1].clip_width = result->width+target_width;
498	}
499	else
500	{
501	/* clip horizontally */
502	layers[1].dst_x = x;
503	layers[1].clip_width = result->width;
504	}
505
506	if (bg_flags & BG_TILE)
507	{
508	while (y > 0) y -= (int)result->height;
509	layers[1].dst_y = y;
510	layers[1].clip_height = result->height + target_height;
511	}
512	else
513	{
514	layers[1].dst_y = y;
515	layers[1].clip_height = result->height;
516	}
517
518	if (rs[Rs_blendtype])
519	{
520	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
521	if (layers[1].merge_scanlines == NULL)
522	layers[1].merge_scanlines = alphablend_scanlines;
523	}
524
525	ASImage *tmp = merge_layers (asv, layers, 2, target_width, target_height,
526	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
527
528	if (tmp)
529	{
530	if (result != original_asim)
531	destroy_asimage (&result);
532
533	result = tmp;
534	}
535
536	free (layers);
537	}
538	}
539
540	bool ret = false;
541
542	if (result)
543	{
544	XGCValues gcv;
545	GC gc;
546
547	/* create Pixmap */
548	if (bg_pixmap == None
549	\|\| bg_pmap_width != new_pmap_width
550	\|\| bg_pmap_height != new_pmap_height)
551	{
552	if (bg_pixmap)
553	XFreePixmap (dpy, bg_pixmap);
554	bg_pixmap = XCreatePixmap (dpy, vt, new_pmap_width, new_pmap_height, depth);
555	bg_pmap_width = new_pmap_width;
556	bg_pmap_height = new_pmap_height;
557	}
558	/* fill with background color (if result's not completely overlapping it) */
559	gcv.foreground = pix_colors[Color_bg];
560	gc = XCreateGC (dpy, vt, GCForeground, &gcv);
561
562	int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
563	int dst_width = result->width, dst_height = result->height;
564	if (background == NULL)
565	{
566	if (!(bg_flags & BG_TILE))
567	{
568	src_x = make_clip_rectangle (x, result->width , new_pmap_width , dst_x, dst_width );
569	src_y = make_clip_rectangle (y, result->height, new_pmap_height, dst_y, dst_height);
570	}
571
572	if (dst_x > 0 \|\| dst_y > 0
573	\|\| dst_x + dst_width < new_pmap_width
574	\|\| dst_y + dst_height < new_pmap_height)
575	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, new_pmap_width, new_pmap_height);
576	}
577
578	/* put result on pixmap */
579	if (dst_x < new_pmap_width && dst_y < new_pmap_height)
580	asimage2drawable (asv, bg_pixmap, result, gc, src_x, src_y, dst_x, dst_y, dst_width, dst_height, True);
581
582	if (result != background && result != original_asim)
583	destroy_asimage (&result);
584
585	XFreeGC (dpy, gc);
586
587	ret = true;
588	}
589
590	if (background)
591	destroy_asimage (&background);
592
593	return ret;
594	}
595	# endif /* HAVE_AFTERIMAGE */
596		346
597	# ifdef HAVE_PIXBUF	347	# ifdef HAVE_PIXBUF
598	bool	348	bool
599	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,	349	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
600	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,
…		…
677	XDestroyImage (ximage);	427	XDestroyImage (ximage);
678	return true;	428	return true;
679	}	429	}
680		430
681	bool	431	bool
682	rxvt_term::render_image (unsigned long tr_flags)	432	rxvt_term::render_image (bool transparent)
683	{	433	{
684	if (!pixbuf)	434	if (!pixbuf)
685	return false;	435	return false;
686		436
687	if (tr_flags	437	if (transparent
688	&& !(bg_flags & BG_HAS_RENDER))	438	&& !(bg_flags & BG_HAS_RENDER))
689	return false;	439	return false;
690		440
691	GdkPixbuf *result;	441	GdkPixbuf *result;
692		442
…		…
732	Pixmap root_pmap;	482	Pixmap root_pmap;
733		483
734	image_width = gdk_pixbuf_get_width (result);	484	image_width = gdk_pixbuf_get_width (result);
735	image_height = gdk_pixbuf_get_height (result);	485	image_height = gdk_pixbuf_get_height (result);
736		486
737	if (tr_flags)	487	if (transparent)
738	{	488	{
739	root_pmap = bg_pixmap;	489	root_pmap = bg_pixmap;
740	bg_pixmap = None;	490	bg_pixmap = None;
741	}	491	}
742	else	492	else
…		…
800	dst_x, dst_y,	550	dst_x, dst_y,
801	dst_width, dst_height);	551	dst_width, dst_height);
802	}	552	}
803		553
804	#if XRENDER	554	#if XRENDER
805	if (tr_flags)	555	if (transparent)
806	{	556	{
807	XRenderPictureAttributes pa;
808
809	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	557	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		558
810	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	559	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
811		560
812	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
813	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	561	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
814		562
815	pa.repeat = True;	563	Picture mask = create_xrender_mask (dpy, vt, False, False);
816	Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
817	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
818	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
819	XFreePixmap (dpy, mask_pmap);
820		564
821	XRenderColor mask_c;	565	XRenderColor mask_c;
822		566
823	mask_c.alpha = 0x8000;	567	mask_c.alpha = 0x8000;
824	mask_c.red = 0;	568	mask_c.red =
825	mask_c.green = 0;	569	mask_c.green =
826	mask_c.blue = 0;	570	mask_c.blue = 0;
827	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	571	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		572
828	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);
829		574
830	XRenderFreePicture (dpy, src);	575	XRenderFreePicture (dpy, src);
831	XRenderFreePicture (dpy, dst);	576	XRenderFreePicture (dpy, dst);
832	XRenderFreePicture (dpy, mask);	577	XRenderFreePicture (dpy, mask);
…		…
839	}	584	}
840		585
841	if (result != pixbuf)	586	if (result != pixbuf)
842	g_object_unref (result);	587	g_object_unref (result);
843		588
844	if (tr_flags)	589	if (transparent)
845	XFreePixmap (dpy, root_pmap);	590	XFreePixmap (dpy, root_pmap);
846		591
847	return ret;	592	return ret;
848	}	593	}
849	# endif /* HAVE_PIXBUF */	594	# endif /* HAVE_PIXBUF */
…		…
864	memcpy (f, file, len);	609	memcpy (f, file, len);
865	f[len] = '\0';	610	f[len] = '\0';
866	file = f;	611	file = f;
867	}	612	}
868		613
869	# ifdef HAVE_AFTERIMAGE
870	if (!asimman)
871	asimman = create_generic_imageman (rs[Rs_path]);
872	ASImage *image = get_asimage (asimman, file, 0xFFFFFFFF, 100);
873	if (image)
874	{
875	if (original_asim)
876	safe_asimage_destroy (original_asim);
877	original_asim = image;
878	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;
879	ret = true;
880	}
881	# endif
882
883	# ifdef HAVE_PIXBUF	614	# ifdef HAVE_PIXBUF
884	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	615	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
885	if (image)	616	if (image)
886	{	617	{
887	if (pixbuf)	618	if (pixbuf)
…		…
944	{	675	{
945	changed = true;	676	changed = true;
946	v_blurRadius = vr;	677	v_blurRadius = vr;
947	}	678	}
948		679
949	if (v_blurRadius == 0 && h_blurRadius == 0)	680	if (h_blurRadius == 0 \|\| v_blurRadius == 0)
950	bg_flags &= ~BG_NEEDS_BLUR;	681	bg_flags &= ~BG_NEEDS_BLUR;
951	else	682	else
952	bg_flags \|= BG_NEEDS_BLUR;	683	bg_flags \|= BG_NEEDS_BLUR;
953		684
954	return changed;	685	return changed;
955	}	686	}
956		687
957	void	688	void
958	rxvt_term::set_tint_shade_flags ()	689	rxvt_term::set_tint_shade_flags ()
959	{	690	{
		691	if (shade != 100 \|\| (bg_flags & BG_TINT_SET))
		692	bg_flags \|= BG_NEEDS_TINT;
		693	else
		694	bg_flags &= ~BG_NEEDS_TINT;
		695	}
		696
		697	bool
		698	rxvt_term::bg_set_tint (rxvt_color &new_tint)
		699	{
		700	if (!(bg_flags & BG_TINT_SET) \|\| tint != new_tint)
		701	{
		702	tint = new_tint;
		703	bg_flags \|= BG_TINT_SET;
		704
960	rgba c;	705	rgba c;
961	bool has_shade = shade != 100;
962
963	bg_flags &= ~BG_TINT_FLAGS;
964
965	if (bg_flags & BG_TINT_SET)
966	{
967	tint.get (c);	706	tint.get (c);
968	if (!has_shade
969	&& (c.r <= 0x00ff \|\| c.r >= 0xff00)	707	if ((c.r <= 0x00ff \|\| c.r >= 0xff00)
970	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)	708	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)
971	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))	709	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))
972	bg_flags \|= BG_TINT_BITAND;	710	bg_flags \|= BG_TINT_BITAND;
973	}	711	else
974
975	if (has_shade \|\| (bg_flags & BG_TINT_SET))
976	bg_flags \|= BG_NEEDS_TINT;
977	}
978
979	bool
980	rxvt_term::bg_set_tint (rxvt_color &new_tint)
981	{
982	if (!(bg_flags & BG_TINT_SET) \|\| tint != new_tint)
983	{
984	tint = new_tint;
985	bg_flags \|= BG_TINT_SET;	712	bg_flags &= ~BG_TINT_BITAND;
		713
986	set_tint_shade_flags ();	714	set_tint_shade_flags ();
987	return true;	715	return true;
988	}	716	}
989		717
990	return false;	718	return false;
…		…
1031	params[i+2] = XDoubleToFixed (kernel[i] / sum);	759	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1032	}	760	}
1033	#endif	761	#endif
1034		762
1035	bool	763	bool
1036	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)
1037	{	765	{
1038	bool ret = false;	766	bool ret = false;
1039	#if XRENDER	767	#if XRENDER
1040	if (!(bg_flags & BG_HAS_RENDER_CONV))	768	if (!(bg_flags & BG_HAS_RENDER_CONV))
1041	return false;	769	return false;
…		…
1045	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	773	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1046		774
1047	XRenderPictureAttributes pa;	775	XRenderPictureAttributes pa;
1048	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	776	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1049		777
		778	pa.repeat = RepeatPad;
1050	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);
1051	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	781	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		782	XFreePixmap (dpy, tmp);
1052		783
1053	if (kernel && params)	784	if (kernel && params)
1054	{	785	{
1055	if (h_blurRadius)
1056	{
1057	size = h_blurRadius * 2 + 1;	786	size = h_blurRadius * 2 + 1;
1058	get_gaussian_kernel (h_blurRadius, size, kernel, params);	787	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1059		788
1060	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	789	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1061	XRenderComposite (dpy,	790	XRenderComposite (dpy,
1062	PictOpSrc,	791	PictOpSrc,
1063	src,	792	src,
1064	None,	793	None,
1065	dst,	794	dst,
1066	0, 0,	795	0, 0,
1067	0, 0,	796	0, 0,
1068	0, 0,	797	0, 0,
1069	width, height);	798	width, height);
1070	}
1071		799
1072	if (v_blurRadius)	800	::swap (src, dst);
1073	{	801
1074	size = v_blurRadius * 2 + 1;	802	size = v_blurRadius * 2 + 1;
1075	get_gaussian_kernel (v_blurRadius, size, kernel, params);	803	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1076	::swap (params[0], params[1]);	804	::swap (params[0], params[1]);
1077		805
1078	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	806	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1079	XRenderComposite (dpy,	807	XRenderComposite (dpy,
1080	PictOpSrc,	808	PictOpSrc,
1081	src,	809	src,
1082	None,	810	None,
1083	dst,	811	dst,
1084	0, 0,	812	0, 0,
1085	0, 0,	813	0, 0,
1086	0, 0,	814	0, 0,
1087	width, height);	815	width, height);
1088	}
1089		816
1090	ret = true;	817	ret = true;
1091	}	818	}
1092		819
1093	free (kernel);	820	free (kernel);
…		…
1101	bool	828	bool
1102	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)
1103	{	830	{
1104	bool ret = false;	831	bool ret = false;
1105		832
1106	if (bg_flags & BG_TINT_BITAND)	833	if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1107	{	834	{
1108	XGCValues gcv;	835	XGCValues gcv;
1109	GC gc;	836	GC gc;
1110		837
1111	/* In this case we can tint image server-side getting significant	838	/* In this case we can tint image server-side getting significant
…		…
1141	c.r = c.r * (200 - shade) / 100;	868	c.r = c.r * (200 - shade) / 100;
1142	c.g = c.g * (200 - shade) / 100;	869	c.g = c.g * (200 - shade) / 100;
1143	c.b = c.b * (200 - shade) / 100;	870	c.b = c.b * (200 - shade) / 100;
1144	}	871	}
1145		872
1146	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1147	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	873	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1148	XRenderPictureAttributes pa;
1149		874
1150	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	875	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1151		876
1152	pa.repeat = True;	877	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1153		878
1154	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	879	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1155	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1156	XFreePixmap (dpy, overlay_pmap);
1157
1158	pa.component_alpha = True;
1159	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1160	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat \| CPComponentAlpha, &pa);
1161	XFreePixmap (dpy, mask_pmap);
1162		880
1163	XRenderColor mask_c;	881	XRenderColor mask_c;
1164		882
1165	mask_c.alpha = 0xffff;	883	mask_c.alpha = 0xffff;
1166	mask_c.red =	884	mask_c.red =
…		…
1171	mask_c.alpha = 0;	889	mask_c.alpha = 0;
1172	mask_c.red = 0xffff - c.r;	890	mask_c.red = 0xffff - c.r;
1173	mask_c.green = 0xffff - c.g;	891	mask_c.green = 0xffff - c.g;
1174	mask_c.blue = 0xffff - c.b;	892	mask_c.blue = 0xffff - c.b;
1175	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	893	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		894
1176	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);
1177		896
1178	if (shade > 100)	897	if (shade > 100)
1179	{	898	{
1180	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1181	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;
1182	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	903	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1183		904
1184	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);
1185	}	906	}
1186		907
…		…
1198	/*	919	/*
1199	* 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
1200	* 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
1201	* our window.	922	* our window.
1202	*/	923	*/
1203	unsigned long	924	bool
1204	rxvt_term::make_transparency_pixmap ()	925	rxvt_term::make_transparency_pixmap ()
1205	{	926	{
1206	unsigned long result = 0;	927	bool ret = false;
1207		928
1208	/* 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
1209	* be always up-to-date, so let's use it :	930	* be always up-to-date, so let's use it :
1210	*/	931	*/
1211	int screen = display->screen;	932	int screen = display->screen;
…		…
1249	#if XRENDER	970	#if XRENDER
1250	if (bg_flags & BG_HAS_RENDER)	971	if (bg_flags & BG_HAS_RENDER)
1251	{	972	{
1252	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);
1253		974
1254	XRenderPictureAttributes pa;
1255
1256	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	975	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1257	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	976	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1258		977
1259	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	978	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1260	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	979	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1261		980
1262	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);
1263		982
1264	XRenderFreePicture (dpy, src);	983	XRenderFreePicture (dpy, src);
1265	XRenderFreePicture (dpy, dst);	984	XRenderFreePicture (dpy, dst);
…		…
1294	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);	1013	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);
1295		1014
1296	if (gc)	1015	if (gc)
1297	{	1016	{
1298	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1017	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1299	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
1300	XFreeGC (dpy, gc);	1047	XFreeGC (dpy, gc);
1301
1302	if (!(bg_flags & BG_CLIENT_RENDER))
1303	{
1304	if (bg_flags & BG_NEEDS_BLUR)
1305	{
1306	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))
1307	result &= ~BG_NEEDS_BLUR;
1308	}
1309	if (bg_flags & BG_NEEDS_TINT)
1310	{
1311	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1312	result &= ~BG_NEEDS_TINT;
1313	}
1314	} /* server side rendering completed */
1315	}	1048	}
1316		1049
1317	if (recoded_root_pmap != root_pixmap)	1050	if (recoded_root_pmap != root_pixmap)
1318	XFreePixmap (dpy, recoded_root_pmap);	1051	XFreePixmap (dpy, recoded_root_pmap);
1319		1052
1320	return result;	1053	return ret;
1321	}	1054	}
1322		1055
1323	void	1056	void
1324	rxvt_term::bg_set_root_pixmap ()	1057	rxvt_term::bg_set_root_pixmap ()
1325	{	1058	{
…		…
1332	# endif /* ENABLE_TRANSPARENCY */	1065	# endif /* ENABLE_TRANSPARENCY */
1333		1066
1334	bool	1067	bool
1335	rxvt_term::bg_render ()	1068	rxvt_term::bg_render ()
1336	{	1069	{
1337	unsigned long tr_flags = 0;	1070	bool transparent = false;
1338		1071
1339	bg_invalidate ();	1072	bg_invalidate ();
1340	# ifdef ENABLE_TRANSPARENCY	1073	# ifdef ENABLE_TRANSPARENCY
1341	if (bg_flags & BG_IS_TRANSPARENT)	1074	if (bg_flags & BG_IS_TRANSPARENT)
1342	{	1075	{
1343	/* we need to re-generate transparency pixmap in that case ! */	1076	/* we need to re-generate transparency pixmap in that case ! */
1344	tr_flags = make_transparency_pixmap ();	1077	transparent = make_transparency_pixmap ();
1345	if (tr_flags == 0)	1078	if (transparent)
1346	return false;
1347	bg_flags \|= BG_IS_VALID;	1079	bg_flags \|= BG_IS_VALID;
1348	}	1080	}
1349	# endif	1081	# endif
1350		1082
1351	# ifdef BG_IMAGE_FROM_FILE	1083	# ifdef BG_IMAGE_FROM_FILE
1352	if ((bg_flags & BG_IS_FROM_FILE)	1084	if (bg_flags & BG_IS_FROM_FILE)
1353	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1354	{	1085	{
1355	if (render_image (tr_flags))	1086	if (render_image (transparent))
1356	bg_flags \|= BG_IS_VALID;	1087	bg_flags \|= BG_IS_VALID;
1357	}
1358	# endif
1359
1360	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1361	XImage *result = NULL;
1362
1363	if (tr_flags & BG_NEEDS_TINT)
1364	{
1365	result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1366	}
1367
1368	if (result)
1369	{
1370	/* our own client-side tinting */
1371	//if (tr_flags & BG_NEEDS_TINT)
1372	if (1)
1373	tint_ximage (DefaultVisual (dpy, display->screen), result);
1374
1375	GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1376
1377	if (gc)
1378	{
1379	XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1380
1381	XFreeGC (dpy, gc);
1382	}
1383
1384	XDestroyImage (result);
1385	}	1088	}
1386	# endif	1089	# endif
1387		1090
1388	if (!(bg_flags & BG_IS_VALID))	1091	if (!(bg_flags & BG_IS_VALID))
1389	{	1092	{
…		…
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	{
…		…
1582	}	1285	}
1583	}	1286	}
1584		1287
1585	free (lookup);	1288	free (lookup);
1586	}	1289	}
1587	#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.186 by sf-exg, Wed Dec 28 11:11:25 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.186 by sf-exg, Wed Dec 28 11:11:25 2011 UTC vs.
Revision 1.203 by sf-exg, Tue Apr 10 15:08:47 2012 UTC