/*

* tkCanvUtil.c --

*

* This file contains a collection of utility functions used by the

* implementations of various canvas item types.

*

* Copyright © 1994 Sun Microsystems, Inc.

*

* 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"

#ifdef _WIN32

#include "tkWinInt.h"

#endif

/*

* Structures defined only in this file.

*/

typedef struct SmoothAssocData {

struct SmoothAssocData *nextPtr;

/* Pointer to next SmoothAssocData. */

Tk_SmoothMethod smooth; /* Name and functions associated with this

* option. */

} SmoothAssocData;

const Tk_SmoothMethod tkBezierSmoothMethod = {

"true",

TkMakeBezierCurve,

(void (*) (Tcl_Interp *interp, Tk_Canvas canvas, double *coordPtr,

int numPoints, int numSteps))(void *)TkMakeBezierPostscript,

};

static const Tk_SmoothMethod tkRawSmoothMethod = {

"raw",

TkMakeRawCurve,

(void (*) (Tcl_Interp *interp, Tk_Canvas canvas, double *coordPtr,

int numPoints, int numSteps))(void *)TkMakeRawCurvePostscript,

};

/*

* Function forward-declarations.

*/

static void SmoothMethodCleanupProc(void *clientData,

Tcl_Interp *interp);

static SmoothAssocData *InitSmoothMethods(Tcl_Interp *interp);

static int DashConvert(char *l, const char *p, int n,

double width);

static void TranslateAndAppendCoords(TkCanvas *canvPtr,

double x, double y, XPoint *outArr, int numOut);

static inline Tcl_Obj * GetPostscriptBuffer(Tcl_Interp *interp);

#define ABS(a) ((a>=0)?(a):(-(a)))



static inline Tcl_Obj *

GetPostscriptBuffer(

Tcl_Interp *interp)

{

Tcl_Obj *psObj = Tcl_GetObjResult(interp);

if (Tcl_IsShared(psObj)) {

psObj = Tcl_DuplicateObj(psObj);

Tcl_SetObjResult(interp, psObj);

}

return psObj;

}



/*

*----------------------------------------------------------------------

*

* Tk_CanvasTkwin --

*

* Given a token for a canvas, this function returns the widget that

* represents the canvas.

*

* Results:

* The return value is a handle for the widget.

*

* Side effects:

* None.

*

*----------------------------------------------------------------------

*/

Tk_Window

Tk_CanvasTkwin(

Tk_Canvas canvas) /* Token for the canvas. */

{

return Canvas(canvas)->tkwin;

}



/*

*----------------------------------------------------------------------

*

* Tk_CanvasDrawableCoords --

*

* Given an (x,y) coordinate pair within a canvas, this function

* returns the corresponding coordinates at which the point should

* be drawn in the drawable used for display.

*

* Results:

* There is no return value. The values at *drawableXPtr and

* *drawableYPtr are filled in with the coordinates at which x and y

* should be drawn. These coordinates are clipped to fit within a

* "short", since this is what X uses in most cases for drawing.

*

* Side effects:

* None.

*

*----------------------------------------------------------------------

*/

void

Tk_CanvasDrawableCoords(

Tk_Canvas canvas, /* Token for the canvas. */

double x, /* Coordinates in canvas space. */

double y,

short *drawableXPtr, /* Screen coordinates are stored here. */

short *drawableYPtr)

{

double tmp;

tmp = x - Canvas(canvas)->drawableXOrigin;

if (tmp > 0) {

tmp += 0.5;

} else {

tmp -= 0.5;

}

if (tmp > 32767) {

*drawableXPtr = 32767;

} else if (tmp < -32768) {

*drawableXPtr = -32768;

} else {

*drawableXPtr = (short) tmp;

}

tmp = y - Canvas(canvas)->drawableYOrigin;

if (tmp > 0) {

tmp += 0.5;

} else {

tmp -= 0.5;

}

if (tmp > 32767) {

*drawableYPtr = 32767;

} else if (tmp < -32768) {

*drawableYPtr = -32768;

} else {

*drawableYPtr = (short) tmp;

}

}



