Add XY movement & refactor monitor types

src/cli/modify/actions/displace.rs

@@ -0,0 +1,21 @@
+use gnome_randr::display_config::{
+    physical_monitor::PhysicalMonitor, ApplyConfig, monitor_models::transform::Displacement,
+};
+
+use super::{Action};
+
+pub struct DisplacementAction {
+    pub displacement: Displacement
+}
+
+impl Action<'_> for DisplacementAction {
+    fn apply(&self, config: &mut ApplyConfig, _: &PhysicalMonitor) {
+        config.transform.displacement = self.displacement;
+    }
+}
+
+impl std::fmt::Display for DisplacementAction {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "setting displacement to {}", self.displacement)
+    }
+}

src/cli/modify/actions/mod.rs

@@ -2,13 +2,15 @@ mod mode;
 mod primary;
 mod rotation;
 mod scale;
+mod displace;
 
 use gnome_randr::display_config::{physical_monitor::PhysicalMonitor, ApplyConfig};
 
 pub use mode::ModeAction;
 pub use primary::PrimaryAction;
-pub use rotation::RotationAction;
+pub use rotation::OrientationAction;
 pub use scale::ScaleAction;
+pub use displace::DisplacementAction;
 
 pub trait Action<'a>: std::fmt::Display {
     fn apply(&self, config: &mut ApplyConfig<'a>, physical_monitor: &PhysicalMonitor);

src/cli/modify/actions/mode.rs

@@ -11,7 +11,7 @@ impl<'a> Action<'a> for ModeAction<'a> {
         config
             .monitors
             .iter_mut()
-            .find(|monitor| monitor.connector == physical_monitor.connector)
+            .find(|monitor| monitor.connector == physical_monitor.monitor_description.connector)
             .unwrap()
             .mode_id = self.mode;
     }

src/cli/modify/actions/rotation.rs

@@ -1,27 +1,21 @@
 use gnome_randr::display_config::{
-    logical_monitor::Transform, physical_monitor::PhysicalMonitor, ApplyConfig,
+    physical_monitor::PhysicalMonitor, ApplyConfig, monitor_models::transform::Orientation,
 };
 
-use super::{super::Rotation, Action};
+use super::{Action};
 
-pub struct RotationAction {
-    pub rotation: Rotation,
+pub struct OrientationAction {
+    pub orientation: Orientation
 }
 
-impl Action<'_> for RotationAction {
+impl Action<'_> for OrientationAction {
     fn apply(&self, config: &mut ApplyConfig, _: &PhysicalMonitor) {
-        config.transform = match self.rotation {
-            Rotation::Normal => Transform::NORMAL,
-            Rotation::Left => Transform::R270,
-            Rotation::Right => Transform::R90,
-            Rotation::Inverted => Transform::R180,
-        }
-        .bits();
+        config.transform.orientation = self.orientation;
     }
 }
 
-impl std::fmt::Display for RotationAction {
+impl std::fmt::Display for OrientationAction {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "setting rotation to {}", self.rotation)
+        write!(f, "setting rotation to {}", self.orientation)
     }
 }

src/cli/modify/actions/scale.rs

@@ -8,7 +8,7 @@ pub struct ScaleAction {
 
 impl Action<'_> for ScaleAction {
     fn apply(&self, config: &mut ApplyConfig, _: &PhysicalMonitor) {
-        config.scale = self.scale;
+        config.transform.displacement.scale = self.scale;
     }
 }
 

src/cli/modify/mod.rs

@@ -1,56 +1,20 @@
 mod actions;
 
-use gnome_randr::{display_config::ApplyConfig, DisplayConfig};
+use gnome_randr::{display_config::{ApplyConfig, monitor_models::transform::{Orientation, Displacement}}, DisplayConfig};
 use structopt::StructOpt;
 
-use self::actions::{Action, ModeAction, PrimaryAction, RotationAction, ScaleAction};
+use self::actions::{Action, ModeAction, PrimaryAction, OrientationAction, ScaleAction, DisplacementAction};
 
-#[derive(Clone, Copy)]
-pub enum Rotation {
-    Normal,
-    Left,
-    Right,
-    Inverted,
-}
-
-impl std::str::FromStr for Rotation {
-    type Err = std::fmt::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_lowercase().as_str() {
-            "normal" => Ok(Rotation::Normal),
-            "left" => Ok(Rotation::Left),
-            "right" => Ok(Rotation::Right),
-            "inverted" => Ok(Rotation::Inverted),
-            _ => Err(std::fmt::Error),
-        }
-    }
-}
-
-impl std::fmt::Display for Rotation {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}",
-            match self {
-                Rotation::Normal => "normal",
-                Rotation::Left => "left",
-                Rotation::Right => "right",
-                Rotation::Inverted => "inverted",
-            }
-        )
-    }
-}
 
 #[derive(StructOpt)]
 pub struct ActionOptions {
     #[structopt(
         short,
-        long = "rotate",
-        help = "One of 'normal', 'left', 'right' or 'inverted'",
-        long_help = "One of 'normal', 'left', 'right' or 'inverted'. This causes the output contents to be rotated in the specified direction. 'right' specifies a clockwise rotation of the picture and 'left' specifies a counter-clockwise rotation."
+        long,
+        help = "A desired orientation of the display.",
+        long_help = "Any of ('normal', 'left', 'right' or 'inverted'). and optionally 'flipped' joined by ','. EG 'normal,flipped'. This causes the output contents to be rotated in the specified direction. 'right' specifies a 1/4 clockwise rotation of the picture and 'left' specifies a 3/4 clockwise rotation."
     )]
-    pub rotation: Option<Rotation>,
+    pub rotation: Option<Orientation>,
 
     #[structopt(
         short,
@@ -65,6 +29,14 @@ pub struct ActionOptions {
 
     #[structopt(long, help = "Set the scale")]
     pub scale: Option<f64>,
+
+    #[structopt(
+        short,
+        long,
+        help = "A desired x,y, and scale.",
+        long_help = "A comma-separated list of displacement information '100,88,1'. The order is always X, Y, Scale. This does not check whether monitors can be arranged in that way."
+    )]
+    pub displacement: Option<Displacement>
 }
 
 #[derive(StructOpt)]
@@ -120,8 +92,8 @@ pub fn handle(
     let primary_is_changing = opts.actions.primary;
 
     if let Some(rotation) = &opts.actions.rotation {
-        actions.push(Box::new(RotationAction {
-            rotation: *rotation,
+        actions.push(Box::new(OrientationAction {
+            orientation: *rotation,
         }));
     }
 
@@ -137,6 +109,12 @@ pub fn handle(
         actions.push(Box::new(ScaleAction { scale: *scale }))
     }
 
+    if let Some(displacement) = &opts.actions.displacement {
+        actions.push(Box::new(DisplacementAction {
+            displacement: *displacement,
+        }))
+    }
+
     if actions.is_empty() {
         println!("no changes made.");
         return Ok(());
@@ -162,11 +140,11 @@ pub fn handle(
         .monitors
         .iter()
         .filter_map(|monitor| {
-            if monitor.connector == opts.connector {
+            if monitor.monitor_description.connector == opts.connector {
                 return Some(apply_config.clone());
             }
 
-            let (logical_monitor, _) = match config.search(&monitor.connector) {
+            let (logical_monitor, _) = match config.search(&monitor.monitor_description.connector) {
                 Some(monitors) => monitors,
                 None => return None,
             };