Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Add support for keyframe-backed CSSRules, CSSKeyframesRule.cssRules and CSSKeyframeRule

Browse source
This commit is contained in:
Manish Goregaokar 2016-11-16 16:22:42 -08:00
parent 2793d5f0a9
commit 52a3a71be3
8 changed files with 143 additions and 18 deletions
Download patch file Download diff file Expand all files Collapse all files

50
components/script/dom/csskeyframerule.rs Normal file
View file

@ -0,0 +1,50 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::bindings::codegen::Bindings::CSSKeyframeRuleBinding;
use dom::bindings::js::Root;
use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::str::DOMString;
use dom::cssrule::{CSSRule, SpecificCSSRule};
use dom::cssstylesheet::CSSStyleSheet;
use dom::window::Window;
use parking_lot::RwLock;
use std::sync::Arc;
use style::keyframes::Keyframe;
#[dom_struct]
pub struct CSSKeyframeRule {
cssrule: CSSRule,
#[ignore_heap_size_of = "Arc"]
keyframerule: Arc<RwLock<Keyframe>>,
}
impl CSSKeyframeRule {
fn new_inherited(parent: &CSSStyleSheet, keyframerule: Arc<RwLock<Keyframe>>) -> CSSKeyframeRule {
CSSKeyframeRule {
cssrule: CSSRule::new_inherited(parent),
keyframerule: keyframerule,
}
}
#[allow(unrooted_must_root)]
pub fn new(window: &Window, parent: &CSSStyleSheet,
keyframerule: Arc<RwLock<Keyframe>>) -> Root<CSSKeyframeRule> {
reflect_dom_object(box CSSKeyframeRule::new_inherited(parent, keyframerule),
window,
CSSKeyframeRuleBinding::Wrap)
}
}
impl SpecificCSSRule for CSSKeyframeRule {
fn ty(&self) -> u16 {
use dom::bindings::codegen::Bindings::CSSRuleBinding::CSSRuleConstants;
CSSRuleConstants::KEYFRAME_RULE
}
fn get_css(&self) -> DOMString {
// self.keyframerule.read().to_css_string().into()
"".into()
}
}

23
components/script/dom/csskeyframesrule.rs
View file

