Rename arg_handler to args

src/args.rs

@@ -0,0 +1,116 @@
+use clap::Parser;
+
+#[derive(Parser)]
+#[command(author, version, about, disable_help_flag = true)]
+pub struct Arguments {
+    // manually redefine help, but without short option, because `-h`
+    // is already used by the height option.
+    /// Show this help
+    #[clap(long, action = clap::ArgAction::HelpLong)]
+    help: Option<bool>,
+
+    /// The host to pwn "host:port"
+    host: String,
+
+    /// Image path(s)
+    #[arg(
+        short,
+        long,
+        value_name = "PATH",
+        required = true,
+        alias = "images",
+        num_args(1..)
+    )]
+    image: Vec<String>,
+
+    /// Draw width [default: screen width]
+    #[arg(short, long, value_name = "PIXELS")]
+    width: Option<u16>,
+    /// Draw height [default: screen height]
+    #[arg(short, long, value_name = "PIXELS")]
+    height: Option<u16>,
+
+    /// Draw X offset
+    #[arg(short, value_name = "PIXELS", default_value_t = 0)]
+    x: u16,
+    /// Draw Y offset
+    #[arg(short, value_name = "PIXELS", default_value_t = 0)]
+    y: u16,
+
+    /// Number of concurrent threads [default: number of CPUs]
+    #[arg(short, long, aliases = ["thread", "threads"])]
+    count: Option<usize>,
+
+    /// Frames per second with multiple images
+    #[arg(short = 'r', long, value_name = "RATE", default_value_t = 1)]
+    fps: u32,
+
+    /// Use binary mode to set pixels (`PB` protocol extension) [default: off]
+    #[arg(short, long, alias = "bin")]
+    binary: bool,
+
+    /// Flush socket after each pixel [default: true]
+    #[arg(short, long, action = clap::ArgAction::Set, value_name = "ENABLED", default_value_t = true)]
+    flush: bool,
+}
+
+/// CLI argument handler.
+pub struct ArgHandler {
+    data: Arguments,
+}
+
+impl ArgHandler {
+    pub fn parse() -> ArgHandler {
+        ArgHandler {
+            data: Arguments::parse(),
+        }
+    }
+
+    /// Get the host property.
+    pub fn host(&self) -> &str {
+        self.data.host.as_str()
+    }
+
+    /// Get the thread count.
+    pub fn count(&self) -> usize {
+        self.data.count.unwrap_or_else(num_cpus::get)
+    }
+
+    /// Get the image paths.
+    pub fn image_paths(&self) -> Vec<&str> {
+        self.data.image.iter().map(|x| x.as_str()).collect()
+    }
+
+    /// Get the image size.
+    /// Use the given default value if not set.
+    pub fn size(&self, def: Option<(u16, u16)>) -> (u16, u16) {
+        (
+            self.data
+                .width
+                .unwrap_or(def.expect("No screen width set or known").0),
+            self.data
+                .height
+                .unwrap_or(def.expect("No screen height set or known").1),
+        )
+    }
+
+    /// Get the image offset.
+    pub fn offset(&self) -> (u16, u16) {
+        (self.data.x, self.data.y)
+    }
+
+    /// Get the FPS.
+    pub fn fps(&self) -> u32 {
+        self.data.fps
+    }
+
+    /// Whether to use binary mode.
+    pub fn binary(&self) -> bool {
+        self.data.binary
+    }
+
+    /// Whether to flush after each pixel.
+    pub fn flush(&self) -> bool {
+        self.data.flush
+    }
+}