StyleValue.h 45 KB

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