From dd7c20a4ee5379302c5c97e8657dcc3fee2942d7 Mon Sep 17 00:00:00 2001 From: Gergely Nagy Date: Sun, 4 Jun 2017 20:14:36 +0200 Subject: [PATCH] Kaleidoscope Style Guide conformance Signed-off-by: Gergely Nagy --- .../LED-Palette-Theme/LED-Palette-Theme.ino | 26 +++-- src/Kaleidoscope/LED-Palette-Theme.cpp | 104 ++++++++---------- src/Kaleidoscope/LED-Palette-Theme.h | 29 ++--- 3 files changed, 77 insertions(+), 82 deletions(-) diff --git a/examples/LED-Palette-Theme/LED-Palette-Theme.ino b/examples/LED-Palette-Theme/LED-Palette-Theme.ino index a530d901..17ad74bd 100644 --- a/examples/LED-Palette-Theme/LED-Palette-Theme.ino +++ b/examples/LED-Palette-Theme/LED-Palette-Theme.ino @@ -22,7 +22,8 @@ #include #include -namespace Example { +namespace example { + class TestLEDMode : public LEDMode { public: TestLEDMode() {} @@ -32,30 +33,30 @@ class TestLEDMode : public LEDMode { static bool focusHook(const char *command); private: - static uint16_t mapBase; + static uint16_t map_base_; }; -uint16_t TestLEDMode::mapBase; +uint16_t TestLEDMode::map_base_; void TestLEDMode::begin(void) { LEDMode::begin(); - mapBase = LEDPaletteTheme.reserveThemes(1); + map_base_ = LEDPaletteTheme.reserveThemes(1); } void TestLEDMode::update(void) { - LEDPaletteTheme.update(mapBase, 0); + LEDPaletteTheme.updateHandler(map_base_, 0); } bool TestLEDMode::focusHook(const char *command) { - return LEDPaletteTheme.themeFocusHandler(command, PSTR("testLedMode.map"), - mapBase, 1); + return LEDPaletteTheme.themeFocusHandler(command, PSTR("testLedMode.map"), map_base_, 1); +} + } -}; -Example::TestLEDMode TestLEDMode; +example::TestLEDMode TestLEDMode; const Key keymaps[][ROWS][COLS] PROGMEM = { [0] = KEYMAP_STACKED @@ -74,13 +75,14 @@ const Key keymaps[][ROWS][COLS] PROGMEM = { Key_skip, Key_N, Key_M, Key_Comma, Key_Period, Key_Slash, Key_Minus, Key_RightShift, Key_RightAlt, Key_Spacebar, Key_RightControl, - Key_NoKey - ), + Key_NoKey), }; void setup() { Serial.begin(9600); - Kaleidoscope.use(&Focus, &LEDPaletteTheme, &TestLEDMode, &EEPROMSettings, NULL); + + USE_PLUGINS(&Focus, &LEDPaletteTheme, &TestLEDMode, &EEPROMSettings); + Kaleidoscope.setup(); EEPROMSettings.seal(); diff --git a/src/Kaleidoscope/LED-Palette-Theme.cpp b/src/Kaleidoscope/LED-Palette-Theme.cpp index 96cd82d5..6c6557f1 100644 --- a/src/Kaleidoscope/LED-Palette-Theme.cpp +++ b/src/Kaleidoscope/LED-Palette-Theme.cpp @@ -21,91 +21,82 @@ #include #include -namespace KaleidoscopePlugins { +namespace kaleidoscope { -uint16_t LEDPaletteTheme::paletteBase; -uint8_t LEDPaletteTheme::transparentIndex = 15; +uint16_t LEDPaletteTheme::palette_base_; +uint8_t LEDPaletteTheme::transparent_index = 15; LEDPaletteTheme::LEDPaletteTheme(void) { } -void -LEDPaletteTheme::begin(void) { +void LEDPaletteTheme::begin(void) { USE_PLUGINS(&::EEPROMSettings); - if (!paletteBase) - paletteBase = ::EEPROMSettings.requestSlice(16 * sizeof(cRGB)); + if (!palette_base_) + palette_base_ = ::EEPROMSettings.requestSlice(16 * sizeof(cRGB)); } -uint16_t -LEDPaletteTheme::reserveThemes(uint8_t maxThemes) { - return ::EEPROMSettings.requestSlice(maxThemes * ROWS * COLS / 2); +uint16_t LEDPaletteTheme::reserveThemes(uint8_t max_themes) { + return ::EEPROMSettings.requestSlice(max_themes * ROWS * COLS / 2); } -void -LEDPaletteTheme::update(uint16_t themeBase, uint8_t theme) { - uint16_t mapBase = themeBase + (theme * ROWS * COLS / 2); - for (uint16_t loc = 0; loc < ROWS * COLS; loc++) { +void LEDPaletteTheme::updateHandler(uint16_t theme_base, uint8_t theme) { + uint16_t map_base = theme_base + (theme * ROWS * COLS / 2); + for (uint16_t pos = 0; pos < ROWS * COLS; pos++) { cRGB color; - if (!lookupColor(mapBase, loc, &color)) + if (!lookupColorAtPosition(theme_base, pos, &color)) continue; - LEDControl.led_set_crgb_at(loc, color); - + LEDControl.led_set_crgb_at(pos, color); } } -const uint8_t -LEDPaletteTheme::lookupColorIndex(uint16_t mapBase, uint16_t loc) { - uint8_t colorIndex; +const uint8_t LEDPaletteTheme::lookupColorIndexAtPosition(uint16_t map_base, uint16_t position) { + uint8_t color_index; - colorIndex = EEPROM.read(mapBase + loc / 2); - if (loc % 2) - colorIndex &= ~0xf0; + color_index = EEPROM.read(map_base + position / 2); + if (position % 2) + color_index &= ~0xf0; else - colorIndex >>= 4; + color_index >>= 4; - return colorIndex; + return color_index; } -const bool -LEDPaletteTheme::lookupColor(uint16_t mapBase, uint16_t loc, cRGB *color) { - uint8_t colorIndex = lookupColorIndex(mapBase, loc); +const bool LEDPaletteTheme::lookupColorAtPosition(uint16_t map_base, uint16_t position, cRGB *color) { + uint8_t color_index = lookupColorIndexAtPosition(map_base, position); - if (colorIndex == transparentIndex) + if (color_index == transparent_index) return false; - EEPROM.get(paletteBase + colorIndex * sizeof(cRGB), *color); + *color = lookupPaletteColor(color_index); return true; } -const cRGB -LEDPaletteTheme::lookupColor(uint8_t index) { +const cRGB LEDPaletteTheme::lookupPaletteColor(uint8_t color_index) { cRGB color; - EEPROM.get(paletteBase + index * sizeof(cRGB), color); + EEPROM.get(palette_base_ + color_index * sizeof(cRGB), color); return color; } -void -LEDPaletteTheme::updateColor(uint16_t mapBase, uint16_t loc, uint8_t index) { +void LEDPaletteTheme::updateColorIndexAtPosition(uint16_t map_base, uint16_t position, uint8_t color_index) { uint8_t indexes; - indexes = EEPROM.read(mapBase + loc / 2); - if (loc % 2) { + indexes = EEPROM.read(map_base + position / 2); + if (position % 2) { uint8_t other = indexes >> 4; - indexes = (other << 4) + index; + indexes = (other << 4) + color_index; } else { uint8_t other = indexes & ~0xf0; - indexes = (index << 4) + other; + indexes = (color_index << 4) + other; } - EEPROM.update(mapBase + loc / 2, indexes); + EEPROM.update(map_base + position / 2, indexes); } -bool -LEDPaletteTheme::paletteFocusHook(const char *command) { +bool LEDPaletteTheme::paletteFocusHook(const char *command) { if (strcmp_P(command, PSTR("palette")) != 0) return false; @@ -113,7 +104,7 @@ LEDPaletteTheme::paletteFocusHook(const char *command) { for (uint8_t i = 0; i < 16; i++) { cRGB color; - EEPROM.get(paletteBase + i * sizeof(color), color); + EEPROM.get(palette_base_ + i * sizeof(color), color); ::Focus.printColor(color.r, color.g, color.b); ::Focus.printSpace(); } @@ -129,24 +120,23 @@ LEDPaletteTheme::paletteFocusHook(const char *command) { color.g = Serial.parseInt(); color.b = Serial.parseInt(); - EEPROM.put(paletteBase + i * sizeof(color), color); + EEPROM.put(palette_base_ + i * sizeof(color), color); i++; } return true; } -bool -LEDPaletteTheme::themeFocusHandler(const char *command, const char *expectedCommand, - uint16_t themeBase, uint8_t maxThemes) { - if (strcmp_P(command, expectedCommand) != 0) +bool LEDPaletteTheme::themeFocusHandler(const char *command, const char *expected_command, + uint16_t theme_base, uint8_t max_themes) { + if (strcmp_P(command, expected_command) != 0) return false; - uint16_t maxIndex = (maxThemes * ROWS * COLS) / 2; + uint16_t max_index = (max_themes * ROWS * COLS) / 2; if (Serial.peek() == '\n') { - for (uint16_t loc = 0; loc < maxIndex; loc++) { - uint8_t indexes = EEPROM.read(themeBase + loc); + for (uint16_t pos = 0; pos < max_index; pos++) { + uint8_t indexes = EEPROM.read(theme_base + pos); ::Focus.printNumber(indexes >> 4); ::Focus.printSpace(); @@ -157,20 +147,20 @@ LEDPaletteTheme::themeFocusHandler(const char *command, const char *expectedComm return true; } - uint16_t loc = 0; + uint16_t pos = 0; - while ((Serial.peek() != '\n') && (loc < maxIndex)) { + while ((Serial.peek() != '\n') && (pos < max_index)) { uint8_t idx1 = Serial.parseInt(); uint8_t idx2 = Serial.parseInt(); uint8_t indexes = (idx1 << 4) + idx2; - EEPROM.update(themeBase + loc, indexes); - loc++; + EEPROM.update(theme_base + pos, indexes); + pos++; } return true; } -}; +} -KaleidoscopePlugins::LEDPaletteTheme LEDPaletteTheme; +kaleidoscope::LEDPaletteTheme LEDPaletteTheme; diff --git a/src/Kaleidoscope/LED-Palette-Theme.h b/src/Kaleidoscope/LED-Palette-Theme.h index 9d12a4af..f855a31f 100644 --- a/src/Kaleidoscope/LED-Palette-Theme.h +++ b/src/Kaleidoscope/LED-Palette-Theme.h @@ -21,33 +21,36 @@ #include #include -namespace KaleidoscopePlugins { +namespace kaleidoscope { + class LEDPaletteTheme : public KaleidoscopePlugin { public: LEDPaletteTheme(void); void begin(void) final; - static uint16_t reserveThemes(uint8_t maxThemes); - static void update(uint16_t themeBase, uint8_t theme); + static uint16_t reserveThemes(uint8_t max_themes); + static void updateHandler(uint16_t theme_base, uint8_t theme); + + static const uint8_t lookupColorIndexAtPosition(uint16_t theme_base, uint16_t position); + static const bool lookupColorAtPosition(uint16_t theme_base, uint16_t position, cRGB *color); + static void updateColorIndexAtPosition(uint16_t theme_base, uint16_t position, uint8_t color_index); - static const uint8_t lookupColorIndex(uint16_t mapBase, uint16_t loc); - static const cRGB lookupColor(uint8_t index); - static const bool lookupColor(uint16_t mapBase, uint16_t loc, cRGB *color); - static void updateColor(uint16_t mapBase, uint16_t loc, uint8_t index); + static const cRGB lookupPaletteColor(uint8_t palette_index); static bool paletteFocusHook(const char *command); - static bool themeFocusHandler(const char *command, const char *expectedCommand, - uint16_t themeBase, uint8_t maxThemes); + static bool themeFocusHandler(const char *command, const char *expected_command, + uint16_t theme_base, uint8_t max_themes); - static uint8_t transparentIndex; + static uint8_t transparent_index; private: - static uint16_t paletteBase; -}; + static uint16_t palette_base_; }; -extern KaleidoscopePlugins::LEDPaletteTheme LEDPaletteTheme; +} + +extern kaleidoscope::LEDPaletteTheme LEDPaletteTheme; #define FOCUS_HOOK_LEDPALETTETHEME \ FOCUS_HOOK(LEDPaletteTheme.paletteFocusHook, \