Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / css / size.lucb

#==============================================================================================
#
#   size - Size: the value of width, height, min-* and max-*
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/Size.cpp (lines 1-178) and the inline members of Size.h, in the
#       order of Size.cpp with the header's members after the factories. The defaulted
#       operator== is css_size_eq (the length-percentages compare as PercentageOr<Length>).
#
#       Copyright (c) 2022, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2023, Sam Atkins <atkinssj@serenityos.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

## Ported from Libraries/LibWeb/CSS/Size.cpp:13 Web::CSS::Size::Size.
pub func css_size_construct(this: CssSize*, type_: CssSizeType, length_percentage: CssLengthPercentage? = none):
    this.m_type = type_
    this.m_length_percentage = length_percentage

## `Size { type, length_percentage }` as a value.
func css_size_new(type_: CssSizeType, length_percentage: CssLengthPercentage? = none) -> CssSize:
    var size: CssSize = ---
    css_size_construct(&size, type_, length_percentage)
    return size

## Ported from Libraries/LibWeb/CSS/Size.cpp:19 Web::CSS::Size::to_px.
pub func css_size_to_px(this: const CssSize*, node: LayoutNode*, reference_value: gfx.CssPixels) -> gfx.CssPixels:
    let length_percentage = this.m_length_percentage else return gfx.css_pixels_from_int(0)
    let resolved = css_percentage_or_resolved_css_pixels(&length_percentage.percentage_or, node, reference_value)
    return css_length_to_px_layout_node(&resolved, node)

## Ported from Libraries/LibWeb/CSS/Size.cpp:26 Web::CSS::Size::make_auto.
pub func css_size_make_auto() -> CssSize:
    return css_size_new(CssSizeType.auto)

## Ported from Libraries/LibWeb/CSS/Size.cpp:31 Web::CSS::Size::make_px.
pub func css_size_make_px(px: gfx.CssPixels) -> CssSize:
    return css_size_make_length(css_length_make_px_css_pixels(px))

## Ported from Libraries/LibWeb/CSS/Size.cpp:36 Web::CSS::Size::make_length.
pub func css_size_make_length(length: CssLength) -> CssSize:
    return css_size_new(CssSizeType.length, css_length_percentage_new_css_length(length))

## Ported from Libraries/LibWeb/CSS/Size.cpp:41 Web::CSS::Size::make_percentage.
pub func css_size_make_percentage(percentage: CssPercentage) -> CssSize:
    return css_size_new(CssSizeType.percentage, css_length_percentage_new_css_percentage(percentage))

## Ported from Libraries/LibWeb/CSS/Size.cpp:46 Web::CSS::Size::make_calculated.
pub func css_size_make_calculated(calculated: CssCalculatedStyleValue*) -> CssSize:
    return css_size_new(CssSizeType.calculated, css_length_percentage_new_css_calculated_style_value(calculated))

## Ported from Libraries/LibWeb/CSS/Size.cpp:51 Web::CSS::Size::make_length_percentage.
pub func css_size_make_length_percentage(length_percentage: CssLengthPercentage) -> CssSize:
    if css_length_percentage_is_length(&length_percentage):
        return css_size_make_length(css_length_percentage_length(&length_percentage))
    if css_percentage_or_is_percentage(&length_percentage.percentage_or):
        return css_size_make_percentage(css_percentage_or_percentage(&length_percentage.percentage_or))
    assert(css_percentage_or_is_calculated(&length_percentage.percentage_or))
    return css_size_make_calculated(css_percentage_or_calculated(&length_percentage.percentage_or))

## Ported from Libraries/LibWeb/CSS/Size.cpp:61 Web::CSS::Size::make_min_content.
pub func css_size_make_min_content() -> CssSize:
    return css_size_new(CssSizeType.min_content)

## Ported from Libraries/LibWeb/CSS/Size.cpp:66 Web::CSS::Size::make_max_content.
pub func css_size_make_max_content() -> CssSize:
    return css_size_new(CssSizeType.max_content)

## Ported from Libraries/LibWeb/CSS/Size.cpp:71 Web::CSS::Size::make_fit_content.
pub func css_size_make_fit_content_css_length_percentage(available_space: CssLengthPercentage) -> CssSize:
    return css_size_new(CssSizeType.fit_content, available_space)

## Ported from Libraries/LibWeb/CSS/Size.cpp:76 Web::CSS::Size::make_fit_content.
pub func css_size_make_fit_content() -> CssSize:
    return css_size_new(CssSizeType.fit_content)

