Changeset 135965 in webkit


Ignore:
Timestamp:
Nov 27, 2012 6:16:36 PM (11 years ago)
Author:
jchaffraix@webkit.org
Message:

Support proper <percent> / calc() resolution for grid items
​https://bugs.webkit.org/show_bug.cgi?id=102968

Reviewed by Ojan Vafai.

Source/WebCore:

This change introduces a mechanism similar to logical height / width override
but for containing block. This is required as we don't have a renderer for the
grid area but any <percent> or calc() size should be resolved against the grid
area size (which is sized after the grid tracks).

Tests: fast/css-grid-layout/calc-resolution-grid-item.html

fast/css-grid-layout/percent-resolution-grid-item.html
fast/css-grid-layout/percent-grid-item-in-percent-grid-track.html
fast/css-grid-layout/percent-grid-item-in-percent-grid-track-in-percent-grid.html

  • rendering/RenderBox.cpp:

(WebCore::RenderBox::willBeDestroyed):
Remove any containing block size override.

(WebCore::RenderBox::overrideContainingBlockContentLogicalWidth):
(WebCore::RenderBox::overrideContainingBlockContentLogicalHeight):
(WebCore::RenderBox::hasOverrideContainingBlockLogicalWidth):
(WebCore::RenderBox::hasOverrideContainingBlockLogicalHeight):
(WebCore::RenderBox::setOverrideContainingBlockContentLogicalWidth):
(WebCore::RenderBox::setOverrideContainingBlockContentLogicalHeight):
(WebCore::RenderBox::clearContainingBlockOverrideSize):
Containing block override size functions.

(WebCore::RenderBox::containingBlockLogicalWidthForContent):
Updated the function to check for any override logical width.

(WebCore::RenderBox::containingBlockLogicalHeightForContent):
New function, similar to RenderBox::containingBlockLogicalWidthForContent.

(WebCore::RenderBox::perpendicularContainingBlockLogicalHeight):
(WebCore::RenderBox::computePercentageLogicalHeight):
Updated these function to return overrideContainingBlockContentLogicalHeight as needed.

(WebCore::RenderBox::computeReplacedLogicalHeightUsing):
(WebCore::RenderBox::availableLogicalHeightUsing):
Updated these functions to use the new containingBlockLogicalHeightForContent instead
of availableLogicalHeight.

  • rendering/RenderBox.h:

Added the previous new functions.

  • rendering/RenderGrid.cpp:

(WebCore::RenderGrid::layoutGridItems):
Updated to override the containing block size so that we properly size our grid items.

LayoutTests:

  • fast/css-grid-layout/calc-resolution-grid-item-expected.txt: Added.
  • fast/css-grid-layout/calc-resolution-grid-item.html: Added.
  • fast/css-grid-layout/percent-resolution-grid-item-expected.txt: Added.
  • fast/css-grid-layout/percent-resolution-grid-item.html: Added.

Test that checks that our override containing block's logical width / height logic
works as expected.

  • fast/css-grid-layout/percent-grid-item-in-percent-grid-track-expected.txt: Added.
  • fast/css-grid-layout/percent-grid-item-in-percent-grid-track.html: Added.
  • fast/css-grid-layout/percent-grid-item-in-percent-grid-track-in-percent-grid.html: Added.
  • fast/css-grid-layout/percent-grid-item-in-percent-grid-track-in-percent-grid-expected.txt: Added.

Those test cases covers the cases of percentage sized grid items with percentage sized grid tracks
inside a fixed or percentage sized grid element. They don't pass yet as we don't support percentage
sized grid tracks (see bug 103335).

