logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

theme_djinn_default.c (11261B)

    

  1. // Copyright 2018-2022 Nick Brassel (@tzarc)
  2. // SPDX-License-Identifier: GPL-2.0-or-later
  3. #include <hal.h>
  4. #include <string.h>
  5. #include <ctype.h>
  6. #include <printf.h>
  7. #include "qp.h"
  8. #include "backlight.h"
  9. #include "transactions.h"
  10. #include "split_util.h"
  12. #include "djinn.h"
  13. #include "theme_djinn_default.h"
  15. #include "djinn.qgf.h"
  16. #include "lock-caps-ON.qgf.h"
  17. #include "lock-scrl-ON.qgf.h"
  18. #include "lock-num-ON.qgf.h"
  19. #include "lock-caps-OFF.qgf.h"
  20. #include "lock-scrl-OFF.qgf.h"
  21. #include "lock-num-OFF.qgf.h"
  22. #include "thintel15.qff.h"
  24. static painter_image_handle_t djinn_logo;
  25. static painter_image_handle_t lock_caps_on;
  26. static painter_image_handle_t lock_caps_off;
  27. static painter_image_handle_t lock_num_on;
  28. static painter_image_handle_t lock_num_off;
  29. static painter_image_handle_t lock_scrl_on;
  30. static painter_image_handle_t lock_scrl_off;
  31. static painter_font_handle_t  thintel;
  33. //----------------------------------------------------------
  34. // RGB Matrix naming
  35. #if defined(RGB_MATRIX_ENABLE)
  36. #    include <rgb_matrix.h>
  38. #    if defined(RGB_MATRIX_EFFECT)
  39. #        undef RGB_MATRIX_EFFECT
  40. #    endif // defined(RGB_MATRIX_EFFECT)
  42. #    define RGB_MATRIX_EFFECT(x) RGB_MATRIX_EFFECT_##x,
  43. enum {
  44.     RGB_MATRIX_EFFECT_NONE,
  45. #    include "rgb_matrix_effects.inc"
  46. #    ifdef RGB_MATRIX_CUSTOM_KB
  47. #        include "rgb_matrix_kb.inc"
  48. #    endif
  49. #    ifdef RGB_MATRIX_CUSTOM_USER
  50. #        include "rgb_matrix_user.inc"
  51. #    endif
  52. #    if defined(COMMUNITY_MODULES_ENABLE) && __has_include("rgb_matrix_community_modules.inc")
  53. #        include "rgb_matrix_community_modules.inc"
  54. #    endif
  55. #    undef RGB_MATRIX_EFFECT
  56. };
  58. #    define RGB_MATRIX_EFFECT(x)    \
  59.         case RGB_MATRIX_EFFECT_##x: \
  60.             return #x;
  61. const char *rgb_matrix_name(uint8_t effect) {
  62.     switch (effect) {
  63.         case RGB_MATRIX_EFFECT_NONE:
  64.             return "NONE";
  65. #    include "rgb_matrix_effects.inc"
  66. #    ifdef RGB_MATRIX_CUSTOM_KB
  67. #        include "rgb_matrix_kb.inc"
  68. #    endif
  69. #    ifdef RGB_MATRIX_CUSTOM_USER
  70. #        include "rgb_matrix_user.inc"
  71. #    endif
  72. #    if defined(COMMUNITY_MODULES_ENABLE) && __has_include("rgb_matrix_community_modules.inc")
  73. #        include "rgb_matrix_community_modules.inc"
  74. #    endif
  75. #    undef RGB_MATRIX_EFFECT
  76.         default:
  77.             return "UNKNOWN";
  78.     }
  79. }
  80. #endif // defined(RGB_MATRIX_ENABLE)
  82. //----------------------------------------------------------
  83. // UI Initialisation
  84. void keyboard_post_init_display(void) {
  85.     djinn_logo    = qp_load_image_mem(gfx_djinn);
  86.     lock_caps_on  = qp_load_image_mem(gfx_lock_caps_ON);
  87.     lock_caps_off = qp_load_image_mem(gfx_lock_caps_OFF);
  88.     lock_num_on   = qp_load_image_mem(gfx_lock_num_ON);
  89.     lock_num_off  = qp_load_image_mem(gfx_lock_num_OFF);
  90.     lock_scrl_on  = qp_load_image_mem(gfx_lock_scrl_ON);
  91.     lock_scrl_off = qp_load_image_mem(gfx_lock_scrl_OFF);
  92.     thintel       = qp_load_font_mem(font_thintel15);
  93. }
  95. //----------------------------------------------------------
  96. // UI Drawing
  97. void draw_ui_user(bool force_redraw) {
  98.     bool            hue_redraw = force_redraw;
  99.     static uint16_t last_hue   = 0xFFFF;
  100. #if defined(RGB_MATRIX_ENABLE)
  101.     uint16_t curr_hue = rgb_matrix_get_hue();
  102. #else  // defined(RGB_MATRIX_ENABLE)
  103.     uint16_t curr_hue = 0;
  104. #endif // defined(RGB_MATRIX_ENABLE)
  105.     if (last_hue != curr_hue) {
  106.         last_hue   = curr_hue;
  107.         hue_redraw = true;
  108.     }
  110.     bool            layer_state_redraw = false;
  111.     static uint32_t last_layer_state   = 0;
  112.     if (last_layer_state != layer_state) {
  113.         last_layer_state   = layer_state;
  114.         layer_state_redraw = true;
  115.     }
  117.     bool                     power_state_redraw = false;
  118.     static usbpd_allowance_t last_current_state = (usbpd_allowance_t)(~0);
  119.     if (last_current_state != kb_state.current_setting) {
  120.         last_current_state = kb_state.current_setting;
  121.         power_state_redraw = true;
  122.     }
  124.     bool            scan_redraw      = false;
  125.     static uint32_t last_scan_update = 0;
  126.     if (timer_elapsed32(last_scan_update) > 125) {
  127.         last_scan_update = timer_read32();
  128.         scan_redraw      = true;
  129.     }
  131.     bool            wpm_redraw      = false;
  132.     static uint32_t last_wpm_update = 0;
  133.     if (timer_elapsed32(last_wpm_update) > 125) {
  134.         last_wpm_update = timer_read32();
  135.         wpm_redraw      = true;
  136.     }
  138. #if defined(RGB_MATRIX_ENABLE)
  139.     bool            rgb_effect_redraw = false;
  140.     static uint16_t last_effect       = 0xFFFF;
  141.     uint8_t         curr_effect       = rgb_matrix_config.mode;
  142.     if (last_effect != curr_effect) {
  143.         last_effect       = curr_effect;
  144.         rgb_effect_redraw = true;
  145.     }
  146. #endif // defined(RGB_MATRIX_ENABLE)
  148.     // Show the Djinn logo and two vertical bars on both sides
  149.     if (hue_redraw) {
  150.         qp_drawimage_recolor(lcd, 120 - djinn_logo->width / 2, 32, djinn_logo, curr_hue, 255, 255, curr_hue, 255, 0);
  151.         qp_rect(lcd, 0, 0, 8, 319, curr_hue, 255, 255, true);
  152.         qp_rect(lcd, 231, 0, 239, 319, curr_hue, 255, 255, true);
  153.     }
  155.     int ypos = 4;
  157.     // Show layer info on the left side
  158.     if (is_keyboard_left()) {
  159.         char buf[64] = {0};
  160.         int  xpos    = 16;
  162. #if defined(RGB_MATRIX_ENABLE)
  163.         if (hue_redraw || rgb_effect_redraw) {
  164.             static int max_rgb_xpos = 0;
  165.             xpos                    = 16;
  166.             snprintf(buf, sizeof(buf), "rgb: %s", rgb_matrix_name(curr_effect));
  168.             for (int i = 5; i < sizeof(buf); ++i) {
  169.                 if (buf[i] == 0)
  170.                     break;
  171.                 else if (buf[i] == '_')
  172.                     buf[i] = ' ';
  173.                 else if (buf[i - 1] == ' ')
  174.                     buf[i] = toupper(buf[i]);
  175.                 else if (buf[i - 1] != ' ')
  176.                     buf[i] = tolower(buf[i]);
  177.             }
  179.             xpos += qp_drawtext_recolor(lcd, xpos, ypos, thintel, buf, curr_hue, 255, 255, curr_hue, 255, 0);
  180.             if (max_rgb_xpos < xpos) {
  181.                 max_rgb_xpos = xpos;
  182.             }
  183.             qp_rect(lcd, xpos, ypos, max_rgb_xpos, ypos + thintel->line_height, 0, 0, 0, true);
  184.         }
  186.         ypos += thintel->line_height + 4;
  187. #endif // defined(RGB_MATRIX_ENABLE)
  189.         if (hue_redraw || layer_state_redraw) {
  190.             extern const char *current_layer_name(void);
  191.             const char        *layer_name = current_layer_name();
  193.             static int max_layer_xpos = 0;
  194.             xpos                      = 16;
  195.             snprintf(buf, sizeof(buf), "layer: %s", layer_name);
  196.             xpos += qp_drawtext_recolor(lcd, xpos, ypos, thintel, buf, curr_hue, 255, 255, curr_hue, 255, 0);
  197.             if (max_layer_xpos < xpos) {
  198.                 max_layer_xpos = xpos;
  199.             }
  200.             qp_rect(lcd, xpos, ypos, max_layer_xpos, ypos + thintel->line_height, 0, 0, 0, true);
  201.         }
  203.         ypos += thintel->line_height + 4;
  205.         if (hue_redraw || power_state_redraw) {
  206.             static int max_power_xpos = 0;
  207.             xpos                      = 16;
  208.             snprintf(buf, sizeof(buf), "power: %s", usbpd_str(kb_state.current_setting));
  209.             xpos += qp_drawtext_recolor(lcd, xpos, ypos, thintel, buf, curr_hue, 255, 255, curr_hue, 255, 0);
  210.             if (max_power_xpos < xpos) {
  211.                 max_power_xpos = xpos;
  212.             }
  213.             qp_rect(lcd, xpos, ypos, max_power_xpos, ypos + thintel->line_height, 0, 0, 0, true);
  214.         }
  216.         ypos += thintel->line_height + 4;
  218.         if (hue_redraw || scan_redraw) {
  219.             static int max_scans_xpos = 0;
  220.             xpos                      = 16;
  221.             snprintf(buf, sizeof(buf), "scans: %d", (int)theme_state.scan_rate);
  222.             xpos += qp_drawtext_recolor(lcd, xpos, ypos, thintel, buf, curr_hue, 255, 255, curr_hue, 255, 0);
  223.             if (max_scans_xpos < xpos) {
  224.                 max_scans_xpos = xpos;
  225.             }
  226.             qp_rect(lcd, xpos, ypos, max_scans_xpos, ypos + thintel->line_height, 0, 0, 0, true);
  227.         }
  229.         ypos += thintel->line_height + 4;
  231.         if (hue_redraw || wpm_redraw) {
  232.             static int max_wpm_xpos = 0;
  233.             xpos                    = 16;
  234.             snprintf(buf, sizeof(buf), "wpm: %d", (int)get_current_wpm());
  235.             xpos += qp_drawtext_recolor(lcd, xpos, ypos, thintel, buf, curr_hue, 255, 255, curr_hue, 255, 0);
  236.             if (max_wpm_xpos < xpos) {
  237.                 max_wpm_xpos = xpos;
  238.             }
  239.             qp_rect(lcd, xpos, ypos, max_wpm_xpos, ypos + thintel->line_height, 0, 0, 0, true);
  240.         }
  242.         ypos += thintel->line_height + 4;
  243.     }
  245.     // Show LED lock indicators on the right side
  246.     if (!is_keyboard_left()) {
  247.         static led_t last_led_state = {0};
  248.         if (hue_redraw || last_led_state.raw != host_keyboard_led_state().raw) {
  249.             last_led_state.raw = host_keyboard_led_state().raw;
  250.             qp_drawimage_recolor(lcd, 239 - 12 - (32 * 3), 0, last_led_state.caps_lock ? lock_caps_on : lock_caps_off, curr_hue, 255, last_led_state.caps_lock ? 255 : 32, curr_hue, 255, 0);
  251.             qp_drawimage_recolor(lcd, 239 - 12 - (32 * 2), 0, last_led_state.num_lock ? lock_num_on : lock_num_off, curr_hue, 255, last_led_state.num_lock ? 255 : 32, curr_hue, 255, 0);
  252.             qp_drawimage_recolor(lcd, 239 - 12 - (32 * 1), 0, last_led_state.scroll_lock ? lock_scrl_on : lock_scrl_off, curr_hue, 255, last_led_state.scroll_lock ? 255 : 32, curr_hue, 255, 0);
  253.         }
  254.     }
  255. }
  257. //----------------------------------------------------------
  258. // Sync
  260. theme_runtime_config theme_state;
  262. void rpc_theme_sync_callback(uint8_t m2s_size, const void *m2s_buffer, uint8_t s2m_size, void *s2m_buffer) {
  263.     if (m2s_size == sizeof(theme_state)) {
  264.         memcpy(&theme_state, m2s_buffer, m2s_size);
  265.     }
  266. }
  268. void theme_init(void) {
  269.     // Register keyboard state sync split transaction
  270.     transaction_register_rpc(THEME_DATA_SYNC, rpc_theme_sync_callback);
  272.     // Reset the initial shared data value between master and slave
  273.     memset(&theme_state, 0, sizeof(theme_state));
  274. }
  276. void theme_state_update(void) {
  277.     if (is_keyboard_master()) {
  278.         // Keep the scan rate in sync
  279.         theme_state.scan_rate = get_matrix_scan_rate();
  280.     }
  281. }
  283. void theme_state_sync(void) {
  284.     if (!is_transport_connected()) return;
  286.     if (is_keyboard_master()) {
  287.         // Keep track of the last state, so that we can tell if we need to propagate to slave
  288.         static theme_runtime_config last_theme_state;
  289.         static uint32_t             last_sync;
  290.         bool                        needs_sync = false;
  292.         // Check if the state values are different
  293.         if (memcmp(&theme_state, &last_theme_state, sizeof(theme_runtime_config))) {
  294.             needs_sync = true;
  295.             memcpy(&last_theme_state, &theme_state, sizeof(theme_runtime_config));
  296.         }
  298.         // Send to slave every 125ms regardless of state change
  299.         if (timer_elapsed32(last_sync) > 125) {
  300.             needs_sync = true;
  301.         }
  303.         // Perform the sync if requested
  304.         if (needs_sync) {
  305.             if (transaction_rpc_send(THEME_DATA_SYNC, sizeof(theme_runtime_config), &theme_state)) {
  306.                 last_sync = timer_read32();
  307.             } else {
  308.                 dprint("Failed to perform rpc call\n");
  309.             }
  310.         }
  311.     }
  312. }