StyleValue.h 55 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707
  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. virtual bool equals(StyleValue const& other) const override
  529. {
  530. if (type() != other.type())
  531. return false;
  532. auto& other_value = static_cast<BackgroundRepeatStyleValue const&>(other);
  533. return m_repeat_x == other_value.m_repeat_x && m_repeat_y == other_value.m_repeat_y;
  534. }
  535. private:
  536. BackgroundRepeatStyleValue(Repeat repeat_x, Repeat repeat_y)
  537. : StyleValue(Type::BackgroundRepeat)
  538. , m_repeat_x(repeat_x)
  539. , m_repeat_y(repeat_y)
  540. {
  541. }
  542. Repeat m_repeat_x;
  543. Repeat m_repeat_y;
  544. };
  545. // NOTE: This is not used for identifier sizes, like `cover` and `contain`.
  546. class BackgroundSizeStyleValue final : public StyleValue {
  547. public:
  548. static NonnullRefPtr<BackgroundSizeStyleValue> create(LengthPercentage size_x, LengthPercentage size_y)
  549. {
  550. return adopt_ref(*new BackgroundSizeStyleValue(size_x, size_y));
  551. }
  552. virtual ~BackgroundSizeStyleValue() override { }
  553. LengthPercentage size_x() const { return m_size_x; }
  554. LengthPercentage size_y() const { return m_size_y; }
  555. virtual String to_string() const override;
  556. virtual bool equals(StyleValue const& other) const override
  557. {
  558. if (type() != other.type())
  559. return false;
  560. auto& other_value = static_cast<BackgroundSizeStyleValue const&>(other);
  561. return m_size_x == other_value.m_size_x && m_size_y == other_value.m_size_y;
  562. }
  563. private:
  564. BackgroundSizeStyleValue(LengthPercentage size_x, LengthPercentage size_y)
  565. : StyleValue(Type::BackgroundSize)
  566. , m_size_x(size_x)
  567. , m_size_y(size_y)
  568. {
  569. }
  570. LengthPercentage m_size_x;
  571. LengthPercentage m_size_y;
  572. };
  573. class BorderStyleValue final : public StyleValue {
  574. public:
  575. static NonnullRefPtr<BorderStyleValue> create(
  576. NonnullRefPtr<StyleValue> border_width,
  577. NonnullRefPtr<StyleValue> border_style,
  578. NonnullRefPtr<StyleValue> border_color)
  579. {
  580. return adopt_ref(*new BorderStyleValue(border_width, border_style, border_color));
  581. }
  582. virtual ~BorderStyleValue() override { }
  583. NonnullRefPtr<StyleValue> border_width() const { return m_border_width; }
  584. NonnullRefPtr<StyleValue> border_style() const { return m_border_style; }
  585. NonnullRefPtr<StyleValue> border_color() const { return m_border_color; }
  586. virtual String to_string() const override;
  587. private:
  588. BorderStyleValue(
  589. NonnullRefPtr<StyleValue> border_width,
  590. NonnullRefPtr<StyleValue> border_style,
  591. NonnullRefPtr<StyleValue> border_color)
  592. : StyleValue(Type::Border)
  593. , m_border_width(border_width)
  594. , m_border_style(border_style)
  595. , m_border_color(border_color)
  596. {
  597. }
  598. NonnullRefPtr<StyleValue> m_border_width;
  599. NonnullRefPtr<StyleValue> m_border_style;
  600. NonnullRefPtr<StyleValue> m_border_color;
  601. };
  602. class BorderRadiusStyleValue final : public StyleValue {
  603. public:
  604. static NonnullRefPtr<BorderRadiusStyleValue> create(LengthPercentage const& horizontal_radius, LengthPercentage const& vertical_radius)
  605. {
  606. return adopt_ref(*new BorderRadiusStyleValue(horizontal_radius, vertical_radius));
  607. }
  608. virtual ~BorderRadiusStyleValue() override { }
  609. LengthPercentage const& horizontal_radius() const { return m_horizontal_radius; }
  610. LengthPercentage const& vertical_radius() const { return m_vertical_radius; }
  611. bool is_elliptical() const { return m_is_elliptical; }
  612. virtual String to_string() const override;
  613. virtual bool equals(StyleValue const& other) const override
  614. {
  615. if (type() != other.type())
  616. return false;
  617. auto& other_value = static_cast<BorderRadiusStyleValue const&>(other);
  618. return m_is_elliptical == other_value.m_is_elliptical
  619. && m_horizontal_radius == other_value.m_horizontal_radius
  620. && m_vertical_radius == other_value.m_vertical_radius;
  621. }
  622. private:
  623. BorderRadiusStyleValue(LengthPercentage const& horizontal_radius, LengthPercentage const& vertical_radius)
  624. : StyleValue(Type::BorderRadius)
  625. , m_horizontal_radius(horizontal_radius)
  626. , m_vertical_radius(vertical_radius)
  627. {
  628. m_is_elliptical = (m_horizontal_radius != m_vertical_radius);
  629. }
  630. virtual NonnullRefPtr<StyleValue> absolutized(Gfx::IntRect const& viewport_rect, Gfx::FontMetrics const& font_metrics, float font_size, float root_font_size) const override;
  631. bool m_is_elliptical;
  632. LengthPercentage m_horizontal_radius;
  633. LengthPercentage m_vertical_radius;
  634. };
  635. class BoxShadowStyleValue final : public StyleValue {
  636. public:
  637. static NonnullRefPtr<BoxShadowStyleValue>
  638. create(Color const& color, Length const& offset_x, Length const& offset_y, Length const& blur_radius, Length const& spread_distance, BoxShadowPlacement placement)
  639. {
  640. return adopt_ref(*new BoxShadowStyleValue(color, offset_x, offset_y, blur_radius, spread_distance, placement));
  641. }
  642. virtual ~BoxShadowStyleValue() override { }
  643. Color const& color() const { return m_color; }
  644. Length const& offset_x() const { return m_offset_x; }
  645. Length const& offset_y() const { return m_offset_y; }
  646. Length const& blur_radius() const { return m_blur_radius; }
  647. Length const& spread_distance() const { return m_spread_distance; }
  648. BoxShadowPlacement placement() const { return m_placement; }
  649. virtual String to_string() const override;
  650. virtual bool equals(StyleValue const& other) const override
  651. {
  652. if (type() != other.type())
  653. return false;
  654. auto& other_value = static_cast<BoxShadowStyleValue const&>(other);
  655. return m_color == other_value.m_color
  656. && m_offset_x == other_value.m_offset_x
  657. && m_offset_y == other_value.m_offset_y
  658. && m_blur_radius == other_value.m_blur_radius
  659. && m_spread_distance == other_value.m_spread_distance
  660. && m_placement == other_value.m_placement;
  661. }
  662. private:
  663. explicit BoxShadowStyleValue(Color const& color, Length const& offset_x, Length const& offset_y, Length const& blur_radius, Length const& spread_distance, BoxShadowPlacement placement)
  664. : StyleValue(Type::BoxShadow)
  665. , m_color(color)
  666. , m_offset_x(offset_x)
  667. , m_offset_y(offset_y)
  668. , m_blur_radius(blur_radius)
  669. , m_spread_distance(spread_distance)
  670. , m_placement(placement)
  671. {
  672. }
  673. virtual NonnullRefPtr<StyleValue> absolutized(Gfx::IntRect const& viewport_rect, Gfx::FontMetrics const& font_metrics, float font_size, float root_font_size) const override;
  674. Color m_color;
  675. Length m_offset_x;
  676. Length m_offset_y;
  677. Length m_blur_radius;
  678. Length m_spread_distance;
  679. BoxShadowPlacement m_placement;
  680. };
  681. class CalculatedStyleValue : public StyleValue {
  682. public:
  683. enum class ResolvedType {
  684. Angle,
  685. Frequency,
  686. Integer,
  687. Length,
  688. Number,
  689. Percentage,
  690. Time,
  691. };
  692. enum class SumOperation {
  693. Add,
  694. Subtract,
  695. };
  696. enum class ProductOperation {
  697. Multiply,
  698. Divide,
  699. };
  700. struct Number {
  701. bool is_integer;
  702. float value;
  703. };
  704. using PercentageBasis = Variant<Empty, Angle, Frequency, Length, Time>;
  705. class CalculationResult {
  706. public:
  707. using Value = Variant<Number, Angle, Frequency, Length, Percentage, Time>;
  708. CalculationResult(Value value)
  709. : m_value(move(value))
  710. {
  711. }
  712. void add(CalculationResult const& other, Layout::Node const*, PercentageBasis const& percentage_basis);
  713. void subtract(CalculationResult const& other, Layout::Node const*, PercentageBasis const& percentage_basis);
  714. void multiply_by(CalculationResult const& other, Layout::Node const*);
  715. void divide_by(CalculationResult const& other, Layout::Node const*);
  716. Value const& value() const { return m_value; }
  717. private:
  718. void add_or_subtract_internal(SumOperation op, CalculationResult const& other, Layout::Node const*, PercentageBasis const& percentage_basis);
  719. Value m_value;
  720. };
  721. struct CalcSum;
  722. struct CalcSumPartWithOperator;
  723. struct CalcProduct;
  724. struct CalcProductPartWithOperator;
  725. struct CalcNumberSum;
  726. struct CalcNumberSumPartWithOperator;
  727. struct CalcNumberProduct;
  728. struct CalcNumberProductPartWithOperator;
  729. struct CalcNumberValue {
  730. Variant<Number, NonnullOwnPtr<CalcNumberSum>> value;
  731. String to_string() const;
  732. Optional<ResolvedType> resolved_type() const;
  733. CalculationResult resolve(Layout::Node const*, PercentageBasis const& percentage_basis) const;
  734. };
  735. struct CalcValue {
  736. Variant<Number, Angle, Frequency, Length, Percentage, Time, NonnullOwnPtr<CalcSum>> value;
  737. String to_string() const;
  738. Optional<ResolvedType> resolved_type() const;
  739. CalculationResult resolve(Layout::Node const*, PercentageBasis const& percentage_basis) const;
  740. };
  741. // This represents that: https://www.w3.org/TR/css-values-3/#calc-syntax
  742. struct CalcSum {
  743. CalcSum(NonnullOwnPtr<CalcProduct> first_calc_product, NonnullOwnPtrVector<CalcSumPartWithOperator> additional)
  744. : first_calc_product(move(first_calc_product))
  745. , zero_or_more_additional_calc_products(move(additional)) {};
  746. NonnullOwnPtr<CalcProduct> first_calc_product;
  747. NonnullOwnPtrVector<CalcSumPartWithOperator> zero_or_more_additional_calc_products;
  748. String to_string() const;
  749. Optional<ResolvedType> resolved_type() const;
  750. CalculationResult resolve(Layout::Node const*, PercentageBasis const& percentage_basis) const;
  751. };
  752. struct CalcNumberSum {
  753. CalcNumberSum(NonnullOwnPtr<CalcNumberProduct> first_calc_number_product, NonnullOwnPtrVector<CalcNumberSumPartWithOperator> additional)
  754. : first_calc_number_product(move(first_calc_number_product))
  755. , zero_or_more_additional_calc_number_products(move(additional)) {};
  756. NonnullOwnPtr<CalcNumberProduct> first_calc_number_product;
  757. NonnullOwnPtrVector<CalcNumberSumPartWithOperator> zero_or_more_additional_calc_number_products;
  758. String to_string() const;
  759. Optional<ResolvedType> resolved_type() const;
  760. CalculationResult resolve(Layout::Node const*, PercentageBasis const& percentage_basis) const;
  761. };
  762. struct CalcProduct {
  763. CalcValue first_calc_value;
  764. NonnullOwnPtrVector<CalcProductPartWithOperator> zero_or_more_additional_calc_values;
  765. String to_string() const;
  766. Optional<ResolvedType> resolved_type() const;
  767. CalculationResult resolve(Layout::Node const*, PercentageBasis const& percentage_basis) const;
  768. };
  769. struct CalcSumPartWithOperator {
  770. CalcSumPartWithOperator(SumOperation op, NonnullOwnPtr<CalcProduct> calc_product)
  771. : op(op)
  772. , value(move(calc_product)) {};
  773. SumOperation op;
  774. NonnullOwnPtr<CalcProduct> value;
  775. String to_string() const;
  776. Optional<ResolvedType> resolved_type() const;
  777. CalculationResult resolve(Layout::Node const*, PercentageBasis const& percentage_basis) const;
  778. };
  779. struct CalcProductPartWithOperator {
  780. ProductOperation op;
  781. Variant<CalcValue, CalcNumberValue> value;
  782. String to_string() const;
  783. Optional<ResolvedType> resolved_type() const;
  784. CalculationResult resolve(Layout::Node const*, PercentageBasis const& percentage_basis) const;
  785. };
  786. struct CalcNumberProduct {
  787. CalcNumberValue first_calc_number_value;
  788. NonnullOwnPtrVector<CalcNumberProductPartWithOperator> zero_or_more_additional_calc_number_values;
  789. String to_string() const;
  790. Optional<ResolvedType> resolved_type() const;
  791. CalculationResult resolve(Layout::Node const*, PercentageBasis const& percentage_basis) const;
  792. };
  793. struct CalcNumberProductPartWithOperator {
  794. ProductOperation op;
  795. CalcNumberValue value;
  796. String to_string() const;
  797. Optional<ResolvedType> resolved_type() const;
  798. CalculationResult resolve(Layout::Node const*, PercentageBasis const& percentage_basis) const;
  799. };
  800. struct CalcNumberSumPartWithOperator {
  801. CalcNumberSumPartWithOperator(SumOperation op, NonnullOwnPtr<CalcNumberProduct> calc_number_product)
  802. : op(op)
  803. , value(move(calc_number_product)) {};
  804. SumOperation op;
  805. NonnullOwnPtr<CalcNumberProduct> value;
  806. String to_string() const;
  807. Optional<ResolvedType> resolved_type() const;
  808. CalculationResult resolve(Layout::Node const*, PercentageBasis const& percentage_basis) const;
  809. };
  810. static NonnullRefPtr<CalculatedStyleValue> create(NonnullOwnPtr<CalcSum> calc_sum, ResolvedType resolved_type)
  811. {
  812. return adopt_ref(*new CalculatedStyleValue(move(calc_sum), resolved_type));
  813. }
  814. String to_string() const override;
  815. ResolvedType resolved_type() const { return m_resolved_type; }
  816. NonnullOwnPtr<CalcSum> const& expression() const { return m_expression; }
  817. Optional<Angle> resolve_angle() const;
  818. Optional<AnglePercentage> resolve_angle_percentage(Angle const& percentage_basis) const;
  819. Optional<Frequency> resolve_frequency() const;
  820. Optional<FrequencyPercentage> resolve_frequency_percentage(Frequency const& percentage_basis) const;
  821. Optional<Length> resolve_length(Layout::Node const& layout_node) const;
  822. Optional<LengthPercentage> resolve_length_percentage(Layout::Node const&, Length const& percentage_basis) const;
  823. Optional<Percentage> resolve_percentage() const;
  824. Optional<Time> resolve_time() const;
  825. Optional<TimePercentage> resolve_time_percentage(Time const& percentage_basis) const;
  826. Optional<float> resolve_number();
  827. Optional<i64> resolve_integer();
  828. private:
  829. explicit CalculatedStyleValue(NonnullOwnPtr<CalcSum> calc_sum, ResolvedType resolved_type)
  830. : StyleValue(Type::Calculated)
  831. , m_resolved_type(resolved_type)
  832. , m_expression(move(calc_sum))
  833. {
  834. }
  835. ResolvedType m_resolved_type;
  836. NonnullOwnPtr<CalcSum> m_expression;
  837. };
  838. class ColorStyleValue : public StyleValue {
  839. public:
  840. static NonnullRefPtr<ColorStyleValue> create(Color color);
  841. virtual ~ColorStyleValue() override { }
  842. Color color() const { return m_color; }
  843. virtual String to_string() const override;
  844. virtual bool has_color() const override { return true; }
  845. virtual Color to_color(Layout::NodeWithStyle const&) const override { return m_color; }
  846. virtual bool equals(StyleValue const& other) const override
  847. {
  848. if (type() != other.type())
  849. return false;
  850. return m_color == static_cast<const ColorStyleValue&>(other).m_color;
  851. }
  852. private:
  853. explicit ColorStyleValue(Color color)
  854. : StyleValue(Type::Color)
  855. , m_color(color)
  856. {
  857. }
  858. Color m_color;
  859. };
  860. class CombinedBorderRadiusStyleValue final : public StyleValue {
  861. public:
  862. static NonnullRefPtr<CombinedBorderRadiusStyleValue> create(NonnullRefPtr<BorderRadiusStyleValue> top_left, NonnullRefPtr<BorderRadiusStyleValue> top_right, NonnullRefPtr<BorderRadiusStyleValue> bottom_right, NonnullRefPtr<BorderRadiusStyleValue> bottom_left)
  863. {
  864. return adopt_ref(*new CombinedBorderRadiusStyleValue(top_left, top_right, bottom_right, bottom_left));
  865. }
  866. virtual ~CombinedBorderRadiusStyleValue() override { }
  867. NonnullRefPtr<BorderRadiusStyleValue> top_left() const { return m_top_left; }
  868. NonnullRefPtr<BorderRadiusStyleValue> top_right() const { return m_top_right; }
  869. NonnullRefPtr<BorderRadiusStyleValue> bottom_right() const { return m_bottom_right; }
  870. NonnullRefPtr<BorderRadiusStyleValue> bottom_left() const { return m_bottom_left; }
  871. virtual String to_string() const override;
  872. private:
  873. CombinedBorderRadiusStyleValue(NonnullRefPtr<BorderRadiusStyleValue> top_left, NonnullRefPtr<BorderRadiusStyleValue> top_right, NonnullRefPtr<BorderRadiusStyleValue> bottom_right, NonnullRefPtr<BorderRadiusStyleValue> bottom_left)
  874. : StyleValue(Type::CombinedBorderRadius)
  875. , m_top_left(top_left)
  876. , m_top_right(top_right)
  877. , m_bottom_right(bottom_right)
  878. , m_bottom_left(bottom_left)
  879. {
  880. }
  881. NonnullRefPtr<BorderRadiusStyleValue> m_top_left;
  882. NonnullRefPtr<BorderRadiusStyleValue> m_top_right;
  883. NonnullRefPtr<BorderRadiusStyleValue> m_bottom_right;
  884. NonnullRefPtr<BorderRadiusStyleValue> m_bottom_left;
  885. };
  886. class ContentStyleValue final : public StyleValue {
  887. public:
  888. static NonnullRefPtr<ContentStyleValue> create(NonnullRefPtr<StyleValueList> content, RefPtr<StyleValueList> alt_text)
  889. {
  890. return adopt_ref(*new ContentStyleValue(move(content), move(alt_text)));
  891. }
  892. StyleValueList const& content() const { return *m_content; }
  893. bool has_alt_text() const { return !m_alt_text.is_null(); }
  894. StyleValueList const* alt_text() const { return m_alt_text; }
  895. virtual String to_string() const override;
  896. private:
  897. ContentStyleValue(NonnullRefPtr<StyleValueList> content, RefPtr<StyleValueList> alt_text)
  898. : StyleValue(Type::Content)
  899. , m_content(move(content))
  900. , m_alt_text(move(alt_text))
  901. {
  902. }
  903. NonnullRefPtr<StyleValueList> m_content;
  904. RefPtr<StyleValueList> m_alt_text;
  905. };
  906. class FlexStyleValue final : public StyleValue {
  907. public:
  908. static NonnullRefPtr<FlexStyleValue> create(
  909. NonnullRefPtr<StyleValue> grow,
  910. NonnullRefPtr<StyleValue> shrink,
  911. NonnullRefPtr<StyleValue> basis)
  912. {
  913. return adopt_ref(*new FlexStyleValue(grow, shrink, basis));
  914. }
  915. virtual ~FlexStyleValue() override { }
  916. NonnullRefPtr<StyleValue> grow() const { return m_grow; }
  917. NonnullRefPtr<StyleValue> shrink() const { return m_shrink; }
  918. NonnullRefPtr<StyleValue> basis() const { return m_basis; }
  919. virtual String to_string() const override;
  920. private:
  921. FlexStyleValue(
  922. NonnullRefPtr<StyleValue> grow,
  923. NonnullRefPtr<StyleValue> shrink,
  924. NonnullRefPtr<StyleValue> basis)
  925. : StyleValue(Type::Flex)
  926. , m_grow(grow)
  927. , m_shrink(shrink)
  928. , m_basis(basis)
  929. {
  930. }
  931. NonnullRefPtr<StyleValue> m_grow;
  932. NonnullRefPtr<StyleValue> m_shrink;
  933. NonnullRefPtr<StyleValue> m_basis;
  934. };
  935. class FlexFlowStyleValue final : public StyleValue {
  936. public:
  937. static NonnullRefPtr<FlexFlowStyleValue> create(NonnullRefPtr<StyleValue> flex_direction, NonnullRefPtr<StyleValue> flex_wrap)
  938. {
  939. return adopt_ref(*new FlexFlowStyleValue(flex_direction, flex_wrap));
  940. }
  941. virtual ~FlexFlowStyleValue() override { }
  942. NonnullRefPtr<StyleValue> flex_direction() const { return m_flex_direction; }
  943. NonnullRefPtr<StyleValue> flex_wrap() const { return m_flex_wrap; }
  944. virtual String to_string() const override;
  945. private:
  946. FlexFlowStyleValue(NonnullRefPtr<StyleValue> flex_direction, NonnullRefPtr<StyleValue> flex_wrap)
  947. : StyleValue(Type::FlexFlow)
  948. , m_flex_direction(flex_direction)
  949. , m_flex_wrap(flex_wrap)
  950. {
  951. }
  952. NonnullRefPtr<StyleValue> m_flex_direction;
  953. NonnullRefPtr<StyleValue> m_flex_wrap;
  954. };
  955. class FontStyleValue final : public StyleValue {
  956. public:
  957. 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)); }
  958. virtual ~FontStyleValue() override { }
  959. NonnullRefPtr<StyleValue> font_style() const { return m_font_style; }
  960. NonnullRefPtr<StyleValue> font_weight() const { return m_font_weight; }
  961. NonnullRefPtr<StyleValue> font_size() const { return m_font_size; }
  962. NonnullRefPtr<StyleValue> line_height() const { return m_line_height; }
  963. NonnullRefPtr<StyleValue> font_families() const { return m_font_families; }
  964. virtual String to_string() const override;
  965. private:
  966. FontStyleValue(NonnullRefPtr<StyleValue> font_style, NonnullRefPtr<StyleValue> font_weight, NonnullRefPtr<StyleValue> font_size, NonnullRefPtr<StyleValue> line_height, NonnullRefPtr<StyleValue> font_families)
  967. : StyleValue(Type::Font)
  968. , m_font_style(font_style)
  969. , m_font_weight(font_weight)
  970. , m_font_size(font_size)
  971. , m_line_height(line_height)
  972. , m_font_families(font_families)
  973. {
  974. }
  975. NonnullRefPtr<StyleValue> m_font_style;
  976. NonnullRefPtr<StyleValue> m_font_weight;
  977. NonnullRefPtr<StyleValue> m_font_size;
  978. NonnullRefPtr<StyleValue> m_line_height;
  979. NonnullRefPtr<StyleValue> m_font_families;
  980. // FIXME: Implement font-stretch and font-variant.
  981. };
  982. class FrequencyStyleValue : public StyleValue {
  983. public:
  984. static NonnullRefPtr<FrequencyStyleValue> create(Frequency frequency)
  985. {
  986. return adopt_ref(*new FrequencyStyleValue(move(frequency)));
  987. }
  988. virtual ~FrequencyStyleValue() override { }
  989. Frequency const& frequency() const { return m_frequency; }
  990. virtual String to_string() const override { return m_frequency.to_string(); }
  991. virtual bool equals(StyleValue const& other) const override
  992. {
  993. if (type() != other.type())
  994. return false;
  995. return m_frequency == static_cast<FrequencyStyleValue const&>(other).m_frequency;
  996. }
  997. private:
  998. explicit FrequencyStyleValue(Frequency frequency)
  999. : StyleValue(Type::Frequency)
  1000. , m_frequency(move(frequency))
  1001. {
  1002. }
  1003. Frequency m_frequency;
  1004. };
  1005. class IdentifierStyleValue final : public StyleValue {
  1006. public:
  1007. static NonnullRefPtr<IdentifierStyleValue> create(CSS::ValueID id)
  1008. {
  1009. return adopt_ref(*new IdentifierStyleValue(id));
  1010. }
  1011. virtual ~IdentifierStyleValue() override { }
  1012. CSS::ValueID id() const { return m_id; }
  1013. virtual bool has_auto() const override { return m_id == ValueID::Auto; }
  1014. virtual bool has_identifier() const override { return true; }
  1015. virtual CSS::ValueID to_identifier() const override { return m_id; }
  1016. virtual bool has_color() const override;
  1017. virtual Color to_color(Layout::NodeWithStyle const& node) const override;
  1018. virtual String to_string() const override;
  1019. virtual bool equals(StyleValue const& other) const override
  1020. {
  1021. if (type() != other.type())
  1022. return false;
  1023. return m_id == static_cast<const IdentifierStyleValue&>(other).m_id;
  1024. }
  1025. private:
  1026. explicit IdentifierStyleValue(CSS::ValueID id)
  1027. : StyleValue(Type::Identifier)
  1028. , m_id(id)
  1029. {
  1030. }
  1031. CSS::ValueID m_id { CSS::ValueID::Invalid };
  1032. };
  1033. class ImageStyleValue final
  1034. : public StyleValue
  1035. , public ImageResourceClient {
  1036. public:
  1037. static NonnullRefPtr<ImageStyleValue> create(AK::URL const& url) { return adopt_ref(*new ImageStyleValue(url)); }
  1038. virtual ~ImageStyleValue() override { }
  1039. virtual String to_string() const override;
  1040. void load_bitmap(DOM::Document& document);
  1041. Gfx::Bitmap const* bitmap() const { return m_bitmap; }
  1042. private:
  1043. ImageStyleValue(AK::URL const&);
  1044. // ^ResourceClient
  1045. virtual void resource_did_load() override;
  1046. AK::URL m_url;
  1047. WeakPtr<DOM::Document> m_document;
  1048. RefPtr<Gfx::Bitmap> m_bitmap;
  1049. };
  1050. class InheritStyleValue final : public StyleValue {
  1051. public:
  1052. static NonnullRefPtr<InheritStyleValue> the()
  1053. {
  1054. static NonnullRefPtr<InheritStyleValue> instance = adopt_ref(*new InheritStyleValue);
  1055. return instance;
  1056. }
  1057. virtual ~InheritStyleValue() override { }
  1058. String to_string() const override { return "inherit"; }
  1059. private:
  1060. InheritStyleValue()
  1061. : StyleValue(Type::Inherit)
  1062. {
  1063. }
  1064. };
  1065. class InitialStyleValue final : public StyleValue {
  1066. public:
  1067. static NonnullRefPtr<InitialStyleValue> the()
  1068. {
  1069. static NonnullRefPtr<InitialStyleValue> instance = adopt_ref(*new InitialStyleValue);
  1070. return instance;
  1071. }
  1072. virtual ~InitialStyleValue() override { }
  1073. String to_string() const override { return "initial"; }
  1074. private:
  1075. InitialStyleValue()
  1076. : StyleValue(Type::Initial)
  1077. {
  1078. }
  1079. };
  1080. class LengthStyleValue : public StyleValue {
  1081. public:
  1082. static NonnullRefPtr<LengthStyleValue> create(Length const&);
  1083. virtual ~LengthStyleValue() override { }
  1084. Length const& length() const { return m_length; }
  1085. virtual bool has_auto() const override { return m_length.is_auto(); }
  1086. virtual bool has_length() const override { return true; }
  1087. virtual bool has_identifier() const override { return has_auto(); }
  1088. virtual String to_string() const override { return m_length.to_string(); }
  1089. virtual Length to_length() const override { return m_length; }
  1090. virtual ValueID to_identifier() const override { return has_auto() ? ValueID::Auto : ValueID::Invalid; }
  1091. virtual NonnullRefPtr<StyleValue> absolutized(Gfx::IntRect const& viewport_rect, Gfx::FontMetrics const& font_metrics, float font_size, float root_font_size) const override;
  1092. virtual bool equals(StyleValue const& other) const override
  1093. {
  1094. if (type() != other.type())
  1095. return false;
  1096. return m_length == static_cast<LengthStyleValue const&>(other).m_length;
  1097. }
  1098. private:
  1099. explicit LengthStyleValue(Length const& length)
  1100. : StyleValue(Type::Length)
  1101. , m_length(length)
  1102. {
  1103. }
  1104. Length m_length;
  1105. };
  1106. class ListStyleStyleValue final : public StyleValue {
  1107. public:
  1108. static NonnullRefPtr<ListStyleStyleValue> create(
  1109. NonnullRefPtr<StyleValue> position,
  1110. NonnullRefPtr<StyleValue> image,
  1111. NonnullRefPtr<StyleValue> style_type)
  1112. {
  1113. return adopt_ref(*new ListStyleStyleValue(position, image, style_type));
  1114. }
  1115. virtual ~ListStyleStyleValue() override { }
  1116. NonnullRefPtr<StyleValue> position() const { return m_position; }
  1117. NonnullRefPtr<StyleValue> image() const { return m_image; }
  1118. NonnullRefPtr<StyleValue> style_type() const { return m_style_type; }
  1119. virtual String to_string() const override;
  1120. private:
  1121. ListStyleStyleValue(
  1122. NonnullRefPtr<StyleValue> position,
  1123. NonnullRefPtr<StyleValue> image,
  1124. NonnullRefPtr<StyleValue> style_type)
  1125. : StyleValue(Type::ListStyle)
  1126. , m_position(position)
  1127. , m_image(image)
  1128. , m_style_type(style_type)
  1129. {
  1130. }
  1131. NonnullRefPtr<StyleValue> m_position;
  1132. NonnullRefPtr<StyleValue> m_image;
  1133. NonnullRefPtr<StyleValue> m_style_type;
  1134. };
  1135. class NumericStyleValue : public StyleValue {
  1136. public:
  1137. static NonnullRefPtr<NumericStyleValue> create_float(float value)
  1138. {
  1139. return adopt_ref(*new NumericStyleValue(value));
  1140. }
  1141. static NonnullRefPtr<NumericStyleValue> create_integer(i64 value)
  1142. {
  1143. return adopt_ref(*new NumericStyleValue(value));
  1144. }
  1145. virtual bool has_length() const override { return to_number() == 0; }
  1146. virtual Length to_length() const override { return Length(0, Length::Type::Px); }
  1147. virtual bool has_number() const override { return true; }
  1148. virtual float to_number() const override
  1149. {
  1150. return m_value.visit(
  1151. [](float value) { return value; },
  1152. [](i64 value) { return (float)value; });
  1153. }
  1154. virtual bool has_integer() const override { return m_value.has<i64>(); }
  1155. virtual float to_integer() const override { return m_value.get<i64>(); }
  1156. virtual String to_string() const override;
  1157. virtual bool equals(StyleValue const& other) const override
  1158. {
  1159. if (type() != other.type())
  1160. return false;
  1161. if (has_integer() != other.has_integer())
  1162. return false;
  1163. if (has_integer())
  1164. return m_value.get<i64>() == static_cast<NumericStyleValue const&>(other).m_value.get<i64>();
  1165. return m_value.get<float>() == static_cast<NumericStyleValue const&>(other).m_value.get<float>();
  1166. }
  1167. private:
  1168. explicit NumericStyleValue(Variant<float, i64> value)
  1169. : StyleValue(Type::Numeric)
  1170. , m_value(move(value))
  1171. {
  1172. }
  1173. Variant<float, i64> m_value { (i64)0 };
  1174. };
  1175. class OverflowStyleValue final : public StyleValue {
  1176. public:
  1177. static NonnullRefPtr<OverflowStyleValue> create(NonnullRefPtr<StyleValue> overflow_x, NonnullRefPtr<StyleValue> overflow_y)
  1178. {
  1179. return adopt_ref(*new OverflowStyleValue(overflow_x, overflow_y));
  1180. }
  1181. virtual ~OverflowStyleValue() override { }
  1182. NonnullRefPtr<StyleValue> overflow_x() const { return m_overflow_x; }
  1183. NonnullRefPtr<StyleValue> overflow_y() const { return m_overflow_y; }
  1184. virtual String to_string() const override;
  1185. private:
  1186. OverflowStyleValue(NonnullRefPtr<StyleValue> overflow_x, NonnullRefPtr<StyleValue> overflow_y)
  1187. : StyleValue(Type::Overflow)
  1188. , m_overflow_x(overflow_x)
  1189. , m_overflow_y(overflow_y)
  1190. {
  1191. }
  1192. NonnullRefPtr<StyleValue> m_overflow_x;
  1193. NonnullRefPtr<StyleValue> m_overflow_y;
  1194. };
  1195. class PercentageStyleValue final : public StyleValue {
  1196. public:
  1197. static NonnullRefPtr<PercentageStyleValue> create(Percentage percentage)
  1198. {
  1199. return adopt_ref(*new PercentageStyleValue(move(percentage)));
  1200. }
  1201. virtual ~PercentageStyleValue() override { }
  1202. Percentage const& percentage() const { return m_percentage; }
  1203. Percentage& percentage() { return m_percentage; }
  1204. virtual String to_string() const override;
  1205. private:
  1206. PercentageStyleValue(Percentage&& percentage)
  1207. : StyleValue(Type::Percentage)
  1208. , m_percentage(percentage)
  1209. {
  1210. }
  1211. Percentage m_percentage;
  1212. };
  1213. class PositionStyleValue final : public StyleValue {
  1214. public:
  1215. static NonnullRefPtr<PositionStyleValue> create(PositionEdge edge_x, LengthPercentage const& offset_x, PositionEdge edge_y, LengthPercentage const& offset_y)
  1216. {
  1217. return adopt_ref(*new PositionStyleValue(edge_x, offset_x, edge_y, offset_y));
  1218. }
  1219. virtual ~PositionStyleValue() override { }
  1220. PositionEdge edge_x() const { return m_edge_x; }
  1221. LengthPercentage const& offset_x() const { return m_offset_x; }
  1222. PositionEdge edge_y() const { return m_edge_y; }
  1223. LengthPercentage const& offset_y() const { return m_offset_y; }
  1224. virtual String to_string() const override;
  1225. virtual bool equals(StyleValue const& other) const override
  1226. {
  1227. if (type() != other.type())
  1228. return false;
  1229. auto const& typed_other = static_cast<PositionStyleValue const&>(other);
  1230. return m_edge_x == typed_other.m_edge_x
  1231. && m_offset_x == typed_other.m_offset_x
  1232. && m_edge_y == typed_other.m_edge_y
  1233. && m_offset_y == typed_other.m_offset_y;
  1234. }
  1235. private:
  1236. PositionStyleValue(PositionEdge edge_x, LengthPercentage const& offset_x, PositionEdge edge_y, LengthPercentage const& offset_y)
  1237. : StyleValue(Type::Position)
  1238. , m_edge_x(edge_x)
  1239. , m_offset_x(offset_x)
  1240. , m_edge_y(edge_y)
  1241. , m_offset_y(offset_y)
  1242. {
  1243. }
  1244. PositionEdge m_edge_x;
  1245. LengthPercentage m_offset_x;
  1246. PositionEdge m_edge_y;
  1247. LengthPercentage m_offset_y;
  1248. };
  1249. class ResolutionStyleValue : public StyleValue {
  1250. public:
  1251. static NonnullRefPtr<ResolutionStyleValue> create(Resolution resolution)
  1252. {
  1253. return adopt_ref(*new ResolutionStyleValue(move(resolution)));
  1254. }
  1255. virtual ~ResolutionStyleValue() override { }
  1256. Resolution const& resolution() const { return m_resolution; }
  1257. virtual String to_string() const override { return m_resolution.to_string(); }
  1258. virtual bool equals(StyleValue const& other) const override
  1259. {
  1260. if (type() != other.type())
  1261. return false;
  1262. return m_resolution == static_cast<ResolutionStyleValue const&>(other).m_resolution;
  1263. }
  1264. private:
  1265. explicit ResolutionStyleValue(Resolution resolution)
  1266. : StyleValue(Type::Resolution)
  1267. , m_resolution(move(resolution))
  1268. {
  1269. }
  1270. Resolution m_resolution;
  1271. };
  1272. class StringStyleValue : public StyleValue {
  1273. public:
  1274. static NonnullRefPtr<StringStyleValue> create(String const& string)
  1275. {
  1276. return adopt_ref(*new StringStyleValue(string));
  1277. }
  1278. virtual ~StringStyleValue() override { }
  1279. String to_string() const override { return m_string; }
  1280. private:
  1281. explicit StringStyleValue(String const& string)
  1282. : StyleValue(Type::String)
  1283. , m_string(string)
  1284. {
  1285. }
  1286. String m_string;
  1287. };
  1288. class TextDecorationStyleValue final : public StyleValue {
  1289. public:
  1290. static NonnullRefPtr<TextDecorationStyleValue> create(
  1291. NonnullRefPtr<StyleValue> line,
  1292. NonnullRefPtr<StyleValue> thickness,
  1293. NonnullRefPtr<StyleValue> style,
  1294. NonnullRefPtr<StyleValue> color)
  1295. {
  1296. return adopt_ref(*new TextDecorationStyleValue(line, thickness, style, color));
  1297. }
  1298. virtual ~TextDecorationStyleValue() override { }
  1299. NonnullRefPtr<StyleValue> line() const { return m_line; }
  1300. NonnullRefPtr<StyleValue> thickness() const { return m_thickness; }
  1301. NonnullRefPtr<StyleValue> style() const { return m_style; }
  1302. NonnullRefPtr<StyleValue> color() const { return m_color; }
  1303. virtual String to_string() const override;
  1304. private:
  1305. TextDecorationStyleValue(
  1306. NonnullRefPtr<StyleValue> line,
  1307. NonnullRefPtr<StyleValue> thickness,
  1308. NonnullRefPtr<StyleValue> style,
  1309. NonnullRefPtr<StyleValue> color)
  1310. : StyleValue(Type::TextDecoration)
  1311. , m_line(line)
  1312. , m_thickness(thickness)
  1313. , m_style(style)
  1314. , m_color(color)
  1315. {
  1316. }
  1317. NonnullRefPtr<StyleValue> m_line;
  1318. NonnullRefPtr<StyleValue> m_thickness;
  1319. NonnullRefPtr<StyleValue> m_style;
  1320. NonnullRefPtr<StyleValue> m_color;
  1321. };
  1322. class TimeStyleValue : public StyleValue {
  1323. public:
  1324. static NonnullRefPtr<TimeStyleValue> create(Time time)
  1325. {
  1326. return adopt_ref(*new TimeStyleValue(move(time)));
  1327. }
  1328. virtual ~TimeStyleValue() override { }
  1329. Time const& time() const { return m_time; }
  1330. virtual String to_string() const override { return m_time.to_string(); }
  1331. virtual bool equals(StyleValue const& other) const override
  1332. {
  1333. if (type() != other.type())
  1334. return false;
  1335. return m_time == static_cast<TimeStyleValue const&>(other).m_time;
  1336. }
  1337. private:
  1338. explicit TimeStyleValue(Time time)
  1339. : StyleValue(Type::Time)
  1340. , m_time(move(time))
  1341. {
  1342. }
  1343. Time m_time;
  1344. };
  1345. class TransformationStyleValue final : public StyleValue {
  1346. public:
  1347. static NonnullRefPtr<TransformationStyleValue> create(CSS::TransformFunction transform_function, NonnullRefPtrVector<StyleValue>&& values)
  1348. {
  1349. return adopt_ref(*new TransformationStyleValue(transform_function, move(values)));
  1350. }
  1351. virtual ~TransformationStyleValue() override { }
  1352. CSS::TransformFunction transform_function() const { return m_transform_function; }
  1353. NonnullRefPtrVector<StyleValue> values() const { return m_values; }
  1354. virtual String to_string() const override;
  1355. private:
  1356. TransformationStyleValue(CSS::TransformFunction transform_function, NonnullRefPtrVector<StyleValue>&& values)
  1357. : StyleValue(Type::Transformation)
  1358. , m_transform_function(transform_function)
  1359. , m_values(move(values))
  1360. {
  1361. }
  1362. CSS::TransformFunction m_transform_function;
  1363. NonnullRefPtrVector<StyleValue> m_values;
  1364. };
  1365. class UnresolvedStyleValue final : public StyleValue {
  1366. public:
  1367. static NonnullRefPtr<UnresolvedStyleValue> create(Vector<StyleComponentValueRule>&& values, bool contains_var)
  1368. {
  1369. return adopt_ref(*new UnresolvedStyleValue(move(values), contains_var));
  1370. }
  1371. virtual ~UnresolvedStyleValue() override { }
  1372. virtual String to_string() const override;
  1373. Vector<StyleComponentValueRule> const& values() const { return m_values; }
  1374. bool contains_var() const { return m_contains_var; }
  1375. private:
  1376. UnresolvedStyleValue(Vector<StyleComponentValueRule>&& values, bool contains_var)
  1377. : StyleValue(Type::Unresolved)
  1378. , m_values(move(values))
  1379. , m_contains_var(contains_var)
  1380. {
  1381. }
  1382. Vector<StyleComponentValueRule> m_values;
  1383. bool m_contains_var { false };
  1384. };
  1385. class UnsetStyleValue final : public StyleValue {
  1386. public:
  1387. static NonnullRefPtr<UnsetStyleValue> the()
  1388. {
  1389. static NonnullRefPtr<UnsetStyleValue> instance = adopt_ref(*new UnsetStyleValue);
  1390. return instance;
  1391. }
  1392. virtual ~UnsetStyleValue() override { }
  1393. String to_string() const override { return "unset"; }
  1394. private:
  1395. UnsetStyleValue()
  1396. : StyleValue(Type::Unset)
  1397. {
  1398. }
  1399. };
  1400. class StyleValueList final : public StyleValue {
  1401. public:
  1402. enum class Separator {
  1403. Space,
  1404. Comma,
  1405. };
  1406. static NonnullRefPtr<StyleValueList> create(NonnullRefPtrVector<StyleValue>&& values, Separator separator) { return adopt_ref(*new StyleValueList(move(values), separator)); }
  1407. size_t size() const { return m_values.size(); }
  1408. NonnullRefPtrVector<StyleValue> const& values() const { return m_values; }
  1409. NonnullRefPtr<StyleValue> value_at(size_t i, bool allow_loop) const
  1410. {
  1411. if (allow_loop)
  1412. return m_values[i % size()];
  1413. return m_values[i];
  1414. }
  1415. virtual String to_string() const override;
  1416. virtual bool equals(StyleValue const& other) const override
  1417. {
  1418. if (type() != other.type())
  1419. return false;
  1420. auto& other_value = static_cast<StyleValueList const&>(other);
  1421. if (m_separator != other_value.m_separator)
  1422. return false;
  1423. if (m_values.size() != other_value.m_values.size())
  1424. return false;
  1425. for (size_t i = 0; i < m_values.size(); ++i) {
  1426. if (!m_values[i].equals(other_value.m_values[i]))
  1427. return false;
  1428. }
  1429. return true;
  1430. }
  1431. private:
  1432. StyleValueList(NonnullRefPtrVector<StyleValue>&& values, Separator separator)
  1433. : StyleValue(Type::ValueList)
  1434. , m_separator(separator)
  1435. , m_values(move(values))
  1436. {
  1437. }
  1438. Separator m_separator;
  1439. NonnullRefPtrVector<StyleValue> m_values;
  1440. };
  1441. }
  1442. template<>
  1443. struct AK::Formatter<Web::CSS::StyleValue> : Formatter<StringView> {
  1444. ErrorOr<void> format(FormatBuilder& builder, Web::CSS::StyleValue const& style_value)
  1445. {
  1446. return Formatter<StringView>::format(builder, style_value.to_string());
  1447. }
  1448. };