/*
* 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:
*/