CSSMathValue.h 34 KB

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