/*
 * tkInt.h --
 *
 *  Declarations for things used internally by the Tk functions but not
 *  exported outside the module.
 *
 * Copyright (c) 1990-1994 The Regents of the University of California.
 * 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.
 */

#ifndef _TKINT
#define _TKINT

#ifndef _TKPORT
#include "tkPort.h"
#endif

/*
 * Ensure WORDS_BIGENDIAN is defined correctly:
 * Needs to happen here in addition to configure to work with fat compiles on
 * Darwin (where configure runs only once for multiple architectures).
 */

#include <stdio.h>
#ifdef HAVE_SYS_TYPES_H
#    include <sys/types.h>
#endif
#ifdef HAVE_SYS_PARAM_H
#    include <sys/param.h>
#endif
#ifdef BYTE_ORDER
#    ifdef BIG_ENDIAN
#   if BYTE_ORDER == BIG_ENDIAN
#       undef WORDS_BIGENDIAN
#       define WORDS_BIGENDIAN 1
#   endif
#    endif
#    ifdef LITTLE_ENDIAN
#   if BYTE_ORDER == LITTLE_ENDIAN
#       undef WORDS_BIGENDIAN
#   endif
#    endif
#endif

/*
 * Used to tag functions that are only to be visible within the module being
 * built and not outside it (where this is supported by the linker).
 */

#ifndef MODULE_SCOPE
#   ifdef __cplusplus
#  define MODULE_SCOPE extern "C"
#   else
#  define MODULE_SCOPE extern
#   endif
#endif

/*
 * Macros used to cast between pointers and integers (e.g. when storing an int
 * in ClientData), on 64-bit architectures they avoid gcc warning about "cast
 * to/from pointer from/to integer of different size".
 */

#if !defined(INT2PTR) && !defined(PTR2INT)
#   if defined(HAVE_INTPTR_T) || defined(intptr_t)
#  define INT2PTR(p) ((void*)(intptr_t)(p))
#  define PTR2INT(p) ((int)(intptr_t)(p))
#   else
#  define INT2PTR(p) ((void*)(p))
#  define PTR2INT(p) ((int)(p))
#   endif
#endif
#if !defined(UINT2PTR) && !defined(PTR2UINT)
#   if defined(HAVE_UINTPTR_T) || defined(uintptr_t)
#  define UINT2PTR(p) ((void*)(uintptr_t)(p))
#  define PTR2UINT(p) ((unsigned int)(uintptr_t)(p))
#   else
#  define UINT2PTR(p) ((void*)(p))
#  define PTR2UINT(p) ((unsigned int)(p))
#   endif
#endif

/*
 * Opaque type declarations:
 */

typedef struct TkColormap TkColormap;
typedef struct TkFontAttributes TkFontAttributes;
typedef struct TkGrabEvent TkGrabEvent;
typedef struct TkpCursor_ *TkpCursor;
typedef struct TkRegion_ *TkRegion;
typedef struct TkStressedCmap TkStressedCmap;
typedef struct TkBindInfo_ *TkBindInfo;
typedef struct Busy *TkBusy;

/*
 * One of the following structures is maintained for each cursor in use in the
 * system. This structure is used by tkCursor.c and the various system-
 * specific cursor files.
 */

typedef struct TkCursor {
    Tk_Cursor cursor;    /* System specific identifier for cursor. */
    Display *display;    /* Display containing cursor. Needed for
         * disposal and retrieval of cursors. */
    int resourceRefCount;  /* Number of active uses of this cursor (each
         * active use corresponds to a call to
         * Tk_AllocPreserveFromObj or Tk_Preserve). If
         * this count is 0, then this structure is no
         * longer valid and it isn't present in a hash
         * table: it is being kept around only because
         * there are objects referring to it. The
         * structure is freed when resourceRefCount
         * and objRefCount are both 0. */
    int objRefCount;    /* Number of Tcl objects that reference this
         * structure.. */
    Tcl_HashTable *otherTable;  /* Second table (other than idTable) used to
         * index this entry. */
    Tcl_HashEntry *hashPtr;  /* Entry in otherTable for this structure
         * (needed when deleting). */
    Tcl_HashEntry *idHashPtr;  /* Entry in idTable for this structure (needed
         * when deleting). */
    struct TkCursor *nextPtr;  /* Points to the next TkCursor structure with
         * the same name. Cursors with the same name
         * but different displays are chained together
         * off a single hash table entry. */
} TkCursor;

/*
 * The following structure is kept one-per-TkDisplay to maintain information
 * about the caret (cursor location) on this display. This is used to dictate
 * global focus location (Windows Accessibility guidelines) and to position
 * the IME or XIM over-the-spot window.
 */

typedef struct TkCaret {
    struct TkWindow *winPtr;  /* The window on which we requested caret
         * placement. */
    int x;      /* Relative x coord of the caret. */
    int y;      /* Relative y coord of the caret. */
    int height;      /* Specified height of the window. */
} TkCaret;

/*
 * One of the following structures is maintained for each display containing a
 * window managed by Tk. In part, the structure is used to store thread-
 * specific data, since each thread will have its own TkDisplay structure.
 */

