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

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.43 by ayin, Sat Jun 30 23:31:29 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	static void rxvt_pixmap_incr (unsigned int wh, unsigned int xy, float incr, float p, unsigned int widthheight, unsigned int xpmwidthheight);
32		30
33	/*	31	/*
34	* These GEOM strings indicate absolute size/position:	32	* These GEOM strings indicate absolute size/position:
35	* @ `WxH+X+Y'	33	* @ `WxH+X+Y'
36	* @ `WxH+X' -> Y = X	34	* @ `WxH+X' -> Y = X
…		…
83	if (n < MAXLEN_GEOM)	81	if (n < MAXLEN_GEOM)
84	{	82	{
85	strncpy (str, geom, n);	83	strncpy (str, geom, n);
86	str[n] = '\0';	84	str[n] = '\0';
87		85
88	if (strcmp(str, "auto") == 0)	86	if (strcmp(str, "auto") == 0)
89	{	87	{
90	if (!bgpixmap->auto_resize)	88	if (!bgpixmap->auto_resize)
91	changed++;	89	changed++;
92	bgpixmap->auto_resize = True ;	90	bgpixmap->auto_resize = True ;
93	w = szHint.width ;	91	w = szHint.width ;
94	h = szHint.height ;	92	h = szHint.height ;
95	flags = WidthValue\|HeightValue ;	93	flags = WidthValue\|HeightValue ;
96	}	94	}
97	else	95	else
98	{	96	{
99	bgpixmap->auto_resize = False ;	97	bgpixmap->auto_resize = False ;
100	flags = XParseGeometry (str, &x, &y, &w, &h);	98	flags = XParseGeometry (str, &x, &y, &w, &h);
101	}	99	}
102		100
103	if (!flags)	101	if (!flags)
104	{	102	{
…		…
209	unsigned int w = bgPixmap.w, h = bgPixmap.h,	207	unsigned int w = bgPixmap.w, h = bgPixmap.h,
210	x = bgPixmap.x, y = bgPixmap.y;	208	x = bgPixmap.x, y = bgPixmap.y;
211	unsigned int xpmh = xpmAttr.height,	209	unsigned int xpmh = xpmAttr.height,
212	xpmw = xpmAttr.width;	210	xpmw = xpmAttr.width;
213		211
214	if (bgPixmap.auto_resize)	212	if (bgPixmap.auto_resize)
215	{	213	{
216	w = szHint.width ;	214	w = szHint.width ;
217	h = szHint.height ;	215	h = szHint.height ;
218	}	216	}
219	/*	217	/*
220	* don't zoom pixmap too much nor expand really small pixmaps	218	* don't zoom pixmap too much nor expand really small pixmaps
221	*/	219	*/
222	if (w > 32767 \|\| h > 32767)	220	if (w > 32767 \|\| h > 32767)
223	w = 1;	221	w = 1;
…		…
234	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);
235	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);
236	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);
237	}	235	}
238	else	236	else
239	#ifdef HAVE_AFTERIMAGE
240	#ifdef ENABLE_TRANSPARENCY	237	#ifdef ENABLE_TRANSPARENCY
241	if (!option(Opt_transparent) \|\| !am_transparent)	238	if (!option(Opt_transparent) \|\| !am_transparent)
242	/* will do that in check_our_parents otherwise */	239	/* will do that in check_our_parents otherwise */
243	#endif	240	#endif
244	{	241	{
245	ASImage *scaled_im = scale_asimage( display->asv, original_asim, w, h, ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT );	242	ASImage *scaled_im = scale_asimage (asv, original_asim, w, h, ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
246	if (scaled_im)	243	if (scaled_im)
247	{	244	{
248	pixmap = asimage2pixmap( display->asv, display->root, scaled_im, gc, True );	245	pixmap = asimage2pixmap(asv, display->root, scaled_im, gc, True);
249	destroy_asimage( &scaled_im );	246	destroy_asimage (&scaled_im);
250	}	247	}
251	}	248	}
252	#else /* HAVE_AFTERIMAGE */
253	{
254	float incr, p;
255	Pixmap tmp;
256
257	pixmap = XCreatePixmap (dpy, vt, width, height, depth);
258	/*
259	* horizontal scaling
260	*/
261	rxvt_pixmap_incr (&w, &x, &incr, &p, width, xpmw);
262
263	tmp = XCreatePixmap (dpy, vt, width, xpmh, depth);
264	XFillRectangle (dpy, tmp, gc, 0, 0, width, xpmh);
265
266	for ( /nil / ; x < w; x++, p += incr)
267	{
268	if (p >= xpmw)
269	p = 0;
270
271	/* copy one column from the original pixmap to the tmp pixmap */
272	XCopyArea (dpy, bgPixmap.pixmap, tmp, gc, (int)p, 0, 1, xpmh, (int)x, 0);
273	}
274
275	/*
276	* vertical scaling
277	*/
278	rxvt_pixmap_incr (&h, &y, &incr, &p, height, xpmh);
279
280	if (y > 0)
281	XFillRectangle (dpy, pixmap, gc, 0, 0, width, y);
282
283	if (h < height)
284	XFillRectangle (dpy, pixmap, gc, 0, (int)h, width, height - h + 1);
285
286	for ( /nil / ; y < h; y++, p += incr)
287	{
288	if (p >= xpmh)
289	p = 0;
290
291	/* copy one row from the tmp pixmap to the main pixmap */
292	XCopyArea (dpy, tmp, pixmap, gc, 0, (int)p, width, 1, 0, (int)y);
293	}
294
295	XFreePixmap (dpy, tmp);
296	}
297	#endif /* HAVE_AFTERIMAGE */
298	}	249	}
299		250
300	XSetWindowBackgroundPixmap (dpy, vt, pixmap);	251	XSetWindowBackgroundPixmap (dpy, vt, pixmap);
301		252
302	XFreeGC (dpy, gc);	253	XFreeGC (dpy, gc);
303	#ifdef ENABLE_TRANSPARENCY	254	#ifdef ENABLE_TRANSPARENCY
304	am_transparent = 0;	255	am_transparent = 0;
305	#endif	256	#endif
306	}
307
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	}	257	}
383		258
384	Pixmap	259	Pixmap
385	rxvt_term::set_bgPixmap (const char *file)	260	rxvt_term::set_bgPixmap (const char *file)
386	{	261	{
…		…
403	/*	278	/*
404	* we already have the required attributes	279	* we already have the required attributes
405	*/	280	*/
406	/* XGetWindowAttributes (dpy, vt, &attr); */	281	/* XGetWindowAttributes (dpy, vt, &attr); */
407		282
408	#ifdef HAVE_AFTERIMAGE
409	if (asimman == NULL)	283	if (asimman == NULL)
410	asimman = create_generic_imageman(rs[Rs_path]);	284	asimman = create_generic_imageman(rs[Rs_path]);
411	if ((f = strchr (file, ';')) == NULL)	285	if ((f = strchr (file, ';')) == NULL)
412	original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );	286	original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );
413	else	287	else
414	{	288	{
415	size_t len = f - file;	289	size_t len = f - file;
416	f = (char *)malloc (len + 1);	290	f = (char *)malloc (len + 1);
417	strncpy (f, file, len);	291	strncpy (f, file, len);
418	f[len] = '\0';	292	f[len] = '\0';
419	original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );	293	original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );
420	free( f );	294	free( f );
421	}	295	}
422	if (original_asim)	296	if (original_asim)
423	{	297	{
424	bgPixmap.pixmap = asimage2pixmap( display->asv, display->root, original_asim, NULL, True );	298	bgPixmap.pixmap = asimage2pixmap (asv, display->root, original_asim, NULL, True);
425	xpmAttr.width = original_asim->width ;	299	xpmAttr.width = original_asim->width ;
426	xpmAttr.height = original_asim->height ;	300	xpmAttr.height = original_asim->height ;
427	}
428	#else /* HAVE_AFTERIMAGE */
429	xpmAttr.closeness = 30000;
430	xpmAttr.colormap = cmap;
431	xpmAttr.visual = visual;
432	xpmAttr.depth = depth;
433	xpmAttr.valuemask = (XpmCloseness \| XpmColormap \| XpmVisual
434	\| XpmDepth \| XpmSize \| XpmReturnPixels);
435
436	/* search environment variables here too */
437	f = (char *)rxvt_File_find (file, ".xpm", rs[Rs_path]);
438	if (f == NULL
439	\|\| XpmReadFileToPixmap (dpy, display->root, f,
440	&bgPixmap.pixmap, NULL,
441	&xpmAttr))
442	{	301	}
443	char *p;
444
445	/* semi-colon delimited */
446	if ((p = strchr (file, ';')) == NULL)
447	p = strchr (file, '\0');
448
449	rxvt_warn ("couldn't load XPM file \"%.*s\", ignoring.\n", (p - file), file);
450	}
451	free (f);
452	#endif /* HAVE_AFTERIMAGE */
453	}	302	}
454		303
455	resize_pixmap ();	304	resize_pixmap ();
456	return bgPixmap.pixmap;	305	return bgPixmap.pixmap;
457	}	306	}
…		…
704	}	553	}
705		554
706	void	555	void
707	rxvt_term::check_our_parents_cb (time_watcher &w)	556	rxvt_term::check_our_parents_cb (time_watcher &w)
708	{	557	{
709	int i, pchanged, aformat, have_pixmap, rootdepth;	558	int i, pchanged, aformat, rootdepth;
710	unsigned long nitems, bytes_after;	559	unsigned long nitems, bytes_after;
711	Atom atype;	560	Atom atype;
712	unsigned char *prop = NULL;	561	unsigned char *prop = NULL;
713	Window root, oldp, *list;	562	Window root, oldp, *list;
714	Pixmap rootpixmap = None;	563	Pixmap rootpixmap = None;
715	XWindowAttributes wattr, wrootattr;	564	XWindowAttributes wattr, wrootattr;
716	int sx, sy;	565	int sx, sy;
717	Window cr;	566	Window cr;
		567	unsigned int rootpixmap_w = 0, rootpixmap_h = 0;
718		568
719	pchanged = 0;	569	pchanged = 0;
720		570
721	if (!option (Opt_transparent))	571	if (!option (Opt_transparent))
722	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
723		584
724	XGetWindowAttributes (dpy, display->root, &wrootattr);	585	XGetWindowAttributes (dpy, display->root, &wrootattr);
725	rootdepth = wrootattr.depth;	586	rootdepth = wrootattr.depth;
726		587
727	XGetWindowAttributes (dpy, parent[0], &wattr);	588	XGetWindowAttributes (dpy, parent[0], &wattr);
…		…
741	/* 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. */
742	XSync (dpy, False);	603	XSync (dpy, False);
743		604
744	XTranslateCoordinates (dpy, parent[0], display->root,	605	XTranslateCoordinates (dpy, parent[0], display->root,
745	0, 0, &sx, &sy, &cr);	606	0, 0, &sx, &sy, &cr);
746
747	/* 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 : */
748	if( sx + (int)szHint.width <= 0 \|\| sy + (int)szHint.height <= 0	608	if( sx + (int)szHint.width <= 0 \|\| sy + (int)szHint.height <= 0
749	\|\| sx >= wrootattr.width \|\| sy >= wrootattr.height )	609	\|\| sx >= wrootattr.width \|\| sy >= wrootattr.height )
750	return /* 0 */ ;	610	return /* 0 */ ;
751	/*	611	/*
752	* Make the frame window set by the window manager have	612	* Make the frame window set by the window manager have
753	* the root background. Some window managers put multiple nested frame	613	* the root background. Some window managers put multiple nested frame
754	* windows for each client, so we have to take care about that.	614	* windows for each client, so we have to take care about that.
…		…
762	i = (xa[XA_ESETROOT_PMAP_ID]	622	i = (xa[XA_ESETROOT_PMAP_ID]
763	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],	623	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],
764	0L, 1L, False, XA_PIXMAP, &atype, &aformat,	624	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
765	&nitems, &bytes_after, &prop) == Success);	625	&nitems, &bytes_after, &prop) == Success);
766		626
		627	/* TODO: the below logic needs to be cleaned up */
767	if (!i \|\| prop == NULL	628	if (!i \|\| prop == NULL
768	#if TINTING	629	#if TINTING
769	\|\| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL	630	\|\| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL
770	#ifdef HAVE_AFTERIMAGE	631	#ifdef HAVE_AFTERIMAGE
771	&& original_asim == NULL && rs[Rs_blurradius] == NULL	632	&& original_asim == NULL && rs[Rs_blurradius] == NULL
772	#endif	633	#endif
773	)	634	)
774	#endif	635	#endif
775	)	636	)
776	have_pixmap = 0;	637	rootpixmap = None;
777	else	638	else
778	{	639	{
779	have_pixmap = 1;	640	int junk;
		641	unsigned int ujunk;
		642	/* root pixmap may be bad - allow a error */
		643	allowedxerror = -1;
780	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)
781	XFree (prop);	651	XFree (prop);
		652
		653	if (rootpixmap != None)
782	}	654	{
783
784	if (have_pixmap)
785	{
786	Bool success = False ;	655	Bool success = False;
787	GC gc = NULL;	656	GC gc = NULL;
788	XGCValues gcvalue;	657	XGCValues gcvalue;
		658	int shade = 100;
		659	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
		660	Bool whole_tint = False, no_tint = True;
		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;
789	#ifdef HAVE_AFTERIMAGE	713	#ifdef HAVE_AFTERIMAGE
		714	if (rs[Rs_blurradius] \|\| original_asim != NULL \|\| (!whole_tint && (!no_tint \|\| shade !=100)))
790	{	715	{
791	Pixmap tmp_pmap = None ;	716	ARGB32 tint = TINT_LEAVE_SAME;
792	ShadingInfo shade;	717	ASImage *back_im = NULL;
793	ARGB32 tint ;
794	unsigned int pmap_w = 0, pmap_h = 0;
795		718
796	if (get_drawable_size( rootpixmap, &pmap_w, &pmap_h ))	719	back_im = pixmap2ximage (asv, pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, 100);
		720	if (back_im != NULL)
797	{	721	{
798	int root_x = 0, root_y = 0;	722	if (!whole_tint && (!no_tint \|\| shade !=100))
799
800	shade.shading = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
801	if (ISSET_PIXCOLOR (Color_tint))
802	{	723	{
803	rgba c;	724	ShadingInfo as_shade;
804	pix_colors_focused [Color_tint].get (c);	725	as_shade.shading = shade;
805	shade.tintColor.red = c.r;	726	as_shade.tintColor.red = c.r;
806	shade.tintColor.green = c.g;	727	as_shade.tintColor.green = c.g;
807	shade.tintColor.blue = c.b;	728	as_shade.tintColor.blue = c.b;
		729	tint = shading2tint32 (&as_shade);
808	}	730	}
809	else	731
810	shade.tintColor.red = shade.tintColor.green = shade.tintColor.blue = 0xFFFF;	732	if (rs[Rs_blurradius] && back_im)
811	tint = shading2tint32( &shade );
812	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
813	if (GetWinPosition (parent[0], &root_x, &root_y) )
814	{	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	{
815	ASImageLayer *layers = create_image_layers( 2 );	754	ASImageLayer *layers = create_image_layers (2);
816	ASImage *merged_im = NULL;	755	ASImage *merged_im = NULL;
817	int back_x, back_y, back_w, back_h;	756	int fore_w, fore_h;
818	/* merge_layers does good job at tiling background appropriately,
819	so all we need is to cut out smallest possible piece : */
820	#define MAKE_ROOTPMAP_GEOM(xy,wh,widthheight) \
821	do{ while( root_##xy < 0 ) root_##xy += (int)wrootattr.widthheight; \
822	back_##xy = root_##xy % pmap_##wh; /* that gives us left side of the closest tile : */ \
823	if( pmap_##wh >= back_##xy + szHint.widthheight ) \
824	back_##wh = szHint.widthheight;/* background is large - limit it by our size */ \
825	else \
826	{ /* small background - need the whole of it for successfull tiling :*/ \
827	back_##xy = 0; \
828	back_##wh = pmap_##wh; \
829	}}while(0)
830
831	MAKE_ROOTPMAP_GEOM(x,w,width);
832	MAKE_ROOTPMAP_GEOM(y,h,height);
833		757
834	layers[0].im = pixmap2asimage (display->asv, rootpixmap, back_x, back_y, back_w, back_h, AllPlanes, ASA_ASImage, 100);	758	layers[0].im = back_im;
835	layers[0].clip_x = (back_w == pmap_w)?root_x:0;
836	layers[0].clip_y = (back_h == pmap_h)?root_y:0;
837	layers[0].clip_width = szHint.width;	759	layers[0].clip_width = szHint.width;
838	layers[0].clip_height = szHint.height;	760	layers[0].clip_height = szHint.height;
839	layers[0].tint = tint;	761	layers[0].tint = tint;
840	if (rs[Rs_blurradius] && layers[0].im)
841	{
842	double r = atof(rs[Rs_blurradius]);
843	ASImage* tmp = blur_asimage_gauss(display->asv, layers[0].im, r, r, 0xFFFFFFFF, ASA_ASImage, 100, ASIMAGE_QUALITY_DEFAULT );
844	if( tmp )
845	{
846	destroy_asimage( &layers[0].im );
847	layers[0].im = tmp;
848	}
849	}
850	if (original_asim != NULL)
851	{
852	int fore_w, fore_h;
853	layers[1].im = original_asim;	762	layers[1].im = original_asim;
854	if( bgPixmap.auto_resize )	763	if (bgPixmap.auto_resize)
855	{	764	{
856	fore_w = szHint.width;	765	fore_w = szHint.width;
857	fore_h = szHint.height;	766	fore_h = szHint.height;
858	}	767	}
859	else	768	else
860	{	769	{
861	fore_w = bgPixmap.w;	770	fore_w = bgPixmap.w;
862	fore_h = bgPixmap.h;	771	fore_h = bgPixmap.h;
863	}	772	}
864	if (fore_w != original_asim->width	773	if (fore_w != original_asim->width
865	\|\| fore_h != original_asim->height)	774	\|\| fore_h != original_asim->height)
866	{	775	{
867	layers[1].im = scale_asimage( display->asv,	776	layers[1].im = scale_asimage (asv,
868	original_asim,	777	original_asim,
869	fore_w, fore_h,	778	fore_w, fore_h,
870	ASA_ASImage, 100,	779	ASA_ASImage, 100,
871	ASIMAGE_QUALITY_DEFAULT );	780	ASIMAGE_QUALITY_DEFAULT);
872	}	781	}
873
874	layers[1].clip_width = szHint.width;	782	layers[1].clip_width = szHint.width;
875	layers[1].clip_height = szHint.height;	783	layers[1].clip_height = szHint.height;
876		784
877	if (rs[Rs_blendtype])	785	if (rs[Rs_blendtype])
878	{	786	{
879	layers[1].merge_scanlines = blend_scanlines_name2func(rs[Rs_blendtype]);	787	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
880	if( layers[1].merge_scanlines == NULL )	788	if (layers[1].merge_scanlines == NULL)
881	layers[1].merge_scanlines = alphablend_scanlines;	789	layers[1].merge_scanlines = alphablend_scanlines;
882	}	790	}
883	}	791	PRINT_BACKGROUND_OP_TIME;
884	merged_im = merge_layers( display->asv, layers, layers[1].im?2:1,	792	merged_im = merge_layers (asv, layers, 2, szHint.width, szHint.height,
885	szHint.width, szHint.height,
886	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT );	793	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
887	if (layers[1].im != original_asim)	794	if (layers[1].im != original_asim)
888	destroy_asimage( &(layers[1].im) );	795	destroy_asimage (&(layers[1].im));
889	destroy_asimage( &(layers[0].im) );	796	free (layers);
		797
890	if (merged_im != NULL)	798	if (merged_im != NULL)
891	{	799	{
892	tmp_pmap = asimage2pixmap( display->asv, DefaultRootWindow(dpy), merged_im, gc, True );
893	destroy_asimage( &merged_im );	800	destroy_asimage (&back_im);
		801	back_im = merged_im;
894	}	802	}
895	free( layers );	803	PRINT_BACKGROUND_OP_TIME;
896	}	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;
897	}	820	}
898	if (tmp_pmap != None)
899	{
900	success = True;
901	if (pixmap != None)
902	XFreePixmap (dpy, pixmap);
903	pixmap = tmp_pmap;
904	}
905	}
906	#else /* HAVE_AFTERIMAGE */	821	#else /* HAVE_AFTERIMAGE */
907	{
908	/*
909	* Copy display->root pixmap transparency
910	*/
911	int nx, ny;
912	unsigned int nw, nh;
913	XImage *image;
914
915	nw = (unsigned int)szHint.width;
916	nh = (unsigned int)szHint.height;
917	nx = ny = 0;
918
919	if (sx < 0)
920	{
921	nw += sx;
922	nx = -sx;
923	sx = 0;
924	}
925
926	if (sy < 0)
927	{
928	nh += sy;
929	ny = -sy;
930	sy = 0;
931	}
932
933	min_it (nw, (unsigned int) (wrootattr.width - sx));
934	min_it (nh, (unsigned int) (wrootattr.height - sy));
935
936	XSync (dpy, False);
937	allowedxerror = -1;
938	image = XGetImage (dpy, rootpixmap, sx, sy, nw, nh, AllPlanes, ZPixmap);
939
940	/* XXX: handle BadMatch - usually because we're outside the pixmap */
941	/* XXX: may need a delay here? */
942	allowedxerror = 0;
943	if (image != NULL)
944	{
945	if (pixmap != None)
946	XFreePixmap (dpy, pixmap);
947
948	#if TINTING	822	#if TINTING
949	if (ISSET_PIXCOLOR (Color_tint))	823	if (!whole_tint && (!no_tint \|\| shade !=100))
		824	{
		825	XImage *image = XGetImage (dpy, pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);
		826	success = False;
		827	if (image != NULL)
950	{	828	{
951	int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;	829	PRINT_BACKGROUND_OP_TIME;
952		830	if (gc == NULL)
953	rgba c;	831	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
954	pix_colors_focused [Color_tint].get (c);	832	if (ISSET_PIXCOLOR (Color_tint) \|\| shade != 100)
955	ShadeXImage (this, image, shade, c.r, c.g, c.b);	833	ShadeXImage (this, image, shade, c.r, c.g, c.b);
956	}	834	XPutImage (dpy, pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);
957	#endif
958
959	pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, image->depth);
960	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
961	XPutImage (dpy, pixmap, gc, image, 0, 0,
962	nx, ny, image->width, image->height);
963	XDestroyImage (image);	835	XDestroyImage (image);
964	success = True ;	836	success = True;
965	}	837	}
966	}	838	}
		839	#endif
967	#endif /* HAVE_AFTERIMAGE */	840	#endif /* HAVE_AFTERIMAGE */
		841	PRINT_BACKGROUND_OP_TIME;
		842
968	if (gc != NULL)	843	if (gc != NULL)
969	XFreeGC (dpy, gc);	844	XFreeGC (dpy, gc);
970		845
971	if (!success)	846	if (!success)
972	{	847	{
973	if (am_transparent && am_pixmap_trans)	848	if (am_transparent && am_pixmap_trans)
…		…
990	if (!am_transparent \|\| !am_pixmap_trans)	865	if (!am_transparent \|\| !am_pixmap_trans)
991	pchanged = 1;	866	pchanged = 1;
992		867
993	am_transparent = am_pixmap_trans = 1;	868	am_transparent = am_pixmap_trans = 1;
994	}	869	}
995	}	870	} /* rootpixmap != None */
996		871
997	if (am_pixmap_trans)	872	if (am_pixmap_trans)
998	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);	873	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
999	else	874	else
1000	{	875	{

Diff Legend

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

Comparing rxvt-unicode/src/xpm.C (file contents): Revision 1.43 by ayin, Sat Jun 30 23:31:29 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.43 by ayin, Sat Jun 30 23:31:29 2007 UTC vs.
Revision 1.54 by ayin, Thu Aug 2 00:09:54 2007 UTC