@ -3,10 +3,14 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::bindings::codegen::Bindings::CSSKeyframesRuleBinding;
use dom::bindings::js::Root;
use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::codegen::Bindings::CSSKeyframesRuleBinding::CSSKeyframesRuleMethods;
use dom::bindings::codegen::Bindings::CSSRuleBinding::CSSRuleMethods;
use dom::bindings::inheritance::Castable;
use dom::bindings::js::{JS, MutNullableHeap, Root};
use dom::bindings::reflector::{Reflectable, reflect_dom_object};
use dom::bindings::str::DOMString;
use dom::cssrule::{CSSRule, SpecificCSSRule};
use dom::cssrulelist::{CSSRuleList, RulesSource};
use dom::cssstylesheet::CSSStyleSheet;
use dom::window::Window;
use parking_lot::RwLock;
@ -19,6 +23,7 @@ pub struct CSSKeyframesRule {
cssrule: CSSRule,
#[ignore_heap_size_of = "Arc"]
keyframesrule: Arc<RwLock<KeyframesRule>>,
rulelist: MutNullableHeap<JS<CSSRuleList>>,
}
impl CSSKeyframesRule {
@ -26,6 +31,7 @@ impl CSSKeyframesRule {
CSSKeyframesRule {
cssrule: CSSRule::new_inherited(parent),
keyframesrule: keyframesrule,
rulelist: MutNullableHeap::new(None),
}
}
@ -36,6 +42,19 @@ impl CSSKeyframesRule {
window,
CSSKeyframesRuleBinding::Wrap)
}
fn rulelist(&self) -> Root<CSSRuleList> {
self.rulelist.or_init(|| CSSRuleList::new(self.global().as_window(),
// temporary unwrap
&self.upcast::<CSSRule>().GetParentStyleSheet().unwrap(),
RulesSource::Keyframes(self.keyframesrule.clone())))
}
}
impl CSSKeyframesRuleMethods for CSSKeyframesRule {
fn CssRules(&self) -> Root<CSSRuleList> {
self.rulelist()
}
}
impl SpecificCSSRule for CSSKeyframesRule {

3
components/script/dom/cssrule.rs
View file

@ -10,6 +10,7 @@ use dom::bindings::reflector::{Reflector, reflect_dom_object};
use dom::bindings::str::DOMString;
use dom::cssfontfacerule::CSSFontFaceRule;
use dom::csskeyframesrule::CSSKeyframesRule;
use dom::csskeyframerule::CSSKeyframeRule;
use dom::cssmediarule::CSSMediaRule;
use dom::cssnamespacerule::CSSNamespaceRule;
use dom::cssstylerule::CSSStyleRule;
@ -54,6 +55,8 @@ impl CSSRule {
rule as &SpecificCSSRule
} else if let Some(rule) = self.downcast::<CSSViewportRule>() {
rule as &SpecificCSSRule
} else if let Some(rule) = self.downcast::<CSSKeyframeRule>() {
rule as &SpecificCSSRule
} else {
unreachable!()
}

67
components/script/dom/cssrulelist.rs
View file

@ -10,27 +10,43 @@ use dom::bindings::error::{Error, ErrorResult, Fallible};
use dom::bindings::js::{JS, MutNullableHeap, Root};
use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
use dom::cssrule::CSSRule;
use dom::csskeyframerule::CSSKeyframeRule;
use dom::cssstylesheet::CSSStyleSheet;
use dom::window::Window;
use parking_lot::RwLock;
use std::sync::Arc;
use style::parser::ParserContextExtraData;
use style::stylesheets::{CssRules, Origin};
use style::stylesheets::{CssRules, KeyframesRule, Origin};
use style::stylesheets::CssRule as StyleCssRule;
no_jsmanaged_fields!(CssRules);
no_jsmanaged_fields!(RulesSource);
#[dom_struct]
pub struct CSSRuleList {
reflector_: Reflector,
sheet: JS<CSSStyleSheet>,
#[ignore_heap_size_of = "Arc"]
rules: CssRules,
rules: RulesSource,
dom_rules: DOMRefCell<Vec<MutNullableHeap<JS<CSSRule>>>>
}
pub enum RulesSource {
Rules(CssRules),
Keyframes(Arc<RwLock<KeyframesRule>>),
}
impl CSSRuleList {
#[allow(unrooted_must_root)]
pub fn new_inherited(sheet: &CSSStyleSheet, rules: CssRules) -> CSSRuleList {
let dom_rules = rules.0.read().iter().map(|_| MutNullableHeap::new(None)).collect();
pub fn new_inherited(sheet: &CSSStyleSheet, rules: RulesSource) -> CSSRuleList {
let dom_rules = match rules {
RulesSource::Rules(ref rules) => {
rules.0.read().iter().map(|_| MutNullableHeap::new(None)).collect()
}
RulesSource::Keyframes(ref rules) => {
rules.read().keyframes.iter().map(|_| MutNullableHeap::new(None)).collect()
}
};
CSSRuleList {
reflector_: Reflector::new(),
sheet: JS::from_ref(sheet),
@ -40,7 +56,7 @@ impl CSSRuleList {
}
#[allow(unrooted_must_root)]
pub fn new(window: &Window, sheet: &CSSStyleSheet, rules: CssRules) -> Root<CSSRuleList> {
pub fn new(window: &Window, sheet: &CSSStyleSheet, rules: RulesSource) -> Root<CSSRuleList> {
reflect_dom_object(box CSSRuleList::new_inherited(sheet, rules),
window,
CSSRuleListBinding::Wrap)
@ -57,6 +73,13 @@ impl CSSRuleList {
vec.insert(index, item);
}
}
let css_rules = if let RulesSource::Rules(ref rules) = self.rules {
rules
} else {
panic!("Called insert_rule on non-CssRule-backed CSSRuleList");
};
let global = self.global();
let window = global.as_window();
let doc = window.Document();
@ -64,7 +87,7 @@ impl CSSRuleList {
let new_rule = {
let rules = self.rules.0.read();
let rules = css_rules.0.read();
let state = if nested {
None
} else {
@ -108,7 +131,7 @@ impl CSSRuleList {
new_rule
};
insert(&mut self.rules.0.write(), index, new_rule.clone());
insert(&mut css_rules.0.write(), index, new_rule.clone());
let dom_rule = CSSRule::new_specific(&window, &self.sheet, new_rule);
insert(&mut self.dom_rules.borrow_mut(),
index, MutNullableHeap::new(Some(&*dom_rule)));
@ -119,8 +142,14 @@ impl CSSRuleList {
pub fn remove_rule(&self, index: u32) -> ErrorResult {
let index = index as usize;
let css_rules = if let RulesSource::Rules(ref rules) = self.rules {
rules
} else {
panic!("Called remove_rule on non-CssRule-backed CSSRuleList");
};
{
let rules = self.rules.0.read();
let rules = css_rules.0.read();
if index >= rules.len() {
return Err(Error::IndexSize);
}
@ -133,7 +162,7 @@ impl CSSRuleList {
}
let mut dom_rules = self.dom_rules.borrow_mut();
self.rules.0.write().remove(index);
css_rules.0.write().remove(index);
dom_rules[index].get().map(|r| r.disown());
dom_rules.remove(index);
Ok(())
@ -145,9 +174,21 @@ impl CSSRuleListMethods for CSSRuleList {
fn Item(&self, idx: u32) -> Option<Root<CSSRule>> {
self.dom_rules.borrow().get(idx as usize).map(|rule| {
rule.or_init(|| {
CSSRule::new_specific(self.global().as_window(),
&self.sheet,
self.rules.0.read()[idx as usize].clone())
match self.rules {
RulesSource::Rules(ref rules) => {
CSSRule::new_specific(self.global().as_window(),
&self.sheet,
rules.0.read()[idx as usize].clone())
}
RulesSource::Keyframes(ref rules) => {
Root::upcast(CSSKeyframeRule::new(self.global().as_window(),
&self.sheet,
rules.read()
.keyframes[idx as usize]
.clone()))
}
}
})
})
}

5
components/script/dom/cssstylesheet.rs
View file

@ -8,7 +8,7 @@ use dom::bindings::error::{ErrorResult, Fallible};
use dom::bindings::js::{JS, Root, MutNullableHeap};
use dom::bindings::reflector::{reflect_dom_object, Reflectable};
use dom::bindings::str::DOMString;
use dom::cssrulelist::CSSRuleList;
use dom::cssrulelist::{CSSRuleList, RulesSource};
use dom::stylesheet::StyleSheet;
use dom::window::Window;
use std::sync::Arc;
@ -45,7 +45,8 @@ impl CSSStyleSheet {
fn rulelist(&self) -> Root<CSSRuleList> {
self.rulelist.or_init(|| CSSRuleList::new(self.global().as_window(),
self,
self.style_stylesheet.rules.clone()))
RulesSource::Rules(self.style_stylesheet
.rules.clone())))
}
}

1
components/script/dom/mod.rs
View file

@ -245,6 +245,7 @@ pub mod css;
pub mod cssfontfacerule;
pub mod cssgroupingrule;
pub mod csskeyframesrule;
pub mod csskeyframerule;
pub mod cssmediarule;
pub mod cssnamespacerule;
pub mod cssrule;

10
components/script/dom/webidls/CSSKeyframeRule.webidl Normal file
View file

@ -0,0 +1,10 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// https://drafts.csswg.org/css-animations/#interface-csskeyframerule
[Exposed=Window]
interface CSSKeyframeRule : CSSRule {
// attribute DOMString keyText;
// readonly attribute CSSStyleDeclaration style;
};

2
components/script/dom/webidls/CSSKeyframesRule.webidl
View file

@ -6,7 +6,7 @@
[Exposed=Window]
interface CSSKeyframesRule : CSSRule {
// attribute DOMString name;
// readonly attribute CSSRuleList cssRules;
readonly attribute CSSRuleList cssRules;
// void appendRule(DOMString rule);
// void deleteRule(DOMString select);