/*

*----------------------------------------------------------------------

*

* Tk_CanvasWindowCoords --

*

* Given an (x,y) coordinate pair within a canvas, this function returns

* the corresponding coordinates in the canvas's window.

*

* Results:

* There is no return value. The values at *screenXPtr and *screenYPtr

* are filled in with the coordinates at which (x,y) appears in the

* canvas's window. These coordinates are clipped to fit within a

* "short", since this is what X uses in most cases for drawing.

*

* Side effects:

* None.

*

*----------------------------------------------------------------------

*/

void

Tk_CanvasWindowCoords(

Tk_Canvas canvas, /* Token for the canvas. */

double x, /* Coordinates in canvas space. */

double y,

short *screenXPtr, /* Screen coordinates are stored here. */

short *screenYPtr)

{

double tmp;

tmp = x - Canvas(canvas)->xOrigin;

if (tmp > 0) {

tmp += 0.5;

} else {

tmp -= 0.5;

}

if (tmp > 32767) {

*screenXPtr = 32767;

} else if (tmp < -32768) {

*screenXPtr = -32768;

} else {

*screenXPtr = (short) tmp;

}

tmp = y - Canvas(canvas)->yOrigin;

if (tmp > 0) {

tmp += 0.5;

} else {

tmp -= 0.5;

}

if (tmp > 32767) {

*screenYPtr = 32767;

} else if (tmp < -32768) {

*screenYPtr = -32768;

} else {

*screenYPtr = (short) tmp;

}

}



/*

*--------------------------------------------------------------

*

* Tk_CanvasGetCoord --

*

* Given a string, returns a floating-point canvas coordinate

* corresponding to that string.

*

* Results:

* The return value is a standard Tcl return result. If TCL_OK is

* returned, then everything went well and the canvas coordinate is

* stored at *doublePtr; otherwise TCL_ERROR is returned and an error

* message is left in the interp's result.

*

* Side effects:

* None.

*

*--------------------------------------------------------------

*/

int

Tk_CanvasGetCoord(

TCL_UNUSED(Tcl_Interp *), /* Interpreter for error reporting. */

Tk_Canvas canvas, /* Canvas to which coordinate applies. */

const char *string, /* Describes coordinate (any screen coordinate

* form may be used here). */

double *doublePtr) /* Place to store converted coordinate. */

{

if (Tk_GetScreenMM(Canvas(canvas)->interp, Canvas(canvas)->tkwin, string,

doublePtr) != TCL_OK) {

return TCL_ERROR;

}

*doublePtr *= Canvas(canvas)->pixelsPerMM;

return TCL_OK;

}

/*

*--------------------------------------------------------------

*

* Tk_CanvasGetCoordFromObj --

*

* Given a string, returns a floating-point canvas coordinate

* corresponding to that string.

*

* Results:

* The return value is a standard Tcl return result. If TCL_OK is

* returned, then everything went well and the canvas coordinate is

* stored at *doublePtr; otherwise TCL_ERROR is returned and an error

* message is left in interp->result.

*

* Side effects:

* None.

*

*--------------------------------------------------------------

*/

int

Tk_CanvasGetCoordFromObj(

TCL_UNUSED(Tcl_Interp *), /* Interpreter for error reporting. */

Tk_Canvas canvas, /* Canvas to which coordinate applies. */

Tcl_Obj *obj, /* Describes coordinate (any screen coordinate

* form may be used here). */

double *doublePtr) /* Place to store converted coordinate. */

{

return Tk_GetDoublePixelsFromObj(Canvas(canvas)->interp, Canvas(canvas)->tkwin, obj, doublePtr);

}



/*

*----------------------------------------------------------------------

*

* Tk_CanvasSetStippleOrigin --

*

* This function sets the stipple origin in a graphics context so that

* stipples drawn with the GC will line up with other stipples previously

* drawn in the canvas.

*

* Results:

* None.

*

* Side effects:

* The graphics context is modified.

*

*----------------------------------------------------------------------

*/

