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

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.44 by ayin, Sat Jun 30 23:34:57 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	/*
32	* Calculate tiling sizes and increments
33	* At start, p == 0, incr == xpmwidthheight
34	*/
35	static void
36	rxvt_pixmap_incr (unsigned int wh, unsigned int xy, float incr, float p, unsigned int widthheight, unsigned int xpmwidthheight)
37	{
38	unsigned int cwh, cxy;
39	float cincr, cp;
40
41	cp = 0;
42	cincr = (float)xpmwidthheight;
43	cxy = *xy;
44	cwh = *wh;
45	if (cwh == 1)
46	{ /* display one image, no horizontal/vertical scaling */
47	cincr = (float)widthheight;
48	if (xpmwidthheight <= widthheight)
49	{
50	cwh = xpmwidthheight;
51	cxy = (cxy * (widthheight - cwh)) / 100; /* beware! order */
52	cwh += cxy;
53	}
54	else
55	{
56	cxy = 0;
57	cwh = widthheight;
58	}
59	}
60	else if (cwh < 10)
61	{ /* fit WH images across/down screen */
62	cincr *= cwh;
63	cxy = 0;
64	cwh = widthheight;
65	}
66	else
67	{
68	cincr *= 100.0 / cwh;
69	if (cwh < 100)
70	{ /* contract */
71	float pos;
72
73	cwh = (cwh * widthheight) / 100;
74	pos = (float)cxy / 100 * widthheight - (cwh / 2);
75
76	cxy = (widthheight - cwh);
77	if (pos <= 0)
78	cxy = 0;
79	else if (pos < cxy)
80	cxy = (int) pos;
81	cwh += cxy;
82	}
83	else
84	{ /* expand */
85	if (cxy > 0)
86	{ /* position */
87	float pos;
88
89	pos = (float)cxy / 100 * xpmwidthheight - (cincr / 2);
90	cp = xpmwidthheight - cincr;
91	if (pos <= 0)
92	cp = 0;
93	else if (pos < cp)
94	cp = pos;
95	}
96	cxy = 0;
97	cwh = widthheight;
98	}
99	}
100	cincr /= widthheight;
101	*wh = cwh;
102	*xy = cxy;
103	*incr = cincr;
104	*p = cp;
105	}
106		30
107	/*	31	/*
108	* These GEOM strings indicate absolute size/position:	32	* These GEOM strings indicate absolute size/position:
109	* @ `WxH+X+Y'	33	* @ `WxH+X+Y'
110	* @ `WxH+X' -> Y = X	34	* @ `WxH+X' -> Y = X
…		…
157	if (n < MAXLEN_GEOM)	81	if (n < MAXLEN_GEOM)
158	{	82	{
159	strncpy (str, geom, n);	83	strncpy (str, geom, n);
160	str[n] = '\0';	84	str[n] = '\0';
161		85
162	if (strcmp(str, "auto") == 0)	86	if (strcmp(str, "auto") == 0)
163	{	87	{
164	if (!bgpixmap->auto_resize)	88	if (!bgpixmap->auto_resize)
165	changed++;	89	changed++;
166	bgpixmap->auto_resize = True ;	90	bgpixmap->auto_resize = True ;
167	w = szHint.width ;	91	w = szHint.width ;
168	h = szHint.height ;	92	h = szHint.height ;
169	flags = WidthValue\|HeightValue ;	93	flags = WidthValue\|HeightValue ;
170	}	94	}
171	else	95	else
172	{	96	{
173	bgpixmap->auto_resize = False ;	97	bgpixmap->auto_resize = False ;
174	flags = XParseGeometry (str, &x, &y, &w, &h);	98	flags = XParseGeometry (str, &x, &y, &w, &h);
175	}	99	}
176		100	/* code below is garbage and needs to be rewritten */
177	if (!flags)	101	if (!flags)
178	{	102	{
179	flags \|= WidthValue;	103	flags \|= WidthValue;
180	w = 0;	104	w = 0;
181	} /* default is tile */	105	} /* default is tile */
…		…
227	{	151	{
228	x += bgpixmap->x;	152	x += bgpixmap->x;
229	y += bgpixmap->y;	153	y += bgpixmap->y;
230	}	154	}
231		155
232	if (xpmAttr.width && xpmAttr.height)
233	{
234	x = MOD(x, xpmAttr.width);
235	y = MOD(y, xpmAttr.height);
236	}
237
238	if (bgpixmap->x != x)	156	if (bgpixmap->x != x)
239	{	157	{
240	bgpixmap->x = x;	158	bgpixmap->x = x;
241	changed++;	159	changed++;
242	}	160	}
…		…
254	void	172	void
255	rxvt_term::resize_pixmap ()	173	rxvt_term::resize_pixmap ()
256	{	174	{
257	XGCValues gcvalue;	175	XGCValues gcvalue;
258	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;
259		180
260	if (pixmap != None)	181	/* preliminary cleanup - this needs to be integrated with check_our_parents() code */
261	{
262	XFreePixmap (dpy, pixmap);
263	pixmap = None ;
264	}
265
266	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)
267	{ /* So be it: I'm not using pixmaps */	197	{ /* So be it: I'm not using pixmaps */
268	pixmap = None;
269
270	#ifdef ENABLE_TRANSPARENCY
271	if (!option (Opt_transparent) \|\| !am_transparent)
272	#endif
273	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);	198	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
274
275	return;	199	return;
276	}	200	}
277		201
278	gcvalue.foreground = pix_colors[Color_bg];	202	gcvalue.foreground = pix_colors[Color_bg];
279	gc = XCreateGC (dpy, vt, GCForeground, &gcvalue);	203	gc = XCreateGC (dpy, vt, GCForeground, &gcvalue);
280		204
281	if (bgPixmap.pixmap != None)
282	{ /* we have a specified pixmap */
283	unsigned int w = bgPixmap.w, h = bgPixmap.h,
284	x = bgPixmap.x, y = bgPixmap.y;
285	unsigned int xpmh = xpmAttr.height,
286	xpmw = xpmAttr.width;
287
288	if (bgPixmap.auto_resize)	205	if (bgPixmap.auto_resize)
289	{	206	{
290	w = szHint.width ;	207	w = szHint.width;
291	h = szHint.height ;	208	h = szHint.height;
292	}	209	}
293	/*	210	else
294	* don't zoom pixmap too much nor expand really small pixmaps	211	{ /* don't zoom pixmap too much nor expand really small pixmaps */
295	*/	212	if (w > 16000)
296	if (w > 32767 \|\| h > 32767)
297	w = 1;	213	w = 1;
298	else if (width > (10 * xpmw)	214	if (h > 16000)
299	\|\| height > (10 * xpmh))	215	h = 1;
300	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;
301		221
302	if (!w)	222	if (w != im->width \|\| h != im->height)
303	{	223	{
304	/* 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);
305	pixmap = XCreatePixmap (dpy, vt, xpmw, xpmh, depth);	225	if (tmp != NULL)
306		226	im = tmp;
307	XCopyArea (dpy, bgPixmap.pixmap, pixmap, gc, x, y, xpmw - x, xpmh - y, 0, 0);	227	}
308	XCopyArea (dpy, bgPixmap.pixmap, pixmap, gc, x, 0, xpmw - x, y, 0, xpmh - y);	228	if (x != 0 \|\| y != 0)
309	XCopyArea (dpy, bgPixmap.pixmap, pixmap, gc, 0, y, x, xpmh - y, xpmw - x, 0);	229	{
310	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)
311	}	232	{
312	else	233	if (im != bgPixmap.original_asim)
313	#ifdef HAVE_AFTERIMAGE	234	destroy_asimage (&im);
314	#ifdef ENABLE_TRANSPARENCY	235	im = tmp;
315	if (!option(Opt_transparent) \|\| !am_transparent)
316	/* will do that in check_our_parents otherwise */
317	#endif
318	{	236	}
319	ASImage *scaled_im = scale_asimage( display->asv, original_asim, w, h, ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT );	237	}
320	if (scaled_im)
321	{
322	pixmap = asimage2pixmap( display->asv, display->root, scaled_im, gc, True );
323	destroy_asimage( &scaled_im );
324	}
325	}
326	#else /* HAVE_AFTERIMAGE */
327	{
328	float incr, p;
329	Pixmap tmp;
330
331	pixmap = XCreatePixmap (dpy, vt, width, height, depth);	238	bgPixmap.pixmap = XCreatePixmap (dpy, vt, w, h, depth);
332	/*	239	bgPixmap.pmap_width = w;
333	* horizontal scaling	240	bgPixmap.pmap_height = h;
334	*/	241	bgPixmap.pmap_depth = depth;
335	rxvt_pixmap_incr (&w, &x, &incr, &p, width, xpmw);
336		242
337	tmp = XCreatePixmap (dpy, vt, width, xpmh, depth);	243	asimage2drawable (asv, bgPixmap.pixmap, im, gc, 0, 0, 0, 0, w, h, True);
338	XFillRectangle (dpy, tmp, gc, 0, 0, width, xpmh);
339		244
340	for ( /nil / ; x < w; x++, p += incr)	245	if (im != bgPixmap.original_asim)
341	{	246	destroy_asimage (&im);
342	if (p >= xpmw)
343	p = 0;
344		247
345	/* copy one column from the original pixmap to the tmp pixmap */
346	XCopyArea (dpy, bgPixmap.pixmap, tmp, gc, (int)p, 0, 1, xpmh, (int)x, 0);
347	}
348
349	/*
350	* vertical scaling
351	*/
352	rxvt_pixmap_incr (&h, &y, &incr, &p, height, xpmh);
353
354	if (y > 0)
355	XFillRectangle (dpy, pixmap, gc, 0, 0, width, y);
356
357	if (h < height)
358	XFillRectangle (dpy, pixmap, gc, 0, (int)h, width, height - h + 1);
359
360	for ( /nil / ; y < h; y++, p += incr)
361	{
362	if (p >= xpmh)
363	p = 0;
364
365	/* copy one row from the tmp pixmap to the main pixmap */
366	XCopyArea (dpy, tmp, pixmap, gc, 0, (int)p, width, 1, 0, (int)y);
367	}
368
369	XFreePixmap (dpy, tmp);
370	}
371	#endif /* HAVE_AFTERIMAGE */
372	}
373
374	XSetWindowBackgroundPixmap (dpy, vt, pixmap);	248	XSetWindowBackgroundPixmap (dpy, vt, bgPixmap.pixmap);
375		249
376	XFreeGC (dpy, gc);	250	XFreeGC (dpy, gc);
377	#ifdef ENABLE_TRANSPARENCY
378	am_transparent = 0;
379	#endif
380	}	251	}
381		252
382	Pixmap	253	void
383	rxvt_term::set_bgPixmap (const char *file)	254	rxvt_term::set_bgPixmap (const char *file)
384	{	255	{
385	char *f;	256	char *f;
386		257
387	assert (file != NULL);	258	assert (file != NULL);
…		…
394		265
395	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);	266	XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
396		267
397	if (*file != '\0')	268	if (*file != '\0')
398	{	269	{
399	/* XWindowAttributes attr; */
400
401	/*
402	* we already have the required attributes
403	*/
404	/* XGetWindowAttributes (dpy, vt, &attr); */
405
406	#ifdef HAVE_AFTERIMAGE
407	if (asimman == NULL)	270	if (asimman == NULL)
408	asimman = create_generic_imageman(rs[Rs_path]);	271	asimman = create_generic_imageman(rs[Rs_path]);
409	if ((f = strchr (file, ';')) == NULL)	272	if ((f = strchr (file, ';')) == NULL)
410	original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );	273	bgPixmap.original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );
411	else	274	else
412	{	275	{
413	size_t len = f - file;	276	size_t len = f - file;
414	f = (char *)malloc (len + 1);	277	f = (char *)malloc (len + 1);
415	strncpy (f, file, len);	278	strncpy (f, file, len);
416	f[len] = '\0';	279	f[len] = '\0';
417	original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );	280	bgPixmap.original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );
418	free( f );	281	free( f );
419	}	282	}
420	if (original_asim)
421	{
422	bgPixmap.pixmap = asimage2pixmap( display->asv, display->root, original_asim, NULL, True );
423	xpmAttr.width = original_asim->width ;
424	xpmAttr.height = original_asim->height ;
425	}
426	#else /* HAVE_AFTERIMAGE */
427	xpmAttr.closeness = 30000;
428	xpmAttr.colormap = cmap;
429	xpmAttr.visual = visual;
430	xpmAttr.depth = depth;
431	xpmAttr.valuemask = (XpmCloseness \| XpmColormap \| XpmVisual
432	\| XpmDepth \| XpmSize \| XpmReturnPixels);
433
434	/* search environment variables here too */
435	f = (char *)rxvt_File_find (file, ".xpm", rs[Rs_path]);
436	if (f == NULL
437	\|\| XpmReadFileToPixmap (dpy, display->root, f,
438	&bgPixmap.pixmap, NULL,
439	&xpmAttr))
440	{
441	char *p;
442
443	/* semi-colon delimited */
444	if ((p = strchr (file, ';')) == NULL)
445	p = strchr (file, '\0');
446
447	rxvt_warn ("couldn't load XPM file \"%.*s\", ignoring.\n", (p - file), file);
448	}
449	free (f);
450	#endif /* HAVE_AFTERIMAGE */
451	}	283	}
452		284
453	resize_pixmap ();	285	resize_pixmap ();
454	return bgPixmap.pixmap;
455	}	286	}
456		287
457	#endif /* XPM_BACKGROUND */	288	#endif /* XPM_BACKGROUND */
458		289
459	#ifdef ENABLE_TRANSPARENCY	290	#ifdef ENABLE_TRANSPARENCY
…		…
702	}	533	}
703		534
704	void	535	void
705	rxvt_term::check_our_parents_cb (time_watcher &w)	536	rxvt_term::check_our_parents_cb (time_watcher &w)
706	{	537	{
707	int i, pchanged, aformat, have_pixmap, rootdepth;	538	int i, pchanged, aformat, rootdepth;
708	unsigned long nitems, bytes_after;	539	unsigned long nitems, bytes_after;
709	Atom atype;	540	Atom atype;
710	unsigned char *prop = NULL;	541	unsigned char *prop = NULL;
711	Window root, oldp, *list;	542	Window root, oldp, *list;
712	Pixmap rootpixmap = None;	543	Pixmap rootpixmap = None;
713	XWindowAttributes wattr, wrootattr;	544	XWindowAttributes wattr, wrootattr;
714	int sx, sy;	545	int sx, sy;
715	Window cr;	546	Window cr;
		547	unsigned int rootpixmap_w = 0, rootpixmap_h = 0;
716		548
717	pchanged = 0;	549	pchanged = 0;
718		550
719	if (!option (Opt_transparent))	551	if (!option (Opt_transparent))
720	return /pchanged/; /* Don't try any more */	552	return /pchanged/; /* Don't try any more */
		553
		554	#if 0
		555	struct timeval stv;
		556	gettimeofday (&stv,NULL);
		557	#define PRINT_BACKGROUND_OP_TIME do{ struct timeval tv;gettimeofday (&tv,NULL); tv.tv_sec-= stv.tv_sec;\
		558	fprintf (stderr,"%d: elapsed %ld usec\n",__LINE__,\
		559	tv.tv_sec*1000000+tv.tv_usec-stv.tv_usec );}while(0)
		560	#else
		561	#define PRINT_BACKGROUND_OP_TIME do{}while(0)
		562	#endif
		563
721		564
722	XGetWindowAttributes (dpy, display->root, &wrootattr);	565	XGetWindowAttributes (dpy, display->root, &wrootattr);
723	rootdepth = wrootattr.depth;	566	rootdepth = wrootattr.depth;
724		567
725	XGetWindowAttributes (dpy, parent[0], &wattr);	568	XGetWindowAttributes (dpy, parent[0], &wattr);
…		…
739	/* Get all X ops out of the queue so that our information is up-to-date. */	582	/* Get all X ops out of the queue so that our information is up-to-date. */
740	XSync (dpy, False);	583	XSync (dpy, False);
741		584
742	XTranslateCoordinates (dpy, parent[0], display->root,	585	XTranslateCoordinates (dpy, parent[0], display->root,
743	0, 0, &sx, &sy, &cr);	586	0, 0, &sx, &sy, &cr);
744
745	/* check if we are outside of the visible part of the virtual screen : */	587	/* check if we are outside of the visible part of the virtual screen : */
746	if( sx + (int)szHint.width <= 0 \|\| sy + (int)szHint.height <= 0	588	if( sx + (int)szHint.width <= 0 \|\| sy + (int)szHint.height <= 0
747	\|\| sx >= wrootattr.width \|\| sy >= wrootattr.height )	589	\|\| sx >= wrootattr.width \|\| sy >= wrootattr.height )
748	return /* 0 */ ;	590	return /* 0 */ ;
749	/*	591	/*
750	* Make the frame window set by the window manager have	592	* Make the frame window set by the window manager have
751	* the root background. Some window managers put multiple nested frame	593	* the root background. Some window managers put multiple nested frame
752	* windows for each client, so we have to take care about that.	594	* windows for each client, so we have to take care about that.
…		…
760	i = (xa[XA_ESETROOT_PMAP_ID]	602	i = (xa[XA_ESETROOT_PMAP_ID]
761	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],	603	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],
762	0L, 1L, False, XA_PIXMAP, &atype, &aformat,	604	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
763	&nitems, &bytes_after, &prop) == Success);	605	&nitems, &bytes_after, &prop) == Success);
764		606
		607	/* TODO: the below logic needs to be cleaned up */
765	if (!i \|\| prop == NULL	608	if (!i \|\| prop == NULL
766	#if TINTING	609	#if TINTING
767	\|\| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL	610	\|\| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL
768	#ifdef HAVE_AFTERIMAGE	611	#ifdef HAVE_AFTERIMAGE
769	&& original_asim == NULL && rs[Rs_blurradius] == NULL	612	&& bgPixmap.original_asim == NULL && rs[Rs_blurradius] == NULL
770	#endif	613	#endif
771	)	614	)
772	#endif	615	#endif
773	)	616	)
774	have_pixmap = 0;	617	rootpixmap = None;
775	else	618	else
776	{	619	{
777	have_pixmap = 1;	620	int junk;
		621	unsigned int ujunk;
		622	/* root pixmap may be bad - allow a error */
		623	allowedxerror = -1;
778	rootpixmap = (Pixmap )prop;	624	if ((rootpixmap = (Pixmap )prop) != None)
		625	if (!XGetGeometry (dpy, rootpixmap, &root, &junk, &junk, &rootpixmap_w, &rootpixmap_h, &ujunk, &ujunk))
		626	rootpixmap = None;
		627	allowedxerror = 0;
		628	}
		629
		630	if (prop != NULL)
779	XFree (prop);	631	XFree (prop);
		632
		633	if (rootpixmap != None)
780	}	634	{
781
782	if (have_pixmap)
783	{
784	Bool success = False ;	635	Bool success = False;
785	GC gc = NULL;	636	GC gc = NULL;
786	XGCValues gcvalue;	637	XGCValues gcvalue;
		638	int shade = 100;
		639	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
		640	Bool whole_tint = False, no_tint = True;
		641
		642	while (sx < 0) sx += (int)wrootattr.width;
		643	while (sy < 0) sy += (int)wrootattr.height;
		644
		645	#if TINTING
		646	if (rs[Rs_shade])
		647	shade = atoi (rs[Rs_shade]);
		648	if (ISSET_PIXCOLOR (Color_tint))
		649	pix_colors_focused [Color_tint].get (c);
		650	#define IS_COMPONENT_WHOLESOME(c) ((c) <=0x000700 \|\| (c)>=0x00f700)
		651	if (shade >= 100)
		652	whole_tint = (IS_COMPONENT_WHOLESOME(c.r)
		653	&& IS_COMPONENT_WHOLESOME(c.g)
		654	&& IS_COMPONENT_WHOLESOME(c.b));
		655	no_tint = (c.r >= 0x00f700 && c.g >= 0x00f700 && c.b >= 0x00f700);
		656	#undef IS_COMPONENT_WHOLESOME
		657	#endif /* TINTING */
		658	/* theer are no performance advantages to reusing same pixmap */
		659	if (bgPixmap.pixmap != None)
		660	XFreePixmap (dpy, bgPixmap.pixmap);
		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;
		665
		666	#if 0 /* TODO : identify cases where this will be detrimental to performance : */
		667	/* we want to tile root pixmap into our own pixmap in this cases :
		668	* 1) rootpixmap does not cover our window entirely
		669	* 2) whole_tint - we can use server-side tinting or tinting disabled
		670	*/
		671	if ( whole_tint \|\| no_tint \|\| pmap_w < sx + szHint.width \|\| pmap_h < sy + szHint.height)
		672	{
		673	}
		674	#endif
		675	gcvalue.tile = rootpixmap;
		676	gcvalue.fill_style = FillTiled;
		677	gcvalue.ts_x_origin = -sx;
		678	gcvalue.ts_y_origin = -sy;
		679	gc = XCreateGC (dpy, rootpixmap, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcvalue);
		680	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);
		681
		682	#if TINTING
		683	if (whole_tint && !no_tint)
		684	{
		685	/* In this case we can tint image server-side getting significant
		686	* performance improvements, as we eliminate XImage transfer
		687	*/
		688	gcvalue.foreground = Pixel (pix_colors_focused [Color_tint]);
		689	gcvalue.function = GXand;
		690	gcvalue.fill_style = FillSolid;
		691	XChangeGC (dpy, gc, GCFillStyle \| GCForeground \| GCFunction, &gcvalue);
		692	XFillRectangle (dpy, bgPixmap.pixmap, gc, 0, 0, szHint.width, szHint.height);
		693	}
		694	#endif
		695	success = True;
787	#ifdef HAVE_AFTERIMAGE	696	#ifdef HAVE_AFTERIMAGE
		697	if (rs[Rs_blurradius] \|\| bgPixmap.original_asim != NULL \|\| (!whole_tint && (!no_tint \|\| shade !=100)))
788	{	698	{
789	Pixmap tmp_pmap = None ;	699	ARGB32 tint = TINT_LEAVE_SAME;
790	ShadingInfo shade;	700	ASImage *back_im = NULL;
791	ARGB32 tint ;
792	unsigned int pmap_w = 0, pmap_h = 0;
793		701
794	if (get_drawable_size( rootpixmap, &pmap_w, &pmap_h ))	702	back_im = pixmap2ximage (asv, bgPixmap.pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, 100);
		703	if (back_im != NULL)
795	{	704	{
796	int root_x = 0, root_y = 0;	705	if (!whole_tint && (!no_tint \|\| shade !=100))
797
798	shade.shading = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
799	if (ISSET_PIXCOLOR (Color_tint))
800	{	706	{
801	rgba c;	707	ShadingInfo as_shade;
802	pix_colors_focused [Color_tint].get (c);	708	as_shade.shading = shade;
803	shade.tintColor.red = c.r;	709	as_shade.tintColor.red = c.r;
804	shade.tintColor.green = c.g;	710	as_shade.tintColor.green = c.g;
805	shade.tintColor.blue = c.b;	711	as_shade.tintColor.blue = c.b;
		712	tint = shading2tint32 (&as_shade);
806	}	713	}
807	else	714
808	shade.tintColor.red = shade.tintColor.green = shade.tintColor.blue = 0xFFFF;	715	if (rs[Rs_blurradius] && back_im)
809	tint = shading2tint32( &shade );
810	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
811	if (GetWinPosition (parent[0], &root_x, &root_y) )
812	{	716	{
		717	ASImage* tmp;
		718	int junk;
		719	unsigned int hr = 1, vr = 1;
		720	int flags = XParseGeometry (rs[Rs_blurradius], &junk, &junk, &hr, &vr);
		721	if (!(flags&WidthValue))
		722	hr = 1;
		723	if (!(flags&HeightValue))
		724	vr = hr;
		725	tmp = blur_asimage_gauss (asv, back_im, hr, vr, 0xFFFFFFFF,
		726	(bgPixmap.original_asim == NULL \|\| tint == TINT_LEAVE_SAME)?ASA_XImage:ASA_ASImage,
		727	100, ASIMAGE_QUALITY_DEFAULT);
		728	if (tmp)
		729	{
		730	destroy_asimage (&back_im);
		731	back_im = tmp;
		732	}
		733	}
		734
		735	if (bgPixmap.original_asim != NULL)
		736	{
813	ASImageLayer *layers = create_image_layers( 2 );	737	ASImageLayer *layers = create_image_layers (2);
814	ASImage *merged_im = NULL;	738	ASImage *merged_im = NULL;
815	int back_x, back_y, back_w, back_h;	739	int fore_w, fore_h;
816	/* merge_layers does good job at tiling background appropriately,
817	so all we need is to cut out smallest possible piece : */
818	#define MAKE_ROOTPMAP_GEOM(xy,wh,widthheight) \
819	do{ while( root_##xy < 0 ) root_##xy += (int)wrootattr.widthheight; \
820	back_##xy = root_##xy % pmap_##wh; /* that gives us left side of the closest tile : */ \
821	if( pmap_##wh >= back_##xy + szHint.widthheight ) \
822	back_##wh = szHint.widthheight;/* background is large - limit it by our size */ \
823	else \
824	{ /* small background - need the whole of it for successfull tiling :*/ \
825	back_##xy = 0; \
826	back_##wh = pmap_##wh; \
827	}}while(0)
828
829	MAKE_ROOTPMAP_GEOM(x,w,width);
830	MAKE_ROOTPMAP_GEOM(y,h,height);
831		740
832	layers[0].im = pixmap2asimage (display->asv, rootpixmap, back_x, back_y, back_w, back_h, AllPlanes, ASA_ASImage, 100);	741	layers[0].im = back_im;
833	layers[0].clip_x = (back_w == pmap_w)?root_x:0;
834	layers[0].clip_y = (back_h == pmap_h)?root_y:0;
835	layers[0].clip_width = szHint.width;	742	layers[0].clip_width = szHint.width;
836	layers[0].clip_height = szHint.height;	743	layers[0].clip_height = szHint.height;
837	layers[0].tint = tint;	744	layers[0].tint = tint;
838	if (rs[Rs_blurradius] && layers[0].im)	745	layers[1].im = bgPixmap.original_asim;
839	{	746	if (bgPixmap.auto_resize)
840	double r = atof(rs[Rs_blurradius]);
841	ASImage* tmp = blur_asimage_gauss(display->asv, layers[0].im, r, r, 0xFFFFFFFF, ASA_ASImage, 100, ASIMAGE_QUALITY_DEFAULT );
842	if( tmp )
843	{	747	{
844	destroy_asimage( &layers[0].im );
845	layers[0].im = tmp;
846	}
847	}
848	if (original_asim != NULL)
849	{
850	int fore_w, fore_h;
851	layers[1].im = original_asim;
852	if( bgPixmap.auto_resize )
853	{
854	fore_w = szHint.width;	748	fore_w = szHint.width;
855	fore_h = szHint.height;	749	fore_h = szHint.height;
856	}	750	}
857	else	751	else
858	{	752	{
859	fore_w = bgPixmap.w;	753	fore_w = (bgPixmap.w == 0) ? bgPixmap.original_asim->width : bgPixmap.w;
860	fore_h = bgPixmap.h;	754	fore_h = (bgPixmap.h == 0) ? bgPixmap.original_asim->height : bgPixmap.h;
861	}	755	}
862	if (fore_w != original_asim->width	756	if (fore_w != bgPixmap.original_asim->width
863	\|\| fore_h != original_asim->height)	757	\|\| fore_h != bgPixmap.original_asim->height)
864	{	758	{
865	layers[1].im = scale_asimage( display->asv,	759	layers[1].im = scale_asimage (asv,
866	original_asim,	760	bgPixmap.original_asim,
867	fore_w, fore_h,	761	fore_w, fore_h,
868	ASA_ASImage, 100,	762	ASA_ASImage, 100,
869	ASIMAGE_QUALITY_DEFAULT );	763	ASIMAGE_QUALITY_DEFAULT);
870	}	764	}
871
872	layers[1].clip_width = szHint.width;	765	layers[1].clip_width = szHint.width;
873	layers[1].clip_height = szHint.height;	766	layers[1].clip_height = szHint.height;
874		767
875	if (rs[Rs_blendtype])	768	if (rs[Rs_blendtype])
876	{	769	{
877	layers[1].merge_scanlines = blend_scanlines_name2func(rs[Rs_blendtype]);	770	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
878	if( layers[1].merge_scanlines == NULL )	771	if (layers[1].merge_scanlines == NULL)
879	layers[1].merge_scanlines = alphablend_scanlines;	772	layers[1].merge_scanlines = alphablend_scanlines;
880	}	773	}
881	}	774	PRINT_BACKGROUND_OP_TIME;
882	merged_im = merge_layers( display->asv, layers, layers[1].im?2:1,	775	merged_im = merge_layers (asv, layers, 2, szHint.width, szHint.height,
883	szHint.width, szHint.height,
884	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT );	776	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
885	if (layers[1].im != original_asim)	777	if (layers[1].im != bgPixmap.original_asim)
886	destroy_asimage( &(layers[1].im) );	778	destroy_asimage (&(layers[1].im));
887	destroy_asimage( &(layers[0].im) );	779	free (layers);
		780
888	if (merged_im != NULL)	781	if (merged_im != NULL)
889	{	782	{
890	tmp_pmap = asimage2pixmap( display->asv, DefaultRootWindow(dpy), merged_im, gc, True );
891	destroy_asimage( &merged_im );	783	destroy_asimage (&back_im);
		784	back_im = merged_im;
892	}	785	}
893	free( layers );	786	PRINT_BACKGROUND_OP_TIME;
894	}	787	}
		788	else if (tint != TINT_LEAVE_SAME)
		789	{
		790	ASImage* tmp = tile_asimage (asv, back_im, 0, 0, szHint.width, szHint.height, tint, ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
		791	if (tmp)
		792	{
		793	destroy_asimage (&back_im);
		794	back_im = tmp;
		795	}
		796	PRINT_BACKGROUND_OP_TIME;
		797	}
		798	asimage2drawable (asv, bgPixmap.pixmap, back_im, gc, 0, 0, 0, 0, szHint.width, szHint.height, True);
		799	destroy_asimage (&back_im);
		800	} /* back_im != NULL */
		801	else
		802	success = False;
895	}	803	}
896	if (tmp_pmap != None)
897	{
898	success = True;
899	if (pixmap != None)
900	XFreePixmap (dpy, pixmap);
901	pixmap = tmp_pmap;
902	}
903	}
904	#else /* HAVE_AFTERIMAGE */	804	#else /* HAVE_AFTERIMAGE */
905	{
906	/*
907	* Copy display->root pixmap transparency
908	*/
909	int nx, ny;
910	unsigned int nw, nh;
911	XImage *image;
912
913	nw = (unsigned int)szHint.width;
914	nh = (unsigned int)szHint.height;
915	nx = ny = 0;
916
917	if (sx < 0)
918	{
919	nw += sx;
920	nx = -sx;
921	sx = 0;
922	}
923
924	if (sy < 0)
925	{
926	nh += sy;
927	ny = -sy;
928	sy = 0;
929	}
930
931	min_it (nw, (unsigned int) (wrootattr.width - sx));
932	min_it (nh, (unsigned int) (wrootattr.height - sy));
933
934	XSync (dpy, False);
935	allowedxerror = -1;
936	image = XGetImage (dpy, rootpixmap, sx, sy, nw, nh, AllPlanes, ZPixmap);
937
938	/* XXX: handle BadMatch - usually because we're outside the pixmap */
939	/* XXX: may need a delay here? */
940	allowedxerror = 0;
941	if (image != NULL)
942	{
943	if (pixmap != None)
944	XFreePixmap (dpy, pixmap);
945
946	#if TINTING	805	#if TINTING
947	if (ISSET_PIXCOLOR (Color_tint))	806	if (!whole_tint && (!no_tint \|\| shade !=100))
		807	{
		808	XImage *image = XGetImage (dpy, bgPixmap.pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);
		809	success = False;
		810	if (image != NULL)
948	{	811	{
949	int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;	812	PRINT_BACKGROUND_OP_TIME;
950		813	if (gc == NULL)
951	rgba c;	814	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
952	pix_colors_focused [Color_tint].get (c);	815	if (ISSET_PIXCOLOR (Color_tint) \|\| shade != 100)
953	ShadeXImage (this, image, shade, c.r, c.g, c.b);	816	ShadeXImage (this, image, shade, c.r, c.g, c.b);
		817	XPutImage (dpy, bgPixmap.pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);
		818	XDestroyImage (image);
		819	success = True;
954	}	820	}
		821	}
955	#endif	822	#endif
956
957	pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, image->depth);
958	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
959	XPutImage (dpy, pixmap, gc, image, 0, 0,
960	nx, ny, image->width, image->height);
961	XDestroyImage (image);
962	success = True ;
963	}
964	}
965	#endif /* HAVE_AFTERIMAGE */	823	#endif /* HAVE_AFTERIMAGE */
		824	PRINT_BACKGROUND_OP_TIME;
		825
966	if (gc != NULL)	826	if (gc != NULL)
967	XFreeGC (dpy, gc);	827	XFreeGC (dpy, gc);
968		828
969	if (!success)	829	if (!success)
970	{	830	{
971	if (am_transparent && am_pixmap_trans)	831	if (am_transparent && am_pixmap_trans)
972	{	832	{
973	pchanged = 1;	833	pchanged = 1;
974	if (pixmap != None)	834	if (bgPixmap.pixmap != None)
975	{	835	{
976	XFreePixmap (dpy, pixmap);	836	XFreePixmap (dpy, bgPixmap.pixmap);
977	pixmap = None;	837	bgPixmap.pixmap = None;
978	}	838	}
979	}	839	}
980		840
981	am_pixmap_trans = 0;	841	am_pixmap_trans = 0;
982	}	842	}
983	else	843	else
984	{	844	{
985	XSetWindowBackgroundPixmap (dpy, parent[0], pixmap);	845	XSetWindowBackgroundPixmap (dpy, parent[0], bgPixmap.pixmap);
986	XClearWindow (dpy, parent[0]);	846	XClearWindow (dpy, parent[0]);
987		847
988	if (!am_transparent \|\| !am_pixmap_trans)	848	if (!am_transparent \|\| !am_pixmap_trans)
989	pchanged = 1;	849	pchanged = 1;
990		850
991	am_transparent = am_pixmap_trans = 1;	851	am_transparent = am_pixmap_trans = 1;
992	}	852	}
993	}	853	} /* rootpixmap != None */
994		854
995	if (am_pixmap_trans)	855	if (am_pixmap_trans)
996	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);	856	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
997	else	857	else
998	{	858	{

Diff Legend

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

Comparing rxvt-unicode/src/xpm.C (file contents): Revision 1.44 by ayin, Sat Jun 30 23:34:57 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.44 by ayin, Sat Jun 30 23:34:57 2007 UTC vs.
Revision 1.55 by sasha, Fri Aug 3 05:33:04 2007 UTC