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