void

Tk_CanvasSetStippleOrigin(

Tk_Canvas canvas, /* Token for a canvas. */

GC gc) /* Graphics context that is about to be used

* to draw a stippled pattern as part of

* redisplaying the canvas. */

{

XSetTSOrigin(Canvas(canvas)->display, gc,

-Canvas(canvas)->drawableXOrigin,

-Canvas(canvas)->drawableYOrigin);

}



/*

*----------------------------------------------------------------------

*

* Tk_CanvasSetOffset--

*

* This function sets the stipple offset in a graphics context so that

* stipples drawn with the GC will line up with other stipples with the

* same offset.

*

* Results:

* None.

*

* Side effects:

* The graphics context is modified.

*

*----------------------------------------------------------------------

*/

void

Tk_CanvasSetOffset(

Tk_Canvas canvas, /* Token for a canvas. */

GC gc, /* Graphics context that is about to be used

* to draw a stippled pattern as part of

* redisplaying the canvas. */

Tk_TSOffset *offset) /* Offset (may be NULL pointer)*/

{

TkCanvas *canvasPtr = Canvas(canvas);

int flags = 0;

int x = - canvasPtr->drawableXOrigin;

int y = - canvasPtr->drawableYOrigin;

if (offset != NULL) {

flags = offset->flags;

x += offset->xoffset;

y += offset->yoffset;

}

if ((flags & TK_OFFSET_RELATIVE) && !(flags & TK_OFFSET_INDEX)) {

Tk_SetTSOrigin(canvasPtr->tkwin, gc, x - canvasPtr->xOrigin,

y - canvasPtr->yOrigin);

} else {

XSetTSOrigin(canvasPtr->display, gc, x, y);

}

}



/*

*----------------------------------------------------------------------

*

* Tk_CanvasGetTextInfo --

*

* This function returns a pointer to a structure containing information

* about the selection and insertion cursor for a canvas widget. Items

* such as text items save the pointer and use it to share access to the

* information with the generic canvas code.

*

* Results:

* The return value is a pointer to the structure holding text

* information for the canvas. Most of the fields should not be modified

* outside the generic canvas code; see the user documentation for

* details.

*

* Side effects:

* None.

*

*----------------------------------------------------------------------

*/

Tk_CanvasTextInfo *

Tk_CanvasGetTextInfo(

Tk_Canvas canvas) /* Token for the canvas widget. */

{

return &Canvas(canvas)->textInfo;

}



/*

*--------------------------------------------------------------

*

* Tk_CanvasTagsParseProc --

*

* This function is invoked during option processing to handle "-tags"

* options for canvas items.

*

* Results:

* A standard Tcl return value.

*

* Side effects:

* The tags for a given item get replaced by those indicated in the value

* argument.

*

*--------------------------------------------------------------

*/

int

Tk_CanvasTagsParseProc(

TCL_UNUSED(void *),

Tcl_Interp *interp, /* Used for reporting errors. */

TCL_UNUSED(Tk_Window), /* Window containing canvas widget. */

const char *value, /* Value of option (list of tag names). */

char *widgRec, /* Pointer to record for item. */

TCL_UNUSED(Tcl_Size)) /* Offset into item (ignored). */

{

Tk_Item *itemPtr = (Tk_Item *) widgRec;

Tcl_Size argc, i;

const char **argv;

Tk_Uid *newPtr;

/*

* Break the value up into the individual tag names.

*/

if (Tcl_SplitList(interp, value, &argc, &argv) != TCL_OK) {

return TCL_ERROR;

}

/*

* Make sure that there's enough space in the item to hold the tag names.

*/

if (itemPtr->tagSpace < argc) {

newPtr = (Tk_Uid *)ckalloc(argc * sizeof(Tk_Uid));

for (i = itemPtr->numTags - 1; i != TCL_INDEX_NONE; i--) {

newPtr[i] = itemPtr->tagPtr[i];

}

if (itemPtr->tagPtr != itemPtr->staticTagSpace) {

ckfree(itemPtr->tagPtr);

}

itemPtr->tagPtr = newPtr;

itemPtr->tagSpace = argc;

}

itemPtr->numTags = argc;

for (i = 0; i < argc; i++) {

itemPtr->tagPtr[i] = Tk_GetUid(argv[i]);

}

ckfree(argv);

return TCL_OK;

}