typedef struct TkDisplay {
    Display *display;    /* Xlib's info about display. */
    struct TkDisplay *nextPtr;  /* Next in list of all displays. */
    char *name;      /* Name of display (with any screen identifier
         * removed). Malloc-ed. */
    Time lastEventTime;    /* Time of last event received for this
         * display. */

    /*
     * Information used primarily by tk3d.c:
     */

    int borderInit;    /* 0 means borderTable needs initializing. */
    Tcl_HashTable borderTable;  /* Maps from color name to TkBorder
         * structure. */

    /*
     * Information used by tkAtom.c only:
     */

    int atomInit;    /* 0 means stuff below hasn't been initialized
         * yet. */
    Tcl_HashTable nameTable;  /* Maps from names to Atom's. */
    Tcl_HashTable atomTable;  /* Maps from Atom's back to names. */

    /*
     * Information used primarily by tkBind.c:
     */

    int bindInfoStale;    /* Non-zero means the variables in this part
         * of the structure are potentially incorrect
         * and should be recomputed. */
    unsigned int modeModMask;  /* Has one bit set to indicate the modifier
         * corresponding to "mode shift". If no such
         * modifier, than this is zero. */
    unsigned int metaModMask;  /* Has one bit set to indicate the modifier
         * corresponding to the "Meta" key. If no such
         * modifier, then this is zero. */
    unsigned int altModMask;  /* Has one bit set to indicate the modifier
         * corresponding to the "Meta" key. If no such
         * modifier, then this is zero. */
    enum {LU_IGNORE, LU_CAPS, LU_SHIFT} lockUsage;
        /* Indicates how to interpret lock
         * modifier. */
    int numModKeyCodes;    /* Number of entries in modKeyCodes array
         * below. */
    KeyCode *modKeyCodes;  /* Pointer to an array giving keycodes for all
         * of the keys that have modifiers associated
         * with them. Malloc'ed, but may be NULL. */

    /*
     * Information used by tkBitmap.c only:
     */

    int bitmapInit;    /* 0 means tables above need initializing. */
    int bitmapAutoNumber;  /* Used to number bitmaps. */
    Tcl_HashTable bitmapNameTable;
        /* Maps from name of bitmap to the first
         * TkBitmap record for that name. */
    Tcl_HashTable bitmapIdTable;/* Maps from bitmap id to the TkBitmap
         * structure for the bitmap. */
    Tcl_HashTable bitmapDataTable;
        /* Used by Tk_GetBitmapFromData to map from a
         * collection of in-core data about a bitmap
         * to a reference giving an automatically-
         * generated name for the bitmap. */

    /*
     * Information used by tkCanvas.c only:
     */

    int numIdSearches;
    int numSlowSearches;

    /*
     * Used by tkColor.c only:
     */

    int colorInit;    /* 0 means color module needs initializing. */
    TkStressedCmap *stressPtr;  /* First in list of colormaps that have filled
         * up, so we have to pick an approximate
         * color. */
    Tcl_HashTable colorNameTable;
        /* Maps from color name to TkColor structure
         * for that color. */
    Tcl_HashTable colorValueTable;
        /* Maps from integer RGB values to TkColor
         * structures. */

    /*
     * Used by tkCursor.c only:
     */

    int cursorInit;    /* 0 means cursor module need initializing. */
    Tcl_HashTable cursorNameTable;
        /* Maps from a string name to a cursor to the
         * TkCursor record for the cursor. */
    Tcl_HashTable cursorDataTable;
        /* Maps from a collection of in-core data
         * about a cursor to a TkCursor structure. */
    Tcl_HashTable cursorIdTable;
        /* Maps from a cursor id to the TkCursor
         * structure for the cursor. */
    char cursorString[20];  /* Used to store a cursor id string. */
    Font cursorFont;    /* Font to use for standard cursors. None
         * means font not loaded yet. */

    /*
     * Information used by tkError.c only:
     */

    struct TkErrorHandler *errorPtr;
        /* First in list of error handlers for this
         * display. NULL means no handlers exist at
         * present. */
    int deleteCount;    /* Counts # of handlers deleted since last
         * time inactive handlers were garbage-
         * collected. When this number gets big,
         * handlers get cleaned up. */

    /*
     * Used by tkEvent.c only:
     */

    struct TkWindowEvent *delayedMotionPtr;
        /* Points to a malloc-ed motion event whose
         * processing has been delayed in the hopes
         * that another motion event will come along
         * right away and we can merge the two of them
         * together. NULL means that there is no
         * delayed motion event. */

    /*
     * Information used by tkFocus.c only:
     */

    int focusDebug;    /* 1 means collect focus debugging
         * statistics. */
    struct TkWindow *implicitWinPtr;
        /* If the focus arrived at a toplevel window
         * implicitly via an Enter event (rather than
         * via a FocusIn event), this points to the
         * toplevel window. Otherwise it is NULL. */
    struct TkWindow *focusPtr;  /* Points to the window on this display that
         * should be receiving keyboard events. When
         * multiple applications on the display have
         * the focus, this will refer to the innermost
         * window in the innermost application. This
         * information isn't used on Windows, but it's
         * needed on the Mac, and also on X11 when XIM
         * processing is being done. */

    /*
     * Information used by tkGC.c only:
     */

    Tcl_HashTable gcValueTable; /* Maps from a GC's values to a TkGC structure
         * describing a GC with those values. */
    Tcl_HashTable gcIdTable;    /* Maps from a GC to a TkGC. */
    int gcInit;      /* 0 means the tables below need
         * initializing. */

    /*
     * Information used by tkGeometry.c only:
     */

    Tcl_HashTable maintainHashTable;
        /* Hash table that maps from a master's
         * Tk_Window token to a list of slaves managed
         * by that master. */
    int geomInit;

    /*
     * Information used by tkGet.c only:
     */

    Tcl_HashTable uidTable;  /* Stores all Tk_Uid used in a thread. */
    int uidInit;    /* 0 means uidTable needs initializing. */

    /*
     * Information used by tkGrab.c only:
     */

    struct TkWindow *grabWinPtr;/* Window in which the pointer is currently
         * grabbed, or NULL if none. */
    struct TkWindow *eventualGrabWinPtr;
        /* Value that grabWinPtr will have once the
         * grab event queue (below) has been
         * completely emptied. */
    struct TkWindow *buttonWinPtr;
        /* Window in which first mouse button was
         * pressed while grab was in effect, or NULL
         * if no such press in effect. */
    struct TkWindow *serverWinPtr;
        /* If no application contains the pointer then
         * this is NULL. Otherwise it contains the
         * last window for which we've gotten an Enter
         * or Leave event from the server (i.e. the
         * last window known to have contained the
         * pointer). Doesn't reflect events that were
         * synthesized in tkGrab.c. */
    TkGrabEvent *firstGrabEventPtr;
        /* First in list of enter/leave events
         * synthesized by grab code. These events must
         * be processed in order before any other
         * events are processed. NULL means no such
         * events. */
    TkGrabEvent *lastGrabEventPtr;
        /* Last in list of synthesized events, or NULL
         * if list is empty. */
    int grabFlags;    /* Miscellaneous flag values. See definitions
         * in tkGrab.c. */

    /*
     * Information used by tkGrid.c only:
     */

    int gridInit;    /* 0 means table below needs initializing. */
    Tcl_HashTable gridHashTable;/* Maps from Tk_Window tokens to corresponding
         * Grid structures. */

    /*
     * Information used by tkImage.c only:
     */

    int imageId;    /* Value used to number image ids. */

    /*
     * Information used by tkMacWinMenu.c only:
     */

    int postCommandGeneration;

    /*
     * Information used by tkPack.c only.
     */

    int packInit;    /* 0 means table below needs initializing. */
    Tcl_HashTable packerHashTable;
        /* Maps from Tk_Window tokens to corresponding
         * Packer structures. */

    /*
     * Information used by tkPlace.c only.
     */

    int placeInit;    /* 0 means tables below need initializing. */
    Tcl_HashTable masterTable;  /* Maps from Tk_Window toke to the Master
         * structure for the window, if it exists. */
    Tcl_HashTable slaveTable;  /* Maps from Tk_Window toke to the Slave
         * structure for the window, if it exists. */

    /*
     * Information used by tkSelect.c and tkClipboard.c only:
     */

    struct TkSelectionInfo *selectionInfoPtr;
        /* First in list of selection information
         * records. Each entry contains information
         * about the current owner of a particular
         * selection on this display. */
    Atom multipleAtom;    /* Atom for MULTIPLE. None means selection
         * stuff isn't initialized. */
    Atom incrAtom;    /* Atom for INCR. */
    Atom targetsAtom;    /* Atom for TARGETS. */
    Atom timestampAtom;    /* Atom for TIMESTAMP. */
    Atom textAtom;    /* Atom for TEXT. */
    Atom compoundTextAtom;  /* Atom for COMPOUND_TEXT. */
    Atom applicationAtom;  /* Atom for TK_APPLICATION. */
    Atom windowAtom;    /* Atom for TK_WINDOW. */
    Atom clipboardAtom;    /* Atom for CLIPBOARD. */
    Atom utf8Atom;    /* Atom for UTF8_STRING. */

    Tk_Window clipWindow;  /* Window used for clipboard ownership and to
         * retrieve selections between processes. NULL
         * means clipboard info hasn't been
         * initialized. */
    int clipboardActive;  /* 1 means we currently own the clipboard
         * selection, 0 means we don't. */
    struct TkMainInfo *clipboardAppPtr;
        /* Last application that owned clipboard. */
    struct TkClipboardTarget *clipTargetPtr;
        /* First in list of clipboard type information
         * records. Each entry contains information
         * about the buffers for a given selection
         * target. */

    /*
     * Information used by tkSend.c only:
     */

    Tk_Window commTkwin;  /* Window used for communication between
         * interpreters during "send" commands. NULL
         * means send info hasn't been initialized
         * yet. */
    Atom commProperty;    /* X's name for comm property. */
    Atom registryProperty;  /* X's name for property containing registry
         * of interpreter names. */
    Atom appNameProperty;  /* X's name for property used to hold the
         * application name on each comm window. */

    /*
     * Information used by tkUnixWm.c and tkWinWm.c only:
     */

    struct TkWmInfo *firstWmPtr;/* Points to first top-level window. */
    struct TkWmInfo *foregroundWmPtr;
        /* Points to the foreground window. */

    /*
     * Information used by tkVisual.c only:
     */

    TkColormap *cmapPtr;  /* First in list of all non-default colormaps
         * allocated for this display. */

    /*
     * Miscellaneous information:
     */

#ifdef TK_USE_INPUT_METHODS
    XIM inputMethod;    /* Input method for this display. */
    XIMStyle inputStyle;  /* Input style selected for this display. */
    XFontSet inputXfs;    /* XFontSet cached for over-the-spot XIM. */
#endif /* TK_USE_INPUT_METHODS */
    Tcl_HashTable winTable;  /* Maps from X window ids to TkWindow ptrs. */

    int refCount;    /* Reference count of how many Tk applications
         * are using this display. Used to clean up
         * the display when we no longer have any Tk
         * applications using it. */

    /*
     * The following field were all added for Tk8.3
     */

    int mouseButtonState;  /* Current mouse button state for this
         * display. */
    Window mouseButtonWindow;  /* Window the button state was set in, added
         * in Tk 8.4. */
    Tk_Window warpWindow;
    Tk_Window warpMainwin;  /* For finding the root window for warping
         * purposes. */
    int warpX;
    int warpY;

    /*
     * The following field(s) were all added for Tk8.4
     */

    unsigned int flags;    /* Various flag values: these are all defined
         * in below. */
    TkCaret caret;    /* Information about the caret for this
         * display. This is not a pointer. */

    int iconDataSize;    /* Size of default iconphoto image data. */
    unsigned char *iconDataPtr;  /* Default iconphoto image data, if set. */
} TkDisplay;

