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

use crate::cli::GlobalArgs;
use crate::cli::json::JsonColorManagementStatus;
use crate::cli::json::jsonl;
use crate::tools::tool_client::Handle;
use crate::tools::tool_client::ToolClient;
use crate::tools::tool_client::with_tool_client;
use crate::wire::JayColorManagementId;
use crate::wire::jay_color_management;
use crate::wire::jay_compositor;
use clap::Args;
use clap::Subcommand;
use std::cell::Cell;
use std::rc::Rc;

#[derive(Args, Debug)]
pub struct ColorManagementArgs {
    #[clap(subcommand)]
    command: Option<ColorManagementCmd>,
}

#[derive(Subcommand, Debug, Default)]
pub enum ColorManagementCmd {
    /// Print the color-management status.
    #[default]
    Status,
    /// Enable the color-management protocol.
    Enable,
    /// Disable the color-management protocol.
    Disable,
}

pub fn main(global: GlobalArgs, args: ColorManagementArgs) {
    with_tool_client(async move |tc| {
        let cm = ColorManagement { tc: tc.clone() };
        cm.run(&global, args).await;
    });
}

struct ColorManagement {
    tc: Rc<ToolClient>,
}

impl ColorManagement {
    async fn run(self, global: &GlobalArgs, args: ColorManagementArgs) {
        let tc = &self.tc;
        let comp = tc.jay_compositor().await;
        let id = tc.id();
        tc.send(jay_compositor::GetColorManagement { self_id: comp, id });
        match args.command.unwrap_or_default() {
            ColorManagementCmd::Status => self.status(global, id).await,
            ColorManagementCmd::Enable => self.set_enabled(id, true).await,
            ColorManagementCmd::Disable => self.set_enabled(id, false).await,
        }
    }

    async fn status(self, global: &GlobalArgs, id: JayColorManagementId) {
        let tc = &self.tc;
        tc.send(jay_color_management::Get { self_id: id });
        let enabled = Rc::new(Cell::new(false));
        jay_color_management::Enabled::handle(tc, id, enabled.clone(), |iv, msg| {
            iv.set(msg.enabled);
        });
        let available = Rc::new(Cell::new(false));
        jay_color_management::Available::handle(tc, id, available.clone(), |iv, msg| {
            iv.set(msg.available);
        });
        tc.round_trip().await;
        if global.json {
            jsonl(&JsonColorManagementStatus {
                enabled: enabled.get(),
                available: available.get(),
            });
        } else {
            if enabled.get() {
                print!("Enabled");
                if !available.get() {
                    print!(" (Unavailable)");
                }
                println!();
            } else {
                println!("Disabled");
            }
        }
    }

    async fn set_enabled(self, id: JayColorManagementId, enabled: bool) {
        let tc = &self.tc;
        tc.send(jay_color_management::SetEnabled {
            self_id: id,
            enabled,
        });
        tc.round_trip().await;
    }
}