Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / css / display.lucb

#==============================================================================================
#
#   display - Display: the value of the display property
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/Display.cpp (lines 1-171) and the inline members of Display.h, in
#       the header's order with to_string, from_keyword, from_short and to_keyword where the
#       header declares them. C++'s operator== is css_display_eq. Display() = default is the
#       zero value (an outside-and-inside display of zeroed parts).
#
#       Copyright (c) 2021, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2022, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2023, Sam Atkins <atkinssj@serenityos.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Serialization and comparison ============================================================

## Ported from Libraries/LibWeb/CSS/Display.cpp:13 Web::CSS::Display::to_string.
pub func css_display_to_string(this: const CssDisplay*) -> ak.String:
    if let keyword = css_display_to_keyword(this):
        let keyword_string = css_data.string_from_keyword(keyword)
        return ak.string_from_utf8_without_validation(ak.string_view_bytes(&keyword_string))
    assert(this.m_type == CssDisplayType.outside_and_inside)
    var parts: ak.StringView[3] = ---
    var count: usize = 0
    let outside_inside = this.m_value.outside_inside
    if not (outside_inside.outside == css_data.DisplayOutside.block and outside_inside.inside == css_data.DisplayInside.flow_root):
        parts[count] = css_data.to_string_display_outside(outside_inside.outside)
        count += 1
    if outside_inside.inside != css_data.DisplayInside.flow:
        parts[count] = css_data.to_string_display_inside(outside_inside.inside)
        count += 1
    if outside_inside.list_item == CssDisplayListItem.yes:
        parts[count] = ak.sv("list-item")
        count += 1
    let joined: const ak.StringView[] = parts[..<count]
    return ak.string_join_string_view(ak.sv(" "), joined) else trap("MUST: String::join")

## Ported from Libraries/LibWeb/CSS/Display.h:24 Web::CSS::Display::operator==.
pub func css_display_eq(this: const CssDisplay*, other: CssDisplay) -> bool:
    if this.m_type != other.m_type:
        return false
    match this.m_type:
        .box:
            return this.m_value.box == other.m_value.box
        .internal:
            return this.m_value.internal == other.m_value.internal
        .outside_and_inside:
            return this.m_value.outside_inside.outside == other.m_value.outside_inside.outside and this.m_value.outside_inside.inside == other.m_value.outside_inside.inside and this.m_value.outside_inside.list_item == other.m_value.outside_inside.list_item
        _: trap("VERIFY_NOT_REACHED")

# mark: Internal displays =======================================================================

## Ported from Libraries/LibWeb/CSS/Display.h:52 Web::CSS::Display::is_internal.
pub func css_display_is_internal(this: const CssDisplay*) -> bool:
    return this.m_type == CssDisplayType.internal

## Ported from Libraries/LibWeb/CSS/Display.h:53 Web::CSS::Display::internal.
pub func css_display_internal(this: const CssDisplay*) -> css_data.DisplayInternal:
    assert(css_display_is_internal(this))
    return this.m_value.internal

## Ported from Libraries/LibWeb/CSS/Display.h:59 Web::CSS::Display::is_table_column.
pub func css_display_is_table_column(this: const CssDisplay*) -> bool:
    return css_display_is_internal(this) and css_display_internal(this) == css_data.DisplayInternal.table_column

## Ported from Libraries/LibWeb/CSS/Display.h:60 Web::CSS::Display::is_table_row_group.
pub func css_display_is_table_row_group(this: const CssDisplay*) -> bool:
    return css_display_is_internal(this) and css_display_internal(this) == css_data.DisplayInternal.table_row_group

## Ported from Libraries/LibWeb/CSS/Display.h:61 Web::CSS::Display::is_table_header_group.
pub func css_display_is_table_header_group(this: const CssDisplay*) -> bool:
    return css_display_is_internal(this) and css_display_internal(this) == css_data.DisplayInternal.table_header_group

## Ported from Libraries/LibWeb/CSS/Display.h:62 Web::CSS::Display::is_table_footer_group.
pub func css_display_is_table_footer_group(this: const CssDisplay*) -> bool:
    return css_display_is_internal(this) and css_display_internal(this) == css_data.DisplayInternal.table_footer_group

