CalculatedStyleValue.h 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608
  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 <LibWeb/CSS/Angle.h>
  11. #include <LibWeb/CSS/Frequency.h>
  12. #include <LibWeb/CSS/Length.h>
  13. #include <LibWeb/CSS/Percentage.h>
  14. #include <LibWeb/CSS/StyleValue.h>
  15. #include <LibWeb/CSS/Time.h>
  16. namespace Web::CSS {
  17. class CalculationNode;
  18. class CalculatedStyleValue : public StyleValue {
  19. public:
  20. enum class ResolvedType {
  21. Angle,
  22. Frequency,
  23. Integer,
  24. Length,
  25. Number,
  26. Percentage,
  27. Time,
  28. };
  29. enum class SumOperation {
  30. Add,
  31. Subtract,
  32. };
  33. enum class ProductOperation {
  34. Multiply,
  35. Divide,
  36. };
  37. using PercentageBasis = Variant<Empty, Angle, Frequency, Length, Time>;
  38. class CalculationResult {
  39. public:
  40. using Value = Variant<Number, Angle, Frequency, Length, Percentage, Time>;
  41. CalculationResult(Value value)
  42. : m_value(move(value))
  43. {
  44. }
  45. void add(CalculationResult const& other, Optional<Length::ResolutionContext const&>, PercentageBasis const& percentage_basis);
  46. void subtract(CalculationResult const& other, Optional<Length::ResolutionContext const&>, PercentageBasis const& percentage_basis);
  47. void multiply_by(CalculationResult const& other, Optional<Length::ResolutionContext const&>);
  48. void divide_by(CalculationResult const& other, Optional<Length::ResolutionContext const&>);
  49. void negate();
  50. void invert();
  51. Value const& value() const { return m_value; }
  52. private:
  53. void add_or_subtract_internal(SumOperation op, CalculationResult const& other, Optional<Length::ResolutionContext const&>, PercentageBasis const& percentage_basis);
  54. Value m_value;
  55. };
  56. static ErrorOr<ValueComparingNonnullRefPtr<CalculatedStyleValue>> create(NonnullOwnPtr<CalculationNode> calculation, ResolvedType resolved_type)
  57. {
  58. return adopt_nonnull_ref_or_enomem(new (nothrow) CalculatedStyleValue(move(calculation), resolved_type));
  59. }
  60. ErrorOr<String> to_string() const override;
  61. virtual bool equals(StyleValue const& other) const override;
  62. ResolvedType resolved_type() const { return m_resolved_type; }
  63. bool resolves_to_angle() const { return m_resolved_type == ResolvedType::Angle; }
  64. Optional<Angle> resolve_angle() const;
  65. Optional<Angle> resolve_angle_percentage(Angle const& percentage_basis) const;
  66. bool resolves_to_frequency() const { return m_resolved_type == ResolvedType::Frequency; }
  67. Optional<Frequency> resolve_frequency() const;
  68. Optional<Frequency> resolve_frequency_percentage(Frequency const& percentage_basis) const;
  69. bool resolves_to_length() const { return m_resolved_type == ResolvedType::Length; }
  70. [[nodiscard]] Optional<Length> resolve_length(Length::ResolutionContext const&) const;
  71. Optional<Length> resolve_length(Layout::Node const& layout_node) const;
  72. Optional<Length> resolve_length_percentage(Layout::Node const&, Length const& percentage_basis) const;
  73. bool resolves_to_percentage() const { return m_resolved_type == ResolvedType::Percentage; }
  74. Optional<Percentage> resolve_percentage() const;
  75. bool resolves_to_time() const { return m_resolved_type == ResolvedType::Time; }
  76. Optional<Time> resolve_time() const;
  77. Optional<Time> resolve_time_percentage(Time const& percentage_basis) const;
  78. bool resolves_to_integer() const { return m_resolved_type == ResolvedType::Integer; }
  79. bool resolves_to_number() const { return resolves_to_integer() || m_resolved_type == ResolvedType::Number; }
  80. Optional<double> resolve_number() const;
  81. Optional<i64> resolve_integer();
  82. bool contains_percentage() const;
  83. private:
  84. explicit CalculatedStyleValue(NonnullOwnPtr<CalculationNode> calculation, ResolvedType resolved_type)
  85. : StyleValue(Type::Calculated)
  86. , m_resolved_type(resolved_type)
  87. , m_calculation(move(calculation))
  88. {
  89. }
  90. ResolvedType m_resolved_type;
  91. NonnullOwnPtr<CalculationNode> m_calculation;
  92. };
  93. // https://www.w3.org/TR/css-values-4/#calculation-tree
  94. class CalculationNode {
  95. public:
  96. // https://drafts.csswg.org/css-values-4/#calc-constants
  97. // https://drafts.csswg.org/css-values-4/#calc-error-constants
  98. enum class ConstantType {
  99. E,
  100. PI,
  101. NaN,
  102. Infinity,
  103. MinusInfinity,
  104. };
  105. enum class Type {
  106. Numeric,
  107. // NOTE: Currently, any value with a `var()` or `attr()` function in it is always an
  108. // UnresolvedStyleValue so we do not have to implement a NonMathFunction type here.
  109. // Comparison function nodes, a sub-type of operator node
  110. // https://drafts.csswg.org/css-values-4/#comp-func
  111. Min,
  112. Max,
  113. Clamp,
  114. // Calc-operator nodes, a sub-type of operator node
  115. // https://www.w3.org/TR/css-values-4/#calculation-tree-calc-operator-nodes
  116. Sum,
  117. Product,
  118. Negate,
  119. Invert,
  120. // Sign-Related Functions, a sub-type of operator node
  121. // https://drafts.csswg.org/css-values-4/#sign-funcs
  122. Abs,
  123. Sign,
  124. // Constant Nodes
  125. // https://drafts.csswg.org/css-values-4/#calc-constants
  126. Constant,
  127. // Trigonometric functions, a sub-type of operator node
  128. // https://drafts.csswg.org/css-values-4/#trig-funcs
  129. Sin,
  130. Cos,
  131. Tan,
  132. Asin,
  133. Acos,
  134. Atan,
  135. Atan2,
  136. // Exponential functions, a sub-type of operator node
  137. // https://drafts.csswg.org/css-values-4/#exponent-funcs
  138. Pow,
  139. Sqrt,
  140. Hypot,
  141. Log,
  142. Exp,
  143. // This only exists during parsing.
  144. Unparsed,
  145. };
  146. using NumericValue = CalculatedStyleValue::CalculationResult::Value;
  147. virtual ~CalculationNode();
  148. Type type() const { return m_type; }
  149. bool is_operator_node() const
  150. {
  151. // FIXME: Check for operator node types once they exist
  152. return is_calc_operator_node();
  153. }
  154. bool is_calc_operator_node() const
  155. {
  156. return first_is_one_of(m_type, Type::Sum, Type::Product, Type::Negate, Type::Invert);
  157. }
  158. virtual ErrorOr<String> to_string() const = 0;
  159. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const = 0;
  160. virtual bool contains_percentage() const = 0;
  161. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const = 0;
  162. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) { return {}; }
  163. virtual ErrorOr<void> dump(StringBuilder&, int indent) const = 0;
  164. protected:
  165. explicit CalculationNode(Type);
  166. private:
  167. Type m_type;
  168. };
  169. class NumericCalculationNode final : public CalculationNode {
  170. public:
  171. static ErrorOr<NonnullOwnPtr<NumericCalculationNode>> create(NumericValue);
  172. ~NumericCalculationNode();
  173. virtual ErrorOr<String> to_string() const override;
  174. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  175. virtual bool contains_percentage() const override;
  176. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  177. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  178. private:
  179. explicit NumericCalculationNode(NumericValue);
  180. NumericValue m_value;
  181. };
  182. class SumCalculationNode final : public CalculationNode {
  183. public:
  184. static ErrorOr<NonnullOwnPtr<SumCalculationNode>> create(Vector<NonnullOwnPtr<CalculationNode>>);
  185. ~SumCalculationNode();
  186. virtual ErrorOr<String> to_string() const override;
  187. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  188. virtual bool contains_percentage() const override;
  189. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  190. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  191. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  192. private:
  193. explicit SumCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
  194. Vector<NonnullOwnPtr<CalculationNode>> m_values;
  195. };
  196. class ProductCalculationNode final : public CalculationNode {
  197. public:
  198. static ErrorOr<NonnullOwnPtr<ProductCalculationNode>> create(Vector<NonnullOwnPtr<CalculationNode>>);
  199. ~ProductCalculationNode();
  200. virtual ErrorOr<String> to_string() const override;
  201. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  202. virtual bool contains_percentage() const override;
  203. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  204. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  205. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  206. private:
  207. explicit ProductCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
  208. Vector<NonnullOwnPtr<CalculationNode>> m_values;
  209. };
  210. class NegateCalculationNode final : public CalculationNode {
  211. public:
  212. static ErrorOr<NonnullOwnPtr<NegateCalculationNode>> create(NonnullOwnPtr<CalculationNode>);
  213. ~NegateCalculationNode();
  214. virtual ErrorOr<String> to_string() const override;
  215. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  216. virtual bool contains_percentage() const override;
  217. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  218. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  219. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  220. private:
  221. explicit NegateCalculationNode(NonnullOwnPtr<CalculationNode>);
  222. NonnullOwnPtr<CalculationNode> m_value;
  223. };
  224. class InvertCalculationNode final : public CalculationNode {
  225. public:
  226. static ErrorOr<NonnullOwnPtr<InvertCalculationNode>> create(NonnullOwnPtr<CalculationNode>);
  227. ~InvertCalculationNode();
  228. virtual ErrorOr<String> to_string() const override;
  229. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  230. virtual bool contains_percentage() const override;
  231. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  232. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  233. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  234. private:
  235. explicit InvertCalculationNode(NonnullOwnPtr<CalculationNode>);
  236. NonnullOwnPtr<CalculationNode> m_value;
  237. };
  238. class MinCalculationNode final : public CalculationNode {
  239. public:
  240. static ErrorOr<NonnullOwnPtr<MinCalculationNode>> create(Vector<NonnullOwnPtr<CalculationNode>>);
  241. ~MinCalculationNode();
  242. virtual ErrorOr<String> to_string() const override;
  243. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  244. virtual bool contains_percentage() const override;
  245. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  246. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  247. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  248. private:
  249. explicit MinCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
  250. Vector<NonnullOwnPtr<CalculationNode>> m_values;
  251. };
  252. class MaxCalculationNode final : public CalculationNode {
  253. public:
  254. static ErrorOr<NonnullOwnPtr<MaxCalculationNode>> create(Vector<NonnullOwnPtr<CalculationNode>>);
  255. ~MaxCalculationNode();
  256. virtual ErrorOr<String> to_string() const override;
  257. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  258. virtual bool contains_percentage() const override;
  259. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  260. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  261. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  262. private:
  263. explicit MaxCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
  264. Vector<NonnullOwnPtr<CalculationNode>> m_values;
  265. };
  266. class ClampCalculationNode final : public CalculationNode {
  267. public:
  268. static ErrorOr<NonnullOwnPtr<ClampCalculationNode>> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  269. ~ClampCalculationNode();
  270. virtual ErrorOr<String> to_string() const override;
  271. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  272. virtual bool contains_percentage() const override;
  273. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  274. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  275. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  276. private:
  277. explicit ClampCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  278. NonnullOwnPtr<CalculationNode> m_min_value;
  279. NonnullOwnPtr<CalculationNode> m_center_value;
  280. NonnullOwnPtr<CalculationNode> m_max_value;
  281. };
  282. class AbsCalculationNode final : public CalculationNode {
  283. public:
  284. static ErrorOr<NonnullOwnPtr<AbsCalculationNode>> create(NonnullOwnPtr<CalculationNode>);
  285. ~AbsCalculationNode();
  286. virtual ErrorOr<String> to_string() const override;
  287. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  288. virtual bool contains_percentage() const override;
  289. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  290. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  291. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  292. private:
  293. AbsCalculationNode(NonnullOwnPtr<CalculationNode>);
  294. NonnullOwnPtr<CalculationNode> m_value;
  295. };
  296. class SignCalculationNode final : public CalculationNode {
  297. public:
  298. static ErrorOr<NonnullOwnPtr<SignCalculationNode>> create(NonnullOwnPtr<CalculationNode>);
  299. ~SignCalculationNode();
  300. virtual ErrorOr<String> to_string() const override;
  301. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  302. virtual bool contains_percentage() const override;
  303. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  304. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  305. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  306. private:
  307. SignCalculationNode(NonnullOwnPtr<CalculationNode>);
  308. NonnullOwnPtr<CalculationNode> m_value;
  309. };
  310. class ConstantCalculationNode final : public CalculationNode {
  311. public:
  312. static ErrorOr<NonnullOwnPtr<ConstantCalculationNode>> create(CalculationNode::ConstantType);
  313. ~ConstantCalculationNode();
  314. virtual ErrorOr<String> to_string() const override;
  315. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  316. virtual bool contains_percentage() const override { return false; };
  317. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&> context, CalculatedStyleValue::PercentageBasis const&) const override;
  318. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  319. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  320. private:
  321. ConstantCalculationNode(ConstantType);
  322. CalculationNode::ConstantType m_constant;
  323. };
  324. class SinCalculationNode final : public CalculationNode {
  325. public:
  326. static ErrorOr<NonnullOwnPtr<SinCalculationNode>> create(NonnullOwnPtr<CalculationNode>);
  327. ~SinCalculationNode();
  328. virtual ErrorOr<String> to_string() const override;
  329. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  330. virtual bool contains_percentage() const override;
  331. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  332. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  333. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  334. private:
  335. SinCalculationNode(NonnullOwnPtr<CalculationNode>);
  336. NonnullOwnPtr<CalculationNode> m_value;
  337. };
  338. class CosCalculationNode final : public CalculationNode {
  339. public:
  340. static ErrorOr<NonnullOwnPtr<CosCalculationNode>> create(NonnullOwnPtr<CalculationNode>);
  341. ~CosCalculationNode();
  342. virtual ErrorOr<String> to_string() const override;
  343. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  344. virtual bool contains_percentage() const override;
  345. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  346. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  347. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  348. private:
  349. CosCalculationNode(NonnullOwnPtr<CalculationNode>);
  350. NonnullOwnPtr<CalculationNode> m_value;
  351. };
  352. class TanCalculationNode final : public CalculationNode {
  353. public:
  354. static ErrorOr<NonnullOwnPtr<TanCalculationNode>> create(NonnullOwnPtr<CalculationNode>);
  355. ~TanCalculationNode();
  356. virtual ErrorOr<String> to_string() const override;
  357. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  358. virtual bool contains_percentage() const override;
  359. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  360. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  361. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  362. private:
  363. TanCalculationNode(NonnullOwnPtr<CalculationNode>);
  364. NonnullOwnPtr<CalculationNode> m_value;
  365. };
  366. class AsinCalculationNode final : public CalculationNode {
  367. public:
  368. static ErrorOr<NonnullOwnPtr<AsinCalculationNode>> create(NonnullOwnPtr<CalculationNode>);
  369. ~AsinCalculationNode();
  370. virtual ErrorOr<String> to_string() const override;
  371. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  372. virtual bool contains_percentage() const override;
  373. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  374. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  375. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  376. private:
  377. AsinCalculationNode(NonnullOwnPtr<CalculationNode>);
  378. NonnullOwnPtr<CalculationNode> m_value;
  379. };
  380. class AcosCalculationNode final : public CalculationNode {
  381. public:
  382. static ErrorOr<NonnullOwnPtr<AcosCalculationNode>> create(NonnullOwnPtr<CalculationNode>);
  383. ~AcosCalculationNode();
  384. virtual ErrorOr<String> to_string() const override;
  385. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  386. virtual bool contains_percentage() const override;
  387. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  388. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  389. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  390. private:
  391. AcosCalculationNode(NonnullOwnPtr<CalculationNode>);
  392. NonnullOwnPtr<CalculationNode> m_value;
  393. };
  394. class AtanCalculationNode final : public CalculationNode {
  395. public:
  396. static ErrorOr<NonnullOwnPtr<AtanCalculationNode>> create(NonnullOwnPtr<CalculationNode>);
  397. ~AtanCalculationNode();
  398. virtual ErrorOr<String> to_string() const override;
  399. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  400. virtual bool contains_percentage() const override;
  401. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  402. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  403. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  404. private:
  405. AtanCalculationNode(NonnullOwnPtr<CalculationNode>);
  406. NonnullOwnPtr<CalculationNode> m_value;
  407. };
  408. class Atan2CalculationNode final : public CalculationNode {
  409. public:
  410. static ErrorOr<NonnullOwnPtr<Atan2CalculationNode>> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  411. ~Atan2CalculationNode();
  412. virtual ErrorOr<String> to_string() const override;
  413. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  414. virtual bool contains_percentage() const override;
  415. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  416. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  417. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  418. private:
  419. Atan2CalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  420. NonnullOwnPtr<CalculationNode> m_y;
  421. NonnullOwnPtr<CalculationNode> m_x;
  422. };
  423. class PowCalculationNode final : public CalculationNode {
  424. public:
  425. static ErrorOr<NonnullOwnPtr<PowCalculationNode>> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  426. ~PowCalculationNode();
  427. virtual ErrorOr<String> to_string() const override;
  428. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  429. virtual bool contains_percentage() const override { return false; };
  430. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  431. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  432. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  433. private:
  434. explicit PowCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  435. NonnullOwnPtr<CalculationNode> m_x;
  436. NonnullOwnPtr<CalculationNode> m_y;
  437. };
  438. class SqrtCalculationNode final : public CalculationNode {
  439. public:
  440. static ErrorOr<NonnullOwnPtr<SqrtCalculationNode>> create(NonnullOwnPtr<CalculationNode>);
  441. ~SqrtCalculationNode();
  442. virtual ErrorOr<String> to_string() const override;
  443. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  444. virtual bool contains_percentage() const override { return false; };
  445. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  446. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  447. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  448. private:
  449. SqrtCalculationNode(NonnullOwnPtr<CalculationNode>);
  450. NonnullOwnPtr<CalculationNode> m_value;
  451. };
  452. class HypotCalculationNode final : public CalculationNode {
  453. public:
  454. static ErrorOr<NonnullOwnPtr<HypotCalculationNode>> create(Vector<NonnullOwnPtr<CalculationNode>>);
  455. ~HypotCalculationNode();
  456. virtual ErrorOr<String> to_string() const override;
  457. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  458. virtual bool contains_percentage() const override;
  459. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  460. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  461. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  462. private:
  463. explicit HypotCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>);
  464. Vector<NonnullOwnPtr<CalculationNode>> m_values;
  465. };
  466. class LogCalculationNode final : public CalculationNode {
  467. public:
  468. static ErrorOr<NonnullOwnPtr<LogCalculationNode>> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  469. ~LogCalculationNode();
  470. virtual ErrorOr<String> to_string() const override;
  471. virtual Optional<CalculatedStyleValue::ResolvedType> resolved_type() const override;
  472. virtual bool contains_percentage() const override { return false; };
  473. virtual CalculatedStyleValue::CalculationResult resolve(Optional<Length::ResolutionContext const&>, CalculatedStyleValue::PercentageBasis const&) const override;
  474. virtual ErrorOr<void> for_each_child_node(Function<ErrorOr<void>(NonnullOwnPtr<CalculationNode>&)> const&) override;
  475. virtual ErrorOr<void> dump(StringBuilder&, int indent) const override;
  476. private:
  477. LogCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>);
  478. NonnullOwnPtr<CalculationNode> m_x;
  479. NonnullOwnPtr<CalculationNode> m_y;
  480. };
  481. }