Source/WebCore/rendering/RenderFlexibleBox.cpp

   1 /*
   2  * Copyright (C) 2011 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "RenderFlexibleBox.h"
  33
  34 #include "LayoutRepainter.h"
  35 #include "RenderLayer.h"
  36 #include "RenderView.h"
  37
  38 namespace WebCore {
  39
  40 // Normally, -1 and 0 are not valid in a HashSet, but these are relatively likely flex-order values. Instead,
  41 // we make the two smallest int values invalid flex-order values (in the css parser code we clamp them to
  42 // int min + 2).
  43 struct RenderFlexibleBox::FlexOrderHashTraits : WTF::GenericHashTraits<int> {
  44     static const bool emptyValueIsZero = false;
  45     static int emptyValue() { return std::numeric_limits<int>::min(); }
  46     static void constructDeletedValue(int& slot) { slot = std::numeric_limits<int>::min() + 1; }
  47     static bool isDeletedValue(int value) { return value == std::numeric_limits<int>::min() + 1; }
  48 };
  49
  50 class RenderFlexibleBox::FlexOrderIterator {
  51 public:
  52     FlexOrderIterator(RenderFlexibleBox* flexibleBox, const FlexOrderHashSet& flexOrderValues)
  53         : m_flexibleBox(flexibleBox)
  54         , m_currentChild(0)
  55         , m_orderValuesIterator(0)
  56     {
  57         copyToVector(flexOrderValues, m_orderValues);
  58         std::sort(m_orderValues.begin(), m_orderValues.end());
  59     }
  60
  61     RenderBox* first()
  62     {
  63         reset();
  64         return next();
  65     }
  66
  67     RenderBox* next()
  68     {
  69         do {
  70             if (!m_currentChild) {
  71                 if (m_orderValuesIterator == m_orderValues.end())
  72                     return 0;
  73                 if (m_orderValuesIterator) {
  74                     ++m_orderValuesIterator;
  75                     if (m_orderValuesIterator == m_orderValues.end())
  76                         return 0;
  77                 } else
  78                     m_orderValuesIterator = m_orderValues.begin();
  79
  80                 m_currentChild = m_flexibleBox->firstChildBox();
  81             } else
  82                 m_currentChild = m_currentChild->nextSiblingBox();
  83         } while (!m_currentChild || m_currentChild->style()->flexOrder() != *m_orderValuesIterator);
  84
  85         return m_currentChild;
  86     }
  87
  88     void reset()
  89     {
  90         m_currentChild = 0;
  91         m_orderValuesIterator = 0;
  92     }
  93
  94 private:
  95     RenderFlexibleBox* m_flexibleBox;
  96     RenderBox* m_currentChild;
  97     Vector<int> m_orderValues;
  98     Vector<int>::const_iterator m_orderValuesIterator;
  99 };
 100
 101
 102 RenderFlexibleBox::RenderFlexibleBox(Node* node)
 103     : RenderBlock(node)
 104 {
 105     setChildrenInline(false); // All of our children must be block-level.
 106 }
 107
 108 RenderFlexibleBox::~RenderFlexibleBox()
 109 {
 110 }
 111
 112 const char* RenderFlexibleBox::renderName() const
 113 {
 114     return "RenderFlexibleBox";
 115 }
 116
 117 static LayoutUnit marginLogicalWidthForChild(RenderBox* child, RenderStyle* parentStyle)
 118 {
 119     // A margin has three types: fixed, percentage, and auto (variable).
 120     // Auto and percentage margins become 0 when computing min/max width.
 121     // Fixed margins can be added in as is.
 122     Length marginLeft = child->style()->marginStartUsing(parentStyle);
 123     Length marginRight = child->style()->marginEndUsing(parentStyle);
 124     LayoutUnit margin = 0;
 125     if (marginLeft.isFixed())
 126         margin += marginLeft.value();
 127     if (marginRight.isFixed())
 128         margin += marginRight.value();
 129     return margin;
 130 }
 131
 132 void RenderFlexibleBox::computePreferredLogicalWidths()
 133 {
 134     ASSERT(preferredLogicalWidthsDirty());
 135
 136     RenderStyle* styleToUse = style();
 137     if (styleToUse->logicalWidth().isFixed() && styleToUse->logicalWidth().value() > 0)
 138         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = computeContentBoxLogicalWidth(styleToUse->logicalWidth().value());
 139     else {
 140         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = 0;
 141
 142         for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
 143             if (child->isPositioned())
 144                 continue;
 145
 146             LayoutUnit margin = marginLogicalWidthForChild(child, style());
 147             bool hasOrthogonalWritingMode = child->isHorizontalWritingMode() != isHorizontalWritingMode();
 148             LayoutUnit minPreferredLogicalWidth = hasOrthogonalWritingMode ? child->logicalHeight() : child->minPreferredLogicalWidth();
 149             LayoutUnit maxPreferredLogicalWidth = hasOrthogonalWritingMode ? child->logicalHeight() : child->maxPreferredLogicalWidth();
 150             minPreferredLogicalWidth += margin;
 151             maxPreferredLogicalWidth += margin;
 152             if (!isColumnFlow()) {
 153                 m_minPreferredLogicalWidth += minPreferredLogicalWidth;
 154                 m_maxPreferredLogicalWidth += maxPreferredLogicalWidth;
 155             } else {
 156                 m_minPreferredLogicalWidth = std::max(minPreferredLogicalWidth, m_minPreferredLogicalWidth);
 157                 m_maxPreferredLogicalWidth = std::max(maxPreferredLogicalWidth, m_maxPreferredLogicalWidth);
 158             }
 159         }
 160
 161         m_maxPreferredLogicalWidth = std::max(m_minPreferredLogicalWidth, m_maxPreferredLogicalWidth);
 162     }
 163
 164     LayoutUnit scrollbarWidth = 0;
 165     if (hasOverflowClip()) {
 166         if (isHorizontalWritingMode() && styleToUse->overflowY() == OSCROLL) {
 167             layer()->setHasVerticalScrollbar(true);
 168             scrollbarWidth = verticalScrollbarWidth();
 169         } else if (!isHorizontalWritingMode() && styleToUse->overflowX() == OSCROLL) {
 170             layer()->setHasHorizontalScrollbar(true);
 171             scrollbarWidth = horizontalScrollbarHeight();
 172         }
 173     }
 174
 175     m_maxPreferredLogicalWidth += scrollbarWidth;
 176     m_minPreferredLogicalWidth += scrollbarWidth;
 177
 178     if (styleToUse->logicalMinWidth().isFixed() && styleToUse->logicalMinWidth().value() > 0) {
 179         m_maxPreferredLogicalWidth = std::max(m_maxPreferredLogicalWidth, computeContentBoxLogicalWidth(styleToUse->logicalMinWidth().value()));
 180         m_minPreferredLogicalWidth = std::max(m_minPreferredLogicalWidth, computeContentBoxLogicalWidth(styleToUse->logicalMinWidth().value()));
 181     }
 182
 183     if (styleToUse->logicalMaxWidth().isFixed()) {
 184         m_maxPreferredLogicalWidth = std::min(m_maxPreferredLogicalWidth, computeContentBoxLogicalWidth(styleToUse->logicalMaxWidth().value()));
 185         m_minPreferredLogicalWidth = std::min(m_minPreferredLogicalWidth, computeContentBoxLogicalWidth(styleToUse->logicalMaxWidth().value()));
 186     }
 187
 188     LayoutUnit borderAndPadding = borderAndPaddingLogicalWidth();
 189     m_minPreferredLogicalWidth += borderAndPadding;
 190     m_maxPreferredLogicalWidth += borderAndPadding;
 191
 192     setPreferredLogicalWidthsDirty(false);
 193 }
 194
 195 void RenderFlexibleBox::layoutBlock(bool relayoutChildren, int, BlockLayoutPass)
 196 {
 197     ASSERT(needsLayout());
 198
 199     if (!relayoutChildren && simplifiedLayout())
 200         return;
 201
 202     LayoutRepainter repainter(*this, checkForRepaintDuringLayout());
 203     LayoutStateMaintainer statePusher(view(), this, IntSize(x(), y()), hasTransform() || hasReflection() || style()->isFlippedBlocksWritingMode());
 204
 205     if (inRenderFlowThread()) {
 206         // Regions changing widths can force us to relayout our children.
 207         if (logicalWidthChangedInRegions())
 208             relayoutChildren = true;
 209     }
 210     computeInitialRegionRangeForBlock();
 211
 212     IntSize previousSize = size();
 213
 214     setLogicalHeight(0);
 215     // We need to call both of these because we grab both crossAxisExtent and mainAxisExtent in layoutFlexItems.
 216     computeLogicalWidth();
 217     computeLogicalHeight();
 218
 219     m_overflow.clear();
 220
 221     // For overflow:scroll blocks, ensure we have both scrollbars in place always.
 222     if (scrollsOverflow()) {
 223         if (style()->overflowX() == OSCROLL)
 224             layer()->setHasHorizontalScrollbar(true);
 225         if (style()->overflowY() == OSCROLL)
 226             layer()->setHasVerticalScrollbar(true);
 227     }
 228
 229     layoutFlexItems(relayoutChildren);
 230
 231     LayoutUnit oldClientAfterEdge = clientLogicalBottom();
 232     computeLogicalHeight();
 233
 234     if (size() != previousSize)
 235         relayoutChildren = true;
 236
 237     layoutPositionedObjects(relayoutChildren || isRoot());
 238
 239     computeRegionRangeForBlock();
 240
 241     // FIXME: css3/flexbox/repaint-rtl-column.html seems to repaint more overflow than it needs to.
 242     computeOverflow(oldClientAfterEdge);
 243     statePusher.pop();
 244
 245     updateLayerTransform();
 246
 247     // Update our scroll information if we're overflow:auto/scroll/hidden now that we know if
 248     // we overflow or not.
 249     if (hasOverflowClip())
 250         layer()->updateScrollInfoAfterLayout();
 251
 252     repainter.repaintAfterLayout();
 253
 254     setNeedsLayout(false);
 255 }
 256
 257 bool RenderFlexibleBox::hasOrthogonalFlow(RenderBox* child) const
 258 {
 259     // FIXME: If the child is a flexbox, then we need to check isHorizontalFlow.
 260     return isHorizontalFlow() != child->isHorizontalWritingMode();
 261 }
 262
 263 bool RenderFlexibleBox::isColumnFlow() const
 264 {
 265     return style()->isColumnFlexDirection();
 266 }
 267
 268 bool RenderFlexibleBox::isHorizontalFlow() const
 269 {
 270     if (isHorizontalWritingMode())
 271         return !isColumnFlow();
 272     return isColumnFlow();
 273 }
 274
 275 bool RenderFlexibleBox::isLeftToRightFlow() const
 276 {
 277     if (isColumnFlow())
 278         return style()->writingMode() == TopToBottomWritingMode || style()->writingMode() == LeftToRightWritingMode;
 279     return style()->isLeftToRightDirection() ^ (style()->flexDirection() == FlowRowReverse);
 280 }
 281
 282 Length RenderFlexibleBox::mainAxisLengthForChild(RenderBox* child) const
 283 {
 284     return isHorizontalFlow() ? child->style()->width() : child->style()->height();
 285 }
 286
 287 Length RenderFlexibleBox::crossAxisLength() const
 288 {
 289     return isHorizontalFlow() ? style()->height() : style()->width();
 290 }
 291
 292 void RenderFlexibleBox::setCrossAxisExtent(LayoutUnit extent)
 293 {
 294     if (isHorizontalFlow())
 295         setHeight(extent);
 296     else
 297         setWidth(extent);
 298 }
 299
 300 LayoutUnit RenderFlexibleBox::crossAxisExtentForChild(RenderBox* child)
 301 {
 302     return isHorizontalFlow() ? child->height() : child->width();
 303 }
 304
 305 LayoutUnit RenderFlexibleBox::mainAxisExtentForChild(RenderBox* child)
 306 {
 307     return isHorizontalFlow() ? child->width() : child->height();
 308 }
 309
 310 LayoutUnit RenderFlexibleBox::crossAxisExtent() const
 311 {
 312     return isHorizontalFlow() ? height() : width();
 313 }
 314
 315 LayoutUnit RenderFlexibleBox::mainAxisExtent() const
 316 {
 317     return isHorizontalFlow() ? width() : height();
 318 }
 319
 320 LayoutUnit RenderFlexibleBox::crossAxisContentExtent() const
 321 {
 322     return isHorizontalFlow() ? contentHeight() : contentWidth();
 323 }
 324
 325 LayoutUnit RenderFlexibleBox::mainAxisContentExtent() const
 326 {
 327     return isHorizontalFlow() ? contentWidth() : contentHeight();
 328 }
 329
 330 WritingMode RenderFlexibleBox::transformedWritingMode() const
 331 {
 332     WritingMode mode = style()->writingMode();
 333     if (!isColumnFlow())
 334         return mode;
 335
 336     switch (mode) {
 337     case TopToBottomWritingMode:
 338     case BottomToTopWritingMode:
 339         return style()->isLeftToRightDirection() ? LeftToRightWritingMode : RightToLeftWritingMode;
 340     case LeftToRightWritingMode:
 341     case RightToLeftWritingMode:
 342         return style()->isLeftToRightDirection() ? TopToBottomWritingMode : BottomToTopWritingMode;
 343     }
 344     ASSERT_NOT_REACHED();
 345     return TopToBottomWritingMode;
 346 }
 347
 348 LayoutUnit RenderFlexibleBox::flowAwareBorderStart() const
 349 {
 350     if (isHorizontalFlow())
 351         return isLeftToRightFlow() ? borderLeft() : borderRight();
 352     return isLeftToRightFlow() ? borderTop() : borderBottom();
 353 }
 354
 355 LayoutUnit RenderFlexibleBox::flowAwareBorderEnd() const
 356 {
 357     if (isHorizontalFlow())
 358         return isLeftToRightFlow() ? borderRight() : borderLeft();
 359     return isLeftToRightFlow() ? borderBottom() : borderTop();
 360 }
 361
 362 LayoutUnit RenderFlexibleBox::flowAwareBorderBefore() const
 363 {
 364     switch (transformedWritingMode()) {
 365     case TopToBottomWritingMode:
 366         return borderTop();
 367     case BottomToTopWritingMode:
 368         return borderBottom();
 369     case LeftToRightWritingMode:
 370         return borderLeft();
 371     case RightToLeftWritingMode:
 372         return borderRight();
 373     }
 374     ASSERT_NOT_REACHED();
 375     return borderTop();
 376 }
 377
 378 LayoutUnit RenderFlexibleBox::crossAxisBorderAndPaddingExtent() const
 379 {
 380     return isHorizontalFlow() ? borderAndPaddingHeight() : borderAndPaddingWidth();
 381 }
 382
 383 LayoutUnit RenderFlexibleBox::flowAwarePaddingStart() const
 384 {
 385     if (isHorizontalFlow())
 386         return isLeftToRightFlow() ? paddingLeft() : paddingRight();
 387     return isLeftToRightFlow() ? paddingTop() : paddingBottom();
 388 }
 389
 390 LayoutUnit RenderFlexibleBox::flowAwarePaddingEnd() const
 391 {
 392     if (isHorizontalFlow())
 393         return isLeftToRightFlow() ? paddingRight() : paddingLeft();
 394     return isLeftToRightFlow() ? paddingBottom() : paddingTop();
 395 }
 396
 397 LayoutUnit RenderFlexibleBox::flowAwarePaddingBefore() const
 398 {
 399     switch (transformedWritingMode()) {
 400     case TopToBottomWritingMode:
 401         return paddingTop();
 402     case BottomToTopWritingMode:
 403         return paddingBottom();
 404     case LeftToRightWritingMode:
 405         return paddingLeft();
 406     case RightToLeftWritingMode:
 407         return paddingRight();
 408     }
 409     ASSERT_NOT_REACHED();
 410     return paddingTop();
 411 }
 412
 413 LayoutUnit RenderFlexibleBox::flowAwareMarginStartForChild(RenderBox* child) const
 414 {
 415     if (isHorizontalFlow())
 416         return isLeftToRightFlow() ? child->marginLeft() : child->marginRight();
 417     return isLeftToRightFlow() ? child->marginTop() : child->marginBottom();
 418 }
 419
 420 LayoutUnit RenderFlexibleBox::flowAwareMarginEndForChild(RenderBox* child) const
 421 {
 422     if (isHorizontalFlow())
 423         return isLeftToRightFlow() ? child->marginRight() : child->marginLeft();
 424     return isLeftToRightFlow() ? child->marginBottom() : child->marginTop();
 425 }
 426
 427 LayoutUnit RenderFlexibleBox::flowAwareMarginBeforeForChild(RenderBox* child) const
 428 {
 429     switch (transformedWritingMode()) {
 430     case TopToBottomWritingMode:
 431         return child->marginTop();
 432     case BottomToTopWritingMode:
 433         return child->marginBottom();
 434     case LeftToRightWritingMode:
 435         return child->marginLeft();
 436     case RightToLeftWritingMode:
 437         return child->marginRight();
 438     }
 439     ASSERT_NOT_REACHED();
 440     return marginTop();
 441 }
 442
 443 LayoutUnit RenderFlexibleBox::flowAwareMarginAfterForChild(RenderBox* child) const
 444 {
 445     switch (transformedWritingMode()) {
 446     case TopToBottomWritingMode:
 447         return child->marginBottom();
 448     case BottomToTopWritingMode:
 449         return child->marginTop();
 450     case LeftToRightWritingMode:
 451         return child->marginRight();
 452     case RightToLeftWritingMode:
 453         return child->marginLeft();
 454     }
 455     ASSERT_NOT_REACHED();
 456     return marginBottom();
 457 }
 458
 459 LayoutUnit RenderFlexibleBox::crossAxisMarginExtentForChild(RenderBox* child) const
 460 {
 461     return isHorizontalFlow() ? child->marginTop() + child->marginBottom() : child->marginLeft() + child->marginRight();
 462 }
 463
 464 LayoutUnit RenderFlexibleBox::crossAxisScrollbarExtent() const
 465 {
 466     return isHorizontalFlow() ? horizontalScrollbarHeight() : verticalScrollbarWidth();
 467 }
 468
 469 LayoutPoint RenderFlexibleBox::flowAwareLocationForChild(RenderBox* child) const
 470 {
 471     return isHorizontalFlow() ? child->location() : child->location().transposedPoint();
 472 }
 473
 474 void RenderFlexibleBox::setFlowAwareLocationForChild(RenderBox* child, const LayoutPoint& location)
 475 {
 476     if (isHorizontalFlow())
 477         child->setLocation(location);
 478     else
 479         child->setLocation(location.transposedPoint());
 480 }
 481
 482 LayoutUnit RenderFlexibleBox::mainAxisBorderAndPaddingExtentForChild(RenderBox* child) const
 483 {
 484     return isHorizontalFlow() ? child->borderAndPaddingWidth() : child->borderAndPaddingHeight();
 485 }
 486
 487 LayoutUnit RenderFlexibleBox::mainAxisScrollbarExtentForChild(RenderBox* child) const
 488 {
 489     return isHorizontalFlow() ? child->verticalScrollbarWidth() : child->horizontalScrollbarHeight();
 490 }
 491
 492 LayoutUnit RenderFlexibleBox::preferredMainAxisContentExtentForChild(RenderBox* child) const
 493 {
 494     Length mainAxisLength = mainAxisLengthForChild(child);
 495     if (mainAxisLength.isAuto()) {
 496         LayoutUnit mainAxisExtent = hasOrthogonalFlow(child) ? child->logicalHeight() : child->maxPreferredLogicalWidth();
 497         return mainAxisExtent - mainAxisBorderAndPaddingExtentForChild(child) - mainAxisScrollbarExtentForChild(child);
 498     }
 499     return mainAxisLength.calcMinValue(mainAxisContentExtent());
 500 }
 501
 502 void RenderFlexibleBox::layoutFlexItems(bool relayoutChildren)
 503 {
 504     FlexOrderHashSet flexOrderValues;
 505     computeMainAxisPreferredSizes(relayoutChildren, flexOrderValues);
 506
 507     OrderedFlexItemList orderedChildren;
 508     LayoutUnit preferredMainAxisExtent;
 509     float totalPositiveFlexibility;
 510     float totalNegativeFlexibility;
 511     FlexOrderIterator flexIterator(this, flexOrderValues);
 512     computeFlexOrder(flexIterator, orderedChildren, preferredMainAxisExtent, totalPositiveFlexibility, totalNegativeFlexibility);
 513
 514     LayoutUnit availableFreeSpace = mainAxisContentExtent() - preferredMainAxisExtent;
 515     InflexibleFlexItemSize inflexibleItems;
 516     WTF::Vector<LayoutUnit> childSizes;
 517     while (!runFreeSpaceAllocationAlgorithm(orderedChildren, availableFreeSpace, totalPositiveFlexibility, totalNegativeFlexibility, inflexibleItems, childSizes)) {
 518         ASSERT(totalPositiveFlexibility >= 0 && totalNegativeFlexibility >= 0);
 519         ASSERT(inflexibleItems.size() > 0);
 520     }
 521
 522     layoutAndPlaceChildren(orderedChildren, childSizes, availableFreeSpace);
 523 }
 524
 525 float RenderFlexibleBox::positiveFlexForChild(RenderBox* child) const
 526 {
 527     return isHorizontalFlow() ? child->style()->flexboxWidthPositiveFlex() : child->style()->flexboxHeightPositiveFlex();
 528 }
 529
 530 float RenderFlexibleBox::negativeFlexForChild(RenderBox* child) const
 531 {
 532     return isHorizontalFlow() ? child->style()->flexboxWidthNegativeFlex() : child->style()->flexboxHeightNegativeFlex();
 533 }
 534
 535 LayoutUnit RenderFlexibleBox::availableAlignmentSpaceForChild(RenderBox* child)
 536 {
 537     LayoutUnit crossContentExtent = crossAxisContentExtent();
 538     LayoutUnit childCrossExtent = crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child);
 539     return crossContentExtent - childCrossExtent;
 540 }
 541
 542 LayoutUnit RenderFlexibleBox::marginBoxAscent(RenderBox* child)
 543 {
 544     LayoutUnit ascent = child->firstLineBoxBaseline();
 545     if (ascent == -1)
 546         ascent = crossAxisExtentForChild(child) + flowAwareMarginAfterForChild(child);
 547     return ascent + flowAwareMarginBeforeForChild(child);
 548 }
 549
 550 void RenderFlexibleBox::computeMainAxisPreferredSizes(bool relayoutChildren, FlexOrderHashSet& flexOrderValues)
 551 {
 552     LayoutUnit flexboxAvailableContentExtent = mainAxisContentExtent();
 553     for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
 554         flexOrderValues.add(child->style()->flexOrder());
 555
 556         if (child->isPositioned())
 557             continue;
 558
 559         child->clearOverrideSize();
 560         if (mainAxisLengthForChild(child).isAuto()) {
 561             if (!relayoutChildren)
 562                 child->setChildNeedsLayout(true);
 563             child->layoutIfNeeded();
 564         }
 565
 566         // We set the margins because we want to make sure 'auto' has a margin
 567         // of 0 and because if we're not auto sizing, we don't do a layout that
 568         // computes the start/end margins.
 569         if (isHorizontalFlow()) {
 570             child->setMarginLeft(child->style()->marginLeft().calcMinValue(flexboxAvailableContentExtent));
 571             child->setMarginRight(child->style()->marginRight().calcMinValue(flexboxAvailableContentExtent));
 572         } else {
 573             child->setMarginTop(child->style()->marginTop().calcMinValue(flexboxAvailableContentExtent));
 574             child->setMarginBottom(child->style()->marginBottom().calcMinValue(flexboxAvailableContentExtent));
 575         }
 576     }
 577 }
 578
 579 void RenderFlexibleBox::computeFlexOrder(FlexOrderIterator& iterator, OrderedFlexItemList& orderedChildren, LayoutUnit& preferredMainAxisExtent, float& totalPositiveFlexibility, float& totalNegativeFlexibility)
 580 {
 581     orderedChildren.clear();
 582     preferredMainAxisExtent = 0;
 583     totalPositiveFlexibility = totalNegativeFlexibility = 0;
 584     for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
 585         orderedChildren.append(child);
 586         if (child->isPositioned())
 587             continue;
 588
 589         LayoutUnit childMainAxisExtent = mainAxisBorderAndPaddingExtentForChild(child) + preferredMainAxisContentExtentForChild(child);
 590         if (isHorizontalFlow())
 591             childMainAxisExtent += child->marginLeft() + child->marginRight();
 592         else
 593             childMainAxisExtent += child->marginTop() + child->marginBottom();
 594
 595         // FIXME: When implementing multiline, we would return here if adding
 596         // the child's main axis extent would cause us to overflow.
 597         preferredMainAxisExtent += childMainAxisExtent;
 598         totalPositiveFlexibility += positiveFlexForChild(child);
 599         totalNegativeFlexibility += negativeFlexForChild(child);
 600     }
 601 }
 602
 603 // Returns true if we successfully ran the algorithm and sized the flex items.
 604 bool RenderFlexibleBox::runFreeSpaceAllocationAlgorithm(const OrderedFlexItemList& children, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize& inflexibleItems, WTF::Vector<LayoutUnit>& childSizes)
 605 {
 606     childSizes.clear();
 607
 608     LayoutUnit flexboxAvailableContentExtent = mainAxisContentExtent();
 609     for (size_t i = 0; i < children.size(); ++i) {
 610         RenderBox* child = children[i];
 611         if (child->isPositioned()) {
 612             childSizes.append(0);
 613             continue;
 614         }
 615
 616         LayoutUnit childPreferredSize;
 617         if (inflexibleItems.contains(child))
 618             childPreferredSize = inflexibleItems.get(child);
 619         else {
 620             childPreferredSize = preferredMainAxisContentExtentForChild(child);
 621             if (availableFreeSpace > 0 && totalPositiveFlexibility > 0) {
 622                 childPreferredSize += lroundf(availableFreeSpace * positiveFlexForChild(child) / totalPositiveFlexibility);
 623
 624                 Length childLogicalMaxWidth = isHorizontalFlow() ? child->style()->maxWidth() : child->style()->maxHeight();
 625                 if (!childLogicalMaxWidth.isUndefined() && childLogicalMaxWidth.isSpecified() && childPreferredSize > childLogicalMaxWidth.calcValue(flexboxAvailableContentExtent)) {
 626                     childPreferredSize = childLogicalMaxWidth.calcValue(flexboxAvailableContentExtent);
 627                     availableFreeSpace -= childPreferredSize - preferredMainAxisContentExtentForChild(child);
 628                     totalPositiveFlexibility -= positiveFlexForChild(child);
 629
 630                     inflexibleItems.set(child, childPreferredSize);
 631                     return false;
 632                 }
 633             } else if (availableFreeSpace < 0 && totalNegativeFlexibility > 0) {
 634                 childPreferredSize += lroundf(availableFreeSpace * negativeFlexForChild(child) / totalNegativeFlexibility);
 635
 636                 Length childLogicalMinWidth = isHorizontalFlow() ? child->style()->minWidth() : child->style()->minHeight();
 637                 if (!childLogicalMinWidth.isUndefined() && childLogicalMinWidth.isSpecified() && childPreferredSize < childLogicalMinWidth.calcValue(flexboxAvailableContentExtent)) {
 638                     childPreferredSize = childLogicalMinWidth.calcValue(flexboxAvailableContentExtent);
 639                     availableFreeSpace += preferredMainAxisContentExtentForChild(child) - childPreferredSize;
 640                     totalNegativeFlexibility -= negativeFlexForChild(child);
 641
 642                     inflexibleItems.set(child, childPreferredSize);
 643                     return false;
 644                 }
 645             }
 646         }
 647         childSizes.append(childPreferredSize);
 648     }
 649     return true;
 650 }
 651
 652 static LayoutUnit initialPackingOffset(LayoutUnit availableFreeSpace, EFlexPack flexPack, size_t numberOfChildren)
 653 {
 654     if (availableFreeSpace > 0) {
 655         if (flexPack == PackEnd)
 656             return availableFreeSpace;
 657         if (flexPack == PackCenter)
 658             return availableFreeSpace / 2;
 659         if (flexPack == PackDistribute && numberOfChildren)
 660             return availableFreeSpace / (2 * numberOfChildren);
 661     } else if (availableFreeSpace < 0) {
 662         if (flexPack == PackCenter || flexPack == PackDistribute)
 663             return availableFreeSpace / 2;
 664     }
 665     return 0;
 666 }
 667
 668 static LayoutUnit packingSpaceBetweenChildren(LayoutUnit availableFreeSpace, EFlexPack flexPack, size_t numberOfChildren)
 669 {
 670     if (availableFreeSpace > 0 && numberOfChildren > 1) {
 671         if (flexPack == PackJustify)
 672             return availableFreeSpace / (numberOfChildren - 1);
 673         if (flexPack == PackDistribute)
 674             return availableFreeSpace / numberOfChildren;
 675     }
 676     return 0;
 677 }
 678
 679 void RenderFlexibleBox::setLogicalOverrideSize(RenderBox* child, LayoutUnit childPreferredSize)
 680 {
 681     // FIXME: Rename setOverrideWidth/setOverrideHeight to setOverrideLogicalWidth/setOverrideLogicalHeight.
 682     if (hasOrthogonalFlow(child))
 683         child->setOverrideHeight(childPreferredSize);
 684     else
 685         child->setOverrideWidth(childPreferredSize);
 686 }
 687
 688 void RenderFlexibleBox::prepareChildForPositionedLayout(RenderBox* child, LayoutUnit mainAxisOffset, LayoutUnit crossAxisOffset)
 689 {
 690     ASSERT(child->isPositioned());
 691     child->containingBlock()->insertPositionedObject(child);
 692     RenderLayer* childLayer = child->layer();
 693     LayoutUnit inlinePosition = isColumnFlow() ? crossAxisOffset : mainAxisOffset;
 694     if (style()->flexDirection() == FlowRowReverse)
 695         inlinePosition = mainAxisExtent() - mainAxisOffset;
 696     childLayer->setStaticInlinePosition(inlinePosition); // FIXME: Not right for regions.
 697
 698     LayoutUnit staticBlockPosition = isColumnFlow() ? mainAxisOffset : crossAxisOffset;
 699     if (childLayer->staticBlockPosition() != staticBlockPosition) {
 700         childLayer->setStaticBlockPosition(staticBlockPosition);
 701         if (child->style()->hasStaticBlockPosition(style()->isHorizontalWritingMode()))
 702             child->setChildNeedsLayout(true, false);
 703     }
 704 }
 705
 706 static EFlexAlign flexAlignForChild(RenderBox* child)
 707 {
 708     EFlexAlign align = child->style()->flexItemAlign();
 709     if (align == AlignAuto)
 710         return child->parent()->style()->flexAlign();
 711     return align;
 712 }
 713
 714 void RenderFlexibleBox::layoutAndPlaceChildren(const OrderedFlexItemList& children, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace)
 715 {
 716     LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
 717     mainAxisOffset += initialPackingOffset(availableFreeSpace, style()->flexPack(), childSizes.size());
 718     if (style()->flexDirection() == FlowRowReverse)
 719         mainAxisOffset += isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
 720
 721     LayoutUnit crossAxisOffset = flowAwareBorderBefore() + flowAwarePaddingBefore();
 722     LayoutUnit totalMainExtent = mainAxisExtent();
 723     LayoutUnit maxAscent = 0, maxDescent = 0; // Used when flex-align: baseline.
 724     bool shouldFlipMainAxis = !isColumnFlow() && !isLeftToRightFlow();
 725     for (size_t i = 0; i < children.size(); ++i) {
 726         RenderBox* child = children[i];
 727         if (child->isPositioned()) {
 728             prepareChildForPositionedLayout(child, mainAxisOffset, crossAxisOffset);
 729             mainAxisOffset += packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
 730             continue;
 731         }
 732         LayoutUnit childPreferredSize = childSizes[i] + mainAxisBorderAndPaddingExtentForChild(child);
 733         setLogicalOverrideSize(child, childPreferredSize);
 734         child->setChildNeedsLayout(true);
 735         child->layoutIfNeeded();
 736
 737         if (flexAlignForChild(child) == AlignBaseline) {
 738             LayoutUnit ascent = marginBoxAscent(child);
 739             LayoutUnit descent = (crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child)) - ascent;
 740
 741             maxAscent = std::max(maxAscent, ascent);
 742             maxDescent = std::max(maxDescent, descent);
 743
 744             if (crossAxisLength().isAuto())
 745                 setCrossAxisExtent(std::max(crossAxisExtent(), crossAxisBorderAndPaddingExtent() + crossAxisMarginExtentForChild(child) + maxAscent + maxDescent + crossAxisScrollbarExtent()));
 746         } else if (crossAxisLength().isAuto())
 747             setCrossAxisExtent(std::max(crossAxisExtent(), crossAxisBorderAndPaddingExtent() + crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child) + crossAxisScrollbarExtent()));
 748
 749         mainAxisOffset += flowAwareMarginStartForChild(child);
 750
 751         LayoutUnit childMainExtent = mainAxisExtentForChild(child);
 752         IntPoint childLocation(shouldFlipMainAxis ? totalMainExtent - mainAxisOffset - childMainExtent : mainAxisOffset,
 753             crossAxisOffset + flowAwareMarginBeforeForChild(child));
 754
 755         // FIXME: Supporting layout deltas.
 756         setFlowAwareLocationForChild(child, childLocation);
 757         mainAxisOffset += childMainExtent + flowAwareMarginEndForChild(child);
 758
 759         mainAxisOffset += packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
 760
 761         if (isColumnFlow())
 762             setLogicalHeight(mainAxisOffset + flowAwareBorderEnd() + flowAwarePaddingEnd() + scrollbarLogicalHeight());
 763     }
 764
 765     if (style()->flexDirection() == FlowColumnReverse) {
 766         // We have to do an extra pass for column-reverse to reposition the flex items since the start depends
 767         // on the height of the flexbox, which we only know after we've positioned all the flex items.
 768         computeLogicalHeight();
 769         layoutColumnReverse(children, childSizes, availableFreeSpace);
 770     }
 771
 772     alignChildren(children, maxAscent);
 773 }
 774
 775 void RenderFlexibleBox::layoutColumnReverse(const OrderedFlexItemList& children, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace)
 776 {
 777     // This is similar to the logic in layoutAndPlaceChildren, except we place the children
 778     // starting from the end of the flexbox. We also don't need to layout anything since we're
 779     // just moving the children to a new position.
 780     LayoutUnit mainAxisOffset = logicalHeight() - flowAwareBorderEnd() - flowAwarePaddingEnd();
 781     mainAxisOffset -= initialPackingOffset(availableFreeSpace, style()->flexPack(), childSizes.size());
 782     mainAxisOffset -= isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
 783
 784     LayoutUnit crossAxisOffset = flowAwareBorderBefore() + flowAwarePaddingBefore();
 785     for (size_t i = 0; i < children.size(); ++i) {
 786         RenderBox* child = children[i];
 787         if (child->isPositioned()) {
 788             child->layer()->setStaticBlockPosition(mainAxisOffset);
 789             mainAxisOffset -= packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
 790             continue;
 791         }
 792         mainAxisOffset -= mainAxisExtentForChild(child) + flowAwareMarginEndForChild(child);
 793
 794         LayoutRect oldRect = child->frameRect();
 795         setFlowAwareLocationForChild(child, IntPoint(mainAxisOffset, crossAxisOffset + flowAwareMarginBeforeForChild(child)));
 796         if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
 797             child->repaintDuringLayoutIfMoved(oldRect);
 798
 799         mainAxisOffset -= flowAwareMarginStartForChild(child);
 800         mainAxisOffset -= packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
 801     }
 802 }
 803
 804 void RenderFlexibleBox::adjustAlignmentForChild(RenderBox* child, LayoutUnit delta)
 805 {
 806     LayoutRect oldRect = child->frameRect();
 807
 808     setFlowAwareLocationForChild(child, flowAwareLocationForChild(child) + LayoutSize(0, delta));
 809
 810     // If the child moved, we have to repaint it as well as any floating/positioned
 811     // descendants. An exception is if we need a layout. In this case, we know we're going to
 812     // repaint ourselves (and the child) anyway.
 813     if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
 814         child->repaintDuringLayoutIfMoved(oldRect);
 815 }
 816
 817 void RenderFlexibleBox::alignChildren(const OrderedFlexItemList& children, LayoutUnit maxAscent)
 818 {
 819     LayoutUnit crossExtent = crossAxisExtent();
 820
 821     for (size_t i = 0; i < children.size(); ++i) {
 822         RenderBox* child = children[i];
 823         // direction:rtl + flex-direction:column means the cross-axis direction is flipped.
 824         if (!style()->isLeftToRightDirection() && isColumnFlow()) {
 825             LayoutPoint location = flowAwareLocationForChild(child);
 826             location.setY(crossExtent - crossAxisExtentForChild(child) - location.y());
 827             setFlowAwareLocationForChild(child, location);
 828         }
 829
 830         // FIXME: Make sure this does the right thing with column flows.
 831         switch (flexAlignForChild(child)) {
 832         case AlignAuto:
 833             ASSERT_NOT_REACHED();
 834             break;
 835         case AlignStretch: {
 836             if (!isColumnFlow() && child->style()->logicalHeight().isAuto()) {
 837                 LayoutUnit logicalHeightBefore = child->logicalHeight();
 838                 LayoutUnit stretchedLogicalHeight = child->logicalHeight() + RenderFlexibleBox::availableAlignmentSpaceForChild(child);
 839                 child->setLogicalHeight(stretchedLogicalHeight);
 840                 child->computeLogicalHeight();
 841
 842                 if (child->logicalHeight() != logicalHeightBefore) {
 843                     child->setOverrideHeight(child->logicalHeight());
 844                     child->setLogicalHeight(0);
 845                     child->setChildNeedsLayout(true);
 846                     child->layoutIfNeeded();
 847                 }
 848             }
 849             break;
 850         }
 851         case AlignStart:
 852             break;
 853         case AlignEnd:
 854             adjustAlignmentForChild(child, RenderFlexibleBox::availableAlignmentSpaceForChild(child));
 855             break;
 856         case AlignCenter:
 857             adjustAlignmentForChild(child, RenderFlexibleBox::availableAlignmentSpaceForChild(child) / 2);
 858             break;
 859         case AlignBaseline: {
 860             LayoutUnit ascent = marginBoxAscent(child);
 861             adjustAlignmentForChild(child, maxAscent - ascent);
 862             break;
 863         }
 864         }
 865     }
 866 }
 867
 868 }