layout/tables/nsTableCellFrame.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 nsTableCellFrame_h__
  38 #define nsTableCellFrame_h__
  39
  40 #include "nsITableCellLayout.h"
  41 #include "nscore.h"
  42 #include "nsHTMLContainerFrame.h"
  43 #include "nsTableRowFrame.h"  // need to actually include this here to inline GetRowIndex
  44 #include "nsStyleContext.h"
  45 #include "nsIPercentHeightObserver.h"
  46 #include "nsGkAtoms.h"
  47 #include "nsLayoutUtils.h"
  48
  49 class nsTableFrame;
  50
  51 /**
  52  * Additional frame-state bits
  53  */
  54 #define NS_TABLE_CELL_CONTENT_EMPTY       0x80000000
  55 #define NS_TABLE_CELL_HAD_SPECIAL_REFLOW  0x20000000
  56 #define NS_TABLE_CELL_HAS_PCT_OVER_HEIGHT 0x10000000
  57
  58 /**
  59  * nsTableCellFrame
  60  * data structure to maintain information about a single table cell's frame
  61  *
  62  * NOTE:  frames are not ref counted.  We expose addref and release here
  63  * so we can change that decsion in the future.  Users of nsITableCellLayout
  64  * should refcount correctly as if this object is being ref counted, though
  65  * no actual support is under the hood.
  66  *
  67  * @author  sclark
  68  */
  69 class nsTableCellFrame : public nsHTMLContainerFrame,
  70                          public nsITableCellLayout,
  71                          public nsIPercentHeightObserver
  72 {
  73 public:
  74
  75   // nsISupports
  76   NS_DECL_ISUPPORTS_INHERITED
  77
  78   // default constructor supplied by the compiler
  79
  80   nsTableCellFrame(nsStyleContext* aContext);
  81   ~nsTableCellFrame();
  82
  83   NS_IMETHOD Init(nsIContent*      aContent,
  84                   nsIFrame*        aParent,
  85                   nsIFrame*        aPrevInFlow);
  86
  87 #ifdef ACCESSIBILITY
  88   NS_IMETHOD GetAccessible(nsIAccessible** aAccessible);
  89 #endif
  90
  91   NS_IMETHOD  AttributeChanged(PRInt32         aNameSpaceID,
  92                                nsIAtom*        aAttribute,
  93                                PRInt32         aModType);
  94
  95   /** @see nsIFrame::DidSetStyleContext */
  96   virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext);
  97
  98   // table cells contain an area frame which does most of the work, and
  99   // so these functions should never be called. They assert and return
 100   // NS_ERROR_NOT_IMPLEMENTED
 101   NS_IMETHOD AppendFrames(nsIAtom*        aListName,
 102                           nsIFrame*       aFrameList);
 103   NS_IMETHOD InsertFrames(nsIAtom*        aListName,
 104                           nsIFrame*       aPrevFrame,
 105                           nsIFrame*       aFrameList);
 106   NS_IMETHOD RemoveFrame(nsIAtom*        aListName,
 107                          nsIFrame*       aOldFrame);
 108
 109   virtual nsIFrame* GetContentInsertionFrame() {
 110     return GetFirstChild(nsnull)->GetContentInsertionFrame();
 111   }
 112
 113   virtual nsMargin GetUsedMargin() const;
 114
 115   virtual void NotifyPercentHeight(const nsHTMLReflowState& aReflowState);
 116
 117   virtual PRBool NeedsToObserve(const nsHTMLReflowState& aReflowState);
 118
 119   /** instantiate a new instance of nsTableRowFrame.
 120     * @param aPresShell the pres shell for this frame
 121     *
 122     * @return           the frame that was created
 123     */
 124   friend nsIFrame* NS_NewTableCellFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
 125
 126   NS_IMETHOD BuildDisplayList(nsDisplayListBuilder*   aBuilder,
 127                               const nsRect&           aDirtyRect,
 128                               const nsDisplayListSet& aLists);
 129
 130   void PaintCellBackground(nsIRenderingContext& aRenderingContext,
 131                            const nsRect& aDirtyRect, nsPoint aPt);
 132
 133   NS_IMETHOD SetSelected(nsPresContext* aPresContext,
 134                          nsIDOMRange *aRange,
 135                          PRBool aSelected,
 136                          nsSpread aSpread,
 137                          SelectionType aType);
 138
 139   virtual nscoord GetMinWidth(nsIRenderingContext *aRenderingContext);
 140   virtual nscoord GetPrefWidth(nsIRenderingContext *aRenderingContext);
 141   virtual IntrinsicWidthOffsetData
 142     IntrinsicWidthOffsets(nsIRenderingContext* aRenderingContext);
 143
 144   NS_IMETHOD Reflow(nsPresContext*      aPresContext,
 145                     nsHTMLReflowMetrics& aDesiredSize,
 146                     const nsHTMLReflowState& aReflowState,
 147                     nsReflowStatus&      aStatus);
 148
 149   /**
 150    * Get the "type" of the frame
 151    *
 152    * @see nsLayoutAtoms::tableCellFrame
 153    */
 154   virtual nsIAtom* GetType() const;
 155
 156   virtual PRBool IsContainingBlock() const;
 157
 158 #ifdef DEBUG
 159   NS_IMETHOD GetFrameName(nsAString& aResult) const;
 160 #endif
 161
 162   void VerticallyAlignChild(nscoord aMaxAscent);
 163
 164   PRBool HasVerticalAlignBaseline();
 165
 166   PRBool CellHasVisibleContent(nscoord       height,
 167                                nsTableFrame* tableFrame,
 168                                nsIFrame*     kidFrame);
 169
 170   /**
 171    * Get the first-line baseline of the cell relative to its top border
 172    * edge, as if the cell were vertically aligned to the top of the row.
 173    */
 174   nscoord GetCellBaseline() const;
 175
 176   /**
 177    * return the cell's specified row span. this is what was specified in the
 178    * content model or in the style info, and is always >= 1.
 179    * to get the effective row span (the actual value that applies), use GetEffectiveRowSpan()
 180    * @see nsTableFrame::GetEffectiveRowSpan()
 181    */
 182   virtual PRInt32 GetRowSpan();
 183
 184   // there is no set row index because row index depends on the cell's parent row only
 185
 186   /*---------------- nsITableCellLayout methods ------------------------*/
 187
 188   /**
 189    * return the cell's starting row index (starting at 0 for the first row).
 190    * for continued cell frames the row index is that of the cell's first-in-flow
 191    * and the column index (starting at 0 for the first column
 192    */
 193   NS_IMETHOD GetCellIndexes(PRInt32 &aRowIndex, PRInt32 &aColIndex);
 194
 195   /** return the mapped cell's row index (starting at 0 for the first row) */
 196   virtual nsresult GetRowIndex(PRInt32 &aRowIndex) const;
 197
 198   /**
 199    * return the cell's specified col span. this is what was specified in the
 200    * content model or in the style info, and is always >= 1.
 201    * to get the effective col span (the actual value that applies), use GetEffectiveColSpan()
 202    * @see nsTableFrame::GetEffectiveColSpan()
 203    */
 204   virtual PRInt32 GetColSpan();
 205
 206   /** return the cell's column index (starting at 0 for the first column) */
 207   virtual nsresult GetColIndex(PRInt32 &aColIndex) const;
 208   void SetColIndex(PRInt32 aColIndex);
 209
 210   /** return the available width given to this frame during its last reflow */
 211   inline nscoord GetPriorAvailWidth();
 212
 213   /** set the available width given to this frame during its last reflow */
 214   inline void SetPriorAvailWidth(nscoord aPriorAvailWidth);
 215
 216   /** return the desired size returned by this frame during its last reflow */
 217   inline nsSize GetDesiredSize();
 218
 219   /** set the desired size returned by this frame during its last reflow */
 220   inline void SetDesiredSize(const nsHTMLReflowMetrics & aDesiredSize);
 221
 222   PRBool GetContentEmpty();
 223   void SetContentEmpty(PRBool aContentEmpty);
 224
 225   PRBool HasPctOverHeight();
 226   void SetHasPctOverHeight(PRBool aValue);
 227
 228   nsTableCellFrame* GetNextCell() const;
 229
 230   virtual nsMargin* GetBorderWidth(nsMargin& aBorder) const;
 231
 232   virtual void PaintBackground(nsIRenderingContext& aRenderingContext,
 233                                const nsRect&        aDirtyRect,
 234                                nsPoint              aPt);
 235
 236   void DecorateForSelection(nsIRenderingContext& aRenderingContext,
 237                             nsPoint              aPt);
 238
 239 protected:
 240   /** implement abstract method on nsHTMLContainerFrame */
 241   virtual PRIntn GetSkipSides() const;
 242
 243   virtual PRBool ParentDisablesSelection() const; //override default behavior
 244
 245   /**
 246    * GetSelfOverflow says what effect the cell should have on its own
 247    * overflow area.  In the separated borders model this should just be
 248    * the frame's size (as it is for most frames), but in the collapsed
 249    * borders model (for which nsBCTableCellFrame overrides this virtual
 250    * method), it considers the extents of the collapsed border so we
 251    * handle invalidation correctly for dynamic border changes.
 252    */
 253   virtual void GetSelfOverflow(nsRect& aOverflowArea);
 254
 255 private:
 256
 257   // All these methods are support methods for RecalcLayoutData
 258   nsIFrame* GetFrameAt(nsVoidArray* aList,  PRInt32 aIndex);
 259
 260 protected:
 261
 262   friend class nsTableRowFrame;
 263
 264   PRUint32     mColIndex;             // the starting column for this cell
 265
 266   nscoord      mPriorAvailWidth;      // the avail width during the last reflow
 267   nsSize       mDesiredSize;          // the last desired width & height
 268 };
 269
 270 inline nscoord nsTableCellFrame::GetPriorAvailWidth()
 271 { return mPriorAvailWidth;}
 272
 273 inline void nsTableCellFrame::SetPriorAvailWidth(nscoord aPriorAvailWidth)
 274 { mPriorAvailWidth = aPriorAvailWidth;}
 275
 276 inline nsSize nsTableCellFrame::GetDesiredSize()
 277 { return mDesiredSize; }
 278
 279 inline void nsTableCellFrame::SetDesiredSize(const nsHTMLReflowMetrics & aDesiredSize)
 280 {
 281   mDesiredSize.width = aDesiredSize.width;
 282   mDesiredSize.height = aDesiredSize.height;
 283 }
 284
 285 inline PRBool nsTableCellFrame::GetContentEmpty()
 286 {
 287   return (mState & NS_TABLE_CELL_CONTENT_EMPTY) ==
 288          NS_TABLE_CELL_CONTENT_EMPTY;
 289 }
 290
 291 inline void nsTableCellFrame::SetContentEmpty(PRBool aContentEmpty)
 292 {
 293   if (aContentEmpty) {
 294     mState |= NS_TABLE_CELL_CONTENT_EMPTY;
 295   } else {
 296     mState &= ~NS_TABLE_CELL_CONTENT_EMPTY;
 297   }
 298 }
 299
 300 inline PRBool nsTableCellFrame::HasPctOverHeight()
 301 {
 302   return (mState & NS_TABLE_CELL_HAS_PCT_OVER_HEIGHT) ==
 303          NS_TABLE_CELL_HAS_PCT_OVER_HEIGHT;
 304 }
 305
 306 inline void nsTableCellFrame::SetHasPctOverHeight(PRBool aValue)
 307 {
 308   if (aValue) {
 309     mState |= NS_TABLE_CELL_HAS_PCT_OVER_HEIGHT;
 310   } else {
 311     mState &= ~NS_TABLE_CELL_HAS_PCT_OVER_HEIGHT;
 312   }
 313 }
 314
 315 // nsBCTableCellFrame
 316 class nsBCTableCellFrame : public nsTableCellFrame
 317 {
 318 public:
 319
 320   nsBCTableCellFrame(nsStyleContext* aContext);
 321
 322   ~nsBCTableCellFrame();
 323
 324   virtual nsIAtom* GetType() const;
 325
 326   virtual nsMargin GetUsedBorder() const;
 327
 328   // Get the *inner half of the border only*, in twips.
 329   virtual nsMargin* GetBorderWidth(nsMargin& aBorder) const;
 330
 331   // Get the *inner half of the border only*, in pixels.
 332   BCPixelSize GetBorderWidth(PRUint8 aSide) const;
 333
 334   // Set the full (both halves) width of the border
 335   void SetBorderWidth(PRUint8 aSide, BCPixelSize aPixelValue);
 336
 337   virtual void GetSelfOverflow(nsRect& aOverflowArea);
 338
 339 #ifdef DEBUG
 340   NS_IMETHOD GetFrameName(nsAString& aResult) const;
 341 #endif
 342
 343   virtual void PaintBackground(nsIRenderingContext& aRenderingContext,
 344                                const nsRect&        aDirtyRect,
 345                                nsPoint              aPt);
 346
 347 private:
 348
 349   // These are the entire width of the border (the cell edge contains only
 350   // the inner half, per the macros in nsTablePainter.h).
 351   BCPixelSize mTopBorder;
 352   BCPixelSize mRightBorder;
 353   BCPixelSize mBottomBorder;
 354   BCPixelSize mLeftBorder;
 355 };
 356
 357 #endif