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

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.49 by sasha, Thu Jul 26 21:14:51 2007 UTC vs.
Revision 1.53 by sasha, Tue Jul 31 22:24:36 2007 UTC

…		…
231	if (n < MAXLEN_GEOM)	231	if (n < MAXLEN_GEOM)
232	{	232	{
233	strncpy (str, geom, n);	233	strncpy (str, geom, n);
234	str[n] = '\0';	234	str[n] = '\0';
235		235
236	if (strcmp(str, "auto") == 0)	236	if (strcmp(str, "auto") == 0)
237	{	237	{
238	if (!bgpixmap->auto_resize)	238	if (!bgpixmap->auto_resize)
239	changed++;	239	changed++;
240	bgpixmap->auto_resize = True ;	240	bgpixmap->auto_resize = True ;
241	w = szHint.width ;	241	w = szHint.width ;
242	h = szHint.height ;	242	h = szHint.height ;
243	flags = WidthValue\|HeightValue ;	243	flags = WidthValue\|HeightValue ;
244	}	244	}
245	else	245	else
246	{	246	{
247	bgpixmap->auto_resize = False ;	247	bgpixmap->auto_resize = False ;
248	flags = XParseGeometry (str, &x, &y, &w, &h);	248	flags = XParseGeometry (str, &x, &y, &w, &h);
249	}	249	}
250		250
251	if (!flags)	251	if (!flags)
252	{	252	{
…		…
357	unsigned int w = bgPixmap.w, h = bgPixmap.h,	357	unsigned int w = bgPixmap.w, h = bgPixmap.h,
358	x = bgPixmap.x, y = bgPixmap.y;	358	x = bgPixmap.x, y = bgPixmap.y;
359	unsigned int xpmh = xpmAttr.height,	359	unsigned int xpmh = xpmAttr.height,
360	xpmw = xpmAttr.width;	360	xpmw = xpmAttr.width;
361		361
362	if (bgPixmap.auto_resize)	362	if (bgPixmap.auto_resize)
363	{	363	{
364	w = szHint.width ;	364	w = szHint.width ;
365	h = szHint.height ;	365	h = szHint.height ;
366	}	366	}
367	/*	367	/*
368	* don't zoom pixmap too much nor expand really small pixmaps	368	* don't zoom pixmap too much nor expand really small pixmaps
369	*/	369	*/
370	if (w > 32767 \|\| h > 32767)	370	if (w > 32767 \|\| h > 32767)
371	w = 1;	371	w = 1;
…		…
389	if (!option(Opt_transparent) \|\| !am_transparent)	389	if (!option(Opt_transparent) \|\| !am_transparent)
390	/* will do that in check_our_parents otherwise */	390	/* will do that in check_our_parents otherwise */
391	#endif	391	#endif
392	{	392	{
393	ASImage *scaled_im = scale_asimage (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);
394	if (scaled_im)	394	if (scaled_im)
395	{	395	{
396	pixmap = asimage2pixmap(asv, display->root, scaled_im, gc, True);	396	pixmap = asimage2pixmap(asv, display->root, scaled_im, gc, True);
397	destroy_asimage (&scaled_im);	397	destroy_asimage (&scaled_im);
398	}	398	}
399	}	399	}
…		…
476	* we already have the required attributes	476	* we already have the required attributes
477	*/	477	*/
478	/* XGetWindowAttributes (dpy, vt, &attr); */	478	/* XGetWindowAttributes (dpy, vt, &attr); */
479		479
480	#ifdef HAVE_AFTERIMAGE	480	#ifdef HAVE_AFTERIMAGE
481	if (asimman == NULL)	481	if (asimman == NULL)
482	asimman = create_generic_imageman(rs[Rs_path]);	482	asimman = create_generic_imageman(rs[Rs_path]);
483	if ((f = strchr (file, ';')) == NULL)	483	if ((f = strchr (file, ';')) == NULL)
484	original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );	484	original_asim = get_asimage( asimman, file, 0xFFFFFFFF, 100 );
485	else	485	else
486	{	486	{
487	size_t len = f - file;	487	size_t len = f - file;
488	f = (char *)malloc (len + 1);	488	f = (char *)malloc (len + 1);
489	strncpy (f, file, len);	489	strncpy (f, file, len);
490	f[len] = '\0';	490	f[len] = '\0';
491	original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );	491	original_asim = get_asimage( asimman, f, 0xFFFFFFFF, 100 );
492	free( f );	492	free( f );
493	}	493	}
494	if (original_asim)	494	if (original_asim)
495	{	495	{
496	bgPixmap.pixmap = asimage2pixmap (asv, display->root, original_asim, NULL, True);	496	bgPixmap.pixmap = asimage2pixmap (asv, display->root, original_asim, NULL, True);
497	xpmAttr.width = original_asim->width ;	497	xpmAttr.width = original_asim->width ;
498	xpmAttr.height = original_asim->height ;	498	xpmAttr.height = original_asim->height ;
499	}	499	}
500	#else /* HAVE_AFTERIMAGE */	500	#else /* HAVE_AFTERIMAGE */
501	xpmAttr.closeness = 30000;	501	xpmAttr.closeness = 30000;
502	xpmAttr.colormap = cmap;	502	xpmAttr.colormap = cmap;
503	xpmAttr.visual = visual;	503	xpmAttr.visual = visual;
…		…
776	}	776	}
777		777
778	void	778	void
779	rxvt_term::check_our_parents_cb (time_watcher &w)	779	rxvt_term::check_our_parents_cb (time_watcher &w)
780	{	780	{
781	int i, pchanged, aformat, have_pixmap, rootdepth;	781	int i, pchanged, aformat, rootdepth;
782	unsigned long nitems, bytes_after;	782	unsigned long nitems, bytes_after;
783	Atom atype;	783	Atom atype;
784	unsigned char *prop = NULL;	784	unsigned char *prop = NULL;
785	Window root, oldp, *list;	785	Window root, oldp, *list;
786	Pixmap rootpixmap = None;	786	Pixmap rootpixmap = None;
787	XWindowAttributes wattr, wrootattr;	787	XWindowAttributes wattr, wrootattr;
788	int sx, sy;	788	int sx, sy;
789	Window cr;	789	Window cr;
		790	unsigned int rootpixmap_w = 0, rootpixmap_h = 0;
790		791
791	pchanged = 0;	792	pchanged = 0;
792		793
793	if (!option (Opt_transparent))	794	if (!option (Opt_transparent))
794	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
795		807
796	XGetWindowAttributes (dpy, display->root, &wrootattr);	808	XGetWindowAttributes (dpy, display->root, &wrootattr);
797	rootdepth = wrootattr.depth;	809	rootdepth = wrootattr.depth;
798		810
799	XGetWindowAttributes (dpy, parent[0], &wattr);	811	XGetWindowAttributes (dpy, parent[0], &wattr);
…		…
813	/* 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. */
814	XSync (dpy, False);	826	XSync (dpy, False);
815		827
816	XTranslateCoordinates (dpy, parent[0], display->root,	828	XTranslateCoordinates (dpy, parent[0], display->root,
817	0, 0, &sx, &sy, &cr);	829	0, 0, &sx, &sy, &cr);
818
819	/* 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 : */
820	if( sx + (int)szHint.width <= 0 \|\| sy + (int)szHint.height <= 0	831	if( sx + (int)szHint.width <= 0 \|\| sy + (int)szHint.height <= 0
821	\|\| sx >= wrootattr.width \|\| sy >= wrootattr.height )	832	\|\| sx >= wrootattr.width \|\| sy >= wrootattr.height )
822	return /* 0 */ ;	833	return /* 0 */ ;
823	/*	834	/*
824	* Make the frame window set by the window manager have	835	* Make the frame window set by the window manager have
825	* the root background. Some window managers put multiple nested frame	836	* the root background. Some window managers put multiple nested frame
826	* 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.
…		…
834	i = (xa[XA_ESETROOT_PMAP_ID]	845	i = (xa[XA_ESETROOT_PMAP_ID]
835	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],	846	&& XGetWindowProperty (dpy, display->root, xa[XA_ESETROOT_PMAP_ID],
836	0L, 1L, False, XA_PIXMAP, &atype, &aformat,	847	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
837	&nitems, &bytes_after, &prop) == Success);	848	&nitems, &bytes_after, &prop) == Success);
838		849
		850	/* TODO: the below logic needs to be cleaned up */
839	if (!i \|\| prop == NULL	851	if (!i \|\| prop == NULL
840	#if TINTING	852	#if TINTING
841	\|\| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL	853	\|\| (!ISSET_PIXCOLOR (Color_tint) && rs[Rs_shade] == NULL
842	#ifdef HAVE_AFTERIMAGE	854	#ifdef HAVE_AFTERIMAGE
843	&& original_asim == NULL && rs[Rs_blurradius] == NULL	855	&& original_asim == NULL && rs[Rs_blurradius] == NULL
844	#endif	856	#endif
845	)	857	)
846	#endif	858	#endif
847	)	859	)
848	have_pixmap = 0;	860	rootpixmap = None;
849	else	861	else
850	{	862	{
851	have_pixmap = 1;	863	int junk;
		864	unsigned int ujunk;
		865	/* root pixmap may be bad - allow a error */
		866	allowedxerror = -1;
852	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)
853	XFree (prop);	874	XFree (prop);
854	}
855		875
856	if (have_pixmap)	876	if (rootpixmap != None)
857	{	877	{
858	Bool success = False;	878	Bool success = False;
859	GC gc = NULL;	879	GC gc = NULL;
860	XGCValues gcvalue;	880	XGCValues gcvalue;
861	unsigned int pmap_w = 0, pmap_h = 0;	881	int shade = 100;
		882	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
		883	Bool whole_tint = False, no_tint = True;
862		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;
863	#ifdef HAVE_AFTERIMAGE	936	#ifdef HAVE_AFTERIMAGE
		937	if (rs[Rs_blurradius] \|\| original_asim != NULL \|\| (!whole_tint && (!no_tint \|\| shade !=100)))
864	{	938	{
865	Pixmap tmp_pmap = None;	939	ARGB32 tint = TINT_LEAVE_SAME;
866	ShadingInfo shade;	940	ASImage *back_im = NULL;
867	ARGB32 tint;
868		941
869	if (get_dpy_drawable_size (dpy, rootpixmap, &pmap_w, &pmap_h))	942	back_im = pixmap2ximage (asv, pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, 100);
		943	if (back_im != NULL)
870	{	944	{
871	int root_x = 0, root_y = 0;	945	if (!whole_tint && (!no_tint \|\| shade !=100))
872
873	shade.shading = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
874	if (ISSET_PIXCOLOR (Color_tint))
875	{	946	{
876	rgba c;	947	ShadingInfo as_shade;
877	pix_colors_focused [Color_tint].get (c);	948	as_shade.shading = shade;
878	shade.tintColor.red = c.r;	949	as_shade.tintColor.red = c.r;
879	shade.tintColor.green = c.g;	950	as_shade.tintColor.green = c.g;
880	shade.tintColor.blue = c.b;	951	as_shade.tintColor.blue = c.b;
		952	tint = shading2tint32 (&as_shade);
881	}	953	}
882	else	954
883	shade.tintColor.red = shade.tintColor.green = shade.tintColor.blue = 0xFFFF;	955	if (rs[Rs_blurradius] && back_im)
884	tint = shading2tint32 (&shade);
885	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
886	if (get_dpy_window_position (dpy, display->root, parent[0], NULL, NULL, &root_x, &root_y))
887	{	956	{
		957	ASImage* tmp;
		958	int junk;
		959	unsigned int hr = 1, vr = 1;
		960	int flags = XParseGeometry (rs[Rs_blurradius], &junk, &junk, &hr, &vr);
		961	if (!(flags&WidthValue))
		962	hr = 1;
		963	if (!(flags&HeightValue))
		964	vr = hr;
		965	tmp = blur_asimage_gauss (asv, back_im, hr, vr, 0xFFFFFFFF,
		966	(original_asim == NULL \|\| tint == TINT_LEAVE_SAME)?ASA_XImage:ASA_ASImage,
		967	100, ASIMAGE_QUALITY_DEFAULT);
		968	if (tmp)
		969	{
		970	destroy_asimage (&back_im);
		971	back_im = tmp;
		972	}
		973	}
		974
		975	if (original_asim != NULL)
		976	{
888	ASImageLayer *layers = create_image_layers (2);	977	ASImageLayer *layers = create_image_layers (2);
889	ASImage *merged_im = NULL;	978	ASImage *merged_im = NULL;
890	int back_x, back_y, back_w, back_h;	979	int fore_w, fore_h;
891	/* merge_layers does good job at tiling background appropriately,
892	so all we need is to cut out smallest possible piece : */
893	#define MAKE_ROOTPMAP_GEOM(xy,wh,widthheight) \
894	do{ while( root_##xy < 0 ) root_##xy += (int)wrootattr.widthheight; \
895	back_##xy = root_##xy % pmap_##wh; /* that gives us left side of the closest tile : */ \
896	if( pmap_##wh >= back_##xy + szHint.widthheight ) \
897	back_##wh = szHint.widthheight;/* background is large - limit it by our size */ \
898	else \
899	{ /* small background - need the whole of it for successfull tiling :*/ \
900	back_##xy = 0; \
901	back_##wh = pmap_##wh; \
902	}}while(0)
903
904	MAKE_ROOTPMAP_GEOM(x,w,width);
905	MAKE_ROOTPMAP_GEOM(y,h,height);
906		980
907	layers[0].im = pixmap2asimage (asv, rootpixmap, back_x, back_y, back_w, back_h, AllPlanes, ASA_ASImage, 100);	981	layers[0].im = back_im;
908	layers[0].clip_x = (back_w == pmap_w)?root_x:0;
909	layers[0].clip_y = (back_h == pmap_h)?root_y:0;
910	layers[0].clip_width = szHint.width;	982	layers[0].clip_width = szHint.width;
911	layers[0].clip_height = szHint.height;	983	layers[0].clip_height = szHint.height;
912	layers[0].tint = tint;	984	layers[0].tint = tint;
913	if (rs[Rs_blurradius] && layers[0].im)
914	{
915	double r = atof(rs[Rs_blurradius]);
916	ASImage* tmp = blur_asimage_gauss (asv, layers[0].im, r, r, 0xFFFFFFFF, ASA_ASImage, 100, ASIMAGE_QUALITY_DEFAULT);
917	if (tmp)
918	{
919	destroy_asimage (&layers[0].im);
920	layers[0].im = tmp;
921	}
922	}
923	if (original_asim != NULL)
924	{
925	int fore_w, fore_h;
926	layers[1].im = original_asim;	985	layers[1].im = original_asim;
927	if (bgPixmap.auto_resize)	986	if (bgPixmap.auto_resize)
928	{	987	{
929	fore_w = szHint.width;	988	fore_w = szHint.width;
930	fore_h = szHint.height;	989	fore_h = szHint.height;
931	}	990	}
932	else	991	else
933	{	992	{
934	fore_w = bgPixmap.w;	993	fore_w = bgPixmap.w;
935	fore_h = bgPixmap.h;	994	fore_h = bgPixmap.h;
936	}	995	}
937	if (fore_w != original_asim->width	996	if (fore_w != original_asim->width
938	\|\| fore_h != original_asim->height)	997	\|\| fore_h != original_asim->height)
939	{	998	{
940	layers[1].im = scale_asimage (asv,	999	layers[1].im = scale_asimage (asv,
941	original_asim,	1000	original_asim,
942	fore_w, fore_h,	1001	fore_w, fore_h,
943	ASA_ASImage, 100,	1002	ASA_ASImage, 100,
944	ASIMAGE_QUALITY_DEFAULT);	1003	ASIMAGE_QUALITY_DEFAULT);
945	}	1004	}
946
947	layers[1].clip_width = szHint.width;	1005	layers[1].clip_width = szHint.width;
948	layers[1].clip_height = szHint.height;	1006	layers[1].clip_height = szHint.height;
949		1007
950	if (rs[Rs_blendtype])	1008	if (rs[Rs_blendtype])
951	{	1009	{
952	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);	1010	layers[1].merge_scanlines = blend_scanlines_name2func (rs[Rs_blendtype]);
953	if (layers[1].merge_scanlines == NULL)	1011	if (layers[1].merge_scanlines == NULL)
954	layers[1].merge_scanlines = alphablend_scanlines;	1012	layers[1].merge_scanlines = alphablend_scanlines;
955	}	1013	}
956	}	1014	PRINT_BACKGROUND_OP_TIME;
957	merged_im = merge_layers (asv, layers, layers[1].im?2:1,	1015	merged_im = merge_layers (asv, layers, 2, szHint.width, szHint.height,
958	szHint.width, szHint.height,
959	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);	1016	ASA_XImage, 0, ASIMAGE_QUALITY_DEFAULT);
960	if (layers[1].im != original_asim)	1017	if (layers[1].im != original_asim)
961	destroy_asimage (&(layers[1].im));	1018	destroy_asimage (&(layers[1].im));
962	destroy_asimage (&(layers[0].im));	1019	free (layers);
		1020
963	if (merged_im != NULL)	1021	if (merged_im != NULL)
964	{	1022	{
965	tmp_pmap = asimage2pixmap (asv, DefaultRootWindow(dpy), merged_im, gc, True);
966	destroy_asimage (&merged_im);	1023	destroy_asimage (&back_im);
		1024	back_im = merged_im;
967	}	1025	}
968	free (layers);	1026	PRINT_BACKGROUND_OP_TIME;
969	}	1027	}
		1028	else if (tint != TINT_LEAVE_SAME)
		1029	{
		1030	ASImage* tmp = tile_asimage (asv, back_im, 0, 0, szHint.width, szHint.height, tint, ASA_XImage, 100, ASIMAGE_QUALITY_DEFAULT);
		1031	if (tmp)
		1032	{
		1033	destroy_asimage (&back_im);
		1034	back_im = tmp;
		1035	}
		1036	PRINT_BACKGROUND_OP_TIME;
		1037	}
		1038	asimage2drawable (asv, pixmap, back_im, gc, 0, 0, 0, 0, szHint.width, szHint.height, True);
		1039	destroy_asimage (&back_im);
		1040	} /* back_im != NULL */
		1041	else
		1042	success = False;
970	}	1043	}
971	if (tmp_pmap != None)
972	{
973	success = True;
974	if (pixmap != None)
975	XFreePixmap (dpy, pixmap);
976	pixmap = tmp_pmap;
977	}
978	}
979	#else /* HAVE_AFTERIMAGE */	1044	#else /* HAVE_AFTERIMAGE */
980	{
981	/*
982	* Copy display->root pixmap transparency
983	*/
984	Window wjunk;
985	int junk;
986	unsigned int ujunk;
987	/* root pixmap may be bad - allow a error */
988	allowedxerror = -1;
989	if (XGetGeometry (dpy, rootpixmap, &wjunk, &junk, &junk, &pmap_w, &pmap_h, &ujunk, &ujunk))
990	{
991	XImage *image = NULL;
992	int shade = 100;
993	rgba c (rgba::MAX_CC,rgba::MAX_CC,rgba::MAX_CC);
994	Bool whole_tint = False;
995
996	while (sx < 0) sx += (int)wrootattr.width;
997	while (sy < 0) sy += (int)wrootattr.height;
998
999	if (pixmap != None)
1000	XFreePixmap (dpy, pixmap);
1001	pixmap = XCreatePixmap (dpy, vt, szHint.width, szHint.height, rootdepth);
1002
1003	#if TINTING	1045	#if TINTING
1004	if (rs[Rs_shade])	1046	if (!whole_tint && (!no_tint \|\| shade !=100))
1005	shade = atoi (rs[Rs_shade]);
1006	if (ISSET_PIXCOLOR (Color_tint))
1007	pix_colors_focused [Color_tint].get (c);
1008	#define IS_COMPONENT_WHOLESOME(c) ((c) <=0x000700 \|\| (c)>=0x00f700)
1009	if (shade >= 100)
1010	whole_tint = (IS_COMPONENT_WHOLESOME(c.r)
1011	&& IS_COMPONENT_WHOLESOME(c.g)
1012	&& IS_COMPONENT_WHOLESOME(c.b));
1013	#undef IS_COMPONENT_WHOLESOME
1014
1015	/* If No tinting to be done - simply tile root pixmap on our pixmap -
1016	* no need in XImage at all, thus following if() only for case with tinting */
1017	if (whole_tint \|\| pmap_w < sx + szHint.width \|\| pmap_h < sy + szHint.height)
1018	#endif /* TINTING */
1019	{	1047	{
1020	gcvalue.tile = rootpixmap;
1021	gcvalue.fill_style = FillTiled;
1022	gcvalue.ts_x_origin = -sx;
1023	gcvalue.ts_y_origin = -sy;
1024	gc = XCreateGC (dpy, rootpixmap, GCFillStyle \| GCTile \| GCTileStipXOrigin \| GCTileStipYOrigin, &gcvalue);
1025	XFillRectangle (dpy, pixmap, gc, 0, 0, szHint.width, szHint.height);
1026	#if TINTING
1027	if (whole_tint)
1028	{
1029	/* In this case we can tint image server-side geting significant
1030	* performance improvements, as we eliminate XImage transfer
1031	*/
1032	gcvalue.foreground = Pixel (pix_colors_focused [Color_tint]);
1033	gcvalue.function = GXand;
1034	gcvalue.fill_style = FillSolid;
1035	XChangeGC (dpy, gc, GCFillStyle \| GCForeground \| GCFunction, &gcvalue);
1036	XFillRectangle (dpy, pixmap, gc, 0, 0, szHint.width, szHint.height);
1037	success = True;
1038	}
1039	else
1040	image = XGetImage (dpy, pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);	1048	XImage *image = XGetImage (dpy, pixmap, 0, 0, szHint.width, szHint.height, AllPlanes, ZPixmap);
1041	#else
1042	success = True;	1049	success = False;
1043	#endif /* TINTING */
1044	}
1045	#if TINTING
1046	if (!success && image == NULL)
1047	image = XGetImage (dpy, rootpixmap, sx, sy, szHint.width, szHint.height, AllPlanes, ZPixmap);
1048	if (image != NULL)	1050	if (image != NULL)
1049	{	1051	{
		1052	PRINT_BACKGROUND_OP_TIME;
1050	if (gc == NULL)	1053	if (gc == NULL)
1051	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);	1054	gc = XCreateGC (dpy, vt, 0UL, &gcvalue);
1052	if (ISSET_PIXCOLOR (Color_tint) \|\| shade != 100)	1055	if (ISSET_PIXCOLOR (Color_tint) \|\| shade != 100)
1053	ShadeXImage (this, image, shade, c.r, c.g, c.b);	1056	ShadeXImage (this, image, shade, c.r, c.g, c.b);
1054	XPutImage (dpy, pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);	1057	XPutImage (dpy, pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);
1055	XDestroyImage (image);	1058	XDestroyImage (image);
1056	success = True;	1059	success = True;
1057	}	1060	}
1058	#endif
1059	}	1061	}
1060	allowedxerror = 0;	1062	#endif
1061	}
1062	#endif /* HAVE_AFTERIMAGE */	1063	#endif /* HAVE_AFTERIMAGE */
		1064	PRINT_BACKGROUND_OP_TIME;
		1065
1063	if (gc != NULL)	1066	if (gc != NULL)
1064	XFreeGC (dpy, gc);	1067	XFreeGC (dpy, gc);
1065		1068
1066	if (!success)	1069	if (!success)
1067	{	1070	{
1068	if (am_transparent && am_pixmap_trans)	1071	if (am_transparent && am_pixmap_trans)
…		…
1085	if (!am_transparent \|\| !am_pixmap_trans)	1088	if (!am_transparent \|\| !am_pixmap_trans)
1086	pchanged = 1;	1089	pchanged = 1;
1087		1090
1088	am_transparent = am_pixmap_trans = 1;	1091	am_transparent = am_pixmap_trans = 1;
1089	}	1092	}
1090	}	1093	} /* rootpixmap != None */
1091		1094
1092	if (am_pixmap_trans)	1095	if (am_pixmap_trans)
1093	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);	1096	XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
1094	else	1097	else
1095	{	1098	{

Diff Legend

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

Comparing rxvt-unicode/src/xpm.C (file contents): Revision 1.49 by sasha, Thu Jul 26 21:14:51 2007 UTC vs. Revision 1.53 by sasha, Tue Jul 31 22:24:36 2007 UTC

Diff Legend

Comparing rxvt-unicode/src/xpm.C (file contents):
Revision 1.49 by sasha, Thu Jul 26 21:14:51 2007 UTC vs.
Revision 1.53 by sasha, Tue Jul 31 22:24:36 2007 UTC