/* 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::CSSStyleDeclarationBinding::CSSStyleDeclarationMethods; use dom::bindings::error::{ErrorResult, Fallible}; use dom::bindings::js::JSRef; use dom::bindings::utils::{Reflectable, Reflector}; use servo_util::str::DOMString; use string_cache::atom::Atom; use std::ascii::AsciiExt; #[dom_struct] pub struct CSSStyleDeclaration { reflector_: Reflector, } fn get_longhands_from_shorthand(shorthand: &Atom) -> Vec { match shorthand.as_slice() { "background" => vec!(Atom::from_slice("background-color"), Atom::from_slice("background-position"), Atom::from_slice("background-attachment"), Atom::from_slice("background-image"), Atom::from_slice("background-repeat")), _ => vec!(), } } type Declaration = int; fn serialize_list(property: String, list: Vec) -> DOMString { let mut result = property; result.push_str(": "); for declaration in list.iter() { result.push_str(serialize_declaration(declaration).as_slice()); } result } fn serialize_declaration(_declaration: &Declaration) -> DOMString { "".to_string() } fn get_declaration(_property: &Atom) -> Option { None } impl CSSStyleDeclaration { pub fn new_inherited() -> CSSStyleDeclaration { CSSStyleDeclaration { reflector_: Reflector::new() } } } impl<'a> CSSStyleDeclarationMethods for JSRef<'a, CSSStyleDeclaration> { fn CssText(self) -> DOMString { "".to_string() } fn SetCssText(self, _cssText: DOMString) -> ErrorResult { Ok(()) } fn Length(self) -> u32 { 0 } fn Item(self, _index: u32) -> DOMString { "".to_string() } //http://dev.w3.org/csswg/cssom/#dom-cssstyledeclaration-getpropertyvalue fn GetPropertyValue(self, property: DOMString) -> DOMString { // 1. Let property be property converted to ASCII lowercase. let property = Atom::from_slice(property.as_slice().to_ascii_lower().as_slice()); // 2. If property is a shorthand property, then follow these substeps: let longhand_properties = get_longhands_from_shorthand(&property); if !longhand_properties.is_empty() { // 1. Let list be a new empty array. let mut list = vec!(); // 2. For each longhand property longhand that property maps to, in canonical order, // follow these substeps: for longhand in longhand_properties.iter() { // 1. If longhand is a case-sensitive match for a property name of a // CSS declaration in the declarations, let declaration be that CSS // declaration, or null otherwise. let declaration = get_declaration(longhand); // 2. If declaration is null, return the empty string and terminate these // steps. if declaration.is_none() { return "".to_string(); } // 3. Append the declaration to list. list.push(declaration.unwrap()); } // 3. Return the serialization of list and terminate these steps. return serialize_list(property.as_slice().to_string(), list); } // 3. If property is a case-sensitive match for a property name of a CSS declaration // in the declarations, return the result of invoking serialize a CSS value of that // declaration and terminate these steps. // 4. Return the empty string. let declaration = get_declaration(&property); declaration.as_ref().map(|declaration| serialize_declaration(declaration)) .unwrap_or("".to_string()) } fn GetPropertyPriority(self, _property: DOMString) -> DOMString { "".to_string() } fn SetProperty(self, _property: DOMString, _value: DOMString, _priority: DOMString) -> ErrorResult { Ok(()) } fn SetPropertyValue(self, _property: DOMString, _value: DOMString) -> ErrorResult { Ok(()) } fn SetPropertyPriority(self, _property: DOMString, _priority: DOMString) -> ErrorResult { Ok(()) } fn RemoveProperty(self, _property: DOMString) -> Fallible { Ok("".to_string()) } fn IndexedGetter(self, _index: u32, _found: &mut bool) -> DOMString { "".to_string() } } impl Reflectable for CSSStyleDeclaration { fn reflector<'a>(&'a self) -> &'a Reflector { &self.reflector_ } }