1/* 2 * tkMenu.h -- 3 * 4 * Declarations shared among all of the files that implement menu widgets. 5 * 6 * Copyright (c) 1996-1998 by Sun Microsystems, Inc. 7 * 8 * See the file "license.terms" for information on usage and redistribution 9 * of this file, and for a DISCLAIMER OF ALL WARRANTIES. 10 * 11 * RCS: @(#) $Id: tkMenu.h,v 1.6.4.1 2003/07/15 13:59:06 vincentdarley Exp $ 12 */ 13 14#ifndef _TKMENU 15#define _TKMENU 16 17#ifndef _TK 18#include "tk.h" 19#endif 20 21#ifndef _TKINT 22#include "tkInt.h" 23#endif 24 25#ifndef _DEFAULT 26#include "default.h" 27#endif 28 29#ifdef BUILD_tk 30# undef TCL_STORAGE_CLASS 31# define TCL_STORAGE_CLASS DLLEXPORT 32#endif 33 34/* 35 * Dummy types used by the platform menu code. 36 */ 37 38typedef struct TkMenuPlatformData_ *TkMenuPlatformData; 39typedef struct TkMenuPlatformEntryData_ *TkMenuPlatformEntryData; 40 41/* 42 * Legal values for the "compound" field of TkMenuEntry and TkMenuButton records. 43 */ 44 45enum compound { 46 COMPOUND_BOTTOM, COMPOUND_CENTER, COMPOUND_LEFT, COMPOUND_NONE, 47 COMPOUND_RIGHT, COMPOUND_TOP 48}; 49 50/* 51 * One of the following data structures is kept for each entry of each 52 * menu managed by this file: 53 */ 54 55typedef struct TkMenuEntry { 56 int type; /* Type of menu entry; see below for 57 * valid types. */ 58 struct TkMenu *menuPtr; /* Menu with which this entry is associated. */ 59 Tk_OptionTable optionTable; /* Option table for this menu entry. */ 60 Tcl_Obj *labelPtr; /* Main text label displayed in entry (NULL 61 * if no label). */ 62 int labelLength; /* Number of non-NULL characters in label. */ 63 int state; /* State of button for display purposes: 64 * normal, active, or disabled. */ 65 int underline; /* Value of -underline option: specifies index 66 * of character to underline (<0 means don't 67 * underline anything). */ 68 Tcl_Obj *underlinePtr; /* Index of character to underline. */ 69 Tcl_Obj *bitmapPtr; /* Bitmap to display in menu entry, or None. 70 * If not None then label is ignored. */ 71 Tcl_Obj *imagePtr; /* Name of image to display, or 72 * NULL. If non-NULL, bitmap, text, and 73 * textVarName are ignored. */ 74 Tk_Image image; /* Image to display in menu entry, or NULL if 75 * none. */ 76 Tcl_Obj *selectImagePtr; /* Name of image to display when selected, or 77 * NULL. */ 78 Tk_Image selectImage; /* Image to display in entry when selected, 79 * or NULL if none. Ignored if image is 80 * NULL. */ 81 Tcl_Obj *accelPtr; /* Accelerator string displayed at right 82 * of menu entry. NULL means no such 83 * accelerator. Malloc'ed. */ 84 int accelLength; /* Number of non-NULL characters in 85 * accelerator. */ 86 int indicatorOn; /* True means draw indicator, false means 87 * don't draw it. This field is ignored unless 88 * the entry is a radio or check button. */ 89 /* 90 * Display attributes 91 */ 92 93 Tcl_Obj *borderPtr; /* Structure used to draw background for 94 * entry. NULL means use overall border 95 * for menu. */ 96 Tcl_Obj *fgPtr; /* Foreground color to use for entry. NULL 97 * means use foreground color from menu. */ 98 Tcl_Obj *activeBorderPtr; /* Used to draw background and border when 99 * element is active. NULL means use 100 * activeBorder from menu. */ 101 Tcl_Obj *activeFgPtr; /* Foreground color to use when entry is 102 * active. NULL means use active foreground 103 * from menu. */ 104 Tcl_Obj *indicatorFgPtr; /* Color for indicators in radio and check 105 * button entries. NULL means use indicatorFg 106 * GC from menu. */ 107 Tcl_Obj *fontPtr; /* Text font for menu entries. NULL means 108 * use overall font for menu. */ 109 int columnBreak; /* If this is 0, this item appears below 110 * the item in front of it. If this is 111 * 1, this item starts a new column. This 112 * field is always 0 for tearoff and separator 113 * entries. */ 114 int hideMargin; /* If this is 0, then the item has enough 115 * margin to accomodate a standard check mark 116 * and a default right margin. If this is 1, 117 * then the item has no such margins. and 118 * checkbuttons and radiobuttons with this set 119 * will have a rectangle drawn in the indicator 120 * around the item if the item is checked. This 121 * is useful for palette menus. This field is 122 * ignored for separators and tearoffs. */ 123 int indicatorSpace; /* The width of the indicator space for this 124 * entry. */ 125 int labelWidth; /* Number of pixels to allow for displaying 126 * labels in menu entries. */ 127 int compound; /* Value of -compound option; specifies whether 128 * the entry should show both an image and 129 * text, and, if so, how. */ 130 131 /* 132 * Information used to implement this entry's action: 133 */ 134 135 Tcl_Obj *commandPtr; /* Command to invoke when entry is invoked. 136 * Malloc'ed. */ 137 Tcl_Obj *namePtr; /* Name of variable (for check buttons and 138 * radio buttons) or menu (for cascade 139 * entries). Malloc'ed.*/ 140 Tcl_Obj *onValuePtr; /* Value to store in variable when selected 141 * (only for radio and check buttons). 142 * Malloc'ed. */ 143 Tcl_Obj *offValuePtr; /* Value to store in variable when not 144 * selected (only for check buttons). 145 * Malloc'ed. */ 146 147 /* 148 * Information used for drawing this menu entry. 149 */ 150 151 int width; /* Number of pixels occupied by entry in 152 * horizontal dimension. Not used except 153 * in menubars. The width of norma menus 154 * is dependent on the rest of the menu. */ 155 int x; /* X-coordinate of leftmost pixel in entry */ 156 int height; /* Number of pixels occupied by entry in 157 * vertical dimension, including raised 158 * border drawn around entry when active. */ 159 int y; /* Y-coordinate of topmost pixel in entry. */ 160 GC textGC; /* GC for drawing text in entry. NULL means 161 * use overall textGC for menu. */ 162 GC activeGC; /* GC for drawing text in entry when active. 163 * NULL means use overall activeGC for 164 * menu. */ 165 GC disabledGC; /* Used to produce disabled effect for entry. 166 * NULL means use overall disabledGC from 167 * menu structure. See comments for 168 * disabledFg in menu structure for more 169 * information. */ 170 GC indicatorGC; /* For drawing indicators. None means use 171 * GC from menu. */ 172 173 /* 174 * Miscellaneous fields. 175 */ 176 177 int entryFlags; /* Various flags. See below for 178 definitions. */ 179 int index; /* Need to know which index we are. This 180 * is zero-based. This is the top-left entry 181 * of the menu. */ 182 183 /* 184 * Bookeeping for master menus and cascade menus. 185 */ 186 187 struct TkMenuReferences *childMenuRefPtr; 188 /* A pointer to the hash table entry for 189 * the child menu. Stored here when the menu 190 * entry is configured so that a hash lookup 191 * is not necessary later.*/ 192 struct TkMenuEntry *nextCascadePtr; 193 /* The next cascade entry that is a parent of 194 * this entry's child cascade menu. NULL 195 * end of list, this is not a cascade entry, 196 * or the menu that this entry point to 197 * does not yet exist. */ 198 TkMenuPlatformEntryData platformEntryData; 199 /* The data for the specific type of menu. 200 * Depends on platform and menu type what 201 * kind of options are in this structure. 202 */ 203} TkMenuEntry; 204 205/* 206 * Flag values defined for menu entries: 207 * 208 * ENTRY_SELECTED: Non-zero means this is a radio or check 209 * button and that it should be drawn in 210 * the "selected" state. 211 * ENTRY_NEEDS_REDISPLAY: Non-zero means the entry should be redisplayed. 212 * ENTRY_LAST_COLUMN: Used by the drawing code. If the entry is in 213 * the last column, the space to its right needs 214 * to be filled. 215 * ENTRY_PLATFORM_FLAG1 - 4 These flags are reserved for use by the 216 * platform-dependent implementation of menus 217 * and should not be used by anything else. 218 */ 219 220#define ENTRY_SELECTED 1 221#define ENTRY_NEEDS_REDISPLAY 2 222#define ENTRY_LAST_COLUMN 4 223#define ENTRY_PLATFORM_FLAG1 (1 << 30) 224#define ENTRY_PLATFORM_FLAG2 (1 << 29) 225#define ENTRY_PLATFORM_FLAG3 (1 << 28) 226#define ENTRY_PLATFORM_FLAG4 (1 << 27) 227 228/* 229 * Types defined for MenuEntries: 230 */ 231 232#define CASCADE_ENTRY 0 233#define CHECK_BUTTON_ENTRY 1 234#define COMMAND_ENTRY 2 235#define RADIO_BUTTON_ENTRY 3 236#define SEPARATOR_ENTRY 4 237#define TEAROFF_ENTRY 5 238 239/* 240 * Menu states 241 */ 242 243EXTERN char *tkMenuStateStrings[]; 244 245#define ENTRY_ACTIVE 0 246#define ENTRY_NORMAL 1 247#define ENTRY_DISABLED 2 248 249/* 250 * A data structure of the following type is kept for each 251 * menu widget: 252 */ 253 254typedef struct TkMenu { 255 Tk_Window tkwin; /* Window that embodies the pane. NULL 256 * means that the window has been destroyed 257 * but the data structures haven't yet been 258 * cleaned up.*/ 259 Display *display; /* Display containing widget. Needed, among 260 * other things, so that resources can be 261 * freed up even after tkwin has gone away. */ 262 Tcl_Interp *interp; /* Interpreter associated with menu. */ 263 Tcl_Command widgetCmd; /* Token for menu's widget command. */ 264 TkMenuEntry **entries; /* Array of pointers to all the entries 265 * in the menu. NULL means no entries. */ 266 int numEntries; /* Number of elements in entries. */ 267 int active; /* Index of active entry. -1 means 268 * nothing active. */ 269 int menuType; /* MASTER_MENU, TEAROFF_MENU, or MENUBAR. 270 * See below for definitions. */ 271 Tcl_Obj *menuTypePtr; /* Used to control whether created tkwin 272 * is a toplevel or not. "normal", "menubar", 273 * or "toplevel" */ 274 275 /* 276 * Information used when displaying widget: 277 */ 278 279 Tcl_Obj *borderPtr; /* Structure used to draw 3-D 280 * border and background for menu. */ 281 Tcl_Obj *borderWidthPtr; /* Width of border around whole menu. */ 282 Tcl_Obj *activeBorderPtr; /* Used to draw background and border for 283 * active element (if any). */ 284 Tcl_Obj *activeBorderWidthPtr; 285 /* Width of border around active element. */ 286 Tcl_Obj *reliefPtr; /* 3-d effect: TK_RELIEF_RAISED, etc. */ 287 Tcl_Obj *fontPtr; /* Text font for menu entries. */ 288 Tcl_Obj *fgPtr; /* Foreground color for entries. */ 289 Tcl_Obj *disabledFgPtr; /* Foreground color when disabled. NULL 290 * means use normalFg with a 50% stipple 291 * instead. */ 292 Tcl_Obj *activeFgPtr; /* Foreground color for active entry. */ 293 Tcl_Obj *indicatorFgPtr; /* Color for indicators in radio and check 294 * button entries. */ 295 Pixmap gray; /* Bitmap for drawing disabled entries in 296 * a stippled fashion. None means not 297 * allocated yet. */ 298 GC textGC; /* GC for drawing text and other features 299 * of menu entries. */ 300 GC disabledGC; /* Used to produce disabled effect. If 301 * disabledFg isn't NULL, this GC is used to 302 * draw text and icons for disabled entries. 303 * Otherwise text and icons are drawn with 304 * normalGC and this GC is used to stipple 305 * background across them. */ 306 GC activeGC; /* GC for drawing active entry. */ 307 GC indicatorGC; /* For drawing indicators. */ 308 GC disabledImageGC; /* Used for drawing disabled images. They 309 * have to be stippled. This is created 310 * when the image is about to be drawn the 311 * first time. */ 312 313 /* 314 * Information about geometry of menu. 315 */ 316 317 int totalWidth; /* Width of entire menu */ 318 int totalHeight; /* Height of entire menu */ 319 320 /* 321 * Miscellaneous information: 322 */ 323 324 int tearoff; /* 1 means this menu can be torn off. On some 325 * platforms, the user can drag an outline 326 * of the menu by just dragging outside of 327 * the menu, and the tearoff is created where 328 * the mouse is released. On others, an 329 * indicator (such as a dashed stripe) is 330 * drawn, and when the menu is selected, the 331 * tearoff is created. */ 332 Tcl_Obj *titlePtr; /* The title to use when this menu is torn 333 * off. If this is NULL, a default scheme 334 * will be used to generate a title for 335 * tearoff. */ 336 Tcl_Obj *tearoffCommandPtr; /* If non-NULL, points to a command to 337 * run whenever the menu is torn-off. */ 338 Tcl_Obj *takeFocusPtr; /* Value of -takefocus option; not used in 339 * the C code, but used by keyboard traversal 340 * scripts. Malloc'ed, but may be NULL. */ 341 Tcl_Obj *cursorPtr; /* Current cursor for window, or None. */ 342 Tcl_Obj *postCommandPtr; /* Used to detect cycles in cascade hierarchy 343 * trees when preprocessing postcommands 344 * on some platforms. See PostMenu for 345 * more details. */ 346 int postCommandGeneration; /* Need to do pre-invocation post command 347 * traversal */ 348 int menuFlags; /* Flags for use by X; see below for 349 definition */ 350 TkMenuEntry *postedCascade; /* Points to menu entry for cascaded submenu 351 * that is currently posted or NULL if no 352 * submenu posted. */ 353 struct TkMenu *nextInstancePtr; 354 /* The next instance of this menu in the 355 * chain. */ 356 struct TkMenu *masterMenuPtr; 357 /* A pointer to the original menu for this 358 * clone chain. Points back to this structure 359 * if this menu is a master menu. */ 360 struct TkMenuOptionTables *optionTablesPtr; 361 /* A pointer to the collection of option tables 362 * that work with menus and menu entries. */ 363 Tk_Window parentTopLevelPtr;/* If this menu is a menubar, this is the 364 * toplevel that owns the menu. Only applicable 365 * for menubar clones. 366 */ 367 struct TkMenuReferences *menuRefPtr; 368 /* Each menu is hashed into a table with the 369 * name of the menu's window as the key. 370 * The information in this hash table includes 371 * a pointer to the menu (so that cascades 372 * can find this menu), a pointer to the 373 * list of toplevel widgets that have this 374 * menu as its menubar, and a list of menu 375 * entries that have this menu specified 376 * as a cascade. */ 377 TkMenuPlatformData platformData; 378 /* The data for the specific type of menu. 379 * Depends on platform and menu type what 380 * kind of options are in this structure. 381 */ 382 Tk_OptionSpec *extensionPtr; 383 /* Needed by the configuration package for 384 * this widget to be extended. */ 385 Tk_SavedOptions *errorStructPtr; 386 /* We actually have to allocate these because 387 * multiple menus get changed during one 388 * ConfigureMenu call. */ 389} TkMenu; 390 391/* 392 * When the toplevel configure -menu command is executed, the menu may not 393 * exist yet. We need to keep a linked list of windows that reference 394 * a particular menu. 395 */ 396 397typedef struct TkMenuTopLevelList { 398 struct TkMenuTopLevelList *nextPtr; 399 /* The next window in the list */ 400 Tk_Window tkwin; /* The window that has this menu as its 401 * menubar. */ 402} TkMenuTopLevelList; 403 404/* 405 * The following structure is used to keep track of things which 406 * reference a menu. It is created when: 407 * - a menu is created. 408 * - a cascade entry is added to a menu with a non-null name 409 * - the "-menu" configuration option is used on a toplevel widget 410 * with a non-null parameter. 411 * 412 * One of these three fields must be non-NULL, but any of the fields may 413 * be NULL. This structure makes it easy to determine whether or not 414 * anything like recalculating platform data or geometry is necessary 415 * when one of the three actions above is performed. 416 */ 417 418typedef struct TkMenuReferences { 419 struct TkMenu *menuPtr; /* The menu data structure. This is NULL 420 * if the menu does not exist. */ 421 TkMenuTopLevelList *topLevelListPtr; 422 /* First in the list of all toplevels that 423 * have this menu as its menubar. NULL if no 424 * toplevel widgets have this menu as its 425 * menubar. */ 426 TkMenuEntry *parentEntryPtr;/* First in the list of all cascade menu 427 * entries that have this menu as their child. 428 * NULL means no cascade entries. */ 429 Tcl_HashEntry *hashEntryPtr;/* This is needed because the pathname of the 430 * window (which is what we hash on) may not 431 * be around when we are deleting. 432 */ 433} TkMenuReferences; 434 435/* 436 * This structure contains all of the option tables that are needed 437 * by menus. 438 */ 439 440typedef struct TkMenuOptionTables { 441 Tk_OptionTable menuOptionTable; /* The option table for menus. */ 442 Tk_OptionTable entryOptionTables[6];/* The tables for menu entries. */ 443} TkMenuOptionTables; 444 445/* 446 * Flag bits for menus: 447 * 448 * REDRAW_PENDING: Non-zero means a DoWhenIdle handler 449 * has already been queued to redraw 450 * this window. 451 * RESIZE_PENDING: Non-zero means a call to ComputeMenuGeometry 452 * has already been scheduled. 453 * MENU_DELETION_PENDING Non-zero means that we are currently destroying 454 * this menu's internal structures. This is useful 455 * when we are in the middle of cleaning 456 * this master menu's chain of menus up when 457 * TkDestroyMenu was called again on this 458 * menu (via a destroy binding or somesuch). 459 * MENU_WIN_DESTRUCTION_PENDING Non-zero means we are in the middle of 460 * destroying this menu's Tk_Window. 461 * MENU_PLATFORM_FLAG1... Reserved for use by the platform-specific menu 462 * code. 463 */ 464 465#define REDRAW_PENDING 1 466#define RESIZE_PENDING 2 467#define MENU_DELETION_PENDING 4 468#define MENU_WIN_DESTRUCTION_PENDING 8 469#define MENU_PLATFORM_FLAG1 (1 << 30) 470#define MENU_PLATFORM_FLAG2 (1 << 29) 471#define MENU_PLATFORM_FLAG3 (1 << 28) 472 473/* 474 * Each menu created by the user is a MASTER_MENU. When a menu is torn off, 475 * a TEAROFF_MENU instance is created. When a menu is assigned to a toplevel 476 * as a menu bar, a MENUBAR instance is created. All instances have the same 477 * configuration information. If the master instance is deleted, all instances 478 * are deleted. If one of the other instances is deleted, only that instance 479 * is deleted. 480 */ 481 482#define UNKNOWN_TYPE -1 483#define MASTER_MENU 0 484#define TEAROFF_MENU 1 485#define MENUBAR 2 486 487/* 488 * Various geometry definitions: 489 */ 490 491#define CASCADE_ARROW_HEIGHT 10 492#define CASCADE_ARROW_WIDTH 8 493#define DECORATION_BORDER_WIDTH 2 494 495/* 496 * Menu-related procedures that are shared among Tk modules but not exported 497 * to the outside world: 498 */ 499 500EXTERN int TkActivateMenuEntry _ANSI_ARGS_((TkMenu *menuPtr, 501 int index)); 502EXTERN void TkBindMenu _ANSI_ARGS_(( 503 Tk_Window tkwin, TkMenu *menuPtr)); 504EXTERN TkMenuReferences * 505 TkCreateMenuReferences _ANSI_ARGS_((Tcl_Interp *interp, 506 char *name)); 507EXTERN void TkDestroyMenu _ANSI_ARGS_((TkMenu *menuPtr)); 508EXTERN void TkEventuallyRecomputeMenu _ANSI_ARGS_(( 509 TkMenu *menuPtr)); 510EXTERN void TkEventuallyRedrawMenu _ANSI_ARGS_(( 511 TkMenu *menuPtr, TkMenuEntry *mePtr)); 512EXTERN TkMenuReferences * 513 TkFindMenuReferences _ANSI_ARGS_((Tcl_Interp *interp, 514 char *name)); 515EXTERN TkMenuReferences * 516 TkFindMenuReferencesObj _ANSI_ARGS_(( 517 Tcl_Interp *interp, Tcl_Obj *namePtr)); 518EXTERN int TkFreeMenuReferences _ANSI_ARGS_(( 519 TkMenuReferences *menuRefPtr)); 520EXTERN Tcl_HashTable * TkGetMenuHashTable _ANSI_ARGS_((Tcl_Interp *interp)); 521EXTERN int TkGetMenuIndex _ANSI_ARGS_((Tcl_Interp *interp, 522 TkMenu *menuPtr, Tcl_Obj *objPtr, int lastOK, 523 int *indexPtr)); 524EXTERN void TkMenuInitializeDrawingFields _ANSI_ARGS_(( 525 TkMenu *menuPtr)); 526EXTERN void TkMenuInitializeEntryDrawingFields _ANSI_ARGS_(( 527 TkMenuEntry *mePtr)); 528EXTERN int TkInvokeMenu _ANSI_ARGS_((Tcl_Interp *interp, 529 TkMenu *menuPtr, int index)); 530EXTERN void TkMenuConfigureDrawOptions _ANSI_ARGS_(( 531 TkMenu *menuPtr)); 532EXTERN int TkMenuConfigureEntryDrawOptions _ANSI_ARGS_(( 533 TkMenuEntry *mePtr, int index)); 534EXTERN void TkMenuFreeDrawOptions _ANSI_ARGS_((TkMenu *menuPtr)); 535EXTERN void TkMenuEntryFreeDrawOptions _ANSI_ARGS_(( 536 TkMenuEntry *mePtr)); 537EXTERN void TkMenuEventProc _ANSI_ARGS_((ClientData clientData, 538 XEvent *eventPtr)); 539EXTERN void TkMenuImageProc _ANSI_ARGS_(( 540 ClientData clientData, int x, int y, int width, 541 int height, int imgWidth, int imgHeight)); 542EXTERN void TkMenuInit _ANSI_ARGS_((void)); 543EXTERN void TkMenuSelectImageProc _ANSI_ARGS_ 544 ((ClientData clientData, int x, int y, 545 int width, int height, int imgWidth, 546 int imgHeight)); 547EXTERN Tcl_Obj * TkNewMenuName _ANSI_ARGS_((Tcl_Interp *interp, 548 Tcl_Obj *parentNamePtr, TkMenu *menuPtr)); 549EXTERN int TkPostCommand _ANSI_ARGS_((TkMenu *menuPtr)); 550EXTERN int TkPostSubmenu _ANSI_ARGS_((Tcl_Interp *interp, 551 TkMenu *menuPtr, TkMenuEntry *mePtr)); 552EXTERN int TkPostTearoffMenu _ANSI_ARGS_((Tcl_Interp *interp, 553 TkMenu *menuPtr, int x, int y)); 554EXTERN int TkPreprocessMenu _ANSI_ARGS_((TkMenu *menuPtr)); 555EXTERN void TkRecomputeMenu _ANSI_ARGS_((TkMenu *menuPtr)); 556 557/* 558 * These routines are the platform-dependent routines called by the 559 * common code. 560 */ 561 562EXTERN void TkpComputeMenubarGeometry _ANSI_ARGS_(( 563 TkMenu *menuPtr)); 564EXTERN void TkpComputeStandardMenuGeometry _ANSI_ARGS_ 565 ((TkMenu *menuPtr)); 566EXTERN int TkpConfigureMenuEntry 567 _ANSI_ARGS_((TkMenuEntry *mePtr)); 568EXTERN void TkpDestroyMenu _ANSI_ARGS_((TkMenu *menuPtr)); 569EXTERN void TkpDestroyMenuEntry 570 _ANSI_ARGS_((TkMenuEntry *mEntryPtr)); 571EXTERN void TkpDrawMenuEntry _ANSI_ARGS_((TkMenuEntry *mePtr, 572 Drawable d, Tk_Font tkfont, 573 CONST Tk_FontMetrics *menuMetricsPtr, int x, 574 int y, int width, int height, int strictMotif, 575 int drawArrow)); 576EXTERN void TkpMenuInit _ANSI_ARGS_((void)); 577EXTERN int TkpMenuNewEntry _ANSI_ARGS_((TkMenuEntry *mePtr)); 578EXTERN int TkpNewMenu _ANSI_ARGS_((TkMenu *menuPtr)); 579EXTERN int TkpPostMenu _ANSI_ARGS_((Tcl_Interp *interp, 580 TkMenu *menuPtr, int x, int y)); 581EXTERN void TkpSetWindowMenuBar _ANSI_ARGS_((Tk_Window tkwin, 582 TkMenu *menuPtr)); 583 584# undef TCL_STORAGE_CLASS 585# define TCL_STORAGE_CLASS DLLIMPORT 586 587#endif /* _TKMENU */ 588 589