CSSComputedStyleDeclaration.cpp

@@static Ref<CSSValueList> createPositionListForLayer(CSSPropertyID propertyID, co

    return list;

}

711 static R~~efPtr<CSSValue> position~~Offset~~Val~~ue(const RenderStyle& style, CSSPropertyID propertyID)

711static Length getOffsetComputedLength(const RenderStyle& style, CSSPropertyID propertyID)

712712{

713 Length length;

    // If specified as a length, the corresponding absolute length; if specified as

    // a percentage, the specified value; otherwise, 'auto'. Hence, we can just

    // return the value in the style.

    //

    // See http://www.w3.org/TR/CSS21/cascade.html#computed-value

714718 switch (propertyID) {

        case CSSPropertyLeft:

            length = style.left();

            break;

        case CSSPropertyRight:

            length = style.right();

            break;

        case CSSPropertyTop:

            length = style.top();

            break;

        case CSSPropertyBottom:

            length = style.bottom();

            break;

        default:

            return nullptr;

    case CSSPropertyLeft:

        return style.left();

    case CSSPropertyRight:

        return style.right();

    case CSSPropertyTop:

        return style.top();

    case CSSPropertyBottom:

        return style.bottom();

    default:

        ASSERT_NOT_REACHED();

729729 }

730730

    if (style.hasOutOfFlowPosition()) {

        if (length.isFixed())

            return zoomAdjustedPixelValue(length.value(), style);

731 return { };

732}

734733

735 return CSSValuePool::singleton().createValue(length);

static LayoutUnit getOffsetUsedStyleRelative(RenderBox& box, CSSPropertyID propertyID)

{

    // For relatively positioned boxes, the offset is with respect to the top edges

    // of the box itself. This ties together top/bottom and left/right to be

    // opposites of each other.

    //

    // See http://www.w3.org/TR/CSS2/visuren.html#relative-positioning

    //

    // Specifically;

    //   Since boxes are not split or stretched as a result of 'left' or

    //   'right', the used values are always: left = -right.

    // and

    //   Since boxes are not split or stretched as a result of 'top' or

    //   'bottom', the used values are always: top = -bottom.

    switch (propertyID) {

    case CSSPropertyTop:

        return box.relativePositionOffset().height();

    case CSSPropertyBottom:

        return -(box.relativePositionOffset().height());

    case CSSPropertyLeft:

        return box.relativePositionOffset().width();

    case CSSPropertyRight:

        return -(box.relativePositionOffset().width());

    default:

        ASSERT_NOT_REACHED();

736759 }

737760

    if (style.hasInFlowPosition()) {

        // FIXME: It's not enough to simply return "auto" values for one offset if the other side is defined.

        // In other words if left is auto and right is not auto, then left's computed value is negative right().

        // So we should get the opposite length unit and see if it is auto.

        return CSSValuePool::singleton().createValue(length);

    return 0;

}

static LayoutUnit getOffsetUsedStyleAbsolute(RenderBlock& container, RenderBox& box, CSSPropertyID propertyID)

{

    // For absoultely positioned boxes, the offset is how far an box's margin

    // edge is offset below the edge of the box's containing block.

    // See http://www.w3.org/TR/CSS2/visuren.html#position-props

    // Margins are included in offsetTop/offsetLeft so we need to remove them here.

    switch (propertyID) {

    case CSSPropertyTop:

        return box.offsetTop() - box.marginTop();

    case CSSPropertyBottom:

        return container.clientHeight() - (box.offsetTop() + box.offsetHeight()) - box.marginBottom();

    case CSSPropertyLeft:

        return box.offsetLeft() - box.marginLeft();

    case CSSPropertyRight:

        return container.clientWidth() - (box.offsetLeft() + box.offsetWidth()) - box.marginRight();

    default:

        ASSERT_NOT_REACHED();

743782 }

744783

745 return CSSValuePool::singleton().createIdentifierValue(CSSValueAuto);

    return 0;

}

static RefPtr<CSSValue> positionOffsetValue(const RenderStyle& style, CSSPropertyID propertyID, RenderObject* renderer)

{

    // If the element is not displayed; return the "computed value".

    if (!renderer || !renderer->isBox())

        return zoomAdjustedPixelValueForLength(getOffsetComputedLength(style, propertyID), style);

    // We should return the "used value".

    LayoutUnit length = 0;

    auto& box = downcast<RenderBox>(*renderer);

    RenderBlock* containingBlock = box.containingBlock();

    if (box.isRelPositioned() || !containingBlock)

        length = getOffsetUsedStyleRelative(box, propertyID);

    else

        length = getOffsetUsedStyleAbsolute(*containingBlock, box, propertyID);

    return zoomAdjustedPixelValue(length, style);

}

RefPtr<CSSPrimitiveValue> ComputedStyleExtractor::currentColorOrValidColor(const RenderStyle* style, const Color& color) const

@@static bool paddingOrMarginIsRendererDependent(const RenderStyle* style, RenderO

    return renderer && style && renderer->isBox() && !(style->*lengthGetter)().isFixed();

}

static bool positionOffsetValueIsRendererDependent(const RenderStyle* style, RenderObject* renderer)

{

    return renderer && style && renderer->isBox();

}

static CSSValueID convertToPageBreak(BreakBetween value)

{

    if (value == PageBreakBetween || value == LeftPageBreakBetween || value == RightPageBreakBetween

@@static CSSValueID convertToRegionBreak(BreakInside value)

    return CSSValueAuto;

}

#endif

2252

static inline bool isNonReplacedInline(RenderObject& renderer)

{

    return renderer.isInline() && !renderer.isReplaced();

}

static bool isLayoutDependent(CSSPropertyID propertyID, const RenderStyle* style, RenderObject* renderer)

{

    switch (propertyID) {

    case CSSPropertyTop:

    case CSSPropertyBottom:

    case CSSPropertyLeft:

    case CSSPropertyRight:

        return positionOffsetValueIsRendererDependent(style, renderer);

22562328 case CSSPropertyWidth:

22572329 case CSSPropertyHeight:

2330 return renderer && !renderer->isRenderSVGModelObject() && !isNonReplacedInline(*renderer);

    case CSSPropertyPerspectiveOrigin:

    case CSSPropertyTransformOrigin:

    case CSSPropertyTransform:

2261 case CSSPropertyFilter:

2334 case CSSPropertyFilter: // Why are filters layout-dependent?

22622335#if ENABLE(FILTERS_LEVEL_2)

2263 case CSSPropertyWebkitBackdropFilter:

2336 case CSSPropertyWebkitBackdropFilter: // Ditto for backdrop-filter.

#endif

        return true;

    case CSSPropertyMargin: {

@@static bool isImplicitlyInheritedGridOrFlexProperty(CSSPropertyID propertyID)

    }

}

// In CSS 2.1 the returned object should actually contain the "used values"

// rather then the "computed values" (despite the name saying otherwise).

//

// See;

// http://www.w3.org/TR/CSS21/cascade.html#used-value

// http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration

// https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle#Notes

RefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(CSSPropertyID propertyID, EUpdateLayout updateLayout) const

{

    return ComputedStyleExtractor(m_element.ptr(), m_allowVisitedStyle, m_pseudoElementSpecifier).propertyValue(propertyID, updateLayout);