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

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.51 by ayin, Fri Jul 27 14:41:15 2007 UTC vs.
Revision 1.54 by ayin, Thu Aug 2 00:09:54 2007 UTC

…		…
25		25
26	#include "../config.h" /* NECESSARY */	26	#include "../config.h" /* NECESSARY */
27	#include "rxvt.h" /* NECESSARY */	27	#include "rxvt.h" /* NECESSARY */
28		28
29	#ifdef XPM_BACKGROUND	29	#ifdef XPM_BACKGROUND
30
31	#ifndef HAVE_AFTERIMAGE
32	/*
33	* search for FILE in the current working directory, and within the
34	* colon-delimited PATHLIST, adding the file extension EXT if required.
35	*
36	* FILE is either semi-colon or zero terminated
37	*/
38	static char *
39	rxvt_File_search_path (const char pathlist, const char file, const char *ext)
40	{
41	int maxpath, len;
42	const char p, path;
43	char name[256];
44
45	if (!access (file, R_OK)) /* found (plain name) in current directory */
46	return strdup (file);
47
48	/* semi-colon delimited */
49	if ((p = strchr (file, ';')))
50	len = (p - file);
51	else
52	len = strlen (file);
53
54	/* leave room for an extra '/' and trailing '\0' */
55	maxpath = sizeof (name) - (len + (ext ? strlen (ext) : 0) + 2);
56	if (maxpath <= 0)
57	return NULL;
58
59	/* check if we can find it now */
60	strncpy (name, file, len);
61	name[len] = '\0';
62
63	if (!access (name, R_OK))
64	return strdup (name);
65	if (ext)
66	{
67	strcat (name, ext);
68	if (!access (name, R_OK))
69	return strdup (name);
70	}
71	for (path = pathlist; path != NULL && *path != '\0'; path = p)
72	{
73	int n;
74
75	/* colon delimited */
76	if ((p = strchr (path, ':')) == NULL)
77	p = strchr (path, '\0');
78
79	n = (p - path);
80	if (*p != '\0')
81	p++;
82
83	if (n > 0 && n <= maxpath)
84	{
85	strncpy (name, path, n);
86	if (name[n - 1] != '/')
87	name[n++] = '/';
88	name[n] = '\0';
89	strncat (name, file, len);
90
91	if (!access (name, R_OK))
92	return strdup (name);
93	if (ext)
94	{
95	strcat (name, ext);
96	if (!access (name, R_OK))
97	return strdup (name);
98	}
99	}
100	}
101	return NULL;
102	}
103
104	/*
105	* Calculate tiling sizes and increments
106	* At start, p == 0, incr == xpmwidthheight
107	*/
108	static void
109	rxvt_pixmap_incr (unsigned int wh, unsigned int xy, float incr, float p, unsigned int widthheight, unsigned int xpmwidthheight)
110	{
111	unsigned int cwh, cxy;
112	float cincr, cp;
113
114	cp = 0;
115	cincr = (float)xpmwidthheight;
116	cxy = *xy;
117	cwh = *wh;
118	if (cwh == 1)
119	{ /* display one image, no horizontal/vertical scaling */
120	cincr = (float)widthheight;
121	if (xpmwidthheight <= widthheight)
122	{
123	cwh = xpmwidthheight;
124	cxy = (cxy * (widthheight - cwh)) / 100; /* beware! order */
125	cwh += cxy;
126	}
127	else
128	{
129	cxy = 0;
130	cwh = widthheight;
131	}
132	}
133	else if (cwh < 10)
134	{ /* fit WH images across/down screen */
135	cincr *= cwh;
136	cxy = 0;
137	cwh = widthheight;
138	}
139	else
140	{
141	cincr *= 100.0 / cwh;
142	if (cwh < 100)
143	{ /* contract */
144	float pos;
145
146	cwh = (cwh * widthheight) / 100;
147	pos = (float)cxy / 100 * widthheight - (cwh / 2);
148
149	cxy = (widthheight - cwh);
150	if (pos <= 0)
151	cxy = 0;
152	else if (pos < cxy)
153	cxy = (int) pos;
154	cwh += cxy;
155	}
156	else
157	{ /* expand */
158	if (cxy > 0)
159	{ /* position */
160	float pos;
161
162	pos = (float)cxy / 100 * xpmwidthheight - (cincr / 2);
163	cp = xpmwidthheight - cincr;
164	if (pos <= 0)
165	cp = 0;
166	else if (pos < cp)
167	cp = pos;
168	}
169	cxy = 0;
170	cwh = widthheight;
171	}
172	}
173	cincr /= widthheight;
174	*wh = cwh;
175	*xy = cxy;
176	*incr = cincr;
177	*p = cp;
178	}
179	#endif
180		30
181	/*	31	/*
182	* These GEOM strings indicate absolute size/position:	32	* These GEOM strings indicate absolute size/position:
183	* @ `WxH+X+Y'	33	* @ `WxH+X+Y'
184	* @ `WxH+X' -> Y = X	34	* @ `WxH+X' -> Y = X
…		…
382	XCopyArea (dpy, bgPixmap.pixmap, pixmap, gc, x, 0, xpmw - x, y, 0, xpmh - y);	232	XCopyArea (dpy, bgPixmap.pixmap, pixmap, gc, x, 0, xpmw - x, y, 0, xpmh - y);
383	XCopyArea (dpy, bgPixmap.pixmap, pixmap, gc, 0, y, x, xpmh - y, xpmw - x, 0);	233	XCopyArea (dpy, bgPixmap.pixmap, pixmap, gc, 0, y, x, xpmh - y, xpmw - x, 0);
384	XCopyArea (dpy, bgPixmap.pixmap, pixmap, gc, 0, 0, x, y, xpmw - x, xpmh - y);	234	XCopyArea (dpy, bgPixmap.pixmap, pixmap, gc, 0, 0, x, y, xpmw - x, xpmh - y);
385	}	235	}
386	else	236	else
387	#ifdef HAVE_AFTERIMAGE
388	#ifdef ENABLE_TRANSPARENCY	237	#ifdef ENABLE_TRANSPARENCY
389	if (!option(Opt_transparent) \|\| !am_transparent)	238	if (!option(Opt_transparent) \|\| !am_transparent)
390	/* will do that in check_our_parents otherwise */	239	/* will do that in check_our_parents otherwise */
391	#endif	240	#endif
392	{	241	{
…		…
395	{	244	{
396	pixmap = asimage2pixmap(asv, display->root, scaled_im, gc, True);	245	pixmap = asimage2pixmap(asv, display->root, scaled_im, gc, True);
397	destroy_asimage (&scaled_im);	246	destroy_asimage (&scaled_im);
398	}	247	}
399	}	248	}
400	#else /* HAVE_AFTERIMAGE */
401	{
402	float incr, p;
403	Pixmap tmp;
404
405	pixmap = XCreatePixmap (dpy, vt, width, height, depth);
406	/*
407	* horizontal scaling
408	*/
409	rxvt_pixmap_incr (&w, &x, &incr, &p, width, xpmw);
410
411	tmp = XCreatePixmap (dpy, vt, width, xpmh, depth);
412	XFillRectangle (dpy, tmp, gc, 0, 0, width, xpmh);
413
414	for ( /nil / ; x < w; x++, p += incr)
415	{
416	if (p >= xpmw)
417	p = 0;
418
419	/* copy one column from the original pixmap to the tmp pixmap */
420	XCopyArea (dpy, bgPixmap.pixmap, tmp, gc, (int)p, 0, 1, xpmh, (int)x, 0);
421	}
422
423	/*
424	* vertical scaling
425	*/
426	rxvt_pixmap_incr (&h, &y, &incr, &p, height, xpmh);
427
428	if (y > 0)
429	XFillRectangle (dpy, pixmap, gc, 0, 0, width, y);
430
431	if (h < height)
432	XFillRectangle (dpy, pixmap, gc, 0, (int)h, width, height - h + 1);
433
434	for ( /nil / ; y < h; y++, p += incr)
435	{
436	if (p >= xpmh)
437	p = 0;
438
439	/* copy one row from the tmp pixmap to the main pixmap */
440	XCopyArea (dpy, tmp, pixmap, gc, 0, (int)p, width, 1, 0, (int)y);
441	}
442
443	XFreePixmap (dpy, tmp);
444	}
445	#endif /* HAVE_AFTERIMAGE */
446	}	249	}
447		250
448	XSetWindowBackgroundPixmap (dpy, vt, pixmap);	251	XSetWindowBackgroundPixmap (dpy, vt, pixmap);
449		252
450	XFreeGC (dpy, gc);	253	XFreeGC (dpy, gc);
…		…
475	/*	278	/*
476	* we already have the required attributes	279	* we already have the required attributes
477	*/	280	*/
478	/* XGetWindowAttributes (dpy, vt, &attr); */	281	/* XGetWindowAttributes (dpy, vt, &attr); */
479		282
480	#ifdef HAVE_AFTERIMAGE
481	if (asimman == NULL)	283	if (asimman == NULL)
482	asimman = create_generic_imageman(rs[Rs_path]);	284	asimman = create_generic_imageman(rs[Rs_path]);
483	if ((f = strchr (file, ';')) == NULL)	285	if ((f = strchr (file, ';')) == NULL)
484	original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );	286	original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );
485	else	287	else
…		…
495	{	297	{
496	bgPixmap.pixmap = asimage2pixmap (asv, display->root, original_asim, NULL, True);	298	bgPixmap.pixmap = asimage2pixmap (asv, display->root, original_asim, NULL, True);
497	xpmAttr.width = original_asim->width ;	299	xpmAttr.width = original_asim->width ;
498	xpmAttr.height = original_asim->height ;	300	xpmAttr.height = original_asim->height ;
499	}	301	}
500	#else /* HAVE_AFTERIMAGE */
501	xpmAttr.closeness = 30000;
502	xpmAttr.colormap = cmap;
503	xpmAttr.visual = visual;
504	xpmAttr.depth = depth;
505	xpmAttr.valuemask = (XpmCloseness \| XpmColormap \| XpmVisual
506	\| XpmDepth \| XpmSize \| XpmReturnPixels);
507
508	/* search environment variables here too */
509	f = rxvt_File_search_path (rs[Rs_path], file, ".xpm");
510	if (f == NULL
511	\|\| XpmReadFileToPixmap (dpy, display->root, f,
512	&bgPixmap.pixmap, NULL,
513	&xpmAttr))
514	{
515	char *p;
516
517	/* semi-colon delimited */
518	if ((p = strchr (file, ';')) == NULL)
519	p = strchr (file, '\0');
520
521	rxvt_warn ("couldn't load XPM file \"%.*s\", ignoring.\n", (p - file), file);
522	}
523	free (f);
524	#endif /* HAVE_AFTERIMAGE */
525	}	302	}
526		303
527	resize_pixmap ();	304	resize_pixmap ();
528	return bgPixmap.pixmap;	305	return bgPixmap.pixmap;
529	}	306	}
…		…
776	}	553	}
777		554
778	void	555	void
779	rxvt_term::check_our_parents_cb (time_watcher &w)	556	rxvt_term::check_our_parents_cb (time_watcher &w)
780	{	557	{
781	int i, pchanged, aformat, have_pixmap, rootdepth;	558	int i, pchanged, aformat, rootdepth;
782	unsigned long nitems, bytes_after;	559	unsigned long nitems, bytes_after;
783	Atom atype;	560	Atom atype;
784	unsigned char *prop = NULL;	561	unsigned char *prop = NULL;
785	Window root, oldp, *list;	562	Window root, oldp, *list;
786	Pixmap rootpixmap = None;	563	Pixmap rootpixmap = None;
787	XWindowAttributes wattr, wrootattr;	564	XWindowAttributes wattr, wrootattr;
788	int sx, sy;	565	int sx, sy;
789	Window cr;	566	Window cr;
		567	unsigned int rootpixmap_w = 0, rootpixmap_h = 0;
790		568
791	pchanged = 0;	569	pchanged = 0;
792		570
793	if (!option (Opt_transparent))	571	if (!option (Opt_transparent))
794	return /pchanged/; /* Don't try any more */	572	return /pchanged/; /* Don't try any more */
		573
		574	#if 0
		575	struct timeval stv;
		576	gettimeofday (&stv,NULL);
		577	#define PRINT_BACKGROUND_OP_TIME do{ struct timeval tv;gettimeofday (&tv,NULL); tv.tv_sec-= stv.tv_sec;\
		578	fprintf (stderr,"%d: elapsed %ld usec\n",__LINE__,\
		579	tv.tv_sec*1000000+tv.tv_usec-stv.tv_usec );}while(0)
		580	#else
		581	#define PRINT_BACKGROUND_OP_TIME do{}while(0)
		582	#endif
		583
795		584
796	XGetWindowAttributes (dpy, display->root, &wrootattr);	585	XGetWindowAttributes (dpy, display->root, &wrootattr);
797	rootdepth = wrootattr.depth;	586	rootdepth = wrootattr.depth;
798		587
799	XGetWindowAttributes (dpy, parent[0], &wattr);	588	XGetWindowAttributes (dpy, parent[0], &wattr);
…		…
813	/* Get all X ops out of the queue so that our information is up-to-date. */	602	/* Get all X ops out of the queue so that our information is up-to-date. */
814	XSync (dpy, False);	603	XSync (dpy, False);
815		604
816	XTranslateCoordinates (dpy, parent[0], display->root,	605	XTranslateCoordinates (dpy, parent[0], display->root,
817	0, 0, &sx, &sy, &cr);	606	0, 0, &sx, &sy, &cr);
818
819	/* check if we are outside of the visible part of the virtual screen : */	607	/* check if we are outside of the visible part of the virtual screen : */
820	if( sx + (int)szHint.width <= 0 \|\| sy + (int)szHint.height <= 0	608	if( sx + (int)szHint.width <= 0 \|\| sy + (int)szHint.height <= 0
821	\|\| sx >= wrootattr.width \|\| sy >= wrootattr.height )	609	\|\| sx >= wrootattr.width \|\| sy >= wrootattr.height )
822	return /* 0 */ ;	610	return /* 0 */ ;
823	/*	611	/*
…		…
834	i = (xa[XA_ESETROOT_PMAP_ID]	622	i = (xa[XA_ESETROOT_PMAP_ID]
835	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],	623	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],
836	0L, 1L, False, XA_PIXMAP, &atype, &aformat,	624	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
837	&nitems, &bytes_after, &prop) == Success);	625	&nitems, &bytes_after, &prop) == Success);
838		626
		627	/* TODO: the below logic needs to be cleaned up */
839	if (!i \|\| prop == NULL	628	if (!i \|\| prop == NULL
840	#if TINTING	629	#if TINTING
841	\|\| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL	630	\|\| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL
842	#ifdef HAVE_AFTERIMAGE	631	#ifdef HAVE_AFTERIMAGE
843	&& original_asim == NULL && rs[Rs_blurradius] == NULL	632	&& original_asim == NULL && rs[Rs_blurradius] == NULL
844	#endif	633	#endif
845	)	634	)
846	#endif	635	#endif
847	)	636	)
848	have_pixmap = 0;	637	rootpixmap = None;
849	else	638	else
850	{	639	{
851	have_pixmap = 1;	640	int junk;
		641	unsigned int ujunk;
		642	/* root pixmap may be bad - allow a error */
		643	allowedxerror = -1;
852	rootpixmap = (Pixmap )prop;	644	if ((rootpixmap = (Pixmap )prop) != None)
		645	if (!XGetGeometry (dpy, rootpixmap, &root, &junk, &junk, &rootpixmap_w, &rootpixmap_h, &ujunk, &ujunk))
		646	rootpixmap = None;
		647	allowedxerror = 0;
		648	}
		649
		650	if (prop != NULL)
853	XFree (prop);	651	XFree (prop);
854	}
855		652
856	if (have_pixmap)	653	if (rootpixmap != None)
857	{	654	{
858	Bool success = False;	655	Bool success = False;
859	GC gc = NULL;	656	GC gc = NULL;
860	XGCValues gcvalue;	657	XGCValues gcvalue;
861	unsigned int pmap_w = 0, pmap_h = 0;	658	int shade = 100;
		659	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
		660	Bool whole_tint = False, no_tint = True;
862		661
		662	while (sx < 0) sx += (int)wrootattr.width;
		663	while (sy < 0) sy += (int)wrootattr.height;
		664
		665	#if TINTING
		666	if (rs[Rs_shade])
		667	shade = atoi (rs[Rs_shade]);
		668	if (ISSET_PIXCOLOR (Color_tint))
		669	pix_colors_focused [Color_tint].get (c);
		670	#define IS_COMPONENT_WHOLESOME(c) ((c) <=0x000700 \|\| (c)>=0x00f700)
		671	if (shade >= 100)
		672	whole_tint = (IS_COMPONENT_WHOLESOME(c.r)
		673	&& IS_COMPONENT_WHOLESOME(c.g)
		674	&& IS_COMPONENT_WHOLESOME(c.b));
		675	no_tint = (c.r >= 0x00f700 && c.g >= 0x00f700 && c.b >= 0x00f700);
		676	#undef IS_COMPONENT_WHOLESOME
		677	#endif /* TINTING */
		678	/* theer are no performance advantages to reusing same pixmap */
		679	if (pixmap != None)
		680	XFreePixmap (dpy, pixmap);
		681	pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);
		682
		683	#if 0 /* TODO : identify cases where this will be detrimental to performance : */
		684	/* we want to tile root pixmap into our own pixmap in this cases :
		685	* 1) rootpixmap does not cover our window entirely
		686	* 2) whole_tint - we can use server-side tinting or tinting disabled
		687	*/
		688	if ( whole_tint \|\| no_tint \|\| pmap_w < sx + szHint.width \|\| pmap_h < sy + szHint.height)
		689	{
		690	}
		691	#endif
		692	gcvalue.tile = rootpixmap;
		693	gcvalue.fill_style = FillTiled;
		694	gcvalue.ts_x_origin = -sx;
		695	gcvalue.ts_y_origin = -sy;
		696	gc = XCreateGC (dpy, rootpixmap, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcvalue);
		697	XFillRectangle (dpy, pixmap, gc, 0, 0, szHint.width, szHint.height);
		698
		699	#if TINTING
		700	if (whole_tint && !no_tint)
		701	{
		702	/* In this case we can tint image server-side getting significant
		703	* performance improvements, as we eliminate XImage transfer
		704	*/
		705	gcvalue.foreground = Pixel (pix_colors_focused [Color_tint]);
		706	gcvalue.function = GXand;
		707	gcvalue.fill_style = FillSolid;
		708	XChangeGC (dpy, gc, GCFillStyle \| GCForeground \| GCFunction, &gcvalue);
		709	XFillRectangle (dpy, pixmap, gc, 0, 0, szHint.width, szHint.height);
		710	}
		711	#endif
		712	success = True;
863	#ifdef HAVE_AFTERIMAGE	713	#ifdef HAVE_AFTERIMAGE
		714	if (rs[Rs_blurradius] \|\| original_asim != NULL \|\| (!whole_tint && (!no_tint \|\| shade !=100)))
864	{	715	{
865	Pixmap tmp_pmap = None;	716	ARGB32 tint = TINT_LEAVE_SAME;
866	ShadingInfo shade;	717	ASImage *back_im = NULL;
867	ARGB32 tint;
868		718
869	if (get_dpy_drawable_size (dpy, rootpixmap, &pmap_w, &pmap_h))	719	back_im = pixmap2ximage (asv, pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, 100);
		720	if (back_im != NULL)
870	{	721	{
871	int root_x = 0, root_y = 0;	722	if (!whole_tint && (!no_tint \|\| shade !=100))
872
873	shade.shading = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
874	if (ISSET_PIXCOLOR (Color_tint))
875	{	723	{
876	rgba c;	724	ShadingInfo as_shade;
877	pix_colors_focused [Color_tint].get (c);	725	as_shade.shading = shade;
878	shade.tintColor.red = c.r;	726	as_shade.tintColor.red = c.r;
879	shade.tintColor.green = c.g;	727	as_shade.tintColor.green = c.g;
880	shade.tintColor.blue = c.b;	728	as_shade.tintColor.blue = c.b;
		729	tint = shading2tint32 (&as_shade);
881	}	730	}
882	else	731
883	shade.tintColor.red = shade.tintColor.green = shade.tintColor.blue = 0xFFFF;	732	if (rs[Rs_blurradius] && back_im)
884	tint = shading2tint32 (&shade);
885	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
886	if (get_dpy_window_position (dpy, display->root, parent[0], NULL, NULL, &root_x, &root_y))
887	{	733	{
		734	ASImage* tmp;
		735	int junk;
		736	unsigned int hr = 1, vr = 1;
		737	int flags = XParseGeometry (rs[Rs_blurradius], &junk, &junk, &hr, &vr);
		738	if (!(flags&WidthValue))
		739	hr = 1;
		740	if (!(flags&HeightValue))
		741	vr = hr;
		742	tmp = blur_asimage_gauss (asv, back_im, hr, vr, 0xFFFFFFFF,
		743	(original_asim == NULL \|\| tint == TINT_LEAVE_SAME)?ASA_XImage:ASA_ASImage,
		744	100, ASIMAGE_QUALITY_DEFAULT);
		745	if (tmp)
		746	{
		747	destroy_asimage (&back_im);
		748	back_im = tmp;
		749	}
		750	}
		751
		752	if (original_asim != NULL)
		753	{
888	ASImageLayer *layers = create_image_layers (2);	754	ASImageLayer *layers = create_image_layers (2);
889	ASImage *merged_im = NULL;	755	ASImage *merged_im = NULL;
890	int back_x, back_y, back_w, back_h;	756	int fore_w, fore_h;
891	/* merge_layers does good job at tiling background appropriately,
892	so all we need is to cut out smallest possible piece : */
893	#define MAKE_ROOTPMAP_GEOM(xy,wh,widthheight) \
894	do{ while( root_##xy < 0 ) root_##xy += (int)wrootattr.widthheight; \
895	back_##xy = root_##xy % pmap_##wh; /* that gives us left side of the closest tile : */ \
896	if( pmap_##wh >= back_##xy + szHint.widthheight ) \
897	back_##wh = szHint.widthheight;/* background is large - limit it by our size */ \
898	else \
899	{ /* small background - need the whole of it for successfull tiling :*/ \
900	back_##xy = 0; \
901	back_##wh = pmap_##wh; \
902	}}while(0)
903		757
904	MAKE_ROOTPMAP_GEOM(x,w,width);	758	layers[0].im = back_im;
905	MAKE_ROOTPMAP_GEOM(y,h,height);
906
907	layers[0].im = pixmap2asimage (asv, rootpixmap, back_x, back_y, back_w, back_h, AllPlanes, ASA_ASImage, 100);
908	layers[0].clip_x = (back_w == pmap_w)?root_x:0;
909	layers[0].clip_y = (back_h == pmap_h)?root_y:0;
910	layers[0].clip_width = szHint.width;	759	layers[0].clip_width = szHint.width;
911	layers[0].clip_height = szHint.height;	760	layers[0].clip_height = szHint.height;
912	layers[0].tint = tint;	761	layers[0].tint = tint;
913	if (rs[Rs_blurradius] && layers[0].im)
914	{
915	double r = atof(rs[Rs_blurradius]);
916	ASImage* tmp = blur_asimage_gauss (asv, layers[0].im, r, r, 0xFFFFFFFF, ASA_ASImage, 100, ASIMAGE_QUALITY_DEFAULT);
917	if (tmp)
918	{
919	destroy_asimage (&layers[0].im);
920	layers[0].im = tmp;
921	}
922	}
923	if (original_asim != NULL)
924	{
925	int fore_w, fore_h;
926	layers[1].im = original_asim;	762	layers[1].im = original_asim;
927	if (bgPixmap.auto_resize)	763	if (bgPixmap.auto_resize)
928	{	764	{
929	fore_w = szHint.width;	765	fore_w = szHint.width;
930	fore_h = szHint.height;	766	fore_h = szHint.height;
931	}	767	}
932	else	768	else
933	{	769	{
934	fore_w = bgPixmap.w;	770	fore_w = bgPixmap.w;
935	fore_h = bgPixmap.h;	771	fore_h = bgPixmap.h;
936	}	772	}
937	if (fore_w != original_asim->width	773	if (fore_w != original_asim->width
938	\|\| fore_h != original_asim->height)	774	\|\| fore_h != original_asim->height)
939	{	775	{
940	layers[1].im = scale_asimage (asv,	776	layers[1].im = scale_asimage (asv,
941	original_asim,	777	original_asim,
942	fore_w, fore_h,	778	fore_w, fore_h,
943	ASA_ASImage, 100,	779	ASA_ASImage, 100,
944	ASIMAGE_QUALITY_DEFAULT);	780	ASIMAGE_QUALITY_DEFAULT);
945	}	781	}
946
947	layers[1].clip_width = szHint.width;	782	layers[1].clip_width = szHint.width;
948	layers[1].clip_height = szHint.height;	783	layers[1].clip_height = szHint.height;
949		784
950	if (rs[Rs_blendtype])	785	if (rs[Rs_blendtype])
951	{	786	{
952	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);	787	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
953	if (layers[1].merge_scanlines == NULL)	788	if (layers[1].merge_scanlines == NULL)
954	layers[1].merge_scanlines = alphablend_scanlines;	789	layers[1].merge_scanlines = alphablend_scanlines;
955	}	790	}
956	}	791	PRINT_BACKGROUND_OP_TIME;
957	merged_im = merge_layers (asv, layers, layers[1].im?2:1,	792	merged_im = merge_layers (asv, layers, 2, szHint.width, szHint.height,
958	szHint.width, szHint.height,
959	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);	793	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
960	if (layers[1].im != original_asim)	794	if (layers[1].im != original_asim)
961	destroy_asimage (&(layers[1].im));	795	destroy_asimage (&(layers[1].im));
962	destroy_asimage (&(layers[0].im));	796	free (layers);
		797
963	if (merged_im != NULL)	798	if (merged_im != NULL)
964	{	799	{
965	tmp_pmap = asimage2pixmap (asv, DefaultRootWindow(dpy), merged_im, gc, True);
966	destroy_asimage (&merged_im);	800	destroy_asimage (&back_im);
		801	back_im = merged_im;
967	}	802	}
968	free (layers);	803	PRINT_BACKGROUND_OP_TIME;
969	}	804	}
		805	else if (tint != TINT_LEAVE_SAME)
		806	{
		807	ASImage* tmp = tile_asimage (asv, back_im, 0, 0, szHint.width, szHint.height, tint, ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
		808	if (tmp)
		809	{
		810	destroy_asimage (&back_im);
		811	back_im = tmp;
		812	}
		813	PRINT_BACKGROUND_OP_TIME;
		814	}
		815	asimage2drawable (asv, pixmap, back_im, gc, 0, 0, 0, 0, szHint.width, szHint.height, True);
		816	destroy_asimage (&back_im);
		817	} /* back_im != NULL */
		818	else
		819	success = False;
970	}	820	}
971	if (tmp_pmap != None)
972	{
973	success = True;
974	if (pixmap != None)
975	XFreePixmap (dpy, pixmap);
976	pixmap = tmp_pmap;
977	}
978	}
979	#else /* HAVE_AFTERIMAGE */	821	#else /* HAVE_AFTERIMAGE */
980	{
981	/*
982	* Copy display->root pixmap transparency
983	*/
984	Window wjunk;
985	int junk;
986	unsigned int ujunk;
987	/* root pixmap may be bad - allow a error */
988	allowedxerror = -1;
989	if (XGetGeometry (dpy, rootpixmap, &wjunk, &junk, &junk, &pmap_w, &pmap_h, &ujunk, &ujunk))
990	{
991	XImage *image = NULL;
992	int shade = 100;
993	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
994	Bool whole_tint = False;
995
996	while (sx < 0) sx += (int)wrootattr.width;
997	while (sy < 0) sy += (int)wrootattr.height;
998
999	if (pixmap != None)
1000	XFreePixmap (dpy, pixmap);
1001	pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);
1002
1003	#if TINTING	822	#if TINTING
1004	if (rs[Rs_shade])	823	if (!whole_tint && (!no_tint \|\| shade !=100))
1005	shade = atoi (rs[Rs_shade]);
1006	if (ISSET_PIXCOLOR (Color_tint))
1007	pix_colors_focused [Color_tint].get (c);
1008	#define IS_COMPONENT_WHOLESOME(c) ((c) <=0x000700 \|\| (c)>=0x00f700)
1009	if (shade >= 100)
1010	whole_tint = (IS_COMPONENT_WHOLESOME(c.r)
1011	&& IS_COMPONENT_WHOLESOME(c.g)
1012	&& IS_COMPONENT_WHOLESOME(c.b));
1013	#undef IS_COMPONENT_WHOLESOME
1014
1015	/* If No tinting to be done - simply tile root pixmap on our pixmap -
1016	* no need in XImage at all, thus following if() only for case with tinting */
1017	if (whole_tint \|\| pmap_w < sx + szHint.width \|\| pmap_h < sy + szHint.height)
1018	#endif /* TINTING */
1019	{	824	{
1020	gcvalue.tile = rootpixmap;
1021	gcvalue.fill_style = FillTiled;
1022	gcvalue.ts_x_origin = -sx;
1023	gcvalue.ts_y_origin = -sy;
1024	gc = XCreateGC (dpy, rootpixmap, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcvalue);
1025	XFillRectangle (dpy, pixmap, gc, 0, 0, szHint.width, szHint.height);
1026	#if TINTING
1027	if (whole_tint)
1028	{
1029	/* In this case we can tint image server-side getting significant
1030	* performance improvements, as we eliminate XImage transfer
1031	*/
1032	gcvalue.foreground = Pixel (pix_colors_focused [Color_tint]);
1033	gcvalue.function = GXand;
1034	gcvalue.fill_style = FillSolid;
1035	XChangeGC (dpy, gc, GCFillStyle \| GCForeground \| GCFunction, &gcvalue);
1036	XFillRectangle (dpy, pixmap, gc, 0, 0, szHint.width, szHint.height);
1037	success = True;
1038	}
1039	else
1040	image = XGetImage (dpy, pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);	825	XImage *image = XGetImage (dpy, pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);
1041	#else
1042	success = True;	826	success = False;
1043	#endif /* TINTING */
1044	}
1045	#if TINTING
1046	if (!success && image == NULL)
1047	image = XGetImage (dpy, rootpixmap, sx, sy, szHint.width, szHint.height, AllPlanes, ZPixmap);
1048	if (image != NULL)	827	if (image != NULL)
1049	{	828	{
		829	PRINT_BACKGROUND_OP_TIME;
1050	if (gc == NULL)	830	if (gc == NULL)
1051	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);	831	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
1052	if (ISSET_PIXCOLOR (Color_tint) \|\| shade != 100)	832	if (ISSET_PIXCOLOR (Color_tint) \|\| shade != 100)
1053	ShadeXImage (this, image, shade, c.r, c.g, c.b);	833	ShadeXImage (this, image, shade, c.r, c.g, c.b);
1054	XPutImage (dpy, pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);	834	XPutImage (dpy, pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);
1055	XDestroyImage (image);	835	XDestroyImage (image);
1056	success = True;	836	success = True;
1057	}	837	}
1058	#endif
1059	}	838	}
1060	allowedxerror = 0;	839	#endif
1061	}
1062	#endif /* HAVE_AFTERIMAGE */	840	#endif /* HAVE_AFTERIMAGE */
		841	PRINT_BACKGROUND_OP_TIME;
		842
1063	if (gc != NULL)	843	if (gc != NULL)
1064	XFreeGC (dpy, gc);	844	XFreeGC (dpy, gc);
1065		845
1066	if (!success)	846	if (!success)
1067	{	847	{
…		…
1085	if (!am_transparent \|\| !am_pixmap_trans)	865	if (!am_transparent \|\| !am_pixmap_trans)
1086	pchanged = 1;	866	pchanged = 1;
1087		867
1088	am_transparent = am_pixmap_trans = 1;	868	am_transparent = am_pixmap_trans = 1;
1089	}	869	}
1090	}	870	} /* rootpixmap != None */
1091		871
1092	if (am_pixmap_trans)	872	if (am_pixmap_trans)
1093	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);	873	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
1094	else	874	else
1095	{	875	{

Diff Legend

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

Comparing rxvt-unicode/src/xpm.C (file contents): Revision 1.51 by ayin, Fri Jul 27 14:41:15 2007 UTC vs. Revision 1.54 by ayin, Thu Aug 2 00:09:54 2007 UTC

Diff Legend

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.51 by ayin, Fri Jul 27 14:41:15 2007 UTC vs.
Revision 1.54 by ayin, Thu Aug 2 00:09:54 2007 UTC