Location:
trunk
Files:
8 added
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r135964 r135965  
     12012-11-27  Julien Chaffraix  <jchaffraix@webkit.org>
     2
     3        Support proper <percent> / calc() resolution for grid items
     4        https://bugs.webkit.org/show_bug.cgi?id=102968
     5
     6        Reviewed by Ojan Vafai.
     7
     8        * fast/css-grid-layout/calc-resolution-grid-item-expected.txt: Added.
     9        * fast/css-grid-layout/calc-resolution-grid-item.html: Added.
     10        * fast/css-grid-layout/percent-resolution-grid-item-expected.txt: Added.
     11        * fast/css-grid-layout/percent-resolution-grid-item.html: Added.
     12        Test that checks that our override containing block's logical width / height logic
     13        works as expected.
     14
     15        * fast/css-grid-layout/percent-grid-item-in-percent-grid-track-expected.txt: Added.
     16        * fast/css-grid-layout/percent-grid-item-in-percent-grid-track.html: Added.
     17        * fast/css-grid-layout/percent-grid-item-in-percent-grid-track-in-percent-grid.html: Added.
     18        * fast/css-grid-layout/percent-grid-item-in-percent-grid-track-in-percent-grid-expected.txt: Added.
     19        Those test cases covers the cases of percentage sized grid items with percentage sized grid tracks
     20        inside a fixed or percentage sized grid element. They don't pass yet as we don't support percentage
     21        sized grid tracks (see bug 103335).
     22
    1232012-11-27  Yael Aharon  <yael.aharon@intel.com>
    224

  • trunk/Source/WebCore/ChangeLog

    r135963 r135965  
     12012-11-27  Julien Chaffraix  <jchaffraix@webkit.org>
     2
     3        Support proper <percent> / calc() resolution for grid items
     4        https://bugs.webkit.org/show_bug.cgi?id=102968
     5
     6        Reviewed by Ojan Vafai.
     7
     8        This change introduces a mechanism similar to logical height / width override
     9        but for containing block. This is required as we don't have a renderer for the
     10        grid area but any <percent> or calc() size should be resolved against the grid
     11        area size (which is sized after the grid tracks).
     12
     13        Tests: fast/css-grid-layout/calc-resolution-grid-item.html
     14               fast/css-grid-layout/percent-resolution-grid-item.html
     15               fast/css-grid-layout/percent-grid-item-in-percent-grid-track.html
     16               fast/css-grid-layout/percent-grid-item-in-percent-grid-track-in-percent-grid.html
     17
     18        * rendering/RenderBox.cpp:
     19        (WebCore::RenderBox::willBeDestroyed):
     20        Remove any containing block size override.
     21
     22        (WebCore::RenderBox::overrideContainingBlockContentLogicalWidth):
     23        (WebCore::RenderBox::overrideContainingBlockContentLogicalHeight):
     24        (WebCore::RenderBox::hasOverrideContainingBlockLogicalWidth):
     25        (WebCore::RenderBox::hasOverrideContainingBlockLogicalHeight):
     26        (WebCore::RenderBox::setOverrideContainingBlockContentLogicalWidth):
     27        (WebCore::RenderBox::setOverrideContainingBlockContentLogicalHeight):
     28        (WebCore::RenderBox::clearContainingBlockOverrideSize):
     29        Containing block override size functions.
     30
     31        (WebCore::RenderBox::containingBlockLogicalWidthForContent):
     32        Updated the function to check for any override logical width.
     33
     34        (WebCore::RenderBox::containingBlockLogicalHeightForContent):
     35        New function, similar to RenderBox::containingBlockLogicalWidthForContent.
     36
     37        (WebCore::RenderBox::perpendicularContainingBlockLogicalHeight):
     38        (WebCore::RenderBox::computePercentageLogicalHeight):
     39        Updated these function to return overrideContainingBlockContentLogicalHeight as needed.
     40
     41        (WebCore::RenderBox::computeReplacedLogicalHeightUsing):
     42        (WebCore::RenderBox::availableLogicalHeightUsing):
     43        Updated these functions to use the new containingBlockLogicalHeightForContent instead
     44        of availableLogicalHeight.
     45
     46        * rendering/RenderBox.h:
     47        Added the previous new functions.
     48
     49        * rendering/RenderGrid.cpp:
     50        (WebCore::RenderGrid::layoutGridItems):
     51        Updated to override the containing block size so that we properly size our grid items.
     52
    1532012-11-27  Kent Tamura  <tkent@chromium.org>
    254

  • trunk/Source/WebCore/rendering/RenderBox.cpp

    r135851 r135965  
    6969static OverrideSizeMap* gOverrideWidthMap = 0;
    7070
     71// Used by grid elements to properly size their grid items.
     72static OverrideSizeMap* gOverrideContainingBlockLogicalHeightMap = 0;
     73static OverrideSizeMap* gOverrideContainingBlockLogicalWidthMap = 0;
     74
    7175bool RenderBox::s_hadOverflowClip = false;
    7276
    … …  
    134138{
    135139    clearOverrideSize();
     140    clearContainingBlockOverrideSize();
    136141
    137142    RenderBlock::removePercentHeightDescendantIfNeeded(this);
    … …  
    739744}
    740745
     746LayoutUnit RenderBox::overrideContainingBlockContentLogicalWidth() const
     747{
     748    ASSERT(hasOverrideContainingBlockLogicalWidth());
     749    return gOverrideContainingBlockLogicalWidthMap->get(this);
     750}
     751
     752LayoutUnit RenderBox::overrideContainingBlockContentLogicalHeight() const
     753{
     754    ASSERT(hasOverrideContainingBlockLogicalHeight());
     755    return gOverrideContainingBlockLogicalHeightMap->get(this);
     756}
     757
     758bool RenderBox::hasOverrideContainingBlockLogicalWidth() const
     759{
     760    return gOverrideContainingBlockLogicalWidthMap && gOverrideContainingBlockLogicalWidthMap->contains(this);
     761}
     762
     763bool RenderBox::hasOverrideContainingBlockLogicalHeight() const
     764{
     765    return gOverrideContainingBlockLogicalHeightMap && gOverrideContainingBlockLogicalHeightMap->contains(this);
     766}
     767
     768void RenderBox::setOverrideContainingBlockContentLogicalWidth(LayoutUnit logicalWidth)
     769{
     770    if (!gOverrideContainingBlockLogicalWidthMap)
     771        gOverrideContainingBlockLogicalWidthMap = new OverrideSizeMap;
     772    gOverrideContainingBlockLogicalWidthMap->set(this, logicalWidth);
     773}
     774
     775void RenderBox::setOverrideContainingBlockContentLogicalHeight(LayoutUnit logicalHeight)
     776{
     777    if (!gOverrideContainingBlockLogicalHeightMap)
     778        gOverrideContainingBlockLogicalHeightMap = new OverrideSizeMap;
     779    gOverrideContainingBlockLogicalHeightMap->set(this, logicalHeight);
     780}
     781
     782void RenderBox::clearContainingBlockOverrideSize()
     783{
     784    if (gOverrideContainingBlockLogicalWidthMap)
     785        gOverrideContainingBlockLogicalWidthMap->remove(this);
     786    if (gOverrideContainingBlockLogicalHeightMap)
     787        gOverrideContainingBlockLogicalHeightMap->remove(this);
     788}
     789
    741790LayoutUnit RenderBox::adjustBorderBoxLogicalWidthForBoxSizing(LayoutUnit width) const
    742791{
    … …  
    12521301LayoutUnit RenderBox::containingBlockLogicalWidthForContent() const
    12531302{
     1303    if (hasOverrideContainingBlockLogicalWidth())
     1304        return overrideContainingBlockContentLogicalWidth();
     1305
    12541306    RenderBlock* cb = containingBlock();
    12551307    return cb->availableLogicalWidth();
    12561308}
    12571309
     1310LayoutUnit RenderBox::containingBlockLogicalHeightForContent() const
     1311{
     1312    if (hasOverrideContainingBlockLogicalHeight())
     1313        return overrideContainingBlockContentLogicalHeight();
     1314
     1315    RenderBlock* cb = containingBlock();
     1316    return cb->availableLogicalHeight();
     1317}
     1318
    12581319LayoutUnit RenderBox::containingBlockLogicalWidthForContentInRegion(RenderRegion* region, LayoutUnit offsetFromLogicalTopOfFirstPage) const
    12591320{
    … …  
    12631324    RenderBlock* cb = containingBlock();
    12641325    RenderRegion* containingBlockRegion = cb->clampToStartAndEndRegions(region);
     1326    // FIXME: It's unclear if a region's content should use the containing block's override logical width.
     1327    // If it should, the following line should call containingBlockLogicalWidthForContent.
    12651328    LayoutUnit result = cb->availableLogicalWidth();
    12661329    RenderBoxRegionInfo* boxInfo = cb->renderBoxRegionInfo(containingBlockRegion, offsetFromLogicalTopOfFirstPage - logicalTop());
    … …  
    12861349LayoutUnit RenderBox::perpendicularContainingBlockLogicalHeight() const
    12871350{
     1351    if (hasOverrideContainingBlockLogicalHeight())
     1352        return overrideContainingBlockContentLogicalHeight();
     1353
    12881354    RenderBlock* cb = containingBlock();
    12891355    if (cb->hasOverrideHeight())
    … …  
    22182284    if (isHorizontalWritingMode() != cb->isHorizontalWritingMode())
    22192285        availableHeight = containingBlockChild->containingBlockLogicalWidthForContent();
     2286    else if (hasOverrideContainingBlockLogicalHeight())
     2287        availableHeight = overrideContainingBlockContentLogicalHeight();
    22202288    else if (cb->isTableCell()) {
    22212289        if (!skippedAutoHeightContainingBlock) {
    … …  
    23642432                availableHeight = containingBlockLogicalHeightForPositioned(toRenderBoxModelObject(cb));
    23652433            else {
    2366                 availableHeight =  toRenderBox(cb)->availableLogicalHeight();
     2434                availableHeight = containingBlockLogicalHeightForContent();
    23672435                // It is necessary to use the border-box to match WinIE's broken
    23682436                // box model.  This is essential for sizing inside
    … …  
    24322500
    24332501    // FIXME: This is wrong if the containingBlock has a perpendicular writing mode.
    2434     return containingBlock()->availableLogicalHeight();
     2502    return containingBlockLogicalHeightForContent();
    24352503}
    24362504

  • trunk/Source/WebCore/rendering/RenderBox.h

    r135025 r135965  
    306306    void clearOverrideLogicalContentWidth();
    307307
     308    LayoutUnit overrideContainingBlockContentLogicalWidth() const;
     309    LayoutUnit overrideContainingBlockContentLogicalHeight() const;
     310    bool hasOverrideContainingBlockLogicalWidth() const;
     311    bool hasOverrideContainingBlockLogicalHeight() const;
     312    void setOverrideContainingBlockContentLogicalWidth(LayoutUnit);
     313    void setOverrideContainingBlockContentLogicalHeight(LayoutUnit);
     314    void clearContainingBlockOverrideSize();
     315
    308316    virtual LayoutSize offsetFromContainer(RenderObject*, const LayoutPoint&, bool* offsetDependsOnPoint = 0) const;
    309317   
    … …  
    369377
    370378    virtual LayoutUnit containingBlockLogicalWidthForContent() const;
     379    LayoutUnit containingBlockLogicalHeightForContent() const;
     380
    371381    LayoutUnit containingBlockLogicalWidthForContentInRegion(RenderRegion*, LayoutUnit offsetFromLogicalTopOfFirstPage) const;
    372382    LayoutUnit containingBlockAvailableLineWidthInRegion(RenderRegion*, LayoutUnit offsetFromLogicalTopOfFirstPage) const;

  • trunk/Source/WebCore/rendering/RenderGrid.cpp

    r135164 r135965  
    162162    for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
    163163        LayoutPoint childPosition = findChildLogicalPosition(child, columnTracks, rowTracks);
     164
     165        size_t columnTrack = resolveGridPosition(child->style()->gridItemColumn());
     166        size_t rowTrack = resolveGridPosition(child->style()->gridItemRow());
     167
     168        // Because the grid area cannot be styled, we don't need to adjust
     169        // the grid breadth to account for 'box-sizing'.
     170        child->setOverrideContainingBlockContentLogicalWidth(columnTracks[columnTrack].m_usedBreadth);
     171        child->setOverrideContainingBlockContentLogicalHeight(rowTracks[rowTrack].m_usedBreadth);
     172
    164173        // FIXME: Grid items should stretch to fill their cells. Once we
    165174        // implement grid-{column,row}-align, we can also shrink to fit. For
Note: See TracChangeset for help on using the changeset viewer.