internal TextParentUndoUnit(ITextSelection selection, ITextPointer anchorPosition, ITextPointer movingPosition)
            : base(String.Empty)
        {
            _selection = selection;

            _undoAnchorPositionOffset = anchorPosition.Offset;
            _undoAnchorPositionDirection = anchorPosition.LogicalDirection;
            _undoMovingPositionOffset = movingPosition.Offset;
            _undoMovingPositionDirection = movingPosition.LogicalDirection;

            // Bug 1706768: we are seeing unitialized values when the undo
            // undo is pulled off the undo stack. _redoAnchorPositionOffset
            // and _redoMovingPositionOffset are supposed to be initialized
            // with calls to RecordRedoSelectionState before that happens.
            //
            // This code path is being left enabled in DEBUG to help track down
            // the underlying bug post V1.
#if DEBUG
            _redoAnchorPositionOffset = -1;
            _redoMovingPositionOffset = -1;
#else
            _redoAnchorPositionOffset = 0;
            _redoMovingPositionOffset = 0;
#endif
        }

 // Raises a Changed event for any listeners, covering the
 // specified text.
 internal void FireChangedEvent(ITextPointer start, ITextPointer end)
 {
     if (Changed != null)
     {
         Changed(this, new SpellerHighlightChangedEventArgs(start, end));
     }
 }

 //------------------------------------------------------
 //
 //  Constructors
 //
 //------------------------------------------------------
 #region Constructors
 // Ctor always set mutable flag to false
 internal DocumentSequenceTextPointer(ChildDocumentBlock childBlock, ITextPointer childPosition)
 {
     Debug.Assert(childBlock != null);
     Debug.Assert(childPosition != null);
     _childBlock = childBlock;
     _childTp = childPosition;
 }

        //------------------------------------------------------
        //
        //  Constructors
        //
        //------------------------------------------------------

        #region Constructors

        // Constructor.
        internal SpellerStatusTable(ITextPointer textContainerStart, SpellerHighlightLayer highlightLayer)
        {
            _highlightLayer = highlightLayer;

            _runList = new ArrayList(1);

            _runList.Add(new Run(textContainerStart, RunType.Dirty));
        }

        //-----------------------------------------------------
        //
        //  Constructors 
        //
        //----------------------------------------------------- 
 
        #region Constructors
 
        // Creates a new instance.
        internal SpellingError(Speller speller, ITextPointer start, ITextPointer end)
        {
            Invariant.Assert(start.CompareTo(end) < 0); 

            _speller = speller; 
            _start = start.GetFrozenPointer(LogicalDirection.Forward); 
            _end = end.GetFrozenPointer(LogicalDirection.Backward);
        } 

 internal TextContainerChangeEventArgs(ITextPointer textPosition, int count, int charCount, TextChangeType textChange, DependencyProperty property, bool affectsRenderOnly) 
 {
     _textPosition = textPosition.GetFrozenPointer(LogicalDirection.Forward); 
     _count = count; 
     _charCount = charCount;
     _textChange = textChange; 
     _property = property;
     _affectsRenderOnly = affectsRenderOnly;
 }

        // Verifies a TextPointer is non-null and is associated with a given TextContainer.
        //
        // Throws an appropriate exception if a test fails.
        internal static void VerifyPosition(ITextContainer container, ITextPointer position, string paramName)
        {
            if (position == null)
            {
                throw new ArgumentNullException(paramName);
            }

            if (position.TextContainer != container)
            {
                throw new ArgumentException(SR.Get(SRID.NotInAssociatedTree, paramName));
            }
        }

 /// <summary> 
 /// <see cref="ITextView.GetRectangleFromTextPosition"/>
 /// </summary> 
 /// <remarks> 
 /// Calls GetRawRectangleFromTextPosition to get a rect and a transform, and applies the transform to the
 /// rect. 
 /// </remarks>
 internal virtual Rect GetRectangleFromTextPosition(ITextPointer position)
 {
     Transform transform; 
     Rect rect = GetRawRectangleFromTextPosition(position, out transform);
     // Transform must not be null. TextViews returning no transform should return identity 
     Invariant.Assert(transform != null); 
     if (rect != Rect.Empty)
     { 
         rect = transform.TransformBounds(rect);
     }
     return rect;
 } 

        // Worker for GetText, accepts any ITextPointer.
        internal static string GetTextInRun(ITextPointer position, LogicalDirection direction)
        {
            char[] text;
            int textLength;
            int getTextLength;

            textLength = position.GetTextRunLength(direction);
            text = new char[textLength];

            getTextLength = position.GetTextInRun(direction, text, 0, textLength);
            Invariant.Assert(getTextLength == textLength, "textLengths returned from GetTextRunLength and GetTextInRun are innconsistent");

            return new string(text);
        }

        // ignoreTextUnitBoundaries - true if normalization should ignore text
        // normalization (surrogates, combining marks, etc).
        // Used for fine-grained control by IMEs.
        internal TextRange(ITextPointer position1, ITextPointer position2, bool ignoreTextUnitBoundaries)
        {
            if (position1 == null)
            {
                throw new ArgumentNullException("position1");
            }
            if (position2 == null)
            {
                throw new ArgumentNullException("position2");
            }

            SetFlags(ignoreTextUnitBoundaries, Flags.IgnoreTextUnitBoundaries);

            ValidationHelper.VerifyPosition(position1.TextContainer, position1, "position1");
            ValidationHelper.VerifyPosition(position1.TextContainer, position2, "position2");

            TextRangeBase.Select(this, position1, position2);
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="startPosition">
        /// Position preceeding the TextSegment's content.
        /// </param>
        /// <param name="endPosition">
        /// Position following the TextSegment's content.
        /// </param>
        /// <param name="preserveLogicalDirection">
        /// Whether preserves LogicalDirection of start and end positions.
        /// </param>
        internal TextSegment(ITextPointer startPosition, ITextPointer endPosition, bool preserveLogicalDirection)
        {
            ValidationHelper.VerifyPositionPair(startPosition, endPosition);

            if (startPosition.CompareTo(endPosition) == 0)
            {
                // To preserve segment emptiness
                // we use the same instance of a pointer
                // for both segment ends.
                _start = startPosition.GetFrozenPointer(startPosition.LogicalDirection);
                _end = _start;
            }
            else
            {
                Invariant.Assert(startPosition.CompareTo(endPosition) < 0);
                _start = startPosition.GetFrozenPointer(preserveLogicalDirection ? startPosition.LogicalDirection : LogicalDirection.Backward);
                _end = endPosition.GetFrozenPointer(preserveLogicalDirection ? endPosition.LogicalDirection : LogicalDirection.Forward);
            }
        }

 // Verifies two positions are safe to use as a logical text span.
 //
 // Throws ArgumentNullException if startPosition == null || endPosition == null
 //        ArgumentException if startPosition.TextContainer != endPosition.TextContainer or
 //                             startPosition > endPosition
 internal static void VerifyPositionPair(ITextPointer startPosition, ITextPointer endPosition)
 {
     if (startPosition == null)
     {
         throw new ArgumentNullException("startPosition");
     }
     if (endPosition == null)
     {
         throw new ArgumentNullException("endPosition");
     }
     if (startPosition.TextContainer != endPosition.TextContainer)
     {
         throw new ArgumentException(SR.Get(SRID.InDifferentTextContainers, "startPosition", "endPosition"));
     }
     if (startPosition.CompareTo(endPosition) > 0)
     {
         throw new ArgumentException(SR.Get(SRID.BadTextPositionOrder, "startPosition", "endPosition"));
     }
 }

        // Like GetText, excepts also accepts a limit parameter -- no text is returned past
        // this second position.
        // limit may be null, in which case it is ignored.
        internal static int GetTextWithLimit(ITextPointer thisPointer, LogicalDirection direction, char[] textBuffer, int startIndex, int count, ITextPointer limit)
        {
            int charsCopied;

            if (limit == null)
            {
                // No limit, just call GetText.
                charsCopied = thisPointer.GetTextInRun(direction, textBuffer, startIndex, count);
            }
            else if (direction == LogicalDirection.Forward && limit.CompareTo(thisPointer) <= 0)
            {
                // Limit completely blocks the read.
                charsCopied = 0;
            }
            else if (direction == LogicalDirection.Backward && limit.CompareTo(thisPointer) >= 0)
            {
                // Limit completely blocks the read.
                charsCopied = 0;
            }
            else
            {
                int maxCount;

                // Get an upper bound on the amount of text to copy.
                // Since GetText always stops on non-text boundaries, it's
                // ok if the count too high, it will get truncated anyways.
                if (direction == LogicalDirection.Forward)
                {
                    maxCount = Math.Min(count, thisPointer.GetOffsetToPosition(limit));
                }
                else
                {
                    maxCount = Math.Min(count, limit.GetOffsetToPosition(thisPointer));
                }
                maxCount = Math.Min(count, maxCount);

                charsCopied = thisPointer.GetTextInRun(direction, textBuffer, startIndex, maxCount);
            }

            return charsCopied;
        }

        /// <summary>
        ///   Apply the display attribute to to the given range.
        /// </summary>
        internal void Apply(ITextPointer start, ITextPointer end)
        {
            //
            // 


             
#if NOT_YET
            if (_attr.crText.type != UnsafeNativeMethods.TF_DA_COLORTYPE.TF_CT_NONE)
            {
            }

            if (_attr.crBk.type != UnsafeNativeMethods.TF_DA_COLORTYPE.TF_CT_NONE)
            {
            }

            if (_attr.lsStyle != UnsafeNativeMethods.TF_DA_LINESTYLE.TF_LS_NONE)
            {
            }
#endif

        }

        /// <summary>
        /// Compares this TextPointer with another TextPointer.
        /// </summary>
        /// <param name="position">
        /// The TextPointer to compare with.
        /// </param>
        /// <returns>
        /// Less than zero: this TextPointer preceeds position.
        /// Zero: this TextPointer is at the same location as position.
        /// Greater than zero: this TextPointer follows position.
        /// </returns>
        int ITextPointer.CompareTo(ITextPointer position)
        {
            int offset;
            int result;

            offset = ((PasswordTextPointer)position)._offset;

            if (_offset < offset)
            {
                result = -1;
            }
            else if (_offset > offset)
            {
                result = +1;
            }
            else
            {
                result = 0;
            }

            return result;
        }

        // Returns the first dirty run following a specified position in the document.
        // start/end will be left null if no dirty ranges are found.
        internal void GetFirstDirtyRange(ITextPointer searchStart, out ITextPointer start, out ITextPointer end)
        {
            int index;
            Run run;

            start = null;
            end = null;

            // If this is ever slow enough to matter, we could cache the value.
            for (index = FindIndex(searchStart.CreateStaticPointer(), LogicalDirection.Forward); index >= 0 && index < _runList.Count; index++)
            {
                run = GetRun(index);

                if (run.RunType == RunType.Dirty)
                {
                    // We might get a hit in the first run, in which case start <= searchStart.
                    // Always return searchStart as a minimum.
                    start = TextPointerBase.Max(searchStart, run.Position);
                    end = GetRunEndPositionDynamic(index);
                    break;
                }
            }
        }

        //----------------------------------------------------- 
        //
        // ITextRange Methods
        //
        //----------------------------------------------------- 

        #region ITextRange Methods 
 
        //......................................................
        // 
        // Selection Building
        //
        //......................................................
 
        /// <summary>
        /// </summary> 
        // 
        internal static bool Contains(ITextRange thisRange, ITextPointer textPointer)
        { 
            NormalizeRange(thisRange);

            if (textPointer == null)
            { 
                throw new ArgumentNullException("textPointer");
            } 
 
            if (textPointer.TextContainer != thisRange.Start.TextContainer)
            { 
                throw new ArgumentException(SR.Get(SRID.NotInAssociatedTree), "textPointer");
            }

            // Correct position normalization on range boundary so that 
            // our test would not depend on what side of formatting tags
            // pointer is located. 
            if (textPointer.CompareTo(thisRange.Start) < 0) 
            {
                textPointer = textPointer.GetFormatNormalizedPosition(LogicalDirection.Forward); 
            }
            else if (textPointer.CompareTo(thisRange.End) > 0)
            {
                textPointer = textPointer.GetFormatNormalizedPosition(LogicalDirection.Backward); 
            }
 
            // Check if at least one segment contains this position. 
            for (int i = 0; i < thisRange._TextSegments.Count; i++)
            { 
                if (thisRange._TextSegments[i].Contains(textPointer))
                {
                    return true;
                } 
            }
 
            return false; 
        }

        //------------------------------------------------------
        //
        //  Internal Methods
        // 
        //-----------------------------------------------------
 
        #region Internal Methods 

        /// <summary> 
        /// Inserts text at a specified position.
        /// </summary>
        /// <param name="position">
        /// Position at which to insert the new text. 
        /// </param>
        /// <param name="textData"> 
        /// Text to insert. 
        /// </param>
        /// <remarks> 
        /// Use the CanInsertText method to determine if text may be inserted
        /// at position.
        ///
        /// All positions at this location are repositioned 
        /// before or after the inserted text according to their gravity.
        /// </remarks> 
        internal void InsertText(ITextPointer position, string textData) 
        {
            int offset; 
            int i;

            BeginChange();
            try 
            {
                offset = ((PasswordTextPointer)position).Offset; 
 
                // Strangely, there is no SecureString.InsertAt(offset, string), so
                // we must use a loop here. 
                for (i = 0; i < textData.Length; i++)
                {
                    _password.InsertAt(offset + i, textData[i]);
                } 

                OnPasswordChange(offset, textData.Length); 
            } 
            finally
            { 
                EndChange();
            }
        }

        /// <summary>
        /// Returns the paragraphs for the appropriate cell, given a point
        /// </summary>
        /// <param name="position">Position of cell.</param>
        /// <returns>
        /// Array of paragraph results
        /// </returns>
        internal ReadOnlyCollection<ParagraphResult> GetParagraphsFromPosition(ITextPointer position)
        {
            CellParaClient cpc = GetCellParaClientFromPosition(position);

            List<ParagraphResult> listResults = new List<ParagraphResult>(0);

            if(cpc != null)
            {
                listResults.Add(cpc.CreateParagraphResult());
            }

            return new ReadOnlyCollection<ParagraphResult>(listResults);
        }

        internal Rect GetRectangleFromRowEndPosition(ITextPointer position)
        {
            Debug.Assert(   TableParagraph.Table != null
                        &&  CalculatedColumns != null  );

            PTS.FSTABLEROWDESCRIPTION[] arrayTableRowDesc;
            PTS.FSKUPDATE fskupdTable;
            PTS.FSRECT rectTable;

            if (QueryTableDetails(out arrayTableRowDesc, out fskupdTable, out rectTable))
            {
                int vrCur = GetTableOffsetFirstRowTop() + rectTable.v;

                for (int iR = 0; iR < arrayTableRowDesc.Length; ++iR)
                {
                    TableRow row = ((RowParagraph)(PtsContext.HandleToObject(arrayTableRowDesc[iR].fsnmRow))).Row;

                    if(((TextPointer)position).CompareTo(row.ContentEnd) == 0)
                    {
                        return new Rect( TextDpi.FromTextDpi(rectTable.u + rectTable.du),
                                         TextDpi.FromTextDpi(vrCur),
                                         1.0,
                                         TextDpi.FromTextDpi(arrayTableRowDesc[iR].u.dvrRow));
                    }

                    vrCur += arrayTableRowDesc[iR].u.dvrRow;
                }
            }

            // Valid row end position should have been specified.
            Debug.Assert(false);

            return System.Windows.Rect.Empty;
        }