/*
 * Flag values for TkDisplay flags.
 *  TK_DISPLAY_COLLAPSE_MOTION_EVENTS:  (default on)
 *  Indicates that we should collapse motion events on this display
 *  TK_DISPLAY_USE_IM:      (default on, set via tk.tcl)
 *  Whether to use input methods for this display
 *  TK_DISPLAY_WM_TRACING:    (default off)
 *  Whether we should do wm tracing on this display.
 *  TK_DISPLAY_IN_WARP:      (default off)
 *  Indicates that we are in a pointer warp
 */

#define TK_DISPLAY_COLLAPSE_MOTION_EVENTS  (1 << 0)
#define TK_DISPLAY_USE_IM      (1 << 1)
#define TK_DISPLAY_WM_TRACING      (1 << 3)
#define TK_DISPLAY_IN_WARP      (1 << 4)

/*
 * One of the following structures exists for each error handler created by a
 * call to Tk_CreateErrorHandler. The structure is managed by tkError.c.
 */

typedef struct TkErrorHandler {
    TkDisplay *dispPtr;    /* Display to which handler applies. */
    unsigned long firstRequest;  /* Only errors with serial numbers >= to this
         * are considered. */
    unsigned long lastRequest;  /* Only errors with serial numbers <= to this
         * are considered. This field is filled in
         * when XUnhandle is called. -1 means
         * XUnhandle hasn't been called yet. */
    int error;      /* Consider only errors with this error_code
         * (-1 means consider all errors). */
    int request;    /* Consider only errors with this major
         * request code (-1 means consider all major
         * codes). */
    int minorCode;    /* Consider only errors with this minor
         * request code (-1 means consider all minor
         * codes). */
    Tk_ErrorProc *errorProc;  /* Function to invoke when a matching error
         * occurs. NULL means just ignore errors. */
    ClientData clientData;  /* Arbitrary value to pass to errorProc. */
    struct TkErrorHandler *nextPtr;
        /* Pointer to next older handler for this
         * display, or NULL for end of list. */
} TkErrorHandler;