## Ported from Libraries/LibWeb/CSS/Display.h:63 Web::CSS::Display::is_table_row.
pub func css_display_is_table_row(this: const CssDisplay*) -> bool:
    return css_display_is_internal(this) and css_display_internal(this) == css_data.DisplayInternal.table_row

## Ported from Libraries/LibWeb/CSS/Display.h:64 Web::CSS::Display::is_table_cell.
pub func css_display_is_table_cell(this: const CssDisplay*) -> bool:
    return css_display_is_internal(this) and css_display_internal(this) == css_data.DisplayInternal.table_cell

## Ported from Libraries/LibWeb/CSS/Display.h:65 Web::CSS::Display::is_table_column_group.
pub func css_display_is_table_column_group(this: const CssDisplay*) -> bool:
    return css_display_is_internal(this) and css_display_internal(this) == css_data.DisplayInternal.table_column_group

## Ported from Libraries/LibWeb/CSS/Display.h:66 Web::CSS::Display::is_table_caption.
pub func css_display_is_table_caption(this: const CssDisplay*) -> bool:
    return css_display_is_internal(this) and css_display_internal(this) == css_data.DisplayInternal.table_caption

## Ported from Libraries/LibWeb/CSS/Display.h:69 Web::CSS::Display::is_internal_table.
# https://drafts.csswg.org/css-display-3/#internal-table-element
pub func css_display_is_internal_table(this: const CssDisplay*) -> bool:
    if not css_display_is_internal(this):
        return false
    let internal = css_display_internal(this)
    return internal == css_data.DisplayInternal.table_row_group or internal == css_data.DisplayInternal.table_header_group or internal == css_data.DisplayInternal.table_footer_group or internal == css_data.DisplayInternal.table_row or internal == css_data.DisplayInternal.table_cell or internal == css_data.DisplayInternal.table_column_group or internal == css_data.DisplayInternal.table_column

# mark: Boxes, outside and inside ===============================================================

## Ported from Libraries/LibWeb/CSS/Display.h:81 Web::CSS::Display::is_none.
pub func css_display_is_none(this: const CssDisplay*) -> bool:
    return this.m_type == CssDisplayType.box and this.m_value.box == css_data.DisplayBox.none_

## Ported from Libraries/LibWeb/CSS/Display.h:82 Web::CSS::Display::is_contents.
pub func css_display_is_contents(this: const CssDisplay*) -> bool:
    return this.m_type == CssDisplayType.box and this.m_value.box == css_data.DisplayBox.contents

## Ported from Libraries/LibWeb/CSS/Display.h:84 Web::CSS::Display::type.
pub func css_display_type(this: const CssDisplay*) -> CssDisplayType:
    return this.m_type

## Ported from Libraries/LibWeb/CSS/Display.h:86 Web::CSS::Display::is_outside_and_inside.
pub func css_display_is_outside_and_inside(this: const CssDisplay*) -> bool:
    return this.m_type == CssDisplayType.outside_and_inside

## Ported from Libraries/LibWeb/CSS/Display.h:88 Web::CSS::Display::outside.
pub func css_display_outside(this: const CssDisplay*) -> css_data.DisplayOutside:
    assert(css_display_is_outside_and_inside(this))
    return this.m_value.outside_inside.outside

## Ported from Libraries/LibWeb/CSS/Display.h:94 Web::CSS::Display::is_block_outside.
pub func css_display_is_block_outside(this: const CssDisplay*) -> bool:
    return css_display_is_outside_and_inside(this) and css_display_outside(this) == css_data.DisplayOutside.block

## Ported from Libraries/LibWeb/CSS/Display.h:95 Web::CSS::Display::is_inline_outside.
pub func css_display_is_inline_outside(this: const CssDisplay*) -> bool:
    return css_display_is_outside_and_inside(this) and css_display_outside(this) == css_data.DisplayOutside.inline

## Ported from Libraries/LibWeb/CSS/Display.h:96 Web::CSS::Display::is_inline_block.
pub func css_display_is_inline_block(this: const CssDisplay*) -> bool:
    return css_display_is_inline_outside(this) and css_display_is_flow_root_inside(this)

