Subversion Repositories or1k

/*

 * tk.h --

 *

 *      Declarations for Tk-related things that are visible

 *      outside of the Tk module itself.

 *

 * Copyright (c) 1989-1994 The Regents of the University of California.

 * Copyright (c) 1994 The Australian National University.

 * Copyright (c) 1994-1997 Sun Microsystems, Inc.

 * Copyright (c) 1998 by Scriptics Corporation.

 *

 * See the file "license.terms" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 * RCS: @(#) $Id: tk.h,v 1.1.1.1 2002-01-16 10:25:50 markom Exp $

 */

#ifndef _TK

#define _TK

/*

 * When version numbers change here, you must also go into the following files

 * and update the version numbers:

 *

 * README

 * unix/configure.in

 * win/makefile.bc      (Not for patch release updates)

 * win/makefile.vc      (Not for patch release updates)

 * win/README

 * library/tk.tcl

 *

 * The release level should be  0 for alpha, 1 for beta, and 2 for

 * final/patch.  The release serial value is the number that follows the

 * "a", "b", or "p" in the patch level; for example, if the patch level

 * is 4.3b2, TK_RELEASE_SERIAL is 2.  It restarts at 1 whenever the

 * release level is changed, except for the final release, which should

 * be 0.

 *

 * You may also need to update some of these files when the numbers change

 * for the version of Tcl that this release of Tk is compiled against.

 */

#define TK_MAJOR_VERSION   8

#define TK_MINOR_VERSION   0

#define TK_RELEASE_LEVEL   2

#define TK_RELEASE_SERIAL  4

#define TK_VERSION "8.0"

#define TK_PATCH_LEVEL "8.0.4"

/*

 * A special definition used to allow this header file to be included

 * in resource files.

 */

#ifndef RESOURCE_INCLUDED

/*

 * The following definitions set up the proper options for Macintosh

 * compilers.  We use this method because there is no autoconf equivalent.

 */

#ifdef MAC_TCL

#   ifndef REDO_KEYSYM_LOOKUP

#       define REDO_KEYSYM_LOOKUP

#   endif

#endif

#ifndef _TCL

#   include <tcl.h>

#endif

#ifndef _XLIB_H

#   ifdef MAC_TCL

#       include <Xlib.h>

#       include <X.h>

#   else

#       include <X11/Xlib.h>

#   endif

#endif

#ifdef __STDC__

#   include <stddef.h>

#endif

#ifdef BUILD_tk

# undef TCL_STORAGE_CLASS

# define TCL_STORAGE_CLASS DLLEXPORT

#endif

/*

 * Decide whether or not to use input methods.

 */

#ifdef XNQueryInputStyle

#define TK_USE_INPUT_METHODS

#endif

/*

 * Dummy types that are used by clients:

 */

typedef struct Tk_BindingTable_ *Tk_BindingTable;

typedef struct Tk_Canvas_ *Tk_Canvas;

typedef struct Tk_Cursor_ *Tk_Cursor;

typedef struct Tk_ErrorHandler_ *Tk_ErrorHandler;

typedef struct Tk_Font_ *Tk_Font;

typedef struct Tk_Image__ *Tk_Image;

typedef struct Tk_ImageMaster_ *Tk_ImageMaster;

typedef struct Tk_TextLayout_ *Tk_TextLayout;

typedef struct Tk_Window_ *Tk_Window;

typedef struct Tk_3DBorder_ *Tk_3DBorder;

/*

 * Additional types exported to clients.

 */

typedef char *Tk_Uid;

/*

 * Structure used to specify how to handle argv options.

 */

typedef struct {

    char *key;          /* The key string that flags the option in the

                         * argv array. */

    int type;           /* Indicates option type;  see below. */

    char *src;          /* Value to be used in setting dst;  usage

                         * depends on type. */

    char *dst;          /* Address of value to be modified;  usage

                         * depends on type. */

    char *help;         /* Documentation message describing this option. */

} Tk_ArgvInfo;

/*

 * Legal values for the type field of a Tk_ArgvInfo: see the user

 * documentation for details.

 */

#define TK_ARGV_CONSTANT                15

#define TK_ARGV_INT                     16

#define TK_ARGV_STRING                  17

#define TK_ARGV_UID                     18

#define TK_ARGV_REST                    19

#define TK_ARGV_FLOAT                   20

