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

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.157 by sf-exg, Tue Aug 9 21:48:00 2011 UTC vs.
Revision 1.196 by sf-exg, Tue Jan 10 18:50:14 2012 UTC

…		…
32		32
33	#ifndef FilterConvolution	33	#ifndef FilterConvolution
34	#define FilterConvolution "convolution"	34	#define FilterConvolution "convolution"
35	#endif	35	#endif
36		36
37	/*	37	#ifndef RepeatPad
38	* Pixmap geometry string interpretation :	38	#define RepeatPad True
39	* Each geometry string contains zero or one scale/position	39	#endif
40	* adjustment and may optionally be followed by a colon and one or more
41	* colon-delimited pixmap operations.
42	* The following table shows the valid geometry strings and their
43	* effects on the background image :
44	*
45	* WxH+X+Y Set scaling to W% by H%, and position to X% by Y%.
46	* W and H are percentages of the terminal window size.
47	* X and Y are also percentages; e.g., +50+50 centers
48	* the image in the window.
49	*
50	* Pixmap Operations : (should be prepended by a colon)
51	* tile Tile image. Scaling/position modifiers above will affect
52	* the tile size and origin.
53	* propscale When scaling, scale proportionally. That is, maintain the
54	* proper aspect ratio for the image. Any portion of the
55	* background not covered by the image is filled with the
56	* current background color.
57	* hscale Scale horizontally, tile vertically ?
58	* vscale Tile horizontally, scale vertically ?
59	* scale Scale both up and down
60	*/
61		40
62	#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
63	void	60	void
64	rxvt_term::bg_destroy ()	61	rxvt_term::bg_destroy ()
65	{	62	{
66	#ifdef HAVE_AFTERIMAGE	63	#ifdef HAVE_AFTERIMAGE
67	if (original_asim)	64	if (original_asim)
…		…
175	int smaller = min (image_size, window_size);	172	int smaller = min (image_size, window_size);
176		173
177	if (align >= 0 && align <= 100)	174	if (align >= 0 && align <= 100)
178	return diff * align / 100;	175	return diff * align / 100;
179	else if (align > 100 && align <= 200)	176	else if (align > 100 && align <= 200)
180	return ((align - 100) * smaller / 100) + window_size - smaller;	177	return (align - 100) * smaller / 100 + window_size - smaller;
181	else if (align >= -100 && align < 0)	178	else if (align >= -100 && align < 0)
182	return ((align + 100) * smaller / 100) - image_size;	179	return (align + 100) * smaller / 100 - image_size;
183	return 0;	180	return 0;
184	}	181	}
185		182
186	static inline int	183	static inline int
187	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)	184	make_clip_rectangle (int pos, int size, int target_size, int &dst_pos, int &dst_size)
…		…
206	{	203	{
207	bool changed = false;	204	bool changed = false;
208	int geom_flags = 0;	205	int geom_flags = 0;
209	int x = 0, y = 0;	206	int x = 0, y = 0;
210	unsigned int w = 0, h = 0;	207	unsigned int w = 0, h = 0;
211	unsigned int n;	208	unsigned long new_flags = 0;
212	unsigned long new_flags = (bg_flags & (~BG_GEOMETRY_FLAGS));
213	const char *ops;
214		209
215	if (geom == NULL)	210	if (geom == NULL)
216	return false;	211	return false;
217		212
218	char str[256];	213	if (geom[0])
219
220	ops = strchr (geom, ':');
221	if (ops == NULL)
222	n = strlen (geom);
223	else
224	n = ops - geom;
225
226	if (n >= sizeof (str))
227	return false;
228
229	memcpy (str, geom, n);
230	str[n] = '\0';
231	rxvt_strtrim (str);
232
233	if (str[0])
234	{	214	{
235	/* we have geometry string - let's handle it prior to applying ops */	215	char **arr = rxvt_strsplit (':', geom);
		216
		217	for (int i = 0; arr[i]; i++)
		218	{
		219	if (!strcasecmp (arr[i], "style=tiled"))
		220	{
		221	new_flags = BG_TILE;
		222	w = h = noScale;
		223	x = y = 0;
		224	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
		225	}
		226	else if (!strcasecmp (arr[i], "style=aspect-stretched"))
		227	{
		228	new_flags = BG_KEEP_ASPECT;
		229	w = h = windowScale;
		230	x = y = centerAlign;
		231	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
		232	}
		233	else if (!strcasecmp (arr[i], "style=stretched"))
		234	{
		235	new_flags = 0;
		236	w = h = windowScale;
		237	geom_flags = WidthValue\|HeightValue;
		238	}
		239	else if (!strcasecmp (arr[i], "style=centered"))
		240	{
		241	new_flags = 0;
		242	w = h = noScale;
		243	x = y = centerAlign;
		244	geom_flags = WidthValue\|HeightValue\|XValue\|YValue;
		245	}
		246	else if (!strcasecmp (arr[i], "style=root-tiled"))
		247	{
		248	new_flags = BG_TILE\|BG_ROOT_ALIGN;
		249	w = h = noScale;
		250	geom_flags = WidthValue\|HeightValue;
		251	}
		252	else if (!strcasecmp (arr[i], "op=tile"))
		253	new_flags \|= BG_TILE;
		254	else if (!strcasecmp (arr[i], "op=keep-aspect"))
		255	new_flags \|= BG_KEEP_ASPECT;
		256	else if (!strcasecmp (arr[i], "op=root-align"))
		257	new_flags \|= BG_ROOT_ALIGN;
		258
		259	// deprecated
		260	else if (!strcasecmp (arr[i], "tile"))
		261	{
		262	new_flags \|= BG_TILE;
		263	w = h = noScale;
		264	geom_flags \|= WidthValue\|HeightValue;
		265	}
		266	else if (!strcasecmp (arr[i], "propscale"))
		267	{
		268	new_flags \|= BG_KEEP_ASPECT;
		269	w = h = windowScale;
		270	geom_flags \|= WidthValue\|HeightValue;
		271	}
		272	else if (!strcasecmp (arr[i], "hscale"))
		273	{
		274	new_flags \|= BG_TILE;
		275	w = windowScale;
		276	h = noScale;
		277	geom_flags \|= WidthValue\|HeightValue;
		278	}
		279	else if (!strcasecmp (arr[i], "vscale"))
		280	{
		281	new_flags \|= BG_TILE;
		282	h = windowScale;
		283	w = noScale;
		284	geom_flags \|= WidthValue\|HeightValue;
		285	}
		286	else if (!strcasecmp (arr[i], "scale"))
		287	{
		288	w = h = windowScale;
		289	geom_flags \|= WidthValue\|HeightValue;
		290	}
		291	else if (!strcasecmp (arr[i], "auto"))
		292	{
		293	w = h = windowScale;
		294	x = y = centerAlign;
		295	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
		296	}
		297	else if (!strcasecmp (arr[i], "root"))
		298	{
		299	new_flags \|= BG_TILE\|BG_ROOT_ALIGN;
		300	w = h = noScale;
		301	geom_flags \|= WidthValue\|HeightValue;
		302	}
		303
		304	else
236	geom_flags = XParseGeometry (str, &x, &y, &w, &h);	305	geom_flags \|= XParseGeometry (arr[i], &x, &y, &w, &h);
237	} /* done parsing geometry string */	306	} /* done parsing ops */
		307
		308	rxvt_free_strsplit (arr);
		309	}
		310
		311	new_flags \|= bg_flags & ~BG_GEOMETRY_FLAGS;
238		312
239	if (!update)	313	if (!update)
240	{	314	{
241	if (!(geom_flags & XValue))	315	if (!(geom_flags & XValue))
242	x = y = defaultAlign;	316	x = y = defaultAlign;
…		…
251	w = h;	325	w = h;
252		326
253	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;	327	geom_flags \|= WidthValue\|HeightValue\|XValue\|YValue;
254	}	328	}
255		329
256	if (ops)
257	{
258	char **arr = rxvt_strsplit (':', ops + 1);
259
260	for (int i = 0; arr[i]; i++)
261	{
262	if (!strcasecmp (arr[i], "tile"))
263	{
264	new_flags \|= BG_TILE;
265	w = h = noScale;
266	geom_flags \|= WidthValue\|HeightValue;
267	}
268	else if (!strcasecmp (arr[i], "propscale"))
269	{
270	new_flags \|= BG_PROP_SCALE;
271	}
272	else if (!strcasecmp (arr[i], "hscale"))
273	{
274	if (w == 0) w = windowScale;
275
276	h = noScale;
277	geom_flags \|= WidthValue\|HeightValue;
278	}
279	else if (!strcasecmp (arr[i], "vscale"))
280	{
281	if (h == 0) h = windowScale;
282
283	w = noScale;
284	geom_flags \|= WidthValue\|HeightValue;
285	}
286	else if (!strcasecmp (arr[i], "scale"))
287	{
288	if (h == 0) h = windowScale;
289	if (w == 0) w = windowScale;
290
291	geom_flags \|= WidthValue\|HeightValue;
292	}
293	else if (!strcasecmp (arr[i], "root"))
294	{
295	new_flags \|= BG_TILE\|BG_ROOT_ALIGN;
296	w = h = noScale;
297	geom_flags \|= WidthValue\|HeightValue;
298	}
299	} /* done parsing ops */
300
301	rxvt_free_strsplit (arr);
302	}
303
304	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;	330	if (check_set_scale_value (geom_flags, WidthValue, h_scale, w)) changed = true;
305	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;	331	if (check_set_scale_value (geom_flags, HeightValue, v_scale, h)) changed = true;
306	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;	332	if (check_set_align_value (geom_flags, XValue, h_align, x)) changed = true;
307	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;	333	if (check_set_align_value (geom_flags, YValue, v_align, y)) changed = true;
308		334
…		…
319	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)	345	rxvt_term::get_image_geometry (int image_width, int image_height, int &w, int &h, int &x, int &y)
320	{	346	{
321	int target_width = szHint.width;	347	int target_width = szHint.width;
322	int target_height = szHint.height;	348	int target_height = szHint.height;
323		349
		350	w = h_scale * target_width / 100;
		351	h = v_scale * target_height / 100;
		352
324	if (bg_flags & BG_PROP_SCALE)	353	if (bg_flags & BG_KEEP_ASPECT)
325	{	354	{
326	float scale = (float)target_width / image_width;	355	float scale = (float)w / image_width;
327	min_it (scale, (float)target_height / image_height);	356	min_it (scale, (float)h / image_height);
328	w = image_width * scale + 0.5;	357	w = image_width * scale + 0.5;
329	h = image_height * scale + 0.5;	358	h = image_height * scale + 0.5;
330	}	359	}
331	else
332	{
333	w = h_scale * target_width / 100;
334	h = v_scale * target_height / 100;
335	}
336		360
337	if (!w) w = image_width;	361	if (!w) w = image_width;
338	if (!h) h = image_height;	362	if (!h) h = image_height;
339		363
340	if (bg_flags & BG_ROOT_ALIGN)	364	if (bg_flags & BG_ROOT_ALIGN)
…		…
348	y = make_align_position (v_align, target_height, h);	372	y = make_align_position (v_align, target_height, h);
349	}	373	}
350		374
351	bg_flags &= ~BG_IS_SIZE_SENSITIVE;	375	bg_flags &= ~BG_IS_SIZE_SENSITIVE;
352	if (!(bg_flags & BG_TILE)	376	if (!(bg_flags & BG_TILE)
353	\|\| (bg_flags & BG_PROP_SCALE) \|\| h_scale \|\| v_scale	377	\|\| h_scale \|\| v_scale
354	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))	378	\|\| (!(bg_flags & BG_ROOT_ALIGN) && (h_align \|\| v_align))
355	\|\| w > target_width \|\| h > target_height)	379	\|\| w > target_width \|\| h > target_height)
356	bg_flags \|= BG_IS_SIZE_SENSITIVE;	380	bg_flags \|= BG_IS_SIZE_SENSITIVE;
357	}	381	}
358		382
…		…
385	}	409	}
386		410
387	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)	411	if ((tr_flags & BG_NEEDS_BLUR) && background != NULL)
388	{	412	{
389	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,	413	ASImage *tmp = blur_asimage_gauss (asv, background, h_blurRadius, v_blurRadius, 0xFFFFFFFF,
390	(original_asim == NULL \|\| tint == TINT_LEAVE_SAME) ? ASA_XImage : ASA_ASImage,	414	ASA_XImage,
391	100, ASIMAGE_QUALITY_DEFAULT);	415	100, ASIMAGE_QUALITY_DEFAULT);
392	if (tmp)	416	if (tmp)
393	{	417	{
394	destroy_asimage (&background);	418	destroy_asimage (&background);
395	background = tmp;	419	background = tmp;
…		…
414		438
415	if (!original_asim	439	if (!original_asim
416	\|\| (!(bg_flags & BG_ROOT_ALIGN)	440	\|\| (!(bg_flags & BG_ROOT_ALIGN)
417	&& (x >= target_width	441	&& (x >= target_width
418	\|\| y >= target_height	442	\|\| y >= target_height
419	\|\| (x + w <= 0)	443	\|\| x + w <= 0
420	\|\| (y + h <= 0))))	444	\|\| y + h <= 0)))
421	{	445	{
422	if (background)	446	if (background)
423	{	447	{
424	new_pmap_width = background->width;	448	new_pmap_width = background->width;
425	new_pmap_height = background->height;	449	new_pmap_height = background->height;
…		…
439	}	463	}
440	else	464	else
441	{	465	{
442	result = original_asim;	466	result = original_asim;
443		467
444	if ((w != original_asim->width)	468	if (w != original_asim->width
445	\|\| (h != original_asim->height))	469	\|\| h != original_asim->height)
446	{	470	{
447	result = scale_asimage (asv, original_asim,	471	result = scale_asimage (asv, original_asim,
448	w, h,	472	w, h,
449	background ? ASA_ASImage : ASA_XImage,	473	ASA_XImage,
450	100, ASIMAGE_QUALITY_DEFAULT);	474	100, ASIMAGE_QUALITY_DEFAULT);
451	}	475	}
452		476
453	if (background == NULL)	477	if (background == NULL)
454	{	478	{
…		…
704	get_image_geometry (image_width, image_height, w, h, x, y);	728	get_image_geometry (image_width, image_height, w, h, x, y);
705		729
706	if (!(bg_flags & BG_ROOT_ALIGN)	730	if (!(bg_flags & BG_ROOT_ALIGN)
707	&& (x >= target_width	731	&& (x >= target_width
708	\|\| y >= target_height	732	\|\| y >= target_height
709	\|\| (x + w <= 0)	733	\|\| x + w <= 0
710	\|\| (y + h <= 0)))	734	\|\| y + h <= 0))
711	return false;	735	return false;
712		736
713	result = pixbuf;	737	result = pixbuf;
714		738
715	if ((w != image_width)	739	if (w != image_width
716	\|\| (h != image_height))	740	\|\| h != image_height)
717	{	741	{
718	result = gdk_pixbuf_scale_simple (pixbuf,	742	result = gdk_pixbuf_scale_simple (pixbuf,
719	w, h,	743	w, h,
720	GDK_INTERP_BILINEAR);	744	GDK_INTERP_BILINEAR);
721	}	745	}
…		…
800	}	824	}
801		825
802	#if XRENDER	826	#if XRENDER
803	if (tr_flags)	827	if (tr_flags)
804	{	828	{
805	XRenderPictureAttributes pa;
806
807	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, visual);	829	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
		830
808	Picture src = XRenderCreatePicture (dpy, root_pmap, src_format, 0, &pa);	831	Picture src = XRenderCreatePicture (dpy, root_pmap, format, 0, 0);
809		832
810	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
811	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, dst_format, 0, &pa);	833	Picture dst = XRenderCreatePicture (dpy, bg_pixmap, format, 0, 0);
812		834
813	pa.repeat = True;	835	Picture mask = create_xrender_mask (dpy, vt, False, False);
814	Pixmap mask_pmap = XCreatePixmap (dpy, vt, 1, 1, 8);
815	XRenderPictFormat *mask_format = XRenderFindStandardFormat (dpy, PictStandardA8);
816	Picture mask = XRenderCreatePicture (dpy, mask_pmap, mask_format, CPRepeat, &pa);
817	XFreePixmap (dpy, mask_pmap);
818		836
819	XRenderColor mask_c;	837	XRenderColor mask_c;
820		838
821	mask_c.alpha = 0x8000;	839	mask_c.alpha = 0x8000;
822	mask_c.red = 0;	840	mask_c.red =
823	mask_c.green = 0;	841	mask_c.green =
824	mask_c.blue = 0;	842	mask_c.blue = 0;
825	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);	843	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
		844
826	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);	845	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, target_width, target_height);
827		846
828	XRenderFreePicture (dpy, src);	847	XRenderFreePicture (dpy, src);
829	XRenderFreePicture (dpy, dst);	848	XRenderFreePicture (dpy, dst);
830	XRenderFreePicture (dpy, mask);	849	XRenderFreePicture (dpy, mask);
…		…
850	rxvt_term::bg_set_file (const char *file)	869	rxvt_term::bg_set_file (const char *file)
851	{	870	{
852	if (!file \|\| !*file)	871	if (!file \|\| !*file)
853	return false;	872	return false;
854		873
		874	bool ret = false;
855	if (const char *p = strchr (file, ';'))	875	const char *p = strchr (file, ';');
		876
		877	if (p)
856	{	878	{
857	size_t len = p - file;	879	size_t len = p - file;
858	char *f = rxvt_temp_buf<char> (len + 1);	880	char *f = rxvt_temp_buf<char> (len + 1);
859	memcpy (f, file, len);	881	memcpy (f, file, len);
860	f[len] = '\0';	882	f[len] = '\0';
…		…
869	{	891	{
870	if (original_asim)	892	if (original_asim)
871	safe_asimage_destroy (original_asim);	893	safe_asimage_destroy (original_asim);
872	original_asim = image;	894	original_asim = image;
873	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;	895	bg_flags \|= BG_IS_FROM_FILE \| BG_CLIENT_RENDER;
874	return true;	896	ret = true;
875	}	897	}
876	# endif	898	# endif
877		899
878	# ifdef HAVE_PIXBUF	900	# ifdef HAVE_PIXBUF
879	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);	901	GdkPixbuf *image = gdk_pixbuf_new_from_file (file, NULL);
…		…
881	{	903	{
882	if (pixbuf)	904	if (pixbuf)
883	g_object_unref (pixbuf);	905	g_object_unref (pixbuf);
884	pixbuf = image;	906	pixbuf = image;
885	bg_flags \|= BG_IS_FROM_FILE;	907	bg_flags \|= BG_IS_FROM_FILE;
886	return true;	908	ret = true;
887	}	909	}
888	# endif	910	# endif
889		911
		912	if (ret)
		913	{
		914	if (p)
		915	bg_set_geometry (p + 1);
		916	else
		917	bg_set_default_geometry ();
		918	}
		919
890	return false;	920	return ret;
891	}	921	}
892		922
893	# endif /* BG_IMAGE_FROM_FILE */	923	# endif /* BG_IMAGE_FROM_FILE */
894		924
895	# ifdef ENABLE_TRANSPARENCY	925	# ifdef ENABLE_TRANSPARENCY
…		…
931	{	961	{
932	changed = true;	962	changed = true;
933	v_blurRadius = vr;	963	v_blurRadius = vr;
934	}	964	}
935		965
936	if (v_blurRadius == 0 && h_blurRadius == 0)	966	if (h_blurRadius == 0 \|\| v_blurRadius == 0)
937	bg_flags &= ~BG_NEEDS_BLUR;	967	bg_flags &= ~BG_NEEDS_BLUR;
938	else	968	else
939	bg_flags \|= BG_NEEDS_BLUR;	969	bg_flags \|= BG_NEEDS_BLUR;
940		970
941	return changed;	971	return changed;
942	}	972	}
943		973
944	void	974	void
945	rxvt_term::set_tint_shade_flags ()	975	rxvt_term::set_tint_shade_flags ()
946	{	976	{
947	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);	977	rgba c;
948	bool has_shade = shade != 100;	978	bool has_shade = shade != 100;
949		979
950	bg_flags &= ~BG_TINT_FLAGS;	980	bg_flags &= ~BG_TINT_FLAGS;
951		981
952	if (bg_flags & BG_TINT_SET)	982	if (bg_flags & BG_TINT_SET)
…		…
978	}	1008	}
979		1009
980	bool	1010	bool
981	rxvt_term::bg_set_shade (const char *shade_str)	1011	rxvt_term::bg_set_shade (const char *shade_str)
982	{	1012	{
983	int new_shade = (shade_str) ? atoi (shade_str) : 100;	1013	int new_shade = atoi (shade_str);
984		1014
985	clamp_it (new_shade, -100, 200);	1015	clamp_it (new_shade, -100, 200);
986	if (new_shade < 0)	1016	if (new_shade < 0)
987	new_shade = 200 - (100 + new_shade);	1017	new_shade = 200 - (100 + new_shade);
988		1018
…		…
1018	params[i+2] = XDoubleToFixed (kernel[i] / sum);	1048	params[i+2] = XDoubleToFixed (kernel[i] / sum);
1019	}	1049	}
1020	#endif	1050	#endif
1021		1051
1022	bool	1052	bool
1023	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height)	1053	rxvt_term::blur_pixmap (Pixmap pixmap, Visual *visual, int width, int height, int depth)
1024	{	1054	{
1025	bool ret = false;	1055	bool ret = false;
1026	#if XRENDER	1056	#if XRENDER
		1057	if (!(bg_flags & BG_HAS_RENDER_CONV))
		1058	return false;
		1059
1027	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;	1060	int size = max (h_blurRadius, v_blurRadius) * 2 + 1;
1028	double kernel = (double )malloc (size * sizeof (double));	1061	double kernel = (double )malloc (size * sizeof (double));
1029	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	1062	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
1030		1063
1031	XRenderPictureAttributes pa;	1064	XRenderPictureAttributes pa;
1032	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1065	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1033		1066
		1067	pa.repeat = RepeatPad;
1034	Picture src = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1068	Picture src = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
		1069	Pixmap tmp = XCreatePixmap (dpy, pixmap, width, height, depth);
1035	Picture dst = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1070	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);
		1071	XFreePixmap (dpy, tmp);
1036		1072
1037	if (kernel && params)	1073	if (kernel && params)
1038	{	1074	{
1039	if (h_blurRadius)
1040	{
1041	size = h_blurRadius * 2 + 1;	1075	size = h_blurRadius * 2 + 1;
1042	get_gaussian_kernel (h_blurRadius, size, kernel, params);	1076	get_gaussian_kernel (h_blurRadius, size, kernel, params);
1043		1077
1044	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1078	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1045	XRenderComposite (dpy,	1079	XRenderComposite (dpy,
1046	PictOpSrc,	1080	PictOpSrc,
1047	src,	1081	src,
1048	None,	1082	None,
1049	dst,	1083	dst,
1050	0, 0,	1084	0, 0,
1051	0, 0,	1085	0, 0,
1052	0, 0,	1086	0, 0,
1053	width, height);	1087	width, height);
1054	}
1055		1088
1056	if (v_blurRadius)	1089	::swap (src, dst);
1057	{	1090
1058	size = v_blurRadius * 2 + 1;	1091	size = v_blurRadius * 2 + 1;
1059	get_gaussian_kernel (v_blurRadius, size, kernel, params);	1092	get_gaussian_kernel (v_blurRadius, size, kernel, params);
1060	::swap (params[0], params[1]);	1093	::swap (params[0], params[1]);
1061		1094
1062	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	1095	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
1063	XRenderComposite (dpy,	1096	XRenderComposite (dpy,
1064	PictOpSrc,	1097	PictOpSrc,
1065	src,	1098	src,
1066	None,	1099	None,
1067	dst,	1100	dst,
1068	0, 0,	1101	0, 0,
1069	0, 0,	1102	0, 0,
1070	0, 0,	1103	0, 0,
1071	width, height);	1104	width, height);
1072	}
1073		1105
1074	ret = true;	1106	ret = true;
1075	}	1107	}
1076		1108
1077	free (kernel);	1109	free (kernel);
…		…
1104	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);	1136	XFillRectangle (dpy, pixmap, gc, 0, 0, width, height);
1105	ret = true;	1137	ret = true;
1106	XFreeGC (dpy, gc);	1138	XFreeGC (dpy, gc);
1107	}	1139	}
1108	}	1140	}
1109	else
1110	{
1111	# if XRENDER	1141	# if XRENDER
		1142	else if (bg_flags & BG_HAS_RENDER)
		1143	{
1112	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);	1144	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
1113		1145
1114	if (bg_flags & BG_TINT_SET)	1146	if (bg_flags & BG_TINT_SET)
1115	tint.get (c);	1147	tint.get (c);
1116		1148
…		…
1125	c.r = c.r * (200 - shade) / 100;	1157	c.r = c.r * (200 - shade) / 100;
1126	c.g = c.g * (200 - shade) / 100;	1158	c.g = c.g * (200 - shade) / 100;
1127	c.b = c.b * (200 - shade) / 100;	1159	c.b = c.b * (200 - shade) / 100;
1128	}	1160	}
1129		1161
1130	XRenderPictFormat *solid_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
1131	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);	1162	XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual);
1132	XRenderPictureAttributes pa;
1133		1163
1134	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, &pa);	1164	Picture back_pic = XRenderCreatePicture (dpy, pixmap, format, 0, 0);
1135		1165
1136	pa.repeat = True;	1166	Picture overlay_pic = create_xrender_mask (dpy, pixmap, True, False);
1137		1167
1138	Pixmap overlay_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);	1168	Picture mask_pic = create_xrender_mask (dpy, pixmap, True, True);
1139	Picture overlay_pic = XRenderCreatePicture (dpy, overlay_pmap, solid_format, CPRepeat, &pa);
1140	XFreePixmap (dpy, overlay_pmap);
1141
1142	pa.component_alpha = True;
1143	Pixmap mask_pmap = XCreatePixmap (dpy, pixmap, 1, 1, 32);
1144	Picture mask_pic = XRenderCreatePicture (dpy, mask_pmap, solid_format, CPRepeat \| CPComponentAlpha, &pa);
1145	XFreePixmap (dpy, mask_pmap);
1146		1169
1147	XRenderColor mask_c;	1170	XRenderColor mask_c;
1148		1171
1149	mask_c.alpha = 0xffff;	1172	mask_c.alpha = 0xffff;
1150	mask_c.red =	1173	mask_c.red =
…		…
1155	mask_c.alpha = 0;	1178	mask_c.alpha = 0;
1156	mask_c.red = 0xffff - c.r;	1179	mask_c.red = 0xffff - c.r;
1157	mask_c.green = 0xffff - c.g;	1180	mask_c.green = 0xffff - c.g;
1158	mask_c.blue = 0xffff - c.b;	1181	mask_c.blue = 0xffff - c.b;
1159	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);	1182	XRenderFillRectangle (dpy, PictOpSrc, mask_pic, &mask_c, 0, 0, 1, 1);
		1183