/*
 * One of the following structures exists for each event handler created by
 * calling Tk_CreateEventHandler. This information is used by tkEvent.c only.
 */

typedef struct TkEventHandler {
    unsigned long mask;    /* Events for which to invoke proc. */
    Tk_EventProc *proc;    /* Function to invoke when an event in mask
         * occurs. */
    ClientData clientData;  /* Argument to pass to proc. */
    struct TkEventHandler *nextPtr;
        /* Next in list of handlers associated with
         * window (NULL means end of list). */
} TkEventHandler;

/*
 * Tk keeps one of the following data structures for each main window (created
 * by a call to TkCreateMainWindow). It stores information that is shared by
 * all of the windows associated with a particular main window.
 */

typedef struct TkMainInfo {
    int refCount;    /* Number of windows whose "mainPtr" fields
         * point here. When this becomes zero, can
         * free up the structure (the reference count
         * is zero because windows can get deleted in
         * almost any order; the main window isn't
         * necessarily the last one deleted). */
    struct TkWindow *winPtr;  /* Pointer to main window. */
    Tcl_Interp *interp;    /* Interpreter associated with application. */
    Tcl_HashTable nameTable;  /* Hash table mapping path names to TkWindow
         * structs for all windows related to this
         * main window. Managed by tkWindow.c. */
    long deletionEpoch;    /* Incremented by window deletions. */
    Tk_BindingTable bindingTable;
        /* Used in conjunction with "bind" command to
         * bind events to Tcl commands. */
    TkBindInfo bindInfo;  /* Information used by tkBind.c on a per
         * application basis. */
    struct TkFontInfo *fontInfoPtr;
        /* Information used by tkFont.c on a per
         * application basis. */

    /*
     * Information used only by tkFocus.c and tk*Embed.c:
     */

    struct TkToplevelFocusInfo *tlFocusPtr;
        /* First in list of records containing focus
         * information for each top-level in the
         * application. Used only by tkFocus.c. */
    struct TkDisplayFocusInfo *displayFocusPtr;
        /* First in list of records containing focus
         * information for each display that this
         * application has ever used. Used only by
         * tkFocus.c. */

    struct ElArray *optionRootPtr;
        /* Top level of option hierarchy for this main
         * window. NULL means uninitialized. Managed
         * by tkOption.c. */
    Tcl_HashTable imageTable;  /* Maps from image names to Tk_ImageMaster
         * structures. Managed by tkImage.c. */
    int strictMotif;    /* This is linked to the tk_strictMotif global
         * variable. */
    int alwaysShowSelection;  /* This is linked to the
         * ::tk::AlwaysShowSelection variable. */
    struct TkMainInfo *nextPtr;  /* Next in list of all main windows managed by
         * this process. */
    Tcl_HashTable busyTable;  /* Information used by [tk busy] command. */
} TkMainInfo;

