dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / css / media_query.lucb
#==============================================================================================
#
# media_query - CSS::MediaQuery and CSS::MediaFeature: media queries, their features and
# values, evaluation against a document and serialization
#
# DESCRIPTION:
# Port of LibWeb/CSS/MediaQuery.cpp (lines 1-359) and the inline members of MediaQuery.h
# (lines 18-218). A MediaFeature is a BooleanExpression; a MediaQuery (C++ RefCounted) is
# a managed blob whose `m_matches` caches the last evaluation.
#
# Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: MediaFeatureValue =======================================================================
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:36 Web::CSS::MediaFeatureValue::MediaFeatureValue.
pub func css_media_feature_value_construct(this: CssMediaFeatureValue*, type_: CssMediaFeatureValueType, value: CssStyleValue*):
this.m_type = type_
this.m_value = value
## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:29 Web::CSS::MediaFeatureValue::to_string.
pub func css_media_feature_value_to_string(this: const CssMediaFeatureValue*, mode: css_syntax.SerializationMode) -> ak.String:
var builder = ak.string_builder_new()
css_style_value_serialize(this.m_value, &builder, mode)
return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:44 Web::CSS::MediaFeatureValue::is_ident.
pub func css_media_feature_value_is_ident(this: const CssMediaFeatureValue*) -> bool:
return this.m_type == CssMediaFeatureValueType.ident
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:45 Web::CSS::MediaFeatureValue::is_length.
pub func css_media_feature_value_is_length(this: const CssMediaFeatureValue*) -> bool:
return this.m_type == CssMediaFeatureValueType.length
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:46 Web::CSS::MediaFeatureValue::is_integer.
pub func css_media_feature_value_is_integer(this: const CssMediaFeatureValue*) -> bool:
return this.m_type == CssMediaFeatureValueType.integer
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:47 Web::CSS::MediaFeatureValue::is_ratio.
pub func css_media_feature_value_is_ratio(this: const CssMediaFeatureValue*) -> bool:
return this.m_type == CssMediaFeatureValueType.ratio
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:48 Web::CSS::MediaFeatureValue::is_resolution.
pub func css_media_feature_value_is_resolution(this: const CssMediaFeatureValue*) -> bool:
return this.m_type == CssMediaFeatureValueType.resolution
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:49 Web::CSS::MediaFeatureValue::is_unknown.
pub func css_media_feature_value_is_unknown(this: const CssMediaFeatureValue*) -> bool:
return this.m_type == CssMediaFeatureValueType.unknown
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:50 Web::CSS::MediaFeatureValue::is_same_type.
pub func css_media_feature_value_is_same_type(this: const CssMediaFeatureValue*, other: CssMediaFeatureValue) -> bool:
return this.m_type == other.m_type
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:52 Web::CSS::MediaFeatureValue::ident.
pub func css_media_feature_value_ident(this: const CssMediaFeatureValue*) -> css_data.Keyword:
assert(css_media_feature_value_is_ident(this))
return css_style_value_to_keyword(this.m_value)
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:58 Web::CSS::MediaFeatureValue::length.
pub func css_media_feature_value_length(this: const CssMediaFeatureValue*, computation_context: CssComputationContext) -> CssLength:
assert(css_media_feature_value_is_length(this))
return css_length_from_style_value(css_style_value_absolutized(this.m_value, computation_context), none)
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:64 Web::CSS::MediaFeatureValue::ratio.
pub func css_media_feature_value_ratio(this: const CssMediaFeatureValue*, computation_context: CssComputationContext) -> CssRatio:
assert(css_media_feature_value_is_ratio(this))
return css_ratio_style_value_resolved(css_style_value_as_ratio(css_style_value_absolutized(this.m_value, computation_context)))
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:70 Web::CSS::MediaFeatureValue::resolution.
pub func css_media_feature_value_resolution(this: const CssMediaFeatureValue*, computation_context: CssComputationContext) -> CssResolution:
assert(css_media_feature_value_is_resolution(this))
return css_resolution_from_style_value(css_style_value_absolutized(this.m_value, computation_context))
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:76 Web::CSS::MediaFeatureValue::integer.
pub func css_media_feature_value_integer(this: const CssMediaFeatureValue*, computation_context: CssComputationContext) -> i32:
assert(css_media_feature_value_is_integer(this))
return css_int_from_style_value(css_style_value_absolutized(this.m_value, computation_context))
# mark: MediaFeature ============================================================================
## A MediaFeature allocated and constructed (`adopt_own(*new MediaFeature(...))`).
func css_media_feature_new(type_: CssMediaFeatureType, id: css_data.MediaFeatureId, value: EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange) -> CssMediaFeature*:
let this = &(new CssMediaFeature[1] --- else trap("out of memory"))[0]
css_media_feature_construct(this, type_, id, value)
return this
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:99 Web::CSS::MediaFeature::boolean.
# Corresponds to `<mf-boolean>` grammar
pub func css_media_feature_boolean(id: css_data.MediaFeatureId) -> CssMediaFeature*:
return css_media_feature_new(CssMediaFeatureType.is_true, id, EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange.empty)
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:105 Web::CSS::MediaFeature::plain.
# Corresponds to `<mf-plain>` grammar
pub func css_media_feature_plain(id: css_data.MediaFeatureId, value: CssMediaFeatureValue) -> CssMediaFeature*:
return css_media_feature_new(CssMediaFeatureType.exact_value, id, EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange.css_media_feature_value(value))
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:109 Web::CSS::MediaFeature::min.
pub func css_media_feature_min(id: css_data.MediaFeatureId, value: CssMediaFeatureValue) -> CssMediaFeature*:
return css_media_feature_new(CssMediaFeatureType.min_value, id, EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange.css_media_feature_value(value))
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:113 Web::CSS::MediaFeature::max.
pub func css_media_feature_max(id: css_data.MediaFeatureId, value: CssMediaFeatureValue) -> CssMediaFeature*:
return css_media_feature_new(CssMediaFeatureType.max_value, id, EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange.css_media_feature_value(value))
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:118 Web::CSS::MediaFeature::half_range.
pub func css_media_feature_half_range_css_media_feature_value(value: CssMediaFeatureValue, comparison: CssMediaFeatureComparison, id: css_data.MediaFeatureId) -> CssMediaFeature*:
let range = CssMediaFeatureRange(left_value = value, left_comparison = comparison)
return css_media_feature_new(CssMediaFeatureType.range, id, EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange.css_media_feature_range(range))
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:126 Web::CSS::MediaFeature::half_range.
pub func css_media_feature_half_range_media_feature_id(id: css_data.MediaFeatureId, comparison: CssMediaFeatureComparison, value: CssMediaFeatureValue) -> CssMediaFeature*:
let range = CssMediaFeatureRange(right_comparison = comparison, right_value = value)
return css_media_feature_new(CssMediaFeatureType.range, id, EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange.css_media_feature_range(range))
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:136 Web::CSS::MediaFeature::range.
# Corresponds to `<mf-range>` grammar, with two comparisons
pub func css_media_feature_range_css_media_feature_value(left_value: CssMediaFeatureValue, left_comparison: CssMediaFeatureComparison, id: css_data.MediaFeatureId, right_comparison: CssMediaFeatureComparison, right_value: CssMediaFeatureValue) -> CssMediaFeature*:
let range = CssMediaFeatureRange(left_value = left_value, left_comparison = left_comparison, right_comparison = right_comparison, right_value = right_value)
return css_media_feature_new(CssMediaFeatureType.range, id, EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange.css_media_feature_range(range))
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:167 Web::CSS::MediaFeature::MediaFeature.
pub func css_media_feature_construct(this: CssMediaFeature*, type_: CssMediaFeatureType, id: css_data.MediaFeatureId, value: EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange):
css_boolean_expression_set_class(this.css_boolean_expression(), (const CssBooleanExpressionVTable*)&css_media_feature_vtable, &css_media_feature_class)
this.m_type = type_
this.m_id = id
this.m_value = value
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:175 Web::CSS::MediaFeature::value.
pub func css_media_feature_value(this: CssMediaFeature*) -> CssMediaFeatureValue:
match this.m_value:
.css_media_feature_value(value): return value
_: trap("VERIFY: Variant::get<MediaFeatureValue>")
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:176 Web::CSS::MediaFeature::range.
pub func css_media_feature_range(this: CssMediaFeature*) -> CssMediaFeatureRange:
match this.m_value:
.css_media_feature_range(range): return range
_: trap("VERIFY: Variant::get<Range>")
## MediaFeature::to_string's `comparison_string` lambda.
func css_media_feature_comparison_string(comparison: CssMediaFeatureComparison) -> str:
match comparison:
.equal: return "="
.less_than: return "<"
.less_than_or_equal: return "<="
.greater_than: return ">"
.greater_than_or_equal: return ">="
_: trap("VERIFY_NOT_REACHED")
## `(<prefix><feature name>: <value>)`, the plain, min and max forms of MediaFeature::to_string.
func css_media_feature_value_string(prefix: str, id: css_data.MediaFeatureId, value: const CssMediaFeatureValue*) -> ak.String:
var builder = ak.string_builder_new()
let value_string = css_media_feature_value_to_string(value, css_syntax.SerializationMode.normal)
ak.string_builder_append(&builder, "(")
ak.string_builder_append(&builder, prefix)
ak.string_builder_append_string_view(&builder, css_data.string_from_media_feature_id(id))
ak.string_builder_append(&builder, ": ")
ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&value_string))
ak.string_builder_append(&builder, ")")
return ak.string_builder_to_string(&builder) else trap("MUST: String::formatted")
## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:36 Web::CSS::MediaFeature::to_string (override).
pub func css_media_feature_to_string_impl(base: CssBooleanExpression*) -> ak.String:
let this = (CssMediaFeature*)base
# NB: Even though we parse the parentheses as part of <media-in-parens> rather than <media-feature>, we serialize
# them as part of <media-feature> to avoid having to create a whole MediaInParens class just for serialization.
match this.m_type:
.is_true:
var builder = ak.string_builder_new()
ak.string_builder_append(&builder, "(")
ak.string_builder_append_string_view(&builder, css_data.string_from_media_feature_id(this.m_id))
ak.string_builder_append(&builder, ")")
return ak.string_builder_to_string(&builder) else trap("MUST: String::formatted")
.exact_value:
let value = css_media_feature_value(this)
return css_media_feature_value_string("", this.m_id, &value)
.min_value:
let value = css_media_feature_value(this)
return css_media_feature_value_string("min-", this.m_id, &value)
.max_value:
let value = css_media_feature_value(this)
return css_media_feature_value_string("max-", this.m_id, &value)
.range:
let range = css_media_feature_range(this)
var builder = ak.string_builder_new()
ak.string_builder_append_u8(&builder, '(')
if let left_comparison = range.left_comparison:
let left_value = range.left_value else trap("VERIFY: Optional::operator->")
let left_string = css_media_feature_value_to_string(&left_value, css_syntax.SerializationMode.normal)
ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&left_string))
ak.string_builder_append(&builder, " ")
ak.string_builder_append(&builder, css_media_feature_comparison_string(left_comparison))
ak.string_builder_append(&builder, " ")
ak.string_builder_append_string_view(&builder, css_data.string_from_media_feature_id(this.m_id))
if let right_comparison = range.right_comparison:
let right_value = range.right_value else trap("VERIFY: Optional::operator->")
let right_string = css_media_feature_value_to_string(&right_value, css_syntax.SerializationMode.normal)
ak.string_builder_append(&builder, " ")
ak.string_builder_append(&builder, css_media_feature_comparison_string(right_comparison))
ak.string_builder_append(&builder, " ")
ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&right_string))
ak.string_builder_append_u8(&builder, ')')
return ak.string_builder_to_string_without_validation(&builder)
_:
trap("VERIFY_NOT_REACHED")
## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:83 Web::CSS::MediaFeature::evaluate (override).
pub func css_media_feature_evaluate_impl(base: CssBooleanExpression*, document: DomDocument*?) -> CssMatchResult:
let this = (CssMediaFeature*)base
let document_ = document else trap("VERIFY: document")
# FIXME: In some cases (e.g. when parsing HTML using DOMParser::parse_from_string()) a document may not be associated with a window -
# for now we just return false but perhaps there are some media queries we should still attempt to resolve.
let window = dom_document_window(document_) else return CssMatchResult.false_
let queried_value = html_window_query_media_feature(window, this.m_id) else return CssMatchResult.false_
let computation_context = CssComputationContext(length_resolution_context = css_length_resolution_context_for_document(document_))
match this.m_type:
.is_true:
if css_media_feature_value_is_integer(&queried_value):
return css_as_match_result(css_media_feature_value_integer(&queried_value, computation_context) != 0)
if css_media_feature_value_is_length(&queried_value):
let length = css_media_feature_value_length(&queried_value, computation_context)
return css_as_match_result(css_length_raw_value(&length) != 0.0)
# FIXME: I couldn't figure out from the spec how ratios should be evaluated in a boolean context.
if css_media_feature_value_is_ratio(&queried_value):
let ratio = css_media_feature_value_ratio(&queried_value, computation_context)
return css_as_match_result(not css_ratio_is_degenerate(&ratio))
if css_media_feature_value_is_resolution(&queried_value):
let resolution = css_media_feature_value_resolution(&queried_value, computation_context)
return css_as_match_result(css_resolution_to_dots_per_pixel(&resolution) != 0.0)
if css_media_feature_value_is_ident(&queried_value):
if css_data.media_feature_keyword_is_falsey(this.m_id, css_media_feature_value_ident(&queried_value)):
return CssMatchResult.false_
return CssMatchResult.true_
return CssMatchResult.false_
.exact_value:
return css_media_feature_compare(document_, css_media_feature_value(this), CssMediaFeatureComparison.equal, queried_value)
.min_value:
return css_media_feature_compare(document_, queried_value, CssMediaFeatureComparison.greater_than_or_equal, css_media_feature_value(this))
.max_value:
return css_media_feature_compare(document_, queried_value, CssMediaFeatureComparison.less_than_or_equal, css_media_feature_value(this))
.range:
let range = css_media_feature_range(this)
if let left_comparison = range.left_comparison:
let left_value = range.left_value else trap("VERIFY: Optional::operator*")
let left_result = css_media_feature_compare(document_, left_value, left_comparison, queried_value)
if left_result != CssMatchResult.true_:
return left_result
if let right_comparison = range.right_comparison:
let right_value = range.right_value else trap("VERIFY: Optional::operator*")
let right_result = css_media_feature_compare(document_, queried_value, right_comparison, right_value)
if right_result != CssMatchResult.true_:
return right_result
return CssMatchResult.true_
_:
trap("VERIFY_NOT_REACHED")
## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:148 Web::CSS::MediaFeature::compare.
pub func css_media_feature_compare(document: DomDocument*, left: CssMediaFeatureValue, comparison: CssMediaFeatureComparison, right: CssMediaFeatureValue) -> CssMatchResult:
if css_media_feature_value_is_unknown(&left) or css_media_feature_value_is_unknown(&right):
return CssMatchResult.unknown
if not css_media_feature_value_is_same_type(&left, right):
return CssMatchResult.false_
if css_media_feature_value_is_ident(&left):
if comparison == CssMediaFeatureComparison.equal:
return css_as_match_result(css_media_feature_value_ident(&left) == css_media_feature_value_ident(&right))
return CssMatchResult.false_
let length_resolution_context = css_length_resolution_context_for_document(document)
let computation_context = CssComputationContext(length_resolution_context = length_resolution_context)
if css_media_feature_value_is_integer(&left):
let left_integer = css_media_feature_value_integer(&left, computation_context)
let right_integer = css_media_feature_value_integer(&right, computation_context)
match comparison:
.equal: return css_as_match_result(left_integer == right_integer)
.less_than: return css_as_match_result(left_integer < right_integer)
.less_than_or_equal: return css_as_match_result(left_integer <= right_integer)
.greater_than: return css_as_match_result(left_integer > right_integer)
.greater_than_or_equal: return css_as_match_result(left_integer >= right_integer)
_: trap("VERIFY_NOT_REACHED")
if css_media_feature_value_is_length(&left):
let left_length = css_media_feature_value_length(&left, computation_context)
let right_length = css_media_feature_value_length(&right, computation_context)
let left_px = css_length_absolute_length_to_px(&left_length)
let right_px = css_length_absolute_length_to_px(&right_length)
match comparison:
.equal: return css_as_match_result(left_px.m_value == right_px.m_value)
.less_than: return css_as_match_result(left_px.m_value < right_px.m_value)
.less_than_or_equal: return css_as_match_result(left_px.m_value <= right_px.m_value)
.greater_than: return css_as_match_result(left_px.m_value > right_px.m_value)
.greater_than_or_equal: return css_as_match_result(left_px.m_value >= right_px.m_value)
_: trap("VERIFY_NOT_REACHED")
if css_media_feature_value_is_ratio(&left):
let left_ratio = css_media_feature_value_ratio(&left, computation_context)
let right_ratio = css_media_feature_value_ratio(&right, computation_context)
let left_decimal = css_ratio_value(&left_ratio)
let right_decimal = css_ratio_value(&right_ratio)
match comparison:
.equal: return css_as_match_result(left_decimal == right_decimal)
.less_than: return css_as_match_result(left_decimal < right_decimal)
.less_than_or_equal: return css_as_match_result(left_decimal <= right_decimal)
.greater_than: return css_as_match_result(left_decimal > right_decimal)
.greater_than_or_equal: return css_as_match_result(left_decimal >= right_decimal)
_: trap("VERIFY_NOT_REACHED")
if css_media_feature_value_is_resolution(&left):
let left_resolution = css_media_feature_value_resolution(&left, computation_context)
let right_resolution = css_media_feature_value_resolution(&right, computation_context)
let left_dppx = css_resolution_to_dots_per_pixel(&left_resolution)
let right_dppx = css_resolution_to_dots_per_pixel(&right_resolution)
match comparison:
.equal: return css_as_match_result(left_dppx == right_dppx)
.less_than: return css_as_match_result(left_dppx < right_dppx)
.less_than_or_equal: return css_as_match_result(left_dppx <= right_dppx)
.greater_than: return css_as_match_result(left_dppx > right_dppx)
.greater_than_or_equal: return css_as_match_result(left_dppx >= right_dppx)
_: trap("VERIFY_NOT_REACHED")
trap("VERIFY_NOT_REACHED")
## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:245 Web::CSS::MediaFeature::dump (override).
pub func css_media_feature_dump_impl(base: CssBooleanExpression*, builder: ak.StringBuilder*, indent_levels: i32):
css_boolean_expression_indent(builder, indent_levels)
let string = css_boolean_expression_to_string(base)
ak.string_builder_append(builder, "MediaFeature: ")
ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&string))
ak.string_builder_append(builder, "\n")
# mark: MediaQuery ==============================================================================
## A MediaQuery with its default member initializers (`new MediaQuery`).
func css_media_query_new() -> CssMediaQuery*:
let media_query = new CssMediaQuery else trap("out of memory")
css_media_query_init_fields(media_query)
return media_query
## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:17 Web::CSS::MediaQuery::create_not_all.
pub func css_media_query_create_not_all() -> CssMediaQuery*:
let media_query = css_media_query_new()
media_query.m_negated = true
media_query.m_media_type = CssMediaQueryMediaType(name = ak.fly_string_from_str("all"), known_type = CssMediaQueryKnownMediaType.all)
return media_query
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:201 Web::CSS::MediaQuery::create.
pub func css_media_query_create() -> CssMediaQuery*:
return css_media_query_new()
## Ported from Libraries/LibWeb/CSS/MediaQuery.h:203 Web::CSS::MediaQuery::matches.
pub func css_media_query_matches(this: const CssMediaQuery*) -> bool:
return this.m_matches
## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:251 Web::CSS::MediaQuery::to_string.
pub func css_media_query_to_string(this: const CssMediaQuery*) -> ak.String:
var builder = ak.string_builder_new()
if this.m_negated:
ak.string_builder_append(&builder, "not ")
if this.m_negated or this.m_media_type.known_type != CssMediaQueryKnownMediaType.all or this.m_media_condition == none:
if let known_type = this.m_media_type.known_type:
ak.string_builder_append_string_view(&builder, css_to_string_css_media_query_known_media_ty(known_type))
else:
let lowercase_name = ak.fly_string_to_ascii_lowercase(&this.m_media_type.name)
let identifier = css_syntax.serialize_an_identifier_string_view(ak.fly_string_bytes_as_string_view(&lowercase_name))
ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&identifier))
if this.m_media_condition != none:
ak.string_builder_append(&builder, " and ")
if let media_condition = this.m_media_condition:
let condition = css_boolean_expression_to_string(media_condition)
ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&condition))
return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")
## MediaQuery::evaluate's `matches_media` lambda.
func css_media_query_matches_media(media: const CssMediaQueryMediaType*) -> CssMatchResult:
let known_type = media.known_type else return CssMatchResult.false_
match known_type:
.all:
return CssMatchResult.true_
.print_:
# FIXME: Enable for printing, when we have printing!
return CssMatchResult.false_
.screen:
# FIXME: Disable for printing, when we have printing!
return CssMatchResult.true_
_:
trap("VERIFY_NOT_REACHED")
## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:275 Web::CSS::MediaQuery::evaluate.
pub func css_media_query_evaluate(this: CssMediaQuery*, document: DomDocument*) -> bool:
var result = css_media_query_matches_media(&this.m_media_type)
if result != CssMatchResult.false_:
if let media_condition = this.m_media_condition:
result = css_and(result, css_boolean_expression_evaluate(media_condition, document))
if this.m_negated:
result = css_negate(result)
this.m_matches = result == CssMatchResult.true_
return this.m_matches
## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:305 Web::CSS::MediaQuery::dump.
pub func css_media_query_dump(this: const CssMediaQuery*, builder: ak.StringBuilder*, indent_levels: i32 = 0):
dump_indent(builder, indent_levels)
dump_appendff(builder, "Media condition: (matches = {})\n", [ak.arg_bool(this.m_matches)])
dump_indent(builder, indent_levels + 1)
dump_appendff(builder, "Negated: {}\n", [ak.arg_bool(this.m_negated)])
dump_indent(builder, indent_levels + 1)
dump_appendff(builder, "Type: {}\n", [dump_arg_fly_string(&this.m_media_type.name)])
if let media_condition = this.m_media_condition:
dump_indent(builder, indent_levels + 1)
ak.string_builder_append(builder, "Condition:\n")
css_boolean_expression_dump(media_condition, builder, indent_levels + 2)
# mark: Media query lists and media types =======================================================
## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:324 Web::CSS::serialize_a_media_query_list.
# https://www.w3.org/TR/cssom-1/#serialize-a-media-query-list
pub func css_serialize_a_media_query_list(media_queries: ak.Vector[CssMediaQuery*]) -> ak.String:
# 1. If the media query list is empty, then return the empty string.
if ak.vector_is_empty(&media_queries):
return ak.string_new()
# 2. Serialize each media query in the list of media queries, in the same order as they
# appear in the media query list, and then serialize the list.
var builder = ak.string_builder_new()
var first = true
for media_query in ak.vector_span_const(&media_queries):
if not first:
ak.string_builder_append(&builder, ", ")
first = false
let serialized = css_media_query_to_string(media_query)
ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&serialized))
return ak.string_builder_to_string(&builder) else trap("MUST: String::join")
## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:335 Web::CSS::media_type_from_string.
pub func css_media_type_from_string(name: ak.StringView) -> CssMediaQueryKnownMediaType?:
if ak.string_view_equals_ignoring_ascii_case(&name, ak.sv("all")):
return CssMediaQueryKnownMediaType.all
if ak.string_view_equals_ignoring_ascii_case(&name, ak.sv("print")):
return CssMediaQueryKnownMediaType.print_
if ak.string_view_equals_ignoring_ascii_case(&name, ak.sv("screen")):
return CssMediaQueryKnownMediaType.screen
return none
## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:346 Web::CSS::to_string.
pub func css_to_string_css_media_query_known_media_ty(media_type: CssMediaQueryKnownMediaType) -> ak.StringView:
match media_type:
.all: return ak.sv("all")
.print_: return ak.sv("print")
.screen: return ak.sv("screen")
_: trap("VERIFY_NOT_REACHED")