/*

*--------------------------------------------------------------

*

* Tk_CanvasTagsPrintProc --

*

* This function is invoked by the Tk configuration code to produce a

* printable string for the "-tags" configuration option for canvas

* items.

*

* Results:

* The return value is a string describing all the tags for the item

* referred to by "widgRec". In addition, *freeProcPtr is filled in with

* the address of a function to call to free the result string when it's

* no longer needed (or NULL to indicate that the string doesn't need to

* be freed).

*

* Side effects:

* None.

*

*--------------------------------------------------------------

*/

const char *

Tk_CanvasTagsPrintProc(

TCL_UNUSED(void *),

TCL_UNUSED(Tk_Window), /* Window containing canvas widget. */

char *widgRec, /* Pointer to record for item. */

TCL_UNUSED(Tcl_Size), /* Ignored. */

Tcl_FreeProc **freeProcPtr) /* Pointer to variable to fill in with

* information about how to reclaim storage

* for return string. */

{

Tk_Item *itemPtr = (Tk_Item *) widgRec;

if (itemPtr->numTags == 0) {

*freeProcPtr = NULL;

return "";

}

if (itemPtr->numTags == 1) {

*freeProcPtr = NULL;

return (const char *) itemPtr->tagPtr[0];

}

*freeProcPtr = TCL_DYNAMIC;

return Tcl_Merge(itemPtr->numTags, (const char **) itemPtr->tagPtr);

}



/*

*--------------------------------------------------------------

*

* TkCanvasDashParseProc --

*

* This function is invoked during option processing to handle "-dash",

* "-activedash" and "-disableddash" options for canvas objects.

*

* Results:

* A standard Tcl return value.

*

* Side effects:

* The dash list for a given canvas object gets replaced by those

* indicated in the value argument.

*

*--------------------------------------------------------------

*/

int

TkCanvasDashParseProc(

TCL_UNUSED(void *),

Tcl_Interp *interp, /* Used for reporting errors. */

TCL_UNUSED(Tk_Window), /* Window containing canvas widget. */

const char *value, /* Value of option. */

char *widgRec, /* Pointer to record for item. */

Tcl_Size offset) /* Offset into item. */

{

return Tk_GetDash(interp, value, (Tk_Dash *) (widgRec+offset));

}



/*

*--------------------------------------------------------------

*

* TkCanvasDashPrintProc --

*

* This function is invoked by the Tk configuration code to produce a

* printable string for the "-dash", "-activedash" and "-disableddash"

* configuration options for canvas items.

*

* Results:

* The return value is a string describing all the dash list for the item

* referred to by "widgRec"and "offset". In addition, *freeProcPtr is

* filled in with the address of a function to call to free the result

* string when it's no longer needed (or NULL to indicate that the string

* doesn't need to be freed).

*

* Side effects:

* None.

*

*--------------------------------------------------------------

*/

const char *

TkCanvasDashPrintProc(

TCL_UNUSED(void *),

TCL_UNUSED(Tk_Window), /* Window containing canvas widget. */

char *widgRec, /* Pointer to record for item. */

Tcl_Size offset, /* Offset in record for item. */

Tcl_FreeProc **freeProcPtr) /* Pointer to variable to fill in with

* information about how to reclaim storage

* for return string. */