## Ported from Libraries/LibWeb/CSS/Size.cpp:81 Web::CSS::Size::make_none.
pub func css_size_make_none() -> CssSize:
    return css_size_new(CssSizeType.none_)

## Ported from Libraries/LibWeb/CSS/Size.cpp:86 Web::CSS::Size::from_style_value.
pub func css_size_from_style_value(value: CssStyleValue*) -> CssSize:
    if css_style_value_is_keyword(value):
        match css_style_value_to_keyword(value):
            .auto: return css_size_make_auto()
            .fit_content: return css_size_make_fit_content()
            .min_content: return css_size_make_min_content()
            .max_content: return css_size_make_max_content()
            .none_: return css_size_make_none()
            _: trap("VERIFY_NOT_REACHED")

    if css_style_value_is_function(value):
        let function = css_style_value_as_function(value)
        let name = css_function_style_value_name(function)
        if ak.fly_string_eq_string_view(&name, ak.sv("fit-content")):
            return css_size_make_fit_content_css_length_percentage(css_length_percentage_from_style_value(css_function_style_value_value(function)))
    if css_style_value_is_calculated(value):
        return css_size_make_calculated(css_style_value_as_calculated(value))
    if css_style_value_is_percentage(value):
        return css_size_make_percentage(css_percentage_style_value_percentage(css_style_value_as_percentage(value)))
    if css_style_value_is_length(value):
        return css_size_make_length(css_length_style_value_length(css_style_value_as_length(value)))
    # FIXME: Support `anchor-size(..)`
    if css_style_value_is_anchor_size(value):
        return css_size_make_none()

    let text = css_style_value_to_string(value, css_syntax.SerializationMode.normal)
    ak.dbgln(f"FIXME: Unsupported size value: `{ak.string_view_text(ak.string_bytes_as_string_view(&text))}`, treating as `auto`")
    return css_size_make_auto()

## Ported from Libraries/LibWeb/CSS/Size.h:42 Web::CSS::Size::is_auto.
pub func css_size_is_auto(this: const CssSize*) -> bool:
    return this.m_type == CssSizeType.auto

## Ported from Libraries/LibWeb/CSS/Size.h:43 Web::CSS::Size::is_calculated.
pub func css_size_is_calculated(this: const CssSize*) -> bool:
    return this.m_type == CssSizeType.calculated

## Ported from Libraries/LibWeb/CSS/Size.h:44 Web::CSS::Size::is_length.
pub func css_size_is_length(this: const CssSize*) -> bool:
    return this.m_type == CssSizeType.length

## Ported from Libraries/LibWeb/CSS/Size.h:45 Web::CSS::Size::is_percentage.
pub func css_size_is_percentage(this: const CssSize*) -> bool:
    return this.m_type == CssSizeType.percentage

## Ported from Libraries/LibWeb/CSS/Size.h:46 Web::CSS::Size::is_min_content.
pub func css_size_is_min_content(this: const CssSize*) -> bool:
    return this.m_type == CssSizeType.min_content

## Ported from Libraries/LibWeb/CSS/Size.h:47 Web::CSS::Size::is_max_content.
pub func css_size_is_max_content(this: const CssSize*) -> bool:
    return this.m_type == CssSizeType.max_content

## Ported from Libraries/LibWeb/CSS/Size.h:48 Web::CSS::Size::is_fit_content.
pub func css_size_is_fit_content(this: const CssSize*) -> bool:
    return this.m_type == CssSizeType.fit_content

## Ported from Libraries/LibWeb/CSS/Size.h:49 Web::CSS::Size::is_none.
pub func css_size_is_none(this: const CssSize*) -> bool:
    return this.m_type == CssSizeType.none_

## Ported from Libraries/LibWeb/CSS/Size.h:50 Web::CSS::Size::type.
pub func css_size_type(this: const CssSize*) -> CssSizeType:
    return this.m_type

## Ported from Libraries/LibWeb/CSS/Size.h:52 Web::CSS::Size::is_intrinsic_sizing_constraint.
pub func css_size_is_intrinsic_sizing_constraint(this: const CssSize*) -> bool:
    return css_size_is_min_content(this) or css_size_is_max_content(this) or css_size_is_fit_content(this)

