text widget 'peer' subcommand -- TIP#169 implementation

1 files changed, 855 insertions, 190 deletions

diff --git a/generic/tkTextBTree.c b/generic/tkTextBTree.c
index 9f3b8e5..964dfcd 100644
--- a/generic/tkTextBTree.c
+++ b/generic/tkTextBTree.c
@@ -4,14 +4,14 @@
  *	This file contains code that manages the B-tree representation
  *	of text for Tk's text widget and implements character and
  *	toggle segment types.
- *
+ *	
  * Copyright (c) 1992-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.
  *
- * RCS: @(#) $Id: tkTextBTree.c,v 1.14 2004/06/07 16:23:52 vincentdarley Exp $
+ * RCS: @(#) $Id: tkTextBTree.c,v 1.15 2004/09/10 12:13:41 vincentdarley Exp $
  */
 
 #include "tkInt.h"
@@ -19,6 +19,29 @@
 #include "tkText.h"
 
 /*
+ * Implementation notes:
+ * 
+ * Most of this file is independent of the text widget implementation
+ * and representation now.  Without much effort this could be developed
+ * further into a new Tcl object type of which the Tk text widget is one
+ * example of a client.
+ * 
+ * The B-tree is set up with a dummy last line of text which must not be
+ * displayed, and must _never_ have a non-zero pixel count.  This dummy
+ * line is a historical convenience to avoid other code having to deal
+ * with NULL TkTextLines.  Since Tk 8.5, with pixel line height
+ * calculations and peer widgets, this dummy line is becoming somewhat
+ * of a liability, and special case code has been required to deal with
+ * it.  It is probably a good idea to investigate removing the dummy
+ * line completely.  This could result in an overall simplification
+ * (although it would require new special case code to deal with the
+ * fact that '.text index end' would then not really point to a valid
+ * line, rather it would point to the beginning of a non-existent line
+ * one beyond all current lines - we could perhaps define that as a
+ * TkTextIndex with a NULL TkTextLine ptr).
+ */
+
+/*
  * The data structure below keeps summary information about one tag as part
  * of the tag information in a node.
  */
@@ -55,11 +78,19 @@ typedef struct Node {
     int numChildren;			/* Number of children of this node. */
     int numLines;			/* Total number of lines (leaves) in
 					 * the subtree rooted here. */
-    int numPixels;                      /* Total number of vertical
-                                         * display pixels in the
-                                         * subtree rooted here. */
+    int* numPixels;                     /* Array containing total number
+                                         * of vertical display pixels in
+                                         * the subtree rooted here, one
+                                         * entry for each peer widget.  */
 } Node;
 
+/* 
+ * Used to avoid having to allocate and deallocate arrays on the
+ * fly for commonly used procedures.  Must be > 0.
+ */
+
+#define PIXEL_CLIENTS 5
+
 /*
  * Upper and lower bounds on how many children a node may have:
  * rebalance when either of these limits is exceeded.  MAX_CHILDREN
@@ -70,13 +101,24 @@ typedef struct Node {
 #define MIN_CHILDREN 6
 
 /*
- * The data structure below defines an entire B-tree.
+ * The data structure below defines an entire B-tree.  Since text
+ * widgets are the only current B-tree clients, 'clients' and
+ * 'pixelReferences' are identical.
  */
 
 typedef struct BTree {
     Node *rootPtr;			/* Pointer to root of B-tree. */
-    TkText *textPtr;			/* Used to find tagTable in consistency
-					 * checking code */
+    int clients;                        /* Number of clients of this
+                                         * B-tree */
+    int pixelReferences;                /* Number of clients of this
+                                         * B-tree which care about
+                                         * pixel heights */
+    TkSharedText *sharedTextPtr;	/* Used to find tagTable in consistency
+					 * checking code, and to access 
+					 * list of all B-tree clients */
+    int startEndCount;
+    TkTextLine **startEnd;
+    TkText **startEndRef;
 } BTree;
 
 /*
@@ -116,6 +158,10 @@ int tkBTreeDebug = 0;
  * Forward declarations for procedures defined in this file:
  */
 
+static int              AdjustPixelClient _ANSI_ARGS_((BTree *treePtr, 
+			    int defaultHeight, Node *nodePtr, TkTextLine *start,
+			    TkTextLine *end, int useReference, 
+			    int newPixelReferences, int *counting));
 static void		ChangeNodeToggleCount _ANSI_ARGS_((Node *nodePtr,
 			    TkTextTag *tagPtr, int delta));
 static void		CharCheckProc _ANSI_ARGS_((TkTextSegment *segPtr,
@@ -126,7 +172,8 @@ static TkTextSegment *	CharCleanupProc _ANSI_ARGS_((TkTextSegment *segPtr,
 			    TkTextLine *linePtr));
 static TkTextSegment *	CharSplitProc _ANSI_ARGS_((TkTextSegment *segPtr,
 			    int index));
-static void		CheckNodeConsistency _ANSI_ARGS_((Node *nodePtr));
+static void		CheckNodeConsistency _ANSI_ARGS_((Node *nodePtr,
+							  int references));
 static void		CleanupLine _ANSI_ARGS_((TkTextLine *linePtr));
 static void		DeleteSummaries _ANSI_ARGS_((Summary *tagPtr));
 static void		DestroyNode _ANSI_ARGS_((Node *nodePtr));
@@ -135,7 +182,10 @@ static TkTextSegment *	FindTagEnd _ANSI_ARGS_((TkTextBTree tree,
 static void		IncCount _ANSI_ARGS_((TkTextTag *tagPtr, int inc,
 			    TagInfo *tagInfoPtr));
 static void		Rebalance _ANSI_ARGS_((BTree *treePtr, Node *nodePtr));
-static void		RecomputeNodeCounts _ANSI_ARGS_((Node *nodePtr));
+static void		RecomputeNodeCounts _ANSI_ARGS_((BTree *treePtr, 
+							 Node *nodePtr));
+static void             RemovePixelClient _ANSI_ARGS_((BTree *treePtr, 
+			    Node *nodePtr, int overwriteWithLast));
 static TkTextSegment *	SplitSeg _ANSI_ARGS_((TkTextIndex *indexPtr));
 static void		ToggleCheckProc _ANSI_ARGS_((TkTextSegment *segPtr,
 			    TkTextLine *linePtr));
@@ -147,6 +197,14 @@ static void		ToggleLineChangeProc _ANSI_ARGS_((TkTextSegment *segPtr,
 			    TkTextLine *linePtr));
 static TkTextSegment *	FindTagStart _ANSI_ARGS_((TkTextBTree tree,
 			    TkTextTag *tagPtr, TkTextIndex *indexPtr));
+static void             AdjustStartEndRefs _ANSI_ARGS_((BTree *treePtr, 
+			    TkText *textPtr, int action));
+
+/* 
+ * Actions for use by AdjustStartEndRefs
+ */
+#define TEXT_ADD_REFS     1
+#define TEXT_REMOVE_REFS  2
 
 /*
  * Type record for character segments:
@@ -213,8 +271,8 @@ Tk_SegType tkTextToggleOffType = {
  */
 
 TkTextBTree
-TkBTreeCreate(textPtr)
-    TkText *textPtr;
+TkBTreeCreate(sharedTextPtr)
+    TkSharedText *sharedTextPtr;
 {
     register BTree *treePtr;
     register Node *rootPtr;
@@ -231,6 +289,7 @@ TkBTreeCreate(textPtr)
     rootPtr = (Node *) ckalloc(sizeof(Node));
     linePtr = (TkTextLine *) ckalloc(sizeof(TkTextLine));
     linePtr2 = (TkTextLine *) ckalloc(sizeof(TkTextLine));
+    
     rootPtr->parentPtr = NULL;
     rootPtr->nextPtr = NULL;
     rootPtr->summaryPtr = NULL;
@@ -238,12 +297,13 @@ TkBTreeCreate(textPtr)
     rootPtr->children.linePtr = linePtr;
     rootPtr->numChildren = 2;
     rootPtr->numLines = 2;
-    rootPtr->numPixels = textPtr->charHeight;
-    linePtr->pixelHeight = textPtr->charHeight;
-    linePtr->pixelCalculationEpoch = 0;
-    /* The last line permanently has a pixel height of zero */
-    linePtr2->pixelHeight = 0;
-    linePtr2->pixelCalculationEpoch = 1;
+    /* 
+     * The tree currently has no registered clients, so all pixel
+     * count pointers are simply NULL
+     */
+    rootPtr->numPixels = NULL;
+    linePtr->pixels = NULL;
+    linePtr2->pixels = NULL;
     
     linePtr->parentPtr = rootPtr;
     linePtr->nextPtr = linePtr2;
@@ -266,21 +326,152 @@ TkBTreeCreate(textPtr)
     segPtr->body.chars[1] = 0;
 
     treePtr = (BTree *) ckalloc(sizeof(BTree));
+    treePtr->sharedTextPtr = sharedTextPtr;
     treePtr->rootPtr = rootPtr;
-    treePtr->textPtr = textPtr;
-
+    treePtr->clients = 0;
+    treePtr->pixelReferences = 0;
+    treePtr->startEndCount = 0;
+    treePtr->startEnd = NULL;
+    treePtr->startEndRef = NULL;
+    
     return (TkTextBTree) treePtr;
 }
 
 /*
  *----------------------------------------------------------------------
  *
+ * TkBTreeAddClient --
+ *
+ *	This procedure is called to provide a client with access to
+ *	a given B-tree.  If the client wishes to make use of the
+ *	B-tree's pixel height storage, caching and calculation 
+ *	mechanisms, then a non-negative 'defaultHeight' must be
+ *	provided.  In this case the return value is a pixel tree
+ *	reference which must be provided in all of the B-tree API which
+ *	refers to or modifies pixel heights:
+ *	
+ *	TkBTreeAdjustPixelHeight, 
+ *	TkBTreeFindPixelLine,
+ *	TkBTreeNumPixels, 
+ *	TkBTreePixelsTo,
+ *	(and two private functions AdjustPixelClient, RemovePixelClient).
+ *	
+ *	If this is not provided, then the above functions must
+ *	never be called for this client.
+ *
+ * Results:
+ *	The return value is the pixelReference used by the B-tree to
+ *	refer to pixel counts for the new client.  It should be stored
+ *	by the caller.  If defaultHeight was negative, then the return
+ *	value will be -1.
+ *
+ * Side effects:
+ *	Memory may be allocated and initialized.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TkBTreeAddClient(tree, textPtr, defaultHeight)
+    TkTextBTree tree;              /* B-tree to add a client to */
+    TkText *textPtr;               /* Client to add */
+    int defaultHeight;             /* Default line height for the new
+                                    * client, or -1 if no pixel
+                                    * heights are to be kept. */
+{
+    register BTree *treePtr = (BTree*) tree;
+    
+    if (treePtr == NULL) {
+	Tcl_Panic("NULL treePtr in TkBTreeAddClient");
+    }
+
+    if (textPtr->start != NULL || textPtr->end != NULL) {
+	AdjustStartEndRefs(treePtr, textPtr, TEXT_ADD_REFS);
+    }
+
+    if (defaultHeight >= 0) {
+	TkTextLine *end;
+	int counting = (textPtr->start == NULL ? 1 : 0);
+	int useReference = treePtr->pixelReferences;
+	/* 
+	 * We must set the 'end' value in AdjustPixelClient so that
+	 * the last dummy line in the B-tree doesn't contain
+	 * a pixel height.
+	 */
+	end = textPtr->end;
+	if (end == NULL) {
+	    end = TkBTreeFindLine(tree, NULL, TkBTreeNumLines(tree, NULL));
+	}
+        AdjustPixelClient(treePtr, defaultHeight, treePtr->rootPtr,
+			  textPtr->start, end, useReference, 
+			  1 + useReference, &counting);
+	
+	textPtr->pixelReference = useReference;
+	treePtr->pixelReferences++;
+    } else {
+	textPtr->pixelReference = -1;
+    }
+    treePtr->clients++;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkBTreeClientRangeChanged --
+ *
+ *	Called when the -startline or -endline options of a text 
+ *	widget client of the B-tree have changed.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Lots of processing of the B-tree is done, with potential
+ *	for memory to be allocated and initialized for the pixel
+ *	heights of the widget.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TkBTreeClientRangeChanged(textPtr, defaultHeight)
+    TkText *textPtr;               /* Client whose start, end have
+                                    * changed. */
+    int defaultHeight;             /* Default line height for the new
+				    * client, or -1 if no pixel
+				    * heights are to be kept. */
+{
+    TkTextLine *end;
+    BTree *treePtr = (BTree*) textPtr->sharedTextPtr->tree;
+    
+    int counting = (textPtr->start == NULL ? 1 : 0);
+    int useReference = textPtr->pixelReference;
+
+    AdjustStartEndRefs(treePtr, textPtr, TEXT_ADD_REFS | TEXT_REMOVE_REFS);
+    /* 
+     * We must set the 'end' value in AdjustPixelClient so that
+     * the last dummy line in the B-tree doesn't contain
+     * a pixel height.
+     */
+    end = textPtr->end;
+    if (end == NULL) {
+	end = TkBTreeFindLine(textPtr->sharedTextPtr->tree, 
+		  NULL, TkBTreeNumLines(textPtr->sharedTextPtr->tree, NULL));
+    }
+    AdjustPixelClient(treePtr, defaultHeight, treePtr->rootPtr,
+		      textPtr->start, end, useReference, 
+		      treePtr->pixelReferences, &counting);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * TkBTreeDestroy --
  *
  *	Delete a B-tree, recycling all of the storage it contains.
  *
  * Results:
- *	The tree given by treePtr is deleted.  TreePtr should never
+ *	The tree is deleted, so 'tree' should never
  *	again be used.
  *
  * Side effects:
@@ -291,17 +482,347 @@ TkBTreeCreate(textPtr)
 
 void
 TkBTreeDestroy(tree)
-    TkTextBTree tree;			/* Pointer to tree to delete. */ 
+    TkTextBTree tree;			/* Tree to clean up */
 {
     BTree *treePtr = (BTree *) tree;
 
+    /* 
+     * There's no need to loop over each client of the tree, calling
+     * 'TkBTreeRemoveClient', since the 'DestroyNode' will clean
+     * everything up itself.
+     */
+    
     DestroyNode(treePtr->rootPtr);
+    if (treePtr->startEnd != NULL) {
+        ckfree((char *) treePtr->startEnd);
+	ckfree((char *) treePtr->startEndRef);
+    }
     ckfree((char *) treePtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
+ * TkBTreeRemoveClient --
+ *
+ *	Remove a client widget from its B-tree, cleaning up the pixel
+ *	arrays which it uses if necessary.  If this is the last such
+ *	widget, we also destroy the whole tree.
+ *
+ * Results:
+ *	All tree-specific aspects of the given client are deleted.
+ *	If no more references exist, then the given tree is also
+ *	deleted (in which case 'tree' must not be used again).
+ *
+ * Side effects:
+ *	Memory may be freed.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TkBTreeRemoveClient(tree, textPtr)
+    TkTextBTree tree;                   /* Tree to remove client from */
+    TkText *textPtr;                    /* Client to remove. */
+{
+    BTree *treePtr = (BTree *) tree;
+    int pixelReference = textPtr->pixelReference;
+    
+    if (treePtr->clients == 1) {
+	/* The last reference to the tree */
+	DestroyNode(treePtr->rootPtr);
+	ckfree((char *) treePtr);
+	return;
+    } else if (pixelReference == -1) {
+	/* A client which doesn't care about pixels */
+	treePtr->clients--;
+    } else {
+	/* Clean up pixel data for the given reference */
+	
+	if (pixelReference == (treePtr->pixelReferences-1)) {
+	    /* 
+	     * The widget we're removing has the last index,
+	     * so deletion is easier.
+	     */
+	    RemovePixelClient(treePtr, treePtr->rootPtr, -1);
+	} else {
+	    TkText *adjustPtr;
+	    
+	    RemovePixelClient(treePtr, treePtr->rootPtr, pixelReference);
+
+	    /* 
+	     * Now we need to adjust the 'pixelReference' of the
+	     * peer widget whose storage we've just moved.
+	     */
+	    adjustPtr = treePtr->sharedTextPtr->peers;
+	    while (adjustPtr != NULL) {
+	        if (adjustPtr->pixelReference == (treePtr->pixelReferences-1)) {
+		    adjustPtr->pixelReference = pixelReference;
+	            break;
+	        }
+	        adjustPtr = adjustPtr->next;
+	    }
+	    if (adjustPtr == NULL) {
+		Tcl_Panic("Couldn't find text widget with correct reference");
+	    }
+	}
+	treePtr->pixelReferences--;
+	treePtr->clients--;
+    }
+    
+    if (textPtr->start != NULL || textPtr->end != NULL) {
+	AdjustStartEndRefs(treePtr, textPtr, TEXT_REMOVE_REFS);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * AdjustStartEndRefs --
+ *
+ *	Modify B-tree's cache of start, end lines for the given text
+ *	widget.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The number of cached items may change
+ *	(treePtr->startEndCount).
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+AdjustStartEndRefs(treePtr, textPtr, action) 
+    BTree *treePtr;           /* The entire B-tree */
+    TkText *textPtr;          /* The text widget for which we want to 
+                               * adjust it's start and end cache. */
+    int action;               /* Action to perform */
+{
+    if (action & TEXT_REMOVE_REFS) {
+	int i = 0;
+	int count = 0;
+
+	while (i < treePtr->startEndCount) {
+	    if (i != count) {
+		treePtr->startEnd[count] = treePtr->startEnd[i];
+		treePtr->startEndRef[count] = treePtr->startEndRef[i];
+	    }
+	    if (treePtr->startEndRef[i] != textPtr) {
+	        count++;
+	    }
+	    i++;
+	}
+	treePtr->startEndCount = count;
+	treePtr->startEnd = (TkTextLine**)ckrealloc((char*)treePtr->startEnd, 
+						   sizeof(TkTextLine*)*count);
+	treePtr->startEndRef = (TkText**)ckrealloc((char*)treePtr->startEndRef, 
+						  sizeof(TkText*)*count);
+    }
+    if ((action & TEXT_ADD_REFS) 
+      && (textPtr->start != NULL || textPtr->end != NULL)) {
+	int count;
+
+	if (textPtr->start != NULL) treePtr->startEndCount++;
+	if (textPtr->end != NULL) treePtr->startEndCount++;
+
+	count = treePtr->startEndCount;
+	
+	treePtr->startEnd = (TkTextLine**)ckrealloc((char*)treePtr->startEnd, 
+						    sizeof(TkTextLine*)*count);
+	treePtr->startEndRef = (TkText**)ckrealloc((char*)treePtr->startEndRef,
+						   sizeof(TkText*)*count);
+	
+	if (textPtr->start != NULL) {
+	    count--;
+	    treePtr->startEnd[count] = textPtr->start;
+	    treePtr->startEndRef[count] = treePtr->sharedTextPtr->peers;
+	}
+	if (textPtr->end != NULL) {
+	    count--;
+	    treePtr->startEnd[count] = textPtr->end;
+	    treePtr->startEndRef[count] = treePtr->sharedTextPtr->peers;
+	}
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * AdjustPixelClient --
+ *
+ *	Utility procedure used to update all data structures for the
+ *	existence of a new peer widget based on this B-tree, or for
+ *	the modification of the start, end lines of an existing peer
+ *	widget.
+ *	
+ *	Immediately _after_ calling this, treePtr->clients and
+ *	treePtr->pixelReferences should be adjusted if needed (i.e.
+ *	if this is a new peer).
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	All the storage for Nodes and TkTextLines in the tree may
+ *	be adjusted.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+AdjustPixelClient(treePtr, defaultHeight, nodePtr, start, end, 
+		  useReference, newPixelReferences, counting)
+    BTree *treePtr;			/* Pointer to tree */
+    int defaultHeight;		        /* Default pixel line
+                      		         * height, which can be zero. */
+    Node *nodePtr;                      /* Adjust from this node
+                                         * downwards */
+    TkTextLine *start;                  /* First line for this pixel
+                                         * client */
+    TkTextLine *end;                    /* Last line for this pixel
+                                         * client */
+    int useReference;                   /* pixel reference for the
+                                         * client we are adding or
+                                         * changing */
+    int newPixelReferences;             /* New number of pixel
+                                         * references to this B-tree */
+    int *counting;                      /* References an integer which
+                                         * is zero if we're outside the
+                                         * relevant range for this
+                                         * client, and 1 if we're 
+                                         * inside. */
+{
+    int pixelCount = 0;
+
+    /*
+     * Traverse entire tree down from nodePtr, reallocating pixel
+     * structures for each Node and TkTextLine, adding room for the new
+     * peer's pixel information (1 extra int per Node, 2 extra ints per
+     * TkTextLine).  Also copy the information from the last peer into
+     * the new space (so it contains something sensible).
+     */
+    
+    if (nodePtr->level != 0) {
+	Node *loopPtr = nodePtr->children.nodePtr;
+	while (loopPtr != NULL) {
+	    pixelCount += AdjustPixelClient(treePtr, defaultHeight, loopPtr,
+					    start, end, useReference, 
+					    newPixelReferences, counting);
+	    loopPtr = loopPtr->nextPtr;
+	}
+    } else {
+	register TkTextLine *linePtr = nodePtr->children.linePtr;
+	
+	while (linePtr != NULL) {
+	    if (!*counting && (linePtr == start)) {
+		*counting = 1;
+	    }
+	    if (*counting && (linePtr == end)) {
+		*counting = 0;
+	    }
+	    if (newPixelReferences != treePtr->pixelReferences) {
+		linePtr->pixels = (int*)ckrealloc((char*)linePtr->pixels, 
+				    sizeof(int)*2*newPixelReferences);
+	    }
+	    /* 
+	     * Notice that for the very last line, we are never counting
+	     * and therefore this always has a height of 0 and an epoch
+	     * of 1.
+	     */
+	    linePtr->pixels[2*useReference] = (*counting ? defaultHeight : 0);
+	    linePtr->pixels[1+2*useReference] = (*counting ? 0 : 1);
+	    pixelCount += linePtr->pixels[2*useReference];
+	    
+	    linePtr = linePtr->nextPtr;
+	}
+    }
+    if (newPixelReferences != treePtr->pixelReferences) {
+	nodePtr->numPixels = (int*)ckrealloc((char*)nodePtr->numPixels, 
+			      sizeof(int)*newPixelReferences);
+    }
+    nodePtr->numPixels[useReference] = pixelCount;
+    return pixelCount;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * RemovePixelClient --
+ *
+ *	Utility procedure used to update all data structures for the
+ *	removal of a peer widget which used to be based on this B-tree.
+ *	
+ *	Immediately _after_ calling this, treePtr->clients should
+ *	be decremented.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	All the storage for Nodes and TkTextLines in the tree may
+ *	be adjusted.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+RemovePixelClient(treePtr, nodePtr, overwriteWithLast)
+    BTree *treePtr;			/* Pointer to tree */
+    Node *nodePtr;                      /* Adjust from this node
+                                         * downwards */
+    int overwriteWithLast;              /* Over-write this peer widget's
+                                         * information with the last one
+                                         */
+{
+    /*
+     * Traverse entire tree down from nodePtr, reallocating pixel
+     * structures for each Node and TkTextLine, removing space allocated
+     * for one peer.  If 'overwriteWithLast' is not -1, then copy the
+     * information which was in the last slot on top of one of the
+     * others (i.e. it's not the last one we're deleting).
+     */
+
+    if (overwriteWithLast != -1) {
+	nodePtr->numPixels[overwriteWithLast] 
+	  = nodePtr->numPixels[treePtr->pixelReferences-1];
+    }
+    if (treePtr->pixelReferences == 1) {
+	nodePtr->numPixels = NULL;
+    } else {
+	nodePtr->numPixels = (int*)ckrealloc((char*)nodePtr->numPixels, 
+			sizeof(int)*(treePtr->pixelReferences-1));
+    }
+    if (nodePtr->level != 0) {
+	nodePtr = nodePtr->children.nodePtr;
+	while (nodePtr != NULL) {
+	    RemovePixelClient(treePtr, nodePtr, overwriteWithLast);
+	    nodePtr = nodePtr->nextPtr;
+	}
+    } else {
+	register TkTextLine *linePtr = nodePtr->children.linePtr;
+	while (linePtr != NULL) {
+	    if (overwriteWithLast != -1) {
+		linePtr->pixels[2*overwriteWithLast] 
+		  = linePtr->pixels[2*(treePtr->pixelReferences-1)];
+		linePtr->pixels[1+2*overwriteWithLast] 
+		  = linePtr->pixels[1+2*(treePtr->pixelReferences-1)];
+	    }
+	    if (treePtr->pixelReferences == 1) {
+		linePtr->pixels = NULL;
+	    } else {
+		linePtr->pixels = (int*)ckrealloc((char*)linePtr->pixels, 
+			sizeof(int)*2*(treePtr->pixelReferences-1));
+	    }
+	    linePtr = linePtr->nextPtr;
+	}
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * DestroyNode --
  *
  *	This is a recursive utility procedure used during the deletion
@@ -318,7 +839,7 @@ TkBTreeDestroy(tree)
 
 static void
 DestroyNode(nodePtr)
-    register Node *nodePtr;
+    register Node *nodePtr;    /* Destroy from this node downwards */
 {
     if (nodePtr->level == 0) {
 	TkTextLine *linePtr;
@@ -332,6 +853,7 @@ DestroyNode(nodePtr)
 		linePtr->segPtr = segPtr->nextPtr;
 		(*segPtr->typePtr->deleteProc)(segPtr, linePtr, 1);
 	    }
+	    ckfree((char *) linePtr->pixels);
 	    ckfree((char *) linePtr);
 	}
     } else {
@@ -344,6 +866,7 @@ DestroyNode(nodePtr)
 	}
     }
     DeleteSummaries(nodePtr->summaryPtr);
+    ckfree((char *) nodePtr->numPixels);
     ckfree((char *) nodePtr);
 }
 
@@ -396,7 +919,8 @@ DeleteSummaries(summaryPtr)
  */
 
 int
-TkBTreeAdjustPixelHeight(linePtr, newPixelHeight)
+TkBTreeAdjustPixelHeight(textPtr, linePtr, newPixelHeight)
+    CONST TkText *textPtr;              /* Client of the B-tree */
     register TkTextLine *linePtr;	/* The logical line to update */
     int newPixelHeight;			/* The line's known height 
                        			 * in pixels */
@@ -404,8 +928,9 @@ TkBTreeAdjustPixelHeight(linePtr, newPixelHeight)
     register Node *nodePtr;
     int changeToPixelCount;		/* Counts change to total number of
 					 * pixels in file. */
-
-    changeToPixelCount = newPixelHeight - linePtr->pixelHeight;
+    int pixelReference = textPtr->pixelReference;
+    
+    changeToPixelCount = newPixelHeight - linePtr->pixels[2*pixelReference];
 
     /*
      * Increment the pixel counts in all the parent nodes of the
@@ -413,16 +938,16 @@ TkBTreeAdjustPixelHeight(linePtr, newPixelHeight)
      */
 
     nodePtr = linePtr->parentPtr;
-    nodePtr->numPixels += changeToPixelCount;
+    nodePtr->numPixels[pixelReference] += changeToPixelCount;
     
     while (nodePtr->parentPtr != NULL) {
 	nodePtr = nodePtr->parentPtr;
-	nodePtr->numPixels += changeToPixelCount;
+	nodePtr->numPixels[pixelReference] += changeToPixelCount;
     }
 
-    linePtr->pixelHeight = newPixelHeight;
+    linePtr->pixels[2*pixelReference] = newPixelHeight;
     
-    return nodePtr->numPixels;
+    return nodePtr->numPixels[pixelReference];
 }
 
 /*
@@ -444,7 +969,8 @@ TkBTreeAdjustPixelHeight(linePtr, newPixelHeight)
  */
 
 void
-TkBTreeInsertChars(indexPtr, string)
+TkBTreeInsertChars(tree, indexPtr, string)
+    TkTextBTree tree;                   /* Tree to insert into */
     register TkTextIndex *indexPtr;	/* Indicates where to insert text.
 					 * When the procedure returns, this
 					 * index is no longer valid because
@@ -471,9 +997,12 @@ TkBTreeInsertChars(indexPtr, string)
 					 * one in current chunk. */
     int changeToLineCount;		/* Counts change to total number of
 					 * lines in file. */
-    int changeToPixelCount;		/* Counts change to total number of
+    int *changeToPixelCount;		/* Counts change to total number of
 					 * pixels in file. */
-
+    int ref;
+    int pixels[PIXEL_CLIENTS];
+    
+    BTree *treePtr = (BTree*)tree;
     prevPtr = SplitSeg(indexPtr);
     linePtr = indexPtr->linePtr;
     curPtr = prevPtr;
@@ -485,7 +1014,16 @@ TkBTreeInsertChars(indexPtr, string)
      */
 
     changeToLineCount = 0;
-    changeToPixelCount = 0;
+    if (treePtr->pixelReferences > PIXEL_CLIENTS) {
+        changeToPixelCount = (int*) ckalloc(sizeof(int) * 
+					    treePtr->pixelReferences);
+    } else {
+	changeToPixelCount = pixels;
+    }
+    for (ref = 0; ref < treePtr->pixelReferences; ref++) {
+	changeToPixelCount[ref] = 0;
+    }
+    
     while (*string != 0) {
 	for (eol = string; *eol != 0; eol++) {
 	    if (*eol == '\n') {
@@ -517,22 +1055,27 @@ TkBTreeInsertChars(indexPtr, string)
 	 */
 
 	newLinePtr = (TkTextLine *) ckalloc(sizeof(TkTextLine));
+	newLinePtr->pixels = 
+                 (int*) ckalloc(sizeof(int)*2*treePtr->pixelReferences);
+	
 	newLinePtr->parentPtr = linePtr->parentPtr;
 	newLinePtr->nextPtr = linePtr->nextPtr;
 	linePtr->nextPtr = newLinePtr;
 	newLinePtr->segPtr = segPtr->nextPtr;
 	/*
 	 * Set up a starting default height, which will be re-adjusted 
-	 * later
+	 * later. We need to do this for each referenced widget
 	 */
-	newLinePtr->pixelHeight = linePtr->pixelHeight;
-	newLinePtr->pixelCalculationEpoch = 0;
+	for (ref = 0; ref < treePtr->pixelReferences; ref++) {
+	    newLinePtr->pixels[2*ref] = linePtr->pixels[2*ref];
+	    newLinePtr->pixels[1+2*ref] = 0;
+	    changeToPixelCount[ref] += newLinePtr->pixels[2*ref];
+	}
 
 	segPtr->nextPtr = NULL;
 	linePtr = newLinePtr;
 	curPtr = NULL;
 	changeToLineCount++;
-	changeToPixelCount += newLinePtr->pixelHeight;
 	
 	string = eol;
     }
@@ -543,7 +1086,7 @@ TkBTreeInsertChars(indexPtr, string)
      * the function is robust to that case anyway.  (We must never
      * re-calculated the line height of the last line).
      */
-    TkTextInvalidateLineMetrics(((BTree*)indexPtr->tree)->textPtr, 
+    TkTextInvalidateLineMetrics(treePtr->sharedTextPtr, NULL, 
 				indexPtr->linePtr, changeToLineCount, 
 				TK_TEXT_INVALIDATE_INSERT);
 
@@ -565,12 +1108,18 @@ TkBTreeInsertChars(indexPtr, string)
     for (nodePtr = linePtr->parentPtr ; nodePtr != NULL;
 	    nodePtr = nodePtr->parentPtr) {
 	nodePtr->numLines += changeToLineCount;
-	nodePtr->numPixels += changeToPixelCount;
+	for (ref = 0; ref < treePtr->pixelReferences; ref++) {
+	    nodePtr->numPixels[ref] += changeToPixelCount[ref];
+	}
+    }
+    if (treePtr->pixelReferences > PIXEL_CLIENTS) {
+	ckfree((char*)changeToPixelCount);
     }
+        
     nodePtr = linePtr->parentPtr;
     nodePtr->numChildren += changeToLineCount;
     if (nodePtr->numChildren > MAX_CHILDREN) {
-	Rebalance((BTree *) indexPtr->tree, nodePtr);
+	Rebalance(treePtr, nodePtr);
     }
 
     if (tkBTreeDebug) {
@@ -715,7 +1264,8 @@ CleanupLine(linePtr)
  */
 
 void
-TkBTreeDeleteChars(index1Ptr, index2Ptr)
+TkBTreeDeleteChars(tree, index1Ptr, index2Ptr)
+    TkTextBTree tree;                   /* Tree to delete from */
     register TkTextIndex *index1Ptr;	/* Indicates first character that is
 					 * to be deleted. */
     register TkTextIndex *index2Ptr;	/* Indicates character just after the
@@ -729,6 +1279,8 @@ TkBTreeDeleteChars(index1Ptr, index2Ptr)
     TkTextLine *curLinePtr;
     Node *curNodePtr, *nodePtr;
     int changeToLineCount = 0;
+    int ref;
+    BTree *treePtr = (BTree*)tree;
     
     /*
      * Tricky point:  split at index2Ptr first;  otherwise the split
@@ -767,7 +1319,7 @@ TkBTreeDeleteChars(index1Ptr, index2Ptr)
 	     * (unless it's the starting line for the range).
 	     */
 
-	    nextLinePtr = TkBTreeNextLine(curLinePtr);
+	    nextLinePtr = TkBTreeNextLine(NULL, curLinePtr);
 	    if (curLinePtr != index1Ptr->linePtr) {
 		if (curNodePtr == index1Ptr->linePtr->parentPtr) {
 		    index1Ptr->linePtr->nextPtr = curLinePtr->nextPtr;
@@ -777,10 +1329,35 @@ TkBTreeDeleteChars(index1Ptr, index2Ptr)
 		for (nodePtr = curNodePtr; nodePtr != NULL;
 			nodePtr = nodePtr->parentPtr) {
 		    nodePtr->numLines--;
-		    nodePtr->numPixels -= curLinePtr->pixelHeight;
+		    for (ref = 0; ref < treePtr->pixelReferences; ref++) {
+			nodePtr->numPixels[ref] -= curLinePtr->pixels[2*ref];
+		    }
 		}
 		changeToLineCount++;
 		curNodePtr->numChildren--;
+		/* Check if we need to adjust any partial clients */
+		if (treePtr->startEnd != NULL) {
+		    int checkCount = 0;
+		    while (checkCount < treePtr->startEndCount) {
+			if (treePtr->startEnd[checkCount] == curLinePtr) {
+			    TkText *peer = treePtr->startEndRef[checkCount];
+			    /* 
+			     * We're deleting a line which is the start
+			     * or end of a current client.  This means
+			     * we need to adjust that client.
+			     */
+			    treePtr->startEnd[checkCount] = nextLinePtr;
+			    if (peer->start == curLinePtr) {
+				peer->start = nextLinePtr;
+			    }
+			    if (peer->end == curLinePtr) {
+				peer->end = nextLinePtr;
+			    }
+			}
+			checkCount++;
+		    }
+		}
+		ckfree((char *) curLinePtr->pixels);
 		ckfree((char *) curLinePtr);
 	    }
 	    curLinePtr = nextLinePtr;
@@ -851,7 +1428,9 @@ TkBTreeDeleteChars(index1Ptr, index2Ptr)
 	for (nodePtr = curNodePtr; nodePtr != NULL;
 		nodePtr = nodePtr->parentPtr) {
 	    nodePtr->numLines--;
-	    nodePtr->numPixels -= index2Ptr->linePtr->pixelHeight;
+	    for (ref = 0; ref < treePtr->pixelReferences; ref++) {
+		nodePtr->numPixels[ref] -= index2Ptr->linePtr->pixels[2*ref];
+	    }
 	}
 	changeToLineCount++;
 	curNodePtr->numChildren--;
@@ -864,6 +1443,36 @@ TkBTreeDeleteChars(index1Ptr, index2Ptr)
 	    }
 	    prevLinePtr->nextPtr = index2Ptr->linePtr->nextPtr;
 	}
+	/* 
+	 * Check if we need to adjust any partial clients.  In this case
+	 * if we're deleting the line, we actually move back to the
+	 * previous line for our (start,end) storage.  We do this
+	 * because we still want the portion of the second line that
+	 * still exists to be in the start,end range.
+	 */
+	if (treePtr->startEnd != NULL) {
+	    int checkCount = 0;
+
+	    while (treePtr->startEnd[checkCount] != NULL) {
+		if (treePtr->startEnd[checkCount] == index2Ptr->linePtr) {
+		    TkText *peer = treePtr->startEndRef[checkCount];
+		    /* 
+		     * We're deleting a line which is the start
+		     * or end of a current client.  This means
+		     * we need to adjust that client.
+		     */
+		    treePtr->startEnd[checkCount] = index1Ptr->linePtr;
+		    if (peer->start == index2Ptr->linePtr) {
+			peer->start = index1Ptr->linePtr;
+		    }
+		    if (peer->end == index2Ptr->linePtr) {
+			peer->end = index1Ptr->linePtr;
+		    }
+		}
+		checkCount++;
+	    }
+	}
+	ckfree((char *) index2Ptr->linePtr->pixels);
 	ckfree((char *) index2Ptr->linePtr);
 
 	Rebalance((BTree *) index2Ptr->tree, curNodePtr);
@@ -881,8 +1490,8 @@ TkBTreeDeleteChars(index1Ptr, index2Ptr)
      * of text.  I _believe_ that it isn't possible to get this far with
      * the last line, but it is good to be safe.
      */
-    if (TkBTreeNextLine(index1Ptr->linePtr) != NULL) {
-        TkTextInvalidateLineMetrics(((BTree*)index1Ptr->tree)->textPtr, 
+    if (TkBTreeNextLine(NULL, index1Ptr->linePtr) != NULL) {
+	TkTextInvalidateLineMetrics(treePtr->sharedTextPtr, NULL, 
 				    index1Ptr->linePtr, changeToLineCount, 
 				    TK_TEXT_INVALIDATE_DELETE);
     }
@@ -915,21 +1524,42 @@ TkBTreeDeleteChars(index1Ptr, index2Ptr)
  */
 
 TkTextLine *
-TkBTreeFindLine(tree, line)
+TkBTreeFindLine(tree, textPtr, line)
     TkTextBTree tree;			/* B-tree in which to find line. */
+    CONST TkText *textPtr;		/* Relative to this client of the 
+                          		 * B-tree */
     int line;				/* Index of desired line. */
 {
     BTree *treePtr = (BTree *) tree;
     register Node *nodePtr;
     register TkTextLine *linePtr;
-    int linesLeft;
 
+    if (treePtr == NULL) {
+	treePtr = (BTree *) textPtr->sharedTextPtr->tree;
+    }
+    
     nodePtr = treePtr->rootPtr;
-    linesLeft = line;
     if ((line < 0) || (line >= nodePtr->numLines)) {
 	return NULL;
     }
-
+    
+    /* 
+     * Check for the any start/end offset for this text widget 
+     */
+    if (textPtr != NULL) {
+        if (textPtr->start != NULL) {
+	    line += TkBTreeLinesTo(NULL, textPtr->start);
+	    if (line >= nodePtr->numLines) {
+		return NULL;
+	    }
+	}
+	if (textPtr->end != NULL) {
+	    if (line > TkBTreeLinesTo(NULL, textPtr->end)) {
+		return NULL;
+	    }
+	}
+    }
+    
     /*
      * Work down through levels of the tree until a node is found at
      * level 0.
@@ -937,12 +1567,12 @@ TkBTreeFindLine(tree, line)
 
     while (nodePtr->level != 0) {
 	for (nodePtr = nodePtr->children.nodePtr;
-		nodePtr->numLines <= linesLeft;
+		nodePtr->numLines <= line;
 		nodePtr = nodePtr->nextPtr) {
 	    if (nodePtr == NULL) {
 		Tcl_Panic("TkBTreeFindLine ran out of nodes");
 	    }
-	    linesLeft -= nodePtr->numLines;
+	    line -= nodePtr->numLines;
 	}
     }
 
@@ -950,12 +1580,12 @@ TkBTreeFindLine(tree, line)
      * Work through the lines attached to the level-0 node.
      */
 
-    for (linePtr = nodePtr->children.linePtr; linesLeft > 0;
+    for (linePtr = nodePtr->children.linePtr; line > 0;
 	    linePtr = linePtr->nextPtr) {
 	if (linePtr == NULL) {
 	    Tcl_Panic("TkBTreeFindLine ran out of lines");
 	}
-	linesLeft -= 1;
+	line -= 1;
     }
     return linePtr;
 }
@@ -985,24 +1615,25 @@ TkBTreeFindLine(tree, line)
  */
 
 TkTextLine *
-TkBTreeFindPixelLine(tree, pixels, pixelOffset)
-    TkTextBTree tree;			/* B-tree in which to find line. */
-    int pixels;				/* Index of desired line. */
+TkBTreeFindPixelLine(tree, textPtr, pixels, pixelOffset)
+    TkTextBTree tree;			/* B-tree to use. */
+    CONST TkText *textPtr;              /* Relative to this client of the 
+                          		 * B-tree */
+    int pixels;				/* Pixel index of desired line. */
     int *pixelOffset;                   /* Used to return offset */
 {
     BTree *treePtr = (BTree *) tree;
     register Node *nodePtr;
     register TkTextLine *linePtr;
-    int pixelsLeft;
-
+    int pixelReference = textPtr->pixelReference;
+    
     nodePtr = treePtr->rootPtr;
-    pixelsLeft = pixels;
 
-    if ((pixels < 0) || (pixels > nodePtr->numPixels)) {
+    if ((pixels < 0) || (pixels > nodePtr->numPixels[pixelReference])) {
 	return NULL;
     }
 
-    if (nodePtr->numPixels == 0) {
+    if (nodePtr->numPixels[pixelReference] == 0) {
 	Tcl_Panic("TkBTreeFindPixelLine called with empty window");
     }
     
@@ -1013,12 +1644,12 @@ TkBTreeFindPixelLine(tree, pixels, pixelOffset)
 
     while (nodePtr->level != 0) {
 	for (nodePtr = nodePtr->children.nodePtr;
-		nodePtr->numPixels <= pixelsLeft;
+		nodePtr->numPixels[pixelReference] <= pixels;
 		nodePtr = nodePtr->nextPtr) {
 	    if (nodePtr == NULL) {
 		Tcl_Panic("TkBTreeFindPixelLine ran out of nodes");
 	    }
-	    pixelsLeft -= nodePtr->numPixels;
+	    pixels -= nodePtr->numPixels[pixelReference];
 	}
     }
 
@@ -1027,15 +1658,15 @@ TkBTreeFindPixelLine(tree, pixels, pixelOffset)
      */
 
     for (linePtr = nodePtr->children.linePtr; 
-	    linePtr->pixelHeight < pixelsLeft;
+	    linePtr->pixels[2*pixelReference] < pixels;
 	    linePtr = linePtr->nextPtr) {
 	if (linePtr == NULL) {
 	    Tcl_Panic("TkBTreeFindPixelLine ran out of lines");
 	}
-	pixelsLeft -= linePtr->pixelHeight;
+	pixels -= linePtr->pixels[2*pixelReference];
     }
     if (pixelOffset != NULL && linePtr != NULL) {
-        *pixelOffset = pixelsLeft;
+        *pixelOffset = pixels;
     }
     return linePtr;
 }
@@ -1060,16 +1691,22 @@ TkBTreeFindPixelLine(tree, pixels, pixelOffset)
  */
 
 TkTextLine *
-TkBTreeNextLine(linePtr)
+TkBTreeNextLine(textPtr, linePtr)
+    CONST TkText *textPtr;              /* Next line in the context of
+                                         * this client */
     register TkTextLine *linePtr;	/* Pointer to existing line in
 					 * B-tree. */
 {
     register Node *nodePtr;
 
     if (linePtr->nextPtr != NULL) {
-	return linePtr->nextPtr;
+	if (textPtr != NULL && (linePtr == textPtr->end)) {
+	    return NULL;
+	} else {
+	    return linePtr->nextPtr;
+	}
     }
-
+    
     /*
      * This was the last line associated with the particular parent node.
      * Search up the tree for the next node, then search down from that
@@ -1111,7 +1748,9 @@ TkBTreeNextLine(linePtr)
  */
 
 TkTextLine *
-TkBTreePreviousLine(linePtr)
+TkBTreePreviousLine(textPtr, linePtr)
+    TkText *textPtr;                    /* Relative to this client of the 
+                          		 * B-tree */
     register TkTextLine *linePtr;	/* Pointer to existing line in
 					 * B-tree. */
 {
@@ -1119,6 +1758,10 @@ TkBTreePreviousLine(linePtr)
     register Node *node2Ptr;
     register TkTextLine *prevPtr;
 
+    if (textPtr != NULL && textPtr->start == linePtr) {
+        return NULL;
+    }
+    
     /*
      * Find the line under this node just before the starting line.
      */
@@ -1166,7 +1809,7 @@ TkBTreePreviousLine(linePtr)
 /*
  *----------------------------------------------------------------------
  *
- * TkBTreePixels --
+ * TkBTreePixelsTo --
  *
  *	Given a pointer to a line in a B-tree, return the numerical
  *	pixel index of the top of that line (i.e. the result does
@@ -1187,16 +1830,19 @@ TkBTreePreviousLine(linePtr)
  */
 
 int
-TkBTreePixels(linePtr)
+TkBTreePixelsTo(textPtr, linePtr)
+    CONST TkText *textPtr;              /* Relative to this client of the 
+                          		 * B-tree */
     TkTextLine *linePtr;		/* Pointer to existing line in
 					 * B-tree. */
 {
     register TkTextLine *linePtr2;
-    register Node *nodePtr, *parentPtr, *nodePtr2;
+    register Node *nodePtr, *parentPtr;
     int index;
+    int pixelReference = textPtr->pixelReference;
 
     /*
-     * First count how many lines precede this one in its level-0
+     * First count how many pixels precede this line in its level-0
      * node.
      */
 
@@ -1205,25 +1851,26 @@ TkBTreePixels(linePtr)
     for (linePtr2 = nodePtr->children.linePtr; linePtr2 != linePtr;
 	    linePtr2 = linePtr2->nextPtr) {
 	if (linePtr2 == NULL) {
-	    Tcl_Panic("TkBTreePixels couldn't find line");
+	    Tcl_Panic("TkBTreePixelsTo couldn't find line");
 	}
-	index += linePtr2->pixelHeight;
+	index += linePtr2->pixels[2*pixelReference];
     }
 
     /*
      * Now work up through the levels of the tree one at a time,
-     * counting how many lines are in nodes preceding the current
+     * counting how many pixels are in nodes preceding the current
      * node.
      */
 
     for (parentPtr = nodePtr->parentPtr ; parentPtr != NULL;
 	    nodePtr = parentPtr, parentPtr = parentPtr->parentPtr) {
+	register Node *nodePtr2;
 	for (nodePtr2 = parentPtr->children.nodePtr; nodePtr2 != nodePtr;
 		nodePtr2 = nodePtr2->nextPtr) {
 	    if (nodePtr2 == NULL) {
-		Tcl_Panic("TkBTreePixels couldn't find node");
+		Tcl_Panic("TkBTreePixelsTo couldn't find node");
 	    }
-	    index += nodePtr2->numPixels;
+	    index += nodePtr2->numPixels[pixelReference];
 	}
     }
     return index;
@@ -1232,7 +1879,7 @@ TkBTreePixels(linePtr)
 /*
  *----------------------------------------------------------------------
  *
- * TkBTreeLineIndex --
+ * TkBTreeLinesTo --
  *
  *	Given a pointer to a line in a B-tree, return the numerical
  *	index of that line.
@@ -1248,7 +1895,9 @@ TkBTreePixels(linePtr)
  */
 
 int
-TkBTreeLineIndex(linePtr)
+TkBTreeLinesTo(textPtr, linePtr)
+    CONST TkText *textPtr;              /* Relative to this client of the 
+                          		 * B-tree */
     TkTextLine *linePtr;		/* Pointer to existing line in
 					 * B-tree. */
 {
@@ -1266,7 +1915,7 @@ TkBTreeLineIndex(linePtr)
     for (linePtr2 = nodePtr->children.linePtr; linePtr2 != linePtr;
 	    linePtr2 = linePtr2->nextPtr) {
 	if (linePtr2 == NULL) {
-	    Tcl_Panic("TkBTreeLineIndex couldn't find line");
+	    Tcl_Panic("TkBTreeLinesTo couldn't find line");
 	}
 	index += 1;
     }
@@ -1282,11 +1931,14 @@ TkBTreeLineIndex(linePtr)
 	for (nodePtr2 = parentPtr->children.nodePtr; nodePtr2 != nodePtr;
 		nodePtr2 = nodePtr2->nextPtr) {
 	    if (nodePtr2 == NULL) {
-		Tcl_Panic("TkBTreeLineIndex couldn't find node");
+		Tcl_Panic("TkBTreeLinesTo couldn't find node");
 	    }
 	    index += nodePtr2->numLines;
 	}
     }
+    if (textPtr != NULL && textPtr->start != NULL) {
+        index -= TkBTreeLinesTo(NULL, textPtr->start);
+    }
     return index;
 }
 
@@ -1352,8 +2004,7 @@ TkBTreeLinkSegment(segPtr, indexPtr)
 
 	/* ARGSUSED */
 void
-TkBTreeUnlinkSegment(tree, segPtr, linePtr)
-    TkTextBTree tree;			/* Tree containing segment. */
+TkBTreeUnlinkSegment(segPtr, linePtr)
     TkTextSegment *segPtr;		/* Segment to be unlinked. */
     TkTextLine *linePtr;		/* Line that currently contains
 					 * segment. */
@@ -1951,8 +2602,8 @@ TkBTreeStartSearch(index1Ptr, index2Ptr, tagPtr, searchPtr)
     }
     searchPtr->lastPtr = TkTextIndexToSeg(index2Ptr, (int *) NULL);
     searchPtr->tagPtr = tagPtr;
-    searchPtr->linesLeft = TkBTreeLineIndex(index2Ptr->linePtr) + 1
-	    - TkBTreeLineIndex(index1Ptr->linePtr);
+    searchPtr->linesLeft = TkBTreeLinesTo(NULL, index2Ptr->linePtr) + 1
+	    - TkBTreeLinesTo(NULL, index1Ptr->linePtr);
     searchPtr->allTags = (tagPtr == NULL);
     if (searchPtr->linesLeft == 1) {
 	/*
@@ -2042,7 +2693,7 @@ TkBTreeStartSearchBack(index1Ptr, index2Ptr, tagPtr, searchPtr)
 	searchPtr->curIndex = index0;
 	index1Ptr = &index0;
     } else {
-	TkTextIndexBackChars(NULL,index1Ptr, 1, &searchPtr->curIndex, 
+	TkTextIndexBackChars(NULL, index1Ptr, 1, &searchPtr->curIndex, 
 			     COUNT_INDICES);
     }
     searchPtr->segPtr = NULL;
@@ -2054,7 +2705,7 @@ TkBTreeStartSearchBack(index1Ptr, index2Ptr, tagPtr, searchPtr)
      * at the second index specified by the user.
      */
 
-    if ((TkBTreeLineIndex(index2Ptr->linePtr) == 0) &&
+    if ((TkBTreeLinesTo(NULL, index2Ptr->linePtr) == 0) &&
 	    (index2Ptr->byteIndex == 0)) {
 	backOne = *index2Ptr;
 	searchPtr->lastPtr = NULL;	/* Signals special case for 1.0 */
@@ -2063,8 +2714,8 @@ TkBTreeStartSearchBack(index1Ptr, index2Ptr, tagPtr, searchPtr)
 	searchPtr->lastPtr = TkTextIndexToSeg(&backOne, (int *) NULL);
     }
     searchPtr->tagPtr = tagPtr;
-    searchPtr->linesLeft = TkBTreeLineIndex(index1Ptr->linePtr) + 1
-	    - TkBTreeLineIndex(backOne.linePtr);
+    searchPtr->linesLeft = TkBTreeLinesTo(NULL, index1Ptr->linePtr) + 1
+	    - TkBTreeLinesTo(NULL, backOne.linePtr);
     searchPtr->allTags = (tagPtr == NULL);
     if (searchPtr->linesLeft == 1) {
 	/*
@@ -2588,9 +3239,12 @@ TkBTreeCharTagged(indexPtr, tagPtr)
 
 	/* ARGSUSED */
 TkTextTag **
-TkBTreeGetTags(indexPtr, numTagsPtr)
+TkBTreeGetTags(indexPtr, textPtr, numTagsPtr)
     CONST TkTextIndex *indexPtr;/* Indicates a particular position in
 				 * the B-tree. */
+    CONST TkText *textPtr;      /* If non-NULL, then only return tags
+                                 * for this text widget (when there are
+                                 * peer widgets). */
     int *numTagsPtr;		/* Store number of tags found at this
 				 * location. */
 {
@@ -2664,13 +3318,17 @@ TkBTreeGetTags(indexPtr, numTagsPtr)
     /*
      * Go through the tag information and squash out all of the tags
      * that have even toggle counts (these tags exist before the point
-     * of interest, but not at the desired character itself).
+     * of interest, but not at the desired character itself).  Also
+     * squash out all tags that don't belong to the requested widget.
      */
 
     for (src = 0, dst = 0; src < tagInfo.numTags; src++) {
 	if (tagInfo.counts[src] & 1) {
-	    tagInfo.tagPtrs[dst] = tagInfo.tagPtrs[src];
-	    dst++;
+	    CONST TkText *tagTextPtr = tagInfo.tagPtrs[src]->textPtr;
+	    if (tagTextPtr == NULL || textPtr == NULL || tagTextPtr == textPtr) {
+		tagInfo.tagPtrs[dst] = tagInfo.tagPtrs[src];
+		dst++;
+	    }
 	}
     }
     *numTagsPtr = dst;
@@ -2688,17 +3346,21 @@ TkBTreeGetTags(indexPtr, numTagsPtr)
  * TkTextIsElided --
  *
  *	Special case to just return information about elided attribute.
- *	Specialized from TkBTreeGetTags(indexPtr, numTagsPtr) and
+ *	Specialized from TkBTreeGetTags(indexPtr, textPtr, numTagsPtr) and
  *	GetStyle(textPtr, indexPtr).  Just need to keep track of
  *	invisibility settings for each priority, pick highest one active
  *	at end.
  *	
  *	Note that this returns all elide information up to and including
  *	the given index (quite obviously).  However, this does mean that
- *	indexPtr is a line-start and one then iterates from the beginning
+ *	if indexPtr is a line-start and one then iterates from the beginning
  *	of that line forwards, one will actually revisit the segPtrs of
  *	size zero (for tag toggling, for example) which have already been
  *	seen here.
+ *	
+ *	For this reason we fill in the fields 'segPtr' and 'segOffset'
+ *	of elideInfo, enabling our caller easily to calculate
+ *	incremental changes from where we left off.
  *
  * Results:
  *	Returns whether this text should be elided or not.
@@ -2738,7 +3400,7 @@ TkTextIsElided(textPtr, indexPtr, elideInfo)
     infoPtr->elide = 0;		/* if nobody says otherwise, it's visible */
     infoPtr->tagCnts = infoPtr->deftagCnts;
     infoPtr->tagPtrs = infoPtr->deftagPtrs;
-    infoPtr->numTags = textPtr->numTags;
+    infoPtr->numTags = textPtr->sharedTextPtr->numTags;
 
     /* Almost always avoid malloc, so stay out of system calls */
     if (LOTSA_TAGS < infoPtr->numTags) {
@@ -2774,7 +3436,8 @@ TkTextIsElided(textPtr, indexPtr, elideInfo)
      * so that our caller knows where to start.
      */
     infoPtr->segPtr = segPtr;
-
+    infoPtr->segOffset = index;
+    
     /*
      * Record toggles for tags in lines that are predecessors of
      * indexPtr->linePtr but under the same level-0 node.
@@ -2829,13 +3492,12 @@ TkTextIsElided(textPtr, indexPtr, elideInfo)
     infoPtr->elidePriority = -1;
     for (i = infoPtr->numTags-1; i >=0; i--) {
 	if (infoPtr->tagCnts[i] & 1) {
-#ifndef ALWAYS_SHOW_SELECTION
-	    /* who would make the selection elided? */
+	    /* Who would make the selection elided? */
 	    if ((tagPtr == textPtr->selTagPtr)
-		    && !(textPtr->flags & GOT_FOCUS)) {
+		    && !(textPtr->flags & GOT_FOCUS)
+		    && (textPtr->inactiveSelBorder == NULL)) {
 		continue;
 	    }
-#endif
 	    infoPtr->elide = infoPtr->tagPtrs[i]->elide;
 	    /* Note: i == infoPtr->tagPtrs[i]->priority */
 	    infoPtr->elidePriority = i;
@@ -2987,7 +3649,7 @@ TkBTreeCheck(tree)
     /*
      * Make sure that the tag toggle counts and the tag root pointers are OK.
      */
-    for (entryPtr = Tcl_FirstHashEntry(&treePtr->textPtr->tagTable, &search);
+    for (entryPtr = Tcl_FirstHashEntry(&treePtr->sharedTextPtr->tagTable, &search);
 	    entryPtr != NULL ; entryPtr = Tcl_NextHashEntry(&search)) {
 	tagPtr = (TkTextTag *) Tcl_GetHashValue(entryPtr);
 	nodePtr = tagPtr->tagRootPtr;
@@ -3045,7 +3707,7 @@ TkBTreeCheck(tree)
      */
 
     nodePtr = treePtr->rootPtr;
-    CheckNodeConsistency(treePtr->rootPtr);
+    CheckNodeConsistency(treePtr->rootPtr, treePtr->pixelReferences);
 
     /*
      * Make sure that there are at least two lines in the text and
@@ -3113,15 +3775,19 @@ TkBTreeCheck(tree)
  */
 
 static void
-CheckNodeConsistency(nodePtr)
+CheckNodeConsistency(nodePtr, references)
     register Node *nodePtr;		/* Node whose subtree should be
 					 * checked. */
+    int references;                     /* Number of referring widgets
+                                         * which have pixel counts. */
 {
     register Node *childNodePtr;
     register Summary *summaryPtr, *summaryPtr2;
     register TkTextLine *linePtr;
     register TkTextSegment *segPtr;
-    int numChildren, numLines, numPixels, toggleCount, minChildren;
+    int numChildren, numLines, toggleCount, minChildren, i;
+    int *numPixels;
+    int pixels[PIXEL_CLIENTS];
 
     if (nodePtr->parentPtr != NULL) {
 	minChildren = MIN_CHILDREN;
@@ -3138,7 +3804,15 @@ CheckNodeConsistency(nodePtr)
 
     numChildren = 0;
     numLines = 0;
-    numPixels = 0;
+    if (references > PIXEL_CLIENTS) {
+	numPixels = (int*)ckalloc(sizeof(int)*references);
+    } else {
+	numPixels = pixels;
+    }
+    for (i = 0; i<references; i++) {
+	numPixels[i] = 0;
+    }
+
     if (nodePtr->level == 0) {
 	for (linePtr = nodePtr->children.linePtr; linePtr != NULL;
 		linePtr = linePtr->nextPtr) {
@@ -3166,7 +3840,9 @@ CheckNodeConsistency(nodePtr)
 	    }
 	    numChildren++;
 	    numLines++;
-	    numPixels += linePtr->pixelHeight;
+	    for (i = 0; i<references; i++) {
+	        numPixels[i] += linePtr->pixels[2*i];
+	    }
 	}
     } else {
 	for (childNodePtr = nodePtr->children.nodePtr; childNodePtr != NULL;
@@ -3178,7 +3854,7 @@ CheckNodeConsistency(nodePtr)
 		Tcl_Panic("CheckNodeConsistency: level mismatch (%d %d)",
 			nodePtr->level, childNodePtr->level);
 	    }
-	    CheckNodeConsistency(childNodePtr);
+	    CheckNodeConsistency(childNodePtr, references);
 	    for (summaryPtr = childNodePtr->summaryPtr; summaryPtr != NULL;
 			summaryPtr = summaryPtr->nextPtr) {
 		for (summaryPtr2 = nodePtr->summaryPtr; ;
@@ -3198,7 +3874,9 @@ CheckNodeConsistency(nodePtr)
 	    }
 	    numChildren++;
 	    numLines += childNodePtr->numLines;
-	    numPixels += childNodePtr->numPixels;
+	    for (i = 0; i<references; i++) {
+		numPixels[i] += childNodePtr->numPixels[i];
+	    }
 	}
     }
     if (numChildren != nodePtr->numChildren) {
@@ -3209,11 +3887,16 @@ CheckNodeConsistency(nodePtr)
 	Tcl_Panic("CheckNodeConsistency: mismatch in numLines (%d %d)",
 		numLines, nodePtr->numLines);
     }
-    if (numPixels != nodePtr->numPixels) {
-	Tcl_Panic("CheckNodeConsistency: mismatch in numPixels (%d %d)",
-	      numPixels, nodePtr->numPixels);
+    for (i = 0; i<references; i++) {
+	if (numPixels[i] != nodePtr->numPixels[i]) {
+	    Tcl_Panic("CheckNodeConsistency: mismatch in numPixels (%d %d) for widget (%d)",
+		  numPixels[i], nodePtr->numPixels[i], i);
+	}
     }
-
+    if (references > PIXEL_CLIENTS) {
+	ckfree((char*)numPixels);
+    }
+        
     for (summaryPtr = nodePtr->summaryPtr; summaryPtr != NULL;
 	    summaryPtr = summaryPtr->nextPtr) {
 	if (summaryPtr->tagPtr->toggleCount == summaryPtr->toggleCount) {
@@ -3319,11 +4002,20 @@ Rebalance(treePtr, nodePtr)
 		    newPtr->children.nodePtr = nodePtr;
 		    newPtr->numChildren = 1;
 		    newPtr->numLines = nodePtr->numLines;
-		    newPtr->numPixels = nodePtr->numPixels;
-		    RecomputeNodeCounts(newPtr);
+		    newPtr->numPixels = (int*) ckalloc(sizeof(int)*
+						       treePtr->pixelReferences);
+		    for (i=0; i<treePtr->pixelReferences; i++) {
+		        newPtr->numPixels[i] = nodePtr->numPixels[i];
+		    }
+		    RecomputeNodeCounts(treePtr, newPtr);
 		    treePtr->rootPtr = newPtr;
 		}
 		newPtr = (Node *) ckalloc(sizeof(Node));
+		newPtr->numPixels = (int*) ckalloc(sizeof(int)*
+						   treePtr->pixelReferences);
+		for (i=0; i<treePtr->pixelReferences; i++) {
+		    newPtr->numPixels[i] = 0;
+		}
 		newPtr->parentPtr = nodePtr->parentPtr;
 		newPtr->nextPtr = nodePtr->nextPtr;
 		nodePtr->nextPtr = newPtr;
@@ -3347,11 +4039,11 @@ Rebalance(treePtr, nodePtr)
 		    newPtr->children.nodePtr = childPtr->nextPtr;
 		    childPtr->nextPtr = NULL;
 		}
-		RecomputeNodeCounts(nodePtr);
+		RecomputeNodeCounts(treePtr, nodePtr);
 		nodePtr->parentPtr->numChildren++;
 		nodePtr = newPtr;
 		if (nodePtr->numChildren <= MAX_CHILDREN) {
-		    RecomputeNodeCounts(nodePtr);
+		    RecomputeNodeCounts(treePtr, nodePtr);
 		    break;
 		}
 	    }
@@ -3462,7 +4154,7 @@ Rebalance(treePtr, nodePtr)
 	     */
 
 	    if (totalChildren <= MAX_CHILDREN) {
-		RecomputeNodeCounts(nodePtr);
+		RecomputeNodeCounts(treePtr, nodePtr);
 		nodePtr->nextPtr = otherPtr->nextPtr;
 		nodePtr->parentPtr->numChildren--;
 		DeleteSummaries(otherPtr->summaryPtr);
@@ -3482,8 +4174,8 @@ Rebalance(treePtr, nodePtr)
 		otherPtr->children.nodePtr = halfwayNodePtr->nextPtr;
 		halfwayNodePtr->nextPtr = NULL;
 	    }
-	    RecomputeNodeCounts(nodePtr);
-	    RecomputeNodeCounts(otherPtr);
+	    RecomputeNodeCounts(treePtr, nodePtr);
+	    RecomputeNodeCounts(treePtr, otherPtr);
 	}
     }
 }
@@ -3511,7 +4203,8 @@ Rebalance(treePtr, nodePtr)
  */
 
 static void
-RecomputeNodeCounts(nodePtr)
+RecomputeNodeCounts(treePtr, nodePtr)
+    register BTree *treePtr;            /* The whole B-tree */
     register Node *nodePtr;		/* Node whose tag summary information
 					 * must be recomputed. */
 {
@@ -3520,7 +4213,8 @@ RecomputeNodeCounts(nodePtr)
     register TkTextLine *linePtr;
     register TkTextSegment *segPtr;
     TkTextTag *tagPtr;
-
+    int ref;
+    
     /*
      * Zero out all the existing counts for the node, but don't delete
      * the existing Summary records (most of them will probably be reused).
@@ -3532,7 +4226,9 @@ RecomputeNodeCounts(nodePtr)
     }
     nodePtr->numChildren = 0;
     nodePtr->numLines = 0;
-    nodePtr->numPixels = 0;
+    for (ref = 0; ref<treePtr->pixelReferences; ref++) {
+	nodePtr->numPixels[ref] = 0;
+    }
 
     /*
      * Scan through the children, adding the childrens' tag counts into
@@ -3545,7 +4241,9 @@ RecomputeNodeCounts(nodePtr)
 		linePtr = linePtr->nextPtr) {
 	    nodePtr->numChildren++;
 	    nodePtr->numLines++;
-	    nodePtr->numPixels += linePtr->pixelHeight;
+	    for (ref = 0; ref<treePtr->pixelReferences; ref++) {
+	        nodePtr->numPixels[ref] += linePtr->pixels[2*ref];
+	    }
 	    linePtr->parentPtr = nodePtr;
 	    for (segPtr = linePtr->segPtr; segPtr != NULL;
 		    segPtr = segPtr->nextPtr) {
@@ -3577,7 +4275,9 @@ RecomputeNodeCounts(nodePtr)
 		childPtr = childPtr->nextPtr) {
 	    nodePtr->numChildren++;
 	    nodePtr->numLines += childPtr->numLines;
-	    nodePtr->numPixels += childPtr->numPixels;
+	    for (ref = 0; ref<treePtr->pixelReferences; ref++) {
+		nodePtr->numPixels[ref] += childPtr->numPixels[ref];
+	    }
 	    childPtr->parentPtr = nodePtr;
 	    for (summaryPtr2 = childPtr->summaryPtr; summaryPtr2 != NULL;
 		    summaryPtr2 = summaryPtr2->nextPtr) {
@@ -3646,7 +4346,7 @@ RecomputeNodeCounts(nodePtr)
  *
  * TkBTreeNumLines --
  *
- *	This procedure returns a count of the number of lines of
+ *	This procedure returns a count of the number of logical lines of
  *	text present in a given B-tree.
  *
  * Results:
@@ -3661,11 +4361,24 @@ RecomputeNodeCounts(nodePtr)
  */
 
 int
-TkBTreeNumLines(tree)
+TkBTreeNumLines(tree, textPtr)
     TkTextBTree tree;			/* Information about tree. */
+    CONST TkText *textPtr;              /* Relative to this client of the 
+					 * B-tree */
 {
     BTree *treePtr = (BTree *) tree;
-    return treePtr->rootPtr->numLines - 1;
+    int count;
+    
+    if (textPtr != NULL && textPtr->end != NULL) {
+	count = TkBTreeLinesTo(NULL, textPtr->end);
+    } else {
+	count = treePtr->rootPtr->numLines - 1;
+    }
+    if (textPtr != NULL && textPtr->start != NULL) {
+	count -= TkBTreeLinesTo(NULL, textPtr->start);
+    }
+
+    return count;
 }
 
 /*
@@ -3674,13 +4387,14 @@ TkBTreeNumLines(tree)
  * TkBTreeNumPixels --
  *
  *	This procedure returns a count of the number of pixels of
- *	text present in a given B-tree.
+ *	text present in a given widget's B-tree representation.
  *
  * Results:
  *	The return value is a count of the number of usable pixels in
- *	tree (since the dummy line used to mark the end of the tree is
- *	maintained with zero height, it doesn't feature in this
- *	calculation).
+ *	tree (since the dummy line used to mark the end of the B-tree is
+ *	maintained with zero height, as are any lines that are before or
+ *	after the '-start -end' range of the text widget in question,
+ *	the number stored at the root is the number we want).
  *
  * Side effects:
  *	None.
@@ -3689,11 +4403,13 @@ TkBTreeNumLines(tree)
  */
 
 int
-TkBTreeNumPixels(tree)
-    TkTextBTree tree;			/* Information about tree. */
+TkBTreeNumPixels(tree, textPtr)
+    TkTextBTree tree;                   /* The B-tree */
+    CONST TkText *textPtr;              /* Relative to this client of the 
+                          		 * B-tree */
 {
     BTree *treePtr = (BTree *) tree;
-    return treePtr->rootPtr->numPixels;
+    return treePtr->rootPtr->numPixels[textPtr->pixelReference];
 }
 
 /*
@@ -4056,54 +4772,3 @@ ToggleCheckProc(segPtr, linePtr)
 	}
     }
 }
-
-/*
- *----------------------------------------------------------------------
- *
- * TkBTreeCharsInLine --
- *
- *	This procedure returns a count of the number of characters
- *	in a given line.
- *
- * Results:
- *	The return value is the character count for linePtr.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-int
-TkBTreeCharsInLine(linePtr)
-    TkTextLine *linePtr;		/* Line whose characters should be
-					 * counted. */
-{
-    TkTextSegment *segPtr;
-    int count;
-
-    count = 0;
-    for (segPtr = linePtr->segPtr; segPtr != NULL; segPtr = segPtr->nextPtr) {
-	if (segPtr->typePtr == &tkTextCharType) {
-	    count += Tcl_NumUtfChars(segPtr->body.chars, segPtr->size);
-	} else {
-	    count += segPtr->size;
-	}
-    }
-    return count;
-}
-
-int
-TkBTreeBytesInLine(linePtr)
-    TkTextLine *linePtr;		/* Line whose characters should be
-					 * counted. */
-{
-    TkTextSegment *segPtr;
-    int count;
-
-    count = 0;
-    for (segPtr = linePtr->segPtr; segPtr != NULL; segPtr = segPtr->nextPtr) {
-	count += segPtr->size;
-    }
-    return count;
-}