shared_source/c_tk_base_7_5_w_mods/tkwinembed.c

/* $Header$ */

/* 
 * tkWinEmbed.c --
 *
 *      This file contains platform specific procedures for Windows platforms
 *      to provide basic operations needed for application embedding (where
 *      one application can use as its main window an internal window from
 *      another application).
 *
 * 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.
 *
 * RCS: @(#) $Id: tkwinembed.c,v 1.1.1.1 2001/06/13 05:13:10 dtashley Exp $
 */

#include "tkWinInt.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 {
    HWND parentHWnd;                    /* Windows HWND to the parent window */
    TkWindow *parentPtr;                /* Tk's information about the container
                                         * or NULL if the container isn't
                                         * in this process. */
    HWND embeddedHWnd;                  /* Windows HWND to the embedded window
                                         */
    TkWindow *embeddedPtr;              /* Tk's information about the embedded
                                         * window, or NULL if the
                                         * embedded application isn't in
                                         * this process. */
    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;

static void             CleanupContainerList _ANSI_ARGS_((
                            ClientData clientData));
static void             ContainerEventProc _ANSI_ARGS_((ClientData clientData,
                            XEvent *eventPtr));
static void             EmbeddedEventProc _ANSI_ARGS_((
                            ClientData clientData, XEvent *eventPtr));
static void             EmbedGeometryRequest _ANSI_ARGS_((
                            Container*containerPtr, int width, int height));
static void             EmbedWindowDeleted _ANSI_ARGS_((TkWindow *winPtr));

/*
 *----------------------------------------------------------------------
 *
 * CleanupContainerList --
 *
 *      Finalizes the list of containers.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Releases memory occupied by containers of embedded windows.
 *
 *----------------------------------------------------------------------
 */

        /* ARGSUSED */
static void
CleanupContainerList(clientData)
    ClientData clientData;
{
    Container *nextPtr;
    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
    
    for (;
        tsdPtr->firstContainerPtr != (Container *) NULL;
        tsdPtr->firstContainerPtr = nextPtr) {
        nextPtr = tsdPtr->firstContainerPtr->nextPtr;
        ckfree((char *) tsdPtr->firstContainerPtr);
    }
    tsdPtr->firstContainerPtr = (Container *) NULL;
}

/*
 *----------------------------------------------------------------------
 *
 * TkpTestembedCmd --
 *
 *      Test command for the embedding facility.
 *
 * Results:
 *      Always returns TCL_OK.
 *
 * Side effects:
 *      Currently it does not do anything.
 *
 *----------------------------------------------------------------------
 */

        /* ARGSUSED */