{

Tk_Dash *dash = (Tk_Dash *) (widgRec+offset);

char *buffer, *p;

int i = dash->number;

if (i < 0) {

i = -i;

*freeProcPtr = TCL_DYNAMIC;

buffer = (char *)ckalloc((Tcl_Size)i + 1);

p = (i > (int)sizeof(char *)) ? dash->pattern.pt : dash->pattern.array;

memcpy(buffer, p, (unsigned int) i);

buffer[i] = 0;

return buffer;

} else if (!i) {

*freeProcPtr = NULL;

return "";

}

buffer = (char *)ckalloc(4 * (Tcl_Size)i);

*freeProcPtr = TCL_DYNAMIC;

p = (i > (int)sizeof(char *)) ? dash->pattern.pt : dash->pattern.array;

snprintf(buffer, 4 * (size_t)i, "%d", *p++ & 0xff);

while (--i) {

snprintf(buffer + strlen(buffer), 4 * (size_t)i - strlen(buffer), " %d", *p++ & 0xff);

}

return buffer;

}



/*

*--------------------------------------------------------------

*

* InitSmoothMethods --

*

* This function is invoked to set up the initial state of the list of

* "-smooth" methods. It should only be called when the list installed

* in the interpreter is NULL.

*

* Results:

* Pointer to the start of the list of default smooth methods.

*

* Side effects:

* A linked list of smooth methods is created and attached to the

* interpreter's association key "smoothMethod"

*

*--------------------------------------------------------------

*/

static SmoothAssocData *

InitSmoothMethods(

Tcl_Interp *interp)

{

SmoothAssocData *methods, *ptr;

methods = (SmoothAssocData *)ckalloc(sizeof(SmoothAssocData));

methods->smooth.name = tkRawSmoothMethod.name;

methods->smooth.coordProc = tkRawSmoothMethod.coordProc;

methods->smooth.postscriptProc = tkRawSmoothMethod.postscriptProc;

ptr = methods->nextPtr = (SmoothAssocData *)ckalloc(sizeof(SmoothAssocData));

ptr->smooth.name = tkBezierSmoothMethod.name;

ptr->smooth.coordProc = tkBezierSmoothMethod.coordProc;

ptr->smooth.postscriptProc = tkBezierSmoothMethod.postscriptProc;

ptr->nextPtr = NULL;

Tcl_SetAssocData(interp, "smoothMethod", SmoothMethodCleanupProc,methods);

return methods;

}



/*

*--------------------------------------------------------------

*

* Tk_CreateSmoothMethod --

*

* This function is invoked to add additional values for the "-smooth"

* option to the list.

*

* Results:

* A standard Tcl return value.

*

* Side effects:

* In the future "-smooth <name>" will be accepted as smooth method for

* the line and polygon.

*

*--------------------------------------------------------------

*/

void

Tk_CreateSmoothMethod(

Tcl_Interp *interp,

const Tk_SmoothMethod *smooth)

{

SmoothAssocData *methods, *typePtr2, *prevPtr, *ptr;

methods = (SmoothAssocData *)Tcl_GetAssocData(interp, "smoothMethod", NULL);

/*

* Initialize if we were not previously initialized.

*/

if (methods == NULL) {

methods = InitSmoothMethods(interp);

}

/*

* If there's already a smooth method with the given name, remove it.

*/

for (typePtr2 = methods, prevPtr = NULL; typePtr2 != NULL;

prevPtr = typePtr2, typePtr2 = typePtr2->nextPtr) {

if (!strcmp(typePtr2->smooth.name, smooth->name)) {

if (prevPtr == NULL) {

methods = typePtr2->nextPtr;

} else {

prevPtr->nextPtr = typePtr2->nextPtr;

}

ckfree(typePtr2);

break;

}

}

ptr = (SmoothAssocData *)ckalloc(sizeof(SmoothAssocData));

ptr->smooth.name = smooth->name;

ptr->smooth.coordProc = smooth->coordProc;

ptr->smooth.postscriptProc = smooth->postscriptProc;

ptr->nextPtr = methods;

Tcl_SetAssocData(interp, "smoothMethod", SmoothMethodCleanupProc, ptr);

}



/*

*----------------------------------------------------------------------

*

* SmoothMethodCleanupProc --

*

* This function is invoked whenever an interpreter is deleted to

* cleanup the smooth methods.

*

* Results:

* None.

*

* Side effects:

* Smooth methods are removed.

*

*----------------------------------------------------------------------

*/

