From a5c9609a13c9be5cd6597c0c214eb11c66f177ab Mon Sep 17 00:00:00 2001 From: brad Date: Thu, 6 Jan 2000 05:43:42 +0000 Subject: [PATCH] split out patches --- x11/tk80/patches/patch-ac | 805 +------------------------------------- x11/tk80/patches/patch-ad | 22 ++ x11/tk80/patches/patch-ae | 135 +++++++ x11/tk80/patches/patch-af | 427 ++++++++++++++++++++ x11/tk80/patches/patch-ag | 52 +++ 5 files changed, 638 insertions(+), 803 deletions(-) create mode 100644 x11/tk80/patches/patch-ad create mode 100644 x11/tk80/patches/patch-ae create mode 100644 x11/tk80/patches/patch-af create mode 100644 x11/tk80/patches/patch-ag diff --git a/x11/tk80/patches/patch-ac b/x11/tk80/patches/patch-ac index 2b06d5c887d..6034266616f 100644 --- a/x11/tk80/patches/patch-ac +++ b/x11/tk80/patches/patch-ac @@ -1,5 +1,5 @@ ---- tkText.c Mon Sep 14 14:23:17 1998 -+++ ../generic/tkText.c Fri Mar 19 16:24:02 1999 +--- ../generic/tkText.c.orig Mon Sep 14 14:23:17 1998 ++++ ../generic/tkText.c Wed Jan 5 23:20:54 2000 @@ -866,6 +866,7 @@ || (textPtr->selTagPtr->spacing2String != NULL) || (textPtr->selTagPtr->spacing3String != NULL) @@ -74,804 +74,3 @@ continue; } Tcl_DStringAppend(&line, segPtr->body.chars, segPtr->size); -*** tkText.h 1997/07/04 22:39:41 2.0 ---- ../generic/tkText.h 1997/08/15 22:18:56 -*************** -*** 370,375 **** ---- 370,379 ---- - * Must be tkTextCharUid, tkTextNoneUid, - * tkTextWordUid, or NULL to use wrapMode - * for whole widget. */ -+ char *elideString; /* -elide option string (malloc-ed). -+ * NULL means option not specified. */ -+ int elide; /* Non-zero means text is elided. -+ * Only valid if elideString is non-NULL. */ - int affectsDisplay; /* Non-zero means that this tag affects the - * way information is displayed on the screen - * (so need to redisplay if tag changes). */ -*************** -*** 800,805 **** ---- 804,811 ---- - ClientData clientData)); - extern TkTextIndex * TkTextMakeIndex _ANSI_ARGS_((TkTextBTree tree, - int lineIndex, int charIndex, -+ TkTextIndex *indexPtr)); -+ extern int TkTextIsElided _ANSI_ARGS_((TkText *textPtr, - TkTextIndex *indexPtr)); - extern int TkTextMarkCmd _ANSI_ARGS_((TkText *textPtr, - Tcl_Interp *interp, int argc, char **argv)); -*** tkTextBTree.c 1997/07/04 22:39:41 2.0 ---- ../generic/tkTextBTree.c 1997/08/15 22:20:16 -*************** -*** 2427,2432 **** ---- 2427,2558 ---- - } - return tagInfo.tagPtrs; - } -+ -+ -+ /* -+ special case to just return information about elided attribute -+ specialized from TkBTreeGetTags(indexPtr, numTagsPtr) and GetStyle(textPtr, indexPtr) -+ just need to keep track of invisibility settings for each priority, pick highest one active at end -+ */ -+ int -+ TkTextIsElided(textPtr, indexPtr) -+ TkText *textPtr; /* Overall information about text widget. */ -+ TkTextIndex *indexPtr; /* The character in the text for which -+ * display information is wanted. */ -+ { -+ #define LOTSA_TAGS 1000 -+ int elide = 0; /* if nobody says otherwise, it's visible */ -+ -+ int deftagCnts[LOTSA_TAGS]; -+ int *tagCnts = deftagCnts; -+ TkTextTag *deftagPtrs[LOTSA_TAGS]; -+ TkTextTag **tagPtrs = deftagPtrs; -+ int numTags = textPtr->numTags; -+ register Node *nodePtr; -+ register TkTextLine *siblingLinePtr; -+ register TkTextSegment *segPtr; -+ register TkTextTag *tagPtr; -+ register int i, index; -+ -+ /* almost always avoid malloc, so stay out of system calls */ -+ if (LOTSA_TAGS < numTags) { -+ tagCnts = (int *)ckalloc((unsigned)sizeof(int) * numTags); -+ tagPtrs = (TkTextTag **)ckalloc((unsigned)sizeof(TkTextTag *) * numTags); -+ } -+ -+ for (i=0; ilinePtr->segPtr; -+ (index + segPtr->size) <= indexPtr->charIndex; -+ index += segPtr->size, segPtr = segPtr->nextPtr) { -+ if ((segPtr->typePtr == &tkTextToggleOnType) -+ || (segPtr->typePtr == &tkTextToggleOffType)) { -+ tagPtr = segPtr->body.toggle.tagPtr; -+ if (tagPtr->elideString != NULL) { -+ tagPtrs[tagPtr->priority] = tagPtr; -+ tagCnts[tagPtr->priority]++; -+ } -+ } -+ } -+ -+ /* -+ * Record toggles for tags in lines that are predecessors of -+ * indexPtr->linePtr but under the same level-0 node. -+ */ -+ -+ for (siblingLinePtr = indexPtr->linePtr->parentPtr->children.linePtr; -+ siblingLinePtr != indexPtr->linePtr; -+ siblingLinePtr = siblingLinePtr->nextPtr) { -+ for (segPtr = siblingLinePtr->segPtr; segPtr != NULL; -+ segPtr = segPtr->nextPtr) { -+ if ((segPtr->typePtr == &tkTextToggleOnType) -+ || (segPtr->typePtr == &tkTextToggleOffType)) { -+ tagPtr = segPtr->body.toggle.tagPtr; -+ if (tagPtr->elideString != NULL) { -+ tagPtrs[tagPtr->priority] = tagPtr; -+ tagCnts[tagPtr->priority]++; -+ } -+ } -+ } -+ } -+ -+ /* -+ * For each node in the ancestry of this line, record tag toggles -+ * for all siblings that precede that node. -+ */ -+ -+ for (nodePtr = indexPtr->linePtr->parentPtr; nodePtr->parentPtr != NULL; -+ nodePtr = nodePtr->parentPtr) { -+ register Node *siblingPtr; -+ register Summary *summaryPtr; -+ -+ for (siblingPtr = nodePtr->parentPtr->children.nodePtr; -+ siblingPtr != nodePtr; siblingPtr = siblingPtr->nextPtr) { -+ for (summaryPtr = siblingPtr->summaryPtr; summaryPtr != NULL; -+ summaryPtr = summaryPtr->nextPtr) { -+ if (summaryPtr->toggleCount & 1) { -+ tagPtr = summaryPtr->tagPtr; -+ if (tagPtr->elideString != NULL) { -+ tagPtrs[tagPtr->priority] = tagPtr; -+ tagCnts[tagPtr->priority] += summaryPtr->toggleCount; -+ } -+ } -+ } -+ } -+ } -+ -+ -+ /* -+ * Now traverse from highest priority to lowest, -+ * take elided value from first odd count (= on) -+ */ -+ -+ for (i = numTags-1; i >=0; i--) { -+ if (tagCnts[i] & 1) { -+ #ifndef ALWAYS_SHOW_SELECTION -+ /* who would make the selection elided? */ -+ if ((tagPtr == textPtr->selTagPtr) && !(textPtr->flags & GOT_FOCUS)) { -+ continue; -+ } -+ #endif -+ elide = tagPtrs[i]->elide; -+ break; -+ } -+ } -+ -+ if (LOTSA_TAGS < numTags) { -+ ckfree((char *) tagCnts); -+ ckfree((char *) tagPtrs); -+ } -+ -+ return elide; -+ } - - /* - *---------------------------------------------------------------------- -*** tkTextDisp.c 1997/07/04 22:39:41 2.0 ---- ../generic/tkTextDisp.c 1997/08/16 01:20:18 -*************** -*** 55,60 **** ---- 55,61 ---- - * be NULL). */ - int underline; /* Non-zero means draw underline underneath - * text. */ -+ int elide; /* Non-zero means draw text */ - Tk_Uid wrapMode; /* How to handle wrap-around for this tag. - * One of tkTextCharUid, tkTextNoneUid, - * or tkTextWordUid. */ -*************** -*** 311,316 **** ---- 312,332 ---- - int x)); - static void CharUndisplayProc _ANSI_ARGS_((TkText *textPtr, - TkTextDispChunk *chunkPtr)); -+ -+ /* -+ Definitions of elided procs. -+ Compiler can't inline these since we use pointers to these functions. -+ ElideDisplayProc, ElideUndisplayProc special-cased for speed, -+ as potentially many elided DLine chunks if large, tag toggle-filled -+ elided region. -+ */ -+ static void ElideBboxProc _ANSI_ARGS_((TkTextDispChunk *chunkPtr, -+ int index, int y, int lineHeight, int baseline, -+ int *xPtr, int *yPtr, int *widthPtr, -+ int *heightPtr)); -+ static int ElideMeasureProc _ANSI_ARGS_((TkTextDispChunk *chunkPtr, -+ int x)); -+ - static void DisplayDLine _ANSI_ARGS_((TkText *textPtr, - DLine *dlPtr, DLine *prevPtr, Pixmap pixmap)); - static void DisplayLineBackground _ANSI_ARGS_((TkText *textPtr, -*************** -*** 479,485 **** - - int borderPrio, borderWidthPrio, reliefPrio, bgStipplePrio; - int fgPrio, fontPrio, fgStipplePrio; -! int underlinePrio, justifyPrio, offsetPrio; - int lMargin1Prio, lMargin2Prio, rMarginPrio; - int spacing1Prio, spacing2Prio, spacing3Prio; - int overstrikePrio, tabPrio, wrapPrio; ---- 495,501 ---- - - int borderPrio, borderWidthPrio, reliefPrio, bgStipplePrio; - int fgPrio, fontPrio, fgStipplePrio; -! int underlinePrio, elidePrio, justifyPrio, offsetPrio; - int lMargin1Prio, lMargin2Prio, rMarginPrio; - int spacing1Prio, spacing2Prio, spacing3Prio; - int overstrikePrio, tabPrio, wrapPrio; -*************** -*** 494,500 **** - tagPtrs = TkBTreeGetTags(indexPtr, &numTags); - borderPrio = borderWidthPrio = reliefPrio = bgStipplePrio = -1; - fgPrio = fontPrio = fgStipplePrio = -1; -! underlinePrio = justifyPrio = offsetPrio = -1; - lMargin1Prio = lMargin2Prio = rMarginPrio = -1; - spacing1Prio = spacing2Prio = spacing3Prio = -1; - overstrikePrio = tabPrio = wrapPrio = -1; ---- 510,516 ---- - tagPtrs = TkBTreeGetTags(indexPtr, &numTags); - borderPrio = borderWidthPrio = reliefPrio = bgStipplePrio = -1; - fgPrio = fontPrio = fgStipplePrio = -1; -! underlinePrio = elidePrio = justifyPrio = offsetPrio = -1; - lMargin1Prio = lMargin2Prio = rMarginPrio = -1; - spacing1Prio = spacing2Prio = spacing3Prio = -1; - overstrikePrio = tabPrio = wrapPrio = -1; -*************** -*** 612,617 **** ---- 628,638 ---- - styleValues.underline = tagPtr->underline; - underlinePrio = tagPtr->priority; - } -+ if ((tagPtr->elideString != NULL) -+ && (tagPtr->priority > elidePrio)) { -+ styleValues.elide = tagPtr->elide; -+ elidePrio = tagPtr->priority; -+ } - if ((tagPtr->wrapMode != NULL) - && (tagPtr->priority > wrapPrio)) { - styleValues.wrapMode = tagPtr->wrapMode; -*************** -*** 768,774 **** - * lines with numChars > 0. Used to - * drop 0-sized chunks from the end - * of the line. */ -! int offset, ascent, descent, code; - StyleValues *sValuePtr; - - /* ---- 789,795 ---- - * lines with numChars > 0. Used to - * drop 0-sized chunks from the end - * of the line. */ -! int offset, ascent, descent, code, elide, elidesize; - StyleValues *sValuePtr; - - /* -*************** -*** 786,791 **** ---- 807,840 ---- - dlPtr->nextPtr = NULL; - dlPtr->flags = NEW_LAYOUT; - -+ -+ /* -+ * special case entirely elide line as there may be 1000s or more -+ */ -+ elide = TkTextIsElided(textPtr, indexPtr); /* save a malloc */ -+ if (elide && indexPtr->charIndex==0) { -+ maxChars = 0; -+ for (segPtr = indexPtr->linePtr->segPtr; elide && segPtr!=NULL; segPtr = segPtr->nextPtr) { -+ if ((elidesize = segPtr->size) > 0) { -+ maxChars += elidesize; -+ -+ /* if have tag toggle, chance that invisibility state changed, so bail out */ -+ } else if (segPtr->typePtr == &tkTextToggleOffType || segPtr->typePtr == &tkTextToggleOnType) { -+ if (segPtr->body.toggle.tagPtr->elideString!=NULL) { -+ elide = (segPtr->typePtr == &tkTextToggleOffType) ^ (segPtr->body.toggle.tagPtr->elide==1); -+ } -+ } -+ } -+ -+ if (elide) { -+ dlPtr->count = maxChars; -+ dlPtr->spaceAbove = dlPtr->spaceBelow = dlPtr->length = 0; -+ return dlPtr; -+ } -+ } -+ -+ -+ - /* - * Each iteration of the loop below creates one TkTextDispChunk for - * the new display line. The line will always have at least one -*************** -*** 797,802 **** ---- 846,852 ---- - lastChunkPtr = NULL; - chunkPtr = NULL; - noCharsYet = 1; -+ elide = 0; - breakChunkPtr = NULL; - breakCharOffset = 0; - justify = TK_JUSTIFY_LEFT; -*************** -*** 821,826 **** ---- 871,901 ---- - } - - while (segPtr != NULL) { -+ -+ /* every line still gets at least one chunk due to expectations in rest of code, -+ but able to skip elided portions of line quickly */ -+ /* if current chunk elided and last chunk was too, coalese */ -+ if (elide && lastChunkPtr!=NULL && lastChunkPtr->displayProc == NULL/*ElideDisplayProc*/) { -+ if ((elidesize = segPtr->size - offset) > 0) { -+ curIndex.charIndex += elidesize; -+ lastChunkPtr->numChars += elidesize; -+ breakCharOffset = lastChunkPtr->breakIndex = lastChunkPtr->numChars; -+ -+ /* if have tag toggle, chance that invisibility state changed */ -+ } else if (segPtr->typePtr == &tkTextToggleOffType || segPtr->typePtr == &tkTextToggleOnType) { -+ if (segPtr->body.toggle.tagPtr->elideString!=NULL) { -+ elide = (segPtr->typePtr == &tkTextToggleOffType) ^ (segPtr->body.toggle.tagPtr->elide==1); -+ } -+ } -+ -+ offset = 0; -+ segPtr = segPtr->nextPtr; -+ if (segPtr == NULL && chunkPtr != NULL) ckfree((char *) chunkPtr); -+ -+ continue; -+ } -+ -+ - if (segPtr->typePtr->layoutProc == NULL) { - segPtr = segPtr->nextPtr; - offset = 0; -*************** -*** 831,836 **** ---- 906,912 ---- - chunkPtr->nextPtr = NULL; - } - chunkPtr->stylePtr = GetStyle(textPtr, &curIndex); -+ elide = chunkPtr->stylePtr->sValuePtr->elide; - - /* - * Save style information such as justification and indentation, -*************** -*** 864,870 **** - - gotTab = 0; - maxChars = segPtr->size - offset; -! if (justify == TK_JUSTIFY_LEFT) { - if (segPtr->typePtr == &tkTextCharType) { - char *p; - ---- 940,946 ---- - - gotTab = 0; - maxChars = segPtr->size - offset; -! if (!elide && justify == TK_JUSTIFY_LEFT) { - if (segPtr->typePtr == &tkTextCharType) { - char *p; - -*************** -*** 877,884 **** - } - } - } -- - chunkPtr->x = x; - code = (*segPtr->typePtr->layoutProc)(textPtr, &curIndex, segPtr, - offset, maxX-tabSize, maxChars, noCharsYet, wrapMode, - chunkPtr); ---- 953,973 ---- - } - } - } - chunkPtr->x = x; -+ if (elide && maxChars) { -+ /* don't free style here, as other code expects to be able to do that */ -+ /*breakCharOffset =*/ chunkPtr->breakIndex = chunkPtr->numChars = maxChars; -+ chunkPtr->width = 0; -+ chunkPtr->minAscent = chunkPtr->minDescent = chunkPtr->minHeight = 0; -+ -+ /* would just like to point to canonical empty chunk */ -+ chunkPtr->displayProc = (Tk_ChunkDisplayProc *) NULL; -+ chunkPtr->undisplayProc = (Tk_ChunkUndisplayProc *) NULL; -+ chunkPtr->measureProc = ElideMeasureProc; -+ chunkPtr->bboxProc = ElideBboxProc; -+ -+ code = 1; -+ } else - code = (*segPtr->typePtr->layoutProc)(textPtr, &curIndex, segPtr, - offset, maxX-tabSize, maxChars, noCharsYet, wrapMode, - chunkPtr); -*************** -*** 950,955 **** ---- 1039,1045 ---- - offset = 0; - segPtr = segPtr->nextPtr; - } -+ - chunkPtr = NULL; - } - if (noCharsYet) { -*************** -*** 998,1003 **** ---- 1088,1094 ---- - wholeLine = 0; - } - -+ - /* - * Make tab adjustments for the last tab stop, if there is one. - */ -*************** -*** 1321,1326 **** ---- 1412,1418 ---- - index.linePtr = TkBTreeFindLine(textPtr->tree, lineNum); - index.charIndex = 0; - lowestPtr = NULL; -+ - do { - dlPtr = LayoutDLine(textPtr, &index); - dlPtr->nextPtr = lowestPtr; -*************** -*** 1554,1559 **** ---- 1646,1653 ---- - Display *display; - int height, x; - -+ if (dlPtr->chunkPtr == NULL) return; -+ - /* - * First, clear the area of the line to the background color for the - * text widget. -*************** -*** 1620,1631 **** ---- 1714,1729 ---- - * something is off to the right). - */ - -+ if (chunkPtr->displayProc != NULL) - (*chunkPtr->displayProc)(chunkPtr, -chunkPtr->width, - dlPtr->spaceAbove, - dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow, - dlPtr->baseline - dlPtr->spaceAbove, display, pixmap, - dlPtr->y + dlPtr->spaceAbove); - } else { -+ /* don't call if elide. This tax ok since not very many visible DLine's in -+ an area, but potentially many elide ones */ -+ if (chunkPtr->displayProc != NULL) - (*chunkPtr->displayProc)(chunkPtr, x, dlPtr->spaceAbove, - dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow, - dlPtr->baseline - dlPtr->spaceAbove, display, pixmap, -*************** -*** 1714,1719 **** ---- 1812,1818 ---- - StyleValues *sValuePtr; - Display *display; - -+ - /* - * Pass 1: scan through dlPtr from left to right. For each range of - * chunks with the same style, draw the main background for the style -*************** -*** 1787,1793 **** - rightX = maxX; - } - chunkPtr2 = NULL; -! if (prevPtr != NULL) { - /* - * Find the chunk in the previous line that covers leftX. - */ ---- 1886,1892 ---- - rightX = maxX; - } - chunkPtr2 = NULL; -! if (prevPtr != NULL && prevPtr->chunkPtr != NULL) { - /* - * Find the chunk in the previous line that covers leftX. - */ -*************** -*** 1908,1914 **** - rightX = maxX; - } - chunkPtr2 = NULL; -! if (dlPtr->nextPtr != NULL) { - /* - * Find the chunk in the previous line that covers leftX. - */ ---- 2007,2014 ---- - rightX = maxX; - } - chunkPtr2 = NULL; -! /* for (dlPtr2 = dlPtr; dlPtr2->nextPtr != NULL && dlPtr2->nextPtr->chunkPtr == NULL; dlPtr2 = dlPtr2->nextPtr) {}*/ -! if (dlPtr->nextPtr != NULL && dlPtr->nextPtr->chunkPtr != NULL) { - /* - * Find the chunk in the previous line that covers leftX. - */ -*************** -*** 2299,2304 **** ---- 2399,2405 ---- - for (prevPtr = NULL, dlPtr = textPtr->dInfoPtr->dLinePtr; - (dlPtr != NULL) && (dlPtr->y < dInfoPtr->maxY); - prevPtr = dlPtr, dlPtr = dlPtr->nextPtr) { -+ if (dlPtr->chunkPtr == NULL) continue; - if (dlPtr->oldY != dlPtr->y) { - if (tkTextDebug) { - char string[TK_POS_CHARS]; -*************** -*** 2315,2320 **** ---- 2416,2422 ---- - dlPtr->oldY = dlPtr->y; - dlPtr->flags &= ~NEW_LAYOUT; - } -+ /*prevPtr = dlPtr;*/ - } - Tk_FreePixmap(Tk_Display(textPtr->tkwin), pixmap); - } -*************** -*** 3369,3374 **** ---- 3471,3477 ---- - dlPtr = LayoutDLine(textPtr, &index); - dlPtr->nextPtr = lowestPtr; - lowestPtr = dlPtr; -+ if (dlPtr->length == 0 && dlPtr->height == 0) { offset--; break; } /* elide */ - TkTextIndexForwChars(&index, dlPtr->count, &index); - charsToCount -= dlPtr->count; - } while ((charsToCount > 0) -*************** -*** 3381,3387 **** - break; - } - } -! - /* - * Discard the display lines, then either return or prepare - * for the next display line to lay out. ---- 3484,3490 ---- - break; - } - } -! - /* - * Discard the display lines, then either return or prepare - * for the next display line to lay out. -*************** -*** 3410,3421 **** ---- 3513,3526 ---- - TkBTreeNumLines(textPtr->tree)); - for (i = 0; i < offset; i++) { - dlPtr = LayoutDLine(textPtr, &textPtr->topIndex); -+ if (dlPtr->length == 0 && dlPtr->height == 0) offset++; - dlPtr->nextPtr = NULL; - TkTextIndexForwChars(&textPtr->topIndex, dlPtr->count, &new); - FreeDLines(textPtr, dlPtr, (DLine *) NULL, 0); - if (new.linePtr == lastLinePtr) { - break; - } -+ - textPtr->topIndex = new; - } - } -*************** -*** 3949,3955 **** - * index of the character nearest to (x,y). */ - { - TextDInfo *dInfoPtr = textPtr->dInfoPtr; -! register DLine *dlPtr; - register TkTextDispChunk *chunkPtr; - - /* ---- 4054,4060 ---- - * index of the character nearest to (x,y). */ - { - TextDInfo *dInfoPtr = textPtr->dInfoPtr; -! register DLine *dlPtr, *validdlPtr; - register TkTextDispChunk *chunkPtr; - - /* -*************** -*** 3982,3989 **** - * Find the display line containing the desired y-coordinate. - */ - -! for (dlPtr = dInfoPtr->dLinePtr; y >= (dlPtr->y + dlPtr->height); - dlPtr = dlPtr->nextPtr) { - if (dlPtr->nextPtr == NULL) { - /* - * Y-coordinate is off the bottom of the displayed text. ---- 4087,4095 ---- - * Find the display line containing the desired y-coordinate. - */ - -! for (dlPtr = validdlPtr = dInfoPtr->dLinePtr; y >= (dlPtr->y + dlPtr->height); - dlPtr = dlPtr->nextPtr) { -+ if (dlPtr->chunkPtr !=NULL) validdlPtr = dlPtr; - if (dlPtr->nextPtr == NULL) { - /* - * Y-coordinate is off the bottom of the displayed text. -*************** -*** 3994,3999 **** ---- 4100,4107 ---- - break; - } - } -+ if (dlPtr->chunkPtr == NULL) dlPtr = validdlPtr; -+ - - /* - * Scan through the line's chunks to find the one that contains -*************** -*** 4005,4016 **** - *indexPtr = dlPtr->index; - x = x - dInfoPtr->x + dInfoPtr->curPixelOffset; - for (chunkPtr = dlPtr->chunkPtr; x >= (chunkPtr->x + chunkPtr->width); -! indexPtr->charIndex += chunkPtr->numChars, -! chunkPtr = chunkPtr->nextPtr) { - if (chunkPtr->nextPtr == NULL) { - indexPtr->charIndex += chunkPtr->numChars - 1; - return; -! } - } - - /* ---- 4113,4124 ---- - *indexPtr = dlPtr->index; - x = x - dInfoPtr->x + dInfoPtr->curPixelOffset; - for (chunkPtr = dlPtr->chunkPtr; x >= (chunkPtr->x + chunkPtr->width); -! indexPtr->charIndex += chunkPtr->numChars, -! chunkPtr = chunkPtr->nextPtr) { - if (chunkPtr->nextPtr == NULL) { - indexPtr->charIndex += chunkPtr->numChars - 1; - return; -! } - } - - /* -*************** -*** 4166,4171 **** ---- 4274,4280 ---- - { - TextDInfo *dInfoPtr = textPtr->dInfoPtr; - DLine *dlPtr; -+ int dlx; - - /* - * Make sure that all of the screen layout information is up to date. -*************** -*** 4184,4191 **** - return -1; - } - -! *xPtr = dInfoPtr->x - dInfoPtr->curPixelOffset + dlPtr->chunkPtr->x; -! *widthPtr = dlPtr->length - dlPtr->chunkPtr->x; - *yPtr = dlPtr->y; - if ((dlPtr->y + dlPtr->height) > dInfoPtr->maxY) { - *heightPtr = dInfoPtr->maxY - dlPtr->y; ---- 4293,4301 ---- - return -1; - } - -! dlx = (dlPtr->chunkPtr != NULL? dlPtr->chunkPtr->x: 0); -! *xPtr = dInfoPtr->x - dInfoPtr->curPixelOffset + dlx; -! *widthPtr = dlPtr->length - dlx; - *yPtr = dlPtr->y; - if ((dlPtr->y + dlPtr->height) > dInfoPtr->maxY) { - *heightPtr = dInfoPtr->maxY - dlPtr->y; -*************** -*** 4196,4201 **** ---- 4306,4346 ---- - return 0; - } - -+ static void -+ ElideBboxProc(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; /* Height of line, in pixels. */ -+ 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. -+ * X-coord is in same coordinate -+ * system as chunkPtr->x. */ -+ int *widthPtr; /* Gets filled in with width of -+ * character, in pixels. */ -+ int *heightPtr; /* Gets filled in with height of -+ * character, in pixels. */ -+ { -+ *xPtr = chunkPtr->x; -+ *yPtr = y; -+ *widthPtr = *heightPtr = 0; -+ } -+ -+ -+ static int -+ ElideMeasureProc(chunkPtr, x) -+ TkTextDispChunk *chunkPtr; /* Chunk containing desired coord. */ -+ int x; /* X-coordinate, in same coordinate -+ * system as chunkPtr->x. */ -+ { -+ return 0 /*chunkPtr->numChars - 1*/; -+ } -+ - /* - *-------------------------------------------------------------- - * -*************** -*** 4421,4427 **** - * Draw the text, underline, and overstrike for this chunk. - */ - -! if (ciPtr->numChars > offsetChars) { - int numChars = ciPtr->numChars - offsetChars; - char *string = ciPtr->chars + offsetChars; - ---- 4566,4572 ---- - * Draw the text, underline, and overstrike for this chunk. - */ - -! if (!sValuePtr->elide && ciPtr->numChars > offsetChars) { - int numChars = ciPtr->numChars - offsetChars; - char *string = ciPtr->chars + offsetChars; - -*** tkTextTag.c 1997/07/04 22:39:41 2.0 ---- ../generic/tkTextTag.c 1997/08/15 22:20:32 -*************** -*** 63,68 **** ---- 63,71 ---- - {TK_CONFIG_STRING, "-underline", (char *) NULL, (char *) NULL, - (char *) NULL, Tk_Offset(TkTextTag, underlineString), - TK_CONFIG_NULL_OK}, -+ {TK_CONFIG_STRING, "-elide", (char *) NULL, (char *) NULL, -+ (char *) NULL, Tk_Offset(TkTextTag, elideString), -+ TK_CONFIG_NULL_OK}, - {TK_CONFIG_UID, "-wrap", (char *) NULL, (char *) NULL, - (char *) NULL, Tk_Offset(TkTextTag, wrapMode), - TK_CONFIG_NULL_OK}, -*************** -*** 378,383 **** ---- 381,392 ---- - return TCL_ERROR; - } - } -+ if (tagPtr->elideString != NULL) { -+ if (Tcl_GetBoolean(interp, tagPtr->elideString, -+ &tagPtr->elide) != TCL_OK) { -+ return TCL_ERROR; -+ } -+ } - if ((tagPtr->wrapMode != NULL) - && (tagPtr->wrapMode != tkTextCharUid) - && (tagPtr->wrapMode != tkTextNoneUid) -*************** -*** 419,424 **** ---- 428,434 ---- - || (tagPtr->spacing3String != NULL) - || (tagPtr->tabString != NULL) - || (tagPtr->underlineString != NULL) -+ || (tagPtr->elideString != NULL) - || (tagPtr->wrapMode != NULL)) { - tagPtr->affectsDisplay = 1; - } -*************** -*** 811,816 **** ---- 821,828 ---- - tagPtr->tabArrayPtr = NULL; - tagPtr->underlineString = NULL; - tagPtr->underline = 0; -+ tagPtr->elideString = NULL; -+ tagPtr->elide = 0; - tagPtr->wrapMode = NULL; - tagPtr->affectsDisplay = 0; - textPtr->numTags++; -*************** -*** 934,939 **** ---- 946,954 ---- - } - if (tagPtr->underlineString != NULL) { - ckfree(tagPtr->underlineString); -+ } -+ if (tagPtr->elideString != NULL) { -+ ckfree(tagPtr->elideString); - } - ckfree((char *) tagPtr); - } diff --git a/x11/tk80/patches/patch-ad b/x11/tk80/patches/patch-ad new file mode 100644 index 00000000000..00f17f901fe --- /dev/null +++ b/x11/tk80/patches/patch-ad @@ -0,0 +1,22 @@ +--- ../generic/tkText.h.orig Mon Sep 14 14:23:18 1998 ++++ ../generic/tkText.h Wed Jan 5 23:20:55 2000 +@@ -370,6 +370,10 @@ + * Must be tkTextCharUid, tkTextNoneUid, + * tkTextWordUid, or NULL to use wrapMode + * for whole widget. */ ++ char *elideString; /* -elide option string (malloc-ed). ++ * NULL means option not specified. */ ++ int elide; /* Non-zero means text is elided. ++ * Only valid if elideString is non-NULL. */ + int affectsDisplay; /* Non-zero means that this tag affects the + * way information is displayed on the screen + * (so need to redisplay if tag changes). */ +@@ -800,6 +804,8 @@ + ClientData clientData)); + extern TkTextIndex * TkTextMakeIndex _ANSI_ARGS_((TkTextBTree tree, + int lineIndex, int charIndex, ++ TkTextIndex *indexPtr)); ++extern int TkTextIsElided _ANSI_ARGS_((TkText *textPtr, + TkTextIndex *indexPtr)); + extern int TkTextMarkCmd _ANSI_ARGS_((TkText *textPtr, + Tcl_Interp *interp, int argc, char **argv)); diff --git a/x11/tk80/patches/patch-ae b/x11/tk80/patches/patch-ae new file mode 100644 index 00000000000..d8091deb086 --- /dev/null +++ b/x11/tk80/patches/patch-ae @@ -0,0 +1,135 @@ +--- ../generic/tkTextBTree.c.orig Mon Sep 14 14:23:18 1998 ++++ ../generic/tkTextBTree.c Wed Jan 5 23:20:55 2000 +@@ -2427,6 +2427,132 @@ + } + return tagInfo.tagPtrs; + } ++ ++ ++/* ++ special case to just return information about elided attribute ++ specialized from TkBTreeGetTags(indexPtr, numTagsPtr) and GetStyle(textPtr, indexPtr) ++ just need to keep track of invisibility settings for each priority, pick highest one active at end ++*/ ++int ++TkTextIsElided(textPtr, indexPtr) ++ TkText *textPtr; /* Overall information about text widget. */ ++ TkTextIndex *indexPtr; /* The character in the text for which ++ * display information is wanted. */ ++{ ++#define LOTSA_TAGS 1000 ++ int elide = 0; /* if nobody says otherwise, it's visible */ ++ ++ int deftagCnts[LOTSA_TAGS]; ++ int *tagCnts = deftagCnts; ++ TkTextTag *deftagPtrs[LOTSA_TAGS]; ++ TkTextTag **tagPtrs = deftagPtrs; ++ int numTags = textPtr->numTags; ++ register Node *nodePtr; ++ register TkTextLine *siblingLinePtr; ++ register TkTextSegment *segPtr; ++ register TkTextTag *tagPtr; ++ register int i, index; ++ ++ /* almost always avoid malloc, so stay out of system calls */ ++ if (LOTSA_TAGS < numTags) { ++ tagCnts = (int *)ckalloc((unsigned)sizeof(int) * numTags); ++ tagPtrs = (TkTextTag **)ckalloc((unsigned)sizeof(TkTextTag *) * numTags); ++ } ++ ++ for (i=0; ilinePtr->segPtr; ++ (index + segPtr->size) <= indexPtr->charIndex; ++ index += segPtr->size, segPtr = segPtr->nextPtr) { ++ if ((segPtr->typePtr == &tkTextToggleOnType) ++ || (segPtr->typePtr == &tkTextToggleOffType)) { ++ tagPtr = segPtr->body.toggle.tagPtr; ++ if (tagPtr->elideString != NULL) { ++ tagPtrs[tagPtr->priority] = tagPtr; ++ tagCnts[tagPtr->priority]++; ++ } ++ } ++ } ++ ++ /* ++ * Record toggles for tags in lines that are predecessors of ++ * indexPtr->linePtr but under the same level-0 node. ++ */ ++ ++ for (siblingLinePtr = indexPtr->linePtr->parentPtr->children.linePtr; ++ siblingLinePtr != indexPtr->linePtr; ++ siblingLinePtr = siblingLinePtr->nextPtr) { ++ for (segPtr = siblingLinePtr->segPtr; segPtr != NULL; ++ segPtr = segPtr->nextPtr) { ++ if ((segPtr->typePtr == &tkTextToggleOnType) ++ || (segPtr->typePtr == &tkTextToggleOffType)) { ++ tagPtr = segPtr->body.toggle.tagPtr; ++ if (tagPtr->elideString != NULL) { ++ tagPtrs[tagPtr->priority] = tagPtr; ++ tagCnts[tagPtr->priority]++; ++ } ++ } ++ } ++ } ++ ++ /* ++ * For each node in the ancestry of this line, record tag toggles ++ * for all siblings that precede that node. ++ */ ++ ++ for (nodePtr = indexPtr->linePtr->parentPtr; nodePtr->parentPtr != NULL; ++ nodePtr = nodePtr->parentPtr) { ++ register Node *siblingPtr; ++ register Summary *summaryPtr; ++ ++ for (siblingPtr = nodePtr->parentPtr->children.nodePtr; ++ siblingPtr != nodePtr; siblingPtr = siblingPtr->nextPtr) { ++ for (summaryPtr = siblingPtr->summaryPtr; summaryPtr != NULL; ++ summaryPtr = summaryPtr->nextPtr) { ++ if (summaryPtr->toggleCount & 1) { ++ tagPtr = summaryPtr->tagPtr; ++ if (tagPtr->elideString != NULL) { ++ tagPtrs[tagPtr->priority] = tagPtr; ++ tagCnts[tagPtr->priority] += summaryPtr->toggleCount; ++ } ++ } ++ } ++ } ++ } ++ ++ ++ /* ++ * Now traverse from highest priority to lowest, ++ * take elided value from first odd count (= on) ++ */ ++ ++ for (i = numTags-1; i >=0; i--) { ++ if (tagCnts[i] & 1) { ++#ifndef ALWAYS_SHOW_SELECTION ++ /* who would make the selection elided? */ ++ if ((tagPtr == textPtr->selTagPtr) && !(textPtr->flags & GOT_FOCUS)) { ++ continue; ++ } ++#endif ++ elide = tagPtrs[i]->elide; ++ break; ++ } ++ } ++ ++ if (LOTSA_TAGS < numTags) { ++ ckfree((char *) tagCnts); ++ ckfree((char *) tagPtrs); ++ } ++ ++ return elide; ++} + + /* + *---------------------------------------------------------------------- diff --git a/x11/tk80/patches/patch-af b/x11/tk80/patches/patch-af new file mode 100644 index 00000000000..c5a320f9c2c --- /dev/null +++ b/x11/tk80/patches/patch-af @@ -0,0 +1,427 @@ +--- ../generic/tkTextDisp.c.orig Mon Sep 14 14:23:18 1998 ++++ ../generic/tkTextDisp.c Wed Jan 5 23:20:56 2000 +@@ -55,6 +55,7 @@ + * be NULL). */ + int underline; /* Non-zero means draw underline underneath + * text. */ ++ int elide; /* Non-zero means draw text */ + Tk_Uid wrapMode; /* How to handle wrap-around for this tag. + * One of tkTextCharUid, tkTextNoneUid, + * or tkTextWordUid. */ +@@ -311,6 +312,21 @@ + int x)); + static void CharUndisplayProc _ANSI_ARGS_((TkText *textPtr, + TkTextDispChunk *chunkPtr)); ++ ++/* ++ Definitions of elided procs. ++ Compiler can't inline these since we use pointers to these functions. ++ ElideDisplayProc, ElideUndisplayProc special-cased for speed, ++ as potentially many elided DLine chunks if large, tag toggle-filled ++ elided region. ++*/ ++static void ElideBboxProc _ANSI_ARGS_((TkTextDispChunk *chunkPtr, ++ int index, int y, int lineHeight, int baseline, ++ int *xPtr, int *yPtr, int *widthPtr, ++ int *heightPtr)); ++static int ElideMeasureProc _ANSI_ARGS_((TkTextDispChunk *chunkPtr, ++ int x)); ++ + static void DisplayDLine _ANSI_ARGS_((TkText *textPtr, + DLine *dlPtr, DLine *prevPtr, Pixmap pixmap)); + static void DisplayLineBackground _ANSI_ARGS_((TkText *textPtr, +@@ -479,7 +495,7 @@ + + int borderPrio, borderWidthPrio, reliefPrio, bgStipplePrio; + int fgPrio, fontPrio, fgStipplePrio; +- int underlinePrio, justifyPrio, offsetPrio; ++ int underlinePrio, elidePrio, justifyPrio, offsetPrio; + int lMargin1Prio, lMargin2Prio, rMarginPrio; + int spacing1Prio, spacing2Prio, spacing3Prio; + int overstrikePrio, tabPrio, wrapPrio; +@@ -494,7 +510,7 @@ + tagPtrs = TkBTreeGetTags(indexPtr, &numTags); + borderPrio = borderWidthPrio = reliefPrio = bgStipplePrio = -1; + fgPrio = fontPrio = fgStipplePrio = -1; +- underlinePrio = justifyPrio = offsetPrio = -1; ++ underlinePrio = elidePrio = justifyPrio = offsetPrio = -1; + lMargin1Prio = lMargin2Prio = rMarginPrio = -1; + spacing1Prio = spacing2Prio = spacing3Prio = -1; + overstrikePrio = tabPrio = wrapPrio = -1; +@@ -612,6 +628,11 @@ + styleValues.underline = tagPtr->underline; + underlinePrio = tagPtr->priority; + } ++ if ((tagPtr->elideString != NULL) ++ && (tagPtr->priority > elidePrio)) { ++ styleValues.elide = tagPtr->elide; ++ elidePrio = tagPtr->priority; ++ } + if ((tagPtr->wrapMode != NULL) + && (tagPtr->priority > wrapPrio)) { + styleValues.wrapMode = tagPtr->wrapMode; +@@ -768,7 +789,7 @@ + * lines with numChars > 0. Used to + * drop 0-sized chunks from the end + * of the line. */ +- int offset, ascent, descent, code; ++ int offset, ascent, descent, code, elide, elidesize; + StyleValues *sValuePtr; + + /* +@@ -786,6 +807,34 @@ + dlPtr->nextPtr = NULL; + dlPtr->flags = NEW_LAYOUT; + ++ ++ /* ++ * special case entirely elide line as there may be 1000s or more ++ */ ++ elide = TkTextIsElided(textPtr, indexPtr); /* save a malloc */ ++ if (elide && indexPtr->charIndex==0) { ++ maxChars = 0; ++ for (segPtr = indexPtr->linePtr->segPtr; elide && segPtr!=NULL; segPtr = segPtr->nextPtr) { ++ if ((elidesize = segPtr->size) > 0) { ++ maxChars += elidesize; ++ ++ /* if have tag toggle, chance that invisibility state changed, so bail out */ ++ } else if (segPtr->typePtr == &tkTextToggleOffType || segPtr->typePtr == &tkTextToggleOnType) { ++ if (segPtr->body.toggle.tagPtr->elideString!=NULL) { ++ elide = (segPtr->typePtr == &tkTextToggleOffType) ^ (segPtr->body.toggle.tagPtr->elide==1); ++ } ++ } ++ } ++ ++ if (elide) { ++ dlPtr->count = maxChars; ++ dlPtr->spaceAbove = dlPtr->spaceBelow = dlPtr->length = 0; ++ return dlPtr; ++ } ++ } ++ ++ ++ + /* + * Each iteration of the loop below creates one TkTextDispChunk for + * the new display line. The line will always have at least one +@@ -797,6 +846,7 @@ + lastChunkPtr = NULL; + chunkPtr = NULL; + noCharsYet = 1; ++ elide = 0; + breakChunkPtr = NULL; + breakCharOffset = 0; + justify = TK_JUSTIFY_LEFT; +@@ -821,6 +871,31 @@ + } + + while (segPtr != NULL) { ++ ++ /* every line still gets at least one chunk due to expectations in rest of code, ++ but able to skip elided portions of line quickly */ ++ /* if current chunk elided and last chunk was too, coalese */ ++ if (elide && lastChunkPtr!=NULL && lastChunkPtr->displayProc == NULL/*ElideDisplayProc*/) { ++ if ((elidesize = segPtr->size - offset) > 0) { ++ curIndex.charIndex += elidesize; ++ lastChunkPtr->numChars += elidesize; ++ breakCharOffset = lastChunkPtr->breakIndex = lastChunkPtr->numChars; ++ ++ /* if have tag toggle, chance that invisibility state changed */ ++ } else if (segPtr->typePtr == &tkTextToggleOffType || segPtr->typePtr == &tkTextToggleOnType) { ++ if (segPtr->body.toggle.tagPtr->elideString!=NULL) { ++ elide = (segPtr->typePtr == &tkTextToggleOffType) ^ (segPtr->body.toggle.tagPtr->elide==1); ++ } ++ } ++ ++ offset = 0; ++ segPtr = segPtr->nextPtr; ++ if (segPtr == NULL && chunkPtr != NULL) ckfree((char *) chunkPtr); ++ ++ continue; ++ } ++ ++ + if (segPtr->typePtr->layoutProc == NULL) { + segPtr = segPtr->nextPtr; + offset = 0; +@@ -831,6 +906,7 @@ + chunkPtr->nextPtr = NULL; + } + chunkPtr->stylePtr = GetStyle(textPtr, &curIndex); ++ elide = chunkPtr->stylePtr->sValuePtr->elide; + + /* + * Save style information such as justification and indentation, +@@ -864,7 +940,7 @@ + + gotTab = 0; + maxChars = segPtr->size - offset; +- if (justify == TK_JUSTIFY_LEFT) { ++ if (!elide && justify == TK_JUSTIFY_LEFT) { + if (segPtr->typePtr == &tkTextCharType) { + char *p; + +@@ -877,8 +953,21 @@ + } + } + } +- + chunkPtr->x = x; ++ if (elide && maxChars) { ++ /* don't free style here, as other code expects to be able to do that */ ++ /*breakCharOffset =*/ chunkPtr->breakIndex = chunkPtr->numChars = maxChars; ++ chunkPtr->width = 0; ++ chunkPtr->minAscent = chunkPtr->minDescent = chunkPtr->minHeight = 0; ++ ++ /* would just like to point to canonical empty chunk */ ++ chunkPtr->displayProc = (Tk_ChunkDisplayProc *) NULL; ++ chunkPtr->undisplayProc = (Tk_ChunkUndisplayProc *) NULL; ++ chunkPtr->measureProc = ElideMeasureProc; ++ chunkPtr->bboxProc = ElideBboxProc; ++ ++ code = 1; ++ } else + code = (*segPtr->typePtr->layoutProc)(textPtr, &curIndex, segPtr, + offset, maxX-tabSize, maxChars, noCharsYet, wrapMode, + chunkPtr); +@@ -950,6 +1039,7 @@ + offset = 0; + segPtr = segPtr->nextPtr; + } ++ + chunkPtr = NULL; + } + if (noCharsYet) { +@@ -998,6 +1088,7 @@ + wholeLine = 0; + } + ++ + /* + * Make tab adjustments for the last tab stop, if there is one. + */ +@@ -1321,6 +1412,7 @@ + index.linePtr = TkBTreeFindLine(textPtr->tree, lineNum); + index.charIndex = 0; + lowestPtr = NULL; ++ + do { + dlPtr = LayoutDLine(textPtr, &index); + dlPtr->nextPtr = lowestPtr; +@@ -1554,6 +1646,8 @@ + Display *display; + int height, x; + ++ if (dlPtr->chunkPtr == NULL) return; ++ + /* + * First, clear the area of the line to the background color for the + * text widget. +@@ -1620,12 +1714,16 @@ + * something is off to the right). + */ + ++ if (chunkPtr->displayProc != NULL) + (*chunkPtr->displayProc)(chunkPtr, -chunkPtr->width, + dlPtr->spaceAbove, + dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow, + dlPtr->baseline - dlPtr->spaceAbove, display, pixmap, + dlPtr->y + dlPtr->spaceAbove); + } else { ++ /* don't call if elide. This tax ok since not very many visible DLine's in ++ an area, but potentially many elide ones */ ++ if (chunkPtr->displayProc != NULL) + (*chunkPtr->displayProc)(chunkPtr, x, dlPtr->spaceAbove, + dlPtr->height - dlPtr->spaceAbove - dlPtr->spaceBelow, + dlPtr->baseline - dlPtr->spaceAbove, display, pixmap, +@@ -1714,6 +1812,7 @@ + StyleValues *sValuePtr; + Display *display; + ++ + /* + * Pass 1: scan through dlPtr from left to right. For each range of + * chunks with the same style, draw the main background for the style +@@ -1787,7 +1886,7 @@ + rightX = maxX; + } + chunkPtr2 = NULL; +- if (prevPtr != NULL) { ++ if (prevPtr != NULL && prevPtr->chunkPtr != NULL) { + /* + * Find the chunk in the previous line that covers leftX. + */ +@@ -1908,7 +2007,8 @@ + rightX = maxX; + } + chunkPtr2 = NULL; +- if (dlPtr->nextPtr != NULL) { ++/* for (dlPtr2 = dlPtr; dlPtr2->nextPtr != NULL && dlPtr2->nextPtr->chunkPtr == NULL; dlPtr2 = dlPtr2->nextPtr) {}*/ ++ if (dlPtr->nextPtr != NULL && dlPtr->nextPtr->chunkPtr != NULL) { + /* + * Find the chunk in the previous line that covers leftX. + */ +@@ -2299,6 +2399,7 @@ + for (prevPtr = NULL, dlPtr = textPtr->dInfoPtr->dLinePtr; + (dlPtr != NULL) && (dlPtr->y < dInfoPtr->maxY); + prevPtr = dlPtr, dlPtr = dlPtr->nextPtr) { ++ if (dlPtr->chunkPtr == NULL) continue; + if (dlPtr->oldY != dlPtr->y) { + if (tkTextDebug) { + char string[TK_POS_CHARS]; +@@ -2315,6 +2416,7 @@ + dlPtr->oldY = dlPtr->y; + dlPtr->flags &= ~NEW_LAYOUT; + } ++ /*prevPtr = dlPtr;*/ + } + Tk_FreePixmap(Tk_Display(textPtr->tkwin), pixmap); + } +@@ -3369,6 +3471,7 @@ + dlPtr = LayoutDLine(textPtr, &index); + dlPtr->nextPtr = lowestPtr; + lowestPtr = dlPtr; ++ if (dlPtr->length == 0 && dlPtr->height == 0) { offset--; break; } /* elide */ + TkTextIndexForwChars(&index, dlPtr->count, &index); + charsToCount -= dlPtr->count; + } while ((charsToCount > 0) +@@ -3381,7 +3484,7 @@ + break; + } + } +- ++ + /* + * Discard the display lines, then either return or prepare + * for the next display line to lay out. +@@ -3410,12 +3513,14 @@ + TkBTreeNumLines(textPtr->tree)); + for (i = 0; i < offset; i++) { + dlPtr = LayoutDLine(textPtr, &textPtr->topIndex); ++ if (dlPtr->length == 0 && dlPtr->height == 0) offset++; + dlPtr->nextPtr = NULL; + TkTextIndexForwChars(&textPtr->topIndex, dlPtr->count, &new); + FreeDLines(textPtr, dlPtr, (DLine *) NULL, 0); + if (new.linePtr == lastLinePtr) { + break; + } ++ + textPtr->topIndex = new; + } + } +@@ -3949,7 +4054,7 @@ + * index of the character nearest to (x,y). */ + { + TextDInfo *dInfoPtr = textPtr->dInfoPtr; +- register DLine *dlPtr; ++ register DLine *dlPtr, *validdlPtr; + register TkTextDispChunk *chunkPtr; + + /* +@@ -3982,8 +4087,9 @@ + * Find the display line containing the desired y-coordinate. + */ + +- for (dlPtr = dInfoPtr->dLinePtr; y >= (dlPtr->y + dlPtr->height); ++ for (dlPtr = validdlPtr = dInfoPtr->dLinePtr; y >= (dlPtr->y + dlPtr->height); + dlPtr = dlPtr->nextPtr) { ++ if (dlPtr->chunkPtr !=NULL) validdlPtr = dlPtr; + if (dlPtr->nextPtr == NULL) { + /* + * Y-coordinate is off the bottom of the displayed text. +@@ -3994,6 +4100,8 @@ + break; + } + } ++ if (dlPtr->chunkPtr == NULL) dlPtr = validdlPtr; ++ + + /* + * Scan through the line's chunks to find the one that contains +@@ -4005,12 +4113,12 @@ + *indexPtr = dlPtr->index; + x = x - dInfoPtr->x + dInfoPtr->curPixelOffset; + for (chunkPtr = dlPtr->chunkPtr; x >= (chunkPtr->x + chunkPtr->width); +- indexPtr->charIndex += chunkPtr->numChars, +- chunkPtr = chunkPtr->nextPtr) { ++ indexPtr->charIndex += chunkPtr->numChars, ++ chunkPtr = chunkPtr->nextPtr) { + if (chunkPtr->nextPtr == NULL) { + indexPtr->charIndex += chunkPtr->numChars - 1; + return; +- } ++ } + } + + /* +@@ -4166,6 +4274,7 @@ + { + TextDInfo *dInfoPtr = textPtr->dInfoPtr; + DLine *dlPtr; ++ int dlx; + + /* + * Make sure that all of the screen layout information is up to date. +@@ -4184,8 +4293,9 @@ + return -1; + } + +- *xPtr = dInfoPtr->x - dInfoPtr->curPixelOffset + dlPtr->chunkPtr->x; +- *widthPtr = dlPtr->length - dlPtr->chunkPtr->x; ++ dlx = (dlPtr->chunkPtr != NULL? dlPtr->chunkPtr->x: 0); ++ *xPtr = dInfoPtr->x - dInfoPtr->curPixelOffset + dlx; ++ *widthPtr = dlPtr->length - dlx; + *yPtr = dlPtr->y; + if ((dlPtr->y + dlPtr->height) > dInfoPtr->maxY) { + *heightPtr = dInfoPtr->maxY - dlPtr->y; +@@ -4196,6 +4306,41 @@ + return 0; + } + ++static void ++ElideBboxProc(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; /* Height of line, in pixels. */ ++ 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. ++ * X-coord is in same coordinate ++ * system as chunkPtr->x. */ ++ int *widthPtr; /* Gets filled in with width of ++ * character, in pixels. */ ++ int *heightPtr; /* Gets filled in with height of ++ * character, in pixels. */ ++{ ++ *xPtr = chunkPtr->x; ++ *yPtr = y; ++ *widthPtr = *heightPtr = 0; ++} ++ ++ ++static int ++ElideMeasureProc(chunkPtr, x) ++ TkTextDispChunk *chunkPtr; /* Chunk containing desired coord. */ ++ int x; /* X-coordinate, in same coordinate ++ * system as chunkPtr->x. */ ++{ ++ return 0 /*chunkPtr->numChars - 1*/; ++} ++ + /* + *-------------------------------------------------------------- + * +@@ -4421,7 +4566,7 @@ + * Draw the text, underline, and overstrike for this chunk. + */ + +- if (ciPtr->numChars > offsetChars) { ++ if (!sValuePtr->elide && ciPtr->numChars > offsetChars) { + int numChars = ciPtr->numChars - offsetChars; + char *string = ciPtr->chars + offsetChars; + diff --git a/x11/tk80/patches/patch-ag b/x11/tk80/patches/patch-ag new file mode 100644 index 00000000000..40583805eb7 --- /dev/null +++ b/x11/tk80/patches/patch-ag @@ -0,0 +1,52 @@ +--- ../generic/tkTextTag.c.orig Mon Sep 14 14:23:19 1998 ++++ ../generic/tkTextTag.c Wed Jan 5 23:20:56 2000 +@@ -63,6 +63,9 @@ + {TK_CONFIG_STRING, "-underline", (char *) NULL, (char *) NULL, + (char *) NULL, Tk_Offset(TkTextTag, underlineString), + TK_CONFIG_NULL_OK}, ++ {TK_CONFIG_STRING, "-elide", (char *) NULL, (char *) NULL, ++ (char *) NULL, Tk_Offset(TkTextTag, elideString), ++ TK_CONFIG_NULL_OK}, + {TK_CONFIG_UID, "-wrap", (char *) NULL, (char *) NULL, + (char *) NULL, Tk_Offset(TkTextTag, wrapMode), + TK_CONFIG_NULL_OK}, +@@ -378,6 +381,12 @@ + return TCL_ERROR; + } + } ++ if (tagPtr->elideString != NULL) { ++ if (Tcl_GetBoolean(interp, tagPtr->elideString, ++ &tagPtr->elide) != TCL_OK) { ++ return TCL_ERROR; ++ } ++ } + if ((tagPtr->wrapMode != NULL) + && (tagPtr->wrapMode != tkTextCharUid) + && (tagPtr->wrapMode != tkTextNoneUid) +@@ -419,6 +428,7 @@ + || (tagPtr->spacing3String != NULL) + || (tagPtr->tabString != NULL) + || (tagPtr->underlineString != NULL) ++ || (tagPtr->elideString != NULL) + || (tagPtr->wrapMode != NULL)) { + tagPtr->affectsDisplay = 1; + } +@@ -811,6 +821,8 @@ + tagPtr->tabArrayPtr = NULL; + tagPtr->underlineString = NULL; + tagPtr->underline = 0; ++ tagPtr->elideString = NULL; ++ tagPtr->elide = 0; + tagPtr->wrapMode = NULL; + tagPtr->affectsDisplay = 0; + textPtr->numTags++; +@@ -934,6 +946,9 @@ + } + if (tagPtr->underlineString != NULL) { + ckfree(tagPtr->underlineString); ++ } ++ if (tagPtr->elideString != NULL) { ++ ckfree(tagPtr->elideString); + } + ckfree((char *) tagPtr); + }