int
TkpTestembedCmd(clientData, interp, argc, argv)
    ClientData clientData;
    Tcl_Interp *interp;
    int argc;
    char **argv;
{
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * TkpUseWindow --
 *
 *      This procedure causes a Tk window to use a given Windows handle
 *      for a window as its underlying window, rather than a new Windows
 *      window being created automatically. It is invoked by an embedded
 *      application to specify the window in which the application is
 *      embedded.
 *
 * Results:
 *      The return value is normally TCL_OK. If an error occurred (such as
 *      if the argument does not identify a legal Windows window handle),
 *      the return value is TCL_ERROR and an error message is left in the
 *      the interp's result if interp is not NULL.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

int 
TkpUseWindow(interp, tkwin, string)
    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. */
    char *string;               /* String identifying an X window to use
                                 * for tkwin;  must be an integer value. */
{
    TkWindow *winPtr = (TkWindow *) tkwin;
    int id;
    HWND hwnd;
    Container *containerPtr;
    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));

    if (winPtr->window != None) {
        panic("TkpUseWindow: Already assigned a window");
    }

    if (Tcl_GetInt(interp, string, &id) != TCL_OK) {
        return TCL_ERROR;
    }
    hwnd = (HWND) id;

    /*
     * Check if the window is a valid handle. If it is invalid, return
     * TCL_ERROR and potentially leave an error message in the interp's
     * result.
     */

    if (!IsWindow(hwnd)) {
        if (interp != (Tcl_Interp *) NULL) {
            Tcl_AppendResult(interp, "window \"", string,
                    "\" doesn't exist", (char *) NULL);
        }
        return TCL_ERROR;
    }

    /*
     * Store the parent window in the platform private data slot so
     * TkWmMapWindow can use it when creating the wrapper window.
     */

    winPtr->privatePtr = (struct TkWindowPrivate*) hwnd;

    /*
     * Create an event handler to clean up the Container structure when
     * tkwin is eventually deleted.
     */

    Tk_CreateEventHandler(tkwin, StructureNotifyMask, EmbeddedEventProc,
            (ClientData) winPtr);

    /*
     * If this is the first container, register an exit handler so that
     * things will get cleaned up at finalization.
     */

    if (tsdPtr->firstContainerPtr == (Container *) NULL) {
        Tcl_CreateExitHandler(CleanupContainerList, (ClientData) NULL);
    }
    
    /*
     * 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->parentHWnd == hwnd) {
            winPtr->flags |= TK_BOTH_HALVES;
            containerPtr->parentPtr->flags |= TK_BOTH_HALVES;
            break;
        }
    }
    if (containerPtr == NULL) {
        containerPtr = (Container *) ckalloc(sizeof(Container));
        containerPtr->parentPtr = NULL;
        containerPtr->parentHWnd = hwnd;
        containerPtr->nextPtr = tsdPtr->firstContainerPtr;
        tsdPtr->firstContainerPtr = containerPtr;
    }

    /*
     * embeddedHWnd is not created yet. It will be created by TkWmMapWindow(),
     * which will send a TK_ATTACHWINDOW to the container window.
     * TkWinEmbeddedEventProc will process this message and set the embeddedHWnd
     * variable
     */

    containerPtr->embeddedPtr = winPtr;
    containerPtr->embeddedHWnd = NULL;

    winPtr->flags |= TK_EMBEDDED;
    winPtr->flags &= (~(TK_MAPPED));

    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * TkpMakeContainer --
 *
 *      This procedure 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(tkwin)
    Tk_Window tkwin;
{
    TkWindow *winPtr = (TkWindow *) tkwin;
    Container *containerPtr;
    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));

    /*
     * If this is the first container, register an exit handler so that
     * things will get cleaned up at finalization.
     */

    if (tsdPtr->firstContainerPtr == (Container *) NULL) {
        Tcl_CreateExitHandler(CleanupContainerList, (ClientData) NULL);
    }
    
    /*
     * 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 = (Container *) ckalloc(sizeof(Container));
    containerPtr->parentPtr = winPtr;
    containerPtr->parentHWnd = Tk_GetHWND(Tk_WindowId(tkwin));
    containerPtr->embeddedHWnd = NULL;
    containerPtr->embeddedPtr = NULL;
    containerPtr->nextPtr = tsdPtr->firstContainerPtr;
    tsdPtr->firstContainerPtr = containerPtr;
    winPtr->flags |= TK_CONTAINER;

    /*
     * Unlike in tkUnixEmbed.c, we don't make any requests for events
     * in the embedded window here.  Now we just allow the embedding
     * of another TK application into TK windows. When the embedded
     * window makes a request, that will be done by sending to the
     * container window a WM_USER message, which will be intercepted
     * by TkWinContainerProc.
     *
     * We need to get structure events of the container itself, though.
     */

    Tk_CreateEventHandler(tkwin, StructureNotifyMask,
        ContainerEventProc, (ClientData) containerPtr);
}

/*
 *----------------------------------------------------------------------
 *
 * EmbeddedEventProc --
 *
 *      This procedure 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, eventPtr)
    ClientData clientData;              /* Token for container window. */
    XEvent *eventPtr;                   /* ResizeRequest event. */
{
    TkWindow *winPtr = (TkWindow *) clientData;

    if (eventPtr->type == DestroyNotify) {
        EmbedWindowDeleted(winPtr);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * TkWinEmbeddedEventProc --
 *
 *      This procedure 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.
 *
 *----------------------------------------------------------------------
 */

LRESULT
TkWinEmbeddedEventProc(hwnd, message, wParam, lParam)
    HWND hwnd;
    UINT message;
    WPARAM wParam;
    LPARAM lParam;
{
    Container *containerPtr;
    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));

    /*
     * Find the Container structure associated with the parent window.
     */

    for (containerPtr = tsdPtr->firstContainerPtr;
            containerPtr->parentHWnd != hwnd;
            containerPtr = containerPtr->nextPtr) {
        if (containerPtr == NULL) {
            panic("TkWinContainerProc couldn't find Container record");
        }
    }

    switch (message) {
      case TK_ATTACHWINDOW:
        /* An embedded window (either from this application or from
         * another application) is trying to attach to this container.
         * We attach it only if this container is not yet containing any
         * window.
         */
        if (containerPtr->embeddedHWnd == NULL) {
            containerPtr->embeddedHWnd = (HWND)wParam;
        } else {
            return 0;
        }

        break;
      case TK_GEOMETRYREQ:
        EmbedGeometryRequest(containerPtr, wParam, lParam);
        break;
    }
    return 1;
}

