script/dom/
csskeyframesrule.rs1use std::cell::RefCell;
6
7use cssparser::{Parser, ParserInput};
8use dom_struct::dom_struct;
9use servo_arc::Arc;
10use style::shared_lock::{Locked, SharedRwLockReadGuard, ToCssWithGuard};
11use style::stylesheets::CssRuleType;
12use style::stylesheets::keyframes_rule::{Keyframe, KeyframeSelector, KeyframesRule};
13use style::values::KeyframesName;
14
15use crate::dom::bindings::codegen::Bindings::CSSKeyframesRuleBinding::CSSKeyframesRuleMethods;
16use crate::dom::bindings::error::ErrorResult;
17use crate::dom::bindings::inheritance::Castable;
18use crate::dom::bindings::reflector::{DomGlobal, reflect_dom_object};
19use crate::dom::bindings::root::{DomRoot, MutNullableDom};
20use crate::dom::bindings::str::DOMString;
21use crate::dom::csskeyframerule::CSSKeyframeRule;
22use crate::dom::cssrule::{CSSRule, SpecificCSSRule};
23use crate::dom::cssrulelist::{CSSRuleList, RulesSource};
24use crate::dom::cssstylesheet::CSSStyleSheet;
25use crate::dom::window::Window;
26use crate::script_runtime::CanGc;
27
28#[dom_struct]
29pub(crate) struct CSSKeyframesRule {
30 cssrule: CSSRule,
31 #[ignore_malloc_size_of = "Arc"]
32 #[no_trace]
33 keyframesrule: RefCell<Arc<Locked<KeyframesRule>>>,
34 rulelist: MutNullableDom<CSSRuleList>,
35}
36
37impl CSSKeyframesRule {
38 fn new_inherited(
39 parent_stylesheet: &CSSStyleSheet,
40 keyframesrule: Arc<Locked<KeyframesRule>>,
41 ) -> CSSKeyframesRule {
42 CSSKeyframesRule {
43 cssrule: CSSRule::new_inherited(parent_stylesheet),
44 keyframesrule: RefCell::new(keyframesrule),
45 rulelist: MutNullableDom::new(None),
46 }
47 }
48
49 #[cfg_attr(crown, allow(crown::unrooted_must_root))]
50 pub(crate) fn new(
51 window: &Window,
52 parent_stylesheet: &CSSStyleSheet,
53 keyframesrule: Arc<Locked<KeyframesRule>>,
54 can_gc: CanGc,
55 ) -> DomRoot<CSSKeyframesRule> {
56 reflect_dom_object(
57 Box::new(CSSKeyframesRule::new_inherited(
58 parent_stylesheet,
59 keyframesrule,
60 )),
61 window,
62 can_gc,
63 )
64 }
65
66 fn rulelist(&self, can_gc: CanGc) -> DomRoot<CSSRuleList> {
67 self.rulelist.or_init(|| {
68 let parent_stylesheet = &self.upcast::<CSSRule>().parent_stylesheet();
69 CSSRuleList::new(
70 self.global().as_window(),
71 parent_stylesheet,
72 RulesSource::Keyframes(self.keyframesrule.borrow().clone()),
73 can_gc,
74 )
75 })
76 }
77
78 fn find_rule(&self, selector: &str) -> Option<usize> {
80 let mut input = ParserInput::new(selector);
81 let mut input = Parser::new(&mut input);
82 if let Ok(sel) = KeyframeSelector::parse(&mut input) {
83 let guard = self.cssrule.shared_lock().read();
84 self.keyframesrule
87 .borrow()
88 .read_with(&guard)
89 .keyframes
90 .iter()
91 .rposition(|frame| frame.read_with(&guard).selector == sel)
92 } else {
93 None
94 }
95 }
96
97 pub(crate) fn update_rule(
98 &self,
99 keyframesrule: Arc<Locked<KeyframesRule>>,
100 guard: &SharedRwLockReadGuard,
101 ) {
102 if let Some(rulelist) = self.rulelist.get() {
103 rulelist.update_rules(RulesSource::Keyframes(keyframesrule.clone()), guard);
104 }
105
106 *self.keyframesrule.borrow_mut() = keyframesrule;
107 }
108}
109
110impl CSSKeyframesRuleMethods<crate::DomTypeHolder> for CSSKeyframesRule {
111 fn CssRules(&self, can_gc: CanGc) -> DomRoot<CSSRuleList> {
113 self.rulelist(can_gc)
114 }
115
116 fn AppendRule(&self, rule: DOMString, can_gc: CanGc) {
118 let style_stylesheet = self.cssrule.parent_stylesheet().style_stylesheet();
119 let rule = Keyframe::parse(
120 &rule,
121 &style_stylesheet.contents,
122 &style_stylesheet.shared_lock,
123 );
124
125 if let Ok(rule) = rule {
126 self.cssrule.parent_stylesheet().will_modify();
127 let mut guard = self.cssrule.shared_lock().write();
128 self.keyframesrule
129 .borrow()
130 .write_with(&mut guard)
131 .keyframes
132 .push(rule);
133 self.rulelist(can_gc).append_lazy_dom_rule();
134 self.cssrule.parent_stylesheet().notify_invalidations();
135 }
136 }
137
138 fn DeleteRule(&self, selector: DOMString, can_gc: CanGc) {
140 if let Some(idx) = self.find_rule(&selector) {
141 let _ = self.rulelist(can_gc).remove_rule(idx as u32);
142 }
143 }
144
145 fn FindRule(&self, selector: DOMString, can_gc: CanGc) -> Option<DomRoot<CSSKeyframeRule>> {
147 self.find_rule(&selector)
148 .and_then(|idx| self.rulelist(can_gc).item(idx as u32, can_gc))
149 .and_then(DomRoot::downcast)
150 }
151
152 fn Name(&self) -> DOMString {
154 let guard = self.cssrule.shared_lock().read();
155 DOMString::from(&**self.keyframesrule.borrow().read_with(&guard).name.as_atom())
156 }
157
158 fn SetName(&self, value: DOMString) -> ErrorResult {
160 self.cssrule.parent_stylesheet().will_modify();
164 let name = KeyframesName::from_ident(&value);
165 let mut guard = self.cssrule.shared_lock().write();
166 self.keyframesrule.borrow().write_with(&mut guard).name = name;
167 self.cssrule.parent_stylesheet().notify_invalidations();
168 Ok(())
169 }
170}
171
172impl SpecificCSSRule for CSSKeyframesRule {
173 fn ty(&self) -> CssRuleType {
174 CssRuleType::Keyframes
175 }
176
177 fn get_css(&self) -> DOMString {
178 let guard = self.cssrule.shared_lock().read();
179 self.keyframesrule
180 .borrow()
181 .read_with(&guard)
182 .to_css_string(&guard)
183 .into()
184 }
185
186 fn deparent_children(&self) {
187 if let Some(list) = self.rulelist.get() {
188 list.deparent_all()
189 }
190 }
191}