layout/tables/nsTableCellFrame.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5 #ifndef nsTableCellFrame_h__
   6 #define nsTableCellFrame_h__
   7
   8 #include "mozilla/Attributes.h"
   9 #include "celldata.h"
  10 #include "nsITableCellLayout.h"
  11 #include "nscore.h"
  12 #include "nsContainerFrame.h"
  13 #include "mozilla/ComputedStyle.h"
  14 #include "nsIPercentBSizeObserver.h"
  15 #include "nsTArray.h"
  16 #include "nsTableRowFrame.h"
  17 #include "mozilla/WritingModes.h"
  18
  19 namespace mozilla {
  20 class PresShell;
  21 }  // namespace mozilla
  22
  23 /**
  24  * nsTableCellFrame
  25  * data structure to maintain information about a single table cell's frame
  26  *
  27  * NOTE:  frames are not ref counted.  We expose addref and release here
  28  * so we can change that decsion in the future.  Users of nsITableCellLayout
  29  * should refcount correctly as if this object is being ref counted, though
  30  * no actual support is under the hood.
  31  *
  32  * @author  sclark
  33  */
  34 class nsTableCellFrame : public nsContainerFrame,
  35                          public nsITableCellLayout,
  36                          public nsIPercentBSizeObserver {
  37   typedef mozilla::gfx::DrawTarget DrawTarget;
  38   typedef mozilla::image::ImgDrawResult ImgDrawResult;
  39
  40   friend nsTableCellFrame* NS_NewTableCellFrame(mozilla::PresShell* aPresShell,
  41                                                 ComputedStyle* aStyle,
  42                                                 nsTableFrame* aTableFrame);
  43
  44   nsTableCellFrame(ComputedStyle* aStyle, nsTableFrame* aTableFrame)
  45       : nsTableCellFrame(aStyle, aTableFrame, kClassID) {}
  46
  47  protected:
  48   typedef mozilla::WritingMode WritingMode;
  49   typedef mozilla::LogicalSide LogicalSide;
  50   typedef mozilla::LogicalMargin LogicalMargin;
  51
  52  public:
  53   NS_DECL_QUERYFRAME
  54   NS_DECL_FRAMEARENA_HELPERS(nsTableCellFrame)
  55
  56   nsIScrollableFrame* GetScrollTargetFrame() const final;
  57
  58   nsTableRowFrame* GetTableRowFrame() const {
  59     nsIFrame* parent = GetParent();
  60     MOZ_ASSERT(parent && parent->IsTableRowFrame());
  61     return static_cast<nsTableRowFrame*>(parent);
  62   }
  63
  64   nsTableFrame* GetTableFrame() const {
  65     return GetTableRowFrame()->GetTableFrame();
  66   }
  67
  68   void Init(nsIContent* aContent, nsContainerFrame* aParent,
  69             nsIFrame* aPrevInFlow) override;
  70
  71   void Destroy(DestroyContext&) override;
  72
  73 #ifdef ACCESSIBILITY
  74   mozilla::a11y::AccType AccessibleType() override;
  75 #endif
  76
  77   nsresult AttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
  78                             int32_t aModType) override;
  79
  80   /** @see nsIFrame::DidSetComputedStyle */
  81   void DidSetComputedStyle(ComputedStyle* aOldComputedStyle) override;
  82
  83 #ifdef DEBUG
  84   // Our anonymous block frame is the content insertion frame so these
  85   // methods should never be called:
  86   void AppendFrames(ChildListID aListID, nsFrameList&& aFrameList) override;
  87   void InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame,
  88                     const nsLineList::iterator* aPrevFrameLine,
  89                     nsFrameList&& aFrameList) override;
  90   void RemoveFrame(DestroyContext&, ChildListID, nsIFrame*) override;
  91 #endif
  92
  93   nsContainerFrame* GetContentInsertionFrame() override {
  94     return PrincipalChildList().FirstChild()->GetContentInsertionFrame();
  95   }
  96
  97   nsIFrame* CellContentFrame() const;
  98
  99   nsMargin GetUsedMargin() const override;
 100
 101   void NotifyPercentBSize(const ReflowInput& aReflowInput) override;
 102
 103   bool NeedsToObserve(const ReflowInput& aReflowInput) override;
 104
 105   void BuildDisplayList(nsDisplayListBuilder* aBuilder,
 106                         const nsDisplayListSet& aLists) override;
 107
 108   virtual void ProcessBorders(nsTableFrame* aFrame,
 109                               nsDisplayListBuilder* aBuilder,
 110                               const nsDisplayListSet& aLists);
 111
 112   nscoord GetMinISize(gfxContext* aRenderingContext) override;
 113   nscoord GetPrefISize(gfxContext* aRenderingContext) override;
 114   IntrinsicSizeOffsetData IntrinsicISizeOffsets(
 115       nscoord aPercentageBasis = NS_UNCONSTRAINEDSIZE) override;
 116
 117   void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
 118               const ReflowInput& aReflowInput,
 119               nsReflowStatus& aStatus) override;
 120
 121 #ifdef DEBUG_FRAME_DUMP
 122   nsresult GetFrameName(nsAString& aResult) const override;
 123 #endif
 124
 125   void BlockDirAlignChild(mozilla::WritingMode aWM, nscoord aMaxAscent);
 126
 127   /*
 128    * Get the value of vertical-align adjusted for CSS 2's rules for a
 129    * table cell, which means the result is always
 130    * StyleVerticalAlignKeyword::{Top,Middle,Bottom,Baseline}.
 131    */
 132   virtual mozilla::StyleVerticalAlignKeyword GetVerticalAlign() const;
 133
 134   bool HasVerticalAlignBaseline() const {
 135     return GetVerticalAlign() == mozilla::StyleVerticalAlignKeyword::Baseline &&
 136            !GetContentEmpty();
 137   }
 138
 139   /**
 140    * Get the first-line baseline of the cell relative to its block-start border
 141    * edge, as if the cell were vertically aligned to the top of the row.
 142    */
 143   nscoord GetCellBaseline() const;
 144
 145   /**
 146    * return the cell's specified row span. this is what was specified in the
 147    * content model or in the style info, and is always >= 0.
 148    * to get the effective row span (the actual value that applies), use
 149    * GetEffectiveRowSpan()
 150    * @see nsTableFrame::GetEffectiveRowSpan()
 151    */
 152   int32_t GetRowSpan();
 153
 154   // there is no set row index because row index depends on the cell's parent
 155   // row only
 156
 157   // Return our cell content frame.
 158   void AppendDirectlyOwnedAnonBoxes(nsTArray<OwnedAnonBox>& aResult) override;
 159
 160   /*---------------- nsITableCellLayout methods ------------------------*/
 161
 162   /**
 163    * return the cell's starting row index (starting at 0 for the first row).
 164    * for continued cell frames the row index is that of the cell's first-in-flow
 165    * and the column index (starting at 0 for the first column
 166    */
 167   NS_IMETHOD GetCellIndexes(int32_t& aRowIndex, int32_t& aColIndex) override;
 168
 169   /** return the mapped cell's row index (starting at 0 for the first row) */
 170   uint32_t RowIndex() const {
 171     return static_cast<nsTableRowFrame*>(GetParent())->GetRowIndex();
 172   }
 173
 174   /**
 175    * return the cell's specified col span. this is what was specified in the
 176    * content model or in the style info, and is always >= 1.
 177    * to get the effective col span (the actual value that applies), use
 178    * GetEffectiveColSpan()
 179    * @see nsTableFrame::GetEffectiveColSpan()
 180    */
 181   int32_t GetColSpan();
 182
 183   /** return the cell's column index (starting at 0 for the first column) */
 184   uint32_t ColIndex() const {
 185     // NOTE: We copy this from previous continuations, and we don't ever have
 186     // dynamic updates when tables split, so our mColIndex always matches our
 187     // first continuation's.
 188     MOZ_ASSERT(static_cast<nsTableCellFrame*>(FirstContinuation())->mColIndex ==
 189                    mColIndex,
 190                "mColIndex out of sync with first continuation");
 191     return mColIndex;
 192   }
 193
 194   void SetColIndex(int32_t aColIndex);
 195
 196   /** return the available isize given to this frame during its last reflow */
 197   inline nscoord GetPriorAvailISize();
 198
 199   /** set the available isize given to this frame during its last reflow */
 200   inline void SetPriorAvailISize(nscoord aPriorAvailISize);
 201
 202   /** return the desired size returned by this frame during its last reflow */
 203   inline mozilla::LogicalSize GetDesiredSize();
 204
 205   /** set the desired size returned by this frame during its last reflow */
 206   inline void SetDesiredSize(const ReflowOutput& aDesiredSize);
 207
 208   bool GetContentEmpty() const;
 209   void SetContentEmpty(bool aContentEmpty);
 210
 211   nsTableCellFrame* GetNextCell() const {
 212     nsIFrame* sibling = GetNextSibling();
 213     MOZ_ASSERT(
 214         !sibling || static_cast<nsTableCellFrame*>(do_QueryFrame(sibling)),
 215         "How do we have a non-cell sibling?");
 216     return static_cast<nsTableCellFrame*>(sibling);
 217   }
 218
 219   virtual LogicalMargin GetBorderWidth(WritingMode aWM) const;
 220
 221   void DecorateForSelection(DrawTarget* aDrawTarget, nsPoint aPt);
 222
 223   bool ComputeCustomOverflow(mozilla::OverflowAreas& aOverflowAreas) override;
 224
 225   void InvalidateFrame(uint32_t aDisplayItemKey = 0,
 226                        bool aRebuildDisplayItems = true) override;
 227   void InvalidateFrameWithRect(const nsRect& aRect,
 228                                uint32_t aDisplayItemKey = 0,
 229                                bool aRebuildDisplayItems = true) override;
 230   void InvalidateFrameForRemoval() override { InvalidateFrameSubtree(); }
 231
 232   bool ShouldPaintBordersAndBackgrounds() const;
 233
 234   bool ShouldPaintBackground(nsDisplayListBuilder* aBuilder);
 235
 236  protected:
 237   nsTableCellFrame(ComputedStyle* aStyle, nsTableFrame* aTableFrame,
 238                    ClassID aID);
 239   ~nsTableCellFrame();
 240
 241   LogicalSides GetLogicalSkipSides() const override;
 242
 243   /**
 244    * GetBorderOverflow says how far the cell's own borders extend
 245    * outside its own bounds.  In the separated borders model this should
 246    * just be zero (as it is for most frames), but in the collapsed
 247    * borders model (for which nsBCTableCellFrame overrides this virtual
 248    * method), it considers the extents of the collapsed border.
 249    */
 250   virtual nsMargin GetBorderOverflow();
 251
 252   friend class nsTableRowFrame;
 253
 254   uint32_t mColIndex;  // the starting column for this cell
 255
 256   nscoord mPriorAvailISize;           // the avail isize during the last reflow
 257   mozilla::LogicalSize mDesiredSize;  // the last desired inline and block size
 258 };
 259
 260 inline nscoord nsTableCellFrame::GetPriorAvailISize() {
 261   return mPriorAvailISize;
 262 }
 263
 264 inline void nsTableCellFrame::SetPriorAvailISize(nscoord aPriorAvailISize) {
 265   mPriorAvailISize = aPriorAvailISize;
 266 }
 267
 268 inline mozilla::LogicalSize nsTableCellFrame::GetDesiredSize() {
 269   return mDesiredSize;
 270 }
 271
 272 inline void nsTableCellFrame::SetDesiredSize(const ReflowOutput& aDesiredSize) {
 273   mDesiredSize = aDesiredSize.Size(GetWritingMode());
 274 }
 275
 276 inline bool nsTableCellFrame::GetContentEmpty() const {
 277   return HasAnyStateBits(NS_TABLE_CELL_CONTENT_EMPTY);
 278 }
 279
 280 inline void nsTableCellFrame::SetContentEmpty(bool aContentEmpty) {
 281   if (aContentEmpty) {
 282     AddStateBits(NS_TABLE_CELL_CONTENT_EMPTY);
 283   } else {
 284     RemoveStateBits(NS_TABLE_CELL_CONTENT_EMPTY);
 285   }
 286 }
 287
 288 // nsBCTableCellFrame
 289 class nsBCTableCellFrame final : public nsTableCellFrame {
 290   typedef mozilla::image::ImgDrawResult ImgDrawResult;
 291
 292  public:
 293   NS_DECL_FRAMEARENA_HELPERS(nsBCTableCellFrame)
 294
 295   nsBCTableCellFrame(ComputedStyle* aStyle, nsTableFrame* aTableFrame);
 296
 297   ~nsBCTableCellFrame();
 298
 299   nsMargin GetUsedBorder() const override;
 300
 301   // Get the *inner half of the border only*, in twips.
 302   LogicalMargin GetBorderWidth(WritingMode aWM) const override;
 303
 304   // Get the *inner half of the border only*, in pixels.
 305   BCPixelSize GetBorderWidth(LogicalSide aSide) const;
 306
 307   // Set the full (both halves) width of the border
 308   void SetBorderWidth(LogicalSide aSide, BCPixelSize aPixelValue);
 309
 310   nsMargin GetBorderOverflow() override;
 311
 312 #ifdef DEBUG_FRAME_DUMP
 313   nsresult GetFrameName(nsAString& aResult) const override;
 314 #endif
 315
 316  private:
 317   // These are the entire width of the border (the cell edge contains only
 318   // the inner half).
 319   BCPixelSize mBStartBorder;
 320   BCPixelSize mIEndBorder;
 321   BCPixelSize mBEndBorder;
 322   BCPixelSize mIStartBorder;
 323 };
 324
 325 // Implemented here because that's a sane-ish way to make the includes work out.
 326 inline nsTableCellFrame* nsTableRowFrame::GetFirstCell() const {
 327   nsIFrame* firstChild = mFrames.FirstChild();
 328   MOZ_ASSERT(
 329       !firstChild || static_cast<nsTableCellFrame*>(do_QueryFrame(firstChild)),
 330       "How do we have a non-cell child?");
 331   return static_cast<nsTableCellFrame*>(firstChild);
 332 }
 333
 334 #endif