/*
* tkoPath.h --
*
* Header file for the internals of the tko path package.
*
* Copyright (c) 2005-2008 Mats Bengtsson
* Copyright (c) 2019 Rene Zaumseil
*
*/
#ifndef _TKOPATH_H
#define _TKOPATH_H
#include "tkoWidget.h"
/*
* For C++ compilers, use extern "C"
*/
#ifdef __cplusplus
extern "C" {
#endif
/*
* Tkpath defines start here
*/
#define TKPATH_VERSION "0.3"
#define TKPATH_PATCHLEVEL "0.3.3"
#define TKPATH_REQUIRE "8.6.8"
/*
* Global variables set in tkpathMain.c
*/
MODULE_SCOPE int Tk_PathAntiAlias;
MODULE_SCOPE int Tk_PathDepixelize;
MODULE_SCOPE int Tk_PathSurfaceCopyPremultiplyAlpha;
/*
* So far we use a fixed number of straight line segments when
* doing various things, but it would be better to use the de Castlejau
* algorithm to iterate these segments.
*/
#define TK_PATH_NUMSEGEMENTS_CurveTo 18
#define TK_PATH_NUMSEGEMENTS_QuadBezier 12
#define TK_PATH_NUMSEGEMENTS_Max 18
#define TK_PATH_NUMSEGEMENTS_Ellipse 48
#define TK_PATH_UNIT_TMATRIX {1.0, 0.0, 0.0, 1.0, 0.0, 0.0}
/*
* Flag bits for gradient and style changes.
*/
enum {
TK_PATH_GRADIENT_FLAG_CONFIGURE = (1L << 0),
TK_PATH_GRADIENT_FLAG_DELETE
};
enum {
TK_PATH_STYLE_FLAG_CONFIGURE = (1L << 0),
TK_PATH_STYLE_FLAG_DELETE
};
enum {
TK_PATH_TEXTANCHOR_Start = 0L,
TK_PATH_TEXTANCHOR_Middle,
TK_PATH_TEXTANCHOR_End,
TK_PATH_TEXTANCHOR_N,
TK_PATH_TEXTANCHOR_W,
TK_PATH_TEXTANCHOR_S,
TK_PATH_TEXTANCHOR_E,
TK_PATH_TEXTANCHOR_NW,
TK_PATH_TEXTANCHOR_NE,
TK_PATH_TEXTANCHOR_SW,
TK_PATH_TEXTANCHOR_SE,
TK_PATH_TEXTANCHOR_C
};
enum {
TK_PATH_IMAGEINTERPOLATION_None = 0,
TK_PATH_IMAGEINTERPOLATION_Fast,
TK_PATH_IMAGEINTERPOLATION_Best
};
/* These MUST be kept in sync with methodST and unitsST! */
enum {
TK_PATH_GRADIENTMETHOD_Pad = 0L,
TK_PATH_GRADIENTMETHOD_Repeat,
TK_PATH_GRADIENTMETHOD_Reflect
};
enum {
TK_PATH_GRADIENTUNITS_BoundingBox = 0L,
TK_PATH_GRADIENTUNITS_UserSpace
};
enum {
TK_PATH_ARC_OK,
TK_PATH_ARC_Line,
TK_PATH_ARC_Skip
};
enum {
TK_PATH_GRADIENTTYPE_LINEAR = 0L,
TK_PATH_GRADIENTTYPE_RADIAL
};
/*
* Flags for 'TkPathStyleMergeStyles'.
*/
enum {
TK_PATH_MERGESTYLE_NOTFILL = 0L,
TK_PATH_MERGESTYLE_NOTSTROKE
};
/*
* The enum below defines the valid types for the TkPathAtom's.
*/
typedef enum {
TK_PATH_ATOM_M = 'M',
TK_PATH_ATOM_L = 'L',
TK_PATH_ATOM_A = 'A',
TK_PATH_ATOM_Q = 'Q',
TK_PATH_ATOM_C = 'C',
TK_PATH_ATOM_Z = 'Z',
TK_PATH_ATOM_ELLIPSE = '1', /* These are not a standard atoms
* since they are more complex (molecule).
* Not all features supported for these! */
TK_PATH_ATOM_RECT = '2'
} TkPathAtomType;
/*
* TkPathRect --
*/
typedef struct TkPathRect {
double x1;
double y1;
double x2;
double y2;
} TkPathRect;
/*
* TkPathPoint --
*/
typedef struct TkPathPoint {
double x;
double y;
} TkPathPoint;
/*
* TkPathMatrix --
*
* The transformation matrix:
* | a b 0 |
* | c d 0 |
* | tx ty 1 |
*/
typedef struct TkPathMatrix {
double a, b, c, d;
double tx, ty;
} TkPathMatrix;
/*
* TkPathAtom --
*
* Records used for parsing path to a linked list of primitive
* drawing instructions.
*
* PathAtom: vaguely modelled after Tk_PathItem. Each atom has a PathAtom record
* in its first position, padded with type specific data.
*/
typedef struct TkPathAtom {
TkPathAtomType type; /* Type of PathAtom. */
struct TkPathAtom *nextPtr; /* Next PathAtom along the path. */
} TkPathAtom;
/*
* TkLookupTable --
*/
typedef struct TkLookupTable {
int from;
int to;
} TkLookupTable;
/*
* TkMoveAtom --
*
* Records used for parsing path to a linked list of primitive
* drawing instructions.
*
* TkPathAtom: vaguely modelled after Tk_PathItem. Each atom has a TkPathAtom record
* in its first position, padded with type specific data.
*/
typedef struct TkMoveToAtom {
TkPathAtom pathAtom; /* Generic stuff that's the same for all
* types. MUST BE FIRST IN STRUCTURE. */
double x;
double y;
} TkMoveToAtom;
/*
* TkLineAtom --
*/
typedef struct TkLineToAtom {
TkPathAtom pathAtom;
double x;
double y;
} TkLineToAtom;
/*
* TkArcAtom --
*/
typedef struct TkArcAtom {
TkPathAtom pathAtom;
double radX;
double radY;
double angle; /* In degrees! */
char largeArcFlag;
char sweepFlag;
double x;
double y;
} TkArcAtom;
/*
* TkQuadBetierAtom --
*/
typedef struct TkQuadBezierAtom {
TkPathAtom pathAtom;
double ctrlX;
double ctrlY;
double anchorX;
double anchorY;
} TkQuadBezierAtom;
/*
* TkCurveToAtom --
*/
typedef struct TkCurveToAtom {
TkPathAtom pathAtom;
double ctrlX1;
double ctrlY1;
double ctrlX2;
double ctrlY2;
double anchorX;
double anchorY;
} TkCurveToAtom;
/*
* TkCloseAtom --
*/
typedef struct TkCloseAtom {
TkPathAtom pathAtom;
double x;
double y;
} TkCloseAtom;
/*
* TkellipseAtom --
*/
typedef struct TkEllipseAtom {
TkPathAtom pathAtom;
double cx;
double cy;
double rx;
double ry;
} TkEllipseAtom;
/*
* TkRectAtom --
*/
typedef struct TkRectAtom {
TkPathAtom pathAtom;
double x;
double y;
double width;
double height;
} TkRectAtom;
/*
* TkPathDash --
*
* Structures used for Dashing and Outline.
*/
typedef struct TkPathDash {
int number;
float *array;
} TkPathDash;
/*
* TkGradientStop --
*
* Records for gradient fills.
* We need a separate GradientStopArray to simplify option parsing.
*/
typedef struct TkGradientStop {
double offset;
XColor *color;
double opacity;
} TkGradientStop;
/*
* TkGradientStopArray --
*/
typedef struct TkGradientStopArray {
int nstops;
TkGradientStop **stops; /* Array of pointers to GradientStop. */
} TkGradientStopArray;
/*
* TkLinearGradientFill --
*/
typedef struct TkLinearGradientFill {
TkPathRect *transitionPtr; /* Actually not a proper rect but a vector. */
int method;
int fillRule; /* Not yet used. */
int units;
TkGradientStopArray *stopArrPtr;
} TkLinearGradientFill;
/*
* TkRadialTransition --
*/
typedef struct TkRadialTransition {
double centerX;
double centerY;
double radius;
double focalX;
double focalY;
} TkRadialTransition;
/*
* TkRadialGradientFill --
*/
typedef struct TkRadialGradientFill {
TkRadialTransition *radialPtr;
int method;
int fillRule; /* Not yet used. */
int units;
TkGradientStopArray *stopArrPtr;
} TkRadialGradientFill;
/*
* Tk_PathCanvas_ is just a dummy which is never defined anywhere.
* This happens to work because Tk_PathCanvas is a pointer.
* Its reason is to hide the internals of TkPathCanvas to item code.
*/
typedef struct Tk_PathCanvas_ *Tk_PathCanvas;
/*
* TkPathGradientMaster --
*
* This is the main record for a gradient object.
*/
typedef struct TkPathGradientMaster {
int type; /* Any of TK_PATH_GRADIENTTYPE_LINEAR or TK_PATH_GRADIENTTYPE_RADIAL */
Tk_OptionTable optionTable;
Tk_Uid name;
Tcl_Obj *transObj;
Tcl_Obj *stopsObj;
TkPathMatrix *matrixPtr; /* a b default (NULL): 1 0
* c d 0 1
* tx ty 0 0 */
struct TkPathGradientInst *instancePtr;
/* Pointer to first in list of instances
* derived from this gradient name. */
union { /* Depending on the 'type'. */
TkLinearGradientFill linearFill;
TkRadialGradientFill radialFill;
};
} TkPathGradientMaster;
typedef void (
TkPathGradientChangedProc) (
ClientData clientData,
int flags);
/*
* TkPathGradientInst --
*
* This defines an instance of a gradient with specified name and hash table.
*/
typedef struct TkPathGradientInst {
struct TkPathGradientMaster *masterPtr;
/* Each instance also points to the actual
* TkPathGradientMaster in order to remove itself
* from its linked list. */
TkPathGradientChangedProc *changeProc;
/* Code in item to call when gradient changes
* in a way that affects redisplay. */
ClientData clientData; /* Argument to pass to changeProc. */
struct TkPathGradientInst *nextPtr;
/* Next in list of all gradient instances
* associated with the same gradient name. */
} TkPathGradientInst;
/*
* TkPathColor --
*
* Only one of color and gradientInstPtr must be non NULL!
*/
typedef struct TkPathColor {
XColor *color; /* Foreground color for filling. */
TkPathGradientInst *gradientInstPtr;
/* This is an instance of a gradient.
* It points to the actual gradient object, the master. */
} TkPathColor;
#define TK_PATH_STYLE_OPTION_INDEX_END 17 /* Use this for item specific flags */
/*
* Tk_PathStyle --
*/
typedef struct Tk_PathStyle {
Tk_OptionTable optionTable; /* Not used for canvas. */
Tk_Uid name; /* Not used for canvas. */
int mask; /* Bits set for actual options modified. */
XColor *strokeColor; /* Stroke color. */
double strokeWidth; /* Width of stroke. */
double strokeOpacity;
int offset; /* Dash offset */
TkPathDash *dashPtr; /* Dash pattern. */
int capStyle; /* Cap style for stroke. */
int joinStyle; /* Join style for stroke. */
double miterLimit;
Tcl_Obj *fillObj; /* This is just used for option parsing. */
TkPathColor *fill; /* Record XColor + TkPathGradientInst. */
double fillOpacity;
int fillRule; /* WindingRule or EvenOddRule. */
TkPathMatrix *matrixPtr; /* a b default (NULL): 1 0
* c d 0 1
* tx ty 0 0 */
struct TkPathStyleInst *instancePtr;
/* Pointer to first in list of instances
* derived from this style name. */
} Tk_PathStyle;
typedef void (
TkPathStyleChangedProc) (
ClientData clientData,
int flags);
/*
* TkPathStyleInst --
*
* This defines an instance of a style with specified name and hash table.
*/
typedef struct TkPathStyleInst {
struct Tk_PathStyle *masterPtr;
/* Each instance also points to the actual
* Tk_PathStyle in order to remove itself
* from its linked list. */
TkPathStyleChangedProc *changeProc;
/* Code in item to call when style changes
* in a way that affects redisplay. */
ClientData clientData; /* Argument to pass to changeProc. */
struct TkPathStyleInst *nextPtr;
/* Next in list of all style instances
* associated with the same style name. */
} TkPathStyleInst;
/*
*--------------------------------------------------------------
*
* Procedure prototypes and structures used for defining new canvas items:
*
*--------------------------------------------------------------
*/
typedef enum {
TK_PATHSTATE_NULL = -1, TK_PATHSTATE_ACTIVE, TK_PATHSTATE_DISABLED,
TK_PATHSTATE_NORMAL, TK_PATHSTATE_HIDDEN
} Tk_PathState;
/*
* Tk_PathSmoothMethod --
*/
typedef struct Tk_PathSmoothMethod {
const char *name;
int (
*coordProc) (
Tk_PathCanvas canvas,
double *pointPtr,
int numPoints,
int numSteps,
XPoint xPoints[],
double dblPoints[]);
void (
*postscriptProc) (
Tcl_Interp * interp,
Tk_PathCanvas canvas,
double *coordPtr,
int numPoints,
int numSteps);
} Tk_PathSmoothMethod;
/*
* For each item in a canvas widget there exists one record with the following
* structure. Each actual item is represented by a record with the following
* stuff at its beginning, plus additional type-specific stuff after that.
*/
#define TK_PATHTAG_SPACE 3
/*
* Tk_PathTags --
*/
typedef struct Tk_PathTags {
Tk_Uid *tagPtr; /* Pointer to array of tags. */
int tagSpace; /* Total amount of tag space available at
* tagPtr. */
int numTags; /* Number of tag slots actually used at
* *tagPtr. */
} Tk_PathTags;
/*
* Tk_PathItem --
*/
typedef struct Tk_PathItem {
int id; /* Unique identifier for this item (also
* serves as first tag for item). */
Tk_OptionTable optionTable; /* Option table */
struct Tk_PathItem *nextPtr; /* Next sibling in display list of this group.
* Later items in list are drawn on
* top of earlier ones. */
struct Tk_PathItem *prevPtr; /* Previous sibling in display list of this group. */
struct Tk_PathItem *parentPtr;
/* Parent of item or NULL if root. */
struct Tk_PathItem *firstChildPtr;
/* First child item, only for groups. */
struct Tk_PathItem *lastChildPtr;
/* Last child item, only for groups. */
Tcl_Obj *parentObj; /* */
Tk_PathTags *pathTagsPtr; /* Allocated struct for storing tags.
* This is needed by the custom option handling. */
struct Tk_PathItemType *typePtr; /* Table of procedures that implement this
* type of item. */
int x1, y1, x2, y2; /* Bounding box for item, in integer canvas
* units. Set by item-specific code and
* guaranteed to contain every pixel drawn in
* item. Item area includes x1 and y1 but not
* x2 and y2. */
Tk_PathState state; /* State of item. */
TkPathRect bbox; /* Bounding box with zero width outline.
* Untransformed coordinates. */
TkPathRect totalBbox; /* Bounding box including stroke.
* Untransformed coordinates. */
char *reserved1; /* reserved for future use */
int redraw_flags; /* Some flags used in the canvas */
/*
*------------------------------------------------------------------
* Starting here is additional type-specific stuff; see the declarations
* for individual types to see what is part of each type. The actual space
* below is determined by the "itemInfoSize" of the type's Tk_PathItemType
* record.
*------------------------------------------------------------------
*/
} Tk_PathItem;
/*
* Records of the following type are used to describe a type of item (e.g.
* lines, circles, etc.) that can form part of a canvas widget.
*/
typedef int Tk_PathItemCreateProc(
Tcl_Interp * interp,
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
int objc,
Tcl_Obj * const objv[]);
typedef int Tk_PathItemConfigureProc(
Tcl_Interp * interp,
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
int objc,
Tcl_Obj * const objv[],
int flags);
typedef int Tk_PathItemCoordProc(
Tcl_Interp * interp,
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
int objc,
Tcl_Obj * const objv[]);
typedef void Tk_PathItemDeleteProc(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
Display * display);
typedef void Tk_PathItemDisplayProc(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
Display * display,
Drawable dst,
int x,
int y,
int width,
int height);
typedef void TkPathItemBboxProc(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
int mask);
typedef double Tk_PathItemPointProc(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
double *pointPtr);
typedef int Tk_PathItemAreaProc(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
double *rectPtr);
typedef int Tk_PathItemPdfProc(
Tcl_Interp * interp,
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
int objc,
Tcl_Obj * const objv[],
int prepass);
typedef void Tk_PathItemScaleProc(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
int compensate,
double originX,
double originY,
double scaleX,
double scaleY);
typedef void Tk_PathItemTranslateProc(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
int compensate,
double deltaX,
double deltaY);
typedef int Tk_PathItemIndexProc(
Tcl_Interp * interp,
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
char *indexString,
int *indexPtr);
typedef void Tk_PathItemCursorProc(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
int index);
typedef int Tk_PathItemSelectionProc(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
int offset,
char *buffer,
int maxBytes);
typedef void Tk_PathItemInsertProc(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
int beforeThis,
char *string);
typedef void Tk_PathItemDCharsProc(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
int first,
int last);
#ifndef __NO_OLD_CONFIG
/*
* Tk_PathItemType --
*/
typedef struct Tk_PathItemType {
const char *name; /* The name of this type of item, such as
* "line". */
int itemSize; /* Total amount of space needed for item's
* record. */
Tk_PathItemCreateProc *createProc;
/* Procedure to create a new item of this
* type. */
Tk_OptionSpec *optionSpecs; /* Pointer to array of option specs for
* this type. Used for returning option
* info. */
Tk_PathItemConfigureProc *configProc;
/* Procedure to call to change configuration
* options. */
Tk_PathItemCoordProc *coordProc; /* Procedure to call to get and set the item's
* coordinates. */
Tk_PathItemDeleteProc *deleteProc;
/* Procedure to delete existing item of this
* type. */
Tk_PathItemDisplayProc *displayProc;
/* Procedure to display items of this type. */
int alwaysRedraw; /* Non-zero means displayProc should be called
* even when the item has been moved
* off-screen. */
TkPathItemBboxProc *bboxProc;
/* Procedure that is invoked by group items
* on its children when it has reconfigured in
* any way that affect the childrens bbox display. */
Tk_PathItemPointProc *pointProc;
/* Computes distance from item to a given
* point. */
Tk_PathItemAreaProc *areaProc;
/* Computes whether item is inside, outside,
* or overlapping an area. */
Tk_PathItemPdfProc *pdfProc;
/* Procedure to write a Pdf description
* for items of this type. */
Tk_PathItemScaleProc *scaleProc; /* Procedure to rescale items of this type. */
Tk_PathItemTranslateProc *translateProc;
/* Procedure to translate items of this
* type. */
Tk_PathItemIndexProc *indexProc; /* Procedure to determine index of indicated
* character. NULL if item doesn't support
* indexing. */
Tk_PathItemCursorProc *icursorProc;
/* Procedure to set insert cursor posn to just
* before a given position. */
Tk_PathItemSelectionProc *selectionProc;
/* Procedure to return selection (in STRING
* format) when it is in this item. */
Tk_PathItemInsertProc *insertProc;
/* Procedure to insert something into an
* item. */
Tk_PathItemDCharsProc *dCharsProc;
/* Procedure to delete characters from an
* item. */
struct Tk_PathItemType *nextPtr; /* Used to link types together into a list. */
int isPathType; /* False for original canvas item types. */
} Tk_PathItemType;
#endif
/*
* Tk_PathCanvasTextInfo --
*
* The following structure provides information about the selection and the
* insertion cursor. It is needed by only a few items, such as those that
* display text. It is shared by the generic canvas code and the item-specific
* code, but most of the fields should be written only by the canvas generic
* code.
*/
typedef struct Tk_PathCanvasTextInfo {
Tk_3DBorder selBorder; /* Border and background for selected
* characters. Read-only to items.*/
int selBorderWidth; /* Width of border around selection. Read-only
* to items. */
XColor *selFgColorPtr; /* Foreground color for selected text.
* Read-only to items. */
Tk_PathItem *selItemPtr; /* Pointer to selected item. NULL means
* selection isn't in this canvas. Writable by
* items. */
int selectFirst; /* Character index of first selected
* character. Writable by items. */
int selectLast; /* Character index of last selected character.
* Writable by items. */
Tk_PathItem *anchorItemPtr; /* Item corresponding to "selectAnchor": not
* necessarily selItemPtr. Read-only to
* items. */
int selectAnchor; /* Character index of fixed end of selection
* (i.e. "select to" operation will use this
* as one end of the selection). Writable by
* items. */
Tk_3DBorder insertBorder; /* Used to draw vertical bar for insertion
* cursor. Read-only to items. */
int insertWidth; /* Total width of insertion cursor. Read-only
* to items. */
int insertBorderWidth; /* Width of 3-D border around insert cursor.
* Read-only to items. */
Tk_PathItem *focusItemPtr; /* Item that currently has the input focus, or
* NULL if no such item. Read-only to items. */
int gotFocus; /* Non-zero means that the canvas widget has
* the input focus. Read-only to items.*/
int cursorOn; /* Non-zero means that an insertion cursor
* should be displayed in focusItemPtr.
* Read-only to items.*/
} Tk_PathCanvasTextInfo;
/*
* Tk_PathOutline --
*/
typedef struct Tk_PathOutline {
GC gc; /* Graphics context. */
double width; /* Width of outline. */
double activeWidth; /* Width of outline. */
double disabledWidth; /* Width of outline. */
int offset; /* Dash offset. */
Tk_Dash *dashPtr; /* Dash pattern. */
Tk_Dash *activeDashPtr; /* Dash pattern if state is active. */
Tk_Dash *disabledDashPtr; /* Dash pattern if state is disabled. */
void *reserved1; /* Reserved for future expansion. */
void *reserved2;
void *reserved3;
Tk_TSOffset *tsoffsetPtr; /* Stipple offset for outline. */
XColor *color; /* Outline color. */
XColor *activeColor; /* Outline color if state is active. */
XColor *disabledColor; /* Outline color if state is disabled. */
Pixmap stipple; /* Outline Stipple pattern. */
Pixmap activeStipple; /* Outline Stipple pattern if state is
* active. */
Pixmap disabledStipple; /* Outline Stipple pattern if state is
* disabled. */
} Tk_PathOutline;
#define TK_PATH_OPTION_SPEC_ARROWLENGTH_DEFAULT "10.0"
#define TK_PATH_OPTION_SPEC_ARROWWIDTH_DEFAULT "5.0"
#define TK_PATH_OPTION_SPEC_ARROWFILL_DEFAULT "0.7"
#define TK_PATH_OPTION_SPEC_STARTARROW(Item) \
{TK_OPTION_BOOLEAN, "-startarrow", NULL, NULL, \
"0", -1, Tk_Offset(Item, startarrow.arrowEnabled), \
0, 0, 0}
#define TK_PATH_OPTION_SPEC_STARTARROWLENGTH(Item) \
{TK_OPTION_DOUBLE, "-startarrowlength", NULL, NULL, \
TK_PATH_OPTION_SPEC_ARROWLENGTH_DEFAULT, -1, \
Tk_Offset(Item, startarrow.arrowLength), \
0, 0, 0}
#define TK_PATH_OPTION_SPEC_STARTARROWWIDTH(Item) \
{TK_OPTION_DOUBLE, "-startarrowwidth", NULL, NULL, \
TK_PATH_OPTION_SPEC_ARROWWIDTH_DEFAULT, -1, \
Tk_Offset(Item, startarrow.arrowWidth), \
0, 0, 0}
#define TK_PATH_OPTION_SPEC_STARTARROWFILL(Item) \
{TK_OPTION_DOUBLE, "-startarrowfill", NULL, NULL, \
TK_PATH_OPTION_SPEC_ARROWFILL_DEFAULT, -1, \
Tk_Offset(Item, startarrow.arrowFillRatio), \
0, 0, 0}
#define TK_PATH_OPTION_SPEC_ENDARROW(Item) \
{TK_OPTION_BOOLEAN, "-endarrow", NULL, NULL, \
"0", -1, Tk_Offset(Item, endarrow.arrowEnabled), \
0, 0, 0}
#define TK_PATH_OPTION_SPEC_ENDARROWLENGTH(Item) \
{TK_OPTION_DOUBLE, "-endarrowlength", NULL, NULL, \
TK_PATH_OPTION_SPEC_ARROWLENGTH_DEFAULT, -1, \
Tk_Offset(Item, endarrow.arrowLength), \
0, 0, 0}
#define TK_PATH_OPTION_SPEC_ENDARROWWIDTH(Item) \
{TK_OPTION_DOUBLE, "-endarrowwidth", NULL, NULL, \
TK_PATH_OPTION_SPEC_ARROWWIDTH_DEFAULT, -1, \
Tk_Offset(Item, endarrow.arrowWidth), \
0, 0, 0}
#define TK_PATH_OPTION_SPEC_ENDARROWFILL(Item) \
{TK_OPTION_DOUBLE, "-endarrowfill", NULL, NULL, \
TK_PATH_OPTION_SPEC_ARROWFILL_DEFAULT, -1, \
Tk_Offset(Item, endarrow.arrowFillRatio), \
0, 0, 0}
#define TK_PATH_OPTION_SPEC_STARTARROW_GRP(Item) \
TK_PATH_OPTION_SPEC_STARTARROW(Item), \
TK_PATH_OPTION_SPEC_STARTARROWLENGTH(Item), \
TK_PATH_OPTION_SPEC_STARTARROWWIDTH(Item), \
TK_PATH_OPTION_SPEC_STARTARROWFILL(Item)
#define TK_PATH_OPTION_SPEC_ENDARROW_GRP(Item) \
TK_PATH_OPTION_SPEC_ENDARROW(Item), \
TK_PATH_OPTION_SPEC_ENDARROWLENGTH(Item), \
TK_PATH_OPTION_SPEC_ENDARROWWIDTH(Item), \
TK_PATH_OPTION_SPEC_ENDARROWFILL(Item)
typedef struct TkPathTagSearchExpr_s TkPathTagSearchExpr;
/*
* TkPathTagSearchExpr_s --
*/
struct TkPathTagSearchExpr_s {
TkPathTagSearchExpr *next; /* For linked lists of expressions - used in
* bindings. */
Tk_Uid uid; /* The uid of the whole expression. */
Tk_Uid *uids; /* Expresion compiled to an array of uids. */
int allocated; /* Available space for array of uids. */
int length; /* Length of expression. */
int index; /* Current position in expression
* evaluation. */
int match; /* This expression matches event's item's
* tags. */
};
/*
* Opaque platform dependent struct.
*/
typedef ClientData TkPathContext;
/*
* TkPathCanvas --
*
* The record below describes a canvas widget. It is made available to the
* item functions so they can access certain shared fields such as the overall
* displacement and scale factor for the canvas.
*/
typedef struct TkPathCanvas {
Tk_Window *win;
Display *display;
Tcl_Interp *interp;
Tk_PathItem *rootItemPtr; /* The root item with id 0, always there. */
/*
* Information used when displaying widget:
*/
int borderWidth; /* Width of 3-D border around window. *
* Integer value corresponding to
* borderWidthPtr. Always >= 0. */
Tk_3DBorder bgBorder; /* Used for canvas background. */
int relief; /* Indicates whether window as a whole is
* raised, sunken, or flat. */
int highlightWidth; /* Integer value corresponding to
* highlightWidthPtr. Always >= 0. */
XColor *highlightBgColorPtr;
/* Color for drawing traversal highlight area
* when highlight is off. */
XColor *highlightColorPtr; /* Color for drawing traversal highlight. */
int inset; /* Total width of all borders, including
* traversal highlight and 3-D border.
* Indicates how much interior stuff must be
* offset from outside edges to leave room for
* borders. */
GC pixmapGC; /* Used to copy bits from a pixmap to the
* screen and also to clear the pixmap. */
int width, height; /* Dimensions to request for canvas window,
* specified in pixels. */
int redrawX1, redrawY1; /* Upper left corner of area to redraw, in
* pixel coordinates. Border pixels are
* included. Only valid if REDRAW_PENDING flag
* is set. */
int redrawX2, redrawY2; /* Lower right corner of area to redraw, in
* integer canvas coordinates. Border pixels
* will *not* be redrawn. */
int confine; /* Non-zero means constrain view to keep as
* much of canvas visible as possible. */
/*
* Information used to manage the selection and insertion cursor:
*/
Tk_PathCanvasTextInfo textInfo; /* Contains lots of fields; see tk.h for
* details. This structure is shared with the
* code that implements individual items. */
int insertOnTime; /* Number of milliseconds cursor should spend
* in "on" state for each blink. */
int insertOffTime; /* Number of milliseconds cursor should spend
* in "off" state for each blink. */
Tcl_TimerToken insertBlinkHandler;
/* Timer handler used to blink cursor on and
* off. */
/*
* Transformation applied to canvas as a whole: to compute screen
* coordinates (X,Y) from canvas coordinates (x,y), do the following:
*
* X = x - xOrigin;
* Y = y - yOrigin;
*/
int xOrigin, yOrigin; /* Canvas coordinates corresponding to
* upper-left corner of window, given in
* canvas pixel units. */
int drawableXOrigin, drawableYOrigin;
/* During redisplay, these fields give the
* canvas coordinates corresponding to the
* upper-left corner of the drawable where
* items are actually being drawn (typically a
* pixmap smaller than the whole window). */
/*
* Information used for event bindings associated with items.
*/
Tk_BindingTable bindingTable;
/* Table of all bindings currently defined for
* this canvas. NULL means that no bindings
* exist, so the table hasn't been created.
* Each "object" used for this table is either
* a Tk_Uid for a tag or the address of an
* item named by id. */
Tk_PathItem *currentItemPtr; /* The item currently containing the mouse
* pointer, or NULL if none. */
Tk_PathItem *newCurrentPtr; /* The item that is about to become the
* current one, or NULL. This field is used to
* detect deletions of the new current item
* pointer that occur during Leave processing
* of the previous current item. */
double closeEnough; /* The mouse is assumed to be inside an item
* if it is this close to it. */
XEvent pickEvent; /* The event upon which the current choice of
* currentItem is based. Must be saved so that
* if the currentItem is deleted, can pick
* another. */
int state; /* Last known modifier state. Used to defer
* picking a new current object while buttons
* are down. */
/*
* Information used for managing scrollbars:
*/
char *xScrollCmd; /* Command prefix for communicating with
* horizontal scrollbar. NULL means no
* horizontal scrollbar. Malloc'ed. */
char *yScrollCmd; /* Command prefix for communicating with
* vertical scrollbar. NULL means no vertical
* scrollbar. Malloc'ed. */
int scroll[4];
/* These four coordinates (x1,y1,x2,y2) define the region
* that is the 100% area for scrolling (i.e.
* these numbers determine the size and
* location of the sliders on scrollbars).
* Units are pixels in canvas coords. */
int xScrollIncrement; /* If >0, defines a grid for horizontal
* scrolling. This is the size of the "unit",
* and the left edge of the screen will always
* lie on an even unit boundary. */
int yScrollIncrement; /* If >0, defines a grid for horizontal
* scrolling. This is the size of the "unit",
* and the left edge of the screen will always
* lie on an even unit boundary. */
/*
* Information used for scanning:
*/
int scanX; /* X-position at which scan started (e.g.
* button was pressed here). */
int scanXOrigin; /* Value of xOrigin field when scan started. */
int scanY; /* Y-position at which scan started (e.g.
* button was pressed here). */
int scanYOrigin; /* Value of yOrigin field when scan started. */
/*
* Information used to speed up searches by remembering the last item
* created or found with an item id search.
*/
Tk_PathItem *hotPtr; /* Pointer to "hot" item (one that's been
* recently used. NULL means there's no hot
* item. */
Tk_PathItem *hotPrevPtr; /* Pointer to predecessor to hotPtr (NULL
* means item is first in list). This is only
* a hint and may not really be hotPtr's
* predecessor. */
/*
* Miscellaneous information:
*/
Tk_Cursor cursor; /* Current cursor for window, or None. */
double pixelsPerMM; /* Scale factor between MM and pixels; used
* when converting coordinates. */
int nextId; /* Number to use as id for next item created
* in widget. */
Tcl_HashTable idTable; /* Table of integer indices. */
/* @@@ TODO: as pointers instead??? */
Tcl_HashTable styleTable; /* Table for styles.
* This defines the namespace for style names. */
Tcl_HashTable gradientTable; /* Table for gradients.
* This defines the namespace for gradient names. */
int styleUid; /* Running integer used to number style tokens. */
int gradientUid; /* Running integer used to number gradient tokens. */
int tagStyle;
int flags;
Tk_PathState canvas_state; /* State of canvas. */
TkPathContext context; /* Path context allocated during a redraw. */
Tk_TSOffset *tsoffsetPtr;
TkPathTagSearchExpr *bindTagExprs; /* Linked list of tag expressions used in
* bindings. */
} TkPathCanvas;
/*
* Tk_PathItemEx --
*
* This is an extended item record that is used for the new
* path based items to allow more generic code to be used for them
* since all of them (?) anyhow include a Tk_PathStyle record.
*/
typedef struct Tk_PathItemEx {
Tk_PathItem header; /* Generic stuff that's the same for all
* types. MUST BE FIRST IN STRUCTURE. */
Tk_PathCanvas canvas; /* Canvas containing item. */
Tk_PathStyle style; /* Contains most drawing info. */
Tcl_Obj *styleObj; /* Object with style name. */
TkPathStyleInst *styleInst;
/* The referenced style instance from styleObj. */
/*
*------------------------------------------------------------------
* Starting here is additional type-specific stuff; see the declarations
* for individual types to see what is part of each type. The actual space
* below is determined by the "itemInfoSize" of the type's Tk_PathItemType
* record.
*------------------------------------------------------------------
*/
} Tk_PathItemEx;
/*
* Retrieve TkPathContext from Tk_PathCanvas.
*/
#define ContextOfCanvas(canvas) (((TkPathCanvas *) (canvas))->context)
/*
* New API option parsing.
*/
#define TK_PATH_DEF_STATE "normal"
/* These MUST be kept in sync with Tk_PathState! */
#define TK_PATH_OPTION_STRING_TABLES_STATE \
static const char *stateStrings[] = { \
"active", "disabled", "normal", "hidden", NULL \
};
#define TK_PATH_CUSTOM_OPTION_TAGS \
static Tk_ObjCustomOption tagsCO = { \
"tags", \
Tk_PathCanvasTagsOptionSetProc, \
Tk_PathCanvasTagsOptionGetProc, \
Tk_PathCanvasTagsOptionRestoreProc, \
Tk_PathCanvasTagsOptionFreeProc, \
(ClientData) NULL \
};
#define TK_PATH_OPTION_SPEC_PARENT \
{TK_OPTION_STRING, "-parent", NULL, NULL, \
"0", Tk_Offset(Tk_PathItem, parentObj), -1, \
0, 0, TK_PATH_CORE_OPTION_PARENT}
#define TK_PATH_OPTION_SPEC_CORE(typeName) \
{TK_OPTION_STRING_TABLE, "-state", NULL, NULL, \
TK_PATH_DEF_STATE, -1, Tk_Offset(Tk_PathItem, state), \
0, (ClientData) stateStrings, 0}, \
{TK_OPTION_STRING, "-style", (char *) NULL, (char *) NULL, \
"", Tk_Offset(typeName, styleObj), -1, \
TK_OPTION_NULL_OK, 0, TK_PATH_CORE_OPTION_STYLENAME}, \
{TK_OPTION_CUSTOM, "-tags", NULL, NULL, \
NULL, -1, Tk_Offset(Tk_PathItem, pathTagsPtr), \
TK_OPTION_NULL_OK, (ClientData) &tagsCO, TK_PATH_CORE_OPTION_TAGS}
/*
* Information used for parsing configuration options.
* Mask bits for options changed.
*/
enum {
TK_PATH_STYLE_OPTION_FILL = (1L << 0),
TK_PATH_STYLE_OPTION_FILL_OFFSET = (1L << 1),
TK_PATH_STYLE_OPTION_FILL_OPACITY = (1L << 2),
TK_PATH_STYLE_OPTION_FILL_RULE = (1L << 3),
TK_PATH_STYLE_OPTION_FILL_STIPPLE = (1L << 4),
TK_PATH_STYLE_OPTION_MATRIX = (1L << 5),
TK_PATH_STYLE_OPTION_STROKE = (1L << 6),
TK_PATH_STYLE_OPTION_STROKE_DASHARRAY = (1L << 7),
TK_PATH_STYLE_OPTION_STROKE_LINECAP = (1L << 8),
TK_PATH_STYLE_OPTION_STROKE_LINEJOIN = (1L << 9),
TK_PATH_STYLE_OPTION_STROKE_MITERLIMIT = (1L << 10),
TK_PATH_STYLE_OPTION_STROKE_OFFSET = (1L << 11),
TK_PATH_STYLE_OPTION_STROKE_OPACITY = (1L << 12),
TK_PATH_STYLE_OPTION_STROKE_STIPPLE = (1L << 13),
TK_PATH_STYLE_OPTION_STROKE_WIDTH = (1L << 14),
TK_PATH_CORE_OPTION_PARENT = (1L << 15),
TK_PATH_CORE_OPTION_STYLENAME = (1L << 16),
TK_PATH_CORE_OPTION_TAGS = (1L << 17),
};
/* @@@ TODO: Much more to be added here! */
enum TkFontWeight {
TK_PATH_TEXT_WEIGHT_NORMAL,
TK_PATH_TEXT_WEIGHT_BOLD
};
enum TkFontSlant {
TK_PATH_TEXT_SLANT_NORMAL,
TK_PATH_TEXT_SLANT_ITALIC,
TK_PATH_TEXT_SLANT_OBLIQUE
};
/*
* Tk_PathTextStyle --
*/
typedef struct Tk_PathTextStyle {
char *fontFamily;
double fontSize;
enum TkFontWeight fontWeight;
enum TkFontSlant fontSlant;
} Tk_PathTextStyle;
#define TK_PATH_STYLE_CUSTOM_OPTION_MATRIX \
static Tk_ObjCustomOption matrixCO = { \
"matrix", \
TkPathMatrixSetOption, \
TkPathMatrixGetOption, \
TkPathMatrixRestoreOption, \
TkPathMatrixFreeOption, \
(ClientData) NULL \
};
#define TK_PATH_STYLE_CUSTOM_OPTION_DASH \
static Tk_ObjCustomOption dashCO = { \
"dasharray", \
Tk_PathDashOptionSetProc, \
Tk_PathDashOptionGetProc, \
Tk_PathDashOptionRestoreProc, \
Tk_PathDashOptionFreeProc, \
(ClientData) NULL \
};
#define TK_PATH_STYLE_CUSTOM_OPTION_PATHCOLOR \
static Tk_ObjCustomOption pathColorCO = { \
"pathcolor", \
TkPathColorSetOption, \
TkPathColorGetOption, \
TkPathColorRestoreOption, \
TkPathColorFreeOption, \
(ClientData) NULL \
};
#define TK_PATH_STYLE_CUSTOM_OPTION_RECORDS \
TK_PATH_STYLE_CUSTOM_OPTION_MATRIX \
TK_PATH_STYLE_CUSTOM_OPTION_DASH
/*
* These must be kept in sync with defines in X.h!
*/
#define TK_PATH_OPTION_STRING_TABLES_FILL \
static const char *fillRuleST[] = { \
"evenodd", "nonzero", (char *) NULL \
};
#define TK_PATH_OPTION_STRING_TABLES_STROKE \
static const char *lineCapST[] = { \
"notlast", "butt", "round", "projecting", (char *) NULL \
}; \
static const char *lineJoinST[] = { \
"miter", "round", "bevel", (char *) NULL \
};
#define TK_PATH_OPTION_SPEC_STYLENAME(typeName) \
{TK_OPTION_STRING, "-style", NULL, NULL, \
"", Tk_Offset(typeName, styleObj), -1, TK_OPTION_NULL_OK, 0, 0}
/*
* This assumes that we have a Tk_PathStyle struct element named 'style'.
*/
#define TK_PATH_OPTION_SPEC_STYLE_FILL(typeName, theColor) \
{TK_OPTION_STRING, "-fill", NULL, NULL, \
theColor, Tk_Offset(typeName, style.fillObj), -1, \
TK_OPTION_NULL_OK, 0, TK_PATH_STYLE_OPTION_FILL}, \
{TK_OPTION_DOUBLE, "-fillopacity", NULL, NULL, \
"1.0", -1, Tk_Offset(typeName, style.fillOpacity), 0, 0, \
TK_PATH_STYLE_OPTION_FILL_OPACITY}, \
{TK_OPTION_STRING_TABLE, "-fillrule", NULL, NULL, \
"nonzero", -1, Tk_Offset(typeName, style.fillRule), \
0, (ClientData) fillRuleST, TK_PATH_STYLE_OPTION_FILL_RULE}
#define TK_PATH_OPTION_SPEC_STYLE_MATRIX(typeName) \
{TK_OPTION_CUSTOM, "-matrix", NULL, NULL, \
NULL, -1, Tk_Offset(typeName, style.matrixPtr), \
TK_OPTION_NULL_OK, (ClientData) &matrixCO, TK_PATH_STYLE_OPTION_MATRIX}
#define TK_PATH_OPTION_SPEC_STYLE_STROKE(typeName, theColor) \
{TK_OPTION_COLOR, "-stroke", NULL, NULL, \
theColor, -1, Tk_Offset(typeName, style.strokeColor), \
TK_OPTION_NULL_OK, 0, TK_PATH_STYLE_OPTION_STROKE}, \
{TK_OPTION_CUSTOM, "-strokedasharray", NULL, NULL, \
NULL, -1, Tk_Offset(typeName, style.dashPtr), \
0, (ClientData) &dashCO, \
TK_PATH_STYLE_OPTION_STROKE_DASHARRAY}, \
{TK_OPTION_STRING_TABLE, "-strokelinecap", NULL, NULL, \
"butt", -1, Tk_Offset(typeName, style.capStyle), \
0, (ClientData) lineCapST, TK_PATH_STYLE_OPTION_STROKE_LINECAP}, \
{TK_OPTION_STRING_TABLE, "-strokelinejoin", NULL, NULL, \
"round", -1, Tk_Offset(typeName, style.joinStyle), \
0, (ClientData) lineJoinST, TK_PATH_STYLE_OPTION_STROKE_LINEJOIN}, \
{TK_OPTION_DOUBLE, "-strokemiterlimit", NULL, NULL, \
"4.0", -1, Tk_Offset(typeName, style.miterLimit), 0, 0, \
TK_PATH_STYLE_OPTION_STROKE_MITERLIMIT}, \
{TK_OPTION_DOUBLE, "-strokeopacity", NULL, NULL, \
"1.0", -1, Tk_Offset(typeName, style.strokeOpacity), 0, 0, \
TK_PATH_STYLE_OPTION_STROKE_OPACITY}, \
{TK_OPTION_DOUBLE, "-strokewidth", NULL, NULL, \
"1.0", -1, Tk_Offset(typeName, style.strokeWidth), 0, 0, \
TK_PATH_STYLE_OPTION_STROKE_WIDTH}
#define TK_PATH_OPTION_SPEC_END \
{TK_OPTION_END, NULL, NULL, NULL, \
NULL, 0, -1, 0, (ClientData) NULL, 0}
/* for arrows: */
/* ARROW_BOTH = ARROWS_FIRST | ARROWS_LAST */
typedef enum {
TK_PATH_ARROWS_OFF = 0, TK_PATH_ARROWS_ON = 1
} TkPathArrowState;
/*
* TkPathArrowDescr --
*/
typedef struct TkPathArrowDescr {
TkPathArrowState arrowEnabled; /* Indicates whether or not to draw arrowheads: off/on */
double arrowLength; /* Length of arrowhead. */
double arrowWidth; /* width of arrowhead. */
double arrowFillRatio; /* filled part of arrow head, relative to arrowLengthRel.
* 0: special case, arrowhead only 2 line, without fill */
TkPathPoint *arrowPointsPtr; /* Points to array of PTS_IN_ARROW points
* describing polygon for arrowhead in line.
* NULL means no arrowhead at current point. */
} TkPathArrowDescr;
/*
* Inline function declarations:
*/
/*
* If stroke width is an integer, widthCode=1,2, move coordinate
* to pixel boundary if even stroke width, widthCode=2,
* or to pixel center if odd stroke width, widthCode=1.
*/
#define TK_PATH_DEPIXELIZE(widthCode,x) \
(!(widthCode) ? (x) : ((int) (floor((x) + 0.001)) + (((widthCode) == 1) ? 0.5 : 0)));
#define GetColorFromPathColor(pcol)\
(((pcol != NULL) && (pcol->color != NULL)) ? pcol->color : NULL )
#define GetGradientMasterFromPathColor(pcol) \
(((pcol != NULL) && (pcol->gradientInstPtr != NULL)) ? pcol->gradientInstPtr->masterPtr : NULL )
#define HaveAnyFillFromPathColor(pcol) \
(((pcol != NULL) && ((pcol->color != NULL) || (pcol->gradientInstPtr != NULL))) ? 1 : 0 )
/*
* tkpath specific item types.
*/
MODULE_SCOPE Tk_PathItemType tkPathTypeWindow;
MODULE_SCOPE Tk_PathItemType tkPathTypePath;
MODULE_SCOPE Tk_PathItemType tkPathTypeRect;
MODULE_SCOPE Tk_PathItemType tkPathTypeLine;
MODULE_SCOPE Tk_PathItemType tkPathTypePolyline;
MODULE_SCOPE Tk_PathItemType tkPathTypePolygon;
MODULE_SCOPE Tk_PathItemType tkPathTypeCircle;
MODULE_SCOPE Tk_PathItemType tkPathTypeEllipse;
MODULE_SCOPE Tk_PathItemType tkPathTypeImage;
MODULE_SCOPE Tk_PathItemType tkPathTypeText;
MODULE_SCOPE Tk_PathItemType tkPathTypeGroup;
MODULE_SCOPE Tk_PathSmoothMethod tkPathBezierSmoothMethod;
/*
* Tcl variable and command names
*/
/* Tcl variables */
#define TK_PATHVAR_PREMULTIPLYALPHA "::path::premultiplyalpha"
#define TK_PATHVAR_DEPIXELIZE "::path::depixelize"
#define TK_PATHVAR_ANTIALIAS "::path::antialias"
/* Tcl commands */
#define TK_PATHCMD_PIXELALIGN "::path::pixelalign"
#define TK_PATHCMD_GRADIENT "::gradient"
#define TK_PATHCMD_PATHGRADIENT "::path::gradient"
#define TK_PATHCMD_STYLE "::style"
#define TK_PATHCMD_PATHSTYLE "::path::style"
#define TK_PATHCMD_PATHSURFACE "::path::surface"
/*
* Function declarations:
*/
/* tkPathCanvArrow.c */
MODULE_SCOPE void TkPathArrowDescrInit(
TkPathArrowDescr * descr);
MODULE_SCOPE void TkPathIncludeArrowPointsInRect(
TkPathRect * bbox,
TkPathArrowDescr * arrowDescrPtr);
MODULE_SCOPE void TkPathIncludeArrowPoints(
Tk_PathItem * itemPtr,
TkPathArrowDescr * arrowDescrPtr);
MODULE_SCOPE void TkPathPreconfigureArrow(
TkPathPoint * pf,
TkPathArrowDescr * arrowDescr);
MODULE_SCOPE TkPathPoint TkPathConfigureArrow(
TkPathPoint pf,
TkPathPoint pl,
TkPathArrowDescr * arrow,
Tk_PathStyle * lineStyle,
int updateFirstPoint);
MODULE_SCOPE void TkPathTranslateArrow(
TkPathArrowDescr * arrowDescr,
double deltaX,
double deltaY);
MODULE_SCOPE void TkPathScaleArrow(
TkPathArrowDescr * arrowDescr,
double originX,
double originY,
double scaleX,
double scaleY);
MODULE_SCOPE void TkPathFreeArrow(
TkPathArrowDescr * arrowDescr);
MODULE_SCOPE int TkPathGetSegmentsFromPathAtomList(
TkPathAtom * firstAtom,
TkPathPoint ** firstPt,
TkPathPoint * secondPt,
TkPathPoint * penultPt,
TkPathPoint ** lastPt);
MODULE_SCOPE TkPathAtom *TkPathMakePathAtomsFromArrow(
TkPathArrowDescr * arrowDescr);
MODULE_SCOPE void TkPathDisplayArrow(
Tk_PathCanvas canvas,
TkPathArrowDescr * arrowDescr,
Tk_PathStyle * const style,
TkPathMatrix * mPtr,
TkPathRect * bboxPtr);
MODULE_SCOPE void TkPathPaintArrow(
TkPathContext context,
TkPathArrowDescr * arrowDescr,
Tk_PathStyle * const style,
TkPathRect * bboxPtr);
/* tkPathCanvas.c */
MODULE_SCOPE int Tk_PathCanvasObjCmd(
ClientData clientData,
Tcl_Interp * interp,
int objc,
Tcl_Obj * const objv[]);
MODULE_SCOPE void Tk_PathCanvasEventuallyRedraw(
Tk_PathCanvas canvas,
int x1,
int y1,
int x2,
int y2);
MODULE_SCOPE void TkPathCanvasSetParent(
Tk_PathItem * parentPtr,
Tk_PathItem * itemPtr);
MODULE_SCOPE int TkPathCanvasFindGroup(
Tcl_Interp * interp,
Tk_PathCanvas canvas,
Tcl_Obj * parentObj,
Tk_PathItem ** parentPtrPtr);
MODULE_SCOPE void TkPathCanvasGroupBbox(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
int *x1Ptr,
int *y1Ptr,
int *x2Ptr,
int *y2Ptr);
MODULE_SCOPE Tk_PathItem *TkPathCanvasItemIteratorNext(
Tk_PathItem * itemPtr);
MODULE_SCOPE Tk_PathItem *TkPathCanvasItemIteratorPrev(
Tk_PathItem * itemPtr);
MODULE_SCOPE void TkPathCanvasItemDetach(
Tk_PathItem * itemPtr);
MODULE_SCOPE void TkPathGroupItemConfigured(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
int mask);
MODULE_SCOPE void TkPathCanvasTranslateGroup(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
int compensate,
double deltaX,
double deltaY);
MODULE_SCOPE void TkPathCanvasScaleGroup(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
int compensate,
double originX,
double originY,
double scaleX,
double scaleY);
MODULE_SCOPE void TkPathCanvasSetParentToRoot(
Tk_PathItem * itemPtr);
/* tkPathCanvEllipse.c */
/* tkPathCanvGroup.c */
MODULE_SCOPE void TkPathCanvasSetGroupDirtyBbox(
Tk_PathItem * itemPtr);
MODULE_SCOPE void TkPathCanvasUpdateGroupBbox(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr);
/* tkPathCanvImage.c */
/* tkPathCanvLine.c */
/* tkPathCanvPath.c */
/* tkPathCanvPoly.c */
/* tkPathCanvRect.c */
/* tkPathCanvText.c */
/* tkPathCanvWindow.c */
/* tkPathGeneric.c */
MODULE_SCOPE int TkPathParseToAtoms(
Tcl_Interp * interp,
Tcl_Obj * listObjPtr,
TkPathAtom ** atomPtrPtr,
int *lenPtr);
MODULE_SCOPE void TkPathFreeAtoms(
TkPathAtom * pathAtomPtr);
MODULE_SCOPE int TkPathNormalize(
Tcl_Interp * interp,
TkPathAtom * atomPtr,
Tcl_Obj ** listObjPtrPtr);
MODULE_SCOPE int TkPathMakePath(
TkPathContext ctx,
TkPathAtom * atomPtr,
Tk_PathStyle * stylePtr);
MODULE_SCOPE void TkPathArcToUsingBezier(
TkPathContext ctx,
double rx,
double ry,
double phiDegrees,
char largeArcFlag,
char sweepFlag,
double x2,
double y2);
MODULE_SCOPE int TkPathPdfNumber(
Tcl_Obj * ret,
int fracDigis,
double number,
const char *append);
MODULE_SCOPE int TkPathPdfColor(
Tcl_Obj * ret,
XColor * colorPtr,
const char *command);
MODULE_SCOPE int TkPathPdfArrow(
Tcl_Interp * interp,
TkPathArrowDescr * arrow,
Tk_PathStyle * const style);
MODULE_SCOPE int TkPathPdf(
Tcl_Interp * interp,
TkPathAtom * atomPtr,
Tk_PathStyle * stylePtr,
TkPathRect * bboxPtr,
int objc,
Tcl_Obj * const objv[]);
MODULE_SCOPE Tcl_Obj *TkPathExtGS(
Tk_PathStyle * stylePtr,
long *smaskRef);
MODULE_SCOPE TkPathAtom *TkPathNewMoveToAtom(
double x,
double y);
MODULE_SCOPE TkPathAtom *TkPathNewLineToAtom(
double x,
double y);
MODULE_SCOPE TkPathAtom *TkPathNewArcAtom(
double radX,
double radY,
double angle,
char largeArcFlag,
char sweepFlag,
double x,
double y);
MODULE_SCOPE TkPathAtom *TkPathNewQuadBezierAtom(
double ctrlX,
double ctrlY,
double anchorX,
double anchorY);
MODULE_SCOPE TkPathAtom *TkPathNewCurveToAtom(
double ctrlX1,
double ctrlY1,
double ctrlX2,
double ctrlY2,
double anchorX,
double anchorY);
MODULE_SCOPE TkPathAtom *TkPathNewRectAtom(
double pointsPtr[]);
MODULE_SCOPE TkPathAtom *TkPathNewCloseAtom(
double x,
double y);
MODULE_SCOPE int TkPathPixelAlignObjCmd(
ClientData clientData,
Tcl_Interp * interp,
int objc,
Tcl_Obj * const objv[]);
/* tkPathGradient.c */
MODULE_SCOPE TkPathColor *TkPathGetPathColorStatic(
Tcl_Interp * interp,
Tk_Window tkwin,
Tcl_Obj * nameObj);
MODULE_SCOPE TkPathGradientInst *TkPathGetGradient(
Tcl_Interp * interp,
const char *name,
Tcl_HashTable * tablePtr,
TkPathGradientChangedProc * changeProc,
ClientData clientData);
MODULE_SCOPE void TkPathFreeGradient(
TkPathGradientInst * gradientPtr);
MODULE_SCOPE void TkPathGradientChanged(
TkPathGradientMaster * masterPtr,
int flags);
MODULE_SCOPE void TkPathGradientInit(
Tcl_Interp * interp);
MODULE_SCOPE void TkPathGradientPaint(
TkPathContext ctx,
TkPathRect * bbox,
TkPathGradientMaster * gradientStylePtr,
int fillRule,
double fillOpacity);
MODULE_SCOPE void TkPathGradientInit(
Tcl_Interp * interp);
MODULE_SCOPE void TkPathGradientPaint(
TkPathContext ctx,
TkPathRect * bbox,
TkPathGradientMaster * gradientStylePtr,
int fillRule,
double fillOpacity);
MODULE_SCOPE int TkPathCanvasGradientObjCmd(
Tcl_Interp * interp,
TkPathCanvas * canvasPtr,
int objc,
Tcl_Obj * const objv[]);
MODULE_SCOPE void TkPathCanvasGradientsFree(
TkPathCanvas * canvasPtr);
/* tkPathInit.c */
MODULE_SCOPE int TkPathSurfaceInit(
Tcl_Interp * interp);
/* tkPathStyle.c */
MODULE_SCOPE TkPathDash *TkPathDashNew(
Tcl_Interp * interp,
Tcl_Obj * dashObjPtr);
MODULE_SCOPE void TkPathDashFree(
TkPathDash * dashPtr);
MODULE_SCOPE Tcl_Obj *Tk_PathDashOptionGetProc(
ClientData clientData,
Tk_Window tkwin,
char *recordPtr,
int internalOffset);
MODULE_SCOPE void Tk_PathDashOptionRestoreProc(
ClientData clientData,
Tk_Window tkwin,
char *internalPtr,
char *oldInternalPtr);
MODULE_SCOPE void Tk_PathDashOptionFreeProc(
ClientData clientData,
Tk_Window tkwin,
char *internalPtr);
MODULE_SCOPE int TkPathConfigStyle(
Tcl_Interp * interp,
Tk_PathStyle * stylePtr,
int objc,
Tcl_Obj * const objv[]);
MODULE_SCOPE int TkPathStyleMergeStyleStatic(
Tcl_Interp * interp,
Tcl_Obj * styleObj,
Tk_PathStyle * dstStyle,
long flags);
MODULE_SCOPE void TkPathStyleMergeStyles(
Tk_PathStyle * srcStyle,
Tk_PathStyle * dstStyle,
long flags);
MODULE_SCOPE void TkPathInitStyle(
Tk_PathStyle * style);
MODULE_SCOPE void TkPathDeleteStyle(
Tk_PathStyle * style);
MODULE_SCOPE TkPathStyleInst *TkPathGetStyle(
Tcl_Interp * interp,
const char *name,
Tcl_HashTable * tablePtr,
TkPathStyleChangedProc * changeProc,
ClientData clientData);
MODULE_SCOPE void TkPathFreeStyle(
TkPathStyleInst * stylePtr);
MODULE_SCOPE void TkPathStyleChanged(
Tk_PathStyle * masterPtr,
int flags);
MODULE_SCOPE void TkPathStyleInit(
Tcl_Interp * interp);
MODULE_SCOPE int Tk_PathDashOptionSetProc(
ClientData clientData,
Tcl_Interp * interp,
Tk_Window tkwin,
Tcl_Obj ** value,
char *recordPtr,
int internalOffset,
char *oldInternalPtr,
int flags);
MODULE_SCOPE void TkPathStylesFree(
Tk_Window tkwin,
Tcl_HashTable * hashTablePtr);
MODULE_SCOPE int TkPathCanvasStyleObjCmd(
Tcl_Interp * interp,
TkPathCanvas * canvasPtr,
int objc,
Tcl_Obj * const objv[]);
MODULE_SCOPE int TkPathMatrixSetOption(
ClientData clientData,
Tcl_Interp * interp,
Tk_Window tkwin,
Tcl_Obj ** value,
char *recordPtr,
int internalOffset,
char *oldInternalPtr,
int flags);
MODULE_SCOPE Tcl_Obj *TkPathMatrixGetOption(
ClientData clientData,
Tk_Window tkwin,
char *recordPtr,
int internalOffset);
MODULE_SCOPE void TkPathMatrixRestoreOption(
ClientData clientData,
Tk_Window tkwin,
char *internalPtr,
char *oldInternalPtr);
MODULE_SCOPE void TkPathMatrixFreeOption(
ClientData clientData,
Tk_Window tkwin,
char *internalPtr);
MODULE_SCOPE int TkPathColorSetOption(
ClientData clientData,
Tcl_Interp * interp,
Tk_Window tkwin,
Tcl_Obj ** value,
char *recordPtr,
int internalOffset,
char *oldInternalPtr,
int flags);
MODULE_SCOPE Tcl_Obj *TkPathColorGetOption(
ClientData clientData,
Tk_Window tkwin,
char *recordPtr,
int internalOffset);
MODULE_SCOPE void TkPathColorRestoreOption(
ClientData clientData,
Tk_Window tkwin,
char *internalPtr,
char *oldInternalPtr);
MODULE_SCOPE void TkPathColorFreeOption(
ClientData clientData,
Tk_Window tkwin,
char *internalPtr);
/* tkPathSurface.c */
/* tkPathUtil.c */
MODULE_SCOPE Tk_TSOffset *TkPathOffsetNew(
Tcl_Interp * interp,
ClientData clientData,
Tk_Window tkwin,
Tcl_Obj * offsetObj);
MODULE_SCOPE void TkPathMakePrectAtoms(
double *pointsPtr,
double rx,
double ry,
TkPathAtom ** atomPtrPtr);
MODULE_SCOPE void TkPathDrawPath(
TkPathContext context,
TkPathAtom * atomPtr,
Tk_PathStyle * stylePtr,
TkPathMatrix * mPtr,
TkPathRect * bboxPtr);
MODULE_SCOPE void TkPathPaintPath(
TkPathContext context,
TkPathAtom * atomPtr,
Tk_PathStyle * stylePtr,
TkPathRect * bboxPtr);
MODULE_SCOPE TkPathRect TkPathGetTotalBbox(
TkPathAtom * atomPtr,
Tk_PathStyle * stylePtr);
MODULE_SCOPE TkPathColor *TkPathNewPathColor(
Tcl_Interp * interp,
Tk_Window tkwin,
Tcl_Obj * nameObj);
MODULE_SCOPE TkPathColor *TkPathGetPathColor(
Tcl_Interp * interp,
Tk_Window tkwin,
Tcl_Obj * nameObj,
Tcl_HashTable * tablePtr,
TkPathGradientChangedProc * changeProc,
ClientData clientData);
MODULE_SCOPE void TkPathFreePathColor(
TkPathColor * colorPtr);
MODULE_SCOPE void TkPathCopyBitsARGB(
unsigned char *from,
unsigned char *to,
int width,
int height,
int bytesPerRow);
MODULE_SCOPE void TkPathCopyBitsBGRA(
unsigned char *from,
unsigned char *to,
int width,
int height,
int bytesPerRow);
MODULE_SCOPE void TkPathCopyBitsPremultipliedAlphaRGBA(
unsigned char *from,
unsigned char *to,
int width,
int height,
int bytesPerRow);
MODULE_SCOPE void TkPathCopyBitsPremultipliedAlphaARGB(
unsigned char *from,
unsigned char *to,
int width,
int height,
int bytesPerRow);
MODULE_SCOPE void TkPathCopyBitsPremultipliedAlphaBGRA(
unsigned char *from,
unsigned char *to,
int width,
int height,
int bytesPerRow);
MODULE_SCOPE int TkPathTableLookup(
TkLookupTable * map,
int n,
int from);
MODULE_SCOPE void TkPathMMulTMatrix(
TkPathMatrix * m1,
TkPathMatrix * m2);
MODULE_SCOPE int TkPathGetTMatrix(
Tcl_Interp * interp,
const char *list,
TkPathMatrix * matrixPtr);
MODULE_SCOPE int TkPathGetTclObjFromTMatrix(
Tcl_Interp * interp,
TkPathMatrix * matrixPtr,
Tcl_Obj ** listObjPtrPtr);
MODULE_SCOPE int TkPathGenericCmdDispatcher(
Tcl_Interp * interp,
Tk_Window tkwin,
int objc,
Tcl_Obj * const objv[],
char *baseName,
int *baseNameUIDPtr,
Tcl_HashTable * hashTablePtr,
Tk_OptionTable optionTable,
char *(*createAndConfigProc) (Tcl_Interp * interp,
char *name,
int objc,
Tcl_Obj * const objv[]),
void (*configNotifyProc) (char *recordPtr,
int mask,
int objc,
Tcl_Obj * const objv[]),
void (*freeProc) (Tcl_Interp * interp,
char *recordPtr));
MODULE_SCOPE int TkPathObjectIsEmpty(
Tcl_Obj * objPtr);
MODULE_SCOPE void TkPathIncludePoint(
Tk_PathItem * itemPtr,
double *pointPtr);
MODULE_SCOPE void TkPathBezierScreenPoints(
Tk_PathCanvas canvas,
double control[],
int numSteps,
XPoint * xPointPtr);
MODULE_SCOPE void TkPathBezierPoints(
double control[],
int numSteps,
double *coordPtr);
MODULE_SCOPE int TkPathMakeBezierCurve(
Tk_PathCanvas canvas,
double *pointPtr,
int numPoints,
int numSteps,
XPoint xPoints[],
double dblPoints[]);
MODULE_SCOPE int TkPathMakeRawCurve(
Tk_PathCanvas canvas,
double *pointPtr,
int numPoints,
int numSteps,
XPoint xPoints[],
double dblPoints[]);
MODULE_SCOPE int TkPathOffsetOptionSetProc(
ClientData clientData,
Tcl_Interp * interp,
Tk_Window tkwin,
Tcl_Obj ** value,
char *recordPtr,
int internalOffset,
char *oldInternalPtr,
int flags);
MODULE_SCOPE Tcl_Obj *TkPathOffsetOptionGetProc(
ClientData clientData,
Tk_Window tkwin,
char *recordPtr,
int internalOffset);
MODULE_SCOPE void TkPathOffsetOptionRestoreProc(
ClientData clientData,
Tk_Window tkwin,
char *internalPtr,
char *oldInternalPtr);
MODULE_SCOPE void TkPathOffsetOptionFreeProc(
ClientData clientData,
Tk_Window tkwin,
char *internalPtr);
MODULE_SCOPE int Tk_PathPixelOptionSetProc(
ClientData clientData,
Tcl_Interp * interp,
Tk_Window tkwin,
Tcl_Obj ** value,
char *recordPtr,
int internalOffset,
char *oldInternalPtr,
int flags);
MODULE_SCOPE Tcl_Obj *Tk_PathPixelOptionGetProc(
ClientData clientData,
Tk_Window tkwin,
char *recordPtr,
int internalOffset);
MODULE_SCOPE void Tk_PathPixelOptionRestoreProc(
ClientData clientData,
Tk_Window tkwin,
char *internalPtr,
char *oldInternalPtr);
MODULE_SCOPE Tk_Window Tk_PathCanvasTkwin(
Tk_PathCanvas canvas);
MODULE_SCOPE void Tk_PathCanvasDrawableCoords(
Tk_PathCanvas canvas,
double x,
double y,
short *drawableXPtr,
short *drawableYPtr);
MODULE_SCOPE void Tk_PathCanvasWindowCoords(
Tk_PathCanvas canvas,
double x,
double y,
short *screenXPtr,
short *screenYPtr);
MODULE_SCOPE int Tk_PathCanvasGetCoord(
Tcl_Interp * interp,
Tk_PathCanvas canvas,
const char *string,
double *doublePtr);
MODULE_SCOPE int Tk_PathCanvasGetCoordFromObj(
Tcl_Interp * interp,
Tk_PathCanvas canvas,
Tcl_Obj * obj,
double *doublePtr);
MODULE_SCOPE void Tk_PathCanvasSetStippleOrigin(
Tk_PathCanvas canvas,
GC gc);
MODULE_SCOPE void Tk_PathCanvasSetOffset(
Tk_PathCanvas canvas,
GC gc,
Tk_TSOffset * offset);
MODULE_SCOPE int TkPathCanvasGetDepth(
Tk_PathItem * itemPtr);
MODULE_SCOPE Tk_PathStyle TkPathCanvasInheritStyle(
Tk_PathItem * itemPtr,
long flags);
MODULE_SCOPE void TkPathCanvasFreeInheritedStyle(
Tk_PathStyle * stylePtr);
MODULE_SCOPE TkPathMatrix TkPathCanvasInheritTMatrix(
Tk_PathItem * itemPtr);
MODULE_SCOPE Tcl_HashTable *TkPathCanvasGradientTable(
Tk_PathCanvas canvas);
MODULE_SCOPE Tcl_HashTable *TkPathCanvasStyleTable(
Tk_PathCanvas canvas);
MODULE_SCOPE Tk_PathState TkPathCanvasState(
Tk_PathCanvas canvas);
MODULE_SCOPE Tk_PathItem *TkPathCanvasCurrentItem(
Tk_PathCanvas canvas);
MODULE_SCOPE Tk_PathCanvasTextInfo *Tk_PathCanvasGetTextInfo(
Tk_PathCanvas canvas);
MODULE_SCOPE Tk_PathTags *TkPathAllocTagsFromObj(
Tcl_Interp * interp,
Tcl_Obj * valuePtr);
MODULE_SCOPE int Tk_PathCanvasTagsOptionSetProc(
ClientData clientData,
Tcl_Interp * interp,
Tk_Window tkwin,
Tcl_Obj ** value,
char *recordPtr,
int internalOffset,
char *oldInternalPtr,
int flags);
MODULE_SCOPE Tcl_Obj *Tk_PathCanvasTagsOptionGetProc(
ClientData clientData,
Tk_Window tkwin,
char *recordPtr,
int internalOffset);
MODULE_SCOPE void Tk_PathCanvasTagsOptionRestoreProc(
ClientData clientData,
Tk_Window tkwin,
char *internalPtr,
char *oldInternalPtr);
MODULE_SCOPE void Tk_PathCanvasTagsOptionFreeProc(
ClientData clientData,
Tk_Window tkwin,
char *internalPtr);
MODULE_SCOPE int Tk_DashOptionSetProc(
ClientData clientData,
Tcl_Interp * interp,
Tk_Window tkwin,
Tcl_Obj ** value,
char *recordPtr,
int internalOffset,
char *oldInternalPtr,
int flags);
MODULE_SCOPE Tcl_Obj *Tk_DashOptionGetProc(
ClientData clientData,
Tk_Window tkwin,
char *recordPtr,
int internalOffset);
MODULE_SCOPE void Tk_DashOptionRestoreProc(
ClientData clientData,
Tk_Window tkwin,
char *internalPtr,
char *oldInternalPtr);
MODULE_SCOPE void Tk_DashOptionFreeProc(
ClientData clientData,
Tk_Window tkwin,
char *internalPtr);
MODULE_SCOPE void Tk_PathCreateSmoothMethod(
Tcl_Interp * interp,
Tk_PathSmoothMethod * method);
MODULE_SCOPE int TkPathSmoothOptionSetProc(
ClientData clientData,
Tcl_Interp * interp,
Tk_Window tkwin,
Tcl_Obj ** value,
char *recordPtr,
int internalOffset,
char *oldInternalPtr,
int flags);
MODULE_SCOPE Tcl_Obj *TkPathSmoothOptionGetProc(
ClientData clientData,
Tk_Window tkwin,
char *recordPtr,
int internalOffset);
MODULE_SCOPE void TkPathSmoothOptionRestoreProc(
ClientData clientData,
Tk_Window tkwin,
char *internalPtr,
char *oldInternalPtr);
MODULE_SCOPE void Tk_PathCreateOutline(
Tk_PathOutline * outline);
MODULE_SCOPE void Tk_PathDeleteOutline(
Display * display,
Tk_PathOutline * outline);
MODULE_SCOPE int Tk_PathConfigOutlineGC(
XGCValues * gcValues,
Tk_PathCanvas canvas,
Tk_PathItem * item,
Tk_PathOutline * outline);
MODULE_SCOPE int Tk_PathChangeOutlineGC(
Tk_PathCanvas canvas,
Tk_PathItem * item,
Tk_PathOutline * outline);
MODULE_SCOPE int Tk_PathResetOutlineGC(
Tk_PathCanvas canvas,
Tk_PathItem * item,
Tk_PathOutline * outline);
MODULE_SCOPE int TkPathCanvTranslatePath(
TkPathCanvas * canvPtr,
int numVertex,
double *coordPtr,
int closed,
XPoint * outPtr);
MODULE_SCOPE int TkPathCanvasItemExConfigure(
Tcl_Interp * interp,
Tk_PathCanvas canvas,
Tk_PathItemEx * itemExPtr,
int mask);
MODULE_SCOPE int TkPathEndpointToCentralArcParameters(
/* Endpoints. */
double x1,
double y1,
double x2,
double y2,
/* Radius. */
double rx,
double ry,
double phi,
char largeArcFlag,
char sweepFlag,
/* Output. */
double *cxPtr,
double *cyPtr,
double *rxPtr,
double *ryPtr,
double *theta1Ptr,
double *dthetaPtr);
MODULE_SCOPE void TkPathGradientChangedPrc(
ClientData clientData,
int flags);
MODULE_SCOPE void TkPathStyleChangedPrc(
ClientData clientData,
int flags);
MODULE_SCOPE void TkPathCurveSegments(
double control[],
int includeFirst,
int numSteps,
double *coordPtr);
MODULE_SCOPE double TkPathRectToPoint(
double rectPtr[],
double width,
int filled,
double pointPtr[]);
MODULE_SCOPE int TkPathRectToArea(
double rectPtr[],
double width,
int filled,
double *areaPtr);
MODULE_SCOPE int TkPathRectToAreaWithMatrix(
TkPathRect bbox,
TkPathMatrix * mPtr,
double *areaPtr);
MODULE_SCOPE double TkPathRectToPointWithMatrix(
TkPathRect bbox,
TkPathMatrix * mPtr,
double *pointPtr);
MODULE_SCOPE void TkPathCompensateScale(
Tk_PathItem * itemPtr,
int compensate,
double *originX,
double *originY,
double *scaleX,
double *scaleY);
MODULE_SCOPE void TkPathCompensateTranslate(
Tk_PathItem * itemPtr,
int compensate,
double *deltaX,
double *deltaY);
MODULE_SCOPE void TkPathScaleItemHeader(
Tk_PathItem * itemPtr,
double originX,
double originY,
double scaleX,
double scaleY);
MODULE_SCOPE void TkPathScalePathRect(
TkPathRect * r,
double originX,
double originY,
double scaleX,
double scaleY);
MODULE_SCOPE void TkPathTranslateItemHeader(
Tk_PathItem * itemPtr,
double deltaX,
double deltaY);
MODULE_SCOPE int TkPathCoordsForPointItems(
Tcl_Interp * interp,
Tk_PathCanvas canvas,
double *pointPtr,
int objc,
Tcl_Obj * const objv[]);
MODULE_SCOPE int TkPathCoordsForRectangularItems(
Tcl_Interp * interp,
Tk_PathCanvas canvas,
TkPathRect * rectPtr,
int objc,
Tcl_Obj * const objv[]);
MODULE_SCOPE TkPathRect TkPathGetGenericBarePathBbox(
TkPathAtom * atomPtr);
MODULE_SCOPE TkPathRect TkPathGetGenericPathTotalBboxFromBare(
TkPathAtom * atomPtr,
Tk_PathStyle * stylePtr,
TkPathRect * bboxPtr);
MODULE_SCOPE void TkPathSetGenericPathHeaderBbox(
Tk_PathItem * headerPtr,
TkPathMatrix * mPtr,
TkPathRect * totalBboxPtr);
MODULE_SCOPE TkPathMatrix TkPathGetCanvasTMatrix(
Tk_PathCanvas canvas);
MODULE_SCOPE TkPathRect TkPathNewEmptyPathRect(
void);
MODULE_SCOPE void TkPathIncludePointInRect(
TkPathRect * r,
double x,
double y);
MODULE_SCOPE double TkPathGenericPathToPoint(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
Tk_PathStyle * stylePtr,
TkPathAtom * atomPtr,
int maxNumSegments,
double *pointPtr);
MODULE_SCOPE int TkPathGenericPathToArea(
Tk_PathCanvas canvas,
Tk_PathItem * itemPtr,
Tk_PathStyle * stylePtr,
TkPathAtom * atomPtr,
int maxNumSegments,
double *areaPtr);
MODULE_SCOPE void TkPathTranslatePathAtoms(
TkPathAtom * atomPtr,
double deltaX,
double deltaY);
MODULE_SCOPE void TkPathScalePathAtoms(
TkPathAtom * atomPtr,
double originX,
double originY,
double scaleX,
double scaleY);
MODULE_SCOPE void TkPathTranslatePathRect(
TkPathRect * r,
double deltaX,
double deltaY);
/* tkMacOSXPath.c tkSDLAGGPath.cpp tkUnixCairoPath.c tkWinGDIPlusPath.cpp */
MODULE_SCOPE int TkPathSetup(
Tcl_Interp * interp);
MODULE_SCOPE TkPathContext TkPathInit(
Tk_Window tkwin,
Drawable d);
MODULE_SCOPE TkPathContext TkPathInitSurface(
Display * display,
int width,
int height);
MODULE_SCOPE void TkPathBeginPath(
TkPathContext ctx,
Tk_PathStyle * stylePtr);
MODULE_SCOPE void TkPathEndPath(
TkPathContext ctx);
MODULE_SCOPE void TkPathMoveTo(
TkPathContext ctx,
double x,
double y);
MODULE_SCOPE void TkPathLineTo(
TkPathContext ctx,
double x,
double y);
MODULE_SCOPE void TkPathArcTo(
TkPathContext ctx,
double rx,
double ry,
double angle,
char largeArcFlag,
char sweepFlag,
double x,
double y);
MODULE_SCOPE void TkPathQuadBezier(
TkPathContext ctx,
double ctrlX,
double ctrlY,
double x,
double y);
MODULE_SCOPE void TkPathCurveTo(
TkPathContext ctx,
double ctrlX1,
double ctrlY1,
double ctrlX2,
double ctrlY2,
double x,
double y);
MODULE_SCOPE void TkPathRectangle(
TkPathContext ctx,
double x,
double y,
double width,
double height);
MODULE_SCOPE void TkPathOval(
TkPathContext ctx,
double cx,
double cy,
double rx,
double ry);
MODULE_SCOPE void TkPathClosePath(
TkPathContext ctx);
MODULE_SCOPE void TkPathImage(
TkPathContext ctx,
Tk_Image image,
Tk_PhotoHandle photo,
double x,
double y,
double width,
double height,
double fillOpacity,
XColor * tintColor,
double tintAmount,
int interpolation,
TkPathRect * srcRegion);
MODULE_SCOPE int TkPathTextConfig(
Tcl_Interp * interp,
Tk_PathTextStyle * textStylePtr,
char *utf8,
void **customPtr);
MODULE_SCOPE void TkPathTextDraw(
TkPathContext ctx,
Tk_PathStyle * style,
Tk_PathTextStyle * textStylePtr,
double x,
double y,
int fillOverStroke,
char *utf8,
void *custom);
MODULE_SCOPE void TkPathTextFree(
Tk_PathTextStyle * textStylePtr,
void *custom);
MODULE_SCOPE TkPathRect TkPathTextMeasureBbox(
Display * display,
Tk_PathTextStyle * textStylePtr,
char *utf8,
double *lineSpacing,
void *custom);
MODULE_SCOPE void TkPathSurfaceErase(
TkPathContext ctx,
double x,
double y,
double width,
double height);
MODULE_SCOPE void TkPathSurfaceToPhoto(
Tcl_Interp * interp,
TkPathContext ctx,
Tk_PhotoHandle photo);
MODULE_SCOPE void TkPathClipToPath(
TkPathContext ctx,
int fillRule);
MODULE_SCOPE void TkPathReleaseClipToPath(
TkPathContext ctx);
MODULE_SCOPE void TkPathStroke(
TkPathContext ctx,
Tk_PathStyle * style);
MODULE_SCOPE void TkPathFill(
TkPathContext ctx,
Tk_PathStyle * style);
MODULE_SCOPE void TkPathFillAndStroke(
TkPathContext ctx,
Tk_PathStyle * style);
MODULE_SCOPE int TkPathGetCurrentPosition(
TkPathContext ctx,
TkPathPoint * ptPtr);
MODULE_SCOPE int TkPathBoundingBox(
TkPathContext ctx,
TkPathRect * rPtr);
MODULE_SCOPE void TkPathPaintLinearGradient(
TkPathContext ctx,
TkPathRect * bbox,
TkLinearGradientFill * fillPtr,
int fillRule,
double fillOpacity,
TkPathMatrix * matrixPtr);
MODULE_SCOPE void TkPathPaintRadialGradient(
TkPathContext ctx,
TkPathRect * bbox,
TkRadialGradientFill * fillPtr,
int fillRule,
double fillOpacity,
TkPathMatrix * mPtr);
MODULE_SCOPE void TkPathFree(
TkPathContext ctx);
MODULE_SCOPE int TkPathDrawingDestroysPath(
void);
MODULE_SCOPE int TkPathPixelAlign(
void);
MODULE_SCOPE void TkPathPushTMatrix(
TkPathContext ctx,
TkPathMatrix * mPtr);
MODULE_SCOPE void TkPathResetTMatrix(
TkPathContext ctx);
MODULE_SCOPE void TkPathSaveState(
TkPathContext ctx);
MODULE_SCOPE void TkPathRestoreState(
TkPathContext ctx);
/*
* end block for C++
*/
#ifdef __cplusplus
}
#endif
#endif /* _TKOPATH_H */
/* vim: set ts=4 sw=4 sts=4 ff=unix et : */
Home
Timeline
Branches
Tags
Tickets
Download
Wiki