StyleValue.h 56 KB

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