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

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.53 by sasha, Tue Jul 31 22:24:36 2007 UTC vs.
Revision 1.55 by sasha, Fri Aug 3 05:33:04 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
…		…
245	else	95	else
246	{	96	{
247	bgpixmap->auto_resize = False ;	97	bgpixmap->auto_resize = False ;
248	flags = XParseGeometry (str, &x, &y, &w, &h);	98	flags = XParseGeometry (str, &x, &y, &w, &h);
249	}	99	}
250		100	/* code below is garbage and needs to be rewritten */
251	if (!flags)	101	if (!flags)
252	{	102	{
253	flags \|= WidthValue;	103	flags \|= WidthValue;
254	w = 0;	104	w = 0;
255	} /* default is tile */	105	} /* default is tile */
…		…
301	{	151	{
302	x += bgpixmap->x;	152	x += bgpixmap->x;
303	y += bgpixmap->y;	153	y += bgpixmap->y;
304	}	154	}
305		155
306	if (xpmAttr.width && xpmAttr.height)
307	{
308	x = MOD(x, xpmAttr.width);
309	y = MOD(y, xpmAttr.height);
310	}
311
312	if (bgpixmap->x != x)	156	if (bgpixmap->x != x)
313	{	157	{
314	bgpixmap->x = x;	158	bgpixmap->x = x;
315	changed++;	159	changed++;
316	}	160	}
…		…
328	void	172	void
329	rxvt_term::resize_pixmap ()	173	rxvt_term::resize_pixmap ()
330	{	174	{
331	XGCValues gcvalue;	175	XGCValues gcvalue;
332	GC gc;	176	GC gc;
		177	unsigned int w = bgPixmap.w, h = bgPixmap.h;
		178	unsigned int x = bgPixmap.x, y = bgPixmap.y;
		179	ASImage *im = bgPixmap.original_asim;
333		180
334	if (pixmap != None)	181	/* preliminary cleanup - this needs to be integrated with check_our_parents() code */
335	{
336	XFreePixmap (dpy, pixmap);
337	pixmap = None ;
338	}
339
340	if (bgPixmap.pixmap == None)	182	if (bgPixmap.pixmap != None)
		183	{
		184	XFreePixmap (dpy, bgPixmap.pixmap);
		185	bgPixmap.pixmap = None ;
		186	}
		187	#ifdef ENABLE_TRANSPARENCY
		188	if (option(Opt_transparent) && am_transparent)
		189	{
		190	/* we need to re-generate transparency pixmap in that case ! */
		191	check_our_parents ();
		192	return;
		193	}
		194	#endif
		195
		196	if (bgPixmap.original_asim == NULL)
341	{ /* So be it: I'm not using pixmaps */	197	{ /* So be it: I'm not using pixmaps */
342	pixmap = None;
343
344	#ifdef ENABLE_TRANSPARENCY
345	if (!option (Opt_transparent) \|\| !am_transparent)
346	#endif
347	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);	198	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
348
349	return;	199	return;
350	}	200	}
351		201
352	gcvalue.foreground = pix_colors[Color_bg];	202	gcvalue.foreground = pix_colors[Color_bg];
353	gc = XCreateGC (dpy, vt, GCForeground, &gcvalue);	203	gc = XCreateGC (dpy, vt, GCForeground, &gcvalue);
354		204
355	if (bgPixmap.pixmap != None)
356	{ /* we have a specified pixmap */
357	unsigned int w = bgPixmap.w, h = bgPixmap.h,
358	x = bgPixmap.x, y = bgPixmap.y;
359	unsigned int xpmh = xpmAttr.height,
360	xpmw = xpmAttr.width;
361
362	if (bgPixmap.auto_resize)	205	if (bgPixmap.auto_resize)
363	{	206	{
364	w = szHint.width ;	207	w = szHint.width;
365	h = szHint.height ;	208	h = szHint.height;
366	}	209	}
367	/*	210	else
368	* don't zoom pixmap too much nor expand really small pixmaps	211	{ /* don't zoom pixmap too much nor expand really small pixmaps */
369	*/	212	if (w > 16000)
370	if (w > 32767 \|\| h > 32767)
371	w = 1;	213	w = 1;
372	else if (width > (10 * xpmw)	214	if (h > 16000)
373	\|\| height > (10 * xpmh))	215	h = 1;
374	w = 0; /* tile */	216	}
		217	if (w == 0) w = im->width;
		218	else if (w < 10) w *= im->width;
		219	if (h == 0) h = im->height;
		220	else if (w < 10) h *= im->height;
375		221
376	if (!w)	222	if (w != im->width \|\| h != im->height)
377	{	223	{
378	/* basic X tiling - let the X server do it */	224	ASImage *tmp = scale_asimage (asv, im, w, h, (x == 0 && y == 0)?ASA_XImage:ASA_ASImage, 0, ASIMAGE_QUALITY_DEFAULT);
379	pixmap = XCreatePixmap (dpy, vt, xpmw, xpmh, depth);	225	if (tmp != NULL)
380		226	im = tmp;
381	XCopyArea (dpy, bgPixmap.pixmap, pixmap, gc, x, y, xpmw - x, xpmh - y, 0, 0);	227	}
382	XCopyArea (dpy, bgPixmap.pixmap, pixmap, gc, x, 0, xpmw - x, y, 0, xpmh - y);	228	if (x != 0 \|\| y != 0)
383	XCopyArea (dpy, bgPixmap.pixmap, pixmap, gc, 0, y, x, xpmh - y, xpmw - x, 0);	229	{
384	XCopyArea (dpy, bgPixmap.pixmap, pixmap, gc, 0, 0, x, y, xpmw - x, xpmh - y);	230	ASImage *tmp = tile_asimage (asv, im, x, y, w, h, TINT_LEAVE_SAME, ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
		231	if (tmp != NULL)
385	}	232	{
386	else	233	if (im != bgPixmap.original_asim)
387	#ifdef HAVE_AFTERIMAGE	234	destroy_asimage (&im);
388	#ifdef ENABLE_TRANSPARENCY	235	im = tmp;
389	if (!option(Opt_transparent) \|\| !am_transparent)
390	/* will do that in check_our_parents otherwise */
391	#endif
392	{	236	}
393	ASImage *scaled_im = scale_asimage (asv, original_asim, w, h, ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);	237	}
394	if (scaled_im)
395	{
396	pixmap = asimage2pixmap(asv, display->root, scaled_im, gc, True);
397	destroy_asimage (&scaled_im);
398	}
399	}
400	#else /* HAVE_AFTERIMAGE */
401	{
402	float incr, p;
403	Pixmap tmp;
404
405	pixmap = XCreatePixmap (dpy, vt, width, height, depth);	238	bgPixmap.pixmap = XCreatePixmap (dpy, vt, w, h, depth);
406	/*	239	bgPixmap.pmap_width = w;
407	* horizontal scaling	240	bgPixmap.pmap_height = h;
408	*/	241	bgPixmap.pmap_depth = depth;
409	rxvt_pixmap_incr (&w, &x, &incr, &p, width, xpmw);
410		242
411	tmp = XCreatePixmap (dpy, vt, width, xpmh, depth);	243	asimage2drawable (asv, bgPixmap.pixmap, im, gc, 0, 0, 0, 0, w, h, True);
412	XFillRectangle (dpy, tmp, gc, 0, 0, width, xpmh);
413		244
414	for ( /nil / ; x < w; x++, p += incr)	245	if (im != bgPixmap.original_asim)
415	{	246	destroy_asimage (&im);
416	if (p >= xpmw)
417	p = 0;
418		247
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	}
447
448	XSetWindowBackgroundPixmap (dpy, vt, pixmap);	248	XSetWindowBackgroundPixmap (dpy, vt, bgPixmap.pixmap);
449		249
450	XFreeGC (dpy, gc);	250	XFreeGC (dpy, gc);
451	#ifdef ENABLE_TRANSPARENCY
452	am_transparent = 0;
453	#endif
454	}	251	}
455		252
456	Pixmap	253	void
457	rxvt_term::set_bgPixmap (const char *file)	254	rxvt_term::set_bgPixmap (const char *file)
458	{	255	{
459	char *f;	256	char *f;
460		257
461	assert (file != NULL);	258	assert (file != NULL);
…		…
468		265
469	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);	266	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
470		267
471	if (*file != '\0')	268	if (*file != '\0')
472	{	269	{
473	/* XWindowAttributes attr; */
474
475	/*
476	* we already have the required attributes
477	*/
478	/* XGetWindowAttributes (dpy, vt, &attr); */
479
480	#ifdef HAVE_AFTERIMAGE
481	if (asimman == NULL)	270	if (asimman == NULL)
482	asimman = create_generic_imageman(rs[Rs_path]);	271	asimman = create_generic_imageman(rs[Rs_path]);
483	if ((f = strchr (file, ';')) == NULL)	272	if ((f = strchr (file, ';')) == NULL)
484	original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );	273	bgPixmap.original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );
485	else	274	else
486	{	275	{
487	size_t len = f - file;	276	size_t len = f - file;
488	f = (char *)malloc (len + 1);	277	f = (char *)malloc (len + 1);
489	strncpy (f, file, len);	278	strncpy (f, file, len);
490	f[len] = '\0';	279	f[len] = '\0';
491	original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );	280	bgPixmap.original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );
492	free( f );	281	free( f );
493	}	282	}
494	if (original_asim)
495	{
496	bgPixmap.pixmap = asimage2pixmap (asv, display->root, original_asim, NULL, True);
497	xpmAttr.width = original_asim->width ;
498	xpmAttr.height = original_asim->height ;
499	}
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	}	283	}
526		284
527	resize_pixmap ();	285	resize_pixmap ();
528	return bgPixmap.pixmap;
529	}	286	}
530		287
531	#endif /* XPM_BACKGROUND */	288	#endif /* XPM_BACKGROUND */
532		289
533	#ifdef ENABLE_TRANSPARENCY	290	#ifdef ENABLE_TRANSPARENCY
…		…
850	/* TODO: the below logic needs to be cleaned up */	607	/* TODO: the below logic needs to be cleaned up */
851	if (!i \|\| prop == NULL	608	if (!i \|\| prop == NULL
852	#if TINTING	609	#if TINTING
853	\|\| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL	610	\|\| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL
854	#ifdef HAVE_AFTERIMAGE	611	#ifdef HAVE_AFTERIMAGE
855	&& original_asim == NULL && rs[Rs_blurradius] == NULL	612	&& bgPixmap.original_asim == NULL && rs[Rs_blurradius] == NULL
856	#endif	613	#endif
857	)	614	)
858	#endif	615	#endif
859	)	616	)
860	rootpixmap = None;	617	rootpixmap = None;
…		…
897	&& IS_COMPONENT_WHOLESOME(c.b));	654	&& IS_COMPONENT_WHOLESOME(c.b));
898	no_tint = (c.r >= 0x00f700 && c.g >= 0x00f700 && c.b >= 0x00f700);	655	no_tint = (c.r >= 0x00f700 && c.g >= 0x00f700 && c.b >= 0x00f700);
899	#undef IS_COMPONENT_WHOLESOME	656	#undef IS_COMPONENT_WHOLESOME
900	#endif /* TINTING */	657	#endif /* TINTING */
901	/* theer are no performance advantages to reusing same pixmap */	658	/* theer are no performance advantages to reusing same pixmap */
902	if (pixmap != None)	659	if (bgPixmap.pixmap != None)
903	XFreePixmap (dpy, pixmap);	660	XFreePixmap (dpy, bgPixmap.pixmap);
904	pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);	661	bgPixmap.pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);
		662	bgPixmap.pmap_width = szHint.width;
		663	bgPixmap.pmap_height = szHint.height;
		664	bgPixmap.pmap_depth = rootdepth;
