// Token: 0x060067A2 RID: 26530 RVA: 0x001D08B8 File Offset: 0x001CEAB8
 internal override void InvalidateFormatCache()
 {
     for (BaseParagraph baseParagraph = this._firstChild; baseParagraph != null; baseParagraph = baseParagraph.Next)
     {
         baseParagraph.InvalidateFormatCache();
     }
 }
Esempio n. 2
0
        // ------------------------------------------------------------------
        // Table has been structurally altered
        // ------------------------------------------------------------------
        private void TableStructureChanged(object sender, EventArgs e)
        {
            // Disconnect obsolete paragraphs.
            BaseParagraph paraInvalid = _firstChild;

            while (paraInvalid != null)
            {
                paraInvalid.Dispose();
                paraInvalid = paraInvalid.Next;
            }
            _firstChild = null;

            //
            // Since whole table content is disposed, we need
            // - to create dirty text range corresponding to the Table content
            // - notify formatter that Table's content is changed.
            //
            int charCount = Table.SymbolCount - 2;// This is equivalent to (ContentEndOffset – ContentStartOffset) but is more performant.

            if (charCount > 0)
            {
                DirtyTextRange dtr = new DirtyTextRange(Table.ContentStartOffset, charCount, charCount);
                StructuralCache.AddDirtyTextRange(dtr);
            }
            if (StructuralCache.FormattingOwner.Formatter != null)
            {
                StructuralCache.FormattingOwner.Formatter.OnContentInvalidated(true, Table.ContentStart, Table.ContentEnd);
            }
        }
        // Token: 0x060067A1 RID: 26529 RVA: 0x001D07BC File Offset: 0x001CE9BC
        internal override bool InvalidateStructure(int startPosition)
        {
            int paragraphStartCharacterPosition = base.ParagraphStartCharacterPosition;

            if (startPosition <= paragraphStartCharacterPosition + TextContainerHelper.ElementEdgeCharacterLength)
            {
                BaseParagraph baseParagraph = this._firstChild;
                while (baseParagraph != null)
                {
                    BaseParagraph baseParagraph2 = baseParagraph;
                    baseParagraph = baseParagraph.Next;
                    baseParagraph2.Dispose();
                    baseParagraph2.Next     = null;
                    baseParagraph2.Previous = null;
                }
                this._firstChild = (this._lastFetchedChild = null);
            }
            else
            {
                BaseParagraph baseParagraph = this._firstChild;
                while (baseParagraph != null)
                {
                    if (baseParagraph.ParagraphStartCharacterPosition + baseParagraph.LastFormatCch >= startPosition)
                    {
                        if (!baseParagraph.InvalidateStructure(startPosition))
                        {
                            baseParagraph = baseParagraph.Next;
                        }
                        if (baseParagraph != null)
                        {
                            if (baseParagraph.Previous != null)
                            {
                                baseParagraph.Previous.Next = null;
                                this._lastFetchedChild      = baseParagraph.Previous;
                            }
                            else
                            {
                                this._firstChild = (this._lastFetchedChild = null);
                            }
                            while (baseParagraph != null)
                            {
                                BaseParagraph baseParagraph3 = baseParagraph;
                                baseParagraph = baseParagraph.Next;
                                baseParagraph3.Dispose();
                                baseParagraph3.Next     = null;
                                baseParagraph3.Previous = null;
                            }
                            break;
                        }
                        break;
                    }
                    else
                    {
                        baseParagraph = baseParagraph.Next;
                    }
                }
            }
            return(startPosition < paragraphStartCharacterPosition + TextContainerHelper.ElementEdgeCharacterLength);
        }
 // Token: 0x06006797 RID: 26519 RVA: 0x001CF7E8 File Offset: 0x001CD9E8
 void ISegment.GetFirstPara(out int fSuccessful, out IntPtr firstParaName)
 {
     if (this._ur != null)
     {
         int cpfromElement = TextContainerHelper.GetCPFromElement(base.StructuralCache.TextContainer, base.Element, ElementEdge.AfterStart);
         if (this._ur.SyncPara != null && cpfromElement == this._ur.SyncPara.ParagraphStartCharacterPosition)
         {
             this._ur.SyncPara.Previous = null;
             if (this._ur.Next != null && this._ur.Next.FirstPara == this._ur.SyncPara)
             {
                 this._ur.SyncPara.SetUpdateInfo(this._ur.Next.ChangeType, false);
             }
             else
             {
                 this._ur.SyncPara.SetUpdateInfo(PTS.FSKCHANGE.fskchNone, this._ur.Next == null);
             }
             Invariant.Assert(this._firstChild == null);
             this._firstChild = this._ur.SyncPara;
             this._ur         = this._ur.Next;
         }
     }
     if (this._firstChild != null)
     {
         if (base.StructuralCache.CurrentFormatContext.IncrementalUpdate && this._ur == null && this.NeedsUpdate() && !this._firstParaValidInUpdateMode)
         {
             if (!base.StructuralCache.CurrentFormatContext.FinitePage)
             {
                 for (BaseParagraph baseParagraph = this._firstChild; baseParagraph != null; baseParagraph = baseParagraph.Next)
                 {
                     baseParagraph.Dispose();
                 }
                 this._firstChild = null;
             }
             this._firstParaValidInUpdateMode = true;
         }
         else if (this._ur != null && this._ur.InProcessing && this._ur.FirstPara == this._firstChild)
         {
             this._firstChild.SetUpdateInfo(PTS.FSKCHANGE.fskchInside, false);
         }
     }
     if (this._firstChild == null)
     {
         ITextPointer contentStart = TextContainerHelper.GetContentStart(base.StructuralCache.TextContainer, base.Element);
         this._firstChild = this.GetParagraph(contentStart, false);
         if (this._ur != null && this._firstChild != null)
         {
             this._firstChild.SetUpdateInfo(PTS.FSKCHANGE.fskchNew, false);
         }
     }
     if (base.StructuralCache.CurrentFormatContext.IncrementalUpdate)
     {
         this._firstParaValidInUpdateMode = true;
     }
     this._lastFetchedChild = this._firstChild;
     fSuccessful            = PTS.FromBoolean(this._firstChild != null);
     firstParaName          = ((this._firstChild != null) ? this._firstChild.Handle : IntPtr.Zero);
 }
 // Token: 0x060067A0 RID: 26528 RVA: 0x001D0780 File Offset: 0x001CE980
 internal override void ClearUpdateInfo()
 {
     for (BaseParagraph baseParagraph = this._firstChild; baseParagraph != null; baseParagraph = baseParagraph.Next)
     {
         baseParagraph.ClearUpdateInfo();
     }
     base.ClearUpdateInfo();
     this._ur = null;
     this._firstParaValidInUpdateMode = false;
 }
