openlogi-cli 0.6.21

Implementation library for the OpenLogi CLI (the `openlogi` binary).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! `openlogi diag wheel` — inspect or set the HiResWheel reporting mode.

use anyhow::{Context, Result};
use clap::{Args, ValueEnum};
use openlogi_hid::{ScrollReportingTarget, ScrollResolution, ScrollWheelMode};

use crate::cmd::diag::select_device;

#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
pub enum ResolutionArg {
    /// One report per physical ratchet step.
    Low,
    /// Fine-grained reports between ratchet steps.
    High,
}

impl From<ResolutionArg> for ScrollResolution {
    fn from(value: ResolutionArg) -> Self {
        match value {
            ResolutionArg::Low => Self::Low,
            ResolutionArg::High => Self::High,
        }
    }
}

#[derive(Debug, Args)]
pub struct WheelArgs {
    /// Resolution to write directly to the device. This does not update
    /// config.toml; use the GUI or TOML for persistent reconnect behavior.
    #[arg(long, value_enum)]
    pub resolution: Option<ResolutionArg>,

    /// Run against the device whose name contains this string
    /// (case-insensitive) instead of auto-selecting.
    #[arg(long, value_name = "NAME")]
    pub device: Option<String>,
}

pub async fn run(args: WheelArgs) -> Result<()> {
    let (route, name) = select_device(args.device.as_deref(), &[0x2121]).await?;
    println!("device: {name} ({route})");

    let before = openlogi_hid::get_scroll_wheel_mode(&route)
        .await
        .context("read HiResWheel mode")?;
    print_mode("current", before);

    let Some(requested) = args.resolution.map(ScrollResolution::from) else {
        return Ok(());
    };

    let after = openlogi_hid::set_scroll_resolution(&route, requested)
        .await
        .context("set wheel resolution")?;
    print_mode("read-back", after);

    if after.resolution != requested {
        anyhow::bail!(
            "wheel resolution write not applied: requested {}, device reports {}",
            resolution_label(requested),
            resolution_label(after.resolution)
        );
    }
    if after.target != ScrollReportingTarget::Native {
        anyhow::bail!(
            "wheel reporting target is not native after write: {:?}",
            after.target
        );
    }
    if after.inverted != before.inverted {
        anyhow::bail!(
            "wheel inversion changed unexpectedly: was {}, now {}",
            before.inverted,
            after.inverted
        );
    }

    println!(
        "✓ wheel resolution set to {} (native reporting, inversion preserved)",
        resolution_label(requested)
    );
    Ok(())
}

fn print_mode(label: &str, mode: ScrollWheelMode) {
    println!(
        "  {label}: resolution={} inversion={} reporting={}",
        resolution_label(mode.resolution),
        if mode.inverted { "inverted" } else { "normal" },
        match mode.target {
            ScrollReportingTarget::Native => "native",
            ScrollReportingTarget::Diverted => "diverted",
        }
    );
}

fn resolution_label(resolution: ScrollResolution) -> &'static str {
    match resolution {
        ScrollResolution::Low => "low",
        ScrollResolution::High => "high",
    }
}