static void

SmoothMethodCleanupProc(

void *clientData, /* Points to "smoothMethod" AssocData for the

* interpreter. */

TCL_UNUSED(Tcl_Interp *)) /* Interpreter that is being deleted. */

{

SmoothAssocData *ptr, *methods = (SmoothAssocData *)clientData;

while (methods != NULL) {

ptr = methods;

methods = methods->nextPtr;

ckfree(ptr);

}

}

/*

*--------------------------------------------------------------

*

* TkSmoothParseProc --

*

* This function is invoked during option processing to handle the

* "-smooth" option.

*

* Results:

* A standard Tcl return value.

*

* Side effects:

* The smooth option for a given item gets replaced by the value

* indicated in the value argument.

*

*--------------------------------------------------------------

*/

int

TkSmoothParseProc(

TCL_UNUSED(void *),

Tcl_Interp *interp, /* Used for reporting errors. */

TCL_UNUSED(Tk_Window), /* Window containing canvas widget. */

const char *value, /* Value of option. */

char *widgRec, /* Pointer to record for item. */

Tcl_Size offset) /* Offset into item. */

{

const Tk_SmoothMethod **smoothPtr =

(const Tk_SmoothMethod **) (widgRec + offset);

const Tk_SmoothMethod *smooth = NULL;

int b;

size_t length;

SmoothAssocData *methods;

if (value == NULL || *value == 0) {

*smoothPtr = NULL;

return TCL_OK;

}

length = strlen(value);

methods = (SmoothAssocData *)Tcl_GetAssocData(interp, "smoothMethod", NULL);

/*

* Not initialized yet; fix that now.

*/

if (methods == NULL) {

methods = InitSmoothMethods(interp);

}

/*

* Backward compatibility hack.

*/

if (strncmp(value, "bezier", length) == 0) {

smooth = &tkBezierSmoothMethod;

}

/*

* Search the list of installed smooth methods.

*/

while (methods != NULL) {

if (strncmp(value, methods->smooth.name, length) == 0) {

if (smooth != NULL) {

Tcl_SetObjResult(interp, Tcl_ObjPrintf(

"ambiguous smooth method \"%s\"", value));

Tcl_SetErrorCode(interp, "TK", "LOOKUP", "SMOOTH", value,

(char *)NULL);

return TCL_ERROR;

}

smooth = &methods->smooth;

}

methods = methods->nextPtr;

}

if (smooth) {

*smoothPtr = smooth;

return TCL_OK;

}

/*

* Did not find it. Try parsing as a boolean instead.

*/

if (Tcl_GetBoolean(interp, (char *) value, &b) != TCL_OK) {

return TCL_ERROR;

}

*smoothPtr = b ? &tkBezierSmoothMethod : NULL;

return TCL_OK;

}

/*

*--------------------------------------------------------------

*

* TkSmoothPrintProc --

*

* This function is invoked by the Tk configuration code to produce a

* printable string for the "-smooth" configuration option.

*

* Results:

* The return value is a string describing the smooth option for the item

* referred to by "widgRec". In addition, *freeProcPtr is filled in with

* the address of a function to call to free the result string when it's

* no longer needed (or NULL to indicate that the string doesn't need to

* be freed).

*

* Side effects:

* None.

*

*--------------------------------------------------------------

*/

const char *

TkSmoothPrintProc(

TCL_UNUSED(void *),

TCL_UNUSED(Tk_Window), /* Window containing canvas widget. */

char *widgRec, /* Pointer to record for item. */

Tcl_Size offset, /* Offset into item. */

TCL_UNUSED(Tcl_FreeProc **)) /* Pointer to variable to fill in with

* information about how to reclaim storage

* for return string. */

{

const Tk_SmoothMethod *smoothPtr =

* (Tk_SmoothMethod **) (widgRec + offset);

return smoothPtr ? smoothPtr->name : "0";

}