Esempio n. 6
0
        // Token: 0x060068B0 RID: 26800 RVA: 0x001D8BE4 File Offset: 0x001D6DE4
        protected override BaseParagraph GetParagraph(ITextPointer textPointer, bool fEmptyOk)
        {
            Invariant.Assert(textPointer is TextPointer);
            BaseParagraph baseParagraph = null;

            while (baseParagraph == null)
            {
                TextPointerContext pointerContext = textPointer.GetPointerContext(LogicalDirection.Forward);
                if (pointerContext == TextPointerContext.ElementStart)
                {
                    TextElement adjacentElementFromOuterPosition = ((TextPointer)textPointer).GetAdjacentElementFromOuterPosition(LogicalDirection.Forward);
                    if (adjacentElementFromOuterPosition is ListItem)
                    {
                        baseParagraph = new ListItemParagraph(adjacentElementFromOuterPosition, base.StructuralCache);
                        break;
                    }
                    if (adjacentElementFromOuterPosition is List)
                    {
                        baseParagraph = new ListParagraph(adjacentElementFromOuterPosition, base.StructuralCache);
                        break;
                    }
                    if (((TextPointer)textPointer).IsFrozen)
                    {
                        textPointer = textPointer.CreatePointer();
                    }
                    textPointer.MoveToPosition(adjacentElementFromOuterPosition.ElementEnd);
                }
                else if (pointerContext == TextPointerContext.ElementEnd)
                {
                    if (base.Element == ((TextPointer)textPointer).Parent)
                    {
                        break;
                    }
                    if (((TextPointer)textPointer).IsFrozen)
                    {
                        textPointer = textPointer.CreatePointer();
                    }
                    textPointer.MoveToNextContextPosition(LogicalDirection.Forward);
                }
                else
                {
                    if (((TextPointer)textPointer).IsFrozen)
                    {
                        textPointer = textPointer.CreatePointer();
                    }
                    textPointer.MoveToNextContextPosition(LogicalDirection.Forward);
                }
            }
            if (baseParagraph != null)
            {
                base.StructuralCache.CurrentFormatContext.DependentMax = (TextPointer)textPointer;
            }
            return(baseParagraph);
        }
        // Token: 0x06006AC7 RID: 27335 RVA: 0x001E901C File Offset: 0x001E721C
        public override void Dispose()
        {
            this.Table.TableStructureChanged -= this.TableStructureChanged;
            BaseParagraph baseParagraph = this._firstChild;

            while (baseParagraph != null)
            {
                BaseParagraph baseParagraph2 = baseParagraph;
                baseParagraph = baseParagraph.Next;
                baseParagraph2.Dispose();
                baseParagraph2.Next     = null;
                baseParagraph2.Previous = null;
            }
            this._firstChild = null;
            base.Dispose();
        }
        // Token: 0x06006796 RID: 26518 RVA: 0x001CF794 File Offset: 0x001CD994
        public override void Dispose()
        {
            BaseParagraph baseParagraph = this._firstChild;

            while (baseParagraph != null)
            {
                BaseParagraph baseParagraph2 = baseParagraph;
                baseParagraph = baseParagraph.Next;
                baseParagraph2.Dispose();
                baseParagraph2.Next     = null;
                baseParagraph2.Previous = null;
            }
            this._firstChild = (this._lastFetchedChild = null);
            base.Dispose();
            GC.SuppressFinalize(this);
        }
