openrazer 0.1.0

Asynchronous bindings to the OpenRazer daemon.
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

//! Types for controlling the reactve effect.

use super::CapabilityBase;
use crate::{Color, Error};
use dbus_message_parser::Value;

/// Controls the reactive effect.
#[derive(Debug, Clone)]
pub struct ReactiveEffect(pub(crate) CapabilityBase);

/// The effect's speed.
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash)]
pub enum Speed {
    /// The reaction stays for 500ms.
    Fast = 1,
    /// The reaction stays for 1000ms.
    Medium = 2,
    /// The reaction stays for 1500ms.
    Slow = 3,
    /// The reaction stays for 2000ms.
    VerySlow = 4,
}

impl ReactiveEffect {
    pub(crate) const INTERFACE: &'static str = "razer.device.lighting.chroma";
    pub(crate) const METHOD: &'static str = "setReactive";

    /// Sets the reactive effect.
    pub async fn set(&self, (red, green, blue): Color, speed: Speed) -> Result<(), Error> {
        self.0
            .call_set_method(
                Self::INTERFACE,
                Self::METHOD,
                vec![
                    Value::Byte(red),
                    Value::Byte(green),
                    Value::Byte(blue),
                    Value::Byte(speed as u8),
                ],
            )
            .await
    }

    /// Sets the reactive effect with `Speed::Fast`.
    pub async fn fast(&self, color: Color) -> Result<(), Error> {
        self.set(color, Speed::Fast).await
    }

    /// Sets the reactive effect with `Speed::Medium`.
    pub async fn medium(&self, color: Color) -> Result<(), Error> {
        self.set(color, Speed::Medium).await
    }

    /// Sets the reactive effect with `Speed::Slow`.
    pub async fn slow(&self, color: Color) -> Result<(), Error> {
        self.set(color, Speed::Slow).await
    }

    /// Sets the reactive effect with `Speed::VerySlow`.
    pub async fn very_slow(&self, color: Color) -> Result<(), Error> {
        self.set(color, Speed::VerySlow).await
    }
}