jay-compositor 1.15.0

The Jay compositor
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
103
104
105
106
107
108
109
110

use crate::cli::GlobalArgs;
use crate::cli::color::parse_color;
use crate::cli::duration::parse_duration;
use crate::cmm::cmm_eotf::Eotf;
use crate::tools::tool_client::ToolClient;
use crate::tools::tool_client::with_tool_client;
use crate::wire::jay_damage_tracking::SetVisualizerColor;
use crate::wire::jay_damage_tracking::SetVisualizerDecay;
use crate::wire::jay_damage_tracking::SetVisualizerEnabled;
use clap::Args;
use clap::Subcommand;
use std::rc::Rc;

#[derive(Args, Debug)]
pub struct DamageTrackingArgs {
    #[clap(subcommand)]
    command: DamageTrackingCmd,
}

#[derive(Subcommand, Debug)]
pub enum DamageTrackingCmd {
    /// Visualize damage.
    Show,
    /// Hide damage.
    Hide,
    /// Set the color used for damage visualization.
    SetColor(ColorArgs),
    /// Set the amount of time damage is shown.
    SetDecay(DecayArgs),
}

#[derive(Args, Debug)]
pub struct ColorArgs {
    /// The color to visualize damage.
    ///
    /// Should be specified in one of the following formats:
    ///
    /// * `#rgb`
    /// * `#rgba`
    /// * `#rrggbb`
    /// * `#rrggbbaa`
    color: String,
}

#[derive(Args, Debug)]
pub struct DecayArgs {
    /// The interval of inactivity after which to disable the screens.
    ///
    /// Minutes, seconds, and milliseconds can be specified in any of the following formats:
    ///
    /// * 1m
    /// * 1m5s
    /// * 1m 5s
    /// * 1min 5sec
    /// * 1 minute 5 seconds.
    duration: Vec<String>,
}

pub fn main(_global: GlobalArgs, damage_tracking_args: DamageTrackingArgs) {
    with_tool_client(async move |tc| {
        let damage_tracking = Rc::new(DamageTracking { tc: tc.clone() });
        damage_tracking.run(damage_tracking_args).await;
    });
}

struct DamageTracking {
    tc: Rc<ToolClient>,
}

impl DamageTracking {
    async fn run(&self, args: DamageTrackingArgs) {
        let tc = &self.tc;
        let Some(dt) = tc.jay_damage_tracking().await else {
            fatal!("Compositor does not support damage tracking");
        };
        match args.command {
            DamageTrackingCmd::Show => {
                tc.send(SetVisualizerEnabled {
                    self_id: dt,
                    enabled: true,
                });
            }
            DamageTrackingCmd::Hide => {
                tc.send(SetVisualizerEnabled {
                    self_id: dt,
                    enabled: false,
                });
            }
            DamageTrackingCmd::SetColor(c) => {
                let color = parse_color(&c.color);
                let [r, g, b, a] = color.to_array(Eotf::Gamma22);
                tc.send(SetVisualizerColor {
                    self_id: dt,
                    r,
                    g,
                    b,
                    a,
                });
            }
            DamageTrackingCmd::SetDecay(c) => {
                let duration = parse_duration(&c.duration);
                tc.send(SetVisualizerDecay {
                    self_id: dt,
                    millis: duration.as_millis() as _,
                });
            }
        }
        tc.round_trip().await;
    }
}