1160	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);	1184	XRenderComposite (dpy, PictOpOver, overlay_pic, mask_pic, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1161		1185
1162	if (shade > 100)	1186	if (shade > 100)
1163	{	1187	{
1164	mask_c.red = mask_c.green = mask_c.blue = 0xffff * (shade - 100) / 100;
1165	mask_c.alpha = 0;	1188	mask_c.alpha = 0;
		1189	mask_c.red =
		1190	mask_c.green =
		1191	mask_c.blue = 0xffff * (shade - 100) / 100;
1166	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);	1192	XRenderFillRectangle (dpy, PictOpSrc, overlay_pic, &mask_c, 0, 0, 1, 1);
1167		1193
1168	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);	1194	XRenderComposite (dpy, PictOpOver, overlay_pic, None, back_pic, 0, 0, 0, 0, 0, 0, width, height);
1169	}	1195	}
1170		1196
1171	ret = true;	1197	ret = true;
1172		1198
1173	XRenderFreePicture (dpy, mask_pic);	1199	XRenderFreePicture (dpy, mask_pic);
1174	XRenderFreePicture (dpy, overlay_pic);	1200	XRenderFreePicture (dpy, overlay_pic);
1175	XRenderFreePicture (dpy, back_pic);	1201	XRenderFreePicture (dpy, back_pic);
		1202	}