## Ported from Libraries/LibWeb/CSS/Size.h:53 Web::CSS::Size::is_length_percentage.
pub func css_size_is_length_percentage(this: const CssSize*) -> bool:
    return css_size_is_length(this) or css_size_is_percentage(this) or css_size_is_calculated(this)

## Ported from Libraries/LibWeb/CSS/Size.h:59 Web::CSS::Size::calculated.
pub func css_size_calculated(this: const CssSize*) -> CssCalculatedStyleValue*:
    assert(css_size_is_calculated(this))
    let length_percentage = this.m_length_percentage else trap("VERIFY: a length-percentage")
    return css_percentage_or_calculated(&length_percentage.percentage_or)

## Ported from Libraries/LibWeb/CSS/Size.h:65 Web::CSS::Size::length.
pub func css_size_length(this: const CssSize*) -> CssLength:
    assert(css_size_is_length(this))
    let length_percentage = this.m_length_percentage else trap("VERIFY: a length-percentage")
    return css_length_percentage_length(&length_percentage)

## Ported from Libraries/LibWeb/CSS/Size.h:71 Web::CSS::Size::percentage.
pub func css_size_percentage(this: const CssSize*) -> CssPercentage:
    assert(css_size_is_percentage(this))
    let length_percentage = this.m_length_percentage else trap("VERIFY: a length-percentage")
    return css_percentage_or_percentage(&length_percentage.percentage_or)

## Ported from Libraries/LibWeb/CSS/Size.h:77 Web::CSS::Size::length_percentage.
pub func css_size_length_percentage(this: const CssSize*) -> CssLengthPercentage:
    assert(css_size_is_length_percentage(this))
    return this.m_length_percentage else trap("VERIFY: a length-percentage")

## Ported from Libraries/LibWeb/CSS/Size.h:83 Web::CSS::Size::fit_content_available_space.
pub func css_size_fit_content_available_space(this: const CssSize*) -> CssLengthPercentage?:
    assert(css_size_is_fit_content(this))
    return this.m_length_percentage

## Ported from Libraries/LibWeb/CSS/Size.cpp:124 Web::CSS::Size::contains_percentage.
pub func css_size_contains_percentage(this: const CssSize*) -> bool:
    match this.m_type:
        .auto, .min_content, .max_content, .none_:
            return false
        .fit_content:
            if let length_percentage = this.m_length_percentage:
                return css_percentage_or_contains_percentage(&length_percentage.percentage_or)
            return false
        _:
            let length_percentage = this.m_length_percentage else trap("VERIFY: a length-percentage")
            return css_percentage_or_contains_percentage(&length_percentage.percentage_or)

## Ported from Libraries/LibWeb/CSS/Size.cpp:139 Web::CSS::Size::serialize.
pub func css_size_serialize(this: const CssSize*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    match this.m_type:
        .auto:
            ak.string_builder_append(builder, "auto")
        .calculated, .length, .percentage:
            let length_percentage = this.m_length_percentage else trap("VERIFY: a length-percentage")
            css_percentage_or_serialize(&length_percentage.percentage_or, builder, mode)
        .min_content:
            ak.string_builder_append(builder, "min-content")
        .max_content:
            ak.string_builder_append(builder, "max-content")
        .fit_content:
            if let length_percentage = this.m_length_percentage:
                ak.string_builder_append(builder, "fit-content(")
                css_percentage_or_serialize(&length_percentage.percentage_or, builder, mode)
                ak.string_builder_append(builder, ")")
            else:
                ak.string_builder_append(builder, "fit-content")
        .none_:
            ak.string_builder_append(builder, "none")
        _: trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/CSS/Size.cpp:171 Web::CSS::Size::to_string.
pub func css_size_to_string(this: const CssSize*, mode: css_syntax.SerializationMode) -> ak.String:
    var builder = ak.string_builder_new()
    css_size_serialize(this, &builder, mode)
    return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")

## Ported from Libraries/LibWeb/CSS/Size.h:91 Web::CSS::Size::operator== (defaulted: the type, then the
## length-percentages as PercentageOr<Length>::operator== compares them).
pub func css_size_eq(this: const CssSize*, other: CssSize) -> bool:
    if this.m_type != other.m_type:
        return false
    if let length_percentage = this.m_length_percentage:
        if let other_length_percentage = other.m_length_percentage:
            return css_percentage_or_eq(&length_percentage.percentage_or, other_length_percentage.percentage_or)
        return false
    return other.m_length_percentage == none