Esempio n. 9
0
        // ------------------------------------------------------------------
        // IDisposable.Dispose
        // ------------------------------------------------------------------
        public override void Dispose()
        {
            Table.TableStructureChanged -= new System.EventHandler(TableStructureChanged);

            BaseParagraph paraChild = _firstChild;

            while (paraChild != null)
            {
                BaseParagraph para = paraChild;
                paraChild = paraChild.Next;
                para.Dispose();
                para.Next     = null;
                para.Previous = null;
            }
            _firstChild = null;

            base.Dispose();
        }
        // Token: 0x06006ADC RID: 27356 RVA: 0x001E94F0 File Offset: 0x001E76F0
        private void TableStructureChanged(object sender, EventArgs e)
        {
            for (BaseParagraph baseParagraph = this._firstChild; baseParagraph != null; baseParagraph = baseParagraph.Next)
            {
                baseParagraph.Dispose();
            }
            this._firstChild = null;
            int num = this.Table.SymbolCount - 2;

            if (num > 0)
            {
                DirtyTextRange dtr = new DirtyTextRange(this.Table.ContentStartOffset, num, num, false);
                base.StructuralCache.AddDirtyTextRange(dtr);
            }
            if (base.StructuralCache.FormattingOwner.Formatter != null)
            {
                base.StructuralCache.FormattingOwner.Formatter.OnContentInvalidated(true, this.Table.ContentStart, this.Table.ContentEnd);
            }
        }
        // Token: 0x06006AD2 RID: 27346 RVA: 0x001E92E0 File Offset: 0x001E74E0
        internal void GetNextRow(IntPtr nmRow, out int fFound, out IntPtr pnmNextRow)
        {
            BaseParagraph baseParagraph  = (RowParagraph)base.PtsContext.HandleToObject(nmRow);
            BaseParagraph baseParagraph2 = baseParagraph.Next;

            if (baseParagraph2 == null)
            {
                TableRow      row      = ((RowParagraph)baseParagraph).Row;
                TableRowGroup rowGroup = row.RowGroup;
                TableRow      tableRow = null;
                int           num      = row.Index + 1;
                int           num2     = rowGroup.Index + 1;
                if (num < rowGroup.Rows.Count)
                {
                    tableRow = rowGroup.Rows[num];
                }
                while (tableRow == null && num2 != this.Table.RowGroups.Count)
                {
                    TableRowCollection rows = this.Table.RowGroups[num2].Rows;
                    if (rows.Count > 0)
                    {
                        tableRow = rows[0];
                    }
                    num2++;
                }
                if (tableRow != null)
                {
                    baseParagraph2          = new RowParagraph(tableRow, base.StructuralCache);
                    baseParagraph.Next      = baseParagraph2;
                    baseParagraph2.Previous = baseParagraph;
                    ((RowParagraph)baseParagraph2).CalculateRowSpans();
                }
            }
            if (baseParagraph2 != null)
            {
                fFound     = 1;
                pnmNextRow = baseParagraph2.Handle;
                return;
            }
            fFound     = 0;
            pnmNextRow = IntPtr.Zero;
        }
        // Token: 0x060067A6 RID: 26534 RVA: 0x001D0CB8 File Offset: 0x001CEEB8
        private UpdateRecord UpdateRecordFromDtr(DtrList dtrs, DirtyTextRange dtr, int dcpContent)
        {
            UpdateRecord updateRecord = new UpdateRecord();

            updateRecord.Dtr = dtr;
            BaseParagraph baseParagraph = this._firstChild;
            int           num           = dcpContent;

            if (num < updateRecord.Dtr.StartIndex)
            {
                while (baseParagraph != null && num + baseParagraph.LastFormatCch <= updateRecord.Dtr.StartIndex && (num + baseParagraph.LastFormatCch != updateRecord.Dtr.StartIndex || !(baseParagraph is TextParagraph)))
                {
                    num          += baseParagraph.LastFormatCch;
                    baseParagraph = baseParagraph.Next;
                }
            }
            updateRecord.FirstPara = baseParagraph;
            if (baseParagraph == null)
            {
                updateRecord.ChangeType = PTS.FSKCHANGE.fskchNew;
            }
            else if (num < updateRecord.Dtr.StartIndex)
            {
                updateRecord.ChangeType = PTS.FSKCHANGE.fskchInside;
            }
            else
            {
                updateRecord.ChangeType = PTS.FSKCHANGE.fskchNew;
            }
            updateRecord.SyncPara = null;
            while (baseParagraph != null)
            {
                if (num + baseParagraph.LastFormatCch > updateRecord.Dtr.StartIndex + updateRecord.Dtr.PositionsRemoved || (num + baseParagraph.LastFormatCch == updateRecord.Dtr.StartIndex + updateRecord.Dtr.PositionsRemoved && updateRecord.ChangeType != PTS.FSKCHANGE.fskchNew))
                {
                    updateRecord.SyncPara = baseParagraph.Next;
                    break;
                }
                num          += baseParagraph.LastFormatCch;
                baseParagraph = baseParagraph.Next;
            }
            return(updateRecord);
        }
 // Token: 0x0600679A RID: 26522 RVA: 0x001CFD2C File Offset: 0x001CDF2C
 internal void UpdGetSegmentChange(out PTS.FSKCHANGE fskch)
 {
     if (base.StructuralCache.CurrentFormatContext.FinitePage)
     {
         DtrList dtrList = base.StructuralCache.DtrsFromRange(TextContainerHelper.GetCPFromElement(base.StructuralCache.TextContainer, base.Element, ElementEdge.BeforeStart), base.LastFormatCch);
         if (dtrList != null)
         {
             int            cpfromElement  = TextContainerHelper.GetCPFromElement(base.StructuralCache.TextContainer, base.Element, ElementEdge.AfterStart);
             DirtyTextRange dirtyTextRange = dtrList[0];
             int            num            = cpfromElement;
             BaseParagraph  baseParagraph  = this._firstChild;
             if (num < dirtyTextRange.StartIndex)
             {
                 while (baseParagraph != null && num + baseParagraph.LastFormatCch <= dirtyTextRange.StartIndex && (num + baseParagraph.LastFormatCch != dirtyTextRange.StartIndex || !(baseParagraph is TextParagraph)))
                 {
                     num          += baseParagraph.Cch;
                     baseParagraph = baseParagraph.Next;
                 }
                 if (baseParagraph != null)
                 {
                     baseParagraph.SetUpdateInfo(PTS.FSKCHANGE.fskchInside, false);
                 }
             }
             else
             {
                 baseParagraph.SetUpdateInfo(PTS.FSKCHANGE.fskchNew, false);
             }
             if (baseParagraph != null)
             {
                 for (baseParagraph = baseParagraph.Next; baseParagraph != null; baseParagraph = baseParagraph.Next)
                 {
                     baseParagraph.SetUpdateInfo(PTS.FSKCHANGE.fskchNew, false);
                 }
             }
             this._changeType = PTS.FSKCHANGE.fskchInside;
         }
     }
     fskch = this._changeType;
 }
 // Token: 0x06006799 RID: 26521 RVA: 0x001CFC28 File Offset: 0x001CDE28
 void ISegment.UpdGetFirstChangeInSegment(out int fFound, out int fChangeFirst, out IntPtr nmpBeforeChange)
 {
     this.BuildUpdateRecord();
     fFound       = PTS.FromBoolean(this._ur != null);
     fChangeFirst = PTS.FromBoolean(this._ur != null && (this._firstChild == null || this._firstChild == this._ur.FirstPara));
     if (PTS.ToBoolean(fFound) && !PTS.ToBoolean(fChangeFirst))
     {
         if (this._ur.FirstPara == null)
         {
             BaseParagraph baseParagraph = this._lastFetchedChild;
             while (baseParagraph.Next != null)
             {
                 baseParagraph = baseParagraph.Next;
             }
             nmpBeforeChange = baseParagraph.Handle;
         }
         else
         {
             if (this._ur.ChangeType == PTS.FSKCHANGE.fskchNew)
             {
                 this._ur.FirstPara.Previous.Next = null;
             }
             nmpBeforeChange = this._ur.FirstPara.Previous.Handle;
         }
     }
     else
     {
         nmpBeforeChange = IntPtr.Zero;
     }
     if (PTS.ToBoolean(fFound))
     {
         this._ur.InProcessing = PTS.ToBoolean(fChangeFirst);
         this._changeType      = PTS.FSKCHANGE.fskchInside;
         this._stopAsking      = false;
     }
 }