1176	# endif	1203	# endif
1177	}
1178		1204
1179	return ret;	1205	return ret;
1180	}	1206	}
1181		1207
1182	/*	1208	/*
…		…
1233	#if XRENDER	1259	#if XRENDER
1234	if (bg_flags & BG_HAS_RENDER)	1260	if (bg_flags & BG_HAS_RENDER)
1235	{	1261	{
1236	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);	1262	recoded_root_pmap = XCreatePixmap (dpy, vt, root_pmap_width, root_pmap_height, depth);
1237		1263
1238	XRenderPictureAttributes pa;
1239
1240	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));	1264	XRenderPictFormat *src_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
1241	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, &pa);	1265	Picture src = XRenderCreatePicture (dpy, root_pixmap, src_format, 0, 0);
1242		1266
1243	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);	1267	XRenderPictFormat *dst_format = XRenderFindVisualFormat (dpy, visual);
1244	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, &pa);	1268	Picture dst = XRenderCreatePicture (dpy, recoded_root_pmap, dst_format, 0, 0);
1245		1269
1246	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);	1270	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, root_pmap_width, root_pmap_height);
1247		1271
1248	XRenderFreePicture (dpy, src);	1272	XRenderFreePicture (dpy, src);
1249	XRenderFreePicture (dpy, dst);	1273	XRenderFreePicture (dpy, dst);
…		…
1266	bg_pmap_width = window_width;	1290	bg_pmap_width = window_width;
1267	bg_pmap_height = window_height;	1291	bg_pmap_height = window_height;
1268	}	1292	}
1269		1293
1270	/* straightforward pixmap copy */	1294	/* straightforward pixmap copy */
1271	while (sx < 0) sx += root_width;	1295	while (sx < 0) sx += root_pmap_width;
1272	while (sy < 0) sy += root_height;	1296	while (sy < 0) sy += root_pmap_height;
1273		1297
1274	gcv.tile = recoded_root_pmap;	1298	gcv.tile = recoded_root_pmap;
1275	gcv.fill_style = FillTiled;	1299	gcv.fill_style = FillTiled;
1276	gcv.ts_x_origin = -sx;	1300	gcv.ts_x_origin = -sx;
1277	gcv.ts_y_origin = -sy;	1301	gcv.ts_y_origin = -sy;
…		…
1279		1303
1280	if (gc)	1304	if (gc)
1281	{	1305	{
1282	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);	1306	XFillRectangle (dpy, bg_pixmap, gc, 0, 0, window_width, window_height);
1283	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);	1307	result \|= BG_IS_VALID \| (bg_flags & BG_EFFECTS_FLAGS);
1284	XFreeGC (dpy, gc);
1285		1308
1286	if (!(bg_flags & BG_CLIENT_RENDER))	1309	if (!(bg_flags & BG_CLIENT_RENDER))
1287	{	1310	{
1288	if ((bg_flags & BG_NEEDS_BLUR)	1311	if (bg_flags & BG_NEEDS_BLUR)
1289	&& (bg_flags & BG_HAS_RENDER_CONV))
1290	{	1312	{
1291	if (blur_pixmap (bg_pixmap, visual, window_width, window_height))	1313	if (blur_pixmap (bg_pixmap, visual, window_width, window_height, depth))
1292	result &= ~BG_NEEDS_BLUR;	1314	result &= ~BG_NEEDS_BLUR;
1293	}	1315	}
1294	if ((bg_flags & BG_NEEDS_TINT)	1316	if (bg_flags & BG_NEEDS_TINT)
1295	&& (bg_flags & (BG_TINT_BITAND \| BG_HAS_RENDER)))
1296	{	1317	{
1297	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))	1318	if (tint_pixmap (bg_pixmap, visual, window_width, window_height))
1298	result &= ~BG_NEEDS_TINT;	1319	result &= ~BG_NEEDS_TINT;
1299	}	1320	}
		1321	# ifndef HAVE_AFTERIMAGE
		1322	if (result & BG_NEEDS_TINT)
		1323	{
		1324	XImage *ximage = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
		1325	if (ximage)
		1326	{
		1327	/* our own client-side tinting */
		1328	tint_ximage (DefaultVisual (dpy, display->screen), ximage);
		1329
		1330	XPutImage (dpy, bg_pixmap, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);
		1331	XDestroyImage (ximage);
		1332	}
		1333	}
		1334	# endif