#define TK_ARGV_FUNC                    21

#define TK_ARGV_GENFUNC                 22

#define TK_ARGV_HELP                    23

#define TK_ARGV_CONST_OPTION            24

#define TK_ARGV_OPTION_VALUE            25

#define TK_ARGV_OPTION_NAME_VALUE       26

/* CYGNUS LOCAL: Support -version argument.  */

#define TK_ARGV_VERSION                 27

#define TK_ARGV_END                     28

/*

 * Flag bits for passing to Tk_ParseArgv:

 */

#define TK_ARGV_NO_DEFAULTS             0x1

#define TK_ARGV_NO_LEFTOVERS            0x2

#define TK_ARGV_NO_ABBREV               0x4

#define TK_ARGV_DONT_SKIP_FIRST_ARG     0x8

/*

 * Structure used to describe application-specific configuration

 * options:  indicates procedures to call to parse an option and

 * to return a text string describing an option.

 */

typedef int (Tk_OptionParseProc) _ANSI_ARGS_((ClientData clientData,

        Tcl_Interp *interp, Tk_Window tkwin, char *value, char *widgRec,

        int offset));

typedef char *(Tk_OptionPrintProc) _ANSI_ARGS_((ClientData clientData,

        Tk_Window tkwin, char *widgRec, int offset,

        Tcl_FreeProc **freeProcPtr));

typedef struct Tk_CustomOption {

    Tk_OptionParseProc *parseProc;      /* Procedure to call to parse an

                                         * option and store it in converted

                                         * form. */

    Tk_OptionPrintProc *printProc;      /* Procedure to return a printable

                                         * string describing an existing

                                         * option. */

    ClientData clientData;              /* Arbitrary one-word value used by

                                         * option parser:  passed to

                                         * parseProc and printProc. */

} Tk_CustomOption;

/*

 * Structure used to specify information for Tk_ConfigureWidget.  Each

 * structure gives complete information for one option, including

 * how the option is specified on the command line, where it appears

 * in the option database, etc.

 */

typedef struct Tk_ConfigSpec {

    int type;                   /* Type of option, such as TK_CONFIG_COLOR;

                                 * see definitions below.  Last option in

                                 * table must have type TK_CONFIG_END. */

    char *argvName;             /* Switch used to specify option in argv.

                                 * NULL means this spec is part of a group. */

    char *dbName;               /* Name for option in option database. */

    char *dbClass;              /* Class for option in database. */

    char *defValue;             /* Default value for option if not

                                 * specified in command line or database. */

    int offset;                 /* Where in widget record to store value;

                                 * use Tk_Offset macro to generate values

                                 * for this. */

    int specFlags;              /* Any combination of the values defined

                                 * below;  other bits are used internally

                                 * by tkConfig.c. */

    Tk_CustomOption *customPtr; /* If type is TK_CONFIG_CUSTOM then this is

                                 * a pointer to info about how to parse and

                                 * print the option.  Otherwise it is

                                 * irrelevant. */

} Tk_ConfigSpec;

/*

 * Type values for Tk_ConfigSpec structures.  See the user

 * documentation for details.

 */

#define TK_CONFIG_BOOLEAN       1

#define TK_CONFIG_INT           2

#define TK_CONFIG_DOUBLE        3

#define TK_CONFIG_STRING        4

#define TK_CONFIG_UID           5

#define TK_CONFIG_COLOR         6

#define TK_CONFIG_FONT          7

#define TK_CONFIG_BITMAP        8

#define TK_CONFIG_BORDER        9

#define TK_CONFIG_RELIEF        10

#define TK_CONFIG_CURSOR        11

#define TK_CONFIG_ACTIVE_CURSOR 12

#define TK_CONFIG_JUSTIFY       13

#define TK_CONFIG_ANCHOR        14

#define TK_CONFIG_SYNONYM       15

#define TK_CONFIG_CAP_STYLE     16

#define TK_CONFIG_JOIN_STYLE    17

#define TK_CONFIG_PIXELS        18

#define TK_CONFIG_MM            19

#define TK_CONFIG_WINDOW        20

#define TK_CONFIG_CUSTOM        21

#define TK_CONFIG_END           22

/*

 * Macro to use to fill in "offset" fields of Tk_ConfigInfos.

 * Computes number of bytes from beginning of structure to a

 * given field.

 */

#ifdef offsetof

