// -*- mode: c++ -*-
#pragma once
/*
this class implements a color theme editor as a LED mode
when this mode is active, nothing gets sent to the host
the Fn keys switch into editing mode, with that half housing the controls
the controls are:
* 8 keys for the 8 colors we currently use
* 3 rows of 4 keys to change the active color in the HSV space
pressing a key on the non-control half of the keyboard assigns the
current color to that key
*/
#include <Kaleidoscope-LEDControl.h>
#include <kaleidoscope/plugin/LEDControl/LEDUtils.h>
#include <Kaleidoscope-FocusSerial.h>
class ColorPicker : public kaleidoscope::plugin::LEDMode {
public:
ColorPicker(void) : current_index(0), which_half(BOTH_HALVES),
colors{}, map{},
hsv_colors{
{ .h=0, .s=150, .v=128 },
{ .h=32, .s=150, .v=128 },
{ .h=64, .s=150, .v=128 },
{ .h=96, .s=150, .v=128 },
{ .h=128, .s=150, .v=128 },
{ .h=160, .s=150, .v=128 },
{ .h=192, .s=150, .v=128 },
{ .h=224, .s=150, .v=128 },
}
{
for (uint8_t i=0;i<16;++i) {
hsv& col = hsv_colors[i];
colors[i] = hsvToRgb(col.h,col.s,col.v);
}
}
kaleidoscope::EventHandlerResult onKeyswitchEvent(KeyEvent &event) {
if (!Kaleidoscope.has_leds || !is_active())
return kaleidoscope::EventHandlerResult::OK;
// only care at press time
if (!keyToggledOn(event.state))
return kaleidoscope::EventHandlerResult::EVENT_CONSUMED;
// uh?
if (event.addr.row() >= kaleidoscope_internal::device.matrix_rows || event.addr.col() >= kaleidoscope_internal::device.matrix_columns)
return kaleidoscope::EventHandlerResult::EVENT_CONSUMED;
// pressing a Fn makes that half the "editing" half; pressing it
// again disables editing
picker_key key = whichKey(event.addr.row(),event.addr.col());
switch (key) {
case OFF:
break;
case LED_KEY:
return kaleidoscope::EventHandlerResult::OK; // let other plugins deal with this
case SHOW:
map[event.addr.row()][event.addr.col()] = current_index; break;
case SWITCH_LEFT:
which_half = which_half == RIGHT_HALF ? BOTH_HALVES : RIGHT_HALF; break;
case SWITCH_RIGHT:
which_half = which_half == LEFT_HALF ? BOTH_HALVES : LEFT_HALF; break;
case COLOR_1 ... COLOR_8:
current_index = key - COLOR_1; break;
case HUE_M10:
updateCurrentColor(-10,0,0); break;
case HUE_M1:
updateCurrentColor(-1,0,0); break;
case HUE_P1:
updateCurrentColor(+1,0,0); break;
case HUE_P10:
updateCurrentColor(+10,0,0); break;
case SAT_M10:
updateCurrentColor(0,-10,0); break;
case SAT_M1:
updateCurrentColor(0,-1,0); break;
case SAT_P1:
updateCurrentColor(0,+1,0); break;
case SAT_P10:
updateCurrentColor(0,+10,0); break;
case VAL_M10:
updateCurrentColor(0,0,-10); break;
case VAL_M1:
updateCurrentColor(0,0,-1); break;
case VAL_P1:
updateCurrentColor(0,0,+1); break;
case VAL_P10:
updateCurrentColor(0,0,+10); break;
};
return kaleidoscope::EventHandlerResult::EVENT_CONSUMED;
}
kaleidoscope::EventHandlerResult onFocusEvent(const char *command) {
if (Focus.handleHelp(command, PSTR("color-picker.dump")))
return kaleidoscope::EventHandlerResult::OK;
if (strncmp_P(command, PSTR("color-picker."), 13) != 0)
return kaleidoscope::EventHandlerResult::OK;
if (strcmp_P(command + 13, PSTR("dump")) != 0)
return kaleidoscope::EventHandlerResult::OK;
for (uint8_t i=0;i<16;++i) {
Focus.send(F("color"),i,colors[i],Focus.NEWLINE);
}
Focus.send(F("map\n"));
for (uint8_t r=0;r<kaleidoscope_internal::device.matrix_rows;++r) {
for (uint8_t c=0;c<kaleidoscope_internal::device.matrix_columns;++c) {
Focus.send(map[r][c]);
}
Focus.send(Focus.NEWLINE);
}
return kaleidoscope::EventHandlerResult::EVENT_CONSUMED;
}
protected:
void update(void) {
for (KeyAddr key_addr : KeyAddr::all()) {
LEDControl.setCrgbAt(key_addr, getColor(key_addr.row(),key_addr.col() ));
}
}
void refreshAt(KeyAddr key_addr) final {
LEDControl.setCrgbAt(key_addr, getColor(key_addr.row(),key_addr.col()));
}
private:
uint8_t current_index;
enum { BOTH_HALVES, LEFT_HALF, RIGHT_HALF } which_half;
cRGB colors[16];
uint8_t map[kaleidoscope_internal::device.matrix_rows][kaleidoscope_internal::device.matrix_columns];
struct hsv { uint8_t h; uint8_t s; uint8_t v; }
hsv_colors[16];
static inline uint8_t add_and_clamp(uint8_t value, int8_t delta) {
int16_t result = ((int16_t)value) + delta;
if (result < 0) return 0;
if (result > 255) return 255;
return result;
}
static inline uint8_t add_and_wrap(uint8_t value, int8_t delta) {
int16_t result = ((int16_t)value) + delta;
if (result < 0) return result+255;
if (result > 255) return result-255;
return result;
}
void updateCurrentColor(int8_t delta_h, int8_t delta_s, int8_t delta_v) {
hsv& color = hsv_colors[current_index];
color.h = add_and_wrap(color.h,delta_h);
color.s = add_and_clamp(color.s,delta_s);
color.v = add_and_clamp(color.v,delta_v);
colors[current_index] = hsvToRgb(color.h,color.s,color.v);
}
bool is_active() {
return LEDControl.get_mode() == this;
}
typedef enum { OFF, LED_KEY, SHOW,
SWITCH_LEFT, SWITCH_RIGHT,
COLOR_1, COLOR_2, COLOR_3, COLOR_4,
COLOR_5, COLOR_6, COLOR_7, COLOR_8,
HUE_M10, HUE_M1, HUE_P1, HUE_P10,
SAT_M10, SAT_M1, SAT_P1, SAT_P10,
VAL_M10, VAL_M1, VAL_P1, VAL_P10 }
picker_key;
picker_key whichKey(byte row, byte col) {
if (row == 3 && col == 6) {
return SWITCH_LEFT;
}
else if (row == 3 && col == 9) {
return SWITCH_RIGHT;
}
else if (row == 0 && col == 6) {
return LED_KEY;
}
// non-editing half? show it
if (which_half == BOTH_HALVES ||
(col < 8 && which_half == LEFT_HALF) ||
(col >= 8 && which_half == RIGHT_HALF)) {
return SHOW;
}
// pretend we're always showing the right half, by changing col if we're not
if (which_half == LEFT_HALF) {
switch (col) {
case 8: col=6; break;
case 9: col=7; break;
case 10: col=2; break;
case 11: col=3; break;
case 12: col=4; break;
case 13: col=5; break;
case 14: col=0; break;
case 15: col=1; break;
}
}
switch (col) {
case 0:
switch (row) {
case 0:
return COLOR_1;
case 1:
return COLOR_2;
case 2:
return COLOR_3;
case 3:
return COLOR_4;
default:
return OFF;
};
case 1:
switch (row) {
case 0:
return COLOR_5;
case 1:
return COLOR_6;
case 2:
return COLOR_7;
case 3:
return COLOR_8;
default:
return OFF;
};
case 2:
switch (row) {
case 1:
return HUE_M10;
case 2:
return SAT_M10;
case 3:
return VAL_M10;
default:
return OFF;
};
case 3:
switch (row) {
case 1:
return HUE_M1;
case 2:
return SAT_M1;
case 3:
return VAL_M1;
default:
return OFF;
};
case 4:
switch (row) {
case 1:
return HUE_P1;
case 2:
return SAT_P1;
case 3:
return VAL_P1;
default:
return OFF;
};
case 5:
switch (row) {
case 1:
return HUE_P10;
case 2:
return SAT_P10;
case 3:
return VAL_P10;
default:
return OFF;
};
default:
return OFF;
};
// won't be reached
return SHOW;
}
cRGB getColor(byte row, byte col) {
picker_key key = whichKey(row,col);
switch (key) {
case SHOW:
return colors[map[row][col]];
case OFF:
case LED_KEY:
case SWITCH_LEFT:
case SWITCH_RIGHT:
return CRGB(0,0,0);
case COLOR_1...COLOR_8:
return colors[key - COLOR_1];
case HUE_M10:
return hsvToRgb(add_and_wrap(hsv_colors[current_index].h,-10),255,128);
case HUE_M1:
return hsvToRgb(add_and_wrap(hsv_colors[current_index].h,-1),255,128);
case HUE_P1:
return hsvToRgb(add_and_wrap(hsv_colors[current_index].h,+1),255,128);
case HUE_P10:
return hsvToRgb(add_and_wrap(hsv_colors[current_index].h,+10),255,128);
case SAT_M10:
return hsvToRgb(hsv_colors[current_index].h,50,128);
case SAT_M1:
return hsvToRgb(hsv_colors[current_index].h,100,128);
case SAT_P1:
return hsvToRgb(hsv_colors[current_index].h,150,128);
case SAT_P10:
return hsvToRgb(hsv_colors[current_index].h,200,128);
case VAL_M10:
return hsvToRgb(hsv_colors[current_index].h,128,50);
case VAL_M1:
return hsvToRgb(hsv_colors[current_index].h,128,100);
case VAL_P1:
return hsvToRgb(hsv_colors[current_index].h,128,150);
case VAL_P10:
return hsvToRgb(hsv_colors[current_index].h,128,200);
};
// won't be reached
return colors[map[row][col]];
}
};
ColorPicker theColorPicker;
