diff --git a/components/style/gecko/mod.rs b/components/style/gecko/mod.rs index 43d38d7dbc1..3ff2cfcf140 100644 --- a/components/style/gecko/mod.rs +++ b/components/style/gecko/mod.rs @@ -17,7 +17,6 @@ pub mod media_queries; pub mod profiler; pub mod pseudo_element; pub mod restyle_damage; -pub mod rules; pub mod selector_parser; pub mod snapshot; pub mod snapshot_helpers; diff --git a/components/style/gecko/rules.rs b/components/style/gecko/rules.rs deleted file mode 100644 index 050a95754df..00000000000 --- a/components/style/gecko/rules.rs +++ /dev/null @@ -1,135 +0,0 @@ -/* 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 https://mozilla.org/MPL/2.0/. */ - -//! Bindings for CSS Rule objects - -use crate::counter_style::{self, CounterBound}; -use crate::gecko_bindings::structs::{self, nsCSSValue}; -use crate::gecko_bindings::sugar::ns_css_value::ToNsCssValue; - -impl<'a> ToNsCssValue for &'a counter_style::System { - fn convert(self, nscssvalue: &mut nsCSSValue) { - use crate::counter_style::System::*; - match *self { - Cyclic => nscssvalue.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_CYCLIC as i32), - Numeric => nscssvalue.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_NUMERIC as i32), - Alphabetic => nscssvalue.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_ALPHABETIC as i32), - Symbolic => nscssvalue.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_SYMBOLIC as i32), - Additive => nscssvalue.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_ADDITIVE as i32), - Fixed { - ref first_symbol_value, - } => { - let mut a = nsCSSValue::null(); - let mut b = nsCSSValue::null(); - a.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_FIXED as i32); - b.set_integer(first_symbol_value.map_or(1, |v| v.value())); - nscssvalue.set_pair(&a, &b); - }, - Extends(ref other) => { - let mut a = nsCSSValue::null(); - let mut b = nsCSSValue::null(); - a.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_EXTENDS as i32); - b.set_atom_ident(other.0.clone()); - nscssvalue.set_pair(&a, &b); - }, - } - } -} - -impl<'a> ToNsCssValue for &'a counter_style::Negative { - fn convert(self, nscssvalue: &mut nsCSSValue) { - if let Some(ref second) = self.1 { - let mut a = nsCSSValue::null(); - let mut b = nsCSSValue::null(); - a.set_from(&self.0); - b.set_from(second); - nscssvalue.set_pair(&a, &b); - } else { - nscssvalue.set_from(&self.0) - } - } -} - -impl<'a> ToNsCssValue for &'a counter_style::Symbol { - fn convert(self, nscssvalue: &mut nsCSSValue) { - match *self { - counter_style::Symbol::String(ref s) => nscssvalue.set_string(s), - counter_style::Symbol::Ident(ref s) => nscssvalue.set_ident_from_atom(&s.0), - } - } -} - -impl<'a> ToNsCssValue for &'a counter_style::Ranges { - fn convert(self, nscssvalue: &mut nsCSSValue) { - if self.0.is_empty() { - nscssvalue.set_auto(); - } else { - nscssvalue.set_pair_list(self.0.iter().map(|range| { - fn set_bound(bound: CounterBound, nscssvalue: &mut nsCSSValue) { - if let CounterBound::Integer(finite) = bound { - nscssvalue.set_integer(finite.value()) - } else { - nscssvalue.set_enum(structs::NS_STYLE_COUNTER_RANGE_INFINITE as i32) - } - } - let mut start = nsCSSValue::null(); - let mut end = nsCSSValue::null(); - set_bound(range.start, &mut start); - set_bound(range.end, &mut end); - (start, end) - })); - } - } -} - -impl<'a> ToNsCssValue for &'a counter_style::Pad { - fn convert(self, nscssvalue: &mut nsCSSValue) { - let mut min_length = nsCSSValue::null(); - let mut pad_with = nsCSSValue::null(); - min_length.set_integer(self.0.value()); - pad_with.set_from(&self.1); - nscssvalue.set_pair(&min_length, &pad_with); - } -} - -impl<'a> ToNsCssValue for &'a counter_style::Fallback { - fn convert(self, nscssvalue: &mut nsCSSValue) { - nscssvalue.set_atom_ident(self.0 .0.clone()) - } -} - -impl<'a> ToNsCssValue for &'a counter_style::Symbols { - fn convert(self, nscssvalue: &mut nsCSSValue) { - nscssvalue.set_list(self.0.iter().map(|item| { - let mut value = nsCSSValue::null(); - value.set_from(item); - value - })); - } -} - -impl<'a> ToNsCssValue for &'a counter_style::AdditiveSymbols { - fn convert(self, nscssvalue: &mut nsCSSValue) { - nscssvalue.set_pair_list(self.0.iter().map(|tuple| { - let mut weight = nsCSSValue::null(); - let mut symbol = nsCSSValue::null(); - weight.set_integer(tuple.weight.value()); - symbol.set_from(&tuple.symbol); - (weight, symbol) - })); - } -} - -impl<'a> ToNsCssValue for &'a counter_style::SpeakAs { - fn convert(self, nscssvalue: &mut nsCSSValue) { - use crate::counter_style::SpeakAs::*; - match *self { - Auto => nscssvalue.set_auto(), - Bullets => nscssvalue.set_enum(structs::NS_STYLE_COUNTER_SPEAKAS_BULLETS as i32), - Numbers => nscssvalue.set_enum(structs::NS_STYLE_COUNTER_SPEAKAS_NUMBERS as i32), - Words => nscssvalue.set_enum(structs::NS_STYLE_COUNTER_SPEAKAS_WORDS as i32), - Other(ref other) => nscssvalue.set_atom_ident(other.0.clone()), - } - } -} diff --git a/components/style/gecko_bindings/sugar/mod.rs b/components/style/gecko_bindings/sugar/mod.rs index 7811cf73d06..338236c175a 100644 --- a/components/style/gecko_bindings/sugar/mod.rs +++ b/components/style/gecko_bindings/sugar/mod.rs @@ -6,7 +6,6 @@ mod ns_com_ptr; mod ns_compatibility; -pub mod ns_css_value; mod ns_style_auto_array; pub mod ns_style_coord; mod ns_t_array; diff --git a/components/style/gecko_bindings/sugar/ns_css_value.rs b/components/style/gecko_bindings/sugar/ns_css_value.rs deleted file mode 100644 index 96b48061c8a..00000000000 --- a/components/style/gecko_bindings/sugar/ns_css_value.rs +++ /dev/null @@ -1,401 +0,0 @@ -/* 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 https://mozilla.org/MPL/2.0/. */ - -//! Little helpers for `nsCSSValue`. - -use crate::gecko_bindings::bindings; -use crate::gecko_bindings::structs; -use crate::gecko_bindings::structs::{nsCSSUnit, nsCSSValue}; -use crate::gecko_bindings::structs::{nsCSSValueList, nsCSSValue_Array}; -use crate::gecko_string_cache::Atom; -use crate::values::computed::{Angle, Length, LengthPercentage, Percentage}; -use crate::Zero; -use std::marker::PhantomData; -use std::mem; -use std::ops::{Index, IndexMut}; -use std::slice; - -impl nsCSSValue { - /// Create a CSSValue with null unit, useful to be used as a return value. - #[inline] - pub fn null() -> Self { - unsafe { mem::zeroed() } - } - - /// Returns true if this nsCSSValue is none. - #[inline] - pub fn is_none(&self) -> bool { - self.mUnit == nsCSSUnit::eCSSUnit_None - } - - /// Returns this nsCSSValue value as an integer, unchecked in release - /// builds. - pub fn integer_unchecked(&self) -> i32 { - debug_assert!( - self.mUnit == nsCSSUnit::eCSSUnit_Integer || - self.mUnit == nsCSSUnit::eCSSUnit_Enumerated - ); - unsafe { *self.mValue.mInt.as_ref() } - } - - /// Checks if it is an integer and returns it if so - pub fn integer(&self) -> Option { - if self.mUnit == nsCSSUnit::eCSSUnit_Integer || self.mUnit == nsCSSUnit::eCSSUnit_Enumerated - { - Some(unsafe { *self.mValue.mInt.as_ref() }) - } else { - None - } - } - - /// Returns this nsCSSValue value as a floating point value, unchecked in - /// release builds. - pub fn float_unchecked(&self) -> f32 { - debug_assert!(nsCSSUnit::eCSSUnit_Number as u32 <= self.mUnit as u32); - unsafe { *self.mValue.mFloat.as_ref() } - } - - /// Returns this nsCSSValue as a nsCSSValue::Array, unchecked in release - /// builds. - pub unsafe fn array_unchecked(&self) -> &nsCSSValue_Array { - debug_assert!( - nsCSSUnit::eCSSUnit_Array as u32 <= self.mUnit as u32 && - self.mUnit as u32 <= nsCSSUnit::eCSSUnit_Calc_Plus as u32 - ); - let array = *self.mValue.mArray.as_ref(); - debug_assert!(!array.is_null()); - &*array - } - - /// Sets LengthPercentage value to this nsCSSValue. - pub unsafe fn set_length_percentage(&mut self, lp: LengthPercentage) { - if lp.was_calc { - return bindings::Gecko_CSSValue_SetCalc(self, lp.into()); - } - debug_assert!(!lp.has_percentage || lp.unclamped_length() == Length::zero()); - if lp.has_percentage { - return self.set_percentage(lp.percentage()); - } - self.set_px(lp.unclamped_length().px()); - } - - /// Sets a px value to this nsCSSValue. - pub unsafe fn set_px(&mut self, px: f32) { - bindings::Gecko_CSSValue_SetPixelLength(self, px) - } - - /// Sets a percentage value to this nsCSSValue. - pub unsafe fn set_percentage(&mut self, unit_value: f32) { - bindings::Gecko_CSSValue_SetPercentage(self, unit_value) - } - - /// Returns LengthPercentage value. - pub unsafe fn get_length_percentage(&self) -> LengthPercentage { - match self.mUnit { - nsCSSUnit::eCSSUnit_Pixel => { - LengthPercentage::new(Length::new(bindings::Gecko_CSSValue_GetNumber(self)), None) - }, - nsCSSUnit::eCSSUnit_Percent => LengthPercentage::new_percent(Percentage( - bindings::Gecko_CSSValue_GetPercentage(self), - )), - nsCSSUnit::eCSSUnit_Calc => bindings::Gecko_CSSValue_GetCalc(self).into(), - _ => panic!("Unexpected unit"), - } - } - - /// Returns Length value. - pub unsafe fn get_length(&self) -> Length { - match self.mUnit { - nsCSSUnit::eCSSUnit_Pixel => Length::new(bindings::Gecko_CSSValue_GetNumber(self)), - _ => panic!("Unexpected unit"), - } - } - - fn set_valueless_unit(&mut self, unit: nsCSSUnit) { - debug_assert_eq!(self.mUnit, nsCSSUnit::eCSSUnit_Null); - debug_assert!( - unit as u32 <= nsCSSUnit::eCSSUnit_DummyInherit as u32, - "Not a valueless unit" - ); - self.mUnit = unit; - } - - /// Set to an auto value - /// - /// This method requires the current value to be null. - pub fn set_auto(&mut self) { - self.set_valueless_unit(nsCSSUnit::eCSSUnit_Auto); - } - - /// Set to a normal value - /// - /// This method requires the current value to be null. - pub fn set_normal(&mut self) { - self.set_valueless_unit(nsCSSUnit::eCSSUnit_Normal); - } - - fn set_string_internal(&mut self, s: &str, unit: nsCSSUnit) { - unsafe { bindings::Gecko_CSSValue_SetString(self, s.as_ptr(), s.len() as u32, unit) } - } - - fn set_string_from_atom_internal(&mut self, s: &Atom, unit: nsCSSUnit) { - unsafe { bindings::Gecko_CSSValue_SetStringFromAtom(self, s.as_ptr(), unit) } - } - - /// Set to a string value - pub fn set_string(&mut self, s: &str) { - self.set_string_internal(s, nsCSSUnit::eCSSUnit_String) - } - - /// Set to a string value from the given atom - pub fn set_string_from_atom(&mut self, s: &Atom) { - self.set_string_from_atom_internal(s, nsCSSUnit::eCSSUnit_String) - } - - /// Set to a ident value from the given atom - pub fn set_ident_from_atom(&mut self, s: &Atom) { - self.set_string_from_atom_internal(s, nsCSSUnit::eCSSUnit_Ident) - } - - /// Set to an identifier value - pub fn set_ident(&mut self, s: &str) { - self.set_string_internal(s, nsCSSUnit::eCSSUnit_Ident) - } - - /// Set to an atom identifier value - pub fn set_atom_ident(&mut self, s: Atom) { - unsafe { bindings::Gecko_CSSValue_SetAtomIdent(self, s.into_addrefed()) } - } - - fn set_int_internal(&mut self, value: i32, unit: nsCSSUnit) { - unsafe { bindings::Gecko_CSSValue_SetInt(self, value, unit) } - } - - /// Set to an integer value - pub fn set_integer(&mut self, value: i32) { - self.set_int_internal(value, nsCSSUnit::eCSSUnit_Integer) - } - - /// Set to an enumerated value - pub fn set_enum>(&mut self, value: T) { - self.set_int_internal(value.into(), nsCSSUnit::eCSSUnit_Enumerated); - } - - /// Set to a number value - pub fn set_number(&mut self, number: f32) { - unsafe { bindings::Gecko_CSSValue_SetFloat(self, number, nsCSSUnit::eCSSUnit_Number) } - } - - /// Set to an array of given length - pub fn set_array(&mut self, len: i32) -> &mut nsCSSValue_Array { - unsafe { bindings::Gecko_CSSValue_SetArray(self, len) } - unsafe { self.mValue.mArray.as_mut().as_mut() }.unwrap() - } - - /// Generic set from any value that implements the ToNsCssValue trait. - pub fn set_from(&mut self, value: T) { - value.convert(self) - } - - /// Returns an `Angle` value from this `nsCSSValue`. - /// - /// Panics if the unit is not `eCSSUnit_Degree`. - #[inline] - pub fn get_angle(&self) -> Angle { - debug_assert_eq!(self.mUnit, nsCSSUnit::eCSSUnit_Degree); - Angle::from_degrees(self.float_unchecked()) - } - - /// Sets Angle value to this nsCSSValue. - pub fn set_angle(&mut self, angle: Angle) { - debug_assert_eq!(self.mUnit, nsCSSUnit::eCSSUnit_Null); - self.mUnit = nsCSSUnit::eCSSUnit_Degree; - unsafe { - *self.mValue.mFloat.as_mut() = angle.degrees(); - } - } - - /// Set to a pair value - /// - /// This is only supported on the main thread. - pub fn set_pair(&mut self, x: &nsCSSValue, y: &nsCSSValue) { - unsafe { bindings::Gecko_CSSValue_SetPair(self, x, y) } - } - - /// Set to a list value - /// - /// This is only supported on the main thread. - pub fn set_list(&mut self, values: I) - where - I: ExactSizeIterator, - { - debug_assert!(values.len() > 0, "Empty list is not supported"); - unsafe { - bindings::Gecko_CSSValue_SetList(self, values.len() as u32); - } - debug_assert_eq!(self.mUnit, nsCSSUnit::eCSSUnit_List); - let list: &mut structs::nsCSSValueList = &mut unsafe { - self.mValue - .mList - .as_ref() // &*nsCSSValueList_heap - .as_mut() - .expect("List pointer should be non-null") - } - ._base; - for (item, new_value) in list.into_iter().zip(values) { - *item = new_value; - } - } - - /// Set to a pair list value - /// - /// This is only supported on the main thread. - pub fn set_pair_list(&mut self, mut values: I) - where - I: ExactSizeIterator, - { - debug_assert!(values.len() > 0, "Empty list is not supported"); - unsafe { - bindings::Gecko_CSSValue_SetPairList(self, values.len() as u32); - } - debug_assert_eq!(self.mUnit, nsCSSUnit::eCSSUnit_PairList); - let mut item_ptr = &mut unsafe { - self.mValue - .mPairList - .as_ref() // &*nsCSSValuePairList_heap - .as_mut() - .expect("List pointer should be non-null") - } - ._base as *mut structs::nsCSSValuePairList; - while let Some(item) = unsafe { item_ptr.as_mut() } { - let value = values.next().expect("Values shouldn't have been exhausted"); - item.mXValue = value.0; - item.mYValue = value.1; - item_ptr = item.mNext; - } - debug_assert!(values.next().is_none(), "Values should have been exhausted"); - } -} - -impl Drop for nsCSSValue { - fn drop(&mut self) { - unsafe { bindings::Gecko_CSSValue_Drop(self) }; - } -} - -/// Iterator of nsCSSValueList. -#[allow(non_camel_case_types)] -pub struct nsCSSValueListIterator<'a> { - current: Option<&'a nsCSSValueList>, -} - -impl<'a> Iterator for nsCSSValueListIterator<'a> { - type Item = &'a nsCSSValue; - fn next(&mut self) -> Option { - match self.current { - Some(item) => { - self.current = unsafe { item.mNext.as_ref() }; - Some(&item.mValue) - }, - None => None, - } - } -} - -impl<'a> IntoIterator for &'a nsCSSValueList { - type Item = &'a nsCSSValue; - type IntoIter = nsCSSValueListIterator<'a>; - - fn into_iter(self) -> Self::IntoIter { - nsCSSValueListIterator { - current: Some(self), - } - } -} - -/// Mutable Iterator of nsCSSValueList. -#[allow(non_camel_case_types)] -pub struct nsCSSValueListMutIterator<'a> { - current: *mut nsCSSValueList, - phantom: PhantomData<&'a mut nsCSSValue>, -} - -impl<'a> Iterator for nsCSSValueListMutIterator<'a> { - type Item = &'a mut nsCSSValue; - fn next(&mut self) -> Option { - match unsafe { self.current.as_mut() } { - Some(item) => { - self.current = item.mNext; - Some(&mut item.mValue) - }, - None => None, - } - } -} - -impl<'a> IntoIterator for &'a mut nsCSSValueList { - type Item = &'a mut nsCSSValue; - type IntoIter = nsCSSValueListMutIterator<'a>; - - fn into_iter(self) -> Self::IntoIter { - nsCSSValueListMutIterator { - current: self as *mut nsCSSValueList, - phantom: PhantomData, - } - } -} - -impl nsCSSValue_Array { - /// Return the length of this `nsCSSValue::Array` - #[inline] - pub fn len(&self) -> usize { - self.mCount - } - - #[inline] - fn buffer(&self) -> *const nsCSSValue { - self.mArray.as_ptr() - } - - /// Get the array as a slice of nsCSSValues. - #[inline] - pub fn as_slice(&self) -> &[nsCSSValue] { - unsafe { slice::from_raw_parts(self.buffer(), self.len()) } - } - - /// Get the array as a mutable slice of nsCSSValues. - #[inline] - pub fn as_mut_slice(&mut self) -> &mut [nsCSSValue] { - unsafe { slice::from_raw_parts_mut(self.buffer() as *mut _, self.len()) } - } -} - -impl Index for nsCSSValue_Array { - type Output = nsCSSValue; - #[inline] - fn index(&self, i: usize) -> &nsCSSValue { - &self.as_slice()[i] - } -} - -impl IndexMut for nsCSSValue_Array { - #[inline] - fn index_mut(&mut self, i: usize) -> &mut nsCSSValue { - &mut self.as_mut_slice()[i] - } -} - -/// Generic conversion to nsCSSValue -pub trait ToNsCssValue { - /// Convert - fn convert(self, nscssvalue: &mut nsCSSValue); -} - -impl From for nsCSSValue { - fn from(value: T) -> nsCSSValue { - let mut result = nsCSSValue::null(); - value.convert(&mut result); - result - } -}