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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.185 by sf-exg, Mon Dec 26 14:53:56 2011 UTC vs.
Revision 1.206 by sf-exg, Thu Apr 12 10:22:50 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;
150	int smaller = min (image_size, window_size);
151
152	if (align >= 0 && align <= 100)	128	if (align >= 0 && align <= 100)
153	return diff * align / 100;	129	return lerp (0, window_size - image_size, align);
154	else if (align > 100 && align <= 200)	130	else if (align > 100)
155	return (align - 100) * smaller / 100 + window_size - smaller;	131	return lerp (window_size - image_size, window_size, align - 100);
156	else if (align >= -100 && align < 0)	132	else
157	return (align + 100) * smaller / 100 - image_size;	133	return lerp (-image_size, 0, align + 100);
158	return 0;
159	}	134	}
160		135
161	static inline int	136	static inline int
162	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	137	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
163	{	138	{
…		…
169	src_pos = -pos;	144	src_pos = -pos;
170	dst_pos = 0;	145	dst_pos = 0;
171	dst_size += pos;	146	dst_size += pos;
172	}	147	}
173		148
174	if (dst_pos + dst_size > target_size)
175	dst_size = target_size - dst_pos;	149	min_it (dst_size, target_size - dst_pos);
176	return src_pos;	150	return src_pos;
177	}	151	}
178		152
179	bool	153	bool
180	rxvt_term::bg_set_geometry (const char *geom, bool update)	154	rxvt_term::bg_set_geometry (const char *geom, bool update)
181	{	155	{
182	bool changed = false;	156	bool changed = false;
183	int geom_flags = 0;	157	int geom_flags = 0;
184	int x = 0, y = 0;	158	int x = h_align;
		159	int y = v_align;
185	unsigned int w = 0, h = 0;	160	unsigned int w = h_scale;
		161	unsigned int h = v_scale;
186	unsigned long new_flags = 0;	162	unsigned long new_flags = 0;
187		163
188	if (geom == NULL)	164	if (geom == NULL)
189	return false;	165	return false;
190		166
…		…
299	w = h = defaultScale;	275	w = h = defaultScale;
300	else if (!(geom_flags & HeightValue))	276	else if (!(geom_flags & HeightValue))
301	h = w;	277	h = w;
302	else if (!(geom_flags & WidthValue))	278	else if (!(geom_flags & WidthValue))
303	w = h;	279	w = h;
304
305	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
306	}	280	}
307		281
308	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;	282	min_it (w, 1000);
309	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;	283	min_it (h, 1000);
310	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;	284	clamp_it (x, -100, 200);
311	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;	285	clamp_it (y, -100, 200);
312		286
313	if (new_flags != bg_flags)	287	if (bg_flags != new_flags
		288	\|\| h_scale != w
		289	\|\| v_scale != h
		290	\|\| h_align != x
		291	\|\| v_align != y)
