CSSRuleList.cpp 6.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183
  1. /*
  2. * Copyright (c) 2021-2022, Sam Atkins <atkinssj@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/TypeCasts.h>
  7. #include <LibWeb/Bindings/CSSRuleListPrototype.h>
  8. #include <LibWeb/Bindings/Intrinsics.h>
  9. #include <LibWeb/CSS/CSSImportRule.h>
  10. #include <LibWeb/CSS/CSSMediaRule.h>
  11. #include <LibWeb/CSS/CSSRule.h>
  12. #include <LibWeb/CSS/CSSRuleList.h>
  13. #include <LibWeb/CSS/CSSSupportsRule.h>
  14. #include <LibWeb/CSS/Parser/Parser.h>
  15. #include <LibWeb/HTML/Window.h>
  16. namespace Web::CSS {
  17. CSSRuleList* CSSRuleList::create(JS::Realm& realm, JS::MarkedVector<CSSRule*> const& rules)
  18. {
  19. auto rule_list = realm.heap().allocate<CSSRuleList>(realm, realm);
  20. for (auto* rule : rules)
  21. rule_list->m_rules.append(*rule);
  22. return rule_list;
  23. }
  24. CSSRuleList::CSSRuleList(JS::Realm& realm)
  25. : Bindings::LegacyPlatformObject(Bindings::ensure_web_prototype<Bindings::CSSRuleListPrototype>(realm, "CSSRuleList"))
  26. {
  27. }
  28. CSSRuleList* CSSRuleList::create_empty(JS::Realm& realm)
  29. {
  30. return realm.heap().allocate<CSSRuleList>(realm, realm);
  31. }
  32. void CSSRuleList::visit_edges(Cell::Visitor& visitor)
  33. {
  34. Base::visit_edges(visitor);
  35. for (auto& rule : m_rules)
  36. visitor.visit(&rule);
  37. }
  38. bool CSSRuleList::is_supported_property_index(u32 index) const
  39. {
  40. // The object’s supported property indices are the numbers in the range zero to one less than the number of CSSRule objects represented by the collection.
  41. // If there are no such CSSRule objects, then there are no supported property indices.
  42. return index < m_rules.size();
  43. }
  44. // https://www.w3.org/TR/cssom/#insert-a-css-rule
  45. WebIDL::ExceptionOr<unsigned> CSSRuleList::insert_a_css_rule(Variant<StringView, CSSRule*> rule, u32 index)
  46. {
  47. // 1. Set length to the number of items in list.
  48. auto length = m_rules.size();
  49. // 2. If index is greater than length, then throw an IndexSizeError exception.
  50. if (index > length)
  51. return WebIDL::IndexSizeError::create(realm(), "CSS rule index out of bounds.");
  52. // 3. Set new rule to the results of performing parse a CSS rule on argument rule.
  53. // NOTE: The insert-a-css-rule spec expects `rule` to be a string, but the CSSStyleSheet.insertRule()
  54. // spec calls this algorithm with an already-parsed CSSRule. So, we use a Variant and skip step 3
  55. // if that variant holds a CSSRule already.
  56. CSSRule* new_rule = nullptr;
  57. if (rule.has<StringView>()) {
  58. new_rule = parse_css_rule(
  59. CSS::Parser::ParsingContext { realm() },
  60. rule.get<StringView>());
  61. } else {
  62. new_rule = rule.get<CSSRule*>();
  63. }
  64. // 4. If new rule is a syntax error, throw a SyntaxError exception.
  65. if (!new_rule)
  66. return WebIDL::SyntaxError::create(realm(), "Unable to parse CSS rule.");
  67. // FIXME: 5. If new rule cannot be inserted into list at the zero-index position index due to constraints specified by CSS, then throw a HierarchyRequestError exception. [CSS21]
  68. // FIXME: 6. If new rule is an @namespace at-rule, and list contains anything other than @import at-rules, and @namespace at-rules, throw an InvalidStateError exception.
  69. // 7. Insert new rule into list at the zero-indexed position index.
  70. m_rules.insert(index, *new_rule);
  71. // 8. Return index.
  72. return index;
  73. }
  74. // https://www.w3.org/TR/cssom/#remove-a-css-rule
  75. WebIDL::ExceptionOr<void> CSSRuleList::remove_a_css_rule(u32 index)
  76. {
  77. // 1. Set length to the number of items in list.
  78. auto length = m_rules.size();
  79. // 2. If index is greater than or equal to length, then throw an IndexSizeError exception.
  80. if (index >= length)
  81. return WebIDL::IndexSizeError::create(realm(), "CSS rule index out of bounds.");
  82. // 3. Set old rule to the indexth item in list.
  83. CSSRule& old_rule = m_rules[index];
  84. // FIXME: 4. If old rule is an @namespace at-rule, and list contains anything other than @import at-rules, and @namespace at-rules, throw an InvalidStateError exception.
  85. // 5. Remove rule old rule from list at the zero-indexed position index.
  86. m_rules.remove(index);
  87. // 6. Set old rule’s parent CSS rule and parent CSS style sheet to null.
  88. old_rule.set_parent_rule(nullptr);
  89. old_rule.set_parent_style_sheet(nullptr);
  90. return {};
  91. }
  92. void CSSRuleList::for_each_effective_style_rule(Function<void(CSSStyleRule const&)> const& callback) const
  93. {
  94. for (auto const& rule : m_rules) {
  95. switch (rule.type()) {
  96. case CSSRule::Type::FontFace:
  97. break;
  98. case CSSRule::Type::Import: {
  99. auto const& import_rule = static_cast<CSSImportRule const&>(rule);
  100. if (import_rule.has_import_result() && import_rule.loaded_style_sheet())
  101. import_rule.loaded_style_sheet()->for_each_effective_style_rule(callback);
  102. break;
  103. }
  104. case CSSRule::Type::Media:
  105. static_cast<CSSMediaRule const&>(rule).for_each_effective_style_rule(callback);
  106. break;
  107. case CSSRule::Type::Style:
  108. callback(static_cast<CSSStyleRule const&>(rule));
  109. break;
  110. case CSSRule::Type::Supports:
  111. static_cast<CSSSupportsRule const&>(rule).for_each_effective_style_rule(callback);
  112. break;
  113. }
  114. }
  115. }
  116. bool CSSRuleList::evaluate_media_queries(HTML::Window const& window)
  117. {
  118. bool any_media_queries_changed_match_state = false;
  119. for (auto& rule : m_rules) {
  120. switch (rule.type()) {
  121. case CSSRule::Type::FontFace:
  122. break;
  123. case CSSRule::Type::Import: {
  124. auto& import_rule = verify_cast<CSSImportRule>(rule);
  125. if (import_rule.has_import_result() && import_rule.loaded_style_sheet() && import_rule.loaded_style_sheet()->evaluate_media_queries(window))
  126. any_media_queries_changed_match_state = true;
  127. break;
  128. }
  129. case CSSRule::Type::Media: {
  130. auto& media_rule = verify_cast<CSSMediaRule>(rule);
  131. bool did_match = media_rule.condition_matches();
  132. bool now_matches = media_rule.evaluate(window);
  133. if (did_match != now_matches)
  134. any_media_queries_changed_match_state = true;
  135. if (now_matches && media_rule.css_rules().evaluate_media_queries(window))
  136. any_media_queries_changed_match_state = true;
  137. break;
  138. }
  139. case CSSRule::Type::Style:
  140. break;
  141. case CSSRule::Type::Supports: {
  142. auto& supports_rule = verify_cast<CSSSupportsRule>(rule);
  143. if (supports_rule.condition_matches() && supports_rule.css_rules().evaluate_media_queries(window))
  144. any_media_queries_changed_match_state = true;
  145. break;
  146. }
  147. }
  148. }
  149. return any_media_queries_changed_match_state;
  150. }
  151. JS::Value CSSRuleList::item_value(size_t index) const
  152. {
  153. return item(index);
  154. }
  155. }