Skip to content

Commit

Permalink
auto merge of #4342 : jdm/servo/cssom, r=jdm,metajack
Browse files Browse the repository at this point in the history 
This does not implement any notion of CSSStyleDeclaration objects that do not have an owning element; there's no actual CSS object model in play here. This does support setting and getting properties of the style attribute for HTMLElement, and tries to implement the ambiguous CSS value serialization spec.
  • Loading branch information
bors-servo committed Dec 18, 2014
2 parents 1f34263 + 2f5786d commit 8247886
Show file tree
Hide file tree
Showing 16 changed files with 1,705 additions and 47 deletions.
350 changes: 350 additions & 0 deletions components/script/dom/cssstyledeclaration.rs
View file
@@ -0,0 +1,350 @@
/* 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::{mod, CSSStyleDeclarationMethods};
use dom::bindings::codegen::InheritTypes::{NodeCast, ElementCast};
use dom::bindings::error::ErrorResult;
use dom::bindings::global;
use dom::bindings::js::{JS, JSRef, OptionalRootedRootable, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::document::DocumentHelpers;
use dom::element::{Element, ElementHelpers};
use dom::htmlelement::HTMLElement;
use dom::node::{window_from_node, document_from_node, NodeDamage, Node};
use dom::window::Window;
use servo_util::str::DOMString;
use string_cache::Atom;
use style::{is_supported_property, longhands_from_shorthand, parse_style_attribute};
use style::PropertyDeclaration;

use std::ascii::AsciiExt;

#[dom_struct]
pub struct CSSStyleDeclaration {
reflector_: Reflector,
owner: JS<HTMLElement>,
}

macro_rules! css_properties(
( $([$getter:ident, $setter:ident, $cssprop:expr]),* ) => (
$(
fn $getter(self) -> DOMString {
self.GetPropertyValue($cssprop.to_string())
}
fn $setter(self, value: DOMString) {
self.SetPropertyValue($cssprop.to_string(), value).unwrap();
}
)*
);
)

fn serialize_list(list: &Vec<PropertyDeclaration>) -> DOMString {
let mut result = String::new();
for declaration in list.iter() {
result.push_str(serialize_value(declaration).as_slice());
result.push_str(" ");
}
result
}

fn serialize_value(declaration: &PropertyDeclaration) -> DOMString {
declaration.value()
}

impl CSSStyleDeclaration {
pub fn new_inherited(owner: JSRef<HTMLElement>) -> CSSStyleDeclaration {
CSSStyleDeclaration {
reflector_: Reflector::new(),
owner: JS::from_rooted(owner),
}
}

pub fn new(global: JSRef<Window>, owner: JSRef<HTMLElement>) -> Temporary<CSSStyleDeclaration> {
reflect_dom_object(box CSSStyleDeclaration::new_inherited(owner),
global::Window(global),
CSSStyleDeclarationBinding::Wrap)
}
}

trait PrivateCSSStyleDeclarationHelpers {
fn get_declaration(self, property: &Atom) -> Option<PropertyDeclaration>;
}

impl<'a> PrivateCSSStyleDeclarationHelpers for JSRef<'a, CSSStyleDeclaration> {
fn get_declaration(self, property: &Atom) -> Option<PropertyDeclaration> {
let owner = self.owner.root();
let element: JSRef<Element> = ElementCast::from_ref(*owner);
element.get_inline_style_declaration(property).map(|decl| decl.clone())
}
}

impl<'a> CSSStyleDeclarationMethods for JSRef<'a, CSSStyleDeclaration> {
fn Length(self) -> u32 {
let owner = self.owner.root();
let elem: JSRef<Element> = ElementCast::from_ref(*owner);
let len = match *elem.style_attribute().borrow() {
Some(ref declarations) => declarations.normal.len() + declarations.important.len(),
None => 0
};
len as u32
}

fn Item(self, index: u32) -> DOMString {
let owner = self.owner.root();
let elem: JSRef<Element> = ElementCast::from_ref(*owner);
let style_attribute = elem.style_attribute().borrow();
let result = style_attribute.as_ref().and_then(|declarations| {
if index as uint > declarations.normal.len() {
declarations.important
.get(index as uint - declarations.normal.len())
.map(|decl| format!("{} !important", decl))
} else {
declarations.normal
.get(index as uint)
.map(|decl| format!("{}", decl))
}
});

result.unwrap_or("".to_string())
}

// http://dev.w3.org/csswg/cssom/#dom-cssstyledeclaration-getpropertyvalue
fn GetPropertyValue(self, property: DOMString) -> DOMString {
// Step 1
let property = Atom::from_slice(property.as_slice().to_ascii_lower().as_slice());

// Step 2
let longhand_properties = longhands_from_shorthand(property.as_slice());
if let Some(longhand_properties) = longhand_properties {
// Step 2.1
let mut list = vec!();

// Step 2.2
for longhand in longhand_properties.iter() {
// Step 2.2.1
let declaration = self.get_declaration(&Atom::from_slice(longhand.as_slice()));

// Step 2.2.2 & 2.2.3
match declaration {
Some(declaration) => list.push(declaration),
None => return "".to_string(),
}
}

// Step 2.3
return serialize_list(&list);
}

// Step 3 & 4
if let Some(ref declaration) = self.get_declaration(&property) {
serialize_value(declaration)
} else {
"".to_string()
}
}

// http://dev.w3.org/csswg/cssom/#dom-cssstyledeclaration-setproperty
fn SetProperty(self, property: DOMString, value: DOMString,
priority: DOMString) -> ErrorResult {
//TODO: disallow modifications if readonly flag is set

// Step 2
let property = property.as_slice().to_ascii_lower();

// Step 3
if !is_supported_property(property.as_slice()) {
return Ok(());
}

// Step 4
if value.is_empty() {
self.RemoveProperty(property);
return Ok(());
}

// Step 5
let priority = priority.as_slice().to_ascii_lower();
if priority.as_slice() != "!important" && !priority.is_empty() {
return Ok(());
}

// Step 6
let mut synthesized_declaration = String::from_str(property.as_slice());
synthesized_declaration.push_str(": ");
synthesized_declaration.push_str(value.as_slice());

let owner = self.owner.root();
let window = window_from_node(*owner).root();
let page = window.page();
let decl_block = parse_style_attribute(synthesized_declaration.as_slice(),
&page.get_url());

// Step 7
if decl_block.normal.len() == 0 {
return Ok(());
}

let owner = self.owner.root();
let element: JSRef<Element> = ElementCast::from_ref(*owner);

// Step 8
for decl in decl_block.normal.iter() {
// Step 9
element.update_inline_style(decl.clone(), !priority.is_empty());
}

let document = document_from_node(element).root();
let node: JSRef<Node> = NodeCast::from_ref(element);
document.content_changed(node, NodeDamage::NodeStyleDamaged);
Ok(())
}

// http://dev.w3.org/csswg/cssom/#dom-cssstyledeclaration-setpropertyvalue
fn SetPropertyValue(self, property: DOMString, value: DOMString) -> ErrorResult {
self.SetProperty(property, value, "".to_string())
}

// http://dev.w3.org/csswg/cssom/#dom-cssstyledeclaration-removeproperty
fn RemoveProperty(self, property: DOMString) -> DOMString {
//TODO: disallow modifications if readonly flag is set

// Step 2
let property = property.as_slice().to_ascii_lower();

// Step 3
let value = self.GetPropertyValue(property.clone());

let longhand_properties = longhands_from_shorthand(property.as_slice());
match longhand_properties {
Some(longhands) => {
// Step 4
for longhand in longhands.iter() {
self.RemoveProperty(longhand.clone());
}
}

None => {
// Step 5
let owner = self.owner.root();
let elem: JSRef<Element> = ElementCast::from_ref(*owner);
elem.remove_inline_style_property(property)
}
}

// Step 6
value
}

// http://dev.w3.org/csswg/cssom/#dom-cssstyledeclaration-cssfloat
fn CssFloat(self) -> DOMString {
self.GetPropertyValue("float".to_string())
}

// http://dev.w3.org/csswg/cssom/#dom-cssstyledeclaration-cssfloat
fn SetCssFloat(self, value: DOMString) -> ErrorResult {
self.SetPropertyValue("float".to_string(), value)
}

fn IndexedGetter(self, index: u32, found: &mut bool) -> DOMString {
let rval = self.Item(index);
*found = index < self.Length();
rval
}

css_properties!(
[Color, SetColor, "color"],
[Background, SetBackground, "background"],
[BackgroundColor, SetBackgroundColor, "background-color"],
[BackgroundPosition, SetBackgroundPosition, "background-position"],
[BackgroundImage, SetBackgroundImage, "background-image"],
[BackgroundRepeat, SetBackgroundRepeat, "background-repeat"],
[BackgroundAttachment, SetBackgroundAttachment, "background-attachment"],
[Border, SetBorder, "border"],
[BorderColor, SetBorderColor, "border-color"],
[BorderRadius, SetBorderRadius, "border-radius"],
[BorderStyle, SetBorderStyle, "border-style"],
[BorderWidth, SetBorderWidth, "border-width"],
[BorderBottom, SetBorderBottom, "border-bottom"],
[BorderBottomColor, SetBorderBottomColor, "border-bottom-color"],
[BorderBottomStyle, SetBorderBottomStyle, "border-bottom-style"],
[BorderBottomWidth, SetBorderBottomWidth, "border-bottom-width"],
[BorderLeft, SetBorderLeft, "border-left"],
[BorderLeftColor, SetBorderLeftColor, "border-left-color"],
[BorderLeftStyle, SetBorderLeftStyle, "border-left-style"],
[BorderLeftWidth, SetBorderLeftWidth, "border-left-width"],
[BorderRight, SetBorderRight, "border-right"],
[BorderRightColor, SetBorderRightColor, "border-right-color"],
[BorderRightStyle, SetBorderRightStyle, "border-right-style"],
[BorderRightWidth, SetBorderRightWidth, "border-right-width"],
[BorderTop, SetBorderTop, "border-top"],
[BorderTopColor, SetBorderTopColor, "border-top-color"],
[BorderTopStyle, SetBorderTopStyle, "border-top-style"],
[BorderTopWidth, SetBorderTopWidth, "border-top-width"],
[Content, SetContent, "content"],
[Display, SetDisplay, "display"],
[Opacity, SetOpacity, "opacity"],
[Width, SetWidth, "width"],
[MinWidth, SetMinWidth, "min-width"],
[MaxWidth, SetMaxWidth, "max-width"],
[Height, SetHeight, "height"],
[MinHeight, SetMinHeight, "min-height"],
[MaxHeight, SetMaxHeight, "max-height"],
[Clear, SetClear, "clear"],
[Direction, SetDirection, "direction"],
[LineHeight, SetLineHeight, "line-height"],
[VerticalAlign, SetVerticalAlign, "vertical-align"],
[ListStyle, SetListStyle, "list-style"],
[ListStylePosition, SetListStylePosition, "list-style-position"],
[ListStyleType, SetListStyleType, "list-style-type"],
[ListStyleImage, SetListStyleImage, "list-style-image"],
[Visibility, SetVisibility, "visibility"],
[Cursor, SetCursor, "cursor"],
[BoxShadow, SetBoxShadow, "box-shadow"],
[BoxSizing, SetBoxSizing, "box-sizing"],
[Overflow, SetOverflow, "overflow"],
[OverflowWrap, SetOverflowWrap, "overflow-wrap"],
[TableLayout, SetTableLayout, "table-layout"],
[EmptyCells, SetEmptyCells, "empty-cells"],
[CaptionSide, SetCaptionSide, "caption-side"],
[WhiteSpace, SetWhiteSpace, "white-space"],
[WritingMode, SetWritingMode, "writing-mode"],
[LetterSpacing, SetLetterSpacing, "letter-spacing"],
[WordSpacing, SetWordSpacing, "word-spacing"],
[WordWrap, SetWordWrap, "word-wrap"],
[TextAlign, SetTextAlign, "text-align"],
[TextDecoration, SetTextDecoration, "text-decoration"],
[TextIndent, SetTextIndent, "text-indent"],
[TextOrientation, SetTextOrientation, "text-orientation"],
[TextTransform, SetTextTransform, "text-transform"],
[Font, SetFont, "font"],
[FontFamily, SetFontFamily, "font-family"],
[FontSize, SetFontSize, "font-size"],
[FontStyle, SetFontStyle, "font-style"],
[FontVariant, SetFontVariant, "font-variant"],
[FontWeight, SetFontWeight, "font-weight"],
[Margin, SetMargin, "margin"],
[MarginBottom, SetMarginBottom, "margin-bottom"],
[MarginLeft, SetMarginLeft, "margin-left"],
[MarginRight, SetMarginRight, "margin-right"],
[MarginTop, SetMarginTop, "margin-top"],
[Padding, SetPadding, "padding"],
[PaddingBottom, SetPaddingBottom, "padding-bottom"],
[PaddingLeft, SetPaddingLeft, "padding-left"],
[PaddingRight, SetPaddingRight, "padding-right"],
[PaddingTop, SetPaddingTop, "padding-top"],
[Outline, SetOutline, "outline"],
[Position, SetPosition, "position"],
[Bottom, SetBottom, "bottom"],
[Left, SetLeft, "left"],
[Right, SetRight, "right"],
[Top, SetTop, "top"],
[ZIndex, SetZIndex, "z-index"]
)
}

impl Reflectable for CSSStyleDeclaration {
fn reflector<'a>(&'a self) -> &'a Reflector {
&self.reflector_
}
}

0 comments on commit 8247886

Please sign in to comment.