/*
 * Tk keeps the following data structure for each of it's builtin bitmaps.
 * This structure is only used by tkBitmap.c and other platform specific
 * bitmap files.
 */

typedef struct {
    const void *source;    /* Bits for bitmap. */
    int width, height;    /* Dimensions of bitmap. */
    int native;      /* 0 means generic (X style) bitmap, 1 means
             * native style bitmap. */
} TkPredefBitmap;

/*
 * Tk keeps one of the following structures for each window. Some of the
 * information (like size and location) is a shadow of information managed by
 * the X server, and some is special information used here, such as event and
 * geometry management information. This information is (mostly) managed by
 * tkWindow.c. WARNING: the declaration below must be kept consistent with the
 * Tk_FakeWin structure in tk.h. If you change one, be sure to change the
 * other!
 */

typedef struct TkWindow {
    /*
     * Structural information:
     */

    Display *display;    /* Display containing window. */
    TkDisplay *dispPtr;    /* Tk's information about display for
         * window. */
    int screenNum;    /* Index of screen for window, among all those
         * for dispPtr. */
    Visual *visual;    /* Visual to use for window. If not default,
         * MUST be set before X window is created. */
    int depth;      /* Number of bits/pixel. */
    Window window;    /* X's id for window. NULL means window hasn't
         * actually been created yet, or it's been
         * deleted. */
    struct TkWindow *childList;  /* First in list of child windows, or NULL if
         * no children. List is in stacking order,
         * lowest window first.*/
    struct TkWindow *lastChildPtr;
        /* Last in list of child windows (highest in
         * stacking order), or NULL if no children. */
    struct TkWindow *parentPtr;  /* Pointer to parent window (logical parent,
         * not necessarily X parent). NULL means
         * either this is the main window, or the
         * window's parent has already been deleted. */
    struct TkWindow *nextPtr;  /* Next higher sibling (in stacking order) in
         * list of children with same parent. NULL
         * means end of list. */
    TkMainInfo *mainPtr;  /* Information shared by all windows
         * associated with a particular main window.
         * NULL means this window is a rogue that is
         * not associated with any application (at
         * present, this only happens for the dummy
         * windows used for "send" communication). */

    /*
     * Name and type information for the window:
     */

    char *pathName;    /* Path name of window (concatenation of all
         * names between this window and its top-level
         * ancestor). This is a pointer into an entry
         * in mainPtr->nameTable. NULL means that the
         * window hasn't been completely created
         * yet. */
    Tk_Uid nameUid;    /* Name of the window within its parent
         * (unique within the parent). */
    Tk_Uid classUid;    /* Class of the window. NULL means window
         * hasn't been given a class yet. */

    /*
     * Geometry and other attributes of window. This information may not be
     * updated on the server immediately; stuff that hasn't been reflected in
     * the server yet is called "dirty". At present, information can be dirty
     * only if the window hasn't yet been created.
     */

    XWindowChanges changes;  /* Geometry and other info about window. */
    unsigned int dirtyChanges;  /* Bits indicate fields of "changes" that are
         * dirty. */
    XSetWindowAttributes atts;  /* Current attributes of window. */
    unsigned long dirtyAtts;  /* Bits indicate fields of "atts" that are
         * dirty. */

    unsigned int flags;    /* Various flag values: these are all defined
         * in tk.h (confusing, but they're needed
         * there for some query macros). */

    /*
     * Information kept by the event manager (tkEvent.c):
     */

    TkEventHandler *handlerList;/* First in list of event handlers declared
         * for this window, or NULL if none. */
#ifdef TK_USE_INPUT_METHODS
    XIC inputContext;    /* XIM input context. */
#endif /* TK_USE_INPUT_METHODS */

    /*
     * Information used for event bindings (see "bind" and "bindtags" commands
     * in tkCmds.c):
     */

    ClientData *tagPtr;    /* Points to array of tags used for bindings
         * on this window. Each tag is a Tk_Uid.
         * Malloc'ed. NULL means no tags. */
    int numTags;    /* Number of tags at *tagPtr. */

    /*
     * Information used by tkOption.c to manage options for the window.
     */

    int optionLevel;    /* -1 means no option information is currently
         * cached for this window. Otherwise this
         * gives the level in the option stack at
         * which info is cached. */
    /*
     * Information used by tkSelect.c to manage the selection.
     */

    struct TkSelHandler *selHandlerList;
        /* First in list of handlers for returning the
         * selection in various forms. */

    /*
     * Information used by tkGeometry.c for geometry management.
     */

    const Tk_GeomMgr *geomMgrPtr;
        /* Information about geometry manager for this
         * window. */
    ClientData geomData;  /* Argument for geometry manager functions. */
    int reqWidth, reqHeight;  /* Arguments from last call to
         * Tk_GeometryRequest, or 0's if
         * Tk_GeometryRequest hasn't been called. */
    int internalBorderLeft;  /* Width of internal border of window (0 means
         * no internal border). Geometry managers
         * should not normally place children on top
         * of the border. Fields for the other three
         * sides are found below. */

    /*
     * Information maintained by tkWm.c for window manager communication.
     */

    struct TkWmInfo *wmInfoPtr;  /* For top-level windows (and also for special
         * Unix menubar and wrapper windows), points
         * to structure with wm-related info (see
         * tkWm.c). For other windows, this is
         * NULL. */

    /*
     * Information used by widget classes.
     */

    const Tk_ClassProcs *classProcsPtr;
    ClientData instanceData;

    /*
     * Platform specific information private to each port.
     */

    struct TkWindowPrivate *privatePtr;

    /*
     * More information used by tkGeometry.c for geometry management.
     */

    /* The remaining fields of internal border. */
    int internalBorderRight;
    int internalBorderTop;
    int internalBorderBottom;

    int minReqWidth;    /* Minimum requested width. */
    int minReqHeight;    /* Minimum requested height. */
    char *geometryMaster;
} TkWindow;

