tkWinEmbed.c
上传用户:rrhhcc
上传日期:2015-12-11
资源大小:54129k
文件大小:20k
源码类别:

通讯编程

开发平台:

Visual C++

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