1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/NonnullOwnPtr.h>
#include <AK/Variant.h>
#include <LibGfx/Font.h>
#include <LibGfx/Rect.h>
#include <LibWeb/CSS/Length.h>
#include <LibWeb/DOM/Document.h>
#include <LibWeb/HTML/HTMLHtmlElement.h>
#include <LibWeb/Page/BrowsingContext.h>
namespace Web::CSS {
float Length::relative_length_to_px(Gfx::IntRect const& viewport_rect, Gfx::FontMetrics const& font_metrics, float root_font_size) const
{
switch (m_type) {
case Type::Ex:
return m_value * font_metrics.x_height;
case Type::Em:
return m_value * font_metrics.size;
case Type::Ch:
// FIXME: Use layout_node.font().glyph_height() when writing-mode is not horizontal-tb (it has to be implemented first)
return m_value * (font_metrics.glyph_width + font_metrics.glyph_spacing);
case Type::Rem:
return m_value * root_font_size;
case Type::Vw:
return viewport_rect.width() * (m_value / 100);
case Type::Vh:
return viewport_rect.height() * (m_value / 100);
case Type::Vmin:
return min(viewport_rect.width(), viewport_rect.height()) * (m_value / 100);
case Type::Vmax:
return max(viewport_rect.width(), viewport_rect.height()) * (m_value / 100);
default:
VERIFY_NOT_REACHED();
}
}
float Length::to_px(Layout::Node const& layout_node) const
{
if (!layout_node.document().browsing_context())
return 0;
auto viewport_rect = layout_node.document().browsing_context()->viewport_rect();
auto* root_element = layout_node.document().document_element();
if (!root_element || !root_element->layout_node())
return 0;
return to_px(viewport_rect, layout_node.font().metrics('M'), root_element->layout_node()->font().presentation_size());
}
float Length::relative_length_to_px(Layout::Node const& layout_node) const
{
auto viewport_rect = layout_node.document().browsing_context()->viewport_rect();
auto root_element = layout_node.document().document_element();
return relative_length_to_px(viewport_rect, layout_node.font().metrics('M'), root_element->layout_node()->font().presentation_size());
}
static float resolve_calc_value(CalculatedStyleValue::CalcValue const&, const Layout::Node& layout_node, float reference_for_percent);
static float resolve_calc_number_value(CalculatedStyleValue::CalcNumberValue const&);
static float resolve_calc_product(NonnullOwnPtr<CalculatedStyleValue::CalcProduct> const&, const Layout::Node& layout_node, float reference_for_percent);
static float resolve_calc_sum(NonnullOwnPtr<CalculatedStyleValue::CalcSum> const&, const Layout::Node& layout_node, float reference_for_percent);
static float resolve_calc_number_sum(NonnullOwnPtr<CalculatedStyleValue::CalcNumberSum> const&);
static float resolve_calc_number_product(NonnullOwnPtr<CalculatedStyleValue::CalcNumberProduct> const&);
float Length::resolve_calculated_value(const Layout::Node& layout_node, float reference_for_percent) const
{
if (!m_calculated_style)
return 0.0f;
auto& expression = m_calculated_style->expression();
auto length = resolve_calc_sum(expression, layout_node, reference_for_percent);
return length;
};
static float resolve_calc_value(CalculatedStyleValue::CalcValue const& calc_value, const Layout::Node& layout_node, float reference_for_percent)
{
return calc_value.visit(
[](float value) { return value; },
[&](Length length) {
return length.resolved_or_zero(layout_node, reference_for_percent).to_px(layout_node);
},
[&](NonnullOwnPtr<CalculatedStyleValue::CalcSum>& calc_sum) {
return resolve_calc_sum(calc_sum, layout_node, reference_for_percent);
},
[](auto&) {
VERIFY_NOT_REACHED();
return 0.0f;
});
}
static float resolve_calc_number_product(NonnullOwnPtr<CalculatedStyleValue::CalcNumberProduct> const& calc_number_product)
{
auto value = resolve_calc_number_value(calc_number_product->first_calc_number_value);
for (auto& additional_number_value : calc_number_product->zero_or_more_additional_calc_number_values) {
auto additional_value = resolve_calc_number_value(additional_number_value.value);
if (additional_number_value.op == CalculatedStyleValue::CalcNumberProductPartWithOperator::Multiply)
value *= additional_value;
else if (additional_number_value.op == CalculatedStyleValue::CalcNumberProductPartWithOperator::Divide)
value /= additional_value;
else
VERIFY_NOT_REACHED();
}
return value;
}
static float resolve_calc_number_sum(NonnullOwnPtr<CalculatedStyleValue::CalcNumberSum> const& calc_number_sum)
{
auto value = resolve_calc_number_product(calc_number_sum->first_calc_number_product);
for (auto& additional_product : calc_number_sum->zero_or_more_additional_calc_number_products) {
auto additional_value = resolve_calc_number_product(additional_product.calc_number_product);
if (additional_product.op == CSS::CalculatedStyleValue::CalcNumberSumPartWithOperator::Add)
value += additional_value;
else if (additional_product.op == CSS::CalculatedStyleValue::CalcNumberSumPartWithOperator::Subtract)
value -= additional_value;
else
VERIFY_NOT_REACHED();
}
return value;
}
static float resolve_calc_number_value(CalculatedStyleValue::CalcNumberValue const& number_value)
{
return number_value.visit(
[](float number) { return number; },
[](NonnullOwnPtr<CalculatedStyleValue::CalcNumberSum>& calc_number_sum) {
return resolve_calc_number_sum(calc_number_sum);
});
}
static float resolve_calc_product(NonnullOwnPtr<CalculatedStyleValue::CalcProduct> const& calc_product, const Layout::Node& layout_node, float reference_for_percent)
{
auto value = resolve_calc_value(calc_product->first_calc_value, layout_node, reference_for_percent);
for (auto& additional_value : calc_product->zero_or_more_additional_calc_values) {
additional_value.value.visit(
[&](CalculatedStyleValue::CalcValue const& calc_value) {
if (additional_value.op != CalculatedStyleValue::CalcProductPartWithOperator::Multiply)
VERIFY_NOT_REACHED();
auto resolved_value = resolve_calc_value(calc_value, layout_node, reference_for_percent);
value *= resolved_value;
},
[&](CalculatedStyleValue::CalcNumberValue const& calc_number_value) {
if (additional_value.op != CalculatedStyleValue::CalcProductPartWithOperator::Divide)
VERIFY_NOT_REACHED();
auto resolved_calc_number_value = resolve_calc_number_value(calc_number_value);
value /= resolved_calc_number_value;
});
}
return value;
}
static float resolve_calc_sum(NonnullOwnPtr<CalculatedStyleValue::CalcSum> const& calc_sum, const Layout::Node& layout_node, float reference_for_percent)
{
auto value = resolve_calc_product(calc_sum->first_calc_product, layout_node, reference_for_percent);
for (auto& additional_product : calc_sum->zero_or_more_additional_calc_products) {
auto additional_value = resolve_calc_product(additional_product.calc_product, layout_node, reference_for_percent);
if (additional_product.op == CalculatedStyleValue::CalcSumPartWithOperator::Operation::Add)
value += additional_value;
else if (additional_product.op == CalculatedStyleValue::CalcSumPartWithOperator::Operation::Subtract)
value -= additional_value;
else
VERIFY_NOT_REACHED();
}
return value;
}
const char* Length::unit_name() const
{
switch (m_type) {
case Type::Cm:
return "cm";
case Type::In:
return "in";
case Type::Px:
return "px";
case Type::Pt:
return "pt";
case Type::Mm:
return "mm";
case Type::Q:
return "Q";
case Type::Pc:
return "pc";
case Type::Ex:
return "ex";
case Type::Em:
return "em";
case Type::Ch:
return "ch";
case Type::Rem:
return "rem";
case Type::Auto:
return "auto";
case Type::Percentage:
return "%";
case Type::Undefined:
return "undefined";
case Type::Vh:
return "vh";
case Type::Vw:
return "vw";
case Type::Vmax:
return "vmax";
case Type::Vmin:
return "vmin";
case Type::Calculated:
return "calculated";
}
VERIFY_NOT_REACHED();
}
}
|