#define Tk_Offset(type, field) ((int) offsetof(type, field))

#else

#define Tk_Offset(type, field) ((int) ((char *) &((type *) 0)->field))

#endif

/*

 * Possible values for flags argument to Tk_ConfigureWidget:

 */

#define TK_CONFIG_ARGV_ONLY     1

/*

 * Possible flag values for Tk_ConfigInfo structures.  Any bits at

 * or above TK_CONFIG_USER_BIT may be used by clients for selecting

 * certain entries.  Before changing any values here, coordinate with

 * tkConfig.c (internal-use-only flags are defined there).

 */

#define TK_CONFIG_COLOR_ONLY            1

#define TK_CONFIG_MONO_ONLY             2

#define TK_CONFIG_NULL_OK               4

#define TK_CONFIG_DONT_SET_DEFAULT      8

#define TK_CONFIG_OPTION_SPECIFIED      0x10

#define TK_CONFIG_USER_BIT              0x100

/*

 * Enumerated type for describing actions to be taken in response

 * to a restrictProc established by Tk_RestrictEvents.

 */

typedef enum {

    TK_DEFER_EVENT, TK_PROCESS_EVENT, TK_DISCARD_EVENT

} Tk_RestrictAction;

/*

 * Priority levels to pass to Tk_AddOption:

 */

#define TK_WIDGET_DEFAULT_PRIO  20

#define TK_STARTUP_FILE_PRIO    40

#define TK_USER_DEFAULT_PRIO    60

#define TK_INTERACTIVE_PRIO     80

#define TK_MAX_PRIO             100

/*

 * Relief values returned by Tk_GetRelief:

 */

#define TK_RELIEF_RAISED        1

#define TK_RELIEF_FLAT          2

#define TK_RELIEF_SUNKEN        4

#define TK_RELIEF_GROOVE        8

#define TK_RELIEF_RIDGE         16

#define TK_RELIEF_SOLID         32

/*

 * "Which" argument values for Tk_3DBorderGC:

 */

#define TK_3D_FLAT_GC           1

#define TK_3D_LIGHT_GC          2

#define TK_3D_DARK_GC           3

/*

 * Special EnterNotify/LeaveNotify "mode" for use in events

 * generated by tkShare.c.  Pick a high enough value that it's

 * unlikely to conflict with existing values (like NotifyNormal)

 * or any new values defined in the future.

 */

#define TK_NOTIFY_SHARE         20

/*

 * Enumerated type for describing a point by which to anchor something:

 */

typedef enum {

    TK_ANCHOR_N, TK_ANCHOR_NE, TK_ANCHOR_E, TK_ANCHOR_SE,

    TK_ANCHOR_S, TK_ANCHOR_SW, TK_ANCHOR_W, TK_ANCHOR_NW,

    TK_ANCHOR_CENTER

} Tk_Anchor;

/*

 * Enumerated type for describing a style of justification:

 */

typedef enum {

    TK_JUSTIFY_LEFT, TK_JUSTIFY_RIGHT, TK_JUSTIFY_CENTER

} Tk_Justify;

/*

 * The following structure is used by Tk_GetFontMetrics() to return

 * information about the properties of a Tk_Font.

 */

typedef struct Tk_FontMetrics {

    int ascent;                 /* The amount in pixels that the tallest

                                 * letter sticks up above the baseline, plus

                                 * any extra blank space added by the designer

                                 * of the font. */

    int descent;                /* The largest amount in pixels that any

                                 * letter sticks below the baseline, plus any

                                 * extra blank space added by the designer of

                                 * the font. */

    int linespace;              /* The sum of the ascent and descent.  How

                                 * far apart two lines of text in the same

                                 * font should be placed so that none of the

                                 * characters in one line overlap any of the

                                 * characters in the other line. */

} Tk_FontMetrics;

/*

 * Flags passed to Tk_MeasureChars:

 */

#define TK_WHOLE_WORDS          1

#define TK_AT_LEAST_ONE         2

#define TK_PARTIAL_OK           4

/*

 * Flags passed to Tk_ComputeTextLayout:

 */

#define TK_IGNORE_TABS          8

#define TK_IGNORE_NEWLINES      16

/*

 * Each geometry manager (the packer, the placer, etc.) is represented

 * by a structure of the following form, which indicates procedures

 * to invoke in the geometry manager to carry out certain functions.

 */

