Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / wpf / src / Framework / System / Windows / Documents / TextPointer.cs / 1 / TextPointer.cs
//----------------------------------------------------------------------------
//
// File: TextPointer.cs
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
// Description: TextPointer object representing a location in formatted text.
//
//---------------------------------------------------------------------------
namespace System.Windows.Documents
{
using System;
using MS.Internal;
using System.Threading;
using System.Windows;
using System.Windows.Media;
using System.Collections;
///
/// Represents a location in a formatted text content.
///
///
/// In Avalon formatted text can be contained in elements such as
///
/// Using the properties and the methods of the TextPointer object, you can:
/// a) Find out what kind of content is in forward or in backward directions from its position;
/// b) Get a
/// c) Get characters preceding or following the TextPointer when it is positioned within text run -
/// d) Insert characters in a position where the TextPointer is located;
/// e) Inspect line layout structure by finding line boundary positions;
/// f) Perform visual hit-testing by translating back and forth positions of TextPointer objects into Point objects representing coordinates;
/// g) Create an instance of a
/// Positions in formatted document where TextPointer objects can be located
/// are places between characters and element tags.
/// As you edit a document, TextPointer objects do not move relative to their surrounding text.
/// That is, if text is inserted before a text pointer, then the offset of the pointer
/// from start position of a text container is incremented to reflect its new location
/// further down in the document (offsets between text pointers can be calculated by
/// a
/// If multiple TextPointer objects are located at the same position and a text
/// is inserted into this position, then the new characters and structural tags are
/// to the right or to the left of all of the TextPointer objects depending on their
///
/// Class None for text container boundaries, ElementStart and ElementEnd
/// for opening and closing tags of EmbeddedElement
/// for UIElements inserted in text as atomic objects. The kind of context can be
/// get from a TextPointer using method
/// TextPointer objects are immutable - they cannot be repositioned in text content
/// by any means; and their LogicalDirection property cannot be changed. The context
/// around a TextPointer can be changed though, as a result of text editing.
/// For instance, when text around a TextPointer is deleted, the TextPointer
/// will appear in a new context - in a content remaining after deletion.
/// To traverse a document content you can use a bunch of Get*Position
/// methods -
/// TextPointer class does not have public constructors.
/// The only way to get an instance of the TextPointer class is by
/// using properties or methods of other objects:
///
/// We use a concept of "insertion positions" in association with TextPointer objects,
/// which is a key for editor behavior and for various api members.
/// When caret travels over text content it can stop only at particular positions,
/// skipping all non-appropriate ones. Positions appropriate for caret stopping are called
/// "insertion positions". Boundary positions of
/// From TextPointer located at arbitrary (possibly non-insertion) position, you
/// can get a TextPointer located at a nearest insertion position by calling
///
///
///
/// Example 0. This code shows how to get an instance of a TextPointer.
/// As TextPointer does not have any public constructors, the only way
/// of getting a TextPointer is to use a property or method of other object.
/// This example ContentStart and ContentEnd properties of main text containers,
/// create a TextRange for the whole content of each of them and applies
/// Bold formatting to it.
///
/// void BoldAll(FlowDocument flowDocument, TextFlow textFlow, TextBlock textBlock, RichTextBox richTextBox)
/// {
/// allContent = new TextRange(flowDocument.ContentStart, flowDocument.ContentEnd);
/// allContent.ApplyPropertyValue(TextElement.FontWeightProperty, FontWeights.Bold);
///
/// allContent = new TextRange(textFlow.ContentStart, textFlow.ContentEnd);
/// allContent.ApplyPropertyValue(TextElement.FontWeightProperty, FontWeights.Bold);
///
/// allContent = new TextRange(textBlock.ContentStart, textFlow.ContentEnd);
/// allContent.ApplyPropertyValue(TextElement.FontWeightProperty, FontWeights.Bold);
///
/// // Note that RichTextBox does not have ContentStart/ContentEnd properties,
/// // we use its Document property to get to FlowDocument contained within.
/// TextRange allContent = new TextRange(richTextBox.Document.ContentStart, richTextBox.Document.ContentEnd);
/// allContent.ApplyPropertyValue(TextElement.FontWeightProperty, FontWeights.Bold);
/// }
///
/// Example 1. This code shows how to use TextPointer for finding a first Run element
/// from a particular position in forard direction.
///
/// Run FindNextRun(TextPointer position)
/// {
/// // Traverse content in forward direction until the position is
/// // immediately after opening tag of a Run element.
/// while (position != null &&
/// !(position.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementStart
/// &&
/// position.Parent is Run))
/// {
/// position = position.GetNextContextPosition(LogicalDirection.Forward);
/// }
///
/// // Return a result
/// return position == null ? null : position.Parent as Run;
/// }
///
/// Example 2. This code shows how to use TextPointer for finding a particular
/// word in text content. This is a simplistic "find" algorithm, not smart enough
/// for international issues and for words crossing formatting boundaries.
///
/// TextPointer FindWord(TextPointer position, string word)
/// {
/// while (position != null)
/// {
/// if (position.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.Text)
/// {
/// string textRun = position.GetTextInRun(LogicalDirection.Forward);
/// int indexInRun = textRun.IndexOf(word);
/// if (indexInRun >= 0)
/// {
/// position = position.GetPositionAtOffset(indexInRun);
/// break;
/// }
/// }
/// else
/// {
/// position = position.GetNextContextPosition(LogicalDirection.Forward);
/// }
/// }
///
/// return position; // will be null, if a word is not found.
/// }
///
/// Example 3. This code shows how to enumerate and count all Paragraphs in a given TextRange.
///
/// int GetParagraphCount(TextRange range)
/// {
/// int paragraphCount = 0;
/// TextPointer position = range.Start;
///
/// while (position != null && position.CompareTo(range.End) < 0)
/// {
/// if (position.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementStart &&
/// position.Parent is Paragraph)
/// {
/// // Just entered a paragraph.
/// paragraphCount ++;
///
/// // Jump over it.
/// // Schema does not allow nested paragraphs, so we will not miss any.
/// position = ((Paragraph)position.Parent).ElementEnd;
/// }
/// else
/// {
/// position = position.GetNextContextPosition(LogicalDirection.Forward);
/// }
/// }
///
/// return paragraphCount;
/// }
///
/// Example 4. Idenifying whether the document is empty. The document appearing as empty
/// in RichTextBox actually contains a Paragraph element with a Run child in it. So checking
/// a document emptiness is a bit tricky task. In the following example we will utilize
/// the insertion positions as the most natural mechanism for getting to character part or text content.
///
/// bool IsRichTextBoxEmpty(RichTextBox richTextBox)
/// {
/// FlowDocument document = richTextBox.Document; // get a document contained in a RichTextBox
///
/// TextPointer normalizedStart = document.ContentStart.GetInsertionPosition(LogicalDirection.Forward);
/// TextPointer normalizedEnd = document.ContentEnd.GetInsertionPosition(LogicalDirection.Backward);
///
/// // The character content is empty if normalized start and end pointers are at the same position
/// bool isEmpty = normalizedStart.CompareTo(normalizedEnd) == 0;
///
/// return isEmpty;
/// }
///
///
//
// Internal comments:
//
// TextContainer's implementation of the Text OM ITextPointer interface.
//
// TextPointers represent locations in the TextContainer. They point to a
// node/edge pair where operations like insert/remove/gettext take place.
//
// TextPointers have a property called LogicalDirection, that specifies where
// they fall if content is insert at their position. We track LogicalDirection
// implicitly: forward direction means the position is always at
// BeforeStart/BeforeEnd edges, backward direction the reverse.
//
// TextPointers are guaranteed to stick with their nodes across editing
// operations. For inserts, this happens automatically. However, if the
// node a TextPointer points to is removed from the tree, it is expected
// that a TextPointer will follow its LogicalDirection to the closest neighbor
// node still living in the tree.
//
// Since we don't store references to TextPointers in the tree itself,
// we have to wait until a method on the TextPointer is called, then
// check if the position's node is still in the tree. This operation is
// called synchronization, and the core method is SyncToTreeGeneration.
//
// SyncToTreeGeneration must be called on every public entry point before
// attempting to use the TextPointer.
//
// Since positions always point to node/edge pairs, if we want to allocate
// a position that references a character not on a node edge, we must split
// the text node at the character position. If we did no other work, the
// tree could become extremely fragmented, with a text node allocated for
// each character. To keep the tree from fragmenting, positions ref count
// the nodes they occupy. We do some gymnastics using a finalizer on
// TextPointer, adding unreferenced positions to a list we check
// periodically in all public TextContainer methods. Dead positions decrement
// their nodes' ref counts, and a text node whose ref count drops to zero will
// attempt to merge with neighbors.
public class TextPointer : ContentPosition, ITextPointer
{
//-----------------------------------------------------
//
// Constructors
//
//-----------------------------------------------------
#region Constructors
///
/// Creates a new instance of TextPointer object.
///
///
/// TextPointer from which initial properties and location are initialized.
///
///
/// New TextPointers always have their IsFrozen property set to false,
/// regardless of the state of the position parameter. Otherwise the
/// new TextPointer instance is identical to the position parameter.
///
internal TextPointer(TextPointer textPointer)
{
if (textPointer == null)
{
throw new ArgumentNullException("textPointer");
}
InitializeOffset(textPointer, 0, textPointer.GetGravityInternal());
}
// Creates a new TextPointer instance.
internal TextPointer(TextPointer position, int offset)
{
if (position == null)
{
throw new ArgumentNullException("position");
}
InitializeOffset(position, offset, position.GetGravityInternal());
}
// Creates a new TextPointer instance.
internal TextPointer(TextPointer position, LogicalDirection direction)
{
InitializeOffset(position, 0, direction);
}
// Creates a new TextPointer instance.
internal TextPointer(TextPointer position, int offset, LogicalDirection direction)
{
InitializeOffset(position, offset, direction);
}
// Creates a new TextPointer instance.
internal TextPointer(TextContainer textContainer, int offset, LogicalDirection direction)
{
SplayTreeNode node;
ElementEdge edge;
if (offset < 1 || offset > textContainer.InternalSymbolCount - 1)
{
throw new ArgumentException(SR.Get(SRID.BadDistance));
}
textContainer.GetNodeAndEdgeAtOffset(offset, out node, out edge);
Initialize(textContainer, (TextTreeNode)node, edge, direction, textContainer.PositionGeneration, false, false, textContainer.LayoutGeneration);
}
// Creates a new TextPointer instance.
internal TextPointer(TextContainer tree, TextTreeNode node, ElementEdge edge)
{
Initialize(tree, node, edge, LogicalDirection.Forward, tree.PositionGeneration, false, false, tree.LayoutGeneration);
}
// Creates a new TextPointer instance.
internal TextPointer(TextContainer tree, TextTreeNode node, ElementEdge edge, LogicalDirection direction)
{
Initialize(tree, node, edge, direction, tree.PositionGeneration, false, false, tree.LayoutGeneration);
}
// Constructor equivalent to ITextPointer.CreatePointer
internal TextPointer CreatePointer()
{
return new TextPointer(this);
}
// Constructor equivalent to ITextPointer.CreatePointer
internal TextPointer CreatePointer(LogicalDirection gravity)
{
return new TextPointer(this, gravity);
}
#if REFCOUNT_DEAD_TEXTPOINTERS
// *** This code removed ***
// The TextContainer originally was designed to ref count TextPointer references
// to TextTreeNodes. When a TextPointer is created, it addrefs its node.
// When moved, it addrefs the destination and decrements the old position.
// When finalized, it would decrement its final TextTreeNode.
//
// There are two problems with this code:
// - The GC will null out managed fields occasionally. This means we simply
// cannot use a finalizer.
// - We don't really know/can't depend on how expensive it is to use the GC,
// and the whole scheme is an attempt at perf optimization.
//
// The current state of the code is that we still ref count on create and
// move, but we've disabled the finalizer so TextPointers will reference
// their final nodes "forever". This leads to fragmentation: because
// we split TextTreeTextNodes as TextPointer reference individual
// characters. However, there's an upper bound on the fragmentation
// (we can't have more nodes than characters) and in practice no one
// walks documents character by character.
//
// So, until we identify a specific perf problem, we're not attempting
// to ressurect this code.
//
// If ever do identify fragmentation as a problem worth solving,
// we can already think of at least three possible approaches:
//
// 1. Keep the existing logic, but instead of using a finalizer,
// store an array of WeakReferences on each node (usually null).
// Periodically check the array, pruning WeakReferences with
// null Targets.
// 2. As above, but introduce a TextPointerNode instead of hanging
// arrays off other nodes.
// 3. Keep a static array of TextContainers in memory, ref counted
// by TextPointers. Restore the TextPointer finalizer, and in
// addition to decrementing the node ref count, decrement the
// TextContainer ref count.
// This method adds the position to a list of "dead" positions (no
// external references) that will be examined later to decrement
// reference counts on nodes, and ultimately merge text nodes.
//
// It's important here that we don't do anything complicated
// that might block the finalizer thread or cause too much
// contention and hurt perf. The same goes for code in
// TextContainer.EmptyDeadPositionList that also uses the lock.
///
///
~TextPointer()
{
ArrayList deadPositionList;
deadPositionList = _tree.DeadPositionList;
lock (deadPositionList)
{
deadPositionList.Add(this);
}
}
#endif // REFCOUNT_DEAD_TEXTPOINTERS
#endregion Constructors
//------------------------------------------------------
//
// Public Methods
//
//-----------------------------------------------------
#region Public Methods
///
/// Returns true if this TextPointer is positioned within the same
/// text containner as another TextPointer.
///
///
/// TextPointer to compare.
///
///
/// TextPointer objects positioned in different containers cannot
/// participate in any operations dealing with several pointers.
/// For instance, TextPointer objects from two different text containers
/// cannot be compared with each other (by calling the method
/// The purpose of this method is to test whether two TextPointer
/// objects belong to the same text container or not.
/// Formatted text can be contained within one these elements in Avalon:
///
/// Note, that if one text container is nested within another
/// TextPointer objects positioned within a nested text container
/// are not considered as belonging to the enclosing one.
///
///
/// Example 1. This example shows how to check whether a given TextPointer
/// is positioned between two other TextPointer objects - in a situation
/// when there is no guarantee that all three positions belong to
/// the same text container
///
/// bool IsPositionContainedBetween(TextPointer test, TextPointer start, TextPointer end)
/// {
/// if (!test.IsInSameDocument(start) || !test.IsInSameDocument(end))
/// {
/// return false;
/// }
/// return start.CompareTo(test) <= 0 && test.CompareTo(end) <= 0;
/// }
///
///
public bool IsInSameDocument(TextPointer textPosition)
{
if (textPosition == null)
{
throw new ArgumentNullException("textPosition");
}
_tree.EmptyDeadPositionList();
return (this.TextContainer == textPosition.TextContainer);
}
///
/// Compares positions of this TextPointer with another TextPointer.
///
///
/// The TextPointer to compare with.
///
///
/// Less than zero: this TextPointer preceeds position.
/// Zero: this TextPointer is at the same location as position.
/// Greater than zero: this TextPointer follows position.
///
///
/// Throws ArgumentException if position does not belong to the same
/// text container as this TextPointer (you can use
public int CompareTo(TextPointer position)
{
int offsetThis;
int offsetPosition;
int result;
_tree.EmptyDeadPositionList();
ValidationHelper.VerifyPosition(_tree, position);
SyncToTreeGeneration();
position.SyncToTreeGeneration();
offsetThis = GetSymbolOffset();
offsetPosition = position.GetSymbolOffset();
if (offsetThis < offsetPosition)
{
result = -1;
}
else if (offsetThis > offsetPosition)
{
result = +1;
}
else
{
result = 0;
}
return result;
}
///
/// Returns the type of content to one side of this TextPointer.
///
///
/// Direction to query.
///
///
/// Returns
/// Returns
/// Returns
/// Returns
/// Returns
///
///
/// This example shows how to use GetPointerContext method in text content
/// traversal algorithms. It implements an algorithm calculating a balanse of
/// opening and closing tags between two TextPointer positions (each opening tag
/// counted as +1, while a closing one as -1).
///
/// int GetElementTagBalance(TextPointer start, TextPointer end)
/// {
/// int balanse = 0;
///
/// while (start != null && start.CompareTo(end) < 0)
/// {
/// TextPointerContext forwardContext = start.GetPointerContext(LogicalDirection.Forward);
///
/// if (forwardContext == TextPointerContext.ElementStart)
/// {
/// balanse++;
/// }
/// else if (forwardContext == TextPointerContext.ElementEnd)
/// {
/// balanse--;
/// }
/// start = start.GetNextContextPosition(LogicalDirection.Forward);
/// }
///
/// return balanse;
/// }
///
///
public TextPointerContext GetPointerContext(LogicalDirection direction)
{
ValidationHelper.VerifyDirection(direction, "direction");
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return (direction == LogicalDirection.Forward) ? GetPointerContextForward(_node, this.Edge) : GetPointerContextBackward(_node, this.Edge);
}
///
/// Returns the count of Unicode characters between this TextPointer and the
/// edge of an element in the given direction.
///
///
/// Direction to query.
///
///
/// If the TetPointer is positioned not inside a
public int GetTextRunLength(LogicalDirection direction)
{
ValidationHelper.VerifyDirection(direction, "direction");
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
int count = 0;
// Combine adjacent text nodes into a single run.
// This isn't just a perf optimization. Because text positions
// split text nodes, if we just returned a single node's text
// callers would see strange side effects where position.GetTextLength() !=
// position.GetText if a position is moved between the calls.
if (_tree.PlainTextOnly)
{
// Optimize for TextBox, which only ever contains (sometimes
// very large quantities of) text nodes.
Invariant.Assert(this.GetScopingNode() is TextTreeRootNode);
if (direction == LogicalDirection.Forward)
{
count = _tree.InternalSymbolCount - this.GetSymbolOffset() - 1;
}
else
{
count = this.GetSymbolOffset() - 1;
}
}
else
{
TextTreeNode textNode = GetAdjacentTextNodeSibling(direction);
while (textNode != null)
{
count += textNode.SymbolCount;
textNode = ((direction == LogicalDirection.Forward) ? textNode.GetNextNode() : textNode.GetPreviousNode()) as TextTreeTextNode;
}
}
return count;
}
///
/// Returns the distance between this TextPointer and another.
///
///
/// TextPointer to compare.
///
///
/// Throws an ArgumentException if the TextPointer position is not
/// positioned within the same document as this TextPointer.
///
///
/// The return value will be negative if the TextPointer position
/// preceeds this TextPointer, zero if the two TextPointers
/// are equally positioned, or positive if position follows this
/// TextPointer.
///
///
/// The distance is represented as a number of "symbols"
/// between these two pointers.
/// Each opening and each closing tag of any TextElement
/// is considered as one symbol. So an empty TextElement contributes
/// two symbols - one for each of tags.
/// UIElement placed within InlineUIContainer or BlockUIContainer
/// represented as one symbol - independently of how complex
/// is its content. Even if the UIElement contains or is a
/// text container it is treated as atomic entity - single symbol.
/// This may be confusing especially if you do not pay
/// muchy attention to a difference between the
/// Each 16-bit unicode character inside a
/// For instance, for the following xaml:
/// <Run>abc</Run><InlineUIContainer><Button>OK</Button></InlineUIContainer>
/// the offset from itw content start to content end will be 8 -
/// one for each of: (1) Run start, (2) "a", (3) "b", (4) "c", (5) Run end, (6) InlineUIContainer start,
/// (7) whole Button element, (8) InlineUIContainer end. Note that Button
/// element considered as one symbol even though it is represented
/// by two tags and two characters.
///
///
/// In this example we show how to use TextPointer offsets for
/// persisting positional information. Assuming that the content of
/// a RichTextBox is not changed between calls of
/// GetPersistedSelection and RestoreSelectionFromPersistedRange
/// methods, the selection will be restored to its original state.
///
/// struct PersistedTextRange { int Start; int End; }
///
/// PersistedTextRange GetPersistedSelection(RichTextBox richTextBox)
/// {
/// PersistedTextRange persistedSelection;
///
/// TextPointer contentStart = richTextBox.Document.ContentStart;
/// persistedSelection.Start = contentStart.GetOffsetToPosition(richTextBox.Selection.Start);
/// persistedSelection.End = contentStart.GetOffsetToPosition(richTextBox.Selection.End);
///
/// return persistedSelection;
/// }
///
/// RestoreSelectionFromPersistedRange(RichTextBox richTextBox, PersistedTextRange persistedRange)
/// {
/// TextPointer contentStart = richTextBox.Document.ContentStart;
///
/// richTextBox.Selection.Select(
/// contentStart.GetPositionAtOffset(persistedRange.Start),
/// contentStart.GetPositionAtOffset(persistedRange.End));
/// }
///
///
///
public int GetOffsetToPosition(TextPointer position)
{
_tree.EmptyDeadPositionList();
ValidationHelper.VerifyPosition(_tree, position);
SyncToTreeGeneration();
position.SyncToTreeGeneration();
return (position.GetSymbolOffset() - GetSymbolOffset());
}
///
/// Returns text bordering this TextPointer from one side or another.
///
///
/// Direction to query.
///
///
/// See GetTextInRun(direction, textBuffer, startIndex, count) method
/// remarks for semantics of the returned text.
///
///
/// This is an example of simplistic plain text converter.
/// This algorithm produces a string concatenating all text runs
/// between two TextPointers.
/// Note that this is really simplistic algorithm. You sould use
///
///
/// string GetPlainText(TextPointer start, TextPointer end)
/// {
/// StringBuilder buffer = new StringBuilder();
///
/// while (start != null && start.CompareTo(end) < end)
/// {
/// if (start.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.Text)
/// {
/// // Check if this text run reaches beyond the end position
/// // and trancate the string if needed.
/// string textRun = start.GetTextInRum(LogicalDirection.Forward);
/// if (textRun.Length > start.GetOffsetToPosition(end))
/// {
/// textRun = textRun.Substring(0, start.GetOffsetToPosition(end));
/// }
///
/// // Add characters from this text run to output buffer.
/// buffer.Add(textRun);
/// }
///
/// start = start.GetNextContextPosition(LogicalDirection.Forward);
/// // Note that for text run this method skips the whole run, not just one character.
/// }
/// return buffer.ToString();
/// }
///
///
public string GetTextInRun(LogicalDirection direction)
{
ValidationHelper.VerifyDirection(direction, "direction");
return TextPointerBase.GetTextInRun(this, direction);
}
///
/// Copies characters bordering this TextPointer into a caller supplied char array.
///
///
/// Direction to query.
///
///
/// Buffer into which chars are copied.
///
///
/// Index within the textBuffer array at which the copy is started.
///
///
/// The maximum number of characters to copy. Must be less than
/// or equal to a (textBuffer.Length - startIndex ).
///
///
/// The count of chars actually copied.
///
///
/// Is thrown in the following cases: (a) when startIndex is less than zero,
/// (b) when startIndex is greater than textBuffer.Length ,
/// (c) when count is less than zero, (d) when count
/// is greater than size available for copying (textBuffer.Length - startIndex ).
///
///
/// This method only returns uninterrupted runs of text -- no text will
/// be returned if any symbol type other than text borders this
/// TextPointer in the specified direction. Similarly, text will only
/// be returned up to the next non-text symbol.
///
public int GetTextInRun(LogicalDirection direction, char[] textBuffer, int startIndex, int count)
{
TextTreeTextNode textNode;
ValidationHelper.VerifyDirection(direction, "direction");
SyncToTreeGeneration();
textNode = GetAdjacentTextNodeSibling(direction);
return textNode == null ? 0 : GetTextInRun(_tree, GetSymbolOffset(), textNode, -1, direction, textBuffer, startIndex, count);
}
///
/// Returns an element represented by a symbol, if any, bordering
/// this TextPointer in the specified direction.
///
///
/// Direction to query.
///
///
/// The element if its opening or closing tag exists
/// in a specified direction. Otherwize returns null.
///
///
/// The returned element may be both a
///
public DependencyObject GetAdjacentElement(LogicalDirection direction)
{
ValidationHelper.VerifyDirection(direction, "direction");
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return GetAdjacentElement(_node, this.Edge, direction);
}
///
/// Returns a TextPointer at a new position by a specified symbol
/// count.
///
///
/// Number of symbols to advance. offset may be negative, in which
/// case the TextPointer is moved backwards.
///
///
/// TextPointer located at requested position in case if requested position
/// does exist, otherwize returns null. LogicalDirection of the TextPointer
/// returned is the same as of this TexPointer.
///
///
/// This method, like all other TextPointer methods, defines a symbol
/// as one of:
/// - 16 bit Unicode character.
/// - opening or closing tag of a
/// - the whole
///
///
/// This example shows how to use this method for creating TextPointers
/// from a persisted index-based position representation.
/// The first method returns a integer offset of a TextPointer
/// from the beginning of a Paragraph. The second method re-creates
/// a pointer from an integer ofset at the same relative position.
///
/// int GetPersistedPositionRelativeToParagraph(TextPointer position)
/// {
/// Paragraph paragraph = position.Paragraph;
///
/// if (paragraph == null)
/// {
/// return 0; // Some positions may be not within any Paragraph,
/// // so we need to return something; or throw exception.
/// }
///
/// return paragraph.ContentStart.GetOffsetToPosition(position);
/// }
///
/// int GetTextPointerRelativeToParagraph(Paragraph paragraph, int persistedPositionRelativeToParagraph)
/// {
/// // Check whether persisted position is still within this paragraph
/// if (persistedPositionRelativeToParagraph >
/// paragraph.ContentStart.GetOffsetToPosition(paragraph.ContentEnd))
/// {
/// // the index is beyond the paragraph end. Return the farthest position within the paragraph.
/// return paragraph.ContentEnd;
/// }
///
/// return paragraph.ContentStart.GetPositionAtOffset(persistedPositionRelativeToParagraph);
/// }
///
///
public TextPointer GetPositionAtOffset(int offset)
{
return GetPositionAtOffset(offset, this.LogicalDirection);
}
///
/// Returns a TextPointer at a new position by a specified symbol
/// count.
///
///
/// Number of symbols to advance. offset may be negative, in which
/// case the TextPointer is moved backwards.
///
///
/// LogicalDirection desired for a returned TextPointer.
///
///
/// TextPointer located at requested position in case if requested position
/// does exist, otherwize returns null. LogicalDirection of the TextPointer
/// returned is as specified by a
///
/// This method, like all other TextPointer methods, defines a symbol
/// as one of:
/// - 16 bit Unicode character.
/// - opening or closing tag of a
/// - the whole
/// See examples in
///
public TextPointer GetPositionAtOffset(int offset, LogicalDirection direction)
{
TextPointer position = new TextPointer(this, direction);
int actualCount = position.MoveByOffset(offset);
if (actualCount == offset)
{
position.Freeze();
return position;
}
else
{
return null;
}
}
///
/// Returns a pointer at the next symbol in a specified
/// direction, or past all following Unicode characters if the
/// bordering content is Unicode text.
///
///
/// Direction to move.
///
///
/// TextPointer in a requested direction, null if this TextPointer
/// borders the start or end of the document.
///
///
/// If the following symbol is of type EmbeddedElement, ElementStart,
/// or ElementEnd (as returned by the GetPointerContext method), then
/// the TextPointer is advanced by exactly one symbol.
/// If the following symbol is of type Text, then the TextPointer is
/// advanced until it passes all following text (ie, until it reaches
/// a position with a different return value for GetPointerContext).
/// The exact symbol count crossed can be calculated in advance by
/// calling GetTextLength.
/// If there is no following symbol (start or end of the document),
/// then the method returns null.
///
///
/// This example shows how to use this method for traversing
/// text content and examine its structure. The method implements
/// a simplistic text content serializer, producing an xml-looking
/// text.
/// Note that to produce really well formed xml System.Xml
/// interfaces must be used. We use this simplification only
/// to make it more readable for people not familiar with System.Xml api.
///
/// string GetXaml(TextElement element)
/// {
/// StringBuilder buffer = new StringBuilder();
///
/// // Position a "navigator" pointer before the opening tag of the element.
/// TextPointer navigator = element.ElementStart;
///
/// while (navigator.CompareTo(element.ElementEnd) < 0)
/// {
/// switch (navigator.GetPointerContext(LogicalDirection.Forward))
/// {
/// case TextPointerContext.ElementStart :
/// // Output opening tag of the TextElement
/// buffer.AddFormat("<{0}>", navigator.GetAdjacentElement(LogicalDirection.Forward).GetType().Name);
/// break;
/// case TextPointerContext.ElementEnd :
/// // Output closing tag of the TextElement
/// buffer.AddFormat("</{0}>", navigator.GetAdjacentElement(LogicalDirection.Forward).GetType().Name);
/// break;
/// case TextPointerContent.EmbeddedElement :
/// // Output simple tag for embedded element
/// buffer.AddFormat("<{0}/>", navigator.GetAdjacentElement(LogicalDirection.Forward).GetType().Name);
/// break;
/// case TextPointerContext.Text :
/// // Output the text content of thi text run
/// buffer.Add(navigator.GetTextInRun(LoigcalDirection.Forward);
/// break;
/// case TextPointerContext.None :
/// Assert(false, "We do not expect to reach end of text container in this loop");
/// break;
/// }
///
/// // Advance the naviagtor to the next context position.
/// navigator = navigator.GetNextContextPosition(LogicalDirection.Forward);
///
/// Assert(navigator != null, "We do not expect to reach an end of a text container in this loop, as it is limited by element.ContentEnd bounadry");
/// }
/// }
///
///
public TextPointer GetNextContextPosition(LogicalDirection direction)
{
return (TextPointer)((ITextPointer)this).GetNextContextPosition(direction);
}
///
/// Returns a TextPointer at the closest insertion position in a
/// specified direction.
///
///
/// Direction to search a closest insertion position.
///
///
/// TextPointer positioned at inserion point. The value is never null.
///
///
/// The concept of insertion position is a convenience
/// for traversing text content across structural boundaries,
/// between table cells, paragraphs, list items etc.
/// An insertion position is anywhere the containing document
/// would normally place the caret. Examples of positions that are not
/// insertion positions include locations between Paragraphs
/// (between closing tag of a preceding paragraph and an opening tag
/// of the following paragraph). A position within text runs
/// in the middle of a surrogate Unicode surrogate pair is also
/// not an insertion position.
/// The method can be used for disambiguating insertion positions
/// in two cases: when the text has two insertion positions separated by
/// a sequence of formatting tags, as between "d" and "t" in this
/// markup: "<Bold>Bold</Bold>text" - we have an insertion position
/// before closing tag of Bold element and immediately after it. Both are
/// valid insertion position and caret would stop on each of them
/// depending on the direction of keyboard navigation. The method
/// GetInsertionPosition allows user to pick one or another
/// without moving to the "next" insertion position.
/// Another important case when the method is useful is
/// when a sequence of structural tags is involved. If you
/// have a position, say between closing and opening paragraph tags,
/// and want to fing a nearest insertion position the direction
/// parameter will tell which of two possible positions to take:
/// in the end of the preceding or in the begining of the following paragraph.
/// If the pointer is already at insertion position
/// but there is a non-empty sequence formatting in the given direction,
/// then the position after all formatting tags will be returned.
/// If the pointer is already at insertion position
/// and there is no any formatting tags in the given direction,
/// then the returned position is the same as this one.
/// Somethimes the whole document does not have even
/// one insertion position - it happens when the content
/// is structurally incomplete, say in empty
///
///
/// This example shows how to use the method GetInsertionPosition
/// as a convenience of finding a starting "editable" position.
///
/// bool IsElementEmpty(TextElement element)
/// {
/// // Find first and last insertion positions in this element.
/// // We use inward directions to make sure that insertion position
/// // will be found correctly in case when the element is inline formatting one
/// // (i.e. Run or Span).
/// TextPointer start = element.ContentStart.GetInsertionPosition(LogicalDirection.Forward);
/// TextPointer end = element.ContentEnd.GetInsertionPosition(LogicalDirection.Backward);
///
/// // Element has empty printable content if its first and last
/// // insertion positions are equal.
/// return start.CompareTo(end) == 0;
/// }
///
///
public TextPointer GetInsertionPosition(LogicalDirection direction)
{
return (TextPointer)((ITextPointer)this).GetInsertionPosition(direction);
}
// Used for pointer normalization in cases when direction does not matter.
internal TextPointer GetInsertionPosition()
{
return GetInsertionPosition(LogicalDirection.Forward);
}
///
/// Returns a TextPointer in the direction indicated to the following
/// insertion position.
///
///
/// Direction to move.
///
///
/// A TextPointer at an insertion position in a requested direction,
/// null if there is no more insertion positions in that direction.
///
///
/// The concept of insertion position is a convenience
/// for traversing text content across structural boundaries,
/// between table cells, paragraphs, list items etc.
/// See more detailed definition of the concept of
/// "insertion position" in the
/// If the TextPointer is not currently at an insertion position, this
/// method will move the TextPointer to the next insertion position in
/// the indicated direction, just like the MoveToInsertionPosition
/// method.
/// If the TextPointer is currently at an insertion position, this
/// method will move the TextPointer to following insertion position,
/// if the end of document is not encountered.
///
///
/// In this example we use the method GetNextInsertionPosition
/// for passing over structural boundaries in a proces of
/// enumerating all
///
/// int GetParagraphCount(TextPointer start, TextPointer end)
/// {
/// int paragraphCount = 0;
///
/// while (start != null && start.CompareTo(end) < 0)
/// {
/// Paragraph paragraph = start.Paragraph;
///
/// if (paragraph != null)
/// {
/// paragraphCount++;
///
/// // Advance start to an end of the paragraph found
/// start = paragraph.ContentEnd;
/// }
///
/// // Use GetNextInsertionPosition method to skip a sequence
/// // of structural tags
/// start = start.GetNextInsertionPosition(LogicalDirection.Forward);
/// }
///
/// return paragraphCount;
/// }
///
///
public TextPointer GetNextInsertionPosition(LogicalDirection direction)
{
return (TextPointer)((ITextPointer)this).GetNextInsertionPosition(direction);
}
///
/// Returns a TextPointer at the start of line after skipping
/// a given number of line starts in forward or backward direction.
///
///
/// Number of line starts to skip when finding a desired line start position.
/// Negative values specify preceding lines, zero specifies the current line,
/// positive values specify following lines.
///
///
/// Throws an InvalidOperationException if this TextPointer's HasValidLayout
/// property is set false. Without a calculated layout it is not possible
/// to position relative to rendered lines.
///
///
/// TextPointer positioned at the begining of a line requested
/// (with LogicalDirection set to Forward).
/// If there is no sufficient lines in requested direction,
/// returns null.
///
///
/// Line identification is possible only from normalized insertion positions;
/// Line identification from not-normalized positions is mbigous and can produce
/// unexpected results. Say, if a position is between closing and opening
/// Paragraph tags, then GetInsertionPosition(LogicalDirection) is needed
/// to decide whether we start from the end of previous Paragraph or
/// from the start of the following one. Without such call
///
/// If this TextPointer is at an otherwise ambiguous position, exactly
/// between two lines, the LogicalDirection property is used to determine
/// current position. So a TextPointer with backward LogicalDirection
/// is considered to be at the end of line, and calling MoveToLineBoundary(0)
/// would reposition it at the start of the preceding line. Making the
/// same call with forward LogicalDirection would leave the TextPointer
/// positioned where it started -- at the start of the following line.
///
///
public TextPointer GetLineStartPosition(int count)
{
int actualCount;
TextPointer lineStartPosition = GetLineStartPosition(count, out actualCount);
return (actualCount != count) ? null : lineStartPosition;
}
///
/// Returns a TextPointer at the start of line after skipping
/// a given number of line starts in forward or backward direction.
///
///
/// Offset of the destination line. Negative values specify preceding
/// lines, zero specifies the current line, positive values specify
/// following lines.
///
///
/// The offset of the line moved to. This value may be less than
/// requested if the beginning or end of document is encountered.
///
///
/// TextPointer positioned at the begining of a line requested
/// (with LogicalDirection set to Forward).
/// If there is no sufficient lines in requested direction,
/// returns a position at the beginning of a farthest line
/// in this direction. In such case out parameter actualCount
/// gets a number of lines actually skipped.
/// Unlike the other override in this case the returned pointer is never null.
///
///
/// If this TextPointer is at an otherwise ambiguous position, exactly
/// between two lines, the LogicalDirection property is used to determine
/// current position. So a TextPointer with backward LogicalDirection
/// is considered to be at the end of line, and calling MoveToLineBoundary(0)
/// would reposition it at the start of the preceding line. Making the
/// same call with forward LogicalDirection would leave the TextPointer
/// positioned where it started -- at the start of the following line.
///
public TextPointer GetLineStartPosition(int count, out int actualCount)
{
this.ValidateLayout();
TextPointer position = new TextPointer(this);
if (this.HasValidLayout)
{
actualCount = position.MoveToLineBoundary(count);
}
else
{
actualCount = 0;
}
position.SetLogicalDirection(LogicalDirection.Forward);
position.Freeze();
return position;
}
///
/// Returns the bounding box of the content bordering this TextPointer
/// in a specified direction.
///
///
/// Direction of content.
///
///
/// TextElement edges are not considered content for the purposes of
/// this method. If the TextPointer is positioned before a TextElement
/// edge, the return value will be the bounding box of the next
/// non-TextElement content.
/// If there is no content in the specified direction, a zero-width
/// Rect is returned with height matching the preceding content.
///
public Rect GetCharacterRect(LogicalDirection direction)
{
ValidationHelper.VerifyDirection(direction, "direction");
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
this.ValidateLayout();
if (!this.HasValidLayout)
{
return Rect.Empty;
}
return TextPointerBase.GetCharacterRect(this, direction);
}
///
/// Inserts text at this TextPointer's position.
///
///
/// Text to insert.
///
///
/// The LogicalDirection property specifies whether this TextPointer
/// will be positioned before or after the new text.
///
public void InsertTextInRun(string textData)
{
if (textData == null)
{
throw new ArgumentNullException("textData");
}
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
TextPointer insertPosition;
if (TextSchema.IsInTextContent(this))
{
insertPosition = this;
}
else
{
insertPosition = TextRangeEditTables.EnsureInsertionPosition(this);
}
_tree.BeginChange();
try
{
_tree.InsertTextInternal(insertPosition, textData);
}
finally
{
_tree.EndChange();
}
}
///
/// Deletes text in Run at this TextPointer's position
///
///
/// Returns the actual count of deleted chars.
/// The actual count may be less than requested in cases
/// when original requested count exceeds text run length in given direction.
///
public int DeleteTextInRun(int count)
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
// TextSchema Validation
if (!TextSchema.IsInTextContent(this))
{
return 0;
}
// Direction to delete text in run
LogicalDirection direction = count < 0 ? LogicalDirection.Backward : LogicalDirection.Forward;
// Get text run length in given direction
int maxDeleteCount = this.GetTextRunLength(direction);
// Truncate count if it extends past the run in given direction
if (count > 0 && count > maxDeleteCount)
{
count = maxDeleteCount;
}
else if (count < 0 && count < -maxDeleteCount)
{
count = -maxDeleteCount;
}
// Get a new pointer for deletion
TextPointer deleteToPosition = new TextPointer(this, count);
_tree.BeginChange();
try
{
if (count > 0)
{
_tree.DeleteContentInternal(this, deleteToPosition);
}
else if (count < 0)
{
_tree.DeleteContentInternal(deleteToPosition, this);
}
}
finally
{
_tree.EndChange();
}
return count;
}
///
/// Inserts a TextElement at this TextPointer's position.
///
///
/// ContentElement to insert.
///
///
/// The LogicalDirection property specifies whether this TextPointer
/// will be positioned before or after the TextElement.
///
///
/// Throws ArgumentException is textElement is not valid
/// according to flow schema.
///
///
/// Throws InvalidOperationException if textElement cannot be inserted
/// at this position because it belongs to another tree.
///
internal void InsertTextElement(TextElement textElement)
{
Invariant.Assert(textElement != null);
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
ValidationHelper.ValidateChild(this, textElement, "textElement");
if (textElement.Parent != null)
{
throw new InvalidOperationException(SR.Get(SRID.TextPointer_CannotInsertTextElementBecauseItBelongsToAnotherTree));
}
textElement.RepositionWithContent(this);
}
///
/// Insert a paragraph break at this position by splitting all elements upto its paragraph ancestor.
///
///
/// When this position has a paragraph parent, this method returns a
/// normalized position in the beginning of a second paragraph.
///
/// Otherwise, if the position is not parented by a paragraph
/// (for special insertion positions such as table row end, BlockUIContainer boundaries, etc),
/// this method creates a paragraph by using rules of EnsureInsertionPosition()
/// and returns a normalized position at the start of the paragraph created.
///
///
/// Throws InvalidOperationException when this position has a non-splittable ancestor such as Hyperlink,
/// since we cannot successfully split upto the parent paragraph in this case.
///
public TextPointer InsertParagraphBreak()
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
Type containerType = this.TextContainer.Parent.GetType();
if (!TextSchema.IsValidChildOfContainer(containerType, typeof(Paragraph)))
{
throw new InvalidOperationException(SR.Get(SRID.TextSchema_IllegalElement, "Paragraph", containerType));
}
Inline ancestor = this.GetNonMergeableInlineAncestor();
if (ancestor != null)
{
// Cannot split a hyperlink element!
throw new InvalidOperationException(SR.Get(SRID.TextSchema_CannotSplitElement, ancestor.GetType().Name));
}
TextPointer position;
_tree.BeginChange();
try
{
position = TextRangeEdit.InsertParagraphBreak(this, /*moveIntoSecondParagraph:*/true);
}
finally
{
_tree.EndChange();
}
return position;
}
///
/// Insert a line break at this position.
/// If the position is parented by a Run, the Run element is split at this position and then a line break inserted.
///
///
/// TextPointer positioned immediately after the closing tag of
/// a
public TextPointer InsertLineBreak()
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
TextPointer position;
_tree.BeginChange();
try
{
position = TextRangeEdit.InsertLineBreak(this);
}
finally
{
_tree.EndChange();
}
return position;
}
///
/// Debug only ToString override.
///
public override string ToString()
{
#if DEBUG
return "TextPointer Id=" + _debugId + " NodeId=" + _node.DebugId + " Edge=" + this.Edge;
#else
return base.ToString();
#endif // DEBUG
}
#endregion Public Methods
//------------------------------------------------------
//
// Public Properties
//
//------------------------------------------------------
#region Public Properties
///
/// Returns true if layout is calculated at the current position.
///
///
/// Methods that depend on layout -- GetLineStartPosition,
/// GetCharacterRect, and IsAtLineStartPosition -- will attempt
/// to re-calculate a dirty layout when called. Recalculating
/// layout can be extremely expensive, however, and this method
/// lets the caller detect when layout is dirty.
///
// Internal methods that depend on this property:
// - MoveToNextCaretPosition
// - MoveToBackspaceCaretPosition
public bool HasValidLayout
{
get
{
return _tree.TextView == null ? false : _tree.TextView.IsValid && _tree.TextView.Contains(this);
}
}
///
/// Specifies whether the TextPointer is associated with preceding or
/// following content.
///
///
/// If new content is insert at the TextPointer's current position, it
/// will move to the edge of the new content that also borders its
/// original associated content.
///
public LogicalDirection LogicalDirection
{
get
{
return GetGravityInternal();
}
}
///
/// Returns the logical parent scoping this TextPointer.
///
public DependencyObject Parent
{
get
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return GetLogicalTreeNode();
}
}
///
/// Returns true if this TextPointer is positioned at an insertion
/// position.
///
///
/// An "insertion position" is a position where where the containing document
/// would normally place the caret. Examples of positions that are not
/// insertion positions include spaces between Paragraphs, or between
/// Unicode surrogate pairs.
///
public bool IsAtInsertionPosition
{
get
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return TextPointerBase.IsAtInsertionPosition(this);
}
}
///
/// Returns true if this TextPointer is positioned at the start of a
/// line.
///
///
/// Throws an InvalidOperationException if this TextPointer's HasValidLayout
/// property is set false. Without a calculated layout it is not possible
/// to determine where the current line starts or ends.
///
///
/// If this TextPointer is at an otherwise ambiguous position, exactly
/// between two lines, the LogicalDirection property is used to determine
/// current position. So a TextPointer with backward LogicalDirection
/// will never have a true IsAtLineStartPosition unless it is positioned at the
/// head of a document.
/// This property is always false when HasValidLayout is false.
///
public bool IsAtLineStartPosition
{
get
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
this.ValidateLayout();
if (!this.HasValidLayout)
{
return false;
}
TextSegment lineRange = _tree.TextView.GetLineRange(this);
// Null lineRange if no layout is available.
if (!lineRange.IsNull)
{
TextPointer position = new TextPointer(this);
TextPointerContext backwardContext = position.GetPointerContext(LogicalDirection.Backward);
// Skip past any formatting.
while ((backwardContext == TextPointerContext.ElementStart || backwardContext == TextPointerContext.ElementEnd) &&
TextSchema.IsFormattingType(position.GetAdjacentElement(LogicalDirection.Backward).GetType()))
{
position.MoveToNextContextPosition(LogicalDirection.Backward);
backwardContext = position.GetPointerContext(LogicalDirection.Backward);
}
if (position.CompareTo((TextPointer)lineRange.Start) <= 0)
{
return true;
}
}
return false;
}
}
///
/// Returns the paragraph scoping this textpointer
///
///
/// When TextPointer is at insertion position it usually
/// have non-null paragraph. The only exception is when
/// it is positioned at the end of TableRow, where
/// there is no scoping paragraph.
/// When TextPointer is positioned outside of a paragraph,
/// the property returns null.
///
public Paragraph Paragraph
{
get
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return this.ParentBlock as Paragraph;
}
}
///
/// Returns the paragraph-like parent of the pointer
///
///
/// If we would have a common base class for Paragraph and BlockUIContainer,
/// we would return it here.
///
internal Block ParagraphOrBlockUIContainer
{
//
get
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
Block parentBlock = this.ParentBlock;
return (parentBlock is Paragraph) || (parentBlock is BlockUIContainer) ? parentBlock : null;
}
}
///
/// The start position of the document's content
///
///
/// This property may be useful as a base for persistent
/// position indexing - for calculating offsets
/// to all other pointers.
/// The
///
public TextPointer DocumentStart
{
get
{
return TextContainer.Start;
}
}
///
/// The end position of the document's content.
///
///
/// The
///
public TextPointer DocumentEnd
{
get
{
return TextContainer.End;
}
}
#endregion Public Properties
//-----------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
// Returns this TextPointer's topmost Inline ancestor, which is not a mergeable (or splittable) Inline element. (e.g. Hyperlink)
internal Inline GetNonMergeableInlineAncestor()
{
Inline ancestor = this.Parent as Inline;
while (ancestor != null && TextSchema.IsMergeableInline(ancestor.GetType()))
{
ancestor = ancestor.Parent as Inline;
}
return ancestor;
}
// Returns this TextPointer's closest ListItem ancestor.
internal ListItem GetListAncestor()
{
TextElement ancestor = this.Parent as TextElement;
while (ancestor != null && !(ancestor is ListItem))
{
ancestor = ancestor.Parent as TextElement;
}
return ancestor as ListItem;
}
internal static int GetTextInRun(TextContainer textContainer, int symbolOffset, TextTreeTextNode textNode, int nodeOffset, LogicalDirection direction, char[] textBuffer, int startIndex, int count)
{
int skipCount;
int finalCount;
if (textBuffer == null)
{
throw new ArgumentNullException("textBuffer");
}
if (startIndex < 0)
{
throw new ArgumentException(SR.Get(SRID.NegativeValue, "startIndex"));
}
if (startIndex > textBuffer.Length)
{
throw new ArgumentException(SR.Get(SRID.StartIndexExceedsBufferSize, startIndex, textBuffer.Length));
}
if (count < 0)
{
throw new ArgumentException(SR.Get(SRID.NegativeValue, "count"));
}
if (count > textBuffer.Length - startIndex)
{
throw new ArgumentException(SR.Get(SRID.MaxLengthExceedsBufferSize, count, textBuffer.Length, startIndex));
}
Invariant.Assert(textNode != null, "textNode is expected to be non-null");
textContainer.EmptyDeadPositionList();
if (nodeOffset < 0)
{
skipCount = 0;
}
else
{
skipCount = (direction == LogicalDirection.Backward) ? nodeOffset : textNode.SymbolCount - nodeOffset;
symbolOffset += nodeOffset;
}
finalCount = 0;
// Loop and combine adjacent text nodes into a single run.
// This isn't just a perf optimization. Because text positions
// split text nodes, if we just returned a single node's text
// callers would see strange side effects where position.GetTextLength() !=
// position.GetText() if another position is moved between the calls.
while (textNode != null)
{
// Never return more textBuffer than the text following this position in the current text node.
finalCount += Math.Min(count - finalCount, textNode.SymbolCount - skipCount);
skipCount = 0;
if (finalCount == count)
break;
textNode = ((direction == LogicalDirection.Forward) ? textNode.GetNextNode() : textNode.GetPreviousNode()) as TextTreeTextNode;
}
// If we're reading backwards, need to fixup symbolOffset to point into the node.
if (direction == LogicalDirection.Backward)
{
symbolOffset -= finalCount;
}
if (finalCount > 0) // We may not have allocated textContainer.RootTextBlock if no text was ever inserted.
{
TextTreeText.ReadText(textContainer.RootTextBlock, symbolOffset, finalCount, textBuffer, startIndex);
}
return finalCount;
}
internal static DependencyObject GetAdjacentElement(TextTreeNode node, ElementEdge edge, LogicalDirection direction)
{
TextTreeNode adjacentNode;
DependencyObject element;
adjacentNode = GetAdjacentNode(node, edge, direction);
if (adjacentNode is TextTreeObjectNode)
{
element = ((TextTreeObjectNode)adjacentNode).EmbeddedElement;
}
else if (adjacentNode is TextTreeTextElementNode)
{
element = ((TextTreeTextElementNode)adjacentNode).TextElement;
}
else
{
// We're adjacent to a text node, or have no sibling in the specified direction.
element = null;
}
return element;
}
///
/// Moves this TextPointer to another TextPointer's position.
///
///
/// Position to move to.
///
///
/// Throws an ArgumentException if textPosition is not
/// positioned within the same document.
///
///
/// Throws an InvalidOperationException if this TextPointer's IsFrozen
/// property is set true. Frozen TextPointers may not be repositioned.
///
internal void MoveToPosition(TextPointer textPosition)
{
ValidationHelper.VerifyPosition(_tree, textPosition);
VerifyNotFrozen();
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
textPosition.SyncToTreeGeneration();
MoveToNode(_tree, textPosition.Node, textPosition.Edge);
}
///
/// Advances this TextPointer to a new position by a specified symbol
/// count.
///
///
/// Number of symbols to advance. offset may be negative, in which
/// case the TextPointer is moved backwards.
///
///
/// Throws an InvalidOperationException if this TextPointer's IsFrozen
/// property is set true. Frozen TextPointers may not be repositioned.
///
///
/// This method, like all other TextPointer methods, defines a symbol
/// as a
/// - 16 bit Unicode character.
/// - TextElement start or end edge.
/// - UIElement.
/// - ContentElement other than TextElement.
///
///
/// The number of symbols actually advanced. The absolute value of the
/// count returned may be less than requested if the end of document is
/// encountered while advancing.
///
internal int MoveByOffset(int offset)
{
SplayTreeNode node;
ElementEdge edge;
int symbolOffset;
int currentOffset;
VerifyNotFrozen();
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
if (offset != 0)
{
currentOffset = GetSymbolOffset();
symbolOffset = unchecked(currentOffset + offset);
if (symbolOffset < 1)
{
if (offset > 0)
{
// Rolled past Int32.MaxValue. Go to end of doc.
symbolOffset = _tree.InternalSymbolCount - 1;
offset = symbolOffset - currentOffset;
}
else
{
// Underflow. Go to start of doc.
offset += (1 - symbolOffset);
symbolOffset = 1;
}
}
else if (symbolOffset > _tree.InternalSymbolCount - 1)
{
// Overflow. Go to end of doc.
// NB: there's no symmetric check here for rolling under with distance=Int32.MinValue.
// Since GetSymbolOffset is always positive, we can't roll-around with a min value.
offset -= (symbolOffset - (_tree.InternalSymbolCount - 1));
symbolOffset = _tree.InternalSymbolCount - 1;
}
_tree.GetNodeAndEdgeAtOffset(symbolOffset, out node, out edge);
MoveToNode(_tree, (TextTreeNode)node, edge);
}
return offset;
}
///
/// Advances this TextPointer to the next symbol in a specified
/// direction, or past all following Unicode characters if the
/// bordering content is Unicode text.
///
///
/// Direction to move.
///
///
/// Throws an InvalidOperationException if this TextPointer's IsFrozen
/// property is set true. Frozen TextPointers may not be repositioned.
///
///
/// true if the TextPointer is repositioned, false if the TextPointer
/// borders the start or end of the document.
///
///
/// If the following symbol is of type EmbeddedElement, ElementStart,
/// or ElementEnd (as returned by the GetPointerContext method), then
/// the TextPointer is advanced by exactly one symbol.
///
/// If the following symbol is of type Text, then the TextPointer is
/// advanced until it passes all following text (ie, until it reaches
/// a position with a different return value for GetPointerContext).
/// The exact symbol count crossed can be calculated in advance by
/// calling GetTextLength.
///
/// If there is no following symbol (start or end of the document),
/// then the method does nothing and returns false.
///
internal bool MoveToNextContextPosition(LogicalDirection direction)
{
TextTreeNode node;
ElementEdge edge;
bool moved;
ValidationHelper.VerifyDirection(direction, "direction");
VerifyNotFrozen();
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
if (direction == LogicalDirection.Forward)
{
moved = GetNextNodeAndEdge(out node, out edge);
}
else
{
moved = GetPreviousNodeAndEdge(out node, out edge);
}
if (moved)
{
SetNodeAndEdge(AdjustRefCounts(node, edge, _node, this.Edge), edge);
DebugAssertGeneration();
}
AssertState();
return moved;
}
///
/// Moves this TextPointer to the closest insertion position in a
/// specified direction. If the pointer is already at insertion point
/// but there is a non-empty sequence formatting in the given direction,
/// then the position moves to the other instance of this insertion
/// position.
///
///
/// Direction to move.
///
///
/// Throws an InvalidOperationException if this TextPointer's IsFrozen
/// property is set true. Frozen TextPointers may not be repositioned.
///
///
/// An "insertion position" is a position where new content may be added
/// without breaking any semantic rules of the containing document.
///
/// In practice, an insertion position is anywhere the containing document
/// would normally place the caret. Examples of positions that are not
/// insertion positions include spaces between Paragraphs, or between
/// Unicode surrogate pairs.
///
///
/// True if the TextPointer is repositioned, false otherwise.
///
internal bool MoveToInsertionPosition(LogicalDirection direction)
{
ValidationHelper.VerifyDirection(direction, "direction");
VerifyNotFrozen();
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return TextPointerBase.MoveToInsertionPosition(this, direction);
}
///
/// Advances this TextPointer in the direction indicated to the following
/// insertion position.
///
///
/// Direction to move.
///
///
/// Throws an InvalidOperationException if this TextPointer's IsFrozen
/// property is set true. Frozen TextPointers may not be repositioned.
///
///
/// An "insertion position" is a position where new content may be added
/// without breaking any semantic rules of the containing document.
///
/// In practice, an insertion position is anywhere the containing document
/// would normally place the caret. Examples of positions that are not
/// insertion positions include spaces between Paragraphs, or between
/// Unicode surrogate pairs.
///
/// If the TextPointer is not currently at an insertion position, this
/// method will move the TextPointer to the next insertion position in
/// the indicated direction, just like the MoveToInsertionPosition
/// method.
///
/// If the TextPointer is currently at an insertion position, this
/// method will move the TextPointer to following insertion position,
/// if the end of document is not encountered.
///
///
/// True if the TextPointer is repositioned, false otherwise.
///
internal bool MoveToNextInsertionPosition(LogicalDirection direction)
{
ValidationHelper.VerifyDirection(direction, "direction");
VerifyNotFrozen();
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return TextPointerBase.MoveToNextInsertionPosition(this, direction);
}
///
/// Advances this TextPointer to the start of a neighboring line.
///
///
/// Offset of the destination line. Negative values specify preceding
/// lines, zero specifies the current line, positive values specify
/// following lines.
///
///
/// Throws an InvalidOperationException if this TextPointer's IsFrozen
/// property is set true. Frozen TextPointers may not be repositioned.
///
///
/// The offset of the line moved to. This value may be less than
/// requested if the beginning or end of document is encountered.
///
///
/// If this TextPointer is at an otherwise ambiguous position, exactly
/// between two lines, the LogicalDirection property is used to determine
/// current position. So a TextPointer with backward LogicalDirection
/// is considered to be at the end of line, and calling MoveToLineBoundary(0)
/// would reposition it at the start of the preceding line. Making the
/// same call with forward LogicalDirection would leave the TextPointer
/// positioned where it started -- at the start of the following line.
///
internal int MoveToLineBoundary(int count)
{
VerifyNotFrozen();
this.ValidateLayout();
if (!this.HasValidLayout)
{
return 0;
}
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return TextPointerBase.MoveToLineBoundary(this, _tree.TextView, count);
}
///
/// Inserts a UIElement at this TextPointer's position.
///
///
/// UIElement to insert.
///
///
/// The LogicalDirection property specifies whether this TextPointer
/// will be positioned before or after the UIElement.
///
///
/// Throws ArgumentException is contentElement is not valid
/// according to flow schema.
///
internal void InsertUIElement(UIElement uiElement)
{
if (uiElement == null)
{
throw new ArgumentNullException("uiElement");
}
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
ValidationHelper.ValidateChild(this, uiElement, "uiElement");
if (!((TextElement)this.Parent).IsEmpty) // the parent may be InlineUIContainer or BlockUIContainer
{
throw new InvalidOperationException(SR.Get(SRID.TextSchema_UIElementNotAllowedInThisPosition));
}
_tree.BeginChange();
try
{
_tree.InsertEmbeddedObjectInternal(this, uiElement);
}
finally
{
_tree.EndChange();
}
}
//
internal TextElement GetAdjacentElementFromOuterPosition(LogicalDirection direction)
{
TextTreeTextElementNode elementNode;
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
elementNode = GetAdjacentTextElementNodeSibling(direction);
return (elementNode == null) ? null : elementNode.TextElement;
}
///
/// Sets the logical direction of this textpointer.
///
///
/// Throws an InvalidOperationException if this TextPointer's Freeze() method has been called.
///
///
internal void SetLogicalDirection(LogicalDirection direction)
{
SplayTreeNode newNode;
ElementEdge edge;
ValidationHelper.VerifyDirection(direction, "direction");
VerifyNotFrozen();
_tree.EmptyDeadPositionList();
if (GetGravityInternal() != direction)
{
SyncToTreeGeneration();
newNode = _node;
// We need to shift nodes to match the new gravity.
switch (this.Edge)
{
case ElementEdge.BeforeStart:
newNode = _node.GetPreviousNode();
if (newNode != null)
{
// Move to the previous sibling.
edge = ElementEdge.AfterEnd;
}
else
{
// Move to parent inner edge.
newNode = _node.GetContainingNode();
Invariant.Assert(newNode != null, "Bad tree state: newNode must be non-null (BeforeStart)");
edge = ElementEdge.AfterStart;
}
break;
case ElementEdge.AfterStart:
newNode = _node.GetFirstContainedNode();
if (newNode != null)
{
// Move to first child.
edge = ElementEdge.BeforeStart;
}
else
{
// Move to opposite edge.
newNode = _node;
edge = ElementEdge.BeforeEnd;
}
break;
case ElementEdge.BeforeEnd:
newNode = _node.GetLastContainedNode();
if (newNode != null)
{
// Move to last child.
edge = ElementEdge.AfterEnd;
}
else
{
// Move to opposite edge.
newNode = _node;
edge = ElementEdge.AfterStart;
}
break;
case ElementEdge.AfterEnd:
newNode = _node.GetNextNode();
if (newNode != null)
{
// Move to the next sibling.
edge = ElementEdge.BeforeStart;
}
else
{
// Move to parent inner edge.
newNode = _node.GetContainingNode();
Invariant.Assert(newNode != null, "Bad tree state: newNode must be non-null (AfterEnd)");
edge = ElementEdge.BeforeEnd;
}
break;
default:
Invariant.Assert(false, "Bad ElementEdge value");
edge = this.Edge;
break;
}
SetNodeAndEdge(AdjustRefCounts((TextTreeNode)newNode, edge, _node, this.Edge), edge);
Invariant.Assert(GetGravityInternal() == direction, "Inconsistent position gravity");
}
}
///
/// True if the Freeze method has been called, in which case
/// this TextPointer is immutable and may not be repositioned.
///
///
/// By default, TextPointers are mutable -- they may be
/// repositioned with calls to methods like MoveByOffset, and
/// LogicalDirection may be changed freely. After Freeze is
/// called, a TextPointer is locked down -- any attempt to set
/// LogicalDirection or call repositioning methods will raise an
/// InvalidOperationException.
///
internal bool IsFrozen
{
get
{
_tree.EmptyDeadPositionList();
return (_flags & (uint)Flags.IsFrozen) == (uint)Flags.IsFrozen;
}
}
///
/// Makes this TextPointer immutable.
///
///
/// By default, TextPointers are mutable -- they may be
/// repositioned with calls to methods like MoveByOffset, and
/// LogicalDirection may be changed freely. After this method is
/// called, a TextPointer is locked down -- any attempt to set
/// LogicalDirection or call repositioning methods will raise an
/// InvalidOperationException.
///
/// The IsFrozen property will return true after this method is called.
///
/// Calling Freeze multiple times has no additional effect.
///
internal void Freeze()
{
_tree.EmptyDeadPositionList();
SetIsFrozen();
}
///
/// Returns an immutable TextPointer instance positioned equally to
/// this one, with a specified LogicalDirection.
///
///
/// LogicalDirection of the returned TextPointer.
///
///
/// The TextPointer returned will always have its IsFrozen property set
/// true.
///
/// The return value will be a new TextPointer instance unless this
/// TextPointer is already frozen with a matching LogicalDirection, in
/// which case this TextPointer will be returned.
///
internal TextPointer GetFrozenPointer(LogicalDirection logicalDirection)
{
ValidationHelper.VerifyDirection(logicalDirection, "logicalDirection");
_tree.EmptyDeadPositionList();
return (TextPointer)TextPointerBase.GetFrozenPointer(this, logicalDirection);
}
void ITextPointer.SetLogicalDirection(LogicalDirection direction)
{
SetLogicalDirection(direction);
}
int ITextPointer.CompareTo(ITextPointer position)
{
return CompareTo((TextPointer)position);
}
int ITextPointer.CompareTo(StaticTextPointer position)
{
int offsetThis;
int offsetPosition;
int result;
offsetThis = this.Offset + 1;
offsetPosition = TextContainer.GetInternalOffset(position);
if (offsetThis < offsetPosition)
{
result = -1;
}
else if (offsetThis > offsetPosition)
{
result = +1;
}
else
{
result = 0;
}
return result;
}
int ITextPointer.GetOffsetToPosition(ITextPointer position)
{
return GetOffsetToPosition((TextPointer)position);
}
TextPointerContext ITextPointer.GetPointerContext(LogicalDirection direction)
{
return GetPointerContext(direction);
}
int ITextPointer.GetTextRunLength(LogicalDirection direction)
{
return GetTextRunLength(direction);
}
//
///
internal bool MoveToCaretPosition(LogicalDirection contentDirection)
{
TextPointer position;
LogicalDirection oppositeDirection;
bool moved;
ValidationHelper.VerifyDirection(contentDirection, "contentDirection");
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
VerifyNotFrozen();
this.ValidateLayout();
if (!this.HasValidLayout)
{
return false;
}
moved = false;
if (!_tree.TextView.IsAtCaretUnitBoundary(this))
{
oppositeDirection = (contentDirection == LogicalDirection.Forward) ? LogicalDirection.Backward : LogicalDirection.Forward;
position = (TextPointer)_tree.TextView.GetNextCaretUnitPosition(this, oppositeDirection);
MoveToPosition(position);
moved = true;
}
return moved;
}
///
///
internal bool MoveToNextCaretPosition(LogicalDirection direction)
{
TextPointer position;
bool moved;
ValidationHelper.VerifyDirection(direction, "direction");
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
VerifyNotFrozen();
this.ValidateLayout();
if (!this.HasValidLayout)
{
return false;
}
position = (TextPointer)_tree.TextView.GetNextCaretUnitPosition(this, direction);
moved = false;
if (this.CompareTo(position) != 0)
{
MoveToPosition(position);
moved = true;
}
return moved;
}
///
///
internal bool MoveToBackspaceCaretPosition()
{
TextPointer position;
bool moved;
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
VerifyNotFrozen();
this.ValidateLayout();
if (!this.HasValidLayout)
{
return false;
}
position = (TextPointer)_tree.TextView.GetBackspaceCaretUnitPosition(this);
moved = false;
if (this.CompareTo(position) != 0)
{
MoveToPosition(position);
moved = true;
}
return moved;
}
#endif
void ITextPointer.InsertTextInRun(string textData)
{
this.InsertTextInRun(textData);
}
//
void ITextPointer.DeleteContentToPosition(ITextPointer limit)
{
_tree.BeginChange();
try
{
// DeleteContent is clever enough to handle the this > limit case.
TextRangeEditTables.DeleteContent(this, (TextPointer)limit);
}
finally
{
_tree.EndChange();
}
}
///
/// Returns the TextContainer that this TextPointer is a part of.
///
ITextContainer ITextPointer.TextContainer
{
get
{
return this.TextContainer;
}
}
//
/// Returns the TextContainer that this TextPointer is a part of.
///
internal TextContainer TextContainer
{
get
{
return _tree;
}
}
///
/// A FrameworkElement owning a TextContainer to which this TextPointer belongs.
///
internal FrameworkElement ContainingFrameworkElement
{
get
{
return ((FrameworkElement)_tree.Parent);
}
}
// Position at row end (immediately before Row closing tag) is a valid stopper for a caret.
// Editing operations are restricted here (e.g. typing should automatically jump
// to the following character position.
// This property identifies such special position.
internal bool IsAtRowEnd
{
get
{
return TextPointerBase.IsAtRowEnd(this);
}
}
#if DEBUG
// Debug-only unique identifier for this instance.
int DebugId
{
get
{
return _debugId;
}
}
#endif // DEBUG
// Indicates if this TextPointer has an ancestor that is not a mergeable (or splittable) Inline element. (e.g. Hyperlink)
internal bool HasNonMergeableInlineAncestor
{
get
{
Inline ancestor = this.GetNonMergeableInlineAncestor();
return ancestor != null;
}
}
// Returns true if position is at the start boundary of a non-mergeable inline ancestor (hyperlink)
internal bool IsAtNonMergeableInlineStart
{
get
{
return TextPointerBase.IsAtNonMergeableInlineStart(this);
}
}
// The node referenced by this position.
internal TextTreeNode Node
{
get
{
return _node;
}
}
// The edge referenced by this position.
internal ElementEdge Edge
{
get
{
return (ElementEdge)(_flags & (uint)Flags.EdgeMask);
}
}
// Returns the Block parenting this TextPointer, or null if none exists.
internal Block ParentBlock
{
get
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
DependencyObject parentBlock = this.Parent;
while (parentBlock is Inline && !(parentBlock is AnchoredBlock))
{
parentBlock = ((Inline)parentBlock).Parent;
}
return parentBlock as Block;
}
}
#endregion Internal Properties
//-----------------------------------------------------
//
// Private Methods
//
//------------------------------------------------------
#region Private Methods
// Called by the TextPointer ctor. Initializes this instance.
private void InitializeOffset(TextPointer position, int distance, LogicalDirection direction)
{
SplayTreeNode node;
ElementEdge edge;
int offset;
bool isCaretUnitBoundaryCacheValid;
// We MUST [....] to the current tree, otherwise we could addref
// an orphaned node, resulting in a future unmatched release...
// Ref counts on orphaned nodes are only considered at the time
// of removal, not afterwards.
position.SyncToTreeGeneration();
if (distance != 0)
{
offset = position.GetSymbolOffset() + distance;
if (offset < 1 || offset > position.TextContainer.InternalSymbolCount - 1)
{
throw new ArgumentException(SR.Get(SRID.BadDistance));
}
position.TextContainer.GetNodeAndEdgeAtOffset(offset, out node, out edge);
isCaretUnitBoundaryCacheValid = false;
}
else
{
node = position.Node;
edge = position.Edge;
isCaretUnitBoundaryCacheValid = position.IsCaretUnitBoundaryCacheValid;
}
Initialize(position.TextContainer, (TextTreeNode)node, edge, direction, position.TextContainer.PositionGeneration,
position.CaretUnitBoundaryCache, isCaretUnitBoundaryCacheValid, position._layoutGeneration);
}
// Called by the TextPointer ctor. Initializes this instance.
private void Initialize(TextContainer tree, TextTreeNode node, ElementEdge edge, LogicalDirection gravity, uint generation,
bool caretUnitBoundaryCache, bool isCaretUnitBoundaryCacheValid, uint layoutGeneration)
{
_tree = tree;
// Fixup of the target node based on gravity.
// Positions always cling to a node edge that matches their gravity,
// so that insert ops never affect the position.
RepositionForGravity(ref node, ref edge, gravity);
SetNodeAndEdge(node.IncrementReferenceCount(edge), edge);
_generation = generation;
this.CaretUnitBoundaryCache = caretUnitBoundaryCache;
this.IsCaretUnitBoundaryCacheValid = isCaretUnitBoundaryCacheValid;
_layoutGeneration = layoutGeneration;
VerifyFlags();
tree.AssertTree();
AssertState();
}
// Throws an exception if this TextPointer is frozen.
private void VerifyNotFrozen()
{
if (this.IsFrozen)
{
throw new InvalidOperationException(SR.Get(SRID.TextPositionIsFrozen));
}
}
// Inc/decs the position ref counts on TextTreeTextNodes as the navigator
// is repositioned.
// If the new ref is to a TextTreeTextNode, the node may be split.
// Returns the actual node referenced, which will always be newNode,
// unless newNode is a TextTreeTextNode that gets split. The caller
// should use the returned node to position navigators.
private TextTreeNode AdjustRefCounts(TextTreeNode newNode, ElementEdge newNodeEdge, TextTreeNode oldNode, ElementEdge oldNodeEdge)
{
TextTreeNode node;
// This test should walk the tree upwards to catch all errors...probably not worth the slowdown though.
Invariant.Assert(oldNode.ParentNode == null || oldNode.IsChildOfNode(oldNode.ParentNode), "Trying to add ref a dead node!");
Invariant.Assert(newNode.ParentNode == null || newNode.IsChildOfNode(newNode.ParentNode), "Trying to add ref a dead node!");
node = newNode;
if (newNode != oldNode || newNodeEdge != oldNodeEdge)
{
node = newNode.IncrementReferenceCount(newNodeEdge);
oldNode.DecrementReferenceCount(oldNodeEdge);
}
return node;
}
// For any logical position (location between two symbols) there are two
// possible node/edge pairs. This method choses the pair that fits a
// specified gravity, such that future inserts won't require that a text
// position be moved, based on its gravity, at the node/edge pair.
private static void RepositionForGravity(ref TextTreeNode node, ref ElementEdge edge, LogicalDirection gravity)
{
SplayTreeNode newNode;
ElementEdge newEdge;
newNode = node;
newEdge = edge;
switch (edge)
{
case ElementEdge.BeforeStart:
if (gravity == LogicalDirection.Backward)
{
newNode = node.GetPreviousNode();
newEdge = ElementEdge.AfterEnd;
if (newNode == null)
{
newNode = node.GetContainingNode();
newEdge = ElementEdge.AfterStart;
}
}
break;
case ElementEdge.AfterStart:
if (gravity == LogicalDirection.Forward)
{
newNode = node.GetFirstContainedNode();
newEdge = ElementEdge.BeforeStart;
if (newNode == null)
{
newNode = node;
newEdge = ElementEdge.BeforeEnd;
}
}
break;
case ElementEdge.BeforeEnd:
if (gravity == LogicalDirection.Backward)
{
newNode = node.GetLastContainedNode();
newEdge = ElementEdge.AfterEnd;
if (newNode == null)
{
newNode = node;
newEdge = ElementEdge.AfterStart;
}
}
break;
case ElementEdge.AfterEnd:
if (gravity == LogicalDirection.Forward)
{
newNode = node.GetNextNode();
newEdge = ElementEdge.BeforeStart;
if (newNode == null)
{
newNode = node.GetContainingNode();
newEdge = ElementEdge.BeforeEnd;
}
}
break;
}
node = (TextTreeNode)newNode;
edge = newEdge;
}
// Worker for GetGravity. No parameter validation.
private LogicalDirection GetGravityInternal()
{
return (this.Edge == ElementEdge.BeforeStart || this.Edge == ElementEdge.BeforeEnd) ? LogicalDirection.Forward : LogicalDirection.Backward;
}
// Returns the DependencyObject scoping this position.
private DependencyObject GetDependencyParent()
{
DebugAssertGeneration();
return GetScopingNode().GetDependencyParent();
}
// Returns the node in the direction indicated bordering
// a TextPointer, or null if no such node exists.
internal TextTreeNode GetAdjacentNode(LogicalDirection direction)
{
return GetAdjacentNode(_node, this.Edge, direction);
}
internal static TextTreeNode GetAdjacentNode(TextTreeNode node, ElementEdge edge, LogicalDirection direction)
{
TextTreeNode adjacentNode;
adjacentNode = GetAdjacentSiblingNode(node, edge, direction);
if (adjacentNode == null)
{
// We're the first or last child, try the parent.
if (edge == ElementEdge.AfterStart || edge == ElementEdge.BeforeEnd)
{
adjacentNode = node;
}
else
{
adjacentNode = (TextTreeNode)node.GetContainingNode();
}
}
return adjacentNode;
}
// Positions this navigator at a node/edge pair.
// Node/edge are adjusted based on the current gravity.
private void MoveToNode(TextContainer tree, TextTreeNode node, ElementEdge edge)
{
RepositionForGravity(ref node, ref edge, GetGravityInternal());
_tree = tree;
SetNodeAndEdge(AdjustRefCounts(node, edge, _node, this.Edge), edge);
_generation = tree.PositionGeneration;
}
///
/// Returns the text element whose edge is in a specified direction
/// from position.
///
///
/// If the symbol in the specified direction is
/// TextPointerContext.ElementStart or TextPointerContext.ElementEnd, then this
/// method will return the element whose edge preceeds this TextPointer.
///
/// Otherwise, the method returns null.
///
private TextElement GetElement(LogicalDirection direction)
{
TextTreeTextElementNode elementNode;
DebugAssertGeneration();
elementNode = GetAdjacentTextElementNode(direction);
return (elementNode == null) ? null : elementNode.TextElement;
}
// Invariant.Strict only. Asserts this position has good state.
private void AssertState()
{
if (Invariant.Strict)
{
// Positions must never have a null tree pointer.
Invariant.Assert(_node != null, "Null position node!");
if (GetGravityInternal() == LogicalDirection.Forward)
{
// Positions with forward gravity must stay at left edges, otherwise inserts could displace them.
Invariant.Assert(this.Edge == ElementEdge.BeforeStart || this.Edge == ElementEdge.BeforeEnd, "Bad position edge/gravity pair! (1)");
}
else
{
// Positions with backward gravity must stay at right edges, otherwise inserts could displace them.
Invariant.Assert(this.Edge == ElementEdge.AfterStart || this.Edge == ElementEdge.AfterEnd, "Bad position edge/gravity pair! (2)");
}
if (_node is TextTreeRootNode)
{
// Positions may never be at the outer edge of the root node, since you can't insert content there.
Invariant.Assert(this.Edge != ElementEdge.BeforeStart && this.Edge != ElementEdge.AfterEnd, "Position at outer edge of root!");
}
else if (_node is TextTreeTextNode || _node is TextTreeObjectNode)
{
// Text and object nodes have no inner edges/chilren, so you can't put a position there.
Invariant.Assert(this.Edge != ElementEdge.AfterStart && this.Edge != ElementEdge.BeforeEnd, "Position at inner leaf node edge!");
}
else
{
// Add new asserts for new node types here.
Invariant.Assert(_node is TextTreeTextElementNode, "Unknown node type!");
}
Invariant.Assert(_tree != null, "Position has no tree!");
#if DEBUG_SLOW
// This test is so slow we can't afford to run it even with Invariant.Strict.
// It grinds execution to a halt.
int count;
if (_tree.RootTextBlock == null)
{
count = 2; // Empty tree has two implicit edge symbols.
}
else
{
count = 0;
for (TextTreeTextBlock textBlock = (TextTreeTextBlock)_tree.RootTextBlock.ContainedNode.GetMinSibling();
textBlock != null;
textBlock = (TextTreeTextBlock)textBlock.GetNextNode())
{
Invariant.Assert(textBlock.Count > 0, "Empty TextBlock!");
count += textBlock.Count;
}
}
Invariant.Assert(_tree.InternalSymbolCount == count, "Bad root symbol count!");
Invariant.Assert((_tree.RootNode == null && count == 2) || count == GetNodeSymbolCountSlow(_tree.RootNode), "TextNode symbol count not in synch with tree!");
if (_tree.RootNode != null)
{
DebugWalkTree(_tree.RootNode.GetMinSibling());
}
#endif // DEBUG_SLOW
}
}
#if DEBUG_SLOW
// This test is so slow we can't afford to run it even with Invariant.Strict.
// It grinds execution to a halt.
private static void DebugWalkTree(SplayTreeNode node)
{
SplayTreeNode previousNode;
SplayTreeNode previousPreviousNode;
previousNode = null;
previousPreviousNode = null;
for (; node != null; node = node.GetNextNode())
{
if (node.SymbolCount == 0 &&
previousNode != null && previousNode.SymbolCount == 0 &&
previousPreviousNode != null && previousPreviousNode.SymbolCount == 0)
{
Invariant.Assert(false, "Found three consecuative zero length nodes!");
}
previousPreviousNode = previousNode;
previousNode = node;
if (node.ContainedNode != null)
{
DebugWalkTree(node.ContainedNode.GetMinSibling());
}
}
}
// Debug only. Walks a node and all its children to get a brute force
// symbol count.
private static int GetNodeSymbolCountSlow(SplayTreeNode node)
{
SplayTreeNode child;
int count;
if (node is TextTreeRootNode || node is TextTreeTextElementNode)
{
count = 2;
for (child = node.GetFirstContainedNode(); child != null; child = child.GetNextNode())
{
count += GetNodeSymbolCountSlow(child);
}
}
else
{
Invariant.Assert(node.ContainedNode == null, "Expected leaf node!");
count = node.SymbolCount;
}
return count;
}
#endif // DEBUG_SLOW
// Repositions the TextPointer and clears any relevant caches.
private void SetNodeAndEdge(TextTreeNode node, ElementEdge edge)
{
Invariant.Assert(edge == ElementEdge.BeforeStart ||
edge == ElementEdge.AfterStart ||
edge == ElementEdge.BeforeEnd ||
edge == ElementEdge.AfterEnd);
_node = node;
_flags = (_flags & ~(uint)Flags.EdgeMask) | (uint)edge;
VerifyFlags();
// Always clear the caret unit boundary cache when we move to a new position.
this.IsCaretUnitBoundaryCacheValid = false;
}
// Setter for the public IsFrozen property.
private void SetIsFrozen()
{
_flags |= (uint)Flags.IsFrozen;
VerifyFlags();
}
// Ensure we have a valid _flags field.
// See bug 1249258.
private void VerifyFlags()
{
ElementEdge edge = (ElementEdge)(_flags & (uint)Flags.EdgeMask);
Invariant.Assert(edge == ElementEdge.BeforeStart ||
edge == ElementEdge.AfterStart ||
edge == ElementEdge.BeforeEnd ||
edge == ElementEdge.AfterEnd);
}
#endregion Private methods
// True when the CaretUnitBoundaryCache is ready for use.
// If false the cache is not reliable.
private bool IsCaretUnitBoundaryCacheValid
{
get
{
return (_flags & (uint)Flags.IsCaretUnitBoundaryCacheValid) == (uint)Flags.IsCaretUnitBoundaryCacheValid;
}
set
{
_flags = (_flags & ~(uint)Flags.IsCaretUnitBoundaryCacheValid) | (value ? (uint)Flags.IsCaretUnitBoundaryCacheValid : 0);
VerifyFlags();
}
}
// Cached value from this.TextContainer.TextView.IsAtCaretUnitBoundary.
private bool CaretUnitBoundaryCache
{
get
{
return (_flags & (uint)Flags.CaretUnitBoundaryCache) == (uint)Flags.CaretUnitBoundaryCache;
}
set
{
_flags = (_flags & ~(uint)Flags.CaretUnitBoundaryCache) | (value ? (uint)Flags.CaretUnitBoundaryCache : 0);
VerifyFlags();
}
}
//-----------------------------------------------------
//
// Private Types
//
//------------------------------------------------------
#region Private Types
// Enum used for the _flags bitfield.
[Flags]
private enum Flags
{
EdgeMask = 15, // 4 low-order bis are an ElementEdge.
IsFrozen = 16,
IsCaretUnitBoundaryCacheValid = 32,
CaretUnitBoundaryCache = 64,
}
#endregion Private Types
//------------------------------------------------------
//
// Private Fields
//
//-----------------------------------------------------
#region Private Fields
// The position's TextContainer.
private TextContainer _tree;
// The node referenced by this position.
private TextTreeNode _node;
// The value of TextContainer.PositionGeneration the last time this position
// called SyncToTreeGeneration.
private uint _generation;
// The value of TextContainer.LayoutGeneration the last time
// this position queried ITextView.IsAtCaretUnitBoundary.
private uint _layoutGeneration;
// Bitfield used by Edge, IsFrozen, IsCaretUnitBoundaryCacheValid, and
// CaretUnitBoundaryCache properties.
private uint _flags;
#if DEBUG
// Debug-only unique identifier for this instance.
private readonly int _debugId = _debugIdCounter++;
// Debug-only id counter.
private static int _debugIdCounter;
#endif // DEBUG
#endregion Private Fields
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
//
// File: TextPointer.cs
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
// Description: TextPointer object representing a location in formatted text.
//
//---------------------------------------------------------------------------
namespace System.Windows.Documents
{
using System;
using MS.Internal;
using System.Threading;
using System.Windows;
using System.Windows.Media;
using System.Collections;
///
/// Represents a location in a formatted text content.
///
///
/// In Avalon formatted text can be contained in elements such as
///
/// Using the properties and the methods of the TextPointer object, you can:
/// a) Find out what kind of content is in forward or in backward directions from its position;
/// b) Get a
/// c) Get characters preceding or following the TextPointer when it is positioned within text run -
/// d) Insert characters in a position where the TextPointer is located;
/// e) Inspect line layout structure by finding line boundary positions;
/// f) Perform visual hit-testing by translating back and forth positions of TextPointer objects into Point objects representing coordinates;
/// g) Create an instance of a
/// Positions in formatted document where TextPointer objects can be located
/// are places between characters and element tags.
/// As you edit a document, TextPointer objects do not move relative to their surrounding text.
/// That is, if text is inserted before a text pointer, then the offset of the pointer
/// from start position of a text container is incremented to reflect its new location
/// further down in the document (offsets between text pointers can be calculated by
/// a
/// If multiple TextPointer objects are located at the same position and a text
/// is inserted into this position, then the new characters and structural tags are
/// to the right or to the left of all of the TextPointer objects depending on their
///
/// Class None for text container boundaries, ElementStart and ElementEnd
/// for opening and closing tags of EmbeddedElement
/// for UIElements inserted in text as atomic objects. The kind of context can be
/// get from a TextPointer using method
/// TextPointer objects are immutable - they cannot be repositioned in text content
/// by any means; and their LogicalDirection property cannot be changed. The context
/// around a TextPointer can be changed though, as a result of text editing.
/// For instance, when text around a TextPointer is deleted, the TextPointer
/// will appear in a new context - in a content remaining after deletion.
/// To traverse a document content you can use a bunch of Get*Position
/// methods -
/// TextPointer class does not have public constructors.
/// The only way to get an instance of the TextPointer class is by
/// using properties or methods of other objects:
///
/// We use a concept of "insertion positions" in association with TextPointer objects,
/// which is a key for editor behavior and for various api members.
/// When caret travels over text content it can stop only at particular positions,
/// skipping all non-appropriate ones. Positions appropriate for caret stopping are called
/// "insertion positions". Boundary positions of
/// From TextPointer located at arbitrary (possibly non-insertion) position, you
/// can get a TextPointer located at a nearest insertion position by calling
///
///
///
/// Example 0. This code shows how to get an instance of a TextPointer.
/// As TextPointer does not have any public constructors, the only way
/// of getting a TextPointer is to use a property or method of other object.
/// This example ContentStart and ContentEnd properties of main text containers,
/// create a TextRange for the whole content of each of them and applies
/// Bold formatting to it.
///
/// void BoldAll(FlowDocument flowDocument, TextFlow textFlow, TextBlock textBlock, RichTextBox richTextBox)
/// {
/// allContent = new TextRange(flowDocument.ContentStart, flowDocument.ContentEnd);
/// allContent.ApplyPropertyValue(TextElement.FontWeightProperty, FontWeights.Bold);
///
/// allContent = new TextRange(textFlow.ContentStart, textFlow.ContentEnd);
/// allContent.ApplyPropertyValue(TextElement.FontWeightProperty, FontWeights.Bold);
///
/// allContent = new TextRange(textBlock.ContentStart, textFlow.ContentEnd);
/// allContent.ApplyPropertyValue(TextElement.FontWeightProperty, FontWeights.Bold);
///
/// // Note that RichTextBox does not have ContentStart/ContentEnd properties,
/// // we use its Document property to get to FlowDocument contained within.
/// TextRange allContent = new TextRange(richTextBox.Document.ContentStart, richTextBox.Document.ContentEnd);
/// allContent.ApplyPropertyValue(TextElement.FontWeightProperty, FontWeights.Bold);
/// }
///
/// Example 1. This code shows how to use TextPointer for finding a first Run element
/// from a particular position in forard direction.
///
/// Run FindNextRun(TextPointer position)
/// {
/// // Traverse content in forward direction until the position is
/// // immediately after opening tag of a Run element.
/// while (position != null &&
/// !(position.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementStart
/// &&
/// position.Parent is Run))
/// {
/// position = position.GetNextContextPosition(LogicalDirection.Forward);
/// }
///
/// // Return a result
/// return position == null ? null : position.Parent as Run;
/// }
///
/// Example 2. This code shows how to use TextPointer for finding a particular
/// word in text content. This is a simplistic "find" algorithm, not smart enough
/// for international issues and for words crossing formatting boundaries.
///
/// TextPointer FindWord(TextPointer position, string word)
/// {
/// while (position != null)
/// {
/// if (position.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.Text)
/// {
/// string textRun = position.GetTextInRun(LogicalDirection.Forward);
/// int indexInRun = textRun.IndexOf(word);
/// if (indexInRun >= 0)
/// {
/// position = position.GetPositionAtOffset(indexInRun);
/// break;
/// }
/// }
/// else
/// {
/// position = position.GetNextContextPosition(LogicalDirection.Forward);
/// }
/// }
///
/// return position; // will be null, if a word is not found.
/// }
///
/// Example 3. This code shows how to enumerate and count all Paragraphs in a given TextRange.
///
/// int GetParagraphCount(TextRange range)
/// {
/// int paragraphCount = 0;
/// TextPointer position = range.Start;
///
/// while (position != null && position.CompareTo(range.End) < 0)
/// {
/// if (position.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementStart &&
/// position.Parent is Paragraph)
/// {
/// // Just entered a paragraph.
/// paragraphCount ++;
///
/// // Jump over it.
/// // Schema does not allow nested paragraphs, so we will not miss any.
/// position = ((Paragraph)position.Parent).ElementEnd;
/// }
/// else
/// {
/// position = position.GetNextContextPosition(LogicalDirection.Forward);
/// }
/// }
///
/// return paragraphCount;
/// }
///
/// Example 4. Idenifying whether the document is empty. The document appearing as empty
/// in RichTextBox actually contains a Paragraph element with a Run child in it. So checking
/// a document emptiness is a bit tricky task. In the following example we will utilize
/// the insertion positions as the most natural mechanism for getting to character part or text content.
///
/// bool IsRichTextBoxEmpty(RichTextBox richTextBox)
/// {
/// FlowDocument document = richTextBox.Document; // get a document contained in a RichTextBox
///
/// TextPointer normalizedStart = document.ContentStart.GetInsertionPosition(LogicalDirection.Forward);
/// TextPointer normalizedEnd = document.ContentEnd.GetInsertionPosition(LogicalDirection.Backward);
///
/// // The character content is empty if normalized start and end pointers are at the same position
/// bool isEmpty = normalizedStart.CompareTo(normalizedEnd) == 0;
///
/// return isEmpty;
/// }
///
///
//
// Internal comments:
//
// TextContainer's implementation of the Text OM ITextPointer interface.
//
// TextPointers represent locations in the TextContainer. They point to a
// node/edge pair where operations like insert/remove/gettext take place.
//
// TextPointers have a property called LogicalDirection, that specifies where
// they fall if content is insert at their position. We track LogicalDirection
// implicitly: forward direction means the position is always at
// BeforeStart/BeforeEnd edges, backward direction the reverse.
//
// TextPointers are guaranteed to stick with their nodes across editing
// operations. For inserts, this happens automatically. However, if the
// node a TextPointer points to is removed from the tree, it is expected
// that a TextPointer will follow its LogicalDirection to the closest neighbor
// node still living in the tree.
//
// Since we don't store references to TextPointers in the tree itself,
// we have to wait until a method on the TextPointer is called, then
// check if the position's node is still in the tree. This operation is
// called synchronization, and the core method is SyncToTreeGeneration.
//
// SyncToTreeGeneration must be called on every public entry point before
// attempting to use the TextPointer.
//
// Since positions always point to node/edge pairs, if we want to allocate
// a position that references a character not on a node edge, we must split
// the text node at the character position. If we did no other work, the
// tree could become extremely fragmented, with a text node allocated for
// each character. To keep the tree from fragmenting, positions ref count
// the nodes they occupy. We do some gymnastics using a finalizer on
// TextPointer, adding unreferenced positions to a list we check
// periodically in all public TextContainer methods. Dead positions decrement
// their nodes' ref counts, and a text node whose ref count drops to zero will
// attempt to merge with neighbors.
public class TextPointer : ContentPosition, ITextPointer
{
//-----------------------------------------------------
//
// Constructors
//
//-----------------------------------------------------
#region Constructors
///
/// Creates a new instance of TextPointer object.
///
///
/// TextPointer from which initial properties and location are initialized.
///
///
/// New TextPointers always have their IsFrozen property set to false,
/// regardless of the state of the position parameter. Otherwise the
/// new TextPointer instance is identical to the position parameter.
///
internal TextPointer(TextPointer textPointer)
{
if (textPointer == null)
{
throw new ArgumentNullException("textPointer");
}
InitializeOffset(textPointer, 0, textPointer.GetGravityInternal());
}
// Creates a new TextPointer instance.
internal TextPointer(TextPointer position, int offset)
{
if (position == null)
{
throw new ArgumentNullException("position");
}
InitializeOffset(position, offset, position.GetGravityInternal());
}
// Creates a new TextPointer instance.
internal TextPointer(TextPointer position, LogicalDirection direction)
{
InitializeOffset(position, 0, direction);
}
// Creates a new TextPointer instance.
internal TextPointer(TextPointer position, int offset, LogicalDirection direction)
{
InitializeOffset(position, offset, direction);
}
// Creates a new TextPointer instance.
internal TextPointer(TextContainer textContainer, int offset, LogicalDirection direction)
{
SplayTreeNode node;
ElementEdge edge;
if (offset < 1 || offset > textContainer.InternalSymbolCount - 1)
{
throw new ArgumentException(SR.Get(SRID.BadDistance));
}
textContainer.GetNodeAndEdgeAtOffset(offset, out node, out edge);
Initialize(textContainer, (TextTreeNode)node, edge, direction, textContainer.PositionGeneration, false, false, textContainer.LayoutGeneration);
}
// Creates a new TextPointer instance.
internal TextPointer(TextContainer tree, TextTreeNode node, ElementEdge edge)
{
Initialize(tree, node, edge, LogicalDirection.Forward, tree.PositionGeneration, false, false, tree.LayoutGeneration);
}
// Creates a new TextPointer instance.
internal TextPointer(TextContainer tree, TextTreeNode node, ElementEdge edge, LogicalDirection direction)
{
Initialize(tree, node, edge, direction, tree.PositionGeneration, false, false, tree.LayoutGeneration);
}
// Constructor equivalent to ITextPointer.CreatePointer
internal TextPointer CreatePointer()
{
return new TextPointer(this);
}
// Constructor equivalent to ITextPointer.CreatePointer
internal TextPointer CreatePointer(LogicalDirection gravity)
{
return new TextPointer(this, gravity);
}
#if REFCOUNT_DEAD_TEXTPOINTERS
// *** This code removed ***
// The TextContainer originally was designed to ref count TextPointer references
// to TextTreeNodes. When a TextPointer is created, it addrefs its node.
// When moved, it addrefs the destination and decrements the old position.
// When finalized, it would decrement its final TextTreeNode.
//
// There are two problems with this code:
// - The GC will null out managed fields occasionally. This means we simply
// cannot use a finalizer.
// - We don't really know/can't depend on how expensive it is to use the GC,
// and the whole scheme is an attempt at perf optimization.
//
// The current state of the code is that we still ref count on create and
// move, but we've disabled the finalizer so TextPointers will reference
// their final nodes "forever". This leads to fragmentation: because
// we split TextTreeTextNodes as TextPointer reference individual
// characters. However, there's an upper bound on the fragmentation
// (we can't have more nodes than characters) and in practice no one
// walks documents character by character.
//
// So, until we identify a specific perf problem, we're not attempting
// to ressurect this code.
//
// If ever do identify fragmentation as a problem worth solving,
// we can already think of at least three possible approaches:
//
// 1. Keep the existing logic, but instead of using a finalizer,
// store an array of WeakReferences on each node (usually null).
// Periodically check the array, pruning WeakReferences with
// null Targets.
// 2. As above, but introduce a TextPointerNode instead of hanging
// arrays off other nodes.
// 3. Keep a static array of TextContainers in memory, ref counted
// by TextPointers. Restore the TextPointer finalizer, and in
// addition to decrementing the node ref count, decrement the
// TextContainer ref count.
// This method adds the position to a list of "dead" positions (no
// external references) that will be examined later to decrement
// reference counts on nodes, and ultimately merge text nodes.
//
// It's important here that we don't do anything complicated
// that might block the finalizer thread or cause too much
// contention and hurt perf. The same goes for code in
// TextContainer.EmptyDeadPositionList that also uses the lock.
///
///
~TextPointer()
{
ArrayList deadPositionList;
deadPositionList = _tree.DeadPositionList;
lock (deadPositionList)
{
deadPositionList.Add(this);
}
}
#endif // REFCOUNT_DEAD_TEXTPOINTERS
#endregion Constructors
//------------------------------------------------------
//
// Public Methods
//
//-----------------------------------------------------
#region Public Methods
///
/// Returns true if this TextPointer is positioned within the same
/// text containner as another TextPointer.
///
///
/// TextPointer to compare.
///
///
/// TextPointer objects positioned in different containers cannot
/// participate in any operations dealing with several pointers.
/// For instance, TextPointer objects from two different text containers
/// cannot be compared with each other (by calling the method
/// The purpose of this method is to test whether two TextPointer
/// objects belong to the same text container or not.
/// Formatted text can be contained within one these elements in Avalon:
///
/// Note, that if one text container is nested within another
/// TextPointer objects positioned within a nested text container
/// are not considered as belonging to the enclosing one.
///
///
/// Example 1. This example shows how to check whether a given TextPointer
/// is positioned between two other TextPointer objects - in a situation
/// when there is no guarantee that all three positions belong to
/// the same text container
///
/// bool IsPositionContainedBetween(TextPointer test, TextPointer start, TextPointer end)
/// {
/// if (!test.IsInSameDocument(start) || !test.IsInSameDocument(end))
/// {
/// return false;
/// }
/// return start.CompareTo(test) <= 0 && test.CompareTo(end) <= 0;
/// }
///
///
public bool IsInSameDocument(TextPointer textPosition)
{
if (textPosition == null)
{
throw new ArgumentNullException("textPosition");
}
_tree.EmptyDeadPositionList();
return (this.TextContainer == textPosition.TextContainer);
}
///
/// Compares positions of this TextPointer with another TextPointer.
///
///
/// The TextPointer to compare with.
///
///
/// Less than zero: this TextPointer preceeds position.
/// Zero: this TextPointer is at the same location as position.
/// Greater than zero: this TextPointer follows position.
///
///
/// Throws ArgumentException if position does not belong to the same
/// text container as this TextPointer (you can use
public int CompareTo(TextPointer position)
{
int offsetThis;
int offsetPosition;
int result;
_tree.EmptyDeadPositionList();
ValidationHelper.VerifyPosition(_tree, position);
SyncToTreeGeneration();
position.SyncToTreeGeneration();
offsetThis = GetSymbolOffset();
offsetPosition = position.GetSymbolOffset();
if (offsetThis < offsetPosition)
{
result = -1;
}
else if (offsetThis > offsetPosition)
{
result = +1;
}
else
{
result = 0;
}
return result;
}
///
/// Returns the type of content to one side of this TextPointer.
///
///
/// Direction to query.
///
///
/// Returns
/// Returns
/// Returns
/// Returns
/// Returns
///
///
/// This example shows how to use GetPointerContext method in text content
/// traversal algorithms. It implements an algorithm calculating a balanse of
/// opening and closing tags between two TextPointer positions (each opening tag
/// counted as +1, while a closing one as -1).
///
/// int GetElementTagBalance(TextPointer start, TextPointer end)
/// {
/// int balanse = 0;
///
/// while (start != null && start.CompareTo(end) < 0)
/// {
/// TextPointerContext forwardContext = start.GetPointerContext(LogicalDirection.Forward);
///
/// if (forwardContext == TextPointerContext.ElementStart)
/// {
/// balanse++;
/// }
/// else if (forwardContext == TextPointerContext.ElementEnd)
/// {
/// balanse--;
/// }
/// start = start.GetNextContextPosition(LogicalDirection.Forward);
/// }
///
/// return balanse;
/// }
///
///
public TextPointerContext GetPointerContext(LogicalDirection direction)
{
ValidationHelper.VerifyDirection(direction, "direction");
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return (direction == LogicalDirection.Forward) ? GetPointerContextForward(_node, this.Edge) : GetPointerContextBackward(_node, this.Edge);
}
///
/// Returns the count of Unicode characters between this TextPointer and the
/// edge of an element in the given direction.
///
///
/// Direction to query.
///
///
/// If the TetPointer is positioned not inside a
public int GetTextRunLength(LogicalDirection direction)
{
ValidationHelper.VerifyDirection(direction, "direction");
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
int count = 0;
// Combine adjacent text nodes into a single run.
// This isn't just a perf optimization. Because text positions
// split text nodes, if we just returned a single node's text
// callers would see strange side effects where position.GetTextLength() !=
// position.GetText if a position is moved between the calls.
if (_tree.PlainTextOnly)
{
// Optimize for TextBox, which only ever contains (sometimes
// very large quantities of) text nodes.
Invariant.Assert(this.GetScopingNode() is TextTreeRootNode);
if (direction == LogicalDirection.Forward)
{
count = _tree.InternalSymbolCount - this.GetSymbolOffset() - 1;
}
else
{
count = this.GetSymbolOffset() - 1;
}
}
else
{
TextTreeNode textNode = GetAdjacentTextNodeSibling(direction);
while (textNode != null)
{
count += textNode.SymbolCount;
textNode = ((direction == LogicalDirection.Forward) ? textNode.GetNextNode() : textNode.GetPreviousNode()) as TextTreeTextNode;
}
}
return count;
}
///
/// Returns the distance between this TextPointer and another.
///
///
/// TextPointer to compare.
///
///
/// Throws an ArgumentException if the TextPointer position is not
/// positioned within the same document as this TextPointer.
///
///
/// The return value will be negative if the TextPointer position
/// preceeds this TextPointer, zero if the two TextPointers
/// are equally positioned, or positive if position follows this
/// TextPointer.
///
///
/// The distance is represented as a number of "symbols"
/// between these two pointers.
/// Each opening and each closing tag of any TextElement
/// is considered as one symbol. So an empty TextElement contributes
/// two symbols - one for each of tags.
/// UIElement placed within InlineUIContainer or BlockUIContainer
/// represented as one symbol - independently of how complex
/// is its content. Even if the UIElement contains or is a
/// text container it is treated as atomic entity - single symbol.
/// This may be confusing especially if you do not pay
/// muchy attention to a difference between the
/// Each 16-bit unicode character inside a
/// For instance, for the following xaml:
/// <Run>abc</Run><InlineUIContainer><Button>OK</Button></InlineUIContainer>
/// the offset from itw content start to content end will be 8 -
/// one for each of: (1) Run start, (2) "a", (3) "b", (4) "c", (5) Run end, (6) InlineUIContainer start,
/// (7) whole Button element, (8) InlineUIContainer end. Note that Button
/// element considered as one symbol even though it is represented
/// by two tags and two characters.
///
///
/// In this example we show how to use TextPointer offsets for
/// persisting positional information. Assuming that the content of
/// a RichTextBox is not changed between calls of
/// GetPersistedSelection and RestoreSelectionFromPersistedRange
/// methods, the selection will be restored to its original state.
///
/// struct PersistedTextRange { int Start; int End; }
///
/// PersistedTextRange GetPersistedSelection(RichTextBox richTextBox)
/// {
/// PersistedTextRange persistedSelection;
///
/// TextPointer contentStart = richTextBox.Document.ContentStart;
/// persistedSelection.Start = contentStart.GetOffsetToPosition(richTextBox.Selection.Start);
/// persistedSelection.End = contentStart.GetOffsetToPosition(richTextBox.Selection.End);
///
/// return persistedSelection;
/// }
///
/// RestoreSelectionFromPersistedRange(RichTextBox richTextBox, PersistedTextRange persistedRange)
/// {
/// TextPointer contentStart = richTextBox.Document.ContentStart;
///
/// richTextBox.Selection.Select(
/// contentStart.GetPositionAtOffset(persistedRange.Start),
/// contentStart.GetPositionAtOffset(persistedRange.End));
/// }
///
///
///
public int GetOffsetToPosition(TextPointer position)
{
_tree.EmptyDeadPositionList();
ValidationHelper.VerifyPosition(_tree, position);
SyncToTreeGeneration();
position.SyncToTreeGeneration();
return (position.GetSymbolOffset() - GetSymbolOffset());
}
///
/// Returns text bordering this TextPointer from one side or another.
///
///
/// Direction to query.
///
///
/// See GetTextInRun(direction, textBuffer, startIndex, count) method
/// remarks for semantics of the returned text.
///
///
/// This is an example of simplistic plain text converter.
/// This algorithm produces a string concatenating all text runs
/// between two TextPointers.
/// Note that this is really simplistic algorithm. You sould use
///
///
/// string GetPlainText(TextPointer start, TextPointer end)
/// {
/// StringBuilder buffer = new StringBuilder();
///
/// while (start != null && start.CompareTo(end) < end)
/// {
/// if (start.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.Text)
/// {
/// // Check if this text run reaches beyond the end position
/// // and trancate the string if needed.
/// string textRun = start.GetTextInRum(LogicalDirection.Forward);
/// if (textRun.Length > start.GetOffsetToPosition(end))
/// {
/// textRun = textRun.Substring(0, start.GetOffsetToPosition(end));
/// }
///
/// // Add characters from this text run to output buffer.
/// buffer.Add(textRun);
/// }
///
/// start = start.GetNextContextPosition(LogicalDirection.Forward);
/// // Note that for text run this method skips the whole run, not just one character.
/// }
/// return buffer.ToString();
/// }
///
///
public string GetTextInRun(LogicalDirection direction)
{
ValidationHelper.VerifyDirection(direction, "direction");
return TextPointerBase.GetTextInRun(this, direction);
}
///
/// Copies characters bordering this TextPointer into a caller supplied char array.
///
///
/// Direction to query.
///
///
/// Buffer into which chars are copied.
///
///
/// Index within the textBuffer array at which the copy is started.
///
///
/// The maximum number of characters to copy. Must be less than
/// or equal to a (textBuffer.Length - startIndex ).
///
///
/// The count of chars actually copied.
///
///
/// Is thrown in the following cases: (a) when startIndex is less than zero,
/// (b) when startIndex is greater than textBuffer.Length ,
/// (c) when count is less than zero, (d) when count
/// is greater than size available for copying (textBuffer.Length - startIndex ).
///
///
/// This method only returns uninterrupted runs of text -- no text will
/// be returned if any symbol type other than text borders this
/// TextPointer in the specified direction. Similarly, text will only
/// be returned up to the next non-text symbol.
///
public int GetTextInRun(LogicalDirection direction, char[] textBuffer, int startIndex, int count)
{
TextTreeTextNode textNode;
ValidationHelper.VerifyDirection(direction, "direction");
SyncToTreeGeneration();
textNode = GetAdjacentTextNodeSibling(direction);
return textNode == null ? 0 : GetTextInRun(_tree, GetSymbolOffset(), textNode, -1, direction, textBuffer, startIndex, count);
}
///
/// Returns an element represented by a symbol, if any, bordering
/// this TextPointer in the specified direction.
///
///
/// Direction to query.
///
///
/// The element if its opening or closing tag exists
/// in a specified direction. Otherwize returns null.
///
///
/// The returned element may be both a
///
public DependencyObject GetAdjacentElement(LogicalDirection direction)
{
ValidationHelper.VerifyDirection(direction, "direction");
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return GetAdjacentElement(_node, this.Edge, direction);
}
///
/// Returns a TextPointer at a new position by a specified symbol
/// count.
///
///
/// Number of symbols to advance. offset may be negative, in which
/// case the TextPointer is moved backwards.
///
///
/// TextPointer located at requested position in case if requested position
/// does exist, otherwize returns null. LogicalDirection of the TextPointer
/// returned is the same as of this TexPointer.
///
///
/// This method, like all other TextPointer methods, defines a symbol
/// as one of:
/// - 16 bit Unicode character.
/// - opening or closing tag of a
/// - the whole
///
///
/// This example shows how to use this method for creating TextPointers
/// from a persisted index-based position representation.
/// The first method returns a integer offset of a TextPointer
/// from the beginning of a Paragraph. The second method re-creates
/// a pointer from an integer ofset at the same relative position.
///
/// int GetPersistedPositionRelativeToParagraph(TextPointer position)
/// {
/// Paragraph paragraph = position.Paragraph;
///
/// if (paragraph == null)
/// {
/// return 0; // Some positions may be not within any Paragraph,
/// // so we need to return something; or throw exception.
/// }
///
/// return paragraph.ContentStart.GetOffsetToPosition(position);
/// }
///
/// int GetTextPointerRelativeToParagraph(Paragraph paragraph, int persistedPositionRelativeToParagraph)
/// {
/// // Check whether persisted position is still within this paragraph
/// if (persistedPositionRelativeToParagraph >
/// paragraph.ContentStart.GetOffsetToPosition(paragraph.ContentEnd))
/// {
/// // the index is beyond the paragraph end. Return the farthest position within the paragraph.
/// return paragraph.ContentEnd;
/// }
///
/// return paragraph.ContentStart.GetPositionAtOffset(persistedPositionRelativeToParagraph);
/// }
///
///
public TextPointer GetPositionAtOffset(int offset)
{
return GetPositionAtOffset(offset, this.LogicalDirection);
}
///
/// Returns a TextPointer at a new position by a specified symbol
/// count.
///
///
/// Number of symbols to advance. offset may be negative, in which
/// case the TextPointer is moved backwards.
///
///
/// LogicalDirection desired for a returned TextPointer.
///
///
/// TextPointer located at requested position in case if requested position
/// does exist, otherwize returns null. LogicalDirection of the TextPointer
/// returned is as specified by a
///
/// This method, like all other TextPointer methods, defines a symbol
/// as one of:
/// - 16 bit Unicode character.
/// - opening or closing tag of a
/// - the whole
/// See examples in
///
public TextPointer GetPositionAtOffset(int offset, LogicalDirection direction)
{
TextPointer position = new TextPointer(this, direction);
int actualCount = position.MoveByOffset(offset);
if (actualCount == offset)
{
position.Freeze();
return position;
}
else
{
return null;
}
}
///
/// Returns a pointer at the next symbol in a specified
/// direction, or past all following Unicode characters if the
/// bordering content is Unicode text.
///
///
/// Direction to move.
///
///
/// TextPointer in a requested direction, null if this TextPointer
/// borders the start or end of the document.
///
///
/// If the following symbol is of type EmbeddedElement, ElementStart,
/// or ElementEnd (as returned by the GetPointerContext method), then
/// the TextPointer is advanced by exactly one symbol.
/// If the following symbol is of type Text, then the TextPointer is
/// advanced until it passes all following text (ie, until it reaches
/// a position with a different return value for GetPointerContext).
/// The exact symbol count crossed can be calculated in advance by
/// calling GetTextLength.
/// If there is no following symbol (start or end of the document),
/// then the method returns null.
///
///
/// This example shows how to use this method for traversing
/// text content and examine its structure. The method implements
/// a simplistic text content serializer, producing an xml-looking
/// text.
/// Note that to produce really well formed xml System.Xml
/// interfaces must be used. We use this simplification only
/// to make it more readable for people not familiar with System.Xml api.
///
/// string GetXaml(TextElement element)
/// {
/// StringBuilder buffer = new StringBuilder();
///
/// // Position a "navigator" pointer before the opening tag of the element.
/// TextPointer navigator = element.ElementStart;
///
/// while (navigator.CompareTo(element.ElementEnd) < 0)
/// {
/// switch (navigator.GetPointerContext(LogicalDirection.Forward))
/// {
/// case TextPointerContext.ElementStart :
/// // Output opening tag of the TextElement
/// buffer.AddFormat("<{0}>", navigator.GetAdjacentElement(LogicalDirection.Forward).GetType().Name);
/// break;
/// case TextPointerContext.ElementEnd :
/// // Output closing tag of the TextElement
/// buffer.AddFormat("</{0}>", navigator.GetAdjacentElement(LogicalDirection.Forward).GetType().Name);
/// break;
/// case TextPointerContent.EmbeddedElement :
/// // Output simple tag for embedded element
/// buffer.AddFormat("<{0}/>", navigator.GetAdjacentElement(LogicalDirection.Forward).GetType().Name);
/// break;
/// case TextPointerContext.Text :
/// // Output the text content of thi text run
/// buffer.Add(navigator.GetTextInRun(LoigcalDirection.Forward);
/// break;
/// case TextPointerContext.None :
/// Assert(false, "We do not expect to reach end of text container in this loop");
/// break;
/// }
///
/// // Advance the naviagtor to the next context position.
/// navigator = navigator.GetNextContextPosition(LogicalDirection.Forward);
///
/// Assert(navigator != null, "We do not expect to reach an end of a text container in this loop, as it is limited by element.ContentEnd bounadry");
/// }
/// }
///
///
public TextPointer GetNextContextPosition(LogicalDirection direction)
{
return (TextPointer)((ITextPointer)this).GetNextContextPosition(direction);
}
///
/// Returns a TextPointer at the closest insertion position in a
/// specified direction.
///
///
/// Direction to search a closest insertion position.
///
///
/// TextPointer positioned at inserion point. The value is never null.
///
///
/// The concept of insertion position is a convenience
/// for traversing text content across structural boundaries,
/// between table cells, paragraphs, list items etc.
/// An insertion position is anywhere the containing document
/// would normally place the caret. Examples of positions that are not
/// insertion positions include locations between Paragraphs
/// (between closing tag of a preceding paragraph and an opening tag
/// of the following paragraph). A position within text runs
/// in the middle of a surrogate Unicode surrogate pair is also
/// not an insertion position.
/// The method can be used for disambiguating insertion positions
/// in two cases: when the text has two insertion positions separated by
/// a sequence of formatting tags, as between "d" and "t" in this
/// markup: "<Bold>Bold</Bold>text" - we have an insertion position
/// before closing tag of Bold element and immediately after it. Both are
/// valid insertion position and caret would stop on each of them
/// depending on the direction of keyboard navigation. The method
/// GetInsertionPosition allows user to pick one or another
/// without moving to the "next" insertion position.
/// Another important case when the method is useful is
/// when a sequence of structural tags is involved. If you
/// have a position, say between closing and opening paragraph tags,
/// and want to fing a nearest insertion position the direction
/// parameter will tell which of two possible positions to take:
/// in the end of the preceding or in the begining of the following paragraph.
/// If the pointer is already at insertion position
/// but there is a non-empty sequence formatting in the given direction,
/// then the position after all formatting tags will be returned.
/// If the pointer is already at insertion position
/// and there is no any formatting tags in the given direction,
/// then the returned position is the same as this one.
/// Somethimes the whole document does not have even
/// one insertion position - it happens when the content
/// is structurally incomplete, say in empty
///
///
/// This example shows how to use the method GetInsertionPosition
/// as a convenience of finding a starting "editable" position.
///
/// bool IsElementEmpty(TextElement element)
/// {
/// // Find first and last insertion positions in this element.
/// // We use inward directions to make sure that insertion position
/// // will be found correctly in case when the element is inline formatting one
/// // (i.e. Run or Span).
/// TextPointer start = element.ContentStart.GetInsertionPosition(LogicalDirection.Forward);
/// TextPointer end = element.ContentEnd.GetInsertionPosition(LogicalDirection.Backward);
///
/// // Element has empty printable content if its first and last
/// // insertion positions are equal.
/// return start.CompareTo(end) == 0;
/// }
///
///
public TextPointer GetInsertionPosition(LogicalDirection direction)
{
return (TextPointer)((ITextPointer)this).GetInsertionPosition(direction);
}
// Used for pointer normalization in cases when direction does not matter.
internal TextPointer GetInsertionPosition()
{
return GetInsertionPosition(LogicalDirection.Forward);
}
///
/// Returns a TextPointer in the direction indicated to the following
/// insertion position.
///
///
/// Direction to move.
///
///
/// A TextPointer at an insertion position in a requested direction,
/// null if there is no more insertion positions in that direction.
///
///
/// The concept of insertion position is a convenience
/// for traversing text content across structural boundaries,
/// between table cells, paragraphs, list items etc.
/// See more detailed definition of the concept of
/// "insertion position" in the
/// If the TextPointer is not currently at an insertion position, this
/// method will move the TextPointer to the next insertion position in
/// the indicated direction, just like the MoveToInsertionPosition
/// method.
/// If the TextPointer is currently at an insertion position, this
/// method will move the TextPointer to following insertion position,
/// if the end of document is not encountered.
///
///
/// In this example we use the method GetNextInsertionPosition
/// for passing over structural boundaries in a proces of
/// enumerating all
///
/// int GetParagraphCount(TextPointer start, TextPointer end)
/// {
/// int paragraphCount = 0;
///
/// while (start != null && start.CompareTo(end) < 0)
/// {
/// Paragraph paragraph = start.Paragraph;
///
/// if (paragraph != null)
/// {
/// paragraphCount++;
///
/// // Advance start to an end of the paragraph found
/// start = paragraph.ContentEnd;
/// }
///
/// // Use GetNextInsertionPosition method to skip a sequence
/// // of structural tags
/// start = start.GetNextInsertionPosition(LogicalDirection.Forward);
/// }
///
/// return paragraphCount;
/// }
///
///
public TextPointer GetNextInsertionPosition(LogicalDirection direction)
{
return (TextPointer)((ITextPointer)this).GetNextInsertionPosition(direction);
}
///
/// Returns a TextPointer at the start of line after skipping
/// a given number of line starts in forward or backward direction.
///
///
/// Number of line starts to skip when finding a desired line start position.
/// Negative values specify preceding lines, zero specifies the current line,
/// positive values specify following lines.
///
///
/// Throws an InvalidOperationException if this TextPointer's HasValidLayout
/// property is set false. Without a calculated layout it is not possible
/// to position relative to rendered lines.
///
///
/// TextPointer positioned at the begining of a line requested
/// (with LogicalDirection set to Forward).
/// If there is no sufficient lines in requested direction,
/// returns null.
///
///
/// Line identification is possible only from normalized insertion positions;
/// Line identification from not-normalized positions is mbigous and can produce
/// unexpected results. Say, if a position is between closing and opening
/// Paragraph tags, then GetInsertionPosition(LogicalDirection) is needed
/// to decide whether we start from the end of previous Paragraph or
/// from the start of the following one. Without such call
///
/// If this TextPointer is at an otherwise ambiguous position, exactly
/// between two lines, the LogicalDirection property is used to determine
/// current position. So a TextPointer with backward LogicalDirection
/// is considered to be at the end of line, and calling MoveToLineBoundary(0)
/// would reposition it at the start of the preceding line. Making the
/// same call with forward LogicalDirection would leave the TextPointer
/// positioned where it started -- at the start of the following line.
///
///
public TextPointer GetLineStartPosition(int count)
{
int actualCount;
TextPointer lineStartPosition = GetLineStartPosition(count, out actualCount);
return (actualCount != count) ? null : lineStartPosition;
}
///
/// Returns a TextPointer at the start of line after skipping
/// a given number of line starts in forward or backward direction.
///
///
/// Offset of the destination line. Negative values specify preceding
/// lines, zero specifies the current line, positive values specify
/// following lines.
///
///
/// The offset of the line moved to. This value may be less than
/// requested if the beginning or end of document is encountered.
///
///
/// TextPointer positioned at the begining of a line requested
/// (with LogicalDirection set to Forward).
/// If there is no sufficient lines in requested direction,
/// returns a position at the beginning of a farthest line
/// in this direction. In such case out parameter actualCount
/// gets a number of lines actually skipped.
/// Unlike the other override in this case the returned pointer is never null.
///
///
/// If this TextPointer is at an otherwise ambiguous position, exactly
/// between two lines, the LogicalDirection property is used to determine
/// current position. So a TextPointer with backward LogicalDirection
/// is considered to be at the end of line, and calling MoveToLineBoundary(0)
/// would reposition it at the start of the preceding line. Making the
/// same call with forward LogicalDirection would leave the TextPointer
/// positioned where it started -- at the start of the following line.
///
public TextPointer GetLineStartPosition(int count, out int actualCount)
{
this.ValidateLayout();
TextPointer position = new TextPointer(this);
if (this.HasValidLayout)
{
actualCount = position.MoveToLineBoundary(count);
}
else
{
actualCount = 0;
}
position.SetLogicalDirection(LogicalDirection.Forward);
position.Freeze();
return position;
}
///
/// Returns the bounding box of the content bordering this TextPointer
/// in a specified direction.
///
///
/// Direction of content.
///
///
/// TextElement edges are not considered content for the purposes of
/// this method. If the TextPointer is positioned before a TextElement
/// edge, the return value will be the bounding box of the next
/// non-TextElement content.
/// If there is no content in the specified direction, a zero-width
/// Rect is returned with height matching the preceding content.
///
public Rect GetCharacterRect(LogicalDirection direction)
{
ValidationHelper.VerifyDirection(direction, "direction");
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
this.ValidateLayout();
if (!this.HasValidLayout)
{
return Rect.Empty;
}
return TextPointerBase.GetCharacterRect(this, direction);
}
///
/// Inserts text at this TextPointer's position.
///
///
/// Text to insert.
///
///
/// The LogicalDirection property specifies whether this TextPointer
/// will be positioned before or after the new text.
///
public void InsertTextInRun(string textData)
{
if (textData == null)
{
throw new ArgumentNullException("textData");
}
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
TextPointer insertPosition;
if (TextSchema.IsInTextContent(this))
{
insertPosition = this;
}
else
{
insertPosition = TextRangeEditTables.EnsureInsertionPosition(this);
}
_tree.BeginChange();
try
{
_tree.InsertTextInternal(insertPosition, textData);
}
finally
{
_tree.EndChange();
}
}
///
/// Deletes text in Run at this TextPointer's position
///
///
/// Returns the actual count of deleted chars.
/// The actual count may be less than requested in cases
/// when original requested count exceeds text run length in given direction.
///
public int DeleteTextInRun(int count)
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
// TextSchema Validation
if (!TextSchema.IsInTextContent(this))
{
return 0;
}
// Direction to delete text in run
LogicalDirection direction = count < 0 ? LogicalDirection.Backward : LogicalDirection.Forward;
// Get text run length in given direction
int maxDeleteCount = this.GetTextRunLength(direction);
// Truncate count if it extends past the run in given direction
if (count > 0 && count > maxDeleteCount)
{
count = maxDeleteCount;
}
else if (count < 0 && count < -maxDeleteCount)
{
count = -maxDeleteCount;
}
// Get a new pointer for deletion
TextPointer deleteToPosition = new TextPointer(this, count);
_tree.BeginChange();
try
{
if (count > 0)
{
_tree.DeleteContentInternal(this, deleteToPosition);
}
else if (count < 0)
{
_tree.DeleteContentInternal(deleteToPosition, this);
}
}
finally
{
_tree.EndChange();
}
return count;
}
///
/// Inserts a TextElement at this TextPointer's position.
///
///
/// ContentElement to insert.
///
///
/// The LogicalDirection property specifies whether this TextPointer
/// will be positioned before or after the TextElement.
///
///
/// Throws ArgumentException is textElement is not valid
/// according to flow schema.
///
///
/// Throws InvalidOperationException if textElement cannot be inserted
/// at this position because it belongs to another tree.
///
internal void InsertTextElement(TextElement textElement)
{
Invariant.Assert(textElement != null);
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
ValidationHelper.ValidateChild(this, textElement, "textElement");
if (textElement.Parent != null)
{
throw new InvalidOperationException(SR.Get(SRID.TextPointer_CannotInsertTextElementBecauseItBelongsToAnotherTree));
}
textElement.RepositionWithContent(this);
}
///
/// Insert a paragraph break at this position by splitting all elements upto its paragraph ancestor.
///
///
/// When this position has a paragraph parent, this method returns a
/// normalized position in the beginning of a second paragraph.
///
/// Otherwise, if the position is not parented by a paragraph
/// (for special insertion positions such as table row end, BlockUIContainer boundaries, etc),
/// this method creates a paragraph by using rules of EnsureInsertionPosition()
/// and returns a normalized position at the start of the paragraph created.
///
///
/// Throws InvalidOperationException when this position has a non-splittable ancestor such as Hyperlink,
/// since we cannot successfully split upto the parent paragraph in this case.
///
public TextPointer InsertParagraphBreak()
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
Type containerType = this.TextContainer.Parent.GetType();
if (!TextSchema.IsValidChildOfContainer(containerType, typeof(Paragraph)))
{
throw new InvalidOperationException(SR.Get(SRID.TextSchema_IllegalElement, "Paragraph", containerType));
}
Inline ancestor = this.GetNonMergeableInlineAncestor();
if (ancestor != null)
{
// Cannot split a hyperlink element!
throw new InvalidOperationException(SR.Get(SRID.TextSchema_CannotSplitElement, ancestor.GetType().Name));
}
TextPointer position;
_tree.BeginChange();
try
{
position = TextRangeEdit.InsertParagraphBreak(this, /*moveIntoSecondParagraph:*/true);
}
finally
{
_tree.EndChange();
}
return position;
}
///
/// Insert a line break at this position.
/// If the position is parented by a Run, the Run element is split at this position and then a line break inserted.
///
///
/// TextPointer positioned immediately after the closing tag of
/// a
public TextPointer InsertLineBreak()
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
TextPointer position;
_tree.BeginChange();
try
{
position = TextRangeEdit.InsertLineBreak(this);
}
finally
{
_tree.EndChange();
}
return position;
}
///
/// Debug only ToString override.
///
public override string ToString()
{
#if DEBUG
return "TextPointer Id=" + _debugId + " NodeId=" + _node.DebugId + " Edge=" + this.Edge;
#else
return base.ToString();
#endif // DEBUG
}
#endregion Public Methods
//------------------------------------------------------
//
// Public Properties
//
//------------------------------------------------------
#region Public Properties
///
/// Returns true if layout is calculated at the current position.
///
///
/// Methods that depend on layout -- GetLineStartPosition,
/// GetCharacterRect, and IsAtLineStartPosition -- will attempt
/// to re-calculate a dirty layout when called. Recalculating
/// layout can be extremely expensive, however, and this method
/// lets the caller detect when layout is dirty.
///
// Internal methods that depend on this property:
// - MoveToNextCaretPosition
// - MoveToBackspaceCaretPosition
public bool HasValidLayout
{
get
{
return _tree.TextView == null ? false : _tree.TextView.IsValid && _tree.TextView.Contains(this);
}
}
///
/// Specifies whether the TextPointer is associated with preceding or
/// following content.
///
///
/// If new content is insert at the TextPointer's current position, it
/// will move to the edge of the new content that also borders its
/// original associated content.
///
public LogicalDirection LogicalDirection
{
get
{
return GetGravityInternal();
}
}
///
/// Returns the logical parent scoping this TextPointer.
///
public DependencyObject Parent
{
get
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return GetLogicalTreeNode();
}
}
///
/// Returns true if this TextPointer is positioned at an insertion
/// position.
///
///
/// An "insertion position" is a position where where the containing document
/// would normally place the caret. Examples of positions that are not
/// insertion positions include spaces between Paragraphs, or between
/// Unicode surrogate pairs.
///
public bool IsAtInsertionPosition
{
get
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return TextPointerBase.IsAtInsertionPosition(this);
}
}
///
/// Returns true if this TextPointer is positioned at the start of a
/// line.
///
///
/// Throws an InvalidOperationException if this TextPointer's HasValidLayout
/// property is set false. Without a calculated layout it is not possible
/// to determine where the current line starts or ends.
///
///
/// If this TextPointer is at an otherwise ambiguous position, exactly
/// between two lines, the LogicalDirection property is used to determine
/// current position. So a TextPointer with backward LogicalDirection
/// will never have a true IsAtLineStartPosition unless it is positioned at the
/// head of a document.
/// This property is always false when HasValidLayout is false.
///
public bool IsAtLineStartPosition
{
get
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
this.ValidateLayout();
if (!this.HasValidLayout)
{
return false;
}
TextSegment lineRange = _tree.TextView.GetLineRange(this);
// Null lineRange if no layout is available.
if (!lineRange.IsNull)
{
TextPointer position = new TextPointer(this);
TextPointerContext backwardContext = position.GetPointerContext(LogicalDirection.Backward);
// Skip past any formatting.
while ((backwardContext == TextPointerContext.ElementStart || backwardContext == TextPointerContext.ElementEnd) &&
TextSchema.IsFormattingType(position.GetAdjacentElement(LogicalDirection.Backward).GetType()))
{
position.MoveToNextContextPosition(LogicalDirection.Backward);
backwardContext = position.GetPointerContext(LogicalDirection.Backward);
}
if (position.CompareTo((TextPointer)lineRange.Start) <= 0)
{
return true;
}
}
return false;
}
}
///
/// Returns the paragraph scoping this textpointer
///
///
/// When TextPointer is at insertion position it usually
/// have non-null paragraph. The only exception is when
/// it is positioned at the end of TableRow, where
/// there is no scoping paragraph.
/// When TextPointer is positioned outside of a paragraph,
/// the property returns null.
///
public Paragraph Paragraph
{
get
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return this.ParentBlock as Paragraph;
}
}
///
/// Returns the paragraph-like parent of the pointer
///
///
/// If we would have a common base class for Paragraph and BlockUIContainer,
/// we would return it here.
///
internal Block ParagraphOrBlockUIContainer
{
//
get
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
Block parentBlock = this.ParentBlock;
return (parentBlock is Paragraph) || (parentBlock is BlockUIContainer) ? parentBlock : null;
}
}
///
/// The start position of the document's content
///
///
/// This property may be useful as a base for persistent
/// position indexing - for calculating offsets
/// to all other pointers.
/// The
///
public TextPointer DocumentStart
{
get
{
return TextContainer.Start;
}
}
///
/// The end position of the document's content.
///
///
/// The
///
public TextPointer DocumentEnd
{
get
{
return TextContainer.End;
}
}
#endregion Public Properties
//-----------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
// Returns this TextPointer's topmost Inline ancestor, which is not a mergeable (or splittable) Inline element. (e.g. Hyperlink)
internal Inline GetNonMergeableInlineAncestor()
{
Inline ancestor = this.Parent as Inline;
while (ancestor != null && TextSchema.IsMergeableInline(ancestor.GetType()))
{
ancestor = ancestor.Parent as Inline;
}
return ancestor;
}
// Returns this TextPointer's closest ListItem ancestor.
internal ListItem GetListAncestor()
{
TextElement ancestor = this.Parent as TextElement;
while (ancestor != null && !(ancestor is ListItem))
{
ancestor = ancestor.Parent as TextElement;
}
return ancestor as ListItem;
}
internal static int GetTextInRun(TextContainer textContainer, int symbolOffset, TextTreeTextNode textNode, int nodeOffset, LogicalDirection direction, char[] textBuffer, int startIndex, int count)
{
int skipCount;
int finalCount;
if (textBuffer == null)
{
throw new ArgumentNullException("textBuffer");
}
if (startIndex < 0)
{
throw new ArgumentException(SR.Get(SRID.NegativeValue, "startIndex"));
}
if (startIndex > textBuffer.Length)
{
throw new ArgumentException(SR.Get(SRID.StartIndexExceedsBufferSize, startIndex, textBuffer.Length));
}
if (count < 0)
{
throw new ArgumentException(SR.Get(SRID.NegativeValue, "count"));
}
if (count > textBuffer.Length - startIndex)
{
throw new ArgumentException(SR.Get(SRID.MaxLengthExceedsBufferSize, count, textBuffer.Length, startIndex));
}
Invariant.Assert(textNode != null, "textNode is expected to be non-null");
textContainer.EmptyDeadPositionList();
if (nodeOffset < 0)
{
skipCount = 0;
}
else
{
skipCount = (direction == LogicalDirection.Backward) ? nodeOffset : textNode.SymbolCount - nodeOffset;
symbolOffset += nodeOffset;
}
finalCount = 0;
// Loop and combine adjacent text nodes into a single run.
// This isn't just a perf optimization. Because text positions
// split text nodes, if we just returned a single node's text
// callers would see strange side effects where position.GetTextLength() !=
// position.GetText() if another position is moved between the calls.
while (textNode != null)
{
// Never return more textBuffer than the text following this position in the current text node.
finalCount += Math.Min(count - finalCount, textNode.SymbolCount - skipCount);
skipCount = 0;
if (finalCount == count)
break;
textNode = ((direction == LogicalDirection.Forward) ? textNode.GetNextNode() : textNode.GetPreviousNode()) as TextTreeTextNode;
}
// If we're reading backwards, need to fixup symbolOffset to point into the node.
if (direction == LogicalDirection.Backward)
{
symbolOffset -= finalCount;
}
if (finalCount > 0) // We may not have allocated textContainer.RootTextBlock if no text was ever inserted.
{
TextTreeText.ReadText(textContainer.RootTextBlock, symbolOffset, finalCount, textBuffer, startIndex);
}
return finalCount;
}
internal static DependencyObject GetAdjacentElement(TextTreeNode node, ElementEdge edge, LogicalDirection direction)
{
TextTreeNode adjacentNode;
DependencyObject element;
adjacentNode = GetAdjacentNode(node, edge, direction);
if (adjacentNode is TextTreeObjectNode)
{
element = ((TextTreeObjectNode)adjacentNode).EmbeddedElement;
}
else if (adjacentNode is TextTreeTextElementNode)
{
element = ((TextTreeTextElementNode)adjacentNode).TextElement;
}
else
{
// We're adjacent to a text node, or have no sibling in the specified direction.
element = null;
}
return element;
}
///
/// Moves this TextPointer to another TextPointer's position.
///
///
/// Position to move to.
///
///
/// Throws an ArgumentException if textPosition is not
/// positioned within the same document.
///
///
/// Throws an InvalidOperationException if this TextPointer's IsFrozen
/// property is set true. Frozen TextPointers may not be repositioned.
///
internal void MoveToPosition(TextPointer textPosition)
{
ValidationHelper.VerifyPosition(_tree, textPosition);
VerifyNotFrozen();
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
textPosition.SyncToTreeGeneration();
MoveToNode(_tree, textPosition.Node, textPosition.Edge);
}
///
/// Advances this TextPointer to a new position by a specified symbol
/// count.
///
///
/// Number of symbols to advance. offset may be negative, in which
/// case the TextPointer is moved backwards.
///
///
/// Throws an InvalidOperationException if this TextPointer's IsFrozen
/// property is set true. Frozen TextPointers may not be repositioned.
///
///
/// This method, like all other TextPointer methods, defines a symbol
/// as a
/// - 16 bit Unicode character.
/// - TextElement start or end edge.
/// - UIElement.
/// - ContentElement other than TextElement.
///
///
/// The number of symbols actually advanced. The absolute value of the
/// count returned may be less than requested if the end of document is
/// encountered while advancing.
///
internal int MoveByOffset(int offset)
{
SplayTreeNode node;
ElementEdge edge;
int symbolOffset;
int currentOffset;
VerifyNotFrozen();
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
if (offset != 0)
{
currentOffset = GetSymbolOffset();
symbolOffset = unchecked(currentOffset + offset);
if (symbolOffset < 1)
{
if (offset > 0)
{
// Rolled past Int32.MaxValue. Go to end of doc.
symbolOffset = _tree.InternalSymbolCount - 1;
offset = symbolOffset - currentOffset;
}
else
{
// Underflow. Go to start of doc.
offset += (1 - symbolOffset);
symbolOffset = 1;
}
}
else if (symbolOffset > _tree.InternalSymbolCount - 1)
{
// Overflow. Go to end of doc.
// NB: there's no symmetric check here for rolling under with distance=Int32.MinValue.
// Since GetSymbolOffset is always positive, we can't roll-around with a min value.
offset -= (symbolOffset - (_tree.InternalSymbolCount - 1));
symbolOffset = _tree.InternalSymbolCount - 1;
}
_tree.GetNodeAndEdgeAtOffset(symbolOffset, out node, out edge);
MoveToNode(_tree, (TextTreeNode)node, edge);
}
return offset;
}
///
/// Advances this TextPointer to the next symbol in a specified
/// direction, or past all following Unicode characters if the
/// bordering content is Unicode text.
///
///
/// Direction to move.
///
///
/// Throws an InvalidOperationException if this TextPointer's IsFrozen
/// property is set true. Frozen TextPointers may not be repositioned.
///
///
/// true if the TextPointer is repositioned, false if the TextPointer
/// borders the start or end of the document.
///
///
/// If the following symbol is of type EmbeddedElement, ElementStart,
/// or ElementEnd (as returned by the GetPointerContext method), then
/// the TextPointer is advanced by exactly one symbol.
///
/// If the following symbol is of type Text, then the TextPointer is
/// advanced until it passes all following text (ie, until it reaches
/// a position with a different return value for GetPointerContext).
/// The exact symbol count crossed can be calculated in advance by
/// calling GetTextLength.
///
/// If there is no following symbol (start or end of the document),
/// then the method does nothing and returns false.
///
internal bool MoveToNextContextPosition(LogicalDirection direction)
{
TextTreeNode node;
ElementEdge edge;
bool moved;
ValidationHelper.VerifyDirection(direction, "direction");
VerifyNotFrozen();
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
if (direction == LogicalDirection.Forward)
{
moved = GetNextNodeAndEdge(out node, out edge);
}
else
{
moved = GetPreviousNodeAndEdge(out node, out edge);
}
if (moved)
{
SetNodeAndEdge(AdjustRefCounts(node, edge, _node, this.Edge), edge);
DebugAssertGeneration();
}
AssertState();
return moved;
}
///
/// Moves this TextPointer to the closest insertion position in a
/// specified direction. If the pointer is already at insertion point
/// but there is a non-empty sequence formatting in the given direction,
/// then the position moves to the other instance of this insertion
/// position.
///
///
/// Direction to move.
///
///
/// Throws an InvalidOperationException if this TextPointer's IsFrozen
/// property is set true. Frozen TextPointers may not be repositioned.
///
///
/// An "insertion position" is a position where new content may be added
/// without breaking any semantic rules of the containing document.
///
/// In practice, an insertion position is anywhere the containing document
/// would normally place the caret. Examples of positions that are not
/// insertion positions include spaces between Paragraphs, or between
/// Unicode surrogate pairs.
///
///
/// True if the TextPointer is repositioned, false otherwise.
///
internal bool MoveToInsertionPosition(LogicalDirection direction)
{
ValidationHelper.VerifyDirection(direction, "direction");
VerifyNotFrozen();
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return TextPointerBase.MoveToInsertionPosition(this, direction);
}
///
/// Advances this TextPointer in the direction indicated to the following
/// insertion position.
///
///
/// Direction to move.
///
///
/// Throws an InvalidOperationException if this TextPointer's IsFrozen
/// property is set true. Frozen TextPointers may not be repositioned.
///
///
/// An "insertion position" is a position where new content may be added
/// without breaking any semantic rules of the containing document.
///
/// In practice, an insertion position is anywhere the containing document
/// would normally place the caret. Examples of positions that are not
/// insertion positions include spaces between Paragraphs, or between
/// Unicode surrogate pairs.
///
/// If the TextPointer is not currently at an insertion position, this
/// method will move the TextPointer to the next insertion position in
/// the indicated direction, just like the MoveToInsertionPosition
/// method.
///
/// If the TextPointer is currently at an insertion position, this
/// method will move the TextPointer to following insertion position,
/// if the end of document is not encountered.
///
///
/// True if the TextPointer is repositioned, false otherwise.
///
internal bool MoveToNextInsertionPosition(LogicalDirection direction)
{
ValidationHelper.VerifyDirection(direction, "direction");
VerifyNotFrozen();
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return TextPointerBase.MoveToNextInsertionPosition(this, direction);
}
///
/// Advances this TextPointer to the start of a neighboring line.
///
///
/// Offset of the destination line. Negative values specify preceding
/// lines, zero specifies the current line, positive values specify
/// following lines.
///
///
/// Throws an InvalidOperationException if this TextPointer's IsFrozen
/// property is set true. Frozen TextPointers may not be repositioned.
///
///
/// The offset of the line moved to. This value may be less than
/// requested if the beginning or end of document is encountered.
///
///
/// If this TextPointer is at an otherwise ambiguous position, exactly
/// between two lines, the LogicalDirection property is used to determine
/// current position. So a TextPointer with backward LogicalDirection
/// is considered to be at the end of line, and calling MoveToLineBoundary(0)
/// would reposition it at the start of the preceding line. Making the
/// same call with forward LogicalDirection would leave the TextPointer
/// positioned where it started -- at the start of the following line.
///
internal int MoveToLineBoundary(int count)
{
VerifyNotFrozen();
this.ValidateLayout();
if (!this.HasValidLayout)
{
return 0;
}
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
return TextPointerBase.MoveToLineBoundary(this, _tree.TextView, count);
}
///
/// Inserts a UIElement at this TextPointer's position.
///
///
/// UIElement to insert.
///
///
/// The LogicalDirection property specifies whether this TextPointer
/// will be positioned before or after the UIElement.
///
///
/// Throws ArgumentException is contentElement is not valid
/// according to flow schema.
///
internal void InsertUIElement(UIElement uiElement)
{
if (uiElement == null)
{
throw new ArgumentNullException("uiElement");
}
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
ValidationHelper.ValidateChild(this, uiElement, "uiElement");
if (!((TextElement)this.Parent).IsEmpty) // the parent may be InlineUIContainer or BlockUIContainer
{
throw new InvalidOperationException(SR.Get(SRID.TextSchema_UIElementNotAllowedInThisPosition));
}
_tree.BeginChange();
try
{
_tree.InsertEmbeddedObjectInternal(this, uiElement);
}
finally
{
_tree.EndChange();
}
}
//
internal TextElement GetAdjacentElementFromOuterPosition(LogicalDirection direction)
{
TextTreeTextElementNode elementNode;
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
elementNode = GetAdjacentTextElementNodeSibling(direction);
return (elementNode == null) ? null : elementNode.TextElement;
}
///
/// Sets the logical direction of this textpointer.
///
///
/// Throws an InvalidOperationException if this TextPointer's Freeze() method has been called.
///
///
internal void SetLogicalDirection(LogicalDirection direction)
{
SplayTreeNode newNode;
ElementEdge edge;
ValidationHelper.VerifyDirection(direction, "direction");
VerifyNotFrozen();
_tree.EmptyDeadPositionList();
if (GetGravityInternal() != direction)
{
SyncToTreeGeneration();
newNode = _node;
// We need to shift nodes to match the new gravity.
switch (this.Edge)
{
case ElementEdge.BeforeStart:
newNode = _node.GetPreviousNode();
if (newNode != null)
{
// Move to the previous sibling.
edge = ElementEdge.AfterEnd;
}
else
{
// Move to parent inner edge.
newNode = _node.GetContainingNode();
Invariant.Assert(newNode != null, "Bad tree state: newNode must be non-null (BeforeStart)");
edge = ElementEdge.AfterStart;
}
break;
case ElementEdge.AfterStart:
newNode = _node.GetFirstContainedNode();
if (newNode != null)
{
// Move to first child.
edge = ElementEdge.BeforeStart;
}
else
{
// Move to opposite edge.
newNode = _node;
edge = ElementEdge.BeforeEnd;
}
break;
case ElementEdge.BeforeEnd:
newNode = _node.GetLastContainedNode();
if (newNode != null)
{
// Move to last child.
edge = ElementEdge.AfterEnd;
}
else
{
// Move to opposite edge.
newNode = _node;
edge = ElementEdge.AfterStart;
}
break;
case ElementEdge.AfterEnd:
newNode = _node.GetNextNode();
if (newNode != null)
{
// Move to the next sibling.
edge = ElementEdge.BeforeStart;
}
else
{
// Move to parent inner edge.
newNode = _node.GetContainingNode();
Invariant.Assert(newNode != null, "Bad tree state: newNode must be non-null (AfterEnd)");
edge = ElementEdge.BeforeEnd;
}
break;
default:
Invariant.Assert(false, "Bad ElementEdge value");
edge = this.Edge;
break;
}
SetNodeAndEdge(AdjustRefCounts((TextTreeNode)newNode, edge, _node, this.Edge), edge);
Invariant.Assert(GetGravityInternal() == direction, "Inconsistent position gravity");
}
}
///
/// True if the Freeze method has been called, in which case
/// this TextPointer is immutable and may not be repositioned.
///
///
/// By default, TextPointers are mutable -- they may be
/// repositioned with calls to methods like MoveByOffset, and
/// LogicalDirection may be changed freely. After Freeze is
/// called, a TextPointer is locked down -- any attempt to set
/// LogicalDirection or call repositioning methods will raise an
/// InvalidOperationException.
///
internal bool IsFrozen
{
get
{
_tree.EmptyDeadPositionList();
return (_flags & (uint)Flags.IsFrozen) == (uint)Flags.IsFrozen;
}
}
///
/// Makes this TextPointer immutable.
///
///
/// By default, TextPointers are mutable -- they may be
/// repositioned with calls to methods like MoveByOffset, and
/// LogicalDirection may be changed freely. After this method is
/// called, a TextPointer is locked down -- any attempt to set
/// LogicalDirection or call repositioning methods will raise an
/// InvalidOperationException.
///
/// The IsFrozen property will return true after this method is called.
///
/// Calling Freeze multiple times has no additional effect.
///
internal void Freeze()
{
_tree.EmptyDeadPositionList();
SetIsFrozen();
}
///
/// Returns an immutable TextPointer instance positioned equally to
/// this one, with a specified LogicalDirection.
///
///
/// LogicalDirection of the returned TextPointer.
///
///
/// The TextPointer returned will always have its IsFrozen property set
/// true.
///
/// The return value will be a new TextPointer instance unless this
/// TextPointer is already frozen with a matching LogicalDirection, in
/// which case this TextPointer will be returned.
///
internal TextPointer GetFrozenPointer(LogicalDirection logicalDirection)
{
ValidationHelper.VerifyDirection(logicalDirection, "logicalDirection");
_tree.EmptyDeadPositionList();
return (TextPointer)TextPointerBase.GetFrozenPointer(this, logicalDirection);
}
void ITextPointer.SetLogicalDirection(LogicalDirection direction)
{
SetLogicalDirection(direction);
}
int ITextPointer.CompareTo(ITextPointer position)
{
return CompareTo((TextPointer)position);
}
int ITextPointer.CompareTo(StaticTextPointer position)
{
int offsetThis;
int offsetPosition;
int result;
offsetThis = this.Offset + 1;
offsetPosition = TextContainer.GetInternalOffset(position);
if (offsetThis < offsetPosition)
{
result = -1;
}
else if (offsetThis > offsetPosition)
{
result = +1;
}
else
{
result = 0;
}
return result;
}
int ITextPointer.GetOffsetToPosition(ITextPointer position)
{
return GetOffsetToPosition((TextPointer)position);
}
TextPointerContext ITextPointer.GetPointerContext(LogicalDirection direction)
{
return GetPointerContext(direction);
}
int ITextPointer.GetTextRunLength(LogicalDirection direction)
{
return GetTextRunLength(direction);
}
//
///
internal bool MoveToCaretPosition(LogicalDirection contentDirection)
{
TextPointer position;
LogicalDirection oppositeDirection;
bool moved;
ValidationHelper.VerifyDirection(contentDirection, "contentDirection");
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
VerifyNotFrozen();
this.ValidateLayout();
if (!this.HasValidLayout)
{
return false;
}
moved = false;
if (!_tree.TextView.IsAtCaretUnitBoundary(this))
{
oppositeDirection = (contentDirection == LogicalDirection.Forward) ? LogicalDirection.Backward : LogicalDirection.Forward;
position = (TextPointer)_tree.TextView.GetNextCaretUnitPosition(this, oppositeDirection);
MoveToPosition(position);
moved = true;
}
return moved;
}
///
///
internal bool MoveToNextCaretPosition(LogicalDirection direction)
{
TextPointer position;
bool moved;
ValidationHelper.VerifyDirection(direction, "direction");
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
VerifyNotFrozen();
this.ValidateLayout();
if (!this.HasValidLayout)
{
return false;
}
position = (TextPointer)_tree.TextView.GetNextCaretUnitPosition(this, direction);
moved = false;
if (this.CompareTo(position) != 0)
{
MoveToPosition(position);
moved = true;
}
return moved;
}
///
///
internal bool MoveToBackspaceCaretPosition()
{
TextPointer position;
bool moved;
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
VerifyNotFrozen();
this.ValidateLayout();
if (!this.HasValidLayout)
{
return false;
}
position = (TextPointer)_tree.TextView.GetBackspaceCaretUnitPosition(this);
moved = false;
if (this.CompareTo(position) != 0)
{
MoveToPosition(position);
moved = true;
}
return moved;
}
#endif
void ITextPointer.InsertTextInRun(string textData)
{
this.InsertTextInRun(textData);
}
//
void ITextPointer.DeleteContentToPosition(ITextPointer limit)
{
_tree.BeginChange();
try
{
// DeleteContent is clever enough to handle the this > limit case.
TextRangeEditTables.DeleteContent(this, (TextPointer)limit);
}
finally
{
_tree.EndChange();
}
}
///
/// Returns the TextContainer that this TextPointer is a part of.
///
ITextContainer ITextPointer.TextContainer
{
get
{
return this.TextContainer;
}
}
//
/// Returns the TextContainer that this TextPointer is a part of.
///
internal TextContainer TextContainer
{
get
{
return _tree;
}
}
///
/// A FrameworkElement owning a TextContainer to which this TextPointer belongs.
///
internal FrameworkElement ContainingFrameworkElement
{
get
{
return ((FrameworkElement)_tree.Parent);
}
}
// Position at row end (immediately before Row closing tag) is a valid stopper for a caret.
// Editing operations are restricted here (e.g. typing should automatically jump
// to the following character position.
// This property identifies such special position.
internal bool IsAtRowEnd
{
get
{
return TextPointerBase.IsAtRowEnd(this);
}
}
#if DEBUG
// Debug-only unique identifier for this instance.
int DebugId
{
get
{
return _debugId;
}
}
#endif // DEBUG
// Indicates if this TextPointer has an ancestor that is not a mergeable (or splittable) Inline element. (e.g. Hyperlink)
internal bool HasNonMergeableInlineAncestor
{
get
{
Inline ancestor = this.GetNonMergeableInlineAncestor();
return ancestor != null;
}
}
// Returns true if position is at the start boundary of a non-mergeable inline ancestor (hyperlink)
internal bool IsAtNonMergeableInlineStart
{
get
{
return TextPointerBase.IsAtNonMergeableInlineStart(this);
}
}
// The node referenced by this position.
internal TextTreeNode Node
{
get
{
return _node;
}
}
// The edge referenced by this position.
internal ElementEdge Edge
{
get
{
return (ElementEdge)(_flags & (uint)Flags.EdgeMask);
}
}
// Returns the Block parenting this TextPointer, or null if none exists.
internal Block ParentBlock
{
get
{
_tree.EmptyDeadPositionList();
SyncToTreeGeneration();
DependencyObject parentBlock = this.Parent;
while (parentBlock is Inline && !(parentBlock is AnchoredBlock))
{
parentBlock = ((Inline)parentBlock).Parent;
}
return parentBlock as Block;
}
}
#endregion Internal Properties
//-----------------------------------------------------
//
// Private Methods
//
//------------------------------------------------------
#region Private Methods
// Called by the TextPointer ctor. Initializes this instance.
private void InitializeOffset(TextPointer position, int distance, LogicalDirection direction)
{
SplayTreeNode node;
ElementEdge edge;
int offset;
bool isCaretUnitBoundaryCacheValid;
// We MUST [....] to the current tree, otherwise we could addref
// an orphaned node, resulting in a future unmatched release...
// Ref counts on orphaned nodes are only considered at the time
// of removal, not afterwards.
position.SyncToTreeGeneration();
if (distance != 0)
{
offset = position.GetSymbolOffset() + distance;
if (offset < 1 || offset > position.TextContainer.InternalSymbolCount - 1)
{
throw new ArgumentException(SR.Get(SRID.BadDistance));
}
position.TextContainer.GetNodeAndEdgeAtOffset(offset, out node, out edge);
isCaretUnitBoundaryCacheValid = false;
}
else
{
node = position.Node;
edge = position.Edge;
isCaretUnitBoundaryCacheValid = position.IsCaretUnitBoundaryCacheValid;
}
Initialize(position.TextContainer, (TextTreeNode)node, edge, direction, position.TextContainer.PositionGeneration,
position.CaretUnitBoundaryCache, isCaretUnitBoundaryCacheValid, position._layoutGeneration);
}
// Called by the TextPointer ctor. Initializes this instance.
private void Initialize(TextContainer tree, TextTreeNode node, ElementEdge edge, LogicalDirection gravity, uint generation,
bool caretUnitBoundaryCache, bool isCaretUnitBoundaryCacheValid, uint layoutGeneration)
{
_tree = tree;
// Fixup of the target node based on gravity.
// Positions always cling to a node edge that matches their gravity,
// so that insert ops never affect the position.
RepositionForGravity(ref node, ref edge, gravity);
SetNodeAndEdge(node.IncrementReferenceCount(edge), edge);
_generation = generation;
this.CaretUnitBoundaryCache = caretUnitBoundaryCache;
this.IsCaretUnitBoundaryCacheValid = isCaretUnitBoundaryCacheValid;
_layoutGeneration = layoutGeneration;
VerifyFlags();
tree.AssertTree();
AssertState();
}
// Throws an exception if this TextPointer is frozen.
private void VerifyNotFrozen()
{
if (this.IsFrozen)
{
throw new InvalidOperationException(SR.Get(SRID.TextPositionIsFrozen));
}
}
// Inc/decs the position ref counts on TextTreeTextNodes as the navigator
// is repositioned.
// If the new ref is to a TextTreeTextNode, the node may be split.
// Returns the actual node referenced, which will always be newNode,
// unless newNode is a TextTreeTextNode that gets split. The caller
// should use the returned node to position navigators.
private TextTreeNode AdjustRefCounts(TextTreeNode newNode, ElementEdge newNodeEdge, TextTreeNode oldNode, ElementEdge oldNodeEdge)
{
TextTreeNode node;
// This test should walk the tree upwards to catch all errors...probably not worth the slowdown though.
Invariant.Assert(oldNode.ParentNode == null || oldNode.IsChildOfNode(oldNode.ParentNode), "Trying to add ref a dead node!");
Invariant.Assert(newNode.ParentNode == null || newNode.IsChildOfNode(newNode.ParentNode), "Trying to add ref a dead node!");
node = newNode;
if (newNode != oldNode || newNodeEdge != oldNodeEdge)
{
node = newNode.IncrementReferenceCount(newNodeEdge);
oldNode.DecrementReferenceCount(oldNodeEdge);
}
return node;
}
// For any logical position (location between two symbols) there are two
// possible node/edge pairs. This method choses the pair that fits a
// specified gravity, such that future inserts won't require that a text
// position be moved, based on its gravity, at the node/edge pair.
private static void RepositionForGravity(ref TextTreeNode node, ref ElementEdge edge, LogicalDirection gravity)
{
SplayTreeNode newNode;
ElementEdge newEdge;
newNode = node;
newEdge = edge;
switch (edge)
{
case ElementEdge.BeforeStart:
if (gravity == LogicalDirection.Backward)
{
newNode = node.GetPreviousNode();
newEdge = ElementEdge.AfterEnd;
if (newNode == null)
{
newNode = node.GetContainingNode();
newEdge = ElementEdge.AfterStart;
}
}
break;
case ElementEdge.AfterStart:
if (gravity == LogicalDirection.Forward)
{
newNode = node.GetFirstContainedNode();
newEdge = ElementEdge.BeforeStart;
if (newNode == null)
{
newNode = node;
newEdge = ElementEdge.BeforeEnd;
}
}
break;
case ElementEdge.BeforeEnd:
if (gravity == LogicalDirection.Backward)
{
newNode = node.GetLastContainedNode();
newEdge = ElementEdge.AfterEnd;
if (newNode == null)
{
newNode = node;
newEdge = ElementEdge.AfterStart;
}
}
break;
case ElementEdge.AfterEnd:
if (gravity == LogicalDirection.Forward)
{
newNode = node.GetNextNode();
newEdge = ElementEdge.BeforeStart;
if (newNode == null)
{
newNode = node.GetContainingNode();
newEdge = ElementEdge.BeforeEnd;
}
}
break;
}
node = (TextTreeNode)newNode;
edge = newEdge;
}
// Worker for GetGravity. No parameter validation.
private LogicalDirection GetGravityInternal()
{
return (this.Edge == ElementEdge.BeforeStart || this.Edge == ElementEdge.BeforeEnd) ? LogicalDirection.Forward : LogicalDirection.Backward;
}
// Returns the DependencyObject scoping this position.
private DependencyObject GetDependencyParent()
{
DebugAssertGeneration();
return GetScopingNode().GetDependencyParent();
}
// Returns the node in the direction indicated bordering
// a TextPointer, or null if no such node exists.
internal TextTreeNode GetAdjacentNode(LogicalDirection direction)
{
return GetAdjacentNode(_node, this.Edge, direction);
}
internal static TextTreeNode GetAdjacentNode(TextTreeNode node, ElementEdge edge, LogicalDirection direction)
{
TextTreeNode adjacentNode;
adjacentNode = GetAdjacentSiblingNode(node, edge, direction);
if (adjacentNode == null)
{
// We're the first or last child, try the parent.
if (edge == ElementEdge.AfterStart || edge == ElementEdge.BeforeEnd)
{
adjacentNode = node;
}
else
{
adjacentNode = (TextTreeNode)node.GetContainingNode();
}
}
return adjacentNode;
}
// Positions this navigator at a node/edge pair.
// Node/edge are adjusted based on the current gravity.
private void MoveToNode(TextContainer tree, TextTreeNode node, ElementEdge edge)
{
RepositionForGravity(ref node, ref edge, GetGravityInternal());
_tree = tree;
SetNodeAndEdge(AdjustRefCounts(node, edge, _node, this.Edge), edge);
_generation = tree.PositionGeneration;
}
///
/// Returns the text element whose edge is in a specified direction
/// from position.
///
///
/// If the symbol in the specified direction is
/// TextPointerContext.ElementStart or TextPointerContext.ElementEnd, then this
/// method will return the element whose edge preceeds this TextPointer.
///
/// Otherwise, the method returns null.
///
private TextElement GetElement(LogicalDirection direction)
{
TextTreeTextElementNode elementNode;
DebugAssertGeneration();
elementNode = GetAdjacentTextElementNode(direction);
return (elementNode == null) ? null : elementNode.TextElement;
}
// Invariant.Strict only. Asserts this position has good state.
private void AssertState()
{
if (Invariant.Strict)
{
// Positions must never have a null tree pointer.
Invariant.Assert(_node != null, "Null position node!");
if (GetGravityInternal() == LogicalDirection.Forward)
{
// Positions with forward gravity must stay at left edges, otherwise inserts could displace them.
Invariant.Assert(this.Edge == ElementEdge.BeforeStart || this.Edge == ElementEdge.BeforeEnd, "Bad position edge/gravity pair! (1)");
}
else
{
// Positions with backward gravity must stay at right edges, otherwise inserts could displace them.
Invariant.Assert(this.Edge == ElementEdge.AfterStart || this.Edge == ElementEdge.AfterEnd, "Bad position edge/gravity pair! (2)");
}
if (_node is TextTreeRootNode)
{
// Positions may never be at the outer edge of the root node, since you can't insert content there.
Invariant.Assert(this.Edge != ElementEdge.BeforeStart && this.Edge != ElementEdge.AfterEnd, "Position at outer edge of root!");
}
else if (_node is TextTreeTextNode || _node is TextTreeObjectNode)
{
// Text and object nodes have no inner edges/chilren, so you can't put a position there.
Invariant.Assert(this.Edge != ElementEdge.AfterStart && this.Edge != ElementEdge.BeforeEnd, "Position at inner leaf node edge!");
}
else
{
// Add new asserts for new node types here.
Invariant.Assert(_node is TextTreeTextElementNode, "Unknown node type!");
}
Invariant.Assert(_tree != null, "Position has no tree!");
#if DEBUG_SLOW
// This test is so slow we can't afford to run it even with Invariant.Strict.
// It grinds execution to a halt.
int count;
if (_tree.RootTextBlock == null)
{
count = 2; // Empty tree has two implicit edge symbols.
}
else
{
count = 0;
for (TextTreeTextBlock textBlock = (TextTreeTextBlock)_tree.RootTextBlock.ContainedNode.GetMinSibling();
textBlock != null;
textBlock = (TextTreeTextBlock)textBlock.GetNextNode())
{
Invariant.Assert(textBlock.Count > 0, "Empty TextBlock!");
count += textBlock.Count;
}
}
Invariant.Assert(_tree.InternalSymbolCount == count, "Bad root symbol count!");
Invariant.Assert((_tree.RootNode == null && count == 2) || count == GetNodeSymbolCountSlow(_tree.RootNode), "TextNode symbol count not in synch with tree!");
if (_tree.RootNode != null)
{
DebugWalkTree(_tree.RootNode.GetMinSibling());
}
#endif // DEBUG_SLOW
}
}
#if DEBUG_SLOW
// This test is so slow we can't afford to run it even with Invariant.Strict.
// It grinds execution to a halt.
private static void DebugWalkTree(SplayTreeNode node)
{
SplayTreeNode previousNode;
SplayTreeNode previousPreviousNode;
previousNode = null;
previousPreviousNode = null;
for (; node != null; node = node.GetNextNode())
{
if (node.SymbolCount == 0 &&
previousNode != null && previousNode.SymbolCount == 0 &&
previousPreviousNode != null && previousPreviousNode.SymbolCount == 0)
{
Invariant.Assert(false, "Found three consecuative zero length nodes!");
}
previousPreviousNode = previousNode;
previousNode = node;
if (node.ContainedNode != null)
{
DebugWalkTree(node.ContainedNode.GetMinSibling());
}
}
}
// Debug only. Walks a node and all its children to get a brute force
// symbol count.
private static int GetNodeSymbolCountSlow(SplayTreeNode node)
{
SplayTreeNode child;
int count;
if (node is TextTreeRootNode || node is TextTreeTextElementNode)
{
count = 2;
for (child = node.GetFirstContainedNode(); child != null; child = child.GetNextNode())
{
count += GetNodeSymbolCountSlow(child);
}
}
else
{
Invariant.Assert(node.ContainedNode == null, "Expected leaf node!");
count = node.SymbolCount;
}
return count;
}
#endif // DEBUG_SLOW
// Repositions the TextPointer and clears any relevant caches.
private void SetNodeAndEdge(TextTreeNode node, ElementEdge edge)
{
Invariant.Assert(edge == ElementEdge.BeforeStart ||
edge == ElementEdge.AfterStart ||
edge == ElementEdge.BeforeEnd ||
edge == ElementEdge.AfterEnd);
_node = node;
_flags = (_flags & ~(uint)Flags.EdgeMask) | (uint)edge;
VerifyFlags();
// Always clear the caret unit boundary cache when we move to a new position.
this.IsCaretUnitBoundaryCacheValid = false;
}
// Setter for the public IsFrozen property.
private void SetIsFrozen()
{
_flags |= (uint)Flags.IsFrozen;
VerifyFlags();
}
// Ensure we have a valid _flags field.
// See bug 1249258.
private void VerifyFlags()
{
ElementEdge edge = (ElementEdge)(_flags & (uint)Flags.EdgeMask);
Invariant.Assert(edge == ElementEdge.BeforeStart ||
edge == ElementEdge.AfterStart ||
edge == ElementEdge.BeforeEnd ||
edge == ElementEdge.AfterEnd);
}
#endregion Private methods
// True when the CaretUnitBoundaryCache is ready for use.
// If false the cache is not reliable.
private bool IsCaretUnitBoundaryCacheValid
{
get
{
return (_flags & (uint)Flags.IsCaretUnitBoundaryCacheValid) == (uint)Flags.IsCaretUnitBoundaryCacheValid;
}
set
{
_flags = (_flags & ~(uint)Flags.IsCaretUnitBoundaryCacheValid) | (value ? (uint)Flags.IsCaretUnitBoundaryCacheValid : 0);
VerifyFlags();
}
}
// Cached value from this.TextContainer.TextView.IsAtCaretUnitBoundary.
private bool CaretUnitBoundaryCache
{
get
{
return (_flags & (uint)Flags.CaretUnitBoundaryCache) == (uint)Flags.CaretUnitBoundaryCache;
}
set
{
_flags = (_flags & ~(uint)Flags.CaretUnitBoundaryCache) | (value ? (uint)Flags.CaretUnitBoundaryCache : 0);
VerifyFlags();
}
}
//-----------------------------------------------------
//
// Private Types
//
//------------------------------------------------------
#region Private Types
// Enum used for the _flags bitfield.
[Flags]
private enum Flags
{
EdgeMask = 15, // 4 low-order bis are an ElementEdge.
IsFrozen = 16,
IsCaretUnitBoundaryCacheValid = 32,
CaretUnitBoundaryCache = 64,
}
#endregion Private Types
//------------------------------------------------------
//
// Private Fields
//
//-----------------------------------------------------
#region Private Fields
// The position's TextContainer.
private TextContainer _tree;
// The node referenced by this position.
private TextTreeNode _node;
// The value of TextContainer.PositionGeneration the last time this position
// called SyncToTreeGeneration.
private uint _generation;
// The value of TextContainer.LayoutGeneration the last time
// this position queried ITextView.IsAtCaretUnitBoundary.
private uint _layoutGeneration;
// Bitfield used by Edge, IsFrozen, IsCaretUnitBoundaryCacheValid, and
// CaretUnitBoundaryCache properties.
private uint _flags;
#if DEBUG
// Debug-only unique identifier for this instance.
private readonly int _debugId = _debugIdCounter++;
// Debug-only id counter.
private static int _debugIdCounter;
#endif // DEBUG
#endregion Private Fields
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- IERequestCache.cs
- EditBehavior.cs
- NullToBooleanConverter.cs
- ReadOnlyDictionary.cs
- RequestSecurityTokenResponseCollection.cs
- MenuItemCollectionEditor.cs
- AutomationTextAttribute.cs
- DataMemberAttribute.cs
- ConfigurationErrorsException.cs
- RadioButtonPopupAdapter.cs
- Binding.cs
- Accessors.cs
- XamlHostingSectionGroup.cs
- TriggerActionCollection.cs
- TrustManagerPromptUI.cs
- ExceptionValidationRule.cs
- DataGridLength.cs
- Tool.cs
- AudioDeviceOut.cs
- DatePickerAutomationPeer.cs
- StatusBar.cs
- DetailsViewDeleteEventArgs.cs
- BasePropertyDescriptor.cs
- RightsManagementEncryptedStream.cs
- ShapingEngine.cs
- DataObjectAttribute.cs
- XamlParser.cs
- DiagnosticTraceSource.cs
- TrackingRecord.cs
- ClosableStream.cs
- WindowHelperService.cs
- StreamInfo.cs
- HelpEvent.cs
- DataGridColumnHeader.cs
- XamlPoint3DCollectionSerializer.cs
- ActivityExecutorDelegateInfo.cs
- Int32EqualityComparer.cs
- ResourceSet.cs
- XmlElementAttribute.cs
- ClusterRegistryConfigurationProvider.cs
- ItemChangedEventArgs.cs
- WebContentFormatHelper.cs
- IncrementalReadDecoders.cs
- ResumeStoryboard.cs
- FlowLayout.cs
- ModelPerspective.cs
- BStrWrapper.cs
- externdll.cs
- RijndaelCryptoServiceProvider.cs
- VirtualStackFrame.cs
- WindowPattern.cs
- RenderData.cs
- __Filters.cs
- CrossSiteScriptingValidation.cs
- ElapsedEventArgs.cs
- InkPresenterAutomationPeer.cs
- FormViewRow.cs
- SqlExpander.cs
- StringExpressionSet.cs
- ParameterExpression.cs
- TraceLevelHelper.cs
- CacheHelper.cs
- ReliableMessagingHelpers.cs
- ImageMap.cs
- CryptoKeySecurity.cs
- FigureParagraph.cs
- SmiTypedGetterSetter.cs
- MsmqIntegrationSecurityMode.cs
- listitem.cs
- CodeTypeReferenceCollection.cs
- EditingCommands.cs
- ControllableStoryboardAction.cs
- ValueType.cs
- Semaphore.cs
- ObjectCloneHelper.cs
- UInt64.cs
- HttpClientCertificate.cs
- TextTreeExtractElementUndoUnit.cs
- ConfigXmlDocument.cs
- ControlCachePolicy.cs
- RuntimeConfigurationRecord.cs
- SqlCacheDependencySection.cs
- CoTaskMemHandle.cs
- SamlAdvice.cs
- X509ThumbprintKeyIdentifierClause.cs
- ElementNotAvailableException.cs
- StringUtil.cs
- XsltFunctions.cs
- DataGridViewMethods.cs
- LookupBindingPropertiesAttribute.cs
- DirectionalLight.cs
- ProxyWebPartManager.cs
- GridViewUpdatedEventArgs.cs
- Keyboard.cs
- DataGridPageChangedEventArgs.cs
- SurrogateSelector.cs
- ComboBox.cs
- CustomCredentialPolicy.cs
- ClientApiGenerator.cs
- ExecutionEngineException.cs