/* * tkWindow.c (CTk) -- * * CTk window manipulation functions. * * Copyright (c) 1989-1994 The Regents of the University of California. * Copyright (c) 1994-1995 Sun Microsystems, Inc. * Copyright (c) 1994-1995 Cleveland Clinic Foundation * * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. */ static char rcsid[] = "@(#) $Id: ctk.shar,v 1.50 1996/01/15 14:47:16 andrewm Exp andrewm $"; #include "tkPort.h" #include "tkInt.h" #include "patchlevel.h" #define HEAD_CHILD(winPtr) ((TkWindow *) &((winPtr)->childList)) #define TOP_CHILD(winPtr) ((winPtr)->childList.priorPtr) #define BOTTOM_CHILD(winPtr) ((winPtr)->childList.nextPtr) /* * Count of number of main windows currently open in this process. */ int tk_NumMainWindows; /* * First in list of all main windows managed by this process. */ TkMainInfo *tkMainWindowList = NULL; /* * List of all displays currently in use. */ TkDisplay *tkDisplayList = NULL; /* * Have statics in this module been initialized? */ static int initialized = 0; /* * The variables below hold several uid's that are used in many places * in the toolkit. */ Tk_Uid tkDisabledUid = NULL; Tk_Uid tkActiveUid = NULL; Tk_Uid tkNormalUid = NULL; /* * The following structure defines all of the commands supported by * CTk, and the C procedures that execute them. */ typedef struct { char *name; /* Name of command. */ int (*cmdProc) _ANSI_ARGS_((ClientData clientData, Tcl_Interp *interp, int argc, char **argv)); /* Command procedure. */ } TkCmd; static TkCmd commands[] = { /* * Commands that are part of the intrinsics: */ {"bell", Tk_BellCmd}, {"bind", Tk_BindCmd}, {"bindtags", Tk_BindtagsCmd}, /* {"clipboard", Tk_ClipboardCmd}, */ {"ctk", Ctk_CtkCmd}, {"ctk_event", Ctk_CtkEventCmd}, {"destroy", Tk_DestroyCmd}, {"exit", Tk_ExitCmd}, {"focus", Tk_FocusCmd}, /* {"grab", Tk_GrabCmd}, */ /* {"image", Tk_ImageCmd}, */ {"lower", Tk_LowerCmd}, {"option", Tk_OptionCmd}, {"pack", Tk_PackCmd}, {"place", Tk_PlaceCmd}, {"raise", Tk_RaiseCmd}, /* {"selection", Tk_SelectionCmd}, */ {"tk", Tk_TkCmd}, {"tk_focusNext", Ctk_TkFocusNextCmd}, {"tk_focusPrev", Ctk_TkFocusPrevCmd}, {"tkEntryInsert", Ctk_TkEntryInsertCmd}, {"tkEntrySeeInsert", Ctk_TkEntrySeeInsertCmd}, {"tkwait", Tk_TkwaitCmd}, {"update", Tk_UpdateCmd}, {"winfo", Tk_WinfoCmd}, /* {"wm", Tk_WmCmd}, */ /* * Widget-creation commands. */ {"button", Tk_ButtonCmd}, /* {"canvas", Tk_CanvasCmd}, */ {"checkbutton", Tk_CheckbuttonCmd}, {"entry", Tk_EntryCmd}, {"frame", Tk_FrameCmd}, {"label", Tk_LabelCmd}, {"listbox", Tk_ListboxCmd}, {"menu", Tk_MenuCmd}, {"menubutton", Tk_MenubuttonCmd}, /* {"message", Tk_MessageCmd}, */ {"radiobutton", Tk_RadiobuttonCmd}, /* {"scale", Tk_ScaleCmd}, */ {"scrollbar", Tk_ScrollbarCmd}, {"text", Tk_TextCmd}, {"toplevel", Tk_FrameCmd}, {(char *) NULL, (int (*)()) NULL} }; /* * Forward declarations to procedures defined later in this file: */ static TkDisplay * GetScreen _ANSI_ARGS_((Tcl_Interp *interp, char *screenName)); static TkWindow * CreateRoot _ANSI_ARGS_((Tcl_Interp *interp, TkDisplay *dispPtr)); static TkWindow * NewWindow _ANSI_ARGS_((TkDisplay *dispPtr)); static void DisplayWindow _ANSI_ARGS_((TkWindow *winPtr)); static void UndisplayWindow _ANSI_ARGS_((TkWindow *winPtr)); static void InsertWindow _ANSI_ARGS_((TkWindow *winPtr, TkWindow *sibling)); static void UnlinkWindow _ANSI_ARGS_((TkWindow *winPtr)); static void Unoverlap _ANSI_ARGS_((TkWindow *underPtr, TkWindow *overPtr)); static void UnoverlapHierarchy _ANSI_ARGS_((TkWindow *underPtr, TkWindow * overPtr)); static void ExposeWindow _ANSI_ARGS_((TkWindow *winPtr, CtkRegion *rgn)); static void ComputeClipRect _ANSI_ARGS_((TkWindow *winPtr)); /* *---------------------------------------------------------------------- * * Tk_Init -- * * This procedure is typically invoked by Tcl_AppInit procedures * to perform additional Tk initialization for a Tcl interpreter, * such as sourcing the "ctk.tcl" script. * * Results: * Returns a standard Tcl completion code and sets interp->result * if there is an error. * * Side effects: * Depends on what's in the ctk.tcl script. * *---------------------------------------------------------------------- */ int Tk_Init(interp) Tcl_Interp *interp; /* Interpreter to initialize. */ { #ifdef USE_TCL_STUBS Tk_Window winPtr; #endif static char initCmd[] = "if [file exists $tk_library/ctk.tcl] {\n\ source $tk_library/ctk.tcl\n\ } else {\n\ set msg \"can't find $tk_library/ctk.tcl; perhaps you \"\n\ append msg \"need to\\ninstall CTk or set your CTK_LIBRARY \"\n\ append msg \"environment variable?\"\n\ error $msg\n\ }"; int retval; #ifdef USE_TCL_STUBS Tcl_InitStubs(interp, "8", 0); #endif #ifdef USE_TCL_STUBS winPtr = Tk_CreateMainWindow(interp, NULL, "ctk", "ctk"); if (winPtr == NULL) { return(TCL_ERROR); } #endif retval = Tcl_Eval(interp, initCmd); if (retval != TCL_OK) { return(retval); } #ifdef USE_TCL_STUBS Tcl_SetMainLoop(Tk_MainLoop); #endif return(retval); } /* *---------------------------------------------------------------------- * * GetScreen -- * * Given a string name for a terminal device-plus-type, find the * TkDisplay structure for the display. * * 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 interp->result. * * Side effects: * A new stream is opened to the device if there is no * connection already. A new TkDisplay data structure is also * setup, if necessary. * *---------------------------------------------------------------------- */ static TkDisplay * GetScreen(interp, screenName) Tcl_Interp *interp; /* Place to leave error message. */ char *screenName; /* Name for screen. NULL or empty means * use CTK_DISPLAY environment variable. */ { register TkDisplay *dispPtr; char *p; size_t length; /* * Separate the terminal type from the rest of the display * name. ScreenName is assumed to have the syntax * : with the colon and the type being * optional. */ if (screenName == NULL || screenName[0] == '\0') { screenName = Tcl_GetVar2(interp, "env", "CTK_DISPLAY", TCL_GLOBAL_ONLY); if (screenName == NULL) { /* * For backwards compatibility, check CWISH_DISPLAY - * this feature will eventually be removed. */ screenName = Tcl_GetVar2(interp, "env", "CWISH_DISPLAY", TCL_GLOBAL_ONLY); } if (screenName == NULL) { screenName = "tty"; } } p = strchr(screenName, ':'); if (p == NULL) { length = strlen(screenName); } else { length = p - screenName; } /* * See if we already have a connection to this display. */ for (dispPtr = tkDisplayList; dispPtr != NULL; dispPtr = dispPtr->nextPtr) { if ((strncmp(dispPtr->name, screenName, length) == 0) && (dispPtr->name[length] == '\0')) { return dispPtr; } } /* * Create entry for new display. */ dispPtr = (TkDisplay *) ckalloc(sizeof(TkDisplay)); if (CtkDisplayInit(interp, dispPtr, screenName) != TCL_OK) { return (TkDisplay *) NULL; } dispPtr->numWindows = 0; dispPtr->rootPtr = CreateRoot(interp, dispPtr); if (dispPtr->rootPtr == NULL) { CtkDisplayEnd(dispPtr); return (TkDisplay *) NULL; } dispPtr->focusPtr = dispPtr->rootPtr; dispPtr->cursorPtr = dispPtr->rootPtr; dispPtr->cursorX = 0; dispPtr->cursorY = 0; dispPtr->nextPtr = tkDisplayList; tkDisplayList = dispPtr; return dispPtr; } /* *---------------------------------------------------------------------- * * Tk_CreateMainWindow -- * * 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 * interp->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. The main * window becomes a "toplevel" widget and its X window will be * created and mapped as an idle handler. * *---------------------------------------------------------------------- */ Tk_Window Tk_CreateMainWindow(interp, screenName, baseName, className) Tcl_Interp *interp; /* Interpreter to use for error reporting. */ char *screenName; /* "device:term-type" on which to create * window. Empty or NULL string means * use stdin/stdout. */ char *baseName; /* Base name for application; usually of the * form "prog instance". */ char *className; /* Class to use for application (same as class * for main window). */ { int dummy; Tcl_HashEntry *hPtr; register TkMainInfo *mainPtr; register TkWindow *winPtr; register TkDisplay *dispPtr; register TkCmd *cmdPtr; char *libDir; char *argv[1]; if (!initialized) { initialized = 1; tkNormalUid = Tk_GetUid("normal"); tkDisabledUid = Tk_GetUid("disabled"); tkActiveUid = Tk_GetUid("active"); } /* * Create the TkMainInfo structure for this application. */ mainPtr = (TkMainInfo *) ckalloc(sizeof(TkMainInfo)); mainPtr->winPtr = NULL; mainPtr->refCount = 0; mainPtr->interp = interp; Tcl_InitHashTable(&mainPtr->nameTable, TCL_STRING_KEYS); mainPtr->bindingTable = Tk_CreateBindingTable(interp); mainPtr->curDispPtr = NULL; mainPtr->bindingDepth = 0; mainPtr->optionRootPtr = NULL; mainPtr->nextPtr = tkMainWindowList; tkMainWindowList = mainPtr; /* * Create the basic TkWindow structure. * * Temporarily put root window into the application's name table * and set root windows mainPtr to the new main structure, * so that Tk_TopLevelCmd() will use the new main structure for * the window it creates. */ if (screenName == (char *) NULL) { screenName = ""; } dispPtr = GetScreen(interp, screenName); if (dispPtr == NULL) { return (Tk_Window) NULL; } dispPtr->rootPtr->mainPtr = mainPtr; hPtr = Tcl_CreateHashEntry(&mainPtr->nameTable, "", &dummy); Tcl_SetHashValue(hPtr, dispPtr->rootPtr); winPtr = Tk_CreateWindowFromPath(interp, dispPtr->rootPtr, ".", screenName); Tcl_DeleteHashEntry(hPtr); dispPtr->rootPtr->mainPtr = NULL; if (winPtr == NULL) { return (Tk_Window) NULL; } mainPtr->winPtr = winPtr; /* * Bind in Tk's commands. */ for (cmdPtr = commands; cmdPtr->name != NULL; cmdPtr++) { Tcl_CreateCommand(interp, cmdPtr->name, cmdPtr->cmdProc, (ClientData) winPtr, (void (*)()) NULL); } /* * Set variables for the intepreter. */ if (Tcl_GetVar(interp, "tk_library", TCL_GLOBAL_ONLY) == NULL) { /* * A library directory hasn't already been set, so figure out * which one to use. */ libDir = getenv("CTK_LIBRARY"); if (libDir == NULL) { libDir = CTK_LIBRARY; } Tcl_SetVar(interp, "tk_library", libDir, TCL_GLOBAL_ONLY); } Tcl_SetVar(interp, "ctk_patchLevel", CTK_PATCH_LEVEL, TCL_GLOBAL_ONLY); Tcl_SetVar(interp, "tk_version", TK_VERSION, TCL_GLOBAL_ONLY); Tcl_SetVar(interp, "tk_port", "curses", TCL_GLOBAL_ONLY); /* * Make the main window into a toplevel widget, and give it an initial * requested size. */ Tk_SetClass(winPtr, className); argv[0] = NULL; if (TkInitFrame(interp, winPtr, 1, 0, argv) == NULL) { return NULL; } Tk_GeometryRequest(winPtr, 20, 10); CtkSetFocus(winPtr); tk_NumMainWindows++; return winPtr; } /* *---------------------------------------------------------------------- * * Ctk_Unsupported -- * * This procedure is invoked when a Tk feature that is not * supported by CTk is requested. * * Results: * A standard TCL result. * * Side effects: * Sets the interpreter result, if "ctk_unsupported" is defined, * could do anything. * *---------------------------------------------------------------------- */ int Ctk_Unsupported(interp, feature) Tcl_Interp *interp; /* Interpreter in which unsupported * feature has been requested. */ char *feature; /* Description of requested feature. */ { Tcl_CmdInfo info; char *argv[3]; Tcl_ResetResult(interp); if (Tcl_GetCommandInfo(interp, "ctk_unsupported", &info)) { argv[0] = "ctk_unsupported"; argv[1] = feature; argv[2] = NULL; return (*info.proc)(info.clientData, interp, 2, argv); } return TCL_OK; } /* *---------------------------------------------------------------------- * * 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. * * Results: * The return value is a token for the new window. If an error * occurred in creating the window (e.g. no such display or * screen), then an error message is left in interp->result and * NULL is returned. * * Side effects: * A new window structure is allocated. * *---------------------------------------------------------------------- */ Tk_Window Tk_CreateWindowFromPath(interp, winPtr, pathName, screenName) Tcl_Interp *interp; /* Interpreter to use for error reporting. * Interp->result is assumed to be * initialized by the caller. */ TkWindow *winPtr; /* Token for any window in application * that is to contain new window. */ 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. */ 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. */ { TkWindow *parentPtr; TkDisplay *dispPtr; Tcl_HashEntry *hPtr; int new; char *name; name = strrchr(pathName, '.'); if (name) { name++; } parentPtr = Ctk_ParentByName(interp, pathName, winPtr); if (parentPtr == (TkWindow *) NULL) { return (TkWindow *) NULL; } if (screenName == NULL) { dispPtr = parentPtr->dispPtr; } else { dispPtr = GetScreen(interp, screenName); } /* * Get entry for new name. */ hPtr = Tcl_CreateHashEntry(&winPtr->mainPtr->nameTable, pathName, &new); if (!new) { Tcl_AppendResult(interp, "window name \"", pathName, "\" already exists", (char *) NULL); return NULL; } /* * Create the window. */ winPtr = NewWindow(dispPtr); if (screenName) { winPtr->parentPtr = dispPtr->rootPtr; winPtr->flags |= TK_TOP_LEVEL; parentPtr->flags |= CTK_HAS_TOPLEVEL_CHILD; } else { winPtr->parentPtr = parentPtr; } winPtr->mainPtr = parentPtr->mainPtr; winPtr->mainPtr->refCount++; InsertWindow(winPtr, HEAD_CHILD(winPtr->parentPtr)); Tcl_SetHashValue(hPtr, winPtr); winPtr->pathName = Tcl_GetHashKey(&winPtr->mainPtr->nameTable, hPtr); winPtr->nameUid = Tk_GetUid(name); return winPtr; } /* *---------------------------------------------------------------------- * Ctk_ParentByName -- * Determine parent of window based on path name. This is necessary * for top level windows because Ctk_Parent() will always return * the root window for them. * * Results: * Returns pointer to new window if successful. Returns * NULL if the parent can't be found, and stores an error * message in interp->result. * * Side Effects: *---------------------------------------------------------------------- */ TkWindow * Ctk_ParentByName(interp, pathName, tkwin) Tcl_Interp *interp; char *pathName; Tk_Window tkwin; { #define FIXED_SPACE 50 char fixedSpace[FIXED_SPACE+1]; char *p; int numChars; Tk_Window parent; /* * 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 * situations where the parent is "" or ".". */ p = strrchr(pathName, '.'); if (p == NULL) { Tcl_AppendResult(interp, "bad window path name \"", pathName, "\"", (char *) NULL); return NULL; } numChars = p-pathName; if (numChars > FIXED_SPACE) { p = (char *) ckalloc((unsigned) (numChars+1)); } else { p = fixedSpace; } if (pathName[1] == '\0') { /* * Parent is root: "" */ *p = '\0'; } else if (numChars == 0) { /* * Parent is main: "." */ *p = '.'; p[1] = '\0'; } else { strncpy(p, pathName, numChars); p[numChars] = '\0'; } /* * Find the parent window. */ parent = Tk_NameToWindow(interp, p, tkwin); if (p != fixedSpace) { ckfree(p); } return parent; } /* *---------------------------------------------------------------------- * * Tk_SetClass -- * * This procedure 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. * *---------------------------------------------------------------------- */ void Tk_SetClass(tkwin, className) Tk_Window tkwin; /* Token for window to assign class. */ char *className; /* New class for tkwin. */ { register TkWindow *winPtr = (TkWindow *) tkwin; winPtr->classUid = Tk_GetUid(className); TkOptionClassChanged(winPtr); } /* *---------------------------------------------------------------------- * * 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. * * 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 interp->result. * * Side effects: * None. * *---------------------------------------------------------------------- */ Tk_Window Tk_NameToWindow(interp, pathName, winPtr) Tcl_Interp *interp; /* Where to report errors. */ char *pathName; /* Path name of window. */ TkWindow *winPtr; /* Token for window, name is assumed to * belong to the same main window as winPtr. */ { Tcl_HashEntry *hPtr; hPtr = Tcl_FindHashEntry(&winPtr->mainPtr->nameTable, pathName); if (hPtr == NULL) { Tcl_AppendResult(interp, "bad window path name \"", pathName, "\"", (char *) NULL); return NULL; } return (Tk_Window) Tcl_GetHashValue(hPtr); } /* *---------------------------------------------------------------------- * * CreateRoot -- * * Creates the root window (whole screen, no parent). The window * is mapped and displayed. * * Results: * A new window pointer. * * Side Effects: * Screen is cleared. * *---------------------------------------------------------------------- */ static TkWindow * CreateRoot(interp, dispPtr) Tcl_Interp *interp; TkDisplay *dispPtr; { TkWindow *winPtr = NewWindow(dispPtr); winPtr->mainPtr = NULL; winPtr->parentPtr = NULL; winPtr->nextPtr = NULL; winPtr->priorPtr = NULL; CtkSetRect(&winPtr->rect, 0, 0, Ctk_DisplayWidth(dispPtr), Ctk_DisplayHeight(dispPtr)); CtkCopyRect(&winPtr->maskRect, &winPtr->rect); CtkCopyRect(&winPtr->clipRect, &winPtr->rect); winPtr->clipRgn = CtkCreateRegion(&(winPtr->maskRect)); winPtr->absLeft = 0; winPtr->absTop = 0; winPtr->flags |= TK_MAPPED|CTK_DISPLAYED|TK_TOP_LEVEL; winPtr->classUid = Tk_GetUid("Root"); Ctk_ClearWindow(winPtr); return winPtr; } /* *---------------------------------------------------------------------- * NewWindow -- * Allocate a window structure and initialize contents. * * Results: * Returns pointer to window. * * Side Effects: * *---------------------------------------------------------------------- */ static TkWindow * NewWindow(dispPtr) TkDisplay *dispPtr; { TkWindow *winPtr = (TkWindow *) ckalloc(sizeof(TkWindow)); winPtr->dispPtr = dispPtr; winPtr->pathName = NULL; winPtr->classUid = NULL; winPtr->mainPtr = NULL; winPtr->flags = 0; winPtr->handlerList = NULL; winPtr->numTags = 0; winPtr->optionLevel = -1; winPtr->tagPtr = NULL; winPtr->childList.nextPtr = HEAD_CHILD(winPtr); winPtr->childList.priorPtr = HEAD_CHILD(winPtr); winPtr->borderWidth = 0; winPtr->fillChar = ' '; winPtr->fillStyle = CTK_PLAIN_STYLE; winPtr->clipRgn = NULL; winPtr->reqWidth = 1; winPtr->reqHeight = 1; winPtr->geomMgrPtr = NULL; winPtr->geomData = NULL; dispPtr->numWindows++; return winPtr; } /* *-------------------------------------------------------------- * * Tk_DestroyWindow -- * * Destroy an existing window. After this call, the caller * should never again use the token. * * Results: * None. * * Side effects: * The window is deleted, along with all of its children. * Relevant callback procedures are invoked. * *-------------------------------------------------------------- */ void Tk_DestroyWindow(winPtr) TkWindow *winPtr; { TkWindow *child; TkWindow *nextPtr; Ctk_Event event; if (winPtr->flags & TK_ALREADY_DEAD) { /* * A destroy event binding caused the window to be destroyed * again. Ignore the request. */ return; } winPtr->flags |= TK_ALREADY_DEAD; Ctk_Unmap(winPtr); /* * 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, * so the reference count of its application doesn't go to zero * when exit calls Tk_DestroyWindow on ".", so the main window * doesn't get removed from the list and exit loops infinitely. * Even worse, if "destroy ." is called by the destroy binding * before calling "exit", "exit" will attempt to destroy * mainPtr->winPtr, which no longer exists, and there may be a * core dump. */ if (winPtr->mainPtr->winPtr == winPtr) { if (tkMainWindowList == winPtr->mainPtr) { tkMainWindowList = winPtr->mainPtr->nextPtr; } else { TkMainInfo *prevPtr; for (prevPtr = tkMainWindowList; prevPtr->nextPtr != winPtr->mainPtr; prevPtr = prevPtr->nextPtr) { /* Empty loop body. */ } prevPtr->nextPtr = winPtr->mainPtr->nextPtr; } tk_NumMainWindows--; } /* * Recursively destroy children. */ for (child = BOTTOM_CHILD(winPtr); child != HEAD_CHILD(winPtr); child = nextPtr) { nextPtr = child->nextPtr; Tk_DestroyWindow(child); } if (winPtr->flags & CTK_HAS_TOPLEVEL_CHILD) { /* * This window has toplevel children, which are not stored * in the child list. Check all the children of all root * windows to see if their name is an extension of this * windows name - if so destroy the top level window. */ char *path = Tk_PathName(winPtr); char *childPath; int length = strlen(path); TkWindow *priorPtr; TkDisplay *dispPtr; for (dispPtr = tkDisplayList; dispPtr != NULL; dispPtr = dispPtr->nextPtr) { priorPtr = HEAD_CHILD(dispPtr->rootPtr); child = BOTTOM_CHILD(dispPtr->rootPtr); while (child != HEAD_CHILD(dispPtr->rootPtr)) { childPath = Tk_PathName(child); if (strncmp(childPath, path, length) == 0 && (childPath[length] == '.' || (length == 1 && childPath[1] != '\0'))) { Tk_DestroyWindow(child); } else { priorPtr = child; } child = priorPtr->nextPtr; } } } /* * Generate a Destroy event. * * Note: if the window's pathName is NULL it means that the window * was not successfully initialized in the first place, so we should * not make the window exist or generate the event. */ if (winPtr->pathName != NULL) { event.type = CTK_DESTROY_EVENT; event.window = winPtr; Tk_HandleEvent(&event); } UnlinkWindow(winPtr); TkEventDeadWindow(winPtr); if (winPtr->tagPtr != NULL) { TkFreeBindingTags(winPtr); } TkOptionDeadWindow(winPtr); TkFocusDeadWindow(winPtr); if (winPtr->mainPtr != NULL) { if (winPtr->pathName != NULL) { Tk_DeleteAllBindings(winPtr->mainPtr->bindingTable, (ClientData) winPtr->pathName); Tcl_DeleteHashEntry(Tcl_FindHashEntry(&winPtr->mainPtr->nameTable, winPtr->pathName)); } winPtr->mainPtr->refCount--; if (winPtr->mainPtr->refCount == 0) { 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 (except don't replace * the "exit" command, since it may be needed for the application * to exit). */ for (cmdPtr = commands; cmdPtr->name != NULL; cmdPtr++) { if (cmdPtr->cmdProc != Tk_ExitCmd) { Tcl_CreateCommand(winPtr->mainPtr->interp, cmdPtr->name, TkDeadAppCmd, (ClientData) NULL, (void (*)()) NULL); } } if (winPtr->mainPtr->bindingDepth == 0) { TkDeleteMain(winPtr->mainPtr); } } } if ((--(winPtr->dispPtr->numWindows)) == 1) { TkDisplay *dispPtr = winPtr->dispPtr; CtkDisplayEnd(dispPtr); if (tkDisplayList == dispPtr) { tkDisplayList = dispPtr->nextPtr; } else { TkDisplay *prevDispPtr; for (prevDispPtr = tkDisplayList; prevDispPtr != NULL; prevDispPtr = prevDispPtr->nextPtr) { if (prevDispPtr->nextPtr == dispPtr) { prevDispPtr->nextPtr = dispPtr->nextPtr; break; } } } ckfree((char *) dispPtr->rootPtr); ckfree((char *) dispPtr); } ckfree((char *) winPtr); } /* *------------------------------------------------------------ * TkDeleteMain -- * * Release resources for a TkMainInfo structure. * All windows for this main should already have * been destroyed. The pointer should no be referenced * again. * * Results: * None. * * Side Effects: * None. * *------------------------------------------------------------ */ void TkDeleteMain(mainPtr) TkMainInfo *mainPtr; { Tcl_DeleteHashTable(&mainPtr->nameTable); Tk_DeleteBindingTable(mainPtr->bindingTable); ckfree((char *) mainPtr); } /* *---------------------------------------------------------------------- * * Tk_RestackWindow -- * * 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. * * Side effects: * Tkwin is repositioned in the stacking order. * *---------------------------------------------------------------------- */ int Tk_RestackWindow(winPtr, aboveBelow, otherPtr) TkWindow *winPtr; int aboveBelow; TkWindow *otherPtr; { int redisplay = 0; if (otherPtr) { /* * Find ancestor of otherPtr (or otherPtr itself) that is a * sibling of winPtr. */ while (otherPtr->parentPtr != winPtr->parentPtr) { otherPtr = otherPtr->parentPtr; if (!otherPtr) { return TCL_ERROR; } } } if (otherPtr == winPtr) { return TCL_OK; } if (CtkIsDisplayed(winPtr)) { UndisplayWindow(winPtr); redisplay = 1; } UnlinkWindow(winPtr); if (aboveBelow == Above) { if (otherPtr) { otherPtr = otherPtr->nextPtr; } else { otherPtr = HEAD_CHILD(winPtr->parentPtr); } } else { if (!otherPtr) { otherPtr = BOTTOM_CHILD(winPtr->parentPtr); } } InsertWindow(winPtr, otherPtr); if (redisplay) { DisplayWindow(winPtr); } return TCL_OK; } /* *------------------------------------------------------------ * Ctk_Map -- * * Position a window within its parent. * * Results: * None. * * Side Effects: * Generates a map event for the window. * If parent is displayed, then the window will be displayed. * *------------------------------------------------------------ */ void Ctk_Map(winPtr, left, top, right, bottom) TkWindow *winPtr; int left; int top; int right; int bottom; { TkWindow *parentPtr = winPtr->parentPtr; Ctk_Event event; /* * Keep top-levels within the bounds of the screen. */ if (winPtr->flags & TK_TOP_LEVEL) { int width = right - left; int height = bottom - top; int screenWidth = Tk_Width(parentPtr); int screenHeight = Tk_Height(parentPtr); if (width > screenWidth) { width = screenWidth; } if (height > screenHeight) { height = screenHeight; } if (left < 0) { left = 0; } else if (left + width > screenWidth) { left = screenWidth - width ; } if (top < 0) { top = 0; } else if (top + height > screenHeight) { top = screenHeight - height; } right = left + width; bottom = top + height; } if ( !Tk_IsMapped(winPtr) || (winPtr->rect.left != left) || (winPtr->rect.top != top) || (winPtr->rect.right != right) || (winPtr->rect.bottom != bottom)) { /* * Window position changed (or window was not mapped * before). Undisplay window, re-position it, and then * display it if parent is displayed. */ if (CtkIsDisplayed(winPtr)) { UndisplayWindow(winPtr); } CtkSetRect(&(winPtr->rect), left, top, right, bottom); winPtr->flags |= TK_MAPPED; if (CtkIsDisplayed(parentPtr)) { DisplayWindow(winPtr); } } event.type = CTK_MAP_EVENT; event.window = winPtr; Tk_HandleEvent(&event); } /* *------------------------------------------------------------ * Ctk_Unmap -- * * Remove positioning for a window. * * Results: * None. * * Side Effects: * If window is displayed, it and all its descendants are * undisplayed. * *------------------------------------------------------------ */ void Ctk_Unmap(winPtr) TkWindow *winPtr; { Ctk_Event event; if (Tk_IsMapped(winPtr)) { /* * Window is mapped, unmap it. */ if (CtkIsDisplayed(winPtr)) { UndisplayWindow(winPtr); } winPtr->flags &= ~TK_MAPPED; event.type = CTK_UNMAP_EVENT; event.window = winPtr; Tk_HandleEvent(&event); } } /* *------------------------------------------------------------ * Ctk_BottomChild -- * Ctk_TopChild -- * Ctk_PriorSibling -- * Ctk_NextSibling -- * Ctk_TopLevel -- * * Get window relative. * * Results: * Pointer to window, or NULL if window has no such relative. * * Side Effects: * None. * *------------------------------------------------------------ */ TkWindow * Ctk_BottomChild(winPtr) TkWindow *winPtr; { TkWindow * child = BOTTOM_CHILD(winPtr); if (child == HEAD_CHILD(winPtr)) { return (TkWindow *) NULL; } else { return child; } } TkWindow * Ctk_TopChild(winPtr) TkWindow *winPtr; { TkWindow * child = TOP_CHILD(winPtr); if (child == HEAD_CHILD(winPtr)) { return (TkWindow *) NULL; } else { return child; } } TkWindow * Ctk_NextSibling(winPtr) TkWindow *winPtr; { TkWindow * sibling = winPtr->nextPtr; if (sibling == HEAD_CHILD(winPtr->parentPtr)) { return (TkWindow *) NULL; } else { return sibling; } } TkWindow * Ctk_PriorSibling(winPtr) TkWindow *winPtr; { TkWindow * sibling = winPtr->priorPtr; if (sibling == HEAD_CHILD(winPtr->parentPtr)) { return (TkWindow *) NULL; } else { return sibling; } } TkWindow * Ctk_TopLevel(winPtr) TkWindow *winPtr; { while (!Tk_IsTopLevel(winPtr)) { winPtr = winPtr->parentPtr; } return winPtr; } /* *------------------------------------------------------------ * Tk_SetInternalBorder -- * * Set window's internal border width. The standard drawing * routines will not draw on the internal border (only * Ctk_DrawBorder() will) and the geometry managers should * not place child windows there. * * Results: * None. * * Side Effects: * The border width is recorded for the window, and a map * event is synthesized so that all geometry managers of all * children are notified to re-layout, if necessary. * *------------------------------------------------------------ */ void Tk_SetInternalBorder(winPtr, width) TkWindow *winPtr; int width; { Ctk_Event event; if (winPtr->borderWidth != width) { winPtr->borderWidth = width; ComputeClipRect(winPtr); event.type = CTK_MAP_EVENT; event.window = winPtr; Tk_HandleEvent(&event); } } /* *-------------------------------------------------------------- * * Ctk_DrawBorder -- * * Draw border for a window in specified style. * * Results: * None. * * Side effects: * Characters are output to the terminal. * *-------------------------------------------------------------- */ void Ctk_DrawBorder(winPtr, style, title) TkWindow *winPtr; Ctk_Style style; char *title; { int borderWidth = winPtr->borderWidth; if (borderWidth > 0) { Ctk_Rect saveClip; /* * Temporarily set clipRect to maskRect so that we can * draw within the border area. */ CtkCopyRect(&saveClip, &winPtr->clipRect); CtkCopyRect(&winPtr->clipRect, &winPtr->maskRect); Ctk_DrawRect(winPtr, 0, 0, Tk_Width(winPtr)-1, Tk_Height(winPtr)-1, style); if (title) { Ctk_DrawString(winPtr, 1, 0, style, title, -1); } CtkCopyRect(&winPtr->clipRect, &saveClip); } } /* *---------------------------------------------------------------------- * * Tk_MainWindow -- * * 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 interp->result. * * Side effects: * None. * *---------------------------------------------------------------------- */ Tk_Window Tk_MainWindow(interp) Tcl_Interp *interp; /* Interpreter that embodies the * application. Used for error * reporting also. */ { TkMainInfo *mainPtr; for (mainPtr = tkMainWindowList; mainPtr != NULL; mainPtr = mainPtr->nextPtr) { if (mainPtr->interp == interp) { return (Tk_Window) mainPtr->winPtr; } } Tcl_SetResult(interp,"this isn't a Tk application",TCL_STATIC); return NULL; } /* *------------------------------------------------------------ * DisplayWindow -- * * Display window and all its mapped descendants. * * Results: * None. * * Side Effects: * *------------------------------------------------------------ */ static void DisplayWindow(winPtr) TkWindow *winPtr; { TkWindow *parentPtr = winPtr->parentPtr; TkWindow *sibling; TkWindow *child; if (CtkIsDisplayed(winPtr)) { panic("Attempt to display already displayed window"); } winPtr->flags |= CTK_DISPLAYED; winPtr->absLeft = parentPtr->absLeft + winPtr->rect.left; winPtr->absTop = parentPtr->absTop + winPtr->rect.top; winPtr->maskRect.top = winPtr->absTop; winPtr->maskRect.left = winPtr->absLeft; winPtr->maskRect.bottom = parentPtr->absTop + winPtr->rect.bottom; winPtr->maskRect.right = parentPtr->absLeft + winPtr->rect.right; CtkIntersectRects(&(winPtr->maskRect), &(parentPtr->clipRect)); ComputeClipRect(winPtr); if (winPtr->flags & TK_TOP_LEVEL) { /* * This is a top level window, compute clipping by siblings. * Start with a clipping region equal to `maskRect', then * remove overlaps with siblings above this window. */ winPtr->clipRgn = CtkCreateRegion(&(winPtr->maskRect)); for (sibling = winPtr->nextPtr; sibling != HEAD_CHILD(parentPtr); sibling = sibling->nextPtr) { if (CtkIsDisplayed(sibling)) { CtkRegionMinusRect(winPtr->clipRgn, &(sibling->maskRect), 0); } } /* * For each sibling below this window (and the root), * subtract the overlap between this window and the sibling * from the sibling's clipping region. */ for (sibling = winPtr->priorPtr; sibling != HEAD_CHILD(parentPtr); sibling = sibling->priorPtr) { if (CtkIsDisplayed(sibling)) { CtkRegionMinusRect(sibling->clipRgn, &(winPtr->maskRect), 0); } } CtkRegionMinusRect(parentPtr->clipRgn, &(winPtr->maskRect), 0); } else { winPtr->clipRgn = parentPtr->clipRgn; } Ctk_ClearWindow(winPtr); ExposeWindow(winPtr, winPtr->clipRgn); for (child = BOTTOM_CHILD(winPtr); child != HEAD_CHILD(winPtr); child = child->nextPtr) { if (Tk_IsMapped(child)) { DisplayWindow(child); } } } /* *------------------------------------------------------------ * ComputeClipRect -- * * Set the clipping rectangle for a window according * to it's position, border-width, and parent's clipping * rectangle. * * Results: * None. * * Side Effects: * Stores new values in winPtr->clipRect. * *------------------------------------------------------------ */ static void ComputeClipRect(winPtr) register TkWindow *winPtr; { register TkWindow *parentPtr = winPtr->parentPtr; winPtr->clipRect.top = winPtr->absTop + winPtr->borderWidth; winPtr->clipRect.left = winPtr->absLeft + winPtr->borderWidth; winPtr->clipRect.bottom = parentPtr->absTop + winPtr->rect.bottom - winPtr->borderWidth; winPtr->clipRect.right = parentPtr->absLeft + winPtr->rect.right - winPtr->borderWidth; CtkIntersectRects(&(winPtr->clipRect), &(parentPtr->clipRect)); } /* *------------------------------------------------------------ * ExposeWindow -- * * Send expose event(s) to window for specified region * * Results: * Pointer to sibling window, or NULL if window * does not have a sibling that is displayed and enabled. * * Side Effects: * None. * *------------------------------------------------------------ */ static void ExposeWindow(winPtr, rgnPtr) TkWindow *winPtr; CtkRegion *rgnPtr; { Ctk_Event event; /* * Compute intersection of rgnPtr and winPtr->maskRect. */ CtkRegionGetRect(rgnPtr, &event.u.expose); CtkIntersectRects(&event.u.expose, &(winPtr->maskRect)); CtkMoveRect(&event.u.expose, -winPtr->absLeft, -winPtr->absTop); event.type = CTK_EXPOSE_EVENT; event.window = winPtr; Tk_HandleEvent(&event); } /* *------------------------------------------------------------ * UndisplayWindow -- * * Stop displaying window and all its descendants. * Window must currently be displayed. * * Results: * None. * * Side Effects: * *------------------------------------------------------------ */ static void UndisplayWindow(winPtr) TkWindow *winPtr; { TkWindow *child; TkWindow *sibling; TkWindow *parentPtr = winPtr->parentPtr; Ctk_Event event; if (!CtkIsDisplayed(winPtr)) { panic("Attempt to undisplay window that isn't displayed"); } /* * Stop displaying the descendants of `winPtr'. */ for (child = BOTTOM_CHILD(winPtr); child != HEAD_CHILD(winPtr); child = child->nextPtr) { if (CtkIsDisplayed(child)) { UndisplayWindow(child); } } winPtr->flags &= ~CTK_DISPLAYED; if (parentPtr == NULL) { CtkDestroyRegion(winPtr->clipRgn); } else if (winPtr->flags & TK_TOP_LEVEL) { /* * This is a top level window, * maintain the clipping regions. */ /* * For each (displayed) sibling below this window * (and the root) add the overlap between the window and the * sibling to the siblings clipping region. */ for (sibling = winPtr->priorPtr; sibling != HEAD_CHILD(parentPtr); sibling = sibling->priorPtr) { if (CtkIsDisplayed(sibling)) { UnoverlapHierarchy(sibling, winPtr); } } Unoverlap(parentPtr, winPtr); CtkDestroyRegion(winPtr->clipRgn); } else if (winPtr->fillStyle != CTK_INVISIBLE_STYLE) { Ctk_FillRect(parentPtr, winPtr->rect.left, winPtr->rect.top, winPtr->rect.right, winPtr->rect.bottom, parentPtr->fillStyle, parentPtr->fillChar); event.type = CTK_EXPOSE_EVENT; event.window = parentPtr; CtkCopyRect(&event.u.expose, &parentPtr->rect); Tk_HandleEvent(&event); } else if (winPtr->borderWidth) { int borderWidth = winPtr->borderWidth; /* * Blank out the border area. * This would be much easier if we could pass a character to * Ctk_DrawRect(). */ Ctk_FillRect(parentPtr, winPtr->rect.left, winPtr->rect.top, winPtr->rect.right, winPtr->rect.top+borderWidth, parentPtr->fillStyle, parentPtr->fillChar); Ctk_FillRect(parentPtr, winPtr->rect.left, winPtr->rect.bottom-borderWidth, winPtr->rect.right, winPtr->rect.bottom, parentPtr->fillStyle, parentPtr->fillChar); Ctk_FillRect(parentPtr, winPtr->rect.left, winPtr->rect.top+borderWidth, winPtr->rect.left+borderWidth, winPtr->rect.bottom-borderWidth, parentPtr->fillStyle, parentPtr->fillChar); Ctk_FillRect(parentPtr, winPtr->rect.right-borderWidth, winPtr->rect.top+borderWidth, winPtr->rect.right, winPtr->rect.bottom-borderWidth, parentPtr->fillStyle, parentPtr->fillChar); } winPtr->clipRgn = NULL; } /* *------------------------------------------------------------ * UnoverlapHierarchy -- * * Restore overlapping region to underlying window tree. * * Results: * None. * * Side Effects: * *------------------------------------------------------------ */ static void UnoverlapHierarchy(underWinPtr, overWinPtr) TkWindow *underWinPtr; TkWindow *overWinPtr; { TkWindow *child; for (child = TOP_CHILD(underWinPtr); child != HEAD_CHILD(underWinPtr); child = child->priorPtr) { if (CtkIsDisplayed(child)) { UnoverlapHierarchy(child, overWinPtr); } } Unoverlap(underWinPtr, overWinPtr); } /* *------------------------------------------------------------ * Unoverlap -- * * Restore overlapping region to underlying window. * * Results: * None. * * Side Effects: * *------------------------------------------------------------ */ static void Unoverlap(underWinPtr, overWinPtr) TkWindow *underWinPtr; TkWindow *overWinPtr; { CtkRegion *overlap; if (underWinPtr->fillStyle != CTK_INVISIBLE_STYLE) { overlap = CtkRegionMinusRect( overWinPtr->clipRgn, &(underWinPtr->maskRect), 1); CtkUnionRegions(underWinPtr->clipRgn, overlap); CtkFillRegion(underWinPtr->dispPtr, overlap, underWinPtr->fillStyle, underWinPtr->fillChar); ExposeWindow(underWinPtr, overlap); CtkDestroyRegion(overlap); } else { if (underWinPtr->borderWidth) { /* * Ok - this is a hack: * Invisible windows can have (visible) borders, so * must send an expose event to the window. Ideally, * I would remove the border area from the overlying * clip region, but that would take a lot of work. * Since I know that the window will not redraw until * idle time, I can send expose now, and let the parent * clear the border area. Later, at idle, the invisible * window will draw the border. */ ExposeWindow(underWinPtr, overWinPtr->clipRgn); } } } /* *------------------------------------------------------------ * InsertWindow -- * * Insert window into list in front of `sibling'. * * Results: * None. * * Side Effects: * *------------------------------------------------------------ */ static void InsertWindow(winPtr, sibling) TkWindow *winPtr; TkWindow *sibling; { winPtr->nextPtr = sibling; winPtr->priorPtr = sibling->priorPtr; sibling->priorPtr->nextPtr = winPtr; sibling->priorPtr = winPtr; } /* *------------------------------------------------------------ * UnlinkWindow -- * * Detachs the window from its parent's list of children. * * Results: * None. * * Side Effects: * *------------------------------------------------------------ */ static void UnlinkWindow(winPtr) TkWindow *winPtr; { winPtr->nextPtr->priorPtr = winPtr->priorPtr; winPtr->priorPtr->nextPtr = winPtr->nextPtr; }