StyleValue.h 42 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
  4. * Copyright (c) 2021, Sam Atkins <atkinssj@serenityos.org>
  5. *
  6. * SPDX-License-Identifier: BSD-2-Clause
  7. */
  8. #pragma once
  9. #include <AK/Function.h>
  10. #include <AK/NonnullOwnPtr.h>
  11. #include <AK/NonnullOwnPtrVector.h>
  12. #include <AK/NonnullRefPtrVector.h>
  13. #include <AK/RefCounted.h>
  14. #include <AK/RefPtr.h>
  15. #include <AK/String.h>
  16. #include <AK/StringView.h>
  17. #include <AK/URL.h>
  18. #include <AK/Variant.h>
  19. #include <AK/Vector.h>
  20. #include <AK/WeakPtr.h>
  21. #include <LibGfx/Bitmap.h>
  22. #include <LibGfx/Color.h>
  23. #include <LibWeb/CSS/Display.h>
  24. #include <LibWeb/CSS/Length.h>
  25. #include <LibWeb/CSS/PropertyID.h>
  26. #include <LibWeb/CSS/ValueID.h>
  27. #include <LibWeb/Forward.h>
  28. #include <LibWeb/Loader/ImageResource.h>
  29. namespace Web::CSS {
  30. enum class AlignItems {
  31. FlexStart,
  32. FlexEnd,
  33. Center,
  34. Baseline,
  35. Stretch,
  36. };
  37. enum class BoxSizing {
  38. BorderBox,
  39. ContentBox,
  40. };
  41. enum class Clear {
  42. None,
  43. Left,
  44. Right,
  45. Both,
  46. };
  47. enum class Cursor {
  48. Auto,
  49. Default,
  50. None,
  51. ContextMenu,
  52. Help,
  53. Pointer,
  54. Progress,
  55. Wait,
  56. Cell,
  57. Crosshair,
  58. Text,
  59. VerticalText,
  60. Alias,
  61. Copy,
  62. Move,
  63. NoDrop,
  64. NotAllowed,
  65. Grab,
  66. Grabbing,
  67. EResize,
  68. NResize,
  69. NeResize,
  70. NwResize,
  71. SResize,
  72. SeResize,
  73. SwResize,
  74. WResize,
  75. EwResize,
  76. NsResize,
  77. NeswResize,
  78. NwseResize,
  79. ColResize,
  80. RowResize,
  81. AllScroll,
  82. ZoomIn,
  83. ZoomOut,
  84. };
  85. enum class FlexBasis {
  86. Content,
  87. Length,
  88. Auto,
  89. };
  90. enum class FlexDirection {
  91. Row,
  92. RowReverse,
  93. Column,
  94. ColumnReverse,
  95. };
  96. enum class FlexWrap {
  97. Nowrap,
  98. Wrap,
  99. WrapReverse
  100. };
  101. enum class Float {
  102. None,
  103. Left,
  104. Right,
  105. };
  106. enum class JustifyContent {
  107. FlexStart,
  108. FlexEnd,
  109. Center,
  110. SpaceBetween,
  111. SpaceAround,
  112. };
  113. enum class LineStyle {
  114. None,
  115. Hidden,
  116. Dotted,
  117. Dashed,
  118. Solid,
  119. Double,
  120. Groove,
  121. Ridge,
  122. Inset,
  123. Outset,
  124. };
  125. enum class ListStyleType {
  126. None,
  127. Disc,
  128. Circle,
  129. Square,
  130. Decimal,
  131. DecimalLeadingZero,
  132. LowerAlpha,
  133. LowerLatin,
  134. LowerRoman,
  135. UpperAlpha,
  136. UpperLatin,
  137. UpperRoman,
  138. };
  139. enum class Overflow : u8 {
  140. Auto,
  141. Clip,
  142. Hidden,
  143. Scroll,
  144. Visible,
  145. };
  146. enum class Position {
  147. Static,
  148. Relative,
  149. Absolute,
  150. Fixed,
  151. Sticky,
  152. };
  153. enum class PositionEdge {
  154. Left,
  155. Right,
  156. Top,
  157. Bottom,
  158. };
  159. enum class Repeat : u8 {
  160. NoRepeat,
  161. Repeat,
  162. Round,
  163. Space,
  164. };
  165. enum class TextAlign {
  166. Left,
  167. Center,
  168. Right,
  169. Justify,
  170. LibwebCenter,
  171. };
  172. enum class TextDecorationLine {
  173. None,
  174. Underline,
  175. Overline,
  176. LineThrough,
  177. Blink,
  178. };
  179. enum class TextTransform {
  180. None,
  181. Capitalize,
  182. Uppercase,
  183. Lowercase,
  184. FullWidth,
  185. FullSizeKana,
  186. };
  187. enum class TransformFunction {
  188. TranslateY,
  189. };
  190. enum class WhiteSpace {
  191. Normal,
  192. Pre,
  193. Nowrap,
  194. PreLine,
  195. PreWrap,
  196. };
  197. enum class PointerEvents {
  198. Auto,
  199. None
  200. };
  201. class StyleValue : public RefCounted<StyleValue> {
  202. public:
  203. virtual ~StyleValue();
  204. enum class Type {
  205. Background,
  206. BackgroundRepeat,
  207. Border,
  208. BorderRadius,
  209. BoxShadow,
  210. Calculated,
  211. Color,
  212. CombinedBorderRadius,
  213. CustomProperty,
  214. Flex,
  215. FlexFlow,
  216. Font,
  217. Identifier,
  218. Image,
  219. Inherit,
  220. Initial,
  221. Invalid,
  222. Length,
  223. ListStyle,
  224. Numeric,
  225. Overflow,
  226. Position,
  227. String,
  228. TextDecoration,
  229. Transformation,
  230. Unset,
  231. ValueList,
  232. };
  233. Type type() const { return m_type; }
  234. bool is_background() const { return type() == Type::Background; }
  235. bool is_background_repeat() const { return type() == Type::BackgroundRepeat; }
  236. bool is_border() const { return type() == Type::Border; }
  237. bool is_border_radius() const { return type() == Type::BorderRadius; }
  238. bool is_box_shadow() const { return type() == Type::BoxShadow; }
  239. bool is_calculated() const { return type() == Type::Calculated; }
  240. bool is_color() const { return type() == Type::Color; }
  241. bool is_custom_property() const { return type() == Type::CustomProperty; }
  242. bool is_flex() const { return type() == Type::Flex; }
  243. bool is_flex_flow() const { return type() == Type::FlexFlow; }
  244. bool is_font() const { return type() == Type::Font; }
  245. bool is_identifier() const { return type() == Type::Identifier; }
  246. bool is_image() const { return type() == Type::Image; }
  247. bool is_inherit() const { return type() == Type::Inherit; }
  248. bool is_initial() const { return type() == Type::Initial; }
  249. bool is_length() const { return type() == Type::Length; }
  250. bool is_list_style() const { return type() == Type::ListStyle; }
  251. bool is_numeric() const { return type() == Type::Numeric; }
  252. bool is_overflow() const { return type() == Type::Overflow; }
  253. bool is_position() const { return type() == Type::Position; }
  254. bool is_string() const { return type() == Type::String; }
  255. bool is_text_decoration() const { return type() == Type::TextDecoration; }
  256. bool is_transformation() const { return type() == Type::Transformation; }
  257. bool is_unset() const { return type() == Type::Unset; }
  258. bool is_value_list() const { return type() == Type::ValueList; }
  259. bool is_builtin() const { return is_inherit() || is_initial() || is_unset(); }
  260. BackgroundStyleValue const& as_background() const;
  261. BackgroundRepeatStyleValue const& as_background_repeat() const;
  262. BorderRadiusStyleValue const& as_border_radius() const;
  263. BorderStyleValue const& as_border() const;
  264. BoxShadowStyleValue const& as_box_shadow() const;
  265. CalculatedStyleValue const& as_calculated() const;
  266. ColorStyleValue const& as_color() const;
  267. CustomStyleValue const& as_custom_property() const;
  268. FlexFlowStyleValue const& as_flex_flow() const;
  269. FlexStyleValue const& as_flex() const;
  270. FontStyleValue const& as_font() const;
  271. IdentifierStyleValue const& as_identifier() const;
  272. ImageStyleValue const& as_image() const;
  273. InheritStyleValue const& as_inherit() const;
  274. InitialStyleValue const& as_initial() const;
  275. LengthStyleValue const& as_length() const;
  276. ListStyleStyleValue const& as_list_style() const;
  277. NumericStyleValue const& as_numeric() const;
  278. OverflowStyleValue const& as_overflow() const;
  279. PositionStyleValue const& as_position() const;
  280. StringStyleValue const& as_string() const;
  281. TextDecorationStyleValue const& as_text_decoration() const;
  282. TransformationStyleValue const& as_transformation() const;
  283. UnsetStyleValue const& as_unset() const;
  284. StyleValueList const& as_value_list() const;
  285. BackgroundStyleValue& as_background() { return const_cast<BackgroundStyleValue&>(const_cast<StyleValue const&>(*this).as_background()); }
  286. BackgroundRepeatStyleValue& as_background_repeat() { return const_cast<BackgroundRepeatStyleValue&>(const_cast<StyleValue const&>(*this).as_background_repeat()); }
  287. BorderRadiusStyleValue& as_border_radius() { return const_cast<BorderRadiusStyleValue&>(const_cast<StyleValue const&>(*this).as_border_radius()); }
  288. BorderStyleValue& as_border() { return const_cast<BorderStyleValue&>(const_cast<StyleValue const&>(*this).as_border()); }
  289. BoxShadowStyleValue& as_box_shadow() { return const_cast<BoxShadowStyleValue&>(const_cast<StyleValue const&>(*this).as_box_shadow()); }
  290. CalculatedStyleValue& as_calculated() { return const_cast<CalculatedStyleValue&>(const_cast<StyleValue const&>(*this).as_calculated()); }
  291. ColorStyleValue& as_color() { return const_cast<ColorStyleValue&>(const_cast<StyleValue const&>(*this).as_color()); }
  292. CustomStyleValue& as_custom_property() { return const_cast<CustomStyleValue&>(const_cast<StyleValue const&>(*this).as_custom_property()); }
  293. FlexFlowStyleValue& as_flex_flow() { return const_cast<FlexFlowStyleValue&>(const_cast<StyleValue const&>(*this).as_flex_flow()); }
  294. FlexStyleValue& as_flex() { return const_cast<FlexStyleValue&>(const_cast<StyleValue const&>(*this).as_flex()); }
  295. FontStyleValue& as_font() { return const_cast<FontStyleValue&>(const_cast<StyleValue const&>(*this).as_font()); }
  296. IdentifierStyleValue& as_identifier() { return const_cast<IdentifierStyleValue&>(const_cast<StyleValue const&>(*this).as_identifier()); }
  297. ImageStyleValue& as_image() { return const_cast<ImageStyleValue&>(const_cast<StyleValue const&>(*this).as_image()); }
  298. InheritStyleValue& as_inherit() { return const_cast<InheritStyleValue&>(const_cast<StyleValue const&>(*this).as_inherit()); }
  299. InitialStyleValue& as_initial() { return const_cast<InitialStyleValue&>(const_cast<StyleValue const&>(*this).as_initial()); }
  300. LengthStyleValue& as_length() { return const_cast<LengthStyleValue&>(const_cast<StyleValue const&>(*this).as_length()); }
  301. ListStyleStyleValue& as_list_style() { return const_cast<ListStyleStyleValue&>(const_cast<StyleValue const&>(*this).as_list_style()); }
  302. NumericStyleValue& as_numeric() { return const_cast<NumericStyleValue&>(const_cast<StyleValue const&>(*this).as_numeric()); }
  303. OverflowStyleValue& as_overflow() { return const_cast<OverflowStyleValue&>(const_cast<StyleValue const&>(*this).as_overflow()); }
  304. PositionStyleValue& as_position() { return const_cast<PositionStyleValue&>(const_cast<StyleValue const&>(*this).as_position()); }
  305. StringStyleValue& as_string() { return const_cast<StringStyleValue&>(const_cast<StyleValue const&>(*this).as_string()); }
  306. TextDecorationStyleValue& as_text_decoration() { return const_cast<TextDecorationStyleValue&>(const_cast<StyleValue const&>(*this).as_text_decoration()); }
  307. TransformationStyleValue& as_transformation() { return const_cast<TransformationStyleValue&>(const_cast<StyleValue const&>(*this).as_transformation()); }
  308. UnsetStyleValue& as_unset() { return const_cast<UnsetStyleValue&>(const_cast<StyleValue const&>(*this).as_unset()); }
  309. StyleValueList& as_value_list() { return const_cast<StyleValueList&>(const_cast<StyleValue const&>(*this).as_value_list()); }
  310. virtual bool has_auto() const { return false; }
  311. virtual bool has_color() const { return false; }
  312. virtual bool has_identifier() const { return false; }
  313. virtual bool has_length() const { return false; }
  314. virtual bool has_number() const { return false; }
  315. virtual bool has_integer() const { return false; }
  316. virtual Color to_color(Layout::NodeWithStyle const&) const { return {}; }
  317. virtual CSS::ValueID to_identifier() const { return ValueID::Invalid; }
  318. virtual Length to_length() const { return {}; }
  319. virtual float to_number() const { return 0; }
  320. virtual float to_integer() const { return 0; }
  321. virtual String to_string() const = 0;
  322. bool operator==(StyleValue const& other) const { return equals(other); }
  323. bool operator!=(StyleValue const& other) const { return !(*this == other); }
  324. virtual bool equals(StyleValue const& other) const
  325. {
  326. if (type() != other.type())
  327. return false;
  328. return to_string() == other.to_string();
  329. }
  330. virtual void visit_lengths(Function<void(CSS::Length&)>) { }
  331. protected:
  332. explicit StyleValue(Type);
  333. private:
  334. Type m_type { Type::Invalid };
  335. };
  336. class BackgroundStyleValue final : public StyleValue {
  337. public:
  338. static NonnullRefPtr<BackgroundStyleValue> create(
  339. NonnullRefPtr<StyleValue> color,
  340. NonnullRefPtr<StyleValue> image,
  341. NonnullRefPtr<StyleValue> repeat_x,
  342. NonnullRefPtr<StyleValue> repeat_y)
  343. {
  344. return adopt_ref(*new BackgroundStyleValue(color, image, repeat_x, repeat_y));
  345. }
  346. virtual ~BackgroundStyleValue() override { }
  347. NonnullRefPtr<StyleValue> color() const { return m_color; }
  348. NonnullRefPtr<StyleValue> image() const { return m_image; }
  349. NonnullRefPtr<StyleValue> repeat_x() const { return m_repeat_x; }
  350. NonnullRefPtr<StyleValue> repeat_y() const { return m_repeat_y; }
  351. virtual String to_string() const override
  352. {
  353. return String::formatted("{} {} {} {}", m_color->to_string(), m_image->to_string(), m_repeat_x->to_string(), m_repeat_y->to_string());
  354. }
  355. private:
  356. BackgroundStyleValue(
  357. NonnullRefPtr<StyleValue> color,
  358. NonnullRefPtr<StyleValue> image,
  359. NonnullRefPtr<StyleValue> repeat_x,
  360. NonnullRefPtr<StyleValue> repeat_y)
  361. : StyleValue(Type::Background)
  362. , m_color(color)
  363. , m_image(image)
  364. , m_repeat_x(repeat_x)
  365. , m_repeat_y(repeat_y)
  366. {
  367. }
  368. NonnullRefPtr<StyleValue> m_color;
  369. NonnullRefPtr<StyleValue> m_image;
  370. // FIXME: background-position
  371. // FIXME: background-size
  372. NonnullRefPtr<StyleValue> m_repeat_x;
  373. NonnullRefPtr<StyleValue> m_repeat_y;
  374. // FIXME: background-attachment
  375. // FIXME: background-clip
  376. // FIXME: background-origin
  377. };
  378. class PositionStyleValue final : public StyleValue {
  379. public:
  380. static NonnullRefPtr<PositionStyleValue> create(PositionEdge edge_x, Length const& offset_x, PositionEdge edge_y, Length const& offset_y)
  381. {
  382. return adopt_ref(*new PositionStyleValue(edge_x, offset_x, edge_y, offset_y));
  383. }
  384. virtual ~PositionStyleValue() override { }
  385. PositionEdge edge_x() const { return m_edge_x; }
  386. Length const& offset_x() const { return m_offset_x; }
  387. PositionEdge edge_y() const { return m_edge_y; }
  388. Length const& offset_y() const { return m_offset_y; }
  389. virtual String to_string() const override;
  390. private:
  391. PositionStyleValue(PositionEdge edge_x, Length const& offset_x, PositionEdge edge_y, Length const& offset_y)
  392. : StyleValue(Type::Position)
  393. , m_edge_x(edge_x)
  394. , m_offset_x(offset_x)
  395. , m_edge_y(edge_y)
  396. , m_offset_y(offset_y)
  397. {
  398. }
  399. PositionEdge m_edge_x;
  400. Length m_offset_x;
  401. PositionEdge m_edge_y;
  402. Length m_offset_y;
  403. };
  404. class BackgroundRepeatStyleValue final : public StyleValue {
  405. public:
  406. static NonnullRefPtr<BackgroundRepeatStyleValue> create(NonnullRefPtr<StyleValue> repeat_x, NonnullRefPtr<StyleValue> repeat_y)
  407. {
  408. return adopt_ref(*new BackgroundRepeatStyleValue(repeat_x, repeat_y));
  409. }
  410. virtual ~BackgroundRepeatStyleValue() override { }
  411. NonnullRefPtr<StyleValue> repeat_x() const { return m_repeat_x; }
  412. NonnullRefPtr<StyleValue> repeat_y() const { return m_repeat_y; }
  413. virtual String to_string() const override
  414. {
  415. return String::formatted("{} {}", m_repeat_x->to_string(), m_repeat_y->to_string());
  416. }
  417. private:
  418. BackgroundRepeatStyleValue(NonnullRefPtr<StyleValue> repeat_x, NonnullRefPtr<StyleValue> repeat_y)
  419. : StyleValue(Type::BackgroundRepeat)
  420. , m_repeat_x(repeat_x)
  421. , m_repeat_y(repeat_y)
  422. {
  423. }
  424. NonnullRefPtr<StyleValue> m_repeat_x;
  425. NonnullRefPtr<StyleValue> m_repeat_y;
  426. };
  427. class BorderStyleValue final : public StyleValue {
  428. public:
  429. static NonnullRefPtr<BorderStyleValue> create(
  430. NonnullRefPtr<StyleValue> border_width,
  431. NonnullRefPtr<StyleValue> border_style,
  432. NonnullRefPtr<StyleValue> border_color)
  433. {
  434. return adopt_ref(*new BorderStyleValue(border_width, border_style, border_color));
  435. }
  436. virtual ~BorderStyleValue() override { }
  437. NonnullRefPtr<StyleValue> border_width() const { return m_border_width; }
  438. NonnullRefPtr<StyleValue> border_style() const { return m_border_style; }
  439. NonnullRefPtr<StyleValue> border_color() const { return m_border_color; }
  440. virtual String to_string() const override
  441. {
  442. return String::formatted("Border border_width: {}, border_style: {}, border_color: {}", m_border_width->to_string(), m_border_style->to_string(), m_border_color->to_string());
  443. }
  444. private:
  445. BorderStyleValue(
  446. NonnullRefPtr<StyleValue> border_width,
  447. NonnullRefPtr<StyleValue> border_style,
  448. NonnullRefPtr<StyleValue> border_color)
  449. : StyleValue(Type::Border)
  450. , m_border_width(border_width)
  451. , m_border_style(border_style)
  452. , m_border_color(border_color)
  453. {
  454. }
  455. NonnullRefPtr<StyleValue> m_border_width;
  456. NonnullRefPtr<StyleValue> m_border_style;
  457. NonnullRefPtr<StyleValue> m_border_color;
  458. };
  459. class BorderRadiusStyleValue final : public StyleValue {
  460. public:
  461. static NonnullRefPtr<BorderRadiusStyleValue> create(Length const& horizontal_radius, Length const& vertical_radius)
  462. {
  463. return adopt_ref(*new BorderRadiusStyleValue(horizontal_radius, vertical_radius));
  464. }
  465. virtual ~BorderRadiusStyleValue() override { }
  466. Length const& horizontal_radius() const { return m_horizontal_radius; }
  467. Length const& vertical_radius() const { return m_vertical_radius; }
  468. bool is_elliptical() const { return m_is_elliptical; }
  469. // FIXME: Remove this once we support elliptical border-radius in Layout/Node.
  470. virtual Length to_length() const override { return horizontal_radius(); }
  471. virtual String to_string() const override
  472. {
  473. return String::formatted("{} / {}", m_horizontal_radius.to_string(), m_vertical_radius.to_string());
  474. }
  475. virtual bool equals(StyleValue const& other) const override
  476. {
  477. if (type() != other.type())
  478. return false;
  479. auto& other_value = static_cast<BorderRadiusStyleValue const&>(other);
  480. return m_is_elliptical == other_value.m_is_elliptical
  481. && m_horizontal_radius == other_value.m_horizontal_radius
  482. && m_vertical_radius == other_value.m_vertical_radius;
  483. }
  484. private:
  485. BorderRadiusStyleValue(Length const& horizontal_radius, Length const& vertical_radius)
  486. : StyleValue(Type::BorderRadius)
  487. , m_horizontal_radius(horizontal_radius)
  488. , m_vertical_radius(vertical_radius)
  489. {
  490. m_is_elliptical = (m_horizontal_radius != m_vertical_radius);
  491. }
  492. virtual void visit_lengths(Function<void(CSS::Length&)> visitor) override
  493. {
  494. visitor(m_horizontal_radius);
  495. visitor(m_vertical_radius);
  496. }
  497. bool m_is_elliptical;
  498. Length m_horizontal_radius;
  499. Length m_vertical_radius;
  500. };
  501. class BoxShadowStyleValue final : public StyleValue {
  502. public:
  503. static NonnullRefPtr<BoxShadowStyleValue> create(Length const& offset_x, Length const& offset_y, Length const& blur_radius, Color const& color)
  504. {
  505. return adopt_ref(*new BoxShadowStyleValue(offset_x, offset_y, blur_radius, color));
  506. }
  507. virtual ~BoxShadowStyleValue() override { }
  508. Length const& offset_x() const { return m_offset_x; }
  509. Length const& offset_y() const { return m_offset_y; }
  510. Length const& blur_radius() const { return m_blur_radius; }
  511. Color const& color() const { return m_color; }
  512. String to_string() const override { return String::formatted("BoxShadow offset_x: {}, offset_y: {}, blur_radius: {}, color: {}",
  513. m_offset_x.to_string(), m_offset_y.to_string(), m_blur_radius.to_string(), m_color.to_string()); }
  514. private:
  515. explicit BoxShadowStyleValue(Length const& offset_x, Length const& offset_y, Length const& blur_radius, Color const& color)
  516. : StyleValue(Type::BoxShadow)
  517. , m_offset_x(offset_x)
  518. , m_offset_y(offset_y)
  519. , m_blur_radius(blur_radius)
  520. , m_color(color)
  521. {
  522. }
  523. virtual void visit_lengths(Function<void(CSS::Length&)> visitor) override
  524. {
  525. visitor(m_offset_x);
  526. visitor(m_offset_y);
  527. visitor(m_blur_radius);
  528. }
  529. Length m_offset_x;
  530. Length m_offset_y;
  531. Length m_blur_radius;
  532. Color m_color;
  533. };
  534. class CalculatedStyleValue : public StyleValue {
  535. public:
  536. struct CalcSum;
  537. struct CalcSumPartWithOperator;
  538. struct CalcProduct;
  539. struct CalcProductPartWithOperator;
  540. struct CalcNumberSum;
  541. struct CalcNumberSumPartWithOperator;
  542. struct CalcNumberProduct;
  543. struct CalcNumberProductPartWithOperator;
  544. using CalcNumberValue = Variant<float, NonnullOwnPtr<CalcNumberSum>>;
  545. using CalcValue = Variant<float, CSS::Length, NonnullOwnPtr<CalcSum>>;
  546. // This represents that: https://www.w3.org/TR/css-values-3/#calc-syntax
  547. struct CalcSum {
  548. CalcSum(NonnullOwnPtr<CalcProduct> first_calc_product, NonnullOwnPtrVector<CalcSumPartWithOperator> additional)
  549. : first_calc_product(move(first_calc_product))
  550. , zero_or_more_additional_calc_products(move(additional)) {};
  551. NonnullOwnPtr<CalcProduct> first_calc_product;
  552. NonnullOwnPtrVector<CalcSumPartWithOperator> zero_or_more_additional_calc_products;
  553. };
  554. struct CalcNumberSum {
  555. CalcNumberSum(NonnullOwnPtr<CalcNumberProduct> first_calc_number_product, NonnullOwnPtrVector<CalcNumberSumPartWithOperator> additional)
  556. : first_calc_number_product(move(first_calc_number_product))
  557. , zero_or_more_additional_calc_number_products(move(additional)) {};
  558. NonnullOwnPtr<CalcNumberProduct> first_calc_number_product;
  559. NonnullOwnPtrVector<CalcNumberSumPartWithOperator> zero_or_more_additional_calc_number_products;
  560. };
  561. struct CalcProduct {
  562. CalcValue first_calc_value;
  563. NonnullOwnPtrVector<CalcProductPartWithOperator> zero_or_more_additional_calc_values;
  564. };
  565. struct CalcSumPartWithOperator {
  566. enum Operation {
  567. Add,
  568. Subtract,
  569. };
  570. CalcSumPartWithOperator(Operation op, NonnullOwnPtr<CalcProduct> calc_product)
  571. : op(op)
  572. , calc_product(move(calc_product)) {};
  573. Operation op;
  574. NonnullOwnPtr<CalcProduct> calc_product;
  575. };
  576. struct CalcProductPartWithOperator {
  577. enum {
  578. Multiply,
  579. Divide,
  580. } op;
  581. Variant<CalcValue, CalcNumberValue> value;
  582. };
  583. struct CalcNumberProduct {
  584. CalcNumberValue first_calc_number_value;
  585. NonnullOwnPtrVector<CalcNumberProductPartWithOperator> zero_or_more_additional_calc_number_values;
  586. };
  587. struct CalcNumberProductPartWithOperator {
  588. enum {
  589. Multiply,
  590. Divide,
  591. } op;
  592. CalcNumberValue value;
  593. };
  594. struct CalcNumberSumPartWithOperator {
  595. enum Operation {
  596. Add,
  597. Subtract,
  598. };
  599. CalcNumberSumPartWithOperator(Operation op, NonnullOwnPtr<CalcNumberProduct> calc_number_product)
  600. : op(op)
  601. , calc_number_product(move(calc_number_product)) {};
  602. Operation op;
  603. NonnullOwnPtr<CalcNumberProduct> calc_number_product;
  604. };
  605. static NonnullRefPtr<CalculatedStyleValue> create(String const& expression_string, NonnullOwnPtr<CalcSum> calc_sum)
  606. {
  607. return adopt_ref(*new CalculatedStyleValue(expression_string, move(calc_sum)));
  608. }
  609. String to_string() const override { return m_expression_string; }
  610. NonnullOwnPtr<CalcSum> const& expression() const { return m_expression; }
  611. private:
  612. explicit CalculatedStyleValue(String const& expression_string, NonnullOwnPtr<CalcSum> calc_sum)
  613. : StyleValue(Type::Calculated)
  614. , m_expression_string(expression_string)
  615. , m_expression(move(calc_sum))
  616. {
  617. }
  618. String m_expression_string;
  619. NonnullOwnPtr<CalcSum> m_expression;
  620. };
  621. class ColorStyleValue : public StyleValue {
  622. public:
  623. static NonnullRefPtr<ColorStyleValue> create(Color color)
  624. {
  625. return adopt_ref(*new ColorStyleValue(color));
  626. }
  627. virtual ~ColorStyleValue() override { }
  628. Color color() const { return m_color; }
  629. virtual String to_string() const override;
  630. virtual bool has_color() const override { return true; }
  631. virtual Color to_color(Layout::NodeWithStyle const&) const override { return m_color; }
  632. virtual bool equals(StyleValue const& other) const override
  633. {
  634. if (type() != other.type())
  635. return false;
  636. return m_color == static_cast<const ColorStyleValue&>(other).m_color;
  637. }
  638. private:
  639. explicit ColorStyleValue(Color color)
  640. : StyleValue(Type::Color)
  641. , m_color(color)
  642. {
  643. }
  644. Color m_color;
  645. };
  646. class CombinedBorderRadiusStyleValue final : public StyleValue {
  647. public:
  648. static NonnullRefPtr<CombinedBorderRadiusStyleValue> create(NonnullRefPtr<BorderRadiusStyleValue> top_left, NonnullRefPtr<BorderRadiusStyleValue> top_right, NonnullRefPtr<BorderRadiusStyleValue> bottom_right, NonnullRefPtr<BorderRadiusStyleValue> bottom_left)
  649. {
  650. return adopt_ref(*new CombinedBorderRadiusStyleValue(top_left, top_right, bottom_right, bottom_left));
  651. }
  652. virtual ~CombinedBorderRadiusStyleValue() override { }
  653. NonnullRefPtr<BorderRadiusStyleValue> top_left() const { return m_top_left; }
  654. NonnullRefPtr<BorderRadiusStyleValue> top_right() const { return m_top_right; }
  655. NonnullRefPtr<BorderRadiusStyleValue> bottom_right() const { return m_bottom_right; }
  656. NonnullRefPtr<BorderRadiusStyleValue> bottom_left() const { return m_bottom_left; }
  657. virtual String to_string() const override
  658. {
  659. return String::formatted("{} {} {} {} / {} {} {} {}", m_top_left->horizontal_radius().to_string(), m_top_right->horizontal_radius().to_string(), m_bottom_right->horizontal_radius().to_string(), m_bottom_left->horizontal_radius().to_string(), m_top_left->vertical_radius().to_string(), m_top_right->vertical_radius().to_string(), m_bottom_right->vertical_radius().to_string(), m_bottom_left->vertical_radius().to_string());
  660. }
  661. private:
  662. CombinedBorderRadiusStyleValue(NonnullRefPtr<BorderRadiusStyleValue> top_left, NonnullRefPtr<BorderRadiusStyleValue> top_right, NonnullRefPtr<BorderRadiusStyleValue> bottom_right, NonnullRefPtr<BorderRadiusStyleValue> bottom_left)
  663. : StyleValue(Type::CombinedBorderRadius)
  664. , m_top_left(top_left)
  665. , m_top_right(top_right)
  666. , m_bottom_right(bottom_right)
  667. , m_bottom_left(bottom_left)
  668. {
  669. }
  670. NonnullRefPtr<BorderRadiusStyleValue> m_top_left;
  671. NonnullRefPtr<BorderRadiusStyleValue> m_top_right;
  672. NonnullRefPtr<BorderRadiusStyleValue> m_bottom_right;
  673. NonnullRefPtr<BorderRadiusStyleValue> m_bottom_left;
  674. };
  675. // FIXME: Allow for fallback
  676. class CustomStyleValue : public StyleValue {
  677. public:
  678. static NonnullRefPtr<CustomStyleValue> create(String const& custom_property_name)
  679. {
  680. return adopt_ref(*new CustomStyleValue(custom_property_name));
  681. }
  682. String custom_property_name() const { return m_custom_property_name; }
  683. String to_string() const override { return m_custom_property_name; }
  684. private:
  685. explicit CustomStyleValue(String const& custom_property_name)
  686. : StyleValue(Type::CustomProperty)
  687. , m_custom_property_name(custom_property_name)
  688. {
  689. }
  690. String m_custom_property_name {};
  691. };
  692. class FlexStyleValue final : public StyleValue {
  693. public:
  694. static NonnullRefPtr<FlexStyleValue> create(
  695. NonnullRefPtr<StyleValue> grow,
  696. NonnullRefPtr<StyleValue> shrink,
  697. NonnullRefPtr<StyleValue> basis)
  698. {
  699. return adopt_ref(*new FlexStyleValue(grow, shrink, basis));
  700. }
  701. virtual ~FlexStyleValue() override { }
  702. NonnullRefPtr<StyleValue> grow() const { return m_grow; }
  703. NonnullRefPtr<StyleValue> shrink() const { return m_shrink; }
  704. NonnullRefPtr<StyleValue> basis() const { return m_basis; }
  705. virtual String to_string() const override
  706. {
  707. return String::formatted("Flex grow: {}, shrink: {}, basis: {}", m_grow->to_string(), m_shrink->to_string(), m_basis->to_string());
  708. }
  709. private:
  710. FlexStyleValue(
  711. NonnullRefPtr<StyleValue> grow,
  712. NonnullRefPtr<StyleValue> shrink,
  713. NonnullRefPtr<StyleValue> basis)
  714. : StyleValue(Type::Flex)
  715. , m_grow(grow)
  716. , m_shrink(shrink)
  717. , m_basis(basis)
  718. {
  719. }
  720. NonnullRefPtr<StyleValue> m_grow;
  721. NonnullRefPtr<StyleValue> m_shrink;
  722. NonnullRefPtr<StyleValue> m_basis;
  723. };
  724. class FlexFlowStyleValue final : public StyleValue {
  725. public:
  726. static NonnullRefPtr<FlexFlowStyleValue> create(NonnullRefPtr<StyleValue> flex_direction, NonnullRefPtr<StyleValue> flex_wrap)
  727. {
  728. return adopt_ref(*new FlexFlowStyleValue(flex_direction, flex_wrap));
  729. }
  730. virtual ~FlexFlowStyleValue() override { }
  731. NonnullRefPtr<StyleValue> flex_direction() const { return m_flex_direction; }
  732. NonnullRefPtr<StyleValue> flex_wrap() const { return m_flex_wrap; }
  733. virtual String to_string() const override
  734. {
  735. return String::formatted("FlexFlow flex_direction: {}, flex_wrap: {}", m_flex_direction->to_string(), m_flex_wrap->to_string());
  736. }
  737. private:
  738. FlexFlowStyleValue(NonnullRefPtr<StyleValue> flex_direction, NonnullRefPtr<StyleValue> flex_wrap)
  739. : StyleValue(Type::FlexFlow)
  740. , m_flex_direction(flex_direction)
  741. , m_flex_wrap(flex_wrap)
  742. {
  743. }
  744. NonnullRefPtr<StyleValue> m_flex_direction;
  745. NonnullRefPtr<StyleValue> m_flex_wrap;
  746. };
  747. class FontStyleValue final : public StyleValue {
  748. public:
  749. static NonnullRefPtr<FontStyleValue> create(NonnullRefPtr<StyleValue> font_style, NonnullRefPtr<StyleValue> font_weight, NonnullRefPtr<StyleValue> font_size, NonnullRefPtr<StyleValue> line_height, NonnullRefPtr<StyleValue> font_families) { return adopt_ref(*new FontStyleValue(font_style, font_weight, font_size, line_height, font_families)); }
  750. virtual ~FontStyleValue() override { }
  751. NonnullRefPtr<StyleValue> font_style() const { return m_font_style; }
  752. NonnullRefPtr<StyleValue> font_weight() const { return m_font_weight; }
  753. NonnullRefPtr<StyleValue> font_size() const { return m_font_size; }
  754. NonnullRefPtr<StyleValue> line_height() const { return m_line_height; }
  755. NonnullRefPtr<StyleValue> font_families() const { return m_font_families; }
  756. virtual String to_string() const override
  757. {
  758. return String::formatted("Font style: {}, weight: {}, size: {}, line_height: {}, families: {}",
  759. m_font_style->to_string(), m_font_weight->to_string(), m_font_size->to_string(), m_line_height->to_string(), m_font_families->to_string());
  760. }
  761. private:
  762. FontStyleValue(NonnullRefPtr<StyleValue> font_style, NonnullRefPtr<StyleValue> font_weight, NonnullRefPtr<StyleValue> font_size, NonnullRefPtr<StyleValue> line_height, NonnullRefPtr<StyleValue> font_families)
  763. : StyleValue(Type::Font)
  764. , m_font_style(font_style)
  765. , m_font_weight(font_weight)
  766. , m_font_size(font_size)
  767. , m_line_height(line_height)
  768. , m_font_families(font_families)
  769. {
  770. }
  771. NonnullRefPtr<StyleValue> m_font_style;
  772. NonnullRefPtr<StyleValue> m_font_weight;
  773. NonnullRefPtr<StyleValue> m_font_size;
  774. NonnullRefPtr<StyleValue> m_line_height;
  775. NonnullRefPtr<StyleValue> m_font_families;
  776. // FIXME: Implement font-stretch and font-variant.
  777. };
  778. class IdentifierStyleValue final : public StyleValue {
  779. public:
  780. static NonnullRefPtr<IdentifierStyleValue> create(CSS::ValueID id)
  781. {
  782. return adopt_ref(*new IdentifierStyleValue(id));
  783. }
  784. virtual ~IdentifierStyleValue() override { }
  785. CSS::ValueID id() const { return m_id; }
  786. virtual bool has_auto() const override { return m_id == ValueID::Auto; }
  787. virtual bool has_identifier() const override { return true; }
  788. virtual CSS::ValueID to_identifier() const override { return m_id; }
  789. virtual bool has_color() const override;
  790. virtual Color to_color(Layout::NodeWithStyle const& node) const override;
  791. virtual String to_string() const override;
  792. virtual bool equals(StyleValue const& other) const override
  793. {
  794. if (type() != other.type())
  795. return false;
  796. return m_id == static_cast<const IdentifierStyleValue&>(other).m_id;
  797. }
  798. private:
  799. explicit IdentifierStyleValue(CSS::ValueID id)
  800. : StyleValue(Type::Identifier)
  801. , m_id(id)
  802. {
  803. }
  804. CSS::ValueID m_id { CSS::ValueID::Invalid };
  805. };
  806. class ImageStyleValue final
  807. : public StyleValue
  808. , public ImageResourceClient {
  809. public:
  810. static NonnullRefPtr<ImageStyleValue> create(AK::URL const& url) { return adopt_ref(*new ImageStyleValue(url)); }
  811. virtual ~ImageStyleValue() override { }
  812. String to_string() const override { return String::formatted("Image({})", m_url.to_string()); }
  813. void load_bitmap(DOM::Document& document);
  814. Gfx::Bitmap const* bitmap() const { return m_bitmap; }
  815. private:
  816. ImageStyleValue(AK::URL const&);
  817. // ^ResourceClient
  818. virtual void resource_did_load() override;
  819. AK::URL m_url;
  820. WeakPtr<DOM::Document> m_document;
  821. RefPtr<Gfx::Bitmap> m_bitmap;
  822. };
  823. class InheritStyleValue final : public StyleValue {
  824. public:
  825. static NonnullRefPtr<InheritStyleValue> the()
  826. {
  827. static NonnullRefPtr<InheritStyleValue> instance = adopt_ref(*new InheritStyleValue);
  828. return instance;
  829. }
  830. virtual ~InheritStyleValue() override { }
  831. String to_string() const override { return "inherit"; }
  832. private:
  833. InheritStyleValue()
  834. : StyleValue(Type::Inherit)
  835. {
  836. }
  837. };
  838. class InitialStyleValue final : public StyleValue {
  839. public:
  840. static NonnullRefPtr<InitialStyleValue> the()
  841. {
  842. static NonnullRefPtr<InitialStyleValue> instance = adopt_ref(*new InitialStyleValue);
  843. return instance;
  844. }
  845. virtual ~InitialStyleValue() override { }
  846. String to_string() const override { return "initial"; }
  847. private:
  848. InitialStyleValue()
  849. : StyleValue(Type::Initial)
  850. {
  851. }
  852. };
  853. class LengthStyleValue : public StyleValue {
  854. public:
  855. static NonnullRefPtr<LengthStyleValue> create(Length const& length)
  856. {
  857. return adopt_ref(*new LengthStyleValue(length));
  858. }
  859. virtual ~LengthStyleValue() override { }
  860. Length const& length() const { return m_length; }
  861. virtual bool has_auto() const override { return m_length.is_auto(); }
  862. virtual bool has_length() const override { return true; }
  863. virtual bool has_identifier() const override { return has_auto(); }
  864. virtual String to_string() const override { return m_length.to_string(); }
  865. virtual Length to_length() const override { return m_length; }
  866. virtual ValueID to_identifier() const override { return has_auto() ? ValueID::Auto : ValueID::Invalid; }
  867. virtual bool equals(StyleValue const& other) const override
  868. {
  869. if (type() != other.type())
  870. return false;
  871. return m_length == static_cast<LengthStyleValue const&>(other).m_length;
  872. }
  873. private:
  874. explicit LengthStyleValue(Length const& length)
  875. : StyleValue(Type::Length)
  876. , m_length(length)
  877. {
  878. }
  879. virtual void visit_lengths(Function<void(CSS::Length&)> visitor) override
  880. {
  881. visitor(m_length);
  882. }
  883. Length m_length;
  884. };
  885. class ListStyleStyleValue final : public StyleValue {
  886. public:
  887. static NonnullRefPtr<ListStyleStyleValue> create(
  888. NonnullRefPtr<StyleValue> position,
  889. NonnullRefPtr<StyleValue> image,
  890. NonnullRefPtr<StyleValue> style_type)
  891. {
  892. return adopt_ref(*new ListStyleStyleValue(position, image, style_type));
  893. }
  894. virtual ~ListStyleStyleValue() override { }
  895. NonnullRefPtr<StyleValue> position() const { return m_position; }
  896. NonnullRefPtr<StyleValue> image() const { return m_image; }
  897. NonnullRefPtr<StyleValue> style_type() const { return m_style_type; }
  898. virtual String to_string() const override
  899. {
  900. return String::formatted("ListStyle position: {}, image: {}, style_type: {}", m_position->to_string(), m_image->to_string(), m_style_type->to_string());
  901. }
  902. private:
  903. ListStyleStyleValue(
  904. NonnullRefPtr<StyleValue> position,
  905. NonnullRefPtr<StyleValue> image,
  906. NonnullRefPtr<StyleValue> style_type)
  907. : StyleValue(Type::ListStyle)
  908. , m_position(position)
  909. , m_image(image)
  910. , m_style_type(style_type)
  911. {
  912. }
  913. NonnullRefPtr<StyleValue> m_position;
  914. NonnullRefPtr<StyleValue> m_image;
  915. NonnullRefPtr<StyleValue> m_style_type;
  916. };
  917. class NumericStyleValue : public StyleValue {
  918. public:
  919. static NonnullRefPtr<NumericStyleValue> create_float(float value)
  920. {
  921. return adopt_ref(*new NumericStyleValue(value));
  922. }
  923. static NonnullRefPtr<NumericStyleValue> create_integer(i64 value)
  924. {
  925. return adopt_ref(*new NumericStyleValue(value));
  926. }
  927. virtual bool has_length() const override { return to_number() == 0; }
  928. virtual Length to_length() const override { return Length(0, Length::Type::Px); }
  929. virtual bool has_number() const override { return true; }
  930. virtual float to_number() const override
  931. {
  932. return m_value.visit(
  933. [](float value) { return value; },
  934. [](i64 value) { return (float)value; });
  935. }
  936. virtual bool has_integer() const override { return m_value.has<i64>(); }
  937. virtual float to_integer() const override { return m_value.get<i64>(); }
  938. String to_string() const override
  939. {
  940. return m_value.visit(
  941. [](float value) {
  942. return String::formatted("{}", value);
  943. },
  944. [](i64 value) {
  945. return String::formatted("{}", value);
  946. });
  947. }
  948. virtual bool equals(StyleValue const& other) const override
  949. {
  950. if (type() != other.type())
  951. return false;
  952. if (has_integer() != other.has_integer())
  953. return false;
  954. if (has_integer())
  955. return m_value.get<i64>() == static_cast<NumericStyleValue const&>(other).m_value.get<i64>();
  956. return m_value.get<float>() == static_cast<NumericStyleValue const&>(other).m_value.get<float>();
  957. }
  958. private:
  959. explicit NumericStyleValue(Variant<float, i64> value)
  960. : StyleValue(Type::Numeric)
  961. , m_value(move(value))
  962. {
  963. }
  964. Variant<float, i64> m_value { (i64)0 };
  965. };
  966. class OverflowStyleValue final : public StyleValue {
  967. public:
  968. static NonnullRefPtr<OverflowStyleValue> create(NonnullRefPtr<StyleValue> overflow_x, NonnullRefPtr<StyleValue> overflow_y)
  969. {
  970. return adopt_ref(*new OverflowStyleValue(overflow_x, overflow_y));
  971. }
  972. virtual ~OverflowStyleValue() override { }
  973. NonnullRefPtr<StyleValue> overflow_x() const { return m_overflow_x; }
  974. NonnullRefPtr<StyleValue> overflow_y() const { return m_overflow_y; }
  975. virtual String to_string() const override
  976. {
  977. return String::formatted("{} {}", m_overflow_x->to_string(), m_overflow_y->to_string());
  978. }
  979. private:
  980. OverflowStyleValue(NonnullRefPtr<StyleValue> overflow_x, NonnullRefPtr<StyleValue> overflow_y)
  981. : StyleValue(Type::Overflow)
  982. , m_overflow_x(overflow_x)
  983. , m_overflow_y(overflow_y)
  984. {
  985. }
  986. NonnullRefPtr<StyleValue> m_overflow_x;
  987. NonnullRefPtr<StyleValue> m_overflow_y;
  988. };
  989. class StringStyleValue : public StyleValue {
  990. public:
  991. static NonnullRefPtr<StringStyleValue> create(String const& string)
  992. {
  993. return adopt_ref(*new StringStyleValue(string));
  994. }
  995. virtual ~StringStyleValue() override { }
  996. String to_string() const override { return m_string; }
  997. private:
  998. explicit StringStyleValue(String const& string)
  999. : StyleValue(Type::String)
  1000. , m_string(string)
  1001. {
  1002. }
  1003. String m_string;
  1004. };
  1005. class TextDecorationStyleValue final : public StyleValue {
  1006. public:
  1007. static NonnullRefPtr<TextDecorationStyleValue> create(
  1008. NonnullRefPtr<StyleValue> line,
  1009. NonnullRefPtr<StyleValue> style,
  1010. NonnullRefPtr<StyleValue> color)
  1011. {
  1012. return adopt_ref(*new TextDecorationStyleValue(line, style, color));
  1013. }
  1014. virtual ~TextDecorationStyleValue() override { }
  1015. NonnullRefPtr<StyleValue> line() const { return m_line; }
  1016. NonnullRefPtr<StyleValue> style() const { return m_style; }
  1017. NonnullRefPtr<StyleValue> color() const { return m_color; }
  1018. virtual String to_string() const override
  1019. {
  1020. return String::formatted("TextDecoration line: {}, style: {}, color: {}", m_line->to_string(), m_style->to_string(), m_color->to_string());
  1021. }
  1022. private:
  1023. TextDecorationStyleValue(
  1024. NonnullRefPtr<StyleValue> line,
  1025. NonnullRefPtr<StyleValue> style,
  1026. NonnullRefPtr<StyleValue> color)
  1027. : StyleValue(Type::TextDecoration)
  1028. , m_line(line)
  1029. , m_style(style)
  1030. , m_color(color)
  1031. {
  1032. }
  1033. NonnullRefPtr<StyleValue> m_line;
  1034. NonnullRefPtr<StyleValue> m_style;
  1035. NonnullRefPtr<StyleValue> m_color;
  1036. };
  1037. class TransformationStyleValue final : public StyleValue {
  1038. public:
  1039. static NonnullRefPtr<TransformationStyleValue> create(CSS::TransformFunction transform_function, NonnullRefPtrVector<StyleValue>&& values)
  1040. {
  1041. return adopt_ref(*new TransformationStyleValue(transform_function, move(values)));
  1042. }
  1043. virtual ~TransformationStyleValue() override { }
  1044. CSS::TransformFunction transform_function() const { return m_transform_function; }
  1045. NonnullRefPtrVector<StyleValue> values() const { return m_values; }
  1046. virtual String to_string() const override
  1047. {
  1048. return String::formatted("TransformationStyleValue");
  1049. }
  1050. private:
  1051. TransformationStyleValue(CSS::TransformFunction transform_function, NonnullRefPtrVector<StyleValue>&& values)
  1052. : StyleValue(Type::Transformation)
  1053. , m_transform_function(transform_function)
  1054. , m_values(move(values))
  1055. {
  1056. }
  1057. CSS::TransformFunction m_transform_function;
  1058. NonnullRefPtrVector<StyleValue> m_values;
  1059. };
  1060. class UnsetStyleValue final : public StyleValue {
  1061. public:
  1062. static NonnullRefPtr<UnsetStyleValue> the()
  1063. {
  1064. static NonnullRefPtr<UnsetStyleValue> instance = adopt_ref(*new UnsetStyleValue);
  1065. return instance;
  1066. }
  1067. virtual ~UnsetStyleValue() override { }
  1068. String to_string() const override { return "unset"; }
  1069. private:
  1070. UnsetStyleValue()
  1071. : StyleValue(Type::Unset)
  1072. {
  1073. }
  1074. };
  1075. class StyleValueList final : public StyleValue {
  1076. public:
  1077. static NonnullRefPtr<StyleValueList> create(NonnullRefPtrVector<StyleValue>&& values) { return adopt_ref(*new StyleValueList(move(values))); }
  1078. NonnullRefPtrVector<StyleValue> const& values() const { return m_values; }
  1079. virtual String to_string() const
  1080. {
  1081. StringBuilder builder;
  1082. builder.appendff("List[{}](", m_values.size());
  1083. for (size_t i = 0; i < m_values.size(); ++i) {
  1084. if (i)
  1085. builder.append(',');
  1086. builder.append(m_values[i].to_string());
  1087. }
  1088. builder.append(')');
  1089. return builder.to_string();
  1090. }
  1091. private:
  1092. StyleValueList(NonnullRefPtrVector<StyleValue>&& values)
  1093. : StyleValue(Type::ValueList)
  1094. , m_values(move(values))
  1095. {
  1096. }
  1097. NonnullRefPtrVector<StyleValue> m_values;
  1098. };
  1099. }