/*
 * Real definition of some events. Note that these events come from outside
 * but have internally generated pieces added to them.
 */

typedef struct {
    XKeyEvent keyEvent;    /* The real event from X11. */
    char *charValuePtr;    /* A pointer to a string that holds the key's
         * %A substitution text (before backslash
         * adding), or NULL if that has not been
         * computed yet. If non-NULL, this string was
         * allocated with ckalloc(). */
    int charValueLen;    /* Length of string in charValuePtr when that
         * is non-NULL. */
    KeySym keysym;    /* Key symbol computed after input methods
         * have been invoked */
} TkKeyEvent;

/*
 * Flags passed to TkpMakeMenuWindow's 'transient' argument.
 */

#define TK_MAKE_MENU_TEAROFF  0  /* Only non-transient case. */
#define TK_MAKE_MENU_POPUP  1
#define TK_MAKE_MENU_DROPDOWN  2

/*
 * The following structure is used with TkMakeEnsemble to create ensemble
 * commands and optionally to create sub-ensembles.
 */

typedef struct TkEnsemble {
    const char *name;
    Tcl_ObjCmdProc *proc;
    const struct TkEnsemble *subensemble;
} TkEnsemble;

/*
 * The following structure is used as a two way map between integers and
 * strings, usually to map between an internal C representation and the
 * strings used in Tcl.
 */

typedef struct TkStateMap {
    int numKey;      /* Integer representation of a value. */
    const char *strKey;    /* String representation of a value. */
} TkStateMap;

/*
 * This structure is used by the Mac and Window porting layers as the internal
 * representation of a clip_mask in a GC.
 */

typedef struct TkpClipMask {
    int type;      /* TKP_CLIP_PIXMAP or TKP_CLIP_REGION. */
    union {
  Pixmap pixmap;
  TkRegion region;
    } value;
} TkpClipMask;

#define TKP_CLIP_PIXMAP 0
#define TKP_CLIP_REGION 1

/*
 * Return values from TkGrabState:
 */

#define TK_GRAB_NONE    0
#define TK_GRAB_IN_TREE    1
#define TK_GRAB_ANCESTOR  2
#define TK_GRAB_EXCLUDED  3

/*
 * Additional flag for TkpMeasureCharsInContext. Coordinate with other flags
 * for this routine, but don't make public until TkpMeasureCharsInContext is
 * made public, too.
 */

#define TK_ISOLATE_END    32

/*
 * The macro below is used to modify a "char" value (e.g. by casting it to an
 * unsigned character) so that it can be used safely with macros such as
 * isspace().
 */

#define UCHAR(c) ((unsigned char) (c))

/*
 * The following symbol is used in the mode field of FocusIn events generated
 * by an embedded application to request the input focus from its container.
 */

#define EMBEDDED_APP_WANTS_FOCUS (NotifyNormal + 20)

/*
 * The following special modifier mask bits are defined, to indicate logical
 * modifiers such as Meta and Alt that may float among the actual modifier
 * bits.
 */

#define META_MASK  (AnyModifier<<1)
#define ALT_MASK  (AnyModifier<<2)
#define EXTENDED_MASK  (AnyModifier<<3)

/*
 * Object types not declared in tkObj.c need to be mentioned here so they can
 * be properly registered with Tcl:
 */