typedef void (Tk_GeomRequestProc) _ANSI_ARGS_((ClientData clientData,

        Tk_Window tkwin));

typedef void (Tk_GeomLostSlaveProc) _ANSI_ARGS_((ClientData clientData,

        Tk_Window tkwin));

typedef struct Tk_GeomMgr {

    char *name;                 /* Name of the geometry manager (command

                                 * used to invoke it, or name of widget

                                 * class that allows embedded widgets). */

    Tk_GeomRequestProc *requestProc;

                                /* Procedure to invoke when a slave's

                                 * requested geometry changes. */

    Tk_GeomLostSlaveProc *lostSlaveProc;

                                /* Procedure to invoke when a slave is

                                 * taken away from one geometry manager

                                 * by another.  NULL means geometry manager

                                 * doesn't care when slaves are lost. */

} Tk_GeomMgr;

/*

 * Result values returned by Tk_GetScrollInfo:

 */

#define TK_SCROLL_MOVETO        1

#define TK_SCROLL_PAGES         2

#define TK_SCROLL_UNITS         3

#define TK_SCROLL_ERROR         4

/*

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

 *

 * Extensions to the X event set

 *

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

 */

#define VirtualEvent        (LASTEvent)

#define ActivateNotify      (LASTEvent + 1)

#define DeactivateNotify    (LASTEvent + 2)

#define MouseWheelEvent     (LASTEvent + 3)

#define TK_LASTEVENT        (LASTEvent + 4)

#define MouseWheelMask      (1L << 28)

#define ActivateMask        (1L << 29)

#define VirtualEventMask    (1L << 30)

#define TK_LASTEVENT        (LASTEvent + 4)

/*

 * A virtual event shares most of its fields with the XKeyEvent and

 * XButtonEvent structures.  99% of the time a virtual event will be

 * an abstraction of a key or button event, so this structure provides

 * the most information to the user.  The only difference is the changing

 * of the detail field for a virtual event so that it holds the name of the

 * virtual event being triggered.

 */

typedef struct {

    int type;

    unsigned long serial;   /* # of last request processed by server */

    Bool send_event;        /* True if this came from a SendEvent request */

    Display *display;       /* Display the event was read from */

    Window event;           /* Window on which event was requested. */

    Window root;            /* root window that the event occured on */

    Window subwindow;       /* child window */

    Time time;              /* milliseconds */

    int x, y;               /* pointer x, y coordinates in event window */

    int x_root, y_root;     /* coordinates relative to root */

    unsigned int state;     /* key or button mask */

    Tk_Uid name;            /* Name of virtual event. */

    Bool same_screen;       /* same screen flag */

} XVirtualEvent;

typedef struct {

    int type;

    unsigned long serial;   /* # of last request processed by server */

    Bool send_event;        /* True if this came from a SendEvent request */

    Display *display;       /* Display the event was read from */

    Window window;          /* Window in which event occurred. */

} XActivateDeactivateEvent;

typedef XActivateDeactivateEvent XActivateEvent;

typedef XActivateDeactivateEvent XDeactivateEvent;

/*

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

 *

 * Macros for querying Tk_Window structures.  See the

 * manual entries for documentation.

 *

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

 */

#define Tk_Display(tkwin)               (((Tk_FakeWin *) (tkwin))->display)

#define Tk_ScreenNumber(tkwin)          (((Tk_FakeWin *) (tkwin))->screenNum)

#define Tk_Screen(tkwin)                (ScreenOfDisplay(Tk_Display(tkwin), \

        Tk_ScreenNumber(tkwin)))

#define Tk_Depth(tkwin)                 (((Tk_FakeWin *) (tkwin))->depth)

#define Tk_Visual(tkwin)                (((Tk_FakeWin *) (tkwin))->visual)

#define Tk_WindowId(tkwin)              (((Tk_FakeWin *) (tkwin))->window)

#define Tk_PathName(tkwin)              (((Tk_FakeWin *) (tkwin))->pathName)

#define Tk_Name(tkwin)                  (((Tk_FakeWin *) (tkwin))->nameUid)

#define Tk_Class(tkwin)                 (((Tk_FakeWin *) (tkwin))->classUid)

#define Tk_X(tkwin)                     (((Tk_FakeWin *) (tkwin))->changes.x)

#define Tk_Y(tkwin)                     (((Tk_FakeWin *) (tkwin))->changes.y)