314	{	292	{
315	bg_flags = new_flags;	293	bg_flags = new_flags;
		294	h_scale = w;
		295	v_scale = h;
		296	h_align = x;
		297	v_align = y;
316	changed = true;	298	changed = true;
317	}	299	}
318		300
319	return changed;	301	return changed;
320	}	302	}
…		…
348	{	330	{
349	x = make_align_position (h_align, target_width, w);	331	x = make_align_position (h_align, target_width, w);
350	y = make_align_position (v_align, target_height, h);	332	y = make_align_position (v_align, target_height, h);
351	}	333	}
352		334
353	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
354	if (!(bg_flags & BG_TILE)	335	if (!(bg_flags & BG_TILE)
355	\|\| h_scale \|\| v_scale	336	\|\| h_scale \|\| v_scale
356	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	337	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
357	\|\| w > target_width \|\| h > target_height)	338	\|\| image_width > target_width \|\| image_height > target_height)
358	bg_flags \|= BG_IS_SIZE_SENSITIVE;	339	bg_flags \|= BG_IS_SIZE_SENSITIVE;
359	}
360
361	# ifdef HAVE_AFTERIMAGE
362	bool
363	rxvt_term::render_image (unsigned long tr_flags)
364	{
365	init_asv ();
366
367	ASImage *background = NULL;
368	ARGB32 background_tint = TINT_LEAVE_SAME;
369
370	# ifdef ENABLE_TRANSPARENCY
371	if (tr_flags)
372	background = pixmap2ximage (asv, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, 100);
373
374	if (tr_flags & BG_NEEDS_TINT)
375	{
376	ShadingInfo as_shade;
377	as_shade.shading = shade;
378
379	rgba c (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	340	else
443	{	341	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
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	}	342	}
595	# endif /* HAVE_AFTERIMAGE */
596		343
597	# ifdef HAVE_PIXBUF	344	# ifdef HAVE_PIXBUF
598	bool	345	bool
599	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,	346	rxvt_term::pixbuf_to_pixmap (GdkPixbuf *pixbuf, Pixmap pixmap, GC gc,
600	int src_x, int src_y, int dst_x, int dst_y,	347	int src_x, int src_y, int dst_x, int dst_y,
…		…
677	XDestroyImage (ximage);	424	XDestroyImage (ximage);
678	return true;	425	return true;
679	}	426	}
680		427
681	bool	428	bool
682	rxvt_term::render_image (unsigned long tr_flags)	429	rxvt_term::render_image (bool transparent)
683	{	430	{
684	if (!pixbuf)	431	if (!pixbuf)
685	return false;	432	return false;
686		433
687	if (tr_flags	434	if (transparent
688	&& !(bg_flags & BG_HAS_RENDER))	435	&& !(bg_flags & BG_HAS_RENDER))
689	return false;	436	return false;
690		437
691	GdkPixbuf *result;	438	GdkPixbuf *result;
692		439
…		…
732	Pixmap root_pmap;	479	Pixmap root_pmap;
733		480
734	image_width = gdk_pixbuf_get_width (result);	481	image_width = gdk_pixbuf_get_width (result);
735	image_height = gdk_pixbuf_get_height (result);	482	image_height = gdk_pixbuf_get_height (result);
736		483
737	if (tr_flags)	484	if (transparent)
738	{	485	{
739	root_pmap = bg_pixmap;	486	root_pmap = bg_pixmap;
740	bg_pixmap = None;	487	bg_pixmap = None;
741	}	488	}
742	else	489	else
…		…
800	dst_x, dst_y,	547	dst_x, dst_y,
801	dst_width, dst_height);	548	dst_width, dst_height);
802	}	549	}
803		550
804	#if XRENDER	551	#if XRENDER
805	if (tr_flags)	552	if (transparent)
806	{	553	{
807	XRenderPictureAttributes pa;
808
809	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	554	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		555
810	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	556	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
811		557
812	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
813	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	558	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
814		559
815	pa.repeat = True;	560	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		561
821	XRenderColor mask_c;	562	XRenderColor mask_c;
822		563
823	mask_c.alpha = 0x8000;	564	mask_c.alpha = 0x8000;
824	mask_c.red = 0;	565	mask_c.red =
825	mask_c.green = 0;	566	mask_c.green =
826	mask_c.blue = 0;	567	mask_c.blue = 0;
827	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	568	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		569
828	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	570	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
829		571
830	XRenderFreePicture (dpy, src);	572	XRenderFreePicture (dpy, src);
831	XRenderFreePicture (dpy, dst);	573	XRenderFreePicture (dpy, dst);
832	XRenderFreePicture (dpy, mask);	574	XRenderFreePicture (dpy, mask);
…		…
839	}	581	}
840		582
841	if (result != pixbuf)	583	if (result != pixbuf)
842	g_object_unref (result);	584	g_object_unref (result);
843		585
844	if (tr_flags)	586	if (transparent)
845	XFreePixmap (dpy, root_pmap);	587	XFreePixmap (dpy, root_pmap);
846		588
847	return ret;	589	return ret;
848	}	590	}
849	# endif /* HAVE_PIXBUF */	591	# endif /* HAVE_PIXBUF */
…		…
864	memcpy (f, file, len);	606	memcpy (f, file, len);
865	f[len] = '\0';	607	f[len] = '\0';
866	file = f;	608	file = f;
867	}	609	}
868		610
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	611	# ifdef HAVE_PIXBUF
884	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	612	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
885	if (image)	613	if (image)
886	{	614	{
887	if (pixbuf)	615	if (pixbuf)
…		…
944	{	672	{
945	changed = true;	673	changed = true;
946	v_blurRadius = vr;	674	v_blurRadius = vr;
947	}	675	}
948		676
949	if (v_blurRadius == 0 && h_blurRadius == 0)	677	if (h_blurRadius && v_blurRadius)
		678	bg_flags \|= BG_NEEDS_BLUR;
		679	else
950	bg_flags &= ~BG_NEEDS_BLUR;	680	bg_flags &= ~BG_NEEDS_BLUR;
951	else
952	bg_flags \|= BG_NEEDS_BLUR;
953		681
954	return changed;	682	return changed;
955	}	683	}
956		684
957	void	685	void
958	rxvt_term::set_tint_shade_flags ()	686	rxvt_term::set_tint_shade_flags ()
959	{	687	{
		688	if (shade != 100 \|\| (bg_flags & BG_TINT_SET))
		689	bg_flags \|= BG_NEEDS_TINT;
		690	else
		691	bg_flags &= ~BG_NEEDS_TINT;
		692	}
		693
		694	bool
		695	rxvt_term::bg_set_tint (rxvt_color &new_tint)
		696	{
		697	if (!(bg_flags & BG_TINT_SET) \|\| tint != new_tint)
		698	{
		699	tint = new_tint;
		700	bg_flags \|= BG_TINT_SET;
		701
960	rgba c;	702	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);	703	tint.get (c);
968	if (!has_shade
969	&& (c.r <= 0x00ff \|\| c.r >= 0xff00)	704	if ((c.r <= 0x00ff \|\| c.r >= 0xff00)
970	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)	705	&& (c.g <= 0x00ff \|\| c.g >= 0xff00)
971	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))	706	&& (c.b <= 0x00ff \|\| c.b >= 0xff00))
972	bg_flags \|= BG_TINT_BITAND;	707	bg_flags \|= BG_TINT_BITAND;
973	}	708	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;	709	bg_flags &= ~BG_TINT_BITAND;
		710