MODULE_SCOPE const Tcl_ObjType tkBorderObjType;
MODULE_SCOPE const Tcl_ObjType tkBitmapObjType;
MODULE_SCOPE const Tcl_ObjType tkColorObjType;
MODULE_SCOPE const Tcl_ObjType tkCursorObjType;
MODULE_SCOPE const Tcl_ObjType tkFontObjType;
MODULE_SCOPE const Tcl_ObjType tkStateKeyObjType;
MODULE_SCOPE const Tcl_ObjType tkTextIndexType;

/*
 * Miscellaneous variables shared among Tk modules but not exported to the
 * outside world:
 */

MODULE_SCOPE const Tk_SmoothMethod tkBezierSmoothMethod;
MODULE_SCOPE Tk_ImageType  tkBitmapImageType;
MODULE_SCOPE Tk_PhotoImageFormat tkImgFmtGIF;
MODULE_SCOPE void    (*tkHandleEventProc) (XEvent* eventPtr);
MODULE_SCOPE Tk_PhotoImageFormat tkImgFmtPNG;
MODULE_SCOPE Tk_PhotoImageFormat tkImgFmtPPM;
MODULE_SCOPE TkMainInfo    *tkMainWindowList;
MODULE_SCOPE Tk_ImageType  tkPhotoImageType;
MODULE_SCOPE Tcl_HashTable  tkPredefBitmapTable;

MODULE_SCOPE const char *const tkWebColors[20];

/*
 * The definition of pi, at least from the perspective of double-precision
 * floats.
 */

#ifndef PI
#ifdef M_PI
#define PI  M_PI
#else
#define PI  3.14159265358979323846
#endif
#endif

/*
 * Support for Clang Static Analyzer <http://clang-analyzer.llvm.org>
 */

#if defined(PURIFY) && defined(__clang__)
#if __has_feature(attribute_analyzer_noreturn) && \
  !defined(Tcl_Panic) && defined(Tcl_Panic_TCL_DECLARED)
void Tcl_Panic(const char *, ...) __attribute__((analyzer_noreturn));
#endif
#if !defined(CLANG_ASSERT)
#include <assert.h>
#define CLANG_ASSERT(x) assert(x)
#endif
#elif !defined(CLANG_ASSERT)
#define CLANG_ASSERT(x)
#endif /* PURIFY && __clang__ */

/*
 * The following magic value is stored in the "send_event" field of FocusIn
 * and FocusOut events. This allows us to separate "real" events coming from
 * the server from those that we generated.
 */

#define GENERATED_FOCUS_EVENT_MAGIC  ((Bool) 0x547321ac)

/*
 * Exported internals.
 */

#include "tkIntDecls.h"

/*
 * Themed widget set init function:
 */

MODULE_SCOPE int  Ttk_Init(Tcl_Interp *interp);

/*
 * Internal functions shared among Tk modules but not exported to the outside
 * world:
 */

MODULE_SCOPE int  Tk_BellObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_BindObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_BindtagsObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_BusyObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_ButtonObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_CanvasObjCmd(ClientData clientData,
          Tcl_Interp *interp, int argc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_CheckbuttonObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_ClipboardObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_ChooseColorObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_ChooseDirectoryObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_DestroyObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_EntryObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_EventObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_FrameObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_FocusObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_FontObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_GetOpenFileObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_GetSaveFileObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_GrabObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_GridObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_ImageObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_LabelObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_LabelframeObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_ListboxObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_LowerObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_MenubuttonObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_MessageBoxObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_MessageObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_PanedWindowObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_OptionObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_PackObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_PlaceObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_RadiobuttonObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_RaiseObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_ScaleObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_ScrollbarCmd(ClientData clientData,
          Tcl_Interp *interp, int argc, const char **argv);
MODULE_SCOPE int  Tk_SelectionObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_SendCmd(ClientData clientData,
          Tcl_Interp *interp, int argc, const char **argv);
MODULE_SCOPE int  Tk_SendObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_SpinboxObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_TextObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_TkwaitObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_ToplevelObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_UpdateObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_WinfoObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);
MODULE_SCOPE int  Tk_WmObjCmd(ClientData clientData, Tcl_Interp *interp,
          int objc, Tcl_Obj *const objv[]);

MODULE_SCOPE int  Tk_GetDoublePixelsFromObj(Tcl_Interp *interp,
          Tk_Window tkwin, Tcl_Obj *objPtr,
          double *doublePtr);
MODULE_SCOPE int  TkSetGeometryMaster(Tcl_Interp *interp,
          Tk_Window tkwin, const char *master);
MODULE_SCOPE void  TkFreeGeometryMaster(Tk_Window tkwin,
          const char *master);

MODULE_SCOPE void  TkEventInit(void);
MODULE_SCOPE void  TkRegisterObjTypes(void);
MODULE_SCOPE int  TkCreateMenuCmd(Tcl_Interp *interp);
MODULE_SCOPE int  TkDeadAppCmd(ClientData clientData,
          Tcl_Interp *interp, int argc, const char **argv);
