Scroll margin and padding

devongovett · devongovett · commit 7645fd2ccae4 · 2021-10-20T22:52:08.000-06:00
diff --git a/src/parser.rs b/src/parser.rs
@@ -4,6 +4,7 @@ use std::fmt;
 use std::cell::RefCell;
 use crate::media_query::*;
 use crate::properties::*;
+use crate::values::traits::PropertyHandler;
 
 #[derive(Debug, Clone)]
 pub struct Selectors;
@@ -380,20 +381,30 @@ impl StyleRule {
     use crate::values::border::*;
     use crate::properties::margin_padding::*;
 
+    // TODO: somehow macro-ify this
     let mut border_handler = BorderHandler::default();
     let mut margin_handler = MarginHandler::default();
     let mut padding_handler = PaddingHandler::default();
+    let mut scroll_margin_handler = MarginHandler::default();
+    let mut scroll_padding_handler = PaddingHandler::default();
 
     let mut decls = vec![];
     for decl in self.declarations.iter() {
-      if !border_handler.handle_property(decl) && !margin_handler.handle_property(decl) && !padding_handler.handle_property(decl) {
+      if !border_handler.handle_property(decl) && 
+        !margin_handler.handle_property(decl) && 
+        !padding_handler.handle_property(decl) &&
+        !scroll_margin_handler.handle_property(decl) && 
+        !scroll_padding_handler.handle_property(decl)
+      {
         decls.push(decl.clone());
       }
     }
 
     decls.extend(border_handler.finalize());
     decls.extend(margin_handler.finalize());
     decls.extend(padding_handler.finalize());
+    decls.extend(scroll_margin_handler.finalize());
+    decls.extend(scroll_padding_handler.finalize());
     self.declarations = decls;
   }
 }
diff --git a/src/properties/margin_padding.rs b/src/properties/margin_padding.rs
@@ -1,5 +1,6 @@
 use crate::values::{length::{Size2D, LengthPercentageOrAuto}, rect::Rect};
 use crate::properties::Property;
