Make the trigger corner configurable

Author: awwaiid

src/main.rs

@@ -16,7 +16,7 @@ use ghostwriter::{
     pen::Pen,
     screenshot::Screenshot,
     segmenter::analyze_image,
-    touch::Touch,
+    touch::{Touch, TriggerCorner},
     util::{setup_uinput, svg_to_bitmap, write_bitmap_to_file, OptionMap},
 };
 
@@ -122,6 +122,10 @@ struct Args {
     /// Set the log level. Try 'debug' or 'trace'
     #[arg(long, default_value = "info")]
     log_level: String,
+
+    /// Sets which corner the touch trigger listens to (UR, UL, LR, LL, upper-right, upper-left, lower-right, lower-left)
+    #[arg(long, default_value = "UR")]
+    trigger_corner: String,
 }
 
 fn main() -> Result<()> {
@@ -174,9 +178,10 @@ fn draw_svg(svg_data: &str, keyboard: &mut Keyboard, pen: &mut Pen, save_bitmap:
 }
 
 fn ghostwriter(args: &Args) -> Result<()> {
+    let trigger_corner = TriggerCorner::from_string(&args.trigger_corner)?;
     let keyboard = shared!(Keyboard::new(args.no_draw || args.no_keyboard, args.no_draw_progress,));
     let pen = shared!(Pen::new(args.no_draw));
-    let touch = shared!(Touch::new(args.no_draw));
+    let touch = shared!(Touch::new(args.no_draw, trigger_corner));
 
     // Give time for the virtual keyboard to be plugged in
     sleep(Duration::from_millis(1000));
@@ -285,7 +290,15 @@ fn ghostwriter(args: &Args) -> Result<()> {
         if args.no_trigger {
             debug!("Skipping waiting for trigger");
         } else {
-            info!("Waiting for trigger (hand-touch in the upper-right corner)...");
+            info!(
+                "Waiting for trigger (hand-touch in the {} corner)...",
+                match TriggerCorner::from_string(&args.trigger_corner).unwrap() {
+                    TriggerCorner::UpperRight => "upper-right",
+                    TriggerCorner::UpperLeft => "upper-left",
+                    TriggerCorner::LowerRight => "lower-right",
+                    TriggerCorner::LowerLeft => "lower-left",
+                }
+            );
             lock!(touch).wait_for_trigger()?;
         }
 

src/touch.rs

@@ -8,6 +8,29 @@ use std::time::Duration;
 
 use crate::device::DeviceModel;
 
+#[derive(Debug, Clone)]
+pub enum TriggerCorner {
+    UpperRight,
+    UpperLeft,
+    LowerRight,
+    LowerLeft,
+}
+
+impl TriggerCorner {
+    pub fn from_string(s: &str) -> Result<Self> {
+        match s.to_lowercase().as_str() {
+            "ur" | "upper-right" => Ok(TriggerCorner::UpperRight),
+            "ul" | "upper-left" => Ok(TriggerCorner::UpperLeft),
+            "lr" | "lower-right" => Ok(TriggerCorner::LowerRight),
+            "ll" | "lower-left" => Ok(TriggerCorner::LowerLeft),
+            _ => Err(anyhow::anyhow!(
+                "Invalid trigger corner: {}. Use UR, UL, LR, LL, upper-right, upper-left, lower-right, or lower-left",
+                s
+            )),
+        }
+    }
+}
+
 // Output dimensions remain the same for both devices
 const VIRTUAL_WIDTH: u16 = 768;
 const VIRTUAL_HEIGHT: u16 = 1024;
@@ -26,10 +49,11 @@ const ABS_MT_PRESSURE: u16 = 58;
 pub struct Touch {
     device: Option<Device>,
     device_model: DeviceModel,
+    trigger_corner: TriggerCorner,
 }
 
 impl Touch {
-    pub fn new(no_touch: bool) -> Self {
+    pub fn new(no_touch: bool, trigger_corner: TriggerCorner) -> Self {
         let device_model = DeviceModel::detect();
         info!("Touch using device model: {}", device_model.name());
 
@@ -41,7 +65,11 @@ impl Touch {
 
         let device = if no_touch { None } else { Some(Device::open(device_path).unwrap()) };
 
-        Self { device, device_model }
+        Self {
+            device,
+            device_model,
+            trigger_corner,
+        }
     }
 
     pub fn wait_for_trigger(&mut self) -> Result<()> {
@@ -67,7 +95,7 @@ impl Touch {
                 if event.code() == ABS_MT_TRACKING_ID && event.value() == -1 {
                     let (x, y) = self.input_to_virtual((position_x, position_y));
                     debug!("Touch release detected at ({}, {}) normalized ({}, {})", position_x, position_y, x, y);
-                    if x > 700 && y < 50 {
+                    if self.is_in_trigger_zone(x, y) {
                         debug!("Touch release in target zone!");
                         return Ok(());
                     }
@@ -133,6 +161,17 @@ impl Touch {
         Ok(())
     }
 
+    fn is_in_trigger_zone(&self, x: i32, y: i32) -> bool {
+        const CORNER_SIZE: i32 = 68; // Size of the trigger zone (68x68 pixels)
+
+        match self.trigger_corner {
+            TriggerCorner::UpperRight => x > VIRTUAL_WIDTH as i32 - CORNER_SIZE && y < CORNER_SIZE,
+            TriggerCorner::UpperLeft => x < CORNER_SIZE && y < CORNER_SIZE,
+            TriggerCorner::LowerRight => x > VIRTUAL_WIDTH as i32 - CORNER_SIZE && y > VIRTUAL_HEIGHT as i32 - CORNER_SIZE,
+            TriggerCorner::LowerLeft => x < CORNER_SIZE && y > VIRTUAL_HEIGHT as i32 - CORNER_SIZE,
+        }
+    }
+
     fn screen_width(&self) -> u32 {
         match self.device_model {
             DeviceModel::Remarkable2 => 1404,