// Token: 0x06006A24 RID: 27172 RVA: 0x001E3960 File Offset: 0x001E1B60 internal void CalculateRowSpans() { RowParagraph previousRow = null; if (this.Row.Index != 0 && this.Previous != null) { previousRow = (RowParagraph)this.Previous; } Invariant.Assert(this._cellParagraphs == null); this._cellParagraphs = new CellParagraph[this.Row.Cells.Count]; for (int i = 0; i < this.Row.Cells.Count; i++) { this._cellParagraphs[i] = new CellParagraph(this.Row.Cells[i], base.StructuralCache); } Invariant.Assert(this._spannedCells == null); if (this.Row.SpannedCells != null) { this._spannedCells = new CellParagraph[this.Row.SpannedCells.Length]; } else { this._spannedCells = new CellParagraph[0]; } for (int j = 0; j < this._spannedCells.Length; j++) { this._spannedCells[j] = this.FindCellParagraphForCell(previousRow, this.Row.SpannedCells[j]); } }
// ------------------------------------------------------------------ // Invalidate accumulated format caches for the row. // ------------------------------------------------------------------ private void InvalidateRowFormatCache(RowParagraph rowParagraph) { for (int iCell = 0; iCell < rowParagraph.Cells.Length; iCell++) { rowParagraph.Cells[iCell].InvalidateFormatCache(); } }
// Token: 0x06006AD8 RID: 27352 RVA: 0x001E9440 File Offset: 0x001E7640 internal override void InvalidateFormatCache() { for (RowParagraph rowParagraph = this._firstChild as RowParagraph; rowParagraph != null; rowParagraph = (rowParagraph.Next as RowParagraph)) { this.InvalidateRowFormatCache(rowParagraph); } }
/// <summary> /// Calculates the spanned cells for this paragraph from the spanned cells for the previous paragraph. /// This needs to be done to share the spanned cell paragraphs. /// </summary> internal void CalculateRowSpans() { RowParagraph rowPrevious = null; if (Row.Index != 0 && Previous != null) { rowPrevious = ((RowParagraph)Previous); } Invariant.Assert(_cellParagraphs == null); _cellParagraphs = new CellParagraph[Row.Cells.Count]; for (int cellIndex = 0; cellIndex < Row.Cells.Count; cellIndex++) { _cellParagraphs[cellIndex] = new CellParagraph(Row.Cells[cellIndex], StructuralCache); } Invariant.Assert(_spannedCells == null); if (Row.SpannedCells != null) { _spannedCells = new CellParagraph[Row.SpannedCells.Length]; } else { _spannedCells = new CellParagraph[0]; } for (int index = 0; index < _spannedCells.Length; index++) { _spannedCells[index] = FindCellParagraphForCell(rowPrevious, Row.SpannedCells[index]); } }
// ------------------------------------------------------------------ // Invalidate accumulated format caches for the table. // ------------------------------------------------------------------ internal override void InvalidateFormatCache() { RowParagraph currentParagraph = _firstChild as RowParagraph; while (currentParagraph != null) { InvalidateRowFormatCache(currentParagraph); currentParagraph = currentParagraph.Next as RowParagraph; } }
// Token: 0x06006AD7 RID: 27351 RVA: 0x001E9404 File Offset: 0x001E7604 internal override bool InvalidateStructure(int startPosition) { bool result = true; for (RowParagraph rowParagraph = this._firstChild as RowParagraph; rowParagraph != null; rowParagraph = (rowParagraph.Next as RowParagraph)) { if (!this.InvalidateRowStructure(rowParagraph, startPosition)) { result = false; } } return(result); }
// Token: 0x06006ADA RID: 27354 RVA: 0x001E9480 File Offset: 0x001E7680 private bool InvalidateRowStructure(RowParagraph rowParagraph, int startPosition) { bool result = true; for (int i = 0; i < rowParagraph.Cells.Length; i++) { CellParagraph cellParagraph = rowParagraph.Cells[i]; if (cellParagraph.ParagraphEndCharacterPosition < startPosition || !cellParagraph.InvalidateStructure(startPosition)) { result = false; } } return(result); }
//------------------------------------------------------ // // Private methods // //------------------------------------------------------ #region Private Methods // ------------------------------------------------------------------ // Invalidate accumulated format caches for the row. // ------------------------------------------------------------------ private bool InvalidateRowStructure(RowParagraph rowParagraph, int startPosition) { bool isEntireTableInvalid = true; for (int iCell = 0; iCell < rowParagraph.Cells.Length; iCell++) { CellParagraph cellParagraph = rowParagraph.Cells[iCell]; if (cellParagraph.ParagraphEndCharacterPosition < startPosition || !cellParagraph.InvalidateStructure(startPosition)) { isEntireTableInvalid = false; } } return(isEntireTableInvalid); }
// ------------------------------------------------------------------ // Invalidate content's structural cache. // // startPosition - Position to start invalidation from. // // Returns: 'true' if entire paragraph is invalid. // ------------------------------------------------------------------ internal override bool InvalidateStructure(int startPosition) { bool isEntireTableInvalid = true; RowParagraph currentParagraph = _firstChild as RowParagraph; while (currentParagraph != null) { if (!InvalidateRowStructure(currentParagraph, startPosition)) { isEntireTableInvalid = false; } currentParagraph = currentParagraph.Next as RowParagraph; } return(isEntireTableInvalid); }
// 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: 0x06006A29 RID: 27177 RVA: 0x001E3AFC File Offset: 0x001E1CFC private CellParagraph FindCellParagraphForCell(RowParagraph previousRow, TableCell cell) { for (int i = 0; i < this._cellParagraphs.Length; i++) { if (this._cellParagraphs[i].Cell == cell) { return(this._cellParagraphs[i]); } } if (previousRow != null) { for (int j = 0; j < previousRow._spannedCells.Length; j++) { if (previousRow._spannedCells[j].Cell == cell) { return(previousRow._spannedCells[j]); } } } Invariant.Assert(false, "Structural integrity for table not correct."); return(null); }
/// <summary> /// GetFirstRow /// </summary> /// <param name="fFound">Indication that first body row is found</param> /// <param name="pnmFirstRow">First body row name</param> internal void GetFirstRow( out int fFound, out IntPtr pnmFirstRow) { if (_firstChild == null) { TableRow tableRow = null; for (int rowGroupIndex = 0; rowGroupIndex < Table.RowGroups.Count && tableRow == null; rowGroupIndex++) { TableRowGroup rowGroup = Table.RowGroups[rowGroupIndex]; if (rowGroup.Rows.Count > 0) { tableRow = rowGroup.Rows[0]; Invariant.Assert(tableRow.Index != -1); } } if (tableRow != null) { _firstChild = new RowParagraph(tableRow, StructuralCache); ((RowParagraph)_firstChild).CalculateRowSpans(); } } if (_firstChild != null) { fFound = PTS.True; pnmFirstRow = _firstChild.Handle; } else { fFound = PTS.False; pnmFirstRow = IntPtr.Zero; } }
//------------------------------------------------------ // // Private Methods // //------------------------------------------------------ #region Private Methods /// <summary> /// Helper method to scan our cell list for a cell paragraph, and if not found, look at the spanning cell paragraphs /// from previous row, if one exists. /// </summary> private CellParagraph FindCellParagraphForCell(RowParagraph previousRow, TableCell cell) { for (int index = 0; index < _cellParagraphs.Length; index++) { if (_cellParagraphs[index].Cell == cell) { return(_cellParagraphs[index]); } } if (previousRow != null) { for (int index = 0; index < previousRow._spannedCells.Length; index++) { if (previousRow._spannedCells[index].Cell == cell) { return(previousRow._spannedCells[index]); } } } Invariant.Assert(false, "Structural integrity for table not correct."); return(null); }
//------------------------------------------------------------------- // // Constructors // //------------------------------------------------------------------- #region Constructors /// <summary> /// Constructor. /// </summary> /// <param name="paraClient">Object representing a paragraph.</param> /// <param name="index">Index of row in paragraph.</param> /// <param name="rowRect">Rectangle of row - as rendered.</param> /// <param name="rowParagraph">Actual paragraph result is bound to.</param> internal RowParagraphResult(BaseParaClient paraClient, int index, Rect rowRect, RowParagraph rowParagraph) : base(paraClient, rowRect, rowParagraph.Element) { _index = index; }
/// <summary> /// GetFirstRow /// </summary> /// <param name="fFound">Indication that first body row is found</param> /// <param name="pnmFirstRow">First body row name</param> internal void GetFirstRow( out int fFound, out IntPtr pnmFirstRow) { if(_firstChild == null) { TableRow tableRow = null; for(int rowGroupIndex = 0; rowGroupIndex < Table.RowGroups.Count && tableRow == null; rowGroupIndex++) { TableRowGroup rowGroup = Table.RowGroups[rowGroupIndex]; if(rowGroup.Rows.Count > 0) { tableRow = rowGroup.Rows[0]; Invariant.Assert(tableRow.Index != -1); } } if(tableRow != null) { _firstChild = new RowParagraph(tableRow, StructuralCache); ((RowParagraph)_firstChild).CalculateRowSpans(); } } if(_firstChild != null) { fFound = PTS.True; pnmFirstRow = _firstChild.Handle; } else { fFound = PTS.False; pnmFirstRow = IntPtr.Zero; } }
/// <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; } }
//------------------------------------------------------ // // Private methods // //------------------------------------------------------ #region Private Methods // ------------------------------------------------------------------ // Invalidate accumulated format caches for the row. // ------------------------------------------------------------------ private bool InvalidateRowStructure(RowParagraph rowParagraph, int startPosition) { bool isEntireTableInvalid = true; for(int iCell = 0; iCell < rowParagraph.Cells.Length; iCell++) { CellParagraph cellParagraph = rowParagraph.Cells[iCell]; if(cellParagraph.ParagraphEndCharacterPosition < startPosition || !cellParagraph.InvalidateStructure(startPosition)) { isEntireTableInvalid = false; } } return isEntireTableInvalid; }
// ------------------------------------------------------------------ // Invalidate accumulated format caches for the row. // ------------------------------------------------------------------ private void InvalidateRowFormatCache(RowParagraph rowParagraph) { for(int iCell = 0; iCell < rowParagraph.Cells.Length; iCell++) { rowParagraph.Cells[iCell].InvalidateFormatCache(); } }
//------------------------------------------------------ // // Private Methods // //------------------------------------------------------ #region Private Methods /// <summary> /// Helper method to scan our cell list for a cell paragraph, and if not found, look at the spanning cell paragraphs /// from previous row, if one exists. /// </summary> private CellParagraph FindCellParagraphForCell(RowParagraph previousRow, TableCell cell) { for(int index = 0; index < _cellParagraphs.Length; index++) { if(_cellParagraphs[index].Cell == cell) { return _cellParagraphs[index]; } } if(previousRow != null) { for(int index = 0; index < previousRow._spannedCells.Length; index++) { if(previousRow._spannedCells[index].Cell == cell) { return previousRow._spannedCells[index]; } } } Invariant.Assert(false, "Structural integrity for table not correct."); return null; }
/// <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; } }