#define Tk_Width(tkwin)                 (((Tk_FakeWin *) (tkwin))->changes.width)

#define Tk_Height(tkwin) \

    (((Tk_FakeWin *) (tkwin))->changes.height)

#define Tk_Changes(tkwin)               (&((Tk_FakeWin *) (tkwin))->changes)

#define Tk_Attributes(tkwin)            (&((Tk_FakeWin *) (tkwin))->atts)

#define Tk_IsEmbedded(tkwin) \

    (((Tk_FakeWin *) (tkwin))->flags & TK_EMBEDDED)

#define Tk_IsContainer(tkwin) \

    (((Tk_FakeWin *) (tkwin))->flags & TK_CONTAINER)

#define Tk_IsMapped(tkwin) \

    (((Tk_FakeWin *) (tkwin))->flags & TK_MAPPED)

#define Tk_IsTopLevel(tkwin) \

    (((Tk_FakeWin *) (tkwin))->flags & TK_TOP_LEVEL)

#define Tk_ReqWidth(tkwin)              (((Tk_FakeWin *) (tkwin))->reqWidth)

#define Tk_ReqHeight(tkwin)             (((Tk_FakeWin *) (tkwin))->reqHeight)

#define Tk_InternalBorderWidth(tkwin) \

    (((Tk_FakeWin *) (tkwin))->internalBorderWidth)

#define Tk_Parent(tkwin)                (((Tk_FakeWin *) (tkwin))->parentPtr)

#define Tk_Colormap(tkwin)              (((Tk_FakeWin *) (tkwin))->atts.colormap)

/*

 * The structure below is needed by the macros above so that they can

 * access the fields of a Tk_Window.  The fields not needed by the macros

 * are declared as "dummyX".  The structure has its own type in order to

 * prevent applications from accessing Tk_Window fields except using

 * official macros.  WARNING!! The structure definition must be kept

 * consistent with the TkWindow structure in tkInt.h.  If you change one,

 * then change the other.  See the declaration in tkInt.h for

 * documentation on what the fields are used for internally.

 */

typedef struct Tk_FakeWin {

    Display *display;

    char *dummy1;

    int screenNum;

    Visual *visual;

    int depth;

    Window window;

    char *dummy2;

    char *dummy3;

    Tk_Window parentPtr;

    char *dummy4;

    char *dummy5;

    char *pathName;

    Tk_Uid nameUid;

    Tk_Uid classUid;

    XWindowChanges changes;

    unsigned int dummy6;

    XSetWindowAttributes atts;

    unsigned long dummy7;

    unsigned int flags;

    char *dummy8;

#ifdef TK_USE_INPUT_METHODS

    XIC dummy9;

#endif /* TK_USE_INPUT_METHODS */

    ClientData *dummy10;

    int dummy11;

    int dummy12;

    char *dummy13;

    char *dummy14;

    ClientData dummy15;

    int reqWidth, reqHeight;

    int internalBorderWidth;

    char *dummy16;

    char *dummy17;

    ClientData dummy18;

    char *dummy19;

} Tk_FakeWin;

