layout/tables/nsTableColGroupFrame.cpp

   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 #include "nsTableColGroupFrame.h"
   6 #include "nsTableColFrame.h"
   7 #include "nsTableFrame.h"
   8 #include "nsStyleContext.h"
   9 #include "nsStyleConsts.h"
  10 #include "nsPresContext.h"
  11 #include "nsHTMLParts.h"
  12 #include "nsGkAtoms.h"
  13 #include "nsCOMPtr.h"
  14 #include "nsCSSRendering.h"
  15 #include "nsIPresShell.h"
  16
  17 using namespace mozilla;
  18
  19 #define COL_GROUP_TYPE_BITS          (NS_FRAME_STATE_BIT(30) | \
  20                                       NS_FRAME_STATE_BIT(31))
  21 #define COL_GROUP_TYPE_OFFSET        30
  22
  23 nsTableColGroupType
  24 nsTableColGroupFrame::GetColType() const
  25 {
  26   return (nsTableColGroupType)((mState & COL_GROUP_TYPE_BITS) >> COL_GROUP_TYPE_OFFSET);
  27 }
  28
  29 void nsTableColGroupFrame::SetColType(nsTableColGroupType aType)
  30 {
  31   NS_ASSERTION(GetColType() == eColGroupContent,
  32                "should only call nsTableColGroupFrame::SetColType with aType "
  33                "!= eColGroupContent once");
  34   uint32_t type = aType - eColGroupContent;
  35   RemoveStateBits(COL_GROUP_TYPE_BITS);
  36   AddStateBits(nsFrameState(type << COL_GROUP_TYPE_OFFSET));
  37 }
  38
  39 void nsTableColGroupFrame::ResetColIndices(nsIFrame*       aFirstColGroup,
  40                                            int32_t         aFirstColIndex,
  41                                            nsIFrame*       aStartColFrame)
  42 {
  43   nsTableColGroupFrame* colGroupFrame = (nsTableColGroupFrame*)aFirstColGroup;
  44   int32_t colIndex = aFirstColIndex;
  45   while (colGroupFrame) {
  46     if (nsGkAtoms::tableColGroupFrame == colGroupFrame->GetType()) {
  47       // reset the starting col index for the first cg only if we should reset
  48       // the whole colgroup (aStartColFrame defaults to nullptr) or if
  49       // aFirstColIndex is smaller than the existing starting col index
  50       if ((colIndex != aFirstColIndex) ||
  51           (colIndex < colGroupFrame->GetStartColumnIndex()) ||
  52           !aStartColFrame) {
  53         colGroupFrame->SetStartColumnIndex(colIndex);
  54       }
  55       nsIFrame* colFrame = aStartColFrame;
  56       if (!colFrame || (colIndex != aFirstColIndex)) {
  57         colFrame = colGroupFrame->GetFirstPrincipalChild();
  58       }
  59       while (colFrame) {
  60         if (nsGkAtoms::tableColFrame == colFrame->GetType()) {
  61           ((nsTableColFrame*)colFrame)->SetColIndex(colIndex);
  62           colIndex++;
  63         }
  64         colFrame = colFrame->GetNextSibling();
  65       }
  66     }
  67     colGroupFrame = static_cast<nsTableColGroupFrame*>
  68                                (colGroupFrame->GetNextSibling());
  69   }
  70 }
  71
  72
  73 nsresult
  74 nsTableColGroupFrame::AddColsToTable(int32_t                   aFirstColIndex,
  75                                      bool                      aResetSubsequentColIndices,
  76                                      const nsFrameList::Slice& aCols)
  77 {
  78   nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
  79
  80   tableFrame->InvalidateFrameSubtree();
  81
  82   // set the col indices of the col frames and and add col info to the table
  83   int32_t colIndex = aFirstColIndex;
  84   nsFrameList::Enumerator e(aCols);
  85   for (; !e.AtEnd(); e.Next()) {
  86     ((nsTableColFrame*)e.get())->SetColIndex(colIndex);
  87     mColCount++;
  88     tableFrame->InsertCol((nsTableColFrame &)*e.get(), colIndex);
  89     colIndex++;
  90   }
  91
  92   for (nsFrameList::Enumerator eTail = e.GetUnlimitedEnumerator();
  93        !eTail.AtEnd();
  94        eTail.Next()) {
  95     ((nsTableColFrame*)eTail.get())->SetColIndex(colIndex);
  96     colIndex++;
  97   }
  98
  99   // We have already set the colindex for all the colframes in this
 100   // colgroup that come after the first inserted colframe, but there could
 101   // be other colgroups following this one and their colframes need
 102   // correct colindices too.
 103   if (aResetSubsequentColIndices && GetNextSibling()) {
 104     ResetColIndices(GetNextSibling(), colIndex);
 105   }
 106
 107   return NS_OK;
 108 }
 109
 110
 111 nsTableColGroupFrame*
 112 nsTableColGroupFrame::GetLastRealColGroup(nsTableFrame* aTableFrame)
 113 {
 114   nsFrameList colGroups = aTableFrame->GetColGroups();
 115
 116   nsIFrame* nextToLastColGroup = nullptr;
 117   nsFrameList::FrameLinkEnumerator link(colGroups);
 118   for ( ; !link.AtEnd(); link.Next()) {
 119     nextToLastColGroup = link.PrevFrame();
 120   }
 121
 122   if (!link.PrevFrame()) {
 123     return nullptr; // there are no col group frames
 124   }
 125
 126   nsTableColGroupType lastColGroupType =
 127     static_cast<nsTableColGroupFrame*>(link.PrevFrame())->GetColType();
 128   if (eColGroupAnonymousCell == lastColGroupType) {
 129     return static_cast<nsTableColGroupFrame*>(nextToLastColGroup);
 130   }
 131
 132   return static_cast<nsTableColGroupFrame*>(link.PrevFrame());
 133 }
 134
 135 // don't set mColCount here, it is done in AddColsToTable
 136 void
 137 nsTableColGroupFrame::SetInitialChildList(ChildListID     aListID,
 138                                           nsFrameList&    aChildList)
 139 {
 140   MOZ_ASSERT(mFrames.IsEmpty(),
 141              "unexpected second call to SetInitialChildList");
 142   MOZ_ASSERT(aListID == kPrincipalList, "unexpected child list");
 143   if (aChildList.IsEmpty()) {
 144     nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
 145     tableFrame->AppendAnonymousColFrames(this, GetSpan(), eColAnonymousColGroup,
 146                                          false);
 147     return;
 148   }
 149
 150   mFrames.AppendFrames(this, aChildList);
 151 }
 152
 153 /* virtual */ void
 154 nsTableColGroupFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
 155 {
 156   nsContainerFrame::DidSetStyleContext(aOldStyleContext);
 157
 158   if (!aOldStyleContext) //avoid this on init
 159     return;
 160
 161   nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
 162   if (tableFrame->IsBorderCollapse() &&
 163       tableFrame->BCRecalcNeeded(aOldStyleContext, StyleContext())) {
 164     int32_t colCount = GetColCount();
 165     if (!colCount)
 166       return; // this is a degenerated colgroup
 167     nsIntRect damageArea(GetFirstColumn()->GetColIndex(), 0, colCount,
 168                          tableFrame->GetRowCount());
 169     tableFrame->AddBCDamageArea(damageArea);
 170   }
 171 }
 172
 173 void
 174 nsTableColGroupFrame::AppendFrames(ChildListID     aListID,
 175                                    nsFrameList&    aFrameList)
 176 {
 177   NS_ASSERTION(aListID == kPrincipalList, "unexpected child list");
 178
 179   nsTableColFrame* col = GetFirstColumn();
 180   nsTableColFrame* nextCol;
 181   while (col && col->GetColType() == eColAnonymousColGroup) {
 182     // this colgroup spans one or more columns but now that there is a
 183     // real column below, spanned anonymous columns should be removed,
 184     // since the HTML spec says to ignore the span of a colgroup if it
 185     // has content columns in it.
 186     nextCol = col->GetNextCol();
 187     RemoveFrame(kPrincipalList, col);
 188     col = nextCol;
 189   }
 190
 191   const nsFrameList::Slice& newFrames =
 192     mFrames.AppendFrames(this, aFrameList);
 193   InsertColsReflow(GetStartColumnIndex() + mColCount, newFrames);
 194 }
 195
 196 void
 197 nsTableColGroupFrame::InsertFrames(ChildListID     aListID,
 198                                    nsIFrame*       aPrevFrame,
 199                                    nsFrameList&    aFrameList)
 200 {
 201   NS_ASSERTION(aListID == kPrincipalList, "unexpected child list");
 202   NS_ASSERTION(!aPrevFrame || aPrevFrame->GetParent() == this,
 203                "inserting after sibling frame with different parent");
 204
 205   nsTableColFrame* col = GetFirstColumn();
 206   nsTableColFrame* nextCol;
 207   while (col && col->GetColType() == eColAnonymousColGroup) {
 208     // this colgroup spans one or more columns but now that there is a
 209     // real column below, spanned anonymous columns should be removed,
 210     // since the HTML spec says to ignore the span of a colgroup if it
 211     // has content columns in it.
 212     nextCol = col->GetNextCol();
 213     if (col == aPrevFrame) {
 214       // This can happen when we're being appended to
 215       NS_ASSERTION(!nextCol || nextCol->GetColType() != eColAnonymousColGroup,
 216                    "Inserting in the middle of our anonymous cols?");
 217       // We'll want to insert at the beginning
 218       aPrevFrame = nullptr;
 219     }
 220     RemoveFrame(kPrincipalList, col);
 221     col = nextCol;
 222   }
 223
 224   NS_ASSERTION(!aPrevFrame || aPrevFrame == aPrevFrame->LastContinuation(),
 225                "Prev frame should be last in continuation chain");
 226   NS_ASSERTION(!aPrevFrame || !GetNextColumn(aPrevFrame) ||
 227                GetNextColumn(aPrevFrame)->GetColType() != eColAnonymousCol,
 228                "Shouldn't be inserting before a spanned colframe");
 229
 230   const nsFrameList::Slice& newFrames =
 231     mFrames.InsertFrames(this, aPrevFrame, aFrameList);
 232   nsIFrame* prevFrame = nsTableFrame::GetFrameAtOrBefore(this, aPrevFrame,
 233                                                          nsGkAtoms::tableColFrame);
 234
 235   int32_t colIndex = (prevFrame) ? ((nsTableColFrame*)prevFrame)->GetColIndex() + 1 : GetStartColumnIndex();
 236   InsertColsReflow(colIndex, newFrames);
 237 }
 238
 239 void
 240 nsTableColGroupFrame::InsertColsReflow(int32_t                   aColIndex,
 241                                        const nsFrameList::Slice& aCols)
 242 {
 243   AddColsToTable(aColIndex, true, aCols);
 244
 245   PresContext()->PresShell()->FrameNeedsReflow(this,
 246                                                nsIPresShell::eTreeChange,
 247                                                NS_FRAME_HAS_DIRTY_CHILDREN);
 248 }
 249
 250 void
 251 nsTableColGroupFrame::RemoveChild(nsTableColFrame& aChild,
 252                                   bool             aResetSubsequentColIndices)
 253 {
 254   int32_t colIndex = 0;
 255   nsIFrame* nextChild = nullptr;
 256   if (aResetSubsequentColIndices) {
 257     colIndex = aChild.GetColIndex();
 258     nextChild = aChild.GetNextSibling();
 259   }
 260   mFrames.DestroyFrame(&aChild);
 261   mColCount--;
 262   if (aResetSubsequentColIndices) {
 263     if (nextChild) { // reset inside this and all following colgroups
 264       ResetColIndices(this, colIndex, nextChild);
 265     }
 266     else {
 267       nsIFrame* nextGroup = GetNextSibling();
 268       if (nextGroup) // reset next and all following colgroups
 269         ResetColIndices(nextGroup, colIndex);
 270     }
 271   }
 272
 273   PresContext()->PresShell()->FrameNeedsReflow(this,
 274                                                nsIPresShell::eTreeChange,
 275                                                NS_FRAME_HAS_DIRTY_CHILDREN);
 276 }
 277
 278 void
 279 nsTableColGroupFrame::RemoveFrame(ChildListID     aListID,
 280                                   nsIFrame*       aOldFrame)
 281 {
 282   NS_ASSERTION(aListID == kPrincipalList, "unexpected child list");
 283
 284   if (!aOldFrame) {
 285     return;
 286   }
 287   bool contentRemoval = false;
 288
 289   if (nsGkAtoms::tableColFrame == aOldFrame->GetType()) {
 290     nsTableColFrame* colFrame = (nsTableColFrame*)aOldFrame;
 291     if (colFrame->GetColType() == eColContent) {
 292       contentRemoval = true;
 293       // Remove any anonymous column frames this <col> produced via a colspan
 294       nsTableColFrame* col = colFrame->GetNextCol();
 295       nsTableColFrame* nextCol;
 296       while (col && col->GetColType() == eColAnonymousCol) {
 297 #ifdef DEBUG
 298         nsIFrame* providerFrame = colFrame->GetParentStyleContextFrame();
 299         if (colFrame->StyleContext()->GetParent() ==
 300             providerFrame->StyleContext()) {
 301           NS_ASSERTION(col->StyleContext() == colFrame->StyleContext() &&
 302                        col->GetContent() == colFrame->GetContent(),
 303                        "How did that happen??");
 304         }
 305         // else colFrame is being removed because of a frame
 306         // reconstruct on it, and its style context is still the old
 307         // one, so we can't assert anything about how it compares to
 308         // col's style context.
 309 #endif
 310         nextCol = col->GetNextCol();
 311         RemoveFrame(kPrincipalList, col);
 312         col = nextCol;
 313       }
 314     }
 315
 316     int32_t colIndex = colFrame->GetColIndex();
 317     // The RemoveChild call handles calling FrameNeedsReflow on us.
 318     RemoveChild(*colFrame, true);
 319
 320     nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
 321     tableFrame->RemoveCol(this, colIndex, true, true);
 322     if (mFrames.IsEmpty() && contentRemoval &&
 323         GetColType() == eColGroupContent) {
 324       tableFrame->AppendAnonymousColFrames(this, GetSpan(),
 325                                            eColAnonymousColGroup, true);
 326     }
 327   }
 328   else {
 329     mFrames.DestroyFrame(aOldFrame);
 330   }
 331 }
 332
 333 nsIFrame::LogicalSides
 334 nsTableColGroupFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const
 335 {
 336   if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak ==
 337                      NS_STYLE_BOX_DECORATION_BREAK_CLONE)) {
 338     return LogicalSides();
 339   }
 340
 341   LogicalSides skip;
 342   if (nullptr != GetPrevInFlow()) {
 343     skip |= eLogicalSideBitsBStart;
 344   }
 345   if (nullptr != GetNextInFlow()) {
 346     skip |= eLogicalSideBitsBEnd;
 347   }
 348   return skip;
 349 }
 350
 351 void
 352 nsTableColGroupFrame::Reflow(nsPresContext*          aPresContext,
 353                                        nsHTMLReflowMetrics&     aDesiredSize,
 354                                        const nsHTMLReflowState& aReflowState,
 355                                        nsReflowStatus&          aStatus)
 356 {
 357   DO_GLOBAL_REFLOW_COUNT("nsTableColGroupFrame");
 358   DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
 359   NS_ASSERTION(nullptr!=mContent, "bad state -- null content for frame");
 360
 361   const nsStyleVisibility* groupVis = StyleVisibility();
 362   bool collapseGroup = (NS_STYLE_VISIBILITY_COLLAPSE == groupVis->mVisible);
 363   if (collapseGroup) {
 364     nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
 365     tableFrame->SetNeedToCollapse(true);
 366   }
 367   // for every content child that (is a column thingy and does not already have a frame)
 368   // create a frame and adjust it's style
 369
 370   for (nsIFrame *kidFrame = mFrames.FirstChild(); kidFrame;
 371        kidFrame = kidFrame->GetNextSibling()) {
 372     // Give the child frame a chance to reflow, even though we know it'll have 0 size
 373     nsHTMLReflowMetrics kidSize(aReflowState);
 374     nsHTMLReflowState kidReflowState(aPresContext, aReflowState, kidFrame,
 375                                      LogicalSize(kidFrame->GetWritingMode()));
 376
 377     nsReflowStatus status;
 378     ReflowChild(kidFrame, aPresContext, kidSize, kidReflowState, 0, 0, 0, status);
 379     FinishReflowChild(kidFrame, aPresContext, kidSize, nullptr, 0, 0, 0);
 380   }
 381
 382   aDesiredSize.ClearSize();
 383   aStatus = NS_FRAME_COMPLETE;
 384   NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
 385 }
 386
 387 nsTableColFrame * nsTableColGroupFrame::GetFirstColumn()
 388 {
 389   return GetNextColumn(nullptr);
 390 }
 391
 392 nsTableColFrame * nsTableColGroupFrame::GetNextColumn(nsIFrame *aChildFrame)
 393 {
 394   nsTableColFrame *result = nullptr;
 395   nsIFrame *childFrame = aChildFrame;
 396   if (!childFrame) {
 397     childFrame = mFrames.FirstChild();
 398   }
 399   else {
 400     childFrame = childFrame->GetNextSibling();
 401   }
 402   while (childFrame)
 403   {
 404     if (NS_STYLE_DISPLAY_TABLE_COLUMN ==
 405         childFrame->StyleDisplay()->mDisplay)
 406     {
 407       result = (nsTableColFrame *)childFrame;
 408       break;
 409     }
 410     childFrame = childFrame->GetNextSibling();
 411   }
 412   return result;
 413 }
 414
 415 int32_t nsTableColGroupFrame::GetSpan()
 416 {
 417   return StyleTable()->mSpan;
 418 }
 419
 420 void nsTableColGroupFrame::SetContinuousBCBorderWidth(uint8_t     aForSide,
 421                                                       BCPixelSize aPixelValue)
 422 {
 423   switch (aForSide) {
 424     case NS_SIDE_TOP:
 425       mTopContBorderWidth = aPixelValue;
 426       return;
 427     case NS_SIDE_BOTTOM:
 428       mBottomContBorderWidth = aPixelValue;
 429       return;
 430     default:
 431       NS_ERROR("invalid side arg");
 432   }
 433 }
 434
 435 void nsTableColGroupFrame::GetContinuousBCBorderWidth(nsMargin& aBorder)
 436 {
 437   int32_t aPixelsToTwips = nsPresContext::AppUnitsPerCSSPixel();
 438   nsTableFrame* table = nsTableFrame::GetTableFrame(this);
 439   nsTableColFrame* col = table->GetColFrame(mStartColIndex + mColCount - 1);
 440   col->GetContinuousBCBorderWidth(aBorder);
 441   aBorder.top = BC_BORDER_BOTTOM_HALF_COORD(aPixelsToTwips,
 442                                             mTopContBorderWidth);
 443   aBorder.bottom = BC_BORDER_TOP_HALF_COORD(aPixelsToTwips,
 444                                             mBottomContBorderWidth);
 445 }
 446
 447 /* ----- global methods ----- */
 448
 449 nsTableColGroupFrame*
 450 NS_NewTableColGroupFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
 451 {
 452   return new (aPresShell) nsTableColGroupFrame(aContext);
 453 }
 454
 455 NS_IMPL_FRAMEARENA_HELPERS(nsTableColGroupFrame)
 456
 457 nsIAtom*
 458 nsTableColGroupFrame::GetType() const
 459 {
 460   return nsGkAtoms::tableColGroupFrame;
 461 }
 462
 463 void
 464 nsTableColGroupFrame::InvalidateFrame(uint32_t aDisplayItemKey)
 465 {
 466   nsIFrame::InvalidateFrame(aDisplayItemKey);
 467   GetParent()->InvalidateFrameWithRect(GetVisualOverflowRect() + GetPosition(), aDisplayItemKey);
 468 }
 469
 470 void
 471 nsTableColGroupFrame::InvalidateFrameWithRect(const nsRect& aRect, uint32_t aDisplayItemKey)
 472 {
 473   nsIFrame::InvalidateFrameWithRect(aRect, aDisplayItemKey);
 474   // If we have filters applied that would affects our bounds, then
 475   // we get an inactive layer created and this is computed
 476   // within FrameLayerBuilder
 477   GetParent()->InvalidateFrameWithRect(aRect + GetPosition(), aDisplayItemKey);
 478 }
 479
 480 #ifdef DEBUG_FRAME_DUMP
 481 nsresult
 482 nsTableColGroupFrame::GetFrameName(nsAString& aResult) const
 483 {
 484   return MakeFrameName(NS_LITERAL_STRING("TableColGroup"), aResult);
 485 }
 486
 487 void nsTableColGroupFrame::Dump(int32_t aIndent)
 488 {
 489   char* indent = new char[aIndent + 1];
 490   if (!indent) return;
 491   for (int32_t i = 0; i < aIndent + 1; i++) {
 492     indent[i] = ' ';
 493   }
 494   indent[aIndent] = 0;
 495
 496   printf("%s**START COLGROUP DUMP**\n%s startcolIndex=%d  colcount=%d span=%d coltype=",
 497     indent, indent, GetStartColumnIndex(),  GetColCount(), GetSpan());
 498   nsTableColGroupType colType = GetColType();
 499   switch (colType) {
 500   case eColGroupContent:
 501     printf(" content ");
 502     break;
 503   case eColGroupAnonymousCol:
 504     printf(" anonymous-column  ");
 505     break;
 506   case eColGroupAnonymousCell:
 507     printf(" anonymous-cell ");
 508     break;
 509   }
 510   // verify the colindices
 511   int32_t j = GetStartColumnIndex();
 512   nsTableColFrame* col = GetFirstColumn();
 513   while (col) {
 514     NS_ASSERTION(j == col->GetColIndex(), "wrong colindex on col frame");
 515     col = col->GetNextCol();
 516     j++;
 517   }
 518   NS_ASSERTION((j - GetStartColumnIndex()) == GetColCount(),
 519                "number of cols out of sync");
 520   printf("\n%s**END COLGROUP DUMP** ", indent);
 521   delete [] indent;
 522 }
 523 #endif
 524