Debian Codegraph @

daemon/openrazer_daemon/dbus_services/dbus_methods/nagahexv2.py

raw
1 # SPDX-License-Identifier: GPL-2.0-or-later
2
3 from openrazer_daemon.dbus_services import endpoint
4
5
6 @endpoint('razer.device.lighting.logo', 'setLogoStatic', in_sig='yyy')
7 def set_logo_static(self, red, green, blue):
8 """
9 Set the device to static colour
10
11 :param red: Red component
12 :type red: int
13
14 :param green: Green component
15 :type green: int
16
17 :param blue: Blue component
18 :type blue: int
19 """
20 self.logger.debug("DBus call set_static_effect")
21
22 # Notify others
23 self.send_effect_event('setStatic', red, green, blue)
24
25 # remember effect
26 self.set_persistence("logo", "effect", 'static')
27 self.zone["logo"]["colors"][0:3] = int(red), int(green), int(blue)
28
29 rgb_driver_path = self.get_driver_path('logo_matrix_effect_static')
30
31 payload = bytes([red, green, blue])
32
33 with open(rgb_driver_path, 'wb') as rgb_driver_file:
34 rgb_driver_file.write(payload)
35
36
37 @endpoint('razer.device.lighting.logo', 'setLogoSpectrum')
38 def set_logo_spectrum(self):
39 """
40 Set the device to spectrum mode
41 """
42 self.logger.debug("DBus call set_logo_spectrum")
43
44 # Notify others
45 self.send_effect_event('setSpectrum')
46
47 # remember effect
48 self.set_persistence("logo", "effect", 'spectrum')
49
50 effect_driver_path = self.get_driver_path('logo_matrix_effect_spectrum')
51
52 with open(effect_driver_path, 'w') as effect_driver_file:
53 effect_driver_file.write('1')
54
55
56 @endpoint('razer.device.lighting.logo', 'setLogoNone')
57 def set_logo_none(self):
58 """
59 Set the device to effect none
60 """
61 self.logger.debug("DBus call set_none_effect")
62
63 # Notify others
64 self.send_effect_event('setNone')
65
66 # remember effect
67 self.set_persistence("logo", "effect", 'none')
68
69 driver_path = self.get_driver_path('logo_matrix_effect_none')
70
71 with open(driver_path, 'w') as driver_file:
72 driver_file.write('1')
73
74
75 @endpoint('razer.device.lighting.logo', 'setLogoOn')
76 def set_logo_on(self):
77 """
78 Set the device to effect on
79 """
80 self.logger.debug("DBus call set_logo_on")
81
82 # Notify others
83 self.send_effect_event('setOn')
84
85 # remember effect
86 self.set_persistence("logo", "effect", 'on')
87
88 driver_path = self.get_driver_path('logo_matrix_effect_on')
89
90 with open(driver_path, 'w') as driver_file:
91 driver_file.write('1')
92
93
94 @endpoint('razer.device.lighting.logo', 'setLogoReactive', in_sig='yyyy')
95 def set_logo_reactive(self, red, green, blue, speed):
96 """
97 Set the device to reactive effect
98
99 :param red: Red component
100 :type red: int
101
102 :param green: Green component
103 :type green: int
104
105 :param blue: Blue component
106 :type blue: int
107
108 :param speed: Speed
109 :type speed: int
110 """
111 self.logger.debug("DBus call set_reactive_effect")
112
113 driver_path = self.get_driver_path('logo_matrix_effect_reactive')
114
115 # Notify others
116 self.send_effect_event('setReactive', red, green, blue, speed)
117
118 # remember effect
119 self.set_persistence("logo", "effect", 'reactive')
120 self.zone["logo"]["colors"][0:3] = int(red), int(green), int(blue)
121 self.set_persistence("logo", "speed", int(speed))
122
123 if speed not in (1, 2, 3, 4):
124 speed = 4
125
126 payload = bytes([speed, red, green, blue])
127
128 with open(driver_path, 'wb') as driver_file:
129 driver_file.write(payload)
130
131
132 @endpoint('razer.device.lighting.logo', 'setLogoBreathMono')
133 def set_logo_breath_mono(self):
134 """
135 Set the device to mono colour breathing effect
136 """
137 self.logger.debug("DBus call set_logo_breath_mono")
138
139 # Notify others
140 self.send_effect_event('setBreathMono')
141
142 # remember effect
143 self.set_persistence("logo", "effect", 'breathMono')
144
145 driver_path = self.get_driver_path('logo_matrix_effect_breath')
146
147 with open(driver_path, 'wb') as driver_file:
148 driver_file.write(b'1')
149
150
151 @endpoint('razer.device.lighting.logo', 'setLogoBreathRandom')
152 def set_logo_breath_random(self):
153 """
154 Set the device to random colour breathing effect
155 """
156 self.logger.debug("DBus call set_breath_random_effect")
157
158 # Notify others
159 self.send_effect_event('setBreathRandom')
160
161 # remember effect
162 self.set_persistence("logo", "effect", 'breathRandom')
163
164 driver_path = self.get_driver_path('logo_matrix_effect_breath')
165
166 payload = b'1'
167
168 with open(driver_path, 'wb') as driver_file:
169 driver_file.write(payload)
170
171
172 @endpoint('razer.device.lighting.logo', 'setLogoBreathSingle', in_sig='yyy')
173 def set_logo_breath_single(self, red, green, blue):
174 """
175 Set the device to single colour breathing effect
176
177 :param red: Red component
178 :type red: int
179
180 :param green: Green component
181 :type green: int
182
183 :param blue: Blue component
184 :type blue: int
185 """
186 self.logger.debug("DBus call set_breath_single_effect")
187
188 # Notify others
189 self.send_effect_event('setBreathSingle', red, green, blue)
190
191 # remember effect
192 self.set_persistence("logo", "effect", 'breathSingle')
193 self.zone["logo"]["colors"][0:3] = int(red), int(green), int(blue)
194
195 driver_path = self.get_driver_path('logo_matrix_effect_breath')
196
197 payload = bytes([red, green, blue])
198
199 with open(driver_path, 'wb') as driver_file:
200 driver_file.write(payload)
201
202
203 @endpoint('razer.device.lighting.logo', 'setLogoBreathDual', in_sig='yyyyyy')
204 def set_logo_breath_dual(self, red1, green1, blue1, red2, green2, blue2):
205 """
206 Set the device to dual colour breathing effect
207
208 :param red1: Red component
209 :type red1: int
210
211 :param green1: Green component
212 :type green1: int
213
214 :param blue1: Blue component
215 :type blue1: int
216
217 :param red2: Red component
218 :type red2: int
219
220 :param green2: Green component
221 :type green2: int
222
223 :param blue2: Blue component
224 :type blue2: int
225 """
226 self.logger.debug("DBus call set_breath_dual_effect")
227
228 # Notify others
229 self.send_effect_event('setBreathDual', red1, green1, blue1, red2, green2, blue2)
230
231 # remember effect
232 self.set_persistence("logo", "effect", 'breathDual')
233 self.zone["logo"]["colors"][0:6] = int(red1), int(green1), int(blue1), int(red2), int(green2), int(blue2)
234
235 driver_path = self.get_driver_path('logo_matrix_effect_breath')
236
237 payload = bytes([red1, green1, blue1, red2, green2, blue2])
238
239 with open(driver_path, 'wb') as driver_file:
240 driver_file.write(payload)
241
242
243 @endpoint('razer.device.lighting.logo', 'setLogoBlinking', in_sig='yyy')
244 def set_logo_blinking(self, red, green, blue):
245 """
246 Set the device to blinking mode
247
248 :param red: Red component
249 :type red: int
250
251 :param green: Green component
252 :type green: int
253
254 :param blue: Blue component
255 :type blue: int
256 """
257 self.logger.debug("DBus call set_logo_blinking")
258
259 # Notify others
260 self.send_effect_event('setBlinking', red, green, blue)
261
262 # remember effect
263 self.set_persistence("logo", "effect", 'blinking')
264 self.zone["logo"]["colors"][0:3] = int(red), int(green), int(blue)
265
266 rgb_driver_path = self.get_driver_path('logo_matrix_effect_blinking')
267
268 payload = bytes([red, green, blue])
269
270 with open(rgb_driver_path, 'wb') as rgb_driver_file:
271 rgb_driver_file.write(payload)
272
273
274 @endpoint('razer.device.lighting.scroll', 'setScrollStatic', in_sig='yyy')
275 def set_scroll_static(self, red, green, blue):
276 """
277 Set the device to static colour
278
279 :param red: Red component
280 :type red: int
281
282 :param green: Green component
283 :type green: int
284
285 :param blue: Blue component
286 :type blue: int
287 """
288 self.logger.debug("DBus call set_static_effect")
289
290 # Notify others
291 self.send_effect_event('setStatic', red, green, blue)
292
293 # remember effect
294 self.set_persistence("scroll", "effect", 'static')
295 self.zone["scroll"]["colors"][0:3] = int(red), int(green), int(blue)
296
297 rgb_driver_path = self.get_driver_path('scroll_matrix_effect_static')
298
299 payload = bytes([red, green, blue])
300
301 with open(rgb_driver_path, 'wb') as rgb_driver_file:
302 rgb_driver_file.write(payload)
303
304
305 @endpoint('razer.device.lighting.scroll', 'setScrollSpectrum')
306 def set_scroll_spectrum(self):
307 """
308 Set the device to spectrum mode
309 """
310 self.logger.debug("DBus call set_scroll_spectrum")
311
312 # Notify others
313 self.send_effect_event('setSpectrum')
314
315 self.set_persistence("scroll", "effect", 'spectrum')
316
317 effect_driver_path = self.get_driver_path('scroll_matrix_effect_spectrum')
318
319 with open(effect_driver_path, 'w') as effect_driver_file:
320 effect_driver_file.write('1')
321
322
323 @endpoint('razer.device.lighting.scroll', 'setScrollNone')
324 def set_scroll_none(self):
325 """
326 Set the device to effect none
327 """
328 self.logger.debug("DBus call set_none_effect")
329
330 # Notify others
331 self.send_effect_event('setNone')
332
333 self.set_persistence("scroll", "effect", 'none')
334
335 driver_path = self.get_driver_path('scroll_matrix_effect_none')
336
337 with open(driver_path, 'w') as driver_file:
338 driver_file.write('1')
339
340
341 @endpoint('razer.device.lighting.scroll', 'setScrollOn')
342 def set_scroll_on(self):
343 """
344 Set the device to effect on
345 """
346 self.logger.debug("DBus call set_scroll_on")
347
348 # Notify others
349 self.send_effect_event('setOn')
350
351 self.set_persistence("scroll", "effect", 'on')
352
353 driver_path = self.get_driver_path('scroll_matrix_effect_on')
354
355 with open(driver_path, 'w') as driver_file:
356 driver_file.write('1')
357
358
359 @endpoint('razer.device.lighting.scroll', 'setScrollReactive', in_sig='yyyy')
360 def set_scroll_reactive(self, red, green, blue, speed):
361 """
362 Set the device to reactive effect
363
364 :param red: Red component
365 :type red: int
366
367 :param green: Green component
368 :type green: int
369
370 :param blue: Blue component
371 :type blue: int
372
373 :param speed: Speed
374 :type speed: int
375 """
376 self.logger.debug("DBus call set_reactive_effect")
377
378 driver_path = self.get_driver_path('scroll_matrix_effect_reactive')
379
380 # Notify others
381 self.send_effect_event('setReactive', red, green, blue, speed)
382
383 # remember effect
384 self.set_persistence("scroll", "effect", 'reactive')
385 self.zone["scroll"]["colors"][0:3] = int(red), int(green), int(blue)
386 self.set_persistence("scroll", "speed", int(speed))
387
388 if speed not in (1, 2, 3, 4):
389 speed = 4
390
391 payload = bytes([speed, red, green, blue])
392
393 with open(driver_path, 'wb') as driver_file:
394 driver_file.write(payload)
395
396
397 @endpoint('razer.device.lighting.scroll', 'setScrollBreathMono')
398 def set_scroll_breath_mono(self):
399 """
400 Set the device to mono colour breathing effect
401 """
402 self.logger.debug("DBus call set_scroll_breath_mono")
403
404 # Notify others
405 self.send_effect_event('setBreathMono')
406
407 # remember effect
408 self.set_persistence("scroll", "effect", 'breathMono')
409
410 driver_path = self.get_driver_path('scroll_matrix_effect_breath')
411
412 with open(driver_path, 'wb') as driver_file:
413 driver_file.write(b'1')
414
415
416 @endpoint('razer.device.lighting.scroll', 'setScrollBreathRandom')
417 def set_scroll_breath_random(self):
418 """
419 Set the device to random colour breathing effect
420 """
421 self.logger.debug("DBus call set_breath_random_effect")
422
423 # Notify others
424 self.send_effect_event('setBreathRandom')
425
426 # remember effect
427 self.set_persistence("scroll", "effect", 'breathRandom')
428
429 driver_path = self.get_driver_path('scroll_matrix_effect_breath')
430
431 payload = b'1'
432
433 with open(driver_path, 'wb') as driver_file:
434 driver_file.write(payload)
435
436
437 @endpoint('razer.device.lighting.scroll', 'setScrollBreathSingle', in_sig='yyy')
438 def set_scroll_breath_single(self, red, green, blue):
439 """
440 Set the device to single colour breathing effect
441
442 :param red: Red component
443 :type red: int
444
445 :param green: Green component
446 :type green: int
447
448 :param blue: Blue component
449 :type blue: int
450 """
451 self.logger.debug("DBus call set_breath_single_effect")
452
453 # Notify others
454 self.send_effect_event('setBreathSingle', red, green, blue)
455
456 # remember effect
457 self.set_persistence("scroll", "effect", 'breathSingle')
458 self.zone["scroll"]["colors"][0:3] = int(red), int(green), int(blue)
459
460 driver_path = self.get_driver_path('scroll_matrix_effect_breath')
461
462 payload = bytes([red, green, blue])
463
464 with open(driver_path, 'wb') as driver_file:
465 driver_file.write(payload)
466
467
468 @endpoint('razer.device.lighting.scroll', 'setScrollBreathDual', in_sig='yyyyyy')
469 def set_scroll_breath_dual(self, red1, green1, blue1, red2, green2, blue2):
470 """
471 Set the device to dual colour breathing effect
472
473 :param red1: Red component
474 :type red1: int
475
476 :param green1: Green component
477 :type green1: int
478
479 :param blue1: Blue component
480 :type blue1: int
481
482 :param red2: Red component
483 :type red2: int
484
485 :param green2: Green component
486 :type green2: int
487
488 :param blue2: Blue component
489 :type blue2: int
490 """
491 self.logger.debug("DBus call set_breath_dual_effect")
492
493 # Notify others
494 self.send_effect_event('setBreathDual', red1, green1, blue1, red2, green2, blue2)
495
496 # remember effect
497 self.set_persistence("scroll", "effect", 'breathDual')
498 self.zone["scroll"]["colors"][0:6] = int(red1), int(green1), int(blue1), int(red2), int(green2), int(blue2)
499
500 driver_path = self.get_driver_path('scroll_matrix_effect_breath')
501
502 payload = bytes([red1, green1, blue1, red2, green2, blue2])
503
504 with open(driver_path, 'wb') as driver_file:
505 driver_file.write(payload)
506
507
508 @endpoint('razer.device.lighting.scroll', 'setScrollBlinking', in_sig='yyy')
509 def set_scroll_blinking(self, red, green, blue):
510 """
511 Set the device to blinking mode
512
513 :param red: Red component
514 :type red: int
515
516 :param green: Green component
517 :type green: int
518
519 :param blue: Blue component
520 :type blue: int
521 """
522 self.logger.debug("DBus call set_scroll_blinking")
523
524 # Notify others
525 self.send_effect_event('setBlinking', red, green, blue)
526
527 # remember effect
528 self.set_persistence("scroll", "effect", 'blinking')
529 self.zone["scroll"]["colors"][0:3] = int(red), int(green), int(blue)
530
531 rgb_driver_path = self.get_driver_path('scroll_matrix_effect_blinking')
532
533 payload = bytes([red, green, blue])
534
535 with open(rgb_driver_path, 'wb') as rgb_driver_file:
536 rgb_driver_file.write(payload)