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

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.42 by ayin, Wed Jun 27 20:26:15 2007 UTC vs.
Revision 1.52 by sasha, Fri Jul 27 22:52:08 2007 UTC

…		…
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		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
31	static void rxvt_pixmap_incr (unsigned int wh, unsigned int xy, float incr, float p, unsigned int widthheight, unsigned int xpmwidthheight);	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
32		180
33	/*	181	/*
34	* These GEOM strings indicate absolute size/position:	182	* These GEOM strings indicate absolute size/position:
35	* @ `WxH+X+Y'	183	* @ `WxH+X+Y'
36	* @ `WxH+X' -> Y = X	184	* @ `WxH+X' -> Y = X
…		…
83	if (n < MAXLEN_GEOM)	231	if (n < MAXLEN_GEOM)
84	{	232	{
85	strncpy (str, geom, n);	233	strncpy (str, geom, n);
86	str[n] = '\0';	234	str[n] = '\0';
87		235
88	if (strcmp(str, "auto") == 0)	236	if (strcmp(str, "auto") == 0)
89	{	237	{
90	if (!bgpixmap->auto_resize)	238	if (!bgpixmap->auto_resize)
91	changed++;	239	changed++;
92	bgpixmap->auto_resize = True ;	240	bgpixmap->auto_resize = True ;
93	w = szHint.width ;	241	w = szHint.width ;
94	h = szHint.height ;	242	h = szHint.height ;
95	flags = WidthValue\|HeightValue ;	243	flags = WidthValue\|HeightValue ;
96	}	244	}
97	else	245	else
98	{	246	{
99	bgpixmap->auto_resize = False ;	247	bgpixmap->auto_resize = False ;
100	flags = XParseGeometry (str, &x, &y, &w, &h);	248	flags = XParseGeometry (str, &x, &y, &w, &h);
101	}	249	}
102		250
103	if (!flags)	251	if (!flags)
104	{	252	{
…		…
209	unsigned int w = bgPixmap.w, h = bgPixmap.h,	357	unsigned int w = bgPixmap.w, h = bgPixmap.h,
210	x = bgPixmap.x, y = bgPixmap.y;	358	x = bgPixmap.x, y = bgPixmap.y;
211	unsigned int xpmh = xpmAttr.height,	359	unsigned int xpmh = xpmAttr.height,
212	xpmw = xpmAttr.width;	360	xpmw = xpmAttr.width;
213		361
214	if (bgPixmap.auto_resize)	362	if (bgPixmap.auto_resize)
215	{	363	{
216	w = szHint.width ;	364	w = szHint.width ;
217	h = szHint.height ;	365	h = szHint.height ;
218	}	366	}
219	/*	367	/*
220	* don't zoom pixmap too much nor expand really small pixmaps	368	* don't zoom pixmap too much nor expand really small pixmaps
221	*/	369	*/
222	if (w > 32767 \|\| h > 32767)	370	if (w > 32767 \|\| h > 32767)
223	w = 1;	371	w = 1;
…		…
240	#ifdef ENABLE_TRANSPARENCY	388	#ifdef ENABLE_TRANSPARENCY
241	if (!option(Opt_transparent) \|\| !am_transparent)	389	if (!option(Opt_transparent) \|\| !am_transparent)
242	/* will do that in check_our_parents otherwise */	390	/* will do that in check_our_parents otherwise */
243	#endif	391	#endif
244	{	392	{
245	ASImage *scaled_im = scale_asimage( display->asv, original_asim, w, h, ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT );	393	ASImage *scaled_im = scale_asimage (asv, original_asim, w, h, ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
246	if (scaled_im)	394	if (scaled_im)
247	{	395	{
248	pixmap = asimage2pixmap( display->asv, display->root, scaled_im, gc, True );	396	pixmap = asimage2pixmap(asv, display->root, scaled_im, gc, True);
249	destroy_asimage( &scaled_im );	397	destroy_asimage (&scaled_im);
250	}	398	}
251	}	399	}
252	#else /* HAVE_AFTERIMAGE */	400	#else /* HAVE_AFTERIMAGE */
253	{	401	{
254	float incr, p;	402	float incr, p;
…		…
303	#ifdef ENABLE_TRANSPARENCY	451	#ifdef ENABLE_TRANSPARENCY
304	am_transparent = 0;	452	am_transparent = 0;
305	#endif	453	#endif
306	}	454	}
307		455
308	/*
309	* Calculate tiling sizes and increments
310	* At start, p == 0, incr == xpmwidthheight
311	*/
312	static void
313	rxvt_pixmap_incr (unsigned int wh, unsigned int xy, float incr, float p, unsigned int widthheight, unsigned int xpmwidthheight)
314	{
315	unsigned int cwh, cxy;
316	float cincr, cp;
317
318	cp = 0;
319	cincr = (float)xpmwidthheight;
320	cxy = *xy;
321	cwh = *wh;
322	if (cwh == 1)
323	{ /* display one image, no horizontal/vertical scaling */
324	cincr = (float)widthheight;
325	if (xpmwidthheight <= widthheight)
326	{
327	cwh = xpmwidthheight;
328	cxy = (cxy * (widthheight - cwh)) / 100; /* beware! order */
329	cwh += cxy;
330	}
331	else
332	{
333	cxy = 0;
334	cwh = widthheight;
335	}
336	}
337	else if (cwh < 10)
338	{ /* fit WH images across/down screen */
339	cincr *= cwh;
340	cxy = 0;
341	cwh = widthheight;
342	}
343	else
344	{
345	cincr *= 100.0 / cwh;
346	if (cwh < 100)
347	{ /* contract */
348	float pos;
349
350	cwh = (cwh * widthheight) / 100;
351	pos = (float)cxy / 100 * widthheight - (cwh / 2);
352
353	cxy = (widthheight - cwh);
354	if (pos <= 0)
355	cxy = 0;
356	else if (pos < cxy)
357	cxy = (int) pos;
358	cwh += cxy;
359	}
360	else
361	{ /* expand */
362	if (cxy > 0)
363	{ /* position */
364	float pos;
365
366	pos = (float)cxy / 100 * xpmwidthheight - (cincr / 2);
367	cp = xpmwidthheight - cincr;
368	if (pos <= 0)
369	cp = 0;
370	else if (pos < cp)
371	cp = pos;
372	}
373	cxy = 0;
374	cwh = widthheight;
375	}
376	}
377	cincr /= widthheight;
378	*wh = cwh;
379	*xy = cxy;
380	*incr = cincr;
381	*p = cp;
382	}
383
384	Pixmap	456	Pixmap
385	rxvt_term::set_bgPixmap (const char *file)	457	rxvt_term::set_bgPixmap (const char *file)
386	{	458	{
387	char *f;	459	char *f;
388		460
…		…
404	* we already have the required attributes	476	* we already have the required attributes
405	*/	477	*/
406	/* XGetWindowAttributes (dpy, vt, &attr); */	478	/* XGetWindowAttributes (dpy, vt, &attr); */
407		479
408	#ifdef HAVE_AFTERIMAGE	480	#ifdef HAVE_AFTERIMAGE
409	if (asimman == NULL)	481	if (asimman == NULL)
410	asimman = create_generic_imageman(rs[Rs_path]);	482	asimman = create_generic_imageman(rs[Rs_path]);
411	if ((f = strchr (file, ';')) == NULL)	483	if ((f = strchr (file, ';')) == NULL)
412	original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );	484	original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );
413	else	485	else
414	{	486	{
415	size_t len = f - file;	487	size_t len = f - file;
416	f = (char *)malloc (len + 1);	488	f = (char *)malloc (len + 1);
417	strncpy (f, file, len);	489	strncpy (f, file, len);
418	f[len] = '\0';	490	f[len] = '\0';
419	original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );	491	original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );
420	free( f );	492	free( f );
421	}	493	}
422	if (original_asim)	494	if (original_asim)
423	{	495	{
424	bgPixmap.pixmap = asimage2pixmap( display->asv, display->root, original_asim, NULL, True );	496	bgPixmap.pixmap = asimage2pixmap (asv, display->root, original_asim, NULL, True);
425	xpmAttr.width = original_asim->width ;	497	xpmAttr.width = original_asim->width ;
426	xpmAttr.height = original_asim->height ;	498	xpmAttr.height = original_asim->height ;
427	}	499	}
428	#else /* HAVE_AFTERIMAGE */	500	#else /* HAVE_AFTERIMAGE */
429	xpmAttr.closeness = 30000;	501	xpmAttr.closeness = 30000;
430	xpmAttr.colormap = cmap;	502	xpmAttr.colormap = cmap;
431	xpmAttr.visual = visual;	503	xpmAttr.visual = visual;
432	xpmAttr.depth = depth;	504	xpmAttr.depth = depth;
433	xpmAttr.valuemask = (XpmCloseness \| XpmColormap \| XpmVisual	505	xpmAttr.valuemask = (XpmCloseness \| XpmColormap \| XpmVisual
434	\| XpmDepth \| XpmSize \| XpmReturnPixels);	506	\| XpmDepth \| XpmSize \| XpmReturnPixels);
435		507
436	/* search environment variables here too */	508	/* search environment variables here too */
437	f = (char *)rxvt_File_find (file, ".xpm", rs[Rs_path]);	509	f = rxvt_File_search_path (rs[Rs_path], file, ".xpm");
438	if (f == NULL	510	if (f == NULL
439	\|\| XpmReadFileToPixmap (dpy, display->root, f,	511	\|\| XpmReadFileToPixmap (dpy, display->root, f,
440	&bgPixmap.pixmap, NULL,	512	&bgPixmap.pixmap, NULL,
441	&xpmAttr))	513	&xpmAttr))
442	{	514	{
…		…
462	#if TINTING && !defined(HAVE_AFTERIMAGE)	534	#if TINTING && !defined(HAVE_AFTERIMAGE)
463	/* taken from aterm-0.4.2 */	535	/* taken from aterm-0.4.2 */
464		536
465	typedef uint32_t RUINT32T;	537	typedef uint32_t RUINT32T;
466		538
		539	static void
467	void ShadeXImage(rxvt_term term, XImage srcImage, int shade, int rm, int gm, int bm)	540	ShadeXImage(rxvt_term term, XImage srcImage, int shade, int rm, int gm, int bm)
468	{	541	{
469	int sh_r, sh_g, sh_b;	542	int sh_r, sh_g, sh_b;
470	RUINT32T mask_r, mask_g, mask_b;	543	RUINT32T mask_r, mask_g, mask_b;
471	RUINT32T lookup, lookup_r, lookup_g, lookup_b;	544	RUINT32T lookup, lookup_r, lookup_g, lookup_b;
472	unsigned int lower_lim_r, lower_lim_g, lower_lim_b;	545	unsigned int lower_lim_r, lower_lim_g, lower_lim_b;
…		…
703	}	776	}
704		777
705	void	778	void
706	rxvt_term::check_our_parents_cb (time_watcher &w)	779	rxvt_term::check_our_parents_cb (time_watcher &w)
707	{	780	{
708	int i, pchanged, aformat, have_pixmap, rootdepth;	781	int i, pchanged, aformat, rootdepth;
709	unsigned long nitems, bytes_after;	782	unsigned long nitems, bytes_after;
710	Atom atype;	783	Atom atype;
711	unsigned char *prop = NULL;	784	unsigned char *prop = NULL;
712	Window root, oldp, *list;	785	Window root, oldp, *list;
713	Pixmap rootpixmap = None;	786	Pixmap rootpixmap = None;
714	XWindowAttributes wattr, wrootattr;	787	XWindowAttributes wattr, wrootattr;
715	int sx, sy;	788	int sx, sy;
716	Window cr;	789	Window cr;
		790	unsigned int rootpixmap_w = 0, rootpixmap_h = 0;
717		791
718	pchanged = 0;	792	pchanged = 0;
719		793
720	if (!option (Opt_transparent))	794	if (!option (Opt_transparent))
721	return /pchanged/; /* Don't try any more */	795	return /pchanged/; /* Don't try any more */
		796
		797	#if 0
		798	struct timeval stv;
		799	gettimeofday (&stv,NULL);
		800	#define PRINT_BACKGROUND_OP_TIME do{ struct timeval tv;gettimeofday (&tv,NULL); tv.tv_sec-= stv.tv_sec;\
		801	fprintf (stderr,"%d: elapsed %ld usec\n",__LINE__,\
		802	tv.tv_sec*1000000+tv.tv_usec-stv.tv_usec );}while(0)
		803	#else
		804	#define PRINT_BACKGROUND_OP_TIME do{}while(0)
		805	#endif
		806
722		807
723	XGetWindowAttributes (dpy, display->root, &wrootattr);	808	XGetWindowAttributes (dpy, display->root, &wrootattr);
724	rootdepth = wrootattr.depth;	809	rootdepth = wrootattr.depth;
725		810
726	XGetWindowAttributes (dpy, parent[0], &wattr);	811	XGetWindowAttributes (dpy, parent[0], &wattr);
…		…
740	/* Get all X ops out of the queue so that our information is up-to-date. */	825	/* Get all X ops out of the queue so that our information is up-to-date. */
741	XSync (dpy, False);	826	XSync (dpy, False);
742		827
743	XTranslateCoordinates (dpy, parent[0], display->root,	828	XTranslateCoordinates (dpy, parent[0], display->root,
744	0, 0, &sx, &sy, &cr);	829	0, 0, &sx, &sy, &cr);
745
746	/* check if we are outside of the visible part of the virtual screen : */	830	/* check if we are outside of the visible part of the virtual screen : */
747	if( sx + (int)szHint.width <= 0 \|\| sy + (int)szHint.height <= 0	831	if( sx + (int)szHint.width <= 0 \|\| sy + (int)szHint.height <= 0
748	\|\| sx >= wrootattr.width \|\| sy >= wrootattr.height )	832	\|\| sx >= wrootattr.width \|\| sy >= wrootattr.height )
749	return /* 0 */ ;	833	return /* 0 */ ;
750	/*	834	/*
751	* Make the frame window set by the window manager have	835	* Make the frame window set by the window manager have
752	* the root background. Some window managers put multiple nested frame	836	* the root background. Some window managers put multiple nested frame
753	* windows for each client, so we have to take care about that.	837	* windows for each client, so we have to take care about that.
…		…
761	i = (xa[XA_ESETROOT_PMAP_ID]	845	i = (xa[XA_ESETROOT_PMAP_ID]
762	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],	846	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],
763	0L, 1L, False, XA_PIXMAP, &atype, &aformat,	847	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
764	&nitems, &bytes_after, &prop) == Success);	848	&nitems, &bytes_after, &prop) == Success);
765		849
		850	/* TODO: the below logic needs to be cleaned up */
766	if (!i \|\| prop == NULL	851	if (!i \|\| prop == NULL
767	#if TINTING	852	#if TINTING
768	\|\| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL	853	\|\| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL
769	#ifdef HAVE_AFTERIMAGE	854	#ifdef HAVE_AFTERIMAGE
770	&& original_asim == NULL && rs[Rs_blurradius] == NULL	855	&& original_asim == NULL && rs[Rs_blurradius] == NULL
771	#endif	856	#endif
772	)	857	)
773	#endif	858	#endif
774	)	859	)
775	have_pixmap = 0;	860	rootpixmap = None;
776	else	861	else
777	{	862	{
778	have_pixmap = 1;	863	int junk;
		864	unsigned int ujunk;
		865	/* root pixmap may be bad - allow a error */
		866	allowedxerror = -1;
779	rootpixmap = (Pixmap )prop;	867	if ((rootpixmap = (Pixmap )prop) != None)
		868	if (!XGetGeometry (dpy, rootpixmap, &root, &junk, &junk, &rootpixmap_w, &rootpixmap_h, &ujunk, &ujunk))
		869	rootpixmap = None;
		870	allowedxerror = 0;
		871	}
		872
		873	if (prop != NULL)
780	XFree (prop);	874	XFree (prop);
		875
		876	if (rootpixmap != None)
781	}	877	{
782
783	if (have_pixmap)
784	{
785	Bool success = False ;	878	Bool success = False;
786	GC gc = NULL;	879	GC gc = NULL;
787	XGCValues gcvalue;	880	XGCValues gcvalue;
		881	int shade = 100;
		882	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
		883	Bool whole_tint = False, no_tint = True;
		884
		885	while (sx < 0) sx += (int)wrootattr.width;
		886	while (sy < 0) sy += (int)wrootattr.height;
		887
		888	#if TINTING
		889	if (rs[Rs_shade])
		890	shade = atoi (rs[Rs_shade]);
		891	if (ISSET_PIXCOLOR (Color_tint))
		892	pix_colors_focused [Color_tint].get (c);
		893	#define IS_COMPONENT_WHOLESOME(c) ((c) <=0x000700 \|\| (c)>=0x00f700)
		894	if (shade >= 100)
		895	whole_tint = (IS_COMPONENT_WHOLESOME(c.r)
		896	&& IS_COMPONENT_WHOLESOME(c.g)
		897	&& IS_COMPONENT_WHOLESOME(c.b));
		898	no_tint = (c.r >= 0x00f700 && c.g >= 0x00f700 && c.b >= 0x00f700);
		899	#undef IS_COMPONENT_WHOLESOME
		900	#endif /* TINTING */
		901	/* theer are no performance advantages to reusing same pixmap */
		902	if (pixmap != None)
		903	XFreePixmap (dpy, pixmap);
		904	pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);
		905
		906	#if 0 /* TODO : identify cases where this will be detrimental to performance : */
		907	/* we want to tile root pixmap into our own pixmap in this cases :
		908	* 1) rootpixmap does not cover our window entirely
		909	* 2) whole_tint - we can use server-side tinting or tinting disabled
		910	*/
		911	if ( whole_tint \|\| no_tint \|\| pmap_w < sx + szHint.width \|\| pmap_h < sy + szHint.height)
		912	{
		913	}
		914	#endif
		915	gcvalue.tile = rootpixmap;
		916	gcvalue.fill_style = FillTiled;
		917	gcvalue.ts_x_origin = -sx;
		918	gcvalue.ts_y_origin = -sy;
		919	gc = XCreateGC (dpy, rootpixmap, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcvalue);
		920	XFillRectangle (dpy, pixmap, gc, 0, 0, szHint.width, szHint.height);
		921
		922	#if TINTING
		923	if (whole_tint && !no_tint)
		924	{
		925	/* In this case we can tint image server-side getting significant
		926	* performance improvements, as we eliminate XImage transfer
		927	*/
		928	gcvalue.foreground = Pixel (pix_colors_focused [Color_tint]);
		929	gcvalue.function = GXand;
		930	gcvalue.fill_style = FillSolid;
		931	XChangeGC (dpy, gc, GCFillStyle \| GCForeground \| GCFunction, &gcvalue);
		932	XFillRectangle (dpy, pixmap, gc, 0, 0, szHint.width, szHint.height);
		933	}
		934	#endif
		935	success = True;
788	#ifdef HAVE_AFTERIMAGE	936	#ifdef HAVE_AFTERIMAGE
		937	if (rs[Rs_blurradius] \|\| original_asim != NULL \|\| (!whole_tint && (!no_tint \|\| shade !=100)))
789	{	938	{
790	Pixmap tmp_pmap = None ;	939	ARGB32 tint = TINT_LEAVE_SAME;
791	ShadingInfo shade;	940	ASImage *back_im = NULL;
792	ARGB32 tint ;
793	unsigned int pmap_w = 0, pmap_h = 0;
794		941
795	if (get_drawable_size( rootpixmap, &pmap_w, &pmap_h ))	942	back_im = pixmap2ximage (asv, pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, 100);
		943	if (back_im != NULL)
796	{	944	{
797	int root_x = 0, root_y = 0;	945	if (!whole_tint && (!no_tint \|\| shade !=100))
798
799	shade.shading = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
800	if (ISSET_PIXCOLOR (Color_tint))
801	{	946	{
802	rgba c;	947	ShadingInfo as_shade;
803	pix_colors_focused [Color_tint].get (c);	948	as_shade.shading = shade;
804	shade.tintColor.red = c.r;	949	as_shade.tintColor.red = c.r;
805	shade.tintColor.green = c.g;	950	as_shade.tintColor.green = c.g;
806	shade.tintColor.blue = c.b;	951	as_shade.tintColor.blue = c.b;
		952	tint = shading2tint32 (&as_shade);
807	}	953	}
808	else	954
809	shade.tintColor.red = shade.tintColor.green = shade.tintColor.blue = 0xFFFF;	955	if (rs[Rs_blurradius] && back_im)
810	tint = shading2tint32( &shade );
811	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
812	if (GetWinPosition (parent[0], &root_x, &root_y) )
813	{	956	{
		957	double r = atof(rs[Rs_blurradius]);
		958	ASImage* tmp = blur_asimage_gauss (asv, back_im, r, r, 0xFFFFFFFF,
		959	(original_asim == NULL \|\| tint == TINT_LEAVE_SAME)?ASA_XImage:ASA_ASImage,
		960	100, ASIMAGE_QUALITY_DEFAULT);
		961	if (tmp)
		962	{
		963	destroy_asimage (&back_im);
		964	back_im = tmp;
		965	}
		966	}
		967
		968	if (original_asim != NULL)
		969	{
814	ASImageLayer *layers = create_image_layers( 2 );	970	ASImageLayer *layers = create_image_layers (2);
815	ASImage *merged_im = NULL;	971	ASImage *merged_im = NULL;
816	int back_x, back_y, back_w, back_h;	972	int fore_w, fore_h;
817	/* merge_layers does good job at tiling background appropriately,
818	so all we need is to cut out smallest possible piece : */
819	#define MAKE_ROOTPMAP_GEOM(xy,wh,widthheight) \
820	do{ while( root_##xy < 0 ) root_##xy += (int)wrootattr.widthheight; \
821	back_##xy = root_##xy % pmap_##wh; /* that gives us left side of the closest tile : */ \
822	if( pmap_##wh >= back_##xy + szHint.widthheight ) \
823	back_##wh = szHint.widthheight;/* background is large - limit it by our size */ \
824	else \
825	{ /* small background - need the whole of it for successfull tiling :*/ \
826	back_##xy = 0; \
827	back_##wh = pmap_##wh; \
828	}}while(0)
829
830	MAKE_ROOTPMAP_GEOM(x,w,width);
831	MAKE_ROOTPMAP_GEOM(y,h,height);
832		973
833	layers[0].im = pixmap2asimage (display->asv, rootpixmap, back_x, back_y, back_w, back_h, AllPlanes, ASA_ASImage, 100);	974	layers[0].im = back_im;
834	layers[0].clip_x = (back_w == pmap_w)?root_x:0;
835	layers[0].clip_y = (back_h == pmap_h)?root_y:0;
836	layers[0].clip_width = szHint.width;	975	layers[0].clip_width = szHint.width;
837	layers[0].clip_height = szHint.height;	976	layers[0].clip_height = szHint.height;
838	layers[0].tint = tint;	977	layers[0].tint = tint;
839	if (rs[Rs_blurradius] && layers[0].im)
840	{
841	double r = atof(rs[Rs_blurradius]);
842	ASImage* tmp = blur_asimage_gauss(display->asv, layers[0].im, r, r, 0xFFFFFFFF, ASA_ASImage, 100, ASIMAGE_QUALITY_DEFAULT );
843	if( tmp )
844	{
845	destroy_asimage( &layers[0].im );
846	layers[0].im = tmp;
847	}
848	}
849	if (original_asim != NULL)
850	{
851	int fore_w, fore_h;
852	layers[1].im = original_asim;	978	layers[1].im = original_asim;
853	if( bgPixmap.auto_resize )	979	if (bgPixmap.auto_resize)
854	{	980	{
855	fore_w = szHint.width;	981	fore_w = szHint.width;
856	fore_h = szHint.height;	982	fore_h = szHint.height;
857	}	983	}
858	else	984	else
859	{	985	{
860	fore_w = bgPixmap.w;	986	fore_w = bgPixmap.w;
861	fore_h = bgPixmap.h;	987	fore_h = bgPixmap.h;
862	}	988	}
863	if (fore_w != original_asim->width	989	if (fore_w != original_asim->width
864	\|\| fore_h != original_asim->height)	990	\|\| fore_h != original_asim->height)
865	{	991	{
866	layers[1].im = scale_asimage( display->asv,	992	layers[1].im = scale_asimage (asv,
867	original_asim,	993	original_asim,
868	fore_w, fore_h,	994	fore_w, fore_h,
869	ASA_ASImage, 100,	995	ASA_ASImage, 100,
870	ASIMAGE_QUALITY_DEFAULT );	996	ASIMAGE_QUALITY_DEFAULT);
871	}	997	}
872
873	layers[1].clip_width = szHint.width;	998	layers[1].clip_width = szHint.width;
874	layers[1].clip_height = szHint.height;	999	layers[1].clip_height = szHint.height;
875		1000
876	if (rs[Rs_blendtype])	1001	if (rs[Rs_blendtype])
877	{	1002	{
878	layers[1].merge_scanlines = blend_scanlines_name2func(rs[Rs_blendtype]);	1003	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
879	if( layers[1].merge_scanlines == NULL )	1004	if (layers[1].merge_scanlines == NULL)
880	layers[1].merge_scanlines = alphablend_scanlines;	1005	layers[1].merge_scanlines = alphablend_scanlines;
881	}	1006	}
882	}	1007	PRINT_BACKGROUND_OP_TIME;
883	merged_im = merge_layers( display->asv, layers, layers[1].im?2:1,	1008	merged_im = merge_layers (asv, layers, 2, szHint.width, szHint.height,
884	szHint.width, szHint.height,
885	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT );	1009	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
886	if (layers[1].im != original_asim)	1010	if (layers[1].im != original_asim)
887	destroy_asimage( &(layers[1].im) );	1011	destroy_asimage (&(layers[1].im));
888	destroy_asimage( &(layers[0].im) );	1012	free (layers);
		1013
889	if (merged_im != NULL)	1014	if (merged_im != NULL)
890	{	1015	{
891	tmp_pmap = asimage2pixmap( display->asv, DefaultRootWindow(dpy), merged_im, gc, True );
892	destroy_asimage( &merged_im );	1016	destroy_asimage (&back_im);
		1017	back_im = merged_im;
893	}	1018	}
894	free( layers );	1019	PRINT_BACKGROUND_OP_TIME;
895	}	1020	}
		1021	else if (tint != TINT_LEAVE_SAME)
		1022	{
		1023	ASImage* tmp = tile_asimage (asv, back_im, 0, 0, szHint.width, szHint.height, tint, ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
		1024	if (tmp)
		1025	{
		1026	destroy_asimage (&back_im);
		1027	back_im = tmp;
		1028	}
		1029	PRINT_BACKGROUND_OP_TIME;
		1030	}
		1031	asimage2drawable (asv, pixmap, back_im, gc, 0, 0, 0, 0, szHint.width, szHint.height, True);
		1032	destroy_asimage (&back_im);
		1033	} /* back_im != NULL */
		1034	else
		1035	success = False;
896	}	1036	}
897	if (tmp_pmap != None)
898	{
899	success = True;
900	if (pixmap != None)
901	XFreePixmap (dpy, pixmap);
902	pixmap = tmp_pmap;
903	}
904	}
905	#else /* HAVE_AFTERIMAGE */	1037	#else /* HAVE_AFTERIMAGE */
906	{
907	/*
908	* Copy display->root pixmap transparency
909	*/
910	int nx, ny;
911	unsigned int nw, nh;
912	XImage *image;
913
914	nw = (unsigned int)szHint.width;
915	nh = (unsigned int)szHint.height;
916	nx = ny = 0;
917
918	if (sx < 0)
919	{
920	nw += sx;
921	nx = -sx;
922	sx = 0;
923	}
924
925	if (sy < 0)
926	{
927	nh += sy;
928	ny = -sy;
929	sy = 0;
930	}
931
932	min_it (nw, (unsigned int) (wrootattr.width - sx));
933	min_it (nh, (unsigned int) (wrootattr.height - sy));
934
935	XSync (dpy, False);
936	allowedxerror = -1;
937	image = XGetImage (dpy, rootpixmap, sx, sy, nw, nh, AllPlanes, ZPixmap);
938
939	/* XXX: handle BadMatch - usually because we're outside the pixmap */
940	/* XXX: may need a delay here? */
941	allowedxerror = 0;
942	if (image != NULL)
943	{
944	if (pixmap != None)
945	XFreePixmap (dpy, pixmap);
946
947	#if TINTING	1038	#if TINTING
948	if (ISSET_PIXCOLOR (Color_tint))	1039	if (!whole_tint && (!no_tint \|\| shade !=100))
		1040	{
		1041	XImage *image = XGetImage (dpy, pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);
		1042	success = False;
		1043	if (image != NULL)
949	{	1044	{
950	int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;	1045	PRINT_BACKGROUND_OP_TIME;
951		1046	if (gc == NULL)
952	rgba c;	1047	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
953	pix_colors_focused [Color_tint].get (c);	1048	if (ISSET_PIXCOLOR (Color_tint) \|\| shade != 100)
954	ShadeXImage (this, image, shade, c.r, c.g, c.b);	1049	ShadeXImage (this, image, shade, c.r, c.g, c.b);
		1050	XPutImage (dpy, pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);
		1051	XDestroyImage (image);
		1052	success = True;
955	}	1053	}
		1054	}
956	#endif	1055	#endif
957
958	pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, image->depth);
959	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
960	XPutImage (dpy, pixmap, gc, image, 0, 0,
961	nx, ny, image->width, image->height);
962	XDestroyImage (image);
963	success = True ;
964	}
965	}
966	#endif /* HAVE_AFTERIMAGE */	1056	#endif /* HAVE_AFTERIMAGE */
		1057	PRINT_BACKGROUND_OP_TIME;
		1058
967	if (gc != NULL)	1059	if (gc != NULL)
968	XFreeGC (dpy, gc);	1060	XFreeGC (dpy, gc);
969		1061
970	if (!success)	1062	if (!success)
971	{	1063	{
972	if (am_transparent && am_pixmap_trans)	1064	if (am_transparent && am_pixmap_trans)
…		…
989	if (!am_transparent \|\| !am_pixmap_trans)	1081	if (!am_transparent \|\| !am_pixmap_trans)
990	pchanged = 1;	1082	pchanged = 1;
991		1083
992	am_transparent = am_pixmap_trans = 1;	1084	am_transparent = am_pixmap_trans = 1;
993	}	1085	}
994	}	1086	} /* rootpixmap != None */
995		1087
996	if (am_pixmap_trans)	1088	if (am_pixmap_trans)
997	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);	1089	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
998	else	1090	else
999	{	1091	{

Diff Legend

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

Comparing rxvt-unicode/src/xpm.C (file contents): Revision 1.42 by ayin, Wed Jun 27 20:26:15 2007 UTC vs. Revision 1.52 by sasha, Fri Jul 27 22:52:08 2007 UTC

Diff Legend

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.42 by ayin, Wed Jun 27 20:26:15 2007 UTC vs.
Revision 1.52 by sasha, Fri Jul 27 22:52:08 2007 UTC