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 "nsVoidArray.h"
  43 #include "nsTPtrArray.h"
  44 #include "nsRect.h"
  45 #include "nsCOMPtr.h"
  46
  47 #undef DEBUG_TABLE_CELLMAP
  48
  49 class nsTableColFrame;
  50 class nsTableCellFrame;
  51 class nsTableRowGroupFrame;
  52 class nsTableFrame;
  53 class nsCellMap;
  54 class nsPresContext;
  55 class nsCellMapColumnIterator;
  56
  57 struct nsColInfo
  58 {
  59   PRInt32 mNumCellsOrig; // number of cells originating in the col
  60   PRInt32 mNumCellsSpan; // number of cells spanning into the col via colspans (not rowspans)
  61
  62   nsColInfo();
  63   nsColInfo(PRInt32 aNumCellsOrig,
  64             PRInt32 aNumCellsSpan);
  65 };
  66
  67 enum Corner
  68 {
  69   eTopLeft     = 0,
  70   eTopRight    = 1,
  71   eBottomRight = 2,
  72   eBottomLeft  = 3
  73 };
  74
  75 struct BCInfo
  76 {
  77   nsVoidArray mRightBorders;
  78   nsVoidArray mBottomBorders;
  79   BCData      mLowerRightCorner;
  80 };
  81
  82 class nsTableCellMap
  83 {
  84 public:
  85   nsTableCellMap(nsTableFrame&   aTableFrame,
  86                  PRBool          aBorderCollapse);
  87
  88   /** destructor
  89     * NOT VIRTUAL BECAUSE THIS CLASS SHOULD **NEVER** BE SUBCLASSED
  90     */
  91   ~nsTableCellMap();
  92
  93   void RemoveGroupCellMap(nsTableRowGroupFrame* aRowGroup);
  94
  95   void InsertGroupCellMap(nsTableRowGroupFrame&  aNewRowGroup,
  96                           nsTableRowGroupFrame*& aPrevRowGroup);
  97
  98   /**
  99    * Get the nsCellMap for the given row group.  If aStartHint is non-null,
 100    * will start looking with that cellmap and only fall back to starting at the
 101    * beginning of the list if that doesn't find us the right nsCellMap.
 102    * Otherwise, just start at the beginning.
 103    *
 104    * aRowGroup must not be null.
 105    */
 106   nsCellMap* GetMapFor(const nsTableRowGroupFrame* aRowGroup,
 107                        nsCellMap* aStartHint) const;
 108
 109   /** synchronize the cellmaps with the rowgroups again **/
 110   void Synchronize(nsTableFrame* aTableFrame);
 111
 112   nsTableCellFrame* GetCellFrame(PRInt32   aRowIndex,
 113                                  PRInt32   aColIndex,
 114                                  CellData& aData,
 115                                  PRBool    aUseRowIfOverlap) const;
 116
 117   /** return the CellData for the cell at (aRowIndex, aColIndex) */
 118   CellData* GetDataAt(PRInt32 aRowIndex,
 119                       PRInt32 aColIndex) const;
 120
 121   // this function creates a col if needed
 122   nsColInfo* GetColInfoAt(PRInt32 aColIndex);
 123
 124   /** append the cellFrame at the end of the row at aRowIndex and return the col index
 125     */
 126   CellData* AppendCell(nsTableCellFrame&     aCellFrame,
 127                        PRInt32               aRowIndex,
 128                        PRBool                aRebuildIfNecessary,
 129                        nsRect&               aDamageArea);
 130
 131   void InsertCells(nsVoidArray&          aCellFrames,
 132                    PRInt32               aRowIndex,
 133                    PRInt32               aColIndexBefore,
 134                    nsRect&               aDamageArea);
 135
 136   void RemoveCell(nsTableCellFrame* aCellFrame,
 137                   PRInt32           aRowIndex,
 138                   nsRect&           aDamageArea);
 139   /** Remove the previously gathered column information */
 140   void ClearCols();
 141   void InsertRows(nsTableRowGroupFrame& aRowGroup,
 142                   nsVoidArray&          aRows,
 143                   PRInt32               aFirstRowIndex,
 144                   PRBool                aConsiderSpans,
 145                   nsRect&               aDamageArea);
 146
 147   void RemoveRows(PRInt32         aFirstRowIndex,
 148                   PRInt32         aNumRowsToRemove,
 149                   PRBool          aConsiderSpans,
 150                   nsRect&               aDamageArea);
 151
 152   PRInt32 GetNumCellsOriginatingInRow(PRInt32 aRowIndex) const;
 153   PRInt32 GetNumCellsOriginatingInCol(PRInt32 aColIndex) const;
 154
 155   /** indicate whether the row has more than one cell that either originates
 156     * or is spanned from the rows above
 157     */
 158   PRBool HasMoreThanOneCell(PRInt32 aRowIndex) const;
 159
 160   PRInt32 GetEffectiveRowSpan(PRInt32 aRowIndex,
 161                               PRInt32 aColIndex) const;
 162   PRInt32 GetEffectiveColSpan(PRInt32 aRowIndex,
 163                               PRInt32 aColIndex) const;
 164
 165   /** return the total number of columns in the table represented by this CellMap */
 166   PRInt32 GetColCount() const;
 167
 168   /** return the actual number of rows in the table represented by this CellMap */
 169   PRInt32 GetRowCount() const;
 170
 171   nsTableCellFrame* GetCellInfoAt(PRInt32  aRowX,
 172                                   PRInt32  aColX,
 173                                   PRBool*  aOriginates = nsnull,
 174                                   PRInt32* aColSpan = nsnull) const;
 175
 176   /**
 177    * Returns the index at the given row and column coordinates.
 178    *
 179    * @see  nsITableLayout::GetIndexByRowAndColumn()
 180    *
 181    * @param aRow     [in] the row coordinate
 182    * @param aColumn  [in] the column coordinate
 183    * @returns             the index for the cell
 184    */
 185   PRInt32 GetIndexByRowAndColumn(PRInt32 aRow, PRInt32 aColumn) const;
 186
 187   /**
 188    * Retrieves the row and column coordinates for the given index.
 189    *
 190    * @see  nsITableLayout::GetRowAndColumnByIndex()
 191    *
 192    * @param aIndex  [in] the index for which coordinates are to be retrieved
 193    * @param aRow    [out] the row coordinate to be returned
 194    * @param aColumn [out] the column coordinate to be returned
 195    */
 196   void GetRowAndColumnByIndex(PRInt32 aIndex,
 197                               PRInt32 *aRow, PRInt32 *aColumn) const;
 198
 199   void AddColsAtEnd(PRUint32 aNumCols);
 200   void RemoveColsAtEnd();
 201
 202   PRBool RowIsSpannedInto(PRInt32 aRowIndex, PRInt32 aNumEffCols) const;
 203   PRBool RowHasSpanningCells(PRInt32 aRowIndex, PRInt32 aNumEffCols) const;
 204   void RebuildConsideringCells(nsCellMap*      aCellMap,
 205                                nsVoidArray*    aCellFrames,
 206                                PRInt32         aRowIndex,
 207                                PRInt32         aColIndex,
 208                                PRBool          aInsert,
 209                                nsRect&         aDamageArea);
 210
 211 protected:
 212   /**
 213    * Rebuild due to rows being inserted or deleted with cells spanning
 214    * into or out of the rows.  This function can only handle insertion
 215    * or deletion but NOT both.  So either aRowsToInsert must be null
 216    * or aNumRowsToRemove must be 0.
 217    *
 218    * // XXXbz are both allowed to happen?  That'd be a no-op...
 219    */
 220   void RebuildConsideringRows(nsCellMap*      aCellMap,
 221                               PRInt32         aStartRowIndex,
 222                               nsVoidArray*    aRowsToInsert,
 223                               PRInt32         aNumRowsToRemove,
 224                               nsRect&         aDamageArea);
 225
 226 public:
 227   PRBool ColIsSpannedInto(PRInt32 aColIndex) const;
 228   PRBool ColHasSpanningCells(PRInt32 aColIndex) const;
 229
 230   void ExpandZeroColSpans();
 231
 232   BCData* GetBCData(PRUint8     aSide,
 233                     nsCellMap&  aCellMap,
 234                     PRUint32    aYPos,
 235                     PRUint32    aXPos,
 236                     PRBool      aIsLowerRight = PR_FALSE);
 237
 238   void SetBCBorderEdge(PRUint8       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                          PRUint8     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 BCMapBorderIterator;
 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   nsAutoVoidArray 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 the index of the given row and column coordinates.
 329    *
 330    * @see  nsITableLayout::GetIndexByRowAndColumn()
 331    *
 332    * @param aColCount  [in] the number of columns in a row
 333    * @param aRow       [in] the row coordinate
 334    * @param aColumn    [in] the column coordinate
 335    */
 336   PRInt32 GetIndexByRowAndColumn(PRInt32 aColCount,
 337                                  PRInt32 aRow, PRInt32 aColumn) const;
 338
 339   /**
 340    * Get the row and column coordinates at the given index.
 341    *
 342    * @see  nsITableLayout::GetRowAndColumnByIndex()
 343    *
 344    * @param aColCount  [in] the number of columns in a row
 345    * @param aIndex     [in] the index for which coordinates are to be retrieved
 346    * @param aRow       [out] the row coordinate to be returned
 347    * @param aColumn    [out] the column coordinate to be returned
 348    */
 349   void GetRowAndColumnByIndex(PRInt32 aColCount, PRInt32 aIndex,
 350                               PRInt32 *aRow, PRInt32 *aColumn) const;
 351
 352   /** append the cellFrame at an empty or dead cell or finally at the end of
 353     * the row at aRowIndex and return a pointer to the celldata entry in the
 354     * cellmap
 355     *
 356     * @param aMap               - reference to the table cell map
 357     * @param aCellFrame         - a pointer to the cellframe which will be appended
 358     *                             to the row
 359     * @param aRowIndex          - to this row the celldata entry will be added
 360     * @param aRebuildIfNecessay - if a cell spans into a row below it might be
 361     *                             necesserary to rebuild the cellmap as this rowspan
 362     *                             might overlap another cell.
 363     * @param aDamageArea        - area in cellmap coordinates which have been updated.
 364     * @param aColToBeginSearch  - if not null contains the column number where
 365     *                             the search for a empty or dead cell in the
 366     *                             row should start
 367     * @return                   - a pointer to the celldata entry inserted into
 368     *                             the cellmap
 369     */
 370   CellData* AppendCell(nsTableCellMap&   aMap,
 371                        nsTableCellFrame* aCellFrame,
 372                        PRInt32           aRowIndex,
 373                        PRBool            aRebuildIfNecessary,
 374                        nsRect&           aDamageArea,
 375                        PRInt32*          aBeginSearchAtCol = nsnull);
 376
 377   /** Function to be called when a cell is added at a location which is spanned
 378     * to by a zero colspan.  We handle this situation by collapsing the zero
 379     * colspan, since there is really no good way to deal with it (trying to
 380     * increase the number of columns to hold the new cell would just mean the
 381     * zero colspan needs to expand).
 382
 383     * @param aMap      - reference to the table cell map
 384     * @param aOrigData - zero colspanned cell that will be collapsed
 385     * @param aRowIndex - row where the first collision appears
 386     * @param aColIndex - column where the first collision appears
 387     **/
 388   void CollapseZeroColSpan(nsTableCellMap& aMap,
 389                            CellData*       aOrigData,
 390                            PRInt32         aRowIndex,
 391                            PRInt32         aColIndex);
 392
 393   void InsertCells(nsTableCellMap& aMap,
 394                    nsVoidArray&    aCellFrames,
 395                    PRInt32         aRowIndex,
 396                    PRInt32         aColIndexBefore,
 397                    nsRect&         aDamageArea);
 398
 399   void RemoveCell(nsTableCellMap&   aMap,
 400                   nsTableCellFrame* aCellFrame,
 401                   PRInt32           aRowIndex,
 402                   nsRect&           aDamageArea);
 403
 404   void InsertRows(nsTableCellMap& aMap,
 405                   nsVoidArray&    aRows,
 406                   PRInt32         aFirstRowIndex,
 407                   PRBool          aConsiderSpans,
 408                   nsRect&         aDamageArea);
 409
 410   void RemoveRows(nsTableCellMap& aMap,
 411                   PRInt32         aFirstRowIndex,
 412                   PRInt32         aNumRowsToRemove,
 413                   PRBool          aConsiderSpans,
 414                   nsRect&         aDamageArea);
 415
 416   PRInt32 GetNumCellsOriginatingInRow(PRInt32 aRowIndex) const;
 417   PRInt32 GetNumCellsOriginatingInCol(PRInt32 aColIndex) const;
 418
 419   /** return the number of rows in the table represented by this CellMap */
 420   PRInt32 GetRowCount(PRBool aConsiderDeadRowSpanRows = PR_FALSE) const;
 421
 422   nsTableCellFrame* GetCellInfoAt(const nsTableCellMap& aMap,
 423                                   PRInt32          aRowX,
 424                                   PRInt32          aColX,
 425                                   PRBool*          aOriginates = nsnull,
 426                                   PRInt32*         aColSpan = nsnull) const;
 427
 428   PRBool RowIsSpannedInto(PRInt32 aRowIndex,
 429                           PRInt32 aNumEffCols) const;
 430
 431   PRBool RowHasSpanningCells(PRInt32 aRowIndex,
 432                              PRInt32 aNumEffCols) const;
 433
 434   PRBool ColHasSpanningCells(PRInt32 aColIndex) const;
 435
 436   void ExpandZeroColSpans(nsTableCellMap& aMap);
 437
 438   /** indicate whether the row has more than one cell that either originates
 439    * or is spanned from the rows above
 440    */
 441   PRBool HasMoreThanOneCell(PRInt32 aRowIndex) const;
 442
 443   /* Get the rowspan for a cell starting at aRowIndex and aColIndex.
 444    * If aGetEffective is true the size will not exceed the last content based
 445    * row. Cells can have a specified rowspan that extends below the last
 446    * content based row. This is legitimate considering incr. reflow where the
 447    * content rows will arive later.
 448    */
 449   PRInt32 GetRowSpan(PRInt32 aRowIndex,
 450                      PRInt32 aColIndex,
 451                      PRBool  aGetEffective) const;
 452
 453   PRInt32 GetEffectiveColSpan(const nsTableCellMap& aMap,
 454                               PRInt32     aRowIndex,
 455                               PRInt32     aColIndex,
 456                               PRBool&     aIsZeroColSpan) const;
 457
 458   typedef nsTPtrArray<CellData> CellDataArray;
 459
 460   /** dump a representation of the cell map to stdout for debugging */
 461 #ifdef NS_DEBUG
 462   void Dump(PRBool aIsBorderCollapse) const;
 463 #endif
 464
 465 protected:
 466   friend class nsTableCellMap;
 467   friend class BCMapCellIterator;
 468   friend class BCMapBorderIterator;
 469   friend class nsTableFrame;
 470   friend class nsCellMapColumnIterator;
 471
 472   /**
 473    * Increase the number of rows in this cellmap by aNumRows.  Put the
 474    * new rows at aRowIndex.  If aRowIndex is -1, put them at the end.
 475    */
 476   PRBool Grow(nsTableCellMap& aMap,
 477               PRInt32         aNumRows,
 478               PRInt32         aRowIndex = -1);
 479
 480   void GrowRow(CellDataArray& aRow,
 481                PRInt32        aNumCols);
 482
 483   /** assign aCellData to the cell at (aRow,aColumn) */
 484   void SetDataAt(nsTableCellMap& aMap,
 485                  CellData&       aCellData,
 486                  PRInt32         aMapRowIndex,
 487                  PRInt32         aColIndex);
 488
 489   CellData* GetDataAt(PRInt32         aMapRowIndex,
 490                       PRInt32         aColIndex) const;
 491
 492   PRInt32 GetNumCellsIn(PRInt32 aColIndex) const;
 493
 494   void ExpandWithRows(nsTableCellMap& aMap,
 495                       nsVoidArray&    aRowFrames,
 496                       PRInt32         aStartRowIndex,
 497                       nsRect&         aDamageArea);
 498
 499   void ExpandWithCells(nsTableCellMap& aMap,
 500                        nsVoidArray&    aCellFrames,
 501                        PRInt32         aRowIndex,
 502                        PRInt32         aColIndex,
 503                        PRInt32         aRowSpan,
 504                        PRBool          aRowSpanIsZero,
 505                        nsRect&         aDamageArea);
 506
 507   void ShrinkWithoutRows(nsTableCellMap& aMap,
 508                          PRInt32         aFirstRowIndex,
 509                          PRInt32         aNumRowsToRemove,
 510                          nsRect&         aDamageArea);
 511
 512   void ShrinkWithoutCell(nsTableCellMap&   aMap,
 513                          nsTableCellFrame& aCellFrame,
 514                          PRInt32           aRowIndex,
 515                          PRInt32           aColIndex,
 516                          nsRect&           aDamageArea);
 517
 518   /**
 519    * Rebuild due to rows being inserted or deleted with cells spanning
 520    * into or out of the rows.  This function can only handle insertion
 521    * or deletion but NOT both.  So either aRowsToInsert must be null
 522    * or aNumRowsToRemove must be 0.
 523    *
 524    * // XXXbz are both allowed to happen?  That'd be a no-op...
 525    */
 526   void RebuildConsideringRows(nsTableCellMap& aMap,
 527                               PRInt32         aStartRowIndex,
 528                               nsVoidArray*    aRowsToInsert,
 529                               PRInt32         aNumRowsToRemove,
 530                               nsRect&         aDamageArea);
 531
 532   void RebuildConsideringCells(nsTableCellMap& aMap,
 533                                PRInt32         aNumOrigCols,
 534                                nsVoidArray*    aCellFrames,
 535                                PRInt32         aRowIndex,
 536                                PRInt32         aColIndex,
 537                                PRBool          aInsert,
 538                                nsRect&         aDamageArea);
 539
 540   PRBool CellsSpanOut(nsVoidArray&    aNewRows) const;
 541
 542   /** If a cell spans out of the area defined by aStartRowIndex, aEndRowIndex
 543     * and aStartColIndex, aEndColIndex the cellmap changes are more severe so
 544     * the corresponding routines needs to be called. This is also necessary if
 545     * cells outside spans into this region.
 546     * @aStartRowIndex       - y start index
 547     * @aEndRowIndex         - y end index
 548     * @param aStartColIndex - x start index
 549     * @param aEndColIndex   - x end index
 550     * @return               - true if a cell span crosses the border of the
 551                               region
 552     */
 553   PRBool CellsSpanInOrOut(PRInt32 aStartRowIndex,
 554                           PRInt32 aEndRowIndex,
 555                           PRInt32 aStartColIndex,
 556                           PRInt32 aEndColIndex) const;
 557
 558   void ExpandForZeroSpan(nsTableCellFrame* aCellFrame,
 559                          PRInt32           aNumColsInTable);
 560
 561   PRBool CreateEmptyRow(PRInt32 aRowIndex,
 562                         PRInt32 aNumCols);
 563
 564   PRInt32 GetRowSpanForNewCell(nsTableCellFrame* aCellFrameToAdd,
 565                                PRInt32           aRowIndex,
 566                                PRBool&           aIsZeroRowSpan) const;
 567
 568   PRInt32 GetColSpanForNewCell(nsTableCellFrame& aCellFrameToAdd,
 569                                PRBool&           aIsZeroColSpan) const;
 570
 571   PRBool IsZeroColSpan(PRInt32 aRowIndex,
 572                        PRInt32 aColIndex) const;
 573
 574   // Destroy a CellData struct.  This will handle the case of aData
 575   // actually being a BCCellData properly.
 576   void DestroyCellData(CellData* aData);
 577   // Allocate a CellData struct.  This will handle needing to create a
 578   // BCCellData properly.
 579   // @param aOrigCell the originating cell to pass to the celldata constructor
 580   CellData* AllocCellData(nsTableCellFrame* aOrigCell);
 581
 582   /** an array containing, for each row, the CellDatas for the cells
 583     * in that row.  It can be larger than mContentRowCount due to row spans
 584     * extending beyond the table */
 585   // XXXbz once we have auto TArrays, we should probably use them here.
 586   nsTArray<CellDataArray> mRows;
 587
 588   /** the number of rows in the table (content) which is not indentical to the
 589     * number of rows in the cell map due to row spans extending beyond the end
 590     * of thetable (dead rows) or empty tr tags
 591     */
 592   PRInt32 mContentRowCount;
 593
 594   // the row group that corresponds to this map
 595   nsTableRowGroupFrame* mRowGroupFrame;
 596
 597   // the next row group cell map
 598   nsCellMap* mNextSibling;
 599
 600   // Whether this is a BC cellmap or not
 601   PRBool mIsBC;
 602
 603   // Prescontext to deallocate and allocate celldata
 604   nsCOMPtr<nsPresContext> mPresContext;
 605 };
 606
 607 /**
 608  * A class for iterating the cells in a given column.  Must be given a
 609  * non-null nsTableCellMap and a column number valid for that cellmap.
 610  */
 611 class nsCellMapColumnIterator
 612 {
 613 public:
 614   nsCellMapColumnIterator(const nsTableCellMap* aMap, PRInt32 aCol) :
 615     mMap(aMap), mCurMap(aMap->mFirstMap), mCurMapStart(0),
 616     mCurMapRow(0), mCol(aCol), mFoundCells(0)
 617   {
 618     NS_PRECONDITION(aMap, "Must have map");
 619     NS_PRECONDITION(mCol < aMap->GetColCount(), "Invalid column");
 620     mOrigCells = aMap->GetNumCellsOriginatingInCol(mCol);
 621     if (mCurMap) {
 622       mCurMapContentRowCount = mCurMap->GetRowCount();
 623       PRUint32 rowArrayLength = mCurMap->mRows.Length();
 624       mCurMapRelevantRowCount = PR_MIN(mCurMapContentRowCount, rowArrayLength);
 625       if (mCurMapRelevantRowCount == 0 && mOrigCells > 0) {
 626         // This row group is useless; advance!
 627         AdvanceRowGroup();
 628       }
 629     }
 630 #ifdef DEBUG
 631     else {
 632       NS_ASSERTION(mOrigCells == 0, "Why no rowgroups?");
 633     }
 634 #endif
 635   }
 636
 637   nsTableCellFrame* GetNextFrame(PRInt32* aRow, PRInt32* aColSpan);
 638
 639 private:
 640   void AdvanceRowGroup();
 641
 642   // Advance the row; aIncrement is considered to be a cell's rowspan,
 643   // so if 0 is passed in we'll advance to the next rowgroup.
 644   void IncrementRow(PRInt32 aIncrement);
 645
 646   const nsTableCellMap* mMap;
 647   const nsCellMap* mCurMap;
 648
 649   // mCurMapStart is the row in the entire nsTableCellMap where
 650   // mCurMap starts.  This is used to compute row indices to pass to
 651   // nsTableCellMap::GetDataAt, so must be a _content_ row index.
 652   PRUint32 mCurMapStart;
 653
 654   // In steady-state mCurMapRow is the row in our current nsCellMap
 655   // that we'll use the next time GetNextFrame() is called.  Due to
 656   // the way we skip over rowspans, the entry in mCurMapRow and mCol
 657   // is either null, dead, originating, or a colspan.  In particular,
 658   // it cannot be a rowspan or overlap entry.
 659   PRUint32 mCurMapRow;
 660   const PRInt32 mCol;
 661   PRUint32 mOrigCells;
 662   PRUint32 mFoundCells;
 663
 664   // The number of content rows in mCurMap.  This may be bigger than the number
 665   // of "relevant" rows, or it might be smaller.
 666   PRUint32 mCurMapContentRowCount;
 667
 668   // The number of "relevant" rows in mCurMap.  That is, the number of rows
 669   // which might have an originating cell in them.  Once mCurMapRow reaches
 670   // mCurMapRelevantRowCount, we should move to the next map.
 671   PRUint32 mCurMapRelevantRowCount;
 672 };
 673
 674
 675 /* ----- inline methods ----- */
 676 inline PRInt32 nsTableCellMap::GetColCount() const
 677 {
 678   return mCols.Count();
 679 }
 680
 681 inline nsCellMap* nsCellMap::GetNextSibling() const
 682 {
 683   return mNextSibling;
 684 }
 685
 686 inline void nsCellMap::SetNextSibling(nsCellMap* aSibling)
 687 {
 688   mNextSibling = aSibling;
 689 }
 690
 691 inline nsTableRowGroupFrame* nsCellMap::GetRowGroup() const
 692 {
 693   return mRowGroupFrame;
 694 }
 695
 696 inline PRInt32 nsCellMap::GetRowCount(PRBool aConsiderDeadRowSpanRows) const
 697 {
 698   PRInt32 rowCount = (aConsiderDeadRowSpanRows) ? mRows.Length() : mContentRowCount;
 699   return rowCount;
 700 }
 701
 702 // nsColInfo
 703
 704 inline nsColInfo::nsColInfo()
 705  :mNumCellsOrig(0), mNumCellsSpan(0)
 706 {}
 707
 708 inline nsColInfo::nsColInfo(PRInt32 aNumCellsOrig,
 709                             PRInt32 aNumCellsSpan)
 710  :mNumCellsOrig(aNumCellsOrig), mNumCellsSpan(aNumCellsSpan)
 711 {}
 712
 713
 714 #endif