MODULE_SCOPE int  TkCanvasGetCoordObj(Tcl_Interp *interp,
          Tk_Canvas canvas, Tcl_Obj *obj,
          double *doublePtr);
MODULE_SCOPE int  TkGetDoublePixels(Tcl_Interp *interp, Tk_Window tkwin,
          const char *string, double *doublePtr);
MODULE_SCOPE int  TkPostscriptImage(Tcl_Interp *interp, Tk_Window tkwin,
          Tk_PostscriptInfo psInfo, XImage *ximage,
          int x, int y, int width, int height);
MODULE_SCOPE void       TkMapTopFrame(Tk_Window tkwin);
MODULE_SCOPE XEvent *  TkpGetBindingXEvent(Tcl_Interp *interp);
MODULE_SCOPE void  TkCreateExitHandler(Tcl_ExitProc *proc,
          ClientData clientData);
MODULE_SCOPE void  TkDeleteExitHandler(Tcl_ExitProc *proc,
          ClientData clientData);
MODULE_SCOPE Tcl_ExitProc  TkFinalize;
MODULE_SCOPE Tcl_ExitProc  TkFinalizeThread;
MODULE_SCOPE void  TkpBuildRegionFromAlphaData(TkRegion region,
          unsigned x, unsigned y, unsigned width,
          unsigned height, unsigned char *dataPtr,
          unsigned pixelStride, unsigned lineStride);
MODULE_SCOPE void  TkAppendPadAmount(Tcl_Obj *bufferObj,
          const char *buffer, int pad1, int pad2);
MODULE_SCOPE int  TkParsePadAmount(Tcl_Interp *interp,
          Tk_Window tkwin, Tcl_Obj *objPtr,
          int *pad1Ptr, int *pad2Ptr);
MODULE_SCOPE void       TkFocusSplit(TkWindow *winPtr);
MODULE_SCOPE void       TkFocusJoin(TkWindow *winPtr);
MODULE_SCOPE int  TkpAlwaysShowSelection(Tk_Window tkwin);
MODULE_SCOPE void  TkpDrawCharsInContext(Display * display,
          Drawable drawable, GC gc, Tk_Font tkfont,
          const char *source, int numBytes, int rangeStart,
          int rangeLength, int x, int y);
MODULE_SCOPE int  TkpMeasureCharsInContext(Tk_Font tkfont,
          const char *source, int numBytes, int rangeStart,
          int rangeLength, int maxLength, int flags,
          int *lengthPtr);
MODULE_SCOPE void  TkUnderlineCharsInContext(Display *display,
          Drawable drawable, GC gc, Tk_Font tkfont,
          const char *string, int numBytes, int x, int y,
          int firstByte, int lastByte);
MODULE_SCOPE void  TkpGetFontAttrsForChar(Tk_Window tkwin, Tk_Font tkfont,
          Tcl_UniChar c, struct TkFontAttributes *faPtr);
MODULE_SCOPE Tcl_Obj *  TkNewWindowObj(Tk_Window tkwin);
MODULE_SCOPE void  TkpShowBusyWindow(TkBusy busy);
MODULE_SCOPE void  TkpHideBusyWindow(TkBusy busy);
MODULE_SCOPE void  TkpMakeTransparentWindowExist(Tk_Window tkwin,
          Window parent);
MODULE_SCOPE void  TkpCreateBusy(Tk_FakeWin *winPtr, Tk_Window tkRef,
          Window *parentPtr, Tk_Window tkParent,
          TkBusy busy);
MODULE_SCOPE int  TkBackgroundEvalObjv(Tcl_Interp *interp,
          int objc, Tcl_Obj *const *objv, int flags);
MODULE_SCOPE void  TkSendVirtualEvent(Tk_Window tgtWin,
          const char *eventName);
MODULE_SCOPE Tcl_Command TkMakeEnsemble(Tcl_Interp *interp,
          const char *nsname, const char *name,
          ClientData clientData, const TkEnsemble *map);
MODULE_SCOPE int  TkInitTkCmd(Tcl_Interp *interp,
          ClientData clientData);
MODULE_SCOPE int  TkInitFontchooser(Tcl_Interp *interp,
          ClientData clientData);
MODULE_SCOPE void  TkpWarpPointer(TkDisplay *dispPtr);

#ifdef __WIN32__
#define TkParseColor XParseColor
#else
MODULE_SCOPE Status TkParseColor (Display * display,
        Colormap map, const char* spec,
        XColor * colorPtr);
#endif
#ifdef HAVE_XFT
MODULE_SCOPE void  TkUnixSetXftClipRegion(TkRegion clipRegion);
#endif

/*
 * Unsupported commands.
 */

MODULE_SCOPE int  TkUnsupported1ObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj *const objv[]);

/*
 * For Tktest.
 */
MODULE_SCOPE int SquareObjCmd(ClientData clientData,
          Tcl_Interp *interp, int objc,
          Tcl_Obj * const objv[]);
MODULE_SCOPE int  TkOldTestInit(Tcl_Interp *interp);
#if !(defined(__WIN32__) || defined(MAC_OSX_TK))
#define TkplatformtestInit(x) TCL_OK
#else
MODULE_SCOPE int  TkplatformtestInit(Tcl_Interp *interp);
#endif

#endif /* _TKINT */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */
