layout/tables/nsTableColFrame.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 nsTableColFrame_h__
   6 #define nsTableColFrame_h__
   7
   8 #include "mozilla/Attributes.h"
   9 #include "celldata.h"
  10 #include "nscore.h"
  11 #include "nsContainerFrame.h"
  12 #include "nsTArray.h"
  13 #include "nsTableColGroupFrame.h"
  14 #include "mozilla/WritingModes.h"
  15
  16 namespace mozilla {
  17 class PresShell;
  18 }  // namespace mozilla
  19
  20 class nsTableColFrame final : public nsSplittableFrame {
  21  public:
  22   NS_DECL_FRAMEARENA_HELPERS(nsTableColFrame)
  23
  24   enum {
  25     eWIDTH_SOURCE_NONE = 0,  // no cell has contributed to the width style
  26     eWIDTH_SOURCE_CELL = 1,  // a cell specified a width
  27     eWIDTH_SOURCE_CELL_WITH_SPAN = 2  // a cell implicitly specified a width via
  28                                       // colspan
  29   };
  30
  31   nsTableColType GetColType() const;
  32   void SetColType(nsTableColType aType);
  33
  34   /**
  35    * instantiate a new instance of nsTableRowFrame.
  36    *
  37    * @param aPresShell the pres shell for this frame
  38    *
  39    * @return           the frame that was created
  40    */
  41   friend nsTableColFrame* NS_NewTableColFrame(mozilla::PresShell* aPresShell,
  42                                               ComputedStyle* aContext);
  43
  44   // nsIFrame overrides
  45   void Init(nsIContent* aContent, nsContainerFrame* aParent,
  46             nsIFrame* aPrevInFlow) override {
  47     nsSplittableFrame::Init(aContent, aParent, aPrevInFlow);
  48     if (!aPrevInFlow) {
  49       mWritingMode = GetTableFrame()->GetWritingMode();
  50     }
  51   }
  52
  53   /** @see nsIFrame::DidSetComputedStyle */
  54   void DidSetComputedStyle(ComputedStyle* aOldComputedStyle) override;
  55
  56   void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
  57               const ReflowInput& aReflowInput,
  58               nsReflowStatus& aStatus) override;
  59
  60   void BuildDisplayList(nsDisplayListBuilder* aBuilder,
  61                         const nsDisplayListSet& aLists) override;
  62
  63 #ifdef DEBUG_FRAME_DUMP
  64   nsresult GetFrameName(nsAString& aResult) const override;
  65 #endif
  66
  67   nsTableColGroupFrame* GetTableColGroupFrame() const {
  68     nsIFrame* parent = GetParent();
  69     MOZ_ASSERT(parent && parent->IsTableColGroupFrame());
  70     return static_cast<nsTableColGroupFrame*>(parent);
  71   }
  72
  73   nsTableFrame* GetTableFrame() const {
  74     return GetTableColGroupFrame()->GetTableFrame();
  75   }
  76
  77   int32_t GetColIndex() const;
  78
  79   void SetColIndex(int32_t aColIndex);
  80
  81   nsTableColFrame* GetNextCol() const;
  82
  83   /** return the number of the columns the col represents.  always >= 1 */
  84   int32_t GetSpan();
  85
  86   /** convenience method, calls into cellmap */
  87   int32_t Count() const;
  88
  89   BCPixelSize GetIStartBorderWidth() const { return mIStartBorderWidth; }
  90   BCPixelSize GetIEndBorderWidth() const { return mIEndBorderWidth; }
  91   void SetIStartBorderWidth(BCPixelSize aWidth) { mIStartBorderWidth = aWidth; }
  92   void SetIEndBorderWidth(BCPixelSize aWidth) { mIEndBorderWidth = aWidth; }
  93
  94   /**
  95    * Gets inner border widths before collapsing with cell borders
  96    * Caller must get istart border from previous column or from table
  97    * GetContinuousBCBorderWidth will not overwrite aBorder.IStart
  98    * see nsTablePainter about continuous borders
  99    *
 100    * @return outer iend border width (istart inner for next column)
 101    */
 102   nscoord GetContinuousBCBorderWidth(mozilla::WritingMode aWM,
 103                                      mozilla::LogicalMargin& aBorder);
 104   /**
 105    * Set full border widths before collapsing with cell borders
 106    * @param aForSide - side to set; only valid for bstart, iend, and bend
 107    */
 108   void SetContinuousBCBorderWidth(mozilla::LogicalSide aForSide,
 109                                   BCPixelSize aPixelValue);
 110 #ifdef DEBUG
 111   void Dump(int32_t aIndent);
 112 #endif
 113
 114   /**
 115    * Restore the default values of the intrinsic widths, so that we can
 116    * re-accumulate intrinsic widths from the cells in the column.
 117    */
 118   void ResetIntrinsics() {
 119     mMinCoord = 0;
 120     mPrefCoord = 0;
 121     mPrefPercent = 0.0f;
 122     mHasSpecifiedCoord = false;
 123   }
 124
 125   /**
 126    * Restore the default value of the preferred percentage width (the
 127    * only intrinsic width used by FixedTableLayoutStrategy.
 128    */
 129   void ResetPrefPercent() { mPrefPercent = 0.0f; }
 130
 131   /**
 132    * Restore the default values of the temporary buffer for
 133    * spanning-cell intrinsic widths (as we process spanning cells).
 134    */
 135   void ResetSpanIntrinsics() {
 136     mSpanMinCoord = 0;
 137     mSpanPrefCoord = 0;
 138     mSpanPrefPercent = 0.0f;
 139   }
 140
 141   /**
 142    * Add the widths for a cell or column element, or the contribution of
 143    * the widths from a column-spanning cell:
 144    * @param aMinCoord The minimum intrinsic width
 145    * @param aPrefCoord The preferred intrinsic width or, if there is a
 146    *   specified non-percentage width, max(specified width, minimum intrinsic
 147    *   width).
 148    * @param aHasSpecifiedCoord Whether there is a specified
 149    *   non-percentage width.
 150    *
 151    * Note that the implementation of this functions is a bit tricky
 152    * since mPrefCoord means different things depending on
 153    * whether mHasSpecifiedCoord is true (and likewise for aPrefCoord and
 154    * aHasSpecifiedCoord).  If mHasSpecifiedCoord is false, then
 155    * all widths added had aHasSpecifiedCoord false and mPrefCoord is the
 156    * largest of the pref widths.  But if mHasSpecifiedCoord is true,
 157    * then mPrefCoord is the largest of (1) the pref widths for cells
 158    * with aHasSpecifiedCoord true and (2) the min widths for cells with
 159    * aHasSpecifiedCoord false.
 160    */
 161   void AddCoords(nscoord aMinCoord, nscoord aPrefCoord,
 162                  bool aHasSpecifiedCoord) {
 163     NS_ASSERTION(aMinCoord <= aPrefCoord, "intrinsic widths out of order");
 164
 165     if (aHasSpecifiedCoord && !mHasSpecifiedCoord) {
 166       mPrefCoord = mMinCoord;
 167       mHasSpecifiedCoord = true;
 168     }
 169     if (!aHasSpecifiedCoord && mHasSpecifiedCoord) {
 170       aPrefCoord = aMinCoord;  // NOTE: modifying argument
 171     }
 172
 173     if (aMinCoord > mMinCoord) mMinCoord = aMinCoord;
 174     if (aPrefCoord > mPrefCoord) mPrefCoord = aPrefCoord;
 175
 176     NS_ASSERTION(mMinCoord <= mPrefCoord, "min larger than pref");
 177   }
 178
 179   /**
 180    * Add a percentage width specified on a cell or column element or the
 181    * contribution to this column of a percentage width specified on a
 182    * column-spanning cell.
 183    */
 184   void AddPrefPercent(float aPrefPercent) {
 185     if (aPrefPercent > mPrefPercent) mPrefPercent = aPrefPercent;
 186   }
 187
 188   /**
 189    * Get the largest minimum intrinsic width for this column.
 190    */
 191   nscoord GetMinCoord() const { return mMinCoord; }
 192   /**
 193    * Get the largest preferred width for this column, or, if there were
 194    * any specified non-percentage widths (see GetHasSpecifiedCoord), the
 195    * largest minimum intrinsic width or specified width.
 196    */
 197   nscoord GetPrefCoord() const { return mPrefCoord; }
 198   /**
 199    * Get whether there were any specified widths contributing to this
 200    * column.
 201    */
 202   bool GetHasSpecifiedCoord() const { return mHasSpecifiedCoord; }
 203
 204   /**
 205    * Get the largest specified percentage width contributing to this
 206    * column (returns 0 if there were none).
 207    */
 208   float GetPrefPercent() const { return mPrefPercent; }
 209
 210   /**
 211    * Like AddCoords, but into a temporary buffer used for groups of
 212    * column-spanning cells.
 213    */
 214   void AddSpanCoords(nscoord aSpanMinCoord, nscoord aSpanPrefCoord,
 215                      bool aSpanHasSpecifiedCoord) {
 216     NS_ASSERTION(aSpanMinCoord <= aSpanPrefCoord,
 217                  "intrinsic widths out of order");
 218
 219     if (!aSpanHasSpecifiedCoord && mHasSpecifiedCoord) {
 220       aSpanPrefCoord = aSpanMinCoord;  // NOTE: modifying argument
 221     }
 222
 223     if (aSpanMinCoord > mSpanMinCoord) mSpanMinCoord = aSpanMinCoord;
 224     if (aSpanPrefCoord > mSpanPrefCoord) mSpanPrefCoord = aSpanPrefCoord;
 225
 226     NS_ASSERTION(mSpanMinCoord <= mSpanPrefCoord, "min larger than pref");
 227   }
 228
 229   /*
 230    * Accumulate percentage widths on column spanning cells into
 231    * temporary variables.
 232    */
 233   void AddSpanPrefPercent(float aSpanPrefPercent) {
 234     if (aSpanPrefPercent > mSpanPrefPercent)
 235       mSpanPrefPercent = aSpanPrefPercent;
 236   }
 237
 238   /*
 239    * Accumulate the temporary variables for column spanning cells into
 240    * the primary variables.
 241    */
 242   void AccumulateSpanIntrinsics() {
 243     AddCoords(mSpanMinCoord, mSpanPrefCoord, mHasSpecifiedCoord);
 244     AddPrefPercent(mSpanPrefPercent);
 245   }
 246
 247   // Used to adjust a column's pref percent so that the table's total
 248   // never exceeeds 100% (by only allowing percentages to be used,
 249   // starting at the first column, until they reach 100%).
 250   void AdjustPrefPercent(float* aTableTotalPercent) {
 251     float allowed = 1.0f - *aTableTotalPercent;
 252     if (mPrefPercent > allowed) mPrefPercent = allowed;
 253     *aTableTotalPercent += mPrefPercent;
 254   }
 255
 256   // The final width of the column.
 257   void ResetFinalISize() {
 258     mFinalISize = nscoord_MIN;  // so we detect that it changed
 259   }
 260   void SetFinalISize(nscoord aFinalISize) { mFinalISize = aFinalISize; }
 261   nscoord GetFinalISize() { return mFinalISize; }
 262
 263   void InvalidateFrame(uint32_t aDisplayItemKey = 0,
 264                        bool aRebuildDisplayItems = true) override;
 265   void InvalidateFrameWithRect(const nsRect& aRect,
 266                                uint32_t aDisplayItemKey = 0,
 267                                bool aRebuildDisplayItems = true) override;
 268   void InvalidateFrameForRemoval() override { InvalidateFrameSubtree(); }
 269
 270  protected:
 271   explicit nsTableColFrame(ComputedStyle* aStyle, nsPresContext* aPresContext);
 272   ~nsTableColFrame();
 273
 274   nscoord mMinCoord;
 275   nscoord mPrefCoord;
 276   nscoord mSpanMinCoord;   // XXX...
 277   nscoord mSpanPrefCoord;  // XXX...
 278   float mPrefPercent;
 279   float mSpanPrefPercent;  // XXX...
 280   // ...XXX the four members marked above could be allocated as part of
 281   // a separate array allocated only during
 282   // BasicTableLayoutStrategy::ComputeColumnIntrinsicISizes (and only
 283   // when colspans were present).
 284   nscoord mFinalISize;
 285
 286   // the index of the column with respect to the whole table (starting at 0)
 287   // it should never be smaller then the start column index of the parent
 288   // colgroup
 289   uint32_t mColIndex;
 290
 291   // border width in pixels of the inner half of the border only
 292   BCPixelSize mIStartBorderWidth;
 293   BCPixelSize mIEndBorderWidth;
 294   BCPixelSize mBStartContBorderWidth;
 295   BCPixelSize mIEndContBorderWidth;
 296   BCPixelSize mBEndContBorderWidth;
 297
 298   bool mHasSpecifiedCoord;
 299 };
 300
 301 inline int32_t nsTableColFrame::GetColIndex() const { return mColIndex; }
 302
 303 inline void nsTableColFrame::SetColIndex(int32_t aColIndex) {
 304   mColIndex = aColIndex;
 305 }
 306
 307 inline nscoord nsTableColFrame::GetContinuousBCBorderWidth(
 308     mozilla::WritingMode aWM, mozilla::LogicalMargin& aBorder) {
 309   int32_t d2a = PresContext()->AppUnitsPerDevPixel();
 310   aBorder.BStart(aWM) = BC_BORDER_END_HALF_COORD(d2a, mBStartContBorderWidth);
 311   aBorder.IEnd(aWM) = BC_BORDER_START_HALF_COORD(d2a, mIEndContBorderWidth);
 312   aBorder.BEnd(aWM) = BC_BORDER_START_HALF_COORD(d2a, mBEndContBorderWidth);
 313   return BC_BORDER_END_HALF_COORD(d2a, mIEndContBorderWidth);
 314 }
 315
 316 #endif