![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkmenu.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Micropolis - Activity] / micropolis / src / tk|
Return to tkmenu.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 ! root 1: /* ! 2: * tkMenu.c -- ! 3: * ! 4: * This module implements menus for the Tk toolkit. The menus ! 5: * support normal button entries, plus check buttons, radio ! 6: * buttons, iconic forms of all of the above, and separator ! 7: * entries. ! 8: * ! 9: * Copyright 1990-1992 Regents of the University of California. ! 10: * Permission to use, copy, modify, and distribute this ! 11: * software and its documentation for any purpose and without ! 12: * fee is hereby granted, provided that the above copyright ! 13: * notice appear in all copies. The University of California ! 14: * makes no representations about the suitability of this ! 15: * software for any purpose. It is provided "as is" without ! 16: * express or implied warranty. ! 17: */ ! 18: ! 19: #ifndef lint ! 20: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkMenu.c,v 1.37 92/08/24 09:24:04 ouster Exp $ SPRITE (Berkeley)"; ! 21: #endif ! 22: ! 23: #include "tkconfig.h" ! 24: #include "default.h" ! 25: #include "tkint.h" ! 26: ! 27: /* ! 28: * One of the following data structures is kept for each entry of each ! 29: * menu managed by this file: ! 30: */ ! 31: ! 32: typedef struct MenuEntry { ! 33: int type; /* Type of menu entry; see below for ! 34: * valid types. */ ! 35: struct Menu *menuPtr; /* Menu with which this entry is associated. */ ! 36: char *label; /* Main text label displayed in entry (NULL ! 37: * if no label). Malloc'ed. */ ! 38: int labelLength; /* Number of non-NULL characters in label. */ ! 39: int underline; /* Index of character to underline. */ ! 40: Pixmap bitmap; /* Bitmap to display in menu entry, or None. ! 41: * If not None then label is ignored. */ ! 42: char *accel; /* Accelerator string displayed at right ! 43: * of menu entry. NULL means no such ! 44: * accelerator. Malloc'ed. */ ! 45: int accelLength; /* Number of non-NULL characters in ! 46: * accelerator. */ ! 47: ! 48: /* ! 49: * Information related to displaying entry: ! 50: */ ! 51: ! 52: Tk_Uid state; /* State of button for display purposes: ! 53: * normal, active, or disabled. */ ! 54: int height; /* Number of pixels occupied by entry in ! 55: * vertical dimension. */ ! 56: int y; /* Y-coordinate of topmost pixel in entry. */ ! 57: int selectorDiameter; /* Size of selector display, in pixels. */ ! 58: Tk_3DBorder border; /* Structure used to draw background for ! 59: * entry. NULL means use overall border ! 60: * for menu. */ ! 61: Tk_3DBorder activeBorder; /* Used to draw background and border when ! 62: * element is active. NULL means use ! 63: * activeBorder from menu. */ ! 64: XFontStruct *fontPtr; /* Text font for menu entries. NULL means ! 65: * use overall font for menu. */ ! 66: GC textGC; /* GC for drawing text in entry. NULL means ! 67: * use overall textGC for menu. */ ! 68: GC activeGC; /* GC for drawing text in entry when active. ! 69: * NULL means use overall activeGC for ! 70: * menu. */ ! 71: GC disabledGC; /* Used to produce disabled effect for entry. ! 72: * NULL means use overall disabledGC from ! 73: * menu structure. See comments for ! 74: * disabledFg in menu structure for more ! 75: * information. */ ! 76: ! 77: /* ! 78: * Information used to implement this entry's action: ! 79: */ ! 80: ! 81: char *command; /* Command to invoke when entry is invoked. ! 82: * Malloc'ed. */ ! 83: char *name; /* Name of variable (for check buttons and ! 84: * radio buttons) or menu (for cascade ! 85: * entries). Malloc'ed.*/ ! 86: char *onValue; /* Value to store in variable when selected ! 87: * (only for radio and check buttons). ! 88: * Malloc'ed. */ ! 89: char *offValue; /* Value to store in variable when not ! 90: * selected (only for check buttons). ! 91: * Malloc'ed. */ ! 92: ! 93: /* ! 94: * Miscellaneous information: ! 95: */ ! 96: ! 97: int flags; /* Various flags. See below for definitions. */ ! 98: } MenuEntry; ! 99: ! 100: /* ! 101: * Flag values defined for menu entries: ! 102: * ! 103: * ENTRY_SELECTED: Non-zero means this is a radio or check ! 104: * button and that it should be drawn in ! 105: * the "selected" state. ! 106: * ENTRY_NEEDS_REDISPLAY: Non-zero means the entry should be redisplayed. ! 107: */ ! 108: ! 109: #define ENTRY_SELECTED 1 ! 110: #define ENTRY_NEEDS_REDISPLAY 4 ! 111: ! 112: /* ! 113: * Types defined for MenuEntries: ! 114: */ ! 115: ! 116: #define COMMAND_ENTRY 0 ! 117: #define SEPARATOR_ENTRY 1 ! 118: #define CHECK_BUTTON_ENTRY 2 ! 119: #define RADIO_BUTTON_ENTRY 3 ! 120: #define CASCADE_ENTRY 4 ! 121: ! 122: /* ! 123: * Mask bits for above types: ! 124: */ ! 125: ! 126: #define COMMAND_MASK TK_CONFIG_USER_BIT ! 127: #define SEPARATOR_MASK (TK_CONFIG_USER_BIT << 1) ! 128: #define CHECK_BUTTON_MASK (TK_CONFIG_USER_BIT << 2) ! 129: #define RADIO_BUTTON_MASK (TK_CONFIG_USER_BIT << 3) ! 130: #define CASCADE_MASK (TK_CONFIG_USER_BIT << 4) ! 131: #define ALL_MASK (COMMAND_MASK | SEPARATOR_MASK \ ! 132: | CHECK_BUTTON_MASK | RADIO_BUTTON_MASK | CASCADE_MASK) ! 133: ! 134: /* ! 135: * Configuration specs for individual menu entries: ! 136: */ ! 137: ! 138: static Tk_ConfigSpec entryConfigSpecs[] = { ! 139: {TK_CONFIG_BORDER, "-activebackground", (char *) NULL, (char *) NULL, ! 140: DEF_MENU_ENTRY_ACTIVE_BG, Tk_Offset(MenuEntry, activeBorder), ! 141: COMMAND_MASK|CHECK_BUTTON_MASK|RADIO_BUTTON_MASK|CASCADE_MASK ! 142: |TK_CONFIG_NULL_OK}, ! 143: {TK_CONFIG_STRING, "-accelerator", (char *) NULL, (char *) NULL, ! 144: DEF_MENU_ENTRY_ACCELERATOR, Tk_Offset(MenuEntry, accel), ! 145: COMMAND_MASK|CHECK_BUTTON_MASK|RADIO_BUTTON_MASK|CASCADE_MASK}, ! 146: {TK_CONFIG_BORDER, "-background", (char *) NULL, (char *) NULL, ! 147: DEF_MENU_ENTRY_BG, Tk_Offset(MenuEntry, border), ! 148: COMMAND_MASK|CHECK_BUTTON_MASK|RADIO_BUTTON_MASK|CASCADE_MASK ! 149: |TK_CONFIG_NULL_OK}, ! 150: #if defined(USE_XPM3) ! 151: {TK_CONFIG_PIXMAP, "-bitmap", (char *) NULL, (char *) NULL, ! 152: DEF_MENU_ENTRY_BITMAP, Tk_Offset(MenuEntry, bitmap), ! 153: COMMAND_MASK|CHECK_BUTTON_MASK|RADIO_BUTTON_MASK|CASCADE_MASK ! 154: |TK_CONFIG_NULL_OK}, ! 155: #else ! 156: {TK_CONFIG_BITMAP, "-bitmap", (char *) NULL, (char *) NULL, ! 157: DEF_MENU_ENTRY_BITMAP, Tk_Offset(MenuEntry, bitmap), ! 158: COMMAND_MASK|CHECK_BUTTON_MASK|RADIO_BUTTON_MASK|CASCADE_MASK ! 159: |TK_CONFIG_NULL_OK}, ! 160: #endif ! 161: {TK_CONFIG_STRING, "-command", (char *) NULL, (char *) NULL, ! 162: DEF_MENU_ENTRY_COMMAND, Tk_Offset(MenuEntry, command), ! 163: COMMAND_MASK|CHECK_BUTTON_MASK|RADIO_BUTTON_MASK|CASCADE_MASK}, ! 164: {TK_CONFIG_FONT, "-font", (char *) NULL, (char *) NULL, ! 165: DEF_MENU_ENTRY_FONT, Tk_Offset(MenuEntry, fontPtr), ! 166: COMMAND_MASK|CHECK_BUTTON_MASK|RADIO_BUTTON_MASK|CASCADE_MASK ! 167: |TK_CONFIG_NULL_OK}, ! 168: {TK_CONFIG_STRING, "-label", (char *) NULL, (char *) NULL, ! 169: DEF_MENU_ENTRY_LABEL, Tk_Offset(MenuEntry, label), ! 170: COMMAND_MASK|CHECK_BUTTON_MASK|RADIO_BUTTON_MASK|CASCADE_MASK}, ! 171: {TK_CONFIG_STRING, "-menu", (char *) NULL, (char *) NULL, ! 172: DEF_MENU_ENTRY_MENU, Tk_Offset(MenuEntry, name), CASCADE_MASK}, ! 173: {TK_CONFIG_STRING, "-offvalue", (char *) NULL, (char *) NULL, ! 174: DEF_MENU_ENTRY_OFF_VALUE, Tk_Offset(MenuEntry, offValue), ! 175: CHECK_BUTTON_MASK}, ! 176: {TK_CONFIG_UID, "-state", (char *) NULL, (char *) NULL, ! 177: DEF_MENU_ENTRY_STATE, Tk_Offset(MenuEntry, state), ! 178: COMMAND_MASK|CHECK_BUTTON_MASK|RADIO_BUTTON_MASK|CASCADE_MASK ! 179: |TK_CONFIG_DONT_SET_DEFAULT}, ! 180: {TK_CONFIG_STRING, "-onvalue", (char *) NULL, (char *) NULL, ! 181: DEF_MENU_ENTRY_ON_VALUE, Tk_Offset(MenuEntry, onValue), ! 182: CHECK_BUTTON_MASK}, ! 183: {TK_CONFIG_STRING, "-value", (char *) NULL, (char *) NULL, ! 184: DEF_MENU_ENTRY_VALUE, Tk_Offset(MenuEntry, onValue), ! 185: RADIO_BUTTON_MASK}, ! 186: {TK_CONFIG_STRING, "-variable", (char *) NULL, (char *) NULL, ! 187: DEF_MENU_ENTRY_CHECK_VARIABLE, Tk_Offset(MenuEntry, name), ! 188: CHECK_BUTTON_MASK}, ! 189: {TK_CONFIG_STRING, "-variable", (char *) NULL, (char *) NULL, ! 190: DEF_MENU_ENTRY_RADIO_VARIABLE, Tk_Offset(MenuEntry, name), ! 191: RADIO_BUTTON_MASK}, ! 192: {TK_CONFIG_INT, "-underline", (char *) NULL, (char *) NULL, ! 193: DEF_MENU_ENTRY_UNDERLINE, Tk_Offset(MenuEntry, underline), ! 194: COMMAND_MASK|CHECK_BUTTON_MASK|RADIO_BUTTON_MASK|CASCADE_MASK ! 195: |TK_CONFIG_DONT_SET_DEFAULT}, ! 196: {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL, ! 197: (char *) NULL, 0, 0} ! 198: }; ! 199: ! 200: /* ! 201: * A data structure of the following type is kept for each ! 202: * menu managed by this file: ! 203: */ ! 204: ! 205: typedef struct Menu { ! 206: Tk_Window tkwin; /* Window that embodies the pane. NULL ! 207: * means that the window has been destroyed ! 208: * but the data structures haven't yet been ! 209: * cleaned up.*/ ! 210: Tcl_Interp *interp; /* Interpreter associated with menu. */ ! 211: MenuEntry **entries; /* Array of pointers to all the entries ! 212: * in the menu. NULL means no entries. */ ! 213: int numEntries; /* Number of elements in entries. */ ! 214: int active; /* Index of active entry. -1 means ! 215: * nothing active. */ ! 216: Tk_Uid group; /* Used to allow event sharing between ! 217: * related menus and menu buttons. */ ! 218: ! 219: /* ! 220: * Information used when displaying widget: ! 221: */ ! 222: ! 223: Tk_3DBorder border; /* Structure used to draw 3-D ! 224: * border and background for menu. */ ! 225: int borderWidth; /* Width of border around whole menu. */ ! 226: Tk_3DBorder activeBorder; /* Used to draw background and border for ! 227: * active element (if any). */ ! 228: int activeBorderWidth; /* Width of border around active element. */ ! 229: XFontStruct *fontPtr; /* Text font for menu entries. */ ! 230: XColor *fg; /* Foreground color for entries. */ ! 231: GC textGC; /* GC for drawing text and other features ! 232: * of menu entries. */ ! 233: XColor *disabledFg; /* Foreground color when disabled. NULL ! 234: * means use normalFg with a 50% stipple ! 235: * instead. */ ! 236: Pixmap gray; /* Bitmap for drawing disabled entries in ! 237: * a stippled fashion. None means not ! 238: * allocated yet. */ ! 239: GC disabledGC; /* Used to produce disabled effect. If ! 240: * disabledFg isn't NULL, this GC is used to ! 241: * draw text and icons for disabled entries. ! 242: * Otherwise text and icons are drawn with ! 243: * normalGC and this GC is used to stipple ! 244: * background across them. */ ! 245: XColor *activeFg; /* Foreground color for active entry. */ ! 246: GC activeGC; /* GC for drawing active entry. */ ! 247: XColor *selectorFg; /* Color for selectors in radio and check ! 248: * button entries. */ ! 249: GC selectorGC; /* For drawing selectors. */ ! 250: int selectorSpace; /* Number of pixels to allow for displaying ! 251: * selectors in menu entries (includes extra ! 252: * space around selector). */ ! 253: int labelWidth; /* Number of pixels to allow for displaying ! 254: * labels in menu entries. */ ! 255: ! 256: /* ! 257: * Miscellaneous information: ! 258: */ ! 259: ! 260: Cursor cursor; /* Current cursor for window, or None. */ ! 261: MenuEntry *postedCascade; /* Points to menu entry for cascaded ! 262: * submenu that is currently posted, or ! 263: * NULL if no submenu posted. */ ! 264: int flags; /* Various flags; see below for ! 265: * definitions. */ ! 266: } Menu; ! 267: ! 268: /* ! 269: * Flag bits for menus: ! 270: * ! 271: * REDRAW_PENDING: Non-zero means a DoWhenIdle handler ! 272: * has already been queued to redraw ! 273: * this window. ! 274: * RESIZE_PENDING: Non-zero means a call to ComputeMenuGeometry ! 275: * has already been scheduled. ! 276: */ ! 277: ! 278: #define REDRAW_PENDING 1 ! 279: #define RESIZE_PENDING 2 ! 280: ! 281: /* ! 282: * Configuration specs valid for the menu as a whole: ! 283: */ ! 284: ! 285: static Tk_ConfigSpec configSpecs[] = { ! 286: {TK_CONFIG_BORDER, "-activebackground", "activeBackground", "Foreground", ! 287: DEF_MENU_ACTIVE_BG_COLOR, Tk_Offset(Menu, activeBorder), ! 288: TK_CONFIG_COLOR_ONLY}, ! 289: {TK_CONFIG_BORDER, "-activebackground", "activeBackground", "Foreground", ! 290: DEF_MENU_ACTIVE_BG_MONO, Tk_Offset(Menu, activeBorder), ! 291: TK_CONFIG_MONO_ONLY}, ! 292: {TK_CONFIG_PIXELS, "-activeborderwidth", "activeBorderWidth", "BorderWidth", ! 293: DEF_MENU_ACTIVE_BORDER_WIDTH, Tk_Offset(Menu, activeBorderWidth), 0}, ! 294: {TK_CONFIG_COLOR, "-activeforeground", "activeForeground", "Background", ! 295: DEF_MENU_ACTIVE_FG_COLOR, Tk_Offset(Menu, activeFg), ! 296: TK_CONFIG_COLOR_ONLY}, ! 297: {TK_CONFIG_COLOR, "-activeforeground", "activeForeground", "Background", ! 298: DEF_MENU_ACTIVE_FG_MONO, Tk_Offset(Menu, activeFg), ! 299: TK_CONFIG_MONO_ONLY}, ! 300: {TK_CONFIG_BORDER, "-background", "background", "Background", ! 301: DEF_MENU_BG_COLOR, Tk_Offset(Menu, border), TK_CONFIG_COLOR_ONLY}, ! 302: {TK_CONFIG_BORDER, "-background", "background", "Background", ! 303: DEF_MENU_BG_MONO, Tk_Offset(Menu, border), TK_CONFIG_MONO_ONLY}, ! 304: {TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL, ! 305: (char *) NULL, 0, 0}, ! 306: {TK_CONFIG_SYNONYM, "-bg", "background", (char *) NULL, ! 307: (char *) NULL, 0, 0}, ! 308: {TK_CONFIG_PIXELS, "-borderwidth", "borderWidth", "BorderWidth", ! 309: DEF_MENU_BORDER_WIDTH, Tk_Offset(Menu, borderWidth), 0}, ! 310: {TK_CONFIG_ACTIVE_CURSOR, "-cursor", "cursor", "Cursor", ! 311: DEF_MENU_CURSOR, Tk_Offset(Menu, cursor), TK_CONFIG_NULL_OK}, ! 312: {TK_CONFIG_COLOR, "-disabledforeground", "disabledForeground", ! 313: "DisabledForeground", DEF_MENU_DISABLED_FG_COLOR, ! 314: Tk_Offset(Menu, disabledFg), TK_CONFIG_COLOR_ONLY|TK_CONFIG_NULL_OK}, ! 315: {TK_CONFIG_COLOR, "-disabledforeground", "disabledForeground", ! 316: "DisabledForeground", DEF_MENU_DISABLED_FG_MONO, ! 317: Tk_Offset(Menu, disabledFg), TK_CONFIG_MONO_ONLY|TK_CONFIG_NULL_OK}, ! 318: {TK_CONFIG_SYNONYM, "-fg", "foreground", (char *) NULL, ! 319: (char *) NULL, 0, 0}, ! 320: {TK_CONFIG_FONT, "-font", "font", "Font", ! 321: DEF_MENU_FONT, Tk_Offset(Menu, fontPtr), 0}, ! 322: {TK_CONFIG_COLOR, "-foreground", "foreground", "Foreground", ! 323: DEF_MENU_FG, Tk_Offset(Menu, fg), 0}, ! 324: {TK_CONFIG_COLOR, "-selector", "selector", "Foreground", ! 325: DEF_MENU_SELECTOR_COLOR, Tk_Offset(Menu, selectorFg), ! 326: TK_CONFIG_COLOR_ONLY}, ! 327: {TK_CONFIG_COLOR, "-selector", "selector", "Foreground", ! 328: DEF_MENU_SELECTOR_MONO, Tk_Offset(Menu, selectorFg), ! 329: TK_CONFIG_MONO_ONLY}, ! 330: {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL, ! 331: (char *) NULL, 0, 0} ! 332: }; ! 333: ! 334: /* ! 335: * Forward declarations for procedures defined later in this file: ! 336: */ ! 337: ! 338: static int ActivateMenuEntry _ANSI_ARGS_((Menu *menuPtr, ! 339: int index)); ! 340: static void ComputeMenuGeometry _ANSI_ARGS_(( ! 341: ClientData clientData)); ! 342: static int ConfigureMenu _ANSI_ARGS_((Tcl_Interp *interp, ! 343: Menu *menuPtr, int argc, char **argv, ! 344: int flags)); ! 345: static int ConfigureMenuEntry _ANSI_ARGS_((Tcl_Interp *interp, ! 346: Menu *menuPtr, MenuEntry *mePtr, int index, ! 347: int argc, char **argv, int flags)); ! 348: static void DestroyMenu _ANSI_ARGS_((ClientData clientData)); ! 349: static void DestroyMenuEntry _ANSI_ARGS_((ClientData clientData)); ! 350: static void DisplayMenu _ANSI_ARGS_((ClientData clientData)); ! 351: static void EventuallyRedrawMenu _ANSI_ARGS_((Menu *menuPtr, ! 352: int index)); ! 353: static int GetMenuIndex _ANSI_ARGS_((Tcl_Interp *interp, ! 354: Menu *menuPtr, char *string, int *indexPtr)); ! 355: static void MenuEventProc _ANSI_ARGS_((ClientData clientData, ! 356: XEvent *eventPtr)); ! 357: static char * MenuVarProc _ANSI_ARGS_((ClientData clientData, ! 358: Tcl_Interp *interp, char *name1, char *name2, ! 359: int flags)); ! 360: static int MenuWidgetCmd _ANSI_ARGS_((ClientData clientData, ! 361: Tcl_Interp *interp, int argc, char **argv)); ! 362: static int PostSubmenu _ANSI_ARGS_((Tcl_Interp *interp, ! 363: Menu *menuPtr, MenuEntry *mePtr)); ! 364: ! 365: /* ! 366: *-------------------------------------------------------------- ! 367: * ! 368: * Tk_MenuCmd -- ! 369: * ! 370: * This procedure is invoked to process the "menu" Tcl ! 371: * command. See the user documentation for details on ! 372: * what it does. ! 373: * ! 374: * Results: ! 375: * A standard Tcl result. ! 376: * ! 377: * Side effects: ! 378: * See the user documentation. ! 379: * ! 380: *-------------------------------------------------------------- ! 381: */ ! 382: ! 383: int ! 384: Tk_MenuCmd(clientData, interp, argc, argv) ! 385: ClientData clientData; /* Main window associated with ! 386: * interpreter. */ ! 387: Tcl_Interp *interp; /* Current interpreter. */ ! 388: int argc; /* Number of arguments. */ ! 389: char **argv; /* Argument strings. */ ! 390: { ! 391: Tk_Window tkwin = (Tk_Window) clientData; ! 392: Tk_Window new; ! 393: register Menu *menuPtr; ! 394: XSetWindowAttributes atts; ! 395: ! 396: if (argc < 2) { ! 397: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 398: argv[0], " pathName ?options?\"", (char *) NULL); ! 399: return TCL_ERROR; ! 400: } ! 401: ! 402: /* ! 403: * Create the new window. Set override-redirect so the window ! 404: * manager won't add a border or argue about placement, and set ! 405: * save-under so that the window can pop up and down without a ! 406: * lot of re-drawing. ! 407: */ ! 408: ! 409: new = Tk_CreateWindowFromPath(interp, tkwin, argv[1], ""); ! 410: if (new == NULL) { ! 411: return TCL_ERROR; ! 412: } ! 413: atts.override_redirect = True; ! 414: atts.save_under = True; ! 415: Tk_ChangeWindowAttributes(new, CWOverrideRedirect|CWSaveUnder, &atts); ! 416: ! 417: /* ! 418: * Initialize the data structure for the menu. ! 419: */ ! 420: ! 421: menuPtr = (Menu *) ckalloc(sizeof(Menu)); ! 422: menuPtr->tkwin = new; ! 423: menuPtr->interp = interp; ! 424: menuPtr->entries = NULL; ! 425: menuPtr->numEntries = 0; ! 426: menuPtr->active = -1; ! 427: menuPtr->group = NULL; ! 428: menuPtr->border = NULL; ! 429: menuPtr->activeBorder = NULL; ! 430: menuPtr->fontPtr = NULL; ! 431: menuPtr->fg = NULL; ! 432: menuPtr->textGC = None; ! 433: menuPtr->disabledFg = NULL; ! 434: menuPtr->gray = None; ! 435: menuPtr->disabledGC = None; ! 436: menuPtr->activeFg = NULL; ! 437: menuPtr->activeGC = None; ! 438: menuPtr->selectorFg = NULL; ! 439: menuPtr->selectorGC = None; ! 440: menuPtr->cursor = None; ! 441: menuPtr->postedCascade = NULL; ! 442: menuPtr->flags = 0; ! 443: ! 444: Tk_SetClass(new, "Menu"); ! 445: Tk_CreateEventHandler(menuPtr->tkwin, ExposureMask|StructureNotifyMask, ! 446: MenuEventProc, (ClientData) menuPtr); ! 447: Tcl_CreateCommand(interp, Tk_PathName(menuPtr->tkwin), MenuWidgetCmd, ! 448: (ClientData) menuPtr, (void (*)()) NULL); ! 449: if (ConfigureMenu(interp, menuPtr, argc-2, argv+2, 0) != TCL_OK) { ! 450: goto error; ! 451: } ! 452: ! 453: interp->result = Tk_PathName(menuPtr->tkwin); ! 454: return TCL_OK; ! 455: ! 456: error: ! 457: Tk_DestroyWindow(menuPtr->tkwin); ! 458: return TCL_ERROR; ! 459: } ! 460: ! 461: /* ! 462: *-------------------------------------------------------------- ! 463: * ! 464: * MenuWidgetCmd -- ! 465: * ! 466: * This procedure is invoked to process the Tcl command ! 467: * that corresponds to a widget managed by this module. ! 468: * See the user documentation for details on what it does. ! 469: * ! 470: * Results: ! 471: * A standard Tcl result. ! 472: * ! 473: * Side effects: ! 474: * See the user documentation. ! 475: * ! 476: *-------------------------------------------------------------- ! 477: */ ! 478: ! 479: static int ! 480: MenuWidgetCmd(clientData, interp, argc, argv) ! 481: ClientData clientData; /* Information about menu widget. */ ! 482: Tcl_Interp *interp; /* Current interpreter. */ ! 483: int argc; /* Number of arguments. */ ! 484: char **argv; /* Argument strings. */ ! 485: { ! 486: register Menu *menuPtr = (Menu *) clientData; ! 487: register MenuEntry *mePtr; ! 488: int result = TCL_OK; ! 489: int length, type; ! 490: char c; ! 491: ! 492: if (argc < 2) { ! 493: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 494: argv[0], " option ?arg arg ...?\"", (char *) NULL); ! 495: return TCL_ERROR; ! 496: } ! 497: Tk_Preserve((ClientData) menuPtr); ! 498: c = argv[1][0]; ! 499: length = strlen(argv[1]); ! 500: if ((c == 'a') && (strncmp(argv[1], "activate", length) == 0) ! 501: && (length >= 2)) { ! 502: int index; ! 503: ! 504: if (argc != 3) { ! 505: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 506: argv[0], " activate index\"", (char *) NULL); ! 507: goto error; ! 508: } ! 509: if (GetMenuIndex(interp, menuPtr, argv[2], &index) != TCL_OK) { ! 510: goto error; ! 511: } ! 512: if (menuPtr->active == index) { ! 513: goto done; ! 514: } ! 515: if (index >= 0) { ! 516: if ((menuPtr->entries[index]->type == SEPARATOR_ENTRY) ! 517: || (menuPtr->entries[index]->state == tkDisabledUid)) { ! 518: index = -1; ! 519: } ! 520: } ! 521: result = ActivateMenuEntry(menuPtr, index); ! 522: } else if ((c == 'a') && (strncmp(argv[1], "add", length) == 0) ! 523: && (length >= 2)) { ! 524: MenuEntry **newEntries; ! 525: ! 526: if (argc < 3) { ! 527: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 528: argv[0], " add type ?options?\"", (char *) NULL); ! 529: goto error; ! 530: } ! 531: ! 532: /* ! 533: * Figure out the type of the new entry. ! 534: */ ! 535: ! 536: c = argv[2][0]; ! 537: length = strlen(argv[2]); ! 538: if ((c == 'c') && (strncmp(argv[2], "cascade", length) == 0) ! 539: && (length >= 2)) { ! 540: type = CASCADE_ENTRY; ! 541: } else if ((c == 'c') && (strncmp(argv[2], "checkbutton", length) == 0) ! 542: && (length >= 2)) { ! 543: type = CHECK_BUTTON_ENTRY; ! 544: } else if ((c == 'c') && (strncmp(argv[2], "command", length) == 0) ! 545: && (length >= 2)) { ! 546: type = COMMAND_ENTRY; ! 547: } else if ((c == 'r') ! 548: && (strncmp(argv[2], "radiobutton", length) == 0)) { ! 549: type = RADIO_BUTTON_ENTRY; ! 550: } else if ((c == 's') ! 551: && (strncmp(argv[2], "separator", length) == 0)) { ! 552: type = SEPARATOR_ENTRY; ! 553: } else { ! 554: Tcl_AppendResult(interp, "bad menu entry type \"", ! 555: argv[2], "\": must be cascade, checkbutton, ", ! 556: "command, radiobutton, or separator", (char *) NULL); ! 557: goto error; ! 558: } ! 559: ! 560: /* ! 561: * Add a new entry to the end of the menu's array of entries, ! 562: * and process options for it. ! 563: */ ! 564: ! 565: mePtr = (MenuEntry *) ckalloc(sizeof(MenuEntry)); ! 566: newEntries = (MenuEntry **) ckalloc((unsigned) ! 567: ((menuPtr->numEntries+1)*sizeof(MenuEntry *))); ! 568: if (menuPtr->numEntries != 0) { ! 569: memcpy((VOID *) newEntries, (VOID *) menuPtr->entries, ! 570: menuPtr->numEntries*sizeof(MenuEntry *)); ! 571: ckfree((char *) menuPtr->entries); ! 572: } ! 573: menuPtr->entries = newEntries; ! 574: menuPtr->entries[menuPtr->numEntries] = mePtr; ! 575: menuPtr->numEntries++; ! 576: mePtr->type = type; ! 577: mePtr->menuPtr = menuPtr; ! 578: mePtr->label = NULL; ! 579: mePtr->underline = -1; ! 580: mePtr->bitmap = None; ! 581: mePtr->accel = NULL; ! 582: mePtr->state = tkNormalUid; ! 583: mePtr->border = NULL; ! 584: mePtr->activeBorder = NULL; ! 585: mePtr->fontPtr = NULL; ! 586: mePtr->textGC = None; ! 587: mePtr->activeGC = None; ! 588: mePtr->disabledGC = None; ! 589: mePtr->command = NULL; ! 590: mePtr->name = NULL; ! 591: mePtr->onValue = NULL; ! 592: mePtr->offValue = NULL; ! 593: mePtr->flags = 0; ! 594: if (ConfigureMenuEntry(interp, menuPtr, mePtr, menuPtr->numEntries-1, ! 595: argc-3, argv+3, 0) != TCL_OK) { ! 596: DestroyMenuEntry((ClientData) mePtr); ! 597: menuPtr->numEntries--; ! 598: goto error; ! 599: } ! 600: } else if ((c == 'c') && (strncmp(argv[1], "configure", length) == 0)) { ! 601: if (argc == 2) { ! 602: result = Tk_ConfigureInfo(interp, menuPtr->tkwin, configSpecs, ! 603: (char *) menuPtr, (char *) NULL, 0); ! 604: } else if (argc == 3) { ! 605: result = Tk_ConfigureInfo(interp, menuPtr->tkwin, configSpecs, ! 606: (char *) menuPtr, argv[2], 0); ! 607: } else { ! 608: result = ConfigureMenu(interp, menuPtr, argc-2, argv+2, ! 609: TK_CONFIG_ARGV_ONLY); ! 610: } ! 611: } else if ((c == 'd') && (strncmp(argv[1], "delete", length) == 0) ! 612: && (length >= 2)) { ! 613: int index, i; ! 614: ! 615: if (argc != 3) { ! 616: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 617: argv[0], " delete index\"", (char *) NULL); ! 618: goto error; ! 619: } ! 620: if (GetMenuIndex(interp, menuPtr, argv[2], &index) != TCL_OK) { ! 621: goto error; ! 622: } ! 623: if (index < 0) { ! 624: goto done; ! 625: } ! 626: Tk_EventuallyFree((ClientData) menuPtr->entries[index], ! 627: DestroyMenuEntry); ! 628: for (i = index; i < menuPtr->numEntries-1; i++) { ! 629: menuPtr->entries[i] = menuPtr->entries[i+1]; ! 630: } ! 631: menuPtr->numEntries -= 1; ! 632: if (menuPtr->active == index) { ! 633: menuPtr->active = -1; ! 634: } else if (menuPtr->active > index) { ! 635: menuPtr->active -= 1; ! 636: } ! 637: if (!(menuPtr->flags & RESIZE_PENDING)) { ! 638: menuPtr->flags |= RESIZE_PENDING; ! 639: Tk_DoWhenIdle(ComputeMenuGeometry, (ClientData) menuPtr); ! 640: } ! 641: } else if ((c == 'd') && (strncmp(argv[1], "disable", length) == 0) ! 642: && (length >= 2)) { ! 643: int index; ! 644: ! 645: if (argc != 3) { ! 646: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 647: argv[0], " disable index\"", (char *) NULL); ! 648: goto error; ! 649: } ! 650: if (GetMenuIndex(interp, menuPtr, argv[2], &index) != TCL_OK) { ! 651: goto error; ! 652: } ! 653: if (index < 0) { ! 654: goto done; ! 655: } ! 656: menuPtr->entries[index]->state = tkDisabledUid; ! 657: if (menuPtr->active == index) { ! 658: menuPtr->active = -1; ! 659: } ! 660: EventuallyRedrawMenu(menuPtr, index); ! 661: } else if ((c == 'e') && (length >= 3) ! 662: && (strncmp(argv[1], "enable", length) == 0)) { ! 663: int index; ! 664: ! 665: if (argc != 3) { ! 666: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 667: argv[0], " enable index\"", (char *) NULL); ! 668: goto error; ! 669: } ! 670: if (GetMenuIndex(interp, menuPtr, argv[2], &index) != TCL_OK) { ! 671: goto error; ! 672: } ! 673: if (index < 0) { ! 674: goto done; ! 675: } ! 676: menuPtr->entries[index]->state = tkNormalUid; ! 677: EventuallyRedrawMenu(menuPtr, index); ! 678: } else if ((c == 'e') && (length >= 3) ! 679: && (strncmp(argv[1], "entryconfigure", length) == 0)) { ! 680: int index; ! 681: ! 682: if (argc < 3) { ! 683: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 684: argv[0], " entryconfigure index ?option value ...?\"", ! 685: (char *) NULL); ! 686: goto error; ! 687: } ! 688: if (GetMenuIndex(interp, menuPtr, argv[2], &index) != TCL_OK) { ! 689: goto error; ! 690: } ! 691: if (index < 0) { ! 692: goto done; ! 693: } ! 694: mePtr = menuPtr->entries[index]; ! 695: Tk_Preserve((ClientData) mePtr); ! 696: if (argc == 3) { ! 697: result = Tk_ConfigureInfo(interp, menuPtr->tkwin, entryConfigSpecs, ! 698: (char *) mePtr, (char *) NULL, ! 699: COMMAND_MASK << mePtr->type); ! 700: } else if (argc == 4) { ! 701: result = Tk_ConfigureInfo(interp, menuPtr->tkwin, entryConfigSpecs, ! 702: (char *) mePtr, argv[3], COMMAND_MASK << mePtr->type); ! 703: } else { ! 704: result = ConfigureMenuEntry(interp, menuPtr, mePtr, index, argc-3, ! 705: argv+3, TK_CONFIG_ARGV_ONLY | COMMAND_MASK << mePtr->type); ! 706: } ! 707: Tk_Release((ClientData) mePtr); ! 708: } else if ((c == 'i') && (strncmp(argv[1], "index", length) == 0) ! 709: && (length >= 3)) { ! 710: int index; ! 711: ! 712: if (argc != 3) { ! 713: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 714: argv[0], " index string\"", (char *) NULL); ! 715: goto error; ! 716: } ! 717: if (GetMenuIndex(interp, menuPtr, argv[2], &index) != TCL_OK) { ! 718: goto error; ! 719: } ! 720: if (index < 0) { ! 721: interp->result = "none"; ! 722: } else { ! 723: sprintf(interp->result, "%d", index); ! 724: } ! 725: } else if ((c == 'i') && (strncmp(argv[1], "invoke", length) == 0) ! 726: && (length >= 3)) { ! 727: int index; ! 728: ! 729: if (argc != 3) { ! 730: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 731: argv[0], " invoke index\"", (char *) NULL); ! 732: goto error; ! 733: } ! 734: if (GetMenuIndex(interp, menuPtr, argv[2], &index) != TCL_OK) { ! 735: goto error; ! 736: } ! 737: if (index < 0) { ! 738: goto done; ! 739: } ! 740: mePtr = menuPtr->entries[index]; ! 741: if (mePtr->state == tkDisabledUid) { ! 742: goto done; ! 743: } ! 744: Tk_Preserve((ClientData) mePtr); ! 745: if (mePtr->type == CHECK_BUTTON_ENTRY) { ! 746: if (mePtr->flags & ENTRY_SELECTED) { ! 747: Tcl_SetVar(interp, mePtr->name, mePtr->offValue, ! 748: TCL_GLOBAL_ONLY); ! 749: } else { ! 750: Tcl_SetVar(interp, mePtr->name, mePtr->onValue, ! 751: TCL_GLOBAL_ONLY); ! 752: } ! 753: } else if (mePtr->type == RADIO_BUTTON_ENTRY) { ! 754: Tcl_SetVar(interp, mePtr->name, mePtr->onValue, TCL_GLOBAL_ONLY); ! 755: } ! 756: if (mePtr->command != NULL) { ! 757: result = Tcl_GlobalEval(interp, mePtr->command); ! 758: } ! 759: Tk_Release((ClientData) mePtr); ! 760: } else if ((c == 'p') && (strncmp(argv[1], "post", length) == 0)) { ! 761: int x, y, tmp; ! 762: Tk_Uid group; ! 763: ! 764: if ((argc != 4) && (argc != 5)) { ! 765: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 766: argv[0], " post x y ?group?\"", (char *) NULL); ! 767: goto error; ! 768: } ! 769: if ((Tcl_GetInt(interp, argv[2], &x) != TCL_OK) ! 770: || (Tcl_GetInt(interp, argv[3], &y) != TCL_OK)) { ! 771: goto error; ! 772: } ! 773: if (argc == 5) { ! 774: group = Tk_GetUid(argv[4]); ! 775: } else { ! 776: group = Tk_GetUid("default"); ! 777: } ! 778: ! 779: /* ! 780: * Adjust the position of the menu if necessary to keep it ! 781: * on-screen. ! 782: */ ! 783: ! 784: tmp = WidthOfScreen(Tk_Screen(menuPtr->tkwin)) ! 785: - Tk_Width(menuPtr->tkwin); ! 786: if (x > tmp) { ! 787: x = tmp; ! 788: } ! 789: if (x < 0) { ! 790: x = 0; ! 791: } ! 792: tmp = HeightOfScreen(Tk_Screen(menuPtr->tkwin)) ! 793: - Tk_Height(menuPtr->tkwin); ! 794: if (y > tmp) { ! 795: y = tmp; ! 796: } ! 797: if (y < 0) { ! 798: y = 0; ! 799: } ! 800: if ((x != Tk_X(menuPtr->tkwin)) || (y != Tk_Y(menuPtr->tkwin))) { ! 801: Tk_MoveWindow(menuPtr->tkwin, x, y); ! 802: } ! 803: if (Tk_IsMapped(menuPtr->tkwin)) { ! 804: if (group != menuPtr->group) { ! 805: Tk_UnshareEvents(menuPtr->tkwin, menuPtr->group); ! 806: Tk_ShareEvents(menuPtr->tkwin, group); ! 807: } ! 808: } else { ! 809: Tk_ShareEvents(menuPtr->tkwin, group); ! 810: Tk_MapWindow(menuPtr->tkwin); ! 811: result = ActivateMenuEntry(menuPtr, -1); ! 812: } ! 813: XRaiseWindow(Tk_Display(menuPtr->tkwin), Tk_WindowId(menuPtr->tkwin)); ! 814: menuPtr->group = group; ! 815: } else if ((c == 'u') && (strncmp(argv[1], "unpost", length) == 0)) { ! 816: if (argc != 2) { ! 817: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 818: argv[0], " unpost\"", (char *) NULL); ! 819: goto error; ! 820: } ! 821: Tk_UnshareEvents(menuPtr->tkwin, menuPtr->group); ! 822: Tk_UnmapWindow(menuPtr->tkwin); ! 823: result = ActivateMenuEntry(menuPtr, -1); ! 824: if (result == TCL_OK) { ! 825: result = PostSubmenu(interp, menuPtr, (MenuEntry *) NULL); ! 826: } ! 827: } else { ! 828: Tcl_AppendResult(interp, "bad option \"", argv[1], ! 829: "\": must be activate, add, configure, delete, disable, ", ! 830: "enable, entryconfigure, index, invoke, post, ", ! 831: "or unpost", (char *) NULL); ! 832: goto error; ! 833: } ! 834: done: ! 835: Tk_Release((ClientData) menuPtr); ! 836: return result; ! 837: ! 838: error: ! 839: Tk_Release((ClientData) menuPtr); ! 840: return TCL_ERROR; ! 841: } ! 842: ! 843: /* ! 844: *---------------------------------------------------------------------- ! 845: * ! 846: * DestroyMenu -- ! 847: * ! 848: * This procedure is invoked by Tk_EventuallyFree or Tk_Release ! 849: * to clean up the internal structure of a menu at a safe time ! 850: * (when no-one is using it anymore). ! 851: * ! 852: * Results: ! 853: * None. ! 854: * ! 855: * Side effects: ! 856: * Everything associated with the menu is freed up. ! 857: * ! 858: *---------------------------------------------------------------------- ! 859: */ ! 860: ! 861: static void ! 862: DestroyMenu(clientData) ! 863: ClientData clientData; /* Info about menu widget. */ ! 864: { ! 865: register Menu *menuPtr = (Menu *) clientData; ! 866: int i; ! 867: ! 868: for (i = 0; i < menuPtr->numEntries; i++) { ! 869: DestroyMenuEntry((ClientData) menuPtr->entries[i]); ! 870: } ! 871: if (menuPtr->entries != NULL) { ! 872: ckfree((char *) menuPtr->entries); ! 873: } ! 874: if (menuPtr->border != NULL) { ! 875: Tk_Free3DBorder(menuPtr->border); ! 876: } ! 877: if (menuPtr->activeBorder != NULL) { ! 878: Tk_Free3DBorder(menuPtr->activeBorder); ! 879: } ! 880: if (menuPtr->fontPtr != NULL) { ! 881: Tk_FreeFontStruct(menuPtr->fontPtr); ! 882: } ! 883: if (menuPtr->fg != NULL) { ! 884: Tk_FreeColor(menuPtr->fg); ! 885: } ! 886: if (menuPtr->textGC != None) { ! 887: Tk_FreeGC(menuPtr->textGC); ! 888: } ! 889: if (menuPtr->disabledFg != NULL) { ! 890: Tk_FreeColor(menuPtr->disabledFg); ! 891: } ! 892: if (menuPtr->gray != None) { ! 893: Tk_FreeBitmap(menuPtr->gray); ! 894: } ! 895: if (menuPtr->disabledGC != None) { ! 896: Tk_FreeGC(menuPtr->disabledGC); ! 897: } ! 898: if (menuPtr->activeFg != NULL) { ! 899: Tk_FreeColor(menuPtr->activeFg); ! 900: } ! 901: if (menuPtr->activeGC != None) { ! 902: Tk_FreeGC(menuPtr->activeGC); ! 903: } ! 904: if (menuPtr->selectorFg != NULL) { ! 905: Tk_FreeColor(menuPtr->selectorFg); ! 906: } ! 907: if (menuPtr->selectorGC != None) { ! 908: Tk_FreeGC(menuPtr->selectorGC); ! 909: } ! 910: if (menuPtr->cursor != None) { ! 911: Tk_FreeCursor(menuPtr->cursor); ! 912: } ! 913: ckfree((char *) menuPtr); ! 914: } ! 915: ! 916: /* ! 917: *---------------------------------------------------------------------- ! 918: * ! 919: * DestroyMenuEntry -- ! 920: * ! 921: * This procedure is invoked by Tk_EventuallyFree or Tk_Release ! 922: * to clean up the internal structure of a menu entry at a safe time ! 923: * (when no-one is using it anymore). ! 924: * ! 925: * Results: ! 926: * None. ! 927: * ! 928: * Side effects: ! 929: * Everything associated with the menu entry is freed up. ! 930: * ! 931: *---------------------------------------------------------------------- ! 932: */ ! 933: ! 934: static void ! 935: DestroyMenuEntry(clientData) ! 936: ClientData clientData; /* Pointer to entry to be freed. */ ! 937: { ! 938: register MenuEntry *mePtr = (MenuEntry *) clientData; ! 939: Menu *menuPtr = mePtr->menuPtr; ! 940: ! 941: if (mePtr->name != NULL) { ! 942: Tcl_UntraceVar(menuPtr->interp, mePtr->name, ! 943: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 944: MenuVarProc, (ClientData) mePtr); ! 945: } ! 946: if (menuPtr->postedCascade == mePtr) { ! 947: if (PostSubmenu(menuPtr->interp, menuPtr, (MenuEntry *) NULL) ! 948: != TCL_OK) { ! 949: TkBindError(menuPtr->interp); ! 950: } ! 951: } ! 952: if (mePtr->label != NULL) { ! 953: ckfree(mePtr->label); ! 954: } ! 955: if (mePtr->bitmap != None) { ! 956: #if defined(USE_XPM3) ! 957: Tk_FreePixmap(mePtr->bitmap); ! 958: #else ! 959: Tk_FreeBitmap(mePtr->bitmap); ! 960: #endif ! 961: } ! 962: if (mePtr->accel != NULL) { ! 963: ckfree(mePtr->accel); ! 964: } ! 965: if (mePtr->border != NULL) { ! 966: Tk_Free3DBorder(mePtr->border); ! 967: } ! 968: if (mePtr->activeBorder != NULL) { ! 969: Tk_Free3DBorder(mePtr->activeBorder); ! 970: } ! 971: if (mePtr->fontPtr != NULL) { ! 972: Tk_FreeFontStruct(mePtr->fontPtr); ! 973: } ! 974: if (mePtr->textGC != NULL) { ! 975: Tk_FreeGC(mePtr->textGC); ! 976: } ! 977: if (mePtr->activeGC != NULL) { ! 978: Tk_FreeGC(mePtr->activeGC); ! 979: } ! 980: if (mePtr->disabledGC != NULL) { ! 981: Tk_FreeGC(mePtr->disabledGC); ! 982: } ! 983: if (mePtr->command != NULL) { ! 984: ckfree(mePtr->command); ! 985: } ! 986: if (mePtr->name != NULL) { ! 987: ckfree(mePtr->name); ! 988: } ! 989: if (mePtr->onValue != NULL) { ! 990: ckfree(mePtr->onValue); ! 991: } ! 992: if (mePtr->offValue != NULL) { ! 993: ckfree(mePtr->offValue); ! 994: } ! 995: ckfree((char *) mePtr); ! 996: } ! 997: ! 998: /* ! 999: *---------------------------------------------------------------------- ! 1000: * ! 1001: * ConfigureMenu -- ! 1002: * ! 1003: * This procedure is called to process an argv/argc list, plus ! 1004: * the Tk option database, in order to configure (or ! 1005: * reconfigure) a menu widget. ! 1006: * ! 1007: * Results: ! 1008: * The return value is a standard Tcl result. If TCL_ERROR is ! 1009: * returned, then interp->result contains an error message. ! 1010: * ! 1011: * Side effects: ! 1012: * Configuration information, such as colors, font, etc. get set ! 1013: * for menuPtr; old resources get freed, if there were any. ! 1014: * ! 1015: *---------------------------------------------------------------------- ! 1016: */ ! 1017: ! 1018: static int ! 1019: ConfigureMenu(interp, menuPtr, argc, argv, flags) ! 1020: Tcl_Interp *interp; /* Used for error reporting. */ ! 1021: register Menu *menuPtr; /* Information about widget; may or may ! 1022: * not already have values for some fields. */ ! 1023: int argc; /* Number of valid entries in argv. */ ! 1024: char **argv; /* Arguments. */ ! 1025: int flags; /* Flags to pass to Tk_ConfigureWidget. */ ! 1026: { ! 1027: XGCValues gcValues; ! 1028: GC newGC; ! 1029: unsigned long mask; ! 1030: int i; ! 1031: ! 1032: if (Tk_ConfigureWidget(interp, menuPtr->tkwin, configSpecs, ! 1033: argc, argv, (char *) menuPtr, flags) != TCL_OK) { ! 1034: return TCL_ERROR; ! 1035: } ! 1036: ! 1037: /* ! 1038: * A few options need special processing, such as setting the ! 1039: * background from a 3-D border, or filling in complicated ! 1040: * defaults that couldn't be specified to Tk_ConfigureWidget. ! 1041: */ ! 1042: ! 1043: Tk_SetBackgroundFromBorder(menuPtr->tkwin, menuPtr->border); ! 1044: ! 1045: gcValues.font = menuPtr->fontPtr->fid; ! 1046: gcValues.foreground = menuPtr->fg->pixel; ! 1047: gcValues.background = Tk_3DBorderColor(menuPtr->border)->pixel; ! 1048: newGC = Tk_GetGC(menuPtr->tkwin, GCForeground|GCBackground|GCFont, ! 1049: &gcValues); ! 1050: if (menuPtr->textGC != None) { ! 1051: Tk_FreeGC(menuPtr->textGC); ! 1052: } ! 1053: menuPtr->textGC = newGC; ! 1054: ! 1055: if (menuPtr->disabledFg != NULL) { ! 1056: gcValues.foreground = menuPtr->disabledFg->pixel; ! 1057: mask = GCForeground|GCBackground|GCFont; ! 1058: } else { ! 1059: gcValues.foreground = gcValues.background; ! 1060: if (menuPtr->gray == None) { ! 1061: menuPtr->gray = Tk_GetBitmap(interp, menuPtr->tkwin, ! 1062: Tk_GetUid("gray50")); ! 1063: if (menuPtr->gray == None) { ! 1064: return TCL_ERROR; ! 1065: } ! 1066: } ! 1067: gcValues.fill_style = FillStippled; ! 1068: gcValues.stipple = menuPtr->gray; ! 1069: mask = GCForeground|GCFillStyle|GCStipple; ! 1070: } ! 1071: newGC = Tk_GetGC(menuPtr->tkwin, mask, &gcValues); ! 1072: if (menuPtr->disabledGC != None) { ! 1073: Tk_FreeGC(menuPtr->disabledGC); ! 1074: } ! 1075: menuPtr->disabledGC = newGC; ! 1076: ! 1077: gcValues.font = menuPtr->fontPtr->fid; ! 1078: gcValues.foreground = menuPtr->activeFg->pixel; ! 1079: gcValues.background = Tk_3DBorderColor(menuPtr->activeBorder)->pixel; ! 1080: newGC = Tk_GetGC(menuPtr->tkwin, GCForeground|GCBackground|GCFont, ! 1081: &gcValues); ! 1082: if (menuPtr->activeGC != None) { ! 1083: Tk_FreeGC(menuPtr->activeGC); ! 1084: } ! 1085: menuPtr->activeGC = newGC; ! 1086: ! 1087: gcValues.foreground = menuPtr->selectorFg->pixel; ! 1088: newGC = Tk_GetGC(menuPtr->tkwin, GCForeground|GCFont, &gcValues); ! 1089: if (menuPtr->selectorGC != None) { ! 1090: Tk_FreeGC(menuPtr->selectorGC); ! 1091: } ! 1092: menuPtr->selectorGC = newGC; ! 1093: ! 1094: /* ! 1095: * After reconfiguring a menu, we need to reconfigure all of the ! 1096: * entries in the menu, since some of the things in the children ! 1097: * (such as graphics contexts) may have to change to reflect changes ! 1098: * in the parent. ! 1099: */ ! 1100: ! 1101: for (i = 0; i < menuPtr->numEntries; i++) { ! 1102: MenuEntry *mePtr; ! 1103: ! 1104: mePtr = menuPtr->entries[i]; ! 1105: ConfigureMenuEntry(interp, menuPtr, mePtr, i, 0, (char **) NULL, ! 1106: TK_CONFIG_ARGV_ONLY | COMMAND_MASK << mePtr->type); ! 1107: } ! 1108: ! 1109: if (!(menuPtr->flags & RESIZE_PENDING)) { ! 1110: menuPtr->flags |= RESIZE_PENDING; ! 1111: Tk_DoWhenIdle(ComputeMenuGeometry, (ClientData) menuPtr); ! 1112: } ! 1113: ! 1114: return TCL_OK; ! 1115: } ! 1116: ! 1117: /* ! 1118: *---------------------------------------------------------------------- ! 1119: * ! 1120: * ConfigureMenuEntry -- ! 1121: * ! 1122: * This procedure is called to process an argv/argc list, plus ! 1123: * the Tk option database, in order to configure (or ! 1124: * reconfigure) one entry in a menu. ! 1125: * ! 1126: * Results: ! 1127: * The return value is a standard Tcl result. If TCL_ERROR is ! 1128: * returned, then interp->result contains an error message. ! 1129: * ! 1130: * Side effects: ! 1131: * Configuration information such as label and accelerator get ! 1132: * set for mePtr; old resources get freed, if there were any. ! 1133: * ! 1134: *---------------------------------------------------------------------- ! 1135: */ ! 1136: ! 1137: static int ! 1138: ConfigureMenuEntry(interp, menuPtr, mePtr, index, argc, argv, flags) ! 1139: Tcl_Interp *interp; /* Used for error reporting. */ ! 1140: Menu *menuPtr; /* Information about whole menu. */ ! 1141: register MenuEntry *mePtr; /* Information about menu entry; may ! 1142: * or may not already have values for ! 1143: * some fields. */ ! 1144: int index; /* Index of mePtr within menuPtr's ! 1145: * entries. */ ! 1146: int argc; /* Number of valid entries in argv. */ ! 1147: char **argv; /* Arguments. */ ! 1148: int flags; /* Additional flags to pass to ! 1149: * Tk_ConfigureWidget. */ ! 1150: { ! 1151: XGCValues gcValues; ! 1152: GC newGC, newActiveGC, newDisabledGC; ! 1153: unsigned long mask; ! 1154: ! 1155: /* ! 1156: * If this entry is a cascade and the cascade is posted, then unpost ! 1157: * it before reconfiguring the entry (otherwise the reconfigure might ! 1158: * change the name of the cascaded entry, leaving a posted menu ! 1159: * high and dry). ! 1160: */ ! 1161: ! 1162: if (menuPtr->postedCascade == mePtr) { ! 1163: if (PostSubmenu(menuPtr->interp, menuPtr, (MenuEntry *) NULL) ! 1164: != TCL_OK) { ! 1165: TkBindError(menuPtr->interp); ! 1166: } ! 1167: } ! 1168: ! 1169: /* ! 1170: * If this entry is a check button or radio button, then remove ! 1171: * its old trace procedure. ! 1172: */ ! 1173: ! 1174: if ((mePtr->name != NULL) && ! 1175: ((mePtr->type == CHECK_BUTTON_ENTRY) ! 1176: || (mePtr->type == RADIO_BUTTON_ENTRY))) { ! 1177: Tcl_UntraceVar(menuPtr->interp, mePtr->name, ! 1178: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 1179: MenuVarProc, (ClientData) mePtr); ! 1180: } ! 1181: ! 1182: if (Tk_ConfigureWidget(interp, menuPtr->tkwin, entryConfigSpecs, ! 1183: argc, argv, (char *) mePtr, ! 1184: flags | (COMMAND_MASK << mePtr->type)) != TCL_OK) { ! 1185: return TCL_ERROR; ! 1186: } ! 1187: ! 1188: /* ! 1189: * The code below handles special configuration stuff not taken ! 1190: * care of by Tk_ConfigureWidget, such as special processing for ! 1191: * defaults, sizing strings, graphics contexts, etc. ! 1192: */ ! 1193: ! 1194: if (mePtr->label == NULL) { ! 1195: mePtr->labelLength = 0; ! 1196: } else { ! 1197: mePtr->labelLength = strlen(mePtr->label); ! 1198: } ! 1199: if (mePtr->accel == NULL) { ! 1200: mePtr->accelLength = 0; ! 1201: } else { ! 1202: mePtr->accelLength = strlen(mePtr->accel); ! 1203: } ! 1204: ! 1205: if (mePtr->state == tkActiveUid) { ! 1206: if (index != menuPtr->active) { ! 1207: ActivateMenuEntry(menuPtr, index); ! 1208: } ! 1209: } else { ! 1210: if (index == menuPtr->active) { ! 1211: ActivateMenuEntry(menuPtr, -1); ! 1212: } ! 1213: if ((mePtr->state != tkNormalUid) && (mePtr->state != tkDisabledUid)) { ! 1214: Tcl_AppendResult(interp, "bad state value \"", mePtr->state, ! 1215: "\": must be normal, active, or disabled", (char *) NULL); ! 1216: mePtr->state = tkNormalUid; ! 1217: return TCL_ERROR; ! 1218: } ! 1219: } ! 1220: ! 1221: if (mePtr->fontPtr != NULL) { ! 1222: gcValues.foreground = menuPtr->fg->pixel; ! 1223: gcValues.background = Tk_3DBorderColor( ! 1224: (mePtr->border != NULL) ? mePtr->border : menuPtr->border) ! 1225: ->pixel; ! 1226: gcValues.font = mePtr->fontPtr->fid; ! 1227: ! 1228: /* ! 1229: * Note: disable GraphicsExpose events; we know there won't be ! 1230: * obscured areas when copying from an off-screen pixmap to the ! 1231: * screen and this gets rid of unnecessary events. ! 1232: */ ! 1233: ! 1234: gcValues.graphics_exposures = False; ! 1235: newGC = Tk_GetGC(menuPtr->tkwin, ! 1236: GCForeground|GCBackground|GCFont|GCGraphicsExposures, ! 1237: &gcValues); ! 1238: ! 1239: if (menuPtr->disabledFg != NULL) { ! 1240: gcValues.foreground = menuPtr->disabledFg->pixel; ! 1241: mask = GCForeground|GCBackground|GCFont|GCGraphicsExposures; ! 1242: } else { ! 1243: gcValues.foreground = gcValues.background; ! 1244: gcValues.fill_style = FillStippled; ! 1245: gcValues.stipple = menuPtr->gray; ! 1246: mask = GCForeground|GCFillStyle|GCStipple; ! 1247: } ! 1248: newDisabledGC = Tk_GetGC(menuPtr->tkwin, mask, &gcValues); ! 1249: ! 1250: gcValues.foreground = menuPtr->activeFg->pixel; ! 1251: gcValues.background = Tk_3DBorderColor( ! 1252: (mePtr->activeBorder != NULL) ? mePtr->activeBorder ! 1253: : menuPtr->activeBorder)->pixel; ! 1254: newActiveGC = Tk_GetGC(menuPtr->tkwin, ! 1255: GCForeground|GCBackground|GCFont|GCGraphicsExposures, ! 1256: &gcValues); ! 1257: } else { ! 1258: newGC = NULL; ! 1259: newActiveGC = NULL; ! 1260: newDisabledGC = NULL; ! 1261: } ! 1262: if (mePtr->textGC != NULL) { ! 1263: Tk_FreeGC(mePtr->textGC); ! 1264: } ! 1265: mePtr->textGC = newGC; ! 1266: if (mePtr->activeGC != NULL) { ! 1267: Tk_FreeGC(mePtr->activeGC); ! 1268: } ! 1269: mePtr->activeGC = newActiveGC; ! 1270: if (mePtr->disabledGC != NULL) { ! 1271: Tk_FreeGC(mePtr->disabledGC); ! 1272: } ! 1273: mePtr->disabledGC = newDisabledGC; ! 1274: ! 1275: if ((mePtr->type == CHECK_BUTTON_ENTRY) ! 1276: || (mePtr->type == RADIO_BUTTON_ENTRY)) { ! 1277: char *value; ! 1278: ! 1279: if (mePtr->name == NULL) { ! 1280: mePtr->name = ckalloc((unsigned) (strlen(mePtr->label) + 1)); ! 1281: strcpy(mePtr->name, mePtr->label); ! 1282: } ! 1283: if (mePtr->onValue == NULL) { ! 1284: mePtr->onValue = ckalloc((unsigned) (strlen(mePtr->label) + 1)); ! 1285: strcpy(mePtr->onValue, mePtr->label); ! 1286: } ! 1287: ! 1288: /* ! 1289: * Select the entry if the associated variable has the ! 1290: * appropriate value, initialize the variable if it doesn't ! 1291: * exist, then set a trace on the variable to monitor future ! 1292: * changes to its value. ! 1293: */ ! 1294: ! 1295: value = Tcl_GetVar(interp, mePtr->name, TCL_GLOBAL_ONLY); ! 1296: mePtr->flags &= ENTRY_SELECTED; ! 1297: if (value != NULL) { ! 1298: if (strcmp(value, mePtr->onValue) == 0) { ! 1299: mePtr->flags |= ENTRY_SELECTED; ! 1300: } ! 1301: } else { ! 1302: Tcl_SetVar(interp, mePtr->name, ! 1303: (mePtr->type == CHECK_BUTTON_ENTRY) ? mePtr->offValue : "", ! 1304: TCL_GLOBAL_ONLY); ! 1305: } ! 1306: Tcl_TraceVar(interp, mePtr->name, ! 1307: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 1308: MenuVarProc, (ClientData) mePtr); ! 1309: } ! 1310: ! 1311: if (!(menuPtr->flags & RESIZE_PENDING)) { ! 1312: menuPtr->flags |= RESIZE_PENDING; ! 1313: Tk_DoWhenIdle(ComputeMenuGeometry, (ClientData) menuPtr); ! 1314: } ! 1315: return TCL_OK; ! 1316: } ! 1317: ! 1318: /* ! 1319: *-------------------------------------------------------------- ! 1320: * ! 1321: * ComputeMenuGeometry -- ! 1322: * ! 1323: * This procedure is invoked to recompute the size and ! 1324: * layout of a menu. It is called as a when-idle handler so ! 1325: * that it only gets done once, even if a group of changes is ! 1326: * made to the menu. ! 1327: * ! 1328: * Results: ! 1329: * None. ! 1330: * ! 1331: * Side effects: ! 1332: * Fields of menu entries are changed to reflect their ! 1333: * current positions, and the size of the menu window ! 1334: * itself may be changed. ! 1335: * ! 1336: *-------------------------------------------------------------- ! 1337: */ ! 1338: ! 1339: static void ! 1340: ComputeMenuGeometry(clientData) ! 1341: ClientData clientData; /* Structure describing menu. */ ! 1342: { ! 1343: Menu *menuPtr = (Menu *) clientData; ! 1344: register MenuEntry *mePtr; ! 1345: XFontStruct *fontPtr; ! 1346: int maxLabelWidth, maxSelectorWidth, maxAccelWidth; ! 1347: int width, height, selectorSpace, horizMargin; ! 1348: int i, y; ! 1349: ! 1350: if (menuPtr->tkwin == NULL) { ! 1351: return; ! 1352: } ! 1353: ! 1354: maxLabelWidth = maxSelectorWidth = maxAccelWidth = 0; ! 1355: y = menuPtr->borderWidth; ! 1356: ! 1357: for (i = 0; i < menuPtr->numEntries; i++) { ! 1358: mePtr = menuPtr->entries[i]; ! 1359: selectorSpace = 0; ! 1360: fontPtr = mePtr->fontPtr; ! 1361: if (fontPtr == NULL) { ! 1362: fontPtr = menuPtr->fontPtr; ! 1363: } ! 1364: ! 1365: /* ! 1366: * For each entry, compute the height required by that ! 1367: * particular entry, plus three widths: the width of the ! 1368: * label, the width to allow for a selector to be displayed ! 1369: * to the left of the label (if any), and the width of the ! 1370: * accelerator to be displayed to the right of the label ! 1371: * (if any). These sizes depend, of course, on the type ! 1372: * of the entry. ! 1373: */ ! 1374: ! 1375: if (mePtr->bitmap != None) { ! 1376: unsigned int bitmapWidth, bitmapHeight; ! 1377: ! 1378: #if defined(USE_XPM3) ! 1379: Tk_SizeOfPixmap(mePtr->bitmap, &bitmapWidth, &bitmapHeight); ! 1380: #else ! 1381: Tk_SizeOfBitmap(mePtr->bitmap, &bitmapWidth, &bitmapHeight); ! 1382: #endif ! 1383: mePtr->height = bitmapHeight; ! 1384: width = bitmapWidth; ! 1385: if (mePtr->type == CHECK_BUTTON_ENTRY) { ! 1386: selectorSpace = (14*mePtr->height)/10; ! 1387: mePtr->selectorDiameter = (65*mePtr->height)/100; ! 1388: } else if (mePtr->type == RADIO_BUTTON_ENTRY) { ! 1389: selectorSpace = (14*mePtr->height)/10; ! 1390: mePtr->selectorDiameter = (75*mePtr->height)/100; ! 1391: } ! 1392: } else { ! 1393: mePtr->height = fontPtr->ascent + fontPtr->descent; ! 1394: if (mePtr->label != NULL) { ! 1395: (void) TkMeasureChars(fontPtr, mePtr->label, ! 1396: mePtr->labelLength, 0, (int) 100000, ! 1397: TK_NEWLINES_NOT_SPECIAL, &width); ! 1398: } else { ! 1399: width = 0; ! 1400: } ! 1401: if (mePtr->type == CHECK_BUTTON_ENTRY) { ! 1402: selectorSpace = mePtr->height; ! 1403: mePtr->selectorDiameter = (80*mePtr->height)/100; ! 1404: } else if (mePtr->type == RADIO_BUTTON_ENTRY) { ! 1405: selectorSpace = mePtr->height; ! 1406: mePtr->selectorDiameter = mePtr->height; ! 1407: } ! 1408: } ! 1409: mePtr->height += 2*menuPtr->activeBorderWidth + 2; ! 1410: if (width > maxLabelWidth) { ! 1411: maxLabelWidth = width; ! 1412: } ! 1413: if (mePtr->accel != NULL) { ! 1414: (void) TkMeasureChars(fontPtr, mePtr->accel, mePtr->accelLength, ! 1415: 0, (int) 100000, TK_NEWLINES_NOT_SPECIAL, &width); ! 1416: if (width > maxAccelWidth) { ! 1417: maxAccelWidth = width; ! 1418: } ! 1419: } ! 1420: if (mePtr->type == SEPARATOR_ENTRY) { ! 1421: mePtr->height = 4*menuPtr->borderWidth; ! 1422: } ! 1423: if (selectorSpace > maxSelectorWidth) { ! 1424: maxSelectorWidth = selectorSpace; ! 1425: } ! 1426: mePtr->y = y; ! 1427: y += mePtr->height; ! 1428: } ! 1429: ! 1430: /* ! 1431: * Got all the sizes. Update fields in the menu structure, then ! 1432: * resize the window if necessary. Leave margins on either side ! 1433: * of the selector (or just one margin if there is no selector). ! 1434: * Leave another margin on the right side of the label, plus yet ! 1435: * another margin to the right of the accelerator (if there is one). ! 1436: */ ! 1437: ! 1438: horizMargin = 2; ! 1439: menuPtr->selectorSpace = maxSelectorWidth + horizMargin; ! 1440: if (maxSelectorWidth != 0) { ! 1441: menuPtr->selectorSpace += horizMargin; ! 1442: } ! 1443: menuPtr->labelWidth = maxLabelWidth + horizMargin; ! 1444: width = menuPtr->selectorSpace + menuPtr->labelWidth + maxAccelWidth ! 1445: + 2*menuPtr->borderWidth + 2*menuPtr->activeBorderWidth + 2; ! 1446: if (maxAccelWidth != 0) { ! 1447: width += horizMargin; ! 1448: } ! 1449: height = y + menuPtr->borderWidth; ! 1450: ! 1451: /* ! 1452: * The X server doesn't like zero dimensions, so round up to at least ! 1453: * 1 (a zero-sized menu should never really occur, anyway). ! 1454: */ ! 1455: ! 1456: if (width <= 0) { ! 1457: width = 1; ! 1458: } ! 1459: if (height <= 0) { ! 1460: height = 1; ! 1461: } ! 1462: if ((width != Tk_ReqWidth(menuPtr->tkwin)) || ! 1463: (height != Tk_ReqHeight(menuPtr->tkwin))) { ! 1464: Tk_GeometryRequest(menuPtr->tkwin, width, height); ! 1465: } else { ! 1466: /* ! 1467: * Must always force a redisplay here if the window is mapped ! 1468: * (even if the size didn't change, something else might have ! 1469: * changed in the menu, such as a label or accelerator). The ! 1470: * resize will force a redisplay above. ! 1471: */ ! 1472: ! 1473: EventuallyRedrawMenu(menuPtr, -1); ! 1474: } ! 1475: ! 1476: menuPtr->flags &= ~RESIZE_PENDING; ! 1477: } ! 1478: ! 1479: /* ! 1480: *---------------------------------------------------------------------- ! 1481: * ! 1482: * DisplayMenu -- ! 1483: * ! 1484: * This procedure is invoked to display a menu widget. ! 1485: * ! 1486: * Results: ! 1487: * None. ! 1488: * ! 1489: * Side effects: ! 1490: * Commands are output to X to display the menu in its ! 1491: * current mode. ! 1492: * ! 1493: *---------------------------------------------------------------------- ! 1494: */ ! 1495: ! 1496: static void ! 1497: DisplayMenu(clientData) ! 1498: ClientData clientData; /* Information about widget. */ ! 1499: { ! 1500: register Menu *menuPtr = (Menu *) clientData; ! 1501: register MenuEntry *mePtr; ! 1502: register Tk_Window tkwin = menuPtr->tkwin; ! 1503: XFontStruct *fontPtr; ! 1504: int index, baseline; ! 1505: GC gc; ! 1506: ! 1507: menuPtr->flags &= ~REDRAW_PENDING; ! 1508: if ((menuPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) { ! 1509: return; ! 1510: } ! 1511: ! 1512: /* ! 1513: * Loop through all of the entries, drawing them one at a time. ! 1514: */ ! 1515: ! 1516: for (index = 0; index < menuPtr->numEntries; index++) { ! 1517: mePtr = menuPtr->entries[index]; ! 1518: if (!(mePtr->flags & ENTRY_NEEDS_REDISPLAY)) { ! 1519: continue; ! 1520: } ! 1521: mePtr->flags &= ~ENTRY_NEEDS_REDISPLAY; ! 1522: ! 1523: /* ! 1524: * Background. ! 1525: */ ! 1526: ! 1527: if (mePtr->state == tkActiveUid) { ! 1528: Tk_Fill3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 1529: (mePtr->activeBorder != NULL) ? mePtr->activeBorder ! 1530: : menuPtr->activeBorder, menuPtr->borderWidth, mePtr->y, ! 1531: Tk_Width(tkwin) - 2*menuPtr->borderWidth, mePtr->height, ! 1532: menuPtr->activeBorderWidth, TK_RELIEF_RAISED); ! 1533: gc = mePtr->activeGC; ! 1534: if (gc == NULL) { ! 1535: gc = menuPtr->activeGC; ! 1536: } ! 1537: } else { ! 1538: Tk_Fill3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 1539: (mePtr->border != NULL) ? mePtr->border ! 1540: : menuPtr->border, menuPtr->borderWidth, mePtr->y, ! 1541: Tk_Width(tkwin) - 2*menuPtr->borderWidth, mePtr->height, ! 1542: 0, TK_RELIEF_FLAT); ! 1543: if ((mePtr->state == tkDisabledUid) ! 1544: && (menuPtr->disabledFg != NULL)) { ! 1545: gc = mePtr->disabledGC; ! 1546: if (gc == NULL) { ! 1547: gc = menuPtr->disabledGC; ! 1548: } ! 1549: } else { ! 1550: gc = mePtr->textGC; ! 1551: if (gc == NULL) { ! 1552: gc = menuPtr->textGC; ! 1553: } ! 1554: } ! 1555: } ! 1556: ! 1557: /* ! 1558: * Draw label or bitmap for entry. ! 1559: */ ! 1560: ! 1561: fontPtr = mePtr->fontPtr; ! 1562: if (fontPtr == NULL) { ! 1563: fontPtr = menuPtr->fontPtr; ! 1564: } ! 1565: baseline = mePtr->y + (mePtr->height + fontPtr->ascent ! 1566: - fontPtr->descent)/2; ! 1567: if (mePtr->bitmap != None) { ! 1568: unsigned int width, height; ! 1569: ! 1570: #if defined(USE_XPM3) ! 1571: Tk_SizeOfPixmap(mePtr->bitmap, &width, &height); ! 1572: XCopyArea(Tk_Display(tkwin), mePtr->bitmap, Tk_WindowId(tkwin), ! 1573: gc, 0, 0, width, height, ! 1574: menuPtr->borderWidth + menuPtr->selectorSpace, ! 1575: (int) (mePtr->y + (mePtr->height - height)/2)); ! 1576: #else ! 1577: Tk_SizeOfBitmap(mePtr->bitmap, &width, &height); ! 1578: XCopyPlane(Tk_Display(tkwin), mePtr->bitmap, Tk_WindowId(tkwin), ! 1579: gc, 0, 0, width, height, ! 1580: menuPtr->borderWidth + menuPtr->selectorSpace, ! 1581: (int) (mePtr->y + (mePtr->height - height)/2), 1); ! 1582: #endif ! 1583: } else { ! 1584: baseline = mePtr->y + (mePtr->height + fontPtr->ascent ! 1585: - fontPtr->descent)/2; ! 1586: if (mePtr->label != NULL) { ! 1587: TkDisplayChars(Tk_Display(tkwin), Tk_WindowId(tkwin), gc, ! 1588: fontPtr, mePtr->label, mePtr->labelLength, ! 1589: menuPtr->borderWidth + menuPtr->selectorSpace, ! 1590: baseline, TK_NEWLINES_NOT_SPECIAL); ! 1591: if (mePtr->underline >= 0) { ! 1592: TkUnderlineChars(Tk_Display(tkwin), Tk_WindowId(tkwin), gc, ! 1593: fontPtr, mePtr->label, ! 1594: menuPtr->borderWidth + menuPtr->selectorSpace, ! 1595: baseline, TK_NEWLINES_NOT_SPECIAL, ! 1596: mePtr->underline, mePtr->underline); ! 1597: } ! 1598: } ! 1599: } ! 1600: ! 1601: /* ! 1602: * Draw accelerator. ! 1603: */ ! 1604: ! 1605: if (mePtr->accel != NULL) { ! 1606: TkDisplayChars(Tk_Display(tkwin), Tk_WindowId(tkwin), gc, ! 1607: fontPtr, mePtr->accel, mePtr->accelLength, ! 1608: menuPtr->borderWidth + menuPtr->selectorSpace ! 1609: + menuPtr->labelWidth, baseline, TK_NEWLINES_NOT_SPECIAL); ! 1610: } ! 1611: ! 1612: /* ! 1613: * Draw check-button selector. ! 1614: */ ! 1615: ! 1616: if (mePtr->type == CHECK_BUTTON_ENTRY) { ! 1617: int dim, x, y; ! 1618: ! 1619: dim = mePtr->selectorDiameter; ! 1620: x = menuPtr->borderWidth + (menuPtr->selectorSpace - dim)/2; ! 1621: y = mePtr->y + (mePtr->height - dim)/2; ! 1622: Tk_Fill3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 1623: menuPtr->border, x, y, dim, dim, ! 1624: menuPtr->activeBorderWidth, TK_RELIEF_SUNKEN); ! 1625: x += menuPtr->activeBorderWidth; ! 1626: y += menuPtr->activeBorderWidth; ! 1627: dim -= 2*menuPtr->activeBorderWidth; ! 1628: if ((dim > 0) && (mePtr->flags & ENTRY_SELECTED)) { ! 1629: XFillRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 1630: menuPtr->selectorGC, x, y, (unsigned int) dim, ! 1631: (unsigned int) dim); ! 1632: } ! 1633: } ! 1634: ! 1635: /* ! 1636: * Draw radio-button selector. ! 1637: */ ! 1638: ! 1639: if (mePtr->type == RADIO_BUTTON_ENTRY) { ! 1640: XPoint points[4]; ! 1641: int radius; ! 1642: ! 1643: radius = mePtr->selectorDiameter/2; ! 1644: points[0].x = menuPtr->borderWidth ! 1645: + (menuPtr->selectorSpace - mePtr->selectorDiameter)/2; ! 1646: points[0].y = mePtr->y + (mePtr->height)/2; ! 1647: points[1].x = points[0].x + radius; ! 1648: points[1].y = points[0].y + radius; ! 1649: points[2].x = points[1].x + radius; ! 1650: points[2].y = points[0].y; ! 1651: points[3].x = points[1].x; ! 1652: points[3].y = points[0].y - radius; ! 1653: if (mePtr->flags & ENTRY_SELECTED) { ! 1654: XFillPolygon(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 1655: menuPtr->selectorGC, points, 4, Convex, ! 1656: CoordModeOrigin); ! 1657: } else { ! 1658: Tk_Fill3DPolygon(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 1659: menuPtr->border, points, 4, menuPtr->activeBorderWidth, ! 1660: TK_RELIEF_FLAT); ! 1661: } ! 1662: Tk_Draw3DPolygon(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 1663: menuPtr->border, points, 4, menuPtr->activeBorderWidth, ! 1664: TK_RELIEF_SUNKEN); ! 1665: } ! 1666: ! 1667: /* ! 1668: * Draw separator. ! 1669: */ ! 1670: ! 1671: if (mePtr->type == SEPARATOR_ENTRY) { ! 1672: XPoint points[2]; ! 1673: int margin; ! 1674: ! 1675: margin = (fontPtr->ascent + fontPtr->descent)/2; ! 1676: points[0].x = 2*menuPtr->borderWidth + margin; ! 1677: points[0].y = mePtr->y + mePtr->height/2; ! 1678: points[1].x = Tk_Width(tkwin) - 2*menuPtr->borderWidth - margin; ! 1679: points[1].y = points[0].y; ! 1680: Tk_Draw3DPolygon(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 1681: menuPtr->border, points, 2, 1, TK_RELIEF_RAISED); ! 1682: } ! 1683: ! 1684: /* ! 1685: * If the entry is disabled with a stipple rather than a special ! 1686: * foreground color, generate the stippled effect. ! 1687: */ ! 1688: ! 1689: if ((mePtr->state == tkDisabledUid) && (menuPtr->disabledFg == NULL)) { ! 1690: XFillRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 1691: menuPtr->disabledGC, menuPtr->borderWidth, ! 1692: mePtr->y, ! 1693: (unsigned) (Tk_Width(tkwin) - 2*menuPtr->borderWidth), ! 1694: (unsigned) mePtr->height); ! 1695: } ! 1696: } ! 1697: ! 1698: Tk_Draw3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 1699: menuPtr->border, 0, 0, Tk_Width(tkwin), Tk_Height(tkwin), ! 1700: menuPtr->borderWidth, TK_RELIEF_RAISED); ! 1701: } ! 1702: ! 1703: /* ! 1704: *-------------------------------------------------------------- ! 1705: * ! 1706: * GetMenuIndex -- ! 1707: * ! 1708: * Parse a textual index into a menu and return the numerical ! 1709: * index of the indicated entry. ! 1710: * ! 1711: * Results: ! 1712: * A standard Tcl result. If all went well, then *indexPtr is ! 1713: * filled in with the entry index corresponding to string ! 1714: * (ranges from -1 to the number of entries in the menu minus ! 1715: * one). Otherwise an error message is left in interp->result. ! 1716: * ! 1717: * Side effects: ! 1718: * None. ! 1719: * ! 1720: *-------------------------------------------------------------- ! 1721: */ ! 1722: ! 1723: static int ! 1724: GetMenuIndex(interp, menuPtr, string, indexPtr) ! 1725: Tcl_Interp *interp; /* For error messages. */ ! 1726: Menu *menuPtr; /* Menu for which the index is being ! 1727: * specified. */ ! 1728: char *string; /* Specification of an entry in menu. See ! 1729: * manual entry for valid .*/ ! 1730: int *indexPtr; /* Where to store converted relief. */ ! 1731: { ! 1732: int i, y; ! 1733: ! 1734: if ((string[0] == 'a') && (strcmp(string, "active") == 0)) { ! 1735: *indexPtr = menuPtr->active; ! 1736: return TCL_OK; ! 1737: } ! 1738: ! 1739: if ((string[0] == 'l') && (strcmp(string, "last") == 0)) { ! 1740: *indexPtr = menuPtr->numEntries-1; ! 1741: return TCL_OK; ! 1742: } ! 1743: ! 1744: if ((string[0] == 'n') && (strcmp(string, "none") == 0)) { ! 1745: *indexPtr = -1; ! 1746: return TCL_OK; ! 1747: } ! 1748: ! 1749: if (string[0] == '@') { ! 1750: if (Tcl_GetInt(interp, string+1, &y) == TCL_OK) { ! 1751: if (y < 0) { ! 1752: *indexPtr = -1; ! 1753: return TCL_OK; ! 1754: } ! 1755: for (i = 0; i < menuPtr->numEntries; i++) { ! 1756: y -= menuPtr->entries[i]->height; ! 1757: if (y < 0) { ! 1758: break; ! 1759: } ! 1760: } ! 1761: if (i >= menuPtr->numEntries) { ! 1762: i = -1; ! 1763: } ! 1764: *indexPtr = i; ! 1765: return TCL_OK; ! 1766: } else { ! 1767: Tcl_SetResult(interp, (char *) NULL, TCL_STATIC); ! 1768: } ! 1769: } ! 1770: ! 1771: if (isdigit(string[0])) { ! 1772: if (Tcl_GetInt(interp, string, &i) == TCL_OK) { ! 1773: if ((i < menuPtr->numEntries) && (i >= 0)) { ! 1774: *indexPtr = i; ! 1775: return TCL_OK; ! 1776: } ! 1777: } else { ! 1778: Tcl_SetResult(interp, (char *) NULL, TCL_STATIC); ! 1779: } ! 1780: } ! 1781: ! 1782: for (i = 0; i < menuPtr->numEntries; i++) { ! 1783: char *label; ! 1784: ! 1785: label = menuPtr->entries[i]->label; ! 1786: if ((label != NULL) ! 1787: && (Tcl_StringMatch(menuPtr->entries[i]->label, string))) { ! 1788: *indexPtr = i; ! 1789: return TCL_OK; ! 1790: } ! 1791: } ! 1792: ! 1793: Tcl_AppendResult(interp, "bad menu entry index \"", ! 1794: string, "\"", (char *) NULL); ! 1795: return TCL_ERROR; ! 1796: } ! 1797: ! 1798: /* ! 1799: *-------------------------------------------------------------- ! 1800: * ! 1801: * MenuEventProc -- ! 1802: * ! 1803: * This procedure is invoked by the Tk dispatcher for various ! 1804: * events on menus. ! 1805: * ! 1806: * Results: ! 1807: * None. ! 1808: * ! 1809: * Side effects: ! 1810: * When the window gets deleted, internal structures get ! 1811: * cleaned up. When it gets exposed, it is redisplayed. ! 1812: * ! 1813: *-------------------------------------------------------------- ! 1814: */ ! 1815: ! 1816: static void ! 1817: MenuEventProc(clientData, eventPtr) ! 1818: ClientData clientData; /* Information about window. */ ! 1819: XEvent *eventPtr; /* Information about event. */ ! 1820: { ! 1821: Menu *menuPtr = (Menu *) clientData; ! 1822: if ((eventPtr->type == Expose) && (eventPtr->xexpose.count == 0)) { ! 1823: EventuallyRedrawMenu(menuPtr, -1); ! 1824: } else if (eventPtr->type == DestroyNotify) { ! 1825: Tcl_DeleteCommand(menuPtr->interp, Tk_PathName(menuPtr->tkwin)); ! 1826: ! 1827: /* ! 1828: * Careful! Must delete the event-sharing information here ! 1829: * rather than in DestroyMenu. By the time that procedure ! 1830: * is called the tkwin may have been reused, resulting in some ! 1831: * other window accidentally being cut off from shared events. ! 1832: */ ! 1833: ! 1834: Tk_UnshareEvents(menuPtr->tkwin, menuPtr->group); ! 1835: menuPtr->tkwin = NULL; ! 1836: if (menuPtr->flags & REDRAW_PENDING) { ! 1837: Tk_CancelIdleCall(DisplayMenu, (ClientData) menuPtr); ! 1838: } ! 1839: if (menuPtr->flags & RESIZE_PENDING) { ! 1840: Tk_CancelIdleCall(ComputeMenuGeometry, (ClientData) menuPtr); ! 1841: } ! 1842: Tk_EventuallyFree((ClientData) menuPtr, DestroyMenu); ! 1843: } ! 1844: } ! 1845: ! 1846: /* ! 1847: *-------------------------------------------------------------- ! 1848: * ! 1849: * MenuVarProc -- ! 1850: * ! 1851: * This procedure is invoked when someone changes the ! 1852: * state variable associated with a radiobutton or checkbutton ! 1853: * menu entry. The entry's selected state is set to match ! 1854: * the value of the variable. ! 1855: * ! 1856: * Results: ! 1857: * NULL is always returned. ! 1858: * ! 1859: * Side effects: ! 1860: * The menu entry may become selected or deselected. ! 1861: * ! 1862: *-------------------------------------------------------------- ! 1863: */ ! 1864: ! 1865: /* ARGSUSED */ ! 1866: static char * ! 1867: MenuVarProc(clientData, interp, name1, name2, flags) ! 1868: ClientData clientData; /* Information about menu entry. */ ! 1869: Tcl_Interp *interp; /* Interpreter containing variable. */ ! 1870: char *name1; /* First part of variable's name. */ ! 1871: char *name2; /* Second part of variable's name. */ ! 1872: int flags; /* Describes what just happened. */ ! 1873: { ! 1874: MenuEntry *mePtr = (MenuEntry *) clientData; ! 1875: Menu *menuPtr; ! 1876: char *value; ! 1877: ! 1878: menuPtr = mePtr->menuPtr; ! 1879: ! 1880: /* ! 1881: * If the variable is being unset, then re-establish the ! 1882: * trace unless the whole interpreter is going away. ! 1883: */ ! 1884: ! 1885: if (flags & TCL_TRACE_UNSETS) { ! 1886: mePtr->flags &= ~ENTRY_SELECTED; ! 1887: if ((flags & TCL_TRACE_DESTROYED) && !(flags & TCL_INTERP_DESTROYED)) { ! 1888: Tcl_TraceVar2(interp, name1, name2, ! 1889: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 1890: MenuVarProc, clientData); ! 1891: } ! 1892: EventuallyRedrawMenu(menuPtr, -1); ! 1893: return (char *) NULL; ! 1894: } ! 1895: ! 1896: /* ! 1897: * Use the value of the variable to update the selected status of ! 1898: * the menu entry. ! 1899: */ ! 1900: ! 1901: value = Tcl_GetVar2(interp, name1, name2, flags & TCL_GLOBAL_ONLY); ! 1902: if (strcmp(value, mePtr->onValue) == 0) { ! 1903: if (mePtr->flags & ENTRY_SELECTED) { ! 1904: return (char *) NULL; ! 1905: } ! 1906: mePtr->flags |= ENTRY_SELECTED; ! 1907: } else if (mePtr->flags & ENTRY_SELECTED) { ! 1908: mePtr->flags &= ~ENTRY_SELECTED; ! 1909: } else { ! 1910: return (char *) NULL; ! 1911: } ! 1912: EventuallyRedrawMenu(menuPtr, -1); ! 1913: return (char *) NULL; ! 1914: } ! 1915: ! 1916: /* ! 1917: *---------------------------------------------------------------------- ! 1918: * ! 1919: * EventuallyRedrawMenu -- ! 1920: * ! 1921: * Arrange for an entry of a menu, or the whole menu, to be ! 1922: * redisplayed at some point in the future. ! 1923: * ! 1924: * Results: ! 1925: * None. ! 1926: * ! 1927: * Side effects: ! 1928: * A when-idle hander is scheduled to do the redisplay, if there ! 1929: * isn't one already scheduled. ! 1930: * ! 1931: *---------------------------------------------------------------------- ! 1932: */ ! 1933: ! 1934: static void ! 1935: EventuallyRedrawMenu(menuPtr, index) ! 1936: register Menu *menuPtr; /* Information about menu to redraw. */ ! 1937: int index; /* Which entry to redraw. If -1, then ! 1938: * all the entries in the menu are redrawn. */ ! 1939: { ! 1940: if (menuPtr->tkwin == NULL) { ! 1941: return; ! 1942: } ! 1943: if (index != -1) { ! 1944: menuPtr->entries[index]->flags |= ENTRY_NEEDS_REDISPLAY; ! 1945: } else { ! 1946: for (index = 0; index < menuPtr->numEntries; index++) { ! 1947: menuPtr->entries[index]->flags |= ENTRY_NEEDS_REDISPLAY; ! 1948: } ! 1949: } ! 1950: if ((menuPtr->tkwin == NULL) || !Tk_IsMapped(menuPtr->tkwin) ! 1951: || (menuPtr->flags & REDRAW_PENDING)) { ! 1952: return; ! 1953: } ! 1954: Tk_DoWhenIdle(DisplayMenu, (ClientData) menuPtr); ! 1955: menuPtr->flags |= REDRAW_PENDING; ! 1956: } ! 1957: ! 1958: /* ! 1959: *-------------------------------------------------------------- ! 1960: * ! 1961: * PostSubmenu -- ! 1962: * ! 1963: * This procedure arranges for a particular submenu (i.e. the ! 1964: * menu corresponding to a given cascade entry) to be ! 1965: * posted. ! 1966: * ! 1967: * Results: ! 1968: * A standard Tcl return result. Errors may occur in the ! 1969: * Tcl commands generated to post and unpost submenus. ! 1970: * ! 1971: * Side effects: ! 1972: * If there is already a submenu posted, it is unposted. ! 1973: * The new submenu is then posted. ! 1974: * ! 1975: *-------------------------------------------------------------- ! 1976: */ ! 1977: ! 1978: static int ! 1979: PostSubmenu(interp, menuPtr, mePtr) ! 1980: Tcl_Interp *interp; /* Used for invoking sub-commands and ! 1981: * reporting errors. */ ! 1982: register Menu *menuPtr; /* Information about menu as a whole. */ ! 1983: register MenuEntry *mePtr; /* Info about submenu that is to be ! 1984: * posted. NULL means make sure that ! 1985: * no submenu is posted. */ ! 1986: { ! 1987: char string[30]; ! 1988: int result, x, y; ! 1989: ! 1990: if (mePtr == menuPtr->postedCascade) { ! 1991: return TCL_OK; ! 1992: } ! 1993: ! 1994: if (menuPtr->postedCascade != NULL) { ! 1995: result = Tcl_VarEval(interp, menuPtr->postedCascade->name, ! 1996: " unpost", (char *) NULL); ! 1997: menuPtr->postedCascade = NULL; ! 1998: if (result != TCL_OK) { ! 1999: return result; ! 2000: } ! 2001: } ! 2002: ! 2003: if ((mePtr != NULL) && (mePtr->name != NULL)) { ! 2004: Tk_GetRootCoords(menuPtr->tkwin, &x, &y); ! 2005: x += Tk_Width(menuPtr->tkwin); ! 2006: y += mePtr->y; ! 2007: sprintf(string, "%d %d ", x, y); ! 2008: result = Tcl_VarEval(interp, mePtr->name, " post ", string, ! 2009: menuPtr->group, (char *) NULL); ! 2010: if (result != TCL_OK) { ! 2011: return result; ! 2012: } ! 2013: menuPtr->postedCascade = mePtr; ! 2014: } ! 2015: return TCL_OK; ! 2016: } ! 2017: ! 2018: /* ! 2019: *---------------------------------------------------------------------- ! 2020: * ! 2021: * ActivateMenuEntry -- ! 2022: * ! 2023: * This procedure is invoked to make a particular menu entry ! 2024: * the active one, deactivating any other entry that might ! 2025: * currently be active. ! 2026: * ! 2027: * Results: ! 2028: * The return value is a standard Tcl result (errors can occur ! 2029: * while posting and unposting submenus). ! 2030: * ! 2031: * Side effects: ! 2032: * Menu entries get redisplayed, and the active entry changes. ! 2033: * Submenus may get posted and unposted. ! 2034: * ! 2035: *---------------------------------------------------------------------- ! 2036: */ ! 2037: ! 2038: static int ! 2039: ActivateMenuEntry(menuPtr, index) ! 2040: register Menu *menuPtr; /* Menu in which to activate. */ ! 2041: int index; /* Index of entry to activate, or ! 2042: * -1 to deactivate all entries. */ ! 2043: { ! 2044: register MenuEntry *mePtr; ! 2045: int result = TCL_OK; ! 2046: ! 2047: if (menuPtr->active >= 0) { ! 2048: mePtr = menuPtr->entries[menuPtr->active]; ! 2049: ! 2050: /* ! 2051: * Don't change the state unless it's currently active (state ! 2052: * might already have been changed to disabled). ! 2053: */ ! 2054: ! 2055: if (mePtr->state == tkActiveUid) { ! 2056: mePtr->state = tkNormalUid; ! 2057: } ! 2058: EventuallyRedrawMenu(menuPtr, menuPtr->active); ! 2059: } ! 2060: menuPtr->active = index; ! 2061: if (index >= 0) { ! 2062: mePtr = menuPtr->entries[index]; ! 2063: mePtr->state = tkActiveUid; ! 2064: EventuallyRedrawMenu(menuPtr, index); ! 2065: Tk_Preserve((ClientData) mePtr); ! 2066: if (mePtr->type == CASCADE_ENTRY) { ! 2067: result = PostSubmenu(menuPtr->interp, menuPtr, mePtr); ! 2068: } else { ! 2069: result = PostSubmenu(menuPtr->interp, menuPtr, (MenuEntry *) NULL); ! 2070: } ! 2071: Tk_Release((ClientData) mePtr); ! 2072: } ! 2073: return result; ! 2074: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.