1use crate::controller::AsusController;
4use crate::error::ControllerError;
5use crate::state::ControllerState;
6
7pub trait DisplayMode: std::fmt::Debug + Send + Sync {
11 fn apply(&self, controller: &AsusController) -> Result<(), ControllerError>;
13
14 fn symbol(&self) -> &'static [u8];
16
17 fn is_ereading(&self) -> bool {
19 false
20 }
21
22 fn mode_id(&self) -> i32;
24}
25
26#[derive(Debug, Clone, Copy)]
32pub struct NormalMode;
33
34impl NormalMode {
35 pub fn new() -> Self {
37 Self
38 }
39}
40
41impl Default for NormalMode {
42 fn default() -> Self {
43 Self::new()
44 }
45}
46
47impl DisplayMode for NormalMode {
48 fn apply(&self, controller: &AsusController) -> Result<(), ControllerError> {
49 controller.set_splendid_mode(b"MyOptSetSplendidFunc", 1)
50 }
51
52 fn symbol(&self) -> &'static [u8] {
53 b"MyOptSetSplendidFunc"
54 }
55
56 fn mode_id(&self) -> i32 {
57 1
58 }
59}
60
61#[derive(Debug, Clone, Copy)]
67pub struct VividMode;
68
69impl VividMode {
70 pub fn new() -> Self {
72 Self
73 }
74}
75
76impl Default for VividMode {
77 fn default() -> Self {
78 Self::new()
79 }
80}
81
82impl DisplayMode for VividMode {
83 fn apply(&self, controller: &AsusController) -> Result<(), ControllerError> {
84 controller.set_splendid_mode(b"MyOptSetSplendidFunc", 2)
85 }
86
87 fn symbol(&self) -> &'static [u8] {
88 b"MyOptSetSplendidFunc"
89 }
90
91 fn mode_id(&self) -> i32 {
92 2
93 }
94}
95
96#[derive(Debug, Clone, Copy)]
102pub struct ManualMode {
103 pub value: u8,
105}
106
107impl ManualMode {
108 pub fn new(value: u8) -> Result<Self, ControllerError> {
113 if value > 100 {
114 return Err(ControllerError::InvalidSliderValue {
115 mode: "Manual",
116 value,
117 min: 0,
118 max: 100,
119 });
120 }
121 Ok(Self { value })
122 }
123
124 pub fn from_controller_state(state: &ControllerState) -> Self {
126 Self {
127 value: state.manual_slider,
128 }
129 }
130}
131
132impl DisplayMode for ManualMode {
133 fn apply(&self, controller: &AsusController) -> Result<(), ControllerError> {
134 controller.set_splendid_mode(b"MyOptSetSplendidManualFunc", self.value)
135 }
136
137 fn symbol(&self) -> &'static [u8] {
138 b"MyOptSetSplendidManualFunc"
139 }
140
141 fn mode_id(&self) -> i32 {
142 6
143 }
144}
145
146#[derive(Debug, Clone, Copy)]
152pub struct EyeCareMode {
153 pub level: u8,
155}
156
157impl EyeCareMode {
158 pub fn new(level: u8) -> Result<Self, ControllerError> {
163 if level > 4 {
164 return Err(ControllerError::InvalidSliderValue {
165 mode: "EyeCare",
166 value: level,
167 min: 0,
168 max: 4,
169 });
170 }
171 Ok(Self { level })
172 }
173
174 pub fn from_controller_state(state: &ControllerState) -> Self {
176 Self {
177 level: state.eyecare_level,
178 }
179 }
180}
181
182impl DisplayMode for EyeCareMode {
183 fn apply(&self, controller: &AsusController) -> Result<(), ControllerError> {
184 controller.set_splendid_mode(b"MyOptSetSplendidEyecareFunc", self.level)
185 }
186
187 fn symbol(&self) -> &'static [u8] {
188 b"MyOptSetSplendidEyecareFunc"
189 }
190
191 fn mode_id(&self) -> i32 {
192 7
193 }
194}
195
196#[derive(Debug, Clone, Copy)]
202pub struct EReadingMode {
203 pub grayscale: u8,
205 pub temp: u8,
207}
208
209impl EReadingMode {
210 pub fn new(grayscale: u8, temp: u8) -> Result<Self, ControllerError> {
219 if grayscale > 4 {
220 return Err(ControllerError::InvalidSliderValue {
221 mode: "EReading grayscale",
222 value: grayscale,
223 min: 0,
224 max: 4,
225 });
226 }
227 Ok(Self { grayscale, temp })
228 }
229
230 pub fn from_controller_state(state: &ControllerState) -> Self {
232 Self {
233 grayscale: state.ereading_grayscale,
234 temp: state.ereading_temp,
235 }
236 }
237}
238
239impl DisplayMode for EReadingMode {
240 fn apply(&self, controller: &AsusController) -> Result<(), ControllerError> {
241 controller.set_monochrome_mode(self.grayscale, self.temp)
242 }
243
244 fn symbol(&self) -> &'static [u8] {
245 b"MyOptSetSplendidMonochromeFunc"
246 }
247
248 fn is_ereading(&self) -> bool {
249 true
250 }
251
252 fn mode_id(&self) -> i32 {
253 -1 }
255}