Esempio n. 15
0
        // Token: 0x06006B36 RID: 27446 RVA: 0x001EF6F4 File Offset: 0x001ED8F4
        internal override bool InvalidateStructure(int startPosition)
        {
            Invariant.Assert(base.ParagraphEndCharacterPosition >= startPosition);
            bool result = false;

            if (base.ParagraphStartCharacterPosition == startPosition)
            {
                result = true;
                AnchoredBlock anchoredBlock = null;
                if (this._attachedObjects != null && this._attachedObjects.Count > 0)
                {
                    anchoredBlock = (AnchoredBlock)this._attachedObjects[0].Element;
                }
                if (anchoredBlock != null && startPosition == anchoredBlock.ElementStartOffset)
                {
                    StaticTextPointer staticTextPointerFromCP = TextContainerHelper.GetStaticTextPointerFromCP(base.StructuralCache.TextContainer, startPosition);
                    if (staticTextPointerFromCP.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementStart)
                    {
                        result = (anchoredBlock != staticTextPointerFromCP.GetAdjacentElement(LogicalDirection.Forward));
                    }
                }
            }
            this.InvalidateTextFormatCache();
            if (this._attachedObjects != null)
            {
                for (int i = 0; i < this._attachedObjects.Count; i++)
                {
                    BaseParagraph para = this._attachedObjects[i].Para;
                    if (para.ParagraphEndCharacterPosition >= startPosition)
                    {
                        para.InvalidateStructure(startPosition);
                    }
                }
            }
            return(result);
        }
        // Token: 0x060067A3 RID: 26531 RVA: 0x001D08E0 File Offset: 0x001CEAE0
        protected virtual BaseParagraph GetParagraph(ITextPointer textPointer, bool fEmptyOk)
        {
            BaseParagraph baseParagraph = null;

            switch (textPointer.GetPointerContext(LogicalDirection.Forward))
            {
            case TextPointerContext.None:
                Invariant.Assert(textPointer.CompareTo(textPointer.TextContainer.End) == 0);
                if (!fEmptyOk)
                {
                    baseParagraph = new TextParagraph(base.Element, base.StructuralCache);
                }
                break;

            case TextPointerContext.Text:
                if (textPointer.TextContainer.Start.CompareTo(textPointer) > 0 && (!(base.Element is TextElement) || ((TextElement)base.Element).ContentStart != textPointer))
                {
                    throw new InvalidOperationException(SR.Get("TextSchema_TextIsNotAllowedInThisContext", new object[]
                    {
                        base.Element.GetType().Name
                    }));
                }
                baseParagraph = new TextParagraph(base.Element, base.StructuralCache);
                break;

            case TextPointerContext.EmbeddedElement:
                baseParagraph = new TextParagraph(base.Element, base.StructuralCache);
                break;

            case TextPointerContext.ElementStart:
            {
                TextElement adjacentElementFromOuterPosition = ((TextPointer)textPointer).GetAdjacentElementFromOuterPosition(LogicalDirection.Forward);
                if (adjacentElementFromOuterPosition is List)
                {
                    baseParagraph = new ListParagraph(adjacentElementFromOuterPosition, base.StructuralCache);
                }
                else if (adjacentElementFromOuterPosition is Table)
                {
                    baseParagraph = new TableParagraph(adjacentElementFromOuterPosition, base.StructuralCache);
                }
                else if (adjacentElementFromOuterPosition is BlockUIContainer)
                {
                    baseParagraph = new UIElementParagraph(adjacentElementFromOuterPosition, base.StructuralCache);
                }
                else if (adjacentElementFromOuterPosition is Block || adjacentElementFromOuterPosition is ListItem)
                {
                    baseParagraph = new ContainerParagraph(adjacentElementFromOuterPosition, base.StructuralCache);
                }
                else if (adjacentElementFromOuterPosition is Inline)
                {
                    baseParagraph = new TextParagraph(base.Element, base.StructuralCache);
                }
                else
                {
                    Invariant.Assert(false);
                }
                break;
            }

            case TextPointerContext.ElementEnd:
                Invariant.Assert(textPointer is TextPointer);
                Invariant.Assert(base.Element == ((TextPointer)textPointer).Parent);
                if (!fEmptyOk)
                {
                    baseParagraph = new TextParagraph(base.Element, base.StructuralCache);
                }
                break;
            }
            if (baseParagraph != null)
            {
                base.StructuralCache.CurrentFormatContext.DependentMax = (TextPointer)textPointer;
            }
            return(baseParagraph);
        }