/*
 *----------------------------------------------------------------------
 *
 * EmbedGeometryRequest --
 *
 *      This procedure is invoked when an embedded application requests
 *      a particular size.  It processes the request (which may or may
 *      not actually resize the window) 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 that the size is the same
 *      as it used to be.  Events get processed while we're waiting for
 *      the geometry managers to do their thing.
 *
 *----------------------------------------------------------------------
 */

void
EmbedGeometryRequest(containerPtr, width, height)
    Container *containerPtr;    /* Information about the container window. */
    int width, 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 even if we decide not to resize
     * the window;  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);

    if (containerPtr->embeddedHWnd != NULL) {
        while (Tcl_DoOneEvent(TCL_IDLE_EVENTS)) {
            /* Empty loop body. */
        }

        SetWindowPos(containerPtr->embeddedHWnd, NULL,
            0, 0, winPtr->changes.width, winPtr->changes.height, SWP_NOZORDER);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * ContainerEventProc --
 *
 *      This procedure is invoked by the Tk event dispatcher when
 *      various useful events are received for the container window.
 *
 * 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, eventPtr)
    ClientData clientData;              /* Token for container window. */
    XEvent *eventPtr;                   /* ResizeRequest event. */
{
    Container *containerPtr = (Container *)clientData;
    Tk_Window tkwin = (Tk_Window)containerPtr->parentPtr;

    if (eventPtr->type == ConfigureNotify) {
        if (containerPtr->embeddedPtr == NULL) {
            return;
        }
        /* Resize the embedded window, if there is any */
        if (containerPtr->embeddedHWnd) {
            SetWindowPos(containerPtr->embeddedHWnd, NULL,
                0, 0, Tk_Width(tkwin), Tk_Height(tkwin), SWP_NOZORDER);
        }
    } else if (eventPtr->type == DestroyNotify) {
        /* The container is gone, remove it from the list */
        EmbedWindowDeleted(containerPtr->parentPtr);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * TkpGetOtherWindow --
 *
 *      If both the container and embedded window are in the same
 *      process, this procedure 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(winPtr)
    TkWindow *winPtr;           /* Tk's structure for a container or
                                 * embedded window. */
{
    Container *containerPtr;
    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
            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;
        }
    }
    panic("TkpGetOtherWindow couldn't find window");
    return NULL;
}

/*
 *----------------------------------------------------------------------
 *
 * TkpClaimFocus --
 *
 *      This procedure 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(topLevelPtr, force)
    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. */
{
    HWND hwnd = GetParent(Tk_GetHWND(topLevelPtr->window));
    SendMessage(hwnd, TK_CLAIMFOCUS, (WPARAM) force, 0);
}

/*
 *----------------------------------------------------------------------
 *
 * TkpRedirectKeyEvent --
 *
 *      This procedure 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 procedure'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(winPtr, eventPtr)
    TkWindow *winPtr;           /* Window to which the event was originally
                                 * reported. */
    XEvent *eventPtr;           /* X event to redirect (should be KeyPress
                                 * or KeyRelease). */
{
    /* not implemented */
}

/*
 *----------------------------------------------------------------------
 *
 * EmbedWindowDeleted --
 *
 *      This procedure 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(winPtr)
    TkWindow *winPtr;           /* Tk's information about window that
                                 * was deleted. */
{
    Container *containerPtr, *prevPtr;
    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
            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->embeddedHWnd = NULL;
            containerPtr->embeddedPtr = NULL;
            break;
        }
        if (containerPtr->parentPtr == winPtr) {
            containerPtr->parentPtr = NULL;
            break;
        }
        prevPtr = containerPtr;
        containerPtr = containerPtr->nextPtr;
        if (containerPtr == NULL) {
            panic("EmbedWindowDeleted couldn't find window");
        }
    }
    if ((containerPtr->embeddedPtr == NULL)
            && (containerPtr->parentPtr == NULL)) {
        if (prevPtr == NULL) {
            tsdPtr->firstContainerPtr = containerPtr->nextPtr;
        } else {
            prevPtr->nextPtr = containerPtr->nextPtr;
        }
        ckfree((char *) containerPtr);
    }
}

