diff options
| author | dkf <donal.k.fellows@manchester.ac.uk> | 2005-08-16 16:36:15 (GMT) |
|---|---|---|
| committer | dkf <donal.k.fellows@manchester.ac.uk> | 2005-08-16 16:36:15 (GMT) |
| commit | 5dd91aa505932ce041fe9c1af0b4c72f1364feea (patch) | |
| tree | 4eb81271a0f9928a8f533cedb812e47ce4d3acb9 | |
| parent | 7edf7399c55b3292a9a28fcf2c1ac0230cec8dea (diff) | |
| download | tk-5dd91aa505932ce041fe9c1af0b4c72f1364feea.zip tk-5dd91aa505932ce041fe9c1af0b4c72f1364feea.tar.gz tk-5dd91aa505932ce041fe9c1af0b4c72f1364feea.tar.bz2 | |
Style systematization
| -rw-r--r-- | generic/tkWindow.c | 1349 |
1 files changed, 667 insertions, 682 deletions
diff --git a/generic/tkWindow.c b/generic/tkWindow.c index 0d34290..c652e34 100644 --- a/generic/tkWindow.c +++ b/generic/tkWindow.c @@ -1,18 +1,17 @@ -/* +/* * tkWindow.c -- * - * This file provides basic window-manipulation procedures, - * which are equivalent to procedures in Xlib (and even - * invoke them) but also maintain the local Tk_Window - * structure. + * This file provides basic window-manipulation functions, which are + * equivalent to functions in Xlib (and even invoke them) but also + * maintain the local Tk_Window structure. * * Copyright (c) 1989-1994 The Regents of the University of California. * Copyright (c) 1994-1997 Sun Microsystems, Inc. * - * See the file "license.terms" for information on usage and redistribution - * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * See the file "license.terms" for information on usage and redistribution of + * this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tkWindow.c,v 1.67 2005/03/23 22:17:26 wolfsuit Exp $ + * RCS: @(#) $Id: tkWindow.c,v 1.68 2005/08/16 16:36:15 dkf Exp $ */ #include "tkPort.h" @@ -22,9 +21,9 @@ #include "tkUnixInt.h" #endif -/* - * Type used to keep track of Window objects that were - * only partically deallocated by Tk_DestroyWindow. +/* + * Type used to keep track of Window objects that were only partially + * deallocated by Tk_DestroyWindow. */ #define HD_CLEANUP 1 @@ -39,34 +38,32 @@ typedef struct TkHalfdeadWindow { struct TkHalfdeadWindow *nextPtr; } TkHalfdeadWindow; - typedef struct ThreadSpecificData { - int numMainWindows; /* Count of numver of main windows currently - * open in this thread. */ + int numMainWindows; /* Count of numver of main windows currently + * open in this thread. */ TkMainInfo *mainWindowList; - /* First in list of all main windows managed - * by this thread. */ + /* First in list of all main windows managed + * by this thread. */ TkHalfdeadWindow *halfdeadWindowList; - /* First in list of partially deallocated - * windows. */ - TkDisplay *displayList; - /* List of all displays currently in use by - * the current thread. */ - int initialized; /* 0 means the structures above need - * initializing. */ + /* First in list of partially deallocated + * windows. */ + TkDisplay *displayList; /* List of all displays currently in use by + * the current thread. */ + int initialized; /* 0 means the structures above need + * initializing. */ } ThreadSpecificData; static Tcl_ThreadDataKey dataKey; -/* - * The Mutex below is used to lock access to the Tk_Uid structs above. +/* + * The Mutex below is used to lock access to the Tk_Uid structs above. */ TCL_DECLARE_MUTEX(windowMutex) /* - * Default values for "changes" and "atts" fields of TkWindows. Note - * that Tk always requests all events for all windows, except StructureNotify - * events on internal windows: these events are generated internally. + * Default values for "changes" and "atts" fields of TkWindows. Note that Tk + * always requests all events for all windows, except StructureNotify events + * on internal windows: these events are generated internally. */ static XWindowChanges defChanges = { @@ -95,21 +92,20 @@ static XSetWindowAttributes defAtts= { }; /* - * The following structure defines all of the commands supported by - * Tk, and the C procedures that execute them. + * The following structure defines all of the commands supported by Tk, and + * the C functions that execute them. */ typedef struct { char *name; /* Name of command. */ - Tcl_CmdProc *cmdProc; /* Command's string-based procedure. */ - Tcl_ObjCmdProc *objProc; /* Command's object-based procedure. */ - int isSafe; /* If !0, this command will be exposed in - * a safe interpreter. Otherwise it will be - * hidden in a safe interpreter. */ - int passMainWindow; /* 0 means provide NULL clientData to - * command procedure; 1 means pass main - * window as clientData to command - * procedure. */ + Tcl_CmdProc *cmdProc; /* Command's string-based function. */ + Tcl_ObjCmdProc *objProc; /* Command's object-based function. */ + int isSafe; /* If !0, this command will be exposed in a + * safe interpreter. Otherwise it will be + * hidden in a safe interpreter. */ + int passMainWindow; /* 0 means provide NULL clientData to command + * function; 1 means pass main window as + * clientData to command function. */ } TkCmd; static TkCmd commands[] = { @@ -136,15 +132,6 @@ static TkCmd commands[] = { {"selection", NULL, Tk_SelectionObjCmd, 0, 1}, {"tk", NULL, Tk_TkObjCmd, 1, 1}, {"tkwait", NULL, Tk_TkwaitObjCmd, 1, 1}, -#if defined(__WIN32__) || defined(MAC_OSX_TK) - {"tk_chooseColor", NULL, Tk_ChooseColorObjCmd, 0, 1}, - {"tk_chooseDirectory", NULL, Tk_ChooseDirectoryObjCmd, 0, 1}, - {"tk_getOpenFile", NULL, Tk_GetOpenFileObjCmd, 0, 1}, - {"tk_getSaveFile", NULL, Tk_GetSaveFileObjCmd, 0, 1}, -#endif -#if defined(__WIN32__) || defined(MAC_OSX_TK) - {"tk_messageBox", NULL, Tk_MessageBoxObjCmd, 0, 1}, -#endif {"update", NULL, Tk_UpdateObjCmd, 1, 1}, {"winfo", NULL, Tk_WinfoObjCmd, 1, 1}, {"wm", NULL, Tk_WmObjCmd, 0, 1}, @@ -156,35 +143,48 @@ static TkCmd commands[] = { {"button", NULL, Tk_ButtonObjCmd, 1, 0}, {"canvas", NULL, Tk_CanvasObjCmd, 1, 1}, {"checkbutton", NULL, Tk_CheckbuttonObjCmd, 1, 0}, - {"entry", NULL, Tk_EntryObjCmd, 1, 0}, + {"entry", NULL, Tk_EntryObjCmd, 1, 0}, {"frame", NULL, Tk_FrameObjCmd, 1, 0}, {"label", NULL, Tk_LabelObjCmd, 1, 0}, {"labelframe", NULL, Tk_LabelframeObjCmd, 1, 0}, {"listbox", NULL, Tk_ListboxObjCmd, 1, 0}, - {"menubutton", NULL, Tk_MenubuttonObjCmd, 1, 0}, + {"menubutton", NULL, Tk_MenubuttonObjCmd, 1, 0}, {"message", NULL, Tk_MessageObjCmd, 1, 0}, {"panedwindow", NULL, Tk_PanedWindowObjCmd, 1, 0}, {"radiobutton", NULL, Tk_RadiobuttonObjCmd, 1, 0}, - {"scale", NULL, Tk_ScaleObjCmd, 1, 0}, + {"scale", NULL, Tk_ScaleObjCmd, 1, 0}, {"scrollbar", Tk_ScrollbarCmd, NULL, 1, 1}, - {"spinbox", NULL, Tk_SpinboxObjCmd, 1, 0}, - {"text", NULL, Tk_TextObjCmd, 1, 1}, + {"spinbox", NULL, Tk_SpinboxObjCmd, 1, 0}, + {"text", NULL, Tk_TextObjCmd, 1, 1}, {"toplevel", NULL, Tk_ToplevelObjCmd, 0, 0}, /* + * Standard dialog support. Note that the Unix/X11 platform implements + * these commands differently (via the script library). + */ + +#if defined(__WIN32__) || defined(MAC_OSX_TK) + {"tk_chooseColor", NULL, Tk_ChooseColorObjCmd, 0, 1}, + {"tk_chooseDirectory", NULL, Tk_ChooseDirectoryObjCmd,0,1}, + {"tk_getOpenFile", NULL, Tk_GetOpenFileObjCmd, 0, 1}, + {"tk_getSaveFile", NULL, Tk_GetSaveFileObjCmd, 0, 1}, + {"tk_messageBox", NULL, Tk_MessageBoxObjCmd, 0, 1}, +#endif + + /* * Misc. */ #if defined(MAC_OSX_TK) {"::tk::unsupported::MacWindowStyle", - NULL, TkUnsupported1ObjCmd, 1, 1}, + NULL, TkUnsupported1ObjCmd, 1, 1}, #endif - {(char *) NULL, (int (*) _ANSI_ARGS_((ClientData, Tcl_Interp *, int, CONST char **))) NULL, NULL, 0} + {(char *) NULL, NULL, NULL, 0, 0} }; /* - * The variables and table below are used to parse arguments from - * the "argv" variable in Tk_Init. + * The variables and table below are used to parse arguments from the "argv" + * variable in Tk_Init. */ static int synchronize = 0; @@ -218,36 +218,36 @@ static Tk_ArgvInfo argTable[] = { }; /* - * Forward declarations to procedures defined later in this file: + * Forward declarations to functions defined later in this file: */ -static Tk_Window CreateTopLevelWindow _ANSI_ARGS_((Tcl_Interp *interp, - Tk_Window parent, CONST char *name, - CONST char *screenName, unsigned int flags)); -static void DeleteWindowsExitProc _ANSI_ARGS_(( - ClientData clientData)); -static TkDisplay * GetScreen _ANSI_ARGS_((Tcl_Interp *interp, - CONST char *screenName, int *screenPtr)); -static int Initialize _ANSI_ARGS_((Tcl_Interp *interp)); -static int NameWindow _ANSI_ARGS_((Tcl_Interp *interp, - TkWindow *winPtr, TkWindow *parentPtr, - CONST char *name)); -static void UnlinkWindow _ANSI_ARGS_((TkWindow *winPtr)); +static Tk_Window CreateTopLevelWindow(Tcl_Interp *interp, + Tk_Window parent, CONST char *name, + CONST char *screenName, unsigned int flags); +static void DeleteWindowsExitProc(ClientData clientData); +static TkDisplay * GetScreen(Tcl_Interp *interp, CONST char *screenName, + int *screenPtr); +static int Initialize(Tcl_Interp *interp); +static int NameWindow(Tcl_Interp *interp, TkWindow *winPtr, + TkWindow *parentPtr, CONST char *name); +static void UnlinkWindow(TkWindow *winPtr); /* *---------------------------------------------------------------------- * * TkCloseDisplay -- - * Closing the display can lead to order of deletion problems. - * We defer it until exit handling for Mac/Win, but since Unix can - * use many displays, try and clean it up as best as possible. + * + * Closing the display can lead to order of deletion problems. We defer + * it until exit handling for Mac/Win, but since Unix can use many + * displays, try and clean it up as best as possible. * * Results: * None. * * Side effects: - * Resources associated with the display will be free. - * The display may not be referenced at all after this. + * Resources associated with the display will be free. The display may + * not be referenced at all after this. + * *---------------------------------------------------------------------- */ @@ -269,8 +269,8 @@ TkCloseDisplay(TkDisplay *dispPtr) if (dispPtr->errorPtr != NULL) { TkErrorHandler *errorPtr; for (errorPtr = dispPtr->errorPtr; - errorPtr != NULL; - errorPtr = dispPtr->errorPtr) { + errorPtr != NULL; + errorPtr = dispPtr->errorPtr) { dispPtr->errorPtr = errorPtr->nextPtr; ckfree((char *) errorPtr); } @@ -281,8 +281,8 @@ TkCloseDisplay(TkDisplay *dispPtr) TkpCloseDisplay(dispPtr); /* - * Delete winTable after TkpCloseDisplay since special windows - * may need call Tk_DestroyWindow and it checks the winTable. + * Delete winTable after TkpCloseDisplay since special windows may need + * call Tk_DestroyWindow and it checks the winTable. */ Tcl_DeleteHashTable(&dispPtr->winTable); @@ -299,19 +299,18 @@ TkCloseDisplay(TkDisplay *dispPtr) * * CreateTopLevelWindow -- * - * Make a new window that will be at top-level (its parent will - * be the root window of a screen). + * Make a new window that will be at top-level (its parent will be the + * root window of a screen). * * Results: - * The return value is a token for the new window, or NULL if - * an error prevented the new window from being created. If - * NULL is returned, an error message will be left in - * the interp's result. + * The return value is a token for the new window, or NULL if an error + * prevented the new window from being created. If NULL is returned, an + * error message will be left in the interp's result. * * Side effects: - * A new window structure is allocated locally. An X - * window is NOT initially created, but will be created - * the first time the window is mapped. + * A new window structure is allocated locally. An X window is NOT + * initially created, but will be created the first time the window is + * mapped. * *---------------------------------------------------------------------- */ @@ -320,23 +319,22 @@ static Tk_Window CreateTopLevelWindow(interp, parent, name, screenName, flags) Tcl_Interp *interp; /* Interpreter to use for error reporting. */ Tk_Window parent; /* Token for logical parent of new window - * (used for naming, options, etc.). May - * be NULL. */ - CONST char *name; /* Name for new window; if parent is - * non-NULL, must be unique among parent's - * children. */ - CONST char *screenName; /* Name of screen on which to create - * window. NULL means use DISPLAY environment - * variable to determine. Empty string means - * use parent's screen, or DISPLAY if no + * (used for naming, options, etc.). May be + * NULL. */ + CONST char *name; /* Name for new window; if parent is non-NULL, + * must be unique among parent's children. */ + CONST char *screenName; /* Name of screen on which to create window. + * NULL means use DISPLAY environment variable + * to determine. Empty string means use + * parent's screen, or DISPLAY if no * parent. */ unsigned int flags; /* Additional flags to set on the window. */ { register TkWindow *winPtr; register TkDisplay *dispPtr; int screenId; - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); if (!tsdPtr->initialized) { tsdPtr->initialized = 1; @@ -344,17 +342,16 @@ CreateTopLevelWindow(interp, parent, name, screenName, flags) /* * Create built-in image types. */ - + Tk_CreateImageType(&tkBitmapImageType); Tk_CreateImageType(&tkPhotoImageType); - + /* * Create built-in photo image formats. */ - + Tk_CreatePhotoImageFormat(&tkImgFmtGIF); Tk_CreatePhotoImageFormat(&tkImgFmtPPM); - } if ((parent != NULL) && (screenName != NULL) && (screenName[0] == '\0')) { @@ -372,28 +369,29 @@ CreateTopLevelWindow(interp, parent, name, screenName, flags) /* * Set the flags specified in the call. */ + winPtr->flags |= flags; - + /* - * Force the window to use a border pixel instead of border pixmap. - * This is needed for the case where the window doesn't use the - * default visual. In this case, the default border is a pixmap - * inherited from the root window, which won't work because it will - * have the wrong visual. + * Force the window to use a border pixel instead of border pixmap. This + * is needed for the case where the window doesn't use the default visual. + * In this case, the default border is a pixmap inherited from the root + * window, which won't work because it will have the wrong visual. */ winPtr->dirtyAtts |= CWBorderPixel; /* - * (Need to set the TK_TOP_HIERARCHY flag immediately here; otherwise - * Tk_DestroyWindow will core dump if it is called before the flag - * has been set.) + * (Need to set the TK_TOP_HIERARCHY flag immediately here; otherwise + * Tk_DestroyWindow will core dump if it is called before the flag has + * been set.) */ - winPtr->flags |= TK_TOP_HIERARCHY|TK_TOP_LEVEL|TK_HAS_WRAPPER|TK_WIN_MANAGED; + winPtr->flags |= + TK_TOP_HIERARCHY|TK_TOP_LEVEL|TK_HAS_WRAPPER|TK_WIN_MANAGED; if (parent != NULL) { - if (NameWindow(interp, winPtr, (TkWindow *) parent, name) != TCL_OK) { + if (NameWindow(interp, winPtr, (TkWindow *) parent, name) != TCL_OK) { Tk_DestroyWindow((Tk_Window) winPtr); return (Tk_Window) NULL; } @@ -408,21 +406,18 @@ CreateTopLevelWindow(interp, parent, name, screenName, flags) * * GetScreen -- * - * Given a string name for a display-plus-screen, find the - * TkDisplay structure for the display and return the screen - * number too. + * Given a string name for a display-plus-screen, find the TkDisplay + * structure for the display and return the screen number too. * * Results: - * The return value is a pointer to information about the display, - * or NULL if the display couldn't be opened. In this case, an - * error message is left in the interp's result. The location at - * *screenPtr is overwritten with the screen number parsed from - * screenName. + * The return value is a pointer to information about the display, or + * NULL if the display couldn't be opened. In this case, an error message + * is left in the interp's result. The location at *screenPtr is + * overwritten with the screen number parsed from screenName. * * Side effects: - * A new connection is opened to the display if there is no - * connection already. A new TkDisplay data structure is also - * setup, if necessary. + * A new connection is opened to the display if there is no connection + * already. A new TkDisplay data structure is also setup, if necessary. * *---------------------------------------------------------------------- */ @@ -430,22 +425,21 @@ CreateTopLevelWindow(interp, parent, name, screenName, flags) static TkDisplay * GetScreen(interp, screenName, screenPtr) Tcl_Interp *interp; /* Place to leave error message. */ - CONST char *screenName; /* Name for screen. NULL or empty means - * use DISPLAY envariable. */ + CONST char *screenName; /* Name for screen. NULL or empty means use + * DISPLAY envariable. */ int *screenPtr; /* Where to store screen number. */ { register TkDisplay *dispPtr; CONST char *p; int screenId; size_t length; - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); /* - * Separate the screen number from the rest of the display - * name. ScreenName is assumed to have the syntax - * <display>.<screen> with the dot and the screen being - * optional. + * Separate the screen number from the rest of the display name. + * ScreenName is assumed to have the syntax <display>.<screen> with the + * dot and the screen being optional. */ screenName = TkGetDefaultScreenName(interp, screenName); @@ -467,16 +461,17 @@ GetScreen(interp, screenName, screenPtr) } /* - * See if we already have a connection to this display. If not, - * then open a new connection. + * See if we already have a connection to this display. If not, then open + * a new connection. */ for (dispPtr = tsdPtr->displayList; ; dispPtr = dispPtr->nextPtr) { if (dispPtr == NULL) { /* - * The private function zeros out dispPtr when it is created, - * so we only need to initialize the non-zero items. + * The private function zeros out dispPtr when it is created, so + * we only need to initialize the non-zero items. */ + dispPtr = TkpOpenDisplay(screenName); if (dispPtr == NULL) { Tcl_ResetResult(interp); @@ -492,10 +487,12 @@ GetScreen(interp, screenName, screenPtr) dispPtr->cursorFont = None; dispPtr->warpWindow = None; dispPtr->multipleAtom = None; + /* * By default we do want to collapse motion events in * Tk_QueueWindowEvent. */ + dispPtr->flags |= TK_DISPLAY_COLLAPSE_MOTION_EVENTS; Tcl_InitHashTable(&dispPtr->winTable, TCL_ONE_WORD_KEYS); @@ -514,7 +511,7 @@ GetScreen(interp, screenName, screenPtr) } if (screenId >= ScreenCount(dispPtr->display)) { char buf[32 + TCL_INTEGER_SPACE]; - + sprintf(buf, "bad screen number \"%d\"", screenId); Tcl_SetResult(interp, buf, TCL_VOLATILE); return (TkDisplay *) NULL; @@ -528,26 +525,26 @@ GetScreen(interp, screenName, screenPtr) * * TkGetDisplay -- * - * Given an X display, TkGetDisplay returns the TkDisplay - * structure for the display. + * Given an X display, TkGetDisplay returns the TkDisplay structure for + * the display. * * Results: - * The return value is a pointer to information about the display, - * or NULL if the display did not have a TkDisplay structure. + * The return value is a pointer to information about the display, or + * NULL if the display did not have a TkDisplay structure. * * Side effects: - * None. + * None. * *---------------------------------------------------------------------- */ TkDisplay * TkGetDisplay(display) - Display *display; /* X's display pointer */ + Display *display; /* X's display pointer */ { TkDisplay *dispPtr; - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); for (dispPtr = tsdPtr->displayList; dispPtr != NULL; dispPtr = dispPtr->nextPtr) { @@ -563,24 +560,25 @@ TkGetDisplay(display) * * TkGetDisplayList -- * - * This procedure returns a pointer to the thread-local - * list of TkDisplays corresponding to the open displays. + * This function returns a pointer to the thread-local list of TkDisplays + * corresponding to the open displays. * * Results: - * The return value is a pointer to the first TkDisplay - * structure in thread-local-storage. + * The return value is a pointer to the first TkDisplay structure in + * thread-local-storage. * * Side effects: - * None. + * None. * *-------------------------------------------------------------- */ + TkDisplay * TkGetDisplayList() { - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + return tsdPtr->displayList; } @@ -589,25 +587,25 @@ TkGetDisplayList() * * TkGetMainInfoList -- * - * This procedure returns a pointer to the list of structures - * containing information about all main windows for the - * current thread. + * This function returns a pointer to the list of structures containing + * information about all main windows for the current thread. * * Results: - * The return value is a pointer to the first TkMainInfo - * structure in thread local storage. + * The return value is a pointer to the first TkMainInfo structure in + * thread local storage. * * Side effects: - * None. + * None. * *-------------------------------------------------------------- */ + TkMainInfo * TkGetMainInfoList() { - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + return tsdPtr->mainWindowList; } /* @@ -615,7 +613,7 @@ TkGetMainInfoList() * * TkAllocWindow -- * - * This procedure creates and initializes a TkWindow structure. + * This function creates and initializes a TkWindow structure. * * Results: * The return value is a pointer to the new window. @@ -632,9 +630,8 @@ TkAllocWindow(dispPtr, screenNum, parentPtr) TkDisplay *dispPtr; /* Display associated with new window. */ int screenNum; /* Index of screen for new window. */ TkWindow *parentPtr; /* Parent from which this window should - * inherit visual information. NULL means - * use screen defaults instead of - * inheriting. */ + * inherit visual information. NULL means use + * screen defaults instead of inheriting. */ { register TkWindow *winPtr; @@ -700,15 +697,14 @@ TkAllocWindow(dispPtr, screenNum, parentPtr) * * NameWindow -- * - * This procedure is invoked to give a window a name and insert - * the window into the hierarchy associated with a particular - * application. + * This function is invoked to give a window a name and insert the window + * into the hierarchy associated with a particular application. * * Results: * A standard Tcl return value. * * Side effects: - * See above. + * See above. * *---------------------------------------------------------------------- */ @@ -717,9 +713,9 @@ static int NameWindow(interp, winPtr, parentPtr, name) Tcl_Interp *interp; /* Interpreter to use for error reporting. */ register TkWindow *winPtr; /* Window that is to be named and inserted. */ - TkWindow *parentPtr; /* Pointer to logical parent for winPtr - * (used for naming, options, etc.). */ - CONST char *name; /* Name for winPtr; must be unique among + TkWindow *parentPtr; /* Pointer to logical parent for winPtr (used + * for naming, options, etc.). */ + CONST char *name; /* Name for winPtr; must be unique among * parentPtr's children. */ { #define FIXED_SIZE 200 @@ -731,10 +727,11 @@ NameWindow(interp, winPtr, parentPtr, name) /* * Setup all the stuff except name right away, then do the name stuff - * last. This is so that if the name stuff fails, everything else - * will be properly initialized (needed to destroy the window cleanly - * after the naming failure). + * last. This is so that if the name stuff fails, everything else will be + * properly initialized (needed to destroy the window cleanly after the + * naming failure). */ + winPtr->parentPtr = parentPtr; winPtr->nextPtr = NULL; if (parentPtr->childList == NULL) { @@ -750,6 +747,7 @@ NameWindow(interp, winPtr, parentPtr, name) * If this is an anonymous window (ie, it has no name), just return OK * now. */ + if (winPtr->flags & TK_ANONYMOUS_WINDOW) { return TCL_OK; } @@ -761,8 +759,8 @@ NameWindow(interp, winPtr, parentPtr, name) winPtr->nameUid = Tk_GetUid(name); /* - * Don't permit names that start with an upper-case letter: this - * will just cause confusion with class names in the option database. + * Don't permit names that start with an upper-case letter: this will just + * cause confusion with class names in the option database. */ if (isupper(UCHAR(name[0]))) { @@ -773,10 +771,9 @@ NameWindow(interp, winPtr, parentPtr, name) } /* - * To permit names of arbitrary length, must be prepared to malloc - * a buffer to hold the new path name. To run fast in the common - * case where names are short, use a fixed-size buffer on the - * stack. + * To permit names of arbitrary length, must be prepared to malloc a + * buffer to hold the new path name. To run fast in the common case where + * names are short, use a fixed-size buffer on the stack. */ length1 = strlen(parentPtr->pathName); @@ -813,22 +810,20 @@ NameWindow(interp, winPtr, parentPtr, name) * * TkCreateMainWindow -- * - * Make a new main window. A main window is a special kind of - * top-level window used as the outermost window in an - * application. + * Make a new main window. A main window is a special kind of top-level + * window used as the outermost window in an application. * * Results: - * The return value is a token for the new window, or NULL if - * an error prevented the new window from being created. If - * NULL is returned, an error message will be left in - * the interp's result. + * The return value is a token for the new window, or NULL if an error + * prevented the new window from being created. If NULL is returned, an + * error message will be left in the interp's result. * * Side effects: - * A new window structure is allocated locally; "interp" is - * associated with the window and registered for "send" commands - * under "baseName". BaseName may be extended with an instance - * number in the form "#2" if necessary to make it globally - * unique. Tk-related commands are bound into interp. + * A new window structure is allocated locally; "interp" is associated + * with the window and registered for "send" commands under "baseName". + * BaseName may be extended with an instance number in the form "#2" if + * necessary to make it globally unique. Tk-related commands are bound + * into interp. * *---------------------------------------------------------------------- */ @@ -836,10 +831,10 @@ NameWindow(interp, winPtr, parentPtr, name) Tk_Window TkCreateMainWindow(interp, screenName, baseName) Tcl_Interp *interp; /* Interpreter to use for error reporting. */ - CONST char *screenName; /* Name of screen on which to create - * window. Empty or NULL string means - * use DISPLAY environment variable. */ - char *baseName; /* Base name for application; usually of the + CONST char *screenName; /* Name of screen on which to create window. + * Empty or NULL string means use DISPLAY + * environment variable. */ + char *baseName; /* Base name for application; usually of the * form "prog instance". */ { Tk_Window tkwin; @@ -850,12 +845,12 @@ TkCreateMainWindow(interp, screenName, baseName) register TkWindow *winPtr; register TkCmd *cmdPtr; ClientData clientData; - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + /* - * Panic if someone updated the TkWindow structure without - * also updating the Tk_FakeWin structure (or vice versa). + * Panic if someone updated the TkWindow structure without also updating + * the Tk_FakeWin structure (or vice versa). */ if (sizeof(TkWindow) != sizeof(Tk_FakeWin)) { @@ -871,10 +866,10 @@ TkCreateMainWindow(interp, screenName, baseName) if (tkwin == NULL) { return NULL; } - + /* - * Create the TkMainInfo structure for this application, and set - * up name-related information for the new window. + * Create the TkMainInfo structure for this application, and set up + * name-related information for the new window. */ winPtr = (TkWindow *) tkwin; @@ -905,8 +900,8 @@ TkCreateMainWindow(interp, screenName, baseName) winPtr->pathName = Tcl_GetHashKey(&mainPtr->nameTable, hPtr); /* - * We have just created another Tk application; increment the refcount - * on the display pointer. + * We have just created another Tk application; increment the refcount on + * the display pointer. */ winPtr->dispPtr->refCount++; @@ -938,11 +933,11 @@ TkCreateMainWindow(interp, screenName, baseName) Tcl_CreateObjCommand(interp, cmdPtr->name, cmdPtr->objProc, clientData, NULL); } - if (isSafe) { - if (!(cmdPtr->isSafe)) { - Tcl_HideCommand(interp, cmdPtr->name, cmdPtr->name); - } - } + if (isSafe) { + if (!(cmdPtr->isSafe)) { + Tcl_HideCommand(interp, cmdPtr->name, cmdPtr->name); + } + } } TkCreateMenuCmd(interp); @@ -963,20 +958,19 @@ TkCreateMainWindow(interp, screenName, baseName) * * Tk_CreateWindow -- * - * Create a new internal or top-level window as a child of an - * existing window. + * Create a new internal or top-level window as a child of an existing + * window. * * Results: - * The return value is a token for the new window. This - * is not the same as X's token for the window. If an error - * occurred in creating the window (e.g. no such display or - * screen), then an error message is left in the interp's result and - * NULL is returned. + * The return value is a token for the new window. This is not the same + * as X's token for the window. If an error occurred in creating the + * window (e.g. no such display or screen), then an error message is left + * in the interp's result and NULL is returned. * * Side effects: - * A new window structure is allocated locally. An X - * window is not initially created, but will be created - * the first time the window is mapped. + * A new window structure is allocated locally. An X window is not + * initially created, but will be created the first time the window is + * mapped. * *-------------------------------------------------------------- */ @@ -987,12 +981,12 @@ Tk_CreateWindow(interp, parent, name, screenName) * the interp's result is assumed to be * initialized by the caller. */ Tk_Window parent; /* Token for parent of new window. */ - CONST char *name; /* Name for new window. Must be unique - * among parent's children. */ + CONST char *name; /* Name for new window. Must be unique among + * parent's children. */ CONST char *screenName; /* If NULL, new window will be internal on - * same screen as its parent. If non-NULL, - * gives name of screen on which to create - * new window; window will be a top-level + * same screen as its parent. If non-NULL, + * gives name of screen on which to create new + * window; window will be a top-level * window. */ { TkWindow *parentPtr = (TkWindow *) parent; @@ -1017,7 +1011,7 @@ Tk_CreateWindow(interp, parent, name, screenName) Tk_DestroyWindow((Tk_Window) winPtr); return NULL; } else { - return (Tk_Window) winPtr; + return (Tk_Window) winPtr; } } else { return CreateTopLevelWindow(interp, parent, name, screenName, @@ -1030,21 +1024,20 @@ Tk_CreateWindow(interp, parent, name, screenName) * * Tk_CreateAnonymousWindow -- * - * Create a new internal or top-level window as a child of an - * existing window; this window will be anonymous (unnamed), so - * it will not be visible at the Tcl level. + * Create a new internal or top-level window as a child of an existing + * window; this window will be anonymous (unnamed), so it will not be + * visible at the Tcl level. * * Results: - * The return value is a token for the new window. This - * is not the same as X's token for the window. If an error - * occurred in creating the window (e.g. no such display or - * screen), then an error message is left in the interp's result and - * NULL is returned. + * The return value is a token for the new window. This is not the same + * as X's token for the window. If an error occurred in creating the + * window (e.g. no such display or screen), then an error message is left + * in the interp's result and NULL is returned. * * Side effects: - * A new window structure is allocated locally. An X - * window is not initially created, but will be created - * the first time the window is mapped. + * A new window structure is allocated locally. An X window is not + * initially created, but will be created the first time the window is + * mapped. * *-------------------------------------------------------------- */ @@ -1056,9 +1049,9 @@ Tk_CreateAnonymousWindow(interp, parent, screenName) * initialized by the caller. */ Tk_Window parent; /* Token for parent of new window. */ CONST char *screenName; /* If NULL, new window will be internal on - * same screen as its parent. If non-NULL, - * gives name of screen on which to create - * new window; window will be a top-level + * same screen as its parent. If non-NULL, + * gives name of screen on which to create new + * window; window will be a top-level * window. */ { TkWindow *parentPtr = (TkWindow *) parent; @@ -1101,21 +1094,19 @@ Tk_CreateAnonymousWindow(interp, parent, screenName) * * Tk_CreateWindowFromPath -- * - * This procedure is similar to Tk_CreateWindow except that - * it uses a path name to create the window, rather than a - * parent and a child name. + * This function is similar to Tk_CreateWindow except that it uses a path + * name to create the window, rather than a parent and a child name. * * Results: - * The return value is a token for the new window. This - * is not the same as X's token for the window. If an error - * occurred in creating the window (e.g. no such display or - * screen), then an error message is left in the interp's result and - * NULL is returned. + * The return value is a token for the new window. This is not the same + * as X's token for the window. If an error occurred in creating the + * window (e.g. no such display or screen), then an error message is left + * in the interp's result and NULL is returned. * * Side effects: - * A new window structure is allocated locally. An X - * window is not initially created, but will be created - * the first time the window is mapped. + * A new window structure is allocated locally. An X window is not + * initially created, but will be created the first time the window is + * mapped. * *---------------------------------------------------------------------- */ @@ -1125,17 +1116,16 @@ Tk_CreateWindowFromPath(interp, tkwin, pathName, screenName) Tcl_Interp *interp; /* Interpreter to use for error reporting. * the interp's result is assumed to be * initialized by the caller. */ - Tk_Window tkwin; /* Token for any window in application - * that is to contain new window. */ + Tk_Window tkwin; /* Token for any window in application that is + * to contain new window. */ CONST char *pathName; /* Path name for new window within the - * application of tkwin. The parent of - * this window must already exist, but - * the window itself must not exist. */ - CONST char *screenName; /* If NULL, new window will be on same - * screen as its parent. If non-NULL, - * gives name of screen on which to create - * new window; window will be a top-level - * window. */ + * application of tkwin. The parent of this + * window must already exist, but the window + * itself must not exist. */ + CONST char *screenName; /* If NULL, new window will be on same screen + * as its parent. If non-NULL, gives name of + * screen on which to create new window; + * window will be a top-level window. */ { #define FIXED_SPACE 5 char fixedSpace[FIXED_SPACE+1]; @@ -1144,12 +1134,11 @@ Tk_CreateWindowFromPath(interp, tkwin, pathName, screenName) int numChars; /* - * Strip the parent's name out of pathName (it's everything up - * to the last dot). There are two tricky parts: (a) must - * copy the parent's name somewhere else to avoid modifying - * the pathName string (for large names, space for the copy - * will have to be malloc'ed); (b) must special-case the - * situation where the parent is ".". + * Strip the parent's name out of pathName (it's everything up to the last + * dot). There are two tricky parts: (a) must copy the parent's name + * somewhere else to avoid modifying the pathName string (for large names, + * space for the copy will have to be malloc'ed); (b) must special-case + * the situation where the parent is ".". */ p = strrchr(pathName, '.'); @@ -1178,18 +1167,19 @@ Tk_CreateWindowFromPath(interp, tkwin, pathName, screenName) parent = Tk_NameToWindow(interp, p, tkwin); if (p != fixedSpace) { - ckfree(p); + ckfree(p); } if (parent == NULL) { return NULL; } if (((TkWindow *) parent)->flags & TK_ALREADY_DEAD) { - Tcl_AppendResult(interp, - "can't create window: parent has been destroyed", (char *) NULL); + Tcl_AppendResult(interp, + "can't create window: parent has been destroyed", + (char *) NULL); return NULL; } else if (((TkWindow *) parent)->flags & TK_CONTAINER) { - Tcl_AppendResult(interp, - "can't create window: its parent has -container = yes", + Tcl_AppendResult(interp, + "can't create window: its parent has -container = yes", (char *) NULL); return NULL; } @@ -1222,17 +1212,17 @@ Tk_CreateWindowFromPath(interp, tkwin, pathName, screenName) * * Tk_DestroyWindow -- * - * Destroy an existing window. After this call, the caller - * should never again use the token. Note that this function - * can be reentered to destroy a window that was only - * partially destroyed before a call to exit. + * Destroy an existing window. After this call, the caller should never + * again use the token. Note that this function can be reentered to + * destroy a window that was only partially destroyed before a call to + * exit. * * Results: * None. * * Side effects: - * The window is deleted, along with all of its children. - * Relevant callback procedures are invoked. + * The window is deleted, along with all of its children. Relevant + * callback functions are invoked. * *-------------------------------------------------------------- */ @@ -1245,13 +1235,13 @@ Tk_DestroyWindow(tkwin) TkDisplay *dispPtr = winPtr->dispPtr; XEvent event; TkHalfdeadWindow *halfdeadPtr, *prev_halfdeadPtr; - ThreadSpecificData *tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); if (winPtr->flags & TK_ALREADY_DEAD) { /* - * A destroy event binding caused the window to be destroyed - * again. Ignore the request. + * A destroy event binding caused the window to be destroyed again. + * Ignore the request. */ return; @@ -1259,9 +1249,8 @@ Tk_DestroyWindow(tkwin) winPtr->flags |= TK_ALREADY_DEAD; /* - * Unless we are cleaning up a half dead - * window from DeleteWindowsExitProc, - * add this window to the half dead list. + * Unless we are cleaning up a half dead window from + * DeleteWindowsExitProc, add this window to the half dead list. */ if (tsdPtr->halfdeadWindowList && @@ -1277,12 +1266,12 @@ Tk_DestroyWindow(tkwin) } /* - * Some cleanup needs to be done immediately, rather than later, - * because it needs information that will be destoyed before we - * get to the main cleanup point. For example, TkFocusDeadWindow - * needs to access the parentPtr field from a window, but if - * a Destroy event handler deletes the window's parent this - * field will be NULL before the main cleanup point is reached. + * Some cleanup needs to be done immediately, rather than later, because + * it needs information that will be destoyed before we get to the main + * cleanup point. For example, TkFocusDeadWindow needs to access the + * parentPtr field from a window, but if a Destroy event handler deletes + * the window's parent this field will be NULL before the main cleanup + * point is reached. */ if (!(halfdeadPtr->flags & HD_FOCUS)) { @@ -1291,23 +1280,23 @@ Tk_DestroyWindow(tkwin) } /* - * If this is a main window, remove it from the list of main - * windows. This needs to be done now (rather than later with - * all the other main window cleanup) to handle situations where - * a destroy binding for a window calls "exit". In this case - * the child window cleanup isn't complete when exit is called. - * This situation is dealt with using the half dead window - * list. Windows that are half dead gets cleaned up during exit. + * If this is a main window, remove it from the list of main windows. + * This needs to be done now (rather than later with all the other main + * window cleanup) to handle situations where a destroy binding for a + * window calls "exit". In this case the child window cleanup isn't + * complete when exit is called. This situation is dealt with using the + * half dead window list. Windows that are half dead gets cleaned up + * during exit. * - * Also decrement the display refcount so that if this is the - * last Tk application in this process on this display, the display - * can be closed and its data structures deleted. + * Also decrement the display refcount so that if this is the last Tk + * application in this process on this display, the display can be closed + * and its data structures deleted. */ if (!(halfdeadPtr->flags & HD_MAIN_WIN) && winPtr->mainPtr != NULL && winPtr->mainPtr->winPtr == winPtr) { halfdeadPtr->flags |= HD_MAIN_WIN; - dispPtr->refCount--; + dispPtr->refCount--; if (tsdPtr->mainWindowList == winPtr->mainPtr) { tsdPtr->mainWindowList = winPtr->mainPtr->nextPtr; } else { @@ -1324,10 +1313,9 @@ Tk_DestroyWindow(tkwin) } /* - * Recursively destroy children. Note that this child - * window block may need to be run multiple times - * in the case where a child window has a Destroy - * binding that calls exit. + * Recursively destroy children. Note that this child window block may + * need to be run multiple times in the case where a child window has a + * Destroy binding that calls exit. */ if (!(halfdeadPtr->flags & HD_DESTROY_COUNT)) { @@ -1342,10 +1330,10 @@ Tk_DestroyWindow(tkwin) Tk_DestroyWindow((Tk_Window) childPtr); if (winPtr->childList == childPtr) { /* - * The child didn't remove itself from the child list, so - * let's remove it here. This can happen in some strange - * conditions, such as when a Destroy event handler for a - * window destroys the window's parent. + * The child didn't remove itself from the child list, so let's + * remove it here. This can happen in some strange conditions, + * such as when a Destroy event handler for a window destroys the + * window's parent. */ winPtr->childList = childPtr->nextPtr; @@ -1355,14 +1343,13 @@ Tk_DestroyWindow(tkwin) if ((winPtr->flags & (TK_CONTAINER|TK_BOTH_HALVES)) == (TK_CONTAINER|TK_BOTH_HALVES)) { /* - * This is the container for an embedded application, and - * the embedded application is also in this process. Delete - * the embedded window in-line here, for the same reasons we - * delete children in-line (otherwise, for example, the Tk - * window may appear to exist even though its X window is - * gone; this could cause errors). Special note: it's possible - * that the embedded window has already been deleted, in which - * case TkpGetOtherWindow will return NULL. + * This is the container for an embedded application, and the embedded + * application is also in this process. Delete the embedded window + * in-line here, for the same reasons we delete children in-line + * (otherwise, for example, the Tk window may appear to exist even + * though its X window is gone; this could cause errors). Special + * note: it's possible that the embedded window has already been + * deleted, in which case TkpGetOtherWindow will return NULL. */ TkWindow *childPtr; @@ -1374,11 +1361,10 @@ Tk_DestroyWindow(tkwin) } /* - * Generate a DestroyNotify event. In order for the DestroyNotify - * event to be processed correctly, need to make sure the window - * exists. This is a bit of a kludge, and may be unnecessarily - * expensive, but without it no event handlers will get called for - * windows that don't exist yet. + * Generate a DestroyNotify event. In order for the DestroyNotify event to + * be processed correctly, need to make sure the window exists. This is a + * bit of a kludge, and may be unnecessarily expensive, but without it no + * event handlers will get called for windows that don't exist yet. * * Note: if the window's pathName is NULL and the window is not an * anonymous window, it means that the window was not successfully @@ -1404,28 +1390,28 @@ Tk_DestroyWindow(tkwin) } /* - * No additional bindings that could call exit - * should be invoked from this point on, - * so it is safe to remove this window - * from the half dead list. + * No additional bindings that could call exit should be invoked from this + * point on, so it is safe to remove this window from the half dead list. */ for (prev_halfdeadPtr = NULL, halfdeadPtr = tsdPtr->halfdeadWindowList; halfdeadPtr != NULL; ) { if (halfdeadPtr->winPtr == winPtr) { - if (prev_halfdeadPtr == NULL) - tsdPtr->halfdeadWindowList = halfdeadPtr->nextPtr; - else - prev_halfdeadPtr->nextPtr = halfdeadPtr->nextPtr; + if (prev_halfdeadPtr == NULL) { + tsdPtr->halfdeadWindowList = halfdeadPtr->nextPtr; + } else { + prev_halfdeadPtr->nextPtr = halfdeadPtr->nextPtr; + } ckfree((char *) halfdeadPtr); break; } prev_halfdeadPtr = halfdeadPtr; halfdeadPtr = halfdeadPtr->nextPtr; } - if (halfdeadPtr == NULL) - Tcl_Panic("window not found on half dead list"); + if (halfdeadPtr == NULL) { + Tcl_Panic("window not found on half dead list"); + } /* * Cleanup the data structures associated with this window. @@ -1443,11 +1429,10 @@ Tk_DestroyWindow(tkwin) if ((winPtr->flags & TK_TOP_HIERARCHY) || !(winPtr->flags & TK_DONT_DESTROY_WINDOW)) { /* - * The parent has already been destroyed and this isn't - * a top-level window, so this window will be destroyed - * implicitly when the parent's X window is destroyed; - * it's much faster not to do an explicit destroy of this - * X window. + * The parent has already been destroyed and this isn't a + * top-level window, so this window will be destroyed implicitly + * when the parent's X window is destroyed; it's much faster not + * to do an explicit destroy of this X window. */ dispPtr->lastDestroyRequest = NextRequest(winPtr->display); @@ -1481,17 +1466,20 @@ Tk_DestroyWindow(tkwin) (ClientData) winPtr->pathName); Tcl_DeleteHashEntry(Tcl_FindHashEntry(&winPtr->mainPtr->nameTable, winPtr->pathName)); - /* - * The memory pointed to by pathName has been deallocated. - * Keep users from accessing it after the window has been - * destroyed by setting it to NULL. - */ - winPtr->pathName = NULL; /* - * Invalidate all objects referring to windows - * with the same main window + * The memory pointed to by pathName has been deallocated. Keep + * users from accessing it after the window has been destroyed by + * setting it to NULL. + */ + + winPtr->pathName = NULL; + + /* + * Invalidate all objects referring to windows with the same main + * window. */ + winPtr->mainPtr->deletionEpoch++; } winPtr->mainPtr->refCount--; @@ -1499,29 +1487,29 @@ Tk_DestroyWindow(tkwin) register TkCmd *cmdPtr; /* - * We just deleted the last window in the application. Delete - * the TkMainInfo structure too and replace all of Tk's commands - * with dummy commands that return errors. Also delete the - * "send" command to unregister the interpreter. + * We just deleted the last window in the application. Delete the + * TkMainInfo structure too and replace all of Tk's commands with + * dummy commands that return errors. Also delete the "send" + * command to unregister the interpreter. * - * NOTE: Only replace the commands it if the interpreter is - * not being deleted. If it *is*, the interpreter cleanup will - * do all the needed work. + * NOTE: Only replace the commands it if the interpreter is not + * being deleted. If it *is*, the interpreter cleanup will do all + * the needed work. */ - if ((winPtr->mainPtr->interp != NULL) && - (!Tcl_InterpDeleted(winPtr->mainPtr->interp))) { - for (cmdPtr = commands; cmdPtr->name != NULL; cmdPtr++) { - Tcl_CreateCommand(winPtr->mainPtr->interp, cmdPtr->name, - TkDeadAppCmd, (ClientData) NULL, - (void (*) _ANSI_ARGS_((ClientData))) NULL); - } - Tcl_CreateCommand(winPtr->mainPtr->interp, "send", - TkDeadAppCmd, (ClientData) NULL, - (void (*) _ANSI_ARGS_((ClientData))) NULL); - Tcl_UnlinkVar(winPtr->mainPtr->interp, "tk_strictMotif"); - } - + if ((winPtr->mainPtr->interp != NULL) && + (!Tcl_InterpDeleted(winPtr->mainPtr->interp))) { + for (cmdPtr = commands; cmdPtr->name != NULL; cmdPtr++) { + Tcl_CreateCommand(winPtr->mainPtr->interp, cmdPtr->name, + TkDeadAppCmd, (ClientData) NULL, + (void (*) _ANSI_ARGS_((ClientData))) NULL); + } + Tcl_CreateCommand(winPtr->mainPtr->interp, "send", + TkDeadAppCmd, (ClientData) NULL, + (void (*) _ANSI_ARGS_((ClientData))) NULL); + Tcl_UnlinkVar(winPtr->mainPtr->interp, "tk_strictMotif"); + } + Tcl_DeleteHashTable(&winPtr->mainPtr->nameTable); TkBindFree(winPtr->mainPtr); TkDeleteAllImages(winPtr->mainPtr); @@ -1529,72 +1517,71 @@ Tk_DestroyWindow(tkwin) TkFocusFree(winPtr->mainPtr); TkStylePkgFree(winPtr->mainPtr); - /* - * When embedding Tk into other applications, make sure - * that all destroy events reach the server. Otherwise - * the embedding application may also attempt to destroy - * the windows, resulting in an X error - */ + /* + * When embedding Tk into other applications, make sure that all + * destroy events reach the server. Otherwise the embedding + * application may also attempt to destroy the windows, resulting + * in an X error + */ - if (winPtr->flags & TK_EMBEDDED) { - XSync(winPtr->display, False); - } + if (winPtr->flags & TK_EMBEDDED) { + XSync(winPtr->display, False); + } ckfree((char *) winPtr->mainPtr); - /* - * If no other applications are using the display, close the - * display now and relinquish its data structures. - */ + /* + * If no other applications are using the display, close the + * display now and relinquish its data structures. + */ #if !defined(WIN32) && defined(NOT_YET) - if (dispPtr->refCount <= 0) { - /* - * I have disabled this code because on Windows there are - * still order dependencies in close-down. All displays - * and resources will get closed down properly anyway at - * exit, through the exit handler. -- jyl - */ + if (dispPtr->refCount <= 0) { /* + * I have disabled this code because on Windows there are + * still order dependencies in close-down. All displays and + * resources will get closed down properly anyway at exit, + * through the exit handler. -- jyl + * * Ideally this should be enabled, as unix Tk can use multiple - * displays. However, there are order issues still, as well - * as the handling of queued events and such that must be - * addressed before this can be enabled. The current cleanup + * displays. However, there are order issues still, as well as + * the handling of queued events and such that must be + * addressed before this can be enabled. The current cleanup * works except for send event issues. -- hobbs 04/2002 */ - - TkDisplay *theDispPtr, *backDispPtr; - - /* - * Splice this display out of the list of displays. - */ - - for (theDispPtr = tsdPtr->displayList, backDispPtr = NULL; - (theDispPtr != winPtr->dispPtr) && - (theDispPtr != NULL); - theDispPtr = theDispPtr->nextPtr) { - backDispPtr = theDispPtr; - } - if (theDispPtr == NULL) { - Tcl_Panic("could not find display to close!"); - } - if (backDispPtr == NULL) { - tsdPtr->displayList = theDispPtr->nextPtr; - } else { - backDispPtr->nextPtr = theDispPtr->nextPtr; - } - - /* + + TkDisplay *theDispPtr, *backDispPtr; + + /* + * Splice this display out of the list of displays. + */ + + for (theDispPtr = tsdPtr->displayList, backDispPtr = NULL; + (theDispPtr!=winPtr->dispPtr) && (theDispPtr!=NULL); + theDispPtr = theDispPtr->nextPtr) { + backDispPtr = theDispPtr; + } + if (theDispPtr == NULL) { + Tcl_Panic("could not find display to close!"); + } + if (backDispPtr == NULL) { + tsdPtr->displayList = theDispPtr->nextPtr; + } else { + backDispPtr->nextPtr = theDispPtr->nextPtr; + } + + /* * Calling XSync creates X server traffic, but addresses a * focus issue on close (but not the send issue). -- hobbs - XSync(dispPtr->display, True); + * + * XSync(dispPtr->display, True); */ - /* - * Found and spliced it out, now actually do the cleanup. - */ + /* + * Found and spliced it out, now actually do the cleanup. + */ TkCloseDisplay(dispPtr); - } + } #endif } } @@ -1606,15 +1593,14 @@ Tk_DestroyWindow(tkwin) * * Tk_MapWindow -- * - * Map a window within its parent. This may require the - * window and/or its parents to actually be created. + * Map a window within its parent. This may require the window and/or its + * parents to actually be created. * * Results: * None. * * Side effects: - * The given window will be mapped. Windows may also - * be created. + * The given window will be mapped. Windows may also be created. * *-------------------------------------------------------------- */ @@ -1634,8 +1620,8 @@ Tk_MapWindow(tkwin) } if (winPtr->flags & TK_WIN_MANAGED) { /* - * Lots of special processing has to be done for top-level - * windows. Let tkWm.c handle everything itself. + * Lots of special processing has to be done for top-level windows. + * Let tkWm.c handle everything itself. */ TkWmMapWindow(winPtr); @@ -1658,18 +1644,17 @@ Tk_MapWindow(tkwin) * * Tk_MakeWindowExist -- * - * Ensure that a particular window actually exists. This - * procedure shouldn't normally need to be invoked from - * outside the Tk package, but may be needed if someone - * wants to manipulate a window before mapping it. + * Ensure that a particular window actually exists. This function should + * not normally need to be invoked from outside the Tk package, but may + * be needed if someone wants to manipulate a window before mapping it. * * Results: * None. * * Side effects: - * When the procedure returns, the X window associated with - * tkwin is guaranteed to exist. This may require the - * window's ancestors to be created also. + * When the function returns, the X window associated with tkwin is + * guaranteed to exist. This may require the window's ancestors to be + * created also. * *-------------------------------------------------------------- */ @@ -1713,14 +1698,14 @@ Tk_MakeWindowExist(tkwin) if (!(winPtr->flags & TK_TOP_HIERARCHY)) { /* - * If any siblings higher up in the stacking order have already - * been created then move this window to its rightful position - * in the stacking order. + * If any siblings higher up in the stacking order have already been + * created then move this window to its rightful position in the + * stacking order. * - * NOTE: this code ignores any changes anyone might have made - * to the sibling and stack_mode field of the window's attributes, - * so it really isn't safe for these to be manipulated except - * by calling Tk_RestackWindow. + * NOTE: this code ignores any changes anyone might have made to the + * sibling and stack_mode field of the window's attributes, so it + * really isn't safe for these to be manipulated except by calling + * Tk_RestackWindow. */ for (winPtr2 = winPtr->nextPtr; winPtr2 != NULL; @@ -1737,8 +1722,8 @@ Tk_MakeWindowExist(tkwin) } /* - * If this window has a different colormap than its parent, add - * the window to the WM_COLORMAP_WINDOWS property for its top-level. + * If this window has a different colormap than its parent, add the + * window to the WM_COLORMAP_WINDOWS property for its top-level. */ if ((winPtr->parentPtr != NULL) && @@ -1750,9 +1735,9 @@ Tk_MakeWindowExist(tkwin) /* * Issue a ConfigureNotify event if there were deferred configuration - * changes (but skip it if the window is being deleted; the - * ConfigureNotify event could cause problems if we're being called - * from Tk_DestroyWindow under some conditions). + * changes (but skip it if the window is being deleted; the + * ConfigureNotify event could cause problems if we're being called from + * Tk_DestroyWindow under some conditions). */ if ((winPtr->flags & TK_NEED_CONFIG_NOTIFY) @@ -1767,12 +1752,11 @@ Tk_MakeWindowExist(tkwin) * * Tk_UnmapWindow, etc. -- * - * There are several procedures under here, each of which - * mirrors an existing X procedure. In addition to performing - * the functions of the corresponding procedure, each - * procedure also updates the local window structure and - * synthesizes an X event (if the window's structure is being - * managed internally). + * There are several functions under here, each of which mirrors an + * existing X function. In addition to performing the functions of the + * corresponding function, each function also updates the local window + * structure and synthesizes an X event (if the window's structure is + * being managed internally). * * Results: * See the manual entries. @@ -1794,8 +1778,8 @@ Tk_UnmapWindow(tkwin) } if (winPtr->flags & TK_WIN_MANAGED) { /* - * Special processing has to be done for top-level windows. Let - * tkWm.c handle everything itself. + * Special processing has to be done for top-level windows. Let tkWm.c + * handle everything itself. */ TkWmUnmapWindow(winPtr); @@ -1820,8 +1804,8 @@ Tk_UnmapWindow(tkwin) void Tk_ConfigureWindow(tkwin, valueMask, valuePtr) Tk_Window tkwin; /* Window to re-configure. */ - unsigned int valueMask; /* Mask indicating which parts of - * *valuePtr are to be used. */ + unsigned int valueMask; /* Mask indicating which parts of *valuePtr + * are to be used. */ XWindowChanges *valuePtr; /* New values. */ { register TkWindow *winPtr = (TkWindow *) tkwin; @@ -1848,7 +1832,7 @@ Tk_ConfigureWindow(tkwin, valueMask, valuePtr) if (winPtr->window != None) { XConfigureWindow(winPtr->display, winPtr->window, valueMask, valuePtr); - TkDoConfigureNotify(winPtr); + TkDoConfigureNotify(winPtr); } else { winPtr->dirtyChanges |= valueMask; winPtr->flags |= TK_NEED_CONFIG_NOTIFY; @@ -1858,8 +1842,7 @@ Tk_ConfigureWindow(tkwin, valueMask, valuePtr) void Tk_MoveWindow(tkwin, x, y) Tk_Window tkwin; /* Window to move. */ - int x, y; /* New location for window (within - * parent). */ + int x, y; /* New location for window (within parent). */ { register TkWindow *winPtr = (TkWindow *) tkwin; @@ -1867,7 +1850,7 @@ Tk_MoveWindow(tkwin, x, y) winPtr->changes.y = y; if (winPtr->window != None) { XMoveWindow(winPtr->display, winPtr->window, x, y); - TkDoConfigureNotify(winPtr); + TkDoConfigureNotify(winPtr); } else { winPtr->dirtyChanges |= CWX|CWY; winPtr->flags |= TK_NEED_CONFIG_NOTIFY; @@ -1886,7 +1869,7 @@ Tk_ResizeWindow(tkwin, width, height) if (winPtr->window != None) { XResizeWindow(winPtr->display, winPtr->window, (unsigned) width, (unsigned) height); - TkDoConfigureNotify(winPtr); + TkDoConfigureNotify(winPtr); } else { winPtr->dirtyChanges |= CWWidth|CWHeight; winPtr->flags |= TK_NEED_CONFIG_NOTIFY; @@ -1896,8 +1879,7 @@ Tk_ResizeWindow(tkwin, width, height) void Tk_MoveResizeWindow(tkwin, x, y, width, height) Tk_Window tkwin; /* Window to move and resize. */ - int x, y; /* New location for window (within - * parent). */ + int x, y; /* New location for window (within parent). */ int width, height; /* New dimensions for window. */ { register TkWindow *winPtr = (TkWindow *) tkwin; @@ -1909,7 +1891,7 @@ Tk_MoveResizeWindow(tkwin, x, y, width, height) if (winPtr->window != None) { XMoveResizeWindow(winPtr->display, winPtr->window, x, y, (unsigned) width, (unsigned) height); - TkDoConfigureNotify(winPtr); + TkDoConfigureNotify(winPtr); } else { winPtr->dirtyChanges |= CWX|CWY|CWWidth|CWHeight; winPtr->flags |= TK_NEED_CONFIG_NOTIFY; @@ -1927,7 +1909,7 @@ Tk_SetWindowBorderWidth(tkwin, width) if (winPtr->window != None) { XSetWindowBorderWidth(winPtr->display, winPtr->window, (unsigned) width); - TkDoConfigureNotify(winPtr); + TkDoConfigureNotify(winPtr); } else { winPtr->dirtyChanges |= CWBorderWidth; winPtr->flags |= TK_NEED_CONFIG_NOTIFY; @@ -1937,9 +1919,8 @@ Tk_SetWindowBorderWidth(tkwin, width) void Tk_ChangeWindowAttributes(tkwin, valueMask, attsPtr) Tk_Window tkwin; /* Window to manipulate. */ - unsigned long valueMask; /* OR'ed combination of bits, - * indicating which fields of - * *attsPtr are to be used. */ + unsigned long valueMask; /* OR'ed combination of bits, indicating which + * fields of *attsPtr are to be used. */ register XSetWindowAttributes *attsPtr; /* New values for some attributes. */ { @@ -2003,8 +1984,8 @@ Tk_ChangeWindowAttributes(tkwin, valueMask, attsPtr) void Tk_SetWindowBackground(tkwin, pixel) Tk_Window tkwin; /* Window to manipulate. */ - unsigned long pixel; /* Pixel value to use for - * window's background. */ + unsigned long pixel; /* Pixel value to use for window's + * background. */ { register TkWindow *winPtr = (TkWindow *) tkwin; @@ -2021,8 +2002,7 @@ Tk_SetWindowBackground(tkwin, pixel) void Tk_SetWindowBackgroundPixmap(tkwin, pixmap) Tk_Window tkwin; /* Window to manipulate. */ - Pixmap pixmap; /* Pixmap to use for window's - * background. */ + Pixmap pixmap; /* Pixmap to use for window's background. */ { register TkWindow *winPtr = (TkWindow *) tkwin; @@ -2040,8 +2020,7 @@ Tk_SetWindowBackgroundPixmap(tkwin, pixmap) void Tk_SetWindowBorder(tkwin, pixel) Tk_Window tkwin; /* Window to manipulate. */ - unsigned long pixel; /* Pixel value to use for - * window's border. */ + unsigned long pixel; /* Pixel value to use for window's border. */ { register TkWindow *winPtr = (TkWindow *) tkwin; @@ -2058,8 +2037,7 @@ Tk_SetWindowBorder(tkwin, pixel) void Tk_SetWindowBorderPixmap(tkwin, pixmap) Tk_Window tkwin; /* Window to manipulate. */ - Pixmap pixmap; /* Pixmap to use for window's - * border. */ + Pixmap pixmap; /* Pixmap to use for window's border. */ { register TkWindow *winPtr = (TkWindow *) tkwin; @@ -2086,7 +2064,7 @@ Tk_DefineCursor(tkwin, cursor) #else winPtr->atts.cursor = (Cursor) cursor; #endif - + if (winPtr->window != None) { XDefineCursor(winPtr->display, winPtr->window, winPtr->atts.cursor); } else { @@ -2126,14 +2104,14 @@ Tk_SetWindowColormap(tkwin, colormap) * * Tk_SetWindowVisual -- * - * This procedure is called to specify a visual to be used - * for a Tk window when it is created. This procedure, if - * called at all, must be called before the X window is created - * (i.e. before Tk_MakeWindowExist is called). + * This function is called to specify a visual to be used for a Tk window + * when it is created. This function, if called at all, must be called + * before the X window is created (i.e. before Tk_MakeWindowExist is + * called). * * Results: - * The return value is 1 if successful, or 0 if the X window has - * been already created. + * The return value is 1 if successful, or 0 if the X window has been + * already created. * * Side effects: * The information given is stored for when the window is created. @@ -2177,8 +2155,8 @@ Tk_SetWindowVisual(tkwin, visual, depth, colormap) * * TkDoConfigureNotify -- * - * Generate a ConfigureNotify event describing the current - * configuration of a window. + * Generate a ConfigureNotify event describing the current configuration + * of a window. * * Results: * None. @@ -2191,8 +2169,8 @@ Tk_SetWindowVisual(tkwin, visual, depth, colormap) void TkDoConfigureNotify(winPtr) - register TkWindow *winPtr; /* Window whose configuration - * was just changed. */ + register TkWindow *winPtr; /* Window whose configuration was just + * changed. */ { XEvent event; @@ -2221,14 +2199,13 @@ TkDoConfigureNotify(winPtr) * * Tk_SetClass -- * - * This procedure is used to give a window a class. + * This function is used to give a window a class. * * Results: * None. * * Side effects: - * A new class is stored for tkwin, replacing any existing - * class for it. + * A new class is stored for tkwin, replacing any existing class for it. * *---------------------------------------------------------------------- */ @@ -2252,15 +2229,15 @@ Tk_SetClass(tkwin, className) * * Tk_SetClassProcs -- * - * This procedure is used to set the class procedures and - * instance data for a window. + * This function is used to set the class functions and instance data for + * a window. * * Results: * None. * * Side effects: - * A new set of class procedures and instance data is stored - * for tkwin, replacing any existing values. + * A new set of class functions and instance data is stored for tkwin, + * replacing any existing values. * *---------------------------------------------------------------------- */ @@ -2269,7 +2246,7 @@ void Tk_SetClassProcs(tkwin, procs, instanceData) Tk_Window tkwin; /* Token for window to modify. */ Tk_ClassProcs *procs; /* Class procs structure. */ - ClientData instanceData; /* Data to be passed to class procedures. */ + ClientData instanceData; /* Data to be passed to class functions. */ { register TkWindow *winPtr = (TkWindow *) tkwin; @@ -2282,14 +2259,13 @@ Tk_SetClassProcs(tkwin, procs, instanceData) * * Tk_NameToWindow -- * - * Given a string name for a window, this procedure - * returns the token for the window, if there exists a - * window corresponding to the given name. + * Given a string name for a window, this function returns the token for + * the window, if there exists a window corresponding to the given name. * * Results: - * The return result is either a token for the window corresponding - * to "name", or else NULL to indicate that there is no such - * window. In this case, an error message is left in the interp's result. + * The return result is either a token for the window corresponding to + * "name", or else NULL to indicate that there is no such window. In this + * case, an error message is left in the interp's result. * * Side effects: * None. @@ -2301,20 +2277,21 @@ Tk_Window Tk_NameToWindow(interp, pathName, tkwin) Tcl_Interp *interp; /* Where to report errors. */ CONST char *pathName; /* Path name of window. */ - Tk_Window tkwin; /* Token for window: name is assumed to - * belong to the same main window as tkwin. */ + Tk_Window tkwin; /* Token for window: name is assumed to belong + * to the same main window as tkwin. */ { Tcl_HashEntry *hPtr; if (tkwin == NULL) { /* * Either we're not really in Tk, or the main window was destroyed and - * we're on our way out of the application + * we're on our way out of the application. */ + Tcl_AppendResult(interp, "NULL main window", (char *)NULL); return NULL; } - + hPtr = Tcl_FindHashEntry(&((TkWindow *) tkwin)->mainPtr->nameTable, pathName); if (hPtr == NULL) { @@ -2330,14 +2307,13 @@ Tk_NameToWindow(interp, pathName, tkwin) * * Tk_IdToWindow -- * - * Given an X display and window ID, this procedure returns the - * Tk token for the window, if there exists a Tk window corresponding - * to the given ID. + * Given an X display and window ID, this function returns the Tk token + * for the window, if there exists a Tk window corresponding to the given + * ID. * * Results: - * The return result is either a token for the window corresponding - * to the given X id, or else NULL to indicate that there is no such - * window. + * The return result is either a token for the window corresponding to + * the given X id, or else NULL to indicate that there is no such window. * * Side effects: * None. @@ -2377,8 +2353,8 @@ Tk_IdToWindow(display, window) * Return the textual name of a window's display. * * Results: - * The return value is the string name of the display associated - * with tkwin. + * The return value is the string name of the display associated with + * tkwin. * * Side effects: * None. @@ -2398,8 +2374,7 @@ Tk_DisplayName(tkwin) * * UnlinkWindow -- * - * This procedure removes a window from the childList of its - * parent. + * This function removes a window from the childList of its parent. * * Results: * None. @@ -2447,9 +2422,8 @@ UnlinkWindow(winPtr) * Change a window's position in the stacking order. * * Results: - * TCL_OK is normally returned. If other is not a descendant - * of tkwin's parent then TCL_ERROR is returned and tkwin is - * not repositioned. + * TCL_OK is normally returned. If other is not a descendant of tkwin's + * parent then TCL_ERROR is returned and tkwin is not repositioned. * * Side effects: * Tkwin is repositioned in the stacking order. @@ -2459,22 +2433,22 @@ UnlinkWindow(winPtr) int Tk_RestackWindow(tkwin, aboveBelow, other) - Tk_Window tkwin; /* Token for window whose position in - * the stacking order is to change. */ - int aboveBelow; /* Indicates new position of tkwin relative - * to other; must be Above or Below. */ - Tk_Window other; /* Tkwin will be moved to a position that - * puts it just above or below this window. - * If NULL then tkwin goes above or below - * all windows in the same parent. */ + Tk_Window tkwin; /* Token for window whose position in the + * stacking order is to change. */ + int aboveBelow; /* Indicates new position of tkwin relative to + * other; must be Above or Below. */ + Tk_Window other; /* Tkwin will be moved to a position that puts + * it just above or below this window. If NULL + * then tkwin goes above or below all windows + * in the same parent. */ { TkWindow *winPtr = (TkWindow *) tkwin; TkWindow *otherPtr = (TkWindow *) other; /* - * Special case: if winPtr is a top-level window then just find - * the top-level ancestor of otherPtr and restack winPtr above - * otherPtr without changing any of Tk's childLists. + * Special case: if winPtr is a top-level window then just find the + * top-level ancestor of otherPtr and restack winPtr above otherPtr + * without changing any of Tk's childLists. */ if (winPtr->flags & TK_WIN_MANAGED) { @@ -2491,7 +2465,7 @@ Tk_RestackWindow(tkwin, aboveBelow, other) if (winPtr->parentPtr == NULL) { /* - * Window is going to be deleted shortly; don't do anything. + * Window is going to be deleted shortly; don't do anything. */ return TCL_OK; @@ -2541,10 +2515,9 @@ Tk_RestackWindow(tkwin, aboveBelow, other) } /* - * Notify the X server of the change. If winPtr hasn't yet been - * created then there's no need to tell the X server now, since - * the stacking order will be handled properly when the window - * is finally created. + * Notify the X server of the change. If winPtr hasn't yet been created + * then there's no need to tell the X server now, since the stacking order + * will be handled properly when the window is finally created. */ if (winPtr->window != None) { @@ -2576,9 +2549,9 @@ Tk_RestackWindow(tkwin, aboveBelow, other) * Returns the main window for an application. * * Results: - * If interp has a Tk application associated with it, the main - * window for the application is returned. Otherwise NULL is - * returned and an error message is left in the interp's result. + * If interp has a Tk application associated with it, the main window for + * the application is returned. Otherwise NULL is returned and an error + * message is left in the interp's result. * * Side effects: * None. @@ -2588,9 +2561,8 @@ Tk_RestackWindow(tkwin, aboveBelow, other) Tk_Window Tk_MainWindow(interp) - Tcl_Interp *interp; /* Interpreter that embodies the - * application. Used for error - * reporting also. */ + Tcl_Interp *interp; /* Interpreter that embodies the application. + * Used for error reporting also. */ { TkMainInfo *mainPtr; ThreadSpecificData *tsdPtr; @@ -2603,7 +2575,7 @@ Tk_MainWindow(interp) return NULL; } #endif - tsdPtr = (ThreadSpecificData *) + tsdPtr = (ThreadSpecificData *) Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); for (mainPtr = tsdPtr->mainWindowList; mainPtr != NULL; @@ -2621,14 +2593,14 @@ Tk_MainWindow(interp) * * Tk_StrictMotif -- * - * Indicates whether strict Motif compliance has been specified - * for the given window. + * Indicates whether strict Motif compliance has been specified for the + * given window. * * Results: - * The return value is 1 if strict Motif compliance has been - * requested for tkwin's application by setting the tk_strictMotif - * variable in its interpreter to a true value. 0 is returned - * if tk_strictMotif has a false value. + * The return value is 1 if strict Motif compliance has been requested + * for tkwin's application by setting the tk_strictMotif variable in its + * interpreter to a true value. 0 is returned if tk_strictMotif has a + * false value. * * Side effects: * None. @@ -2638,8 +2610,8 @@ Tk_MainWindow(interp) int Tk_StrictMotif(tkwin) - Tk_Window tkwin; /* Window whose application is - * to be checked. */ + Tk_Window tkwin; /* Window whose application is to be + * checked. */ { return ((TkWindow *) tkwin)->mainPtr->strictMotif; } @@ -2649,8 +2621,8 @@ Tk_StrictMotif(tkwin) * * Tk_GetNumMainWindows -- * - * This procedure returns the number of main windows currently - * open in this process. + * This function returns the number of main windows currently open in + * this process. * * Results: * The number of main windows open in this process. @@ -2672,8 +2644,8 @@ Tk_GetNumMainWindows() } #endif - tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); return tsdPtr->numMainWindows; } @@ -2683,11 +2655,10 @@ Tk_GetNumMainWindows() * * DeleteWindowsExitProc -- * - * This procedure is invoked as an exit handler. It deletes all - * of the main windows in the current thread. We really should - * be using a thread local exit handler to delete windows and a - * process exit handler to close the display but Tcl does - * not provide support for this usage. + * This function is invoked as an exit handler. It deletes all of the + * main windows in the current thread. We really should be using a thread + * local exit handler to delete windows and a process exit handler to + * close the display but Tcl does not provide support for this usage. * * Results: * None. @@ -2707,59 +2678,55 @@ DeleteWindowsExitProc(clientData) ThreadSpecificData *tsdPtr = (ThreadSpecificData *) clientData; /* - * Finish destroying any windows that are in a - * half-dead state. We must protect the interpreter - * while destroying the window, because of <Destroy> - * bindings which could destroy the interpreter - * while the window is being deleted. This would - * leave frames on the call stack pointing at + * Finish destroying any windows that are in a half-dead state. We must + * protect the interpreter while destroying the window, because of + * <Destroy> bindings which could destroy the interpreter while the window + * is being deleted. This would leave frames on the call stack pointing at * deleted memory, causing core dumps. */ while (tsdPtr->halfdeadWindowList != NULL) { - interp = tsdPtr->halfdeadWindowList->winPtr->mainPtr->interp; - Tcl_Preserve((ClientData) interp); - tsdPtr->halfdeadWindowList->flags |= HD_CLEANUP; - tsdPtr->halfdeadWindowList->winPtr->flags &= ~TK_ALREADY_DEAD; - Tk_DestroyWindow((Tk_Window) tsdPtr->halfdeadWindowList->winPtr); - Tcl_Release((ClientData) interp); + interp = tsdPtr->halfdeadWindowList->winPtr->mainPtr->interp; + Tcl_Preserve((ClientData) interp); + tsdPtr->halfdeadWindowList->flags |= HD_CLEANUP; + tsdPtr->halfdeadWindowList->winPtr->flags &= ~TK_ALREADY_DEAD; + Tk_DestroyWindow((Tk_Window) tsdPtr->halfdeadWindowList->winPtr); + Tcl_Release((ClientData) interp); } /* * Destroy any remaining main windows. */ - while (tsdPtr->mainWindowList != NULL) { - interp = tsdPtr->mainWindowList->interp; - Tcl_Preserve((ClientData) interp); - Tk_DestroyWindow((Tk_Window) tsdPtr->mainWindowList->winPtr); - Tcl_Release((ClientData) interp); + while (tsdPtr->mainWindowList != NULL) { + interp = tsdPtr->mainWindowList->interp; + Tcl_Preserve((ClientData) interp); + Tk_DestroyWindow((Tk_Window) tsdPtr->mainWindowList->winPtr); + Tcl_Release((ClientData) interp); } /* - * Iterate destroying the displays until no more displays remain. - * It is possible for displays to get recreated during exit by any - * code that calls GetScreen, so we must destroy these new displays - * as well as the old ones. + * Iterate destroying the displays until no more displays remain. It is + * possible for displays to get recreated during exit by any code that + * calls GetScreen, so we must destroy these new displays as well as the + * old ones. */ - for (dispPtr = tsdPtr->displayList; - dispPtr != NULL; - dispPtr = tsdPtr->displayList) { - /* - * Now iterate over the current list of open displays, and first - * set the global pointer to NULL so we will be able to notice if - * any new displays got created during deletion of the current set. - * We must also do this to ensure that Tk_IdToWindow does not find - * the old display as it is being destroyed, when it wants to see - * if it needs to dispatch a message. - */ - - for (tsdPtr->displayList = NULL; dispPtr != NULL; - dispPtr = nextPtr) { - nextPtr = dispPtr->nextPtr; - TkCloseDisplay(dispPtr); - } + for (dispPtr = tsdPtr->displayList; dispPtr != NULL; + dispPtr = tsdPtr->displayList) { + /* + * Now iterate over the current list of open displays, and first set + * the global pointer to NULL so we will be able to notice if any new + * displays got created during deletion of the current set. We must + * also do this to ensure that Tk_IdToWindow does not find the old + * display as it is being destroyed, when it wants to see if it needs + * to dispatch a message. + */ + + for (tsdPtr->displayList = NULL; dispPtr != NULL; dispPtr = nextPtr) { + nextPtr = dispPtr->nextPtr; + TkCloseDisplay(dispPtr); + } } tsdPtr->numMainWindows = 0; @@ -2772,18 +2739,17 @@ DeleteWindowsExitProc(clientData) * * Tk_Init -- * - * This procedure is invoked to add Tk to an interpreter. It - * incorporates all of Tk's commands into the interpreter and - * creates the main window for a new Tk application. If the - * interpreter contains a variable "argv", this procedure - * extracts several arguments from that variable, uses them - * to configure the main window, and modifies argv to exclude - * the arguments (see the "wish" documentation for a list of - * the arguments that are extracted). + * This function is invoked to add Tk to an interpreter. It incorporates + * all of Tk's commands into the interpreter and creates the main window + * for a new Tk application. If the interpreter contains a variable + * "argv", this function extracts several arguments from that variable, + * uses them to configure the main window, and modifies argv to exclude + * the arguments (see the "wish" documentation for a list of the + * arguments that are extracted). * * Results: - * Returns a standard Tcl completion code and sets the interp's result - * if there is an error. + * Returns a standard Tcl completion code and sets the interp's result if + * there is an error. * * Side effects: * Depends on various initialization scripts that get invoked. @@ -2803,12 +2769,12 @@ Tk_Init(interp) * * Tk_SafeInit -- * - * This procedure is invoked to add Tk to a safe interpreter. It - * invokes the internal procedure that does the real work. + * This function is invoked to add Tk to a safe interpreter. It invokes + * the internal function that does the real work. * * Results: - * Returns a standard Tcl completion code and sets the interp's result - * if there is an error. + * Returns a standard Tcl completion code and sets the interp's result if + * there is an error. * * Side effects: * Depends on various initialization scripts that are invoked. @@ -2821,46 +2787,46 @@ Tk_SafeInit(interp) Tcl_Interp *interp; /* Interpreter to initialize. */ { /* - * Initialize the interpreter with Tk, safely. This removes - * all the Tk commands that are unsafe. + * Initialize the interpreter with Tk, safely. This removes all the Tk + * commands that are unsafe. * * Rationale: * - * - Toplevel and menu are unsafe because they can be used to cover - * the entire screen and to steal input from the user. + * - Toplevel and menu are unsafe because they can be used to cover the + * entire screen and to steal input from the user. * - Continuous ringing of the bell is a nuisance. - * - Cannot allow access to the clipboard because a malicious script - * can replace the contents with the string "rm -r *" and lead to - * surprises when the contents of the clipboard are pasted. Similarly, - * the selection command is blocked. - * - Cannot allow send because it can be used to cause unsafe - * interpreters to execute commands. The tk command recreates the - * send command, so that too must be hidden. - * - Focus can be used to grab the focus away from another window, - * in effect stealing user input. Cannot allow that. - * NOTE: We currently do *not* hide focus as it would make it - * impossible to provide keyboard input to Tk in a safe interpreter. - * - Grab can be used to block the user from using any other apps - * on the screen. + * - Cannot allow access to the clipboard because a malicious script can + * replace the contents with the string "rm -r *" and lead to surprises + * when the contents of the clipboard are pasted. Similarly, the + * selection command is blocked. + * - Cannot allow send because it can be used to cause unsafe interpreters + * to execute commands. The tk command recreates the send command, so + * that too must be hidden. + * - Focus can be used to grab the focus away from another window, in + * effect stealing user input. Cannot allow that. + * NOTE: We currently do *not* hide focus as it would make it impossible + * to provide keyboard input to Tk in a safe interpreter. + * - Grab can be used to block the user from using any other apps on the + * screen. * - Tkwait can block the containing process forever. Use bindings, * fileevents and split the protocol into before-the-wait and * after-the-wait parts. More work but necessary. - * - Wm is unsafe because (if toplevels are allowed, in the future) - * it can be used to remove decorations, move windows around, cover - * the entire screen etc etc. + * - Wm is unsafe because (if toplevels are allowed, in the future) it can + * be used to remove decorations, move windows around, cover the entire + * screen etc etc. * * Current risks: * * - No CPU time limit, no memory allocation limits, no color limits. + * CPU time limits can be imposed by an unsafe master interpreter. * - * The actual code called is the same as Tk_Init but Tcl_IsSafe() - * is checked at several places to differentiate the two initialisations. + * The actual code called is the same as Tk_Init but Tcl_IsSafe() is + * checked at several places to differentiate the two initialisations. */ return Initialize(interp); } - extern TkStubs tkStubs; /* @@ -2868,6 +2834,7 @@ extern TkStubs tkStubs; * * Initialize -- * + * ???TODO??? * * Results: * A standard Tcl result. Also leaves an error message in the interp's @@ -2885,28 +2852,29 @@ Initialize(interp) { char *p; int argc, code; - CONST char **argv; + CONST char **argv; char *args[20]; CONST char *argString = NULL; Tcl_DString class; ThreadSpecificData *tsdPtr; - + /* - * Ensure that we are getting the matching version of Tcl. This is - * really only an issue when Tk is loaded dynamically. + * Ensure that we are getting the matching version of Tcl. This is really + * only an issue when Tk is loaded dynamically. */ if (Tcl_InitStubs(interp, TCL_VERSION, 1) == NULL) { - return TCL_ERROR; + return TCL_ERROR; } /* * Ensure that our obj-types are registered with the Tcl runtime. */ + TkRegisterObjTypes(); - tsdPtr = (ThreadSpecificData *) - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); + tsdPtr = (ThreadSpecificData *) + Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); /* * Start by initializing all the static variables to default acceptable @@ -2927,21 +2895,24 @@ Initialize(interp) /* * We start by resetting the result because it might not be clean */ + Tcl_ResetResult(interp); if (Tcl_IsSafe(interp)) { /* - * Get the clearance to start Tk and the "argv" parameters - * from the master. + * Get the clearance to start Tk and the "argv" parameters from the + * master. */ + Tcl_DString ds; - + /* - * Step 1 : find the master and construct the interp name - * (could be a function if new APIs were ok). - * We could also construct the path while walking, but there - * is no API to get the name of an interp either. + * Step 1 : find the master and construct the interp name (could be a + * function if new APIs were ok). We could also construct the path + * while walking, but there is no API to get the name of an interp + * either. */ + Tcl_Interp *master = interp; while (1) { @@ -2956,52 +2927,58 @@ Initialize(interp) break; } } + /* * Construct the name (rewalk...) */ + if (Tcl_GetInterpPath(master, interp) != TCL_OK) { Tcl_AppendResult(interp, "error in Tcl_GetInterpPath", (char *) NULL); Tcl_MutexUnlock(&windowMutex); return TCL_ERROR; } + /* * Build the string to eval. */ + Tcl_DStringInit(&ds); Tcl_DStringAppendElement(&ds, "::safe::TkInit"); Tcl_DStringAppendElement(&ds, Tcl_GetStringResult(master)); - + /* - * Step 2 : Eval in the master. The argument is the *reversed* - * interp path of the slave. + * Step 2 : Eval in the master. The argument is the *reversed* interp + * path of the slave. */ - + if (Tcl_Eval(master, Tcl_DStringValue(&ds)) != TCL_OK) { /* - * We might want to transfer the error message or not. - * We don't. (no API to do it and maybe security reasons). + * We might want to transfer the error message or not. We don't. + * (No API to do it and maybe security reasons). */ + Tcl_DStringFree(&ds); - Tcl_AppendResult(interp, + Tcl_AppendResult(interp, "not allowed to start Tk by master's safe::TkInit", (char *) NULL); Tcl_MutexUnlock(&windowMutex); return TCL_ERROR; } Tcl_DStringFree(&ds); - /* - * Use the master's result as argv. - * Note: We don't use the Obj interfaces to avoid dealing with - * cross interp refcounting and changing the code below. + + /* + * Use the master's result as argv. Note: We don't use the Obj + * interfaces to avoid dealing with cross interp refcounting and + * changing the code below. */ argString = Tcl_GetStringResult(master); } else { /* - * If there is an "argv" variable, get its value, extract out - * relevant arguments from it, and rewrite the variable without - * the arguments that we used. + * If there is an "argv" variable, get its value, extract out relevant + * arguments from it, and rewrite the variable without the arguments + * that we used. */ argString = Tcl_GetVar2(interp, "argv", (char *) NULL, TCL_GLOBAL_ONLY); @@ -3011,7 +2988,7 @@ Initialize(interp) char buffer[TCL_INTEGER_SPACE]; if (Tcl_SplitList(interp, argString, &argc, &argv) != TCL_OK) { - argError: + argError: Tcl_AddErrorInfo(interp, "\n (processing arguments in argv variable)"); Tcl_MutexUnlock(&windowMutex); @@ -3052,8 +3029,8 @@ Initialize(interp) } /* - * Create an argument list for creating the top-level window, - * using the information parsed from argv, if any. + * Create an argument list for creating the top-level window, using the + * information parsed from argv, if any. */ args[0] = "toplevel"; @@ -3067,9 +3044,9 @@ Initialize(interp) argc += 2; /* - * If this is the first application for this process, save - * the display name in the DISPLAY environment variable so - * that it will be available to subprocesses created by us. + * If this is the first application for this process, save the display + * name in the DISPLAY environment variable so that it will be + * available to subprocesses created by us. */ if (tsdPtr->numMainWindows == 0) { @@ -3080,19 +3057,19 @@ Initialize(interp) args[argc] = "-colormap"; args[argc+1] = colormap; argc += 2; - colormap = NULL; + colormap = NULL; } if (use != NULL) { args[argc] = "-use"; args[argc+1] = use; argc += 2; - use = NULL; + use = NULL; } if (visual != NULL) { args[argc] = "-visual"; args[argc+1] = visual; argc += 2; - visual = NULL; + visual = NULL; } args[argc] = NULL; code = TkCreateFrame((ClientData) NULL, interp, argc, args, 1, name); @@ -3107,8 +3084,8 @@ Initialize(interp) } /* - * Set the geometry of the main window, if requested. Put the - * requested geometry into the "geometry" variable. + * Set the geometry of the main window, if requested. Put the requested + * geometry into the "geometry" variable. */ if (geometry != NULL) { @@ -3117,7 +3094,7 @@ Initialize(interp) if (code != TCL_OK) { goto done; } - geometry = NULL; + geometry = NULL; } Tcl_MutexUnlock(&windowMutex); @@ -3135,11 +3112,11 @@ Initialize(interp) goto done; } else { /* - * If we were able to provide ourselves as a package, then set - * the main loop procedure in Tcl to our main loop proc. This - * will cause tclsh to be event-aware when Tk is dynamically - * loaded. This will have no effect in wish, which already is - * prepared to run the event loop. + * If we were able to provide ourselves as a package, then set the + * main loop function in Tcl to our main loop proc. This will cause + * tclsh to be event-aware when Tk is dynamically loaded. This will + * have no effect in wish, which already is prepared to run the event + * loop. */ Tcl_SetMainLoop(Tk_MainLoop); @@ -3161,16 +3138,24 @@ Initialize(interp) } /* - * Create exit handler to delete all windows when the application - * exits. This handler needs to be invoked before other platform - * specific cleanups take place to avoid panics in finalization. + * Create exit handler to delete all windows when the application exits. + * This handler needs to be invoked before other platform specific + * cleanups take place to avoid panics in finalization. */ TkCreateExitHandler(DeleteWindowsExitProc, (ClientData) tsdPtr); - done: + done: if (argv != NULL) { ckfree((char *) argv); } return code; } + +/* + * Local Variables: + * mode: c + * c-basic-offset: 4 + * fill-column: 78 + * End: + */ |