diff options
Diffstat (limited to 'tk8.6/generic/tkTextWind.c')
-rw-r--r-- | tk8.6/generic/tkTextWind.c | 1409 |
1 files changed, 1409 insertions, 0 deletions
diff --git a/tk8.6/generic/tkTextWind.c b/tk8.6/generic/tkTextWind.c new file mode 100644 index 0000000..c9fc20f --- /dev/null +++ b/tk8.6/generic/tkTextWind.c @@ -0,0 +1,1409 @@ +/* + * 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-1997 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution of + * this file, and for a DISCLAIMER OF ALL WARRANTIES. + */ + +#include "tkPort.h" +#include "tkText.h" + +/* + * The following structure is the official type record for the embedded window + * geometry manager: + */ + +static void EmbWinRequestProc(ClientData clientData, + Tk_Window tkwin); +static void EmbWinLostSlaveProc(ClientData clientData, + Tk_Window tkwin); + +static const Tk_GeomMgr textGeomType = { + "text", /* name */ + EmbWinRequestProc, /* requestProc */ + EmbWinLostSlaveProc, /* lostSlaveProc */ +}; + +/* + * Macro that determines the size of an embedded window segment: + */ + +#define EW_SEG_SIZE ((unsigned) (Tk_Offset(TkTextSegment, body) \ + + sizeof(TkTextEmbWindow))) + +/* + * Prototypes for functions defined in this file: + */ + +static TkTextSegment * EmbWinCleanupProc(TkTextSegment *segPtr, + TkTextLine *linePtr); +static void EmbWinCheckProc(TkTextSegment *segPtr, + TkTextLine *linePtr); +static void EmbWinBboxProc(TkText *textPtr, + TkTextDispChunk *chunkPtr, int index, int y, + int lineHeight, int baseline, int *xPtr,int *yPtr, + int *widthPtr, int *heightPtr); +static int EmbWinConfigure(TkText *textPtr, TkTextSegment *ewPtr, + int objc, Tcl_Obj *const objv[]); +static void EmbWinDelayedUnmap(ClientData clientData); +static int EmbWinDeleteProc(TkTextSegment *segPtr, + TkTextLine *linePtr, int treeGone); +static int EmbWinLayoutProc(TkText *textPtr, + TkTextIndex *indexPtr, TkTextSegment *segPtr, + int offset, int maxX, int maxChars,int noCharsYet, + TkWrapMode wrapMode, TkTextDispChunk *chunkPtr); +static void EmbWinStructureProc(ClientData clientData, + XEvent *eventPtr); +static void EmbWinUndisplayProc(TkText *textPtr, + TkTextDispChunk *chunkPtr); +static TkTextEmbWindowClient *EmbWinGetClient(const TkText *textPtr, + TkTextSegment *ewPtr); + +/* + * The following structure declares the "embedded window" segment type. + */ + +const Tk_SegType tkTextEmbWindowType = { + "window", /* name */ + 0, /* leftGravity */ + NULL, /* splitProc */ + EmbWinDeleteProc, /* deleteProc */ + EmbWinCleanupProc, /* cleanupProc */ + NULL, /* lineChangeProc */ + EmbWinLayoutProc, /* layoutProc */ + EmbWinCheckProc /* checkProc */ +}; + +/* + * Definitions for alignment values: + */ + +static const char *const alignStrings[] = { + "baseline", "bottom", "center", "top", NULL +}; + +typedef enum { + ALIGN_BASELINE, ALIGN_BOTTOM, ALIGN_CENTER, ALIGN_TOP +} alignMode; + +/* + * Information used for parsing window configuration options: + */ + +static const Tk_OptionSpec optionSpecs[] = { + {TK_OPTION_STRING_TABLE, "-align", NULL, NULL, + "center", -1, Tk_Offset(TkTextEmbWindow, align), + 0, alignStrings, 0}, + {TK_OPTION_STRING, "-create", NULL, NULL, + NULL, -1, Tk_Offset(TkTextEmbWindow, create), TK_OPTION_NULL_OK, 0, 0}, + {TK_OPTION_PIXELS, "-padx", NULL, NULL, + "0", -1, Tk_Offset(TkTextEmbWindow, padX), 0, 0, 0}, + {TK_OPTION_PIXELS, "-pady", NULL, NULL, + "0", -1, Tk_Offset(TkTextEmbWindow, padY), 0, 0, 0}, + {TK_OPTION_BOOLEAN, "-stretch", NULL, NULL, + "0", -1, Tk_Offset(TkTextEmbWindow, stretch), 0, 0, 0}, + {TK_OPTION_WINDOW, "-window", NULL, NULL, + NULL, -1, Tk_Offset(TkTextEmbWindow, tkwin), TK_OPTION_NULL_OK, 0, 0}, + {TK_OPTION_END, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0} +}; + +/* + *-------------------------------------------------------------- + * + * TkTextWindowCmd -- + * + * This function 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( + register TkText *textPtr, /* Information about text widget. */ + Tcl_Interp *interp, /* Current interpreter. */ + int objc, /* Number of arguments. */ + Tcl_Obj *const objv[]) /* Argument objects. Someone else has already + * parsed this command enough to know that + * objv[1] is "window". */ +{ + int optionIndex; + static const char *const windOptionStrings[] = { + "cget", "configure", "create", "names", NULL + }; + enum windOptions { + WIND_CGET, WIND_CONFIGURE, WIND_CREATE, WIND_NAMES + }; + register TkTextSegment *ewPtr; + + if (objc < 3) { + Tcl_WrongNumArgs(interp, 2, objv, "option ?arg ...?"); + return TCL_ERROR; + } + if (Tcl_GetIndexFromObjStruct(interp, objv[2], windOptionStrings, + sizeof(char *), "window option", 0, &optionIndex) != TCL_OK) { + return TCL_ERROR; + } + switch ((enum windOptions) optionIndex) { + case WIND_CGET: { + TkTextIndex index; + TkTextSegment *ewPtr; + Tcl_Obj *objPtr; + TkTextEmbWindowClient *client; + + if (objc != 5) { + Tcl_WrongNumArgs(interp, 3, objv, "index option"); + return TCL_ERROR; + } + if (TkTextGetObjIndex(interp, textPtr, objv[3], &index) != TCL_OK) { + return TCL_ERROR; + } + ewPtr = TkTextIndexToSeg(&index, NULL); + if (ewPtr->typePtr != &tkTextEmbWindowType) { + Tcl_SetObjResult(interp, Tcl_ObjPrintf( + "no embedded window at index \"%s\"", + Tcl_GetString(objv[3]))); + Tcl_SetErrorCode(interp, "TK", "TEXT", "NO_WINDOW", NULL); + return TCL_ERROR; + } + + /* + * Copy over client specific value before querying. + */ + + client = EmbWinGetClient(textPtr, ewPtr); + if (client != NULL) { + ewPtr->body.ew.tkwin = client->tkwin; + } else { + ewPtr->body.ew.tkwin = NULL; + } + + objPtr = Tk_GetOptionValue(interp, (char *) &ewPtr->body.ew, + ewPtr->body.ew.optionTable, objv[4], textPtr->tkwin); + if (objPtr == NULL) { + return TCL_ERROR; + } + Tcl_SetObjResult(interp, objPtr); + return TCL_OK; + } + case WIND_CONFIGURE: { + TkTextIndex index; + TkTextSegment *ewPtr; + + if (objc < 4) { + Tcl_WrongNumArgs(interp, 3, objv, "index ?-option value ...?"); + return TCL_ERROR; + } + if (TkTextGetObjIndex(interp, textPtr, objv[3], &index) != TCL_OK) { + return TCL_ERROR; + } + ewPtr = TkTextIndexToSeg(&index, NULL); + if (ewPtr->typePtr != &tkTextEmbWindowType) { + Tcl_SetObjResult(interp, Tcl_ObjPrintf( + "no embedded window at index \"%s\"", + Tcl_GetString(objv[3]))); + Tcl_SetErrorCode(interp, "TK", "TEXT", "NO_WINDOW", NULL); + return TCL_ERROR; + } + if (objc <= 5) { + TkTextEmbWindowClient *client; + Tcl_Obj *objPtr; + + /* + * Copy over client specific value before querying. + */ + + client = EmbWinGetClient(textPtr, ewPtr); + if (client != NULL) { + ewPtr->body.ew.tkwin = client->tkwin; + } else { + ewPtr->body.ew.tkwin = NULL; + } + + objPtr = Tk_GetOptionInfo(interp, (char *) &ewPtr->body.ew, + ewPtr->body.ew.optionTable, (objc == 5) ? objv[4] : NULL, + textPtr->tkwin); + if (objPtr == NULL) { + return TCL_ERROR; + } + Tcl_SetObjResult(interp, objPtr); + return TCL_OK; + } else { + TkTextChanged(textPtr->sharedTextPtr, NULL, &index, &index); + + /* + * It's probably not true that all window configuration can change + * the line height, so we could be more efficient here and only + * call this when necessary. + */ + + TkTextInvalidateLineMetrics(textPtr->sharedTextPtr, NULL, + index.linePtr, 0, TK_TEXT_INVALIDATE_ONLY); + return EmbWinConfigure(textPtr, ewPtr, objc-4, objv+4); + } + } + case WIND_CREATE: { + TkTextIndex index; + int lineIndex; + TkTextEmbWindowClient *client; + int res; + + /* + * Add a new window. Find where to put the new window, and mark that + * position for redisplay. + */ + + if (objc < 4) { + Tcl_WrongNumArgs(interp, 3, objv, "index ?-option value ...?"); + return TCL_ERROR; + } + if (TkTextGetObjIndex(interp, textPtr, objv[3], &index) != TCL_OK) { + return TCL_ERROR; + } + + /* + * Don't allow insertions on the last (dummy) line of the text. + */ + + lineIndex = TkBTreeLinesTo(textPtr, index.linePtr); + if (lineIndex == TkBTreeNumLines(textPtr->sharedTextPtr->tree, + textPtr)) { + lineIndex--; + TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr, + lineIndex, 1000000, &index); + } + + /* + * Create the new window segment and initialize it. + */ + + ewPtr = ckalloc(EW_SEG_SIZE); + ewPtr->typePtr = &tkTextEmbWindowType; + ewPtr->size = 1; + ewPtr->body.ew.sharedTextPtr = textPtr->sharedTextPtr; + 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.optionTable = Tk_CreateOptionTable(interp, optionSpecs); + + client = ckalloc(sizeof(TkTextEmbWindowClient)); + client->next = NULL; + client->textPtr = textPtr; + client->tkwin = NULL; + client->chunkCount = 0; + client->displayed = 0; + client->parent = ewPtr; + ewPtr->body.ew.clients = client; + + /* + * Link the segment into the text widget, then configure it (delete it + * again if the configuration fails). + */ + + TkTextChanged(textPtr->sharedTextPtr, NULL, &index, &index); + TkBTreeLinkSegment(ewPtr, &index); + res = EmbWinConfigure(textPtr, ewPtr, objc-4, objv+4); + client->tkwin = ewPtr->body.ew.tkwin; + if (res != TCL_OK) { + TkTextIndex index2; + + TkTextIndexForwChars(NULL, &index, 1, &index2, COUNT_INDICES); + TkBTreeDeleteIndexRange(textPtr->sharedTextPtr->tree, &index, + &index2); + return TCL_ERROR; + } + TkTextInvalidateLineMetrics(textPtr->sharedTextPtr, NULL, + index.linePtr, 0, TK_TEXT_INVALIDATE_ONLY); + break; + } + case WIND_NAMES: { + Tcl_HashSearch search; + Tcl_HashEntry *hPtr; + Tcl_Obj *resultObj; + + if (objc != 3) { + Tcl_WrongNumArgs(interp, 3, objv, NULL); + return TCL_ERROR; + } + resultObj = Tcl_NewObj(); + for (hPtr = Tcl_FirstHashEntry(&textPtr->sharedTextPtr->windowTable, + &search); hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) { + Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewStringObj( + Tcl_GetHashKey(&textPtr->sharedTextPtr->markTable, hPtr), + -1)); + } + Tcl_SetObjResult(interp, resultObj); + break; + } + } + return TCL_OK; +} + +/* + *-------------------------------------------------------------- + * + * EmbWinConfigure -- + * + * This function is called to handle configuration options for an + * embedded window, using an objc/objv list. + * + * Results: + * The return value is a standard Tcl result. If TCL_ERROR is returned, + * then the interp's result contains an error message.. + * + * Side effects: + * Configuration information for the embedded window changes, such as + * alignment, stretching, or name of the embedded window. + * + * Note that this function may leave widget specific client information + * with a NULL tkwin attached to ewPtr. While we could choose to clean up + * the client data structure here, there is no need to do so, and it is + * likely that the user is going to adjust the tkwin again soon. + * + *-------------------------------------------------------------- + */ + +static int +EmbWinConfigure( + TkText *textPtr, /* Information about text widget that contains + * embedded window. */ + TkTextSegment *ewPtr, /* Embedded window to be configured. */ + int objc, /* Number of strings in objv. */ + Tcl_Obj *const objv[]) /* Array of objects describing configuration + * options. */ +{ + Tk_Window oldWindow; + TkTextEmbWindowClient *client; + + /* + * Copy over client specific value before querying or setting. + */ + + client = EmbWinGetClient(textPtr, ewPtr); + if (client != NULL) { + ewPtr->body.ew.tkwin = client->tkwin; + } else { + ewPtr->body.ew.tkwin = NULL; + } + + oldWindow = ewPtr->body.ew.tkwin; + if (Tk_SetOptions(textPtr->interp, (char *) &ewPtr->body.ew, + ewPtr->body.ew.optionTable, objc, objv, textPtr->tkwin, NULL, + NULL) != TCL_OK) { + return TCL_ERROR; + } + + if (oldWindow != ewPtr->body.ew.tkwin) { + if (oldWindow != NULL) { + Tcl_DeleteHashEntry(Tcl_FindHashEntry( + &textPtr->sharedTextPtr->windowTable, + Tk_PathName(oldWindow))); + Tk_DeleteEventHandler(oldWindow, StructureNotifyMask, + EmbWinStructureProc, client); + Tk_ManageGeometry(oldWindow, NULL, NULL); + if (textPtr->tkwin != Tk_Parent(oldWindow)) { + Tk_UnmaintainGeometry(oldWindow, textPtr->tkwin); + } else { + Tk_UnmapWindow(oldWindow); + } + } + if (client != NULL) { + client->tkwin = NULL; + } + if (ewPtr->body.ew.tkwin != NULL) { + Tk_Window ancestor, parent; + Tcl_HashEntry *hPtr; + int isNew; + + /* + * 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_TopWinHierarchy(ancestor)) { + badMaster: + Tcl_SetObjResult(textPtr->interp, Tcl_ObjPrintf( + "can't embed %s in %s", + Tk_PathName(ewPtr->body.ew.tkwin), + Tk_PathName(textPtr->tkwin))); + Tcl_SetErrorCode(textPtr->interp, "TK", "GEOMETRY", + "HIERARCHY", NULL); + ewPtr->body.ew.tkwin = NULL; + if (client != NULL) { + client->tkwin = NULL; + } + return TCL_ERROR; + } + } + if (Tk_TopWinHierarchy(ewPtr->body.ew.tkwin) + || (ewPtr->body.ew.tkwin == textPtr->tkwin)) { + goto badMaster; + } + + if (client == NULL) { + /* + * Have to make the new client. + */ + + client = ckalloc(sizeof(TkTextEmbWindowClient)); + client->next = ewPtr->body.ew.clients; + client->textPtr = textPtr; + client->tkwin = NULL; + client->chunkCount = 0; + client->displayed = 0; + client->parent = ewPtr; + ewPtr->body.ew.clients = client; + } + client->tkwin = ewPtr->body.ew.tkwin; + + /* + * 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, client); + Tk_CreateEventHandler(ewPtr->body.ew.tkwin, StructureNotifyMask, + EmbWinStructureProc, client); + + /* + * 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->sharedTextPtr->windowTable, + Tk_PathName(ewPtr->body.ew.tkwin), &isNew); + Tcl_SetHashValue(hPtr, ewPtr); + } + } + return TCL_OK; +} + +/* + *-------------------------------------------------------------- + * + * EmbWinStructureProc -- + * + * This function is invoked by the Tk event loop whenever StructureNotify + * events occur for a window that's embedded in a text widget. This + * function'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 clientData, /* Pointer to record describing window item. */ + XEvent *eventPtr) /* Describes what just happened. */ +{ + TkTextEmbWindowClient *client = clientData; + TkTextSegment *ewPtr = client->parent; + TkTextIndex index; + Tcl_HashEntry *hPtr; + + if (eventPtr->type != DestroyNotify) { + return; + } + + hPtr = Tcl_FindHashEntry(&ewPtr->body.ew.sharedTextPtr->windowTable, + Tk_PathName(client->tkwin)); + if (hPtr != NULL) { + /* + * This may not exist if the entire widget is being deleted. + */ + + Tcl_DeleteHashEntry(hPtr); + } + + ewPtr->body.ew.tkwin = NULL; + client->tkwin = NULL; + index.tree = ewPtr->body.ew.sharedTextPtr->tree; + index.linePtr = ewPtr->body.ew.linePtr; + index.byteIndex = TkTextSegToOffset(ewPtr, ewPtr->body.ew.linePtr); + TkTextChanged(ewPtr->body.ew.sharedTextPtr, NULL, &index, &index); + TkTextInvalidateLineMetrics(ewPtr->body.ew.sharedTextPtr, NULL, + index.linePtr, 0, TK_TEXT_INVALIDATE_ONLY); +} + +/* + *-------------------------------------------------------------- + * + * EmbWinRequestProc -- + * + * This function 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 clientData, /* Pointer to record for window item. */ + Tk_Window tkwin) /* Window that changed its desired size. */ +{ + TkTextEmbWindowClient *client = clientData; + TkTextSegment *ewPtr = client->parent; + TkTextIndex index; + + index.tree = ewPtr->body.ew.sharedTextPtr->tree; + index.linePtr = ewPtr->body.ew.linePtr; + index.byteIndex = TkTextSegToOffset(ewPtr, ewPtr->body.ew.linePtr); + TkTextChanged(ewPtr->body.ew.sharedTextPtr, NULL, &index, &index); + TkTextInvalidateLineMetrics(ewPtr->body.ew.sharedTextPtr, NULL, + index.linePtr, 0, TK_TEXT_INVALIDATE_ONLY); +} + +/* + *-------------------------------------------------------------- + * + * EmbWinLostSlaveProc -- + * + * This function 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 clientData, /* Pointer to record describing window item. */ + Tk_Window tkwin) /* Window that was claimed away by another + * geometry manager. */ +{ + TkTextEmbWindowClient *client = clientData; + TkTextSegment *ewPtr = client->parent; + TkTextIndex index; + Tcl_HashEntry *hPtr; + TkTextEmbWindowClient *loop; + + Tk_DeleteEventHandler(client->tkwin, StructureNotifyMask, + EmbWinStructureProc, client); + Tcl_CancelIdleCall(EmbWinDelayedUnmap, client); + if (client->textPtr->tkwin != Tk_Parent(tkwin)) { + Tk_UnmaintainGeometry(tkwin, client->textPtr->tkwin); + } else { + Tk_UnmapWindow(tkwin); + } + hPtr = Tcl_FindHashEntry(&ewPtr->body.ew.sharedTextPtr->windowTable, + Tk_PathName(client->tkwin)); + Tcl_DeleteHashEntry(hPtr); + client->tkwin = NULL; + ewPtr->body.ew.tkwin = NULL; + + /* + * Free up the memory allocation for this client. + */ + + loop = ewPtr->body.ew.clients; + if (loop == client) { + ewPtr->body.ew.clients = client->next; + } else { + while (loop->next != client) { + loop = loop->next; + } + loop->next = client->next; + } + ckfree(client); + + index.tree = ewPtr->body.ew.sharedTextPtr->tree; + index.linePtr = ewPtr->body.ew.linePtr; + index.byteIndex = TkTextSegToOffset(ewPtr, ewPtr->body.ew.linePtr); + TkTextChanged(ewPtr->body.ew.sharedTextPtr, NULL, &index, &index); + TkTextInvalidateLineMetrics(ewPtr->body.ew.sharedTextPtr, NULL, + index.linePtr, 0, TK_TEXT_INVALIDATE_ONLY); +} + +/* + *-------------------------------------------------------------- + * + * TkTextWinFreeClient -- + * + * Free up the hash entry and client information for a given embedded + * window. + * + * It is assumed the caller will manage the linked list of clients + * associated with the relevant TkTextSegment. + * + * Results: + * Nothing. + * + * Side effects: + * The embedded window information for a single client is deleted, if it + * exists, and any resources associated with it are released. + * + *-------------------------------------------------------------- + */ + +void +TkTextWinFreeClient( + Tcl_HashEntry *hPtr, /* Hash entry corresponding to this client, or + * NULL */ + TkTextEmbWindowClient *client) + /* Client data structure, with the 'tkwin' + * field to be cleaned up. */ +{ + 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). + */ + + if (client->tkwin != NULL) { + Tk_DeleteEventHandler(client->tkwin, StructureNotifyMask, + EmbWinStructureProc, client); + Tk_DestroyWindow(client->tkwin); + } + Tcl_CancelIdleCall(EmbWinDelayedUnmap, client); + + /* + * Free up this client. + */ + + ckfree(client); +} + +/* + *-------------------------------------------------------------- + * + * EmbWinDeleteProc -- + * + * This function 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( + 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. */ +{ + TkTextEmbWindowClient *client; + client = ewPtr->body.ew.clients; + + while (client != NULL) { + TkTextEmbWindowClient *next = client->next; + Tcl_HashEntry *hPtr = NULL; + + if (client->tkwin != NULL) { + hPtr = Tcl_FindHashEntry( + &ewPtr->body.ew.sharedTextPtr->windowTable, + Tk_PathName(client->tkwin)); + } + TkTextWinFreeClient(hPtr, client); + client = next; + } + ewPtr->body.ew.clients = NULL; + + Tk_FreeConfigOptions((char *) &ewPtr->body.ew, ewPtr->body.ew.optionTable, + NULL); + + /* + * Free up all memory allocated. + */ + + ckfree(ewPtr); + return 0; +} + +/* + *-------------------------------------------------------------- + * + * EmbWinCleanupProc -- + * + * This function 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( + TkTextSegment *ewPtr, /* Mark segment that's being moved. */ + TkTextLine *linePtr) /* Line that now contains segment. */ +{ + ewPtr->body.ew.linePtr = linePtr; + return ewPtr; +} + +/* + *-------------------------------------------------------------- + * + * EmbWinLayoutProc -- + * + * This function 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( + 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. */ + TkWrapMode wrapMode, /* Wrap mode to use for line: + * TEXT_WRAPMODE_CHAR, TEXT_WRAPMODE_NONE, or + * TEXT_WRAPMODE_WORD. */ + 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; + TkTextEmbWindowClient *client; + + if (offset != 0) { + Tcl_Panic("Non-zero offset in EmbWinLayoutProc"); + } + + client = EmbWinGetClient(textPtr, ewPtr); + if (client == NULL) { + ewPtr->body.ew.tkwin = NULL; + } else { + ewPtr->body.ew.tkwin = client->tkwin; + } + + if ((ewPtr->body.ew.tkwin == NULL) && (ewPtr->body.ew.create != NULL)) { + int code, isNew; + Tk_Window ancestor; + Tcl_HashEntry *hPtr; + const char *before, *string; + Tcl_DString buf, *dsPtr = NULL; + Tcl_Obj *nameObj; + + before = ewPtr->body.ew.create; + + /* + * Find everything up to the next % character and append it to the + * result string. + */ + + string = before; + while (*string != 0) { + if ((*string == '%') && (string[1] == '%' || string[1] == 'W')) { + if (dsPtr == NULL) { + Tcl_DStringInit(&buf); + dsPtr = &buf; + } + if (string != before) { + Tcl_DStringAppend(dsPtr, before, (int) (string-before)); + before = string; + } + if (string[1] == '%') { + Tcl_DStringAppend(dsPtr, "%", 1); + } else { + /* + * Substitute string as proper Tcl list element. + */ + + int spaceNeeded, cvtFlags, length; + const char *str = Tk_PathName(textPtr->tkwin); + + spaceNeeded = Tcl_ScanElement(str, &cvtFlags); + length = Tcl_DStringLength(dsPtr); + Tcl_DStringSetLength(dsPtr, length + spaceNeeded); + spaceNeeded = Tcl_ConvertElement(str, + Tcl_DStringValue(dsPtr) + length, + cvtFlags | TCL_DONT_USE_BRACES); + Tcl_DStringSetLength(dsPtr, length + spaceNeeded); + } + before += 2; + string++; + } + string++; + } + + /* + * 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. + */ + + if (dsPtr != NULL) { + Tcl_DStringAppend(dsPtr, before, (int) (string-before)); + code = Tcl_EvalEx(textPtr->interp, Tcl_DStringValue(dsPtr), -1, TCL_EVAL_GLOBAL); + Tcl_DStringFree(dsPtr); + } else { + code = Tcl_EvalEx(textPtr->interp, ewPtr->body.ew.create, -1, TCL_EVAL_GLOBAL); + } + if (code != TCL_OK) { + Tcl_BackgroundException(textPtr->interp, code); + goto gotWindow; + } + nameObj = Tcl_GetObjResult(textPtr->interp); + Tcl_IncrRefCount(nameObj); + Tcl_ResetResult(textPtr->interp); + ewPtr->body.ew.tkwin = Tk_NameToWindow(textPtr->interp, + Tcl_GetString(nameObj), textPtr->tkwin); + Tcl_DecrRefCount(nameObj); + if (ewPtr->body.ew.tkwin == NULL) { + Tcl_BackgroundException(textPtr->interp, TCL_ERROR); + goto gotWindow; + } + + for (ancestor = textPtr->tkwin; ; ancestor = Tk_Parent(ancestor)) { + if (ancestor == Tk_Parent(ewPtr->body.ew.tkwin)) { + break; + } + if (Tk_TopWinHierarchy(ancestor)) { + goto badMaster; + } + } + if (Tk_TopWinHierarchy(ewPtr->body.ew.tkwin) + || (textPtr->tkwin == ewPtr->body.ew.tkwin)) { + badMaster: + Tcl_SetObjResult(textPtr->interp, Tcl_ObjPrintf( + "can't embed %s relative to %s", + Tk_PathName(ewPtr->body.ew.tkwin), + Tk_PathName(textPtr->tkwin))); + Tcl_SetErrorCode(textPtr->interp, "TK", "GEOMETRY", "HIERARCHY", + NULL); + Tcl_BackgroundException(textPtr->interp, TCL_ERROR); + ewPtr->body.ew.tkwin = NULL; + goto gotWindow; + } + + if (client == NULL) { + /* + * We just used a '-create' script to make a new window, which we + * now need to add to our client list. + */ + + client = ckalloc(sizeof(TkTextEmbWindowClient)); + client->next = ewPtr->body.ew.clients; + client->textPtr = textPtr; + client->tkwin = NULL; + client->chunkCount = 0; + client->displayed = 0; + client->parent = ewPtr; + ewPtr->body.ew.clients = client; + } + + client->tkwin = ewPtr->body.ew.tkwin; + Tk_ManageGeometry(client->tkwin, &textGeomType, client); + Tk_CreateEventHandler(client->tkwin, StructureNotifyMask, + EmbWinStructureProc, client); + + /* + * 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->sharedTextPtr->windowTable, + Tk_PathName(client->tkwin), &isNew); + 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 != TEXT_WRAPMODE_NONE)) { + return 0; + } + + /* + * Fill in the chunk structure. + */ + + chunkPtr->displayProc = TkTextEmbWinDisplayProc; + chunkPtr->undisplayProc = EmbWinUndisplayProc; + chunkPtr->measureProc = NULL; + chunkPtr->bboxProc = EmbWinBboxProc; + chunkPtr->numBytes = 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 = ewPtr; + if (client != NULL) { + client->chunkCount += 1; + } + return 1; +} + +/* + *-------------------------------------------------------------- + * + * EmbWinCheckProc -- + * + * This function is invoked by the B-tree code to perform consistency + * checks on embedded windows. + * + * Results: + * None. + * + * Side effects: + * The function panics if it detects anything wrong with the embedded + * window. + * + *-------------------------------------------------------------- + */ + +static void +EmbWinCheckProc( + TkTextSegment *ewPtr, /* Segment to check. */ + TkTextLine *linePtr) /* Line containing segment. */ +{ + if (ewPtr->nextPtr == NULL) { + Tcl_Panic("EmbWinCheckProc: embedded window is last segment in line"); + } + if (ewPtr->size != 1) { + Tcl_Panic("EmbWinCheckProc: embedded window has size %d", ewPtr->size); + } +} + +/* + *-------------------------------------------------------------- + * + * TkTextEmbWinDisplayProc -- + * + * This function 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. + * + *-------------------------------------------------------------- + */ + +void +TkTextEmbWinDisplayProc( + TkText *textPtr, /* Information about text widget. */ + 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 (unused). */ + Drawable dst, /* Pixmap or window in which to draw + * (unused). */ + int screenY) /* Y-coordinate in text window that + * corresponds to y. */ +{ + int lineX, windowX, windowY, width, height; + Tk_Window tkwin; + TkTextSegment *ewPtr = chunkPtr->clientData; + TkTextEmbWindowClient *client = EmbWinGetClient(textPtr, ewPtr); + + if (client == NULL) { + return; + } + + tkwin = client->tkwin; + if (tkwin == NULL) { + return; + } + + if ((x + chunkPtr->width) <= 0) { + /* + * The window is off-screen; just unmap it. + */ + + if (textPtr->tkwin != Tk_Parent(tkwin)) { + Tk_UnmaintainGeometry(tkwin, 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(textPtr, chunkPtr, 0, screenY, lineHeight, baseline, + &lineX, &windowY, &width, &height); + windowX = lineX - chunkPtr->x + x; + + /* + * Mark the window as displayed so that it won't get unmapped. + * This needs to be done before the next instruction block because + * Tk_MaintainGeometry/Tk_MapWindow will run event handlers, in + * particular for the <Map> event, and if the bound script deletes + * the embedded window its clients will get freed. + */ + + client->displayed = 1; + + if (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, textPtr->tkwin, windowX, windowY, + width, height); + } +} + +/* + *-------------------------------------------------------------- + * + * EmbWinUndisplayProc -- + * + * This function 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( + TkText *textPtr, /* Overall information about text widget. */ + TkTextDispChunk *chunkPtr) /* Chunk that is about to be freed. */ +{ + TkTextSegment *ewPtr = chunkPtr->clientData; + TkTextEmbWindowClient *client = EmbWinGetClient(textPtr, ewPtr); + + if (client == NULL) { + return; + } + + client->chunkCount--; + if (client->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. + */ + + client->displayed = 0; + Tcl_DoWhenIdle(EmbWinDelayedUnmap, client); + } +} + +/* + *-------------------------------------------------------------- + * + * EmbWinBboxProc -- + * + * This function 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( + TkText *textPtr, /* Information about text widget. */ + 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, int *yPtr, /* Gets filled in with coords of character's + * upper-left pixel. */ + int *widthPtr, /* Gets filled in with width of window, in + * pixels. */ + int *heightPtr) /* Gets filled in with height of window, in + * pixels. */ +{ + Tk_Window tkwin; + TkTextSegment *ewPtr = chunkPtr->clientData; + TkTextEmbWindowClient *client = EmbWinGetClient(textPtr, ewPtr); + + if (client == NULL) { + tkwin = NULL; + } else { + tkwin = client->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 function 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) /* Token for the window to be unmapped. */ +{ + TkTextEmbWindowClient *client = clientData; + + if (!client->displayed && (client->tkwin != NULL)) { + if (client->textPtr->tkwin != Tk_Parent(client->tkwin)) { + Tk_UnmaintainGeometry(client->tkwin, client->textPtr->tkwin); + } else { + Tk_UnmapWindow(client->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( + TkText *textPtr, /* Text widget containing window. */ + const char *name, /* Name of window. */ + TkTextIndex *indexPtr) /* Index information gets stored here. */ +{ + Tcl_HashEntry *hPtr; + TkTextSegment *ewPtr; + + if (textPtr == NULL) { + return 0; + } + + hPtr = Tcl_FindHashEntry(&textPtr->sharedTextPtr->windowTable, name); + if (hPtr == NULL) { + return 0; + } + + ewPtr = Tcl_GetHashValue(hPtr); + indexPtr->tree = textPtr->sharedTextPtr->tree; + indexPtr->linePtr = ewPtr->body.ew.linePtr; + indexPtr->byteIndex = TkTextSegToOffset(ewPtr, indexPtr->linePtr); + return 1; +} + +/* + *-------------------------------------------------------------- + * + * EmbWinGetClient -- + * + * Given a text widget and a segment which contains an embedded window, + * find the text-widget specific information about the embedded window, + * if any. + * + * This function performs a completely linear lookup for a matching data + * structure. If we envisage using this code with dozens of peer widgets, + * then performance could become an issue and a more sophisticated lookup + * mechanism might be desirable. + * + * Results: + * NULL if no widget-specific info exists, otherwise the structure is + * returned. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + +static TkTextEmbWindowClient * +EmbWinGetClient( + const TkText *textPtr, /* Information about text widget. */ + TkTextSegment *ewPtr) /* Segment containing embedded window. */ +{ + TkTextEmbWindowClient *client = ewPtr->body.ew.clients; + + while (client != NULL) { + if (client->textPtr == textPtr) { + return client; + } + client = client->next; + } + return NULL; +} + +/* + * Local Variables: + * mode: c + * c-basic-offset: 4 + * fill-column: 78 + * End: + */ |