/* End of tkwinembed.c */
1	/* $Header$ */
2
3	/*
4	* tkWinEmbed.c --
5	*
6	* This file contains platform specific procedures for Windows platforms
7	* to provide basic operations needed for application embedding (where
8	* one application can use as its main window an internal window from
9	* another application).
10	*
11	* Copyright (c) 1996-1997 Sun Microsystems, Inc.
12	*
13	* See the file "license.terms" for information on usage and redistribution
14	* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
15	*
16	* RCS: @(#) $Id: tkwinembed.c,v 1.1.1.1 2001/06/13 05:13:10 dtashley Exp $
17	*/
18
19	#include "tkWinInt.h"
20
21
22	/*
23	* One of the following structures exists for each container in this
24	* application. It keeps track of the container window and its
25	* associated embedded window.
26	*/
27
28	typedef struct Container {
29	HWND parentHWnd; /* Windows HWND to the parent window */
30	TkWindow parentPtr; / Tk's information about the container
31	* or NULL if the container isn't
32	* in this process. */
33	HWND embeddedHWnd; /* Windows HWND to the embedded window
34	*/
35	TkWindow embeddedPtr; / Tk's information about the embedded
36	* window, or NULL if the
37	* embedded application isn't in
38	* this process. */
39	struct Container nextPtr; / Next in list of all containers in
40	* this process. */
41	} Container;
42
43	typedef struct ThreadSpecificData {
44	Container firstContainerPtr; / First in list of all containers
45	* managed by this process. */
46	} ThreadSpecificData;
47	static Tcl_ThreadDataKey dataKey;
48
49	static void CleanupContainerList _ANSI_ARGS_((
50	ClientData clientData));
51	static void ContainerEventProc _ANSI_ARGS_((ClientData clientData,
52	XEvent *eventPtr));
53	static void EmbeddedEventProc _ANSI_ARGS_((
54	ClientData clientData, XEvent *eventPtr));
55	static void EmbedGeometryRequest _ANSI_ARGS_((
56	Container*containerPtr, int width, int height));
57	static void EmbedWindowDeleted _ANSI_ARGS_((TkWindow *winPtr));
58
59	/*
60	*----------------------------------------------------------------------
61	*
62	* CleanupContainerList --
63	*
64	* Finalizes the list of containers.
65	*
66	* Results:
67	* None.
68	*
69	* Side effects:
70	* Releases memory occupied by containers of embedded windows.
71	*
72	*----------------------------------------------------------------------
73	*/
74
75	/* ARGSUSED */
76	static void
77	CleanupContainerList(clientData)
78	ClientData clientData;
79	{
80	Container *nextPtr;
81	ThreadSpecificData tsdPtr = (ThreadSpecificData )
82	Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
83
84	for (;
85	tsdPtr->firstContainerPtr != (Container *) NULL;
86	tsdPtr->firstContainerPtr = nextPtr) {
87	nextPtr = tsdPtr->firstContainerPtr->nextPtr;
88	ckfree((char *) tsdPtr->firstContainerPtr);
89	}
90	tsdPtr->firstContainerPtr = (Container *) NULL;
91	}
92
93	/*
94	*----------------------------------------------------------------------
95	*
96	* TkpTestembedCmd --
97	*
98	* Test command for the embedding facility.
99	*
100	* Results:
101	* Always returns TCL_OK.
102	*
103	* Side effects:
104	* Currently it does not do anything.
105	*
106	*----------------------------------------------------------------------
107	*/
108
109	/* ARGSUSED */
110	int
111	TkpTestembedCmd(clientData, interp, argc, argv)
112	ClientData clientData;
113	Tcl_Interp *interp;
114	int argc;
115	char **argv;
116	{
117	return TCL_OK;
118	}
119
120	/*
121	*----------------------------------------------------------------------
122	*
123	* TkpUseWindow --
124	*
125	* This procedure causes a Tk window to use a given Windows handle
126	* for a window as its underlying window, rather than a new Windows
127	* window being created automatically. It is invoked by an embedded
128	* application to specify the window in which the application is
129	* embedded.
130	*
131	* Results:
132	* The return value is normally TCL_OK. If an error occurred (such as
133	* if the argument does not identify a legal Windows window handle),
134	* the return value is TCL_ERROR and an error message is left in the
135	* the interp's result if interp is not NULL.
136	*
137	* Side effects:
138	* None.
139	*
140	*----------------------------------------------------------------------
141	*/
142
143	int
144	TkpUseWindow(interp, tkwin, string)
145	Tcl_Interp interp; / If not NULL, used for error reporting
146	* if string is bogus. */
147	Tk_Window tkwin; /* Tk window that does not yet have an
148	* associated X window. */
149	char string; / String identifying an X window to use
150	* for tkwin; must be an integer value. */
151	{
152	TkWindow winPtr = (TkWindow ) tkwin;
153	int id;
154	HWND hwnd;
155	Container *containerPtr;
156	ThreadSpecificData tsdPtr = (ThreadSpecificData )
157	Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
158
159	if (winPtr->window != None) {
160	panic("TkpUseWindow: Already assigned a window");
161	}
162
163	if (Tcl_GetInt(interp, string, &id) != TCL_OK) {
164	return TCL_ERROR;
165	}
166	hwnd = (HWND) id;
167
168	/*
169	* Check if the window is a valid handle. If it is invalid, return
170	* TCL_ERROR and potentially leave an error message in the interp's
171	* result.
172	*/
173
174	if (!IsWindow(hwnd)) {
175	if (interp != (Tcl_Interp *) NULL) {
176	Tcl_AppendResult(interp, "window \"", string,
177	"\" doesn't exist", (char *) NULL);
178	}
179	return TCL_ERROR;
180	}
181
182	/*
183	* Store the parent window in the platform private data slot so
184	* TkWmMapWindow can use it when creating the wrapper window.
185	*/
186
187	winPtr->privatePtr = (struct TkWindowPrivate*) hwnd;
188
189	/*
190	* Create an event handler to clean up the Container structure when
191	* tkwin is eventually deleted.
192	*/
193
194	Tk_CreateEventHandler(tkwin, StructureNotifyMask, EmbeddedEventProc,
195	(ClientData) winPtr);
196
197	/*
198	* If this is the first container, register an exit handler so that
199	* things will get cleaned up at finalization.
200	*/
201
202	if (tsdPtr->firstContainerPtr == (Container *) NULL) {
203	Tcl_CreateExitHandler(CleanupContainerList, (ClientData) NULL);
204	}
205
206	/*
207	* Save information about the container and the embedded window
208	* in a Container structure. If there is already an existing
209	* Container structure, it means that both container and embedded
210	* app. are in the same process.
211	*/
212
213	for (containerPtr = tsdPtr->firstContainerPtr;
214	containerPtr != NULL; containerPtr = containerPtr->nextPtr) {
215	if (containerPtr->parentHWnd == hwnd) {
216	winPtr->flags \|= TK_BOTH_HALVES;
217	containerPtr->parentPtr->flags \|= TK_BOTH_HALVES;
218	break;
219	}
220	}
221	if (containerPtr == NULL) {
222	containerPtr = (Container *) ckalloc(sizeof(Container));
223	containerPtr->parentPtr = NULL;
224	containerPtr->parentHWnd = hwnd;
225	containerPtr->nextPtr = tsdPtr->firstContainerPtr;
226	tsdPtr->firstContainerPtr = containerPtr;
227	}
228
229	/*
230	* embeddedHWnd is not created yet. It will be created by TkWmMapWindow(),
231	* which will send a TK_ATTACHWINDOW to the container window.
232	* TkWinEmbeddedEventProc will process this message and set the embeddedHWnd
233	* variable
234	*/
235
236	containerPtr->embeddedPtr = winPtr;
237	containerPtr->embeddedHWnd = NULL;
238
239	winPtr->flags \|= TK_EMBEDDED;
240	winPtr->flags &= (~(TK_MAPPED));
241
242	return TCL_OK;
243	}
244
245	/*
246	*----------------------------------------------------------------------
247	*
248	* TkpMakeContainer --
249	*
250	* This procedure is called to indicate that a particular window will
251	* be a container for an embedded application. This changes certain
252	* aspects of the window's behavior, such as whether it will receive
253	* events anymore.
254	*
255	* Results:
256	* None.
257	*
258	* Side effects:
259	* None.
260	*
261	*----------------------------------------------------------------------
262	*/
263
264	void
265	TkpMakeContainer(tkwin)
266	Tk_Window tkwin;
267	{
268	TkWindow winPtr = (TkWindow ) tkwin;
269	Container *containerPtr;
270	ThreadSpecificData tsdPtr = (ThreadSpecificData )
271	Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
272
273	/*
274	* If this is the first container, register an exit handler so that
275	* things will get cleaned up at finalization.
276	*/
277
278	if (tsdPtr->firstContainerPtr == (Container *) NULL) {
279	Tcl_CreateExitHandler(CleanupContainerList, (ClientData) NULL);
280	}
281
282	/*
283	* Register the window as a container so that, for example, we can
284	* find out later if the embedded app. is in the same process.
285	*/
286
287	Tk_MakeWindowExist(tkwin);
288	containerPtr = (Container *) ckalloc(sizeof(Container));
289	containerPtr->parentPtr = winPtr;
290	containerPtr->parentHWnd = Tk_GetHWND(Tk_WindowId(tkwin));
291	containerPtr->embeddedHWnd = NULL;
292	containerPtr->embeddedPtr = NULL;
293	containerPtr->nextPtr = tsdPtr->firstContainerPtr;
294	tsdPtr->firstContainerPtr = containerPtr;
295	winPtr->flags \|= TK_CONTAINER;
296
297	/*
298	* Unlike in tkUnixEmbed.c, we don't make any requests for events
299	* in the embedded window here. Now we just allow the embedding
300	* of another TK application into TK windows. When the embedded
301	* window makes a request, that will be done by sending to the
302	* container window a WM_USER message, which will be intercepted
303	* by TkWinContainerProc.
304	*
305	* We need to get structure events of the container itself, though.
306	*/
307
308	Tk_CreateEventHandler(tkwin, StructureNotifyMask,
309	ContainerEventProc, (ClientData) containerPtr);
310	}
311
312	/*
313	*----------------------------------------------------------------------
314	*
315	* EmbeddedEventProc --
316	*
317	* This procedure is invoked by the Tk event dispatcher when various
318	* useful events are received for a window that is embedded in
319	* another application.
320	*
321	* Results:
322	* None.
323	*
324	* Side effects:
325	* Our internal state gets cleaned up when an embedded window is
326	* destroyed.
327	*
328	*----------------------------------------------------------------------
329	*/
330
331	static void
332	EmbeddedEventProc(clientData, eventPtr)
333	ClientData clientData; /* Token for container window. */
334	XEvent eventPtr; / ResizeRequest event. */
335	{
336	TkWindow winPtr = (TkWindow ) clientData;
337
338	if (eventPtr->type == DestroyNotify) {
339	EmbedWindowDeleted(winPtr);
340	}
341	}
342
343	/*
344	*----------------------------------------------------------------------
345	*
346	* TkWinEmbeddedEventProc --
347	*
348	* This procedure is invoked by the Tk event dispatcher when
349	* various useful events are received for the children of a
350	* container window. It forwards relevant information, such as
351	* geometry requests, from the events into the container's
352	* application.
353	*
354	* Results:
355	* None.
356	*
357	* Side effects:
358	* Depends on the event. For example, when ConfigureRequest events
359	* occur, geometry information gets set for the container window.
360	*
361	*----------------------------------------------------------------------
362	*/
363
364	LRESULT
365	TkWinEmbeddedEventProc(hwnd, message, wParam, lParam)
366	HWND hwnd;
367	UINT message;
368	WPARAM wParam;
369	LPARAM lParam;
370	{
371	Container *containerPtr;
372	ThreadSpecificData tsdPtr = (ThreadSpecificData )
373	Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
374
375	/*
376	* Find the Container structure associated with the parent window.
377	*/
378
379	for (containerPtr = tsdPtr->firstContainerPtr;
380	containerPtr->parentHWnd != hwnd;
381	containerPtr = containerPtr->nextPtr) {
382	if (containerPtr == NULL) {
383	panic("TkWinContainerProc couldn't find Container record");
384	}
385	}
386
387	switch (message) {
388	case TK_ATTACHWINDOW:
389	/* An embedded window (either from this application or from
390	* another application) is trying to attach to this container.
391	* We attach it only if this container is not yet containing any
392	* window.
393	*/
394	if (containerPtr->embeddedHWnd == NULL) {
395	containerPtr->embeddedHWnd = (HWND)wParam;
396	} else {
397	return 0;
398	}
399
400	break;
401	case TK_GEOMETRYREQ:
402	EmbedGeometryRequest(containerPtr, wParam, lParam);
403	break;
404	}
405	return 1;
406	}
407
408	/*
409	*----------------------------------------------------------------------
410	*
411	* EmbedGeometryRequest --
412	*
413	* This procedure is invoked when an embedded application requests
414	* a particular size. It processes the request (which may or may
415	* not actually resize the window) and reflects the results back
416	* to the embedded application.
417	*
418	* Results:
419	* None.
420	*
421	* Side effects:
422	* If we deny the child's size change request, a Configure event
423	* is synthesized to let the child know that the size is the same
424	* as it used to be. Events get processed while we're waiting for
425	* the geometry managers to do their thing.
426	*
427	*----------------------------------------------------------------------
428	*/
429
430	void
431	EmbedGeometryRequest(containerPtr, width, height)
432	Container containerPtr; / Information about the container window. */
433	int width, height; /* Size that the child has requested. */
434	{
435	TkWindow * winPtr = containerPtr->parentPtr;
436
437	/*
438	* Forward the requested size into our geometry management hierarchy
439	* via the container window. We need to send a Configure event back
440	* to the embedded application even if we decide not to resize
441	* the window; to make this happen, process all idle event handlers
442	* synchronously here (so that the geometry managers have had a
443	* chance to do whatever they want to do), and if the window's size
444	* didn't change then generate a configure event.
445	*/
446	Tk_GeometryRequest((Tk_Window)winPtr, width, height);
447
448	if (containerPtr->embeddedHWnd != NULL) {
449	while (Tcl_DoOneEvent(TCL_IDLE_EVENTS)) {
450	/* Empty loop body. */
451	}
452
453	SetWindowPos(containerPtr->embeddedHWnd, NULL,
454	0, 0, winPtr->changes.width, winPtr->changes.height, SWP_NOZORDER);
455	}
456	}
457
458	/*
459	*----------------------------------------------------------------------
460	*
461	* ContainerEventProc --
462	*
463	* This procedure is invoked by the Tk event dispatcher when
464	* various useful events are received for the container window.
465	*
466	* Results:
467	* None.
468	*
469	* Side effects:
470	* Depends on the event. For example, when ConfigureRequest events
471	* occur, geometry information gets set for the container window.
472	*
473	*----------------------------------------------------------------------
474	*/
475
476	static void
477	ContainerEventProc(clientData, eventPtr)
478	ClientData clientData; /* Token for container window. */
479	XEvent eventPtr; / ResizeRequest event. */
480	{
481	Container containerPtr = (Container )clientData;
482	Tk_Window tkwin = (Tk_Window)containerPtr->parentPtr;
483
484	if (eventPtr->type == ConfigureNotify) {
485	if (containerPtr->embeddedPtr == NULL) {
486	return;
487	}
488	/* Resize the embedded window, if there is any */
489	if (containerPtr->embeddedHWnd) {
490	SetWindowPos(containerPtr->embeddedHWnd, NULL,
491	0, 0, Tk_Width(tkwin), Tk_Height(tkwin), SWP_NOZORDER);
492	}
493	} else if (eventPtr->type == DestroyNotify) {
494	/* The container is gone, remove it from the list */
495	EmbedWindowDeleted(containerPtr->parentPtr);
496	}
497	}
498
499	/*
500	*----------------------------------------------------------------------
501	*
502	* TkpGetOtherWindow --
503	*
504	* If both the container and embedded window are in the same
505	* process, this procedure will return either one, given the other.
506	*
507	* Results:
508	* If winPtr is a container, the return value is the token for the
509	* embedded window, and vice versa. If the "other" window isn't in
510	* this process, NULL is returned.
511	*
512	* Side effects:
513	* None.
514	*
515	*----------------------------------------------------------------------
516	*/
517
518	TkWindow *
519	TkpGetOtherWindow(winPtr)
520	TkWindow winPtr; / Tk's structure for a container or
521	* embedded window. */
522	{
523	Container *containerPtr;
524	ThreadSpecificData tsdPtr = (ThreadSpecificData )
525	Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
526
527	for (containerPtr = tsdPtr->firstContainerPtr; containerPtr != NULL;
528	containerPtr = containerPtr->nextPtr) {
529	if (containerPtr->embeddedPtr == winPtr) {
530	return containerPtr->parentPtr;
531	} else if (containerPtr->parentPtr == winPtr) {
532	return containerPtr->embeddedPtr;
533	}
534	}
535	panic("TkpGetOtherWindow couldn't find window");
536	return NULL;
537	}
538
539	/*
540	*----------------------------------------------------------------------
541	*
542	* TkpClaimFocus --
543	*
544	* This procedure is invoked when someone asks or the input focus
545	* to be put on a window in an embedded application, but the
546	* application doesn't currently have the focus. It requests the
547	* input focus from the container application.
548	*
549	* Results:
550	* None.
551	*
552	* Side effects:
553	* The input focus may change.
554	*
555	*----------------------------------------------------------------------
556	*/
557
558	void
559	TkpClaimFocus(topLevelPtr, force)
560	TkWindow topLevelPtr; / Top-level window containing desired
561	* focus window; should be embedded. */
562	int force; /* One means that the container should
563	* claim the focus if it doesn't
564	* currently have it. */
565	{
566	HWND hwnd = GetParent(Tk_GetHWND(topLevelPtr->window));
567	SendMessage(hwnd, TK_CLAIMFOCUS, (WPARAM) force, 0);
568	}
569
570	/*
571	*----------------------------------------------------------------------
572	*
573	* TkpRedirectKeyEvent --
574	*
575	* This procedure is invoked when a key press or release event
576	* arrives for an application that does not believe it owns the
577	* input focus. This can happen because of embedding; for example,
578	* X can send an event to an embedded application when the real
579	* focus window is in the container application and is an ancestor
580	* of the container. This procedure's job is to forward the event
581	* back to the application where it really belongs.
582	*
583	* Results:
584	* None.
585	*
586	* Side effects:
587	* The event may get sent to a different application.
588	*
589	*----------------------------------------------------------------------
590	*/
591
592	void
593	TkpRedirectKeyEvent(winPtr, eventPtr)
594	TkWindow winPtr; / Window to which the event was originally
595	* reported. */
596	XEvent eventPtr; / X event to redirect (should be KeyPress
597	* or KeyRelease). */
598	{
599	/* not implemented */
600	}
601
602	/*
603	*----------------------------------------------------------------------
604	*
605	* EmbedWindowDeleted --
606	*
607	* This procedure is invoked when a window involved in embedding
608	* (as either the container or the embedded application) is
609	* destroyed. It cleans up the Container structure for the window.
610	*
611	* Results:
612	* None.
613	*
614	* Side effects:
615	* A Container structure may be freed.
616	*
617	*----------------------------------------------------------------------
618	*/
619
620	static void
621	EmbedWindowDeleted(winPtr)
622	TkWindow winPtr; / Tk's information about window that
623	* was deleted. */
624	{
625	Container containerPtr, prevPtr;
626	ThreadSpecificData tsdPtr = (ThreadSpecificData )
627	Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
628
629	/*
630	* Find the Container structure for this window work. Delete the
631	* information about the embedded application and free the container's
632	* record.
633	*/
634
635	prevPtr = NULL;
636	containerPtr = tsdPtr->firstContainerPtr;
637	while (1) {
638	if (containerPtr->embeddedPtr == winPtr) {
639	containerPtr->embeddedHWnd = NULL;
640	containerPtr->embeddedPtr = NULL;
641	break;
642	}
643	if (containerPtr->parentPtr == winPtr) {
644	containerPtr->parentPtr = NULL;
645	break;
646	}
647	prevPtr = containerPtr;
648	containerPtr = containerPtr->nextPtr;
649	if (containerPtr == NULL) {
650	panic("EmbedWindowDeleted couldn't find window");
651	}
652	}
653	if ((containerPtr->embeddedPtr == NULL)
654	&& (containerPtr->parentPtr == NULL)) {
655	if (prevPtr == NULL) {
656	tsdPtr->firstContainerPtr = containerPtr->nextPtr;
657	} else {
658	prevPtr->nextPtr = containerPtr->nextPtr;
659	}
660	ckfree((char *) containerPtr);
661	}
662	}
663
664	/* End of tkwinembed.c */