/*

*--------------------------------------------------------------

*

* Tk_GetDash

*

* This function is used to parse a string, assuming it is dash

* information.

*

* Results:

* The return value is a standard Tcl result: TCL_OK means that the dash

* information was parsed ok, and TCL_ERROR means it couldn't be parsed.

*

* Side effects:

* Dash information in the dash structure is updated.

*

*--------------------------------------------------------------

*/

int

Tk_GetDash(

Tcl_Interp *interp, /* Used for error reporting. */

const char *value, /* Textual specification of dash list. */

Tk_Dash *dash) /* Pointer to record in which to store dash

* information. */

{

Tcl_Size argc;

int i;

const char **largv, **argv = NULL;

char *pt;

if ((value == NULL) || (*value == '\0')) {

dash->number = 0;

return TCL_OK;

}

/*

* switch is usually compiled more efficiently than a chain of conditions.

*/

switch (*value) {

case '.': case ',': case '-': case '_':

i = DashConvert(NULL, value, -1, 0.0);

if (i <= 0) {

goto badDashList;

}

i = (int)strlen(value);

if (i > (int) sizeof(char *)) {

dash->pattern.pt = pt = (char *)ckalloc(strlen(value));

} else {

pt = dash->pattern.array;

}

memcpy(pt, value, (unsigned) i);

dash->number = -i;

return TCL_OK;

}

if (Tcl_SplitList(interp, (char *) value, &argc, &argv) != TCL_OK) {

Tcl_ResetResult(interp);

goto badDashList;

}

if ((unsigned) ABS(dash->number) > sizeof(char *)) {

ckfree(dash->pattern.pt);

}

if (argc > (int) sizeof(char *)) {

dash->pattern.pt = pt = (char *)ckalloc(argc);

} else {

pt = dash->pattern.array;

}

dash->number = argc;

largv = argv;

while (argc > 0) {

if (Tcl_GetInt(interp, *largv, &i) != TCL_OK || i < 1 || i>255) {

Tcl_SetObjResult(interp, Tcl_ObjPrintf(

"expected integer in the range 1..255 but got \"%s\"",

*largv));

Tcl_SetErrorCode(interp, "TK", "VALUE", "DASH", (char *)NULL);

goto syntaxError;

}

*pt++ = i;

argc--;

largv++;

}

if (argv != NULL) {

ckfree(argv);

}

return TCL_OK;

/*

* Something went wrong. Generate error message, clean up and return.

*/

badDashList:

Tcl_SetObjResult(interp, Tcl_ObjPrintf(

"bad dash list \"%s\": must be a list of integers or a format like \"-..\"",

value));

Tcl_SetErrorCode(interp, "TK", "VALUE", "DASH", (char *)NULL);

syntaxError:

if (argv != NULL) {

ckfree(argv);

}

if ((unsigned) ABS(dash->number) > sizeof(char *)) {

ckfree(dash->pattern.pt);

}

dash->number = 0;

return TCL_ERROR;

}



/*

*--------------------------------------------------------------

*

* Tk_CreateOutline

*

* This function initializes the Tk_Outline structure with default

* values.

*

* Results:

* None

*

* Side effects:

* None

*

*--------------------------------------------------------------

*/

void

Tk_CreateOutline(

Tk_Outline *outline) /* Outline structure to be filled in. */

{

outline->gc = NULL;

outline->width = 1.0;

outline->activeWidth = 0.0;

outline->disabledWidth = 0.0;

outline->offset = 0;

outline->offsetObj = NULL;

outline->reserved2 = NULL;

outline->reserved3 = NULL;

outline->dash.number = 0;

outline->activeDash.number = 0;

outline->disabledDash.number = 0;

outline->tsoffset.flags = 0;

outline->tsoffset.xoffset = 0;

outline->tsoffset.yoffset = 0;

outline->color = NULL;

outline->activeColor = NULL;

outline->disabledColor = NULL;

outline->stipple = None;

outline->activeStipple = None;

outline->disabledStipple = None;

}



/*

*--------------------------------------------------------------

*

* Tk_DeleteOutline

*

* This function frees all memory that might be allocated and referenced

* in the Tk_Outline structure.

*

* Results:

* None