mirror of
https://github.com/servo/servo.git
synced 2025-06-19 06:38:59 +01:00
674fe910c1
Tweak getPropertyPriority to match recommendations Adding Tests for Style Priority Use else if Adding Content Test for GetPropertyPriority Revert "Adding Tests for Style Priority" This reverts commit 8666a37f833b06c3e43f27acd8a9678e94425e55.
418 lines
16 KiB
Rust
418 lines
16 KiB
Rust
/* 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::GlobalRef;
|
|
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),
|
|
GlobalRef::Window(global),
|
|
CSSStyleDeclarationBinding::Wrap)
|
|
}
|
|
}
|
|
|
|
trait PrivateCSSStyleDeclarationHelpers {
|
|
fn get_declaration(self, property: &Atom) -> Option<PropertyDeclaration>;
|
|
fn get_important_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())
|
|
}
|
|
|
|
fn get_important_declaration(self, property: &Atom) -> Option<PropertyDeclaration> {
|
|
let owner = self.owner.root();
|
|
let element: JSRef<Element> = ElementCast::from_ref(*owner);
|
|
element.get_important_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-getpropertypriority
|
|
fn GetPropertyPriority(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 & 2.2 & 2.3
|
|
if longhand_properties.iter()
|
|
.map(|longhand| self.GetPropertyPriority(longhand.clone()))
|
|
.all(|priority| priority.as_slice() == "important") {
|
|
|
|
return "important".to_string();
|
|
}
|
|
// Step 3
|
|
} else if self.get_important_declaration(&property).is_some() {
|
|
return "important".to_string();
|
|
}
|
|
|
|
// Step 4
|
|
"".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-setpropertypriority
|
|
fn SetPropertyPriority(self, property: 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
|
|
let priority = priority.as_slice().to_ascii_lower();
|
|
if priority.as_slice() != "important" && !priority.is_empty() {
|
|
return Ok(());
|
|
}
|
|
|
|
let owner = self.owner.root();
|
|
let window = window_from_node(*owner).root();
|
|
let page = window.page();
|
|
let decl_block = parse_style_attribute(property.as_slice(),
|
|
&page.get_url());
|
|
let element: JSRef<Element> = ElementCast::from_ref(*owner);
|
|
|
|
// Step 5
|
|
for decl in decl_block.normal.iter() {
|
|
// Step 6
|
|
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_
|
|
}
|
|
}
|