## Ported from Libraries/LibWeb/CSS/Display.h:98 Web::CSS::Display::list_item.
pub func css_display_list_item(this: const CssDisplay*) -> CssDisplayListItem:
    assert(css_display_is_outside_and_inside(this))
    return this.m_value.outside_inside.list_item

## Ported from Libraries/LibWeb/CSS/Display.h:104 Web::CSS::Display::is_list_item.
pub func css_display_is_list_item(this: const CssDisplay*) -> bool:
    return css_display_is_outside_and_inside(this) and css_display_list_item(this) == CssDisplayListItem.yes

## Ported from Libraries/LibWeb/CSS/Display.h:106 Web::CSS::Display::inside.
pub func css_display_inside(this: const CssDisplay*) -> css_data.DisplayInside:
    assert(css_display_is_outside_and_inside(this))
    return this.m_value.outside_inside.inside

## Ported from Libraries/LibWeb/CSS/Display.h:112 Web::CSS::Display::is_flow_inside.
pub func css_display_is_flow_inside(this: const CssDisplay*) -> bool:
    return css_display_is_outside_and_inside(this) and css_display_inside(this) == css_data.DisplayInside.flow

## Ported from Libraries/LibWeb/CSS/Display.h:113 Web::CSS::Display::is_flow_root_inside.
pub func css_display_is_flow_root_inside(this: const CssDisplay*) -> bool:
    return css_display_is_outside_and_inside(this) and css_display_inside(this) == css_data.DisplayInside.flow_root

## Ported from Libraries/LibWeb/CSS/Display.h:114 Web::CSS::Display::is_table_inside.
pub func css_display_is_table_inside(this: const CssDisplay*) -> bool:
    return css_display_is_outside_and_inside(this) and css_display_inside(this) == css_data.DisplayInside.table

## Ported from Libraries/LibWeb/CSS/Display.h:115 Web::CSS::Display::is_flex_inside.
pub func css_display_is_flex_inside(this: const CssDisplay*) -> bool:
    return css_display_is_outside_and_inside(this) and css_display_inside(this) == css_data.DisplayInside.flex

## Ported from Libraries/LibWeb/CSS/Display.h:116 Web::CSS::Display::is_grid_inside.
pub func css_display_is_grid_inside(this: const CssDisplay*) -> bool:
    return css_display_is_outside_and_inside(this) and css_display_inside(this) == css_data.DisplayInside.grid

## Ported from Libraries/LibWeb/CSS/Display.h:117 Web::CSS::Display::is_ruby_inside.
pub func css_display_is_ruby_inside(this: const CssDisplay*) -> bool:
    return css_display_is_outside_and_inside(this) and css_display_inside(this) == css_data.DisplayInside.ruby

## Ported from Libraries/LibWeb/CSS/Display.h:118 Web::CSS::Display::is_math_inside.
pub func css_display_is_math_inside(this: const CssDisplay*) -> bool:
    return css_display_is_outside_and_inside(this) and css_display_inside(this) == css_data.DisplayInside.math

# mark: Keywords and short displays =============================================================

## Ported from Libraries/LibWeb/CSS/Display.cpp:30 Web::CSS::Display::from_keyword.
pub func css_display_from_keyword(keyword: css_data.Keyword) -> CssDisplay:
    match keyword:
        .none_: return css_display_from_short(CssDisplayShort.none_)
        .contents: return css_display_from_short(CssDisplayShort.contents)
        .block: return css_display_from_short(CssDisplayShort.block)
        .inline: return css_display_from_short(CssDisplayShort.inline)
        .flow: return css_display_from_short(CssDisplayShort.flow)
        .flow_root: return css_display_from_short(CssDisplayShort.flow_root)
        .inline_block: return css_display_from_short(CssDisplayShort.inline_block)
        .run_in: return css_display_from_short(CssDisplayShort.run_in)
        .list_item: return css_display_from_short(CssDisplayShort.list_item)
        .flex: return css_display_from_short(CssDisplayShort.flex)
        .inline_flex: return css_display_from_short(CssDisplayShort.inline_flex)
        .grid: return css_display_from_short(CssDisplayShort.grid)
        .inline_grid: return css_display_from_short(CssDisplayShort.inline_grid)
        .ruby: return css_display_from_short(CssDisplayShort.ruby)
        .table: return css_display_from_short(CssDisplayShort.table)
        .inline_table: return css_display_from_short(CssDisplayShort.inline_table)
        .math: return css_display_from_short(CssDisplayShort.math)
        _: _ = keyword

    if let internal_value = css_data.keyword_to_display_internal(keyword):
        return css_display_new_display_internal(internal_value)
    trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/CSS/Display.cpp:77 Web::CSS::Display::from_short.
