Initial revision

1 files changed, 1176 insertions, 0 deletions

diff --git a/generic/tkTextWind.c b/generic/tkTextWind.c
new file mode 100644
index 0000000..6452d13
--- /dev/null
+++ b/generic/tkTextWind.c
@@ -0,0 +1,1176 @@
+/* 
+ * tkTextWind.c --
+ *
+ *	This file contains code that allows arbitrary windows to be
+ *	nested inside text widgets.  It also implements the "window"
+ *	widget command for texts.
+ *
+ * Copyright (c) 1994 The Regents of the University of California.
+ * Copyright (c) 1994-1995 Sun Microsystems, Inc.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * SCCS: @(#) tkTextWind.c 1.14 97/04/25 16:52:09
+ */
+
+#include "tk.h"
+#include "tkText.h"
+#include "tkPort.h"
+
+/*
+ * The following structure is the official type record for the
+ * embedded window geometry manager:
+ */
+
+static void		EmbWinRequestProc _ANSI_ARGS_((ClientData clientData,
+			    Tk_Window tkwin));
+static void		EmbWinLostSlaveProc _ANSI_ARGS_((ClientData clientData,
+			    Tk_Window tkwin));
+
+static Tk_GeomMgr textGeomType = {
+    "text",			/* name */
+    EmbWinRequestProc,		/* requestProc */
+    EmbWinLostSlaveProc,	/* lostSlaveProc */
+};
+
+/*
+ * Definitions for alignment values:
+ */
+
+#define ALIGN_BOTTOM		0
+#define ALIGN_CENTER		1
+#define ALIGN_TOP		2
+#define ALIGN_BASELINE		3
+
+/*
+ * Macro that determines the size of an embedded window segment:
+ */
+
+#define EW_SEG_SIZE ((unsigned) (Tk_Offset(TkTextSegment, body) \
+	+ sizeof(TkTextEmbWindow)))
+
+/*
+ * Prototypes for procedures defined in this file:
+ */
+
+static int		AlignParseProc _ANSI_ARGS_((ClientData clientData,
+			    Tcl_Interp *interp, Tk_Window tkwin, char *value,
+			    char *widgRec, int offset));
+static char *		AlignPrintProc _ANSI_ARGS_((ClientData clientData,
+			    Tk_Window tkwin, char *widgRec, int offset,
+			    Tcl_FreeProc **freeProcPtr));
+static TkTextSegment *	EmbWinCleanupProc _ANSI_ARGS_((TkTextSegment *segPtr,
+			    TkTextLine *linePtr));
+static void		EmbWinCheckProc _ANSI_ARGS_((TkTextSegment *segPtr,
+			    TkTextLine *linePtr));
+static void		EmbWinBboxProc _ANSI_ARGS_((TkTextDispChunk *chunkPtr,
+			    int index, int y, int lineHeight, int baseline,
+			    int *xPtr, int *yPtr, int *widthPtr,
+			    int *heightPtr));
+static int		EmbWinConfigure _ANSI_ARGS_((TkText *textPtr,
+			    TkTextSegment *ewPtr, int argc, char **argv));
+static void		EmbWinDelayedUnmap _ANSI_ARGS_((
+			    ClientData clientData));
+static int		EmbWinDeleteProc _ANSI_ARGS_((TkTextSegment *segPtr,
+			    TkTextLine *linePtr, int treeGone));
+static void		EmbWinDisplayProc _ANSI_ARGS_((
+			    TkTextDispChunk *chunkPtr, int x, int y,
+			    int lineHeight, int baseline, Display *display,
+			    Drawable dst, int screenY));
+static int		EmbWinLayoutProc _ANSI_ARGS_((TkText *textPtr,
+			    TkTextIndex *indexPtr, TkTextSegment *segPtr,
+			    int offset, int maxX, int maxChars,
+			    int noCharsYet, Tk_Uid wrapMode,
+			    TkTextDispChunk *chunkPtr));
+static void		EmbWinStructureProc _ANSI_ARGS_((ClientData clientData,
+			    XEvent *eventPtr));
+static void		EmbWinUndisplayProc _ANSI_ARGS_((TkText *textPtr,
+			    TkTextDispChunk *chunkPtr));
+
+/*
+ * The following structure declares the "embedded window" segment type.
+ */
+
+static Tk_SegType tkTextEmbWindowType = {
+    "window",					/* name */
+    0,						/* leftGravity */
+    (Tk_SegSplitProc *) NULL,			/* splitProc */
+    EmbWinDeleteProc,				/* deleteProc */
+    EmbWinCleanupProc,				/* cleanupProc */
+    (Tk_SegLineChangeProc *) NULL,		/* lineChangeProc */
+    EmbWinLayoutProc,				/* layoutProc */
+    EmbWinCheckProc				/* checkProc */
+};
+
+/*
+ * Information used for parsing window configuration options:
+ */
+
+static Tk_CustomOption alignOption = {AlignParseProc, AlignPrintProc,
+	(ClientData) NULL};
+
+static Tk_ConfigSpec configSpecs[] = {
+    {TK_CONFIG_CUSTOM, "-align", (char *) NULL, (char *) NULL,
+	"center", 0, TK_CONFIG_DONT_SET_DEFAULT, &alignOption},
+    {TK_CONFIG_STRING, "-create", (char *) NULL, (char *) NULL,
+	(char *) NULL, Tk_Offset(TkTextEmbWindow, create),
+	TK_CONFIG_DONT_SET_DEFAULT|TK_CONFIG_NULL_OK},
+    {TK_CONFIG_INT, "-padx", (char *) NULL, (char *) NULL,
+	"0", Tk_Offset(TkTextEmbWindow, padX),
+	TK_CONFIG_DONT_SET_DEFAULT},
+    {TK_CONFIG_INT, "-pady", (char *) NULL, (char *) NULL,
+	"0", Tk_Offset(TkTextEmbWindow, padY),
+	TK_CONFIG_DONT_SET_DEFAULT},
+    {TK_CONFIG_BOOLEAN, "-stretch", (char *) NULL, (char *) NULL,
+	"0", Tk_Offset(TkTextEmbWindow, stretch),
+	TK_CONFIG_DONT_SET_DEFAULT},
+    {TK_CONFIG_WINDOW, "-window", (char *) NULL, (char *) NULL,
+	(char *) NULL, Tk_Offset(TkTextEmbWindow, tkwin),
+	TK_CONFIG_DONT_SET_DEFAULT|TK_CONFIG_NULL_OK},
+    {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
+	(char *) NULL, 0, 0}
+};
+
+/*
+ *--------------------------------------------------------------
+ *
+ * TkTextWindowCmd --
+ *
+ *	This procedure implements the "window" widget command
+ *	for text widgets.  See the user documentation for details
+ *	on what it does.
+ *
+ * Results:
+ *	A standard Tcl result or error.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *--------------------------------------------------------------
+ */
+
+int
+TkTextWindowCmd(textPtr, interp, argc, argv)
+    register TkText *textPtr;	/* Information about text widget. */
+    Tcl_Interp *interp;		/* Current interpreter. */
+    int argc;			/* Number of arguments. */
+    char **argv;		/* Argument strings.  Someone else has already
+				 * parsed this command enough to know that
+				 * argv[1] is "window". */
+{
+    size_t length;
+    register TkTextSegment *ewPtr;
+
+    if (argc < 3) {
+	Tcl_AppendResult(interp, "wrong # args: should be \"",
+		argv[0], " window option ?arg arg ...?\"", (char *) NULL);
+	return TCL_ERROR;
+    }
+    length = strlen(argv[2]);
+    if ((strncmp(argv[2], "cget", length) == 0) && (length >= 2)) {
+	TkTextIndex index;
+	TkTextSegment *ewPtr;
+
+	if (argc != 5) {
+	    Tcl_AppendResult(interp, "wrong # args: should be \"",
+		    argv[0], " window cget index option\"",
+		    (char *) NULL);
+	    return TCL_ERROR;
+	}
+	if (TkTextGetIndex(interp, textPtr, argv[3], &index) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	ewPtr = TkTextIndexToSeg(&index, (int *) NULL);
+	if (ewPtr->typePtr != &tkTextEmbWindowType) {
+	    Tcl_AppendResult(interp, "no embedded window at index \"",
+		    argv[3], "\"", (char *) NULL);
+	    return TCL_ERROR;
+	}
+	return Tk_ConfigureValue(interp, textPtr->tkwin, configSpecs,
+		(char *) &ewPtr->body.ew, argv[4], 0);
+    } else if ((strncmp(argv[2], "configure", length) == 0) && (length >= 2)) {
+	TkTextIndex index;
+	TkTextSegment *ewPtr;
+
+	if (argc < 4) {
+	    Tcl_AppendResult(interp, "wrong # args: should be \"",
+		    argv[0], " window configure index ?option value ...?\"",
+		    (char *) NULL);
+	    return TCL_ERROR;
+	}
+	if (TkTextGetIndex(interp, textPtr, argv[3], &index) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	ewPtr = TkTextIndexToSeg(&index, (int *) NULL);
+	if (ewPtr->typePtr != &tkTextEmbWindowType) {
+	    Tcl_AppendResult(interp, "no embedded window at index \"",
+		    argv[3], "\"", (char *) NULL);
+	    return TCL_ERROR;
+	}
+	if (argc == 4) {
+	    return Tk_ConfigureInfo(interp, textPtr->tkwin, configSpecs,
+		    (char *) &ewPtr->body.ew, (char *) NULL, 0);
+	} else if (argc == 5) {
+	    return Tk_ConfigureInfo(interp, textPtr->tkwin, configSpecs,
+		    (char *) &ewPtr->body.ew, argv[4], 0);
+	} else {
+	    TkTextChanged(textPtr, &index, &index);
+	    return EmbWinConfigure(textPtr, ewPtr, argc-4, argv+4);
+	}
+    } else if ((strncmp(argv[2], "create", length) == 0) && (length >= 2)) {
+	TkTextIndex index;
+	int lineIndex;
+
+	/*
+	 * Add a new window.  Find where to put the new window, and
+	 * mark that position for redisplay.
+	 */
+
+	if (argc < 4) {
+	    Tcl_AppendResult(interp, "wrong # args: should be \"",
+		    argv[0], " window create index ?option value ...?\"",
+		    (char *) NULL);
+	    return TCL_ERROR;
+	}
+	if (TkTextGetIndex(interp, textPtr, argv[3], &index) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+
+	/*
+	 * Don't allow insertions on the last (dummy) line of the text.
+	 */
+    
+	lineIndex = TkBTreeLineIndex(index.linePtr);
+	if (lineIndex == TkBTreeNumLines(textPtr->tree)) {
+	    lineIndex--;
+	    TkTextMakeIndex(textPtr->tree, lineIndex, 1000000, &index);
+	}
+
+	/*
+	 * Create the new window segment and initialize it.
+	 */
+
+	ewPtr = (TkTextSegment *) ckalloc(EW_SEG_SIZE);
+	ewPtr->typePtr = &tkTextEmbWindowType;
+	ewPtr->size = 1;
+	ewPtr->body.ew.textPtr = textPtr;
+	ewPtr->body.ew.linePtr = NULL;
+	ewPtr->body.ew.tkwin = NULL;
+	ewPtr->body.ew.create = NULL;
+	ewPtr->body.ew.align = ALIGN_CENTER;
+	ewPtr->body.ew.padX = ewPtr->body.ew.padY = 0;
+	ewPtr->body.ew.stretch = 0;
+	ewPtr->body.ew.chunkCount = 0;
+	ewPtr->body.ew.displayed = 0;
+
+	/*
+	 * Link the segment into the text widget, then configure it (delete
+	 * it again if the configuration fails).
+	 */
+
+	TkTextChanged(textPtr, &index, &index);
+	TkBTreeLinkSegment(ewPtr, &index);
+	if (EmbWinConfigure(textPtr, ewPtr, argc-4, argv+4) != TCL_OK) {
+	    TkTextIndex index2;
+
+	    TkTextIndexForwChars(&index, 1, &index2);
+	    TkBTreeDeleteChars(&index, &index2);
+	    return TCL_ERROR;
+	}
+    } else if (strncmp(argv[2], "names", length) == 0) {
+	Tcl_HashSearch search;
+	Tcl_HashEntry *hPtr;
+
+	if (argc != 3) {
+	    Tcl_AppendResult(interp, "wrong # args: should be \"",
+		    argv[0], " window names\"", (char *) NULL);
+	    return TCL_ERROR;
+	}
+	for (hPtr = Tcl_FirstHashEntry(&textPtr->windowTable, &search);
+		hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
+	    Tcl_AppendElement(interp,
+		    Tcl_GetHashKey(&textPtr->markTable, hPtr));
+	}
+    } else {
+	Tcl_AppendResult(interp, "bad window option \"", argv[2],
+		"\": must be cget, configure, create, or names",
+		(char *) NULL);
+	return TCL_ERROR;
+    }
+    return TCL_OK;
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * EmbWinConfigure --
+ *
+ *	This procedure is called to handle configuration options
+ *	for an embedded window, using an argc/argv list.
+ *
+ * Results:
+ *	The return value is a standard Tcl result.  If TCL_ERROR is
+ *	returned, then interp->result contains an error message..
+ *
+ * Side effects:
+ *	Configuration information for the embedded window changes,
+ *	such as alignment, stretching, or name of the embedded
+ *	window.
+ *
+ *--------------------------------------------------------------
+ */
+
+static int
+EmbWinConfigure(textPtr, ewPtr, argc, argv)
+    TkText *textPtr;		/* Information about text widget that
+				 * contains embedded window. */
+    TkTextSegment *ewPtr;	/* Embedded window to be configured. */
+    int argc;			/* Number of strings in argv. */
+    char **argv;		/* Array of strings describing configuration
+				 * options. */
+{
+    Tk_Window oldWindow;
+    Tcl_HashEntry *hPtr;
+    int new;
+
+    oldWindow = ewPtr->body.ew.tkwin;
+    if (Tk_ConfigureWidget(textPtr->interp, textPtr->tkwin, configSpecs,
+	    argc, argv, (char *) &ewPtr->body.ew, TK_CONFIG_ARGV_ONLY)
+	    != TCL_OK) {
+	return TCL_ERROR;
+    }
+    if (oldWindow != ewPtr->body.ew.tkwin) {
+	if (oldWindow != NULL) {
+	    Tcl_DeleteHashEntry(Tcl_FindHashEntry(&textPtr->windowTable,
+		    Tk_PathName(oldWindow)));
+	    Tk_DeleteEventHandler(oldWindow, StructureNotifyMask,
+		    EmbWinStructureProc, (ClientData) ewPtr);
+	    Tk_ManageGeometry(oldWindow, (Tk_GeomMgr *) NULL,
+		    (ClientData) NULL);
+	    if (textPtr->tkwin != Tk_Parent(oldWindow)) {
+		Tk_UnmaintainGeometry(oldWindow, textPtr->tkwin);
+	    } else {
+		Tk_UnmapWindow(oldWindow);
+	    }
+	}
+	if (ewPtr->body.ew.tkwin != NULL) {
+	    Tk_Window ancestor, parent;
+
+	    /*
+	     * Make sure that the text is either the parent of the
+	     * embedded window or a descendant of that parent.  Also,
+	     * don't allow a top-level window to be managed inside
+	     * a text.
+	     */
+
+	    parent = Tk_Parent(ewPtr->body.ew.tkwin);
+	    for (ancestor = textPtr->tkwin; ;
+		    ancestor = Tk_Parent(ancestor)) {
+		if (ancestor == parent) {
+		    break;
+		}
+		if (Tk_IsTopLevel(ancestor)) {
+		    badMaster:
+		    Tcl_AppendResult(textPtr->interp, "can't embed ",
+			    Tk_PathName(ewPtr->body.ew.tkwin), " in ",
+			    Tk_PathName(textPtr->tkwin), (char *) NULL);
+		    ewPtr->body.ew.tkwin = NULL;
+		    return TCL_ERROR;
+		}
+	    }
+	    if (Tk_IsTopLevel(ewPtr->body.ew.tkwin)
+		    || (ewPtr->body.ew.tkwin == textPtr->tkwin)) {
+		goto badMaster;
+	    }
+
+	    /*
+	     * Take over geometry management for the window, plus create
+	     * an event handler to find out when it is deleted.
+	     */
+
+	    Tk_ManageGeometry(ewPtr->body.ew.tkwin, &textGeomType,
+		    (ClientData) ewPtr);
+	    Tk_CreateEventHandler(ewPtr->body.ew.tkwin, StructureNotifyMask,
+		    EmbWinStructureProc, (ClientData) ewPtr);
+
+	    /*
+	     * Special trick!  Must enter into the hash table *after*
+	     * calling Tk_ManageGeometry:  if the window was already managed
+	     * elsewhere in this text, the Tk_ManageGeometry call will cause
+	     * the entry to be removed, which could potentially lose the new
+	     * entry.
+	     */
+
+	    hPtr = Tcl_CreateHashEntry(&textPtr->windowTable,
+		    Tk_PathName(ewPtr->body.ew.tkwin), &new);
+	    Tcl_SetHashValue(hPtr, ewPtr);
+
+	}
+    }
+    return TCL_OK;
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * AlignParseProc --
+ *
+ *	This procedure is invoked by Tk_ConfigureWidget during
+ *	option processing to handle "-align" options for embedded
+ *	windows.
+ *
+ * Results:
+ *	A standard Tcl return value.
+ *
+ * Side effects:
+ *	The alignment for the embedded window may change.
+ *
+ *--------------------------------------------------------------
+ */
+
+	/* ARGSUSED */
+static int
+AlignParseProc(clientData, interp, tkwin, value, widgRec, offset)
+    ClientData clientData;		/* Not used.*/
+    Tcl_Interp *interp;			/* Used for reporting errors. */
+    Tk_Window tkwin;			/* Window for text widget. */
+    char *value;			/* Value of option. */
+    char *widgRec;			/* Pointer to TkTextEmbWindow
+					 * structure. */
+    int offset;				/* Offset into item (ignored). */
+{
+    register TkTextEmbWindow *embPtr = (TkTextEmbWindow *) widgRec;
+
+    if (strcmp(value, "baseline") == 0) {
+	embPtr->align = ALIGN_BASELINE;
+    } else if (strcmp(value, "bottom") == 0) {
+	embPtr->align = ALIGN_BOTTOM;
+    } else if (strcmp(value, "center") == 0) {
+	embPtr->align = ALIGN_CENTER;
+    } else if (strcmp(value, "top") == 0) {
+	embPtr->align = ALIGN_TOP;
+    } else {
+	Tcl_AppendResult(interp, "bad alignment \"", value,
+		"\": must be baseline, bottom, center, or top",
+		(char *) NULL);
+	return TCL_ERROR;
+    }
+    return TCL_OK;
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * AlignPrintProc --
+ *
+ *	This procedure is invoked by the Tk configuration code
+ *	to produce a printable string for the "-align" configuration
+ *	option for embedded windows.
+ *
+ * Results:
+ *	The return value is a string describing the embedded
+ *	window's current alignment.
+ *
+ * Side effects:
+ *	None.
+ *
+ *--------------------------------------------------------------
+ */
+
+	/* ARGSUSED */
+static char *
+AlignPrintProc(clientData, tkwin, widgRec, offset, freeProcPtr)
+    ClientData clientData;		/* Ignored. */
+    Tk_Window tkwin;			/* Window for text widget. */
+    char *widgRec;			/* Pointer to TkTextEmbWindow
+					 * structure. */
+    int offset;				/* Ignored. */
+    Tcl_FreeProc **freeProcPtr;		/* Pointer to variable to fill in with
+					 * information about how to reclaim
+					 * storage for return string. */
+{
+    switch (((TkTextEmbWindow *) widgRec)->align) {
+	case ALIGN_BASELINE:
+	    return "baseline";
+	case ALIGN_BOTTOM:
+	    return "bottom";
+	case ALIGN_CENTER:
+	    return "center";
+	case ALIGN_TOP:
+	    return "top";
+	default:
+	    return "??";
+    }
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * EmbWinStructureProc --
+ *
+ *	This procedure is invoked by the Tk event loop whenever
+ *	StructureNotify events occur for a window that's embedded
+ *	in a text widget.  This procedure's only purpose is to
+ *	clean up when windows are deleted.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The window is disassociated from the window segment, and
+ *	the portion of the text is redisplayed.
+ *
+ *--------------------------------------------------------------
+ */
+
+static void
+EmbWinStructureProc(clientData, eventPtr)
+    ClientData clientData;	/* Pointer to record describing window item. */
+    XEvent *eventPtr;		/* Describes what just happened. */
+{
+    register TkTextSegment *ewPtr = (TkTextSegment *) clientData;
+    TkTextIndex index;
+
+    if (eventPtr->type != DestroyNotify) {
+	return;
+    }
+
+    Tcl_DeleteHashEntry(Tcl_FindHashEntry(&ewPtr->body.ew.textPtr->windowTable,
+	    Tk_PathName(ewPtr->body.ew.tkwin)));
+    ewPtr->body.ew.tkwin = NULL;
+    index.tree = ewPtr->body.ew.textPtr->tree;
+    index.linePtr = ewPtr->body.ew.linePtr;
+    index.charIndex = TkTextSegToOffset(ewPtr, ewPtr->body.ew.linePtr);
+    TkTextChanged(ewPtr->body.ew.textPtr, &index, &index);
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * EmbWinRequestProc --
+ *
+ *	This procedure is invoked whenever a window that's associated
+ *	with a window canvas item changes its requested dimensions.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The size and location on the screen of the window may change,
+ *	depending on the options specified for the window item.
+ *
+ *--------------------------------------------------------------
+ */
+
+	/* ARGSUSED */
+static void
+EmbWinRequestProc(clientData, tkwin)
+    ClientData clientData;		/* Pointer to record for window item. */
+    Tk_Window tkwin;			/* Window that changed its desired
+					 * size. */
+{
+    TkTextSegment *ewPtr = (TkTextSegment *) clientData;
+    TkTextIndex index;
+
+    index.tree = ewPtr->body.ew.textPtr->tree;
+    index.linePtr = ewPtr->body.ew.linePtr;
+    index.charIndex = TkTextSegToOffset(ewPtr, ewPtr->body.ew.linePtr);
+    TkTextChanged(ewPtr->body.ew.textPtr, &index, &index);
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * EmbWinLostSlaveProc --
+ *
+ *	This procedure is invoked by the Tk geometry manager when
+ *	a slave window managed by a text widget is claimed away
+ *	by another geometry manager.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The window is disassociated from the window segment, and
+ *	the portion of the text is redisplayed.
+ *
+ *--------------------------------------------------------------
+ */
+
+static void
+EmbWinLostSlaveProc(clientData, tkwin)
+    ClientData clientData;	/* Pointer to record describing window item. */
+    Tk_Window tkwin;		/* Window that was claimed away by another
+				 * geometry manager. */
+{
+    register TkTextSegment *ewPtr = (TkTextSegment *) clientData;
+    TkTextIndex index;
+
+    Tk_DeleteEventHandler(ewPtr->body.ew.tkwin, StructureNotifyMask,
+	    EmbWinStructureProc, (ClientData) ewPtr);
+    Tcl_CancelIdleCall(EmbWinDelayedUnmap, (ClientData) ewPtr);
+    if (ewPtr->body.ew.textPtr->tkwin != Tk_Parent(tkwin)) {
+	Tk_UnmaintainGeometry(tkwin, ewPtr->body.ew.textPtr->tkwin);
+    } else {
+	Tk_UnmapWindow(tkwin);
+    }
+    Tcl_DeleteHashEntry(Tcl_FindHashEntry(&ewPtr->body.ew.textPtr->windowTable,
+	    Tk_PathName(ewPtr->body.ew.tkwin)));
+    ewPtr->body.ew.tkwin = NULL;
+    index.tree = ewPtr->body.ew.textPtr->tree;
+    index.linePtr = ewPtr->body.ew.linePtr;
+    index.charIndex = TkTextSegToOffset(ewPtr, ewPtr->body.ew.linePtr);
+    TkTextChanged(ewPtr->body.ew.textPtr, &index, &index);
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * EmbWinDeleteProc --
+ *
+ *	This procedure is invoked by the text B-tree code whenever
+ *	an embedded window lies in a range of characters being deleted.
+ *
+ * Results:
+ *	Returns 0 to indicate that the deletion has been accepted.
+ *
+ * Side effects:
+ *	The embedded window is deleted, if it exists, and any resources
+ *	associated with it are released.
+ *
+ *--------------------------------------------------------------
+ */
+
+	/* ARGSUSED */
+static int
+EmbWinDeleteProc(ewPtr, linePtr, treeGone)
+    TkTextSegment *ewPtr;		/* Segment being deleted. */
+    TkTextLine *linePtr;		/* Line containing segment. */
+    int treeGone;			/* Non-zero means the entire tree is
+					 * being deleted, so everything must
+					 * get cleaned up. */
+{
+    Tcl_HashEntry *hPtr;
+
+    if (ewPtr->body.ew.tkwin != NULL) {
+	hPtr = Tcl_FindHashEntry(&ewPtr->body.ew.textPtr->windowTable,
+		Tk_PathName(ewPtr->body.ew.tkwin));
+	if (hPtr != NULL) {
+	    /*
+	     * (It's possible for there to be no hash table entry for this
+	     * window, if an error occurred while creating the window segment
+	     * but before the window got added to the table)
+	     */
+
+	    Tcl_DeleteHashEntry(hPtr);
+	}
+
+	/*
+	 * Delete the event handler for the window before destroying
+	 * the window, so that EmbWinStructureProc doesn't get called
+	 * (we'll already do everything that it would have done, and
+	 * it will just get confused).
+	 */
+
+	Tk_DeleteEventHandler(ewPtr->body.ew.tkwin, StructureNotifyMask,
+		EmbWinStructureProc, (ClientData) ewPtr);
+	Tk_DestroyWindow(ewPtr->body.ew.tkwin);
+    }
+    Tcl_CancelIdleCall(EmbWinDelayedUnmap, (ClientData) ewPtr);
+    Tk_FreeOptions(configSpecs, (char *) &ewPtr->body.ew,
+	    ewPtr->body.ew.textPtr->display, 0);
+    ckfree((char *) ewPtr);
+    return 0;
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * EmbWinCleanupProc --
+ *
+ *	This procedure is invoked by the B-tree code whenever a
+ *	segment containing an embedded window is moved from one
+ *	line to another.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The linePtr field of the segment gets updated.
+ *
+ *--------------------------------------------------------------
+ */
+
+static TkTextSegment *
+EmbWinCleanupProc(ewPtr, linePtr)
+    TkTextSegment *ewPtr;		/* Mark segment that's being moved. */
+    TkTextLine *linePtr;		/* Line that now contains segment. */
+{
+    ewPtr->body.ew.linePtr = linePtr;
+    return ewPtr;
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * EmbWinLayoutProc --
+ *
+ *	This procedure is the "layoutProc" for embedded window
+ *	segments.
+ *
+ * Results:
+ *	1 is returned to indicate that the segment should be
+ *	displayed.  The chunkPtr structure is filled in.
+ *
+ * Side effects:
+ *	None, except for filling in chunkPtr.
+ *
+ *--------------------------------------------------------------
+ */
+
+	/*ARGSUSED*/
+static int
+EmbWinLayoutProc(textPtr, indexPtr, ewPtr, offset, maxX, maxChars,
+	noCharsYet, wrapMode, chunkPtr)
+    TkText *textPtr;		/* Text widget being layed out. */
+    TkTextIndex *indexPtr;	/* Identifies first character in chunk. */
+    TkTextSegment *ewPtr;	/* Segment corresponding to indexPtr. */
+    int offset;			/* Offset within segPtr corresponding to
+				 * indexPtr (always 0). */
+    int maxX;			/* Chunk must not occupy pixels at this
+				 * position or higher. */
+    int maxChars;		/* Chunk must not include more than this
+				 * many characters. */
+    int noCharsYet;		/* Non-zero means no characters have been
+				 * assigned to this line yet. */
+    Tk_Uid wrapMode;		/* Wrap mode to use for line: tkTextCharUid,
+				 * tkTextNoneUid, or tkTextWordUid. */
+    register TkTextDispChunk *chunkPtr;
+				/* Structure to fill in with information
+				 * about this chunk.  The x field has already
+				 * been set by the caller. */
+{
+    int width, height;
+
+    if (offset != 0) {
+	panic("Non-zero offset in EmbWinLayoutProc");
+    }
+
+    if ((ewPtr->body.ew.tkwin == NULL) && (ewPtr->body.ew.create != NULL)) {
+	int code, new;
+	Tcl_DString name;
+	Tk_Window ancestor;
+	Tcl_HashEntry *hPtr;
+
+	/*
+	 * The window doesn't currently exist.  Create it by evaluating
+	 * the creation script.  The script must return the window's
+	 * path name:  look up that name to get back to the window
+	 * token.  Then register ourselves as the geometry manager for
+	 * the window.
+	 */
+
+	code = Tcl_GlobalEval(textPtr->interp, ewPtr->body.ew.create);
+	if (code != TCL_OK) {
+	    createError:
+	    Tcl_BackgroundError(textPtr->interp);
+	    goto gotWindow;
+	}
+	Tcl_DStringInit(&name);
+	Tcl_DStringAppend(&name, textPtr->interp->result, -1);
+	Tcl_ResetResult(textPtr->interp);
+	ewPtr->body.ew.tkwin = Tk_NameToWindow(textPtr->interp,
+		Tcl_DStringValue(&name), textPtr->tkwin);
+	if (ewPtr->body.ew.tkwin == NULL) {
+	    goto createError;
+	}
+	for (ancestor = textPtr->tkwin; ;
+		ancestor = Tk_Parent(ancestor)) {
+	    if (ancestor == Tk_Parent(ewPtr->body.ew.tkwin)) {
+		break;
+	    }
+	    if (Tk_IsTopLevel(ancestor)) {
+		badMaster:
+		Tcl_AppendResult(textPtr->interp, "can't embed ",
+			Tk_PathName(ewPtr->body.ew.tkwin), " relative to ",
+			Tk_PathName(textPtr->tkwin), (char *) NULL);
+		Tcl_BackgroundError(textPtr->interp);
+		ewPtr->body.ew.tkwin = NULL;
+		goto gotWindow;
+	    }
+	}
+	if (Tk_IsTopLevel(ewPtr->body.ew.tkwin)
+		|| (textPtr->tkwin == ewPtr->body.ew.tkwin)) {
+	    goto badMaster;
+	}
+	Tk_ManageGeometry(ewPtr->body.ew.tkwin, &textGeomType,
+		(ClientData) ewPtr);
+	Tk_CreateEventHandler(ewPtr->body.ew.tkwin, StructureNotifyMask,
+		EmbWinStructureProc, (ClientData) ewPtr);
+
+	/*
+	 * Special trick!  Must enter into the hash table *after*
+	 * calling Tk_ManageGeometry:  if the window was already managed
+	 * elsewhere in this text, the Tk_ManageGeometry call will cause
+	 * the entry to be removed, which could potentially lose the new
+	 * entry.
+	 */
+
+	hPtr = Tcl_CreateHashEntry(&textPtr->windowTable,
+		Tk_PathName(ewPtr->body.ew.tkwin), &new);
+	Tcl_SetHashValue(hPtr, ewPtr);
+    }
+
+    /*
+     * See if there's room for this window on this line.
+     */
+
+    gotWindow:
+    if (ewPtr->body.ew.tkwin == NULL) {
+	width = 0;
+	height = 0;
+    } else {
+	width = Tk_ReqWidth(ewPtr->body.ew.tkwin) + 2*ewPtr->body.ew.padX;
+	height = Tk_ReqHeight(ewPtr->body.ew.tkwin) + 2*ewPtr->body.ew.padY;
+    }
+    if ((width > (maxX - chunkPtr->x))
+	    && !noCharsYet && (textPtr->wrapMode != tkTextNoneUid)) {
+	return 0;
+    }
+
+    /*
+     * Fill in the chunk structure.
+     */
+
+    chunkPtr->displayProc = EmbWinDisplayProc;
+    chunkPtr->undisplayProc = EmbWinUndisplayProc;
+    chunkPtr->measureProc = (Tk_ChunkMeasureProc *) NULL;
+    chunkPtr->bboxProc = EmbWinBboxProc;
+    chunkPtr->numChars = 1;
+    if (ewPtr->body.ew.align == ALIGN_BASELINE) {
+	chunkPtr->minAscent = height - ewPtr->body.ew.padY;
+	chunkPtr->minDescent = ewPtr->body.ew.padY;
+	chunkPtr->minHeight = 0;
+    } else {
+	chunkPtr->minAscent = 0;
+	chunkPtr->minDescent = 0;
+	chunkPtr->minHeight = height;
+    }
+    chunkPtr->width = width;
+    chunkPtr->breakIndex = -1;
+    chunkPtr->breakIndex = 1;
+    chunkPtr->clientData = (ClientData) ewPtr;
+    ewPtr->body.ew.chunkCount += 1;
+    return 1;
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * EmbWinCheckProc --
+ *
+ *	This procedure is invoked by the B-tree code to perform
+ *	consistency checks on embedded windows.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The procedure panics if it detects anything wrong with
+ *	the embedded window.
+ *
+ *--------------------------------------------------------------
+ */
+
+static void
+EmbWinCheckProc(ewPtr, linePtr)
+    TkTextSegment *ewPtr;		/* Segment to check. */
+    TkTextLine *linePtr;		/* Line containing segment. */
+{
+    if (ewPtr->nextPtr == NULL) {
+	panic("EmbWinCheckProc: embedded window is last segment in line");
+    }
+    if (ewPtr->size != 1) {
+	panic("EmbWinCheckProc: embedded window has size %d", ewPtr->size);
+    }
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * EmbWinDisplayProc --
+ *
+ *	This procedure is invoked by the text displaying code
+ *	when it is time to actually draw an embedded window
+ *	chunk on the screen.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The embedded window gets moved to the correct location
+ *	and mapped onto the screen.
+ *
+ *--------------------------------------------------------------
+ */
+
+static void
+EmbWinDisplayProc(chunkPtr, x, y, lineHeight, baseline, display, dst, screenY)
+    TkTextDispChunk *chunkPtr;		/* Chunk that is to be drawn. */
+    int x;				/* X-position in dst at which to
+					 * draw this chunk (differs from
+					 * the x-position in the chunk because
+					 * of scrolling). */
+    int y;				/* Top of rectangular bounding box
+					 * for line: tells where to draw this
+					 * chunk in dst (x-position is in
+					 * the chunk itself). */
+    int lineHeight;			/* Total height of line. */
+    int baseline;			/* Offset of baseline from y. */
+    Display *display;			/* Display to use for drawing. */
+    Drawable dst;			/* Pixmap or window in which to draw */
+    int screenY;			/* Y-coordinate in text window that
+					 * corresponds to y. */
+{
+    TkTextSegment *ewPtr = (TkTextSegment *) chunkPtr->clientData;
+    int lineX, windowX, windowY, width, height;
+    Tk_Window tkwin;
+
+    tkwin = ewPtr->body.ew.tkwin;
+    if (tkwin == NULL) {
+	return;
+    }
+    if ((x + chunkPtr->width) <= 0) {
+	/*
+	 * The window is off-screen;  just unmap it.
+	 */
+
+	if (ewPtr->body.ew.textPtr->tkwin != Tk_Parent(tkwin)) {
+	    Tk_UnmaintainGeometry(tkwin, ewPtr->body.ew.textPtr->tkwin);
+	} else {
+	    Tk_UnmapWindow(tkwin);
+	}
+	return;
+    }
+
+    /*
+     * Compute the window's location and size in the text widget, taking
+     * into account the align and stretch values for the window.
+     */
+
+    EmbWinBboxProc(chunkPtr, 0, screenY, lineHeight, baseline, &lineX,
+	    &windowY, &width, &height);
+    windowX = lineX - chunkPtr->x + x;
+
+    if (ewPtr->body.ew.textPtr->tkwin == Tk_Parent(tkwin)) {
+	if ((windowX != Tk_X(tkwin)) || (windowY != Tk_Y(tkwin))
+		|| (Tk_ReqWidth(tkwin) != Tk_Width(tkwin))
+		|| (height != Tk_Height(tkwin))) {
+	    Tk_MoveResizeWindow(tkwin, windowX, windowY, width, height);
+	}
+	Tk_MapWindow(tkwin);
+    } else {
+	Tk_MaintainGeometry(tkwin, ewPtr->body.ew.textPtr->tkwin,
+		windowX, windowY, width, height);
+    }
+
+    /*
+     * Mark the window as displayed so that it won't get unmapped.
+     */
+
+    ewPtr->body.ew.displayed = 1;
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * EmbWinUndisplayProc --
+ *
+ *	This procedure is called when the chunk for an embedded
+ *	window is no longer going to be displayed.  It arranges
+ *	for the window associated with the chunk to be unmapped.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The window is scheduled for unmapping.
+ *
+ *--------------------------------------------------------------
+ */
+
+static void
+EmbWinUndisplayProc(textPtr, chunkPtr)
+    TkText *textPtr;			/* Overall information about text
+					 * widget. */
+    TkTextDispChunk *chunkPtr;		/* Chunk that is about to be freed. */
+{
+    TkTextSegment *ewPtr = (TkTextSegment *) chunkPtr->clientData;
+
+    ewPtr->body.ew.chunkCount--;
+    if (ewPtr->body.ew.chunkCount == 0) {
+	/*
+	 * Don't unmap the window immediately, since there's a good chance
+	 * that it will immediately be redisplayed, perhaps even in the
+	 * same place.  Instead, schedule the window to be unmapped later;
+	 * the call to EmbWinDelayedUnmap will be cancelled in the likely
+	 * event that the unmap becomes unnecessary.
+	 */
+
+	ewPtr->body.ew.displayed = 0;
+	Tcl_DoWhenIdle(EmbWinDelayedUnmap, (ClientData) ewPtr);
+    }
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * EmbWinBboxProc --
+ *
+ *	This procedure is called to compute the bounding box of
+ *	the area occupied by an embedded window.
+ *
+ * Results:
+ *	There is no return value.  *xPtr and *yPtr are filled in
+ *	with the coordinates of the upper left corner of the
+ *	window, and *widthPtr and *heightPtr are filled in with
+ *	the dimensions of the window in pixels.  Note:  not all
+ *	of the returned bbox is necessarily visible on the screen
+ *	(the rightmost part might be off-screen to the right,
+ *	and the bottommost part might be off-screen to the bottom).
+ *
+ * Side effects:
+ *	None.
+ *
+ *--------------------------------------------------------------
+ */
+
+static void
+EmbWinBboxProc(chunkPtr, index, y, lineHeight, baseline, xPtr, yPtr,
+	widthPtr, heightPtr)
+    TkTextDispChunk *chunkPtr;		/* Chunk containing desired char. */
+    int index;				/* Index of desired character within
+					 * the chunk. */
+    int y;				/* Topmost pixel in area allocated
+					 * for this line. */
+    int lineHeight;			/* Total height of line. */
+    int baseline;			/* Location of line's baseline, in
+					 * pixels measured down from y. */
+    int *xPtr, *yPtr;			/* Gets filled in with coords of
+					 * character's upper-left pixel. */
+    int *widthPtr;			/* Gets filled in with width of
+					 * character, in pixels. */
+    int *heightPtr;			/* Gets filled in with height of
+					 * character, in pixels. */
+{
+    TkTextSegment *ewPtr = (TkTextSegment *) chunkPtr->clientData;
+    Tk_Window tkwin;
+
+    tkwin = ewPtr->body.ew.tkwin;
+    if (tkwin != NULL) {
+	*widthPtr = Tk_ReqWidth(tkwin);
+	*heightPtr = Tk_ReqHeight(tkwin);
+    } else {
+	*widthPtr = 0;
+	*heightPtr = 0;
+    }
+    *xPtr = chunkPtr->x + ewPtr->body.ew.padX;
+    if (ewPtr->body.ew.stretch) {
+	if (ewPtr->body.ew.align == ALIGN_BASELINE) {
+	    *heightPtr = baseline - ewPtr->body.ew.padY;
+	} else {
+	    *heightPtr = lineHeight - 2*ewPtr->body.ew.padY;
+	}
+    }
+    switch (ewPtr->body.ew.align) {
+	case ALIGN_BOTTOM:
+	    *yPtr = y + (lineHeight - *heightPtr - ewPtr->body.ew.padY);
+	    break;
+	case ALIGN_CENTER:
+	    *yPtr = y + (lineHeight - *heightPtr)/2;
+	    break;
+	case ALIGN_TOP:
+	    *yPtr = y + ewPtr->body.ew.padY;
+	    break;
+	case ALIGN_BASELINE:
+	    *yPtr = y + (baseline - *heightPtr);
+	    break;
+    }
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * EmbWinDelayedUnmap --
+ *
+ *	This procedure is an idle handler that does the actual
+ *	work of unmapping an embedded window.  See the comment
+ *	in EmbWinUndisplayProc for details.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The window gets unmapped, unless its chunk reference count
+ *	has become non-zero again.
+ *
+ *--------------------------------------------------------------
+ */
+
+static void
+EmbWinDelayedUnmap(clientData)
+    ClientData clientData;		/* Token for the window to
+					 * be unmapped. */
+{
+    TkTextSegment *ewPtr = (TkTextSegment *) clientData;
+
+    if (!ewPtr->body.ew.displayed && (ewPtr->body.ew.tkwin != NULL)) {
+	if (ewPtr->body.ew.textPtr->tkwin != Tk_Parent(ewPtr->body.ew.tkwin)) {
+	    Tk_UnmaintainGeometry(ewPtr->body.ew.tkwin,
+		    ewPtr->body.ew.textPtr->tkwin);
+	} else {
+	    Tk_UnmapWindow(ewPtr->body.ew.tkwin);
+	}
+    }
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * TkTextWindowIndex --
+ *
+ *	Given the name of an embedded window within a text widget,
+ *	returns an index corresponding to the window's position
+ *	in the text.
+ *
+ * Results:
+ *	The return value is 1 if there is an embedded window by
+ *	the given name in the text widget, 0 otherwise.  If the
+ *	window exists, *indexPtr is filled in with its index.
+ *
+ * Side effects:
+ *	None.
+ *
+ *--------------------------------------------------------------
+ */
+
+int
+TkTextWindowIndex(textPtr, name, indexPtr)
+    TkText *textPtr;		/* Text widget containing window. */
+    char *name;			/* Name of window. */
+    TkTextIndex *indexPtr;	/* Index information gets stored here. */
+{
+    Tcl_HashEntry *hPtr;
+    TkTextSegment *ewPtr;
+
+    hPtr = Tcl_FindHashEntry(&textPtr->windowTable, name);
+    if (hPtr == NULL) {
+	return 0;
+    }
+    ewPtr = (TkTextSegment *) Tcl_GetHashValue(hPtr);
+    indexPtr->tree = textPtr->tree;
+    indexPtr->linePtr = ewPtr->body.ew.linePtr;
+    indexPtr->charIndex = TkTextSegToOffset(ewPtr, indexPtr->linePtr);
+    return 1;
+}