diff options
Diffstat (limited to 'users')
23 files changed, 1715 insertions, 0 deletions
diff --git a/users/muppetjones/.clang-format b/users/muppetjones/.clang-format new file mode 100644 index 0000000000..df3dbd17b4 --- /dev/null +++ b/users/muppetjones/.clang-format @@ -0,0 +1,26 @@ +--- +BasedOnStyle: Google +AlignAfterOpenBracket: Align +AlignConsecutiveAssignments: 'true' +AlignConsecutiveDeclarations: 'true' +AlignOperands: 'true' +AllowAllParametersOfDeclarationOnNextLine: 'false' +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: 'false' +BinPackArguments: 'true' +BinPackParameters: 'true' +ColumnLimit: '160' +IndentCaseLabels: 'true' +IndentPPDirectives: AfterHash +IndentWidth: '4' +MaxEmptyLinesToKeep: '1' +PointerAlignment: Right +SortIncludes: 'false' +SpaceBeforeAssignmentOperators: 'true' +SpaceBeforeParens: ControlStatements +SpaceInEmptyParentheses: 'false' +TabWidth: '4' +UseTab: Never + +... diff --git a/users/muppetjones/config.h b/users/muppetjones/config.h new file mode 100644 index 0000000000..e8afa9d8c5 --- /dev/null +++ b/users/muppetjones/config.h @@ -0,0 +1,44 @@ +/* Copyright 2020 Stephen J. Bush @muppetjones + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#pragma once + +#ifdef RGBLIGHT_ENABLE +// # define RGBLIGHT_ANIMATIONS +# define RGBLIGHT_HUE_STEP 8 +# define RGBLIGHT_SAT_STEP 16 +# define RGBLIGHT_VAL_STEP 16 +# define RGBLIGHT_LIMIT_VAL 150 +# define RGBLIGHT_SLEEP +// # define RGBLIGHT_LAYERS +#endif + +#ifdef TAP_DANCE_ENABLE +// Change "hold" time (default is 200 ms) +// -- used for tap dance and other tap mods +# define TAPPING_TERM 175 + +// Prevent normal rollover on alphas from accidentally triggering mods. +# define IGNORE_MOD_TAP_INTERRUPT + +// Enable rapid switch from tap to hold, disables double tap hold auto-repeat. +# define TAPPING_FORCE_HOLD + +#endif + + +#define COMBO_COUNT 3 +#define COMBO_TERM 40 diff --git a/users/muppetjones/features/casemodes.c b/users/muppetjones/features/casemodes.c new file mode 100644 index 0000000000..da7c5e8fa9 --- /dev/null +++ b/users/muppetjones/features/casemodes.c @@ -0,0 +1,247 @@ +/* Copyright 2021 Andrew Rae ajrae.nv@gmail.com @andrewjrae + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "casemodes.h" + +/* The caps word concept started with me @iaap on splitkb.com discord. + * However it has been implemented and extended by many splitkb.com users: + * - @theol0403 made many improvements to initial implementation + * - @precondition used caps lock rather than shifting + * - @dnaq his own implementation which also used caps lock + * - @sevanteri added underscores on spaces + * - @metheon extended on @sevanteri's work and added specific modes for + * snake_case and SCREAMING_SNAKE_CASE + * - @baffalop came up with the idea for xcase, which he implements in his own + * repo, however this is implemented by @iaap with support also for one-shot-shift. + * - @sevanteri + * - fixed xcase waiting mode to allow more modified keys and keys from other layers. + * - Added @baffalop's separator defaulting on first keypress, with a + * configurable default separator and overrideable function to determine + * if the default should be used. + */ + +#ifndef DEFAULT_XCASE_SEPARATOR +# define DEFAULT_XCASE_SEPARATOR KC_UNDS +#endif + +#define IS_OSM(keycode) (keycode >= QK_ONE_SHOT_MOD && keycode <= QK_ONE_SHOT_MOD_MAX) + +// bool to keep track of the caps word state +static bool caps_word_on = false; + +// enum to keep track of the xcase state +static enum xcase_state xcase_state = XCASE_OFF; +// the keycode of the xcase delimiter +static uint16_t xcase_delimiter; +// the number of keys to the last delimiter +static int8_t distance_to_last_delim = -1; + +// Check whether caps word is on +bool caps_word_enabled(void) { return caps_word_on; } + +// Enable caps word +void enable_caps_word(void) { + caps_word_on = true; +#ifndef CAPSWORD_USE_SHIFT + if (!host_keyboard_led_state().caps_lock) { + tap_code(KC_CAPS); + } +#endif +} + +// Disable caps word +void disable_caps_word(void) { + caps_word_on = false; +#ifndef CAPSWORD_USE_SHIFT + if (host_keyboard_led_state().caps_lock) { + tap_code(KC_CAPS); + } +#else + unregister_mods(MOD_LSFT); +#endif +} + +// Toggle caps word +void toggle_caps_word(void) { + if (caps_word_on) { + disable_caps_word(); + } else { + enable_caps_word(); + } +} + +// Get xcase state +enum xcase_state get_xcase_state(void) { return xcase_state; } + +// Enable xcase and pickup the next keystroke as the delimiter +void enable_xcase(void) { xcase_state = XCASE_WAIT; } + +// Enable xcase with the specified delimiter +void enable_xcase_with(uint16_t delimiter) { + xcase_state = XCASE_ON; + xcase_delimiter = delimiter; + distance_to_last_delim = -1; +} + +// Disable xcase +void disable_xcase(void) { xcase_state = XCASE_OFF; } + +// Place the current xcase delimiter +static void place_delimiter(void) { + if (IS_OSM(xcase_delimiter)) { + // apparently set_oneshot_mods() is dumb and doesn't deal with handedness for you + uint8_t mods = xcase_delimiter & 0x10 ? (xcase_delimiter & 0x0F) << 4 : xcase_delimiter & 0xFF; + set_oneshot_mods(mods); + } else { + tap_code16(xcase_delimiter); + } +} + +// Removes a delimiter, used for double tap space exit +static void remove_delimiter(void) { + if (IS_OSM(xcase_delimiter)) { + clear_oneshot_mods(); + } else { + tap_code(KC_BSPC); + } +} + +// overrideable function to determine whether the case mode should stop +__attribute__((weak)) bool terminate_case_modes(uint16_t keycode, const keyrecord_t *record) { + switch (keycode) { + // Keycodes to ignore (don't disable caps word) + case KC_A ... KC_Z: + case KC_1 ... KC_0: + case KC_MINS: + case KC_BSPC: + // If mod chording disable the mods + if (record->event.pressed && (get_mods() != 0)) { + return true; + } + break; + case KC_UNDS: + // Allow to be pressed with or without a modifier (prob w/ shift) + break; + default: + if (record->event.pressed) { + return true; + } + break; + } + return false; +} + +/* overrideable function to determine whether to use the default separator on + * first keypress when waiting for the separator. */ +__attribute__((weak)) bool use_default_xcase_separator(uint16_t keycode, const keyrecord_t *record) { + // for example: + /* switch (keycode) { */ + /* case KC_A ... KC_Z: */ + /* case KC_1 ... KC_0: */ + /* return true; */ + /* } */ + return false; +} + +bool process_case_modes(uint16_t keycode, const keyrecord_t *record) { + if (caps_word_on || xcase_state) { + if ((QK_MOD_TAP <= keycode && keycode <= QK_MOD_TAP_MAX) || (QK_LAYER_TAP <= keycode && keycode <= QK_LAYER_TAP_MAX)) { + // Earlier return if this has not been considered tapped yet + if (record->tap.count == 0) return true; + keycode = keycode & 0xFF; + } + + if (keycode >= QK_LAYER_TAP && keycode <= QK_ONE_SHOT_LAYER_MAX) { + // let special keys and normal modifiers go through + return true; + } + + if (xcase_state == XCASE_WAIT) { + // grab the next input to be the delimiter + if (use_default_xcase_separator(keycode, record)) { + enable_xcase_with(DEFAULT_XCASE_SEPARATOR); + } else if (record->event.pressed) { + // factor in mods + if (get_mods() & MOD_MASK_SHIFT) { + keycode = LSFT(keycode); + } else if (get_mods() & MOD_BIT(KC_RALT)) { + keycode = RALT(keycode); + } + enable_xcase_with(keycode); + return false; + } else { + if (IS_OSM(keycode)) { + // this catches the OSM release if no other key was pressed + set_oneshot_mods(0); + enable_xcase_with(keycode); + return false; + } + // let other special keys go through + return true; + } + } + + if (record->event.pressed) { + // handle xcase mode + if (xcase_state == XCASE_ON) { + // place the delimiter if space is tapped + if (keycode == KC_SPACE) { + if (distance_to_last_delim != 0) { + place_delimiter(); + distance_to_last_delim = 0; + return false; + } + // remove the delimiter and disable modes + else { + remove_delimiter(); + disable_xcase(); + disable_caps_word(); + return true; + } + } + // decrement distance to delimiter on back space + else if (keycode == KC_BSPC) { + --distance_to_last_delim; + } + // don't increment distance to last delim if negative + else if (distance_to_last_delim >= 0) { + // puts back a one shot delimiter if you we're back to the delimiter pos + if (distance_to_last_delim == 0 && (IS_OSM(xcase_delimiter))) { + place_delimiter(); + } + ++distance_to_last_delim; + } + + } // end XCASE_ON + + // check if the case modes have been terminated + if (terminate_case_modes(keycode, record)) { + disable_caps_word(); + disable_xcase(); + } +#ifdef CAPSWORD_USE_SHIFT + else if (keycode >= KC_A && keycode <= KC_Z) { + tap_code16(LSFT(keycode)); + return false; + } +#endif + + } // end if event.pressed + + return true; + } + return true; +} diff --git a/users/muppetjones/features/casemodes.h b/users/muppetjones/features/casemodes.h new file mode 100644 index 0000000000..4a8c00b3d2 --- /dev/null +++ b/users/muppetjones/features/casemodes.h @@ -0,0 +1,47 @@ +/* Copyright 2021 Andrew Rae ajrae.nv@gmail.com @andrewjrae + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#pragma once + +#include QMK_KEYBOARD_H + +// Check whether caps word is on +bool caps_word_enabled(void); +// Enable caps word +void enable_caps_word(void); +// Disable caps word +void disable_caps_word(void); +// Toggle caps word +void toggle_caps_word(void); + +// enum for the xcase states +enum xcase_state { + XCASE_OFF = 0, // xcase is off + XCASE_ON, // xcase is actively on + XCASE_WAIT, // xcase is waiting for the delimiter input +}; + +// Get xcase state +enum xcase_state get_xcase_state(void); +// Enable xcase and pickup the next keystroke as the delimiter +void enable_xcase(void); +// Enable xcase with the specified delimiter +void enable_xcase_with(uint16_t delimiter); +// Disable xcase +void disable_xcase(void); + +// Function to be put in process user +bool process_case_modes(uint16_t keycode, const keyrecord_t *record); diff --git a/users/muppetjones/features/combos.c b/users/muppetjones/features/combos.c new file mode 100644 index 0000000000..a6d14bb25c --- /dev/null +++ b/users/muppetjones/features/combos.c @@ -0,0 +1,36 @@ +/* Copyright 2020 Stephen J. Bush + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifdef COMBO_ENABLE +# include QMK_KEYBOARD_H + +enum combos { + H_COMM_TAB, + L_U_SCLN, + J_M_CAPS, +}; + +const uint16_t PROGMEM h_comm_tab[] = {KC_H, KC_COMM, COMBO_END}; +const uint16_t PROGMEM l_u_scln[] = {KC_L, KC_U, COMBO_END}; +const uint16_t PROGMEM j_m_caps[] = {KC_J, KC_M, COMBO_END}; + +// COMBO_COUNT defined in config.h +combo_t key_combos[COMBO_COUNT] = { + [H_COMM_TAB] = COMBO(h_comm_tab, KC_TAB), + [L_U_SCLN] = COMBO(l_u_scln, KC_SCLN), + [J_M_CAPS] = COMBO(j_m_caps, KC_CAPS), +}; +#endif diff --git a/users/muppetjones/features/combos.h b/users/muppetjones/features/combos.h new file mode 100644 index 0000000000..af092904e4 --- /dev/null +++ b/users/muppetjones/features/combos.h @@ -0,0 +1,17 @@ +/* Copyright 2020 Stephen J. Bush + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#pragma once diff --git a/users/muppetjones/features/dancelayers.c b/users/muppetjones/features/dancelayers.c new file mode 100644 index 0000000000..e7e5f2a6f2 --- /dev/null +++ b/users/muppetjones/features/dancelayers.c @@ -0,0 +1,98 @@ +/* Copyright 2020 Stephen J. Bush + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifdef TAP_DANCE_ENABLE + +# include QMK_KEYBOARD_H +# include "muppetjones.h" +# include "dancelayers.h" + +// Initialize tap structure associated with example tap dance key +static td_tap_t lyr_tap_state = {.is_press_action = true, .state = TD_NONE}; + +/* @brief Determine the current tap dance state + * @param A tap dance state struct. + * @return A struct. + */ +td_state_t cur_dance(qk_tap_dance_state_t *state) { + switch (state->count) { + case 1: + if (!state->pressed) + return TD_1X_TAP; + else + return TD_1X_HOLD; + case 2: + return TD_2X_TAP; + break; + case 3: + return TD_3X_TAP; + break; + case 4: + return TD_4X_TAP; + break; + default: + return TD_UNKNOWN; + } +} + +// Functions that control what our tap dance key does +__attribute__((weak)) void td_layer_finished(qk_tap_dance_state_t *state, void *user_data) { + lyr_tap_state.state = cur_dance(state); + switch (lyr_tap_state.state) { + case TD_1X_TAP: + if (layer_state_is(_MOUSE)) + layer_off(_MOUSE); + else + layer_on(_MOUSE); + break; + case TD_1X_HOLD: + layer_on(_ADJUST); + break; + case TD_2X_TAP: + // Toggle lower layer + if (layer_state_is(_LOWER)) + layer_off(_LOWER); + else + layer_on(_LOWER); + break; + case TD_3X_TAP: + // Toggle lower layer + if (layer_state_is(_RAISE)) + layer_off(_RAISE); + else + layer_on(_RAISE); + break; + case TD_4X_TAP: + // Toggle lower layer + if (layer_state_is(_ADJUST)) + layer_off(_ADJUST); + else + layer_on(_ADJUST); + break; + default: + break; + } +} + +__attribute__((weak)) void td_layer_reset(qk_tap_dance_state_t *state, void *user_data) { + // If the key was held down and now is released then switch off the layer + if (lyr_tap_state.state == TD_1X_HOLD) { + layer_off(_ADJUST); + } + lyr_tap_state.state = TD_NONE; +} + +#endif diff --git a/users/muppetjones/features/dancelayers.h b/users/muppetjones/features/dancelayers.h new file mode 100644 index 0000000000..23defcca92 --- /dev/null +++ b/users/muppetjones/features/dancelayers.h @@ -0,0 +1,82 @@ +/* Copyright 2020 Stephen J. Bush + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#pragma once +#ifdef TAP_DANCE_ENABLE +# include QMK_KEYBOARD_H + +/* + * TAP DANCE + * https://docs.qmk.fm/#/feature_tap_dance + */ + +// Define a type for as many tap dance states as you need +typedef enum { + TD_NONE = 0, + TD_UNKNOWN, + TD_1X_TAP, + TD_1X_HOLD, + TD_2X_TAP, + TD_3X_TAP, + TD_4X_TAP, +} td_state_t; + +// Our custom tap dance key; add any other tap dance keys to this enum +enum { + TD_LAYERS = 0, // NOTE: Start at 0 as this is also an array index +}; +# define TD_LAYR TD(TD_LAYERS) + +typedef struct { + bool is_press_action; + td_state_t state; +} td_tap_t; + +// Declare the functions to be used with your tap dance key(s) + +/* @brief Determine the current tap dance state + * @param A tap dance state struct. + * @return A struct. + */ +td_state_t cur_dance(qk_tap_dance_state_t *state); + +// Functions associated with individual tap dances + +/* @brief Associate tap actions with layers. + * + * NOTE: Weak attribute. Can (and should) be defined in keymap.c + * + * @param state Pointer to a tap dance state object. + * @param user_data Pointer to user data. + * @return None. + */ +void td_layer_finished(qk_tap_dance_state_t *state, void *user_data); + +/* @brief Reset tap dance actions. + * + * NOTE: Weak attribute. Can (and should) be defined in keymap.c + * + * @param state Pointer to a tap dance state object. + * @param user_data Pointer to user data. + * @return None. + */ +void td_layer_reset(qk_tap_dance_state_t *state, void *user_data); + +/* Define tap dance actions. + */ +__attribute__((weak)) +qk_tap_dance_action_t tap_dance_actions[1] = {[TD_LAYERS] = ACTION_TAP_DANCE_FN_ADVANCED_TIME(NULL, td_layer_finished, td_layer_reset, 275)}; +#endif diff --git a/users/muppetjones/features/etchamouse.c b/users/muppetjones/features/etchamouse.c new file mode 100644 index 0000000000..e1d4c38e81 --- /dev/null +++ b/users/muppetjones/features/etchamouse.c @@ -0,0 +1,101 @@ +/* Copyright 2020 Stephen J. Bush + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include QMK_KEYBOARD_H +#include "etchamouse.h" +#include "pointing_device.h" + +#if defined(POINTING_DEVICE_ENABLE) && defined(ENCODER_ENABLE) + +/** Track movement separately in both directions. This will allow us to + * smooth out the movement along diagonals + */ +typedef struct { + bool clockwise : 1; + uint8_t count : 7; + uint16_t timer : 16; + uint16_t elapsed : 16; +} key_tracker_t; + +static key_tracker_t tracker_x = {false, 0, 0, 0}; +static key_tracker_t tracker_y = {false, 0, 0, 0}; + +/** + * @brief Calculate the mouse move units for the given tracker. + * + * By using a key tracker rederence, we can minimize the amount of space + * required on the stack. As we will have the tracker object, we will also + * take the clockwise direction into account, which completely internalizes + * the movement unit logic within this single function. + * + * @param tracker: Pointer to a key tracker object. + * @return A integer from -127 to 127 + */ +static int8_t move_unit(key_tracker_t *tracker) { + if (0 == tracker->count) return 0; + + const uint16_t modifier = TAPPING_TERM_MOUSE_ENCODER < tracker->elapsed ? 1 : (TAPPING_TERM_MOUSE_ENCODER - tracker->elapsed) >> 1; + uint16_t speed = MOUSEKEY_INITIAL_SPEED + MOUSEKEY_MOVE_DELTA * modifier * (tracker->count >> 1); + + /* convert speed to USB mouse speed 1 to 127 */ + speed = (uint8_t)(speed / (1000.0f / MOUSEKEY_INTERVAL)); + speed = speed < 1 ? 1 : speed; + + return (tracker->clockwise ? 1 : -1) * (speed > MOUSEKEY_MOVE_MAX ? MOUSEKEY_MOVE_MAX : speed); +} + +/** + * @brief Update key press tracker + * + * Update the time elapsed since the last keypress. + * If the key has not been pressed since the tapping term, then reset the count to zero. + * If the key was pressed, update the timer and increment the count. + * Number of keypresses will degrade based on tapping term and zero out based + * on the persistenc term. + * + * @param tracker: The object to update + * @param pressed: A boolean indicating whether or not the key was pressed + * @return None. + */ +static void update_tracker(key_tracker_t *tracker, bool pressed, bool clockwise) { + tracker->elapsed = timer_elapsed(tracker->timer); + if (pressed) { + tracker->timer = timer_read(); + tracker->count += 1; + tracker->clockwise = clockwise; + } else if (TAPPING_TERM_PERSISTENCE < tracker->elapsed) { + tracker->count = 0; + } else if (TAPPING_TERM_MOUSE_ENCODER < tracker->elapsed) { + tracker->count >>= 1; + } +} + +bool encoder_update_mouse(uint8_t index, bool clockwise) { + report_mouse_t curr_report = pointing_device_get_report(); + + update_tracker(&tracker_x, 0 == index, clockwise); + update_tracker(&tracker_y, 1 == index, clockwise); + + curr_report.x += move_unit(&tracker_x); + curr_report.y += move_unit(&tracker_y); + + pointing_device_set_report(curr_report); + pointing_device_send(); + + return true; +} + +#endif diff --git a/users/muppetjones/features/etchamouse.h b/users/muppetjones/features/etchamouse.h new file mode 100644 index 0000000000..86b0d03c6e --- /dev/null +++ b/users/muppetjones/features/etchamouse.h @@ -0,0 +1,59 @@ +/* Copyright 2020 Stephen J. Bush + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#pragma once + +#if defined(POINTING_DEVICE_ENABLE) && defined(ENCODER_ENABLE) + +/* max value on report descriptor */ +# ifndef MOUSEKEY_MOVE_MAX +# define MOUSEKEY_MOVE_MAX 127 +# elif MOUSEKEY_MOVE_MAX > 127 +# error MOUSEKEY_MOVE_MAX needs to be smaller than 127 +# endif +# ifndef MOUSEKEY_MOVE_DELTA +# define MOUSEKEY_MOVE_DELTA 25 +# endif +# ifndef MOUSEKEY_INITIAL_SPEED +# define MOUSEKEY_INITIAL_SPEED 100 +# endif +# ifndef MOUSEKEY_INTERVAL +# define MOUSEKEY_INTERVAL 75 +# endif + +/** Amount of time (ms) before zeroing out the count. + * A higher value will result in smoother curves but may lower accuracy + */ +# ifndef TAPPING_TERM_PERSISTENCE +# define TAPPING_TERM_PERSISTENCE 150 +# endif + +/** Amount of time (ms) to register consecutive key presses + * A higher value will smooth out mouse movement and increase speed for + * consecutive presses. + */ +# ifndef TAPPING_TERM_MOUSE_ENCODER +# define TAPPING_TERM_MOUSE_ENCODER 50 +# endif + +/** @brief Update mouse position based on encoder movement. + * @param index The encoder index. 0 controls x-axis; 1 controls y-axis. + * @param clockwise Indicates direction encoder was turned. + * @returns None. + */ +bool encoder_update_mouse(uint8_t index, bool clockwise); + +#endif diff --git a/users/muppetjones/features/rgblayers.c b/users/muppetjones/features/rgblayers.c new file mode 100644 index 0000000000..46858ae671 --- /dev/null +++ b/users/muppetjones/features/rgblayers.c @@ -0,0 +1,69 @@ +/* Copyright 2020 Stephen J. Bush + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifdef RGBLIGHT_ENABLE +# include QMK_KEYBOARD_H +# include "rgblayers.h" + +static rgblight_config_t home_rgb; + +__attribute__((weak)) void set_layer_hsv(layer_state_t state, HSV* offset) {} + +/* Placeholder function + * If defined in a keymap.c, this will be ignored. + */ +__attribute__((weak)) void post_process_record_keymap(uint16_t keycode, keyrecord_t* record) { return; } + +void post_process_record_user(uint16_t keycode, keyrecord_t* record) { + // Regular user keycode case statement + switch (keycode) { +# ifdef RGBLIGHT_ENABLE + case RGB_HUD: + case RGB_HUI: + case RGB_SAD: + case RGB_SAI: + case RGB_VAD: + case RGB_VAI: + set_rgb_home(); + break; +# endif + default: + break; + } +} + +void set_rgb_home(void) { + home_rgb.raw = eeconfig_read_rgblight(); + // these get the current -- not eeprom + // home_rgb.hue = rgblight_get_hue(); + // home_rgb.sat = rgblight_get_sat(); + // home_rgb.val = rgblight_get_val(); +} + +void set_rgb_by_layer(layer_state_t state) { + if (!rgblight_is_enabled()) { + return; // lighting not enabled + } + + HSV layer_color = {home_rgb.hue, home_rgb.sat, home_rgb.val}; + set_layer_hsv(state, &layer_color); + rgblight_sethsv_noeeprom( // + layer_color.h, // all 3 MUST be btwn 0 and 255 + layer_color.s, // + layer_color.v // + ); +} +#endif diff --git a/users/muppetjones/features/rgblayers.h b/users/muppetjones/features/rg |