/*

 * Flag values for TkWindow (and Tk_FakeWin) structures are:

 *

 * TK_MAPPED:                   1 means window is currently mapped,

 *                              0 means unmapped.

 * TK_TOP_LEVEL:                1 means this is a top-level window (it

 *                              was or will be created as a child of

 *                              a root window).

 * TK_ALREADY_DEAD:             1 means the window is in the process of

 *                              being destroyed already.

 * TK_NEED_CONFIG_NOTIFY:       1 means that the window has been reconfigured

 *                              before it was made to exist.  At the time of

 *                              making it exist a ConfigureNotify event needs

 *                              to be generated.

 * TK_GRAB_FLAG:                Used to manage grabs.  See tkGrab.c for

 *                              details.

 * TK_CHECKED_IC:               1 means we've already tried to get an input

 *                              context for this window;  if the ic field

 *                              is NULL it means that there isn't a context

 *                              for the field.

 * TK_DONT_DESTROY_WINDOW:      1 means that Tk_DestroyWindow should not

 *                              invoke XDestroyWindow to destroy this widget's

 *                              X window.  The flag is set when the window

 *                              has already been destroyed elsewhere (e.g.

 *                              by another application) or when it will be

 *                              destroyed later (e.g. by destroying its

 *                              parent).

 * TK_WM_COLORMAP_WINDOW:       1 means that this window has at some time

 *                              appeared in the WM_COLORMAP_WINDOWS property

 *                              for its toplevel, so we have to remove it

 *                              from that property if the window is

 *                              deleted and the toplevel isn't.

 * TK_EMBEDDED:                 1 means that this window (which must be a

 *                              toplevel) is not a free-standing window but

 *                              rather is embedded in some other application.

 * TK_CONTAINER:                1 means that this window is a container, and

 *                              that some other application (either in

 *                              this process or elsewhere) may be

 *                              embedding itself inside the window.

 * TK_BOTH_HALVES:              1 means that this window is used for

 *                              application embedding (either as

 *                              container or embedded application), and

 *                              both the containing and embedded halves

 *                              are associated with windows in this

 *                              particular process.

 * TK_DEFER_MODAL:              1 means that this window has deferred a modal

 *                              loop until all of the bindings for the current

 *                              event have been invoked.

 * TK_WRAPPER:                  1 means that this window is the extra

 *                              wrapper window created around a toplevel

 *                              to hold the menubar under Unix.  See

 *                              tkUnixWm.c for more information.

 * TK_REPARENTED:               1 means that this window has been reparented

 *                              so that as far as the window system is

 *                              concerned it isn't a child of its Tk

 *                              parent.  Initially this is used only for

 *                              special Unix menubar windows.

 */

#define TK_MAPPED               1

#define TK_TOP_LEVEL            2

#define TK_ALREADY_DEAD         4

#define TK_NEED_CONFIG_NOTIFY   8

#define TK_GRAB_FLAG            0x10

#define TK_CHECKED_IC           0x20

#define TK_DONT_DESTROY_WINDOW  0x40

#define TK_WM_COLORMAP_WINDOW   0x80

#define TK_EMBEDDED             0x100

#define TK_CONTAINER            0x200

#define TK_BOTH_HALVES          0x400

#define TK_DEFER_MODAL          0x800

#define TK_WRAPPER              0x1000

#define TK_REPARENTED           0x2000

/*

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

 *

 * Procedure prototypes and structures used for defining new canvas

 * items:

 *

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

 */

/*

 * 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_TAG_SPACE 3

typedef struct Tk_Item  {

    int id;                             /* Unique identifier for this item

                                         * (also serves as first tag for

                                         * item). */

    struct Tk_Item *nextPtr;            /* Next in display list of all

                                         * items in this canvas.  Later items

                                         * in list are drawn on top of earlier

                                         * ones. */

    Tk_Uid staticTagSpace[TK_TAG_SPACE];/* Built-in space for limited # of

                                         * tags. */

    Tk_Uid *tagPtr;                     /* Pointer to array of tags.  Usually

                                         * points to staticTagSpace, but

                                         * may point to malloc-ed space if

                                         * there are lots of tags. */

    int tagSpace;                       /* Total amount of tag space available

                                         * at tagPtr. */

    int numTags;                        /* Number of tag slots actually used

                                         * at *tagPtr. */

    struct Tk_ItemType *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. */

    struct Tk_Item *prevPtr;            /* Previous in display list of all

                                         * items in this canvas. Later items

                                         * in list are drawn just below earlier

                                         * ones. */

    int   reserved1;                    /* This padding is for compatibility */

    char *reserved2;                    /* with Jan Nijtmans dash patch */

    int   reserved3;

    /*

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

     * 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_ItemType record.

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

     */

} Tk_Item;

