1/* 2 * tk.h -- 3 * 4 * Declarations for Tk-related things that are visible outside of the Tk 5 * module itself. 6 * 7 * Copyright (c) 1989-1994 The Regents of the University of California. 8 * Copyright (c) 1994 The Australian National University. 9 * Copyright (c) 1994-1998 Sun Microsystems, Inc. 10 * Copyright (c) 1998-2000 Ajuba Solutions. 11 * 12 * See the file "license.terms" for information on usage and redistribution of 13 * this file, and for a DISCLAIMER OF ALL WARRANTIES. 14 * 15 * RCS: @(#) $Id$ 16 */ 17 18#ifndef _TK 19#define _TK 20 21#include <tcl.h> 22#if (TCL_MAJOR_VERSION != 8) || (TCL_MINOR_VERSION != 5) 23# error Tk 8.5 must be compiled with tcl.h from Tcl 8.5 24#endif 25 26/* 27 * For C++ compilers, use extern "C" 28 */ 29 30#ifdef __cplusplus 31extern "C" { 32#endif 33 34/* 35 * When version numbers change here, you must also go into the following files 36 * and update the version numbers: 37 * 38 * library/tk.tcl (2 LOC patch) 39 * unix/configure.in (2 LOC Major, 2 LOC minor, 1 LOC patch) 40 * win/configure.in (as above) 41 * README (sections 0 and 1) 42 * macosx/Wish.xcode/project.pbxproj (not patchlevel) 1 LOC 43 * macosx/Wish-Common.xcconfig (not patchlevel) 1 LOC 44 * win/README (not patchlevel) 45 * unix/README (not patchlevel) 46 * unix/tk.spec (1 LOC patch) 47 * win/tcl.m4 (not patchlevel) 48 * 49 * You may also need to update some of these files when the numbers change for 50 * the version of Tcl that this release of Tk is compiled against. 51 */ 52 53#define TK_MAJOR_VERSION 8 54#define TK_MINOR_VERSION 5 55#define TK_RELEASE_LEVEL TCL_FINAL_RELEASE 56#define TK_RELEASE_SERIAL 9 57 58#define TK_VERSION "8.5" 59#define TK_PATCH_LEVEL "8.5.9" 60 61/* 62 * A special definition used to allow this header file to be included from 63 * windows or mac resource files so that they can obtain version information. 64 * RC_INVOKED is defined by default by the windows RC tool and manually set 65 * for macintosh. 66 * 67 * Resource compilers don't like all the C stuff, like typedefs and procedure 68 * declarations, that occur below, so block them out. 69 */ 70 71#ifndef RC_INVOKED 72 73#ifndef _XLIB_H 74# if defined(MAC_OSX_TK) 75# include <X11/Xlib.h> 76# include <X11/X.h> 77# else 78# include <X11/Xlib.h> 79# endif 80#endif 81#ifdef __STDC__ 82# include <stddef.h> 83#endif 84 85#ifdef BUILD_tk 86# undef TCL_STORAGE_CLASS 87# define TCL_STORAGE_CLASS DLLEXPORT 88#endif 89 90/* 91 * Decide whether or not to use input methods. 92 */ 93 94#ifdef XNQueryInputStyle 95#define TK_USE_INPUT_METHODS 96#endif 97 98/* 99 * Dummy types that are used by clients: 100 */ 101 102typedef struct Tk_BindingTable_ *Tk_BindingTable; 103typedef struct Tk_Canvas_ *Tk_Canvas; 104typedef struct Tk_Cursor_ *Tk_Cursor; 105typedef struct Tk_ErrorHandler_ *Tk_ErrorHandler; 106typedef struct Tk_Font_ *Tk_Font; 107typedef struct Tk_Image__ *Tk_Image; 108typedef struct Tk_ImageMaster_ *Tk_ImageMaster; 109typedef struct Tk_OptionTable_ *Tk_OptionTable; 110typedef struct Tk_PostscriptInfo_ *Tk_PostscriptInfo; 111typedef struct Tk_TextLayout_ *Tk_TextLayout; 112typedef struct Tk_Window_ *Tk_Window; 113typedef struct Tk_3DBorder_ *Tk_3DBorder; 114typedef struct Tk_Style_ *Tk_Style; 115typedef struct Tk_StyleEngine_ *Tk_StyleEngine; 116typedef struct Tk_StyledElement_ *Tk_StyledElement; 117 118/* 119 * Additional types exported to clients. 120 */ 121 122typedef const char *Tk_Uid; 123 124/* 125 * The enum below defines the valid types for Tk configuration options as 126 * implemented by Tk_InitOptions, Tk_SetOptions, etc. 127 */ 128 129typedef enum { 130 TK_OPTION_BOOLEAN, 131 TK_OPTION_INT, 132 TK_OPTION_DOUBLE, 133 TK_OPTION_STRING, 134 TK_OPTION_STRING_TABLE, 135 TK_OPTION_COLOR, 136 TK_OPTION_FONT, 137 TK_OPTION_BITMAP, 138 TK_OPTION_BORDER, 139 TK_OPTION_RELIEF, 140 TK_OPTION_CURSOR, 141 TK_OPTION_JUSTIFY, 142 TK_OPTION_ANCHOR, 143 TK_OPTION_SYNONYM, 144 TK_OPTION_PIXELS, 145 TK_OPTION_WINDOW, 146 TK_OPTION_END, 147 TK_OPTION_CUSTOM, 148 TK_OPTION_STYLE 149} Tk_OptionType; 150 151/* 152 * Structures of the following type are used by widgets to specify their 153 * configuration options. Typically each widget has a static array of these 154 * structures, where each element of the array describes a single 155 * configuration option. The array is passed to Tk_CreateOptionTable. 156 */ 157 158typedef struct Tk_OptionSpec { 159 Tk_OptionType type; /* Type of option, such as TK_OPTION_COLOR; 160 * see definitions above. Last option in table 161 * must have type TK_OPTION_END. */ 162 const char *optionName; /* Name used to specify option in Tcl 163 * commands. */ 164 const char *dbName; /* Name for option in option database. */ 165 const char *dbClass; /* Class for option in database. */ 166 const char *defValue; /* Default value for option if not specified 167 * in command line, the option database, or 168 * the system. */ 169 int objOffset; /* Where in record to store a Tcl_Obj * that 170 * holds the value of this option, specified 171 * as an offset in bytes from the start of the 172 * record. Use the Tk_Offset macro to generate 173 * values for this. -1 means don't store the 174 * Tcl_Obj in the record. */ 175 int internalOffset; /* Where in record to store the internal 176 * representation of the value of this option, 177 * such as an int or XColor *. This field is 178 * specified as an offset in bytes from the 179 * start of the record. Use the Tk_Offset 180 * macro to generate values for it. -1 means 181 * don't store the internal representation in 182 * the record. */ 183 int flags; /* Any combination of the values defined 184 * below. */ 185 ClientData clientData; /* An alternate place to put option-specific 186 * data. Used for the monochrome default value 187 * for colors, etc. */ 188 int typeMask; /* An arbitrary bit mask defined by the class 189 * manager; typically bits correspond to 190 * certain kinds of options such as all those 191 * that require a redisplay when they change. 192 * Tk_SetOptions returns the bit-wise OR of 193 * the typeMasks of all options that were 194 * changed. */ 195} Tk_OptionSpec; 196 197/* 198 * Flag values for Tk_OptionSpec structures. These flags are shared by 199 * Tk_ConfigSpec structures, so be sure to coordinate any changes carefully. 200 */ 201 202#define TK_OPTION_NULL_OK (1 << 0) 203#define TK_OPTION_DONT_SET_DEFAULT (1 << 3) 204 205/* 206 * The following structure and function types are used by TK_OPTION_CUSTOM 207 * options; the structure holds pointers to the functions needed by the Tk 208 * option config code to handle a custom option. 209 */ 210 211typedef int (Tk_CustomOptionSetProc) _ANSI_ARGS_((ClientData clientData, 212 Tcl_Interp *interp, Tk_Window tkwin, Tcl_Obj **value, char *widgRec, 213 int offset, char *saveInternalPtr, int flags)); 214typedef Tcl_Obj *(Tk_CustomOptionGetProc) _ANSI_ARGS_((ClientData clientData, 215 Tk_Window tkwin, char *widgRec, int offset)); 216typedef void (Tk_CustomOptionRestoreProc) _ANSI_ARGS_((ClientData clientData, 217 Tk_Window tkwin, char *internalPtr, char *saveInternalPtr)); 218typedef void (Tk_CustomOptionFreeProc) _ANSI_ARGS_((ClientData clientData, 219 Tk_Window tkwin, char *internalPtr)); 220 221typedef struct Tk_ObjCustomOption { 222 const char *name; /* Name of the custom option. */ 223 Tk_CustomOptionSetProc *setProc; 224 /* Function to use to set a record's option 225 * value from a Tcl_Obj */ 226 Tk_CustomOptionGetProc *getProc; 227 /* Function to use to get a Tcl_Obj 228 * representation from an internal 229 * representation of an option. */ 230 Tk_CustomOptionRestoreProc *restoreProc; 231 /* Function to use to restore a saved value 232 * for the internal representation. */ 233 Tk_CustomOptionFreeProc *freeProc; 234 /* Function to use to free the internal 235 * representation of an option. */ 236 ClientData clientData; /* Arbitrary one-word value passed to the 237 * handling procs. */ 238} Tk_ObjCustomOption; 239 240/* 241 * Macro to use to fill in "offset" fields of the Tk_OptionSpec structure. 242 * Computes number of bytes from beginning of structure to a given field. 243 */ 244 245#ifdef offsetof 246#define Tk_Offset(type, field) ((int) offsetof(type, field)) 247#else 248#define Tk_Offset(type, field) ((int) ((char *) &((type *) 0)->field)) 249#endif 250 251/* 252 * The following two structures are used for error handling. When config 253 * options are being modified, the old values are saved in a Tk_SavedOptions 254 * structure. If an error occurs, then the contents of the structure can be 255 * used to restore all of the old values. The contents of this structure are 256 * for the private use Tk. No-one outside Tk should ever read or write any of 257 * the fields of these structures. 258 */ 259 260typedef struct Tk_SavedOption { 261 struct TkOption *optionPtr; /* Points to information that describes the 262 * option. */ 263 Tcl_Obj *valuePtr; /* The old value of the option, in the form of 264 * a Tcl object; may be NULL if the value was 265 * not saved as an object. */ 266 double internalForm; /* The old value of the option, in some 267 * internal representation such as an int or 268 * (XColor *). Valid only if the field 269 * optionPtr->specPtr->objOffset is < 0. The 270 * space must be large enough to accommodate a 271 * double, a long, or a pointer; right now it 272 * looks like a double (i.e., 8 bytes) is big 273 * enough. Also, using a double guarantees 274 * that the field is properly aligned for 275 * storing large values. */ 276} Tk_SavedOption; 277 278#ifdef TCL_MEM_DEBUG 279# define TK_NUM_SAVED_OPTIONS 2 280#else 281# define TK_NUM_SAVED_OPTIONS 20 282#endif 283 284typedef struct Tk_SavedOptions { 285 char *recordPtr; /* The data structure in which to restore 286 * configuration options. */ 287 Tk_Window tkwin; /* Window associated with recordPtr; needed to 288 * restore certain options. */ 289 int numItems; /* The number of valid items in items field. */ 290 Tk_SavedOption items[TK_NUM_SAVED_OPTIONS]; 291 /* Items used to hold old values. */ 292 struct Tk_SavedOptions *nextPtr; 293 /* Points to next structure in list; needed if 294 * too many options changed to hold all the 295 * old values in a single structure. NULL 296 * means no more structures. */ 297} Tk_SavedOptions; 298 299/* 300 * Structure used to describe application-specific configuration options: 301 * indicates procedures to call to parse an option and to return a text string 302 * describing an option. THESE ARE DEPRECATED; PLEASE USE THE NEW STRUCTURES 303 * LISTED ABOVE. 304 */ 305 306/* 307 * This is a temporary flag used while tkObjConfig and new widgets are in 308 * development. 309 */ 310 311#ifndef __NO_OLD_CONFIG 312 313typedef int (Tk_OptionParseProc) _ANSI_ARGS_((ClientData clientData, 314 Tcl_Interp *interp, Tk_Window tkwin, CONST84 char *value, char *widgRec, 315 int offset)); 316typedef char *(Tk_OptionPrintProc) _ANSI_ARGS_((ClientData clientData, 317 Tk_Window tkwin, char *widgRec, int offset, 318 Tcl_FreeProc **freeProcPtr)); 319 320typedef struct Tk_CustomOption { 321 Tk_OptionParseProc *parseProc; 322 /* Procedure to call to parse an option and 323 * store it in converted form. */ 324 Tk_OptionPrintProc *printProc; 325 /* Procedure to return a printable string 326 * describing an existing option. */ 327 ClientData clientData; /* Arbitrary one-word value used by option 328 * parser: passed to parseProc and 329 * printProc. */ 330} Tk_CustomOption; 331 332/* 333 * Structure used to specify information for Tk_ConfigureWidget. Each 334 * structure gives complete information for one option, including how the 335 * option is specified on the command line, where it appears in the option 336 * database, etc. 337 */ 338 339typedef struct Tk_ConfigSpec { 340 int type; /* Type of option, such as TK_CONFIG_COLOR; 341 * see definitions below. Last option in table 342 * must have type TK_CONFIG_END. */ 343 char *argvName; /* Switch used to specify option in argv. NULL 344 * means this spec is part of a group. */ 345 Tk_Uid dbName; /* Name for option in option database. */ 346 Tk_Uid dbClass; /* Class for option in database. */ 347 Tk_Uid defValue; /* Default value for option if not specified 348 * in command line or database. */ 349 int offset; /* Where in widget record to store value; use 350 * Tk_Offset macro to generate values for 351 * this. */ 352 int specFlags; /* Any combination of the values defined 353 * below; other bits are used internally by 354 * tkConfig.c. */ 355 Tk_CustomOption *customPtr; /* If type is TK_CONFIG_CUSTOM then this is a 356 * pointer to info about how to parse and 357 * print the option. Otherwise it is 358 * irrelevant. */ 359} Tk_ConfigSpec; 360 361/* 362 * Type values for Tk_ConfigSpec structures. See the user documentation for 363 * details. 364 */ 365 366typedef enum { 367 TK_CONFIG_BOOLEAN, TK_CONFIG_INT, TK_CONFIG_DOUBLE, TK_CONFIG_STRING, 368 TK_CONFIG_UID, TK_CONFIG_COLOR, TK_CONFIG_FONT, TK_CONFIG_BITMAP, 369 TK_CONFIG_BORDER, TK_CONFIG_RELIEF, TK_CONFIG_CURSOR, 370 TK_CONFIG_ACTIVE_CURSOR, TK_CONFIG_JUSTIFY, TK_CONFIG_ANCHOR, 371 TK_CONFIG_SYNONYM, TK_CONFIG_CAP_STYLE, TK_CONFIG_JOIN_STYLE, 372 TK_CONFIG_PIXELS, TK_CONFIG_MM, TK_CONFIG_WINDOW, TK_CONFIG_CUSTOM, 373 TK_CONFIG_END 374} Tk_ConfigTypes; 375 376/* 377 * Possible values for flags argument to Tk_ConfigureWidget: 378 */ 379 380#define TK_CONFIG_ARGV_ONLY 1 381#define TK_CONFIG_OBJS 0x80 382 383/* 384 * Possible flag values for Tk_ConfigSpec structures. Any bits at or above 385 * TK_CONFIG_USER_BIT may be used by clients for selecting certain entries. 386 * Before changing any values here, coordinate with tkOldConfig.c 387 * (internal-use-only flags are defined there). 388 */ 389 390#define TK_CONFIG_NULL_OK (1 << 0) 391#define TK_CONFIG_COLOR_ONLY (1 << 1) 392#define TK_CONFIG_MONO_ONLY (1 << 2) 393#define TK_CONFIG_DONT_SET_DEFAULT (1 << 3) 394#define TK_CONFIG_OPTION_SPECIFIED (1 << 4) 395#define TK_CONFIG_USER_BIT 0x100 396#endif /* __NO_OLD_CONFIG */ 397 398/* 399 * Structure used to specify how to handle argv options. 400 */ 401 402typedef struct { 403 char *key; /* The key string that flags the option in the 404 * argv array. */ 405 int type; /* Indicates option type; see below. */ 406 char *src; /* Value to be used in setting dst; usage 407 * depends on type. */ 408 char *dst; /* Address of value to be modified; usage 409 * depends on type. */ 410 char *help; /* Documentation message describing this 411 * option. */ 412} Tk_ArgvInfo; 413 414/* 415 * Legal values for the type field of a Tk_ArgvInfo: see the user 416 * documentation for details. 417 */ 418 419#define TK_ARGV_CONSTANT 15 420#define TK_ARGV_INT 16 421#define TK_ARGV_STRING 17 422#define TK_ARGV_UID 18 423#define TK_ARGV_REST 19 424#define TK_ARGV_FLOAT 20 425#define TK_ARGV_FUNC 21 426#define TK_ARGV_GENFUNC 22 427#define TK_ARGV_HELP 23 428#define TK_ARGV_CONST_OPTION 24 429#define TK_ARGV_OPTION_VALUE 25 430#define TK_ARGV_OPTION_NAME_VALUE 26 431#define TK_ARGV_END 27 432 433/* 434 * Flag bits for passing to Tk_ParseArgv: 435 */ 436 437#define TK_ARGV_NO_DEFAULTS 0x1 438#define TK_ARGV_NO_LEFTOVERS 0x2 439#define TK_ARGV_NO_ABBREV 0x4 440#define TK_ARGV_DONT_SKIP_FIRST_ARG 0x8 441 442/* 443 * Enumerated type for describing actions to be taken in response to a 444 * restrictProc established by Tk_RestrictEvents. 445 */ 446 447typedef enum { 448 TK_DEFER_EVENT, TK_PROCESS_EVENT, TK_DISCARD_EVENT 449} Tk_RestrictAction; 450 451/* 452 * Priority levels to pass to Tk_AddOption: 453 */ 454 455#define TK_WIDGET_DEFAULT_PRIO 20 456#define TK_STARTUP_FILE_PRIO 40 457#define TK_USER_DEFAULT_PRIO 60 458#define TK_INTERACTIVE_PRIO 80 459#define TK_MAX_PRIO 100 460 461/* 462 * Relief values returned by Tk_GetRelief: 463 */ 464 465#define TK_RELIEF_NULL -1 466#define TK_RELIEF_FLAT 0 467#define TK_RELIEF_GROOVE 1 468#define TK_RELIEF_RAISED 2 469#define TK_RELIEF_RIDGE 3 470#define TK_RELIEF_SOLID 4 471#define TK_RELIEF_SUNKEN 5 472 473/* 474 * "Which" argument values for Tk_3DBorderGC: 475 */ 476 477#define TK_3D_FLAT_GC 1 478#define TK_3D_LIGHT_GC 2 479#define TK_3D_DARK_GC 3 480 481/* 482 * Special EnterNotify/LeaveNotify "mode" for use in events generated by 483 * tkShare.c. Pick a high enough value that it's unlikely to conflict with 484 * existing values (like NotifyNormal) or any new values defined in the 485 * future. 486 */ 487 488#define TK_NOTIFY_SHARE 20 489 490/* 491 * Enumerated type for describing a point by which to anchor something: 492 */ 493 494typedef enum { 495 TK_ANCHOR_N, TK_ANCHOR_NE, TK_ANCHOR_E, TK_ANCHOR_SE, 496 TK_ANCHOR_S, TK_ANCHOR_SW, TK_ANCHOR_W, TK_ANCHOR_NW, 497 TK_ANCHOR_CENTER 498} Tk_Anchor; 499 500/* 501 * Enumerated type for describing a style of justification: 502 */ 503 504typedef enum { 505 TK_JUSTIFY_LEFT, TK_JUSTIFY_RIGHT, TK_JUSTIFY_CENTER 506} Tk_Justify; 507 508/* 509 * The following structure is used by Tk_GetFontMetrics() to return 510 * information about the properties of a Tk_Font. 511 */ 512 513typedef struct Tk_FontMetrics { 514 int ascent; /* The amount in pixels that the tallest 515 * letter sticks up above the baseline, plus 516 * any extra blank space added by the designer 517 * of the font. */ 518 int descent; /* The largest amount in pixels that any 519 * letter sticks below the baseline, plus any 520 * extra blank space added by the designer of 521 * the font. */ 522 int linespace; /* The sum of the ascent and descent. How far 523 * apart two lines of text in the same font 524 * should be placed so that none of the 525 * characters in one line overlap any of the 526 * characters in the other line. */ 527} Tk_FontMetrics; 528 529/* 530 * Flags passed to Tk_MeasureChars: 531 */ 532 533#define TK_WHOLE_WORDS 1 534#define TK_AT_LEAST_ONE 2 535#define TK_PARTIAL_OK 4 536 537/* 538 * Flags passed to Tk_ComputeTextLayout: 539 */ 540 541#define TK_IGNORE_TABS 8 542#define TK_IGNORE_NEWLINES 16 543 544/* 545 * Widget class procedures used to implement platform specific widget 546 * behavior. 547 */ 548 549typedef Window (Tk_ClassCreateProc) _ANSI_ARGS_((Tk_Window tkwin, 550 Window parent, ClientData instanceData)); 551typedef void (Tk_ClassWorldChangedProc) _ANSI_ARGS_((ClientData instanceData)); 552typedef void (Tk_ClassModalProc) _ANSI_ARGS_((Tk_Window tkwin, 553 XEvent *eventPtr)); 554 555typedef struct Tk_ClassProcs { 556 unsigned int size; 557 Tk_ClassWorldChangedProc *worldChangedProc; 558 /* Procedure to invoke when the widget needs 559 * to respond in some way to a change in the 560 * world (font changes, etc.) */ 561 Tk_ClassCreateProc *createProc; 562 /* Procedure to invoke when the platform- 563 * dependent window needs to be created. */ 564 Tk_ClassModalProc *modalProc; 565 /* Procedure to invoke after all bindings on a 566 * widget have been triggered in order to 567 * handle a modal loop. */ 568} Tk_ClassProcs; 569 570/* 571 * Simple accessor for Tk_ClassProcs structure. Checks that the structure is 572 * not NULL, then checks the size field and returns either the requested 573 * field, if present, or NULL if the structure is too small to have the field 574 * (or NULL if the structure is NULL). 575 * 576 * A more general version of this function may be useful if other 577 * size-versioned structure pop up in the future: 578 * 579 * #define Tk_GetField(name, who, which) \ 580 * (((who) == NULL) ? NULL : 581 * (((who)->size <= Tk_Offset(name, which)) ? NULL :(name)->which)) 582 */ 583 584#define Tk_GetClassProc(procs, which) \ 585 (((procs) == NULL) ? NULL : \ 586 (((procs)->size <= Tk_Offset(Tk_ClassProcs, which)) ? NULL:(procs)->which)) 587 588/* 589 * Each geometry manager (the packer, the placer, etc.) is represented by a 590 * structure of the following form, which indicates procedures to invoke in 591 * the geometry manager to carry out certain functions. 592 */ 593 594typedef void (Tk_GeomRequestProc) _ANSI_ARGS_((ClientData clientData, 595 Tk_Window tkwin)); 596typedef void (Tk_GeomLostSlaveProc) _ANSI_ARGS_((ClientData clientData, 597 Tk_Window tkwin)); 598 599typedef struct Tk_GeomMgr { 600 const char *name; /* Name of the geometry manager (command used 601 * to invoke it, or name of widget class that 602 * allows embedded widgets). */ 603 Tk_GeomRequestProc *requestProc; 604 /* Procedure to invoke when a slave's 605 * requested geometry changes. */ 606 Tk_GeomLostSlaveProc *lostSlaveProc; 607 /* Procedure to invoke when a slave is taken 608 * away from one geometry manager by another. 609 * NULL means geometry manager doesn't care 610 * when slaves are lost. */ 611} Tk_GeomMgr; 612 613/* 614 * Result values returned by Tk_GetScrollInfo: 615 */ 616 617#define TK_SCROLL_MOVETO 1 618#define TK_SCROLL_PAGES 2 619#define TK_SCROLL_UNITS 3 620#define TK_SCROLL_ERROR 4 621 622/* 623 *--------------------------------------------------------------------------- 624 * 625 * Extensions to the X event set 626 * 627 *--------------------------------------------------------------------------- 628 */ 629 630#define VirtualEvent (MappingNotify + 1) 631#define ActivateNotify (MappingNotify + 2) 632#define DeactivateNotify (MappingNotify + 3) 633#define MouseWheelEvent (MappingNotify + 4) 634#define TK_LASTEVENT (MappingNotify + 5) 635 636#define MouseWheelMask (1L << 28) 637#define ActivateMask (1L << 29) 638#define VirtualEventMask (1L << 30) 639 640/* 641 * A virtual event shares most of its fields with the XKeyEvent and 642 * XButtonEvent structures. 99% of the time a virtual event will be an 643 * abstraction of a key or button event, so this structure provides the most 644 * information to the user. The only difference is the changing of the detail 645 * field for a virtual event so that it holds the name of the virtual event 646 * being triggered. 647 * 648 * When using this structure, you should ensure that you zero out all the 649 * fields first using memset() or bzero(). 650 */ 651 652typedef struct { 653 int type; 654 unsigned long serial; /* # of last request processed by server. */ 655 Bool send_event; /* True if this came from a SendEvent 656 * request. */ 657 Display *display; /* Display the event was read from. */ 658 Window event; /* Window on which event was requested. */ 659 Window root; /* Root window that the event occured on. */ 660 Window subwindow; /* Child window. */ 661 Time time; /* Milliseconds. */ 662 int x, y; /* Pointer x, y coordinates in event 663 * window. */ 664 int x_root, y_root; /* Coordinates relative to root. */ 665 unsigned int state; /* Key or button mask */ 666 Tk_Uid name; /* Name of virtual event. */ 667 Bool same_screen; /* Same screen flag. */ 668 Tcl_Obj *user_data; /* Application-specific data reference; Tk 669 * will decrement the reference count *once* 670 * when it has finished processing the 671 * event. */ 672} XVirtualEvent; 673 674typedef struct { 675 int type; 676 unsigned long serial; /* # of last request processed by server. */ 677 Bool send_event; /* True if this came from a SendEvent 678 * request. */ 679 Display *display; /* Display the event was read from. */ 680 Window window; /* Window in which event occurred. */ 681} XActivateDeactivateEvent; 682typedef XActivateDeactivateEvent XActivateEvent; 683typedef XActivateDeactivateEvent XDeactivateEvent; 684 685/* 686 *-------------------------------------------------------------- 687 * 688 * Macros for querying Tk_Window structures. See the manual entries for 689 * documentation. 690 * 691 *-------------------------------------------------------------- 692 */ 693 694#define Tk_Display(tkwin) (((Tk_FakeWin *) (tkwin))->display) 695#define Tk_ScreenNumber(tkwin) (((Tk_FakeWin *) (tkwin))->screenNum) 696#define Tk_Screen(tkwin) \ 697 (ScreenOfDisplay(Tk_Display(tkwin), Tk_ScreenNumber(tkwin))) 698#define Tk_Depth(tkwin) (((Tk_FakeWin *) (tkwin))->depth) 699#define Tk_Visual(tkwin) (((Tk_FakeWin *) (tkwin))->visual) 700#define Tk_WindowId(tkwin) (((Tk_FakeWin *) (tkwin))->window) 701#define Tk_PathName(tkwin) (((Tk_FakeWin *) (tkwin))->pathName) 702#define Tk_Name(tkwin) (((Tk_FakeWin *) (tkwin))->nameUid) 703#define Tk_Class(tkwin) (((Tk_FakeWin *) (tkwin))->classUid) 704#define Tk_X(tkwin) (((Tk_FakeWin *) (tkwin))->changes.x) 705#define Tk_Y(tkwin) (((Tk_FakeWin *) (tkwin))->changes.y) 706#define Tk_Width(tkwin) (((Tk_FakeWin *) (tkwin))->changes.width) 707#define Tk_Height(tkwin) \ 708 (((Tk_FakeWin *) (tkwin))->changes.height) 709#define Tk_Changes(tkwin) (&((Tk_FakeWin *) (tkwin))->changes) 710#define Tk_Attributes(tkwin) (&((Tk_FakeWin *) (tkwin))->atts) 711#define Tk_IsEmbedded(tkwin) \ 712 (((Tk_FakeWin *) (tkwin))->flags & TK_EMBEDDED) 713#define Tk_IsContainer(tkwin) \ 714 (((Tk_FakeWin *) (tkwin))->flags & TK_CONTAINER) 715#define Tk_IsMapped(tkwin) \ 716 (((Tk_FakeWin *) (tkwin))->flags & TK_MAPPED) 717#define Tk_IsTopLevel(tkwin) \ 718 (((Tk_FakeWin *) (tkwin))->flags & TK_TOP_LEVEL) 719#define Tk_HasWrapper(tkwin) \ 720 (((Tk_FakeWin *) (tkwin))->flags & TK_HAS_WRAPPER) 721#define Tk_WinManaged(tkwin) \ 722 (((Tk_FakeWin *) (tkwin))->flags & TK_WIN_MANAGED) 723#define Tk_TopWinHierarchy(tkwin) \ 724 (((Tk_FakeWin *) (tkwin))->flags & TK_TOP_HIERARCHY) 725#define Tk_IsManageable(tkwin) \ 726 (((Tk_FakeWin *) (tkwin))->flags & TK_WM_MANAGEABLE) 727#define Tk_ReqWidth(tkwin) (((Tk_FakeWin *) (tkwin))->reqWidth) 728#define Tk_ReqHeight(tkwin) (((Tk_FakeWin *) (tkwin))->reqHeight) 729/* Tk_InternalBorderWidth is deprecated */ 730#define Tk_InternalBorderWidth(tkwin) \ 731 (((Tk_FakeWin *) (tkwin))->internalBorderLeft) 732#define Tk_InternalBorderLeft(tkwin) \ 733 (((Tk_FakeWin *) (tkwin))->internalBorderLeft) 734#define Tk_InternalBorderRight(tkwin) \ 735 (((Tk_FakeWin *) (tkwin))->internalBorderRight) 736#define Tk_InternalBorderTop(tkwin) \ 737 (((Tk_FakeWin *) (tkwin))->internalBorderTop) 738#define Tk_InternalBorderBottom(tkwin) \ 739 (((Tk_FakeWin *) (tkwin))->internalBorderBottom) 740#define Tk_MinReqWidth(tkwin) (((Tk_FakeWin *) (tkwin))->minReqWidth) 741#define Tk_MinReqHeight(tkwin) (((Tk_FakeWin *) (tkwin))->minReqHeight) 742#define Tk_Parent(tkwin) (((Tk_FakeWin *) (tkwin))->parentPtr) 743#define Tk_Colormap(tkwin) (((Tk_FakeWin *) (tkwin))->atts.colormap) 744 745/* 746 * The structure below is needed by the macros above so that they can access 747 * the fields of a Tk_Window. The fields not needed by the macros are declared 748 * as "dummyX". The structure has its own type in order to prevent apps from 749 * accessing Tk_Window fields except using official macros. WARNING!! The 750 * structure definition must be kept consistent with the TkWindow structure in 751 * tkInt.h. If you change one, then change the other. See the declaration in 752 * tkInt.h for documentation on what the fields are used for internally. 753 */ 754 755typedef struct Tk_FakeWin { 756 Display *display; 757 char *dummy1; /* dispPtr */ 758 int screenNum; 759 Visual *visual; 760 int depth; 761 Window window; 762 char *dummy2; /* childList */ 763 char *dummy3; /* lastChildPtr */ 764 Tk_Window parentPtr; /* parentPtr */ 765 char *dummy4; /* nextPtr */ 766 char *dummy5; /* mainPtr */ 767 char *pathName; 768 Tk_Uid nameUid; 769 Tk_Uid classUid; 770 XWindowChanges changes; 771 unsigned int dummy6; /* dirtyChanges */ 772 XSetWindowAttributes atts; 773 unsigned long dummy7; /* dirtyAtts */ 774 unsigned int flags; 775 char *dummy8; /* handlerList */ 776#ifdef TK_USE_INPUT_METHODS 777 XIC dummy9; /* inputContext */ 778#endif /* TK_USE_INPUT_METHODS */ 779 ClientData *dummy10; /* tagPtr */ 780 int dummy11; /* numTags */ 781 int dummy12; /* optionLevel */ 782 char *dummy13; /* selHandlerList */ 783 char *dummy14; /* geomMgrPtr */ 784 ClientData dummy15; /* geomData */ 785 int reqWidth, reqHeight; 786 int internalBorderLeft; 787 char *dummy16; /* wmInfoPtr */ 788 char *dummy17; /* classProcPtr */ 789 ClientData dummy18; /* instanceData */ 790 char *dummy19; /* privatePtr */ 791 int internalBorderRight; 792 int internalBorderTop; 793 int internalBorderBottom; 794 int minReqWidth; 795 int minReqHeight; 796} Tk_FakeWin; 797 798/* 799 * Flag values for TkWindow (and Tk_FakeWin) structures are: 800 * 801 * TK_MAPPED: 1 means window is currently mapped, 802 * 0 means unmapped. 803 * TK_TOP_LEVEL: 1 means this is a top-level widget. 804 * TK_ALREADY_DEAD: 1 means the window is in the process of 805 * being destroyed already. 806 * TK_NEED_CONFIG_NOTIFY: 1 means that the window has been reconfigured 807 * before it was made to exist. At the time of 808 * making it exist a ConfigureNotify event needs 809 * to be generated. 810 * TK_GRAB_FLAG: Used to manage grabs. See tkGrab.c for details 811 * TK_CHECKED_IC: 1 means we've already tried to get an input 812 * context for this window; if the ic field is 813 * NULL it means that there isn't a context for 814 * the field. 815 * TK_DONT_DESTROY_WINDOW: 1 means that Tk_DestroyWindow should not 816 * invoke XDestroyWindow to destroy this widget's 817 * X window. The flag is set when the window has 818 * already been destroyed elsewhere (e.g. by 819 * another application) or when it will be 820 * destroyed later (e.g. by destroying its parent) 821 * TK_WM_COLORMAP_WINDOW: 1 means that this window has at some time 822 * appeared in the WM_COLORMAP_WINDOWS property 823 * for its toplevel, so we have to remove it from 824 * that property if the window is deleted and the 825 * toplevel isn't. 826 * TK_EMBEDDED: 1 means that this window (which must be a 827 * toplevel) is not a free-standing window but 828 * rather is embedded in some other application. 829 * TK_CONTAINER: 1 means that this window is a container, and 830 * that some other application (either in this 831 * process or elsewhere) may be embedding itself 832 * inside the window. 833 * TK_BOTH_HALVES: 1 means that this window is used for 834 * application embedding (either as container or 835 * embedded application), and both the containing 836 * and embedded halves are associated with 837 * windows in this particular process. 838 * TK_DEFER_MODAL: 1 means that this window has deferred a modal 839 * loop until all of the bindings for the current 840 * event have been invoked. 841 * TK_WRAPPER: 1 means that this window is the extra wrapper 842 * window created around a toplevel to hold the 843 * menubar under Unix. See tkUnixWm.c for more 844 * information. 845 * TK_REPARENTED: 1 means that this window has been reparented 846 * so that as far as the window system is 847 * concerned it isn't a child of its Tk parent. 848 * Initially this is used only for special Unix 849 * menubar windows. 850 * TK_ANONYMOUS_WINDOW: 1 means that this window has no name, and is 851 * thus not accessible from Tk. 852 * TK_HAS_WRAPPER 1 means that this window has a wrapper window 853 * TK_WIN_MANAGED 1 means that this window is a child of the root 854 * window, and is managed by the window manager. 855 * TK_TOP_HIERARCHY 1 means this window is at the top of a physical 856 * window hierarchy within this process, i.e. the 857 * window's parent either doesn't exist or is not 858 * owned by this Tk application. 859 * TK_PROP_PROPCHANGE 1 means that PropertyNotify events in the 860 * window's children should propagate up to this 861 * window. 862 * TK_WM_MANAGEABLE 1 marks a window as capable of being converted 863 * into a toplevel using [wm manage]. 864 */ 865 866#define TK_MAPPED 1 867#define TK_TOP_LEVEL 2 868#define TK_ALREADY_DEAD 4 869#define TK_NEED_CONFIG_NOTIFY 8 870#define TK_GRAB_FLAG 0x10 871#define TK_CHECKED_IC 0x20 872#define TK_DONT_DESTROY_WINDOW 0x40 873#define TK_WM_COLORMAP_WINDOW 0x80 874#define TK_EMBEDDED 0x100 875#define TK_CONTAINER 0x200 876#define TK_BOTH_HALVES 0x400 877#define TK_DEFER_MODAL 0x800 878#define TK_WRAPPER 0x1000 879#define TK_REPARENTED 0x2000 880#define TK_ANONYMOUS_WINDOW 0x4000 881#define TK_HAS_WRAPPER 0x8000 882#define TK_WIN_MANAGED 0x10000 883#define TK_TOP_HIERARCHY 0x20000 884#define TK_PROP_PROPCHANGE 0x40000 885#define TK_WM_MANAGEABLE 0x80000 886 887/* 888 *-------------------------------------------------------------- 889 * 890 * Procedure prototypes and structures used for defining new canvas items: 891 * 892 *-------------------------------------------------------------- 893 */ 894 895typedef enum { 896 TK_STATE_NULL = -1, TK_STATE_ACTIVE, TK_STATE_DISABLED, 897 TK_STATE_NORMAL, TK_STATE_HIDDEN 898} Tk_State; 899 900typedef struct Tk_SmoothMethod { 901 char *name; 902 int (*coordProc) _ANSI_ARGS_((Tk_Canvas canvas, 903 double *pointPtr, int numPoints, int numSteps, 904 XPoint xPoints[], double dblPoints[])); 905 void (*postscriptProc) _ANSI_ARGS_((Tcl_Interp *interp, 906 Tk_Canvas canvas, double *coordPtr, 907 int numPoints, int numSteps)); 908} Tk_SmoothMethod; 909 910/* 911 * For each item in a canvas widget there exists one record with the following 912 * structure. Each actual item is represented by a record with the following 913 * stuff at its beginning, plus additional type-specific stuff after that. 914 */ 915 916#define TK_TAG_SPACE 3 917 918typedef struct Tk_Item { 919 int id; /* Unique identifier for this item (also 920 * serves as first tag for item). */ 921 struct Tk_Item *nextPtr; /* Next in display list of all items in this 922 * canvas. Later items in list are drawn on 923 * top of earlier ones. */ 924 Tk_Uid staticTagSpace[TK_TAG_SPACE]; 925 /* Built-in space for limited # of tags. */ 926 Tk_Uid *tagPtr; /* Pointer to array of tags. Usually points to 927 * staticTagSpace, but may point to malloc-ed 928 * space if there are lots of tags. */ 929 int tagSpace; /* Total amount of tag space available at 930 * tagPtr. */ 931 int numTags; /* Number of tag slots actually used at 932 * *tagPtr. */ 933 struct Tk_ItemType *typePtr;/* Table of procedures that implement this 934 * type of item. */ 935 int x1, y1, x2, y2; /* Bounding box for item, in integer canvas 936 * units. Set by item-specific code and 937 * guaranteed to contain every pixel drawn in 938 * item. Item area includes x1 and y1 but not 939 * x2 and y2. */ 940 struct Tk_Item *prevPtr; /* Previous in display list of all items in 941 * this canvas. Later items in list are drawn 942 * just below earlier ones. */ 943 Tk_State state; /* State of item. */ 944 char *reserved1; /* reserved for future use */ 945 int redraw_flags; /* Some flags used in the canvas */ 946 947 /* 948 *------------------------------------------------------------------ 949 * Starting here is additional type-specific stuff; see the declarations 950 * for individual types to see what is part of each type. The actual space 951 * below is determined by the "itemInfoSize" of the type's Tk_ItemType 952 * record. 953 *------------------------------------------------------------------ 954 */ 955} Tk_Item; 956 957/* 958 * Flag bits for canvases (redraw_flags): 959 * 960 * TK_ITEM_STATE_DEPENDANT - 1 means that object needs to be redrawn if the 961 * canvas state changes. 962 * TK_ITEM_DONT_REDRAW - 1 means that the object redraw is already been 963 * prepared, so the general canvas code doesn't 964 * need to do that any more. 965 */ 966 967#define TK_ITEM_STATE_DEPENDANT 1 968#define TK_ITEM_DONT_REDRAW 2 969 970/* 971 * Records of the following type are used to describe a type of item (e.g. 972 * lines, circles, etc.) that can form part of a canvas widget. 973 */ 974 975#ifdef USE_OLD_CANVAS 976typedef int Tk_ItemCreateProc _ANSI_ARGS_((Tcl_Interp *interp, 977 Tk_Canvas canvas, Tk_Item *itemPtr, int argc, 978 char **argv)); 979typedef int Tk_ItemConfigureProc _ANSI_ARGS_((Tcl_Interp *interp, 980 Tk_Canvas canvas, Tk_Item *itemPtr, int argc, 981 char **argv, int flags)); 982typedef int Tk_ItemCoordProc _ANSI_ARGS_((Tcl_Interp *interp, 983 Tk_Canvas canvas, Tk_Item *itemPtr, int argc, 984 char **argv)); 985#else 986typedef int Tk_ItemCreateProc _ANSI_ARGS_((Tcl_Interp *interp, 987 Tk_Canvas canvas, Tk_Item *itemPtr, int argc, 988 Tcl_Obj *const objv[])); 989typedef int Tk_ItemConfigureProc _ANSI_ARGS_((Tcl_Interp *interp, 990 Tk_Canvas canvas, Tk_Item *itemPtr, int argc, 991 Tcl_Obj *const objv[], int flags)); 992typedef int Tk_ItemCoordProc _ANSI_ARGS_((Tcl_Interp *interp, 993 Tk_Canvas canvas, Tk_Item *itemPtr, int argc, 994 Tcl_Obj *const argv[])); 995#endif 996typedef void Tk_ItemDeleteProc _ANSI_ARGS_((Tk_Canvas canvas, 997 Tk_Item *itemPtr, Display *display)); 998typedef void Tk_ItemDisplayProc _ANSI_ARGS_((Tk_Canvas canvas, 999 Tk_Item *itemPtr, Display *display, Drawable dst, 1000 int x, int y, int width, int height)); 1001typedef double Tk_ItemPointProc _ANSI_ARGS_((Tk_Canvas canvas, 1002 Tk_Item *itemPtr, double *pointPtr)); 1003typedef int Tk_ItemAreaProc _ANSI_ARGS_((Tk_Canvas canvas, 1004 Tk_Item *itemPtr, double *rectPtr)); 1005typedef int Tk_ItemPostscriptProc _ANSI_ARGS_((Tcl_Interp *interp, 1006 Tk_Canvas canvas, Tk_Item *itemPtr, int prepass)); 1007typedef void Tk_ItemScaleProc _ANSI_ARGS_((Tk_Canvas canvas, 1008 Tk_Item *itemPtr, double originX, double originY, 1009 double scaleX, double scaleY)); 1010typedef void Tk_ItemTranslateProc _ANSI_ARGS_((Tk_Canvas canvas, 1011 Tk_Item *itemPtr, double deltaX, double deltaY)); 1012typedef int Tk_ItemIndexProc _ANSI_ARGS_((Tcl_Interp *interp, 1013 Tk_Canvas canvas, Tk_Item *itemPtr, char *indexString, 1014 int *indexPtr)); 1015typedef void Tk_ItemCursorProc _ANSI_ARGS_((Tk_Canvas canvas, 1016 Tk_Item *itemPtr, int index)); 1017typedef int Tk_ItemSelectionProc _ANSI_ARGS_((Tk_Canvas canvas, 1018 Tk_Item *itemPtr, int offset, char *buffer, 1019 int maxBytes)); 1020typedef void Tk_ItemInsertProc _ANSI_ARGS_((Tk_Canvas canvas, 1021 Tk_Item *itemPtr, int beforeThis, char *string)); 1022typedef void Tk_ItemDCharsProc _ANSI_ARGS_((Tk_Canvas canvas, 1023 Tk_Item *itemPtr, int first, int last)); 1024 1025#ifndef __NO_OLD_CONFIG 1026 1027typedef struct Tk_ItemType { 1028 char *name; /* The name of this type of item, such as 1029 * "line". */ 1030 int itemSize; /* Total amount of space needed for item's 1031 * record. */ 1032 Tk_ItemCreateProc *createProc; 1033 /* Procedure to create a new item of this 1034 * type. */ 1035 Tk_ConfigSpec *configSpecs; /* Pointer to array of configuration specs for 1036 * this type. Used for returning configuration 1037 * info. */ 1038 Tk_ItemConfigureProc *configProc; 1039 /* Procedure to call to change configuration 1040 * options. */ 1041 Tk_ItemCoordProc *coordProc;/* Procedure to call to get and set the item's 1042 * coordinates. */ 1043 Tk_ItemDeleteProc *deleteProc; 1044 /* Procedure to delete existing item of this 1045 * type. */ 1046 Tk_ItemDisplayProc *displayProc; 1047 /* Procedure to display items of this type. */ 1048 int alwaysRedraw; /* Non-zero means displayProc should be called 1049 * even when the item has been moved 1050 * off-screen. */ 1051 Tk_ItemPointProc *pointProc;/* Computes distance from item to a given 1052 * point. */ 1053 Tk_ItemAreaProc *areaProc; /* Computes whether item is inside, outside, 1054 * or overlapping an area. */ 1055 Tk_ItemPostscriptProc *postscriptProc; 1056 /* Procedure to write a Postscript description 1057 * for items of this type. */ 1058 Tk_ItemScaleProc *scaleProc;/* Procedure to rescale items of this type. */ 1059 Tk_ItemTranslateProc *translateProc; 1060 /* Procedure to translate items of this 1061 * type. */ 1062 Tk_ItemIndexProc *indexProc;/* Procedure to determine index of indicated 1063 * character. NULL if item doesn't support 1064 * indexing. */ 1065 Tk_ItemCursorProc *icursorProc; 1066 /* Procedure to set insert cursor posn to just 1067 * before a given position. */ 1068 Tk_ItemSelectionProc *selectionProc; 1069 /* Procedure to return selection (in STRING 1070 * format) when it is in this item. */ 1071 Tk_ItemInsertProc *insertProc; 1072 /* Procedure to insert something into an 1073 * item. */ 1074 Tk_ItemDCharsProc *dCharsProc; 1075 /* Procedure to delete characters from an 1076 * item. */ 1077 struct Tk_ItemType *nextPtr;/* Used to link types together into a list. */ 1078 char *reserved1; /* Reserved for future extension. */ 1079 int reserved2; /* Carefully compatible with */ 1080 char *reserved3; /* Jan Nijtmans dash patch */ 1081 char *reserved4; 1082} Tk_ItemType; 1083 1084#endif 1085 1086/* 1087 * The following structure provides information about the selection and the 1088 * insertion cursor. It is needed by only a few items, such as those that 1089 * display text. It is shared by the generic canvas code and the item-specific 1090 * code, but most of the fields should be written only by the canvas generic 1091 * code. 1092 */ 1093 1094typedef struct Tk_CanvasTextInfo { 1095 Tk_3DBorder selBorder; /* Border and background for selected 1096 * characters. Read-only to items.*/ 1097 int selBorderWidth; /* Width of border around selection. Read-only 1098 * to items. */ 1099 XColor *selFgColorPtr; /* Foreground color for selected text. 1100 * Read-only to items. */ 1101 Tk_Item *selItemPtr; /* Pointer to selected item. NULL means 1102 * selection isn't in this canvas. Writable by 1103 * items. */ 1104 int selectFirst; /* Character index of first selected 1105 * character. Writable by items. */ 1106 int selectLast; /* Character index of last selected character. 1107 * Writable by items. */ 1108 Tk_Item *anchorItemPtr; /* Item corresponding to "selectAnchor": not 1109 * necessarily selItemPtr. Read-only to 1110 * items. */ 1111 int selectAnchor; /* Character index of fixed end of selection 1112 * (i.e. "select to" operation will use this 1113 * as one end of the selection). Writable by 1114 * items. */ 1115 Tk_3DBorder insertBorder; /* Used to draw vertical bar for insertion 1116 * cursor. Read-only to items. */ 1117 int insertWidth; /* Total width of insertion cursor. Read-only 1118 * to items. */ 1119 int insertBorderWidth; /* Width of 3-D border around insert cursor. 1120 * Read-only to items. */ 1121 Tk_Item *focusItemPtr; /* Item that currently has the input focus, or 1122 * NULL if no such item. Read-only to items. */ 1123 int gotFocus; /* Non-zero means that the canvas widget has 1124 * the input focus. Read-only to items.*/ 1125 int cursorOn; /* Non-zero means that an insertion cursor 1126 * should be displayed in focusItemPtr. 1127 * Read-only to items.*/ 1128} Tk_CanvasTextInfo; 1129 1130/* 1131 * Structures used for Dashing and Outline. 1132 */ 1133 1134typedef struct Tk_Dash { 1135 int number; 1136 union { 1137 char *pt; 1138 char array[sizeof(char *)]; 1139 } pattern; 1140} Tk_Dash; 1141 1142typedef struct Tk_TSOffset { 1143 int flags; /* Flags; see below for possible values */ 1144 int xoffset; /* x offset */ 1145 int yoffset; /* y offset */ 1146} Tk_TSOffset; 1147 1148/* 1149 * Bit fields in Tk_Offset->flags: 1150 */ 1151 1152#define TK_OFFSET_INDEX 1 1153#define TK_OFFSET_RELATIVE 2 1154#define TK_OFFSET_LEFT 4 1155#define TK_OFFSET_CENTER 8 1156#define TK_OFFSET_RIGHT 16 1157#define TK_OFFSET_TOP 32 1158#define TK_OFFSET_MIDDLE 64 1159#define TK_OFFSET_BOTTOM 128 1160 1161typedef struct Tk_Outline { 1162 GC gc; /* Graphics context. */ 1163 double width; /* Width of outline. */ 1164 double activeWidth; /* Width of outline. */ 1165 double disabledWidth; /* Width of outline. */ 1166 int offset; /* Dash offset. */ 1167 Tk_Dash dash; /* Dash pattern. */ 1168 Tk_Dash activeDash; /* Dash pattern if state is active. */ 1169 Tk_Dash disabledDash; /* Dash pattern if state is disabled. */ 1170 VOID *reserved1; /* Reserved for future expansion. */ 1171 VOID *reserved2; 1172 VOID *reserved3; 1173 Tk_TSOffset tsoffset; /* Stipple offset for outline. */ 1174 XColor *color; /* Outline color. */ 1175 XColor *activeColor; /* Outline color if state is active. */ 1176 XColor *disabledColor; /* Outline color if state is disabled. */ 1177 Pixmap stipple; /* Outline Stipple pattern. */ 1178 Pixmap activeStipple; /* Outline Stipple pattern if state is 1179 * active. */ 1180 Pixmap disabledStipple; /* Outline Stipple pattern if state is 1181 * disabled. */ 1182} Tk_Outline; 1183 1184/* 1185 *-------------------------------------------------------------- 1186 * 1187 * Procedure prototypes and structures used for managing images: 1188 * 1189 *-------------------------------------------------------------- 1190 */ 1191 1192typedef struct Tk_ImageType Tk_ImageType; 1193#ifdef USE_OLD_IMAGE 1194typedef int (Tk_ImageCreateProc) _ANSI_ARGS_((Tcl_Interp *interp, 1195 char *name, int argc, char **argv, Tk_ImageType *typePtr, 1196 Tk_ImageMaster master, ClientData *masterDataPtr)); 1197#else 1198typedef int (Tk_ImageCreateProc) _ANSI_ARGS_((Tcl_Interp *interp, 1199 char *name, int objc, Tcl_Obj *const objv[], Tk_ImageType *typePtr, 1200 Tk_ImageMaster master, ClientData *masterDataPtr)); 1201#endif 1202typedef ClientData (Tk_ImageGetProc) _ANSI_ARGS_((Tk_Window tkwin, 1203 ClientData masterData)); 1204typedef void (Tk_ImageDisplayProc) _ANSI_ARGS_((ClientData instanceData, 1205 Display *display, Drawable drawable, int imageX, int imageY, 1206 int width, int height, int drawableX, int drawableY)); 1207typedef void (Tk_ImageFreeProc) _ANSI_ARGS_((ClientData instanceData, 1208 Display *display)); 1209typedef void (Tk_ImageDeleteProc) _ANSI_ARGS_((ClientData masterData)); 1210typedef void (Tk_ImageChangedProc) _ANSI_ARGS_((ClientData clientData, 1211 int x, int y, int width, int height, int imageWidth, 1212 int imageHeight)); 1213typedef int (Tk_ImagePostscriptProc) _ANSI_ARGS_((ClientData clientData, 1214 Tcl_Interp *interp, Tk_Window tkwin, Tk_PostscriptInfo psinfo, 1215 int x, int y, int width, int height, int prepass)); 1216 1217/* 1218 * The following structure represents a particular type of image (bitmap, xpm 1219 * image, etc.). It provides information common to all images of that type, 1220 * such as the type name and a collection of procedures in the image manager 1221 * that respond to various events. Each image manager is represented by one of 1222 * these structures. 1223 */ 1224 1225struct Tk_ImageType { 1226 char *name; /* Name of image type. */ 1227 Tk_ImageCreateProc *createProc; 1228 /* Procedure to call to create a new image of 1229 * this type. */ 1230 Tk_ImageGetProc *getProc; /* Procedure to call the first time 1231 * Tk_GetImage is called in a new way (new 1232 * visual or screen). */ 1233 Tk_ImageDisplayProc *displayProc; 1234 /* Call to draw image, in response to 1235 * Tk_RedrawImage calls. */ 1236 Tk_ImageFreeProc *freeProc; /* Procedure to call whenever Tk_FreeImage is 1237 * called to release an instance of an 1238 * image. */ 1239 Tk_ImageDeleteProc *deleteProc; 1240 /* Procedure to call to delete image. It will 1241 * not be called until after freeProc has been 1242 * called for each instance of the image. */ 1243 Tk_ImagePostscriptProc *postscriptProc; 1244 /* Procedure to call to produce postscript 1245 * output for the image. */ 1246 struct Tk_ImageType *nextPtr; 1247 /* Next in list of all image types currently 1248 * known. Filled in by Tk, not by image 1249 * manager. */ 1250 char *reserved; /* reserved for future expansion */ 1251}; 1252 1253/* 1254 *-------------------------------------------------------------- 1255 * 1256 * Additional definitions used to manage images of type "photo". 1257 * 1258 *-------------------------------------------------------------- 1259 */ 1260 1261/* 1262 * The following type is used to identify a particular photo image to be 1263 * manipulated: 1264 */ 1265 1266typedef void *Tk_PhotoHandle; 1267 1268/* 1269 * The following structure describes a block of pixels in memory: 1270 */ 1271 1272typedef struct Tk_PhotoImageBlock { 1273 unsigned char *pixelPtr; /* Pointer to the first pixel. */ 1274 int width; /* Width of block, in pixels. */ 1275 int height; /* Height of block, in pixels. */ 1276 int pitch; /* Address difference between corresponding 1277 * pixels in successive lines. */ 1278 int pixelSize; /* Address difference between successive 1279 * pixels in the same line. */ 1280 int offset[4]; /* Address differences between the red, green, 1281 * blue and alpha components of the pixel and 1282 * the pixel as a whole. */ 1283} Tk_PhotoImageBlock; 1284 1285/* 1286 * The following values control how blocks are combined into photo images when 1287 * the alpha component of a pixel is not 255, a.k.a. the compositing rule. 1288 */ 1289 1290#define TK_PHOTO_COMPOSITE_OVERLAY 0 1291#define TK_PHOTO_COMPOSITE_SET 1 1292 1293/* 1294 * Procedure prototypes and structures used in reading and writing photo 1295 * images: 1296 */ 1297 1298typedef struct Tk_PhotoImageFormat Tk_PhotoImageFormat; 1299#ifdef USE_OLD_IMAGE 1300typedef int (Tk_ImageFileMatchProc) _ANSI_ARGS_((Tcl_Channel chan, 1301 char *fileName, char *formatString, int *widthPtr, int *heightPtr)); 1302typedef int (Tk_ImageStringMatchProc) _ANSI_ARGS_((char *string, 1303 char *formatString, int *widthPtr, int *heightPtr)); 1304typedef int (Tk_ImageFileReadProc) _ANSI_ARGS_((Tcl_Interp *interp, 1305 Tcl_Channel chan, char *fileName, char *formatString, 1306 Tk_PhotoHandle imageHandle, int destX, int destY, 1307 int width, int height, int srcX, int srcY)); 1308typedef int (Tk_ImageStringReadProc) _ANSI_ARGS_((Tcl_Interp *interp, 1309 char *string, char *formatString, Tk_PhotoHandle imageHandle, 1310 int destX, int destY, int width, int height, int srcX, int srcY)); 1311typedef int (Tk_ImageFileWriteProc) _ANSI_ARGS_((Tcl_Interp *interp, 1312 char *fileName, char *formatString, Tk_PhotoImageBlock *blockPtr)); 1313typedef int (Tk_ImageStringWriteProc) _ANSI_ARGS_((Tcl_Interp *interp, 1314 Tcl_DString *dataPtr, char *formatString, 1315 Tk_PhotoImageBlock *blockPtr)); 1316#else 1317typedef int (Tk_ImageFileMatchProc) _ANSI_ARGS_((Tcl_Channel chan, 1318 const char *fileName, Tcl_Obj *format, int *widthPtr, 1319 int *heightPtr, Tcl_Interp *interp)); 1320typedef int (Tk_ImageStringMatchProc) _ANSI_ARGS_((Tcl_Obj *dataObj, 1321 Tcl_Obj *format, int *widthPtr, int *heightPtr, 1322 Tcl_Interp *interp)); 1323typedef int (Tk_ImageFileReadProc) _ANSI_ARGS_((Tcl_Interp *interp, 1324 Tcl_Channel chan, const char *fileName, Tcl_Obj *format, 1325 Tk_PhotoHandle imageHandle, int destX, int destY, 1326 int width, int height, int srcX, int srcY)); 1327typedef int (Tk_ImageStringReadProc) _ANSI_ARGS_((Tcl_Interp *interp, 1328 Tcl_Obj *dataObj, Tcl_Obj *format, Tk_PhotoHandle imageHandle, 1329 int destX, int destY, int width, int height, int srcX, int srcY)); 1330typedef int (Tk_ImageFileWriteProc) _ANSI_ARGS_((Tcl_Interp *interp, 1331 const char *fileName, Tcl_Obj *format, Tk_PhotoImageBlock *blockPtr)); 1332typedef int (Tk_ImageStringWriteProc) _ANSI_ARGS_((Tcl_Interp *interp, 1333 Tcl_Obj *format, Tk_PhotoImageBlock *blockPtr)); 1334#endif 1335 1336/* 1337 * The following structure represents a particular file format for storing 1338 * images (e.g., PPM, GIF, JPEG, etc.). It provides information to allow image 1339 * files of that format to be recognized and read into a photo image. 1340 */ 1341 1342struct Tk_PhotoImageFormat { 1343 char *name; /* Name of image file format */ 1344 Tk_ImageFileMatchProc *fileMatchProc; 1345 /* Procedure to call to determine whether an 1346 * image file matches this format. */ 1347 Tk_ImageStringMatchProc *stringMatchProc; 1348 /* Procedure to call to determine whether the 1349 * data in a string matches this format. */ 1350 Tk_ImageFileReadProc *fileReadProc; 1351 /* Procedure to call to read data from an 1352 * image file into a photo image. */ 1353 Tk_ImageStringReadProc *stringReadProc; 1354 /* Procedure to call to read data from a 1355 * string into a photo image. */ 1356 Tk_ImageFileWriteProc *fileWriteProc; 1357 /* Procedure to call to write data from a 1358 * photo image to a file. */ 1359 Tk_ImageStringWriteProc *stringWriteProc; 1360 /* Procedure to call to obtain a string 1361 * representation of the data in a photo 1362 * image.*/ 1363 struct Tk_PhotoImageFormat *nextPtr; 1364 /* Next in list of all photo image formats 1365 * currently known. Filled in by Tk, not by 1366 * image format handler. */ 1367}; 1368 1369#ifdef USE_OLD_IMAGE 1370#define Tk_CreateImageType Tk_CreateOldImageType 1371#define Tk_CreatePhotoImageFormat Tk_CreateOldPhotoImageFormat 1372#endif 1373 1374/* 1375 *-------------------------------------------------------------- 1376 * 1377 * Procedure prototypes and structures used for managing styles: 1378 * 1379 *-------------------------------------------------------------- 1380 */ 1381 1382/* 1383 * Style support version tag. 1384 */ 1385 1386#define TK_STYLE_VERSION_1 0x1 1387#define TK_STYLE_VERSION TK_STYLE_VERSION_1 1388 1389/* 1390 * The following structures and prototypes are used as static templates to 1391 * declare widget elements. 1392 */ 1393 1394typedef void (Tk_GetElementSizeProc) _ANSI_ARGS_((ClientData clientData, 1395 char *recordPtr, const Tk_OptionSpec **optionsPtr, Tk_Window tkwin, 1396 int width, int height, int inner, int *widthPtr, int *heightPtr)); 1397typedef void (Tk_GetElementBoxProc) _ANSI_ARGS_((ClientData clientData, 1398 char *recordPtr, const Tk_OptionSpec **optionsPtr, Tk_Window tkwin, 1399 int x, int y, int width, int height, int inner, int *xPtr, int *yPtr, 1400 int *widthPtr, int *heightPtr)); 1401typedef int (Tk_GetElementBorderWidthProc) _ANSI_ARGS_((ClientData clientData, 1402 char *recordPtr, const Tk_OptionSpec **optionsPtr, Tk_Window tkwin)); 1403typedef void (Tk_DrawElementProc) _ANSI_ARGS_((ClientData clientData, 1404 char *recordPtr, const Tk_OptionSpec **optionsPtr, Tk_Window tkwin, 1405 Drawable d, int x, int y, int width, int height, int state)); 1406 1407typedef struct Tk_ElementOptionSpec { 1408 char *name; /* Name of the required option. */ 1409 Tk_OptionType type; /* Accepted option type. TK_OPTION_END means 1410 * any. */ 1411} Tk_ElementOptionSpec; 1412 1413typedef struct Tk_ElementSpec { 1414 int version; /* Version of the style support. */ 1415 char *name; /* Name of element. */ 1416 Tk_ElementOptionSpec *options; 1417 /* List of required options. Last one's name 1418 * must be NULL. */ 1419 Tk_GetElementSizeProc *getSize; 1420 /* Compute the external (resp. internal) size 1421 * of the element from its desired internal 1422 * (resp. external) size. */ 1423 Tk_GetElementBoxProc *getBox; 1424 /* Compute the inscribed or bounding boxes 1425 * within a given area. */ 1426 Tk_GetElementBorderWidthProc *getBorderWidth; 1427 /* Return the element's internal border width. 1428 * Mostly useful for widgets. */ 1429 Tk_DrawElementProc *draw; /* Draw the element in the given bounding 1430 * box. */ 1431} Tk_ElementSpec; 1432 1433/* 1434 * Element state flags. Can be OR'ed. 1435 */ 1436 1437#define TK_ELEMENT_STATE_ACTIVE 1<<0 1438#define TK_ELEMENT_STATE_DISABLED 1<<1 1439#define TK_ELEMENT_STATE_FOCUS 1<<2 1440#define TK_ELEMENT_STATE_PRESSED 1<<3 1441 1442/* 1443 *-------------------------------------------------------------- 1444 * 1445 * The definitions below provide backward compatibility for functions and 1446 * types related to event handling that used to be in Tk but have moved to 1447 * Tcl. 1448 * 1449 *-------------------------------------------------------------- 1450 */ 1451 1452#define TK_READABLE TCL_READABLE 1453#define TK_WRITABLE TCL_WRITABLE 1454#define TK_EXCEPTION TCL_EXCEPTION 1455 1456#define TK_DONT_WAIT TCL_DONT_WAIT 1457#define TK_X_EVENTS TCL_WINDOW_EVENTS 1458#define TK_WINDOW_EVENTS TCL_WINDOW_EVENTS 1459#define TK_FILE_EVENTS TCL_FILE_EVENTS 1460#define TK_TIMER_EVENTS TCL_TIMER_EVENTS 1461#define TK_IDLE_EVENTS TCL_IDLE_EVENTS 1462#define TK_ALL_EVENTS TCL_ALL_EVENTS 1463 1464#define Tk_IdleProc Tcl_IdleProc 1465#define Tk_FileProc Tcl_FileProc 1466#define Tk_TimerProc Tcl_TimerProc 1467#define Tk_TimerToken Tcl_TimerToken 1468 1469#define Tk_BackgroundError Tcl_BackgroundError 1470#define Tk_CancelIdleCall Tcl_CancelIdleCall 1471#define Tk_CreateFileHandler Tcl_CreateFileHandler 1472#define Tk_CreateTimerHandler Tcl_CreateTimerHandler 1473#define Tk_DeleteFileHandler Tcl_DeleteFileHandler 1474#define Tk_DeleteTimerHandler Tcl_DeleteTimerHandler 1475#define Tk_DoOneEvent Tcl_DoOneEvent 1476#define Tk_DoWhenIdle Tcl_DoWhenIdle 1477#define Tk_Sleep Tcl_Sleep 1478 1479/* Additional stuff that has moved to Tcl: */ 1480 1481#define Tk_EventuallyFree Tcl_EventuallyFree 1482#define Tk_FreeProc Tcl_FreeProc 1483#define Tk_Preserve Tcl_Preserve 1484#define Tk_Release Tcl_Release 1485 1486/* Removed Tk_Main, use macro instead */ 1487#define Tk_Main(argc, argv, proc) \ 1488 Tk_MainEx(argc, argv, proc, Tcl_CreateInterp()) 1489 1490const char * Tk_InitStubs _ANSI_ARGS_((Tcl_Interp *interp, 1491 const char *version, int exact)); 1492EXTERN const char * Tk_PkgInitStubsCheck _ANSI_ARGS_((Tcl_Interp *interp, 1493 const char *version, int exact)); 1494 1495#ifndef USE_TK_STUBS 1496 1497#define Tk_InitStubs(interp, version, exact) \ 1498 Tk_PkgInitStubsCheck(interp, version, exact) 1499 1500#endif 1501 1502#define Tk_InitImageArgs(interp, argc, argv) /**/ 1503 1504 1505/* 1506 *-------------------------------------------------------------- 1507 * 1508 * Additional procedure types defined by Tk. 1509 * 1510 *-------------------------------------------------------------- 1511 */ 1512 1513typedef int (Tk_ErrorProc) _ANSI_ARGS_((ClientData clientData, 1514 XErrorEvent *errEventPtr)); 1515typedef void (Tk_EventProc) _ANSI_ARGS_((ClientData clientData, 1516 XEvent *eventPtr)); 1517typedef int (Tk_GenericProc) _ANSI_ARGS_((ClientData clientData, 1518 XEvent *eventPtr)); 1519typedef int (Tk_ClientMessageProc) _ANSI_ARGS_((Tk_Window tkwin, 1520 XEvent *eventPtr)); 1521typedef int (Tk_GetSelProc) _ANSI_ARGS_((ClientData clientData, 1522 Tcl_Interp *interp, char *portion)); 1523typedef void (Tk_LostSelProc) _ANSI_ARGS_((ClientData clientData)); 1524typedef Tk_RestrictAction (Tk_RestrictProc) _ANSI_ARGS_(( 1525 ClientData clientData, XEvent *eventPtr)); 1526typedef int (Tk_SelectionProc) _ANSI_ARGS_((ClientData clientData, 1527 int offset, char *buffer, int maxBytes)); 1528 1529/* 1530 *-------------------------------------------------------------- 1531 * 1532 * Platform independant exported procedures and variables. 1533 * 1534 *-------------------------------------------------------------- 1535 */ 1536 1537#include "tkDecls.h" 1538 1539/* 1540 * Allow users to say that they don't want to alter their source to add extra 1541 * arguments to Tk_PhotoPutBlock() et al; DO NOT DEFINE THIS WHEN BUILDING TK. 1542 * 1543 * This goes after the inclusion of the stubbed-decls so that the declarations 1544 * of what is actually there can be correct. 1545 */ 1546 1547#ifdef USE_COMPOSITELESS_PHOTO_PUT_BLOCK 1548# ifdef Tk_PhotoPutBlock 1549# undef Tk_PhotoPutBlock 1550# endif 1551# define Tk_PhotoPutBlock Tk_PhotoPutBlock_NoComposite 1552# ifdef Tk_PhotoPutZoomedBlock 1553# undef Tk_PhotoPutZoomedBlock 1554# endif 1555# define Tk_PhotoPutZoomedBlock Tk_PhotoPutZoomedBlock_NoComposite 1556# define USE_PANIC_ON_PHOTO_ALLOC_FAILURE 1557#else /* !USE_COMPOSITELESS_PHOTO_PUT_BLOCK */ 1558# ifdef USE_PANIC_ON_PHOTO_ALLOC_FAILURE 1559# ifdef Tk_PhotoPutBlock 1560# undef Tk_PhotoPutBlock 1561# endif 1562# define Tk_PhotoPutBlock Tk_PhotoPutBlock_Panic 1563# ifdef Tk_PhotoPutZoomedBlock 1564# undef Tk_PhotoPutZoomedBlock 1565# endif 1566# define Tk_PhotoPutZoomedBlock Tk_PhotoPutZoomedBlock_Panic 1567# endif /* USE_PANIC_ON_PHOTO_ALLOC_FAILURE */ 1568#endif /* USE_COMPOSITELESS_PHOTO_PUT_BLOCK */ 1569#ifdef USE_PANIC_ON_PHOTO_ALLOC_FAILURE 1570# ifdef Tk_PhotoExpand 1571# undef Tk_PhotoExpand 1572# endif 1573# define Tk_PhotoExpand Tk_PhotoExpand_Panic 1574# ifdef Tk_PhotoSetSize 1575# undef Tk_PhotoSetSize 1576# endif 1577# define Tk_PhotoSetSize Tk_PhotoSetSize_Panic 1578#endif /* USE_PANIC_ON_PHOTO_ALLOC_FAILURE */ 1579 1580/* 1581 * Tcl commands exported by Tk: 1582 */ 1583 1584#undef TCL_STORAGE_CLASS 1585#define TCL_STORAGE_CLASS DLLIMPORT 1586 1587#endif /* RC_INVOKED */ 1588 1589/* 1590 * end block for C++ 1591 */ 1592 1593#ifdef __cplusplus 1594} 1595#endif 1596 1597#endif /* _TK */ 1598 1599/* 1600 * Local Variables: 1601 * mode: c 1602 * c-basic-offset: 4 1603 * fill-column: 78 1604 * End: 1605 */ 1606