905		665
906	#if 0 /* TODO : identify cases where this will be detrimental to performance : */	666	#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 :	667	/* we want to tile root pixmap into our own pixmap in this cases :
908	* 1) rootpixmap does not cover our window entirely	668	* 1) rootpixmap does not cover our window entirely
909	* 2) whole_tint - we can use server-side tinting or tinting disabled	669	* 2) whole_tint - we can use server-side tinting or tinting disabled
…		…
915	gcvalue.tile = rootpixmap;	675	gcvalue.tile = rootpixmap;
916	gcvalue.fill_style = FillTiled;	676	gcvalue.fill_style = FillTiled;
917	gcvalue.ts_x_origin = -sx;	677	gcvalue.ts_x_origin = -sx;
918	gcvalue.ts_y_origin = -sy;	678	gcvalue.ts_y_origin = -sy;
919	gc = XCreateGC (dpy, rootpixmap, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcvalue);	679	gc = XCreateGC (dpy, rootpixmap, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcvalue);
920	XFillRectangle (dpy, pixmap, gc, 0, 0, szHint.width, szHint.height);	680	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);
921		681
922	#if TINTING	682	#if TINTING
923	if (whole_tint && !no_tint)	683	if (whole_tint && !no_tint)
924	{	684	{
925	/* In this case we can tint image server-side getting significant	685	/* In this case we can tint image server-side getting significant
…		…
927	*/	687	*/
928	gcvalue.foreground = Pixel (pix_colors_focused [Color_tint]);	688	gcvalue.foreground = Pixel (pix_colors_focused [Color_tint]);
929	gcvalue.function = GXand;	689	gcvalue.function = GXand;
930	gcvalue.fill_style = FillSolid;	690	gcvalue.fill_style = FillSolid;
931	XChangeGC (dpy, gc, GCFillStyle \| GCForeground \| GCFunction, &gcvalue);	691	XChangeGC (dpy, gc, GCFillStyle \| GCForeground \| GCFunction, &gcvalue);
932	XFillRectangle (dpy, pixmap, gc, 0, 0, szHint.width, szHint.height);	692	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);
933	}	693	}
934	#endif	694	#endif
935	success = True;	695	success = True;
936	#ifdef HAVE_AFTERIMAGE	696	#ifdef HAVE_AFTERIMAGE
937	if (rs[Rs_blurradius] \|\| original_asim != NULL \|\| (!whole_tint && (!no_tint \|\| shade !=100)))	697	if (rs[Rs_blurradius] \|\| bgPixmap.original_asim != NULL \|\| (!whole_tint && (!no_tint \|\| shade !=100)))
938	{	698	{
939	ARGB32 tint = TINT_LEAVE_SAME;	699	ARGB32 tint = TINT_LEAVE_SAME;
940	ASImage *back_im = NULL;	700	ASImage *back_im = NULL;
941		701
942	back_im = pixmap2ximage (asv, pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, 100);	702	back_im = pixmap2ximage (asv, bgPixmap.pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, 100);
943	if (back_im != NULL)	703	if (back_im != NULL)
944	{	704	{
945	if (!whole_tint && (!no_tint \|\| shade !=100))	705	if (!whole_tint && (!no_tint \|\| shade !=100))
946	{	706	{
947	ShadingInfo as_shade;	707	ShadingInfo as_shade;
…		…
961	if (!(flags&WidthValue))	721	if (!(flags&WidthValue))
962	hr = 1;	722	hr = 1;
963	if (!(flags&HeightValue))	723	if (!(flags&HeightValue))
964	vr = hr;	724	vr = hr;
965	tmp = blur_asimage_gauss (asv, back_im, hr, vr, 0xFFFFFFFF,	725	tmp = blur_asimage_gauss (asv, back_im, hr, vr, 0xFFFFFFFF,
966	(original_asim == NULL \|\| tint == TINT_LEAVE_SAME)?ASA_XImage:ASA_ASImage,	726	(bgPixmap.original_asim == NULL \|\| tint == TINT_LEAVE_SAME)?ASA_XImage:ASA_ASImage,
967	100, ASIMAGE_QUALITY_DEFAULT);	727	100, ASIMAGE_QUALITY_DEFAULT);
968	if (tmp)	728	if (tmp)
969	{	729	{
970	destroy_asimage (&back_im);	730	destroy_asimage (&back_im);
971	back_im = tmp;	731	back_im = tmp;
972	}	732	}
973	}	733	}
974		734
975	if (original_asim != NULL)	735	if (bgPixmap.original_asim != NULL)
976	{	736	{
977	ASImageLayer *layers = create_image_layers (2);	737	ASImageLayer *layers = create_image_layers (2);
978	ASImage *merged_im = NULL;	738	ASImage *merged_im = NULL;
979	int fore_w, fore_h;	739	int fore_w, fore_h;
980		740
981	layers[0].im = back_im;	741	layers[0].im = back_im;
982	layers[0].clip_width = szHint.width;	742	layers[0].clip_width = szHint.width;
983	layers[0].clip_height = szHint.height;	743	layers[0].clip_height = szHint.height;
984	layers[0].tint = tint;	744	layers[0].tint = tint;
985	layers[1].im = original_asim;	745	layers[1].im = bgPixmap.original_asim;
986	if (bgPixmap.auto_resize)	746	if (bgPixmap.auto_resize)
987	{	747	{
988	fore_w = szHint.width;	748	fore_w = szHint.width;
989	fore_h = szHint.height;	749	fore_h = szHint.height;
990	}	750	}
991	else	751	else
992	{	752	{
993	fore_w = bgPixmap.w;	753	fore_w = (bgPixmap.w == 0) ? bgPixmap.original_asim->width : bgPixmap.w;
994	fore_h = bgPixmap.h;	754	fore_h = (bgPixmap.h == 0) ? bgPixmap.original_asim->height : bgPixmap.h;
995	}	755	}
996	if (fore_w != original_asim->width	756	if (fore_w != bgPixmap.original_asim->width
997	\|\| fore_h != original_asim->height)	757	\|\| fore_h != bgPixmap.original_asim->height)
998	{	758	{
999	layers[1].im = scale_asimage (asv,	759	layers[1].im = scale_asimage (asv,
1000	original_asim,	760	bgPixmap.original_asim,
1001	fore_w, fore_h,	761	fore_w, fore_h,
1002	ASA_ASImage, 100,	762	ASA_ASImage, 100,
1003	ASIMAGE_QUALITY_DEFAULT);	763	ASIMAGE_QUALITY_DEFAULT);
1004	}	764	}
1005	layers[1].clip_width = szHint.width;	765	layers[1].clip_width = szHint.width;
…		…
1012	layers[1].merge_scanlines = alphablend_scanlines;	772	layers[1].merge_scanlines = alphablend_scanlines;
1013	}	773	}
1014	PRINT_BACKGROUND_OP_TIME;	774	PRINT_BACKGROUND_OP_TIME;
1015	merged_im = merge_layers (asv, layers, 2, szHint.width, szHint.height,	775	merged_im = merge_layers (asv, layers, 2, szHint.width, szHint.height,
1016	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);	776	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
1017	if (layers[1].im != original_asim)	777	if (layers[1].im != bgPixmap.original_asim)
1018	destroy_asimage (&(layers[1].im));	778	destroy_asimage (&(layers[1].im));
1019	free (layers);	779	free (layers);
1020		780
1021	if (merged_im != NULL)	781	if (merged_im != NULL)
1022	{	782	{
…		…
1033	destroy_asimage (&back_im);	793	destroy_asimage (&back_im);
1034	back_im = tmp;	794	back_im = tmp;
1035	}	795	}
1036	PRINT_BACKGROUND_OP_TIME;	796	PRINT_BACKGROUND_OP_TIME;
1037	}	797	}
1038	asimage2drawable (asv, pixmap, back_im, gc, 0, 0, 0, 0, szHint.width, szHint.height, True);	798	asimage2drawable (asv, bgPixmap.pixmap, back_im, gc, 0, 0, 0, 0, szHint.width, szHint.height, True);
1039	destroy_asimage (&back_im);	799	destroy_asimage (&back_im);
1040	} /* back_im != NULL */	800	} /* back_im != NULL */
1041	else	801	else
1042	success = False;	802	success = False;
1043	}	803	}
1044	#else /* HAVE_AFTERIMAGE */	804	#else /* HAVE_AFTERIMAGE */
1045	#if TINTING	805	#if TINTING
1046	if (!whole_tint && (!no_tint \|\| shade !=100))	806	if (!whole_tint && (!no_tint \|\| shade !=100))
1047	{	807	{
1048	XImage *image = XGetImage (dpy, pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);	808	XImage *image = XGetImage (dpy, bgPixmap.pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);
1049	success = False;	809	success = False;
1050	if (image != NULL)	810	if (image != NULL)
1051	{	811	{
1052	PRINT_BACKGROUND_OP_TIME;	812	PRINT_BACKGROUND_OP_TIME;
1053	if (gc == NULL)	813	if (gc == NULL)
1054	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);	814	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
1055	if (ISSET_PIXCOLOR (Color_tint) \|\| shade != 100)	815	if (ISSET_PIXCOLOR (Color_tint) \|\| shade != 100)
1056	ShadeXImage (this, image, shade, c.r, c.g, c.b);	816	ShadeXImage (this, image, shade, c.r, c.g, c.b);
1057	XPutImage (dpy, pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);	817	XPutImage (dpy, bgPixmap.pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);
1058	XDestroyImage (image);	818	XDestroyImage (image);
1059	success = True;	819	success = True;
1060	}	820	}
1061	}	821	}
1062	#endif	822	#endif
…		…
1069	if (!success)	829	if (!success)
1070	{	830	{
1071	if (am_transparent && am_pixmap_trans)	831	if (am_transparent && am_pixmap_trans)
1072	{	832	{
1073	pchanged = 1;	833	pchanged = 1;
1074	if (pixmap != None)	834	if (bgPixmap.pixmap != None)
1075	{	835	{
1076	XFreePixmap (dpy, pixmap);	836	XFreePixmap (dpy, bgPixmap.pixmap);
1077	pixmap = None;	837	bgPixmap.pixmap = None;
1078	}	838	}
1079	}	839	}
1080		840
1081	am_pixmap_trans = 0;	841	am_pixmap_trans = 0;
1082	}	842	}
1083	else	843	else
1084	{	844	{
1085	XSetWindowBackgroundPixmap (dpy, parent[0], pixmap);	845	XSetWindowBackgroundPixmap (dpy, parent[0], bgPixmap.pixmap);
1086	XClearWindow (dpy, parent[0]);	846	XClearWindow (dpy, parent[0]);
1087		847
1088	if (!am_transparent \|\| !am_pixmap_trans)	848	if (!am_transparent \|\| !am_pixmap_trans)
1089	pchanged = 1;	849	pchanged = 1;
1090		850

Diff Legend

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

Comparing rxvt-unicode/src/xpm.C (file contents): Revision 1.53 by sasha, Tue Jul 31 22:24:36 2007 UTC vs. Revision 1.55 by sasha, Fri Aug 3 05:33:04 2007 UTC

Diff Legend

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.53 by sasha, Tue Jul 31 22:24:36 2007 UTC vs.
Revision 1.55 by sasha, Fri Aug 3 05:33:04 2007 UTC