/*

 * 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_ItemCreateProc _ANSI_ARGS_((Tcl_Interp *interp,

                    Tk_Canvas canvas, Tk_Item *itemPtr, int argc,

                    char **argv));

typedef int     Tk_ItemConfigureProc _ANSI_ARGS_((Tcl_Interp *interp,

                    Tk_Canvas canvas, Tk_Item *itemPtr, int argc,

                    char **argv, int flags));

typedef int     Tk_ItemCoordProc _ANSI_ARGS_((Tcl_Interp *interp,

                    Tk_Canvas canvas, Tk_Item *itemPtr, int argc,

                    char **argv));

typedef void    Tk_ItemDeleteProc _ANSI_ARGS_((Tk_Canvas canvas,

                    Tk_Item *itemPtr, Display *display));

typedef void    Tk_ItemDisplayProc _ANSI_ARGS_((Tk_Canvas canvas,

                    Tk_Item *itemPtr, Display *display, Drawable dst,

                    int x, int y, int width, int height));

typedef double  Tk_ItemPointProc _ANSI_ARGS_((Tk_Canvas canvas,

                    Tk_Item *itemPtr, double *pointPtr));

typedef int     Tk_ItemAreaProc _ANSI_ARGS_((Tk_Canvas canvas,

                    Tk_Item *itemPtr, double *rectPtr));

typedef int     Tk_ItemPostscriptProc _ANSI_ARGS_((Tcl_Interp *interp,

                    Tk_Canvas canvas, Tk_Item *itemPtr, int prepass));

typedef void    Tk_ItemScaleProc _ANSI_ARGS_((Tk_Canvas canvas,

                    Tk_Item *itemPtr, double originX, double originY,

                    double scaleX, double scaleY));

typedef void    Tk_ItemTranslateProc _ANSI_ARGS_((Tk_Canvas canvas,

                    Tk_Item *itemPtr, double deltaX, double deltaY));

typedef int     Tk_ItemIndexProc _ANSI_ARGS_((Tcl_Interp *interp,

                    Tk_Canvas canvas, Tk_Item *itemPtr, char *indexString,

                    int *indexPtr));

typedef void    Tk_ItemCursorProc _ANSI_ARGS_((Tk_Canvas canvas,

                    Tk_Item *itemPtr, int index));

typedef int     Tk_ItemSelectionProc _ANSI_ARGS_((Tk_Canvas canvas,

                    Tk_Item *itemPtr, int offset, char *buffer,

                    int maxBytes));

typedef void    Tk_ItemInsertProc _ANSI_ARGS_((Tk_Canvas canvas,

                    Tk_Item *itemPtr, int beforeThis, char *string));

typedef void    Tk_ItemDCharsProc _ANSI_ARGS_((Tk_Canvas canvas,

                    Tk_Item *itemPtr, int first, int last));

typedef struct Tk_ItemType {

    char *name;                         /* The name of this type of item, such

                                         * as "line". */

    int itemSize;                       /* Total amount of space needed for

                                         * item's record. */

    Tk_ItemCreateProc *createProc;      /* Procedure to create a new item of

                                         * this type. */

    Tk_ConfigSpec *configSpecs;         /* Pointer to array of configuration

                                         * specs for this type.  Used for

                                         * returning configuration info. */

    Tk_ItemConfigureProc *configProc;   /* Procedure to call to change

                                         * configuration options. */

    Tk_ItemCoordProc *coordProc;        /* Procedure to call to get and set

                                         * the item's coordinates. */

    Tk_ItemDeleteProc *deleteProc;      /* Procedure to delete existing item of

                                         * this type. */

    Tk_ItemDisplayProc *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. */

    Tk_ItemPointProc *pointProc;        /* Computes distance from item to

                                         * a given point. */

    Tk_ItemAreaProc *areaProc;          /* Computes whether item is inside,

                                         * outside, or overlapping an area. */

    Tk_ItemPostscriptProc *postscriptProc;

                                        /* Procedure to write a Postscript

                                         * description for items of this

                                         * type. */

    Tk_ItemScaleProc *scaleProc;        /* Procedure to rescale items of

                                         * this type. */

    Tk_ItemTranslateProc *translateProc;/* Procedure to translate items of

                                         * this type. */

    Tk_ItemIndexProc *indexProc;        /* Procedure to determine index of

                                         * indicated character.  NULL if

                                         * item doesn't support indexing. */

    Tk_ItemCursorProc *icursorProc;     /* Procedure to set insert cursor pos.

                                         * to just before a given position. */

    Tk_ItemSelectionProc *selectionProc;/* Procedure to return selection (in

                                         * STRING format) when it is in this

                                         * item. */

    Tk_ItemInsertProc *insertProc;      /* Procedure to insert something into

                                         * an item. */

    Tk_ItemDCharsProc *dCharsProc;      /* Procedure to delete characters

                                         * from an item. */

    struct Tk_ItemType *nextPtr;        /* Used to link types together into

                                         * a list. */

    char *reserved1;                    /* Reserved for future extension. */

    int   reserved2;                    /* Carefully compatible with */

    char *reserved3;                    /* Jan Nijtmans dash patch */

    char *reserved4;

} Tk_ItemType;

/*

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