b025cd3178fae742c5adcef9cd58cb5b6f78bc62
[WebKit-https.git] / 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 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 typedef HashSet<int, DefaultHash<int>::Hash, FlexOrderHashTraits> FlexOrderHashSet;
51
52 class RenderFlexibleBox::TreeOrderIterator {
53 public:
54     explicit TreeOrderIterator(RenderFlexibleBox* flexibleBox)
55         : m_flexibleBox(flexibleBox)
56         , m_currentChild(0)
57     {
58     }
59
60     RenderBox* first()
61     {
62         reset();
63         return next();
64     }
65
66     RenderBox* next()
67     {
68         m_currentChild = m_currentChild ? m_currentChild->nextSiblingBox() : m_flexibleBox->firstChildBox();
69
70         if (m_currentChild)
71             m_flexOrderValues.add(m_currentChild->style()->flexOrder());
72
73         return m_currentChild;
74     }
75
76     void reset()
77     {
78         m_currentChild = 0;
79     }
80
81     const FlexOrderHashSet& flexOrderValues()
82     {
83         return m_flexOrderValues;
84     }
85
86 private:
87     RenderFlexibleBox* m_flexibleBox;
88     RenderBox* m_currentChild;
89     FlexOrderHashSet m_flexOrderValues;
90 };
91
92 class RenderFlexibleBox::FlexOrderIterator {
93 public:
94     FlexOrderIterator(RenderFlexibleBox* flexibleBox, const FlexOrderHashSet& flexOrderValues)
95         : m_flexibleBox(flexibleBox)
96         , m_currentChild(0)
97         , m_orderValuesIterator(0)
98     {
99         copyToVector(flexOrderValues, m_orderValues);
100         std::sort(m_orderValues.begin(), m_orderValues.end());
101     }
102
103     RenderBox* first()
104     {
105         reset();
106         return next();
107     }
108
109     RenderBox* next()
110     {
111         do {
112             if (!m_currentChild) {
113                 if (m_orderValuesIterator == m_orderValues.end())
114                     return 0;
115                 if (m_orderValuesIterator) {
116                     ++m_orderValuesIterator;
117                     if (m_orderValuesIterator == m_orderValues.end())
118                         return 0;
119                 } else
120                     m_orderValuesIterator = m_orderValues.begin();
121
122                 m_currentChild = m_flexibleBox->firstChildBox();
123             } else
124                 m_currentChild = m_currentChild->nextSiblingBox();
125         } while (!m_currentChild || m_currentChild->style()->flexOrder() != *m_orderValuesIterator);
126
127         return m_currentChild;
128     }
129
130     void reset()
131     {
132         m_currentChild = 0;
133         m_orderValuesIterator = 0;
134     }
135
136 private:
137     RenderFlexibleBox* m_flexibleBox;
138     RenderBox* m_currentChild;
139     Vector<int> m_orderValues;
140     Vector<int>::const_iterator m_orderValuesIterator;
141 };
142
143
144 RenderFlexibleBox::RenderFlexibleBox(Node* node)
145     : RenderBlock(node)
146 {
147     setChildrenInline(false); // All of our children must be block-level.
148 }
149
150 RenderFlexibleBox::~RenderFlexibleBox()
151 {
152 }
153
154 const char* RenderFlexibleBox::renderName() const
155 {
156     return "RenderFlexibleBox";
157 }
158
159 void RenderFlexibleBox::layoutBlock(bool relayoutChildren, int, BlockLayoutPass)
160 {
161     ASSERT(needsLayout());
162
163     if (!relayoutChildren && simplifiedLayout())
164         return;
165
166     LayoutRepainter repainter(*this, checkForRepaintDuringLayout());
167     LayoutStateMaintainer statePusher(view(), this, IntSize(x(), y()), hasTransform() || hasReflection() || style()->isFlippedBlocksWritingMode());
168
169     if (inRenderFlowThread()) {
170         // Regions changing widths can force us to relayout our children.
171         if (logicalWidthChangedInRegions())
172             relayoutChildren = true;
173     }
174     computeInitialRegionRangeForBlock();
175
176     IntSize previousSize = size();
177
178     setLogicalHeight(0);
179     // We need to call both of these because we grab both crossAxisExtent and mainAxisExtent in layoutFlexItems.
180     computeLogicalWidth();
181     computeLogicalHeight();
182
183     m_overflow.clear();
184
185     // For overflow:scroll blocks, ensure we have both scrollbars in place always.
186     if (scrollsOverflow()) {
187         if (style()->overflowX() == OSCROLL)
188             layer()->setHasHorizontalScrollbar(true);
189         if (style()->overflowY() == OSCROLL)
190             layer()->setHasVerticalScrollbar(true);
191     }
192
193     layoutFlexItems(relayoutChildren);
194
195     LayoutUnit oldClientAfterEdge = clientLogicalBottom();
196     computeLogicalHeight();
197
198     if (size() != previousSize)
199         relayoutChildren = true;
200
201     layoutPositionedObjects(relayoutChildren || isRoot());
202
203     computeRegionRangeForBlock();
204
205     // FIXME: css3/flexbox/repaint-rtl-column.html seems to repaint more overflow than it needs to.
206     computeOverflow(oldClientAfterEdge);
207     statePusher.pop();
208
209     updateLayerTransform();
210
211     // Update our scroll information if we're overflow:auto/scroll/hidden now that we know if
212     // we overflow or not.
213     if (hasOverflowClip())
214         layer()->updateScrollInfoAfterLayout();
215
216     repainter.repaintAfterLayout();
217
218     setNeedsLayout(false);
219 }
220
221 bool RenderFlexibleBox::hasOrthogonalFlow(RenderBox* child) const
222 {
223     // FIXME: If the child is a flexbox, then we need to check isHorizontalFlow.
224     return isHorizontalFlow() != child->isHorizontalWritingMode();
225 }
226
227 bool RenderFlexibleBox::isColumnFlow() const
228 {
229     return style()->isColumnFlexDirection();
230 }
231
232 bool RenderFlexibleBox::isHorizontalFlow() const
233 {
234     if (isHorizontalWritingMode())
235         return !isColumnFlow();
236     return isColumnFlow();
237 }
238
239 bool RenderFlexibleBox::isLeftToRightFlow() const
240 {
241     if (isColumnFlow())
242         return style()->writingMode() == TopToBottomWritingMode || style()->writingMode() == LeftToRightWritingMode;
243     return style()->isLeftToRightDirection() ^ (style()->flexDirection() == FlowRowReverse);
244 }
245
246 Length RenderFlexibleBox::mainAxisLengthForChild(RenderBox* child) const
247 {
248     return isHorizontalFlow() ? child->style()->width() : child->style()->height();
249 }
250
251 Length RenderFlexibleBox::crossAxisLength() const
252 {
253     return isHorizontalFlow() ? style()->height() : style()->width();
254 }
255
256 void RenderFlexibleBox::setCrossAxisExtent(LayoutUnit extent)
257 {
258     if (isHorizontalFlow())
259         setHeight(extent);
260     else
261         setWidth(extent);
262 }
263
264 LayoutUnit RenderFlexibleBox::crossAxisExtentForChild(RenderBox* child)
265 {
266     return isHorizontalFlow() ? child->height() : child->width();
267 }
268
269 LayoutUnit RenderFlexibleBox::mainAxisExtentForChild(RenderBox* child)
270 {
271     return isHorizontalFlow() ? child->width() : child->height();
272 }
273
274 LayoutUnit RenderFlexibleBox::crossAxisExtent() const
275 {
276     return isHorizontalFlow() ? height() : width();
277 }
278
279 LayoutUnit RenderFlexibleBox::mainAxisExtent() const
280 {
281     return isHorizontalFlow() ? width() : height();
282 }
283
284 LayoutUnit RenderFlexibleBox::crossAxisContentExtent() const
285 {
286     return isHorizontalFlow() ? contentHeight() : contentWidth();
287 }
288
289 LayoutUnit RenderFlexibleBox::mainAxisContentExtent() const
290 {
291     return isHorizontalFlow() ? contentWidth() : contentHeight();
292 }
293
294 WritingMode RenderFlexibleBox::transformedWritingMode() const
295 {
296     WritingMode mode = style()->writingMode();
297     if (!isColumnFlow())
298         return mode;
299
300     switch (mode) {
301     case TopToBottomWritingMode:
302     case BottomToTopWritingMode:
303         return style()->isLeftToRightDirection() ? LeftToRightWritingMode : RightToLeftWritingMode;
304     case LeftToRightWritingMode:
305     case RightToLeftWritingMode:
306         return style()->isLeftToRightDirection() ? TopToBottomWritingMode : BottomToTopWritingMode;
307     }
308     ASSERT_NOT_REACHED();
309     return TopToBottomWritingMode;
310 }
311
312 LayoutUnit RenderFlexibleBox::flowAwareBorderStart() const
313 {
314     if (isHorizontalFlow())
315         return isLeftToRightFlow() ? borderLeft() : borderRight();
316     return isLeftToRightFlow() ? borderTop() : borderBottom();
317 }
318
319 LayoutUnit RenderFlexibleBox::flowAwareBorderEnd() const
320 {
321     if (isHorizontalFlow())
322         return isLeftToRightFlow() ? borderRight() : borderLeft();
323     return isLeftToRightFlow() ? borderBottom() : borderTop();
324 }
325
326 LayoutUnit RenderFlexibleBox::flowAwareBorderBefore() const
327 {
328     switch (transformedWritingMode()) {
329     case TopToBottomWritingMode:
330         return borderTop();
331     case BottomToTopWritingMode:
332         return borderBottom();
333     case LeftToRightWritingMode:
334         return borderLeft();
335     case RightToLeftWritingMode:
336         return borderRight();
337     }
338     ASSERT_NOT_REACHED();
339     return borderTop();
340 }
341
342 LayoutUnit RenderFlexibleBox::crossAxisBorderAndPaddingExtent() const
343 {
344     return isHorizontalFlow() ? borderAndPaddingHeight() : borderAndPaddingWidth();
345 }
346
347 LayoutUnit RenderFlexibleBox::flowAwarePaddingStart() const
348 {
349     if (isHorizontalFlow())
350         return isLeftToRightFlow() ? paddingLeft() : paddingRight();
351     return isLeftToRightFlow() ? paddingTop() : paddingBottom();
352 }
353
354 LayoutUnit RenderFlexibleBox::flowAwarePaddingEnd() const
355 {
356     if (isHorizontalFlow())
357         return isLeftToRightFlow() ? paddingRight() : paddingLeft();
358     return isLeftToRightFlow() ? paddingBottom() : paddingTop();
359 }
360
361 LayoutUnit RenderFlexibleBox::flowAwarePaddingBefore() const
362 {
363     switch (transformedWritingMode()) {
364     case TopToBottomWritingMode:
365         return paddingTop();
366     case BottomToTopWritingMode:
367         return paddingBottom();
368     case LeftToRightWritingMode:
369         return paddingLeft();
370     case RightToLeftWritingMode:
371         return paddingRight();
372     }
373     ASSERT_NOT_REACHED();
374     return paddingTop();
375 }
376
377 LayoutUnit RenderFlexibleBox::flowAwareMarginStartForChild(RenderBox* child) const
378 {
379     if (isHorizontalFlow())
380         return isLeftToRightFlow() ? child->marginLeft() : child->marginRight();
381     return isLeftToRightFlow() ? child->marginTop() : child->marginBottom();
382 }
383
384 LayoutUnit RenderFlexibleBox::flowAwareMarginEndForChild(RenderBox* child) const
385 {
386     if (isHorizontalFlow())
387         return isLeftToRightFlow() ? child->marginRight() : child->marginLeft();
388     return isLeftToRightFlow() ? child->marginBottom() : child->marginTop();
389 }
390
391 LayoutUnit RenderFlexibleBox::flowAwareMarginBeforeForChild(RenderBox* child) const
392 {
393     switch (transformedWritingMode()) {
394     case TopToBottomWritingMode:
395         return child->marginTop();
396     case BottomToTopWritingMode:
397         return child->marginBottom();
398     case LeftToRightWritingMode:
399         return child->marginLeft();
400     case RightToLeftWritingMode:
401         return child->marginRight();
402     }
403     ASSERT_NOT_REACHED();
404     return marginTop();
405 }
406
407 LayoutUnit RenderFlexibleBox::flowAwareMarginAfterForChild(RenderBox* child) const
408 {
409     switch (transformedWritingMode()) {
410     case TopToBottomWritingMode:
411         return child->marginBottom();
412     case BottomToTopWritingMode:
413         return child->marginTop();
414     case LeftToRightWritingMode:
415         return child->marginRight();
416     case RightToLeftWritingMode:
417         return child->marginLeft();
418     }
419     ASSERT_NOT_REACHED();
420     return marginBottom();
421 }
422
423 LayoutUnit RenderFlexibleBox::crossAxisMarginExtentForChild(RenderBox* child) const
424 {
425     return isHorizontalFlow() ? child->marginTop() + child->marginBottom() : child->marginLeft() + child->marginRight();
426 }
427
428 LayoutUnit RenderFlexibleBox::crossAxisScrollbarExtent() const
429 {
430     return isHorizontalFlow() ? horizontalScrollbarHeight() : verticalScrollbarWidth();
431 }
432
433 LayoutPoint RenderFlexibleBox::flowAwareLocationForChild(RenderBox* child) const
434 {
435     return isHorizontalFlow() ? child->location() : child->location().transposedPoint();
436 }
437
438 void RenderFlexibleBox::setFlowAwareLocationForChild(RenderBox* child, const LayoutPoint& location)
439 {
440     if (isHorizontalFlow())
441         child->setLocation(location);
442     else
443         child->setLocation(location.transposedPoint());
444 }
445
446 LayoutUnit RenderFlexibleBox::mainAxisBorderAndPaddingExtentForChild(RenderBox* child) const
447 {
448     return isHorizontalFlow() ? child->borderAndPaddingWidth() : child->borderAndPaddingHeight();
449 }
450
451 LayoutUnit RenderFlexibleBox::mainAxisScrollbarExtentForChild(RenderBox* child) const
452 {
453     return isHorizontalFlow() ? child->verticalScrollbarWidth() : child->horizontalScrollbarHeight();
454 }
455
456 LayoutUnit RenderFlexibleBox::preferredMainAxisContentExtentForChild(RenderBox* child) const
457 {
458     Length mainAxisLength = mainAxisLengthForChild(child);
459     if (mainAxisLength.isAuto()) {
460         LayoutUnit mainAxisExtent = hasOrthogonalFlow(child) ? child->logicalHeight() : child->maxPreferredLogicalWidth();
461         return mainAxisExtent - mainAxisBorderAndPaddingExtentForChild(child) - mainAxisScrollbarExtentForChild(child);
462     }
463     return mainAxisLength.calcMinValue(mainAxisContentExtent());
464 }
465
466 void RenderFlexibleBox::layoutFlexItems(bool relayoutChildren)
467 {
468     float totalPositiveFlexibility;
469     float totalNegativeFlexibility;
470     TreeOrderIterator treeIterator(this);
471
472     WTF::Vector<LayoutUnit> preferredSizes;
473     computeMainAxisPreferredSizes(relayoutChildren, treeIterator, preferredSizes, totalPositiveFlexibility, totalNegativeFlexibility);
474     LayoutUnit preferredMainAxisExtent = 0;
475     for (size_t i = 0; i < preferredSizes.size(); ++i)
476         preferredMainAxisExtent += preferredSizes[i];
477     LayoutUnit availableFreeSpace = mainAxisContentExtent() - preferredMainAxisExtent;
478
479     FlexOrderIterator flexIterator(this, treeIterator.flexOrderValues());
480     InflexibleFlexItemSize inflexibleItems;
481     WTF::Vector<LayoutUnit> childSizes;
482     while (!runFreeSpaceAllocationAlgorithm(flexIterator, availableFreeSpace, totalPositiveFlexibility, totalNegativeFlexibility, inflexibleItems, childSizes)) {
483         ASSERT(totalPositiveFlexibility >= 0 && totalNegativeFlexibility >= 0);
484         ASSERT(inflexibleItems.size() > 0);
485     }
486
487     layoutAndPlaceChildren(flexIterator, childSizes, availableFreeSpace, totalPositiveFlexibility);
488 }
489
490 float RenderFlexibleBox::positiveFlexForChild(RenderBox* child) const
491 {
492     return isHorizontalFlow() ? child->style()->flexboxWidthPositiveFlex() : child->style()->flexboxHeightPositiveFlex();
493 }
494
495 float RenderFlexibleBox::negativeFlexForChild(RenderBox* child) const
496 {
497     return isHorizontalFlow() ? child->style()->flexboxWidthNegativeFlex() : child->style()->flexboxHeightNegativeFlex();
498 }
499
500 LayoutUnit RenderFlexibleBox::availableAlignmentSpaceForChild(RenderBox* child)
501 {
502     LayoutUnit crossContentExtent = crossAxisContentExtent();
503     LayoutUnit childCrossExtent = crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child);
504     return crossContentExtent - childCrossExtent;
505 }
506
507 LayoutUnit RenderFlexibleBox::marginBoxAscent(RenderBox* child)
508 {
509     LayoutUnit ascent = child->firstLineBoxBaseline();
510     if (ascent == -1)
511         ascent = crossAxisExtentForChild(child) + flowAwareMarginAfterForChild(child);
512     return ascent + flowAwareMarginBeforeForChild(child);
513 }
514
515 void RenderFlexibleBox::computeMainAxisPreferredSizes(bool relayoutChildren, TreeOrderIterator& iterator, WTF::Vector<LayoutUnit>& preferredSizes, float& totalPositiveFlexibility, float& totalNegativeFlexibility)
516 {
517     totalPositiveFlexibility = totalNegativeFlexibility = 0;
518
519     LayoutUnit flexboxAvailableContentExtent = mainAxisContentExtent();
520     for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
521         if (child->isPositioned()) {
522             preferredSizes.append(0);
523             continue;
524         }
525
526         child->clearOverrideSize();
527         if (mainAxisLengthForChild(child).isAuto()) {
528             if (!relayoutChildren)
529                 child->setChildNeedsLayout(true);
530             child->layoutIfNeeded();
531         }
532
533         LayoutUnit preferredSize = mainAxisBorderAndPaddingExtentForChild(child) + preferredMainAxisContentExtentForChild(child);
534
535         // We set the margins because we want to make sure 'auto' has a margin
536         // of 0 and because if we're not auto sizing, we don't do a layout that
537         // computes the start/end margins.
538         if (isHorizontalFlow()) {
539             child->setMarginLeft(child->style()->marginLeft().calcMinValue(flexboxAvailableContentExtent));
540             child->setMarginRight(child->style()->marginRight().calcMinValue(flexboxAvailableContentExtent));
541             preferredSize += child->marginLeft() + child->marginRight();
542         } else {
543             child->setMarginTop(child->style()->marginTop().calcMinValue(flexboxAvailableContentExtent));
544             child->setMarginBottom(child->style()->marginBottom().calcMinValue(flexboxAvailableContentExtent));
545             preferredSize += child->marginTop() + child->marginBottom();
546         }
547
548         preferredSizes.append(preferredSize);
549
550         totalPositiveFlexibility += positiveFlexForChild(child);
551         totalNegativeFlexibility += negativeFlexForChild(child);
552     }
553 }
554
555 // Returns true if we successfully ran the algorithm and sized the flex items.
556 bool RenderFlexibleBox::runFreeSpaceAllocationAlgorithm(FlexOrderIterator& iterator, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize& inflexibleItems, WTF::Vector<LayoutUnit>& childSizes)
557 {
558     childSizes.clear();
559
560     LayoutUnit flexboxAvailableContentExtent = mainAxisContentExtent();
561     for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
562         if (child->isPositioned()) {
563             childSizes.append(0);
564             continue;
565         }
566
567         LayoutUnit childPreferredSize;
568         if (inflexibleItems.contains(child))
569             childPreferredSize = inflexibleItems.get(child);
570         else {
571             childPreferredSize = preferredMainAxisContentExtentForChild(child);
572             if (availableFreeSpace > 0 && totalPositiveFlexibility > 0) {
573                 childPreferredSize += lroundf(availableFreeSpace * positiveFlexForChild(child) / totalPositiveFlexibility);
574
575                 Length childLogicalMaxWidth = isHorizontalFlow() ? child->style()->maxWidth() : child->style()->maxHeight();
576                 if (!childLogicalMaxWidth.isUndefined() && childLogicalMaxWidth.isSpecified() && childPreferredSize > childLogicalMaxWidth.calcValue(flexboxAvailableContentExtent)) {
577                     childPreferredSize = childLogicalMaxWidth.calcValue(flexboxAvailableContentExtent);
578                     availableFreeSpace -= childPreferredSize - preferredMainAxisContentExtentForChild(child);
579                     totalPositiveFlexibility -= positiveFlexForChild(child);
580
581                     inflexibleItems.set(child, childPreferredSize);
582                     return false;
583                 }
584             } else if (availableFreeSpace < 0 && totalNegativeFlexibility > 0) {
585                 childPreferredSize += lroundf(availableFreeSpace * negativeFlexForChild(child) / totalNegativeFlexibility);
586
587                 Length childLogicalMinWidth = isHorizontalFlow() ? child->style()->minWidth() : child->style()->minHeight();
588                 if (!childLogicalMinWidth.isUndefined() && childLogicalMinWidth.isSpecified() && childPreferredSize < childLogicalMinWidth.calcValue(flexboxAvailableContentExtent)) {
589                     childPreferredSize = childLogicalMinWidth.calcValue(flexboxAvailableContentExtent);
590                     availableFreeSpace += preferredMainAxisContentExtentForChild(child) - childPreferredSize;
591                     totalNegativeFlexibility -= negativeFlexForChild(child);
592
593                     inflexibleItems.set(child, childPreferredSize);
594                     return false;
595                 }
596             }
597         }
598         childSizes.append(childPreferredSize);
599     }
600     return true;
601 }
602
603 static bool hasPackingSpace(LayoutUnit availableFreeSpace, float totalPositiveFlexibility)
604 {
605     return availableFreeSpace > 0 && !totalPositiveFlexibility;
606 }
607
608 static LayoutUnit initialPackingOffset(LayoutUnit availableFreeSpace, float totalPositiveFlexibility, EFlexPack flexPack, size_t numberOfChildren)
609 {
610     if (hasPackingSpace(availableFreeSpace, totalPositiveFlexibility)) {
611         if (flexPack == PackEnd)
612             return availableFreeSpace;
613         if (flexPack == PackCenter)
614             return availableFreeSpace / 2;
615         if (flexPack == PackDistribute && numberOfChildren)
616             return availableFreeSpace / (2 * numberOfChildren);
617     }
618     return 0;
619 }
620
621 static LayoutUnit packingSpaceBetweenChildren(LayoutUnit availableFreeSpace, float totalPositiveFlexibility, EFlexPack flexPack, size_t numberOfChildren)
622 {
623     if (hasPackingSpace(availableFreeSpace, totalPositiveFlexibility) && numberOfChildren > 1) {
624         if (flexPack == PackJustify)
625             return availableFreeSpace / (numberOfChildren - 1);
626         if (flexPack == PackDistribute)
627             return availableFreeSpace / numberOfChildren;
628     }
629     return 0;
630 }
631
632 void RenderFlexibleBox::setLogicalOverrideSize(RenderBox* child, LayoutUnit childPreferredSize)
633 {
634     // FIXME: Rename setOverrideWidth/setOverrideHeight to setOverrideLogicalWidth/setOverrideLogicalHeight.
635     if (hasOrthogonalFlow(child))
636         child->setOverrideHeight(childPreferredSize);
637     else
638         child->setOverrideWidth(childPreferredSize);
639 }
640
641 void RenderFlexibleBox::prepareChildForPositionedLayout(RenderBox* child, LayoutUnit mainAxisOffset, LayoutUnit crossAxisOffset)
642 {
643     ASSERT(child->isPositioned());
644     child->containingBlock()->insertPositionedObject(child);
645     RenderLayer* childLayer = child->layer();
646     LayoutUnit inlinePosition = isColumnFlow() ? crossAxisOffset : mainAxisOffset;
647     if (style()->flexDirection() == FlowRowReverse)
648         inlinePosition = mainAxisExtent() - mainAxisOffset;
649     childLayer->setStaticInlinePosition(inlinePosition); // FIXME: Not right for regions.
650
651     LayoutUnit staticBlockPosition = isColumnFlow() ? mainAxisOffset : crossAxisOffset;
652     if (childLayer->staticBlockPosition() != staticBlockPosition) {
653         childLayer->setStaticBlockPosition(staticBlockPosition);
654         if (child->style()->hasStaticBlockPosition(style()->isHorizontalWritingMode()))
655             child->setChildNeedsLayout(true, false);
656     }
657 }
658
659 static EFlexAlign flexAlignForChild(RenderBox* child)
660 {
661     EFlexAlign align = child->style()->flexItemAlign();
662     if (align == AlignAuto)
663         return child->parent()->style()->flexAlign();
664     return align;
665 }
666
667 void RenderFlexibleBox::layoutAndPlaceChildren(FlexOrderIterator& iterator, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace, float totalPositiveFlexibility)
668 {
669     LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
670     mainAxisOffset += initialPackingOffset(availableFreeSpace, totalPositiveFlexibility, style()->flexPack(), childSizes.size());
671     if (style()->flexDirection() == FlowRowReverse)
672         mainAxisOffset += isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
673
674     LayoutUnit crossAxisOffset = flowAwareBorderBefore() + flowAwarePaddingBefore();
675     LayoutUnit totalMainExtent = mainAxisExtent();
676     LayoutUnit maxAscent = 0, maxDescent = 0; // Used when flex-align: baseline.
677     bool shouldFlipMainAxis = !isColumnFlow() && !isLeftToRightFlow();
678     size_t i = 0;
679     for (RenderBox* child = iterator.first(); child; child = iterator.next(), ++i) {
680         if (child->isPositioned()) {
681             prepareChildForPositionedLayout(child, mainAxisOffset, crossAxisOffset);
682             mainAxisOffset += packingSpaceBetweenChildren(availableFreeSpace, totalPositiveFlexibility, style()->flexPack(), childSizes.size());
683             continue;
684         }
685         LayoutUnit childPreferredSize = childSizes[i] + mainAxisBorderAndPaddingExtentForChild(child);
686         setLogicalOverrideSize(child, childPreferredSize);
687         child->setChildNeedsLayout(true);
688         child->layoutIfNeeded();
689
690         if (flexAlignForChild(child) == AlignBaseline) {
691             LayoutUnit ascent = marginBoxAscent(child);
692             LayoutUnit descent = (crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child)) - ascent;
693
694             maxAscent = std::max(maxAscent, ascent);
695             maxDescent = std::max(maxDescent, descent);
696
697             if (crossAxisLength().isAuto())
698                 setCrossAxisExtent(std::max(crossAxisExtent(), crossAxisBorderAndPaddingExtent() + crossAxisMarginExtentForChild(child) + maxAscent + maxDescent + crossAxisScrollbarExtent()));
699         } else if (crossAxisLength().isAuto())
700             setCrossAxisExtent(std::max(crossAxisExtent(), crossAxisBorderAndPaddingExtent() + crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child) + crossAxisScrollbarExtent()));
701
702         mainAxisOffset += flowAwareMarginStartForChild(child);
703
704         LayoutUnit childMainExtent = mainAxisExtentForChild(child);
705         IntPoint childLocation(shouldFlipMainAxis ? totalMainExtent - mainAxisOffset - childMainExtent : mainAxisOffset,
706             crossAxisOffset + flowAwareMarginBeforeForChild(child));
707
708         // FIXME: Supporting layout deltas.
709         setFlowAwareLocationForChild(child, childLocation);
710         mainAxisOffset += childMainExtent + flowAwareMarginEndForChild(child);
711
712         mainAxisOffset += packingSpaceBetweenChildren(availableFreeSpace, totalPositiveFlexibility, style()->flexPack(), childSizes.size());
713
714         if (isColumnFlow())
715             setLogicalHeight(mainAxisOffset + flowAwareBorderEnd() + flowAwarePaddingEnd() + scrollbarLogicalHeight());
716     }
717
718     if (style()->flexDirection() == FlowColumnReverse) {
719         // We have to do an extra pass for column-reverse to reposition the flex items since the start depends
720         // on the height of the flexbox, which we only know after we've positioned all the flex items.
721         computeLogicalHeight();
722         layoutColumnReverse(iterator, childSizes, availableFreeSpace, totalPositiveFlexibility);
723     }
724
725     alignChildren(iterator, maxAscent);
726 }
727
728 void RenderFlexibleBox::layoutColumnReverse(FlexOrderIterator& iterator, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace, float totalPositiveFlexibility)
729 {
730     // This is similar to the logic in layoutAndPlaceChildren, except we place the children
731     // starting from the end of the flexbox. We also don't need to layout anything since we're
732     // just moving the children to a new position.
733     LayoutUnit mainAxisOffset = logicalHeight() - flowAwareBorderEnd() - flowAwarePaddingEnd();
734     mainAxisOffset -= initialPackingOffset(availableFreeSpace, totalPositiveFlexibility, style()->flexPack(), childSizes.size());
735     mainAxisOffset -= isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
736
737     LayoutUnit crossAxisOffset = flowAwareBorderBefore() + flowAwarePaddingBefore();
738     size_t i = 0;
739     for (RenderBox* child = iterator.first(); child; child = iterator.next(), ++i) {
740         if (child->isPositioned()) {
741             child->layer()->setStaticBlockPosition(mainAxisOffset);
742             mainAxisOffset -= packingSpaceBetweenChildren(availableFreeSpace, totalPositiveFlexibility, style()->flexPack(), childSizes.size());
743             continue;
744         }
745         mainAxisOffset -= mainAxisExtentForChild(child) + flowAwareMarginEndForChild(child);
746
747         LayoutRect oldRect = child->frameRect();
748         setFlowAwareLocationForChild(child, IntPoint(mainAxisOffset, crossAxisOffset + flowAwareMarginBeforeForChild(child)));
749         if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
750             child->repaintDuringLayoutIfMoved(oldRect);
751
752         mainAxisOffset -= flowAwareMarginStartForChild(child);
753         mainAxisOffset -= packingSpaceBetweenChildren(availableFreeSpace, totalPositiveFlexibility, style()->flexPack(), childSizes.size());
754     }
755 }
756
757 void RenderFlexibleBox::adjustAlignmentForChild(RenderBox* child, LayoutUnit delta)
758 {
759     LayoutRect oldRect = child->frameRect();
760
761     setFlowAwareLocationForChild(child, flowAwareLocationForChild(child) + LayoutSize(0, delta));
762
763     // If the child moved, we have to repaint it as well as any floating/positioned
764     // descendants. An exception is if we need a layout. In this case, we know we're going to
765     // repaint ourselves (and the child) anyway.
766     if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
767         child->repaintDuringLayoutIfMoved(oldRect);
768 }
769
770 void RenderFlexibleBox::alignChildren(FlexOrderIterator& iterator, LayoutUnit maxAscent)
771 {
772     LayoutUnit crossExtent = crossAxisExtent();
773
774     for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
775         // direction:rtl + flex-direction:column means the cross-axis direction is flipped.
776         if (!style()->isLeftToRightDirection() && isColumnFlow()) {
777             LayoutPoint location = flowAwareLocationForChild(child);
778             location.setY(crossExtent - crossAxisExtentForChild(child) - location.y());
779             setFlowAwareLocationForChild(child, location);
780         }
781
782         // FIXME: Make sure this does the right thing with column flows.
783         switch (flexAlignForChild(child)) {
784         case AlignAuto:
785             ASSERT_NOT_REACHED();
786             break;
787         case AlignStretch: {
788             if (!isColumnFlow() && child->style()->logicalHeight().isAuto()) {
789                 LayoutUnit logicalHeightBefore = child->logicalHeight();
790                 LayoutUnit stretchedLogicalHeight = child->logicalHeight() + RenderFlexibleBox::availableAlignmentSpaceForChild(child);
791                 child->setLogicalHeight(stretchedLogicalHeight);
792                 child->computeLogicalHeight();
793
794                 if (child->logicalHeight() != logicalHeightBefore) {
795                     child->setOverrideHeight(child->logicalHeight());
796                     child->setLogicalHeight(0);
797                     child->setChildNeedsLayout(true);
798                     child->layoutIfNeeded();
799                 }
800             }
801             break;
802         }
803         case AlignStart:
804             break;
805         case AlignEnd:
806             adjustAlignmentForChild(child, RenderFlexibleBox::availableAlignmentSpaceForChild(child));
807             break;
808         case AlignCenter:
809             adjustAlignmentForChild(child, RenderFlexibleBox::availableAlignmentSpaceForChild(child) / 2);
810             break;
811         case AlignBaseline: {
812             LayoutUnit ascent = marginBoxAscent(child);
813             adjustAlignmentForChild(child, maxAscent - ascent);
814             break;
815         }
816         }
817     }
818 }
819
820 }