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

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

通讯编程

开发平台：

Visual C++

tkFrame.c：源码内容
  1. /* 
  2.  * tkFrame.c --
  3.  *
  4.  * This module implements "frame", "labelframe" and "toplevel" widgets
  5.  *      for the Tk toolkit.  Frames are windows with a background color
  6.  * and possibly a 3-D effect, but not much else in the way of
  7.  * attributes.
  8.  *
  9.  * Copyright (c) 1990-1994 The Regents of the University of California.
  10.  * Copyright (c) 1994-1997 Sun Microsystems, Inc.
  11.  *
  12.  * See the file "license.terms" for information on usage and redistribution
  13.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  14.  *
  15.  * RCS: @(#) $Id: tkFrame.c,v 1.15.2.4 2007/04/29 02:24:02 das Exp $
  16.  */
  18. #include "default.h"
  19. #include "tkPort.h"
  20. #include "tkInt.h"
  22. /*
  23.  * The following enum is used to define the type of the frame.
  24.  */
  26. enum FrameType {
  27.     TYPE_FRAME, TYPE_TOPLEVEL, TYPE_LABELFRAME
  28. };
  30. /*
  31.  * A data structure of the following type is kept for each
  32.  * frame that currently exists for this process:
  33.  */
  35. typedef struct {
  36.     Tk_Window tkwin; /* Window that embodies the frame.  NULL
  37.  * means that the window has been destroyed
  38.  * but the data structures haven't yet been
  39.  * cleaned up. */
  40.     Display *display; /* Display containing widget.  Used, among
  41.  * other things, so that resources can be
  42.  * freed even after tkwin has gone away. */
  43.     Tcl_Interp *interp; /* Interpreter associated with widget.  Used
  44.  * to delete widget command. */
  45.     Tcl_Command widgetCmd; /* Token for frame's widget command. */
  46.     Tk_OptionTable optionTable; /* Table that defines configuration options
  47.  * available for this widget. */
  48.     char *className; /* Class name for widget (from configuration
  49.  * option).  Malloc-ed. */
  50.     enum FrameType type; /* Type of widget, such as TYPE_FRAME. */
  51.     char *screenName; /* Screen on which widget is created.  Non-null
  52.  * only for top-levels.  Malloc-ed, may be
  53.  * NULL. */
  54.     char *visualName; /* Textual description of visual for window,
  55.  * from -visual option.  Malloc-ed, may be
  56.  * NULL. */
  57.     char *colormapName; /* Textual description of colormap for window,
  58.  * from -colormap option.  Malloc-ed, may be
  59.  * NULL. */
  60.     char *menuName; /* Textual description of menu to use for
  61.  * menubar. Malloc-ed, may be NULL. */
  62.     Colormap colormap; /* If not None, identifies a colormap
  63.  * allocated for this window, which must be
  64.  * freed when the window is deleted. */
  65.     Tk_3DBorder border; /* Structure used to draw 3-D border and
  66.  * background.  NULL means no background
  67.  * or border. */
  68.     int borderWidth; /* Width of 3-D border (if any). */
  69.     int relief; /* 3-d effect: TK_RELIEF_RAISED etc. */
  70.     int highlightWidth; /* Width in pixels of highlight to draw
  71.  * around widget when it has the focus.
  72.  * 0 means don't draw a highlight. */
  73.     XColor *highlightBgColorPtr;
  74. /* Color for drawing traversal highlight
  75.  * area when highlight is off. */
  76.     XColor *highlightColorPtr; /* Color for drawing traversal highlight. */
  77.     int width; /* Width to request for window.  <= 0 means
  78.  * don't request any size. */
  79.     int height; /* Height to request for window.  <= 0 means
  80.  * don't request any size. */
  81.     Tk_Cursor cursor; /* Current cursor for window, or None. */
  82.     char *takeFocus; /* Value of -takefocus option;  not used in
  83.  * the C code, but used by keyboard traversal
  84.  * scripts.  Malloc'ed, but may be NULL. */
  85.     int isContainer; /* 1 means this window is a container, 0 means
  86.  * that it isn't. */
  87.     char *useThis; /* If the window is embedded, this points to
  88.  * the name of the window in which it is
  89.  * embedded (malloc'ed).  For non-embedded
  90.  * windows this is NULL. */
  91.     int flags; /* Various flags;  see below for
  92.  * definitions. */
  93.     Tcl_Obj *padXPtr; /* Value of -padx option: specifies how many
  94.  * pixels of extra space to leave on left and
  95.  * right of child area. */
  96.     int padX; /* Integer value corresponding to padXPtr. */
  97.     Tcl_Obj *padYPtr; /* Value of -padx option: specifies how many
  98.  * pixels of extra space to leave above and
  99.  * below child area. */
  100.     int padY; /* Integer value corresponding to padYPtr. */
  101. } Frame;
  103. /*
  104.  * A data structure of the following type is kept for each labelframe
  105.  * widget managed by this file:
  106.  */
  108. typedef struct {
  109.     Frame frame; /* A pointer to the generic frame structure.
  110.  * This must be the first element of the
  111.  * Labelframe. */
  113.     /*
  114.      * Labelframe specific configuration settings.
  115.      */
  117.     Tcl_Obj *textPtr; /* Value of -text option: specifies text to
  118.  * display in button. */
  119.     Tk_Font tkfont; /* Value of -font option: specifies font
  120.  * to use for display text. */
  121.     XColor *textColorPtr; /* Value of -fg option: specifies foreground
  122.  * color in normal mode. */
  123.     int labelAnchor; /* Value of -labelanchor option: specifies
  124.  * where to place the label. */
  125.     Tk_Window labelWin; /* Value of -labelwidget option: Window to
  126.                                  * use as label for the frame. */
  128.     /*
  129.      * Labelframe specific fields for use with configuration settings above.
  130.      */
  132.     GC textGC; /* GC for drawing text in normal mode. */
  133.     Tk_TextLayout textLayout; /* Stored text layout information. */
  134.     XRectangle labelBox; /* The label's actual size and position. */
  135.     int labelReqWidth; /* The label's requested width. */
  136.     int labelReqHeight; /* The label's requested height. */
  137.     int labelTextX, labelTextY; /* Position of the text to be drawn. */
  139. } Labelframe;
  141. /*
  142.  * The following macros define how many extra pixels to leave
  143.  * around a label's text.
  144.  */
  146. #define LABELSPACING 1
  147. #define LABELMARGIN 4
  149. /*
  150.  * Flag bits for frames:
  151.  *
  152.  * REDRAW_PENDING: Non-zero means a DoWhenIdle handler
  153.  * has already been queued to redraw
  154.  * this window.
  155.  * GOT_FOCUS: Non-zero means this widget currently
  156.  * has the input focus.
  157.  */
  159. #define REDRAW_PENDING 1
  160. #define GOT_FOCUS 4
  162. /*
  163.  * The following enum is used to define a type for the -labelanchor option
  164.  * of the Labelframe widget.  These values are used as indices into the 
  165.  * string table below.
  166.  */
  168. enum labelanchor {
  169.     LABELANCHOR_E, LABELANCHOR_EN, LABELANCHOR_ES,
  170.     LABELANCHOR_N, LABELANCHOR_NE, LABELANCHOR_NW,
  171.     LABELANCHOR_S, LABELANCHOR_SE, LABELANCHOR_SW,
  172.     LABELANCHOR_W, LABELANCHOR_WN, LABELANCHOR_WS
  173. };
  175. static char *labelAnchorStrings[] = {
  176.     "e", "en", "es", "n", "ne", "nw", "s", "se", "sw", "w", "wn", "ws",
  177.     (char *) NULL
  178. };
  180. /*
  181.  * Information used for parsing configuration options.  There are
  182.  * one common table used by all and one table for each widget class.
  183.  */
  185. static Tk_OptionSpec commonOptSpec[] = {
  186.     {TK_OPTION_BORDER, "-background", "background", "Background",
  187. DEF_FRAME_BG_COLOR, -1, Tk_Offset(Frame, border),
  188. TK_OPTION_NULL_OK, (ClientData) DEF_FRAME_BG_MONO, 0},
  189.     {TK_OPTION_SYNONYM, "-bg", (char *) NULL, (char *) NULL,
  190. (char *) NULL, 0, -1, 0, (ClientData) "-background", 0},
  191.     {TK_OPTION_STRING, "-colormap", "colormap", "Colormap",
  192. DEF_FRAME_COLORMAP, -1, Tk_Offset(Frame, colormapName),
  193. TK_OPTION_NULL_OK, 0, 0},
  194.     {TK_OPTION_BOOLEAN, "-container", "container", "Container",
  195. DEF_FRAME_CONTAINER, -1, Tk_Offset(Frame, isContainer),
  196. 0, 0, 0},
  197.     {TK_OPTION_CURSOR, "-cursor", "cursor", "Cursor",
  198. DEF_FRAME_CURSOR, -1, Tk_Offset(Frame, cursor),
  199. TK_OPTION_NULL_OK, 0, 0},
  200.     {TK_OPTION_PIXELS, "-height", "height", "Height",
  201. DEF_FRAME_HEIGHT, -1, Tk_Offset(Frame, height),
  202. 0, 0, 0},
  203.     {TK_OPTION_COLOR, "-highlightbackground", "highlightBackground",
  204. "HighlightBackground", DEF_FRAME_HIGHLIGHT_BG, -1,
  205. Tk_Offset(Frame, highlightBgColorPtr), 0, 0, 0},
  206.     {TK_OPTION_COLOR, "-highlightcolor", "highlightColor", "HighlightColor",
  207. DEF_FRAME_HIGHLIGHT, -1, Tk_Offset(Frame, highlightColorPtr),
  208. 0, 0, 0},
  209.     {TK_OPTION_PIXELS, "-highlightthickness", "highlightThickness",
  210. "HighlightThickness", DEF_FRAME_HIGHLIGHT_WIDTH, -1,
  211. Tk_Offset(Frame, highlightWidth), 0, 0, 0},
  212.     {TK_OPTION_PIXELS, "-padx", "padX", "Pad",
  213. DEF_FRAME_PADX, Tk_Offset(Frame, padXPtr),
  214. Tk_Offset(Frame, padX), 0, 0, 0},
  215.     {TK_OPTION_PIXELS, "-pady", "padY", "Pad",
  216. DEF_FRAME_PADY, Tk_Offset(Frame, padYPtr),
  217. Tk_Offset(Frame, padY), 0, 0, 0},
  218.     {TK_OPTION_STRING, "-takefocus", "takeFocus", "TakeFocus",
  219. DEF_FRAME_TAKE_FOCUS, -1, Tk_Offset(Frame, takeFocus),
  220. TK_OPTION_NULL_OK, 0, 0},
  221.     {TK_OPTION_STRING, "-visual", "visual", "Visual",
  222. DEF_FRAME_VISUAL, -1, Tk_Offset(Frame, visualName),
  223. TK_OPTION_NULL_OK, 0, 0},
  224.     {TK_OPTION_PIXELS, "-width", "width", "Width",
  225. DEF_FRAME_WIDTH, -1, Tk_Offset(Frame, width),
  226. 0, 0, 0},
  227.     {TK_OPTION_END, (char *) NULL, (char *) NULL, (char *) NULL,
  228. (char *) NULL, 0, 0, 0, 0, 0}
  229. };
  231. static Tk_OptionSpec frameOptSpec[] = {
  232.     {TK_OPTION_SYNONYM, "-bd", (char *) NULL, (char *) NULL,
  233. (char *) NULL, 0, -1, 0, (ClientData) "-borderwidth", 0},
  234.     {TK_OPTION_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
  235. DEF_FRAME_BORDER_WIDTH, -1, Tk_Offset(Frame, borderWidth),
  236.         0, 0, 0},
  237.     {TK_OPTION_STRING, "-class", "class", "Class",
  238. DEF_FRAME_CLASS, -1, Tk_Offset(Frame, className),
  239. 0, 0, 0},
  240.     {TK_OPTION_RELIEF, "-relief", "relief", "Relief",
  241. DEF_FRAME_RELIEF, -1, Tk_Offset(Frame, relief),
  242. 0, 0, 0},
  243.     {TK_OPTION_END, (char *) NULL, (char *) NULL, (char *) NULL,
  244. (char *) NULL, 0, 0, 0, (ClientData) commonOptSpec, 0}
  245. };
  247. static Tk_OptionSpec toplevelOptSpec[] = {
  248.     {TK_OPTION_SYNONYM, "-bd", (char *) NULL, (char *) NULL,
  249. (char *) NULL, 0, -1, 0, (ClientData) "-borderwidth", 0},
  250.     {TK_OPTION_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
  251. DEF_FRAME_BORDER_WIDTH, -1, Tk_Offset(Frame, borderWidth),
  252.         0, 0, 0},
  253.     {TK_OPTION_STRING, "-class", "class", "Class",
  254. DEF_TOPLEVEL_CLASS, -1, Tk_Offset(Frame, className),
  255. 0, 0, 0},
  256.     {TK_OPTION_STRING, "-menu", "menu", "Menu",
  257. DEF_TOPLEVEL_MENU, -1, Tk_Offset(Frame, menuName),
  258. TK_OPTION_NULL_OK, 0, 0},
  259.     {TK_OPTION_RELIEF, "-relief", "relief", "Relief",
  260. DEF_FRAME_RELIEF, -1, Tk_Offset(Frame, relief),
  261. 0, 0, 0},
  262.     {TK_OPTION_STRING, "-screen", "screen", "Screen",
  263. DEF_TOPLEVEL_SCREEN, -1, Tk_Offset(Frame, screenName),
  264. TK_OPTION_NULL_OK, 0, 0},
  265.     {TK_OPTION_STRING, "-use", "use", "Use",
  266. DEF_TOPLEVEL_USE, -1, Tk_Offset(Frame, useThis),
  267. TK_OPTION_NULL_OK, 0, 0},
  268.     {TK_OPTION_END, (char *) NULL, (char *) NULL, (char *) NULL,
  269. (char *) NULL, 0, 0, 0, (ClientData) commonOptSpec, 0}
  270. };
  272. static Tk_OptionSpec labelframeOptSpec[] = {
  273.     {TK_OPTION_SYNONYM, "-bd", (char *) NULL, (char *) NULL,
  274. (char *) NULL, 0, -1, 0, (ClientData) "-borderwidth", 0},
  275.     {TK_OPTION_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
  276. DEF_LABELFRAME_BORDER_WIDTH, -1, Tk_Offset(Frame, borderWidth),
  277.         0, 0, 0},
  278.     {TK_OPTION_STRING, "-class", "class", "Class",
  279. DEF_LABELFRAME_CLASS, -1, Tk_Offset(Frame, className),
  280. 0, 0, 0},
  281.     {TK_OPTION_SYNONYM, "-fg", "foreground", (char *) NULL,
  282. (char *) NULL, 0, -1, 0, (ClientData) "-foreground", 0},
  283.     {TK_OPTION_FONT, "-font", "font", "Font",
  284. DEF_LABELFRAME_FONT, -1, Tk_Offset(Labelframe, tkfont), 0, 0, 0},
  285.     {TK_OPTION_COLOR, "-foreground", "foreground", "Foreground",
  286. DEF_LABELFRAME_FG, -1, Tk_Offset(Labelframe, textColorPtr), 0, 0, 0},
  287.     {TK_OPTION_STRING_TABLE, "-labelanchor", "labelAnchor", "LabelAnchor",
  288. DEF_LABELFRAME_LABELANCHOR, -1, Tk_Offset(Labelframe, labelAnchor),
  289.         0, (ClientData) labelAnchorStrings, 0},
  290.     {TK_OPTION_WINDOW, "-labelwidget", "labelWidget", "LabelWidget",
  291.         (char *) NULL, -1, Tk_Offset(Labelframe, labelWin),
  292.         TK_OPTION_NULL_OK, 0, 0},
  293.     {TK_OPTION_RELIEF, "-relief", "relief", "Relief",
  294. DEF_LABELFRAME_RELIEF, -1, Tk_Offset(Frame, relief),
  295. 0, 0, 0},
  296.     {TK_OPTION_STRING, "-text", "text", "Text",
  297. DEF_LABELFRAME_TEXT, Tk_Offset(Labelframe, textPtr), -1,
  298. TK_OPTION_NULL_OK, 0, 0},
  299.     {TK_OPTION_END, (char *) NULL, (char *) NULL, (char *) NULL,
  300. (char *) NULL, 0, 0, 0, (ClientData) commonOptSpec, 0}
  301. };
  303. /*
  304.  * Class names for widgets, indexed by FrameType.
  305.  */
  307. static char *classNames[] = {"Frame", "Toplevel", "Labelframe"};
  309. /*
  310.  * The following table maps from FrameType to the option template for
  311.  * that class of widgets.
  312.  */
  314. static Tk_OptionSpec *optionSpecs[] = {
  315.     frameOptSpec,
  316.     toplevelOptSpec,
  317.     labelframeOptSpec,
  318. };
  320. /*
  321.  * Forward declarations for procedures defined later in this file:
  322.  */
  324. static void ComputeFrameGeometry _ANSI_ARGS_((Frame *framePtr));
  325. static int ConfigureFrame _ANSI_ARGS_((Tcl_Interp *interp,
  326.     Frame *framePtr, int objc, Tcl_Obj *CONST objv[]));
  327. static int CreateFrame _ANSI_ARGS_((ClientData clientData,
  328.     Tcl_Interp *interp, int objc, Tcl_Obj *CONST argv[],
  329.     enum FrameType type, char *appName));
  330. static void DestroyFrame _ANSI_ARGS_((char *memPtr));
  331. static void DestroyFramePartly _ANSI_ARGS_((Frame *framePtr));
  332. static void DisplayFrame _ANSI_ARGS_((ClientData clientData));
  333. static void FrameCmdDeletedProc _ANSI_ARGS_((
  334.     ClientData clientData));
  335. static void FrameEventProc _ANSI_ARGS_((ClientData clientData,
  336.     XEvent *eventPtr));
  337. static void FrameLostSlaveProc _ANSI_ARGS_((
  338.     ClientData clientData, Tk_Window tkwin));
  339. static void FrameRequestProc _ANSI_ARGS_((ClientData clientData,
  340.     Tk_Window tkwin));
  341. static void FrameStructureProc _ANSI_ARGS_((
  342.     ClientData clientData, XEvent *eventPtr));
  343. static int FrameWidgetObjCmd _ANSI_ARGS_((ClientData clientData,
  344.     Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]));
  345. static void FrameWorldChanged _ANSI_ARGS_((
  346.     ClientData instanceData));
  347. static void MapFrame _ANSI_ARGS_((ClientData clientData));
  349. /*
  350.  * The structure below defines frame class behavior by means of procedures
  351.  * that can be invoked from generic window code.
  352.  */
  354. static Tk_ClassProcs frameClass = {
  355.     sizeof(Tk_ClassProcs), /* size */
  356.     FrameWorldChanged /* worldChangedProc */
  357. };
  359. /*
  360.  * The structure below defines the official type record for the
  361.  * labelframe's geometry manager:
  362.  */
  364. static Tk_GeomMgr frameGeomType = {
  365.     "labelframe", /* name */
  366.     FrameRequestProc, /* requestProc */
  367.     FrameLostSlaveProc /* lostSlaveProc */
  368. };
  371. /*
  372.  *--------------------------------------------------------------
  373.  *
  374.  * Tk_FrameObjCmd, Tk_ToplevelObjCmd, Tk_LabelframeObjCmd --
  375.  *
  376.  * These procedures are invoked to process the "frame",
  377.  *      "toplevel" and "labelframe" Tcl commands.  See the user
  378.  *      documentation for details on what they do.
  379.  *
  380.  * Results:
  381.  * A standard Tcl result.
  382.  *
  383.  * Side effects:
  384.  * See the user documentation.  These procedures are just wrappers;
  385.  * they call CreateFrame to do all of the real work.
  386.  *
  387.  *--------------------------------------------------------------
  388.  */
  390. int
  391. Tk_FrameObjCmd(clientData, interp, objc, objv)
  392.     ClientData clientData; /* Either NULL or pointer to option table. */
  393.     Tcl_Interp *interp; /* Current interpreter. */
  394.     int objc; /* Number of arguments. */
  395.     Tcl_Obj *CONST objv[]; /* Argument objects. */
  396. {
  397.     return CreateFrame(clientData, interp, objc, objv, TYPE_FRAME,
  398.     (char *) NULL);
  399. }
  401. int
  402. Tk_ToplevelObjCmd(clientData, interp, objc, objv)
  403.     ClientData clientData; /* Either NULL or pointer to option table. */
  404.     Tcl_Interp *interp; /* Current interpreter. */
  405.     int objc; /* Number of arguments. */
  406.     Tcl_Obj *CONST objv[]; /* Argument objects. */
  407. {
  408.     return CreateFrame(clientData, interp, objc, objv, TYPE_TOPLEVEL,
  409.     (char *) NULL);
  410. }
  412. int
  413. Tk_LabelframeObjCmd(clientData, interp, objc, objv)
  414.     ClientData clientData; /* Either NULL or pointer to option table. */
  415.     Tcl_Interp *interp; /* Current interpreter. */
  416.     int objc; /* Number of arguments. */
  417.     Tcl_Obj *CONST objv[]; /* Argument objects. */
  418. {
  419.     return CreateFrame(clientData, interp, objc, objv, TYPE_LABELFRAME,
  420.     (char *) NULL);
  421. }
  423. /*
  424.  *--------------------------------------------------------------
  425.  *
  426.  * TkCreateFrame --
  427.  *
  428.  * This procedure is the old command procedure for the "frame"
  429.  *      and "toplevel" commands.  Now it is used directly by Tk_Init to
  430.  *      create a new main window.  See the user documentation for the
  431.  *      "frame" and "toplevel" commands for details on what it does.
  432.  *
  433.  * Results:
  434.  * A standard Tcl result.
  435.  *
  436.  * Side effects:
  437.  * See the user documentation.
  438.  *
  439.  *--------------------------------------------------------------
  440.  */
  442. int
  443. TkCreateFrame(clientData, interp, argc, argv, toplevel, appName)
  444.     ClientData clientData; /* Either NULL or pointer to option table. */
  445.     Tcl_Interp *interp; /* Current interpreter. */
  446.     int argc; /* Number of arguments. */
  447.     char **argv; /* Argument strings. */
  448.     int toplevel; /* Non-zero means create a toplevel window,
  449.  * zero means create a frame. */
  450.     char *appName; /* Should only be non-NULL if there is no main
  451.  * window associated with the interpreter.
  452.  * Gives the base name to use for the
  453.  * new application. */
  454. {
  455.     int result, i;
  456.     Tcl_Obj **objv = (Tcl_Obj **) ckalloc((argc+1) * sizeof(Tcl_Obj **));
  457.     for (i=0; i<argc; i++) {
  458. objv[i] = Tcl_NewStringObj(argv[i], -1);
  459. Tcl_IncrRefCount(objv[i]);
  460.     }
  461.     objv[argc] = NULL;
  462.     result = CreateFrame(clientData, interp, argc, objv,
  463.     toplevel ? TYPE_TOPLEVEL : TYPE_FRAME, appName);
  464.     for (i=0; i<argc; i++) {
  465. Tcl_DecrRefCount(objv[i]);
  466.     }
  467.     ckfree((char *) objv);
  468.     return result;
  469. }
  471. static int
  472. CreateFrame(clientData, interp, objc, objv, type, appName)
  473.     ClientData clientData; /* NULL. */
  474.     Tcl_Interp *interp; /* Current interpreter. */
  475.     int objc; /* Number of arguments. */
  476.     Tcl_Obj *CONST objv[]; /* Argument objects. */
  477.     enum FrameType type; /* What widget type to create. */
  478.     char *appName; /* Should only be non-NULL if there are no
  479.  * Main window associated with the interpreter.
  480.  * Gives the base name to use for the
  481.  * new application. */
  482. {
  483.     Tk_Window tkwin;
  484.     Frame *framePtr;
  485.     Tk_OptionTable optionTable;
  486.     Tk_Window new;
  487.     CONST char *className, *screenName, *visualName, *colormapName, *arg, *useOption;
  488.     int i, c, depth, length;
  489.     unsigned int mask;
  490.     Colormap colormap;
  491.     Visual *visual;
  493.     if (objc < 2) {
  494. Tcl_WrongNumArgs(interp, 1, objv, "pathName ?options?");
  495. return TCL_ERROR;
  496.     }
  498.     /*
  499.      * Create the option table for this widget class.  If it has already
  500.      * been created, the cached pointer will be returned.
  501.      */
  503.     optionTable = Tk_CreateOptionTable(interp, optionSpecs[type]);
  505.     /*
  506.      * Pre-process the argument list.  Scan through it to find any
  507.      * "-class", "-screen", "-visual", and "-colormap" options.  These
  508.      * arguments need to be processed specially, before the window
  509.      * is configured using the usual Tk mechanisms.
  510.      */
  512.     className = colormapName = screenName = visualName = useOption = NULL;
  513.     colormap = None;
  514.     for (i = 2; i < objc; i += 2) {
  515. arg = Tcl_GetStringFromObj(objv[i], &length);
  516. if (length < 2) {
  517.     continue;
  518. }
  519. c = arg[1];
  520. if ((c == 'c') && (strncmp(arg, "-class", (unsigned) length) == 0)
  521. && (length >= 3)) {
  522.     className = Tcl_GetString(objv[i+1]);
  523. } else if ((c == 'c')
  524. && (strncmp(arg, "-colormap", (unsigned) length) == 0)) {
  525.     colormapName = Tcl_GetString(objv[i+1]);
  526. } else if ((c == 's') && (type == TYPE_TOPLEVEL)
  527. && (strncmp(arg, "-screen", (unsigned) length) == 0)) {
  528.     screenName = Tcl_GetString(objv[i+1]);
  529. } else if ((c == 'u') && (type == TYPE_TOPLEVEL)
  530. && (strncmp(arg, "-use", (unsigned) length) == 0)) {
  531.     useOption = Tcl_GetString(objv[i+1]);
  532. } else if ((c == 'v')
  533. && (strncmp(arg, "-visual", (unsigned) length) == 0)) {
  534.     visualName = Tcl_GetString(objv[i+1]);
  535. }
  536.     }
  538.     /*
  539.      * Create the window, and deal with the special options -use,
  540.      * -classname, -colormap, -screenname, and -visual.  These options
  541.      * must be handle before calling ConfigureFrame below, and they must
  542.      * also be processed in a particular order, for the following
  543.      * reasons:
  544.      * 1. Must set the window's class before calling ConfigureFrame,
  545.      *    so that unspecified options are looked up in the option
  546.      *    database using the correct class.
  547.      * 2. Must set visual information before calling ConfigureFrame
  548.      *    so that colors are allocated in a proper colormap.
  549.      * 3. Must call TkpUseWindow before setting non-default visual
  550.      *    information, since TkpUseWindow changes the defaults.
  551.      */
  553.     if (screenName == NULL) {
  554. screenName = (type == TYPE_TOPLEVEL) ? "" : NULL;
  555.     }
  557.     /*
  558.      * Main window associated with interpreter.
  559.      * If we're called by Tk_Init to create a
  560.      * new application, then this is NULL.
  561.      */
  563.     tkwin = Tk_MainWindow(interp);
  564.     if (tkwin != NULL) {
  565. new = Tk_CreateWindowFromPath(interp, tkwin, Tcl_GetString(objv[1]),
  566. screenName);
  567.     } else if (appName == NULL) {
  568. /*
  569.  * This occurs when someone tried to create a frame/toplevel
  570.  * while we are being destroyed.  Let an error be thrown.
  571.  */
  573. Tcl_AppendResult(interp, "unable to create widget "",
  574. Tcl_GetString(objv[1]), """, (char *) NULL);
  575. new = NULL;
  576.     } else {
  577. /*
  578.  * We were called from Tk_Init;  create a new application.
  579.  */
  581. new = TkCreateMainWindow(interp, screenName, appName);
  582.     }
  583.     if (new == NULL) {
  584. goto error;
  585.     }
  586.     if (className == NULL) {
  587. className = Tk_GetOption(new, "class", "Class");
  588. if (className == NULL) {
  589.     className = classNames[type];
  590. }
  591.     }
  592.     Tk_SetClass(new, className);
  593.     if (useOption == NULL) {
  594. useOption = Tk_GetOption(new, "use", "Use");
  595.     }
  596.     if ((useOption != NULL) && (*useOption != 0)) {
  597. if (TkpUseWindow(interp, new, useOption) != TCL_OK) {
  598.     goto error;
  599. }
  600.     }
  601.     if (visualName == NULL) {
  602. visualName = Tk_GetOption(new, "visual", "Visual");
  603.     }
  604.     if (colormapName == NULL) {
  605. colormapName = Tk_GetOption(new, "colormap", "Colormap");
  606.     }
  607.     if ((colormapName != NULL) && (*colormapName == 0)) {
  608. colormapName = NULL;
  609.     }
  610.     if (visualName != NULL) {
  611. visual = Tk_GetVisual(interp, new, visualName, &depth,
  612. (colormapName == NULL) ? &colormap : (Colormap *) NULL);
  613. if (visual == NULL) {
  614.     goto error;
  615. }
  616. Tk_SetWindowVisual(new, visual, depth, colormap);
  617.     }
  618.     if (colormapName != NULL) {
  619. colormap = Tk_GetColormap(interp, new, colormapName);
  620. if (colormap == None) {
  621.     goto error;
  622. }
  623. Tk_SetWindowColormap(new, colormap);
  624.     }
  626.     /*
  627.      * For top-level windows, provide an initial geometry request of
  628.      * 200x200,  just so the window looks nicer on the screen if it
  629.      * doesn't request a size for itself.
  630.      */
  632.     if (type == TYPE_TOPLEVEL) {
  633. Tk_GeometryRequest(new, 200, 200);
  634.     }
  636.     /*
  637.      * Create the widget record, process configuration options, and
  638.      * create event handlers.  Then fill in a few additional fields
  639.      * in the widget record from the special options.
  640.      */
  642.     if (type == TYPE_LABELFRAME) {
  643. framePtr = (Frame *) ckalloc(sizeof(Labelframe));
  644. memset((void *) framePtr, 0, (sizeof(Labelframe)));
  645.     } else {
  646. framePtr = (Frame *) ckalloc(sizeof(Frame));
  647. memset((void *) framePtr, 0, (sizeof(Frame)));
  648.     }
  649.     framePtr->tkwin = new;
  650.     framePtr->display = Tk_Display(new);
  651.     framePtr->interp = interp;
  652.     framePtr->widgetCmd = Tcl_CreateObjCommand(interp,
  653.     Tk_PathName(new), FrameWidgetObjCmd,
  654.     (ClientData) framePtr, FrameCmdDeletedProc);
  655.     framePtr->optionTable = optionTable;
  656.     framePtr->type = type;
  657.     framePtr->colormap = colormap;
  658.     framePtr->relief = TK_RELIEF_FLAT;
  659.     framePtr->cursor = None;
  661.     if (framePtr->type == TYPE_LABELFRAME) {
  662. Labelframe *labelframePtr = (Labelframe *) framePtr;
  663. labelframePtr->labelAnchor = LABELANCHOR_NW;
  664. labelframePtr->textGC = None;
  665.     }
  667.     /*
  668.      * Store backreference to frame widget in window structure.
  669.      */
  670.     Tk_SetClassProcs(new, &frameClass, (ClientData) framePtr);
  672.     mask = ExposureMask | StructureNotifyMask | FocusChangeMask;
  673.     if (type == TYPE_TOPLEVEL) {
  674.         mask |= ActivateMask;
  675.     }
  676.     Tk_CreateEventHandler(new, mask, FrameEventProc, (ClientData) framePtr);
  677.     if ((Tk_InitOptions(interp, (char *) framePtr, optionTable, new)
  678.     != TCL_OK) ||
  679.     (ConfigureFrame(interp, framePtr, objc-2, objv+2) != TCL_OK)) {
  680. goto error;
  681.     }
  682.     if ((framePtr->isContainer)) {
  683. if (framePtr->useThis == NULL) {
  684.     TkpMakeContainer(framePtr->tkwin);
  685. } else {
  686.     Tcl_AppendResult(interp, "A window cannot have both the -use ",
  687.     "and the -container option set.", (char *) NULL);
  688.     goto error;
  689. }
  690.     }
  691.     if (type == TYPE_TOPLEVEL) {
  692. Tcl_DoWhenIdle(MapFrame, (ClientData) framePtr);
  693.     }
  694.     Tcl_SetResult(interp, Tk_PathName(new), TCL_STATIC);
  695.     return TCL_OK;
  697.     error:
  698.     if (new != NULL) {
  699. Tk_DestroyWindow(new);
  700.     }
  701.     return TCL_ERROR;
  702. }
  704. /*
  705.  *--------------------------------------------------------------
  706.  *
  707.  * FrameWidgetObjCmd --
  708.  *
  709.  * This procedure is invoked to process the Tcl command
  710.  * that corresponds to a frame widget.  See the user
  711.  * documentation for details on what it does.
  712.  *
  713.  * Results:
  714.  * A standard Tcl result.
  715.  *
  716.  * Side effects:
  717.  * See the user documentation.
  718.  *
  719.  *--------------------------------------------------------------
  720.  */
  722. static int
  723. FrameWidgetObjCmd(clientData, interp, objc, objv)
  724.     ClientData clientData; /* Information about frame widget. */
  725.     Tcl_Interp *interp; /* Current interpreter. */
  726.     int objc; /* Number of arguments. */
  727.     Tcl_Obj *CONST objv[]; /* Argument objects. */
  728. {
  729.     static CONST char *frameOptions[] = {
  730. "cget", "configure", (char *) NULL
  731.     };
  732.     enum options {
  733. FRAME_CGET, FRAME_CONFIGURE
  734.     };
  735.     register Frame *framePtr = (Frame *) clientData;
  736.     int result = TCL_OK, index;
  737.     int c, i, length;
  738.     Tcl_Obj *objPtr;
  740.     if (objc < 2) {
  741. Tcl_WrongNumArgs(interp, 1, objv, "option ?arg arg ...?");
  742. return TCL_ERROR;
  743.     }
  744.     if (Tcl_GetIndexFromObj(interp, objv[1], frameOptions, "option", 0,
  745.     &index) != TCL_OK) {
  746. return TCL_ERROR;
  747.     }
  748.     Tcl_Preserve((ClientData) framePtr);
  749.     switch ((enum options) index) {
  750.       case FRAME_CGET: {
  751. if (objc != 3) {
  752.     Tcl_WrongNumArgs(interp, 2, objv, "option");
  753.     result = TCL_ERROR;
  754.     goto done;
  755. }
  756.         objPtr = Tk_GetOptionValue(interp, (char *) framePtr,
  757. framePtr->optionTable, objv[2], framePtr->tkwin);
  758.         if (objPtr == NULL) {
  759.     result = TCL_ERROR;
  760.     goto done;
  761.         } else {
  762.     Tcl_SetObjResult(interp, objPtr);
  763.         }
  764. break;
  765.       }
  766.       case FRAME_CONFIGURE: {
  767. if (objc <= 3) {
  768.     objPtr = Tk_GetOptionInfo(interp, (char *) framePtr,
  769.     framePtr->optionTable,
  770.     (objc == 3) ? objv[2] : (Tcl_Obj *) NULL,
  771.     framePtr->tkwin);
  772.     if (objPtr == NULL) {
  773. result = TCL_ERROR;
  774. goto done;
  775.     } else {
  776. Tcl_SetObjResult(interp, objPtr);
  777.     }
  778. } else {
  779.     /*
  780.      * Don't allow the options -class, -colormap, -container,
  781.      * -newcmap, -screen, -use, or -visual to be changed.
  782.      */
  784.     for (i = 2; i < objc; i++) {
  785. char *arg = Tcl_GetStringFromObj(objv[i], &length);
  786. if (length < 2) {
  787.     continue;
  788. }
  789. c = arg[1];
  790. if (((c == 'c')
  791. && (strncmp(arg, "-class", (unsigned) length) == 0)
  792. && (length >= 2))
  793. || ((c == 'c')
  794. && (strncmp(arg, "-colormap", (unsigned) length) == 0)
  795. && (length >= 3))
  796. || ((c == 'c')
  797. && (strncmp(arg, "-container", (unsigned) length) == 0)
  798. && (length >= 3))
  799. || ((c == 's') && (framePtr->type == TYPE_TOPLEVEL)
  800. && (strncmp(arg, "-screen", (unsigned) length) == 0))
  801. || ((c == 'u') && (framePtr->type == TYPE_TOPLEVEL)
  802. && (strncmp(arg, "-use", (unsigned) length) == 0))
  803. || ((c == 'v')
  804. && (strncmp(arg, "-visual", (unsigned) length) ==0))) {
  805.     Tcl_AppendResult(interp, "can't modify ", arg,
  806.     " option after widget is created", (char *) NULL);
  807.     result = TCL_ERROR;
  808.     goto done;
  809. }
  810.     }
  811.     result = ConfigureFrame(interp, framePtr, objc-2, objv+2);
  812. }
  813. break;
  814.       }
  815.     }
  817.     done:
  818.     Tcl_Release((ClientData) framePtr);
  819.     return result;
  820. }
  822. /*
  823.  *----------------------------------------------------------------------
  824.  *
  825.  * DestroyFrame --
  826.  *
  827.  * This procedure is invoked by Tcl_EventuallyFree or Tcl_Release
  828.  * to clean up the internal structure of a frame at a safe time
  829.  * (when no-one is using it anymore).
  830.  *
  831.  * Results:
  832.  * None.
  833.  *
  834.  * Side effects:
  835.  * Everything associated with the frame is freed up.
  836.  *
  837.  *----------------------------------------------------------------------
  838.  */
  840. static void
  841. DestroyFrame(memPtr)
  842.     char *memPtr; /* Info about frame widget. */
  843. {
  844.     register Frame *framePtr = (Frame *) memPtr;
  845.     register Labelframe *labelframePtr = (Labelframe *) memPtr;
  847.     if (framePtr->type == TYPE_LABELFRAME) {
  848. Tk_FreeTextLayout(labelframePtr->textLayout);
  849. if (labelframePtr->textGC != None) {
  850.     Tk_FreeGC(framePtr->display, labelframePtr->textGC);
  851. }
  852.     }
  853.     if (framePtr->colormap != None) {
  854. Tk_FreeColormap(framePtr->display, framePtr->colormap);
  855.     }
  856.     ckfree((char *) framePtr);
  857. }
  859. /*
  860.  *----------------------------------------------------------------------
  861.  *
  862.  * DestroyFramePartly --
  863.  *
  864.  * This procedure is invoked to clean up everything that needs
  865.  *      tkwin to be defined when deleted.  During the destruction
  866.  *      process tkwin is always set to NULL and this procedure must
  867.  *      be called before that happens.
  868.  *
  869.  * Results:
  870.  * None.
  871.  *
  872.  * Side effects:
  873.  * Some things associated with the frame are freed up.
  874.  *
  875.  *----------------------------------------------------------------------
  876.  */
  878. static void
  879. DestroyFramePartly(framePtr)
  880.     Frame *framePtr; /* Info about frame widget. */
  881. {
  882.     register Labelframe *labelframePtr = (Labelframe *) framePtr;
  884.     if (framePtr->type == TYPE_LABELFRAME && labelframePtr->labelWin != NULL) {
  885. Tk_DeleteEventHandler(labelframePtr->labelWin, StructureNotifyMask,
  886. FrameStructureProc, (ClientData) framePtr);
  887. Tk_ManageGeometry(labelframePtr->labelWin, (Tk_GeomMgr *) NULL,
  888. (ClientData) NULL);
  889. if (framePtr->tkwin != Tk_Parent(labelframePtr->labelWin)) {
  890.     Tk_UnmaintainGeometry(labelframePtr->labelWin, framePtr->tkwin);
  891. }
  892. Tk_UnmapWindow(labelframePtr->labelWin);
  893. labelframePtr->labelWin = NULL;
  894.     }
  896.     Tk_FreeConfigOptions((char *) framePtr, framePtr->optionTable,
  897.             framePtr->tkwin);
  898. }
  900. /*
  901.  *----------------------------------------------------------------------
  902.  *
  903.  * ConfigureFrame --
  904.  *
  905.  * This procedure is called to process an objv/objc list, plus
  906.  * the Tk option database, in order to configure (or
  907.  * reconfigure) a frame widget.
  908.  *
  909.  * Results:
  910.  * The return value is a standard Tcl result.  If TCL_ERROR is
  911.  * returned, then the interp's result contains an error message.
  912.  *
  913.  * Side effects:
  914.  * Configuration information, such as text string, colors, font,
  915.  * etc. get set for framePtr;  old resources get freed, if there
  916.  * were any.
  917.  *
  918.  *----------------------------------------------------------------------
  919.  */
  921. static int
  922. ConfigureFrame(interp, framePtr, objc, objv)
  923.     Tcl_Interp *interp; /* Used for error reporting. */
  924.     register Frame *framePtr; /* Information about widget;  may or may
  925.  * not already have values for some fields. */
  926.     int objc; /* Number of valid entries in objv. */
  927.     Tcl_Obj *CONST objv[]; /* Arguments. */
  928. {
  929.     Tk_SavedOptions savedOptions;
  930.     char *oldMenuName;
  931.     Tk_Window oldWindow = NULL;
  932.     Labelframe *labelframePtr = (Labelframe *) framePtr;
  934.     /*
  935.      * Need the old menubar name for the menu code to delete it.
  936.      */
  937.     
  938.     if (framePtr->menuName == NULL) {
  939.      oldMenuName = NULL;
  940.     } else {
  941.      oldMenuName = ckalloc(strlen(framePtr->menuName) + 1);
  942.      strcpy(oldMenuName, framePtr->menuName);
  943.     }
  945.     if (framePtr->type == TYPE_LABELFRAME) {
  946. oldWindow = labelframePtr->labelWin;
  947.     }
  948.     if (Tk_SetOptions(interp, (char *) framePtr,
  949.     framePtr->optionTable, objc, objv,
  950.     framePtr->tkwin, &savedOptions, (int *) NULL) != TCL_OK) {
  951. if (oldMenuName != NULL) {
  952.     ckfree(oldMenuName);
  953. }
  954. return TCL_ERROR;
  955.     } else {
  956. Tk_FreeSavedOptions(&savedOptions);
  957.     }
  959.     /*
  960.      * A few of the options require additional processing.
  961.      */
  963.     if (((oldMenuName == NULL) && (framePtr->menuName != NULL))
  964.     || ((oldMenuName != NULL) && (framePtr->menuName == NULL))
  965.     || ((oldMenuName != NULL) && (framePtr->menuName != NULL)
  966.     && strcmp(oldMenuName, framePtr->menuName) != 0)) {
  967. TkSetWindowMenuBar(interp, framePtr->tkwin, oldMenuName,
  968. framePtr->menuName);
  969.     }
  971.     if (oldMenuName != NULL) {
  972.      ckfree(oldMenuName);
  973.     }
  975.     if (framePtr->border != NULL) {
  976. Tk_SetBackgroundFromBorder(framePtr->tkwin, framePtr->border);
  977.     } else {
  978. Tk_SetWindowBackgroundPixmap(framePtr->tkwin, None);
  979.     }
  981.     if (framePtr->highlightWidth < 0) {
  982. framePtr->highlightWidth = 0;
  983.     }
  984.     if (framePtr->padX < 0) {
  985. framePtr->padX = 0;
  986.     }
  987.     if (framePtr->padY < 0) {
  988. framePtr->padY = 0;
  989.     }
  991.     /*
  992.      * If a -labelwidget is specified, check that it is valid and set
  993.      * up geometry management for it.
  994.      */
  996.     if (framePtr->type == TYPE_LABELFRAME) {
  997. if (oldWindow != labelframePtr->labelWin) {
  998.     if (oldWindow != NULL) {
  999. Tk_DeleteEventHandler(oldWindow, StructureNotifyMask,
  1000. FrameStructureProc, (ClientData) framePtr);
  1001. Tk_ManageGeometry(oldWindow, (Tk_GeomMgr *) NULL,
  1002. (ClientData) NULL);
  1003. Tk_UnmaintainGeometry(oldWindow, framePtr->tkwin);
  1004. Tk_UnmapWindow(oldWindow);
  1005.     }
  1006.     if (labelframePtr->labelWin != NULL) {
  1007. Tk_Window ancestor, parent, sibling = NULL;
  1009. /*
  1010.  * Make sure that the frame is either the parent of the
  1011.  * window used as label or a descendant of that
  1012.  * parent.  Also, don't allow a top-level window to be
  1013.  * managed inside the frame.
  1014.  */
  1016. parent = Tk_Parent(labelframePtr->labelWin);
  1017. for (ancestor = framePtr->tkwin; ;
  1018.      ancestor = Tk_Parent(ancestor)) {
  1019.     if (ancestor == parent) {
  1020. break;
  1021.     }
  1022.     sibling = ancestor;
  1023.     if (Tk_IsTopLevel(ancestor)) {
  1024. badWindow:
  1025. Tcl_AppendResult(interp, "can't use ",
  1026. Tk_PathName(labelframePtr->labelWin),
  1027. " as label in this frame", (char *) NULL);
  1028. labelframePtr->labelWin = NULL;
  1029. return TCL_ERROR;
  1030.     }
  1031. }
  1032. if (Tk_IsTopLevel(labelframePtr->labelWin)) {
  1033.     goto badWindow;
  1034. }
  1035. if (labelframePtr->labelWin == framePtr->tkwin) {
  1036.     goto badWindow;
  1037. }
  1038. Tk_CreateEventHandler(labelframePtr->labelWin,
  1039. StructureNotifyMask, FrameStructureProc,
  1040. (ClientData) framePtr);
  1041. Tk_ManageGeometry(labelframePtr->labelWin, &frameGeomType,
  1042. (ClientData) framePtr);
  1044. /*
  1045.  * If the frame is not parent to the label, make
  1046.  * sure the label is above its sibling in the stacking
  1047.  * order.
  1048.  */
  1050. if (sibling != NULL) {
  1051.     Tk_RestackWindow(labelframePtr->labelWin, Above, sibling);
  1052. }
  1053.     }
  1054. }
  1055.     }
  1057.     FrameWorldChanged((ClientData) framePtr);
  1059.     return TCL_OK;
  1060. }
  1062. /*
  1063.  *---------------------------------------------------------------------------
  1064.  *
  1065.  * FrameWorldChanged --
  1066.  *
  1067.  *      This procedure is called when the world has changed in some
  1068.  *      way and the widget needs to recompute all its graphics contexts
  1069.  * and determine its new geometry.
  1070.  *
  1071.  * Results:
  1072.  *      None.
  1073.  *
  1074.  * Side effects:
  1075.  *      Frame will be relayed out and redisplayed.
  1076.  *
  1077.  *---------------------------------------------------------------------------
  1078.  */
  1079.  
  1080. static void
  1081. FrameWorldChanged(instanceData)
  1082.     ClientData instanceData; /* Information about widget. */
  1083. {
  1084.     Frame *framePtr = (Frame *) instanceData;
  1085.     Labelframe *labelframePtr = (Labelframe *) framePtr;
  1086.     Tk_Window tkwin = framePtr->tkwin;
  1087.     XGCValues gcValues;
  1088.     GC gc;
  1089.     int anyTextLabel, anyWindowLabel;
  1090.     int bWidthLeft, bWidthRight, bWidthTop, bWidthBottom;
  1091.     char *labelText;
  1093.     anyTextLabel = (framePtr->type == TYPE_LABELFRAME) &&
  1094.     (labelframePtr->textPtr != NULL) &&
  1095.     (labelframePtr->labelWin == NULL);
  1096.     anyWindowLabel = (framePtr->type == TYPE_LABELFRAME) &&
  1097.     (labelframePtr->labelWin != NULL);
  1099.     if (framePtr->type == TYPE_LABELFRAME) {
  1100. /*
  1101.  * The textGC is needed even in the labelWin case, so it's
  1102.  * always created for a labelframe.
  1103.  */
  1105. gcValues.font = Tk_FontId(labelframePtr->tkfont);
  1106. gcValues.foreground = labelframePtr->textColorPtr->pixel;
  1107. gcValues.graphics_exposures = False;
  1108. gc = Tk_GetGC(tkwin, GCForeground | GCFont | GCGraphicsExposures,
  1109. &gcValues);
  1110. if (labelframePtr->textGC != None) {
  1111.     Tk_FreeGC(framePtr->display, labelframePtr->textGC);
  1112. }
  1113. labelframePtr->textGC = gc;
  1115. /*
  1116.  * Calculate label size.
  1117.  */
  1119. labelframePtr->labelReqWidth = labelframePtr->labelReqHeight = 0;
  1121. if (anyTextLabel) {
  1122.     labelText = Tcl_GetString(labelframePtr->textPtr);
  1123.     Tk_FreeTextLayout(labelframePtr->textLayout);
  1124.     labelframePtr->textLayout = Tk_ComputeTextLayout(labelframePtr->tkfont,
  1125.     labelText, -1, 0, TK_JUSTIFY_CENTER, 0,
  1126.     &labelframePtr->labelReqWidth, &labelframePtr->labelReqHeight);
  1127.     labelframePtr->labelReqWidth += 2 * LABELSPACING;
  1128.     labelframePtr->labelReqHeight += 2 * LABELSPACING;
  1129. } else if (anyWindowLabel) {
  1130.     labelframePtr->labelReqWidth = Tk_ReqWidth(labelframePtr->labelWin);
  1131.     labelframePtr->labelReqHeight = Tk_ReqHeight(labelframePtr->labelWin);
  1132. }
  1134. /* 
  1135.  * Make sure label size is at least as big as the border.
  1136.  * This simplifies later calculations and gives a better
  1137.  * appearance with thick borders.
  1138.  */
  1139.      
  1140. if ((labelframePtr->labelAnchor >= LABELANCHOR_N) && 
  1141. (labelframePtr->labelAnchor <= LABELANCHOR_SW)) {
  1142.     if (labelframePtr->labelReqHeight < framePtr->borderWidth) {
  1143. labelframePtr->labelReqHeight = framePtr->borderWidth;
  1144.     }
  1145. } else {
  1146.     if (labelframePtr->labelReqWidth < framePtr->borderWidth) {
  1147. labelframePtr->labelReqWidth = framePtr->borderWidth;
  1148.     }
  1149. }
  1150.     }
  1152.     /*
  1153.      * Calculate individual border widths.
  1154.      */
  1156.     bWidthBottom = bWidthTop = bWidthRight = bWidthLeft = 
  1157.             framePtr->borderWidth + framePtr->highlightWidth;
  1159.     bWidthLeft   += framePtr->padX;
  1160.     bWidthRight  += framePtr->padX;
  1161.     bWidthTop    += framePtr->padY;
  1162.     bWidthBottom += framePtr->padY;
  1163.     
  1164.     if (anyTextLabel || anyWindowLabel) {
  1165. switch (labelframePtr->labelAnchor) {
  1166.   case LABELANCHOR_E:
  1167.   case LABELANCHOR_EN:
  1168.   case LABELANCHOR_ES:
  1169.     bWidthRight += labelframePtr->labelReqWidth -
  1170.     framePtr->borderWidth;
  1171.     break;
  1172.   case LABELANCHOR_N:
  1173.   case LABELANCHOR_NE:
  1174.   case LABELANCHOR_NW:
  1175.     bWidthTop += labelframePtr->labelReqHeight - framePtr->borderWidth;
  1176.     break;
  1177.   case LABELANCHOR_S:
  1178.   case LABELANCHOR_SE:
  1179.   case LABELANCHOR_SW:
  1180.     bWidthBottom += labelframePtr->labelReqHeight -
  1181.     framePtr->borderWidth;
  1182.     break;
  1183.   default:
  1184.     bWidthLeft += labelframePtr->labelReqWidth - framePtr->borderWidth;
  1185.     break;
  1186. }
  1187.     }
  1189.     Tk_SetInternalBorderEx(tkwin, bWidthLeft, bWidthRight, bWidthTop,
  1190.     bWidthBottom);
  1192.     ComputeFrameGeometry(framePtr);
  1194.     /*
  1195.      * A labelframe should request size for its label.
  1196.      */
  1198.     if (framePtr->type == TYPE_LABELFRAME) {
  1199. int minwidth = labelframePtr->labelReqWidth;
  1200. int minheight = labelframePtr->labelReqHeight;
  1201. int padding = framePtr->highlightWidth;
  1202. if (framePtr->borderWidth > 0) {
  1203.     padding += framePtr->borderWidth + LABELMARGIN;
  1204. }
  1205. padding *= 2;
  1206. if ((labelframePtr->labelAnchor >= LABELANCHOR_N) && 
  1207. (labelframePtr->labelAnchor <= LABELANCHOR_SW)) {
  1208.     minwidth += padding;
  1209.     minheight += framePtr->borderWidth + framePtr->highlightWidth;
  1210. } else {
  1211.     minheight += padding;
  1212.     minwidth += framePtr->borderWidth + framePtr->highlightWidth;
  1213. }
  1214. Tk_SetMinimumRequestSize(tkwin, minwidth, minheight);
  1215.     }
  1217.     if ((framePtr->width > 0) || (framePtr->height > 0)) {
  1218. Tk_GeometryRequest(tkwin, framePtr->width, framePtr->height);
  1219.     }
  1221.     if (Tk_IsMapped(tkwin)) {
  1222. if (!(framePtr->flags & REDRAW_PENDING)) {
  1223.     Tcl_DoWhenIdle(DisplayFrame, (ClientData) framePtr);
  1224. }
  1225. framePtr->flags |= REDRAW_PENDING;
  1226.     }
  1227. }
  1229. /*
  1230.  *----------------------------------------------------------------------
  1231.  *
  1232.  * ComputeFrameGeometry --
  1233.  *
  1234.  * This procedure is called to compute various geometrical
  1235.  * information for a frame, such as where various things get
  1236.  * displayed.  It's called when the window is reconfigured.
  1237.  *
  1238.  * Results:
  1239.  * None.
  1240.  *
  1241.  * Side effects:
  1242.  * Display-related numbers get changed in *framePtr.
  1243.  *
  1244.  *----------------------------------------------------------------------
  1245.  */
  1247. static void
  1248. ComputeFrameGeometry(framePtr)
  1249.     register Frame *framePtr; /* Information about widget. */
  1250. {
  1251.     int otherWidth, otherHeight, otherWidthT, otherHeightT, padding;
  1252.     int maxWidth, maxHeight;
  1253.     Tk_Window tkwin;
  1254.     Labelframe *labelframePtr = (Labelframe *) framePtr;
  1256.     /*
  1257.      * We have nothing to do here unless there is a label.
  1258.      */
  1260.     if (framePtr->type != TYPE_LABELFRAME) return;
  1261.     if ((labelframePtr->textPtr == NULL) &&
  1262.     (labelframePtr->labelWin == NULL))  return;
  1264.     tkwin = framePtr->tkwin;
  1266.     /* 
  1267.      * Calculate the available size for the label
  1268.      */
  1270.     labelframePtr->labelBox.width = labelframePtr->labelReqWidth;
  1271.     labelframePtr->labelBox.height = labelframePtr->labelReqHeight;
  1273.     padding = framePtr->highlightWidth;
  1274.     if (framePtr->borderWidth > 0) {
  1275.         padding += framePtr->borderWidth + LABELMARGIN;
  1276.     }
  1277.     padding *= 2;
  1279.     maxHeight = Tk_Height(tkwin);
  1280.     maxWidth  = Tk_Width(tkwin);
  1282.     if ((labelframePtr->labelAnchor >= LABELANCHOR_N) && 
  1283.             (labelframePtr->labelAnchor <= LABELANCHOR_SW)) {
  1284. maxWidth -= padding;
  1285. if (maxWidth < 1) maxWidth = 1;
  1286.     } else {
  1287. maxHeight -= padding;
  1288. if (maxHeight < 1) maxHeight = 1;
  1289.     }
  1290.     if (labelframePtr->labelBox.width > maxWidth) {
  1291. labelframePtr->labelBox.width = maxWidth;
  1292.     }
  1293.     if (labelframePtr->labelBox.height > maxHeight) {
  1294. labelframePtr->labelBox.height = maxHeight;
  1295.     }
  1297.     /*
  1298.      * Calculate label and text position.
  1299.      * The text's position is based on the requested size (= the text's
  1300.      * real size) to get proper alignment if the text does not fit.
  1301.      */
  1303.     otherWidth   = Tk_Width(tkwin)  - labelframePtr->labelBox.width;
  1304.     otherHeight  = Tk_Height(tkwin) - labelframePtr->labelBox.height;
  1305.     otherWidthT  = Tk_Width(tkwin)  - labelframePtr->labelReqWidth;
  1306.     otherHeightT = Tk_Height(tkwin) - labelframePtr->labelReqHeight;
  1307.     padding = framePtr->highlightWidth;
  1309.     switch (labelframePtr->labelAnchor) {
  1310.       case LABELANCHOR_E:
  1311.       case LABELANCHOR_EN:
  1312.       case LABELANCHOR_ES:
  1313.         labelframePtr->labelTextX = otherWidthT - padding;
  1314.         labelframePtr->labelBox.x = otherWidth - padding;
  1315.         break;
  1316.       case LABELANCHOR_N:
  1317.       case LABELANCHOR_NE:
  1318.       case LABELANCHOR_NW:
  1319.         labelframePtr->labelTextY = padding;
  1320.         labelframePtr->labelBox.y = padding;
  1321.         break;
  1322.       case LABELANCHOR_S:
  1323.       case LABELANCHOR_SE:
  1324.       case LABELANCHOR_SW:
  1325.         labelframePtr->labelTextY = otherHeightT - padding;
  1326.         labelframePtr->labelBox.y = otherHeight - padding;
  1327.         break;
  1328.       default:
  1329.         labelframePtr->labelTextX = padding;
  1330.         labelframePtr->labelBox.x = padding;
  1331.         break;
  1332.     }
  1334.     if (framePtr->borderWidth > 0) {
  1335.         padding += framePtr->borderWidth + LABELMARGIN;
  1336.     }
  1338.     switch (labelframePtr->labelAnchor) {
  1339.       case LABELANCHOR_NW:
  1340.       case LABELANCHOR_SW:
  1341.         labelframePtr->labelTextX = padding;
  1342.         labelframePtr->labelBox.x = padding;
  1343.         break;
  1344.       case LABELANCHOR_N:
  1345.       case LABELANCHOR_S:
  1346.         labelframePtr->labelTextX = otherWidthT / 2;
  1347.         labelframePtr->labelBox.x = otherWidth / 2;
  1348.         break;
  1349.       case LABELANCHOR_NE:
  1350.       case LABELANCHOR_SE:
  1351.         labelframePtr->labelTextX = otherWidthT - padding;
  1352.         labelframePtr->labelBox.x = otherWidth - padding;
  1353.         break;
  1354.       case LABELANCHOR_EN:
  1355.       case LABELANCHOR_WN:
  1356.         labelframePtr->labelTextY = padding;
  1357.         labelframePtr->labelBox.y = padding;
  1358.         break;
  1359.       case LABELANCHOR_E:
  1360.       case LABELANCHOR_W:
  1361.         labelframePtr->labelTextY = otherHeightT / 2;
  1362.         labelframePtr->labelBox.y = otherHeight / 2;
  1363.         break;
  1364.       default:
  1365. labelframePtr->labelTextY = otherHeightT - padding;
  1366. labelframePtr->labelBox.y = otherHeight - padding;
  1367.         break;
  1368.     }
  1369. }
  1371. /*
  1372.  *----------------------------------------------------------------------
  1373.  *
  1374.  * DisplayFrame --
  1375.  *
  1376.  * This procedure is invoked to display a frame widget.
  1377.  *
  1378.  * Results:
  1379.  * None.
  1380.  *
  1381.  * Side effects:
  1382.  * Commands are output to X to display the frame in its
  1383.  * current mode.
  1384.  *
  1385.  *----------------------------------------------------------------------
  1386.  */
  1388. static void
  1389. DisplayFrame(clientData)
  1390.     ClientData clientData; /* Information about widget. */
  1391. {
  1392.     register Frame *framePtr = (Frame *) clientData;
  1393.     register Tk_Window tkwin = framePtr->tkwin;
  1394.     int bdX1, bdY1, bdX2, bdY2, hlWidth;
  1395.     Pixmap pixmap;
  1396.     TkRegion clipRegion = NULL;
  1398.     framePtr->flags &= ~REDRAW_PENDING;
  1399.     if ((framePtr->tkwin == NULL) || !Tk_IsMapped(tkwin)
  1400.         || framePtr->isContainer) {
  1401. return;
  1402.     }
  1404.     /*
  1405.      * Highlight shall always be drawn if it exists, so do that first.
  1406.      */
  1408.     hlWidth = framePtr->highlightWidth;
  1410.     if (hlWidth != 0) {
  1411.         GC fgGC, bgGC;
  1413. bgGC = Tk_GCForColor(framePtr->highlightBgColorPtr,
  1414. Tk_WindowId(tkwin));
  1415. if (framePtr->flags & GOT_FOCUS) {
  1416.     fgGC = Tk_GCForColor(framePtr->highlightColorPtr,
  1417.     Tk_WindowId(tkwin));
  1418.     TkpDrawHighlightBorder(tkwin, fgGC, bgGC, hlWidth,
  1419.     Tk_WindowId(tkwin));
  1420. } else {
  1421.     TkpDrawHighlightBorder(tkwin, bgGC, bgGC, hlWidth,
  1422.     Tk_WindowId(tkwin));
  1423. }
  1424.     }
  1426.     /*
  1427.      * If -background is set to "", no interior is drawn.
  1428.      */
  1430.     if (framePtr->border == NULL) return;
  1432.     if (framePtr->type != TYPE_LABELFRAME) {
  1433. /*
  1434.  * Pass to platform specific draw function.  In general, it just
  1435.  * draws a simple rectangle, but it may "theme" the background.
  1436.  */
  1438. noLabel:
  1439. TkpDrawFrame(tkwin, framePtr->border, hlWidth,
  1440. framePtr->borderWidth, framePtr->relief);
  1441.     } else {
  1442. Labelframe *labelframePtr = (Labelframe *) framePtr;
  1444. if ((labelframePtr->textPtr == NULL) &&
  1445. (labelframePtr->labelWin == NULL)) {
  1446.     goto noLabel;
  1447. }
  1449. #ifndef TK_NO_DOUBLE_BUFFERING
  1450. /*
  1451.  * In order to avoid screen flashes, this procedure redraws the
  1452.  * frame into off-screen memory, then copies it back on-screen 
  1453.  * in a single operation.  This means there's no point in time 
  1454.  * where the on-screen image has been cleared.
  1455.  */
  1457. pixmap = Tk_GetPixmap(framePtr->display, Tk_WindowId(tkwin),
  1458. Tk_Width(tkwin), Tk_Height(tkwin), Tk_Depth(tkwin));
  1459. #else
  1460. pixmap = Tk_WindowId(tkwin);
  1461. #endif /* TK_NO_DOUBLE_BUFFERING */
  1463. /* 
  1464.  * Clear the pixmap.
  1465.  */
  1467. Tk_Fill3DRectangle(tkwin, pixmap, framePtr->border, 0, 0,
  1468. Tk_Width(tkwin), Tk_Height(tkwin), 0, TK_RELIEF_FLAT);
  1470. /*
  1471.  * Calculate how the label affects the border's position.
  1472.  */
  1474. bdX1 = bdY1 = hlWidth;
  1475. bdX2 = Tk_Width(tkwin) - hlWidth;
  1476. bdY2 = Tk_Height(tkwin) - hlWidth;
  1478. switch (labelframePtr->labelAnchor) {
  1479.   case LABELANCHOR_E:
  1480.   case LABELANCHOR_EN:
  1481.   case LABELANCHOR_ES:
  1482.     bdX2 -= (labelframePtr->labelBox.width - framePtr->borderWidth)
  1483.     / 2;
  1484.     break;
  1485.   case LABELANCHOR_N:
  1486.   case LABELANCHOR_NE:
  1487.   case LABELANCHOR_NW:
  1488.     /* 
  1489.      * Since the glyphs of the text tend to be in the lower part
  1490.              * we favor a lower border position by rounding up.
  1491.      */
  1493.     bdY1 += (labelframePtr->labelBox.height - framePtr->borderWidth +1)
  1494.     / 2;
  1495.     break;
  1496.   case LABELANCHOR_S:
  1497.   case LABELANCHOR_SE:
  1498.   case LABELANCHOR_SW:
  1499.     bdY2 -= (labelframePtr->labelBox.height - framePtr->borderWidth)
  1500.     / 2;
  1501.     break;
  1502.   default:
  1503.     bdX1 += (labelframePtr->labelBox.width - framePtr->borderWidth)
  1504.     / 2;
  1505.     break;
  1506. }
  1508. /* 
  1509.          * Draw border
  1510.          */
  1512. Tk_Draw3DRectangle(tkwin, pixmap, framePtr->border, bdX1, bdY1,
  1513. bdX2 - bdX1, bdY2 - bdY1, framePtr->borderWidth,
  1514. framePtr->relief);
  1516.         if (labelframePtr->labelWin == NULL) {
  1517.             /* 
  1518.              * Clear behind the label
  1519.              */
  1521.             Tk_Fill3DRectangle(tkwin, pixmap,
  1522.                     framePtr->border, labelframePtr->labelBox.x,
  1523.                     labelframePtr->labelBox.y, labelframePtr->labelBox.width,
  1524.                     labelframePtr->labelBox.height, 0, TK_RELIEF_FLAT);
  1526.             /*
  1527.              * Draw label.
  1528.      * If there is not room for the entire label, use clipping to
  1529.      * get a nice appearance.
  1530.              */
  1531.     
  1532.     if ((labelframePtr->labelBox.width < labelframePtr->labelReqWidth)
  1533.     || (labelframePtr->labelBox.height < 
  1534.     labelframePtr->labelReqHeight)) {
  1535. clipRegion = TkCreateRegion();
  1536. TkUnionRectWithRegion(&labelframePtr->labelBox, clipRegion,
  1537. clipRegion);
  1538. TkSetRegion(framePtr->display, labelframePtr->textGC,
  1539. clipRegion);
  1540.     }
  1542.             Tk_DrawTextLayout(framePtr->display, pixmap,
  1543.                     labelframePtr->textGC, labelframePtr->textLayout,
  1544.                     labelframePtr->labelTextX + LABELSPACING,
  1545.                     labelframePtr->labelTextY + LABELSPACING, 0, -1);
  1547.     if (clipRegion != NULL) {
  1548. XSetClipMask(framePtr->display, labelframePtr->textGC, None);
  1549. TkDestroyRegion(clipRegion);
  1550.     }
  1551.         } else {
  1552.     /*
  1553.      * Reposition and map the window (but in different ways depending
  1554.      * on whether the frame is the window's parent).
  1555.      */
  1556.             
  1557.     if (framePtr->tkwin == Tk_Parent(labelframePtr->labelWin)) {
  1558. if ((labelframePtr->labelBox.x != Tk_X(labelframePtr->labelWin))
  1559. || (labelframePtr->labelBox.y !=
  1560. Tk_Y(labelframePtr->labelWin))
  1561. || (labelframePtr->labelBox.width != 
  1562. Tk_Width(labelframePtr->labelWin))
  1563. || (labelframePtr->labelBox.height != 
  1564. Tk_Height(labelframePtr->labelWin))) {
  1565.     Tk_MoveResizeWindow(labelframePtr->labelWin,
  1566.     labelframePtr->labelBox.x, labelframePtr->labelBox.y, 
  1567.     labelframePtr->labelBox.width,
  1568.     labelframePtr->labelBox.height);
  1569. }
  1570. Tk_MapWindow(labelframePtr->labelWin);
  1571.     } else {
  1572. Tk_MaintainGeometry(labelframePtr->labelWin, framePtr->tkwin, 
  1573. labelframePtr->labelBox.x, labelframePtr->labelBox.y,
  1574. labelframePtr->labelBox.width,
  1575. labelframePtr->labelBox.height);
  1576.     }
  1577. }
  1580. #ifndef TK_NO_DOUBLE_BUFFERING
  1581. /*
  1582.  * Everything's been redisplayed;  now copy the pixmap onto the screen
  1583.  * and free up the pixmap.
  1584.  */
  1586. XCopyArea(framePtr->display, pixmap, Tk_WindowId(tkwin),
  1587. labelframePtr->textGC, hlWidth, hlWidth,
  1588. (unsigned) (Tk_Width(tkwin) - 2 * hlWidth),
  1589. (unsigned) (Tk_Height(tkwin) - 2 * hlWidth),
  1590. hlWidth, hlWidth);
  1591. Tk_FreePixmap(framePtr->display, pixmap);
  1592. #endif /* TK_NO_DOUBLE_BUFFERING */
  1593.     }
  1595. }
  1597. /*
  1598.  *--------------------------------------------------------------
  1599.  *
  1600.  * FrameEventProc --
  1601.  *
  1602.  * This procedure is invoked by the Tk dispatcher on
  1603.  * structure changes to a frame.  For frames with 3D
  1604.  * borders, this procedure is also invoked for exposures.
  1605.  *
  1606.  * Results:
  1607.  * None.
  1608.  *
  1609.  * Side effects:
  1610.  * When the window gets deleted, internal structures get
  1611.  * cleaned up.  When it gets exposed, it is redisplayed.
  1612.  *
  1613.  *--------------------------------------------------------------
  1614.  */
  1616. static void
  1617. FrameEventProc(clientData, eventPtr)
  1618.     ClientData clientData; /* Information about window. */
  1619.     register XEvent *eventPtr; /* Information about event. */
  1620. {
  1621.     register Frame *framePtr = (Frame *) clientData;
  1623.     if ((eventPtr->type == Expose) && (eventPtr->xexpose.count == 0)) {
  1624. goto redraw;
  1625.     } else if (eventPtr->type == ConfigureNotify) {
  1626. ComputeFrameGeometry(framePtr);
  1627. goto redraw;
  1628.     } else if (eventPtr->type == DestroyNotify) {
  1629. if (framePtr->menuName != NULL) {
  1630.     TkSetWindowMenuBar(framePtr->interp, framePtr->tkwin,
  1631.     framePtr->menuName, NULL);
  1632.     ckfree(framePtr->menuName);
  1633.     framePtr->menuName = NULL;
  1634. }
  1635. if (framePtr->tkwin != NULL) {
  1637.     /*
  1638.      * If this window is a container, then this event could be
  1639.      * coming from the embedded application, in which case
  1640.      * Tk_DestroyWindow hasn't been called yet.  When Tk_DestroyWindow
  1641.      * is called later, then another destroy event will be generated.
  1642.      * We need to be sure we ignore the second event, since the frame
  1643.      * could be gone by then.  To do so, delete the event handler
  1644.      * explicitly (normally it's done implicitly by Tk_DestroyWindow).
  1645.      */
  1647.     /*
  1648.      * Since the tkwin pointer will be gone when we reach
  1649.      * DestroyFrame, we must free all options now.
  1650.      */
  1652.             DestroyFramePartly(framePtr);
  1654.     Tk_DeleteEventHandler(framePtr->tkwin,
  1655.     ExposureMask|StructureNotifyMask|FocusChangeMask,
  1656.     FrameEventProc, (ClientData) framePtr);
  1657.     framePtr->tkwin = NULL;
  1658.             Tcl_DeleteCommandFromToken(framePtr->interp, framePtr->widgetCmd);
  1659. }
  1660. if (framePtr->flags & REDRAW_PENDING) {
  1661.     Tcl_CancelIdleCall(DisplayFrame, (ClientData) framePtr);
  1662. }
  1663. Tcl_CancelIdleCall(MapFrame, (ClientData) framePtr);
  1664. Tcl_EventuallyFree((ClientData) framePtr, DestroyFrame);
  1665.     } else if (eventPtr->type == FocusIn) {
  1666. if (eventPtr->xfocus.detail != NotifyInferior) {
  1667.     framePtr->flags |= GOT_FOCUS;
  1668.     if (framePtr->highlightWidth > 0) {
  1669. goto redraw;
  1670.     }
  1671. }
  1672.     } else if (eventPtr->type == FocusOut) {
  1673. if (eventPtr->xfocus.detail != NotifyInferior) {
  1674.     framePtr->flags &= ~GOT_FOCUS;
  1675.     if (framePtr->highlightWidth > 0) {
  1676. goto redraw;
  1677.     }
  1678. }
  1679.     } else if (eventPtr->type == ActivateNotify) {
  1680.      TkpSetMainMenubar(framePtr->interp, framePtr->tkwin,
  1681.      framePtr->menuName);
  1682.     }
  1683.     return;
  1685.     redraw:
  1686.     if ((framePtr->tkwin != NULL) && !(framePtr->flags & REDRAW_PENDING)) {
  1687. Tcl_DoWhenIdle(DisplayFrame, (ClientData) framePtr);
  1688. framePtr->flags |= REDRAW_PENDING;
  1689.     }
  1690. }
  1692. /*
  1693.  *----------------------------------------------------------------------
  1694.  *
  1695.  * FrameCmdDeletedProc --
  1696.  *
  1697.  * This procedure is invoked when a widget command is deleted.  If
  1698.  * the widget isn't already in the process of being destroyed,
  1699.  * this command destroys it.
  1700.  *
  1701.  * Results:
  1702.  * None.
  1703.  *
  1704.  * Side effects:
  1705.  * The widget is destroyed.
  1706.  *
  1707.  *----------------------------------------------------------------------
  1708.  */
  1710. static void
  1711. FrameCmdDeletedProc(clientData)
  1712.     ClientData clientData; /* Pointer to widget record for widget. */
  1713. {
  1714.     Frame *framePtr = (Frame *) clientData;
  1715.     Tk_Window tkwin = framePtr->tkwin;
  1717.     if (framePtr->menuName != NULL) {
  1718. TkSetWindowMenuBar(framePtr->interp, framePtr->tkwin,
  1719. framePtr->menuName, NULL);
  1720. ckfree(framePtr->menuName);
  1721. framePtr->menuName = NULL;
  1722.     }
  1724.     /*
  1725.      * This procedure could be invoked either because the window was
  1726.      * destroyed and the command was then deleted (in which case tkwin
  1727.      * is NULL) or because the command was deleted, and then this procedure
  1728.      * destroys the widget.
  1729.      */
  1731.     if (tkwin != NULL) {
  1732. /* 
  1733.  * Some options need tkwin to be freed, so we free them here,
  1734.  * before setting tkwin to NULL.
  1735.  */
  1737.         DestroyFramePartly(framePtr);
  1739. framePtr->tkwin = NULL;
  1740. Tk_DestroyWindow(tkwin);
  1741.     }
  1742. }
  1744. /*
  1745.  *----------------------------------------------------------------------
  1746.  *
  1747.  * MapFrame --
  1748.  *
  1749.  * This procedure is invoked as a when-idle handler to map a
  1750.  * newly-created top-level frame.
  1751.  *
  1752.  * Results:
  1753.  * None.
  1754.  *
  1755.  * Side effects:
  1756.  * The frame given by the clientData argument is mapped.
  1757.  *
  1758.  *----------------------------------------------------------------------
  1759.  */
  1761. static void
  1762. MapFrame(clientData)
  1763.     ClientData clientData; /* Pointer to frame structure. */
  1764. {
  1765.     Frame *framePtr = (Frame *) clientData;
  1767.     /*
  1768.      * Wait for all other background events to be processed before
  1769.      * mapping window.  This ensures that the window's correct geometry
  1770.      * will have been determined before it is first mapped, so that the
  1771.      * window manager doesn't get a false idea of its desired geometry.
  1772.      */
  1774.     Tcl_Preserve((ClientData) framePtr);
  1775.     while (1) {
  1776. if (Tcl_DoOneEvent(TCL_IDLE_EVENTS) == 0) {
  1777.     break;
  1778. }
  1780. /*
  1781.  * After each event, make sure that the window still exists
  1782.  * and quit if the window has been destroyed.
  1783.  */
  1785. if (framePtr->tkwin == NULL) {
  1786.     Tcl_Release((ClientData) framePtr);
  1787.     return;
  1788. }
  1789.     }
  1790.     Tk_MapWindow(framePtr->tkwin);
  1791.     Tcl_Release((ClientData) framePtr);
  1792. }
  1794. /*
  1795.  *--------------------------------------------------------------
  1796.  *
  1797.  * TkInstallFrameMenu --
  1798.  *
  1799.  * This function is needed when a Windows HWND is created
  1800.  * and a menubar has been set to the window with a system
  1801.  * menu. It notifies the menu package so that the system
  1802.  * menu can be rebuilt.
  1803.  *
  1804.  * Results:
  1805.  * None.
  1806.  *
  1807.  * Side effects:
  1808.  * The system menu (if any) is created for the menubar
  1809.  * associated with this frame.
  1810.  *
  1811.  *--------------------------------------------------------------
  1812.  */
  1814. void
  1815. TkInstallFrameMenu(tkwin)
  1816.     Tk_Window tkwin; /* The window that was just created. */
  1817. {
  1818.     TkWindow *winPtr = (TkWindow *) tkwin;
  1820.     if (winPtr->mainPtr != NULL) {
  1821. Frame *framePtr;
  1822. framePtr = (Frame*) winPtr->instanceData;
  1823. if (framePtr == NULL) {
  1824.     panic("TkInstallFrameMenu couldn't get frame pointer");
  1825. }
  1826. TkpMenuNotifyToplevelCreate(winPtr->mainPtr->interp, 
  1827. framePtr->menuName);
  1828.     }
  1829. }
  1831. /*
  1832.  *--------------------------------------------------------------
  1833.  *
  1834.  * FrameStructureProc --
  1835.  *
  1836.  * This procedure is invoked whenever StructureNotify events
  1837.  * occur for a window that's managed as label for the frame.
  1838.  * This procudure's only purpose is to clean up when windows
  1839.  * are deleted.
  1840.  *
  1841.  * Results:
  1842.  * None.
  1843.  *
  1844.  * Side effects:
  1845.  * The window is disassociated from the frame when it is
  1846.  * deleted.
  1847.  *
  1848.  *--------------------------------------------------------------
  1849.  */
  1851. static void
  1852. FrameStructureProc(clientData, eventPtr)
  1853.     ClientData clientData; /* Pointer to record describing frame. */
  1854.     XEvent *eventPtr; /* Describes what just happened. */
  1855. {
  1856.     Labelframe *labelframePtr = (Labelframe *) clientData;
  1858.     if (eventPtr->type == DestroyNotify) {
  1859. /*
  1860.  * This should only happen in a labelframe but it doesn't
  1861.  * hurt to be careful.
  1862.  */
  1864. if (labelframePtr->frame.type == TYPE_LABELFRAME) {
  1865.     labelframePtr->labelWin = NULL;
  1866.     FrameWorldChanged((ClientData) labelframePtr);
  1867. }
  1868.     }
  1869. }
  1871. /*
  1872.  *--------------------------------------------------------------
  1873.  *
  1874.  * FrameRequestProc --
  1875.  *
  1876.  * This procedure is invoked whenever a window that's associated
  1877.  * with a frame changes its requested dimensions.
  1878.  *
  1879.  * Results:
  1880.  * None.
  1881.  *
  1882.  * Side effects:
  1883.  * The size and location on the screen of the window may change.
  1884.  * depending on the options specified for the frame.
  1885.  *
  1886.  *--------------------------------------------------------------
  1887.  */
  1889. static void
  1890. FrameRequestProc(clientData, tkwin)
  1891.     ClientData clientData; /* Pointer to record for frame. */
  1892.     Tk_Window tkwin; /* Window that changed its desired
  1893.  * size. */
  1894. {
  1895.     Frame *framePtr = (Frame *) clientData;
  1897.     FrameWorldChanged((ClientData) framePtr);
  1898. }
  1900. /*
  1901.  *--------------------------------------------------------------
  1902.  *
  1903.  * FrameLostSlaveProc --
  1904.  *
  1905.  * This procedure is invoked by Tk whenever some other geometry
  1906.  * claims control over a slave that used to be managed by us.
  1907.  *
  1908.  * Results:
  1909.  * None.
  1910.  *
  1911.  * Side effects:
  1912.  * Forgets all frame-related information about the slave.
  1913.  *
  1914.  *--------------------------------------------------------------
  1915.  */
  1917. static void
  1918. FrameLostSlaveProc(clientData, tkwin)
  1919.     ClientData clientData; /* Frame structure for slave window that
  1920.  * was stolen away. */
  1921.     Tk_Window tkwin; /* Tk's handle for the slave window. */
  1922. {
  1923.     Frame *framePtr = (Frame *) clientData;
  1924.     Labelframe *labelframePtr = (Labelframe *) clientData;
  1926.     /*
  1927.      * This should only happen in a labelframe but it doesn't
  1928.      * hurt to be careful.
  1929.      */
  1930.     
  1931.     if (labelframePtr->frame.type == TYPE_LABELFRAME) {
  1932. Tk_DeleteEventHandler(labelframePtr->labelWin, StructureNotifyMask,
  1933. FrameStructureProc, (ClientData) labelframePtr);
  1934. if (framePtr->tkwin != Tk_Parent(labelframePtr->labelWin)) {
  1935.     Tk_UnmaintainGeometry(labelframePtr->labelWin, framePtr->tkwin);
  1936. }
  1937. Tk_UnmapWindow(labelframePtr->labelWin);
  1938. labelframePtr->labelWin = NULL;
  1939.     }
  1940.     FrameWorldChanged((ClientData) framePtr);
  1941. }
  1943. /*
  1944.  *--------------------------------------------------------------
  1945.  *
  1946.  * TkToplevelWindowFromCommandToken --
  1947.  *
  1948.  * If the given command name to the command for a toplevel window
  1949.  * in the given interpreter, return the tkwin for that toplevel
  1950.  * window.  Note that this lookup can't be done using the
  1951.  * standard tkwin internal table because the command might have
  1952.  * been renamed.
  1953.  *
  1954.  * Results:
  1955.  * A Tk_Window token, or NULL if the name does not refer to a
  1956.  * toplevel window.
  1957.  *
  1958.  * Side effects:
  1959.  * None.
  1960.  *
  1961.  *--------------------------------------------------------------
  1962.  */
  1964. Tk_Window
  1965. TkToplevelWindowForCommand(interp, cmdName)
  1966.     Tcl_Interp *interp;
  1967.     CONST char *cmdName;
  1968. {
  1969.     Tcl_CmdInfo cmdInfo;
  1970.     Frame *framePtr;
  1972.     if (Tcl_GetCommandInfo(interp, cmdName, &cmdInfo) == 0) {
  1973. return NULL;
  1974.     }
  1975.     if (cmdInfo.objProc != FrameWidgetObjCmd) {
  1976. return NULL;
  1977.     }
  1978.     framePtr = (Frame *) cmdInfo.objClientData;
  1979.     if (framePtr->type != TYPE_TOPLEVEL) {
  1980. return NULL;
  1981.     }
  1982.     return framePtr->tkwin;
  1983. }