986	set_tint_shade_flags ();	711	set_tint_shade_flags ();
987	return true;	712	return true;
988	}	713	}
989		714
990	return false;	715	return false;
991	}	716	}
992		717
993	bool	718	bool
994	rxvt_term::bg_set_shade (const char *shade_str)	719	rxvt_term::bg_set_shade (const char *shade_str)
995	{	720	{
996	int new_shade = (shade_str) ? atoi (shade_str) : 100;	721	int new_shade = atoi (shade_str);
997		722
998	clamp_it (new_shade, -100, 200);	723	clamp_it (new_shade, -100, 200);
999	if (new_shade < 0)	724	if (new_shade < 0)
1000	new_shade = 200 - (100 + new_shade);	725	new_shade = 200 - (100 + new_shade);
1001		726
…		…
1031	params[i+2] = XDoubleToFixed (kernel[i] / sum);	756	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1032	}	757	}
1033	#endif	758	#endif
1034		759
1035	bool	760	bool
1036	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	761	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1037	{	762	{
1038	bool ret = false;	763	bool ret = false;
1039	#if XRENDER	764	#if XRENDER
1040	if (!(bg_flags & BG_HAS_RENDER_CONV))	765	if (!(bg_flags & BG_HAS_RENDER_CONV))
1041	return false;	766	return false;
…		…
1045	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	770	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1046		771
1047	XRenderPictureAttributes pa;	772	XRenderPictureAttributes pa;
1048	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	773	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1049		774
		775	pa.repeat = RepeatPad;
1050	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	776	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		777	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1051	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	778	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		779	XFreePixmap (dpy, tmp);
1052		780
1053	if (kernel && params)	781	if (kernel && params)
1054	{	782	{
1055	if (h_blurRadius)
1056	{
1057	size = h_blurRadius * 2 + 1;	783	size = h_blurRadius * 2 + 1;
1058	get_gaussian_kernel (h_blurRadius, size, kernel, params);	784	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1059		785
1060	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	786	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1061	XRenderComposite (dpy,	787	XRenderComposite (dpy,
1062	PictOpSrc,	788	PictOpSrc,
1063	src,	789	src,
1064	None,	790	None,
1065	dst,	791	dst,
1066	0, 0,	792	0, 0,
1067	0, 0,	793	0, 0,
1068	0, 0,	794	0, 0,
1069	width, height);	795	width, height);
1070	}
1071		796
1072	if (v_blurRadius)	797	::swap (src, dst);
1073	{	798
1074	size = v_blurRadius * 2 + 1;	799	size = v_blurRadius * 2 + 1;
1075	get_gaussian_kernel (v_blurRadius, size, kernel, params);	800	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1076	::swap (params[0], params[1]);	801	::swap (params[0], params[1]);
1077		802
1078	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	803	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1079	XRenderComposite (dpy,	804	XRenderComposite (dpy,
1080	PictOpSrc,	805	PictOpSrc,
1081	src,	806	src,
1082	None,	807	None,
1083	dst,	808	dst,
1084	0, 0,	809	0, 0,
1085	0, 0,	810	0, 0,
1086	0, 0,	811	0, 0,
1087	width, height);	812	width, height);
1088	}
1089		813
1090	ret = true;	814	ret = true;
1091	}	815	}
1092		816
1093	free (kernel);	817	free (kernel);
…		…
1101	bool	825	bool
1102	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	826	rxvt_term::tint_pixmap (Pixmap pixmap, Visual *visual, int width, int height)
1103	{	827	{
1104	bool ret = false;	828	bool ret = false;
1105		829
1106	if (bg_flags & BG_TINT_BITAND)	830	if (shade == 100 && (bg_flags & BG_TINT_BITAND))
1107	{	831	{
1108	XGCValues gcv;	832	XGCValues gcv;
1109	GC gc;	833	GC gc;
1110		834
1111	/* In this case we can tint image server-side getting significant	835	/* In this case we can tint image server-side getting significant
…		…
1141	c.r = c.r * (200 - shade) / 100;	865	c.r = c.r * (200 - shade) / 100;
1142	c.g = c.g * (200 - shade) / 100;	866	c.g = c.g * (200 - shade) / 100;
1143	c.b = c.b * (200 - shade) / 100;	867	c.b = c.b * (200 - shade) / 100;
1144	}	868	}
1145		869
1146	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1147	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	870	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1148	XRenderPictureAttributes pa;
1149		871
1150	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	872	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1151		873
1152	pa.repeat = True;	874	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1153		875
1154	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	876	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		877
1163	XRenderColor mask_c;	878	XRenderColor mask_c;
1164		879
1165	mask_c.alpha = 0xffff;	880	mask_c.alpha = 0xffff;
1166	mask_c.red =	881	mask_c.red =
…		…
1171	mask_c.alpha = 0;	886	mask_c.alpha = 0;
1172	mask_c.red = 0xffff - c.r;	887	mask_c.red = 0xffff - c.r;
1173	mask_c.green = 0xffff - c.g;	888	mask_c.green = 0xffff - c.g;
1174	mask_c.blue = 0xffff - c.b;	889	mask_c.blue = 0xffff - c.b;
1175	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	890	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		891
1176	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);	892	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1177		893
1178	if (shade > 100)	894	if (shade > 100)
1179	{	895	{
1180	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1181	mask_c.alpha = 0;	896	mask_c.alpha = 0;
		897	mask_c.red =
		898	mask_c.green =
		899	mask_c.blue = 0xffff * (shade - 100) / 100;
1182	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	900	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1183		901
1184	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);	902	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1185	}	903	}
1186		904
…		…
1198	/*	916	/*
1199	* Builds a pixmap of the same size as the terminal window that contains	917	* 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	918	* the tiled portion of the root pixmap that is supposed to be covered by
1201	* our window.	919	* our window.
1202	*/	920	*/
1203	unsigned long	921	bool
1204	rxvt_term::make_transparency_pixmap ()	922	rxvt_term::make_transparency_pixmap ()
1205	{	923	{
1206	unsigned long result = 0;	924	bool ret = false;
1207		925
1208	/* root dimensions may change from call to call - but Display structure should	926	/* root dimensions may change from call to call - but Display structure should
1209	* be always up-to-date, so let's use it :	927	* be always up-to-date, so let's use it :
1210	*/	928	*/
1211	int screen = display->screen;	929	int screen = display->screen;
…		…
1249	#if XRENDER	967	#if XRENDER
1250	if (bg_flags & BG_HAS_RENDER)	968	if (bg_flags & BG_HAS_RENDER)
1251	{	969	{
1252	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);	970	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1253		971
1254	XRenderPictureAttributes pa;
1255
1256	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	972	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1257	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	973	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1258		974
1259	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	975	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1260	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	976	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1261		977
1262	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	978	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1263		979
1264	XRenderFreePicture (dpy, src);	980	XRenderFreePicture (dpy, src);
1265	XRenderFreePicture (dpy, dst);	981	XRenderFreePicture (dpy, dst);
…		…
1294	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);	1010	gc = XCreateGC (dpy, vt, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcv);
1295		1011
1296	if (gc)	1012	if (gc)
1297	{	1013	{
1298	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1014	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1299	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1015	ret = true;
		1016	unsigned long tr_flags = bg_flags & BG_EFFECTS_FLAGS;
		1017
		1018	if (!(bg_flags & BG_CLIENT_RENDER))
		1019	{
		1020	if (bg_flags & BG_NEEDS_BLUR)
		1021	{
		1022	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
		1023	tr_flags &= ~BG_NEEDS_BLUR;
		1024	}
		1025	if (bg_flags & BG_NEEDS_TINT)
		1026	{
		1027	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
		1028	tr_flags &= ~BG_NEEDS_TINT;
		1029	}
		1030	if (tr_flags & BG_NEEDS_TINT)
		1031	{
		1032	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1033	if (ximage)
		1034	{
		1035	/* our own client-side tinting */
		1036	tint_ximage (DefaultVisual (dpy, display->screen), ximage);
		1037
		1038	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1039	XDestroyImage (ximage);
		1040	}
		1041	}
		1042	} /* server side rendering completed */
		1043
1300	XFreeGC (dpy, gc);	1044	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	}	1045	}
1316		1046
1317	if (recoded_root_pmap != root_pixmap)	1047	if (recoded_root_pmap != root_pixmap)
1318	XFreePixmap (dpy, recoded_root_pmap);	1048	XFreePixmap (dpy, recoded_root_pmap);
1319		1049
1320	return result;	1050	return ret;
1321	}	1051	}
1322		1052
1323	void	1053	void
1324	rxvt_term::bg_set_root_pixmap ()	1054	rxvt_term::bg_set_root_pixmap ()
1325	{	1055	{
…		…
1332	# endif /* ENABLE_TRANSPARENCY */	1062	# endif /* ENABLE_TRANSPARENCY */
1333		1063
1334	bool	1064	bool
1335	rxvt_term::bg_render ()	1065	rxvt_term::bg_render ()
1336	{	1066	{
1337	unsigned long tr_flags = 0;	1067	bool transparent = false;
1338		1068
1339	bg_invalidate ();	1069	bg_invalidate ();
1340	# ifdef ENABLE_TRANSPARENCY	1070	# ifdef ENABLE_TRANSPARENCY
1341	if (bg_flags & BG_IS_TRANSPARENT)	1071	if (bg_flags & BG_IS_TRANSPARENT)
1342	{	1072	{
1343	/* we need to re-generate transparency pixmap in that case ! */	1073	/* we need to re-generate transparency pixmap in that case ! */
1344	tr_flags = make_transparency_pixmap ();	1074	transparent = make_transparency_pixmap ();
1345	if (tr_flags == 0)	1075	if (transparent)
1346	return false;
1347	bg_flags \|= BG_IS_VALID;	1076	bg_flags \|= BG_IS_VALID;
1348	}	1077	}
1349	# endif	1078	# endif
1350		1079
1351	# ifdef BG_IMAGE_FROM_FILE	1080	# ifdef BG_IMAGE_FROM_FILE
1352	if ((bg_flags & BG_IS_FROM_FILE)	1081	if (bg_flags & BG_IS_FROM_FILE)
1353	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1354	{	1082	{
1355	if (render_image (tr_flags))	1083	if (render_image (transparent))
1356	bg_flags \|= BG_IS_VALID;	1084	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	}	1085	}
1386	# endif	1086	# endif
1387		1087
1388	if (!(bg_flags & BG_IS_VALID))	1088	if (!(bg_flags & BG_IS_VALID))
1389	{	1089	{
…		…
1426	#endif	1126	#endif
1427	}	1127	}
1428		1128
1429	#endif /* HAVE_BG_PIXMAP */	1129	#endif /* HAVE_BG_PIXMAP */
1430		1130
1431	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1131	#ifdef ENABLE_TRANSPARENCY
1432	/* based on code from aterm-0.4.2 */	1132	/* based on code from aterm-0.4.2 */
1433		1133
1434	static inline void	1134	static inline void
1435	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)	1135	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
1436	{	1136	{
…		…
1582	}	1282	}
1583	}	1283	}
1584		1284
1585	free (lookup);	1285	free (lookup);
1586	}	1286	}
1587	#endif /* defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE) */	1287	#endif /* ENABLE_TRANSPARENCY */

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.185 by sf-exg, Mon Dec 26 14:53:56 2011 UTC vs. Revision 1.206 by sf-exg, Thu Apr 12 10:22:50 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.185 by sf-exg, Mon Dec 26 14:53:56 2011 UTC vs.
Revision 1.206 by sf-exg, Thu Apr 12 10:22:50 2012 UTC