Esempio n. 17
0
        /// <summary>
        /// Determine paragraph type at the current TextPointer and
        /// create it. Only ListItem elements are considered. Any other
        /// content is skipped.
        /// </summary>
        /// <param name="textPointer">
        /// TextPointer at which paragraph is to be created
        /// </param>
        /// <param name="fEmptyOk">
        /// True if empty paragraph is acceptable
        /// </param>
        /// <returns>
        /// BaseParagraph that was created
        /// </returns>
        protected override BaseParagraph GetParagraph(ITextPointer textPointer, bool fEmptyOk)
        {
            Invariant.Assert(textPointer is TextPointer);

            BaseParagraph paragraph = null;

            while (paragraph == null)
            {
                TextPointerContext runType = textPointer.GetPointerContext(LogicalDirection.Forward);
                if (runType == TextPointerContext.ElementStart)
                {
                    TextElement element = ((TextPointer)textPointer).GetAdjacentElementFromOuterPosition(LogicalDirection.Forward);
                    if (element is ListItem)
                    {
                        //      Need to handle visibility collapsed.
                        //Visibility visibility = Retriever.Visibility(treePtr.CPPtr.Element);
                        //if (visibility != Visibility.Collapsed)
                        //{
                        //    para = new
                        //}
                        //else skip the element
                        paragraph = new ListItemParagraph(element, StructuralCache);
                        break;
                    }
                    else if (element is List)
                    {
                        //      Need to handle visibility collapsed.
                        //Visibility visibility = Retriever.Visibility(treePtr.CPPtr.Element);
                        //if (visibility != Visibility.Collapsed)
                        //{
                        //    para = new
                        //}
                        //else skip the element
                        paragraph = new ListParagraph(element, StructuralCache);
                        break;
                    }
                    // Skip all elements, which are not valid list item children
                    if (((TextPointer)textPointer).IsFrozen)
                    {
                        // Need to clone TextPointer before moving it.
                        textPointer = textPointer.CreatePointer();
                    }
                    textPointer.MoveToPosition(element.ElementEnd);
                }
                else if (runType == TextPointerContext.ElementEnd)
                {
                    // End of list, if the same as Owner of associated element
                    // Skip content otherwise
                    if (Element == ((TextPointer)textPointer).Parent)
                    {
                        break;
                    }
                    if (((TextPointer)textPointer).IsFrozen)
                    {
                        // Need to clone TextPointer before moving it.
                        textPointer = textPointer.CreatePointer();
                    }
                    textPointer.MoveToNextContextPosition(LogicalDirection.Forward);
                }
                else
                {
                    // Skip content
                    if (((TextPointer)textPointer).IsFrozen)
                    {
                        // Need to clone TextPointer before moving it.
                        textPointer = textPointer.CreatePointer();
                    }
                    textPointer.MoveToNextContextPosition(LogicalDirection.Forward);
                }
            }

            if (paragraph != null)
            {
                StructuralCache.CurrentFormatContext.DependentMax = (TextPointer)textPointer;
            }

            return(paragraph);
        }
 // Token: 0x060067BE RID: 26558 RVA: 0x001D150D File Offset: 0x001CF70D
 internal AttachedObject(int dcp, BaseParagraph para) : base(dcp)
 {
     this.Para = para;
 }