+use crate::values::traits::PropertyHandler;
 
 #[derive(Debug, PartialEq)]
 enum SideCategory {
@@ -29,8 +30,8 @@ macro_rules! side_handler {
       decls: Vec<Property>
     }
 
-    impl $name {
-      pub fn handle_property(&mut self, property: &Property) -> bool {
+    impl PropertyHandler for $name {
+      fn handle_property(&mut self, property: &Property) -> bool {
         use Property::*;
         use SideCategory::*;
 
@@ -83,6 +84,13 @@ macro_rules! side_handler {
         true
       }
 
+      fn finalize(&mut self) -> Vec<Property> {
+        self.flush();
+        std::mem::take(&mut self.decls)
+      }
+    }
+
+    impl $name {
       fn flush(&mut self) {
         use Property::*;
 
@@ -137,11 +145,6 @@ macro_rules! side_handler {
         logical_side!(block_start, block_end, $block_shorthand, $block_start, $block_end);
         logical_side!(inline_start, inline_end, $inline_shorthand, $inline_start, $inline_end);
       }
-
-      pub fn finalize(&mut self) -> Vec<Property> {
-        self.flush();
-        std::mem::take(&mut self.decls)
-      }
     }
   };
 }
@@ -175,3 +178,33 @@ side_handler!(
   PaddingBlock,
   PaddingInline
 );
+
+side_handler!(
+  ScrollMarginHandler,
+  ScrollMarginTop,
+  ScrollMarginBottom,
+  ScrollMarginLeft,
+  ScrollMarginRight,
+  ScrollMarginBlockStart,
+  ScrollMarginBlockEnd,
+  ScrollMarginInlineStart,
+  ScrollMarginInlineEnd,
+  ScrollMargin,
+  ScrollMarginBlock,
+  ScrollMarginInline
+);
+
+side_handler!(
+  ScrollPaddingHandler,
+  ScrollPaddingTop,
+  ScrollPaddingBottom,
+  ScrollPaddingLeft,
+  ScrollPaddingRight,
+  ScrollPaddingBlockStart,
+  ScrollPaddingBlockEnd,
+  ScrollPaddingInlineStart,
+  ScrollPaddingInlineEnd,
+  ScrollPadding,
+  ScrollPaddingBlock,
+  ScrollPaddingInline
+);
diff --git a/src/properties/mod.rs b/src/properties/mod.rs
@@ -144,6 +144,30 @@ pub enum Property {
   PaddingInline(Size2D<LengthPercentageOrAuto>),
   Padding(Rect<LengthPercentageOrAuto>),
 
+  ScrollMarginTop(LengthPercentageOrAuto),
+  ScrollMarginBottom(LengthPercentageOrAuto),
+  ScrollMarginLeft(LengthPercentageOrAuto),
+  ScrollMarginRight(LengthPercentageOrAuto),
+  ScrollMarginBlockStart(LengthPercentageOrAuto),
+  ScrollMarginBlockEnd(LengthPercentageOrAuto),
+  ScrollMarginInlineStart(LengthPercentageOrAuto),
+  ScrollMarginInlineEnd(LengthPercentageOrAuto),
+  ScrollMarginBlock(Size2D<LengthPercentageOrAuto>),
+  ScrollMarginInline(Size2D<LengthPercentageOrAuto>),
+  ScrollMargin(Rect<LengthPercentageOrAuto>),
+
+  ScrollPaddingTop(LengthPercentageOrAuto),
+  ScrollPaddingBottom(LengthPercentageOrAuto),
+  ScrollPaddingLeft(LengthPercentageOrAuto),
+  ScrollPaddingRight(LengthPercentageOrAuto),
+  ScrollPaddingBlockStart(LengthPercentageOrAuto),
+  ScrollPaddingBlockEnd(LengthPercentageOrAuto),
+  ScrollPaddingInlineStart(LengthPercentageOrAuto),
+  ScrollPaddingInlineEnd(LengthPercentageOrAuto),
+  ScrollPaddingBlock(Size2D<LengthPercentageOrAuto>),
+  ScrollPaddingInline(Size2D<LengthPercentageOrAuto>),
+  ScrollPadding(Rect<LengthPercentageOrAuto>),
+
   // ScrollMargin
   // ScrollPadding
 }
@@ -269,6 +293,28 @@ impl Property {
       "padding-block" => property!(PaddingBlock, Size2D),
       "padding-inline" => property!(PaddingInline, Size2D),
       "padding" => property!(Padding, Rect),
+      "scroll-margin-left" => property!(ScrollMarginLeft, LengthPercentageOrAuto),
+      "scroll-margin-right" => property!(ScrollMarginRight, LengthPercentageOrAuto),
+      "scroll-margin-top" => property!(ScrollMarginTop, LengthPercentageOrAuto),
+      "scroll-margin-bottom" => property!(ScrollMarginBottom, LengthPercentageOrAuto),
+      "scroll-margin-block-start" => property!(ScrollMarginBlockStart, LengthPercentageOrAuto),
+      "scroll-margin-block-end" => property!(ScrollMarginBlockEnd, LengthPercentageOrAuto),
+      "scroll-margin-inline-start" => property!(ScrollMarginInlineStart, LengthPercentageOrAuto),
+      "scroll-margin-inline-end" => property!(ScrollMarginInlineEnd, LengthPercentageOrAuto),
+      "scroll-margin-block" => property!(ScrollMarginBlock, Size2D),
+      "scroll-margin-inline" => property!(ScrollMarginInline, Size2D),
+      "scroll-margin" => property!(ScrollMargin, Rect),
+      "scroll-padding-left" => property!(ScrollPaddingLeft, LengthPercentageOrAuto),
+      "scroll-padding-right" => property!(ScrollPaddingRight, LengthPercentageOrAuto),
+      "scroll-padding-top" => property!(ScrollPaddingTop, LengthPercentageOrAuto),
+      "scroll-padding-bottom" => property!(ScrollPaddingBottom, LengthPercentageOrAuto),
+      "scroll-padding-block-start" => property!(ScrollPaddingBlockStart, LengthPercentageOrAuto),
+      "scroll-padding-block-end" => property!(ScrollPaddingBlockEnd, LengthPercentageOrAuto),
+      "scroll-padding-inline-start" => property!(ScrollPaddingInlineStart, LengthPercentageOrAuto),
+      "scroll-padding-inline-end" => property!(ScrollPaddingInlineEnd, LengthPercentageOrAuto),
+      "scroll-padding-block" => property!(ScrollPaddingBlock, Size2D),
+      "scroll-padding-inline" => property!(ScrollPaddingInline, Size2D),
+      "scroll-padding" => property!(ScrollPadding, Rect),
       _ => {}
     }
 
@@ -406,6 +452,28 @@ impl Property {
       PaddingBlock(val) => property!("padding-block", val),
       PaddingInline(val) => property!("padding-inline", val),
       Padding(val) => property!("padding", val),
+      ScrollMarginLeft(val) => property!("scroll-margin-left", val),
+      ScrollMarginRight(val) => property!("scroll-margin-right", val),
+      ScrollMarginTop(val) => property!("scroll-margin-top", val),
+      ScrollMarginBottom(val) => property!("scroll-margin-bottom", val),
+      ScrollMarginBlockStart(val) => property!("scroll-margin-block-start", val),
+      ScrollMarginBlockEnd(val) => property!("scroll-margin-block-end", val),
+      ScrollMarginInlineStart(val) => property!("scroll-margin-inline-start", val),
+      ScrollMarginInlineEnd(val) => property!("scroll-margin-inline-end", val),
+      ScrollMarginBlock(val) => property!("scroll-margin-block", val),
+      ScrollMarginInline(val) => property!("scroll-margin-inline", val),
+      ScrollMargin(val) => property!("scroll-margin", val),
+      ScrollPaddingLeft(val) => property!("scroll-padding-left", val),
+      ScrollPaddingRight(val) => property!("scroll-padding-right", val),
+      ScrollPaddingTop(val) => property!("scroll-padding-top", val),
+      ScrollPaddingBottom(val) => property!("scroll-padding-bottom", val),
+      ScrollPaddingBlockStart(val) => property!("scroll-padding-block-start", val),
+      ScrollPaddingBlockEnd(val) => property!("scroll-padding-block-end", val),
+      ScrollPaddingInlineStart(val) => property!("scroll-padding-inline-start", val),
+      ScrollPaddingInlineEnd(val) => property!("scroll-padding-inline-end", val),
+      ScrollPaddingBlock(val) => property!("scroll-padding-block", val),
+      ScrollPaddingInline(val) => property!("scroll-padding-inline", val),
+      ScrollPadding(val) => property!("scroll-padding", val),
       Custom(custom) => {
         dest.write_str(custom.name.as_ref())?;
         dest.write_str(": ")?;
diff --git a/src/values/border.rs b/src/values/border.rs
@@ -1,6 +1,6 @@
 use super::length::*;
 use cssparser::*;
-use super::traits::{Parse, ToCss};
+use super::traits::{Parse, ToCss, PropertyHandler};
 use super::color::CssColor;
 use crate::properties::Property;
 use super::rect::Rect;
@@ -198,8 +198,8 @@ pub struct BorderHandler {
   border_radius_handler: BorderRadiusHandler
 }
 
-impl BorderHandler {
-  pub fn handle_property(&mut self, property: &Property) -> bool {
+impl PropertyHandler for BorderHandler {
+  fn handle_property(&mut self, property: &Property) -> bool {
     use Property::*;
     use BorderCategory::*;
 
@@ -316,6 +316,15 @@ impl BorderHandler {
     true
   }
 
+  fn finalize(&mut self) -> Vec<Property> {
+    self.flush();
+    self.decls.extend(self.border_image_handler.finalize());
+    self.decls.extend(self.border_radius_handler.finalize());
+    std::mem::take(&mut self.decls)
+  }
+}
+
+impl BorderHandler {
   fn flush(&mut self) {
     use Property::*;
 
@@ -518,11 +527,4 @@ impl BorderHandler {
     self.border_inline_start.reset();
     self.border_inline_end.reset();
   }
-
-  pub fn finalize(&mut self) -> Vec<Property> {
-    self.flush();
-    self.decls.extend(self.border_image_handler.finalize());
-    self.decls.extend(self.border_radius_handler.finalize());
-    std::mem::take(&mut self.decls)
-  }
 }
diff --git a/src/values/border_image.rs b/src/values/border_image.rs
@@ -1,6 +1,6 @@
 use super::length::{*, NumberOrPercentage};
 use cssparser::*;
-use super::traits::{Parse, ToCss};
+use super::traits::{Parse, ToCss, PropertyHandler};
 use crate::properties::Property;
 use super::rect::Rect;
 use super::image::Image;
@@ -246,8 +246,8 @@ pub struct BorderImageHandler {
   repeat: Option<BorderImageRepeat>
 }
 
-impl BorderImageHandler {
-  pub fn handle_property(&mut self, property: &Property) -> bool {
+impl PropertyHandler for BorderImageHandler {
+  fn handle_property(&mut self, property: &Property) -> bool {
     use Property::*;
     match property {
       BorderImageSource(val) => self.source = Some(val.clone()),
@@ -262,23 +262,7 @@ impl BorderImageHandler {
     true
   }
 
-  pub fn reset(&mut self) {
-    self.source = None;
-    self.slice = None;
-    self.width = None;
-    self.outset = None;
-    self.repeat = None;
-  }
-
-  pub fn set_border_image(&mut self, border_image: &BorderImage) {
-    self.source = Some(border_image.source.clone());
-    self.slice = Some(border_image.slice.clone());
-    self.width = Some(border_image.width.clone());
-    self.outset = Some(border_image.outset.clone());
-    self.repeat = Some(border_image.repeat.clone());
-  }
-
-  pub fn finalize(&mut self) -> Vec<Property> {
+  fn finalize(&mut self) -> Vec<Property> {
     let mut decls = vec![];
     let source = std::mem::take(&mut self.source);
     let slice = std::mem::take(&mut self.slice);
@@ -319,3 +303,21 @@ impl BorderImageHandler {
     decls
   }
 }
+
+impl BorderImageHandler {
+  pub fn reset(&mut self) {
+    self.source = None;
+    self.slice = None;
+    self.width = None;
+    self.outset = None;
+    self.repeat = None;
+  }
+
+  pub fn set_border_image(&mut self, border_image: &BorderImage) {
+    self.source = Some(border_image.source.clone());
+    self.slice = Some(border_image.slice.clone());
+    self.width = Some(border_image.width.clone());
+    self.outset = Some(border_image.outset.clone());
+    self.repeat = Some(border_image.repeat.clone());
+  }
+}
diff --git a/src/values/border_radius.rs b/src/values/border_radius.rs
@@ -1,6 +1,6 @@
 use super::length::*;
 use cssparser::*;
-use super::traits::{Parse, ToCss};
+use super::traits::{Parse, ToCss, PropertyHandler};
 use crate::properties::Property;
 use super::rect::Rect;
 
@@ -54,8 +54,8 @@ pub struct BorderRadiusHandler {
   decls: Vec<Property>
 }
 
-impl BorderRadiusHandler {
-  pub fn handle_property(&mut self, property: &Property) -> bool {
+impl PropertyHandler for BorderRadiusHandler {
+  fn handle_property(&mut self, property: &Property) -> bool {
     use Property::*;
     match property {
       BorderTopLeftRadius(val) => self.top_left = Some(val.clone()),
@@ -79,7 +79,14 @@ impl BorderRadiusHandler {
     true
   }
 
-  pub fn flush(&mut self) {
+  fn finalize(&mut self) -> Vec<Property> {
+    self.flush();
+    std::mem::take(&mut self.decls)
+  }
+}
+
+impl BorderRadiusHandler {
+  fn flush(&mut self) {
     let top_left = std::mem::take(&mut self.top_left);
     let top_right = std::mem::take(&mut self.top_right);
     let bottom_left = std::mem::take(&mut self.bottom_left);
@@ -110,9 +117,4 @@ impl BorderRadiusHandler {
       }
     }
   }
-
-  pub fn finalize(&mut self) -> Vec<Property> {
-    self.flush();
-    std::mem::take(&mut self.decls)
-  }
 }
diff --git a/src/values/traits.rs b/src/values/traits.rs
@@ -1,4 +1,5 @@
 use cssparser::*;
+use crate::properties::Property;
 
 pub trait Parse: Sized {
   /// Parse a value of this type.
@@ -33,3 +34,8 @@ where
       (*self).to_css(dest)
     }
 }
+
+pub trait PropertyHandler: Sized {
+  fn handle_property(&mut self, property: &Property) -> bool;
+  fn finalize(&mut self) -> Vec<Property>;
+}

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`use cssparser::*;`
	`2`	`+use crate::properties::Property;`
`2`	`3`
`3`	`4`	`pub trait Parse: Sized {`
`4`	`5`	`/// Parse a value of this type.`
`@@ -33,3 +34,8 @@ where`
`33`	`34`	`(*self).to_css(dest)`
`34`	`35`	`}`
`35`	`36`	`}`
	`37`	`+`
	`38`	`+pub trait PropertyHandler: Sized {`
	`39`	`+ fn handle_property(&mut self, property: &Property) -> bool;`
	`40`	`+ fn finalize(&mut self) -> Vec<Property>;`
	`41`	`+}`