pub func css_display_from_short(short_: CssDisplayShort) -> CssDisplay:
    match short_:
        .none_: return css_display_new_display_box(css_data.DisplayBox.none_)
        .contents: return css_display_new_display_box(css_data.DisplayBox.contents)
        .block: return css_display_new(css_data.DisplayOutside.block, css_data.DisplayInside.flow)
        .inline: return css_display_new(css_data.DisplayOutside.inline, css_data.DisplayInside.flow)
        .flow: return css_display_new(css_data.DisplayOutside.block, css_data.DisplayInside.flow)
        .flow_root: return css_display_new(css_data.DisplayOutside.block, css_data.DisplayInside.flow_root)
        .inline_block: return css_display_new(css_data.DisplayOutside.inline, css_data.DisplayInside.flow_root)
        .run_in: return css_display_new(css_data.DisplayOutside.run_in, css_data.DisplayInside.flow)
        .list_item: return css_display_new_list_item(css_data.DisplayOutside.block, css_data.DisplayInside.flow, CssDisplayListItem.yes)
        .inline_list_item: return css_display_new_list_item(css_data.DisplayOutside.inline, css_data.DisplayInside.flow, CssDisplayListItem.yes)
        .flex: return css_display_new(css_data.DisplayOutside.block, css_data.DisplayInside.flex)
        .inline_flex: return css_display_new(css_data.DisplayOutside.inline, css_data.DisplayInside.flex)
        .grid: return css_display_new(css_data.DisplayOutside.block, css_data.DisplayInside.grid)
        .inline_grid: return css_display_new(css_data.DisplayOutside.inline, css_data.DisplayInside.grid)
        .ruby: return css_display_new(css_data.DisplayOutside.inline, css_data.DisplayInside.ruby)
        .table: return css_display_new(css_data.DisplayOutside.block, css_data.DisplayInside.table)
        .inline_table: return css_display_new(css_data.DisplayOutside.inline, css_data.DisplayInside.table)
        .math:
            # NOTE: The spec ( https://w3c.github.io/mathml-core/#new-display-math-value ) does not
            #       mention what the outside value for `display: math` should be but other browsers
            #       use `inline` so let's go with that.
            return css_display_new(css_data.DisplayOutside.inline, css_data.DisplayInside.math)
        _: trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/CSS/Display.cpp:123 Web::CSS::Display::to_keyword.
