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
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 super::{available::CustomEffectAvailability, matrix_dimensions::Dimensions, CapabilityBase};
use crate::{Color, Error};
use dbus_message_parser::Value;
use std::ops::{Index, IndexMut};

#[derive(Debug, Clone)]
pub struct CustomEffect {
    pub(crate) base: CapabilityBase,
    pub(crate) availability: CustomEffectAvailability,
}

#[derive(Debug, Clone)]
pub struct Frame {
    effect: CustomEffect,
    dimensions: Dimensions,
    buffer: Vec<Color>,
}

impl CustomEffect {
    pub(crate) const INTERFACE: &'static str = "razer.device.lighting.chroma";
    pub(crate) const SET_ROW_METHOD: &'static str = "setKeyRow";
    pub(crate) const SET_CUSTOM_METHOD: &'static str = "setCustom";

    pub(crate) async fn set_row(&self, bytes: Vec<Value>) -> Result<(), Error> {
        if !self.availability.set_key_row {
            return Err(Error::UnsupportedCapability);
        }

        self.base
            .call_set_method(
                Self::INTERFACE,
                Self::SET_ROW_METHOD,
                vec![Value::Array(bytes, "y".to_string())],
            )
            .await
    }

    pub async fn set(&self) -> Result<(), Error> {
        if !self.availability.set_effect {
            return Err(Error::UnsupportedCapability);
        }

        self.base
            .call_set_method(Self::INTERFACE, Self::SET_CUSTOM_METHOD, vec![])
            .await
    }

    pub fn frame(self, dimensions: Dimensions) -> Frame {
        Frame {
            effect: self,
            dimensions,
            buffer: vec![(0, 0, 0); dimensions.rows * dimensions.columns],
        }
    }
}

impl Frame {
    pub async fn draw(&self) -> Result<(), Error> {
        let mut bytes = Vec::with_capacity(self.dimensions.rows * (self.dimensions.columns + 3));

        for row_index in 0..self.dimensions.rows {
            bytes.push(Value::Byte(row_index as u8));
            bytes.push(Value::Byte(0));
            bytes.push(Value::Byte((self.dimensions.columns - 1) as u8));
            let row = &self.buffer
                [row_index * self.dimensions.columns..(row_index + 1) * self.dimensions.columns];
            bytes.extend(row.iter().flat_map(|(red, green, blue)| {
                vec![Value::Byte(*red), Value::Byte(*green), Value::Byte(*blue)]
            }));
        }

        self.effect.set_row(bytes).await
    }
}

impl Index<(usize, usize)> for Frame {
    type Output = Color;

    fn index(&self, (row, column): (usize, usize)) -> &Self::Output {
        assert!(
            row < self.dimensions.rows,
            "row is {} but dimensions are {:?}",
            row,
            self.dimensions
        );
        assert!(
            column < self.dimensions.columns,
            "column is {} but dimensions are {:?}",
            column,
            self.dimensions
        );

        &self.buffer[(row * self.dimensions.columns + column)]
    }
}

impl IndexMut<(usize, usize)> for Frame {
    fn index_mut(&mut self, (row, column): (usize, usize)) -> &mut Self::Output {
        assert!(
            row < self.dimensions.rows,
            "row is {} but dimensions are {:?}",
            row,
            self.dimensions
        );
        assert!(
            column < self.dimensions.columns,
            "column is {} but dimensions are {:?}",
            column,
            self.dimensions
        );

        &mut self.buffer[(row * self.dimensions.columns + column)]
    }
}