upgrade to tcl/tk 8.6.8

1 files changed, 0 insertions, 1999 deletions

diff --git a/tk8.6/generic/tkCanvPoly.c b/tk8.6/generic/tkCanvPoly.c
deleted file mode 100644
index b4ef098..0000000
--- a/tk8.6/generic/tkCanvPoly.c
+++ /dev/null
@@ -1,1999 +0,0 @@
-/*
- * tkCanvPoly.c --
- *
- *	This file implements polygon items for canvas widgets.
- *
- * Copyright (c) 1991-1994 The Regents of the University of California.
- * Copyright (c) 1994-1997 Sun Microsystems, Inc.
- * Copyright (c) 1998-2000 Ajuba Solutions.
- *
- * See the file "license.terms" for information on usage and redistribution of
- * this file, and for a DISCLAIMER OF ALL WARRANTIES.
- */
-
-#include "tkInt.h"
-#include "tkCanvas.h"
-
-/*
- * The structure below defines the record for each polygon item.
- */
-
-typedef struct PolygonItem  {
-    Tk_Item header;		/* Generic stuff that's the same for all
-				 * types. MUST BE FIRST IN STRUCTURE. */
-    Tk_Outline outline;		/* Outline structure */
-    int numPoints;		/* Number of points in polygon. Polygon is
-				 * always closed. */
-    int pointsAllocated;	/* Number of points for which space is
-				 * allocated at *coordPtr. */
-    double *coordPtr;		/* Pointer to malloc-ed array containing x-
-				 * and y-coords of all points in polygon.
-				 * X-coords are even-valued indices, y-coords
-				 * are corresponding odd-valued indices. */
-    int joinStyle;		/* Join style for outline */
-    Tk_TSOffset tsoffset;
-    XColor *fillColor;		/* Foreground color for polygon. */
-    XColor *activeFillColor;	/* Foreground color for polygon if state is
-				 * active. */
-    XColor *disabledFillColor;	/* Foreground color for polygon if state is
-				 * disabled. */
-    Pixmap fillStipple;		/* Stipple bitmap for filling polygon. */
-    Pixmap activeFillStipple;	/* Stipple bitmap for filling polygon if state
-				 * is active. */
-    Pixmap disabledFillStipple;	/* Stipple bitmap for filling polygon if state
-				 * is disabled. */
-    GC fillGC;			/* Graphics context for filling polygon. */
-    const Tk_SmoothMethod *smooth; /* Non-zero means draw shape smoothed (i.e.
-				 * with Bezier splines). */
-    int splineSteps;		/* Number of steps in each spline segment. */
-    int autoClosed;		/* Zero means the given polygon was closed,
-				   one means that we auto closed it. */
-} PolygonItem;
-
-/*
- * Information used for parsing configuration specs:
- */
-
-static const Tk_CustomOption smoothOption = {
-    TkSmoothParseProc, TkSmoothPrintProc, NULL
-};
-static const Tk_CustomOption stateOption = {
-    TkStateParseProc, TkStatePrintProc, INT2PTR(2)
-};
-static const Tk_CustomOption tagsOption = {
-    Tk_CanvasTagsParseProc, Tk_CanvasTagsPrintProc, NULL
-};
-static const Tk_CustomOption dashOption = {
-    TkCanvasDashParseProc, TkCanvasDashPrintProc, NULL
-};
-static const Tk_CustomOption offsetOption = {
-    TkOffsetParseProc, TkOffsetPrintProc,
-    INT2PTR(TK_OFFSET_RELATIVE|TK_OFFSET_INDEX)
-};
-static const Tk_CustomOption pixelOption = {
-    TkPixelParseProc, TkPixelPrintProc, NULL
-};
-
-static const Tk_ConfigSpec configSpecs[] = {
-    {TK_CONFIG_CUSTOM, "-activedash", NULL, NULL,
-	NULL, Tk_Offset(PolygonItem, outline.activeDash),
-	TK_CONFIG_NULL_OK, &dashOption},
-    {TK_CONFIG_COLOR, "-activefill", NULL, NULL,
-	NULL, Tk_Offset(PolygonItem, activeFillColor), TK_CONFIG_NULL_OK, NULL},
-    {TK_CONFIG_COLOR, "-activeoutline", NULL, NULL,
-	NULL, Tk_Offset(PolygonItem, outline.activeColor), TK_CONFIG_NULL_OK, NULL},
-    {TK_CONFIG_BITMAP, "-activeoutlinestipple", NULL, NULL,
-	NULL, Tk_Offset(PolygonItem, outline.activeStipple),
-	TK_CONFIG_NULL_OK, NULL},
-    {TK_CONFIG_BITMAP, "-activestipple", NULL, NULL,
-	NULL, Tk_Offset(PolygonItem, activeFillStipple), TK_CONFIG_NULL_OK, NULL},
-    {TK_CONFIG_CUSTOM, "-activewidth", NULL, NULL,
-	"0.0", Tk_Offset(PolygonItem, outline.activeWidth),
-	TK_CONFIG_DONT_SET_DEFAULT, &pixelOption},
-    {TK_CONFIG_CUSTOM, "-dash", NULL, NULL,
-	NULL, Tk_Offset(PolygonItem, outline.dash),
-	TK_CONFIG_NULL_OK, &dashOption},
-    {TK_CONFIG_PIXELS, "-dashoffset", NULL, NULL,
-	"0", Tk_Offset(PolygonItem, outline.offset),
-	TK_CONFIG_DONT_SET_DEFAULT, NULL},
-    {TK_CONFIG_CUSTOM, "-disableddash", NULL, NULL,
-	NULL, Tk_Offset(PolygonItem, outline.disabledDash),
-	TK_CONFIG_NULL_OK, &dashOption},
-    {TK_CONFIG_COLOR, "-disabledfill", NULL, NULL,
-	NULL, Tk_Offset(PolygonItem, disabledFillColor), TK_CONFIG_NULL_OK, NULL},
-    {TK_CONFIG_COLOR, "-disabledoutline", NULL, NULL,
-	NULL, Tk_Offset(PolygonItem, outline.disabledColor),
-	TK_CONFIG_NULL_OK, NULL},
-    {TK_CONFIG_BITMAP, "-disabledoutlinestipple", NULL, NULL,
-	NULL, Tk_Offset(PolygonItem, outline.disabledStipple),
-	TK_CONFIG_NULL_OK, NULL},
-    {TK_CONFIG_BITMAP, "-disabledstipple", NULL, NULL,
-	NULL, Tk_Offset(PolygonItem, disabledFillStipple), TK_CONFIG_NULL_OK, NULL},
-    {TK_CONFIG_CUSTOM, "-disabledwidth", NULL, NULL,
-	"0.0", Tk_Offset(PolygonItem, outline.disabledWidth),
-	TK_CONFIG_DONT_SET_DEFAULT, &pixelOption},
-    {TK_CONFIG_COLOR, "-fill", NULL, NULL,
-	"black", Tk_Offset(PolygonItem, fillColor), TK_CONFIG_NULL_OK, NULL},
-    {TK_CONFIG_JOIN_STYLE, "-joinstyle", NULL, NULL,
-	"round", Tk_Offset(PolygonItem, joinStyle), TK_CONFIG_DONT_SET_DEFAULT, NULL},
-    {TK_CONFIG_CUSTOM, "-offset", NULL, NULL,
-	"0,0", Tk_Offset(PolygonItem, tsoffset),
-	TK_CONFIG_NULL_OK, &offsetOption},
-    {TK_CONFIG_COLOR, "-outline", NULL, NULL,
-	NULL, Tk_Offset(PolygonItem, outline.color), TK_CONFIG_NULL_OK, NULL},
-    {TK_CONFIG_CUSTOM, "-outlineoffset", NULL, NULL,
-	"0,0", Tk_Offset(PolygonItem, outline.tsoffset),
-	TK_CONFIG_NULL_OK, &offsetOption},
-    {TK_CONFIG_BITMAP, "-outlinestipple", NULL, NULL,
-	NULL, Tk_Offset(PolygonItem, outline.stipple), TK_CONFIG_NULL_OK, NULL},
-    {TK_CONFIG_CUSTOM, "-smooth", NULL, NULL,
-	"0", Tk_Offset(PolygonItem, smooth),
-	TK_CONFIG_DONT_SET_DEFAULT, &smoothOption},
-    {TK_CONFIG_INT, "-splinesteps", NULL, NULL,
-	"12", Tk_Offset(PolygonItem, splineSteps), TK_CONFIG_DONT_SET_DEFAULT, NULL},
-    {TK_CONFIG_CUSTOM, "-state", NULL, NULL,
-	NULL, Tk_Offset(Tk_Item, state), TK_CONFIG_NULL_OK, &stateOption},
-    {TK_CONFIG_BITMAP, "-stipple", NULL, NULL,
-	NULL, Tk_Offset(PolygonItem, fillStipple), TK_CONFIG_NULL_OK, NULL},
-    {TK_CONFIG_CUSTOM, "-tags", NULL, NULL,
-	NULL, 0, TK_CONFIG_NULL_OK, &tagsOption},
-    {TK_CONFIG_CUSTOM, "-width", NULL, NULL,
-	"1.0", Tk_Offset(PolygonItem, outline.width),
-	TK_CONFIG_DONT_SET_DEFAULT, &pixelOption},
-    {TK_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0, NULL}
-};
-
-/*
- * Prototypes for functions defined in this file:
- */
-
-static void		ComputePolygonBbox(Tk_Canvas canvas,
-			    PolygonItem *polyPtr);
-static int		ConfigurePolygon(Tcl_Interp *interp,
-			    Tk_Canvas canvas, Tk_Item *itemPtr, int objc,
-			    Tcl_Obj *const objv[], int flags);
-static int		CreatePolygon(Tcl_Interp *interp,
-			    Tk_Canvas canvas, struct Tk_Item *itemPtr,
-			    int objc, Tcl_Obj *const objv[]);
-static void		DeletePolygon(Tk_Canvas canvas,
-			    Tk_Item *itemPtr,  Display *display);
-static void		DisplayPolygon(Tk_Canvas canvas,
-			    Tk_Item *itemPtr, Display *display, Drawable dst,
-			    int x, int y, int width, int height);
-static int		GetPolygonIndex(Tcl_Interp *interp,
-			    Tk_Canvas canvas, Tk_Item *itemPtr,
-			    Tcl_Obj *obj, int *indexPtr);
-static int		PolygonCoords(Tcl_Interp *interp,
-			    Tk_Canvas canvas, Tk_Item *itemPtr,
-			    int objc, Tcl_Obj *const objv[]);
-static void		PolygonDeleteCoords(Tk_Canvas canvas,
-			    Tk_Item *itemPtr, int first, int last);
-static void		PolygonInsert(Tk_Canvas canvas,
-			    Tk_Item *itemPtr, int beforeThis, Tcl_Obj *obj);
-static int		PolygonToArea(Tk_Canvas canvas,
-			    Tk_Item *itemPtr, double *rectPtr);
-static double		PolygonToPoint(Tk_Canvas canvas,
-			    Tk_Item *itemPtr, double *pointPtr);
-static int		PolygonToPostscript(Tcl_Interp *interp,
-			    Tk_Canvas canvas, Tk_Item *itemPtr, int prepass);
-static void		ScalePolygon(Tk_Canvas canvas,
-			    Tk_Item *itemPtr, double originX, double originY,
-			    double scaleX, double scaleY);
-static void		TranslatePolygon(Tk_Canvas canvas,
-			    Tk_Item *itemPtr, double deltaX, double deltaY);
-
-/*
- * The structures below defines the polygon item type by means of functions
- * that can be invoked by generic item code.
- */
-
-Tk_ItemType tkPolygonType = {
-    "polygon",				/* name */
-    sizeof(PolygonItem),		/* itemSize */
-    CreatePolygon,			/* createProc */
-    configSpecs,			/* configSpecs */
-    ConfigurePolygon,			/* configureProc */
-    PolygonCoords,			/* coordProc */
-    DeletePolygon,			/* deleteProc */
-    DisplayPolygon,			/* displayProc */
-    TK_CONFIG_OBJS | TK_MOVABLE_POINTS,	/* flags */
-    PolygonToPoint,			/* pointProc */
-    PolygonToArea,			/* areaProc */
-    PolygonToPostscript,		/* postscriptProc */
-    ScalePolygon,			/* scaleProc */
-    TranslatePolygon,			/* translateProc */
-    GetPolygonIndex,	/* indexProc */
-    NULL,				/* icursorProc */
-    NULL,				/* selectionProc */
-    PolygonInsert,		/* insertProc */
-    PolygonDeleteCoords,		/* dTextProc */
-    NULL,				/* nextPtr */
-    NULL, 0, NULL, NULL
-};
-
-/*
- * The definition below determines how large are static arrays used to hold
- * spline points (splines larger than this have to have their arrays
- * malloc-ed).
- */
-
-#define MAX_STATIC_POINTS 200
-
-/*
- *--------------------------------------------------------------
- *
- * CreatePolygon --
- *
- *	This function is invoked to create a new polygon item in a canvas.
- *
- * Results:
- *	A standard Tcl return value. If an error occurred in creating the
- *	item, then an error message is left in the interp's result; in this
- *	case itemPtr is left uninitialized, so it can be safely freed by the
- *	caller.
- *
- * Side effects:
- *	A new polygon item is created.
- *
- *--------------------------------------------------------------
- */
-
-static int
-CreatePolygon(
-    Tcl_Interp *interp,		/* Interpreter for error reporting. */
-    Tk_Canvas canvas,		/* Canvas to hold new item. */
-    Tk_Item *itemPtr,		/* Record to hold new item; header has been
-				 * initialized by caller. */
-    int objc,			/* Number of arguments in objv. */
-    Tcl_Obj *const objv[])	/* Arguments describing polygon. */
-{
-    PolygonItem *polyPtr = (PolygonItem *) itemPtr;
-    int i;
-
-    if (objc == 0) {
-	Tcl_Panic("canvas did not pass any coords");
-    }
-
-    /*
-     * Carry out initialization that is needed in order to clean up after
-     * errors during the the remainder of this function.
-     */
-
-    Tk_CreateOutline(&polyPtr->outline);
-    polyPtr->numPoints = 0;
-    polyPtr->pointsAllocated = 0;
-    polyPtr->coordPtr = NULL;
-    polyPtr->joinStyle = JoinRound;
-    polyPtr->tsoffset.flags = 0;
-    polyPtr->tsoffset.xoffset = 0;
-    polyPtr->tsoffset.yoffset = 0;
-    polyPtr->fillColor = NULL;
-    polyPtr->activeFillColor = NULL;
-    polyPtr->disabledFillColor = NULL;
-    polyPtr->fillStipple = None;
-    polyPtr->activeFillStipple = None;
-    polyPtr->disabledFillStipple = None;
-    polyPtr->fillGC = None;
-    polyPtr->smooth = NULL;
-    polyPtr->splineSteps = 12;
-    polyPtr->autoClosed = 0;
-
-    /*
-     * Count the number of points and then parse them into a point array.
-     * Leading arguments are assumed to be points if they start with a digit
-     * or a minus sign followed by a digit.
-     */
-
-    for (i = 0; i < objc; i++) {
-	const char *arg = Tcl_GetString(objv[i]);
-
-	if ((arg[0] == '-') && (arg[1] >= 'a') && (arg[1] <= 'z')) {
-	    break;
-	}
-    }
-    if (i && PolygonCoords(interp, canvas, itemPtr, i, objv) != TCL_OK) {
-	goto error;
-    }
-
-    if (ConfigurePolygon(interp, canvas, itemPtr, objc-i, objv+i, 0)
-	    == TCL_OK) {
-	return TCL_OK;
-    }
-
-  error:
-    DeletePolygon(canvas, itemPtr, Tk_Display(Tk_CanvasTkwin(canvas)));
-    return TCL_ERROR;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * PolygonCoords --
- *
- *	This function is invoked to process the "coords" widget command on
- *	polygons. See the user documentation for details on what it does.
- *
- * Results:
- *	Returns TCL_OK or TCL_ERROR, and sets the interp's result.
- *
- * Side effects:
- *	The coordinates for the given item may be changed.
- *
- *--------------------------------------------------------------
- */
-
-static int
-PolygonCoords(
-    Tcl_Interp *interp,		/* Used for error reporting. */
-    Tk_Canvas canvas,		/* Canvas containing item. */
-    Tk_Item *itemPtr,		/* Item whose coordinates are to be read or
-				 * modified. */
-    int objc,			/* Number of coordinates supplied in objv. */
-    Tcl_Obj *const objv[])	/* Array of coordinates: x1, y1, x2, y2, ... */
-{
-    PolygonItem *polyPtr = (PolygonItem *) itemPtr;
-    int i, numPoints;
-
-    if (objc == 0) {
-	/*
-	 * Print the coords used to create the polygon. If we auto closed the
-	 * polygon then we don't report the last point.
-	 */
-
-	Tcl_Obj *subobj, *obj = Tcl_NewObj();
-
-	for (i = 0; i < 2*(polyPtr->numPoints - polyPtr->autoClosed); i++) {
-	    subobj = Tcl_NewDoubleObj(polyPtr->coordPtr[i]);
-	    Tcl_ListObjAppendElement(interp, obj, subobj);
-	}
-	Tcl_SetObjResult(interp, obj);
-	return TCL_OK;
-    }
-    if (objc == 1) {
-	if (Tcl_ListObjGetElements(interp, objv[0], &objc,
-		(Tcl_Obj ***) &objv) != TCL_OK) {
-	    return TCL_ERROR;
-	}
-    }
-    if (objc & 1) {
-	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		"wrong # coordinates: expected an even number, got %d",
-		objc));
-	Tcl_SetErrorCode(interp, "TK", "CANVAS", "COORDS", "POLYGON", NULL);
-	return TCL_ERROR;
-    }
-
-    numPoints = objc/2;
-    if (polyPtr->pointsAllocated <= numPoints) {
-	if (polyPtr->coordPtr != NULL) {
-	    ckfree(polyPtr->coordPtr);
-	}
-
-	/*
-	 * One extra point gets allocated here, because we always add
-	 * another point to close the polygon.
-	 */
-
-	polyPtr->coordPtr = ckalloc(sizeof(double) * (objc+2));
-	polyPtr->pointsAllocated = numPoints+1;
-    }
-    for (i = objc-1; i >= 0; i--) {
-	if (Tk_CanvasGetCoordFromObj(interp, canvas, objv[i],
-		&polyPtr->coordPtr[i]) != TCL_OK) {
-	    return TCL_ERROR;
-	}
-    }
-    polyPtr->numPoints = numPoints;
-    polyPtr->autoClosed = 0;
-
-    /*
-     * Close the polygon if it isn't already closed.
-     */
-
-    if (objc>2 && ((polyPtr->coordPtr[objc-2] != polyPtr->coordPtr[0])
-	    || (polyPtr->coordPtr[objc-1] != polyPtr->coordPtr[1]))) {
-	polyPtr->autoClosed = 1;
-	polyPtr->numPoints++;
-	polyPtr->coordPtr[objc] = polyPtr->coordPtr[0];
-	polyPtr->coordPtr[objc+1] = polyPtr->coordPtr[1];
-    }
-
-    ComputePolygonBbox(canvas, polyPtr);
-    return TCL_OK;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * ConfigurePolygon --
- *
- *	This function is invoked to configure various aspects of a polygon
- *	item such as its background color.
- *
- * Results:
- *	A standard Tcl result code. If an error occurs, then an error message
- *	is left in the interp's result.
- *
- * Side effects:
- *	Configuration information, such as colors and stipple patterns, may be
- *	set for itemPtr.
- *
- *--------------------------------------------------------------
- */
-
-static int
-ConfigurePolygon(
-    Tcl_Interp *interp,		/* Interpreter for error reporting. */
-    Tk_Canvas canvas,		/* Canvas containing itemPtr. */
-    Tk_Item *itemPtr,		/* Polygon item to reconfigure. */
-    int objc,			/* Number of elements in objv.  */
-    Tcl_Obj *const objv[],	/* Arguments describing things to configure. */
-    int flags)			/* Flags to pass to Tk_ConfigureWidget. */
-{
-    PolygonItem *polyPtr = (PolygonItem *) itemPtr;
-    XGCValues gcValues;
-    GC newGC;
-    unsigned long mask;
-    Tk_Window tkwin;
-    XColor *color;
-    Pixmap stipple;
-    Tk_State state;
-
-    tkwin = Tk_CanvasTkwin(canvas);
-    if (TCL_OK != Tk_ConfigureWidget(interp, tkwin, configSpecs, objc,
-	    (const char **) objv, (char *) polyPtr, flags|TK_CONFIG_OBJS)) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * A few of the options require additional processing, such as graphics
-     * contexts.
-     */
-
-    state = itemPtr->state;
-
-    if (polyPtr->outline.activeWidth > polyPtr->outline.width ||
-	    polyPtr->outline.activeDash.number != 0 ||
-	    polyPtr->outline.activeColor != NULL ||
-	    polyPtr->outline.activeStipple != None ||
-	    polyPtr->activeFillColor != NULL ||
-	    polyPtr->activeFillStipple != None) {
-	itemPtr->redraw_flags |= TK_ITEM_STATE_DEPENDANT;
-    } else {
-	itemPtr->redraw_flags &= ~TK_ITEM_STATE_DEPENDANT;
-    }
-
-    if (state == TK_STATE_NULL) {
-	state = Canvas(canvas)->canvas_state;
-    }
-    if (state == TK_STATE_HIDDEN) {
-	ComputePolygonBbox(canvas, polyPtr);
-	return TCL_OK;
-    }
-
-    mask = Tk_ConfigOutlineGC(&gcValues, canvas, itemPtr, &polyPtr->outline);
-    if (mask) {
-	gcValues.cap_style = CapRound;
-	gcValues.join_style = polyPtr->joinStyle;
-	mask |= GCCapStyle|GCJoinStyle;
-	newGC = Tk_GetGC(tkwin, mask, &gcValues);
-    } else {
-	newGC = None;
-    }
-    if (polyPtr->outline.gc != None) {
-	Tk_FreeGC(Tk_Display(tkwin), polyPtr->outline.gc);
-    }
-    polyPtr->outline.gc = newGC;
-
-    color = polyPtr->fillColor;
-    stipple = polyPtr->fillStipple;
-    if (Canvas(canvas)->currentItemPtr == itemPtr) {
-	if (polyPtr->activeFillColor != NULL) {
-	    color = polyPtr->activeFillColor;
-	}
-	if (polyPtr->activeFillStipple != None) {
-	    stipple = polyPtr->activeFillStipple;
-	}
-    } else if (state == TK_STATE_DISABLED) {
-	if (polyPtr->disabledFillColor != NULL) {
-	    color = polyPtr->disabledFillColor;
-	}
-	if (polyPtr->disabledFillStipple != None) {
-	    stipple = polyPtr->disabledFillStipple;
-	}
-    }
-
-    if (color == NULL) {
-	newGC = None;
-    } else {
-	gcValues.foreground = color->pixel;
-	mask = GCForeground;
-	if (stipple != None) {
-	    gcValues.stipple = stipple;
-	    gcValues.fill_style = FillStippled;
-	    mask |= GCStipple|GCFillStyle;
-	}
-#ifdef MAC_OSX_TK
-	/*
-	 * Mac OS X CG drawing needs access to the outline linewidth
-	 * even for fills (as linewidth controls antialiasing).
-	 */
-	gcValues.line_width = polyPtr->outline.gc != None ?
-		polyPtr->outline.gc->line_width : 0;
-	mask |= GCLineWidth;
-#endif
-	newGC = Tk_GetGC(tkwin, mask, &gcValues);
-    }
-    if (polyPtr->fillGC != None) {
-	Tk_FreeGC(Tk_Display(tkwin), polyPtr->fillGC);
-    }
-    polyPtr->fillGC = newGC;
-
-    /*
-     * Keep spline parameters within reasonable limits.
-     */
-
-    if (polyPtr->splineSteps < 1) {
-	polyPtr->splineSteps = 1;
-    } else if (polyPtr->splineSteps > 100) {
-	polyPtr->splineSteps = 100;
-    }
-
-    ComputePolygonBbox(canvas, polyPtr);
-    return TCL_OK;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * DeletePolygon --
- *
- *	This function is called to clean up the data structure associated with
- *	a polygon item.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Resources associated with itemPtr are released.
- *
- *--------------------------------------------------------------
- */
-
-static void
-DeletePolygon(
-    Tk_Canvas canvas,		/* Info about overall canvas widget. */
-    Tk_Item *itemPtr,		/* Item that is being deleted. */
-    Display *display)		/* Display containing window for canvas. */
-{
-    PolygonItem *polyPtr = (PolygonItem *) itemPtr;
-
-    Tk_DeleteOutline(display, &polyPtr->outline);
-    if (polyPtr->coordPtr != NULL) {
-	ckfree(polyPtr->coordPtr);
-    }
-    if (polyPtr->fillColor != NULL) {
-	Tk_FreeColor(polyPtr->fillColor);
-    }
-    if (polyPtr->activeFillColor != NULL) {
-	Tk_FreeColor(polyPtr->activeFillColor);
-    }
-    if (polyPtr->disabledFillColor != NULL) {
-	Tk_FreeColor(polyPtr->disabledFillColor);
-    }
-    if (polyPtr->fillStipple != None) {
-	Tk_FreeBitmap(display, polyPtr->fillStipple);
-    }
-    if (polyPtr->activeFillStipple != None) {
-	Tk_FreeBitmap(display, polyPtr->activeFillStipple);
-    }
-    if (polyPtr->disabledFillStipple != None) {
-	Tk_FreeBitmap(display, polyPtr->disabledFillStipple);
-    }
-    if (polyPtr->fillGC != None) {
-	Tk_FreeGC(display, polyPtr->fillGC);
-    }
-}
-
-/*
- *--------------------------------------------------------------
- *
- * ComputePolygonBbox --
- *
- *	This function is invoked to compute the bounding box of all the pixels
- *	that may be drawn as part of a polygon.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	The fields x1, y1, x2, and y2 are updated in the header for itemPtr.
- *
- *--------------------------------------------------------------
- */
-
-static void
-ComputePolygonBbox(
-    Tk_Canvas canvas,		/* Canvas that contains item. */
-    PolygonItem *polyPtr)	/* Item whose bbox is to be recomputed. */
-{
-    double *coordPtr;
-    int i;
-    double width;
-    Tk_State state = polyPtr->header.state;
-    Tk_TSOffset *tsoffset;
-
-    if (state == TK_STATE_NULL) {
-	state = Canvas(canvas)->canvas_state;
-    }
-    width = polyPtr->outline.width;
-    if (polyPtr->coordPtr == NULL || (polyPtr->numPoints < 1)
-	    || (state == TK_STATE_HIDDEN)) {
-	polyPtr->header.x1 = polyPtr->header.x2 =
-		polyPtr->header.y1 = polyPtr->header.y2 = -1;
-	return;
-    }
-    if (Canvas(canvas)->currentItemPtr == (Tk_Item *) polyPtr) {
-	if (polyPtr->outline.activeWidth > width) {
-	    width = polyPtr->outline.activeWidth;
-	}
-    } else if (state == TK_STATE_DISABLED) {
-	if (polyPtr->outline.disabledWidth > 0.0) {
-	    width = polyPtr->outline.disabledWidth;
-	}
-    }
-
-    coordPtr = polyPtr->coordPtr;
-    polyPtr->header.x1 = polyPtr->header.x2 = (int) *coordPtr;
-    polyPtr->header.y1 = polyPtr->header.y2 = (int) coordPtr[1];
-
-    /*
-     * Compute the bounding box of all the points in the polygon, then expand
-     * in all directions by the outline's width to take care of butting or
-     * rounded corners and projecting or rounded caps. This expansion is an
-     * overestimate (worst-case is square root of two over two) but it's
-     * simple. Don't do anything special for curves. This causes an additional
-     * overestimate in the bounding box, but is faster.
-     */
-
-    for (i = 1, coordPtr = polyPtr->coordPtr+2; i < polyPtr->numPoints-1;
-	    i++, coordPtr += 2) {
-	TkIncludePoint((Tk_Item *) polyPtr, coordPtr);
-    }
-
-    tsoffset = &polyPtr->tsoffset;
-    if (tsoffset->flags & TK_OFFSET_INDEX) {
-	int index = tsoffset->flags & ~TK_OFFSET_INDEX;
-
-	if (tsoffset->flags == INT_MAX) {
-	    index = (polyPtr->numPoints - polyPtr->autoClosed) * 2;
-	    if (index < 0) {
-		index = 0;
-	    }
-	}
-	index %= (polyPtr->numPoints - polyPtr->autoClosed) * 2;
-	if (index < 0) {
-	    index += (polyPtr->numPoints - polyPtr->autoClosed) * 2;
-	}
- 	tsoffset->xoffset = (int) (polyPtr->coordPtr[index] + 0.5);
-	tsoffset->yoffset = (int) (polyPtr->coordPtr[index+1] + 0.5);
-    } else {
-	if (tsoffset->flags & TK_OFFSET_LEFT) {
-	    tsoffset->xoffset = polyPtr->header.x1;
-	} else if (tsoffset->flags & TK_OFFSET_CENTER) {
-	    tsoffset->xoffset = (polyPtr->header.x1 + polyPtr->header.x2)/2;
-	} else if (tsoffset->flags & TK_OFFSET_RIGHT) {
-	    tsoffset->xoffset = polyPtr->header.x2;
-	}
-	if (tsoffset->flags & TK_OFFSET_TOP) {
-	    tsoffset->yoffset = polyPtr->header.y1;
-	} else if (tsoffset->flags & TK_OFFSET_MIDDLE) {
-	    tsoffset->yoffset = (polyPtr->header.y1 + polyPtr->header.y2)/2;
-	} else if (tsoffset->flags & TK_OFFSET_BOTTOM) {
-	    tsoffset->yoffset = polyPtr->header.y2;
-	}
-    }
-
-    if (polyPtr->outline.gc != None) {
-	tsoffset = &polyPtr->outline.tsoffset;
-	if (tsoffset) {
-	    if (tsoffset->flags & TK_OFFSET_INDEX) {
-		int index = tsoffset->flags & ~TK_OFFSET_INDEX;
-
-		if (tsoffset->flags == INT_MAX) {
-		    index = (polyPtr->numPoints - 1) * 2;
-		}
-		index %= (polyPtr->numPoints - 1) * 2;
-		if (index < 0) {
-		    index += (polyPtr->numPoints - 1) * 2;
-		}
-		tsoffset->xoffset = (int) (polyPtr->coordPtr[index] + 0.5);
-		tsoffset->yoffset = (int) (polyPtr->coordPtr[index+1] + 0.5);
-	    } else {
-		if (tsoffset->flags & TK_OFFSET_LEFT) {
-		    tsoffset->xoffset = polyPtr->header.x1;
-		} else if (tsoffset->flags & TK_OFFSET_CENTER) {
-		    tsoffset->xoffset =
-			    (polyPtr->header.x1 + polyPtr->header.x2) / 2;
-		} else if (tsoffset->flags & TK_OFFSET_RIGHT) {
-		    tsoffset->xoffset = polyPtr->header.x2;
-		}
-		if (tsoffset->flags & TK_OFFSET_TOP) {
-		    tsoffset->yoffset = polyPtr->header.y1;
-		} else if (tsoffset->flags & TK_OFFSET_MIDDLE) {
-		    tsoffset->yoffset =
-			    (polyPtr->header.y1 + polyPtr->header.y2) / 2;
-		} else if (tsoffset->flags & TK_OFFSET_BOTTOM) {
-		    tsoffset->yoffset = polyPtr->header.y2;
-		}
-	    }
-	}
-
-	i = (int) ((width+1.5) / 2.0);
-	polyPtr->header.x1 -= i;
-	polyPtr->header.x2 += i;
-	polyPtr->header.y1 -= i;
-	polyPtr->header.y2 += i;
-
-	/*
-	 * For mitered lines, make a second pass through all the points.
-	 * Compute the locations of the two miter vertex points and add those
-	 * into the bounding box.
-	 */
-
-	if (polyPtr->joinStyle == JoinMiter) {
-	    double miter[4];
-	    int j;
-
-	    coordPtr = polyPtr->coordPtr;
-	    if (polyPtr->numPoints > 3) {
-		if (TkGetMiterPoints(coordPtr+2*(polyPtr->numPoints-2),
-			coordPtr, coordPtr+2, width, miter, miter+2)) {
-		    for (j = 0; j < 4; j += 2) {
-			TkIncludePoint((Tk_Item *) polyPtr, miter+j);
-		    }
-		}
-	    }
-	    for (i = polyPtr->numPoints ; i >= 3; i--, coordPtr += 2) {
-		if (TkGetMiterPoints(coordPtr, coordPtr+2, coordPtr+4, width,
-			miter, miter+2)) {
-		    for (j = 0; j < 4; j += 2) {
-			TkIncludePoint((Tk_Item *) polyPtr, miter+j);
-		    }
-		}
-	    }
-	}
-    }
-
-    /*
-     * Add one more pixel of fudge factor just to be safe (e.g. X may round
-     * differently than we do).
-     */
-
-    polyPtr->header.x1 -= 1;
-    polyPtr->header.x2 += 1;
-    polyPtr->header.y1 -= 1;
-    polyPtr->header.y2 += 1;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * TkFillPolygon --
- *
- *	This function is invoked to convert a polygon to screen coordinates
- *	and display it using a particular GC.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	ItemPtr is drawn in drawable using the transformation information in
- *	canvas.
- *
- *--------------------------------------------------------------
- */
-
-void
-TkFillPolygon(
-    Tk_Canvas canvas,		/* Canvas whose coordinate system is to be
-				 * used for drawing. */
-    double *coordPtr,		/* Array of coordinates for polygon: x1, y1,
-				 * x2, y2, .... */
-    int numPoints,		/* Twice this many coordinates are present at
-				 * *coordPtr. */
-    Display *display,		/* Display on which to draw polygon. */
-    Drawable drawable,		/* Pixmap or window in which to draw
-				 * polygon. */
-    GC gc,			/* Graphics context for drawing. */
-    GC outlineGC)		/* If not None, use this to draw an outline
-				 * around the polygon after filling it. */
-{
-    XPoint staticPoints[MAX_STATIC_POINTS];
-    XPoint *pointPtr;
-    XPoint *pPtr;
-    int i;
-
-    /*
-     * Build up an array of points in screen coordinates. Use a static array
-     * unless the polygon has an enormous number of points; in this case,
-     * dynamically allocate an array.
-     */
-
-    if (numPoints <= MAX_STATIC_POINTS) {
-	pointPtr = staticPoints;
-    } else {
-	pointPtr = ckalloc(numPoints * sizeof(XPoint));
-    }
-
-    for (i=0, pPtr=pointPtr ; i<numPoints; i+=1, coordPtr+=2, pPtr++) {
-	Tk_CanvasDrawableCoords(canvas, coordPtr[0], coordPtr[1], &pPtr->x,
-		&pPtr->y);
-    }
-
-    /*
-     * Display polygon, then free up polygon storage if it was dynamically
-     * allocated.
-     */
-
-    if (gc != None && numPoints > 3) {
-	XFillPolygon(display, drawable, gc, pointPtr, numPoints, Complex,
-		CoordModeOrigin);
-    }
-    if (outlineGC != None) {
-	XDrawLines(display, drawable, outlineGC, pointPtr, numPoints,
-		CoordModeOrigin);
-    }
-    if (pointPtr != staticPoints) {
-	ckfree(pointPtr);
-    }
-}
-
-/*
- *--------------------------------------------------------------
- *
- * DisplayPolygon --
- *
- *	This function is invoked to draw a polygon item in a given drawable.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	ItemPtr is drawn in drawable using the transformation information in
- *	canvas.
- *
- *--------------------------------------------------------------
- */
-
-static void
-DisplayPolygon(
-    Tk_Canvas canvas,		/* Canvas that contains item. */
-    Tk_Item *itemPtr,		/* Item to be displayed. */
-    Display *display,		/* Display on which to draw item. */
-    Drawable drawable,		/* Pixmap or window in which to draw item. */
-    int x, int y, int width, int height)
-				/* Describes region of canvas that must be
-				 * redisplayed (not used). */
-{
-    PolygonItem *polyPtr = (PolygonItem *) itemPtr;
-    Tk_State state = itemPtr->state;
-    Pixmap stipple = polyPtr->fillStipple;
-    double linewidth = polyPtr->outline.width;
-
-    if (((polyPtr->fillGC == None) && (polyPtr->outline.gc == None)) ||
-	    (polyPtr->numPoints < 1) ||
-	    (polyPtr->numPoints < 3 && polyPtr->outline.gc == None)) {
-	return;
-    }
-
-    if (state == TK_STATE_NULL) {
-	state = Canvas(canvas)->canvas_state;
-    }
-    if (Canvas(canvas)->currentItemPtr == itemPtr) {
-	if (polyPtr->outline.activeWidth > linewidth) {
-	    linewidth = polyPtr->outline.activeWidth;
-	}
-	if (polyPtr->activeFillStipple != None) {
-	    stipple = polyPtr->activeFillStipple;
-	}
-    } else if (state == TK_STATE_DISABLED) {
-	if (polyPtr->outline.disabledWidth > 0.0) {
-	    linewidth = polyPtr->outline.disabledWidth;
-	}
-	if (polyPtr->disabledFillStipple != None) {
-	    stipple = polyPtr->disabledFillStipple;
-	}
-    }
-
-    /*
-     * If we're stippling then modify the stipple offset in the GC. Be sure to
-     * reset the offset when done, since the GC is supposed to be read-only.
-     */
-
-    if ((stipple != None) && (polyPtr->fillGC != None)) {
-	Tk_TSOffset *tsoffset = &polyPtr->tsoffset;
-	int w = 0, h = 0;
-	int flags = tsoffset->flags;
-
-	if (!(flags & TK_OFFSET_INDEX)
-		&& (flags & (TK_OFFSET_CENTER|TK_OFFSET_MIDDLE))) {
-	    Tk_SizeOfBitmap(display, stipple, &w, &h);
-	    if (flags & TK_OFFSET_CENTER) {
-		w /= 2;
-	    } else {
-		w = 0;
-	    }
-	    if (flags & TK_OFFSET_MIDDLE) {
-		h /= 2;
-	    } else {
-		h = 0;
-	    }
-	}
-	tsoffset->xoffset -= w;
-	tsoffset->yoffset -= h;
-	Tk_CanvasSetOffset(canvas, polyPtr->fillGC, tsoffset);
-	tsoffset->xoffset += w;
-	tsoffset->yoffset += h;
-    }
-    Tk_ChangeOutlineGC(canvas, itemPtr, &polyPtr->outline);
-
-    if (polyPtr->numPoints < 3) {
-	short x, y;
-	int intLineWidth = (int) (linewidth + 0.5);
-
-	if (intLineWidth < 1) {
-	    intLineWidth = 1;
-	}
-	Tk_CanvasDrawableCoords(canvas, polyPtr->coordPtr[0],
-		polyPtr->coordPtr[1], &x, &y);
-	XFillArc(display, drawable, polyPtr->outline.gc,
-		x - intLineWidth/2, y - intLineWidth/2,
-		(unsigned) intLineWidth+1, (unsigned) intLineWidth+1,
-		0, 64*360);
-    } else if (!polyPtr->smooth || polyPtr->numPoints < 4) {
-	TkFillPolygon(canvas, polyPtr->coordPtr, polyPtr->numPoints,
-		    display, drawable, polyPtr->fillGC, polyPtr->outline.gc);
-    } else {
-	int numPoints;
-	XPoint staticPoints[MAX_STATIC_POINTS];
-	XPoint *pointPtr;
-
-	/*
-	 * This is a smoothed polygon. Display using a set of generated spline
-	 * points rather than the original points.
-	 */
-
-	numPoints = polyPtr->smooth->coordProc(canvas, NULL,
-		polyPtr->numPoints, polyPtr->splineSteps, NULL, NULL);
-	if (numPoints <= MAX_STATIC_POINTS) {
-	    pointPtr = staticPoints;
-	} else {
-	    pointPtr = ckalloc(numPoints * sizeof(XPoint));
-	}
-	numPoints = polyPtr->smooth->coordProc(canvas, polyPtr->coordPtr,
-		polyPtr->numPoints, polyPtr->splineSteps, pointPtr, NULL);
-	if (polyPtr->fillGC != None) {
-	    XFillPolygon(display, drawable, polyPtr->fillGC, pointPtr,
-		    numPoints, Complex, CoordModeOrigin);
-	}
-	if (polyPtr->outline.gc != None) {
-	    XDrawLines(display, drawable, polyPtr->outline.gc, pointPtr,
-		    numPoints, CoordModeOrigin);
-	}
-	if (pointPtr != staticPoints) {
-	    ckfree(pointPtr);
-	}
-    }
-    Tk_ResetOutlineGC(canvas, itemPtr, &polyPtr->outline);
-    if ((stipple != None) && (polyPtr->fillGC != None)) {
-	XSetTSOrigin(display, polyPtr->fillGC, 0, 0);
-    }
-}
-
-/*
- *--------------------------------------------------------------
- *
- * PolygonInsert --
- *
- *	Insert coords into a polugon item at a given index.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	The coords in the given item is modified.
- *
- *--------------------------------------------------------------
- */
-
-static void
-PolygonInsert(
-    Tk_Canvas canvas,		/* Canvas containing text item. */
-    Tk_Item *itemPtr,		/* Line item to be modified. */
-    int beforeThis,		/* Index before which new coordinates are to
-				 * be inserted. */
-    Tcl_Obj *obj)		/* New coordinates to be inserted. */
-{
-    PolygonItem *polyPtr = (PolygonItem *) itemPtr;
-    int length, objc, i;
-    Tcl_Obj **objv;
-    double *newCoordPtr;
-    Tk_State state = itemPtr->state;
-
-    if (state == TK_STATE_NULL) {
-	state = Canvas(canvas)->canvas_state;
-    }
-
-    if (!obj || (Tcl_ListObjGetElements(NULL, obj, &objc, &objv) != TCL_OK)
-	    || !objc || objc&1) {
-	return;
-    }
-    length = 2*(polyPtr->numPoints - polyPtr->autoClosed);
-    while (beforeThis > length) {
-	beforeThis -= length;
-    }
-    while (beforeThis < 0) {
-	beforeThis += length;
-    }
-    newCoordPtr = ckalloc(sizeof(double) * (length + 2 + objc));
-    for (i=0; i<beforeThis; i++) {
-	newCoordPtr[i] = polyPtr->coordPtr[i];
-    }
-    for (i=0; i<objc; i++) {
-	if (Tcl_GetDoubleFromObj(NULL, objv[i],
-		&newCoordPtr[i+beforeThis]) != TCL_OK){
-	    ckfree(newCoordPtr);
-	    return;
-	}
-    }
-
-    for (i=beforeThis; i<length; i++) {
-	newCoordPtr[i+objc] = polyPtr->coordPtr[i];
-    }
-    if (polyPtr->coordPtr) {
-	ckfree(polyPtr->coordPtr);
-    }
-    length += objc;
-    polyPtr->coordPtr = newCoordPtr;
-    polyPtr->numPoints = (length/2) + polyPtr->autoClosed;
-
-    /*
-     * Close the polygon if it isn't already closed, or remove autoclosing if
-     * the user's coordinates are now closed.
-     */
-
-    if (polyPtr->autoClosed) {
-	if ((newCoordPtr[length-2] == newCoordPtr[0])
-		&& (newCoordPtr[length-1] == newCoordPtr[1])) {
-	    polyPtr->autoClosed = 0;
-	    polyPtr->numPoints--;
-	}
-    } else {
-	if ((newCoordPtr[length-2] != newCoordPtr[0])
-		|| (newCoordPtr[length-1] != newCoordPtr[1])) {
-	    polyPtr->autoClosed = 1;
-	    polyPtr->numPoints++;
-	}
-    }
-
-    newCoordPtr[length] = newCoordPtr[0];
-    newCoordPtr[length+1] = newCoordPtr[1];
-    if ((length-objc > 3) && (state != TK_STATE_HIDDEN)) {
-	/*
-	 * This is some optimizing code that will result that only the part of
-	 * the polygon that changed (and the objects that are overlapping with
-	 * that part) need to be redrawn. A special flag is set that instructs
-	 * the general canvas code not to redraw the whole object. If this
-	 * flag is not set, the canvas will do the redrawing, otherwise I have
-	 * to do it here.
-	 */
-
-    	double width;
-	int j;
-
-	itemPtr->redraw_flags |= TK_ITEM_DONT_REDRAW;
-
-	/*
-	 * The header elements that normally are used for the bounding box,
-	 * are now used to calculate the bounding box for only the part that
-	 * has to be redrawn. That doesn't matter, because afterwards the
-	 * bounding box has to be re-calculated anyway.
-	 */
-
-	itemPtr->x1 = itemPtr->x2 = (int) polyPtr->coordPtr[beforeThis];
-	itemPtr->y1 = itemPtr->y2 = (int) polyPtr->coordPtr[beforeThis+1];
-	beforeThis -= 2;
-	objc += 4;
-	if (polyPtr->smooth) {
-	    beforeThis -= 2;
-	    objc += 4;
-	}
-
-	/*
-	 * Be careful; beforeThis could now be negative
-	 */
-
-	for (i=beforeThis; i<beforeThis+objc; i+=2) {
-	    j = i;
-	    if (j < 0) {
-		j += length;
-	    } else if (j >= length) {
-		j -= length;
-	    }
-	    TkIncludePoint(itemPtr, polyPtr->coordPtr+j);
-	}
-	width = polyPtr->outline.width;
-	if (Canvas(canvas)->currentItemPtr == itemPtr) {
-	    if (polyPtr->outline.activeWidth > width) {
-		width = polyPtr->outline.activeWidth;
-	    }
-	} else if (state == TK_STATE_DISABLED) {
-	    if (polyPtr->outline.disabledWidth > 0.0) {
-		width = polyPtr->outline.disabledWidth;
-	    }
-	}
-	itemPtr->x1 -= (int) width;
-	itemPtr->y1 -= (int) width;
-	itemPtr->x2 += (int) width;
-	itemPtr->y2 += (int) width;
-	Tk_CanvasEventuallyRedraw(canvas,
-		itemPtr->x1, itemPtr->y1, itemPtr->x2, itemPtr->y2);
-    }
-
-    ComputePolygonBbox(canvas, polyPtr);
-}
-
-/*
- *--------------------------------------------------------------
- *
- * PolygonDeleteCoords --
- *
- *	Delete one or more coordinates from a polygon item.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Characters between "first" and "last", inclusive, get deleted from
- *	itemPtr.
- *
- *--------------------------------------------------------------
- */
-
-static void
-PolygonDeleteCoords(
-    Tk_Canvas canvas,		/* Canvas containing itemPtr. */
-    Tk_Item *itemPtr,		/* Item in which to delete characters. */
-    int first,			/* Index of first character to delete. */
-    int last)			/* Index of last character to delete. */
-{
-    PolygonItem *polyPtr = (PolygonItem *) itemPtr;
-    int count, i;
-    int length = 2*(polyPtr->numPoints - polyPtr->autoClosed);
-
-    while (first >= length) {
-	first -= length;
-    }
-    while (first < 0) {
-	first += length;
-    }
-    while (last >= length) {
-	last -= length;
-    }
-    while (last < 0) {
-	last += length;
-    }
-
-    first &= -2;
-    last &= -2;
-
-    count = last + 2 - first;
-    if (count <= 0) {
-	count += length;
-    }
-
-    if (count >= length) {
-	polyPtr->numPoints = 0;
-	if (polyPtr->coordPtr != NULL) {
-	    ckfree(polyPtr->coordPtr);
-	    polyPtr->coordPtr = NULL;
-	}
-	ComputePolygonBbox(canvas, polyPtr);
-	return;
-    }
-
-    if (last >= first) {
-	for (i=last+2; i<length; i++) {
-	    polyPtr->coordPtr[i-count] = polyPtr->coordPtr[i];
-	}
-    } else {
-	for (i=last; i<=first; i++) {
-	    polyPtr->coordPtr[i-last] = polyPtr->coordPtr[i];
-	}
-    }
-    polyPtr->coordPtr[length-count] = polyPtr->coordPtr[0];
-    polyPtr->coordPtr[length-count+1] = polyPtr->coordPtr[1];
-    polyPtr->numPoints -= count/2;
-    ComputePolygonBbox(canvas, polyPtr);
-}
-
-/*
- *--------------------------------------------------------------
- *
- * PolygonToPoint --
- *
- *	Computes the distance from a given point to a given polygon, in canvas
- *	units.
- *
- * Results:
- *	The return value is 0 if the point whose x and y coordinates are
- *	pointPtr[0] and pointPtr[1] is inside the polygon. If the point isn't
- *	inside the polygon then the return value is the distance from the
- *	point to the polygon.
- *
- * Side effects:
- *	None.
- *
- *--------------------------------------------------------------
- */
-
-	/* ARGSUSED */
-static double
-PolygonToPoint(
-    Tk_Canvas canvas,		/* Canvas containing item. */
-    Tk_Item *itemPtr,		/* Item to check against point. */
-    double *pointPtr)		/* Pointer to x and y coordinates. */
-{
-    PolygonItem *polyPtr = (PolygonItem *) itemPtr;
-    double *coordPtr, *polyPoints;
-    double staticSpace[2*MAX_STATIC_POINTS];
-    double poly[10];
-    double radius;
-    double bestDist, dist;
-    int numPoints, count;
-    int changedMiterToBevel;	/* Non-zero means that a mitered corner had to
-				 * be treated as beveled after all because the
-				 * angle was < 11 degrees. */
-    double width;
-    Tk_State state = itemPtr->state;
-
-    bestDist = 1.0e36;
-
-    if (state == TK_STATE_NULL) {
-	state = Canvas(canvas)->canvas_state;
-    }
-    width = polyPtr->outline.width;
-    if (Canvas(canvas)->currentItemPtr == itemPtr) {
-	if (polyPtr->outline.activeWidth > width) {
-	    width = polyPtr->outline.activeWidth;
-	}
-    } else if (state == TK_STATE_DISABLED) {
-	if (polyPtr->outline.disabledWidth > 0.0) {
-	    width = polyPtr->outline.disabledWidth;
-	}
-    }
-    radius = width/2.0;
-
-    /*
-     * Handle smoothed polygons by generating an expanded set of points
-     * against which to do the check.
-     */
-
-    if ((polyPtr->smooth) && (polyPtr->numPoints > 2)) {
-	numPoints = polyPtr->smooth->coordProc(canvas, NULL,
-		polyPtr->numPoints, polyPtr->splineSteps, NULL, NULL);
-	if (numPoints <= MAX_STATIC_POINTS) {
-	    polyPoints = staticSpace;
-	} else {
-	    polyPoints = ckalloc(2 * numPoints * sizeof(double));
-	}
-	numPoints = polyPtr->smooth->coordProc(canvas, polyPtr->coordPtr,
-		polyPtr->numPoints, polyPtr->splineSteps, NULL, polyPoints);
-    } else {
-	numPoints = polyPtr->numPoints;
-	polyPoints = polyPtr->coordPtr;
-    }
-
-    bestDist = TkPolygonToPoint(polyPoints, numPoints, pointPtr);
-    if (bestDist <= 0.0) {
-	goto donepoint;
-    }
-    if ((polyPtr->outline.gc != None) && (polyPtr->joinStyle == JoinRound)) {
-	dist = bestDist - radius;
-	if (dist <= 0.0) {
-	    bestDist = 0.0;
-	    goto donepoint;
-	} else {
-	    bestDist = dist;
-	}
-    }
-
-    if ((polyPtr->outline.gc == None) || (width <= 1)) {
-	goto donepoint;
-    }
-
-    /*
-     * The overall idea is to iterate through all of the edges of the line,
-     * computing a polygon for each edge and testing the point against that
-     * polygon. In addition, there are additional tests to deal with rounded
-     * joints and caps.
-     */
-
-    changedMiterToBevel = 0;
-    for (count = numPoints, coordPtr = polyPoints; count >= 2;
-	    count--, coordPtr += 2) {
-	/*
-	 * If rounding is done around the first point then compute the
-	 * distance between the point and the point.
-	 */
-
-	if (polyPtr->joinStyle == JoinRound) {
-	    dist = hypot(coordPtr[0] - pointPtr[0], coordPtr[1] - pointPtr[1])
-		    - radius;
-	    if (dist <= 0.0) {
-		bestDist = 0.0;
-		goto donepoint;
-	    } else if (dist < bestDist) {
-		bestDist = dist;
-	    }
-	}
-
-	/*
-	 * Compute the polygonal shape corresponding to this edge, consisting
-	 * of two points for the first point of the edge and two points for
-	 * the last point of the edge.
-	 */
-
-	if (count == numPoints) {
-	    TkGetButtPoints(coordPtr+2, coordPtr, (double) width, 0, poly,
-		    poly+2);
-	} else if ((polyPtr->joinStyle == JoinMiter) && !changedMiterToBevel) {
-	    poly[0] = poly[6];
-	    poly[1] = poly[7];
-	    poly[2] = poly[4];
-	    poly[3] = poly[5];
-	} else {
-	    TkGetButtPoints(coordPtr+2, coordPtr, (double) width, 0, poly,
-		    poly+2);
-
-	    /*
-	     * If this line uses beveled joints, then check the distance to a
-	     * polygon comprising the last two points of the previous polygon
-	     * and the first two from this polygon; this checks the wedges
-	     * that fill the mitered joint.
-	     */
-
-	    if ((polyPtr->joinStyle == JoinBevel) || changedMiterToBevel) {
-		poly[8] = poly[0];
-		poly[9] = poly[1];
-		dist = TkPolygonToPoint(poly, 5, pointPtr);
-		if (dist <= 0.0) {
-		    bestDist = 0.0;
-		    goto donepoint;
-		} else if (dist < bestDist) {
-		    bestDist = dist;
-		}
-		changedMiterToBevel = 0;
-	    }
-	}
-	if (count == 2) {
-	    TkGetButtPoints(coordPtr, coordPtr+2, (double) width, 0, poly+4,
-		    poly+6);
-	} else if (polyPtr->joinStyle == JoinMiter) {
-	    if (TkGetMiterPoints(coordPtr, coordPtr+2, coordPtr+4,
-		    (double) width, poly+4, poly+6) == 0) {
-		changedMiterToBevel = 1;
-		TkGetButtPoints(coordPtr, coordPtr+2, (double) width, 0,
-			poly+4, poly+6);
-	    }
-	} else {
-	    TkGetButtPoints(coordPtr, coordPtr+2, (double) width, 0, poly+4,
-		    poly+6);
-	}
-	poly[8] = poly[0];
-	poly[9] = poly[1];
-	dist = TkPolygonToPoint(poly, 5, pointPtr);
-	if (dist <= 0.0) {
-	    bestDist = 0.0;
-	    goto donepoint;
-	} else if (dist < bestDist) {
-	    bestDist = dist;
-	}
-    }
-
-  donepoint:
-    if (polyPoints != staticSpace && polyPoints != polyPtr->coordPtr) {
-	ckfree(polyPoints);
-    }
-    return bestDist;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * PolygonToArea --
- *
- *	This function is called to determine whether an item lies entirely
- *	inside, entirely outside, or overlapping a given rectangular area.
- *
- * Results:
- *	-1 is returned if the item is entirely outside the area given by
- *	rectPtr, 0 if it overlaps, and 1 if it is entirely inside the given
- *	area.
- *
- * Side effects:
- *	None.
- *
- *--------------------------------------------------------------
- */
-
-	/* ARGSUSED */
-static int
-PolygonToArea(
-    Tk_Canvas canvas,		/* Canvas containing item. */
-    Tk_Item *itemPtr,		/* Item to check against polygon. */
-    double *rectPtr)		/* Pointer to array of four coordinates
-				 * (x1,y1,x2,y2) describing rectangular
-				 * area. */
-{
-    PolygonItem *polyPtr = (PolygonItem *) itemPtr;
-    double *coordPtr;
-    double staticSpace[2*MAX_STATIC_POINTS];
-    double *polyPoints, poly[10];
-    double radius;
-    int numPoints, count;
-    int changedMiterToBevel;	/* Non-zero means that a mitered corner had to
-				 * be treated as beveled after all because the
-				 * angle was < 11 degrees. */
-    int inside;			/* Tentative guess about what to return, based
-				 * on all points seen so far: one means
-				 * everything seen so far was inside the area;
-				 * -1 means everything was outside the area. 0
-				 * means overlap has been found. */
-    double width;
-    Tk_State state = itemPtr->state;
-
-    if (state == TK_STATE_NULL) {
-	state = Canvas(canvas)->canvas_state;
-    }
-
-    width = polyPtr->outline.width;
-    if (Canvas(canvas)->currentItemPtr == itemPtr) {
-	if (polyPtr->outline.activeWidth > width) {
-	    width = polyPtr->outline.activeWidth;
-	}
-    } else if (state == TK_STATE_DISABLED) {
-	if (polyPtr->outline.disabledWidth > 0.0) {
-	    width = polyPtr->outline.disabledWidth;
-	}
-    }
-
-    radius = width/2.0;
-    inside = -1;
-
-    if ((state == TK_STATE_HIDDEN) || polyPtr->numPoints < 2) {
-	return -1;
-    } else if (polyPtr->numPoints < 3) {
-	double oval[4];
-
-	oval[0] = polyPtr->coordPtr[0]-radius;
-	oval[1] = polyPtr->coordPtr[1]-radius;
-	oval[2] = polyPtr->coordPtr[0]+radius;
-	oval[3] = polyPtr->coordPtr[1]+radius;
-	return TkOvalToArea(oval, rectPtr);
-    }
-
-    /*
-     * Handle smoothed polygons by generating an expanded set of points
-     * against which to do the check.
-     */
-
-    if (polyPtr->smooth) {
-	numPoints = polyPtr->smooth->coordProc(canvas, NULL,
-		polyPtr->numPoints, polyPtr->splineSteps, NULL, NULL);
-	if (numPoints <= MAX_STATIC_POINTS) {
-	    polyPoints = staticSpace;
-	} else {
-	    polyPoints = ckalloc(2 * numPoints * sizeof(double));
-	}
-	numPoints = polyPtr->smooth->coordProc(canvas, polyPtr->coordPtr,
-		polyPtr->numPoints, polyPtr->splineSteps, NULL, polyPoints);
-    } else {
-	numPoints = polyPtr->numPoints;
-	polyPoints = polyPtr->coordPtr;
-    }
-
-    /*
-     * Simple test to see if we are in the polygon. Polygons are different
-     * from othe canvas items in that they register points being inside even
-     * if it isn't filled.
-     */
-
-    inside = TkPolygonToArea(polyPoints, numPoints, rectPtr);
-    if (inside == 0) {
-	goto donearea;
-    }
-
-    if (polyPtr->outline.gc == None) {
-	goto donearea;
-    }
-
-    /*
-     * Iterate through all of the edges of the line, computing a polygon for
-     * each edge and testing the area against that polygon. In addition, there
-     * are additional tests to deal with rounded joints and caps.
-     */
-
-    changedMiterToBevel = 0;
-    for (count = numPoints, coordPtr = polyPoints; count >= 2;
-	    count--, coordPtr += 2) {
-	/*
-	 * If rounding is done around the first point of the edge then test a
-	 * circular region around the point with the area.
-	 */
-
-	if (polyPtr->joinStyle == JoinRound) {
-	    poly[0] = coordPtr[0] - radius;
-	    poly[1] = coordPtr[1] - radius;
-	    poly[2] = coordPtr[0] + radius;
-	    poly[3] = coordPtr[1] + radius;
-	    if (TkOvalToArea(poly, rectPtr) != inside) {
-		inside = 0;
-		goto donearea;
-	    }
-	}
-
-	/*
-	 * Compute the polygonal shape corresponding to this edge, consisting
-	 * of two points for the first point of the edge and two points for
-	 * the last point of the edge.
-	 */
-
-	if (count == numPoints) {
-	    TkGetButtPoints(coordPtr+2, coordPtr, width, 0, poly, poly+2);
-	} else if ((polyPtr->joinStyle == JoinMiter) && !changedMiterToBevel) {
-	    poly[0] = poly[6];
-	    poly[1] = poly[7];
-	    poly[2] = poly[4];
-	    poly[3] = poly[5];
-	} else {
-	    TkGetButtPoints(coordPtr+2, coordPtr, width, 0, poly, poly+2);
-
-	    /*
-	     * If the last joint was beveled, then also check a polygon
-	     * comprising the last two points of the previous polygon and the
-	     * first two from this polygon; this checks the wedges that fill
-	     * the beveled joint.
-	     */
-
-	    if ((polyPtr->joinStyle == JoinBevel) || changedMiterToBevel) {
-		poly[8] = poly[0];
-		poly[9] = poly[1];
-		if (TkPolygonToArea(poly, 5, rectPtr) != inside) {
-		    inside = 0;
-		    goto donearea;
-		}
-		changedMiterToBevel = 0;
-	    }
-	}
-	if (count == 2) {
-	    TkGetButtPoints(coordPtr, coordPtr+2, width, 0, poly+4, poly+6);
-	} else if (polyPtr->joinStyle == JoinMiter) {
-	    if (TkGetMiterPoints(coordPtr, coordPtr+2, coordPtr+4, width,
-		    poly+4, poly+6) == 0) {
-		changedMiterToBevel = 1;
-		TkGetButtPoints(coordPtr, coordPtr+2, width,0, poly+4, poly+6);
-	    }
-	} else {
-	    TkGetButtPoints(coordPtr, coordPtr+2, width, 0, poly+4, poly+6);
-	}
-	poly[8] = poly[0];
-	poly[9] = poly[1];
-	if (TkPolygonToArea(poly, 5, rectPtr) != inside) {
-	    inside = 0;
-	    goto donearea;
-	}
-    }
-
-  donearea:
-    if ((polyPoints != staticSpace) && (polyPoints != polyPtr->coordPtr)) {
-	ckfree(polyPoints);
-    }
-    return inside;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * ScalePolygon --
- *
- *	This function is invoked to rescale a polygon item.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	The polygon referred to by itemPtr is rescaled so that the following
- *	transformation is applied to all point coordinates:
- *		x' = originX + scaleX*(x-originX)
- *		y' = originY + scaleY*(y-originY)
- *
- *--------------------------------------------------------------
- */
-
-static void
-ScalePolygon(
-    Tk_Canvas canvas,		/* Canvas containing polygon. */
-    Tk_Item *itemPtr,		/* Polygon to be scaled. */
-    double originX, double originY,
-				/* Origin about which to scale rect. */
-    double scaleX,		/* Amount to scale in X direction. */
-    double scaleY)		/* Amount to scale in Y direction. */
-{
-    PolygonItem *polyPtr = (PolygonItem *) itemPtr;
-    double *coordPtr;
-    int i;
-
-    for (i = 0, coordPtr = polyPtr->coordPtr; i < polyPtr->numPoints;
-	    i++, coordPtr += 2) {
-	*coordPtr = originX + scaleX*(*coordPtr - originX);
-	coordPtr[1] = originY + scaleY*(coordPtr[1] - originY);
-    }
-    ComputePolygonBbox(canvas, polyPtr);
-}
-
-/*
- *--------------------------------------------------------------
- *
- * GetPolygonIndex --
- *
- *	Parse an index into a polygon item and return either its value or an
- *	error.
- *
- * Results:
- *	A standard Tcl result. If all went well, then *indexPtr is filled in
- *	with the index (into itemPtr) corresponding to string. Otherwise an
- *	error message is left in interp->result.
- *
- * Side effects:
- *	None.
- *
- *--------------------------------------------------------------
- */
-
-static int
-GetPolygonIndex(
-    Tcl_Interp *interp,		/* Used for error reporting. */
-    Tk_Canvas canvas,		/* Canvas containing item. */
-    Tk_Item *itemPtr,		/* Item for which the index is being
-				 * specified. */
-    Tcl_Obj *obj,		/* Specification of a particular coord in
-				 * itemPtr's line. */
-    int *indexPtr)		/* Where to store converted index. */
-{
-    PolygonItem *polyPtr = (PolygonItem *) itemPtr;
-    const char *string = Tcl_GetString(obj);
-
-    if (string[0] == 'e') {
-	if (strncmp(string, "end", obj->length) != 0) {
-	    goto badIndex;
-	}
-	*indexPtr = 2*(polyPtr->numPoints - polyPtr->autoClosed);
-    } else if (string[0] == '@') {
-	int i;
-	double x, y, bestDist, dist, *coordPtr;
-	char *end;
-	const char *p;
-
-	p = string+1;
-	x = strtod(p, &end);
-	if ((end == p) || (*end != ',')) {
-	    goto badIndex;
-	}
-	p = end+1;
-	y = strtod(p, &end);
-	if ((end == p) || (*end != 0)) {
-	    goto badIndex;
-	}
-	bestDist = 1.0e36;
-	coordPtr = polyPtr->coordPtr;
-	*indexPtr = 0;
-	for (i=0; i<polyPtr->numPoints-1; i++) {
-	    dist = hypot(coordPtr[0] - x, coordPtr[1] - y);
-	    if (dist < bestDist) {
-		bestDist = dist;
-		*indexPtr = 2*i;
-	    }
-	    coordPtr += 2;
-	}
-    } else {
-	int count = 2*(polyPtr->numPoints - polyPtr->autoClosed);
-
-	if (Tcl_GetIntFromObj(interp, obj, indexPtr) != TCL_OK) {
-	    goto badIndex;
-	}
-	*indexPtr &= -2; /* if odd, make it even */
-	if (!count) {
-	    *indexPtr = 0;
-	} else if (*indexPtr > 0) {
-	    *indexPtr = ((*indexPtr - 2) % count) + 2;
-	} else {
-	    *indexPtr = -((-(*indexPtr)) % count);
-	}
-    }
-    return TCL_OK;
-
-    /*
-     * Some of the paths here leave messages in interp->result, so we have to
-     * clear it out before storing our own message.
-     */
-
-  badIndex:
-    Tcl_SetObjResult(interp, Tcl_ObjPrintf("bad index \"%s\"", string));
-    Tcl_SetErrorCode(interp, "TK", "CANVAS", "ITEM_INDEX", "POLY", NULL);
-    return TCL_ERROR;
-}
-
-/*
- *--------------------------------------------------------------
- *
- * TranslatePolygon --
- *
- *	This function is called to move a polygon by a given amount.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	The position of the polygon is offset by (xDelta, yDelta), and the
- *	bounding box is updated in the generic part of the item structure.
- *
- *--------------------------------------------------------------
- */
-
-static void
-TranslatePolygon(
-    Tk_Canvas canvas,		/* Canvas containing item. */
-    Tk_Item *itemPtr,		/* Item that is being moved. */
-    double deltaX, double deltaY)
-				/* Amount by which item is to be moved. */
-{
-    PolygonItem *polyPtr = (PolygonItem *) itemPtr;
-    double *coordPtr;
-    int i;
-
-    for (i = 0, coordPtr = polyPtr->coordPtr; i < polyPtr->numPoints;
-	    i++, coordPtr += 2) {
-	*coordPtr += deltaX;
-	coordPtr[1] += deltaY;
-    }
-    ComputePolygonBbox(canvas, polyPtr);
-}
-
-/*
- *--------------------------------------------------------------
- *
- * PolygonToPostscript --
- *
- *	This function is called to generate Postscript for polygon items.
- *
- * Results:
- *	The return value is a standard Tcl result. If an error occurs in
- *	generating Postscript then an error message is left in the interp's
- *	result, replacing whatever used to be there. If no error occurs, then
- *	Postscript for the item is appended to the result.
- *
- * Side effects:
- *	None.
- *
- *--------------------------------------------------------------
- */
-
-static int
-PolygonToPostscript(
-    Tcl_Interp *interp,		/* Leave Postscript or error message here. */
-    Tk_Canvas canvas,		/* Information about overall canvas. */
-    Tk_Item *itemPtr,		/* Item for which Postscript is wanted. */
-    int prepass)		/* 1 means this is a prepass to collect font
-				 * information; 0 means final Postscript is
-				 * being created. */
-{
-    PolygonItem *polyPtr = (PolygonItem *) itemPtr;
-    int style;
-    XColor *color;
-    XColor *fillColor;
-    Pixmap stipple;
-    Pixmap fillStipple;
-    Tk_State state = itemPtr->state;
-    double width;
-    Tcl_Obj *psObj;
-    Tcl_InterpState interpState;
-
-    if (polyPtr->numPoints < 2 || polyPtr->coordPtr == NULL) {
-	return TCL_OK;
-    }
-
-    if (state == TK_STATE_NULL) {
-	state = Canvas(canvas)->canvas_state;
-    }
-    width = polyPtr->outline.width;
-    color = polyPtr->outline.color;
-    stipple = polyPtr->fillStipple;
-    fillColor = polyPtr->fillColor;
-    fillStipple = polyPtr->fillStipple;
-    if (Canvas(canvas)->currentItemPtr == itemPtr) {
-	if (polyPtr->outline.activeWidth > width) {
-	    width = polyPtr->outline.activeWidth;
-	}
-	if (polyPtr->outline.activeColor != NULL) {
-	    color = polyPtr->outline.activeColor;
-	}
-	if (polyPtr->outline.activeStipple != None) {
-	    stipple = polyPtr->outline.activeStipple;
-	}
-	if (polyPtr->activeFillColor != NULL) {
-	    fillColor = polyPtr->activeFillColor;
-	}
-	if (polyPtr->activeFillStipple != None) {
-	    fillStipple = polyPtr->activeFillStipple;
-	}
-    } else if (state == TK_STATE_DISABLED) {
-	if (polyPtr->outline.disabledWidth > 0.0) {
-	    width = polyPtr->outline.disabledWidth;
-	}
-	if (polyPtr->outline.disabledColor != NULL) {
-	    color = polyPtr->outline.disabledColor;
-	}
-	if (polyPtr->outline.disabledStipple != None) {
-	    stipple = polyPtr->outline.disabledStipple;
-	}
-	if (polyPtr->disabledFillColor != NULL) {
-	    fillColor = polyPtr->disabledFillColor;
-	}
-	if (polyPtr->disabledFillStipple != None) {
-	    fillStipple = polyPtr->disabledFillStipple;
-	}
-    }
-
-    /*
-     * Make our working space.
-     */
-
-    psObj = Tcl_NewObj();
-    interpState = Tcl_SaveInterpState(interp, TCL_OK);
-
-    if (polyPtr->numPoints == 2) {
-	if (color == NULL) {
-	    goto done;
-	}
-
-	/*
-	 * Create a point by using a small circle. (Printer pixels are too
-	 * tiny to be used directly...)
-	 */
-
-	Tcl_AppendPrintfToObj(psObj,
-		"matrix currentmatrix\n"	/* save state */
-		"%.15g %.15g translate "	/* go to drawing location */
-		"%.15g %.15g scale "		/* scale the drawing */
-		"1 0 moveto "			/* correct for origin */
-		"0 0 1 0 360 arc\n"		/* make the circle */
-		"setmatrix\n",			/* restore state */
-		polyPtr->coordPtr[0],
-		Tk_CanvasPsY(canvas, polyPtr->coordPtr[1]),
-		width/2.0, width/2.0);
-
-	/*
-	 * Color it in.
-	 */
-
-	Tcl_ResetResult(interp);
-	if (Tk_CanvasPsColor(interp, canvas, color) != TCL_OK) {
-	    goto error;
-	}
-	Tcl_AppendObjToObj(psObj, Tcl_GetObjResult(interp));
-
-	if (stipple != None) {
-	    Tcl_AppendToObj(psObj, "clip ", -1);
-
-	    Tcl_ResetResult(interp);
-	    if (Tk_CanvasPsStipple(interp, canvas, stipple) != TCL_OK) {
-		goto error;
-	    }
-	    Tcl_AppendObjToObj(psObj, Tcl_GetObjResult(interp));
-	} else {
-	    Tcl_AppendToObj(psObj, "fill\n", -1);
-	}
-	goto done;
-    }
-
-    /*
-     * Fill the area of the polygon.
-     */
-
-    if (fillColor != NULL && polyPtr->numPoints > 3) {
-	Tcl_ResetResult(interp);
-	if (!polyPtr->smooth || !polyPtr->smooth->postscriptProc) {
-	    Tk_CanvasPsPath(interp, canvas, polyPtr->coordPtr,
-		    polyPtr->numPoints);
-	} else {
-	    polyPtr->smooth->postscriptProc(interp, canvas, polyPtr->coordPtr,
-		    polyPtr->numPoints, polyPtr->splineSteps);
-	}
-	if (Tk_CanvasPsColor(interp, canvas, fillColor) != TCL_OK) {
-	    goto error;
-	}
-	Tcl_AppendObjToObj(psObj, Tcl_GetObjResult(interp));
-
-	if (fillStipple != None) {
-	    Tcl_AppendToObj(psObj, "eoclip ", -1);
-
-	    Tcl_ResetResult(interp);
-	    if (Tk_CanvasPsStipple(interp, canvas, fillStipple) != TCL_OK) {
-		goto error;
-	    }
-	    Tcl_AppendObjToObj(psObj, Tcl_GetObjResult(interp));
-
-	    if (color != NULL) {
-		Tcl_AppendToObj(psObj, "grestore gsave\n", -1);
-	    }
-	} else {
-	    Tcl_AppendToObj(psObj, "eofill\n", -1);
-	}
-    }
-
-    /*
-     * Now draw the outline, if there is one.
-     */
-
-    if (color != NULL) {
-	Tcl_ResetResult(interp);
-	if (!polyPtr->smooth || !polyPtr->smooth->postscriptProc) {
-	    Tk_CanvasPsPath(interp, canvas, polyPtr->coordPtr,
-		    polyPtr->numPoints);
-	} else {
-	    polyPtr->smooth->postscriptProc(interp, canvas, polyPtr->coordPtr,
-		    polyPtr->numPoints, polyPtr->splineSteps);
-	}
-	Tcl_AppendObjToObj(psObj, Tcl_GetObjResult(interp));
-
-	if (polyPtr->joinStyle == JoinRound) {
-	    style = 1;
-	} else if (polyPtr->joinStyle == JoinBevel) {
-	    style = 2;
-	} else {
-	    style = 0;
-	}
-	Tcl_AppendPrintfToObj(psObj, "%d setlinejoin 1 setlinecap\n", style);
-
-	Tcl_ResetResult(interp);
-	if (Tk_CanvasPsOutline(canvas, itemPtr, &polyPtr->outline) != TCL_OK){
-	    goto error;
-	}
-	Tcl_AppendObjToObj(psObj, Tcl_GetObjResult(interp));
-    }
-
-    /*
-     * Plug the accumulated postscript back into the result.
-     */
-
-  done:
-    (void) Tcl_RestoreInterpState(interp, interpState);
-    Tcl_AppendObjToObj(Tcl_GetObjResult(interp), psObj);
-    Tcl_DecrRefCount(psObj);
-    return TCL_OK;
-
-  error:
-    Tcl_DiscardInterpState(interpState);
-    Tcl_DecrRefCount(psObj);
-    return TCL_ERROR;
-}
-
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 4
- * fill-column: 78
- * End:
- */