layout/tables/nsCellMap.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either of the GNU General Public License Version 2 or later (the "GPL"),
  26  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37 #ifndef nsCellMap_h__
  38 #define nsCellMap_h__
  39
  40 #include "nscore.h"
  41 #include "celldata.h"
  42 #include "nsTArray.h"
  43 #include "nsTPtrArray.h"
  44 #include "nsRect.h"
  45 #include "nsCOMPtr.h"
  46 #include "nsAlgorithm.h"
  47 #include "nsAutoPtr.h"
  48
  49 #undef DEBUG_TABLE_CELLMAP
  50
  51 class nsTableColFrame;
  52 class nsTableCellFrame;
  53 class nsTableRowFrame;
  54 class nsTableRowGroupFrame;
  55 class nsTableFrame;
  56 class nsCellMap;
  57 class nsPresContext;
  58 class nsCellMapColumnIterator;
  59
  60 struct nsColInfo
  61 {
  62   PRInt32 mNumCellsOrig; // number of cells originating in the col
  63   PRInt32 mNumCellsSpan; // number of cells spanning into the col via colspans (not rowspans)
  64
  65   nsColInfo();
  66   nsColInfo(PRInt32 aNumCellsOrig,
  67             PRInt32 aNumCellsSpan);
  68 };
  69
  70 enum Corner
  71 {
  72   eTopLeft     = 0,
  73   eTopRight    = 1,
  74   eBottomRight = 2,
  75   eBottomLeft  = 3
  76 };
  77
  78 struct BCInfo
  79 {
  80   nsTArray<BCData> mRightBorders;
  81   nsTArray<BCData> mBottomBorders;
  82   BCData           mLowerRightCorner;
  83 };
  84
  85 class nsTableCellMap
  86 {
  87 public:
  88   nsTableCellMap(nsTableFrame&   aTableFrame,
  89                  PRBool          aBorderCollapse);
  90
  91   /** destructor
  92     * NOT VIRTUAL BECAUSE THIS CLASS SHOULD **NEVER** BE SUBCLASSED
  93     */
  94   ~nsTableCellMap();
  95
  96   void RemoveGroupCellMap(nsTableRowGroupFrame* aRowGroup);
  97
  98   void InsertGroupCellMap(nsTableRowGroupFrame*  aNewRowGroup,
  99                           nsTableRowGroupFrame*& aPrevRowGroup);
 100
 101   /**
 102    * Get the nsCellMap for the given row group.  If aStartHint is non-null,
 103    * will start looking with that cellmap and only fall back to starting at the
 104    * beginning of the list if that doesn't find us the right nsCellMap.
 105    * Otherwise, just start at the beginning.
 106    *
 107    * aRowGroup must not be null.
 108    */
 109   nsCellMap* GetMapFor(const nsTableRowGroupFrame* aRowGroup,
 110                        nsCellMap* aStartHint) const;
 111
 112   /** synchronize the cellmaps with the rowgroups again **/
 113   void Synchronize(nsTableFrame* aTableFrame);
 114
 115   nsTableCellFrame* GetCellFrame(PRInt32   aRowIndex,
 116                                  PRInt32   aColIndex,
 117                                  CellData& aData,
 118                                  PRBool    aUseRowIfOverlap) const;
 119
 120   /** return the CellData for the cell at (aRowIndex, aColIndex) */
 121   CellData* GetDataAt(PRInt32 aRowIndex,
 122                       PRInt32 aColIndex) const;
 123
 124   // this function creates a col if needed
 125   nsColInfo* GetColInfoAt(PRInt32 aColIndex);
 126
 127   /** append the cellFrame at the end of the row at aRowIndex and return the col index
 128     */
 129   CellData* AppendCell(nsTableCellFrame&     aCellFrame,
 130                        PRInt32               aRowIndex,
 131                        PRBool                aRebuildIfNecessary,
 132                        nsRect&               aDamageArea);
 133
 134   void InsertCells(nsTArray<nsTableCellFrame*>& aCellFrames,
 135                    PRInt32                      aRowIndex,
 136                    PRInt32                      aColIndexBefore,
 137                    nsRect&                      aDamageArea);
 138
 139   void RemoveCell(nsTableCellFrame* aCellFrame,
 140                   PRInt32           aRowIndex,
 141                   nsRect&           aDamageArea);
 142   /** Remove the previously gathered column information */
 143   void ClearCols();
 144   void InsertRows(nsTableRowGroupFrame*       aRowGroup,
 145                   nsTArray<nsTableRowFrame*>& aRows,
 146                   PRInt32                     aFirstRowIndex,
 147                   PRBool                      aConsiderSpans,
 148                   nsRect&                     aDamageArea);
 149
 150   void RemoveRows(PRInt32         aFirstRowIndex,
 151                   PRInt32         aNumRowsToRemove,
 152                   PRBool          aConsiderSpans,
 153                   nsRect&               aDamageArea);
 154
 155   PRInt32 GetNumCellsOriginatingInRow(PRInt32 aRowIndex) const;
 156   PRInt32 GetNumCellsOriginatingInCol(PRInt32 aColIndex) const;
 157
 158   /** indicate whether the row has more than one cell that either originates
 159     * or is spanned from the rows above
 160     */
 161   PRBool HasMoreThanOneCell(PRInt32 aRowIndex) const;
 162
 163   PRInt32 GetEffectiveRowSpan(PRInt32 aRowIndex,
 164                               PRInt32 aColIndex) const;
 165   PRInt32 GetEffectiveColSpan(PRInt32 aRowIndex,
 166                               PRInt32 aColIndex) const;
 167
 168   /** return the total number of columns in the table represented by this CellMap */
 169   PRInt32 GetColCount() const;
 170
 171   /** return the actual number of rows in the table represented by this CellMap */
 172   PRInt32 GetRowCount() const;
 173
 174   nsTableCellFrame* GetCellInfoAt(PRInt32  aRowX,
 175                                   PRInt32  aColX,
 176                                   PRBool*  aOriginates = nsnull,
 177                                   PRInt32* aColSpan = nsnull) const;
 178
 179   /**
 180    * Returns the index at the given row and column coordinates.
 181    *
 182    * @see  nsITableLayout::GetIndexByRowAndColumn()
 183    *
 184    * @param aRow     [in] the row coordinate
 185    * @param aColumn  [in] the column coordinate
 186    * @returns             the index for the cell
 187    */
 188   PRInt32 GetIndexByRowAndColumn(PRInt32 aRow, PRInt32 aColumn) const;
 189
 190   /**
 191    * Retrieves the row and column coordinates for the given index.
 192    *
 193    * @see  nsITableLayout::GetRowAndColumnByIndex()
 194    *
 195    * @param aIndex  [in] the index for which coordinates are to be retrieved
 196    * @param aRow    [out] the row coordinate to be returned
 197    * @param aColumn [out] the column coordinate to be returned
 198    */
 199   void GetRowAndColumnByIndex(PRInt32 aIndex,
 200                               PRInt32 *aRow, PRInt32 *aColumn) const;
 201
 202   void AddColsAtEnd(PRUint32 aNumCols);
 203   void RemoveColsAtEnd();
 204
 205   PRBool RowIsSpannedInto(PRInt32 aRowIndex, PRInt32 aNumEffCols) const;
 206   PRBool RowHasSpanningCells(PRInt32 aRowIndex, PRInt32 aNumEffCols) const;
 207   void RebuildConsideringCells(nsCellMap*                   aCellMap,
 208                                nsTArray<nsTableCellFrame*>* aCellFrames,
 209                                PRInt32                      aRowIndex,
 210                                PRInt32                      aColIndex,
 211                                PRBool                       aInsert,
 212                                nsRect&                      aDamageArea);
 213
 214 protected:
 215   /**
 216    * Rebuild due to rows being inserted or deleted with cells spanning
 217    * into or out of the rows.  This function can only handle insertion
 218    * or deletion but NOT both.  So either aRowsToInsert must be null
 219    * or aNumRowsToRemove must be 0.
 220    *
 221    * // XXXbz are both allowed to happen?  That'd be a no-op...
 222    */
 223   void RebuildConsideringRows(nsCellMap*                  aCellMap,
 224                               PRInt32                     aStartRowIndex,
 225                               nsTArray<nsTableRowFrame*>* aRowsToInsert,
 226                               PRInt32                     aNumRowsToRemove,
 227                               nsRect&                     aDamageArea);
 228
 229 public:
 230   void ExpandZeroColSpans();
 231
 232   void SetNotTopStart(PRUint8    aSide,
 233                       nsCellMap& aCellMap,
 234                       PRUint32   aYPos,
 235                       PRUint32   aXPos,
 236                       PRBool     aIsLowerRight = PR_FALSE);
 237
 238   void SetBCBorderEdge(mozilla::css::Side aEdge,
 239                        nsCellMap&    aCellMap,
 240                        PRUint32      aCellMapStart,
 241                        PRUint32      aYPos,
 242                        PRUint32      aXPos,
 243                        PRUint32      aLength,
 244                        BCBorderOwner aOwner,
 245                        nscoord       aSize,
 246                        PRBool        aChanged);
 247
 248   void SetBCBorderCorner(Corner      aCorner,
 249                          nsCellMap&  aCellMap,
 250                          PRUint32    aCellMapStart,
 251                          PRUint32    aYPos,
 252                          PRUint32    aXPos,
 253                          mozilla::css::Side aOwner,
 254                          nscoord     aSubSize,
 255                          PRBool      aBevel,
 256                          PRBool      aIsBottomRight = PR_FALSE);
 257
 258   /** dump a representation of the cell map to stdout for debugging */
 259 #ifdef NS_DEBUG
 260   void Dump(char* aString = nsnull) const;
 261 #endif
 262
 263 protected:
 264   BCData* GetRightMostBorder(PRInt32 aRowIndex);
 265   BCData* GetBottomMostBorder(PRInt32 aColIndex);
 266
 267   friend class nsCellMap;
 268   friend class BCMapCellIterator;
 269   friend class BCPaintBorderIterator;
 270   friend class nsCellMapColumnIterator;
 271
 272 /** Insert a row group cellmap after aPrevMap, if aPrefMap is null insert it
 273   * at the beginning, the ordering of the cellmap corresponds to the ordering of
 274   * rowgroups once OrderRowGroups has been called
 275   */
 276   void InsertGroupCellMap(nsCellMap* aPrevMap,
 277                           nsCellMap& aNewMap);
 278   void DeleteRightBottomBorders();
 279
 280   nsTableFrame&               mTableFrame;
 281   nsAutoTArray<nsColInfo, 8>  mCols;
 282   nsCellMap*                  mFirstMap;
 283   // border collapsing info
 284   BCInfo*                     mBCInfo;
 285 };
 286
 287 /** nsCellMap is a support class for nsTablePart.
 288   * It maintains an Rows x Columns grid onto which the cells of the table are mapped.
 289   * This makes processing of rowspan and colspan attributes much easier.
 290   * Each cell is represented by a CellData object.
 291   *
 292   * @see CellData
 293   * @see nsTableFrame::AddCellToMap
 294   * @see nsTableFrame::GrowCellMap
 295   * @see nsTableFrame::BuildCellIntoMap
 296   *
 297   * mRows is an array of rows.  Each row is an array of cells.  a cell
 298   * can be null.
 299   */
 300 class nsCellMap
 301 {
 302 public:
 303   /** constructor
 304     * @param aRowGroupFrame the row group frame this is a cellmap for
 305     * @param aIsBC whether the table is doing border-collapse
 306     */
 307   nsCellMap(nsTableRowGroupFrame* aRowGroupFrame, PRBool aIsBC);
 308
 309   /** destructor
 310     * NOT VIRTUAL BECAUSE THIS CLASS SHOULD **NEVER** BE SUBCLASSED
 311     */
 312   ~nsCellMap();
 313
 314   static nsresult Init();
 315   static void Shutdown();
 316
 317   nsCellMap* GetNextSibling() const;
 318   void SetNextSibling(nsCellMap* aSibling);
 319
 320   nsTableRowGroupFrame* GetRowGroup() const;
 321
 322   nsTableCellFrame* GetCellFrame(PRInt32   aRowIndex,
 323                                  PRInt32   aColIndex,
 324                                  CellData& aData,
 325                                  PRBool    aUseRowSpanIfOverlap) const;
 326
 327   /**
 328    * Returns highest cell index within the cell map.
 329    *
 330    * @param  aColCount  [in] the number of columns in the table
 331    */
 332   PRInt32 GetHighestIndex(PRInt32 aColCount);
 333
 334   /**
 335    * Returns the index of the given row and column coordinates.
 336    *
 337    * @see  nsITableLayout::GetIndexByRowAndColumn()
 338    *
 339    * @param aColCount    [in] the number of columns in the table
 340    * @param aRow         [in] the row coordinate
 341    * @param aColumn      [in] the column coordinate
 342    */
 343   PRInt32 GetIndexByRowAndColumn(PRInt32 aColCount,
 344                                  PRInt32 aRow, PRInt32 aColumn) const;
 345
 346   /**
 347    * Get the row and column coordinates at the given index.
 348    *
 349    * @see  nsITableLayout::GetRowAndColumnByIndex()
 350    *
 351    * @param aColCount  [in] the number of columns in the table
 352    * @param aIndex     [in] the index for which coordinates are to be retrieved
 353    * @param aRow       [out] the row coordinate to be returned
 354    * @param aColumn    [out] the column coordinate to be returned
 355    */
 356   void GetRowAndColumnByIndex(PRInt32 aColCount, PRInt32 aIndex,
 357                               PRInt32 *aRow, PRInt32 *aColumn) const;
 358
 359   /** append the cellFrame at an empty or dead cell or finally at the end of
 360     * the row at aRowIndex and return a pointer to the celldata entry in the
 361     * cellmap
 362     *
 363     * @param aMap               - reference to the table cell map
 364     * @param aCellFrame         - a pointer to the cellframe which will be appended
 365     *                             to the row
 366     * @param aRowIndex          - to this row the celldata entry will be added
 367     * @param aRebuildIfNecessay - if a cell spans into a row below it might be
 368     *                             necesserary to rebuild the cellmap as this rowspan
 369     *                             might overlap another cell.
 370     * @param aDamageArea        - area in cellmap coordinates which have been updated.
 371     * @param aColToBeginSearch  - if not null contains the column number where
 372     *                             the search for a empty or dead cell in the
 373     *                             row should start
 374     * @return                   - a pointer to the celldata entry inserted into
 375     *                             the cellmap
 376     */
 377   CellData* AppendCell(nsTableCellMap&   aMap,
 378                        nsTableCellFrame* aCellFrame,
 379                        PRInt32           aRowIndex,
 380                        PRBool            aRebuildIfNecessary,
 381                        nsRect&           aDamageArea,
 382                        PRInt32*          aBeginSearchAtCol = nsnull);
 383
 384   /** Function to be called when a cell is added at a location which is spanned
 385     * to by a zero colspan.  We handle this situation by collapsing the zero
 386     * colspan, since there is really no good way to deal with it (trying to
 387     * increase the number of columns to hold the new cell would just mean the
 388     * zero colspan needs to expand).
 389
 390     * @param aMap      - reference to the table cell map
 391     * @param aOrigData - zero colspanned cell that will be collapsed
 392     * @param aRowIndex - row where the first collision appears
 393     * @param aColIndex - column where the first collision appears
 394     **/
 395   void CollapseZeroColSpan(nsTableCellMap& aMap,
 396                            CellData*       aOrigData,
 397                            PRInt32         aRowIndex,
 398                            PRInt32         aColIndex);
 399
 400   void InsertCells(nsTableCellMap&              aMap,
 401                    nsTArray<nsTableCellFrame*>& aCellFrames,
 402                    PRInt32                      aRowIndex,
 403                    PRInt32                      aColIndexBefore,
 404                    nsRect&                      aDamageArea);
 405
 406   void RemoveCell(nsTableCellMap&   aMap,
 407                   nsTableCellFrame* aCellFrame,
 408                   PRInt32           aRowIndex,
 409                   nsRect&           aDamageArea);
 410
 411   void InsertRows(nsTableCellMap&             aMap,
 412                   nsTArray<nsTableRowFrame*>& aRows,
 413                   PRInt32                     aFirstRowIndex,
 414                   PRBool                      aConsiderSpans,
 415                   nsRect&                     aDamageArea);
 416
 417   void RemoveRows(nsTableCellMap& aMap,
 418                   PRInt32         aFirstRowIndex,
 419                   PRInt32         aNumRowsToRemove,
 420                   PRBool          aConsiderSpans,
 421                   nsRect&         aDamageArea);
 422
 423   PRInt32 GetNumCellsOriginatingInRow(PRInt32 aRowIndex) const;
 424   PRInt32 GetNumCellsOriginatingInCol(PRInt32 aColIndex) const;
 425
 426   /** return the number of rows in the table represented by this CellMap */
 427   PRInt32 GetRowCount(PRBool aConsiderDeadRowSpanRows = PR_FALSE) const;
 428
 429   nsTableCellFrame* GetCellInfoAt(const nsTableCellMap& aMap,
 430                                   PRInt32          aRowX,
 431                                   PRInt32          aColX,
 432                                   PRBool*          aOriginates = nsnull,
 433                                   PRInt32*         aColSpan = nsnull) const;
 434
 435   PRBool RowIsSpannedInto(PRInt32 aRowIndex,
 436                           PRInt32 aNumEffCols) const;
 437
 438   PRBool RowHasSpanningCells(PRInt32 aRowIndex,
 439                              PRInt32 aNumEffCols) const;
 440
 441   void ExpandZeroColSpans(nsTableCellMap& aMap);
 442
 443   /** indicate whether the row has more than one cell that either originates
 444    * or is spanned from the rows above
 445    */
 446   PRBool HasMoreThanOneCell(PRInt32 aRowIndex) const;
 447
 448   /* Get the rowspan for a cell starting at aRowIndex and aColIndex.
 449    * If aGetEffective is true the size will not exceed the last content based
 450    * row. Cells can have a specified rowspan that extends below the last
 451    * content based row. This is legitimate considering incr. reflow where the
 452    * content rows will arive later.
 453    */
 454   PRInt32 GetRowSpan(PRInt32 aRowIndex,
 455                      PRInt32 aColIndex,
 456                      PRBool  aGetEffective) const;
 457
 458   PRInt32 GetEffectiveColSpan(const nsTableCellMap& aMap,
 459                               PRInt32     aRowIndex,
 460                               PRInt32     aColIndex,
 461                               PRBool&     aIsZeroColSpan) const;
 462
 463   typedef nsTPtrArray<CellData> CellDataArray;
 464
 465   /** dump a representation of the cell map to stdout for debugging */
 466 #ifdef NS_DEBUG
 467   void Dump(PRBool aIsBorderCollapse) const;
 468 #endif
 469
 470 protected:
 471   friend class nsTableCellMap;
 472   friend class BCMapCellIterator;
 473   friend class BCPaintBorderIterator;
 474   friend class nsTableFrame;
 475   friend class nsCellMapColumnIterator;
 476
 477   /**
 478    * Increase the number of rows in this cellmap by aNumRows.  Put the
 479    * new rows at aRowIndex.  If aRowIndex is -1, put them at the end.
 480    */
 481   PRBool Grow(nsTableCellMap& aMap,
 482               PRInt32         aNumRows,
 483               PRInt32         aRowIndex = -1);
 484
 485   void GrowRow(CellDataArray& aRow,
 486                PRInt32        aNumCols);
 487
 488   /** assign aCellData to the cell at (aRow,aColumn) */
 489   void SetDataAt(nsTableCellMap& aMap,
 490                  CellData&       aCellData,
 491                  PRInt32         aMapRowIndex,
 492                  PRInt32         aColIndex);
 493
 494   CellData* GetDataAt(PRInt32         aMapRowIndex,
 495                       PRInt32         aColIndex) const;
 496
 497   PRInt32 GetNumCellsIn(PRInt32 aColIndex) const;
 498
 499   void ExpandWithRows(nsTableCellMap&             aMap,
 500                       nsTArray<nsTableRowFrame*>& aRowFrames,
 501                       PRInt32                     aStartRowIndex,
 502                       nsRect&                     aDamageArea);
 503
 504   void ExpandWithCells(nsTableCellMap&              aMap,
 505                        nsTArray<nsTableCellFrame*>& aCellFrames,
 506                        PRInt32                      aRowIndex,
 507                        PRInt32                      aColIndex,
 508                        PRInt32                      aRowSpan,
 509                        PRBool                       aRowSpanIsZero,
 510                        nsRect&                      aDamageArea);
 511
 512   void ShrinkWithoutRows(nsTableCellMap& aMap,
 513                          PRInt32         aFirstRowIndex,
 514                          PRInt32         aNumRowsToRemove,
 515                          nsRect&         aDamageArea);
 516
 517   void ShrinkWithoutCell(nsTableCellMap&   aMap,
 518                          nsTableCellFrame& aCellFrame,
 519                          PRInt32           aRowIndex,
 520                          PRInt32           aColIndex,
 521                          nsRect&           aDamageArea);
 522
 523   /**
 524    * Rebuild due to rows being inserted or deleted with cells spanning
 525    * into or out of the rows.  This function can only handle insertion
 526    * or deletion but NOT both.  So either aRowsToInsert must be null
 527    * or aNumRowsToRemove must be 0.
 528    *
 529    * // XXXbz are both allowed to happen?  That'd be a no-op...
 530    */
 531   void RebuildConsideringRows(nsTableCellMap&             aMap,
 532                               PRInt32                     aStartRowIndex,
 533                               nsTArray<nsTableRowFrame*>* aRowsToInsert,
 534                               PRInt32                     aNumRowsToRemove,
 535                               nsRect&                     aDamageArea);
 536
 537   void RebuildConsideringCells(nsTableCellMap&              aMap,
 538                                PRInt32                      aNumOrigCols,
 539                                nsTArray<nsTableCellFrame*>* aCellFrames,
 540                                PRInt32                      aRowIndex,
 541                                PRInt32                      aColIndex,
 542                                PRBool                       aInsert,
 543                                nsRect&                      aDamageArea);
 544
 545   PRBool CellsSpanOut(nsTArray<nsTableRowFrame*>& aNewRows) const;
 546
 547   /** If a cell spans out of the area defined by aStartRowIndex, aEndRowIndex
 548     * and aStartColIndex, aEndColIndex the cellmap changes are more severe so
 549     * the corresponding routines needs to be called. This is also necessary if
 550     * cells outside spans into this region.
 551     * @aStartRowIndex       - y start index
 552     * @aEndRowIndex         - y end index
 553     * @param aStartColIndex - x start index
 554     * @param aEndColIndex   - x end index
 555     * @return               - true if a cell span crosses the border of the
 556                               region
 557     */
 558   PRBool CellsSpanInOrOut(PRInt32 aStartRowIndex,
 559                           PRInt32 aEndRowIndex,
 560                           PRInt32 aStartColIndex,
 561                           PRInt32 aEndColIndex) const;
 562
 563   void ExpandForZeroSpan(nsTableCellFrame* aCellFrame,
 564                          PRInt32           aNumColsInTable);
 565
 566   PRBool CreateEmptyRow(PRInt32 aRowIndex,
 567                         PRInt32 aNumCols);
 568
 569   PRInt32 GetRowSpanForNewCell(nsTableCellFrame* aCellFrameToAdd,
 570                                PRInt32           aRowIndex,
 571                                PRBool&           aIsZeroRowSpan) const;
 572
 573   PRInt32 GetColSpanForNewCell(nsTableCellFrame& aCellFrameToAdd,
 574                                PRBool&           aIsZeroColSpan) const;
 575
 576   // Destroy a CellData struct.  This will handle the case of aData
 577   // actually being a BCCellData properly.
 578   void DestroyCellData(CellData* aData);
 579   // Allocate a CellData struct.  This will handle needing to create a
 580   // BCCellData properly.
 581   // @param aOrigCell the originating cell to pass to the celldata constructor
 582   CellData* AllocCellData(nsTableCellFrame* aOrigCell);
 583
 584   /** an array containing, for each row, the CellDatas for the cells
 585     * in that row.  It can be larger than mContentRowCount due to row spans
 586     * extending beyond the table */
 587   // XXXbz once we have auto TArrays, we should probably use them here.
 588   nsTArray<CellDataArray> mRows;
 589
 590   /** the number of rows in the table (content) which is not indentical to the
 591     * number of rows in the cell map due to row spans extending beyond the end
 592     * of thetable (dead rows) or empty tr tags
 593     */
 594   PRInt32 mContentRowCount;
 595
 596   // the row group that corresponds to this map
 597   nsTableRowGroupFrame* mRowGroupFrame;
 598
 599   // the next row group cell map
 600   nsCellMap* mNextSibling;
 601
 602   // Whether this is a BC cellmap or not
 603   PRBool mIsBC;
 604
 605   // Prescontext to deallocate and allocate celldata
 606   nsRefPtr<nsPresContext> mPresContext;
 607 };
 608
 609 /**
 610  * A class for iterating the cells in a given column.  Must be given a
 611  * non-null nsTableCellMap and a column number valid for that cellmap.
 612  */
 613 class nsCellMapColumnIterator
 614 {
 615 public:
 616   nsCellMapColumnIterator(const nsTableCellMap* aMap, PRInt32 aCol) :
 617     mMap(aMap), mCurMap(aMap->mFirstMap), mCurMapStart(0),
 618     mCurMapRow(0), mCol(aCol), mFoundCells(0)
 619   {
 620     NS_PRECONDITION(aMap, "Must have map");
 621     NS_PRECONDITION(mCol < aMap->GetColCount(), "Invalid column");
 622     mOrigCells = aMap->GetNumCellsOriginatingInCol(mCol);
 623     if (mCurMap) {
 624       mCurMapContentRowCount = mCurMap->GetRowCount();
 625       PRUint32 rowArrayLength = mCurMap->mRows.Length();
 626       mCurMapRelevantRowCount = NS_MIN(mCurMapContentRowCount, rowArrayLength);
 627       if (mCurMapRelevantRowCount == 0 && mOrigCells > 0) {
 628         // This row group is useless; advance!
 629         AdvanceRowGroup();
 630       }
 631     }
 632 #ifdef DEBUG
 633     else {
 634       NS_ASSERTION(mOrigCells == 0, "Why no rowgroups?");
 635     }
 636 #endif
 637   }
 638
 639   nsTableCellFrame* GetNextFrame(PRInt32* aRow, PRInt32* aColSpan);
 640
 641 private:
 642   void AdvanceRowGroup();
 643
 644   // Advance the row; aIncrement is considered to be a cell's rowspan,
 645   // so if 0 is passed in we'll advance to the next rowgroup.
 646   void IncrementRow(PRInt32 aIncrement);
 647
 648   const nsTableCellMap* mMap;
 649   const nsCellMap* mCurMap;
 650
 651   // mCurMapStart is the row in the entire nsTableCellMap where
 652   // mCurMap starts.  This is used to compute row indices to pass to
 653   // nsTableCellMap::GetDataAt, so must be a _content_ row index.
 654   PRUint32 mCurMapStart;
 655
 656   // In steady-state mCurMapRow is the row in our current nsCellMap
 657   // that we'll use the next time GetNextFrame() is called.  Due to
 658   // the way we skip over rowspans, the entry in mCurMapRow and mCol
 659   // is either null, dead, originating, or a colspan.  In particular,
 660   // it cannot be a rowspan or overlap entry.
 661   PRUint32 mCurMapRow;
 662   const PRInt32 mCol;
 663   PRUint32 mOrigCells;
 664   PRUint32 mFoundCells;
 665
 666   // The number of content rows in mCurMap.  This may be bigger than the number
 667   // of "relevant" rows, or it might be smaller.
 668   PRUint32 mCurMapContentRowCount;
 669
 670   // The number of "relevant" rows in mCurMap.  That is, the number of rows
 671   // which might have an originating cell in them.  Once mCurMapRow reaches
 672   // mCurMapRelevantRowCount, we should move to the next map.
 673   PRUint32 mCurMapRelevantRowCount;
 674 };
 675
 676
 677 /* ----- inline methods ----- */
 678 inline PRInt32 nsTableCellMap::GetColCount() const
 679 {
 680   return mCols.Length();
 681 }
 682
 683 inline nsCellMap* nsCellMap::GetNextSibling() const
 684 {
 685   return mNextSibling;
 686 }
 687
 688 inline void nsCellMap::SetNextSibling(nsCellMap* aSibling)
 689 {
 690   mNextSibling = aSibling;
 691 }
 692
 693 inline nsTableRowGroupFrame* nsCellMap::GetRowGroup() const
 694 {
 695   return mRowGroupFrame;
 696 }
 697
 698 inline PRInt32 nsCellMap::GetRowCount(PRBool aConsiderDeadRowSpanRows) const
 699 {
 700   PRInt32 rowCount = (aConsiderDeadRowSpanRows) ? mRows.Length() : mContentRowCount;
 701   return rowCount;
 702 }
 703
 704 // nsColInfo
 705
 706 inline nsColInfo::nsColInfo()
 707  :mNumCellsOrig(0), mNumCellsSpan(0)
 708 {}
 709
 710 inline nsColInfo::nsColInfo(PRInt32 aNumCellsOrig,
 711                             PRInt32 aNumCellsSpan)
 712  :mNumCellsOrig(aNumCellsOrig), mNumCellsSpan(aNumCellsSpan)
 713 {}
 714
 715
 716 #endif