aboutsummaryrefslogtreecommitdiff
path: root/users/drashna/oled/oled_stuff.c
diff options
context:
space:
mode:
Diffstat (limited to 'users/drashna/oled/oled_stuff.c')
-rw-r--r--users/drashna/oled/oled_stuff.c445
1 files changed, 445 insertions, 0 deletions
diff --git a/users/drashna/oled/oled_stuff.c b/users/drashna/oled/oled_stuff.c
new file mode 100644
index 000000000..9ee2cbfed
--- /dev/null
+++ b/users/drashna/oled/oled_stuff.c
@@ -0,0 +1,445 @@
1/* Copyright 2020 Christopher Courtney, aka Drashna Jael're (@drashna) <drashna@live.com>
2 *
3 * This program is free software: you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation, either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program. If not, see <http://www.gnu.org/licenses/>.
15 */
16
17#include "drashna.h"
18#ifdef CUSTOM_UNICODE_ENABLE
19# include "process_unicode_common.h"
20#endif
21#include <string.h>
22
23extern bool host_driver_disabled;
24
25#ifndef KEYLOGGER_LENGTH
26// # ifdef OLED_DISPLAY_128X64
27# define KEYLOGGER_LENGTH ((uint8_t)(OLED_DISPLAY_HEIGHT / OLED_FONT_WIDTH))
28// # else
29// # define KEYLOGGER_LENGTH (uint8_t *(OLED_DISPLAY_WIDTH / OLED_FONT_HEIGHT))
30// # endif
31#endif
32
33uint32_t oled_timer = 0;
34static char keylog_str[KEYLOGGER_LENGTH + 1] = {0};
35static uint16_t log_timer = 0;
36
37// clang-format off
38static const char PROGMEM code_to_name[256] = {
39// 0 1 2 3 4 5 6 7 8 9 A B c D E F
40 ' ', ' ', ' ', ' ', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', // 0x
41 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', // 1x
42 '3', '4', '5', '6', '7', '8', '9', '0', 20, 19, 27, 26, 22, '-', '=', '[', // 2x
43 ']','\\', '#', ';','\'', '`', ',', '.', '/', 128,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA, // 3x
44 0xDB,0xDC,0xDD,0xDE,0XDF,0xFB,'P', 'S', 19, ' ', 17, 30, 16, 16, 31, 26, // 4x
45 27, 25, 24, 'N', '/', '*', '-', '+', 23, '1', '2', '3', '4', '5', '6', '7', // 5x
46 '8', '9', '0', '.','\\', 'A', 0, '=', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 6x
47 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 7x
48 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 8x
49 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 9x
50 ' ', ' ', ' ', ' ', ' ', 0, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Ax
51 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Bx
52 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Cx
53 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Dx
54 'C', 'S', 'A', 'C', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 24, 26, 24, // Ex
55 25,0x9D,0x9D,0x9D,0x9D,0x9D,0x9D,0x9D,0x9D, 24, 25, 27, 26, ' ', ' ', ' ' // Fx
56};
57// clang-format on
58
59void add_keylog(uint16_t keycode, keyrecord_t *record) {
60 if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX) || (keycode >= QK_MODS && keycode <= QK_MODS_MAX)) {
61 if (((keycode & 0xFF) == KC_BSPC) && mod_config(get_mods() | get_oneshot_mods()) & MOD_MASK_CTRL) {
62 memset(keylog_str, ' ', sizeof(keylog_str) - 1);
63 return;
64 }
65 if (record->tap.count) {
66 keycode &= 0xFF;
67 } else if (keycode > 0xFF) {
68 return;
69 }
70 }
71 if (keycode > 0xFF) {
72 return;
73 }
74
75 for (uint8_t i = 1; i < KEYLOGGER_LENGTH; i++) {
76 keylog_str[i - 1] = keylog_str[i];
77 }
78
79 if (keycode < (sizeof(code_to_name) / sizeof(char))) {
80 keylog_str[(KEYLOGGER_LENGTH - 1)] = pgm_read_byte(&code_to_name[keycode]);
81 }
82
83 log_timer = timer_read();
84}
85
86bool process_record_user_oled(uint16_t keycode, keyrecord_t *record) {
87 if (record->event.pressed) {
88#ifdef OLED_ENABLE
89 oled_timer = timer_read32();
90 add_keylog(keycode, record);
91#endif
92 }
93 return true;
94}
95
96void update_log(void) {
97 if (timer_elapsed(log_timer) > 750) {
98 // add_keylog(0);
99 }
100}
101
102void render_keylogger_status(void) {
103 oled_write_P(PSTR(OLED_RENDER_KEYLOGGER), false);
104 oled_write(keylog_str, false);
105}
106
107void render_default_layer_state(void) {
108 oled_write_P(PSTR(OLED_RENDER_LAYOUT_NAME), false);
109 switch (get_highest_layer(default_layer_state)) {
110 case _QWERTY:
111 oled_write_P(PSTR(OLED_RENDER_LAYOUT_QWERTY), false);
112 break;
113 case _COLEMAK_DH:
114 oled_write_P(PSTR(OLED_RENDER_LAYOUT_COLEMAK_DH), false);
115 break;
116 case _COLEMAK:
117 oled_write_P(PSTR(OLED_RENDER_LAYOUT_COLEMAK), false);
118 break;
119 case _DVORAK:
120 oled_write_P(PSTR(OLED_RENDER_LAYOUT_DVORAK), false);
121 break;
122 }
123#ifdef OLED_DISPLAY_128X64
124 oled_advance_page(true);
125#endif
126}
127
128void render_layer_state(void) {
129 oled_write_P(PSTR(OLED_RENDER_LAYER_NAME), false);
130#ifdef OLED_DISPLAY_128X64
131 oled_write_P(PSTR(" "), false);
132#endif
133 oled_write_P(PSTR(OLED_RENDER_LAYER_LOWER), layer_state_is(_LOWER));
134#ifdef OLED_DISPLAY_128X64
135 oled_write_P(PSTR(" "), false);
136#endif
137 oled_write_P(PSTR(OLED_RENDER_LAYER_RAISE), layer_state_is(_RAISE));
138#ifdef OLED_DISPLAY_128X64
139 oled_advance_page(true);
140 oled_write_P(PSTR(" "), false);
141 oled_write_P(PSTR("GamePad"), layer_state_is(_GAMEPAD));
142 oled_write_P(PSTR(" "), false);
143 oled_write_P(PSTR("Diablo"), layer_state_is(_DIABLO));
144 oled_write_P(PSTR(" "), false);
145 oled_write_P(PSTR("Mouse"), layer_state_is(_MOUSE));
146#endif
147}
148
149void render_keylock_status(uint8_t led_usb_state) {
150 oled_write_P(PSTR(OLED_RENDER_LOCK_NAME), false);
151#if !defined(OLED_DISPLAY_128X64)
152 oled_write_P(PSTR(" "), false);
153#endif
154 oled_write_P(PSTR(OLED_RENDER_LOCK_NUML), led_usb_state & (1 << USB_LED_NUM_LOCK));
155 oled_write_P(PSTR(" "), false);
156 oled_write_P(PSTR(OLED_RENDER_LOCK_CAPS), led_usb_state & (1 << USB_LED_CAPS_LOCK));
157#if defined(OLED_DISPLAY_128X64)
158 oled_write_P(PSTR(" "), false);
159 oled_write_P(PSTR(OLED_RENDER_LOCK_SCLK), led_usb_state & (1 << USB_LED_SCROLL_LOCK));
160#endif
161}
162
163void render_matrix_scan_rate(void) {
164#ifdef DEBUG_MATRIX_SCAN_RATE
165 char matrix_rate[5];
166 uint16_t n = get_matrix_scan_rate();
167 matrix_rate[4] = '\0';
168 matrix_rate[3] = '0' + n % 10;
169 matrix_rate[2] = (n /= 10) % 10 ? '0' + (n) % 10 : (n / 10) % 10 ? '0' : ' ';
170 matrix_rate[1] = n / 10 ? '0' + n / 10 : ' ';
171 matrix_rate[0] = ' ';
172 oled_write_P(PSTR("MS:"), false);
173 oled_write(matrix_rate, false);
174#endif
175}
176
177void render_mod_status(uint8_t modifiers) {
178 static const char PROGMEM mod_status[5][3] = {{0xE8, 0xE9, 0}, {0xE4, 0xE5, 0}, {0xE6, 0xE7, 0}, {0xEA, 0xEB, 0}, {0xEC, 0xED, 0}};
179 oled_write_P(PSTR(OLED_RENDER_MODS_NAME), false);
180#if defined(OLED_DISPLAY_128X64)
181 oled_write_P(mod_status[0], (modifiers & MOD_BIT(KC_LSHIFT)));
182 oled_write_P(mod_status[!keymap_config.swap_lctl_lgui ? 3 : 4], (modifiers & MOD_BIT(KC_LGUI)));
183 oled_write_P(mod_status[2], (modifiers & MOD_BIT(KC_LALT)));
184 oled_write_P(mod_status[1], (modifiers & MOD_BIT(KC_LCTL)));
185 oled_write_P(mod_status[1], (modifiers & MOD_BIT(KC_RCTL)));
186 oled_write_P(mod_status[2], (modifiers & MOD_BIT(KC_RALT)));
187 oled_write_P(mod_status[!keymap_config.swap_lctl_lgui ? 3 : 4], (modifiers & MOD_BIT(KC_RGUI)));
188 oled_write_P(mod_status[0], (modifiers & MOD_BIT(KC_RSHIFT)));
189#else
190 oled_write_P(mod_status[0], (modifiers & MOD_MASK_SHIFT));
191 oled_write_P(mod_status[!keymap_config.swap_lctl_lgui ? 3 : 4], (modifiers & MOD_MASK_GUI));
192 oled_write_P(PSTR(" "), false);
193 oled_write_P(mod_status[2], (modifiers & MOD_MASK_ALT));
194 oled_write_P(mod_status[1], (modifiers & MOD_MASK_CTRL));
195#endif
196}
197
198#ifdef SWAP_HANDS_ENABLE
199extern bool swap_hands;
200#endif
201
202void render_bootmagic_status(void) {
203 /* Show Ctrl-Gui Swap options */
204 static const char PROGMEM logo[][2][3] = {
205 {{0x97, 0x98, 0}, {0xb7, 0xb8, 0}},
206 {{0x95, 0x96, 0}, {0xb5, 0xb6, 0}},
207 };
208
209 bool is_bootmagic_on;
210#ifdef OLED_DISPLAY_128X64
211 is_bootmagic_on = !keymap_config.swap_lctl_lgui;
212#else
213 is_bootmagic_on = keymap_config.swap_lctl_lgui;
214#endif
215
216 oled_write_P(PSTR(OLED_RENDER_BOOTMAGIC_NAME), false);
217#ifdef OLED_DISPLAY_128X64
218 if (keymap_config.swap_lctl_lgui)
219#else
220 oled_write_P(PSTR(" "), false);
221#endif
222 {
223 oled_write_P(logo[1][0], is_bootmagic_on);
224#ifdef OLED_DISPLAY_128X64
225 } else {
226#endif
227 oled_write_P(logo[0][0], !is_bootmagic_on);
228 }
229#ifndef OLED_DISPLAY_128X64
230 oled_write_P(PSTR(" "), false);
231 oled_write_P(logo[1][1], is_bootmagic_on);
232 oled_write_P(logo[0][1], !is_bootmagic_on);
233#endif
234 oled_write_P(PSTR(" "), false);
235 oled_write_P(PSTR(OLED_RENDER_BOOTMAGIC_NKRO), keymap_config.nkro);
236 oled_write_P(PSTR(" "), false);
237#ifdef AUTOCORRECTION_ENABLE
238 oled_write_P(PSTR("CRCT"), userspace_config.autocorrection);
239#else
240 oled_write_P(PSTR(OLED_RENDER_BOOTMAGIC_NOGUI), keymap_config.no_gui);
241#endif
242#ifdef OLED_DISPLAY_128X64
243 oled_advance_page(true);
244 oled_write_P(PSTR("Magic"), false);
245 oled_write_P(PSTR(" "), false);
246 if (keymap_config.swap_lctl_lgui) {
247 oled_write_P(logo[1][1], is_bootmagic_on);
248 } else {
249 oled_write_P(logo[0][1], !is_bootmagic_on);
250 }
251#endif
252 oled_write_P(PSTR(" "), false);
253 oled_write_P(PSTR(OLED_RENDER_BOOTMAGIC_ONESHOT), !is_oneshot_enabled());
254#ifdef SWAP_HANDS_ENABLE
255 oled_write_P(PSTR(" "), false);
256 oled_write_P(PSTR(OLED_RENDER_BOOTMAGIC_SWAP), swap_hands);
257#endif
258#ifdef OLED_DISPLAY_128X64
259 oled_advance_page(true);
260#endif
261}
262
263#if defined(POINTING_DEVICE_ENABLE)
264extern bool tap_toggling;
265#endif
266
267void render_user_status(void) {
268#ifdef AUDIO_ENABLE
269 bool is_audio_on = false, is_clicky_on = false;
270# ifdef SPLIT_KEYBOARD
271
272 is_audio_on = user_state.audio_enable;
273 is_clicky_on = user_state.audio_clicky_enable;
274# else
275 is_audio_on = is_audio_on();
276 is_clicky_on = is_clicky_on();
277# endif
278#endif
279 oled_write_P(PSTR(OLED_RENDER_USER_NAME), false);
280#if !defined(OLED_DISPLAY_128X64)
281 oled_write_P(PSTR(" "), false);
282#endif
283#if defined(RGB_MATRIX_ENABLE)
284 oled_write_P(PSTR(OLED_RENDER_USER_ANIM), userspace_config.rgb_matrix_idle_anim);
285# if !defined(OLED_DISPLAY_128X64)
286 oled_write_P(PSTR(" "), false);
287# endif
288#elif defined(POINTING_DEVICE_ENABLE)
289 static const char PROGMEM mouse_lock[3] = {0xF2, 0xF3, 0};
290 oled_write_P(mouse_lock, tap_toggling);
291#endif
292#ifdef AUDIO_ENABLE
293 static const char PROGMEM audio_status[2][3] = {{0xE0, 0xE1, 0}, {0xE2, 0xE3, 0}};
294 oled_write_P(audio_status[is_audio_on], false);
295
296# ifdef AUDIO_CLICKY
297 static const char PROGMEM audio_clicky_status[2][3] = {{0xF4, 0xF5, 0}, {0xF6, 0xF7, 0}};
298 oled_write_P(audio_clicky_status[is_clicky_on && is_audio_on], false);
299# if !defined(OLED_DISPLAY_128X64)
300 oled_write_P(PSTR(" "), false);
301# endif
302# endif
303#endif
304
305 static const char PROGMEM rgb_layer_status[2][3] = {{0xEE, 0xEF, 0}, {0xF0, 0xF1, 0}};
306 oled_write_P(rgb_layer_status[userspace_config.rgb_layer_change], false);
307 static const char PROGMEM cat_mode[2][3] = {{0xF8, 0xF9, 0}, {0xF6, 0xF7, 0}};
308 oled_write_P(cat_mode[0], host_driver_disabled);
309#if defined(CUSTOM_UNICODE_ENABLE)
310 static const char PROGMEM uc_mod_status[5][3] = {{0xEA, 0xEB, 0}, {0xEC, 0xED, 0}};
311 oled_write_P(uc_mod_status[get_unicode_input_mode() == UC_MAC], false);
312#endif
313 if (userspace_config.nuke_switch) {
314#if !defined(OLED_DISPLAY_128X64)
315 oled_write_P(PSTR(" "), false);
316#endif
317 static const char PROGMEM nukem_good[2] = {0xFA, 0};
318 oled_write_P(nukem_good, false);
319#if !defined(OLED_DISPLAY_128X64)
320 oled_advance_page(true);
321#endif
322 }
323#if defined(OLED_DISPLAY_128X64)
324 oled_advance_page(true);
325#endif
326}
327
328void oled_driver_render_logo(void) {
329 // clang-format off
330 static const char PROGMEM qmk_logo[] = {
331 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,
332 0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4,
333 0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0xd4,0};
334 // clang-format on
335 oled_write_P(qmk_logo, false);
336}
337
338void render_wpm(uint8_t padding) {
339#ifdef WPM_ENABLE
340
341 oled_write_P(PSTR(OLED_RENDER_WPM_COUNTER), false);
342 if (padding) {
343 for (uint8_t n = padding; n > 0; n--) {
344 oled_write_P(PSTR(" "), false);
345 }
346 }
347 oled_write(get_u8_str(get_current_wpm(), ' '), false);
348#endif
349}
350
351#if defined(KEYBOARD_handwired_tractyl_manuform) || defined(KEYBOARD_bastardkb_charybdis)
352extern kb_config_data_t kb_config;
353void render_pointing_dpi_status(uint8_t padding) {
354 oled_write_P(PSTR("CPI:"), false);
355 if (padding) {
356 for (uint8_t n = padding - 1; n > 0; n--) {
357 oled_write_P(PSTR(" "), false);
358 }
359 }
360
361 oled_write(get_u16_str(kb_config.device_cpi, ' '), false);
362}
363#endif
364
365__attribute__((weak)) void oled_driver_render_logo_right(void) {
366#if defined(OLED_DISPLAY_128X64)
367 oled_driver_render_logo();
368 render_default_layer_state();
369 oled_set_cursor(0, 4);
370#else
371 render_default_layer_state();
372#endif
373}
374
375__attribute__((weak)) void oled_driver_render_logo_left(void) {
376#if defined(OLED_DISPLAY_128X64)
377 oled_driver_render_logo();
378# ifdef DEBUG_MATRIX_SCAN_RATE
379 render_matrix_scan_rate();
380# elif defined(WPM_ENABLE)
381 render_wpm(0);
382# endif
383 oled_write_P(PSTR(" "), false);
384# if defined(KEYBOARD_handwired_tractyl_manuform) || defined(KEYBOARD_bastardkb_charybdis)
385 render_pointing_dpi_status(1);
386# endif
387 oled_set_cursor(0, 4);
388#else
389 render_default_layer_state();
390#endif
391}
392
393void render_status_secondary(void) {
394 oled_driver_render_logo_right();
395 /* Show Keyboard Layout */
396 render_layer_state();
397 render_mod_status(get_mods() | get_oneshot_mods());
398#if !defined(OLED_DISPLAY_128X64) && defined(WPM_ENABLE) && !defined(CONVERT_TO_PROTON_C)
399 render_wpm(2);
400#endif
401 // render_keylock_status(host_keyboard_leds());
402}
403
404void render_status_main(void) {
405 oled_driver_render_logo_left();
406
407 /* Show Keyboard Layout */
408 // render_keylock_status(host_keyboard_leds());
409 render_bootmagic_status();
410 render_user_status();
411
412 // render_keylogger_status();
413}
414
415__attribute__((weak)) oled_rotation_t oled_init_keymap(oled_rotation_t rotation) { return rotation; }
416
417oled_rotation_t oled_init_user(oled_rotation_t rotation) {
418 memset(keylog_str, ' ', sizeof(keylog_str) - 1);
419
420 return oled_init_keymap(rotation);
421}
422
423bool oled_task_user(void) {
424 update_log();
425
426 if (is_keyboard_master()) {
427 if (timer_elapsed32(oled_timer) > 30000) {
428 oled_off();
429 return false;
430 } else {
431 oled_on();
432 }
433 }
434 if (is_keyboard_left()) {
435 render_status_main(); // Renders the current keyboard state (layer, lock, caps, scroll, etc)
436 } else {
437 render_status_secondary();
438 }
439 if (is_keyboard_master()) {
440 render_keylogger_status();
441 } else {
442 render_keylock_status(host_keyboard_leds());
443 }
444 return false;
445}
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-05 23:25:47 +0000