/// <summary> /// Updates the start and end offsets of all segments stored in this collection. /// </summary> /// <param name="change">OffsetChangeMapEntry instance describing the change to the document.</param> public void UpdateOffsets(OffsetChangeMapEntry change) { if (_isConnectedToDocument) { throw new InvalidOperationException("This TextSegmentCollection will automatically update offsets; do not call UpdateOffsets manually!"); } UpdateOffsetsInternal(change); CheckProperties(); }
void ChangeDocument(OffsetChangeMapEntry change) { tree.UpdateOffsets(change); foreach (TestTextSegment s in expectedSegments) { int endOffset = s.ExpectedOffset + s.ExpectedLength; s.ExpectedOffset = change.GetNewOffset(s.ExpectedOffset, AnchorMovementType.AfterInsertion); s.ExpectedLength = Math.Max(0, change.GetNewOffset(endOffset, AnchorMovementType.BeforeInsertion) - s.ExpectedOffset); } }
private void UpdateOffsetsInternal(OffsetChangeMapEntry change) { // Special case pure insertions, because they don't always cause a text segment to increase in size when the replaced region // is inside a segment (when offset is at start or end of a text semgent). if (change.RemovalLength == 0) { InsertText(change.Offset, change.InsertionLength); } else { ReplaceText(change); } }
private void ReplaceText(OffsetChangeMapEntry change) { Debug.Assert(change.RemovalLength > 0); var offset = change.Offset; foreach (var segment in FindOverlappingSegments(offset, change.RemovalLength)) { if (segment.StartOffset <= offset) { if (segment.EndOffset >= offset + change.RemovalLength) { // Replacement inside segment: adjust segment length segment.Length += change.InsertionLength - change.RemovalLength; } else { // Replacement starting inside segment and ending after segment end: set segment end to removal position //segment.EndOffset = offset; segment.Length = offset - segment.StartOffset; } } else { // Replacement starting in front of text segment and running into segment. // Keep segment.EndOffset constant and move segment.StartOffset to the end of the replacement var remainingLength = segment.EndOffset - (offset + change.RemovalLength); RemoveSegment(segment); segment.StartOffset = offset + change.RemovalLength; segment.Length = Math.Max(0, remainingLength); AddSegment(segment); } } // move start offsets of all segments > offset TextSegment node = FindFirstSegmentWithStartAfter(offset + 1); if (node != null) { Debug.Assert(node.NodeLength >= change.RemovalLength); node.NodeLength += change.InsertionLength - change.RemovalLength; UpdateAugmentedData(node); } }
public void HandleTextChange(OffsetChangeMapEntry entry, DelayedEvents delayedEvents) { //Log("HandleTextChange(" + entry + ")"); if (entry.RemovalLength == 0) { // This is a pure insertion. // Unlike a replace with removal, a pure insertion can result in nodes at the same location // to split depending on their MovementType. // Thus, we handle this case on a separate code path // (the code below looks like it does something similar, but it can only split // the set of deletion survivors, not all nodes at an offset) InsertText(entry.Offset, entry.InsertionLength, entry.DefaultAnchorMovementIsBeforeInsertion); return; } // When handling a replacing text change, we need to: // - find all anchors in the deleted segment and delete them / move them to the appropriate // surviving side. // - adjust the segment size between the left and right side int offset = entry.Offset; int remainingRemovalLength = entry.RemovalLength; // if the text change is happening after the last anchor, we don't have to do anything if (_root == null || offset >= _root.TotalLength) { return; } TextAnchorNode node = FindNode(ref offset); TextAnchorNode firstDeletionSurvivor = null; // go forward through the tree and delete all nodes in the removal segment while (node != null && offset + remainingRemovalLength > node.Length) { TextAnchor anchor = (TextAnchor)node.Target; if (anchor != null && (anchor.SurviveDeletion || entry.RemovalNeverCausesAnchorDeletion)) { if (firstDeletionSurvivor == null) { firstDeletionSurvivor = node; } // This node should be deleted, but it wants to survive. // We'll just remove the deleted length segment, so the node will be positioned // in front of the removed segment. remainingRemovalLength -= node.Length - offset; node.Length = offset; offset = 0; UpdateAugmentedData(node); node = node.Successor; } else { // delete node TextAnchorNode s = node.Successor; remainingRemovalLength -= node.Length; RemoveNode(node); // we already deleted the node, don't delete it twice _nodesToDelete.Remove(node); anchor?.OnDeleted(delayedEvents); node = s; } } // 'node' now is the first anchor after the deleted segment. // If there are no anchors after the deleted segment, 'node' is null. // firstDeletionSurvivor was set to the first node surviving deletion. // Because all non-surviving nodes up to 'node' were deleted, the node range // [firstDeletionSurvivor, node) now refers to the set of all deletion survivors. // do the remaining job of the removal if (node != null) { node.Length -= remainingRemovalLength; Debug.Assert(node.Length >= 0); } if (entry.InsertionLength > 0) { // we are performing a replacement if (firstDeletionSurvivor != null) { // We got deletion survivors which need to be split into BeforeInsertion // and AfterInsertion groups. // Take care that we don't regroup everything at offset, but only the deletion // survivors - from firstDeletionSurvivor (inclusive) to node (exclusive). // This ensures that nodes immediately before or after the replaced segment // stay where they are (independent from their MovementType) PerformInsertText(firstDeletionSurvivor, node, entry.InsertionLength, entry.DefaultAnchorMovementIsBeforeInsertion); } else if (node != null) { // No deletion survivors: // just perform the insertion node.Length += entry.InsertionLength; } } if (node != null) { UpdateAugmentedData(node); } DeleteMarkedNodes(); }