diff options
Diffstat (limited to 'src/library')
| -rw-r--r-- | src/library/align.rs | 18 | ||||
| -rw-r--r-- | src/library/boxed.rs | 6 | ||||
| -rw-r--r-- | src/library/direction.rs | 26 | ||||
| -rw-r--r-- | src/library/keys.rs | 141 | ||||
| -rw-r--r-- | src/library/maps.rs | 27 | ||||
| -rw-r--r-- | src/library/mod.rs | 10 |
6 files changed, 116 insertions, 112 deletions
diff --git a/src/library/align.rs b/src/library/align.rs index 3b06fe2c..616ede6b 100644 --- a/src/library/align.rs +++ b/src/library/align.rs @@ -34,20 +34,20 @@ function! { let map = self.map.dedup(|key, alignment| { let axis = match key { - Key::First => alignment.axis(axes, GenericAxisKind::Primary), - Key::Second => alignment.axis(axes, GenericAxisKind::Secondary), - Key::Axis(AxisKey::Primary) => GenericAxisKind::Primary, - Key::Axis(AxisKey::Secondary) => GenericAxisKind::Secondary, - Key::Axis(AxisKey::Horizontal) => axes.horizontal(), - Key::Axis(AxisKey::Vertical) => axes.vertical(), + Key::First => alignment.axis(axes, Primary), + Key::Second => alignment.axis(axes, Secondary), + Key::Axis(AxisKey::Primary) => Primary, + Key::Axis(AxisKey::Secondary) => Secondary, + Key::Axis(AxisKey::Horizontal) => Horizontal.to_generic(axes), + Key::Axis(AxisKey::Vertical) => Vertical.to_generic(axes), }; - let alignment = alignment.generic(axes, axis)?; + let alignment = alignment.to_generic(axes, axis)?; Ok((axis, alignment)) })?; - map.with(GenericAxisKind::Primary, |&val| ctx.alignment.primary = val); - map.with(GenericAxisKind::Secondary, |&val| ctx.alignment.secondary = val); + map.with(Primary, |&val| ctx.alignment.primary = val); + map.with(Secondary, |&val| ctx.alignment.secondary = val); match &self.body { Some(body) => vec![AddMultiple(layout_tree(&body, ctx)?)], diff --git a/src/library/boxed.rs b/src/library/boxed.rs index 0428e746..c205eec6 100644 --- a/src/library/boxed.rs +++ b/src/library/boxed.rs @@ -21,15 +21,13 @@ function! { } layout(self, mut ctx) { - use SpecificAxisKind::*; - ctx.debug = self.debug; let space = &mut ctx.spaces[0]; self.map.apply_with(ctx.axes, |axis, p| { let entity = match axis { - Horizontal => { space.expand.horizontal = true; &mut space.dimensions.x }, - Vertical => { space.expand.vertical = true; &mut space.dimensions.y }, + Horizontal => { space.expansion.horizontal = true; &mut space.dimensions.x }, + Vertical => { space.expansion.vertical = true; &mut space.dimensions.y }, }; *entity = p.concretize(*entity) diff --git a/src/library/direction.rs b/src/library/direction.rs index 7edad323..ac1fac08 100644 --- a/src/library/direction.rs +++ b/src/library/direction.rs @@ -5,25 +5,25 @@ use super::keys::AxisKey; function! { /// `direction`: Sets the directions of the layouting axes. #[derive(Debug, PartialEq)] - pub struct Direction { + pub struct DirectionChange { body: Option<SyntaxTree>, - map: ConsistentMap<AxisKey, Axis>, + map: ConsistentMap<AxisKey, Direction>, } parse(args, body, ctx) { let mut map = ConsistentMap::new(); - map.add_opt_span(AxisKey::Primary, args.get_pos_opt::<Axis>()?)?; - map.add_opt_span(AxisKey::Secondary, args.get_pos_opt::<Axis>()?)?; + map.add_opt_span(AxisKey::Primary, args.get_pos_opt::<Direction>()?)?; + map.add_opt_span(AxisKey::Secondary, args.get_pos_opt::<Direction>()?)?; for arg in args.keys() { let axis = AxisKey::from_ident(&arg.v.key)?; - let value = Axis::from_expr(arg.v.value)?; + let value = Direction::from_expr(arg.v.value)?; map.add(axis, value)?; } - Direction { + DirectionChange { body: parse!(optional: body, ctx), map, } @@ -34,17 +34,17 @@ function! { let map = self.map.dedup(|key, &direction| { Ok((match key { - AxisKey::Primary => GenericAxisKind::Primary, - AxisKey::Secondary => GenericAxisKind::Secondary, - AxisKey::Horizontal => axes.horizontal(), - AxisKey::Vertical => axes.vertical(), + AxisKey::Primary => Primary, + AxisKey::Secondary => Secondary, + AxisKey::Horizontal => Horizontal.to_generic(axes), + AxisKey::Vertical => Vertical.to_generic(axes), }, direction)) })?; - map.with(GenericAxisKind::Primary, |&val| ctx.axes.primary = val); - map.with(GenericAxisKind::Secondary, |&val| ctx.axes.secondary = val); + map.with(Primary, |&val| ctx.axes.primary = val); + map.with(Secondary, |&val| ctx.axes.secondary = val); - if ctx.axes.primary.is_horizontal() == ctx.axes.secondary.is_horizontal() { + if ctx.axes.primary.axis() == ctx.axes.secondary.axis() { error!( "aligned primary and secondary axes: `{}`, `{}`", format!("{:?}", ctx.axes.primary).to_lowercase(), diff --git a/src/library/keys.rs b/src/library/keys.rs index 969d92be..bee45638 100644 --- a/src/library/keys.rs +++ b/src/library/keys.rs @@ -39,33 +39,26 @@ pub enum AxisKey { impl AxisKey { /// The generic version of this axis key in the given system of axes. - pub fn generic(&self, axes: LayoutAxes) -> GenericAxisKind { + pub fn to_generic(self, axes: LayoutAxes) -> GenericAxis { match self { - AxisKey::Primary => GenericAxisKind::Primary, - AxisKey::Secondary => GenericAxisKind::Secondary, - AxisKey::Vertical => axes.vertical(), - AxisKey::Horizontal => axes.horizontal(), + AxisKey::Primary => Primary, + AxisKey::Secondary => Secondary, + AxisKey::Vertical => Vertical.to_generic(axes), + AxisKey::Horizontal => Horizontal.to_generic(axes), } } /// The specific version of this axis key in the given system of axes. - pub fn specific(&self, axes: LayoutAxes) -> SpecificAxisKind { + pub fn to_specific(self, axes: LayoutAxes) -> SpecificAxis { match self { - AxisKey::Primary => axes.primary(), - AxisKey::Secondary => axes.secondary(), - AxisKey::Vertical => SpecificAxisKind::Vertical, - AxisKey::Horizontal => SpecificAxisKind::Horizontal, + AxisKey::Primary => Primary.to_specific(axes), + AxisKey::Secondary => Secondary.to_specific(axes), + AxisKey::Vertical => Vertical, + AxisKey::Horizontal => Horizontal, } } } -kind!(AxisKey, "axis", - "horizontal" => AxisKey::Horizontal, - "vertical" => AxisKey::Vertical, - "primary" => AxisKey::Primary, - "secondary" => AxisKey::Secondary, -); - /// An argument key which describes a target alignment. #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] pub enum AlignmentKey { @@ -81,29 +74,35 @@ pub enum AlignmentKey { impl AlignmentKey { /// The generic axis this alignment key corresopnds to in the given system /// of layouting axes. Falls back to `default` if the alignment is generic. - pub fn axis(&self, axes: LayoutAxes, default: GenericAxisKind) -> GenericAxisKind { + pub fn axis(self, axes: LayoutAxes, default: GenericAxis) -> GenericAxis { use AlignmentKey::*; match self { Origin | Center | End => default, - Left | Right => axes.horizontal(), - Top | Bottom => axes.vertical(), + Left | Right => Horizontal.to_generic(axes), + Top | Bottom => Vertical.to_generic(axes), } } /// The generic version of this alignment in the given system of layouting - /// axes. Returns an error if the alignment is invalid for the given axis. - pub fn generic(&self, axes: LayoutAxes, axis: GenericAxisKind) -> LayoutResult<Alignment> { - use AlignmentKey::*; + /// axes. + /// + /// Returns an error if the alignment is invalid for the given axis. + pub fn to_generic(self, axes: LayoutAxes, axis: GenericAxis) -> LayoutResult<Alignment> { + let specific = axis.to_specific(axes); + + Ok(match (self, specific) { + (AlignmentKey::Origin, _) => Origin, + (AlignmentKey::Center, _) => Center, + (AlignmentKey::End, _) => End, + + (AlignmentKey::Left, Horizontal) | (AlignmentKey::Top, Vertical) => { + if axes.get_specific(specific).is_positive() { Origin } else { End } + } + + (AlignmentKey::Right, Horizontal) | (AlignmentKey::Bottom, Vertical) => { + if axes.get_specific(specific).is_positive() { End } else { Origin } + } - let horizontal = axis == axes.horizontal(); - Ok(match self { - Origin => Alignment::Origin, - Center => Alignment::Center, - End => Alignment::End, - Left if horizontal => axes.left(), - Right if horizontal => axes.right(), - Top if !horizontal => axes.top(), - Bottom if !horizontal => axes.bottom(), _ => error!( "invalid alignment `{}` for {} axis", format!("{:?}", self).to_lowercase(), @@ -114,31 +113,20 @@ impl AlignmentKey { /// The specific version of this alignment in the given system of layouting /// axes. - pub fn specific(&self, axes: LayoutAxes, axis: SpecificAxisKind) -> AlignmentKey { + pub fn to_specific(self, axes: LayoutAxes, axis: SpecificAxis) -> AlignmentKey { use AlignmentKey::*; - use SpecificAxisKind::*; - let positive = axes.specific(axis).is_positive(); + let positive = axes.get_specific(axis).is_positive(); match (self, axis, positive) { (Origin, Horizontal, true) | (End, Horizontal, false) => Left, (End, Horizontal, true) | (Origin, Horizontal, false) => Right, (Origin, Vertical, true) | (End, Vertical, false) => Top, (End, Vertical, true) | (Origin, Vertical, false) => Bottom, - _ => *self, + _ => self, } } } -kind!(AlignmentKey, "alignment", - "left" => AlignmentKey::Left, - "top" => AlignmentKey::Top, - "right" => AlignmentKey::Right, - "bottom" => AlignmentKey::Bottom, - "origin" => AlignmentKey::Origin, - "center" => AlignmentKey::Center, - "end" => AlignmentKey::End, -); - /// An argument key which identifies a margin or padding target. /// /// A is the used axis type. @@ -152,30 +140,47 @@ pub enum PaddingKey<A> { AxisAligned(A, AlignmentKey), } +kind!(AxisKey, "axis", + "horizontal" | "h" => AxisKey::Horizontal, + "vertical" | "v" => AxisKey::Vertical, + "primary" | "p" => AxisKey::Primary, + "secondary" | "s" => AxisKey::Secondary, +); + +kind!(AlignmentKey, "alignment", + "left" => AlignmentKey::Left, + "top" => AlignmentKey::Top, + "right" => AlignmentKey::Right, + "bottom" => AlignmentKey::Bottom, + "origin" => AlignmentKey::Origin, + "center" => AlignmentKey::Center, + "end" => AlignmentKey::End, +); + kind!(PaddingKey<AxisKey>, "axis or side", - "horizontal" => PaddingKey::Axis(AxisKey::Horizontal), - "vertical" => PaddingKey::Axis(AxisKey::Vertical), - "primary" => PaddingKey::Axis(AxisKey::Primary), - "secondary" => PaddingKey::Axis(AxisKey::Secondary), - - "left" => PaddingKey::AxisAligned(AxisKey::Horizontal, AlignmentKey::Left), - "right" => PaddingKey::AxisAligned(AxisKey::Horizontal, AlignmentKey::Right), - "top" => PaddingKey::AxisAligned(AxisKey::Vertical, AlignmentKey::Top), - "bottom" => PaddingKey::AxisAligned(AxisKey::Vertical, AlignmentKey::Bottom), - - "primary-origin" => PaddingKey::AxisAligned(AxisKey::Primary, AlignmentKey::Origin), - "primary-end" => PaddingKey::AxisAligned(AxisKey::Primary, AlignmentKey::End), - "secondary-origin" => PaddingKey::AxisAligned(AxisKey::Secondary, AlignmentKey::Origin), - "secondary-end" => PaddingKey::AxisAligned(AxisKey::Secondary, AlignmentKey::End), + "horizontal" | "h" => PaddingKey::Axis(AxisKey::Horizontal), + "vertical" | "v" => PaddingKey::Axis(AxisKey::Vertical), + "primary" | "p" => PaddingKey::Axis(AxisKey::Primary), + "secondary" | "s" => PaddingKey::Axis(AxisKey::Secondary), + + "left" => PaddingKey::AxisAligned(AxisKey::Horizontal, AlignmentKey::Left), + "right" => PaddingKey::AxisAligned(AxisKey::Horizontal, AlignmentKey::Right), + "top" => PaddingKey::AxisAligned(AxisKey::Vertical, AlignmentKey::Top), + "bottom" => PaddingKey::AxisAligned(AxisKey::Vertical, AlignmentKey::Bottom), + + "primary-origin" => PaddingKey::AxisAligned(AxisKey::Primary, AlignmentKey::Origin), + "primary-end" => PaddingKey::AxisAligned(AxisKey::Primary, AlignmentKey::End), + "secondary-origin" => PaddingKey::AxisAligned(AxisKey::Secondary, AlignmentKey::Origin), + "secondary-end" => PaddingKey::AxisAligned(AxisKey::Secondary, AlignmentKey::End), "horizontal-origin" => PaddingKey::AxisAligned(AxisKey::Horizontal, AlignmentKey::Origin), - "horizontal-end" => PaddingKey::AxisAligned(AxisKey::Horizontal, AlignmentKey::End), - "vertical-origin" => PaddingKey::AxisAligned(AxisKey::Vertical, AlignmentKey::Origin), - "vertical-end" => PaddingKey::AxisAligned(AxisKey::Vertical, AlignmentKey::End), + "horizontal-end" => PaddingKey::AxisAligned(AxisKey::Horizontal, AlignmentKey::End), + "vertical-origin" => PaddingKey::AxisAligned(AxisKey::Vertical, AlignmentKey::Origin), + "vertical-end" => PaddingKey::AxisAligned(AxisKey::Vertical, AlignmentKey::End), ); -kind!(Axis, "direction", - "ltr" => Axis::LeftToRight, - "rtl" => Axis::RightToLeft, - "ttb" => Axis::TopToBottom, - "btt" => Axis::BottomToTop, +kind!(Direction, "direction", + "left-to-right" | "ltr" => LeftToRight, + "right-to-left" | "rtl" => RightToLeft, + "top-to-bottom" | "ttb" => TopToBottom, + "bottom-to-top" | "btt" => BottomToTop, ); diff --git a/src/library/maps.rs b/src/library/maps.rs index 077ebc5e..4eafd9cc 100644 --- a/src/library/maps.rs +++ b/src/library/maps.rs @@ -84,10 +84,11 @@ impl<E: ExpressionKind + Copy> ExtentMap<E> { for arg in args.keys() { let key = match arg.v.key.v.0.as_str() { - "width" | "w" => AxisKey::Horizontal, - "height" | "h" => AxisKey::Vertical, - "primary-size" | "ps" => AxisKey::Primary, + "width" | "w" => AxisKey::Horizontal, + "height" | "h" => AxisKey::Vertical, + "primary-size" | "ps" => AxisKey::Primary, "secondary-size" | "ss" => AxisKey::Secondary, + _ => if enforce { error!("expected dimension") } else { @@ -111,22 +112,22 @@ impl<E: ExpressionKind + Copy> ExtentMap<E> { size: F ) -> LayoutResult<()> where F: Fn(&E) -> Size { let map = self.dedup(axes)?; - map.with(SpecificAxisKind::Horizontal, |val| dimensions.x = size(val)); - map.with(SpecificAxisKind::Vertical, |val| dimensions.y = size(val)); + map.with(Horizontal, |val| dimensions.x = size(val)); + map.with(Vertical, |val| dimensions.y = size(val)); Ok(()) } /// Map from any axis key to the specific axis kind. pub fn apply_with<F>(&self, axes: LayoutAxes, mut f: F) -> LayoutResult<()> - where F: FnMut(SpecificAxisKind, &E) { + where F: FnMut(SpecificAxis, &E) { for (&key, value) in self.dedup(axes)?.iter() { f(key, value); } Ok(()) } - fn dedup(&self, axes: LayoutAxes) -> LayoutResult<ConsistentMap<SpecificAxisKind, E>> { - self.0.dedup(|key, &val| Ok((key.specific(axes), val))) + fn dedup(&self, axes: LayoutAxes) -> LayoutResult<ConsistentMap<SpecificAxis, E>> { + self.0.dedup(|key, &val| Ok((key.to_specific(axes), val))) } } @@ -165,17 +166,17 @@ impl PaddingMap { let map = self.0.dedup(|key, &val| { Ok((match key { All => All, - Axis(axis) => Axis(axis.specific(axes)), + Axis(axis) => Axis(axis.to_specific(axes)), AxisAligned(axis, alignment) => { - let axis = axis.specific(axes); - AxisAligned(axis, alignment.specific(axes, axis)) + let axis = axis.to_specific(axes); + AxisAligned(axis, alignment.to_specific(axes, axis)) } }, val)) })?; map.with(All, |&val| padding.set_all(val)); - map.with(Axis(SpecificAxisKind::Horizontal), |&val| padding.set_horizontal(val)); - map.with(Axis(SpecificAxisKind::Vertical), |&val| padding.set_vertical(val)); + map.with(Axis(Horizontal), |&val| padding.set_horizontal(val)); + map.with(Axis(Vertical), |&val| padding.set_vertical(val)); for (key, &val) in map.iter() { if let AxisAligned(_, alignment) = key { diff --git a/src/library/mod.rs b/src/library/mod.rs index b6561d5a..0fcc8647 100644 --- a/src/library/mod.rs +++ b/src/library/mod.rs @@ -19,7 +19,7 @@ pub fn std() -> Scope { std.add::<Align>("align"); std.add::<Boxed>("box"); - std.add::<Direction>("direction"); + std.add::<DirectionChange>("direction"); std.add::<PageSize>("page.size"); std.add::<PageMargins>("page.margins"); @@ -30,10 +30,10 @@ pub fn std() -> Scope { std.add::<FontSize>("font.size"); - std.add_with_metadata::<Spacing, Option<AxisKey>>("spacing", None); + std.add_with_metadata::<Spacing>("spacing", None); for (name, key) in &[("h", AxisKey::Horizontal), ("v", AxisKey::Vertical)] { - std.add_with_metadata::<Spacing, Option<AxisKey>>(name, Some(*key)); + std.add_with_metadata::<Spacing>(name, Some(*key)); } for (name, class) in &[ @@ -41,7 +41,7 @@ pub fn std() -> Scope { ("italic", FontClass::Italic), ("mono", FontClass::Monospace), ] { - std.add_with_metadata::<StyleChange, FontClass>(name, class.clone()); + std.add_with_metadata::<StyleChange>(name, class.clone()); } std @@ -152,7 +152,7 @@ function! { } layout(self, ctx) { - let axis = self.axis.generic(ctx.axes); + let axis = self.axis.to_generic(ctx.axes); let spacing = self.spacing.concretize(ctx.style.text.font_size); vec![AddSpacing(spacing, SpacingKind::Hard, axis)] } |