1300	} /* server side rendering completed */	1335	} /* server side rendering completed */
		1336
		1337	XFreeGC (dpy, gc);
1301	}	1338	}
1302		1339
1303	if (recoded_root_pmap != root_pixmap)	1340	if (recoded_root_pmap != root_pixmap)
1304	XFreePixmap (dpy, recoded_root_pmap);	1341	XFreePixmap (dpy, recoded_root_pmap);
1305		1342
…		…
1314	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);	1351	new_root_pixmap = get_pixmap_property (xa[XA_ESETROOT_PMAP_ID]);
1315		1352
1316	root_pixmap = new_root_pixmap;	1353	root_pixmap = new_root_pixmap;
1317	}	1354	}
1318	# endif /* ENABLE_TRANSPARENCY */	1355	# endif /* ENABLE_TRANSPARENCY */
1319
1320	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1321	static void shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c);
1322	# endif
1323		1356
1324	bool	1357	bool
1325	rxvt_term::bg_render ()	1358	rxvt_term::bg_render ()
1326	{	1359	{
1327	unsigned long tr_flags = 0;	1360	unsigned long tr_flags = 0;
…		…
1332	{	1365	{
1333	/* we need to re-generate transparency pixmap in that case ! */	1366	/* we need to re-generate transparency pixmap in that case ! */
1334	tr_flags = make_transparency_pixmap ();	1367	tr_flags = make_transparency_pixmap ();
1335	if (tr_flags == 0)	1368	if (tr_flags == 0)
1336	return false;	1369	return false;
1337	else if (!(tr_flags & BG_EFFECTS_FLAGS))
1338	bg_flags \|= BG_IS_VALID;	1370	bg_flags \|= BG_IS_VALID;
1339	}	1371	}
1340	# endif	1372	# endif
1341		1373
1342	# ifdef BG_IMAGE_FROM_FILE	1374	# ifdef BG_IMAGE_FROM_FILE
1343	if ((bg_flags & BG_IS_FROM_FILE)	1375	if ((bg_flags & BG_IS_FROM_FILE)
1344	\|\| (tr_flags & BG_EFFECTS_FLAGS))	1376	\|\| (tr_flags & BG_EFFECTS_FLAGS))
1345	{	1377	{
1346	if (render_image (tr_flags))	1378	if (render_image (tr_flags))
1347	bg_flags \|= BG_IS_VALID;	1379	bg_flags \|= BG_IS_VALID;
1348	}
1349	# endif
1350
1351	# if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1352	XImage *result = NULL;
1353
1354	if (tr_flags && !(bg_flags & BG_IS_VALID))
1355	{
1356	result = XGetImage (dpy, bg_pixmap, 0, 0, bg_pmap_width, bg_pmap_height, AllPlanes, ZPixmap);
1357	}
1358
1359	if (result)
1360	{
1361	/* our own client-side tinting */
1362	if (tr_flags & BG_NEEDS_TINT)
1363	{
1364	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
1365	if (bg_flags & BG_TINT_SET)
1366	tint.get (c);
1367	shade_ximage (DefaultVisual (dpy, display->screen), result, shade, c);
1368	}
1369
1370	GC gc = XCreateGC (dpy, vt, 0UL, NULL);
1371
1372	if (gc)
1373	{
1374	XPutImage (dpy, bg_pixmap, gc, result, 0, 0, 0, 0, result->width, result->height);
1375
1376	XFreeGC (dpy, gc);
1377	bg_flags \|= BG_IS_VALID;
1378	}
1379
1380	XDestroyImage (result);
1381	}	1380	}
1382	# endif	1381	# endif
1383		1382
1384	if (!(bg_flags & BG_IS_VALID))	1383	if (!(bg_flags & BG_IS_VALID))
1385	{	1384	{
…		…
1423	}	1422	}
1424		1423
1425	#endif /* HAVE_BG_PIXMAP */	1424	#endif /* HAVE_BG_PIXMAP */
1426		1425
1427	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)	1426	#if defined(ENABLE_TRANSPARENCY) && !defined(HAVE_AFTERIMAGE)
1428	/* taken from aterm-0.4.2 */	1427	/* based on code from aterm-0.4.2 */
1429		1428
1430	static void	1429	static inline void
1431	shade_ximage (Visual visual, XImage ximage, int shade, const rgba &c)	1430	fill_lut (uint32_t *lookup, uint32_t mask, int sh, unsigned short low, unsigned short high)
		1431	{
		1432	for (int i = 0; i <= mask >> sh; i++)
		1433	{
		1434	uint32_t tmp;
		1435	tmp = i * high;
		1436	tmp += (mask >> sh) * low;
		1437	lookup[i] = (tmp / 0xffff) << sh;
		1438	}
		1439	}
		1440
		1441	void
		1442	rxvt_term::tint_ximage (Visual visual, XImage ximage)
1432	{	1443	{
1433	int sh_r, sh_g, sh_b;	1444	int sh_r, sh_g, sh_b;
1434	uint32_t mask_r, mask_g, mask_b;	1445	uint32_t mask_r, mask_g, mask_b;
1435	uint32_t lookup, lookup_r, lookup_g, lookup_b;	1446	uint32_t lookup, lookup_r, lookup_g, lookup_b;
1436	rgba low;	1447	unsigned short low;
1437	rgba high;
1438	int i;
1439	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	1448	int host_byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
1440		1449
1441	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;	1450	if (visual->c_class != TrueColor \|\| ximage->format != ZPixmap) return;
1442		1451
1443	/* for convenience */	1452	/* for convenience */
…		…
1502	break;	1511	break;
1503	default:	1512	default:
1504	return; /* we do not support this color depth */	1513	return; /* we do not support this color depth */
1505	}	1514	}
1506		1515
		1516	rgba c (rgba::MAX_CC, rgba::MAX_CC, rgba::MAX_CC);
		1517
		1518	if (bg_flags & BG_TINT_SET)
		1519	tint.get (c);
		1520
1507	/* prepare limits for color transformation (each channel is handled separately) */	1521	/* prepare limits for color transformation (each channel is handled separately) */
1508	if (shade > 100)	1522	if (shade > 100)
1509	{	1523	{
1510	shade = 200 - shade;
1511
1512	high.r = c.r * shade / 100;
1513	high.g = c.g * shade / 100;
1514	high.b = c.b * shade / 100;
1515
1516	low.r = 65535 * (100 - shade) / 100;	1524	c.r = c.r * (200 - shade) / 100;
1517	low.g = 65535 * (100 - shade) / 100;	1525	c.g = c.g * (200 - shade) / 100;
1518	low.b = 65535 * (100 - shade) / 100;	1526	c.b = c.b * (200 - shade) / 100;
		1527
		1528	low = 0xffff * (shade - 100) / 100;
1519	}	1529	}
1520	else	1530	else
1521	{	1531	{
1522	high.r = c.r * shade / 100;	1532	c.r = c.r * shade / 100;
1523	high.g = c.g * shade / 100;	1533	c.g = c.g * shade / 100;
1524	high.b = c.b * shade / 100;	1534	c.b = c.b * shade / 100;
1525		1535
1526	low.r = low.g = low.b = 0;	1536	low = 0;
1527	}	1537	}
1528		1538
1529	/* fill our lookup tables */	1539	/* fill our lookup tables */
1530	for (i = 0; i <= mask_r>>sh_r; i++)	1540	fill_lut (lookup_r, mask_r, sh_r, low, c.r);
1531	{	1541	fill_lut (lookup_g, mask_g, sh_g, low, c.g);
1532	uint32_t tmp;	1542	fill_lut (lookup_b, mask_b, sh_b, low, c.b);
1533	tmp = i * high.r;
1534	tmp += (mask_r>>sh_r) * low.r;
1535	lookup_r[i] = (tmp/65535)<<sh_r;
1536	}
1537	for (i = 0; i <= mask_g>>sh_g; i++)
1538	{
1539	uint32_t tmp;
1540	tmp = i * high.g;
1541	tmp += (mask_g>>sh_g) * low.g;
1542	lookup_g[i] = (tmp/65535)<<sh_g;
1543	}
1544	for (i = 0; i <= mask_b>>sh_b; i++)
1545	{
1546	uint32_t tmp;
1547	tmp = i * high.b;
1548	tmp += (mask_b>>sh_b) * low.b;
1549	lookup_b[i] = (tmp/65535)<<sh_b;
1550	}
1551		1543
1552	/* apply table to input image (replacing colors by newly calculated ones) */	1544	/* apply table to input image (replacing colors by newly calculated ones) */
1553	if (ximage->bits_per_pixel == 32	1545	if (ximage->bits_per_pixel == 32
1554	&& (ximage->depth == 24 \|\| ximage->depth == 32)	1546	&& (ximage->depth == 24 \|\| ximage->depth == 32)
1555	&& ximage->byte_order == host_byte_order)	1547	&& ximage->byte_order == host_byte_order)

Diff Legend

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

Comparing rxvt-unicode/src/background.C (file contents): Revision 1.157 by sf-exg, Tue Aug 9 21:48:00 2011 UTC vs. Revision 1.196 by sf-exg, Tue Jan 10 18:50:14 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/background.C (file contents):
Revision 1.157 by sf-exg, Tue Aug 9 21:48:00 2011 UTC vs.
Revision 1.196 by sf-exg, Tue Jan 10 18:50:14 2012 UTC