diff options
Diffstat (limited to 'tk8.6/unix/tkUnixEmbed.c')
| -rw-r--r-- | tk8.6/unix/tkUnixEmbed.c | 1185 |
1 files changed, 0 insertions, 1185 deletions
diff --git a/tk8.6/unix/tkUnixEmbed.c b/tk8.6/unix/tkUnixEmbed.c deleted file mode 100644 index b170ad0..0000000 --- a/tk8.6/unix/tkUnixEmbed.c +++ /dev/null @@ -1,1185 +0,0 @@ -/* - * tkUnixEmbed.c -- - * - * This file contains platform-specific functions for UNIX to provide - * basic operations needed for application embedding (where one - * application can use as its main window an internal window from some - * other application). Also includes code to support busy windows. - * - * Copyright (c) 1996-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. - */ - -#include "tkUnixInt.h" -#include "tkBusy.h" - -/* - * One of the following structures exists for each container in this - * application. It keeps track of the container window and its associated - * embedded window. - */ - -typedef struct Container { - Window parent; /* X's window id for the parent of the pair - * (the container). */ - Window parentRoot; /* Id for the root window of parent's - * screen. */ - TkWindow *parentPtr; /* Tk's information about the container, or - * NULL if the container isn't in this - * process. */ - Window wrapper; /* X's window id for the wrapper window for - * the embedded window. Starts off as None, - * but gets filled in when the window is - * eventually created. */ - TkWindow *embeddedPtr; /* Tk's information about the embedded window, - * or NULL if the embedded application isn't - * in this process. Note that this is *not* - * the same window as wrapper: wrapper is the - * parent of embeddedPtr. */ - struct Container *nextPtr; /* Next in list of all containers in this - * process. */ -} Container; - -typedef struct ThreadSpecificData { - Container *firstContainerPtr; - /* First in list of all containers managed by - * this process. */ -} ThreadSpecificData; -static Tcl_ThreadDataKey dataKey; - -/* - * Prototypes for static functions defined in this file: - */ - -static void ContainerEventProc(ClientData clientData, - XEvent *eventPtr); -static void EmbeddedEventProc(ClientData clientData, - XEvent *eventPtr); -static int EmbedErrorProc(ClientData clientData, - XErrorEvent *errEventPtr); -static void EmbedFocusProc(ClientData clientData, - XEvent *eventPtr); -static void EmbedGeometryRequest(Container *containerPtr, - int width, int height); -static void EmbedSendConfigure(Container *containerPtr); -static void EmbedStructureProc(ClientData clientData, - XEvent *eventPtr); -static void EmbedWindowDeleted(TkWindow *winPtr); - -/* - *---------------------------------------------------------------------- - * - * TkpUseWindow -- - * - * This function causes a Tk window to use a given X window as its parent - * window, rather than the root window for the screen. It is invoked by - * an embedded application to specify the window in which it is embedded. - * - * Results: - * The return value is normally TCL_OK. If an error occurs (such as - * string not being a valid window spec), then the return value is - * TCL_ERROR and an error message is left in the interp's result if - * interp is non-NULL. - * - * Side effects: - * Changes the colormap and other visual information to match that of the - * parent window given by "string". - * - *---------------------------------------------------------------------- - */ - -int -TkpUseWindow( - Tcl_Interp *interp, /* If not NULL, used for error reporting if - * string is bogus. */ - Tk_Window tkwin, /* Tk window that does not yet have an - * associated X window. */ - const char *string) /* String identifying an X window to use for - * tkwin; must be an integer value. */ -{ - TkWindow *winPtr = (TkWindow *) tkwin; - TkWindow *usePtr; - int anyError; - Window parent; - Tk_ErrorHandler handler; - Container *containerPtr; - XWindowAttributes parentAtts; - ThreadSpecificData *tsdPtr = - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - - if (winPtr->window != None) { - Tcl_SetObjResult(interp, Tcl_NewStringObj( - "can't modify container after widget is created", -1)); - Tcl_SetErrorCode(interp, "TK", "EMBED", "POST_CREATE", NULL); - return TCL_ERROR; - } - if (TkpScanWindowId(interp, string, &parent) != TCL_OK) { - return TCL_ERROR; - } - - usePtr = (TkWindow *) Tk_IdToWindow(winPtr->display, parent); - if (usePtr != NULL && !(usePtr->flags & TK_CONTAINER)) { - Tcl_SetObjResult(interp, Tcl_ObjPrintf( - "window \"%s\" doesn't have -container option set", - usePtr->pathName)); - Tcl_SetErrorCode(interp, "TK", "EMBED", "CONTAINER", NULL); - return TCL_ERROR; - } - - /* - * Tk sets the window colormap to the screen default colormap in - * tkWindow.c:AllocWindow. This doesn't work well for embedded windows. So - * we override the colormap and visual settings to be the same as the - * parent window (which is in the container app). - */ - - anyError = 0; - handler = Tk_CreateErrorHandler(winPtr->display, -1, -1, -1, - EmbedErrorProc, &anyError); - if (!XGetWindowAttributes(winPtr->display, parent, &parentAtts)) { - anyError = 1; - } - XSync(winPtr->display, False); - Tk_DeleteErrorHandler(handler); - if (anyError) { - if (interp != NULL) { - Tcl_SetObjResult(interp, Tcl_ObjPrintf( - "couldn't create child of window \"%s\"", string)); - Tcl_SetErrorCode(interp, "TK", "EMBED", "NO_TARGET", NULL); - } - return TCL_ERROR; - } - Tk_SetWindowVisual(tkwin, parentAtts.visual, parentAtts.depth, - parentAtts.colormap); - - /* - * Create an event handler to clean up the Container structure when tkwin - * is eventually deleted. - */ - - Tk_CreateEventHandler(tkwin, StructureNotifyMask, EmbeddedEventProc, - winPtr); - - /* - * Save information about the container and the embedded window in a - * Container structure. If there is already an existing Container - * structure, it means that both container and embedded app. are in the - * same process. - */ - - for (containerPtr = tsdPtr->firstContainerPtr; containerPtr != NULL; - containerPtr = containerPtr->nextPtr) { - if (containerPtr->parent == parent) { - winPtr->flags |= TK_BOTH_HALVES; - containerPtr->parentPtr->flags |= TK_BOTH_HALVES; - break; - } - } - if (containerPtr == NULL) { - containerPtr = ckalloc(sizeof(Container)); - containerPtr->parent = parent; - containerPtr->parentRoot = parentAtts.root; - containerPtr->parentPtr = NULL; - containerPtr->wrapper = None; - containerPtr->nextPtr = tsdPtr->firstContainerPtr; - tsdPtr->firstContainerPtr = containerPtr; - } - containerPtr->embeddedPtr = winPtr; - winPtr->flags |= TK_EMBEDDED; - return TCL_OK; -} - -/* - *---------------------------------------------------------------------- - * - * TkpMakeWindow -- - * - * Create an actual window system window object based on the current - * attributes of the specified TkWindow. - * - * Results: - * Returns the handle to the new window, or None on failure. - * - * Side effects: - * Creates a new X window. - * - *---------------------------------------------------------------------- - */ - -Window -TkpMakeWindow( - TkWindow *winPtr, /* Tk's information about the window that is - * to be instantiated. */ - Window parent) /* Window system token for the parent in which - * the window is to be created. */ -{ - Container *containerPtr; - ThreadSpecificData *tsdPtr = - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - - if (winPtr->flags & TK_EMBEDDED) { - /* - * This window is embedded. Don't create the new window in the given - * parent; instead, create it as a child of the root window of the - * container's screen. The window will get reparented into a wrapper - * window later. - */ - - for (containerPtr = tsdPtr->firstContainerPtr; ; - containerPtr = containerPtr->nextPtr) { - if (containerPtr == NULL) { - Tcl_Panic("TkMakeWindow couldn't find container for window"); - } - if (containerPtr->embeddedPtr == winPtr) { - break; - } - } - parent = containerPtr->parentRoot; - } - - return XCreateWindow(winPtr->display, parent, winPtr->changes.x, - winPtr->changes.y, (unsigned) winPtr->changes.width, - (unsigned) winPtr->changes.height, - (unsigned) winPtr->changes.border_width, winPtr->depth, - InputOutput, winPtr->visual, winPtr->dirtyAtts, - &winPtr->atts); -} - -/* - *---------------------------------------------------------------------- - * - * TkpMakeContainer -- - * - * This function is called to indicate that a particular window will be a - * container for an embedded application. This changes certain aspects of - * the window's behavior, such as whether it will receive events anymore. - * - * Results: - * None. - * - * Side effects: - * None. - * - *---------------------------------------------------------------------- - */ - -void -TkpMakeContainer( - Tk_Window tkwin) /* Token for a window that is about to become - * a container. */ -{ - TkWindow *winPtr = (TkWindow *) tkwin; - Container *containerPtr; - ThreadSpecificData *tsdPtr = - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - - /* - * Register the window as a container so that, for example, we can find - * out later if the embedded app. is in the same process. - */ - - Tk_MakeWindowExist(tkwin); - containerPtr = ckalloc(sizeof(Container)); - containerPtr->parent = Tk_WindowId(tkwin); - containerPtr->parentRoot = RootWindowOfScreen(Tk_Screen(tkwin)); - containerPtr->parentPtr = winPtr; - containerPtr->wrapper = None; - containerPtr->embeddedPtr = NULL; - containerPtr->nextPtr = tsdPtr->firstContainerPtr; - tsdPtr->firstContainerPtr = containerPtr; - winPtr->flags |= TK_CONTAINER; - - /* - * Request SubstructureNotify events so that we can find out when the - * embedded application creates its window or attempts to resize it. Also - * watch Configure events on the container so that we can resize the child - * to match. - */ - - winPtr->atts.event_mask |= SubstructureRedirectMask|SubstructureNotifyMask; - XSelectInput(winPtr->display, winPtr->window, winPtr->atts.event_mask); - Tk_CreateEventHandler(tkwin, - SubstructureNotifyMask|SubstructureRedirectMask, - ContainerEventProc, winPtr); - Tk_CreateEventHandler(tkwin, StructureNotifyMask, EmbedStructureProc, - containerPtr); - Tk_CreateEventHandler(tkwin, FocusChangeMask, EmbedFocusProc, - containerPtr); -} - -/* - *---------------------------------------------------------------------- - * - * EmbedErrorProc -- - * - * This function is invoked if an error occurs while creating an embedded - * window. - * - * Results: - * Always returns 0 to indicate that the error has been properly handled. - * - * Side effects: - * The integer pointed to by the clientData argument is set to 1. - * - *---------------------------------------------------------------------- - */ - -static int -EmbedErrorProc( - ClientData clientData, /* Points to integer to set. */ - XErrorEvent *errEventPtr) /* Points to information about error (not - * used). */ -{ - int *iPtr = clientData; - - *iPtr = 1; - return 0; -} - -/* - *---------------------------------------------------------------------- - * - * EmbeddedEventProc -- - * - * This function is invoked by the Tk event dispatcher when various - * useful events are received for a window that is embedded in another - * application. - * - * Results: - * None. - * - * Side effects: - * Our internal state gets cleaned up when an embedded window is - * destroyed. - * - *---------------------------------------------------------------------- - */ - -static void -EmbeddedEventProc( - ClientData clientData, /* Token for container window. */ - XEvent *eventPtr) /* ResizeRequest event. */ -{ - TkWindow *winPtr = clientData; - - if (eventPtr->type == DestroyNotify) { - EmbedWindowDeleted(winPtr); - } -} - -/* - *---------------------------------------------------------------------- - * - * ContainerEventProc -- - * - * This function is invoked by the Tk event dispatcher when various - * useful events are received for the children of a container window. It - * forwards relevant information, such as geometry requests, from the - * events into the container's application. - * - * Results: - * None. - * - * Side effects: - * Depends on the event. For example, when ConfigureRequest events occur, - * geometry information gets set for the container window. - * - *---------------------------------------------------------------------- - */ - -static void -ContainerEventProc( - ClientData clientData, /* Token for container window. */ - XEvent *eventPtr) /* ResizeRequest event. */ -{ - TkWindow *winPtr = clientData; - Container *containerPtr; - Tk_ErrorHandler errHandler; - ThreadSpecificData *tsdPtr = - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - - /* - * Ignore any X protocol errors that happen in this function (almost any - * operation could fail, for example, if the embedded application has - * deleted its window). - */ - - errHandler = Tk_CreateErrorHandler(eventPtr->xfocus.display, -1, - -1, -1, NULL, NULL); - - /* - * Find the Container structure associated with the parent window. - */ - - for (containerPtr = tsdPtr->firstContainerPtr; - containerPtr->parent != eventPtr->xmaprequest.parent; - containerPtr = containerPtr->nextPtr) { - if (containerPtr == NULL) { - Tcl_Panic("ContainerEventProc couldn't find Container record"); - } - } - - if (eventPtr->type == CreateNotify) { - /* - * A new child window has been created in the container. Record its id - * in the Container structure (if more than one child is created, just - * remember the last one and ignore the earlier ones). Also set the - * child's size to match the container. - */ - - containerPtr->wrapper = eventPtr->xcreatewindow.window; - XMoveResizeWindow(eventPtr->xcreatewindow.display, - containerPtr->wrapper, 0, 0, - (unsigned) Tk_Width((Tk_Window) containerPtr->parentPtr), - (unsigned) Tk_Height((Tk_Window) containerPtr->parentPtr)); - } else if (eventPtr->type == ConfigureRequest) { - if ((eventPtr->xconfigurerequest.x != 0) - || (eventPtr->xconfigurerequest.y != 0)) { - /* - * The embedded application is trying to move itself, which isn't - * legal. At this point, the window hasn't actually moved, but we - * need to send it a ConfigureNotify event to let it know that its - * request has been denied. If the embedded application was also - * trying to resize itself, a ConfigureNotify will be sent by the - * geometry management code below, so we don't need to do - * anything. Otherwise, generate a synthetic event. - */ - - if ((eventPtr->xconfigurerequest.width == winPtr->changes.width) - && (eventPtr->xconfigurerequest.height - == winPtr->changes.height)) { - EmbedSendConfigure(containerPtr); - } - } - EmbedGeometryRequest(containerPtr, - eventPtr->xconfigurerequest.width, - eventPtr->xconfigurerequest.height); - } else if (eventPtr->type == MapRequest) { - /* - * The embedded application's map request was ignored and simply - * passed on to us, so we have to map the window for it to appear on - * the screen. - */ - - XMapWindow(eventPtr->xmaprequest.display, - eventPtr->xmaprequest.window); - } else if (eventPtr->type == DestroyNotify) { - /* - * The embedded application is gone. Destroy the container window. - */ - - Tk_DestroyWindow((Tk_Window) winPtr); - } - Tk_DeleteErrorHandler(errHandler); -} - -/* - *---------------------------------------------------------------------- - * - * EmbedStructureProc -- - * - * This function is invoked by the Tk event dispatcher when a container - * window owned by this application gets resized (and also at several - * other times that we don't care about). This function reflects the size - * change in the embedded window that corresponds to the container. - * - * Results: - * None. - * - * Side effects: - * The embedded window gets resized to match the container. - * - *---------------------------------------------------------------------- - */ - -static void -EmbedStructureProc( - ClientData clientData, /* Token for container window. */ - XEvent *eventPtr) /* ResizeRequest event. */ -{ - Container *containerPtr = clientData; - Tk_ErrorHandler errHandler; - - if (eventPtr->type == ConfigureNotify) { - if (containerPtr->wrapper != None) { - /* - * Ignore errors, since the embedded application could have - * deleted its window. - */ - - errHandler = Tk_CreateErrorHandler(eventPtr->xfocus.display, -1, - -1, -1, NULL, NULL); - XMoveResizeWindow(eventPtr->xconfigure.display, - containerPtr->wrapper, 0, 0, - (unsigned) Tk_Width((Tk_Window) containerPtr->parentPtr), - (unsigned) Tk_Height((Tk_Window) containerPtr->parentPtr)); - Tk_DeleteErrorHandler(errHandler); - } - } else if (eventPtr->type == DestroyNotify) { - EmbedWindowDeleted(containerPtr->parentPtr); - } -} - -/* - *---------------------------------------------------------------------- - * - * EmbedFocusProc -- - * - * This function is invoked by the Tk event dispatcher when FocusIn and - * FocusOut events occur for a container window owned by this - * application. It is responsible for moving the focus back and forth - * between a container application and an embedded application. - * - * Results: - * None. - * - * Side effects: - * The X focus may change. - * - *---------------------------------------------------------------------- - */ - -static void -EmbedFocusProc( - ClientData clientData, /* Token for container window. */ - XEvent *eventPtr) /* ResizeRequest event. */ -{ - Container *containerPtr = clientData; - Tk_ErrorHandler errHandler; - Display *display; - - display = Tk_Display(containerPtr->parentPtr); - if (eventPtr->type == FocusIn) { - /* - * The focus just arrived at the container. Change the X focus to move - * it to the embedded application, if there is one. Ignore X errors - * that occur during this operation (it's possible that the new focus - * window isn't mapped). - */ - - if (containerPtr->wrapper != None) { - errHandler = Tk_CreateErrorHandler(eventPtr->xfocus.display, -1, - -1, -1, NULL, NULL); - XSetInputFocus(display, containerPtr->wrapper, RevertToParent, - CurrentTime); - Tk_DeleteErrorHandler(errHandler); - } - } -} - -/* - *---------------------------------------------------------------------- - * - * EmbedGeometryRequest -- - * - * This function is invoked when an embedded application requests a - * particular size. It processes the request (which may or may not - * actually honor the request) and reflects the results back to the - * embedded application. - * - * Results: - * None. - * - * Side effects: - * If we deny the child's size change request, a Configure event is - * synthesized to let the child know how big it ought to be. Events get - * processed while we're waiting for the geometry managers to do their - * thing. - * - *---------------------------------------------------------------------- - */ - -static void -EmbedGeometryRequest( - Container *containerPtr, /* Information about the embedding. */ - int width, int height) /* Size that the child has requested. */ -{ - TkWindow *winPtr = containerPtr->parentPtr; - - /* - * Forward the requested size into our geometry management hierarchy via - * the container window. We need to send a Configure event back to the - * embedded application if we decide not to honor its request; to make - * this happen, process all idle event handlers synchronously here (so - * that the geometry managers have had a chance to do whatever they want - * to do), and if the window's size didn't change then generate a - * configure event. - */ - - Tk_GeometryRequest((Tk_Window) winPtr, width, height); - while (Tcl_DoOneEvent(TCL_IDLE_EVENTS)) { - /* Empty loop body. */ - } - if ((winPtr->changes.width != width) - || (winPtr->changes.height != height)) { - EmbedSendConfigure(containerPtr); - } -} - -/* - *---------------------------------------------------------------------- - * - * EmbedSendConfigure -- - * - * This function synthesizes a ConfigureNotify event to notify an - * embedded application of its current size and location. This function - * is called when the embedded application made a geometry request that - * we did not grant, so that the embedded application knows that its - * geometry didn't change after all. - * - * Results: - * None. - * - * Side effects: - * None. - * - *---------------------------------------------------------------------- - */ - -static void -EmbedSendConfigure( - Container *containerPtr) /* Information about the embedding. */ -{ - TkWindow *winPtr = containerPtr->parentPtr; - XEvent event; - - event.xconfigure.type = ConfigureNotify; - event.xconfigure.serial = LastKnownRequestProcessed(winPtr->display); - event.xconfigure.send_event = True; - event.xconfigure.display = winPtr->display; - event.xconfigure.event = containerPtr->wrapper; - event.xconfigure.window = containerPtr->wrapper; - event.xconfigure.x = 0; - event.xconfigure.y = 0; - event.xconfigure.width = winPtr->changes.width; - event.xconfigure.height = winPtr->changes.height; - event.xconfigure.above = None; - event.xconfigure.override_redirect = False; - - /* - * Note: when sending the event below, the ButtonPressMask causes the - * event to be sent only to applications that have selected for - * ButtonPress events, which should be just the embedded application. - */ - - XSendEvent(winPtr->display, containerPtr->wrapper, False, - 0, &event); - - /* - * The following needs to be done if the embedded window is not in the - * same application as the container window. - */ - - if (containerPtr->embeddedPtr == NULL) { - XMoveResizeWindow(winPtr->display, containerPtr->wrapper, 0, 0, - (unsigned) winPtr->changes.width, - (unsigned) winPtr->changes.height); - } -} - -/* - *---------------------------------------------------------------------- - * - * TkpGetOtherWindow -- - * - * If both the container and embedded window are in the same process, - * this function will return either one, given the other. - * - * Results: - * If winPtr is a container, the return value is the token for the - * embedded window, and vice versa. If the "other" window isn't in this - * process, NULL is returned. - * - * Side effects: - * None. - * - *---------------------------------------------------------------------- - */ - -TkWindow * -TkpGetOtherWindow( - TkWindow *winPtr) /* Tk's structure for a container or embedded - * window. */ -{ - Container *containerPtr; - ThreadSpecificData *tsdPtr = - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - - for (containerPtr = tsdPtr->firstContainerPtr; - containerPtr != NULL; - containerPtr = containerPtr->nextPtr) { - if (containerPtr->embeddedPtr == winPtr) { - return containerPtr->parentPtr; - } else if (containerPtr->parentPtr == winPtr) { - return containerPtr->embeddedPtr; - } - } - return NULL; -} - -/* - *---------------------------------------------------------------------- - * - * TkpRedirectKeyEvent -- - * - * This function is invoked when a key press or release event arrives for - * an application that does not believe it owns the input focus. This can - * happen because of embedding; for example, X can send an event to an - * embedded application when the real focus window is in the container - * application and is an ancestor of the container. This function's job - * is to forward the event back to the application where it really - * belongs. - * - * Results: - * None. - * - * Side effects: - * The event may get sent to a different application. - * - *---------------------------------------------------------------------- - */ - -void -TkpRedirectKeyEvent( - TkWindow *winPtr, /* Window to which the event was originally - * reported. */ - XEvent *eventPtr) /* X event to redirect (should be KeyPress or - * KeyRelease). */ -{ - Container *containerPtr; - Window saved; - ThreadSpecificData *tsdPtr = - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - - /* - * First, find the top-level window corresponding to winPtr. - */ - - while (1) { - if (winPtr == NULL) { - /* - * This window is being deleted. This is too confusing a case to - * handle so discard the event. - */ - - return; - } - if (winPtr->flags & TK_TOP_HIERARCHY) { - break; - } - winPtr = winPtr->parentPtr; - } - - if (winPtr->flags & TK_EMBEDDED) { - /* - * This application is embedded. If we got a key event without - * officially having the focus, it means that the focus is really in - * the container, but the mouse was over the embedded application. - * Send the event back to the container. - */ - - for (containerPtr = tsdPtr->firstContainerPtr; - containerPtr->embeddedPtr != winPtr; - containerPtr = containerPtr->nextPtr) { - /* Empty loop body. */ - } - saved = eventPtr->xkey.window; - eventPtr->xkey.window = containerPtr->parent; - XSendEvent(eventPtr->xkey.display, eventPtr->xkey.window, False, - KeyPressMask|KeyReleaseMask, eventPtr); - eventPtr->xkey.window = saved; - } -} - -/* - *---------------------------------------------------------------------- - * - * TkpClaimFocus -- - * - * This function is invoked when someone asks or the input focus to be - * put on a window in an embedded application, but the application - * doesn't currently have the focus. It requests the input focus from the - * container application. - * - * Results: - * None. - * - * Side effects: - * The input focus may change. - * - *---------------------------------------------------------------------- - */ - -void -TkpClaimFocus( - TkWindow *topLevelPtr, /* Top-level window containing desired focus - * window; should be embedded. */ - int force) /* One means that the container should claim - * the focus if it doesn't currently have - * it. */ -{ - XEvent event; - Container *containerPtr; - ThreadSpecificData *tsdPtr = - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - - if (!(topLevelPtr->flags & TK_EMBEDDED)) { - return; - } - - for (containerPtr = tsdPtr->firstContainerPtr; - containerPtr->embeddedPtr != topLevelPtr; - containerPtr = containerPtr->nextPtr) { - /* Empty loop body. */ - } - - event.xfocus.type = FocusIn; - event.xfocus.serial = LastKnownRequestProcessed(topLevelPtr->display); - event.xfocus.send_event = 1; - event.xfocus.display = topLevelPtr->display; - event.xfocus.window = containerPtr->parent; - event.xfocus.mode = EMBEDDED_APP_WANTS_FOCUS; - event.xfocus.detail = force; - XSendEvent(event.xfocus.display, event.xfocus.window, False, 0, &event); -} - -/* - *---------------------------------------------------------------------- - * - * TkpTestembedCmd -- - * - * This function implements the "testembed" command. It returns some or - * all of the information in the list pointed to by firstContainerPtr. - * - * Results: - * A standard Tcl result. - * - * Side effects: - * None. - * - *---------------------------------------------------------------------- - */ - -int -TkpTestembedCmd( - ClientData clientData, /* Main window for application. */ - Tcl_Interp *interp, /* Current interpreter. */ - int objc, /* Number of arguments. */ - Tcl_Obj *const objv[]) /* Argument strings. */ -{ - int all; - Container *containerPtr; - Tcl_DString dString; - char buffer[50]; - ThreadSpecificData *tsdPtr = - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - - if ((objc > 1) && (strcmp(Tcl_GetString(objv[1]), "all") == 0)) { - all = 1; - } else { - all = 0; - } - Tcl_DStringInit(&dString); - for (containerPtr = tsdPtr->firstContainerPtr; containerPtr != NULL; - containerPtr = containerPtr->nextPtr) { - Tcl_DStringStartSublist(&dString); - if (containerPtr->parent == None) { - Tcl_DStringAppendElement(&dString, ""); - } else if (all) { - sprintf(buffer, "0x%x", (int) containerPtr->parent); - Tcl_DStringAppendElement(&dString, buffer); - } else { - Tcl_DStringAppendElement(&dString, "XXX"); - } - if (containerPtr->parentPtr == NULL) { - Tcl_DStringAppendElement(&dString, ""); - } else { - Tcl_DStringAppendElement(&dString, - containerPtr->parentPtr->pathName); - } - if (containerPtr->wrapper == None) { - Tcl_DStringAppendElement(&dString, ""); - } else if (all) { - sprintf(buffer, "0x%x", (int) containerPtr->wrapper); - Tcl_DStringAppendElement(&dString, buffer); - } else { - Tcl_DStringAppendElement(&dString, "XXX"); - } - if (containerPtr->embeddedPtr == NULL) { - Tcl_DStringAppendElement(&dString, ""); - } else { - Tcl_DStringAppendElement(&dString, - containerPtr->embeddedPtr->pathName); - } - Tcl_DStringEndSublist(&dString); - } - Tcl_DStringResult(interp, &dString); - return TCL_OK; -} - -/* - *---------------------------------------------------------------------- - * - * EmbedWindowDeleted -- - * - * This function is invoked when a window involved in embedding (as - * either the container or the embedded application) is destroyed. It - * cleans up the Container structure for the window. - * - * Results: - * None. - * - * Side effects: - * A Container structure may be freed. - * - *---------------------------------------------------------------------- - */ - -static void -EmbedWindowDeleted( - TkWindow *winPtr) /* Tk's information about window that was - * deleted. */ -{ - Container *containerPtr, *prevPtr; - ThreadSpecificData *tsdPtr = - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - - /* - * Find the Container structure for this window work. Delete the - * information about the embedded application and free the container's - * record. - */ - - prevPtr = NULL; - containerPtr = tsdPtr->firstContainerPtr; - while (1) { - if (containerPtr->embeddedPtr == winPtr) { - containerPtr->wrapper = None; - containerPtr->embeddedPtr = NULL; - break; - } - if (containerPtr->parentPtr == winPtr) { - containerPtr->parentPtr = NULL; - break; - } - prevPtr = containerPtr; - containerPtr = containerPtr->nextPtr; - } - if ((containerPtr->embeddedPtr == NULL) - && (containerPtr->parentPtr == NULL)) { - if (prevPtr == NULL) { - tsdPtr->firstContainerPtr = containerPtr->nextPtr; - } else { - prevPtr->nextPtr = containerPtr->nextPtr; - } - ckfree(containerPtr); - } -} - -/* - *---------------------------------------------------------------------- - * - * TkUnixContainerId -- - * - * Given an embedded window, this function returns the X window - * identifier for the associated container window. - * - * Results: - * The return value is the X window identifier for winPtr's container - * window. - * - * Side effects: - * None. - * - *---------------------------------------------------------------------- - */ - -Window -TkUnixContainerId( - TkWindow *winPtr) /* Tk's structure for an embedded window. */ -{ - Container *containerPtr; - ThreadSpecificData *tsdPtr = - Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); - - for (containerPtr = tsdPtr->firstContainerPtr; - containerPtr != NULL; containerPtr = containerPtr->nextPtr) { - if (containerPtr->embeddedPtr == winPtr) { - return containerPtr->parent; - } - } - Tcl_Panic("TkUnixContainerId couldn't find window"); - return None; -} - -/* - *---------------------------------------------------------------------- - * - * TkpShowBusyWindow -- - * - * Makes a busy window "appear". - * - * Results: - * None. - * - * Side effects: - * Arranges for the busy window to start intercepting events and the - * cursor to change to the configured "hey, I'm busy!" setting. - * - *---------------------------------------------------------------------- - */ - -void -TkpShowBusyWindow( - TkBusy busy) -{ - Busy *busyPtr = (Busy *) busy; - - if (busyPtr->tkBusy != NULL) { - Tk_MapWindow(busyPtr->tkBusy); - - /* - * Always raise the busy window just in case new sibling windows have - * been created in the meantime. Can't use Tk_RestackWindow because it - * doesn't work under Win32. - */ - - XRaiseWindow(Tk_Display(busyPtr->tkBusy), - Tk_WindowId(busyPtr->tkBusy)); - } -} - -/* - *---------------------------------------------------------------------- - * - * TkpHideBusyWindow -- - * - * Makes a busy window "disappear". - * - * Results: - * None. - * - * Side effects: - * Arranges for the busy window to stop intercepting events, and the - * cursor to change back to its normal setting. - * - *---------------------------------------------------------------------- - */ - -void -TkpHideBusyWindow( - TkBusy busy) -{ - Busy *busyPtr = (Busy *) busy; - - if (busyPtr->tkBusy != NULL) { - Tk_UnmapWindow(busyPtr->tkBusy); - } -} - -/* - *---------------------------------------------------------------------- - * - * TkpMakeTransparentWindowExist -- - * - * Construct the platform-specific resources for a transparent window. - * - * Results: - * None. - * - * Side effects: - * Moves the specified window in the stacking order. - * - *---------------------------------------------------------------------- - */ - -void -TkpMakeTransparentWindowExist( - Tk_Window tkwin, /* Token for window. */ - Window parent) /* Parent window. */ -{ - TkWindow *winPtr = (TkWindow *) tkwin; - long int mask = CWDontPropagate | CWEventMask; - - /* - * Ignore the important events while the window is mapped. - */ - -#define USER_EVENTS \ - (EnterWindowMask | LeaveWindowMask | KeyPressMask | KeyReleaseMask | \ - ButtonPressMask | ButtonReleaseMask | PointerMotionMask) -#define PROP_EVENTS \ - (KeyPressMask | KeyReleaseMask | ButtonPressMask | \ - ButtonReleaseMask | PointerMotionMask) - - winPtr->atts.do_not_propagate_mask = PROP_EVENTS; - winPtr->atts.event_mask = USER_EVENTS; - winPtr->changes.border_width = 0; - winPtr->depth = 0; - - winPtr->window = XCreateWindow(winPtr->display, parent, - winPtr->changes.x, winPtr->changes.y, - (unsigned) winPtr->changes.width, /* width */ - (unsigned) winPtr->changes.height, /* height */ - (unsigned) winPtr->changes.border_width, /* border_width */ - winPtr->depth, InputOnly, winPtr->visual, mask, &winPtr->atts); -} - -/* - *---------------------------------------------------------------------- - * - * TkpCreateBusy -- - * - * Construct the platform-specific parts of a busy window. Note that this - * postpones the actual creation of the window resource until later. - * - * Results: - * None. - * - * Side effects: - * Sets up part of the busy window structure. - * - *---------------------------------------------------------------------- - */ - -void -TkpCreateBusy( - Tk_FakeWin *winPtr, - Tk_Window tkRef, - Window *parentPtr, - Tk_Window tkParent, - TkBusy busy) -{ - Window root, parent, *dummy; - unsigned int count; - - if (winPtr->flags & TK_REPARENTED) { - /* - * This works around a bug in the implementation of menubars for - * non-MacIntosh window systems (Win32 and X11). Tk doesn't reset the - * pointers to the parent window when the menu is reparented (since - * winPtr->parentPtr points to the wrong window). We get around this - * by determining the parent via the native API calls. - */ - - if (XQueryTree(Tk_Display(tkRef), Tk_WindowId(tkRef), &root, - &parent, &dummy, &count) > 0) { - XFree(dummy); - *parentPtr = parent; - } else { - *parentPtr = None; - } - } else { - *parentPtr = Tk_WindowId(tkParent); - } -} - -/* - * Local Variables: - * mode: c - * c-basic-offset: 4 - * fill-column: 78 - * End: - */ |