StyleValue.h 54 KB

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