开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
tkMenubutton.c
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：29k
源码类别：

通讯编程

开发平台：

Visual C++

tkMenubutton.c：源码内容
  1. /* 
  2.  * tkMenubutton.c --
  3.  *
  4.  * This module implements button-like widgets that are used
  5.  * to invoke pull-down menus.
  6.  *
  7.  * Copyright (c) 1990-1994 The Regents of the University of California.
  8.  * Copyright (c) 1994-1997 Sun Microsystems, Inc.
  9.  *
  10.  * See the file "license.terms" for information on usage and redistribution
  11.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  12.  *
  13.  * RCS: @(#) $Id: tkMenubutton.c,v 1.12.2.2 2007/12/13 23:13:52 hobbs Exp $
  14.  */
  16. #include "tkMenubutton.h"
  17. #include "tkPort.h"
  18. #include "default.h"
  20. /*
  21.  * The following table defines the legal values for the -direction 
  22.  * option.  It is used together with the "enum direction" declaration 
  23.  * in tkMenubutton.h.
  24.  */
  26. static char *directionStrings[] = {
  27.     "above", "below", "flush", "left", "right", (char *) NULL
  28. };
  30. /*
  31.  * The following table defines the legal values for the -state option.
  32.  * It is used together with the "enum state" declaration in tkMenubutton.h.
  33.  */
  35. static char *stateStrings[] = {
  36.     "active", "disabled", "normal", (char *) NULL
  37. };
  39. /*
  40.  * The following table defines the legal values for the -compound option.
  41.  * It is used with the "enum compound" declaration in tkMenuButton.h
  42.  */
  44. static char *compoundStrings[] = {
  45.     "bottom", "center", "left", "none", "right", "top", (char *) NULL
  46. };
  48. /*
  49.  * Information used for parsing configuration specs:
  50.  */
  52. static Tk_OptionSpec optionSpecs[] = {
  53.     {TK_OPTION_BORDER, "-activebackground", "activeBackground", "Foreground",
  54.         DEF_MENUBUTTON_ACTIVE_BG_COLOR, -1, 
  55.         Tk_Offset(TkMenuButton, activeBorder), 0, 
  56.         (ClientData) DEF_MENUBUTTON_ACTIVE_BG_MONO, 0},
  57.     {TK_OPTION_COLOR, "-activeforeground", "activeForeground", "Background",
  58. DEF_MENUBUTTON_ACTIVE_FG_COLOR, -1, 
  59.          Tk_Offset(TkMenuButton, activeFg),
  60.          0, (ClientData) DEF_MENUBUTTON_ACTIVE_FG_MONO, 0},
  61.     {TK_OPTION_ANCHOR, "-anchor", "anchor", "Anchor",
  62. DEF_MENUBUTTON_ANCHOR, -1, 
  63.         Tk_Offset(TkMenuButton, anchor), 0, 0, 0},
  64.     {TK_OPTION_BORDER, "-background", "background", "Background",
  65. DEF_MENUBUTTON_BG_COLOR, -1, Tk_Offset(TkMenuButton, normalBorder),
  66.         0, (ClientData) DEF_MENUBUTTON_BG_MONO, 0},
  67.     {TK_OPTION_SYNONYM, "-bd", (char *) NULL, (char *) NULL,
  68. (char *) NULL, 0, -1, 0, (ClientData) "-borderwidth", 0},
  69.     {TK_OPTION_SYNONYM, "-bg", (char *) NULL, (char *) NULL,
  70. (char *) NULL, 0, -1, 0, (ClientData) "-background", 0},
  71.     {TK_OPTION_BITMAP, "-bitmap", "bitmap", "Bitmap",
  72. DEF_MENUBUTTON_BITMAP, -1, Tk_Offset(TkMenuButton, bitmap),
  73. TK_OPTION_NULL_OK, 0, 0},
  74.     {TK_OPTION_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
  75. DEF_MENUBUTTON_BORDER_WIDTH, -1, 
  76.         Tk_Offset(TkMenuButton, borderWidth), 0, 0, 0},
  77.     {TK_OPTION_CURSOR, "-cursor", "cursor", "Cursor",
  78. DEF_MENUBUTTON_CURSOR, -1, Tk_Offset(TkMenuButton, cursor),
  79. TK_OPTION_NULL_OK, 0, 0},
  80.     {TK_OPTION_STRING_TABLE, "-direction", "direction", "Direction",
  81.      DEF_MENUBUTTON_DIRECTION, -1, Tk_Offset(TkMenuButton, direction), 
  82. 0, (ClientData) directionStrings, 0},
  83.     {TK_OPTION_COLOR, "-disabledforeground", "disabledForeground",
  84. "DisabledForeground", DEF_MENUBUTTON_DISABLED_FG_COLOR,
  85. -1, Tk_Offset(TkMenuButton, disabledFg), TK_OPTION_NULL_OK,
  86. (ClientData) DEF_MENUBUTTON_DISABLED_FG_MONO, 0},
  87.     {TK_OPTION_SYNONYM, "-fg", "foreground", (char *) NULL,
  88. (char *) NULL, 0, -1, 0, (ClientData) "-foreground", 0},
  89.     {TK_OPTION_FONT, "-font", "font", "Font",
  90. DEF_MENUBUTTON_FONT, -1, Tk_Offset(TkMenuButton, tkfont), 0, 0, 0},
  91.     {TK_OPTION_COLOR, "-foreground", "foreground", "Foreground",
  92. DEF_MENUBUTTON_FG, -1, Tk_Offset(TkMenuButton, normalFg), 0, 0, 0},
  93.     {TK_OPTION_STRING, "-height", "height", "Height",
  94. DEF_MENUBUTTON_HEIGHT, -1, Tk_Offset(TkMenuButton, heightString), 
  95.         0, 0, 0},
  96.     {TK_OPTION_COLOR, "-highlightbackground", "highlightBackground",
  97. "HighlightBackground", DEF_MENUBUTTON_HIGHLIGHT_BG_COLOR,
  98. -1, Tk_Offset(TkMenuButton, highlightBgColorPtr), 0, 0, 0},
  99.     {TK_OPTION_COLOR, "-highlightcolor", "highlightColor", "HighlightColor",
  100. DEF_MENUBUTTON_HIGHLIGHT, -1, 
  101.         Tk_Offset(TkMenuButton, highlightColorPtr), 0, 0, 0},
  102.     {TK_OPTION_PIXELS, "-highlightthickness", "highlightThickness",
  103. "HighlightThickness", DEF_MENUBUTTON_HIGHLIGHT_WIDTH,
  104. -1, Tk_Offset(TkMenuButton, highlightWidth), 0, 0, 0},
  105.     {TK_OPTION_STRING, "-image", "image", "Image",
  106. DEF_MENUBUTTON_IMAGE, -1, Tk_Offset(TkMenuButton, imageString), 
  107. TK_OPTION_NULL_OK, 0, 0},
  108.     {TK_OPTION_BOOLEAN, "-indicatoron", "indicatorOn", "IndicatorOn",
  109. DEF_MENUBUTTON_INDICATOR, -1, Tk_Offset(TkMenuButton, indicatorOn),
  110.         0, 0, 0},
  111.     {TK_OPTION_JUSTIFY, "-justify", "justify", "Justify",
  112. DEF_BUTTON_JUSTIFY, -1, Tk_Offset(TkMenuButton, justify), 0, 0, 0},
  113.     {TK_OPTION_STRING, "-menu", "menu", "Menu",
  114. DEF_MENUBUTTON_MENU, -1, Tk_Offset(TkMenuButton, menuName), 
  115. TK_OPTION_NULL_OK, 0, 0},
  116.     {TK_OPTION_PIXELS, "-padx", "padX", "Pad",
  117. DEF_MENUBUTTON_PADX, -1, Tk_Offset(TkMenuButton, padX),
  118. 0, 0, 0},
  119.     {TK_OPTION_PIXELS, "-pady", "padY", "Pad",
  120. DEF_MENUBUTTON_PADY, -1, Tk_Offset(TkMenuButton, padY),
  121. 0, 0, 0},
  122.     {TK_OPTION_RELIEF, "-relief", "relief", "Relief",
  123. DEF_MENUBUTTON_RELIEF, -1, Tk_Offset(TkMenuButton, relief), 
  124.         0, 0, 0},
  125.     {TK_OPTION_STRING_TABLE, "-compound", "compound", "Compound",
  126.          DEF_BUTTON_COMPOUND, -1, Tk_Offset(TkMenuButton, compound), 0,
  127.          (ClientData) compoundStrings, 0},
  128.     {TK_OPTION_STRING_TABLE, "-state", "state", "State",
  129. DEF_MENUBUTTON_STATE, -1, Tk_Offset(TkMenuButton, state),
  130. 0, (ClientData) stateStrings, 0},
  131.     {TK_OPTION_STRING, "-takefocus", "takeFocus", "TakeFocus",
  132. DEF_MENUBUTTON_TAKE_FOCUS, -1, 
  133.         Tk_Offset(TkMenuButton, takeFocus), TK_OPTION_NULL_OK, 0, 0},
  134.     {TK_OPTION_STRING, "-text", "text", "Text",
  135. DEF_MENUBUTTON_TEXT, -1, Tk_Offset(TkMenuButton, text), 0, 0, 0},
  136.     {TK_OPTION_STRING, "-textvariable", "textVariable", "Variable",
  137. DEF_MENUBUTTON_TEXT_VARIABLE, -1, 
  138.         Tk_Offset(TkMenuButton, textVarName), TK_OPTION_NULL_OK, 0, 0},
  139.     {TK_OPTION_INT, "-underline", "underline", "Underline",
  140. DEF_MENUBUTTON_UNDERLINE, -1, Tk_Offset(TkMenuButton, underline),
  141.          0, 0, 0},
  142.     {TK_OPTION_STRING, "-width", "width", "Width",
  143. DEF_MENUBUTTON_WIDTH, -1, Tk_Offset(TkMenuButton, widthString), 
  144.         0, 0, 0},
  145.     {TK_OPTION_PIXELS, "-wraplength", "wrapLength", "WrapLength",
  146. DEF_MENUBUTTON_WRAP_LENGTH, -1, Tk_Offset(TkMenuButton, wrapLength),
  147.         0, 0, 0},
  148.     {TK_OPTION_END, (char *) NULL, (char *) NULL, (char *) NULL,
  149. (char *) NULL, 0, 0}
  150. };
  152. /*
  153.  * The following tables define the menubutton widget commands and map the 
  154.  * indexes into the string tables into a single enumerated type used 
  155.  * to dispatch the scale widget command.
  156.  */
  158. static CONST char *commandNames[] = {
  159.     "cget", "configure", (char *) NULL
  160. };
  162. enum command {
  163.     COMMAND_CGET, COMMAND_CONFIGURE
  164. };
  166. /*
  167.  * Forward declarations for procedures defined later in this file:
  168.  */
  170. static void MenuButtonCmdDeletedProc _ANSI_ARGS_((
  171.     ClientData clientData));
  172. static void MenuButtonEventProc _ANSI_ARGS_((ClientData clientData,
  173.     XEvent *eventPtr));
  174. static void MenuButtonImageProc _ANSI_ARGS_((ClientData clientData,
  175.     int x, int y, int width, int height, int imgWidth,
  176.     int imgHeight));
  177. static char * MenuButtonTextVarProc _ANSI_ARGS_((
  178.     ClientData clientData, Tcl_Interp *interp,
  179.     CONST char *name1, CONST char *name2, int flags));
  180. static int MenuButtonWidgetObjCmd _ANSI_ARGS_((
  181.                             ClientData clientData, Tcl_Interp *interp, 
  182.     int objc, Tcl_Obj *CONST objv[]));
  183. static int ConfigureMenuButton _ANSI_ARGS_((Tcl_Interp *interp,
  184.     TkMenuButton *mbPtr, int objc, 
  185.                             Tcl_Obj *CONST objv[]));
  186. static void DestroyMenuButton _ANSI_ARGS_((char *memPtr));
  188. /*
  189.  *--------------------------------------------------------------
  190.  *
  191.  * Tk_MenubuttonObjCmd --
  192.  *
  193.  * This procedure is invoked to process the "button", "label",
  194.  * "radiobutton", and "checkbutton" Tcl commands.  See the
  195.  * user documentation for details on what it does.
  196.  *
  197.  * Results:
  198.  * A standard Tcl result.
  199.  *
  200.  * Side effects:
  201.  * See the user documentation.
  202.  *
  203.  *--------------------------------------------------------------
  204.  */
  206. int
  207. Tk_MenubuttonObjCmd(clientData, interp, objc, objv)
  208.     ClientData clientData; /* NULL. */
  209.     Tcl_Interp *interp; /* Current interpreter. */
  210.     int objc; /* Number of arguments. */
  211.     Tcl_Obj *CONST objv[]; /* Argument objects. */
  212. {
  213.     register TkMenuButton *mbPtr;
  214.     Tk_OptionTable optionTable;
  215.     Tk_Window tkwin;
  217.     if (objc < 2) {
  218. Tcl_WrongNumArgs(interp, 1, objv, "pathName ?options?");
  219. return TCL_ERROR;
  220.     }
  222.     /*
  223.      * Create the new window.
  224.      */
  226.     tkwin = Tk_CreateWindowFromPath(interp, Tk_MainWindow(interp),
  227.     Tcl_GetString(objv[1]), (char *) NULL);
  228.     if (tkwin == NULL) {
  229. return TCL_ERROR;
  230.     }
  232.     /*
  233.      * Create the option table for this widget class.  If it has already
  234.      * been created, the cached pointer will be returned.
  235.      */
  237.     optionTable = Tk_CreateOptionTable(interp, optionSpecs);
  239.     Tk_SetClass(tkwin, "Menubutton");
  240.     mbPtr = TkpCreateMenuButton(tkwin);
  242.     Tk_SetClassProcs(tkwin, &tkpMenubuttonClass, (ClientData) mbPtr);
  244.     /*
  245.      * Initialize the data structure for the button.
  246.      */
  248.     mbPtr->tkwin = tkwin;
  249.     mbPtr->display = Tk_Display (tkwin);
  250.     mbPtr->interp = interp;
  251.     mbPtr->widgetCmd = Tcl_CreateObjCommand(interp, 
  252.             Tk_PathName(mbPtr->tkwin), MenuButtonWidgetObjCmd, 
  253.             (ClientData) mbPtr, MenuButtonCmdDeletedProc);
  254.     mbPtr->optionTable = optionTable;
  255.     mbPtr->menuName = NULL;
  256.     mbPtr->text = NULL;
  257.     mbPtr->underline = -1;
  258.     mbPtr->textVarName = NULL;
  259.     mbPtr->bitmap = None;
  260.     mbPtr->imageString = NULL;
  261.     mbPtr->image = NULL;
  262.     mbPtr->state = STATE_NORMAL;
  263.     mbPtr->normalBorder = NULL;
  264.     mbPtr->activeBorder = NULL;
  265.     mbPtr->borderWidth = 0;
  266.     mbPtr->relief = TK_RELIEF_FLAT;
  267.     mbPtr->highlightWidth = 0;
  268.     mbPtr->highlightBgColorPtr = NULL;
  269.     mbPtr->highlightColorPtr = NULL;
  270.     mbPtr->inset = 0;
  271.     mbPtr->tkfont = NULL;
  272.     mbPtr->normalFg = NULL;
  273.     mbPtr->activeFg = NULL;
  274.     mbPtr->disabledFg = NULL;
  275.     mbPtr->normalTextGC = None;
  276.     mbPtr->activeTextGC = None;
  277.     mbPtr->gray = None;
  278.     mbPtr->disabledGC = None;
  279.     mbPtr->stippleGC = None;
  280.     mbPtr->leftBearing = 0;
  281.     mbPtr->rightBearing = 0;
  282.     mbPtr->widthString = NULL;
  283.     mbPtr->heightString = NULL;
  284.     mbPtr->width = 0;
  285.     mbPtr->width = 0;
  286.     mbPtr->wrapLength = 0;
  287.     mbPtr->padX = 0;
  288.     mbPtr->padY = 0;
  289.     mbPtr->anchor = TK_ANCHOR_CENTER;
  290.     mbPtr->justify = TK_JUSTIFY_CENTER;
  291.     mbPtr->textLayout = NULL;
  292.     mbPtr->indicatorOn = 0;
  293.     mbPtr->indicatorWidth = 0;
  294.     mbPtr->indicatorHeight = 0;
  295.     mbPtr->direction = DIRECTION_FLUSH;
  296.     mbPtr->cursor = None;
  297.     mbPtr->takeFocus = NULL;
  298.     mbPtr->flags = 0;
  300.     Tk_CreateEventHandler(mbPtr->tkwin,
  301.     ExposureMask|StructureNotifyMask|FocusChangeMask,
  302.     MenuButtonEventProc, (ClientData) mbPtr);
  304.     if (Tk_InitOptions(interp, (char *) mbPtr, optionTable, tkwin) != TCL_OK) {
  305. Tk_DestroyWindow(mbPtr->tkwin);
  306. return TCL_ERROR;
  307.     }
  309.     if (ConfigureMenuButton(interp, mbPtr, objc-2, objv+2) != TCL_OK) {
  310. Tk_DestroyWindow(mbPtr->tkwin);
  311. return TCL_ERROR;
  312.     }
  314.     Tcl_SetStringObj(Tcl_GetObjResult(interp), Tk_PathName(mbPtr->tkwin), -1);
  315.     return TCL_OK;
  316. }
  318. /*
  319.  *--------------------------------------------------------------
  320.  *
  321.  * MenuButtonWidgetObjCmd --
  322.  *
  323.  * This procedure is invoked to process the Tcl command
  324.  * that corresponds to a widget managed by this module.
  325.  * See the user documentation for details on what it does.
  326.  *
  327.  * Results:
  328.  * A standard Tcl result.
  329.  *
  330.  * Side effects:
  331.  * See the user documentation.
  332.  *
  333.  *--------------------------------------------------------------
  334.  */
  336. static int
  337. MenuButtonWidgetObjCmd(clientData, interp, objc, objv)
  338.     ClientData clientData; /* Information about button widget. */
  339.     Tcl_Interp *interp; /* Current interpreter. */
  340.     int objc; /* Number of arguments. */
  341.     Tcl_Obj *CONST objv[]; /* Argument objects. */
  342. {
  343.     register TkMenuButton *mbPtr = (TkMenuButton *) clientData;
  344.     int result, index;
  345.     Tcl_Obj *objPtr;
  347.     if (objc < 2) {
  348.         Tcl_WrongNumArgs(interp, 1, objv, "option ?arg arg ...?");
  349. return TCL_ERROR;
  350.     }
  351.     result = Tcl_GetIndexFromObj(interp, objv[1], 
  352.             commandNames, "option", 0, &index);
  353.     if (result != TCL_OK) {
  354.         return result;
  355.     }
  356.     Tcl_Preserve((ClientData) mbPtr);
  358.     switch (index) {
  359.         case COMMAND_CGET: {
  360.     if (objc != 3) {
  361.         Tcl_WrongNumArgs(interp, 1, objv, "cget option");
  362.     goto error;
  363.     }
  365.     objPtr = Tk_GetOptionValue(interp, (char *) mbPtr,
  366.                     mbPtr->optionTable, objv[2], mbPtr->tkwin);
  367.     if (objPtr == NULL) {
  368.         goto error;
  369.     } else {
  370.         Tcl_SetObjResult(interp, objPtr);
  371.     }
  372.     break;
  373. }
  375.         case COMMAND_CONFIGURE: {
  376.     if (objc <= 3) {
  377. objPtr = Tk_GetOptionInfo(interp, (char *) mbPtr,
  378. mbPtr->optionTable,
  379. (objc == 3) ? objv[2] : (Tcl_Obj *) NULL,
  380. mbPtr->tkwin);
  381. if (objPtr == NULL) {
  382.     goto error;
  383. } else {
  384.     Tcl_SetObjResult(interp, objPtr);
  385. }
  386.     } else {
  387. result = ConfigureMenuButton(interp, mbPtr, objc-2, 
  388.         objv+2);
  389.     }
  390.     break;
  391. }
  392.     }
  393.     Tcl_Release((ClientData) mbPtr);
  394.     return result;
  396.     error:
  397.     Tcl_Release((ClientData) mbPtr);
  398.     return TCL_ERROR;
  399. }
  401. /*
  402.  *----------------------------------------------------------------------
  403.  *
  404.  * DestroyMenuButton --
  405.  *
  406.  * This procedure is invoked to recycle all of the resources
  407.  * associated with a menubutton widget.  It is invoked as a
  408.  * when-idle handler in order to make sure that there is no
  409.  * other use of the menubutton pending at the time of the deletion.
  410.  *
  411.  * Results:
  412.  * None.
  413.  *
  414.  * Side effects:
  415.  * Everything associated with the widget is freed up.
  416.  *
  417.  *----------------------------------------------------------------------
  418.  */
  420. static void
  421. DestroyMenuButton(memPtr)
  422.     char *memPtr; /* Info about button widget. */
  423. {
  424.     register TkMenuButton *mbPtr = (TkMenuButton *) memPtr;
  425.     TkpDestroyMenuButton(mbPtr);
  427.     if (mbPtr->flags & REDRAW_PENDING) {
  428.         Tcl_CancelIdleCall(TkpDisplayMenuButton, (ClientData) mbPtr);
  429.     }
  431.     /*
  432.      * Free up all the stuff that requires special handling, then
  433.      * let Tk_FreeOptions handle all the standard option-related
  434.      * stuff.
  435.      */
  437.     Tcl_DeleteCommandFromToken(mbPtr->interp, mbPtr->widgetCmd);
  438.     if (mbPtr->textVarName != NULL) {
  439. Tcl_UntraceVar(mbPtr->interp, mbPtr->textVarName,
  440. TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
  441. MenuButtonTextVarProc, (ClientData) mbPtr);
  442.     }
  443.     if (mbPtr->image != NULL) {
  444. Tk_FreeImage(mbPtr->image);
  445.     }
  446.     if (mbPtr->normalTextGC != None) {
  447. Tk_FreeGC(mbPtr->display, mbPtr->normalTextGC);
  448.     }
  449.     if (mbPtr->activeTextGC != None) {
  450. Tk_FreeGC(mbPtr->display, mbPtr->activeTextGC);
  451.     }
  452.     if (mbPtr->disabledGC != None) {
  453. Tk_FreeGC(mbPtr->display, mbPtr->disabledGC);
  454.     }
  455.     if (mbPtr->stippleGC != None) {
  456. Tk_FreeGC(mbPtr->display, mbPtr->stippleGC);
  457.     }
  458.     if (mbPtr->gray != None) {
  459. Tk_FreeBitmap(mbPtr->display, mbPtr->gray);
  460.     }
  461.     if (mbPtr->textLayout != NULL) {
  462.         Tk_FreeTextLayout(mbPtr->textLayout);
  463.     }
  464.     Tk_FreeConfigOptions((char *) mbPtr, mbPtr->optionTable, mbPtr->tkwin);
  465.     mbPtr->tkwin = NULL;
  466.     Tcl_EventuallyFree((ClientData) mbPtr, TCL_DYNAMIC);
  467. }
  469. /*
  470.  *----------------------------------------------------------------------
  471.  *
  472.  * ConfigureMenuButton --
  473.  *
  474.  * This procedure is called to process an argv/argc list, plus
  475.  * the Tk option database, in order to configure (or
  476.  * reconfigure) a menubutton widget.
  477.  *
  478.  * Results:
  479.  * The return value is a standard Tcl result.  If TCL_ERROR is
  480.  * returned, then the interp's result contains an error message.
  481.  *
  482.  * Side effects:
  483.  * Configuration information, such as text string, colors, font,
  484.  * etc. get set for mbPtr;  old resources get freed, if there
  485.  * were any.  The menubutton is redisplayed.
  486.  *
  487.  *----------------------------------------------------------------------
  488.  */
  490. static int
  491. ConfigureMenuButton(interp, mbPtr, objc, objv)
  492.     Tcl_Interp *interp; /* Used for error reporting. */
  493.     register TkMenuButton *mbPtr;
  494.                                 /* Information about widget;  may or may
  495.  * not already have values for some 
  496.  * fields. */
  497.     int objc; /* Number of valid entries in objv. */
  498.     Tcl_Obj *CONST objv[]; /* Arguments. */
  499. {
  500.     Tk_SavedOptions savedOptions;
  501.     Tcl_Obj *errorResult = NULL;
  502.     int error;
  503.     Tk_Image image;
  505.     /*
  506.      * Eliminate any existing trace on variables monitored by the 
  507.      * menubutton.
  508.      */
  510.     if (mbPtr->textVarName != NULL) {
  511. Tcl_UntraceVar(interp, mbPtr->textVarName, 
  512. TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
  513. MenuButtonTextVarProc, (ClientData) mbPtr);
  514.     }
  516.     /*
  517.      * The following loop is potentially executed twice.  During the
  518.      * first pass configuration options get set to their new values.
  519.      * If there is an error in this pass, we execute a second pass
  520.      * to restore all the options to their previous values.
  521.      */
  523.     for (error = 0; error <= 1; error++) {
  524. if (!error) {
  525.     /*
  526.      * First pass: set options to new values.
  527.      */
  529.     if (Tk_SetOptions(interp, (char *) mbPtr,
  530.     mbPtr->optionTable, objc, objv,
  531.     mbPtr->tkwin, &savedOptions, (int *) NULL) != TCL_OK) {
  532. continue;
  533.     }
  534. } else {
  535.     /*
  536.      * Second pass: restore options to old values.
  537.      */
  539.     errorResult = Tcl_GetObjResult(interp);
  540.     Tcl_IncrRefCount(errorResult);
  541.     Tk_RestoreSavedOptions(&savedOptions);
  542. }
  544. /*
  545.  * A few options need special processing, such as setting the
  546.  * background from a 3-D border, or filling in complicated
  547.  * defaults that couldn't be specified to Tk_SetOptions.
  548.  */
  550. if ((mbPtr->state == STATE_ACTIVE)
  551. && !Tk_StrictMotif(mbPtr->tkwin)) {
  552.     Tk_SetBackgroundFromBorder(mbPtr->tkwin, mbPtr->activeBorder);
  553. } else {
  554.     Tk_SetBackgroundFromBorder(mbPtr->tkwin, mbPtr->normalBorder);
  555. }
  557. if (mbPtr->highlightWidth < 0) {
  558.     mbPtr->highlightWidth = 0;
  559. }
  561. if (mbPtr->padX < 0) {
  562.     mbPtr->padX = 0;
  563. }
  564. if (mbPtr->padY < 0) {
  565.     mbPtr->padY = 0;
  566. }
  568. /*
  569.  * Get the image for the widget, if there is one.  Allocate the
  570.  * new image before freeing the old one, so that the reference
  571.  * count doesn't go to zero and cause image data to be discarded.
  572.  */
  574. if (mbPtr->imageString != NULL) {
  575.     image = Tk_GetImage(mbPtr->interp, mbPtr->tkwin,
  576.     mbPtr->imageString, MenuButtonImageProc, 
  577.     (ClientData) mbPtr);
  578.     if (image == NULL) {
  579.         return TCL_ERROR;
  580.     }
  581. } else {
  582.     image = NULL;
  583. }
  584. if (mbPtr->image != NULL) {
  585.     Tk_FreeImage(mbPtr->image);
  586. }
  587. mbPtr->image = image;
  589. /*
  590.  * Recompute the geometry for the button.
  591.  */
  593. if ((mbPtr->bitmap != None) || (mbPtr->image != NULL)) {
  594.     if (Tk_GetPixels(interp, mbPtr->tkwin, mbPtr->widthString,
  595.                     &mbPtr->width) != TCL_OK) {
  596.                 widthError:
  597.         Tcl_AddErrorInfo(interp, "n    (processing -width option)");
  598. continue;
  599.     }
  600.     if (Tk_GetPixels(interp, mbPtr->tkwin, mbPtr->heightString,
  601.     &mbPtr->height) != TCL_OK) {
  602.         heightError:
  603.         Tcl_AddErrorInfo(interp, "n    (processing -height option)");
  604. continue;
  605.     }
  606. } else {
  607.     if (Tcl_GetInt(interp, mbPtr->widthString, &mbPtr->width)
  608.     != TCL_OK) {
  609.         goto widthError;
  610.     }
  611.     if (Tcl_GetInt(interp, mbPtr->heightString, &mbPtr->height)
  612.     != TCL_OK) {
  613.         goto heightError;
  614.     }
  615. }
  616. break;
  617.     }
  619.     if (!error) {
  620.       Tk_FreeSavedOptions(&savedOptions);
  621.     }
  623.     if (mbPtr->textVarName != NULL) {
  624. /*
  625.  * If no image or -compound is used, display the value of a variable.
  626.  * Set up a trace to watch for any changes in it, create the variable
  627.  * if it doesn't exist, and fetch its current value.
  628.  */
  629. CONST char *value;
  631. value = Tcl_GetVar(interp, mbPtr->textVarName, TCL_GLOBAL_ONLY);
  632. if (value == NULL) {
  633.     Tcl_SetVar(interp, mbPtr->textVarName, mbPtr->text,
  634.     TCL_GLOBAL_ONLY);
  635. } else {
  636.     if (mbPtr->text != NULL) {
  637. ckfree(mbPtr->text);
  638.     }
  639.     mbPtr->text = (char *) ckalloc((unsigned) (strlen(value) + 1));
  640.     strcpy(mbPtr->text, value);
  641. }
  642. Tcl_TraceVar(interp, mbPtr->textVarName,
  643. TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
  644. MenuButtonTextVarProc, (ClientData) mbPtr);
  645.     }
  647.     TkMenuButtonWorldChanged((ClientData) mbPtr);
  648.     if (error) {
  649. Tcl_SetObjResult(interp, errorResult);
  650. Tcl_DecrRefCount(errorResult);
  651.         return TCL_ERROR;
  652.     } else {
  653.         return TCL_OK;
  654.     }
  655. }
  657. /*
  658.  *---------------------------------------------------------------------------
  659.  *
  660.  * TkMenuButtonWorldChanged --
  661.  *
  662.  *      This procedure is called when the world has changed in some
  663.  *      way and the widget needs to recompute all its graphics contexts
  664.  * and determine its new geometry.
  665.  *
  666.  * Results:
  667.  *      None.
  668.  *
  669.  * Side effects:
  670.  *      TkMenuButton will be relayed out and redisplayed.
  671.  *
  672.  *---------------------------------------------------------------------------
  673.  */
  674.  
  675. void
  676. TkMenuButtonWorldChanged(instanceData)
  677.     ClientData instanceData; /* Information about widget. */
  678. {
  679.     XGCValues gcValues;
  680.     GC gc;
  681.     unsigned long mask;
  682.     TkMenuButton *mbPtr;
  684.     mbPtr = (TkMenuButton *) instanceData;
  686.     gcValues.font = Tk_FontId(mbPtr->tkfont);
  687.     gcValues.foreground = mbPtr->normalFg->pixel;
  688.     gcValues.background = Tk_3DBorderColor(mbPtr->normalBorder)->pixel;
  690.     /*
  691.      * Note: GraphicsExpose events are disabled in GC's because they're
  692.      * used to copy stuff from an off-screen pixmap onto the screen (we know
  693.      * that there's no problem with obscured areas).
  694.      */
  696.     gcValues.graphics_exposures = False;
  697.     mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
  698.     gc = Tk_GetGC(mbPtr->tkwin, mask, &gcValues);
  699.     if (mbPtr->normalTextGC != None) {
  700. Tk_FreeGC(mbPtr->display, mbPtr->normalTextGC);
  701.     }
  702.     mbPtr->normalTextGC = gc;
  704.     gcValues.foreground = mbPtr->activeFg->pixel;
  705.     gcValues.background = Tk_3DBorderColor(mbPtr->activeBorder)->pixel;
  706.     mask = GCForeground | GCBackground | GCFont;
  707.     gc = Tk_GetGC(mbPtr->tkwin, mask, &gcValues);
  708.     if (mbPtr->activeTextGC != None) {
  709. Tk_FreeGC(mbPtr->display, mbPtr->activeTextGC);
  710.     }
  711.     mbPtr->activeTextGC = gc;
  713.     gcValues.background = Tk_3DBorderColor(mbPtr->normalBorder)->pixel;
  715.     /*
  716.      * Create the GC that can be used for stippling
  717.      */
  719.     if (mbPtr->stippleGC == None) {
  720. gcValues.foreground = gcValues.background;
  721. mask = GCForeground;
  722. if (mbPtr->gray == None) {
  723.     mbPtr->gray = Tk_GetBitmap(NULL, mbPtr->tkwin, "gray50");
  724. }
  725. if (mbPtr->gray != None) {
  726.     gcValues.fill_style = FillStippled;
  727.     gcValues.stipple = mbPtr->gray;
  728.     mask |= GCFillStyle | GCStipple;
  729. }
  730. mbPtr->stippleGC = Tk_GetGC(mbPtr->tkwin, mask, &gcValues);
  731.     }
  733.     /*
  734.      * Allocate the disabled graphics context, for drawing text in
  735.      * its disabled state.
  736.      */
  738.     mask = GCForeground | GCBackground | GCFont;
  739.     if (mbPtr->disabledFg != NULL) {
  740. gcValues.foreground = mbPtr->disabledFg->pixel;
  741.     } else {
  742. gcValues.foreground = gcValues.background;
  743.     }
  744.     gc = Tk_GetGC(mbPtr->tkwin, mask, &gcValues);
  745.     if (mbPtr->disabledGC != None) {
  746. Tk_FreeGC(mbPtr->display, mbPtr->disabledGC);
  747.     }
  748.     mbPtr->disabledGC = gc;
  750.     TkpComputeMenuButtonGeometry(mbPtr);
  752.     /*
  753.      * Lastly, arrange for the button to be redisplayed.
  754.      */
  756.     if (Tk_IsMapped(mbPtr->tkwin) && !(mbPtr->flags & REDRAW_PENDING)) {
  757. Tcl_DoWhenIdle(TkpDisplayMenuButton, (ClientData) mbPtr);
  758. mbPtr->flags |= REDRAW_PENDING;
  759.     }
  760. }
  762. /*
  763.  *--------------------------------------------------------------
  764.  *
  765.  * MenuButtonEventProc --
  766.  *
  767.  * This procedure is invoked by the Tk dispatcher for various
  768.  * events on buttons.
  769.  *
  770.  * Results:
  771.  * None.
  772.  *
  773.  * Side effects:
  774.  * When the window gets deleted, internal structures get
  775.  * cleaned up.  When it gets exposed, it is redisplayed.
  776.  *
  777.  *--------------------------------------------------------------
  778.  */
  780. static void
  781. MenuButtonEventProc(clientData, eventPtr)
  782.     ClientData clientData; /* Information about window. */
  783.     XEvent *eventPtr; /* Information about event. */
  784. {
  785.     TkMenuButton *mbPtr = (TkMenuButton *) clientData;
  786.     if ((eventPtr->type == Expose) && (eventPtr->xexpose.count == 0)) {
  787. goto redraw;
  788.     } else if (eventPtr->type == ConfigureNotify) {
  789. /*
  790.  * Must redraw after size changes, since layout could have changed
  791.  * and borders will need to be redrawn.
  792.  */
  794. goto redraw;
  795.     } else if (eventPtr->type == DestroyNotify) {
  796.         DestroyMenuButton((char *) mbPtr);
  797.     } else if (eventPtr->type == FocusIn) {
  798. if (eventPtr->xfocus.detail != NotifyInferior) {
  799.     mbPtr->flags |= GOT_FOCUS;
  800.     if (mbPtr->highlightWidth > 0) {
  801. goto redraw;
  802.     }
  803. }
  804.     } else if (eventPtr->type == FocusOut) {
  805. if (eventPtr->xfocus.detail != NotifyInferior) {
  806.     mbPtr->flags &= ~GOT_FOCUS;
  807.     if (mbPtr->highlightWidth > 0) {
  808. goto redraw;
  809.     }
  810. }
  811.     }
  812.     return;
  814.     redraw:
  815.     if ((mbPtr->tkwin != NULL) && !(mbPtr->flags & REDRAW_PENDING)) {
  816. Tcl_DoWhenIdle(TkpDisplayMenuButton, (ClientData) mbPtr);
  817. mbPtr->flags |= REDRAW_PENDING;
  818.     }
  819. }
  821. /*
  822.  *----------------------------------------------------------------------
  823.  *
  824.  * MenuButtonCmdDeletedProc --
  825.  *
  826.  * This procedure is invoked when a widget command is deleted.  If
  827.  * the widget isn't already in the process of being destroyed,
  828.  * this command destroys it.
  829.  *
  830.  * Results:
  831.  * None.
  832.  *
  833.  * Side effects:
  834.  * The widget is destroyed.
  835.  *
  836.  *----------------------------------------------------------------------
  837.  */
  839. static void
  840. MenuButtonCmdDeletedProc(clientData)
  841.     ClientData clientData; /* Pointer to widget record for widget. */
  842. {
  843.     TkMenuButton *mbPtr = (TkMenuButton *) clientData;
  844.     Tk_Window tkwin = mbPtr->tkwin;
  846.     /*
  847.      * This procedure could be invoked either because the window was
  848.      * destroyed and the command was then deleted (in which case tkwin
  849.      * is NULL) or because the command was deleted, and then this procedure
  850.      * destroys the widget.
  851.      */
  853.     if (tkwin != NULL) {
  854. Tk_DestroyWindow(tkwin);
  855.     }
  856. }
  858. /*
  859.  *--------------------------------------------------------------
  860.  *
  861.  * MenuButtonTextVarProc --
  862.  *
  863.  * This procedure is invoked when someone changes the variable
  864.  * whose contents are to be displayed in a menu button.
  865.  *
  866.  * Results:
  867.  * NULL is always returned.
  868.  *
  869.  * Side effects:
  870.  * The text displayed in the menu button will change to match the
  871.  * variable.
  872.  *
  873.  *--------------------------------------------------------------
  874.  */
  876. /* ARGSUSED */
  877. static char *
  878. MenuButtonTextVarProc(clientData, interp, name1, name2, flags)
  879.     ClientData clientData; /* Information about button. */
  880.     Tcl_Interp *interp; /* Interpreter containing variable. */
  881.     CONST char *name1; /* Name of variable. */
  882.     CONST char *name2; /* Second part of variable name. */
  883.     int flags; /* Information about what happened. */
  884. {
  885.     register TkMenuButton *mbPtr = (TkMenuButton *) clientData;
  886.     CONST char *value;
  888.     /*
  889.      * If the variable is unset, then immediately recreate it unless
  890.      * the whole interpreter is going away.
  891.      */
  893.     if (flags & TCL_TRACE_UNSETS) {
  894. if ((flags & TCL_TRACE_DESTROYED) && !(flags & TCL_INTERP_DESTROYED)) {
  895.     Tcl_SetVar(interp, mbPtr->textVarName, mbPtr->text,
  896.     TCL_GLOBAL_ONLY);
  897.     Tcl_TraceVar(interp, mbPtr->textVarName,
  898.     TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
  899.     MenuButtonTextVarProc, clientData);
  900. }
  901. return (char *) NULL;
  902.     }
  904.     value = Tcl_GetVar(interp, mbPtr->textVarName, TCL_GLOBAL_ONLY);
  905.     if (value == NULL) {
  906. value = "";
  907.     }
  908.     if (mbPtr->text != NULL) {
  909. ckfree(mbPtr->text);
  910.     }
  911.     mbPtr->text = (char *) ckalloc((unsigned) (strlen(value) + 1));
  912.     strcpy(mbPtr->text, value);
  913.     TkpComputeMenuButtonGeometry(mbPtr);
  915.     if ((mbPtr->tkwin != NULL) && Tk_IsMapped(mbPtr->tkwin)
  916.     && !(mbPtr->flags & REDRAW_PENDING)) {
  917. Tcl_DoWhenIdle(TkpDisplayMenuButton, (ClientData) mbPtr);
  918. mbPtr->flags |= REDRAW_PENDING;
  919.     }
  920.     return (char *) NULL;
  921. }
  923. /*
  924.  *----------------------------------------------------------------------
  925.  *
  926.  * MenuButtonImageProc --
  927.  *
  928.  * This procedure is invoked by the image code whenever the manager
  929.  * for an image does something that affects the size of contents
  930.  * of an image displayed in a button.
  931.  *
  932.  * Results:
  933.  * None.
  934.  *
  935.  * Side effects:
  936.  * Arranges for the button to get redisplayed.
  937.  *
  938.  *----------------------------------------------------------------------
  939.  */
  941. static void
  942. MenuButtonImageProc(clientData, x, y, width, height, imgWidth, imgHeight)
  943.     ClientData clientData; /* Pointer to widget record. */
  944.     int x, y; /* Upper left pixel (within image)
  945.  * that must be redisplayed. */
  946.     int width, height; /* Dimensions of area to redisplay
  947.  * (may be <= 0). */
  948.     int imgWidth, imgHeight; /* New dimensions of image. */
  949. {
  950.     register TkMenuButton *mbPtr = (TkMenuButton *) clientData;
  952.     if (mbPtr->tkwin != NULL) {
  953. TkpComputeMenuButtonGeometry(mbPtr);
  954. if (Tk_IsMapped(mbPtr->tkwin) && !(mbPtr->flags & REDRAW_PENDING)) {
  955.     Tcl_DoWhenIdle(TkpDisplayMenuButton, (ClientData) mbPtr);
  956.     mbPtr->flags |= REDRAW_PENDING;
  957. }
  958.     }
  959. }