Make alignment a widget property

core/src/orientation/align.rs

@@ -2,7 +2,7 @@ use crate::vec2;
 
 use super::*;
 
-#[derive(Clone, Copy, PartialEq, Eq)]
+#[derive(Clone, Copy, PartialEq)]
 pub struct Align {
     pub x: Option<AxisAlign>,
     pub y: Option<AxisAlign>,
@@ -30,20 +30,30 @@ impl Align {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub enum AxisAlign {
-    Neg,
-    Center,
-    Pos,
-}
+/// Where a widget sits in a box longer than it is. The default is the middle,
+/// because the two edges are the ones that assume a direction: which of them
+/// is the near one depends on the writing system and on which way a container
+/// runs, and the middle is the same either way.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct AxisAlign(f32);
 
 impl AxisAlign {
+    pub const NEG: Self = Self::new(0.0);
+    pub const CENTER: Self = Self::new(0.5);
+    pub const POS: Self = Self::new(1.0);
+
+    pub const fn new(rel: f32) -> Self {
+        Self(rel)
+    }
+
     pub const fn rel(&self) -> f32 {
-        match self {
-            Self::Neg => 0.0,
-            Self::Center => 0.5,
-            Self::Pos => 1.0,
-        }
+        self.0
+    }
+}
+
+impl Default for AxisAlign {
+    fn default() -> Self {
+        Self::CENTER
     }
 }
 
@@ -53,34 +63,57 @@ pub struct CardinalAlign {
 }
 
 impl CardinalAlign {
-    pub const LEFT: Self = Self::new(Axis::X, AxisAlign::Neg);
-    pub const H_CENTER: Self = Self::new(Axis::X, AxisAlign::Center);
-    pub const RIGHT: Self = Self::new(Axis::X, AxisAlign::Pos);
-    pub const TOP: Self = Self::new(Axis::Y, AxisAlign::Neg);
-    pub const V_CENTER: Self = Self::new(Axis::Y, AxisAlign::Center);
-    pub const BOT: Self = Self::new(Axis::Y, AxisAlign::Pos);
+    pub const LEFT: Self = Self::new(Axis::X, AxisAlign::NEG);
+    pub const H_CENTER: Self = Self::new(Axis::X, AxisAlign::CENTER);
+    pub const RIGHT: Self = Self::new(Axis::X, AxisAlign::POS);
+    pub const TOP: Self = Self::new(Axis::Y, AxisAlign::NEG);
+    pub const V_CENTER: Self = Self::new(Axis::Y, AxisAlign::CENTER);
+    pub const BOT: Self = Self::new(Axis::Y, AxisAlign::POS);
 
     pub const fn new(axis: Axis, align: AxisAlign) -> Self {
         Self { axis, align }
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
 pub struct RegionAlign {
     pub x: AxisAlign,
     pub y: AxisAlign,
 }
 
 impl RegionAlign {
-    pub const TOP_LEFT: Self = Self::new(AxisAlign::Neg, AxisAlign::Neg);
-    pub const TOP_CENTER: Self = Self::new(AxisAlign::Center, AxisAlign::Neg);
-    pub const TOP_RIGHT: Self = Self::new(AxisAlign::Pos, AxisAlign::Neg);
-    pub const CENTER_LEFT: Self = Self::new(AxisAlign::Neg, AxisAlign::Center);
-    pub const CENTER: Self = Self::new(AxisAlign::Center, AxisAlign::Center);
-    pub const CENTER_RIGHT: Self = Self::new(AxisAlign::Pos, AxisAlign::Center);
-    pub const BOT_LEFT: Self = Self::new(AxisAlign::Neg, AxisAlign::Pos);
-    pub const BOT_CENTER: Self = Self::new(AxisAlign::Center, AxisAlign::Pos);
-    pub const BOT_RIGHT: Self = Self::new(AxisAlign::Pos, AxisAlign::Pos);
+    /// Both axes at the near edge. What a container passes as an override for
+    /// a child it is going to position itself.
+    pub const NEAR: Self = Self {
+        x: AxisAlign::NEG,
+        y: AxisAlign::NEG,
+    };
+
+    pub fn axis(&self, axis: Axis) -> AxisAlign {
+        match axis {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
+    }
+
+    pub fn axis_mut(&mut self, axis: Axis) -> &mut AxisAlign {
+        match axis {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+}
+
+impl RegionAlign {
+    pub const TOP_LEFT: Self = Self::new(AxisAlign::NEG, AxisAlign::NEG);
+    pub const TOP_CENTER: Self = Self::new(AxisAlign::CENTER, AxisAlign::NEG);
+    pub const TOP_RIGHT: Self = Self::new(AxisAlign::POS, AxisAlign::NEG);
+    pub const CENTER_LEFT: Self = Self::new(AxisAlign::NEG, AxisAlign::CENTER);
+    pub const CENTER: Self = Self::new(AxisAlign::CENTER, AxisAlign::CENTER);
+    pub const CENTER_RIGHT: Self = Self::new(AxisAlign::POS, AxisAlign::CENTER);
+    pub const BOT_LEFT: Self = Self::new(AxisAlign::NEG, AxisAlign::POS);
+    pub const BOT_CENTER: Self = Self::new(AxisAlign::CENTER, AxisAlign::POS);
+    pub const BOT_RIGHT: Self = Self::new(AxisAlign::POS, AxisAlign::POS);
 
     pub const fn new(x: AxisAlign, y: AxisAlign) -> Self {
         Self { x, y }
@@ -165,8 +198,8 @@ impl From<RegionAlign> for Align {
 impl From<Align> for RegionAlign {
     fn from(align: Align) -> Self {
         Self {
-            x: align.x.unwrap_or(AxisAlign::Center),
-            y: align.y.unwrap_or(AxisAlign::Center),
+            x: align.x.unwrap_or(AxisAlign::CENTER),
+            y: align.y.unwrap_or(AxisAlign::CENTER),
         }
     }
 }

core/src/orientation/pos.rs

@@ -188,6 +188,15 @@ impl UiScalar {
         }
     }
 
+    /// Both channels by the same factor, which is what a fraction of a
+    /// length means when the length is part pixels and part a share.
+    pub const fn scale(&self, by: f32) -> Self {
+        Self {
+            rel: self.rel * by,
+            px: self.px * by,
+        }
+    }
+
     pub const fn offset(mut self, amt: f32) -> Self {
         self.px += amt;
         self