C# ITextRange.Select方法代码示例

 // Apply initial typing heuristics -- adjust range for typing 
 // when it spans one or more TableCells.
 // 
 // ApplyInitialTypingHeuristics/ApplyFinalTypingHeuristics are
 // called together, with a an extra step in between for TextSelection
 // overrides of the ApplyTypingHueristic method.
 internal static void ApplyInitialTypingHeuristics(ITextRange thisRange) 
 {
     // When table cells selected, clear the start cell and collapse selection into it 
     if (thisRange.IsTableCellRange) 
     {
         TableCell cell; 
         if (thisRange.Start is TextPointer &&
             (cell = TextRangeEditTables.GetTableCellFromPosition((TextPointer)thisRange.Start)) != null)
         {
             // Select the first cell content to make springload formatting happen below 
             thisRange.Select(cell.ContentStart, cell.ContentEnd);
         } 
         else 
         {
             thisRange.Select(thisRange.Start, thisRange.Start); 
         }
     }
 }

        // Apply typing heuristics
        //  - extend for overtype. 
        //  - prevent paragraph merges when only the leading edge of that 
        //    last paragraph is selected.
        // 
        // ApplyInitialTypingHeuristics/ApplyFinalTypingHeuristics are
        // called together, with a an extra step in between for TextSelection
        // overrides of the ApplyTypingHueristic method.
        internal static void ApplyFinalTypingHeuristics(ITextRange thisRange, bool overType) 
        {
            // Expand empty selection forward in overtype mode 
            if (overType && thisRange.IsEmpty && 
                !TextPointerBase.IsNextToAnyBreak(thisRange.End, LogicalDirection.Forward))
            { 
                //


                ITextPointer nextPosition = thisRange.End.CreatePointer(); 
                nextPosition.MoveToNextInsertionPosition(LogicalDirection.Forward);
                if (!TextRangeEditTables.IsTableStructureCrossed(thisRange.Start, nextPosition)) 
                { 
                    TextRange range = new TextRange(thisRange.Start, nextPosition);
                    Invariant.Assert(!range.IsTableCellRange); 

                    range.Text = String.Empty;
                }
            } 

            // If the range is non-empty, and its end just passes a paragraph break, 
            // pull the end back to stop a paragraph merge on the next keystroke. 
            if (!thisRange.IsEmpty &&
                (TextPointerBase.IsNextToAnyBreak(thisRange.End, LogicalDirection.Backward) || 
                 TextPointerBase.IsAfterLastParagraph(thisRange.End)))
            {
                ITextPointer newEnd = thisRange.End.GetNextInsertionPosition(LogicalDirection.Backward);
                thisRange.Select(thisRange.Start, newEnd); 
            }
        } 

        // Implementation of a setter fot ITextRange.Text property
        internal static void SetText(ITextRange thisRange, string textData) 
        {
            NormalizeRange(thisRange); 
 
            if (textData == null)
            { 
                throw new ArgumentNullException("textData");
            }

            ITextPointer explicitInsertPosition = null; 

            TextRangeBase.BeginChange(thisRange); 
            try 
            {
                // Delete content covered by this range 
                if (!thisRange.IsEmpty)
                {
                    if (thisRange.Start is TextPointer &&
                        ((TextPointer)thisRange.Start).Parent == ((TextPointer)thisRange.End).Parent && 
                        ((TextPointer)thisRange.Start).Parent is Run &&
                        textData.Length > 0) 
                    { 
                        // When textrange start/end are parented by the same Run, we can optimize
                        // and delete content without any checks. 
                        //
                        // Note that NOT doing so has a serious side effect in this case.
                        // Low-level code in TextRangeEdit does not preserve an empty run
                        // with no formatting properties after deletion. 
                        // We dont want to loose the empty Run,
                        // when we are just about to set the range text to non-empty string. 
                        // Otherwise, newly inserted text might have undesirable formatting properties 
                        // applied due to an insertion position within an adjacent Run.
 
                        if (thisRange.Start.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.Text &&
                            thisRange.End.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.Text)
                        {
                            // If we're deleting with surrounding text, make sure we insert later between the surrounding text. 
                            // Because we will invalidate layout with the delete, it's possible that thisRange.Start
                            // will normalize itself to a different character offset on the next reference. 
                            // This is because -- unfortunately -- when layout is valid we use ITextView.IsAtCaretUnitBoundary 
                            // to normalize unicode offsets, but when layout is dirty we use a different code path
                            // that ignores the current font and simply checks Unicode values for surrogates and 
                            // combining marks.  See bug 1683515 for an example.
                            explicitInsertPosition = thisRange.Start;
                        }
 
                        TextContainer textContainer = ((TextPointer)thisRange.Start).TextContainer;
                        textContainer.DeleteContentInternal((TextPointer)thisRange.Start, (TextPointer)thisRange.End); 
                    } 
                    else
                    { 
                        thisRange.Start.DeleteContentToPosition(thisRange.End);
                    }

                    if (thisRange.Start is TextPointer) 
                    {
                        TextRangeEdit.MergeFlowDirection((TextPointer)thisRange.Start); 
                    } 

                    thisRange.Select(thisRange.Start, thisRange.Start); 
                }

                // Insert text at end position
                // Note that the non-emptiness check below is not an optimization: 
                // In case of empty text the code block in it would change an empty range
                // orientation, which is undesirable side effect. 
                // Also if the inserted text is empty we need to avoid ensuring insertion position, 
                // which can create paragraphs etc.
                if (textData.Length > 0) 
                {
                    ITextPointer insertPosition = (explicitInsertPosition == null) ? thisRange.Start : explicitInsertPosition;

                    // Ensure last paragraph existence and prepare ends for the new selection 
                    bool pastedFragmentEndsWithNewLine = textData.EndsWith("\n", StringComparison.Ordinal);
 
                    // We are going to insert paragraph implicitly when the block content becomes totally empty. 
                    // Store the fact that implicit paragraph was inserted to exclude ane extra paragraph break
                    // from the end of pasted fragment 
                    bool implicitParagraphInserted = insertPosition is TextPointer &&
                        TextSchema.IsValidChild(/*position*/insertPosition, /*childType*/typeof(Block)) &&
                        (insertPosition.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.None ||
                        insertPosition.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementStart) && 
                        (insertPosition.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.None ||
                        insertPosition.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementEnd); 
 
                    // Make sure that the range is positioned at insertion position
                    if (insertPosition is TextPointer && explicitInsertPosition == null) 
                    {
                        TextPointer insertionPosition = TextRangeEditTables.EnsureInsertionPosition((TextPointer)insertPosition);
                        thisRange.Select(insertionPosition, insertionPosition);
                        insertPosition = thisRange.Start; 
                    }
                    Invariant.Assert(TextSchema.IsInTextContent(insertPosition), "range.Start is expected to be in text content"); 
 
                    ITextPointer newStart = insertPosition.GetFrozenPointer(LogicalDirection.Backward);
                    ITextPointer newEnd = insertPosition.CreatePointer(LogicalDirection.Forward); 

                    if ((newStart is TextPointer) && ((TextPointer)newStart).Paragraph != null)
                    {
//.........这里部分代码省略.........