Esempio n. 19
0
        /// <summary>
        /// GetNextRow
        /// </summary>
        /// <param name="nmRow">Previous body row name</param>
        /// <param name="fFound">Indication that body row is found</param>
        /// <param name="pnmNextRow">Body row name</param>
        internal void GetNextRow(
            IntPtr nmRow,
            out int fFound,
            out IntPtr pnmNextRow)
        {
            Debug.Assert(Table.RowGroups.Count > 0);

            BaseParagraph prevParagraph = ((RowParagraph)PtsContext.HandleToObject(nmRow));
            BaseParagraph nextParagraph = prevParagraph.Next;

            if (nextParagraph == null)
            {
                TableRow      currentRow      = ((RowParagraph)prevParagraph).Row;
                TableRowGroup currentRowGroup = currentRow.RowGroup;
                TableRow      tableRow        = null;

                int nextRowIndex      = currentRow.Index + 1;
                int nextRowGroupIndex = currentRowGroup.Index + 1;

                if (nextRowIndex < currentRowGroup.Rows.Count)
                {
                    Debug.Assert(currentRowGroup.Rows[nextRowIndex].Index != -1,
                                 "Row is not in a table");

                    tableRow = currentRowGroup.Rows[nextRowIndex];
                }

                while (tableRow == null)
                {
                    if (nextRowGroupIndex == Table.RowGroups.Count)
                    {
                        break;
                    }

                    TableRowCollection Rows = Table.RowGroups[nextRowGroupIndex].Rows;

                    if (Rows.Count > 0)
                    {
                        Debug.Assert(Rows[0].Index != -1,
                                     "Row is not in a table");

                        tableRow = Rows[0];
                    }

                    nextRowGroupIndex++;
                }

                if (tableRow != null)
                {
                    nextParagraph          = new RowParagraph(tableRow, StructuralCache);
                    prevParagraph.Next     = nextParagraph;
                    nextParagraph.Previous = prevParagraph;

                    ((RowParagraph)nextParagraph).CalculateRowSpans();
                }
            }

            if (nextParagraph != null)
            {
                fFound     = PTS.True;
                pnmNextRow = nextParagraph.Handle;
            }
            else
            {
                fFound     = PTS.False;
                pnmNextRow = IntPtr.Zero;
            }
        }
 protected BaseParaClient(BaseParagraph paragraph) : base(paragraph.PtsContext)
 {
     _paraHandle = new SecurityCriticalDataForSet<IntPtr>(IntPtr.Zero);
     _paragraph = paragraph;
 }
        // Token: 0x06006798 RID: 26520 RVA: 0x001CFA2C File Offset: 0x001CDC2C
        void ISegment.GetNextPara(BaseParagraph prevParagraph, out int fFound, out IntPtr nextParaName)
        {
            if (this._ur != null)
            {
                int paragraphEndCharacterPosition = prevParagraph.ParagraphEndCharacterPosition;
                if (this._ur.SyncPara != null && paragraphEndCharacterPosition == this._ur.SyncPara.ParagraphStartCharacterPosition)
                {
                    this._ur.SyncPara.Previous = prevParagraph;
                    prevParagraph.Next         = this._ur.SyncPara;
                    if (this._ur.Next != null && this._ur.Next.FirstPara == this._ur.SyncPara)
                    {
                        this._ur.SyncPara.SetUpdateInfo(this._ur.Next.ChangeType, false);
                    }
                    else
                    {
                        this._ur.SyncPara.SetUpdateInfo(PTS.FSKCHANGE.fskchNone, this._ur.Next == null);
                    }
                    this._ur = this._ur.Next;
                }
                else
                {
                    Invariant.Assert(this._ur.SyncPara == null || paragraphEndCharacterPosition < this._ur.SyncPara.ParagraphStartCharacterPosition);
                    if (!this._ur.InProcessing && this._ur.FirstPara != prevParagraph.Next && prevParagraph.Next != null)
                    {
                        prevParagraph.Next.SetUpdateInfo(PTS.FSKCHANGE.fskchNone, false);
                    }
                    else if (this._ur.FirstPara != null && this._ur.FirstPara == prevParagraph.Next)
                    {
                        this._ur.InProcessing = true;
                        prevParagraph.Next.SetUpdateInfo(PTS.FSKCHANGE.fskchInside, false);
                    }
                }
            }
            BaseParagraph baseParagraph = prevParagraph.Next;

            if (baseParagraph == null)
            {
                ITextPointer textPointerFromCP = TextContainerHelper.GetTextPointerFromCP(base.StructuralCache.TextContainer, prevParagraph.ParagraphEndCharacterPosition, LogicalDirection.Forward);
                baseParagraph = this.GetParagraph(textPointerFromCP, true);
                if (baseParagraph != null)
                {
                    baseParagraph.Previous = prevParagraph;
                    prevParagraph.Next     = baseParagraph;
                    if (this._changeType == PTS.FSKCHANGE.fskchInside)
                    {
                        baseParagraph.SetUpdateInfo(PTS.FSKCHANGE.fskchNew, false);
                    }
                }
            }
            if (baseParagraph != null)
            {
                fFound                 = 1;
                nextParaName           = baseParagraph.Handle;
                this._lastFetchedChild = baseParagraph;
                return;
            }
            fFound                 = 0;
            nextParaName           = IntPtr.Zero;
            this._lastFetchedChild = prevParagraph;
            this._ur               = null;
        }
        //-------------------------------------------------------------------
        // ISegment.GetNextPara
        //-------------------------------------------------------------------
        void ISegment.GetNextPara(
            BaseParagraph prevParagraph,        // IN:  current para
            out int fFound,                     // OUT: is there next paragraph?
            out IntPtr nextParaName)            // OUT: name of the next paragraph in section
        {
            if (_ur != null)
            {
                // Determine if synchronization point has been reached.
                int cpCurrent = prevParagraph.ParagraphEndCharacterPosition;
                if (_ur.SyncPara != null && cpCurrent == _ur.SyncPara.ParagraphStartCharacterPosition)
                {
                    _ur.SyncPara.Previous = prevParagraph;
                    prevParagraph.Next = _ur.SyncPara;
                    if (_ur.Next != null && _ur.Next.FirstPara == _ur.SyncPara)
                    {
                        _ur.SyncPara.SetUpdateInfo(_ur.Next.ChangeType, false);
                    }
                    else
                    {
                        _ur.SyncPara.SetUpdateInfo(PTS.FSKCHANGE.fskchNone, _ur.Next == null);
                    }

                    _ur = _ur.Next;
                }
                else
                {
                    Invariant.Assert(_ur.SyncPara == null || cpCurrent < _ur.SyncPara.ParagraphStartCharacterPosition);

                    // Skip all paragraphs before the beginning of the next UpdateRecord. 
                    // This situation may happen when we go to the next UpdateRecord after finding 
                    // synchronization point. It means that we have to run into _ur.FirstPara and all 
                    // paragraphs up to this point dont need to be updated.
                    if (!_ur.InProcessing && _ur.FirstPara != prevParagraph.Next && prevParagraph.Next != null)
                    {
                        prevParagraph.Next.SetUpdateInfo(PTS.FSKCHANGE.fskchNone, false);
                    }
                    // If updated paragraph return it
                    else if (_ur.FirstPara != null && _ur.FirstPara == prevParagraph.Next)
                    {
                        Debug.Assert(_ur.ChangeType == PTS.FSKCHANGE.fskchInside); // Inconsistent UpdateRecord data
                        _ur.InProcessing = true;
                        prevParagraph.Next.SetUpdateInfo(PTS.FSKCHANGE.fskchInside, false);
                    }
                }

            }

            BaseParagraph nextParagraph = prevParagraph.Next;
#if TEXTPANELLAYOUTDEBUG
            bool cached = nextParagraph != null;
#endif
            if (nextParagraph == null)
            {
                // Determine paragraph type and create it
                ITextPointer textPointer = TextContainerHelper.GetTextPointerFromCP(StructuralCache.TextContainer, prevParagraph.ParagraphEndCharacterPosition, LogicalDirection.Forward);
                nextParagraph = GetParagraph(textPointer, true);

                // Add new paragraph to a linked list of paragraphs in the segment
                if (nextParagraph != null)
                {
                    nextParagraph.Previous = prevParagraph;
                    prevParagraph.Next = nextParagraph;
                    if (_changeType == PTS.FSKCHANGE.fskchInside)
                    {
                        nextParagraph.SetUpdateInfo(PTS.FSKCHANGE.fskchNew, false);
                    }
                }
            }

            // Initialize output parameters
            if (nextParagraph != null)
            {
                fFound = PTS.True;
                nextParaName = nextParagraph.Handle;
                _lastFetchedChild = nextParagraph;
            }
            else
            {
                fFound = PTS.False;
                nextParaName = IntPtr.Zero;
                // Pages might be created in random order (assuming that structure is not
                // dirty). Because of that always update last fetched paragraph cache.
                _lastFetchedChild = prevParagraph;
                _ur = null; // Clear out any additional update record info for this segment.
            }
#if TEXTPANELLAYOUTDEBUG
            if (StructuralCache.CurrentFormatContext.IncrementalUpdate)
            {
                System.Text.StringBuilder msg = new System.Text.StringBuilder();
                msg.Append("ContPara.GetNextPara, Found=" + fFound);
                if (nextParagraph != null)
                {
                    msg.Append(" Cached=" + cached + " Para=" + nextParagraph.GetType().Name);
                }
                TextPanelDebug.Log(msg.ToString(), TextPanelDebug.Category.ContentChange);
            }
#endif
        }
Esempio n. 23
0
 protected BaseParaClient(BaseParagraph paragraph) : base(paragraph.PtsContext)
 {
     this._paraHandle = new SecurityCriticalDataForSet <IntPtr>(IntPtr.Zero);
     this._paragraph  = paragraph;
 }
Esempio n. 24
0
 /// <summary> 
 /// Constructor.
 /// </summary>
 /// <param name="dcp">
 /// Attached object's character position. 
 /// </param>
 /// <param name="para"> 
 /// Paragraph associated with attached object. 
 /// </param>
 internal AttachedObject(int dcp, BaseParagraph para) 
     : base(dcp)
 {
     Para = para;
 }