fireplace_lib 3.0.2

Modular wayland window manager library
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
111
112
113
114



use handlers::geometry::GapsConfig;
#[cfg(feature = "conrod_ui")]
use handlers::render::conrod::provider::BackgroundConfig;
#[cfg(feature = "conrod_ui")]
use handlers::render::conrod::provider::StatusbarConfig;
use handlers::store::{Store, StoreKey};
use slog;
use slog_scope;

use std::collections::HashMap;

use wlc::{Callback, Output};

/// Handler to apply output configurations to every newly created
/// `Output` automatically.
///
/// ## Dependencies
///
/// - [`StoreHandler`](./struct.StoreHandler.html)
///
pub struct OutputConfigHandler {
    outputs: HashMap<String, OutputConfig>,
    logger: slog::Logger,
}

/// Output configuration
///
/// Contains properties that may be applied for an `Output`
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct OutputConfig {
    /// Scale of the `Output`
    pub scale: u32,
    /// Ui Configuration of the `Output`
    pub ui: UiConfig,
}

/// Ui Configuration mostly only available by enabling the `ui` feature
#[derive(Clone, Deserialize, Default)]
#[serde(deny_unknown_fields)]
pub struct UiConfig {
    /// The kind of background to be drawn
    #[serde(default)]
    #[cfg(feature = "conrod_ui")]
    pub background: BackgroundConfig,
    /// Configuration of gaps between windows
    #[serde(default)]
    pub gaps: GapsConfig,
    /// Statusbar configuraion
    #[serde(default)]
    #[cfg(feature = "conrod_ui")]
    pub statusbar: StatusbarConfig,
}
impl StoreKey for UiConfig {
    type Value = UiConfig;
}

impl Default for OutputConfig {
    fn default() -> OutputConfig {
        OutputConfig {
            scale: 1,
            ui: UiConfig::default(),
        }
    }
}

impl OutputConfigHandler {
    /// Initialize a new `OutputConfigHandler`
    ///
    /// # Arguments
    /// *outputs - A `HashMap` of an `OutputConfig` for each name of
    /// an `Output`. The name `default` or `generic` might be used for a
    /// generic configuration.
    pub fn new(outputs: HashMap<String, OutputConfig>) -> OutputConfigHandler {
        OutputConfigHandler {
            outputs: outputs,
            logger: slog_scope::logger().new(o!("handler" => "OutputConfig")),
        }
    }
}

impl Callback for OutputConfigHandler {
    fn output_created(&mut self, output: &Output) -> bool {
        if let Some(config) = self.outputs.get(&*output.name()) {
            info!(self.logger,
                  "Setting scale {:?} for output {:?}",
                  config.scale,
                  output.name());
            let res = output.resolution();
            output.set_resolution(res, config.scale);
            output.insert::<UiConfig>(config.ui.clone());
        } else if let Some(config) = self.outputs.get("default") {
            info!(self.logger,
                  "Setting scale {:?} for output {:?}",
                  config.scale,
                  output.name());
            let res = output.resolution();
            output.set_resolution(res, config.scale);
            output.insert::<UiConfig>(config.ui.clone());
        } else if let Some(config) = self.outputs.get("generic") {
            info!(self.logger,
                  "Setting scale {:?} for output {:?}",
                  config.scale,
                  output.name());
            let res = output.resolution();
            output.set_resolution(res, config.scale);
            output.insert::<UiConfig>(config.ui.clone());
        }
        output.set_sleeping(false);
        true
    }
}