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 #include "resources/resources.h"
  22
  23 bool lcd_keyframe_display_layer_text(keyframe_animation_t* animation, visualizer_state_t* state) {
  24     (void)animation;
  25     gdispClear(White);
  26     gdispDrawString(0, 10, state->layer_text, state->font_dejavusansbold12, Black);
  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     return false;
  66 }
  67
  68 static void format_mods_bitmap_string(uint8_t mods, char* buffer) {
  69     *buffer = ' ';
  70     ++buffer;
  71
  72     for (int i = 0; i<8; i++)
  73     {
  74         uint32_t mask = (1u << i);
  75         if (mods & mask) {
  76             *buffer = '1';
  77         } else {
  78             *buffer = '0';
  79         }
  80         ++buffer;
  81
  82         if (i==3) {
  83             *buffer = ' ';
  84             ++buffer;
  85         }
  86     }
  87     *buffer = 0;
  88 }
  89
  90 bool lcd_keyframe_display_mods_bitmap(keyframe_animation_t* animation, visualizer_state_t* state) {
  91     (void)animation;
  92
  93     const char* title = "Modifier states";
  94     const char* mods_header = " CSAG CSAG ";
  95     char status_buffer[12];
  96
  97     gdispClear(White);
  98     gdispDrawString(0, 0, title, state->font_fixed5x8, Black);
  99     gdispDrawString(0, 10, mods_header, state->font_fixed5x8, Black);
 100     format_mods_bitmap_string(state->status.mods, status_buffer);
 101     gdispDrawString(0, 20, status_buffer, state->font_fixed5x8, Black);
 102
 103     return false;
 104 }
 105
 106 #define LED_STATE_STRING_SIZE sizeof("NUM CAPS SCRL COMP KANA")
 107
 108 static void get_led_state_string(char* output, visualizer_state_t* state) {
 109     uint8_t pos = 0;
 110
 111     if (state->status.leds & (1u << USB_LED_NUM_LOCK)) {
 112        memcpy(output + pos, "NUM ", 4);
 113        pos += 4;
 114     }
 115     if (state->status.leds & (1u << USB_LED_CAPS_LOCK)) {
 116        memcpy(output + pos, "CAPS ", 5);
 117        pos += 5;
 118     }
 119     if (state->status.leds & (1u << USB_LED_SCROLL_LOCK)) {
 120        memcpy(output + pos, "SCRL ", 5);
 121        pos += 5;
 122     }
 123     if (state->status.leds & (1u << USB_LED_COMPOSE)) {
 124        memcpy(output + pos, "COMP ", 5);
 125        pos += 5;
 126     }
 127     if (state->status.leds & (1u << USB_LED_KANA)) {
 128        memcpy(output + pos, "KANA", 4);
 129        pos += 4;
 130     }
 131     output[pos] = 0;
 132 }
 133
 134 bool lcd_keyframe_display_led_states(keyframe_animation_t* animation, visualizer_state_t* state)
 135 {
 136     (void)animation;
 137     char output[LED_STATE_STRING_SIZE];
 138     get_led_state_string(output, state);
 139     gdispClear(White);
 140     gdispDrawString(0, 10, output, state->font_dejavusansbold12, Black);
 141     return false;
 142 }
 143
 144 bool lcd_keyframe_display_layer_and_led_states(keyframe_animation_t* animation, visualizer_state_t* state) {
 145     (void)animation;
 146     gdispClear(White);
 147     uint8_t y = 10;
 148     if (state->status.leds) {
 149         char output[LED_STATE_STRING_SIZE];
 150         get_led_state_string(output, state);
 151         gdispDrawString(0, 1, output, state->font_dejavusansbold12, Black);
 152         y = 17;
 153     }
 154     gdispDrawString(0, y, state->layer_text, state->font_dejavusansbold12, Black);
 155     return false;
 156 }
 157
 158 bool lcd_keyframe_draw_logo(keyframe_animation_t* animation, visualizer_state_t* state) {
 159     (void)state;
 160     (void)animation;
 161     // Read the uGFX documentation for information how to use the displays
 162     // http://wiki.ugfx.org/index.php/Main_Page
 163     gdispClear(White);
 164
 165     // You can use static variables for things that can't be found in the animation
 166     // or state structs, here we use the image
 167
 168     //gdispGBlitArea is a tricky function to use since it supports blitting part of the image
 169     // if you have full screen image, then just use LCD_WIDTH and LCD_HEIGHT for both source and target dimensions
 170     gdispGBlitArea(GDISP, 0, 0, LCD_WIDTH, LCD_HEIGHT, 0, 0, LCD_WIDTH, (pixel_t*)resource_lcd_logo);
 171
 172     return false;
 173 }
 174
 175
 176 bool lcd_keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state) {
 177     (void)animation;
 178     (void)state;
 179     gdispSetPowerMode(powerOff);
 180     return false;
 181 }
 182
 183 bool lcd_keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state) {
 184     (void)animation;
 185     (void)state;
 186     gdispSetPowerMode(powerOn);
 187     return false;
 188 }