quantum/visualizer/lcd_keyframes.c

   1 /* Copyright 2017 Fred Sundvik
   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 "lcd_keyframes.h"
  18 #include <string.h>
  19 #include "action_util.h"
  20 #include "led.h"
  21
  22 bool lcd_keyframe_display_layer_text(keyframe_animation_t* animation, visualizer_state_t* state) {
  23     (void)animation;
  24     gdispClear(White);
  25     gdispDrawString(0, 10, state->layer_text, state->font_dejavusansbold12, Black);
  26     gdispFlush();
  27     return false;
  28 }
  29
  30 static void format_layer_bitmap_string(uint16_t default_layer, uint16_t layer, char* buffer) {
  31     for (int i=0; i<16;i++)
  32     {
  33         uint32_t mask = (1u << i);
  34         if (default_layer & mask) {
  35             if (layer & mask) {
  36                 *buffer = 'B';
  37             } else {
  38                 *buffer = 'D';
  39             }
  40         } else if (layer & mask) {
  41             *buffer = '1';
  42         } else {
  43             *buffer = '0';
  44         }
  45         ++buffer;
  46
  47         if (i==3 || i==7 || i==11) {
  48             *buffer = ' ';
  49             ++buffer;
  50         }
  51     }
  52     *buffer = 0;
  53 }
  54
  55 bool lcd_keyframe_display_layer_bitmap(keyframe_animation_t* animation, visualizer_state_t* state) {
  56     (void)animation;
  57     const char* layer_help = "1=On D=Default B=Both";
  58     char layer_buffer[16 + 4]; // 3 spaces and one null terminator
  59     gdispClear(White);
  60     gdispDrawString(0, 0, layer_help, state->font_fixed5x8, Black);
  61     format_layer_bitmap_string(state->status.default_layer, state->status.layer, layer_buffer);
  62     gdispDrawString(0, 10, layer_buffer, state->font_fixed5x8, Black);
  63     format_layer_bitmap_string(state->status.default_layer >> 16, state->status.layer >> 16, layer_buffer);
  64     gdispDrawString(0, 20, layer_buffer, state->font_fixed5x8, Black);
  65     gdispFlush();
  66     return false;
  67 }
  68
  69 static void format_mods_bitmap_string(uint8_t mods, char* buffer) {
  70     *buffer = ' ';
  71     ++buffer;
  72
  73     for (int i = 0; i<8; i++)
  74     {
  75         uint32_t mask = (1u << i);
  76         if (mods & mask) {
  77             *buffer = '1';
  78         } else {
  79             *buffer = '0';
  80         }
  81         ++buffer;
  82
  83         if (i==3) {
  84             *buffer = ' ';
  85             ++buffer;
  86         }
  87     }
  88     *buffer = 0;
  89 }
  90
  91 bool lcd_keyframe_display_mods_bitmap(keyframe_animation_t* animation, visualizer_state_t* state) {
  92     (void)animation;
  93
  94     const char* title = "Modifier states";
  95     const char* mods_header = " CSAG CSAG ";
  96     char status_buffer[12];
  97
  98     gdispClear(White);
  99     gdispDrawString(0, 0, title, state->font_fixed5x8, Black);
 100     gdispDrawString(0, 10, mods_header, state->font_fixed5x8, Black);
 101     format_mods_bitmap_string(state->status.mods, status_buffer);
 102     gdispDrawString(0, 20, status_buffer, state->font_fixed5x8, Black);
 103
 104     gdispFlush();
 105     return false;
 106 }
 107
 108 #define LED_STATE_STRING_SIZE sizeof("NUM CAPS SCRL COMP KANA")
 109
 110 static void get_led_state_string(char* output, visualizer_state_t* state) {
 111     uint8_t pos = 0;
 112
 113     if (state->status.leds & (1u << USB_LED_NUM_LOCK)) {
 114        memcpy(output + pos, "NUM ", 4);
 115        pos += 4;
 116     }
 117     if (state->status.leds & (1u << USB_LED_CAPS_LOCK)) {
 118        memcpy(output + pos, "CAPS ", 5);
 119        pos += 5;
 120     }
 121     if (state->status.leds & (1u << USB_LED_SCROLL_LOCK)) {
 122        memcpy(output + pos, "SCRL ", 5);
 123        pos += 5;
 124     }
 125     if (state->status.leds & (1u << USB_LED_COMPOSE)) {
 126        memcpy(output + pos, "COMP ", 5);
 127        pos += 5;
 128     }
 129     if (state->status.leds & (1u << USB_LED_KANA)) {
 130        memcpy(output + pos, "KANA ", 5);
 131        pos += 5;
 132     }
 133     output[pos] = 0;
 134 }
 135
 136 bool lcd_keyframe_display_led_states(keyframe_animation_t* animation, visualizer_state_t* state)
 137 {
 138     (void)animation;
 139     char output[LED_STATE_STRING_SIZE];
 140     get_led_state_string(output, state);
 141     gdispClear(White);
 142     gdispDrawString(0, 10, output, state->font_dejavusansbold12, Black);
 143     gdispFlush();
 144     return false;
 145 }
 146
 147 bool lcd_keyframe_display_layer_and_led_states(keyframe_animation_t* animation, visualizer_state_t* state) {
 148     (void)animation;
 149     gdispClear(White);
 150     uint8_t y = 10;
 151     if (state->status.leds) {
 152         char output[LED_STATE_STRING_SIZE];
 153         get_led_state_string(output, state);
 154         gdispDrawString(0, 1, output, state->font_dejavusansbold12, Black);
 155         y = 17;
 156     }
 157     gdispDrawString(0, y, state->layer_text, state->font_dejavusansbold12, Black);
 158     gdispFlush();
 159     return false;
 160 }