CalculatedStyleValue.h 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
  4. * Copyright (c) 2021-2023, Sam Atkins <atkinssj@serenityos.org>
  5. * Copyright (c) 2022-2023, MacDue <macdue@dueutil.tech>
  6. *
  7. * SPDX-License-Identifier: BSD-2-Clause
  8. */
  9. #pragma once
  10. #include <AK/Function.h>
  11. #include <LibWeb/CSS/Angle.h>
  12. #include <LibWeb/CSS/CSSNumericType.h>
  13. #include <LibWeb/CSS/CSSStyleValue.h>
  14. #include <LibWeb/CSS/Flex.h>
  15. #include <LibWeb/CSS/Frequency.h>
  16. #include <LibWeb/CSS/Length.h>
  17. #include <LibWeb/CSS/Percentage.h>
  18. #include <LibWeb/CSS/Resolution.h>
  19. #include <LibWeb/CSS/Time.h>
  20. namespace Web::CSS {
  21. class CalculationNode;
  22. class CalculatedStyleValue : public CSSStyleValue {
  23. public:
  24. enum class ResolvedType {
  25. Angle,
  26. Flex,
  27. Frequency,
  28. Integer,
  29. Length,
  30. Number,
  31. Percentage,
  32. Resolution,
  33. Time,
  34. };
  35. enum class SumOperation {
  36. Add,
  37. Subtract,
  38. };
  39. enum class ProductOperation {
  40. Multiply,
  41. Divide,
  42. };
  43. using PercentageBasis = Variant<Empty, Angle, Flex, Frequency, Length, Time>;
  44. class CalculationResult {
  45. public:
  46. using Value = Variant<Number, Angle, Flex, Frequency, Length, Percentage, Resolution, Time>;
  47. CalculationResult(Value value)
  48. : m_value(move(value))
  49. {
  50. }
  51. void add(CalculationResult const& other, Optional<Length::ResolutionContext const&>, PercentageBasis const& percentage_basis);
  52. void subtract(CalculationResult const& other, Optional<Length::ResolutionContext const&>, PercentageBasis const& percentage_basis);
  53. void multiply_by(CalculationResult const& other, Optional<Length::ResolutionContext const&>);
  54. void divide_by(CalculationResult const& other, Optional<Length::ResolutionContext const&>);
  55. void negate();
  56. void invert();
  57. Value const& value() const { return m_value; }
  58. [[nodiscard]] bool operator==(CalculationResult const&) const = default;
  59. private:
  60. void add_or_subtract_internal(SumOperation op, CalculationResult const& other, Optional<Length::ResolutionContext const&>, PercentageBasis const& percentage_basis);
  61. Value m_value;
  62. };
  63. static ValueComparingNonnullRefPtr<CalculatedStyleValue> create(NonnullOwnPtr<CalculationNode> calculation, CSSNumericType resolved_type)
  64. {
  65. return adopt_ref(*new (nothrow) CalculatedStyleValue(move(calculation), resolved_type));
  66. }
  67. String to_string() const override;
  68. virtual bool equals(CSSStyleValue const& other) const override;
  69. bool resolves_to_angle() const { return m_resolved_type.matches_angle(); }
  70. bool resolves_to_angle_percentage() const { return m_resolved_type.matches_angle_percentage(); }
  71. Optional<Angle> resolve_angle() const;
  72. Optional<Angle> resolve_angle_percentage(Angle const& percentage_basis) const;
  73. bool resolves_to_flex() const { return m_resolved_type.matches_flex(); }
  74. Optional<Flex> resolve_flex() const;
  75. bool resolves_to_frequency() const { return m_resolved_type.matches_frequency(); }
  76. bool resolves_to_frequency_percentage() const { return m_resolved_type.matches_frequency_percentage(); }
  77. Optional<Frequency> resolve_frequency() const;
  78. Optional<Frequency> resolve_frequency_percentage(Frequency const& percentage_basis) const;
  79. bool resolves_to_length() const { return m_resolved_type.matches_length(); }
  80. bool resolves_to_length_percentage() const { return m_resolved_type.matches_length_percentage(); }
  81. [[nodiscard]] Optional<Length> resolve_length(Length::ResolutionContext const&) const;
  82. Optional<Length> resolve_length(Layout::Node const& layout_node) const;
  83. Optional<Length> resolve_length_percentage(Layout::Node const&, Length const& percentage_basis) const;
  84. Optional<Length> resolve_length_percentage(Layout::Node const&, CSSPixels percentage_basis) const;
  85. Optional<Length> resolve_length_percentage(Length::ResolutionContext const&, Length const& percentage_basis) const;
  86. bool resolves_to_percentage() const { return m_resolved_type.matches_percentage(); }
  87. Optional<Percentage> resolve_percentage() const;
  88. bool resolves_to_resolution() const { return m_resolved_type.matches_resolution(); }
  89. Optional<Resolution> resolve_resolution() const;
  90. bool resolves_to_time() const { return m_resolved_type.matches_time(); }
  91. bool resolves_to_time_percentage() const { return m_resolved_type.matches_time_percentage(); }
  92. Optional<Time> resolve_time() const;
  93. Optional<Time> resolve_time_percentage(Time const& percentage_basis) const;
  94. bool resolves_to_number() const { return m_resolved_type.matches_number(); }
  95. bool resolves_to_number_percentage() const { return m_resolved_type.matches_number_percentage(); }
  96. Optional<double> resolve_number() const;
  97. Optional<i64> resolve_integer() const;
  98. bool resolves_to_dimension() const { return m_resolved_type.matches_dimension(); }
  99. bool contains_percentage() const;
  100. String dump() const;
  101. private:
  102. explicit CalculatedStyleValue(NonnullOwnPtr<CalculationNode> calculation, CSSNumericType resolved_type)
  103. : CSSStyleValue(Type::Calculated)
  104. , m_resolved_type(resolved_type)
  105. , m_calculation(move(calculation))
  106. {
  107. }
  108. CSSNumericType m_resolved_type;
  109. NonnullOwnPtr<CalculationNode> m_calculation;
  110. };
  111. // https://www.w3.org/TR/css-values-4/#calculation-tree
  112. class CalculationNode {
  113. public:
  114. // https://drafts.csswg.org/css-values-4/#calc-constants
  115. // https://drafts.csswg.org/css-values-4/#calc-error-constants
  116. enum class ConstantType {
  117. E,
  118. Pi,
  119. NaN,
  120. Infinity,
  121. MinusInfinity,
  122. };
  123. static Optional<ConstantType> constant_type_from_string(StringView);
  124. enum class Type {
  125. Numeric,
  126. // NOTE: Currently, any value with a `var()` or `attr()` function in it is always an
  127. // UnresolvedStyleValue so we do not have to implement a NonMathFunction type here.
  128. // Comparison function nodes, a sub-type of operator node
  129. // https://drafts.csswg.org/css-values-4/#comp-func
  130. Min,
  131. Max,
  132. Clamp,
  133. // Calc-operator nodes, a sub-type of operator node
  134. // https://www.w3.org/TR/css-values-4/#calculation-tree-calc-operator-nodes
  135. Sum,
  136. Product,
  137. Negate,
  138. Invert,
  139. // Sign-Related Functions, a sub-type of operator node
  140. // https://drafts.csswg.org/css-values-4/#sign-funcs
  141. Abs,
  142. Sign,
  143. // Constant Nodes
  144. // https://drafts.csswg.org/css-values-4/#calc-constants
  145. Constant,
  146. // Trigonometric functions, a sub-type of operator node
  147. // https://drafts.csswg.org/css-values-4/#trig-funcs
  148. Sin,
  149. Cos,
  150. Tan,
  151. Asin,
  152. Acos,
  153. Atan,
  154. Atan2,
  155. // Exponential functions, a sub-type of operator node
  156. // https://drafts.csswg.org/css-values-4/#exponent-funcs
  157. Pow,
  158. Sqrt,
  159. Hypot,
  160. Log,
  161. Exp,
  162. // Stepped value functions, a sub-type of operator node
  163. // https://drafts.csswg.org/css-values-4/#round-func
  164. Round,
  165. Mod,
  166. Rem,
  167. // This only exists during parsing.
  168. Unparsed,
  169. };
  170. using NumericValue = CalculatedStyleValue::CalculationResult::Value;
  171. virtual ~CalculationNode();
  172. Type type() const { return m_type; }
  173. // https://www.w3.org/TR/css-values-4/#calculation-tree-operator-nodes
  174. bool is_operator_node() const
  175. {
  176. return is_calc_operator_node() || is_math_function_node();
  177. }
  178. bool is_math_function_node() const
  179. {
  180. switch (m_type) {
  181. case Type::Min:
  182. case Type::Max:
  183. case Type::Clamp:
  184. case Type::Abs:
  185. case Type::Sign:
  186. case Type::Sin:
  187. case Type::Cos:
  188. case Type::Tan:
  189. case Type::Asin:
  190. case Type::Acos:
  191. case Type::Atan:
  192. case Type::Atan2:
  193. case Type::Pow:
  194. case Type::Sqrt:
  195. case Type::Hypot:
  196. case Type::Log:
  197. case Type::Exp:
  198. case Type::Round:
  199. case Type::Mod:
  200. case Type::Rem:
  201. return true;
  202. default:
  203. return false;
  204. }
  205. }
  206. // https://www.w3.org/TR/css-values-4/#calculation-tree-calc-operator-nodes
  207. bool is_calc_operator_node() const
  208. {
  209. return first_is_one_of(m_type, Type::Sum, Type::Product, Type::Negate, Type::Invert);
  210. }
  211. virtual String to_string() const = 0;
  212. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const = 0;
  213. virtual Optional<CSSNumericType> determine_type(PropertyID) const = 0;
  214. virtual bool contains_percentage() const = 0;
  215. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const = 0;
  216. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) = 0;
  217. virtual void dump(StringBuilder&, int indent) const = 0;
  218. virtual bool equals(CalculationNode const&) const = 0;
  219. protected:
  220. explicit CalculationNode(Type);
  221. private:
  222. Type m_type;
  223. };
  224. class NumericCalculationNode final : public CalculationNode {
  225. public:
  226. static NonnullOwnPtr<NumericCalculationNode> create(NumericValue);
  227. ~NumericCalculationNode();
  228. virtual String to_string() const override;
  229. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  230. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  231. virtual bool contains_percentage() const override;
  232. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  233. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override { }
  234. virtual void dump(StringBuilder&, int indent) const override;
  235. virtual bool equals(CalculationNode const&) const override;
  236. private:
  237. explicit NumericCalculationNode(NumericValue);
  238. NumericValue m_value;
  239. };
  240. class SumCalculationNode final : public CalculationNode {
  241. public:
  242. static NonnullOwnPtr<SumCalculationNode> create(Vector<NonnullOwnPtr<CalculationNode>>);
  243. ~SumCalculationNode();
  244. virtual String to_string() const override;
  245. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  246. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  247. virtual bool contains_percentage() const override;
  248. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  249. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  250. virtual void dump(StringBuilder&, int indent) const override;
  251. virtual bool equals(CalculationNode const&) const override;
  252. private:
  253. explicit SumCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
  254. Vector<NonnullOwnPtr<CalculationNode>> m_values;
  255. };
  256. class ProductCalculationNode final : public CalculationNode {
  257. public:
  258. static NonnullOwnPtr<ProductCalculationNode> create(Vector<NonnullOwnPtr<CalculationNode>>);
  259. ~ProductCalculationNode();
  260. virtual String to_string() const override;
  261. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  262. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  263. virtual bool contains_percentage() const override;
  264. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  265. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  266. virtual void dump(StringBuilder&, int indent) const override;
  267. virtual bool equals(CalculationNode const&) const override;
  268. private:
  269. explicit ProductCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
  270. Vector<NonnullOwnPtr<CalculationNode>> m_values;
  271. };
  272. class NegateCalculationNode final : public CalculationNode {
  273. public:
  274. static NonnullOwnPtr<NegateCalculationNode> create(NonnullOwnPtr<CalculationNode>);
  275. ~NegateCalculationNode();
  276. virtual String to_string() const override;
  277. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  278. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  279. virtual bool contains_percentage() const override;
  280. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  281. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  282. virtual void dump(StringBuilder&, int indent) const override;
  283. virtual bool equals(CalculationNode const&) const override;
  284. private:
  285. explicit NegateCalculationNode(NonnullOwnPtr<CalculationNode>);
  286. NonnullOwnPtr<CalculationNode> m_value;
  287. };
  288. class InvertCalculationNode final : public CalculationNode {
  289. public:
  290. static NonnullOwnPtr<InvertCalculationNode> create(NonnullOwnPtr<CalculationNode>);
  291. ~InvertCalculationNode();
  292. virtual String to_string() const override;
  293. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  294. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  295. virtual bool contains_percentage() const override;
  296. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  297. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  298. virtual void dump(StringBuilder&, int indent) const override;
  299. virtual bool equals(CalculationNode const&) const override;
  300. private:
  301. explicit InvertCalculationNode(NonnullOwnPtr<CalculationNode>);
  302. NonnullOwnPtr<CalculationNode> m_value;
  303. };
  304. class MinCalculationNode final : public CalculationNode {
  305. public:
  306. static NonnullOwnPtr<MinCalculationNode> create(Vector<NonnullOwnPtr<CalculationNode>>);
  307. ~MinCalculationNode();
  308. virtual String to_string() const override;
  309. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  310. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  311. virtual bool contains_percentage() const override;
  312. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  313. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  314. virtual void dump(StringBuilder&, int indent) const override;
  315. virtual bool equals(CalculationNode const&) const override;
  316. private:
  317. explicit MinCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
  318. Vector<NonnullOwnPtr<CalculationNode>> m_values;
  319. };
  320. class MaxCalculationNode final : public CalculationNode {
  321. public:
  322. static NonnullOwnPtr<MaxCalculationNode> create(Vector<NonnullOwnPtr<CalculationNode>>);
  323. ~MaxCalculationNode();
  324. virtual String to_string() const override;
  325. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  326. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  327. virtual bool contains_percentage() const override;
  328. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  329. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  330. virtual void dump(StringBuilder&, int indent) const override;
  331. virtual bool equals(CalculationNode const&) const override;
  332. private:
  333. explicit MaxCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
  334. Vector<NonnullOwnPtr<CalculationNode>> m_values;
  335. };
  336. class ClampCalculationNode final : public CalculationNode {
  337. public:
  338. static NonnullOwnPtr<ClampCalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  339. ~ClampCalculationNode();
  340. virtual String to_string() const override;
  341. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  342. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  343. virtual bool contains_percentage() const override;
  344. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  345. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  346. virtual void dump(StringBuilder&, int indent) const override;
  347. virtual bool equals(CalculationNode const&) const override;
  348. private:
  349. explicit ClampCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  350. NonnullOwnPtr<CalculationNode> m_min_value;
  351. NonnullOwnPtr<CalculationNode> m_center_value;
  352. NonnullOwnPtr<CalculationNode> m_max_value;
  353. };
  354. class AbsCalculationNode final : public CalculationNode {
  355. public:
  356. static NonnullOwnPtr<AbsCalculationNode> create(NonnullOwnPtr<CalculationNode>);
  357. ~AbsCalculationNode();
  358. virtual String to_string() const override;
  359. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  360. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  361. virtual bool contains_percentage() const override;
  362. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  363. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  364. virtual void dump(StringBuilder&, int indent) const override;
  365. virtual bool equals(CalculationNode const&) const override;
  366. private:
  367. AbsCalculationNode(NonnullOwnPtr<CalculationNode>);
  368. NonnullOwnPtr<CalculationNode> m_value;
  369. };
  370. class SignCalculationNode final : public CalculationNode {
  371. public:
  372. static NonnullOwnPtr<SignCalculationNode> create(NonnullOwnPtr<CalculationNode>);
  373. ~SignCalculationNode();
  374. virtual String to_string() const override;
  375. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  376. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  377. virtual bool contains_percentage() const override;
  378. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  379. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  380. virtual void dump(StringBuilder&, int indent) const override;
  381. virtual bool equals(CalculationNode const&) const override;
  382. private:
  383. SignCalculationNode(NonnullOwnPtr<CalculationNode>);
  384. NonnullOwnPtr<CalculationNode> m_value;
  385. };
  386. class ConstantCalculationNode final : public CalculationNode {
  387. public:
  388. static NonnullOwnPtr<ConstantCalculationNode> create(CalculationNode::ConstantType);
  389. ~ConstantCalculationNode();
  390. virtual String to_string() const override;
  391. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  392. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  393. virtual bool contains_percentage() const override { return false; }
  394. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const&) const override;
  395. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override { }
  396. virtual void dump(StringBuilder&, int indent) const override;
  397. virtual bool equals(CalculationNode const&) const override;
  398. private:
  399. ConstantCalculationNode(ConstantType);
  400. CalculationNode::ConstantType m_constant;
  401. };
  402. class SinCalculationNode final : public CalculationNode {
  403. public:
  404. static NonnullOwnPtr<SinCalculationNode> create(NonnullOwnPtr<CalculationNode>);
  405. ~SinCalculationNode();
  406. virtual String to_string() const override;
  407. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  408. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  409. virtual bool contains_percentage() const override;
  410. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  411. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  412. virtual void dump(StringBuilder&, int indent) const override;
  413. virtual bool equals(CalculationNode const&) const override;
  414. private:
  415. SinCalculationNode(NonnullOwnPtr<CalculationNode>);
  416. NonnullOwnPtr<CalculationNode> m_value;
  417. };
  418. class CosCalculationNode final : public CalculationNode {
  419. public:
  420. static NonnullOwnPtr<CosCalculationNode> create(NonnullOwnPtr<CalculationNode>);
  421. ~CosCalculationNode();
  422. virtual String to_string() const override;
  423. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  424. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  425. virtual bool contains_percentage() const override;
  426. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  427. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  428. virtual void dump(StringBuilder&, int indent) const override;
  429. virtual bool equals(CalculationNode const&) const override;
  430. private:
  431. CosCalculationNode(NonnullOwnPtr<CalculationNode>);
  432. NonnullOwnPtr<CalculationNode> m_value;
  433. };
  434. class TanCalculationNode final : public CalculationNode {
  435. public:
  436. static NonnullOwnPtr<TanCalculationNode> create(NonnullOwnPtr<CalculationNode>);
  437. ~TanCalculationNode();
  438. virtual String to_string() const override;
  439. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  440. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  441. virtual bool contains_percentage() const override;
  442. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  443. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  444. virtual void dump(StringBuilder&, int indent) const override;
  445. virtual bool equals(CalculationNode const&) const override;
  446. private:
  447. TanCalculationNode(NonnullOwnPtr<CalculationNode>);
  448. NonnullOwnPtr<CalculationNode> m_value;
  449. };
  450. class AsinCalculationNode final : public CalculationNode {
  451. public:
  452. static NonnullOwnPtr<AsinCalculationNode> create(NonnullOwnPtr<CalculationNode>);
  453. ~AsinCalculationNode();
  454. virtual String to_string() const override;
  455. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  456. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  457. virtual bool contains_percentage() const override;
  458. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  459. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  460. virtual void dump(StringBuilder&, int indent) const override;
  461. virtual bool equals(CalculationNode const&) const override;
  462. private:
  463. AsinCalculationNode(NonnullOwnPtr<CalculationNode>);
  464. NonnullOwnPtr<CalculationNode> m_value;
  465. };
  466. class AcosCalculationNode final : public CalculationNode {
  467. public:
  468. static NonnullOwnPtr<AcosCalculationNode> create(NonnullOwnPtr<CalculationNode>);
  469. ~AcosCalculationNode();
  470. virtual String to_string() const override;
  471. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  472. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  473. virtual bool contains_percentage() const override;
  474. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  475. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  476. virtual void dump(StringBuilder&, int indent) const override;
  477. virtual bool equals(CalculationNode const&) const override;
  478. private:
  479. AcosCalculationNode(NonnullOwnPtr<CalculationNode>);
  480. NonnullOwnPtr<CalculationNode> m_value;
  481. };
  482. class AtanCalculationNode final : public CalculationNode {
  483. public:
  484. static NonnullOwnPtr<AtanCalculationNode> create(NonnullOwnPtr<CalculationNode>);
  485. ~AtanCalculationNode();
  486. virtual String to_string() const override;
  487. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  488. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  489. virtual bool contains_percentage() const override;
  490. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  491. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  492. virtual void dump(StringBuilder&, int indent) const override;
  493. virtual bool equals(CalculationNode const&) const override;
  494. private:
  495. AtanCalculationNode(NonnullOwnPtr<CalculationNode>);
  496. NonnullOwnPtr<CalculationNode> m_value;
  497. };
  498. class Atan2CalculationNode final : public CalculationNode {
  499. public:
  500. static NonnullOwnPtr<Atan2CalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  501. ~Atan2CalculationNode();
  502. virtual String to_string() const override;
  503. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  504. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  505. virtual bool contains_percentage() const override;
  506. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  507. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  508. virtual void dump(StringBuilder&, int indent) const override;
  509. virtual bool equals(CalculationNode const&) const override;
  510. private:
  511. Atan2CalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  512. NonnullOwnPtr<CalculationNode> m_y;
  513. NonnullOwnPtr<CalculationNode> m_x;
  514. };
  515. class PowCalculationNode final : public CalculationNode {
  516. public:
  517. static NonnullOwnPtr<PowCalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  518. ~PowCalculationNode();
  519. virtual String to_string() const override;
  520. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  521. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  522. virtual bool contains_percentage() const override { return false; }
  523. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  524. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  525. virtual void dump(StringBuilder&, int indent) const override;
  526. virtual bool equals(CalculationNode const&) const override;
  527. private:
  528. explicit PowCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  529. NonnullOwnPtr<CalculationNode> m_x;
  530. NonnullOwnPtr<CalculationNode> m_y;
  531. };
  532. class SqrtCalculationNode final : public CalculationNode {
  533. public:
  534. static NonnullOwnPtr<SqrtCalculationNode> create(NonnullOwnPtr<CalculationNode>);
  535. ~SqrtCalculationNode();
  536. virtual String to_string() const override;
  537. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  538. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  539. virtual bool contains_percentage() const override { return false; }
  540. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  541. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  542. virtual void dump(StringBuilder&, int indent) const override;
  543. virtual bool equals(CalculationNode const&) const override;
  544. private:
  545. SqrtCalculationNode(NonnullOwnPtr<CalculationNode>);
  546. NonnullOwnPtr<CalculationNode> m_value;
  547. };
  548. class HypotCalculationNode final : public CalculationNode {
  549. public:
  550. static NonnullOwnPtr<HypotCalculationNode> create(Vector<NonnullOwnPtr<CalculationNode>>);
  551. ~HypotCalculationNode();
  552. virtual String to_string() const override;
  553. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  554. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  555. virtual bool contains_percentage() const override;
  556. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  557. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  558. virtual void dump(StringBuilder&, int indent) const override;
  559. virtual bool equals(CalculationNode const&) const override;
  560. private:
  561. explicit HypotCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
  562. Vector<NonnullOwnPtr<CalculationNode>> m_values;
  563. };
  564. class LogCalculationNode final : public CalculationNode {
  565. public:
  566. static NonnullOwnPtr<LogCalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  567. ~LogCalculationNode();
  568. virtual String to_string() const override;
  569. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  570. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  571. virtual bool contains_percentage() const override { return false; }
  572. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  573. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  574. virtual void dump(StringBuilder&, int indent) const override;
  575. virtual bool equals(CalculationNode const&) const override;
  576. private:
  577. LogCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  578. NonnullOwnPtr<CalculationNode> m_x;
  579. NonnullOwnPtr<CalculationNode> m_y;
  580. };
  581. class ExpCalculationNode final : public CalculationNode {
  582. public:
  583. static NonnullOwnPtr<ExpCalculationNode> create(NonnullOwnPtr<CalculationNode>);
  584. ~ExpCalculationNode();
  585. virtual String to_string() const override;
  586. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  587. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  588. virtual bool contains_percentage() const override { return false; }
  589. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  590. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  591. virtual void dump(StringBuilder&, int indent) const override;
  592. virtual bool equals(CalculationNode const&) const override;
  593. private:
  594. ExpCalculationNode(NonnullOwnPtr<CalculationNode>);
  595. NonnullOwnPtr<CalculationNode> m_value;
  596. };
  597. class RoundCalculationNode final : public CalculationNode {
  598. public:
  599. static NonnullOwnPtr<RoundCalculationNode> create(RoundingStrategy, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  600. ~RoundCalculationNode();
  601. virtual String to_string() const override;
  602. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  603. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  604. virtual bool contains_percentage() const override;
  605. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  606. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  607. virtual void dump(StringBuilder&, int indent) const override;
  608. virtual bool equals(CalculationNode const&) const override;
  609. private:
  610. RoundCalculationNode(RoundingStrategy, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  611. RoundingStrategy m_strategy;
  612. NonnullOwnPtr<CalculationNode> m_x;
  613. NonnullOwnPtr<CalculationNode> m_y;
  614. };
  615. class ModCalculationNode final : public CalculationNode {
  616. public:
  617. static NonnullOwnPtr<ModCalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  618. ~ModCalculationNode();
  619. virtual String to_string() const override;
  620. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  621. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  622. virtual bool contains_percentage() const override;
  623. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  624. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  625. virtual void dump(StringBuilder&, int indent) const override;
  626. virtual bool equals(CalculationNode const&) const override;
  627. private:
  628. ModCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  629. NonnullOwnPtr<CalculationNode> m_x;
  630. NonnullOwnPtr<CalculationNode> m_y;
  631. };
  632. class RemCalculationNode final : public CalculationNode {
  633. public:
  634. static NonnullOwnPtr<RemCalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  635. ~RemCalculationNode();
  636. virtual String to_string() const override;
  637. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  638. virtual Optional<CSSNumericType> determine_type(PropertyID) const override;
  639. virtual bool contains_percentage() const override;
  640. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  641. virtual void for_each_child_node(Function<void(NonnullOwnPtr<CalculationNode>&)> const&) override;
  642. virtual void dump(StringBuilder&, int indent) const override;
  643. virtual bool equals(CalculationNode const&) const override;
  644. private:
  645. RemCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  646. NonnullOwnPtr<CalculationNode> m_x;
  647. NonnullOwnPtr<CalculationNode> m_y;
  648. };
  649. }