pub func css_display_to_keyword(this: const CssDisplay*) -> css_data.Keyword?:
    match this.m_type:
        .box:
            return css_data.keyword_from_string(css_data.to_string_display_box(this.m_value.box))
        .internal:
            return css_data.keyword_from_string(css_data.to_string_display_internal(this.m_value.internal))
        .outside_and_inside:
            # NOTE: Following the precedence rules of "most backwards-compatible, then shortest",
            #       serialization of equivalent display values uses the "Short display" column.
            if css_display_eq(this, css_display_from_short(CssDisplayShort.none_)):
                return css_data.Keyword.none_
            if css_display_eq(this, css_display_from_short(CssDisplayShort.contents)):
                return css_data.Keyword.contents
            if css_display_eq(this, css_display_from_short(CssDisplayShort.block)):
                return css_data.Keyword.block
            if css_display_eq(this, css_display_from_short(CssDisplayShort.flow_root)):
                return css_data.Keyword.flow_root
            if css_display_eq(this, css_display_from_short(CssDisplayShort.inline)):
                return css_data.Keyword.inline
            if css_display_eq(this, css_display_from_short(CssDisplayShort.inline_block)):
                return css_data.Keyword.inline_block
            if css_display_eq(this, css_display_from_short(CssDisplayShort.run_in)):
                return css_data.Keyword.run_in
            if css_display_eq(this, css_display_from_short(CssDisplayShort.list_item)):
                return css_data.Keyword.list_item
            if css_display_eq(this, css_display_from_short(CssDisplayShort.flex)):
                return css_data.Keyword.flex
            if css_display_eq(this, css_display_from_short(CssDisplayShort.inline_flex)):
                return css_data.Keyword.inline_flex
            if css_display_eq(this, css_display_from_short(CssDisplayShort.grid)):
                return css_data.Keyword.grid
            if css_display_eq(this, css_display_from_short(CssDisplayShort.inline_grid)):
                return css_data.Keyword.inline_grid
            if css_display_eq(this, css_display_from_short(CssDisplayShort.ruby)):
                return css_data.Keyword.ruby
            if css_display_eq(this, css_display_from_short(CssDisplayShort.table)):
                return css_data.Keyword.table
            if css_display_eq(this, css_display_from_short(CssDisplayShort.inline_table)):
                return css_data.Keyword.inline_table
            if css_display_eq(this, css_display_from_short(CssDisplayShort.math)):
                return css_data.Keyword.math
            return none
        _: trap("VERIFY_NOT_REACHED")

# mark: Constructors ============================================================================

## Ported from Libraries/LibWeb/CSS/Display.h:145 Web::CSS::Display::Display.
pub func css_display_construct_display_outside_display_inside(this: CssDisplay*, outside: css_data.DisplayOutside, inside: css_data.DisplayInside):
    this.m_type = CssDisplayType.outside_and_inside
    this.m_value.outside_inside = CssDisplayUnionStruct(outside = outside, inside = inside, list_item = CssDisplayListItem.no)

## Ported from Libraries/LibWeb/CSS/Display.h:155 Web::CSS::Display::Display.
pub func css_display_construct_display_outside_display_inside_css_display_list_item(this: CssDisplay*, outside: css_data.DisplayOutside, inside: css_data.DisplayInside, list_item: CssDisplayListItem):
    this.m_type = CssDisplayType.outside_and_inside
    this.m_value.outside_inside = CssDisplayUnionStruct(outside = outside, inside = inside, list_item = list_item)

## Ported from Libraries/LibWeb/CSS/Display.h:165 Web::CSS::Display::Display.
pub func css_display_construct_display_internal(this: CssDisplay*, internal: css_data.DisplayInternal):
    this.m_type = CssDisplayType.internal
    this.m_value.internal = internal

## Ported from Libraries/LibWeb/CSS/Display.h:171 Web::CSS::Display::Display.
pub func css_display_construct_display_box(this: CssDisplay*, box: css_data.DisplayBox):
    this.m_type = CssDisplayType.box
    this.m_value.box = box

## `Display { outside, inside }` as a value.
pub func css_display_new(outside: css_data.DisplayOutside, inside: css_data.DisplayInside) -> CssDisplay:
    var display: CssDisplay
    css_display_construct_display_outside_display_inside(&display, outside, inside)
    return display

## `Display { outside, inside, list_item }` as a value.
pub func css_display_new_list_item(outside: css_data.DisplayOutside, inside: css_data.DisplayInside, list_item: CssDisplayListItem) -> CssDisplay:
    var display: CssDisplay
    css_display_construct_display_outside_display_inside_css_display_list_item(&display, outside, inside, list_item)
    return display

## `Display { internal }` as a value.
pub func css_display_new_display_internal(internal: css_data.DisplayInternal) -> CssDisplay:
    var display: CssDisplay
    css_display_construct_display_internal(&display, internal)
    return display

## `Display { box }` as a value.
pub func css_display_new_display_box(box: css_data.DisplayBox) -> CssDisplay:
    var display: CssDisplay
    css_display_construct_display_box(&display, box)
    return display