![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkmnbut.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 tkmnbut.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 ! root 1: /* ! 2: * tkMenubutton.c -- ! 3: * ! 4: * This module implements button-like widgets that are used ! 5: * to invoke pull-down menus. ! 6: * ! 7: * Copyright 1990 Regents of the University of California. ! 8: * Permission to use, copy, modify, and distribute this ! 9: * software and its documentation for any purpose and without ! 10: * fee is hereby granted, provided that the above copyright ! 11: * notice appear in all copies. The University of California ! 12: * makes no representations about the suitability of this ! 13: * software for any purpose. It is provided "as is" without ! 14: * express or implied warranty. ! 15: */ ! 16: ! 17: #ifndef lint ! 18: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkMenubutton.c,v 1.33 92/08/21 16:21:47 ouster Exp $ SPRITE (Berkeley)"; ! 19: #endif ! 20: ! 21: #include "tkconfig.h" ! 22: #include "default.h" ! 23: #include "tkint.h" ! 24: ! 25: /* ! 26: * A data structure of the following type is kept for each ! 27: * widget managed by this file: ! 28: */ ! 29: ! 30: typedef struct { ! 31: Tk_Window tkwin; /* Window that embodies the widget. NULL ! 32: * means that the window has been destroyed ! 33: * but the data structures haven't yet been ! 34: * cleaned up.*/ ! 35: Tcl_Interp *interp; /* Interpreter associated with menu button. */ ! 36: char *menuName; /* Name of menu associated with widget (used ! 37: * to generate post and unpost commands). ! 38: * Malloc-ed. */ ! 39: Tk_Uid varName; /* Name of variable associated with collection ! 40: * of menu bars: used to allow scanning of ! 41: * menus. Also used as identifier for ! 42: * menu group. */ ! 43: ! 44: /* ! 45: * Information about what's displayed in the menu button: ! 46: */ ! 47: ! 48: char *text; /* Text to display in button (malloc'ed) ! 49: * or NULL. */ ! 50: int textLength; /* # of characters in text. */ ! 51: int underline; /* Index of character to underline. */ ! 52: char *textVarName; /* Name of variable (malloc'ed) or NULL. ! 53: * If non-NULL, button displays the contents ! 54: * of this variable. */ ! 55: Pixmap bitmap; /* Bitmap to display or None. If not None ! 56: * then text and textVar and underline ! 57: * are ignored. */ ! 58: ! 59: /* ! 60: * Information used when displaying widget: ! 61: */ ! 62: ! 63: Tk_Uid state; /* State of button for display purposes: ! 64: * normal, active, or disabled. */ ! 65: Tk_3DBorder normalBorder; /* Structure used to draw 3-D ! 66: * border and background when window ! 67: * isn't active. NULL means no such ! 68: * border exists. */ ! 69: Tk_3DBorder activeBorder; /* Structure used to draw 3-D ! 70: * border and background when window ! 71: * is active. NULL means no such ! 72: * border exists. */ ! 73: int borderWidth; /* Width of border. */ ! 74: int relief; /* 3-d effect: TK_RELIEF_RAISED, etc. */ ! 75: XFontStruct *fontPtr; /* Information about text font, or NULL. */ ! 76: XColor *normalFg; /* Foreground color in normal mode. */ ! 77: XColor *activeFg; /* Foreground color in active mode. NULL ! 78: * means use normalFg instead. */ ! 79: XColor *disabledFg; /* Foreground color when disabled. NULL ! 80: * means use normalFg with a 50% stipple ! 81: * instead. */ ! 82: GC normalTextGC; /* GC for drawing text in normal mode. */ ! 83: GC activeTextGC; /* GC for drawing text in active mode (NULL ! 84: * means use normalTextGC). */ ! 85: Pixmap gray; /* Pixmap for displaying disabled text/icon if ! 86: * disabledFg is NULL. */ ! 87: GC disabledGC; /* Used to produce disabled effect. If ! 88: * disabledFg isn't NULL, this GC is used to ! 89: * draw button text or icon. Otherwise ! 90: * text or icon is drawn with normalGC and ! 91: * this GC is used to stipple background ! 92: * across it. */ ! 93: int leftBearing; /* Amount text sticks left from its origin, ! 94: * in pixels. */ ! 95: int rightBearing; /* Amount text sticks right from its origin. */ ! 96: int width, height; /* If > 0, these specify dimensions to request ! 97: * for window, in characters for text and in ! 98: * pixels for bitmaps. In this case the actual ! 99: * size of the text string or bitmap is ! 100: * ignored in computing desired window size. */ ! 101: int padX, padY; /* Extra space around text or bitmap (pixels ! 102: * on each side). */ ! 103: Tk_Anchor anchor; /* Where text/bitmap should be displayed ! 104: * inside window region. */ ! 105: ! 106: /* ! 107: * Miscellaneous information: ! 108: */ ! 109: ! 110: Cursor cursor; /* Current cursor for window, or None. */ ! 111: int flags; /* Various flags; see below for ! 112: * definitions. */ ! 113: } MenuButton; ! 114: ! 115: /* ! 116: * Flag bits for buttons: ! 117: * ! 118: * REDRAW_PENDING: Non-zero means a DoWhenIdle handler ! 119: * has already been queued to redraw ! 120: * this window. ! 121: * POSTED: Non-zero means that the menu associated ! 122: * with this button has been posted (typically ! 123: * because of an active button press). ! 124: */ ! 125: ! 126: #define REDRAW_PENDING 1 ! 127: #define POSTED 2 ! 128: ! 129: /* ! 130: * Information used for parsing configuration specs: ! 131: */ ! 132: ! 133: static Tk_ConfigSpec configSpecs[] = { ! 134: {TK_CONFIG_BORDER, "-activebackground", "activeBackground", "Foreground", ! 135: DEF_MENUBUTTON_ACTIVE_BG_COLOR, Tk_Offset(MenuButton, activeBorder), ! 136: TK_CONFIG_COLOR_ONLY}, ! 137: {TK_CONFIG_BORDER, "-activebackground", "activeBackground", "Foreground", ! 138: DEF_MENUBUTTON_ACTIVE_BG_MONO, Tk_Offset(MenuButton, activeBorder), ! 139: TK_CONFIG_MONO_ONLY}, ! 140: {TK_CONFIG_COLOR, "-activeforeground", "activeForeground", "Background", ! 141: DEF_MENUBUTTON_ACTIVE_FG_COLOR, Tk_Offset(MenuButton, activeFg), ! 142: TK_CONFIG_COLOR_ONLY}, ! 143: {TK_CONFIG_COLOR, "-activeforeground", "activeForeground", "Background", ! 144: DEF_MENUBUTTON_ACTIVE_FG_MONO, Tk_Offset(MenuButton, activeFg), ! 145: TK_CONFIG_MONO_ONLY}, ! 146: {TK_CONFIG_ANCHOR, "-anchor", "anchor", "Anchor", ! 147: DEF_MENUBUTTON_ANCHOR, Tk_Offset(MenuButton, anchor), 0}, ! 148: {TK_CONFIG_BORDER, "-background", "background", "Background", ! 149: DEF_MENUBUTTON_BG_COLOR, Tk_Offset(MenuButton, normalBorder), ! 150: TK_CONFIG_COLOR_ONLY}, ! 151: {TK_CONFIG_BORDER, "-background", "background", "Background", ! 152: DEF_MENUBUTTON_BG_MONO, Tk_Offset(MenuButton, normalBorder), ! 153: TK_CONFIG_MONO_ONLY}, ! 154: {TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL, ! 155: (char *) NULL, 0, 0}, ! 156: {TK_CONFIG_SYNONYM, "-bg", "background", (char *) NULL, ! 157: (char *) NULL, 0, 0}, ! 158: #if defined(USE_XPM3) ! 159: {TK_CONFIG_PIXMAP, "-bitmap", "bitmap", "Bitmap", ! 160: DEF_MENUBUTTON_BITMAP, Tk_Offset(MenuButton, bitmap), ! 161: TK_CONFIG_NULL_OK}, ! 162: #else ! 163: {TK_CONFIG_BITMAP, "-bitmap", "bitmap", "Bitmap", ! 164: DEF_MENUBUTTON_BITMAP, Tk_Offset(MenuButton, bitmap), ! 165: TK_CONFIG_NULL_OK}, ! 166: #endif ! 167: {TK_CONFIG_PIXELS, "-borderwidth", "borderWidth", "BorderWidth", ! 168: DEF_MENUBUTTON_BORDER_WIDTH, Tk_Offset(MenuButton, borderWidth), 0}, ! 169: {TK_CONFIG_ACTIVE_CURSOR, "-cursor", "cursor", "Cursor", ! 170: DEF_MENUBUTTON_CURSOR, Tk_Offset(MenuButton, cursor), ! 171: TK_CONFIG_NULL_OK}, ! 172: {TK_CONFIG_COLOR, "-disabledforeground", "disabledForeground", ! 173: "DisabledForeground", DEF_MENUBUTTON_DISABLED_FG_COLOR, ! 174: Tk_Offset(MenuButton, disabledFg), ! 175: TK_CONFIG_COLOR_ONLY|TK_CONFIG_NULL_OK}, ! 176: {TK_CONFIG_COLOR, "-disabledforeground", "disabledForeground", ! 177: "DisabledForeground", DEF_MENUBUTTON_DISABLED_FG_MONO, ! 178: Tk_Offset(MenuButton, disabledFg), ! 179: TK_CONFIG_MONO_ONLY|TK_CONFIG_NULL_OK}, ! 180: {TK_CONFIG_SYNONYM, "-fg", "foreground", (char *) NULL, ! 181: (char *) NULL, 0, 0}, ! 182: {TK_CONFIG_FONT, "-font", "font", "Font", ! 183: DEF_MENUBUTTON_FONT, Tk_Offset(MenuButton, fontPtr), 0}, ! 184: {TK_CONFIG_COLOR, "-foreground", "foreground", "Foreground", ! 185: DEF_MENUBUTTON_FG, Tk_Offset(MenuButton, normalFg), 0}, ! 186: {TK_CONFIG_INT, "-height", "height", "Height", ! 187: DEF_MENUBUTTON_HEIGHT, Tk_Offset(MenuButton, height), 0}, ! 188: {TK_CONFIG_STRING, "-menu", "menu", "Menu", ! 189: DEF_MENUBUTTON_MENU, Tk_Offset(MenuButton, menuName), 0}, ! 190: {TK_CONFIG_PIXELS, "-padx", "padX", "Pad", ! 191: DEF_MENUBUTTON_PADX, Tk_Offset(MenuButton, padX), 0}, ! 192: {TK_CONFIG_PIXELS, "-pady", "padY", "Pad", ! 193: DEF_MENUBUTTON_PADY, Tk_Offset(MenuButton, padY), 0}, ! 194: {TK_CONFIG_RELIEF, "-relief", "relief", "Relief", ! 195: DEF_MENUBUTTON_RELIEF, Tk_Offset(MenuButton, relief), 0}, ! 196: {TK_CONFIG_UID, "-state", "state", "State", ! 197: DEF_MENUBUTTON_STATE, Tk_Offset(MenuButton, state), 0}, ! 198: {TK_CONFIG_STRING, "-text", "text", "Text", ! 199: DEF_MENUBUTTON_TEXT, Tk_Offset(MenuButton, text), 0}, ! 200: {TK_CONFIG_STRING, "-textvariable", "textVariable", "Variable", ! 201: DEF_MENUBUTTON_TEXT_VARIABLE, Tk_Offset(MenuButton, textVarName), ! 202: TK_CONFIG_NULL_OK}, ! 203: {TK_CONFIG_INT, "-underline", "underline", "Underline", ! 204: DEF_MENUBUTTON_UNDERLINE, Tk_Offset(MenuButton, underline), 0}, ! 205: {TK_CONFIG_UID, "-variable", "variable", "Variable", ! 206: DEF_MENUBUTTON_VARIABLE, Tk_Offset(MenuButton, varName), 0}, ! 207: {TK_CONFIG_INT, "-width", "width", "Width", ! 208: DEF_MENUBUTTON_WIDTH, Tk_Offset(MenuButton, width), 0}, ! 209: {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL, ! 210: (char *) NULL, 0, 0} ! 211: }; ! 212: ! 213: /* ! 214: * Forward declarations for procedures defined later in this file: ! 215: */ ! 216: ! 217: static void ComputeMenuButtonGeometry _ANSI_ARGS_(( ! 218: MenuButton *mbPtr)); ! 219: static void MenuButtonEventProc _ANSI_ARGS_((ClientData clientData, ! 220: XEvent *eventPtr)); ! 221: static char * MenuButtonTextVarProc _ANSI_ARGS_(( ! 222: ClientData clientData, Tcl_Interp *interp, ! 223: char *name1, char *name2, int flags)); ! 224: static char * MenuButtonVarProc _ANSI_ARGS_((ClientData clientData, ! 225: Tcl_Interp *interp, char *name1, char *name2, ! 226: int flags)); ! 227: static int MenuButtonWidgetCmd _ANSI_ARGS_((ClientData clientData, ! 228: Tcl_Interp *interp, int argc, char **argv)); ! 229: static int ConfigureMenuButton _ANSI_ARGS_((Tcl_Interp *interp, ! 230: MenuButton *mbPtr, int argc, char **argv, ! 231: int flags)); ! 232: static void DestroyMenuButton _ANSI_ARGS_((ClientData clientData)); ! 233: static void DisplayMenuButton _ANSI_ARGS_((ClientData clientData)); ! 234: ! 235: /* ! 236: *-------------------------------------------------------------- ! 237: * ! 238: * Tk_MenubuttonCmd -- ! 239: * ! 240: * This procedure is invoked to process the "button", "label", ! 241: * "radiobutton", and "checkbutton" Tcl commands. See the ! 242: * user documentation for details on what it does. ! 243: * ! 244: * Results: ! 245: * A standard Tcl result. ! 246: * ! 247: * Side effects: ! 248: * See the user documentation. ! 249: * ! 250: *-------------------------------------------------------------- ! 251: */ ! 252: ! 253: int ! 254: Tk_MenubuttonCmd(clientData, interp, argc, argv) ! 255: ClientData clientData; /* Main window associated with ! 256: * interpreter. */ ! 257: Tcl_Interp *interp; /* Current interpreter. */ ! 258: int argc; /* Number of arguments. */ ! 259: char **argv; /* Argument strings. */ ! 260: { ! 261: register MenuButton *mbPtr; ! 262: Tk_Window tkwin = (Tk_Window) clientData; ! 263: Tk_Window new; ! 264: ! 265: if (argc < 2) { ! 266: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 267: argv[0], " pathName ?options?\"", (char *) NULL); ! 268: return TCL_ERROR; ! 269: } ! 270: ! 271: /* ! 272: * Create the new window. ! 273: */ ! 274: ! 275: new = Tk_CreateWindowFromPath(interp, tkwin, argv[1], (char *) NULL); ! 276: if (new == NULL) { ! 277: return TCL_ERROR; ! 278: } ! 279: ! 280: /* ! 281: * Initialize the data structure for the button. ! 282: */ ! 283: ! 284: mbPtr = (MenuButton *) ckalloc(sizeof(MenuButton)); ! 285: mbPtr->tkwin = new; ! 286: mbPtr->interp = interp; ! 287: mbPtr->menuName = NULL; ! 288: mbPtr->varName = NULL; ! 289: mbPtr->text = NULL; ! 290: mbPtr->underline = -1; ! 291: mbPtr->textVarName = NULL; ! 292: mbPtr->bitmap = None; ! 293: mbPtr->state = tkNormalUid; ! 294: mbPtr->normalBorder = NULL; ! 295: mbPtr->activeBorder = NULL; ! 296: mbPtr->borderWidth = 0; ! 297: mbPtr->relief = TK_RELIEF_FLAT; ! 298: mbPtr->fontPtr = NULL; ! 299: mbPtr->normalFg = NULL; ! 300: mbPtr->activeFg = NULL; ! 301: mbPtr->disabledFg = NULL; ! 302: mbPtr->normalTextGC = NULL; ! 303: mbPtr->activeTextGC = NULL; ! 304: mbPtr->gray = None; ! 305: mbPtr->disabledGC = NULL; ! 306: mbPtr->cursor = None; ! 307: mbPtr->flags = 0; ! 308: ! 309: Tk_SetClass(mbPtr->tkwin, "Menubutton"); ! 310: Tk_CreateEventHandler(mbPtr->tkwin, ExposureMask|StructureNotifyMask, ! 311: MenuButtonEventProc, (ClientData) mbPtr); ! 312: Tcl_CreateCommand(interp, Tk_PathName(mbPtr->tkwin), MenuButtonWidgetCmd, ! 313: (ClientData) mbPtr, (void (*)()) NULL); ! 314: if (ConfigureMenuButton(interp, mbPtr, argc-2, argv+2, 0) != TCL_OK) { ! 315: Tk_DestroyWindow(mbPtr->tkwin); ! 316: return TCL_ERROR; ! 317: } ! 318: ! 319: interp->result = Tk_PathName(mbPtr->tkwin); ! 320: return TCL_OK; ! 321: } ! 322: ! 323: /* ! 324: *-------------------------------------------------------------- ! 325: * ! 326: * MenuButtonWidgetCmd -- ! 327: * ! 328: * This procedure is invoked to process the Tcl command ! 329: * that corresponds to a widget managed by this module. ! 330: * See the user documentation for details on what it does. ! 331: * ! 332: * Results: ! 333: * A standard Tcl result. ! 334: * ! 335: * Side effects: ! 336: * See the user documentation. ! 337: * ! 338: *-------------------------------------------------------------- ! 339: */ ! 340: ! 341: static int ! 342: MenuButtonWidgetCmd(clientData, interp, argc, argv) ! 343: ClientData clientData; /* Information about button widget. */ ! 344: Tcl_Interp *interp; /* Current interpreter. */ ! 345: int argc; /* Number of arguments. */ ! 346: char **argv; /* Argument strings. */ ! 347: { ! 348: register MenuButton *mbPtr = (MenuButton *) clientData; ! 349: int result = TCL_OK; ! 350: int length; ! 351: char c; ! 352: ! 353: if (argc < 2) { ! 354: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], ! 355: " option ?arg arg ...?\"", (char *) NULL); ! 356: return TCL_ERROR; ! 357: } ! 358: Tk_Preserve((ClientData) mbPtr); ! 359: c = argv[1][0]; ! 360: length = strlen(argv[1]); ! 361: if ((c == 'a') && (strncmp(argv[1], "activate", length) == 0)) { ! 362: if (argc > 2) { ! 363: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 364: argv[0], " activate\"", (char *) NULL); ! 365: goto error; ! 366: } ! 367: if (mbPtr->state != tkDisabledUid) { ! 368: mbPtr->state = tkActiveUid; ! 369: Tk_SetBackgroundFromBorder(mbPtr->tkwin, mbPtr->activeBorder); ! 370: goto redisplay; ! 371: } ! 372: } else if ((c == 'c') && (strncmp(argv[1], "configure", length) == 0)) { ! 373: if (argc == 2) { ! 374: result = Tk_ConfigureInfo(interp, mbPtr->tkwin, configSpecs, ! 375: (char *) mbPtr, (char *) NULL, 0); ! 376: } else if (argc == 3) { ! 377: result = Tk_ConfigureInfo(interp, mbPtr->tkwin, configSpecs, ! 378: (char *) mbPtr, argv[2], 0); ! 379: } else { ! 380: result = ConfigureMenuButton(interp, mbPtr, argc-2, argv+2, ! 381: TK_CONFIG_ARGV_ONLY); ! 382: } ! 383: } else if ((c == 'd') && (strncmp(argv[1], "deactivate", length) == 0)) { ! 384: if (argc > 2) { ! 385: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 386: argv[0], " deactivate\"", (char *) NULL); ! 387: goto error; ! 388: } ! 389: if (mbPtr->state != tkDisabledUid) { ! 390: mbPtr->state = tkNormalUid; ! 391: Tk_SetBackgroundFromBorder(mbPtr->tkwin, mbPtr->normalBorder); ! 392: goto redisplay; ! 393: } ! 394: } else if ((c == 'p') && (strncmp(argv[1], "post", length) == 0)) { ! 395: if (argc > 2) { ! 396: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 397: argv[0], " post\"", (char *) NULL); ! 398: goto error; ! 399: } ! 400: if ((mbPtr->flags & POSTED) || (mbPtr->menuName == NULL) ! 401: || (mbPtr->state == tkDisabledUid)) { ! 402: goto done; ! 403: } ! 404: ! 405: /* ! 406: * Store the name of the posted menu into the associated variable. ! 407: * This will cause any other menu posted via that variable to ! 408: * unpost itself and will cause this menu to post itself. ! 409: */ ! 410: ! 411: Tcl_SetVar(interp, mbPtr->varName, Tk_PathName(mbPtr->tkwin), ! 412: TCL_GLOBAL_ONLY); ! 413: } else if ((c == 'u') && (strncmp(argv[1], "unpost", length) == 0)) { ! 414: if (argc > 2) { ! 415: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 416: argv[0], " unpost\"", (char *) NULL); ! 417: goto error; ! 418: } ! 419: ! 420: /* ! 421: * The one-liner below looks simple, but it isn't. This code ! 422: * does the right thing even if this menu isn't posted anymore, ! 423: * but some other variable associated with the same variable ! 424: * is posted instead: it unposts whatever is posted. This ! 425: * approach is necessary because at present ButtonRelease ! 426: * events go to the menu button where the mouse button was ! 427: * first pressed; this may not be the same menu button that's ! 428: * currently active. ! 429: */ ! 430: Tcl_SetVar(interp, mbPtr->varName, "", TCL_GLOBAL_ONLY); ! 431: } else { ! 432: Tcl_AppendResult(interp, "bad option \"", argv[1], ! 433: "\": must be activate, configure, deactivate, ", ! 434: "post, or unpost", (char *) NULL); ! 435: goto error; ! 436: } ! 437: done: ! 438: Tk_Release((ClientData) mbPtr); ! 439: return result; ! 440: ! 441: redisplay: ! 442: if (Tk_IsMapped(mbPtr->tkwin) && !(mbPtr->flags & REDRAW_PENDING)) { ! 443: Tk_DoWhenIdle(DisplayMenuButton, (ClientData) mbPtr); ! 444: mbPtr->flags |= REDRAW_PENDING; ! 445: } ! 446: goto done; ! 447: ! 448: error: ! 449: Tk_Release((ClientData) mbPtr); ! 450: return TCL_ERROR; ! 451: } ! 452: ! 453: /* ! 454: *---------------------------------------------------------------------- ! 455: * ! 456: * DestroyMenuButton -- ! 457: * ! 458: * This procedure is invoked to recycle all of the resources ! 459: * associated with a button widget. It is invoked as a ! 460: * when-idle handler in order to make sure that there is no ! 461: * other use of the button pending at the time of the deletion. ! 462: * ! 463: * Results: ! 464: * None. ! 465: * ! 466: * Side effects: ! 467: * Everything associated with the widget is freed up. ! 468: * ! 469: *---------------------------------------------------------------------- ! 470: */ ! 471: ! 472: static void ! 473: DestroyMenuButton(clientData) ! 474: ClientData clientData; /* Info about button widget. */ ! 475: { ! 476: register MenuButton *mbPtr = (MenuButton *) clientData; ! 477: if (mbPtr->menuName != NULL) { ! 478: ckfree(mbPtr->menuName); ! 479: } ! 480: if (mbPtr->varName != NULL) { ! 481: Tcl_UntraceVar(mbPtr->interp, mbPtr->varName, ! 482: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 483: MenuButtonVarProc, (ClientData) mbPtr); ! 484: } ! 485: if (mbPtr->text != NULL) { ! 486: ckfree(mbPtr->text); ! 487: } ! 488: if (mbPtr->textVarName != NULL) { ! 489: Tcl_UntraceVar(mbPtr->interp, mbPtr->textVarName, ! 490: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 491: MenuButtonTextVarProc, (ClientData) mbPtr); ! 492: ckfree(mbPtr->textVarName); ! 493: } ! 494: if (mbPtr->bitmap != None) { ! 495: #if defined(USE_XPM3) ! 496: Tk_FreePixmap(mbPtr->bitmap); ! 497: #else ! 498: Tk_FreeBitmap(mbPtr->bitmap); ! 499: #endif ! 500: } ! 501: if (mbPtr->normalBorder != NULL) { ! 502: Tk_Free3DBorder(mbPtr->normalBorder); ! 503: } ! 504: if (mbPtr->activeBorder != NULL) { ! 505: Tk_Free3DBorder(mbPtr->activeBorder); ! 506: } ! 507: if (mbPtr->fontPtr != NULL) { ! 508: Tk_FreeFontStruct(mbPtr->fontPtr); ! 509: } ! 510: if (mbPtr->normalFg != NULL) { ! 511: Tk_FreeColor(mbPtr->normalFg); ! 512: } ! 513: if (mbPtr->activeFg != NULL) { ! 514: Tk_FreeColor(mbPtr->activeFg); ! 515: } ! 516: if (mbPtr->disabledFg != NULL) { ! 517: Tk_FreeColor(mbPtr->disabledFg); ! 518: } ! 519: if (mbPtr->normalTextGC != None) { ! 520: Tk_FreeGC(mbPtr->normalTextGC); ! 521: } ! 522: if (mbPtr->activeTextGC != None) { ! 523: Tk_FreeGC(mbPtr->activeTextGC); ! 524: } ! 525: if (mbPtr->gray != None) { ! 526: Tk_FreeBitmap(mbPtr->gray); ! 527: } ! 528: if (mbPtr->disabledGC != None) { ! 529: Tk_FreeGC(mbPtr->disabledGC); ! 530: } ! 531: if (mbPtr->cursor != None) { ! 532: Tk_FreeCursor(mbPtr->cursor); ! 533: } ! 534: ckfree((char *) mbPtr); ! 535: } ! 536: ! 537: /* ! 538: *---------------------------------------------------------------------- ! 539: * ! 540: * ConfigureMenuButton -- ! 541: * ! 542: * This procedure is called to process an argv/argc list, plus ! 543: * the Tk option database, in order to configure (or ! 544: * reconfigure) a menubutton widget. ! 545: * ! 546: * Results: ! 547: * The return value is a standard Tcl result. If TCL_ERROR is ! 548: * returned, then interp->result contains an error message. ! 549: * ! 550: * Side effects: ! 551: * Configuration information, such as text string, colors, font, ! 552: * etc. get set for mbPtr; old resources get freed, if there ! 553: * were any. The menubutton is redisplayed. ! 554: * ! 555: *---------------------------------------------------------------------- ! 556: */ ! 557: ! 558: static int ! 559: ConfigureMenuButton(interp, mbPtr, argc, argv, flags) ! 560: Tcl_Interp *interp; /* Used for error reporting. */ ! 561: register MenuButton *mbPtr; /* Information about widget; may or may ! 562: * not already have values for some fields. */ ! 563: int argc; /* Number of valid entries in argv. */ ! 564: char **argv; /* Arguments. */ ! 565: int flags; /* Flags to pass to Tk_ConfigureWidget. */ ! 566: { ! 567: XGCValues gcValues; ! 568: GC newGC; ! 569: unsigned long mask; ! 570: int result; ! 571: Tk_Uid oldGroup; ! 572: char *value; ! 573: ! 574: /* ! 575: * Eliminate any existing traces on variables monitored by the button. ! 576: */ ! 577: ! 578: if (mbPtr->varName != NULL) { ! 579: Tcl_UntraceVar(interp, mbPtr->varName, ! 580: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 581: MenuButtonVarProc, (ClientData) mbPtr); ! 582: } ! 583: if (mbPtr->textVarName != NULL) { ! 584: Tcl_UntraceVar(interp, mbPtr->textVarName, ! 585: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 586: MenuButtonTextVarProc, (ClientData) mbPtr); ! 587: } ! 588: ! 589: oldGroup = mbPtr->varName; ! 590: result = Tk_ConfigureWidget(interp, mbPtr->tkwin, configSpecs, ! 591: argc, argv, (char *) mbPtr, flags); ! 592: if (oldGroup != mbPtr->varName) { ! 593: Tk_UnshareEvents(mbPtr->tkwin, oldGroup); ! 594: Tk_ShareEvents(mbPtr->tkwin, mbPtr->varName); ! 595: } ! 596: if (result != TCL_OK) { ! 597: return TCL_ERROR; ! 598: } ! 599: ! 600: /* ! 601: * A few options need special processing, such as setting the ! 602: * background from a 3-D border, or filling in complicated ! 603: * defaults that couldn't be specified to Tk_ConfigureWidget. ! 604: */ ! 605: ! 606: if (mbPtr->state == tkActiveUid) { ! 607: Tk_SetBackgroundFromBorder(mbPtr->tkwin, mbPtr->activeBorder); ! 608: } else { ! 609: Tk_SetBackgroundFromBorder(mbPtr->tkwin, mbPtr->normalBorder); ! 610: if ((mbPtr->state != tkNormalUid) && (mbPtr->state != tkDisabledUid)) { ! 611: Tcl_AppendResult(interp, "bad state value \"", mbPtr->state, ! 612: "\": must be normal, active, or disabled", (char *) NULL); ! 613: mbPtr->state = tkNormalUid; ! 614: return TCL_ERROR; ! 615: } ! 616: } ! 617: ! 618: gcValues.font = mbPtr->fontPtr->fid; ! 619: gcValues.foreground = mbPtr->normalFg->pixel; ! 620: gcValues.background = Tk_3DBorderColor(mbPtr->normalBorder)->pixel; ! 621: ! 622: /* ! 623: * Note: GraphicsExpose events are disabled in GC's because they're ! 624: * used to copy stuff from an off-screen pixmap onto the screen (we know ! 625: * that there's no problem with obscured areas). ! 626: */ ! 627: ! 628: gcValues.graphics_exposures = False; ! 629: newGC = Tk_GetGC(mbPtr->tkwin, ! 630: GCForeground|GCBackground|GCFont|GCGraphicsExposures, &gcValues); ! 631: if (mbPtr->normalTextGC != None) { ! 632: Tk_FreeGC(mbPtr->normalTextGC); ! 633: } ! 634: mbPtr->normalTextGC = newGC; ! 635: ! 636: gcValues.font = mbPtr->fontPtr->fid; ! 637: gcValues.foreground = mbPtr->activeFg->pixel; ! 638: gcValues.background = Tk_3DBorderColor(mbPtr->activeBorder)->pixel; ! 639: newGC = Tk_GetGC(mbPtr->tkwin, GCForeground|GCBackground|GCFont, ! 640: &gcValues); ! 641: if (mbPtr->activeTextGC != None) { ! 642: Tk_FreeGC(mbPtr->activeTextGC); ! 643: } ! 644: mbPtr->activeTextGC = newGC; ! 645: ! 646: gcValues.font = mbPtr->fontPtr->fid; ! 647: gcValues.background = Tk_3DBorderColor(mbPtr->normalBorder)->pixel; ! 648: if (mbPtr->disabledFg != NULL) { ! 649: gcValues.foreground = mbPtr->disabledFg->pixel; ! 650: mask = GCForeground|GCBackground|GCFont; ! 651: } else { ! 652: gcValues.foreground = gcValues.background; ! 653: if (mbPtr->gray == None) { ! 654: mbPtr->gray = Tk_GetBitmap(interp, mbPtr->tkwin, ! 655: Tk_GetUid("gray50")); ! 656: if (mbPtr->gray == None) { ! 657: return TCL_ERROR; ! 658: } ! 659: } ! 660: gcValues.fill_style = FillStippled; ! 661: gcValues.stipple = mbPtr->gray; ! 662: mask = GCForeground|GCFillStyle|GCStipple; ! 663: } ! 664: newGC = Tk_GetGC(mbPtr->tkwin, mask, &gcValues); ! 665: if (mbPtr->disabledGC != None) { ! 666: Tk_FreeGC(mbPtr->disabledGC); ! 667: } ! 668: mbPtr->disabledGC = newGC; ! 669: ! 670: if (mbPtr->padX < 0) { ! 671: mbPtr->padX = 0; ! 672: } ! 673: if (mbPtr->padY < 0) { ! 674: mbPtr->padY = 0; ! 675: } ! 676: ! 677: /* ! 678: * Set up a trace on the menu button's variable, then initialize ! 679: * the variable if it doesn't already exist, so that it can be ! 680: * accessed immediately from Tcl code without fear of ! 681: * "nonexistent variable" errors. ! 682: */ ! 683: ! 684: value = Tcl_GetVar(interp, mbPtr->varName, TCL_GLOBAL_ONLY); ! 685: if (value == NULL) { ! 686: Tcl_SetVar(interp, mbPtr->varName, "", TCL_GLOBAL_ONLY); ! 687: } ! 688: Tcl_TraceVar(interp, mbPtr->varName, ! 689: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 690: MenuButtonVarProc, (ClientData) mbPtr); ! 691: ! 692: /* ! 693: * Set up a trace on the variable that determines what's displayed ! 694: * in the menu button, if such a trace has been requested. ! 695: */ ! 696: ! 697: if ((mbPtr->bitmap == None) && (mbPtr->textVarName != NULL)) { ! 698: char *value; ! 699: ! 700: value = Tcl_GetVar(interp, mbPtr->textVarName, TCL_GLOBAL_ONLY); ! 701: if (value == NULL) { ! 702: Tcl_SetVar(interp, mbPtr->textVarName, mbPtr->text, ! 703: TCL_GLOBAL_ONLY); ! 704: } else { ! 705: if (mbPtr->text != NULL) { ! 706: ckfree(mbPtr->text); ! 707: } ! 708: mbPtr->text = ckalloc((unsigned) (strlen(value) + 1)); ! 709: strcpy(mbPtr->text, value); ! 710: } ! 711: Tcl_TraceVar(interp, mbPtr->textVarName, ! 712: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 713: MenuButtonTextVarProc, (ClientData) mbPtr); ! 714: } ! 715: ! 716: /* ! 717: * Recompute the geometry for the button. ! 718: */ ! 719: ! 720: ComputeMenuButtonGeometry(mbPtr); ! 721: ! 722: /* ! 723: * Lastly, arrange for the button to be redisplayed. ! 724: */ ! 725: ! 726: if (Tk_IsMapped(mbPtr->tkwin) && !(mbPtr->flags & REDRAW_PENDING)) { ! 727: Tk_DoWhenIdle(DisplayMenuButton, (ClientData) mbPtr); ! 728: mbPtr->flags |= REDRAW_PENDING; ! 729: } ! 730: ! 731: return TCL_OK; ! 732: } ! 733: ! 734: /* ! 735: *---------------------------------------------------------------------- ! 736: * ! 737: * DisplayMenuButton -- ! 738: * ! 739: * This procedure is invoked to display a menubutton widget. ! 740: * ! 741: * Results: ! 742: * None. ! 743: * ! 744: * Side effects: ! 745: * Commands are output to X to display the menubutton in its ! 746: * current mode. ! 747: * ! 748: *---------------------------------------------------------------------- ! 749: */ ! 750: ! 751: static void ! 752: DisplayMenuButton(clientData) ! 753: ClientData clientData; /* Information about widget. */ ! 754: { ! 755: register MenuButton *mbPtr = (MenuButton *) clientData; ! 756: GC gc; ! 757: Tk_3DBorder border; ! 758: Pixmap pixmap; ! 759: int x = 0; /* Initialization needed only to stop ! 760: * compiler warning. */ ! 761: int y; ! 762: register Tk_Window tkwin = mbPtr->tkwin; ! 763: ! 764: mbPtr->flags &= ~REDRAW_PENDING; ! 765: if ((mbPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) { ! 766: return; ! 767: } ! 768: ! 769: if ((mbPtr->state == tkDisabledUid) && (mbPtr->disabledFg != NULL)) { ! 770: gc = mbPtr->disabledGC; ! 771: border = mbPtr->normalBorder; ! 772: } else if (mbPtr->state == tkActiveUid) { ! 773: gc = mbPtr->activeTextGC; ! 774: border = mbPtr->activeBorder; ! 775: } else { ! 776: gc = mbPtr->normalTextGC; ! 777: border = mbPtr->normalBorder; ! 778: } ! 779: ! 780: /* ! 781: * In order to avoid screen flashes, this procedure redraws ! 782: * the menu button in a pixmap, then copies the pixmap to the ! 783: * screen in a single operation. This means that there's no ! 784: * point in time where the on-sreen image has been cleared. ! 785: */ ! 786: ! 787: pixmap = XCreatePixmap(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 788: Tk_Width(tkwin), Tk_Height(tkwin), ! 789: Tk_DefaultDepth(Tk_Screen(tkwin))); ! 790: Tk_Fill3DRectangle(Tk_Display(tkwin), pixmap, border, ! 791: 0, 0, Tk_Width(tkwin), Tk_Height(tkwin), 0, TK_RELIEF_FLAT); ! 792: ! 793: /* ! 794: * Display bitmap or text for button. ! 795: */ ! 796: ! 797: if (mbPtr->bitmap != None) { ! 798: unsigned int width, height; ! 799: ! 800: #if defined(USE_XPM3) ! 801: Tk_SizeOfPixmap(mbPtr->bitmap, &width, &height); ! 802: #else ! 803: Tk_SizeOfBitmap(mbPtr->bitmap, &width, &height); ! 804: #endif ! 805: switch (mbPtr->anchor) { ! 806: case TK_ANCHOR_NW: case TK_ANCHOR_W: case TK_ANCHOR_SW: ! 807: x += mbPtr->borderWidth + mbPtr->padX; ! 808: break; ! 809: case TK_ANCHOR_N: case TK_ANCHOR_CENTER: case TK_ANCHOR_S: ! 810: x += (Tk_Width(tkwin) - width)/2; ! 811: break; ! 812: default: ! 813: x += Tk_Width(tkwin) - mbPtr->borderWidth - mbPtr->padX ! 814: - width; ! 815: break; ! 816: } ! 817: switch (mbPtr->anchor) { ! 818: case TK_ANCHOR_NW: case TK_ANCHOR_N: case TK_ANCHOR_NE: ! 819: y = mbPtr->borderWidth + mbPtr->padY; ! 820: break; ! 821: case TK_ANCHOR_W: case TK_ANCHOR_CENTER: case TK_ANCHOR_E: ! 822: y = (Tk_Height(tkwin) - height)/2; ! 823: break; ! 824: default: ! 825: y = Tk_Height(tkwin) - mbPtr->borderWidth - mbPtr->padY ! 826: - height; ! 827: break; ! 828: } ! 829: #if defined(USE_XPM3) ! 830: XCopyArea(Tk_Display(tkwin), mbPtr->bitmap, pixmap, ! 831: gc, 0, 0, width, height, x, y); ! 832: #else ! 833: XCopyPlane(Tk_Display(tkwin), mbPtr->bitmap, pixmap, ! 834: gc, 0, 0, width, height, x, y, 1); ! 835: #endif ! 836: } else { ! 837: switch (mbPtr->anchor) { ! 838: case TK_ANCHOR_NW: case TK_ANCHOR_W: case TK_ANCHOR_SW: ! 839: x = mbPtr->borderWidth + mbPtr->padX + mbPtr->leftBearing; ! 840: break; ! 841: case TK_ANCHOR_N: case TK_ANCHOR_CENTER: case TK_ANCHOR_S: ! 842: x = (Tk_Width(tkwin) + mbPtr->leftBearing ! 843: - mbPtr->rightBearing)/2; ! 844: break; ! 845: default: ! 846: x = Tk_Width(tkwin) - mbPtr->borderWidth - mbPtr->padX ! 847: - mbPtr->rightBearing; ! 848: break; ! 849: } ! 850: switch (mbPtr->anchor) { ! 851: case TK_ANCHOR_NW: case TK_ANCHOR_N: case TK_ANCHOR_NE: ! 852: y = mbPtr->borderWidth + mbPtr->fontPtr->ascent ! 853: + mbPtr->padY; ! 854: break; ! 855: case TK_ANCHOR_W: case TK_ANCHOR_CENTER: case TK_ANCHOR_E: ! 856: y = (Tk_Height(tkwin) + mbPtr->fontPtr->ascent ! 857: - mbPtr->fontPtr->descent)/2; ! 858: break; ! 859: default: ! 860: y = Tk_Height(tkwin) - mbPtr->borderWidth - mbPtr->padY ! 861: - mbPtr->fontPtr->descent; ! 862: break; ! 863: } ! 864: XDrawString(Tk_Display(tkwin), pixmap, gc, x, y, mbPtr->text, ! 865: mbPtr->textLength); ! 866: if (mbPtr->underline >= 0) { ! 867: TkUnderlineChars(Tk_Display(tkwin), pixmap, gc, mbPtr->fontPtr, ! 868: mbPtr->text, x, y, TK_NEWLINES_NOT_SPECIAL, ! 869: mbPtr->underline, mbPtr->underline); ! 870: } ! 871: } ! 872: ! 873: /* ! 874: * If the menu button is disabled with a stipple rather than a special ! 875: * foreground color, generate the stippled effect. ! 876: */ ! 877: ! 878: if ((mbPtr->state == tkDisabledUid) && (mbPtr->disabledFg == NULL)) { ! 879: XFillRectangle(Tk_Display(tkwin), pixmap, mbPtr->disabledGC, ! 880: mbPtr->borderWidth, mbPtr->borderWidth, ! 881: (unsigned) (Tk_Width(tkwin) - 2*mbPtr->borderWidth), ! 882: (unsigned) (Tk_Height(tkwin) - 2*mbPtr->borderWidth)); ! 883: } ! 884: ! 885: /* ! 886: * Draw the border last. This way, if the menu button's contents ! 887: * overflow onto the border they'll be covered up by the border. ! 888: */ ! 889: ! 890: if (mbPtr->relief != TK_RELIEF_FLAT) { ! 891: Tk_Draw3DRectangle(Tk_Display(tkwin), pixmap, border, ! 892: 0, 0, Tk_Width(tkwin), Tk_Height(tkwin), ! 893: mbPtr->borderWidth, mbPtr->relief); ! 894: } ! 895: ! 896: /* ! 897: * Copy the information from the off-screen pixmap onto the screen, ! 898: * then delete the pixmap. ! 899: */ ! 900: ! 901: XCopyArea(Tk_Display(tkwin), pixmap, Tk_WindowId(tkwin), ! 902: mbPtr->normalTextGC, 0, 0, Tk_Width(tkwin), Tk_Height(tkwin), 0, 0); ! 903: XFreePixmap(Tk_Display(tkwin), pixmap); ! 904: } ! 905: ! 906: /* ! 907: *-------------------------------------------------------------- ! 908: * ! 909: * MenuButtonEventProc -- ! 910: * ! 911: * This procedure is invoked by the Tk dispatcher for various ! 912: * events on buttons. ! 913: * ! 914: * Results: ! 915: * None. ! 916: * ! 917: * Side effects: ! 918: * When the window gets deleted, internal structures get ! 919: * cleaned up. When it gets exposed, it is redisplayed. ! 920: * ! 921: *-------------------------------------------------------------- ! 922: */ ! 923: ! 924: static void ! 925: MenuButtonEventProc(clientData, eventPtr) ! 926: ClientData clientData; /* Information about window. */ ! 927: XEvent *eventPtr; /* Information about event. */ ! 928: { ! 929: MenuButton *mbPtr = (MenuButton *) clientData; ! 930: if ((eventPtr->type == Expose) && (eventPtr->xexpose.count == 0)) { ! 931: if ((mbPtr->tkwin != NULL) && !(mbPtr->flags & REDRAW_PENDING)) { ! 932: Tk_DoWhenIdle(DisplayMenuButton, (ClientData) mbPtr); ! 933: mbPtr->flags |= REDRAW_PENDING; ! 934: } ! 935: } else if (eventPtr->type == DestroyNotify) { ! 936: Tcl_DeleteCommand(mbPtr->interp, Tk_PathName(mbPtr->tkwin)); ! 937: ! 938: /* ! 939: * Careful! Must delete the event-sharing information here ! 940: * rather than in DestroyMenuButton. By the time that procedure ! 941: * is called the tkwin may have been reused, resulting in some ! 942: * other window accidentally being cut off from shared events. ! 943: */ ! 944: ! 945: Tk_UnshareEvents(mbPtr->tkwin, mbPtr->varName); ! 946: mbPtr->tkwin = NULL; ! 947: if (mbPtr->flags & REDRAW_PENDING) { ! 948: Tk_CancelIdleCall(DisplayMenuButton, (ClientData) mbPtr); ! 949: } ! 950: Tk_EventuallyFree((ClientData) mbPtr, DestroyMenuButton); ! 951: } ! 952: } ! 953: ! 954: /* ! 955: *---------------------------------------------------------------------- ! 956: * ! 957: * ComputeMenuButtonGeometry -- ! 958: * ! 959: * After changes in a menu button's text or bitmap, this procedure ! 960: * recomputes the menu button's geometry and passes this information ! 961: * along to the geometry manager for the window. ! 962: * ! 963: * Results: ! 964: * None. ! 965: * ! 966: * Side effects: ! 967: * The menu button's window may change size. ! 968: * ! 969: *---------------------------------------------------------------------- ! 970: */ ! 971: ! 972: static void ! 973: ComputeMenuButtonGeometry(mbPtr) ! 974: register MenuButton *mbPtr; /* Widget record for menu button. */ ! 975: { ! 976: XCharStruct bbox; ! 977: int dummy; ! 978: unsigned int width, height; ! 979: ! 980: if (mbPtr->bitmap != None) { ! 981: #if defined(USE_XPM3) ! 982: Tk_SizeOfPixmap(mbPtr->bitmap, &width, &height); ! 983: #else ! 984: Tk_SizeOfBitmap(mbPtr->bitmap, &width, &height); ! 985: #endif ! 986: if (mbPtr->width > 0) { ! 987: width = mbPtr->width; ! 988: } ! 989: if (mbPtr->height > 0) { ! 990: height = mbPtr->height; ! 991: } ! 992: } else { ! 993: mbPtr->textLength = strlen(mbPtr->text); ! 994: XTextExtents(mbPtr->fontPtr, mbPtr->text, mbPtr->textLength, ! 995: &dummy, &dummy, &dummy, &bbox); ! 996: mbPtr->leftBearing = bbox.lbearing; ! 997: mbPtr->rightBearing = bbox.rbearing; ! 998: width = bbox.lbearing + bbox.rbearing; ! 999: height = mbPtr->fontPtr->ascent + mbPtr->fontPtr->descent; ! 1000: if (mbPtr->width > 0) { ! 1001: width = mbPtr->width * XTextWidth(mbPtr->fontPtr, "0", 1); ! 1002: } ! 1003: if (mbPtr->height > 0) { ! 1004: height *= mbPtr->height; ! 1005: } ! 1006: } ! 1007: ! 1008: width += 2*mbPtr->padX; ! 1009: height += 2*mbPtr->padY; ! 1010: Tk_GeometryRequest(mbPtr->tkwin, (int) (width + 2*mbPtr->borderWidth), ! 1011: (int) (height + 2*mbPtr->borderWidth)); ! 1012: Tk_SetInternalBorder(mbPtr->tkwin, mbPtr->borderWidth); ! 1013: } ! 1014: ! 1015: /* ! 1016: *-------------------------------------------------------------- ! 1017: * ! 1018: * MenuButtonVarProc -- ! 1019: * ! 1020: * This procedure is invoked when someone changes the ! 1021: * state variable associated with a menubutton. This causes ! 1022: * the posted/unposted state of the menu to change if needed ! 1023: * to match the variable's new value. ! 1024: * ! 1025: * Results: ! 1026: * NULL is always returned. ! 1027: * ! 1028: * Side effects: ! 1029: * The menu may be posted or unposted. ! 1030: * ! 1031: *-------------------------------------------------------------- ! 1032: */ ! 1033: ! 1034: /* ARGSUSED */ ! 1035: static char * ! 1036: MenuButtonVarProc(clientData, interp, name1, name2, flags) ! 1037: ClientData clientData; /* Information about button. */ ! 1038: Tcl_Interp *interp; /* Interpreter containing variable. */ ! 1039: char *name1; /* First part of variable's name. */ ! 1040: char *name2; /* Second part of variable's name. */ ! 1041: int flags; /* Describes what's happening to variable. */ ! 1042: { ! 1043: register MenuButton *mbPtr = (MenuButton *) clientData; ! 1044: char *value; ! 1045: int newFlags; ! 1046: ! 1047: /* ! 1048: * If the variable is being unset, then just re-establish the ! 1049: * trace unless the whole interpreter is going away. Also unpost ! 1050: * the menu. ! 1051: */ ! 1052: ! 1053: newFlags = mbPtr->flags; ! 1054: if (flags & TCL_TRACE_UNSETS) { ! 1055: newFlags &= ~POSTED; ! 1056: if ((flags & TCL_TRACE_DESTROYED) && !(flags & TCL_INTERP_DESTROYED)) { ! 1057: Tcl_TraceVar2(interp, name1, name2, ! 1058: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 1059: MenuButtonVarProc, clientData); ! 1060: } ! 1061: } else { ! 1062: ! 1063: /* ! 1064: * Use the value of the variable to update the posted status of ! 1065: * the menu. ! 1066: */ ! 1067: ! 1068: value = Tcl_GetVar2(interp, name1, name2, flags & TCL_GLOBAL_ONLY); ! 1069: if (strcmp(value, Tk_PathName(mbPtr->tkwin)) == 0) { ! 1070: newFlags |= POSTED; ! 1071: } else { ! 1072: newFlags &= ~POSTED; ! 1073: } ! 1074: } ! 1075: ! 1076: if ((mbPtr->menuName != NULL) && (newFlags != mbPtr->flags)) { ! 1077: mbPtr->flags = newFlags; ! 1078: if (newFlags & POSTED) { ! 1079: int x, y; ! 1080: char string[50]; ! 1081: ! 1082: /* ! 1083: * Post the menu just below the menu button. ! 1084: */ ! 1085: ! 1086: Tk_GetRootCoords(mbPtr->tkwin, &x, &y); ! 1087: y += Tk_Height(mbPtr->tkwin); ! 1088: sprintf(string, "%d %d ", x, y); ! 1089: if (Tcl_VarEval(interp, mbPtr->menuName, " post ", string, ! 1090: mbPtr->varName, (char *) NULL) != TCL_OK) { ! 1091: TkBindError(interp); ! 1092: } ! 1093: } else { ! 1094: if (Tcl_VarEval(interp, mbPtr->menuName, " unpost", ! 1095: (char *) NULL) != TCL_OK) { ! 1096: TkBindError(interp); ! 1097: } ! 1098: } ! 1099: } ! 1100: return (char *) NULL; ! 1101: } ! 1102: ! 1103: /* ! 1104: *-------------------------------------------------------------- ! 1105: * ! 1106: * MenuButtonTextVarProc -- ! 1107: * ! 1108: * This procedure is invoked when someone changes the variable ! 1109: * whose contents are to be displayed in a menu button. ! 1110: * ! 1111: * Results: ! 1112: * NULL is always returned. ! 1113: * ! 1114: * Side effects: ! 1115: * The text displayed in the menu button will change to match the ! 1116: * variable. ! 1117: * ! 1118: *-------------------------------------------------------------- ! 1119: */ ! 1120: ! 1121: /* ARGSUSED */ ! 1122: static char * ! 1123: MenuButtonTextVarProc(clientData, interp, name1, name2, flags) ! 1124: ClientData clientData; /* Information about button. */ ! 1125: Tcl_Interp *interp; /* Interpreter containing variable. */ ! 1126: char *name1; /* Name of variable. */ ! 1127: char *name2; /* Second part of variable name. */ ! 1128: int flags; /* Information about what happened. */ ! 1129: { ! 1130: register MenuButton *mbPtr = (MenuButton *) clientData; ! 1131: char *value; ! 1132: ! 1133: /* ! 1134: * If the variable is unset, then immediately recreate it unless ! 1135: * the whole interpreter is going away. ! 1136: */ ! 1137: ! 1138: if (flags & TCL_TRACE_UNSETS) { ! 1139: if ((flags & TCL_TRACE_DESTROYED) && !(flags & TCL_INTERP_DESTROYED)) { ! 1140: Tcl_SetVar2(interp, name1, name2, mbPtr->text, ! 1141: flags & TCL_GLOBAL_ONLY); ! 1142: Tcl_TraceVar2(interp, name1, name2, ! 1143: TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS, ! 1144: MenuButtonTextVarProc, clientData); ! 1145: } ! 1146: return (char *) NULL; ! 1147: } ! 1148: ! 1149: value = Tcl_GetVar2(interp, name1, name2, flags & TCL_GLOBAL_ONLY); ! 1150: if (value == NULL) { ! 1151: value = ""; ! 1152: } ! 1153: if (mbPtr->text != NULL) { ! 1154: ckfree(mbPtr->text); ! 1155: } ! 1156: mbPtr->text = ckalloc((unsigned) (strlen(value) + 1)); ! 1157: strcpy(mbPtr->text, value); ! 1158: ComputeMenuButtonGeometry(mbPtr); ! 1159: ! 1160: if ((mbPtr->tkwin != NULL) && Tk_IsMapped(mbPtr->tkwin) ! 1161: && !(mbPtr->flags & REDRAW_PENDING)) { ! 1162: Tk_DoWhenIdle(DisplayMenuButton, (ClientData) mbPtr); ! 1163: mbPtr->flags |= REDRAW_PENDING; ! 1164: } ! 1165: return (char *) NULL; ! 1166: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.