*** macosx-8-4-branch merged into the mainline [tcl patch #602770] ***macosx_8_4_merge_2002_08_31_trunk

	* generic/tk.decls:
	* generic/tkInt.decls: added new "aqua" specific entries to the
	stubs tables. Changed all "unix" entries to "x11" to allow us to
	distinguish and build both "aqua" on MacOSX and "x11" on MacOSX.

	* generic/tk.h: added a #ifnded RESOURCE_INCLUDED so that tk.h can
	be passed to the resource compiler.

	* generic/tkCmds.c (Tk_TkObjCmd): added [tk windowingsystem]
	subcommand: returns "x11" when running on X11, "win32" on Windows,
	"classic" on MacOS9 and "aqua" on MacOSX Aqua (i.e. Carbon)

	* generic/tkFont.c (TkFontGetFirstTextLayout): new private function
	returning the first chunk of a Tk_TextLayout, i.e. until the first
	font change on the first line (or the whole first line if there is
	no such font change).

	* generic/tkMain.c: made Tcl_ThreadDataKey static

	* library/demos/puzzle.tcl: fixed button metrics for aqua

	* tests/cursor.test: check for presence of arrow cursor instead of
	heart cursor

	* xlib/xcolors.c: changed xColors static initialization to more
	standard C

	* macosx/Wish.pbproj/jingham.pbxuser (new):
	* macosx/Wish.pbproj/project.pbxproj (new): project for Apple's
	ProjectBuilder IDE.

	* macosx/Makefile (new): simple makefile for building the project
	from the command line via the ProjectBuilder tool 'pbxbuild'.

	* macosx/tkMacOSXAppInit.c (new): macosx specific AppInit looking
	for a AppMain.tcl file in its bundled Resources/Scripts folder. If
	present, argv[1] is set to that file and the Scripts folder is
	added to the auto_path. This allows tk apps to embed scripts within
	their bundle directory structure.

	* macosx/tkMacOSXInit.c (new): macosx adapted version of
	tkUnixInit.c: we initialize & cache the Carbon native encoding
	(e.g. 'macRoman') and try to find the tk script library files
	inside Tk packaged as a framework.

	* macosx/tkMacOSXNotify.c (new): new macosx specific merged
	Carbon/select-based notifier.

	* macosx/tkMacOSXEvent.c (new):
	* macosx/tkMacOSXEvent.h (new):
	* macosx/tkMacOSXKeyEvent.c (new):
	* macosx/tkMacOSXMouseEvent.c (new):
	* macosx/tkMacOSXWindowEvent.c (new): new macosx specific event
	handling functionality.

	* macosx/tkMacOSX.h (new):
	* macosx/tkMacOSXBitmap.c (new):
	* macosx/tkMacOSXButton.c (new):
	* macosx/tkMacOSXClipboard.c (new):
	* macosx/tkMacOSXColor.c (new):
	* macosx/tkMacOSXConfig.c (new):
	* macosx/tkMacOSXCursor.c (new):
	* macosx/tkMacOSXDefault.h (new):
	* macosx/tkMacOSXDialog.c (new):
	* macosx/tkMacOSXDraw.c (new):
	* macosx/tkMacOSXEmbed.c (new):
	* macosx/tkMacOSXFont.c (new):
	* macosx/tkMacOSXHLEvents.c (new):
	* macosx/tkMacOSXInt.h (new):
	* macosx/tkMacOSXKeyboard.c (new):
	* macosx/tkMacOSXMenu.c (new):
	* macosx/tkMacOSXMenubutton.c (new):
	* macosx/tkMacOSXMenus.c (new):
	* macosx/tkMacOSXPort.h (new):
	* macosx/tkMacOSXRegion.c (new):
	* macosx/tkMacOSXScale.c (new):
	* macosx/tkMacOSXScrlbr.c (new):
	* macosx/tkMacOSXSubwindows.c (new):
	* macosx/tkMacOSXTest.c (new):
	* macosx/tkMacOSXUtil.c (new):
	* macosx/tkMacOSXUtil.h (new):
	* macosx/tkMacOSXWm.c (new):
	* macosx/tkMacOSXWm.h (new):
	* macosx/tkMacOSXXStubs.c (new): macosx ports of classic mac Tk
	implementation in tk/mac.

	* macosx/tkMacOSXSend.c (new): only send to local interp
	implemented currently.

	* macosx/tkMacOSXDebug.h (new):
	* macosx/tkMacOSXDebug.c (new): new macosx specific functions for
	debugging MacOS events, regions, etc.

	* macosx/tkAboutDlg.r (new):
	* macosx/tkMacOSXApplication.r (new):
	* macosx/tkMacOSXCursors.r (new):
	* macosx/tkMacOSXLibrary.r (new):
	* macosx/tkMacOSXMenu.r (new):
	* macosx/tkMacOSXResource.r (new):
	* macosx/tkMacOSXXCursors.r (new):
	* macosx/tclets.r (new): sources for Rez resource compiler.

	* macosx/Wish.icns (new): Wish application icon.

	* generic/tk.h:
	* generic/default.h:
	* generic/tkBind.c:
	* generic/tkCmds.c:
	* generic/tkGrab.c:
	* generic/tkPointer.c:
	* generic/tkPort.h:
	* generic/tkSelect.c:
	* generic/tkStubLib.c:
	* generic/tkTest.c:
	* generic/tkText.c:
	* generic/tkWindow.c:
	* unix/tkUnix3d.c:
	* xlib/xgc.c:
	* xlib/X11/X.h:
	* xlib/X11/Xlib.h:
	* xlib/X11/Xutil.h: added #includes and #ifdefs for macosx

	* library/bgerror.tcl:
	* library/button.tcl:
	* library/console.tcl:
	* library/dialog.tcl:
	* library/entry.tcl:
	* library/listbox.tcl:
	* library/menu.tcl:
	* library/msgbox.tcl:
	* library/scrlbar.tcl:
	* library/spinbox.tcl:
	* library/text.tcl:
	* library/tk.tcl:
	* library/demos/menu.tcl:
	* library/demos/menubu.tcl:
	* library/demos/widget: check [tk windowingsystem] instead of
	and/or in addition to $tcl_platform(platform).

	* generic/tkInt.h:
	* mac/tkMacBitmap.c:
	* mac/tkMacWm.c: added missing CONSTification

	* generic/tkIntDecls.h:
	* generic/tkIntPlatDecls.h:
	* generic/tkIntXlibDecls.h:
	* generic/tkPlatDecls.h:
	* generic/tkStubInit.c: regen

1 files changed, 1193 insertions, 0 deletions

diff --git a/macosx/tkMacOSXEmbed.c b/macosx/tkMacOSXEmbed.c
new file mode 100644
index 0000000..3405014
--- /dev/null
+++ b/macosx/tkMacOSXEmbed.c
@@ -0,0 +1,1193 @@
+/* 
+ * tkMacOSXEmbed.c --
+ *
+ *        This file contains platform-specific procedures for theMac to provide
+ *        basic operations needed for application embedding (where one
+ *        application can use as its main window an internal window from
+ *        some other application).
+ *        Currently only Toplevel embedding within the same Tk application is
+ *      allowed on the Macintosh.
+ *
+ * Copyright (c) 1996-1997 Sun Microsystems, Inc.
+ * Copyright 2001, Apple Computer, Inc.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ *  RCS: @(#) $Id: tkMacOSXEmbed.c,v 1.2 2002/08/31 06:12:29 das Exp $
+ */
+
+#include "tkInt.h"
+#include "tkPort.h"
+#include "X11/X.h"
+#include "X11/Xlib.h"
+#include <stdio.h>
+
+#include <Carbon/Carbon.h>
+#include "tkMacOSXInt.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;                /* The Mac Drawable for the parent of
+                                 * the pair (the container). */
+    TkWindow *parentPtr;        /* Tk's information about the container,
+                                 * or NULL if the container isn't
+                                 * in this process. */
+    Window embedded;                /* The MacDrawable 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. */
+    struct Container *nextPtr;        /* Next in list of all containers in
+                                 * this process. */
+} Container;
+
+static Container *firstContainerPtr = NULL;
+                                        /* First in list of all containers
+                                         * managed by this process.  */
+/*
+ * Globals defined in this file
+ */
+
+TkMacOSXEmbedHandler *gMacEmbedHandler = NULL;
+
+/*
+ * Prototypes for static procedures defined in this file:
+ */
+
+static void                ContainerEventProc _ANSI_ARGS_((
+                            ClientData clientData, XEvent *eventPtr));
+static void                EmbeddedEventProc _ANSI_ARGS_((
+                            ClientData clientData, XEvent *eventPtr));
+static void                EmbedActivateProc _ANSI_ARGS_((ClientData clientData, 
+                            XEvent *eventPtr));
+static void                EmbedFocusProc _ANSI_ARGS_((ClientData clientData,
+                            XEvent *eventPtr));
+static void                EmbedGeometryRequest _ANSI_ARGS_((
+                            Container * containerPtr, int width, int height));
+static void                EmbedSendConfigure _ANSI_ARGS_((
+                            Container *containerPtr));
+static void                EmbedStructureProc _ANSI_ARGS_((ClientData clientData,
+                            XEvent *eventPtr));
+static void                EmbedWindowDeleted _ANSI_ARGS_((TkWindow *winPtr));
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tk_MacOSXSetEmbedHandler --
+ *
+ *        Registers a handler for an in process form of embedding, like 
+ *        Netscape plugins, where Tk is loaded into the process, but does
+ *        not control the main window
+ *
+ * Results:
+ *        None
+ *
+ * Side effects:
+ *        The embed handler is set.
+ *
+ *----------------------------------------------------------------------
+ */
+void
+Tk_MacOSXSetEmbedHandler(
+    Tk_MacOSXEmbedRegisterWinProc *registerWinProc,
+    Tk_MacOSXEmbedGetGrafPortProc *getPortProc,
+    Tk_MacOSXEmbedMakeContainerExistProc *containerExistProc,
+    Tk_MacOSXEmbedGetClipProc *getClipProc,
+    Tk_MacOSXEmbedGetOffsetInParentProc *getOffsetProc)
+{
+    if (gMacEmbedHandler == NULL) {
+            gMacEmbedHandler = (TkMacOSXEmbedHandler *) ckalloc(sizeof(TkMacOSXEmbedHandler));
+    }
+    gMacEmbedHandler->registerWinProc = registerWinProc;
+    gMacEmbedHandler->getPortProc = getPortProc;
+    gMacEmbedHandler->containerExistProc = containerExistProc;
+    gMacEmbedHandler->getClipProc = getClipProc;
+    gMacEmbedHandler->getOffsetProc = getOffsetProc;    
+}
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkpMakeWindow --
+ *
+ *        Creates an X Window (Mac subwindow).
+ *
+ * Results:
+ *        The window id is returned.
+ *
+ * Side effects:
+ *        None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Window
+TkpMakeWindow(
+    TkWindow *winPtr,
+    Window parent)
+{
+    MacDrawable *macWin;
+    XEvent event;
+
+    /*
+     * If this window is marked as embedded then
+     * the window structure should have already been
+     * created in the TkpUseWindow function.
+     */
+    
+    if (Tk_IsEmbedded(winPtr)) {
+        return (Window) winPtr->privatePtr;
+    }
+    
+    /*
+     * Allocate sub window
+     */
+    
+    macWin = (MacDrawable *) ckalloc(sizeof(MacDrawable));
+    if (macWin == NULL) {
+        winPtr->privatePtr = NULL;
+        return None;
+    }
+    macWin->winPtr = winPtr;
+    winPtr->privatePtr = macWin;
+    macWin->clipRgn = NewRgn();
+    macWin->aboveClipRgn = NewRgn();
+    macWin->referenceCount = 0;
+    macWin->flags = TK_CLIP_INVALID;
+
+    if (Tk_IsTopLevel(macWin->winPtr)) {
+        
+        /*
+         *This will be set when we are mapped.
+         */
+        
+        macWin->grafPtr  = NULL;  
+        macWin->toplevel = macWin;
+        macWin->xOff = 0;
+        macWin->yOff = 0;
+    } else {
+        macWin->grafPtr = NULL;
+        macWin->xOff = winPtr->parentPtr->privatePtr->xOff +
+            winPtr->parentPtr->changes.border_width +
+            winPtr->changes.x;
+        macWin->yOff = winPtr->parentPtr->privatePtr->yOff +
+            winPtr->parentPtr->changes.border_width +
+            winPtr->changes.y;
+        macWin->toplevel = winPtr->parentPtr->privatePtr->toplevel;
+    }
+
+    macWin->toplevel->referenceCount++;
+    
+    /* 
+     * TODO: need general solution for visibility events.
+     */
+    event.xany.serial = Tk_Display(winPtr)->request;
+    event.xany.send_event = False;
+    event.xany.display = Tk_Display(winPtr);
+        
+    event.xvisibility.type = VisibilityNotify;
+    event.xvisibility.window = (Window) macWin;
+    event.xvisibility.state = VisibilityUnobscured;
+    Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
+
+    return (Window) macWin;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkpUseWindow --
+ *
+ *        This procedure 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:
+ *        None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+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;
+    MacDrawable *parent, *macWin;
+    Container *containerPtr;
+    XEvent event;
+    int result;
+
+    if (winPtr->window != None) {
+        panic("TkpUseWindow: X window already assigned");
+    }
+    
+    /*
+     * Decode the container pointer, and look for it among the 
+     *list of available containers.
+     *
+     * N.B. For now, we are limiting the containers to be in the same Tk
+     * application as tkwin, since otherwise they would not be in our list
+     * of containers.
+     *
+     */
+     
+    if (Tcl_GetInt(interp, string, &result) != TCL_OK) {
+        return TCL_ERROR;
+    }
+
+    parent = (MacDrawable *) result;
+
+    /*
+     * Save information about the container and the embedded window
+     * in a Container structure.  Currently, there must already be an existing
+     * Container structure, since we only allow the case where both container 
+     * and embedded app. are in the same process.
+     */
+
+    for (containerPtr = firstContainerPtr; containerPtr != NULL;
+            containerPtr = containerPtr->nextPtr) {
+        if (containerPtr->parent == (Window) parent) {
+            winPtr->flags |= TK_BOTH_HALVES;
+            containerPtr->parentPtr->flags |= TK_BOTH_HALVES;
+            break;
+        }
+    }
+    
+    /*
+     * Make the embedded window.  
+     */
+
+    macWin = (MacDrawable *) ckalloc(sizeof(MacDrawable));
+    if (macWin == NULL) {
+        winPtr->privatePtr = NULL;
+        return TCL_ERROR;
+    }
+    
+    macWin->winPtr = winPtr;
+    winPtr->privatePtr = macWin;
+
+    /*
+     * The grafPtr will be NULL for a Tk in Tk embedded window.
+     * It is none of our business what it is for a Tk not in Tk embedded window,
+     * but we will initialize it to NULL, and let the registerWinProc 
+     * set it.  In any case, you must always use TkMacOSXGetDrawablePort 
+     * to get the portPtr.  It will correctly find the container's port.
+     */
+
+    macWin->grafPtr = NULL;
+
+    macWin->clipRgn = NewRgn();
+    macWin->aboveClipRgn = NewRgn();
+    macWin->referenceCount = 0;
+    macWin->flags = TK_CLIP_INVALID;
+    macWin->toplevel = macWin;
+    macWin->toplevel->referenceCount++;
+   
+    winPtr->flags |= TK_EMBEDDED;
+    
+    
+    /*
+     * Make a copy of the TK_EMBEDDED flag, since sometimes
+     * we need this to get the port after the TkWindow structure
+     * has been freed.
+     */
+     
+    macWin->flags |= TK_EMBEDDED;
+    
+    /*
+     * Now check whether it is embedded in another Tk widget.  If not (the first
+     * case below) we see if there is an in-process embedding handler registered,
+     * and if so, let that fill in the rest of the macWin.
+     */
+    
+    if (containerPtr == NULL) {
+        /*
+         * If someone has registered an in process embedding handler, then 
+         * see if it can handle this window...
+         */
+        
+        if (gMacEmbedHandler == NULL ||
+                gMacEmbedHandler->registerWinProc(result, (Tk_Window) winPtr) != TCL_OK) {
+            Tcl_AppendResult(interp, "The window ID ", string,
+                    " does not correspond to a valid Tk Window.",
+                     (char *) NULL);
+            return TCL_ERROR;        
+        } else {
+            containerPtr = (Container *) ckalloc(sizeof(Container));
+
+            containerPtr->parentPtr = NULL;
+            containerPtr->embedded = (Window) macWin;
+            containerPtr->embeddedPtr = macWin->winPtr;
+            containerPtr->nextPtr = firstContainerPtr;
+            firstContainerPtr = containerPtr;
+            
+        }    
+    } else {
+        
+        /* 
+         * The window is embedded in another Tk window.
+         */ 
+        
+        macWin->xOff = parent->winPtr->privatePtr->xOff +
+                parent->winPtr->changes.border_width +
+                winPtr->changes.x;
+        macWin->yOff = parent->winPtr->privatePtr->yOff +
+                parent->winPtr->changes.border_width +
+                winPtr->changes.y;
+    
+    
+        /*
+         * Finish filling up the container structure with the embedded window's 
+         * information.
+         */
+     
+        containerPtr->embedded = (Window) macWin;
+        containerPtr->embeddedPtr = macWin->winPtr;
+
+        /*
+         * Create an event handler to clean up the Container structure when
+         * tkwin is eventually deleted.
+         */
+
+        Tk_CreateEventHandler(tkwin, StructureNotifyMask, EmbeddedEventProc,
+                (ClientData) winPtr);
+
+    }
+
+   /* 
+     * TODO: need general solution for visibility events.
+     */
+     
+
+    event.xany.serial = Tk_Display(winPtr)->request;
+    event.xany.send_event = False;
+    event.xany.display = Tk_Display(winPtr);
+        
+    event.xvisibility.type = VisibilityNotify;
+    event.xvisibility.window = (Window) macWin;;
+    event.xvisibility.state = VisibilityUnobscured;
+    Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
+
+    
+    /* 
+     * TODO: need general solution for visibility events.
+     */
+     
+    event.xany.serial = Tk_Display(winPtr)->request;
+    event.xany.send_event = False;
+    event.xany.display = Tk_Display(winPtr);
+        
+    event.xvisibility.type = VisibilityNotify;
+    event.xvisibility.window = (Window) macWin;;
+    event.xvisibility.state = VisibilityUnobscured;
+    Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
+     
+    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(
+    Tk_Window tkwin)                /* Token for a window that is about to
+                                 * become a container. */
+{
+    TkWindow *winPtr = (TkWindow *) tkwin;
+    Container *containerPtr;
+
+    /*
+     * Register the window as a container so that, for example, we can
+     * make sure the argument to -use is valid.
+     */
+
+
+    Tk_MakeWindowExist(tkwin);
+    containerPtr = (Container *) ckalloc(sizeof(Container));
+    containerPtr->parent = Tk_WindowId(tkwin);
+    containerPtr->parentPtr = winPtr;
+    containerPtr->embedded = None;
+    containerPtr->embeddedPtr = NULL;
+    containerPtr->nextPtr = firstContainerPtr;
+    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.  Also, pass activate events from
+     * the container down to the embedded toplevel.
+     */
+
+    Tk_CreateEventHandler(tkwin,
+            SubstructureNotifyMask|SubstructureRedirectMask,
+            ContainerEventProc, (ClientData) winPtr);
+    Tk_CreateEventHandler(tkwin, StructureNotifyMask, EmbedStructureProc,
+            (ClientData) containerPtr);
+    Tk_CreateEventHandler(tkwin, ActivateMask, EmbedActivateProc,
+            (ClientData) containerPtr);
+    Tk_CreateEventHandler(tkwin, FocusChangeMask, EmbedFocusProc,
+            (ClientData) containerPtr);
+         
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkMacOSXContainerId --
+ *
+ *        Given an embedded window, this procedure returns the MacDrawable
+ *        identifier for the associated container window.
+ *
+ * Results:
+ *        The return value is the MacDrawable for winPtr's
+ *        container window.
+ *
+ * Side effects:
+ *        None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+MacDrawable *
+TkMacOSXContainerId(winPtr)
+    TkWindow *winPtr;                /* Tk's structure for an embedded window. */
+{
+    Container *containerPtr;
+
+    for (containerPtr = firstContainerPtr; containerPtr != NULL;
+            containerPtr = containerPtr->nextPtr) {
+        if (containerPtr->embeddedPtr == winPtr) {
+            return (MacDrawable *) containerPtr->parent;
+        }
+    }
+    panic("TkMacOSXContainerId couldn't find window");
+    return None;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkMacOSXGetHostToplevel --
+ *
+ *        Given the TkWindow, return the MacDrawable for the outermost
+ *      toplevel containing it.  This will be a real Macintosh window.
+ *
+ * Results:
+ *        Returns a MacDrawable corresponding to a Macintosh Toplevel
+ *
+ * Side effects:
+ *        None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+MacDrawable *
+TkMacOSXGetHostToplevel(
+    TkWindow *winPtr)                /* Tk's structure for a window. */
+{
+    TkWindow *contWinPtr, *topWinPtr;
+
+    topWinPtr = winPtr->privatePtr->toplevel->winPtr;
+    if (!Tk_IsEmbedded(topWinPtr)) {
+            return winPtr->privatePtr->toplevel;
+    } else {
+        contWinPtr = TkpGetOtherWindow(topWinPtr);
+
+        /*
+         * NOTE: Here we should handle out of process embedding.
+         */
+        
+        if (contWinPtr != NULL) {
+            return TkMacOSXGetHostToplevel(contWinPtr);
+        } else {
+            return None;
+        }
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkpClaimFocus --
+ *
+ *        This procedure is invoked when someone asks for 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;
+
+    if (!(topLevelPtr->flags & TK_EMBEDDED)) {
+        return;
+    }
+
+    for (containerPtr = 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;
+    Tk_QueueWindowEvent(&event,TCL_QUEUE_TAIL);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkpTestembedCmd --
+ *
+ *        This procedure 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 argc,                                /* Number of arguments. */
+    CONST char **argv)                        /* Argument strings. */
+{
+    int all;
+    Container *containerPtr;
+    Tcl_DString dString;
+    char buffer[50];
+
+    if ((argc > 1) && (strcmp(argv[1], "all") == 0)) {
+        all = 1;
+    } else {
+        all = 0;
+    }
+    Tcl_DStringInit(&dString);
+    for (containerPtr = 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->embedded == None) {
+            Tcl_DStringAppendElement(&dString, "");
+        } else {
+            if (all) {
+                sprintf(buffer, "0x%x", (int) containerPtr->embedded);
+                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;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * 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(
+    TkWindow *winPtr,                /* Window to which the event was originally
+                                 * reported. */
+    XEvent *eventPtr)                /* X event to redirect (should be KeyPress
+                                 * or KeyRelease). */
+{
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * 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(
+    TkWindow *winPtr)                /* Tk's structure for a container or
+                                 * embedded window. */
+{
+    Container *containerPtr;
+
+    /*
+     * TkpGetOtherWindow returns NULL if both windows are not
+     * in the same process...
+     */
+
+    if (!(winPtr->flags & TK_BOTH_HALVES)) {
+        return NULL;
+    }
+    
+    for (containerPtr = firstContainerPtr; containerPtr != NULL;
+            containerPtr = containerPtr->nextPtr) {
+        if (containerPtr->embeddedPtr == winPtr) {
+            return containerPtr->parentPtr;
+        } else if (containerPtr->parentPtr == winPtr) {
+            return containerPtr->embeddedPtr;
+        }
+    }
+    return NULL;
+}
+/*
+ *----------------------------------------------------------------------
+ *
+ * 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);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ContainerEventProc --
+ *
+ *        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.
+ *
+ *        NOTE: on the Mac, only the DestroyNotify branch is ever taken.
+ *      We don't synthesize the other events.
+ *
+ * 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. */
+{
+    TkWindow *winPtr = (TkWindow *) clientData;
+    Container *containerPtr;
+    Tk_ErrorHandler errHandler;
+
+    /*
+     * Ignore any X protocol errors that happen in this procedure
+     * (almost any operation could fail, for example, if the embedded
+     * application has deleted its window).
+     */
+
+    errHandler = Tk_CreateErrorHandler(eventPtr->xfocus.display, -1,
+            -1, -1, (Tk_ErrorProc *) NULL, (ClientData) NULL);
+
+    /*
+     * Find the Container structure associated with the parent window.
+     */
+
+    for (containerPtr = firstContainerPtr;
+            containerPtr->parent != eventPtr->xmaprequest.parent;
+            containerPtr = containerPtr->nextPtr) {
+        if (containerPtr == NULL) {
+            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).
+         */
+
+        containerPtr->embedded = eventPtr->xcreatewindow.window;
+    } 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 procedure 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 procedure 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, eventPtr)
+    ClientData clientData;                /* Token for container window. */
+    XEvent *eventPtr;                        /* ResizeRequest event. */
+{
+    Container *containerPtr = (Container *) clientData;
+    Tk_ErrorHandler errHandler;
+
+    if (eventPtr->type == ConfigureNotify) {
+        if (containerPtr->embedded != None) {
+            /*
+             * Ignore errors, since the embedded application could have
+             * deleted its window.
+             */
+
+            errHandler = Tk_CreateErrorHandler(eventPtr->xfocus.display, -1,
+                    -1, -1, (Tk_ErrorProc *) NULL, (ClientData) NULL);
+            Tk_MoveResizeWindow((Tk_Window) containerPtr->embeddedPtr, 0, 0,
+                    (unsigned int) Tk_Width(
+                            (Tk_Window) containerPtr->parentPtr),
+                    (unsigned int) Tk_Height(
+                            (Tk_Window) containerPtr->parentPtr));
+            Tk_DeleteErrorHandler(errHandler);
+        }
+    } else if (eventPtr->type == DestroyNotify) {
+        EmbedWindowDeleted(containerPtr->parentPtr);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * EmbedActivateProc --
+ *
+ *        This procedure is invoked by the Tk event dispatcher when
+ *        Activate and Deactivate events occur for a container window owned
+ *        by this application.  It is responsible for forwarding an activate 
+ *      event down into the embedded toplevel.
+ *
+ * Results:
+ *        None.
+ *
+ * Side effects:
+ *        The X focus may change.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+EmbedActivateProc(clientData, eventPtr)
+    ClientData clientData;                /* Token for container window. */
+    XEvent *eventPtr;                        /* ResizeRequest event. */
+{
+    Container *containerPtr = (Container *) clientData;
+    
+    if (containerPtr->embeddedPtr != NULL) {
+        if (eventPtr->type == ActivateNotify) {
+            TkGenerateActivateEvents(containerPtr->embeddedPtr,1);
+        } else if (eventPtr->type == DeactivateNotify) {
+            TkGenerateActivateEvents(containerPtr->embeddedPtr,0);
+        }        
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * EmbedFocusProc --
+ *
+ *        This procedure 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, eventPtr)
+    ClientData clientData;                /* Token for container window. */
+    XEvent *eventPtr;                        /* ResizeRequest event. */
+{
+    Container *containerPtr = (Container *) clientData;
+    Display *display;
+    XEvent event;
+
+    if (containerPtr->embeddedPtr != NULL) {
+    display = Tk_Display(containerPtr->parentPtr);
+        event.xfocus.serial = LastKnownRequestProcessed(display);
+        event.xfocus.send_event = false;
+        event.xfocus.display = display;
+        event.xfocus.mode = NotifyNormal;
+        event.xfocus.window = containerPtr->embedded; 
+        
+    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).
+         */
+    
+            event.xfocus.detail = NotifyNonlinear;
+            event.xfocus.type = FocusIn;
+
+        } else if (eventPtr->type == FocusOut) {
+        /* When the container gets a FocusOut event, it has to  tell the embedded app
+         * that it has lost the focus.
+         */
+         
+            event.xfocus.type = FocusOut;
+            event.xfocus.detail = NotifyNonlinear;
+         }
+         
+        Tk_QueueWindowEvent(&event, TCL_QUEUE_MARK);
+    } 
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * EmbedGeometryRequest --
+ *
+ *        This procedure 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.
+ *
+ *      NOTE: On the Mac, this is a stub, since we don't synthesize
+ *      ConfigureRequest events.
+ *
+ * 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(containerPtr, width, height)
+    Container *containerPtr;        /* Information about the embedding. */
+    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 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 is currently a stub.  It is called to notify an
+ *        embedded application of its current size and location.  This
+ *        procedure 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.
+ *      It is a response to ConfigureRequest events, which we do not
+ *      currently synthesize on the Mac
+ *
+ * Results:
+ *        None.
+ *
+ * Side effects:
+ *        None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+EmbedSendConfigure(containerPtr)
+    Container *containerPtr;        /* Information about the embedding. */
+{
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * 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;
+
+    /*
+     * Find the Container structure for this window.  Delete the
+     * information about the embedded application and free the container's
+     * record.
+     */
+
+    prevPtr = NULL;
+    containerPtr = firstContainerPtr;
+    while (1) {
+        if (containerPtr->embeddedPtr == winPtr) {
+
+            /*
+             * We also have to destroy our parent, to clean up the container.
+             * Fabricate an event to do this.
+             */
+             
+            if (containerPtr->parentPtr != NULL &&
+                    containerPtr->parentPtr->flags & TK_BOTH_HALVES) {
+                XEvent event;
+                
+                event.xany.serial = 
+                    Tk_Display(containerPtr->parentPtr)->request;
+                    event.xany.send_event = False;
+                    event.xany.display = Tk_Display(containerPtr->parentPtr);
+        
+                    event.xany.type = DestroyNotify;
+                    event.xany.window = containerPtr->parent;
+                    event.xdestroywindow.event = containerPtr->parent;
+                    Tk_QueueWindowEvent(&event, TCL_QUEUE_HEAD);
+
+            }
+            
+            containerPtr->embedded = 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) {
+            firstContainerPtr = containerPtr->nextPtr;
+        } else {
+            prevPtr->nextPtr = containerPtr->nextPtr;
+        }
+        ckfree((char *) containerPtr);
+    }
+}
+