diff --git a/keyboards/cyboard/config.h b/keyboards/cyboard/config.h index 411f818e7de..58f226e426d 100644 --- a/keyboards/cyboard/config.h +++ b/keyboards/cyboard/config.h @@ -44,4 +44,6 @@ #define SPI_MOSI_PIN GP23 #define POINTING_DEVICE_CS_PIN GP21 #define POINTING_DEVICE_INVERT_X -#define PMW3360_CPI 500 \ No newline at end of file +#define PMW3360_CPI 500 +#define SPLIT_POINTING_ENABLE +#define POINTING_DEVICE_RIGHT diff --git a/keyboards/cyboard/cyboard.c b/keyboards/cyboard/cyboard.c new file mode 100644 index 00000000000..ee4a5deaf09 --- /dev/null +++ b/keyboards/cyboard/cyboard.c @@ -0,0 +1,384 @@ +/* + * Copyright 2020 Christopher Courtney (@drashna) + * Copyright 2021 Quentin LEBASTARD + * Copyright 2021 Charly Delay (@0xcharly) + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Publicw 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 . + */ + +#include "cyboard.h" +#include "transactions.h" +#include + +#ifdef CONSOLE_ENABLE +# include "print.h" +#endif // CONSOLE_ENABLE + +#ifdef POINTING_DEVICE_ENABLE +# ifndef CHARYBDIS_MINIMUM_DEFAULT_DPI +# define CHARYBDIS_MINIMUM_DEFAULT_DPI 400 +# endif // CHARYBDIS_MINIMUM_DEFAULT_DPI + +# ifndef CHARYBDIS_DEFAULT_DPI_CONFIG_STEP +# define CHARYBDIS_DEFAULT_DPI_CONFIG_STEP 200 +# endif // CHARYBDIS_DEFAULT_DPI_CONFIG_STEP + +# ifndef CHARYBDIS_MINIMUM_SNIPING_DPI +# define CHARYBDIS_MINIMUM_SNIPING_DPI 200 +# endif // CHARYBDIS_MINIMUM_SNIPER_MODE_DPI + +# ifndef CHARYBDIS_SNIPING_DPI_CONFIG_STEP +# define CHARYBDIS_SNIPING_DPI_CONFIG_STEP 100 +# endif // CHARYBDIS_SNIPING_DPI_CONFIG_STEP + +// Fixed DPI for drag-scroll. +# ifndef CHARYBDIS_DRAGSCROLL_DPI +# define CHARYBDIS_DRAGSCROLL_DPI 100 +# endif // CHARYBDIS_DRAGSCROLL_DPI + +# ifndef CHARYBDIS_DRAGSCROLL_BUFFER_SIZE +# define CHARYBDIS_DRAGSCROLL_BUFFER_SIZE 6 +# endif // !CHARYBDIS_DRAGSCROLL_BUFFER_SIZE + +typedef union { + uint8_t raw; + struct { + uint8_t pointer_default_dpi : 4; // 16 steps available. + uint8_t pointer_sniping_dpi : 2; // 4 steps available. + bool is_dragscroll_enabled : 1; + bool is_sniping_enabled : 1; + } __attribute__((packed)); +} charybdis_config_t; + +static charybdis_config_t g_charybdis_config = {0}; + +/** + * \brief Set the value of `config` from EEPROM. + * + * Note that `is_dragscroll_enabled` and `is_sniping_enabled` are purposefully + * ignored since we do not want to persist this state to memory. In practice, + * this state is always written to maximize write-performances. Therefore, we + * explicitly set them to `false` in this function. + */ +static void read_charybdis_config_from_eeprom(charybdis_config_t* config) { + config->raw = eeconfig_read_kb() & 0xff; + config->is_dragscroll_enabled = false; + config->is_sniping_enabled = false; +} + +/** + * \brief Save the value of `config` to eeprom. + * + * Note that all values are written verbatim, including whether drag-scroll + * and/or sniper mode are enabled. `read_charybdis_config_from_eeprom(…)` + * resets these 2 values to `false` since it does not make sense to persist + * these across reboots of the board. + */ +static void write_charybdis_config_to_eeprom(charybdis_config_t* config) { + eeconfig_update_kb(config->raw); +} + +/** \brief Return the current value of the pointer's default DPI. */ +static uint16_t get_pointer_default_dpi(charybdis_config_t* config) { + return (uint16_t)config->pointer_default_dpi * CHARYBDIS_DEFAULT_DPI_CONFIG_STEP + CHARYBDIS_MINIMUM_DEFAULT_DPI; +} + +/** \brief Return the current value of the pointer's sniper-mode DPI. */ +static uint16_t get_pointer_sniping_dpi(charybdis_config_t* config) { + return (uint16_t)config->pointer_sniping_dpi * CHARYBDIS_SNIPING_DPI_CONFIG_STEP + CHARYBDIS_MINIMUM_SNIPING_DPI; +} + +/** \brief Set the appropriate DPI for the input config. */ +static void maybe_update_pointing_device_cpi(charybdis_config_t* config) { + if (config->is_dragscroll_enabled) { + pointing_device_set_cpi(CHARYBDIS_DRAGSCROLL_DPI); + } else if (config->is_sniping_enabled) { + pointing_device_set_cpi(get_pointer_sniping_dpi(config)); + } else { + pointing_device_set_cpi(get_pointer_default_dpi(config)); + } +} + +/** + * \brief Update the pointer's default DPI to the next or previous step. + * + * Increases the DPI value if `forward` is `true`, decreases it otherwise. + * The increment/decrement steps are equal to CHARYBDIS_DEFAULT_DPI_CONFIG_STEP. + */ +static void step_pointer_default_dpi(charybdis_config_t* config, bool forward) { + config->pointer_default_dpi += forward ? 1 : -1; + maybe_update_pointing_device_cpi(config); +} + +/** + * \brief Update the pointer's sniper-mode DPI to the next or previous step. + * + * Increases the DPI value if `forward` is `true`, decreases it otherwise. + * The increment/decrement steps are equal to CHARYBDIS_SNIPING_DPI_CONFIG_STEP. + */ +static void step_pointer_sniping_dpi(charybdis_config_t* config, bool forward) { + config->pointer_sniping_dpi += forward ? 1 : -1; + maybe_update_pointing_device_cpi(config); +} + +uint16_t charybdis_get_pointer_default_dpi(void) { + return get_pointer_default_dpi(&g_charybdis_config); +} + +uint16_t charybdis_get_pointer_sniping_dpi(void) { + return get_pointer_sniping_dpi(&g_charybdis_config); +} + +void charybdis_cycle_pointer_default_dpi_noeeprom(bool forward) { + step_pointer_default_dpi(&g_charybdis_config, forward); +} + +void charybdis_cycle_pointer_default_dpi(bool forward) { + step_pointer_default_dpi(&g_charybdis_config, forward); + write_charybdis_config_to_eeprom(&g_charybdis_config); +} + +void charybdis_cycle_pointer_sniping_dpi_noeeprom(bool forward) { + step_pointer_sniping_dpi(&g_charybdis_config, forward); +} + +void charybdis_cycle_pointer_sniping_dpi(bool forward) { + step_pointer_sniping_dpi(&g_charybdis_config, forward); + write_charybdis_config_to_eeprom(&g_charybdis_config); +} + +bool charybdis_get_pointer_sniping_enabled(void) { + return g_charybdis_config.is_sniping_enabled; +} + +void charybdis_set_pointer_sniping_enabled(bool enable) { + g_charybdis_config.is_sniping_enabled = enable; + maybe_update_pointing_device_cpi(&g_charybdis_config); +} + +bool charybdis_get_pointer_dragscroll_enabled(void) { + return g_charybdis_config.is_dragscroll_enabled; +} + +void charybdis_set_pointer_dragscroll_enabled(bool enable) { + g_charybdis_config.is_dragscroll_enabled = enable; + maybe_update_pointing_device_cpi(&g_charybdis_config); +} + +/** + * \brief Augment the pointing device behavior. + * + * Implement drag-scroll. + */ +static void pointing_device_task_charybdis(report_mouse_t* mouse_report) { + static int16_t scroll_buffer_x = 0; + static int16_t scroll_buffer_y = 0; + if (g_charybdis_config.is_dragscroll_enabled) { +# ifdef CHARYBDIS_DRAGSCROLL_REVERSE_X + scroll_buffer_x -= mouse_report->x; +# else + scroll_buffer_x += mouse_report->x; +# endif // CHARYBDIS_DRAGSCROLL_REVERSE_X +# ifdef CHARYBDIS_DRAGSCROLL_REVERSE_Y + scroll_buffer_y -= mouse_report->y; +# else + scroll_buffer_y += mouse_report->y; +# endif // CHARYBDIS_DRAGSCROLL_REVERSE_Y + mouse_report->x = 0; + mouse_report->y = 0; + if (abs(scroll_buffer_x) > CHARYBDIS_DRAGSCROLL_BUFFER_SIZE) { + mouse_report->h = scroll_buffer_x > 0 ? 1 : -1; + scroll_buffer_x = 0; + } + if (abs(scroll_buffer_y) > CHARYBDIS_DRAGSCROLL_BUFFER_SIZE) { + mouse_report->v = scroll_buffer_y > 0 ? 1 : -1; + scroll_buffer_y = 0; + } + } +} + +report_mouse_t pointing_device_task_kb(report_mouse_t mouse_report) { + if (is_keyboard_master()) { + pointing_device_task_charybdis(&mouse_report); + mouse_report = pointing_device_task_user(mouse_report); + } + return mouse_report; +} + +# if defined(POINTING_DEVICE_ENABLE) && !defined(NO_CHARYBDIS_KEYCODES) +/** \brief Whether SHIFT mod is enabled. */ +static bool has_shift_mod(void) { +# ifdef NO_ACTION_ONESHOT + return mod_config(get_mods()) & MOD_MASK_SHIFT; +# else + return mod_config(get_mods() | get_oneshot_mods()) & MOD_MASK_SHIFT; +# endif // NO_ACTION_ONESHOT +} +# endif // POINTING_DEVICE_ENABLE && !NO_CHARYBDIS_KEYCODES + +/** + * \brief Outputs the Charybdis configuration to console. + * + * Prints the in-memory configuration structure to console, for debugging. + * Includes: + * - raw value + * - drag-scroll: on/off + * - sniping: on/off + * - default DPI: internal table index/actual DPI + * - sniping DPI: internal table index/actual DPI + */ +static void debug_charybdis_config_to_console(charybdis_config_t* config) { +# ifdef CONSOLE_ENABLE + dprintf("(charybdis) process_record_kb: config = {\n" + "\traw = 0x%X,\n" + "\t{\n" + "\t\tis_dragscroll_enabled=%u\n" + "\t\tis_sniping_enabled=%u\n" + "\t\tdefault_dpi=0x%X (%u)\n" + "\t\tsniping_dpi=0x%X (%u)\n" + "\t}\n" + "}\n", + config->raw, config->is_dragscroll_enabled, config->is_sniping_enabled, config->pointer_default_dpi, get_pointer_default_dpi(config), config->pointer_sniping_dpi, get_pointer_sniping_dpi(config)); +# endif // CONSOLE_ENABLE +} + +bool process_record_kb(uint16_t keycode, keyrecord_t* record) { + if (!process_record_user(keycode, record)) { + debug_charybdis_config_to_console(&g_charybdis_config); + return false; + } +# ifdef POINTING_DEVICE_ENABLE +# ifndef NO_CHARYBDIS_KEYCODES + switch (keycode) { + case POINTER_DEFAULT_DPI_FORWARD: + if (record->event.pressed) { + // Step backward if shifted, forward otherwise. + charybdis_cycle_pointer_default_dpi(/* forward= */ !has_shift_mod()); + } + break; + case POINTER_DEFAULT_DPI_REVERSE: + if (record->event.pressed) { + // Step forward if shifted, backward otherwise. + charybdis_cycle_pointer_default_dpi(/* forward= */ has_shift_mod()); + } + break; + case POINTER_SNIPING_DPI_FORWARD: + if (record->event.pressed) { + // Step backward if shifted, forward otherwise. + charybdis_cycle_pointer_sniping_dpi(/* forward= */ !has_shift_mod()); + } + break; + case POINTER_SNIPING_DPI_REVERSE: + if (record->event.pressed) { + // Step forward if shifted, backward otherwise. + charybdis_cycle_pointer_sniping_dpi(/* forward= */ has_shift_mod()); + } + break; + case SNIPING_MODE: + charybdis_set_pointer_sniping_enabled(record->event.pressed); + break; + case SNIPING_MODE_TOGGLE: + if (record->event.pressed) { + charybdis_set_pointer_sniping_enabled(!charybdis_get_pointer_sniping_enabled()); + } + break; + case DRAGSCROLL_MODE: + charybdis_set_pointer_dragscroll_enabled(record->event.pressed); + break; + case DRAGSCROLL_MODE_TOGGLE: + if (record->event.pressed) { + charybdis_set_pointer_dragscroll_enabled(!charybdis_get_pointer_dragscroll_enabled()); + } + break; + } +# endif // !NO_CHARYBDIS_KEYCODES +# endif // POINTING_DEVICE_ENABLE + if (IS_QK_KB(keycode) || IS_MOUSEKEY(keycode)) { + debug_charybdis_config_to_console(&g_charybdis_config); + } + return true; +} + +void eeconfig_init_kb(void) { + g_charybdis_config.raw = 0; + write_charybdis_config_to_eeprom(&g_charybdis_config); + maybe_update_pointing_device_cpi(&g_charybdis_config); + eeconfig_init_user(); +} + +void matrix_init_kb(void) { + read_charybdis_config_from_eeprom(&g_charybdis_config); + matrix_init_user(); +} + +# ifdef CHARYBDIS_CONFIG_SYNC +void charybdis_config_sync_handler(uint8_t initiator2target_buffer_size, const void* initiator2target_buffer, uint8_t target2initiator_buffer_size, void* target2initiator_buffer) { + if (initiator2target_buffer_size == sizeof(g_charybdis_config)) { + memcpy(&g_charybdis_config, initiator2target_buffer, sizeof(g_charybdis_config)); + } +} +# endif + +void keyboard_post_init_kb(void) { + maybe_update_pointing_device_cpi(&g_charybdis_config); +# ifdef CHARYBDIS_CONFIG_SYNC + transaction_register_rpc(RPC_ID_KB_CONFIG_SYNC, charybdis_config_sync_handler); +# endif + keyboard_post_init_user(); +} + +# ifdef CHARYBDIS_CONFIG_SYNC +void housekeeping_task_kb(void) { + if (is_keyboard_master()) { + // Keep track of the last state, so that we can tell if we need to propagate to slave. + static charybdis_config_t last_charybdis_config = {0}; + static uint32_t last_sync = 0; + bool needs_sync = false; + + // Check if the state values are different. + if (memcmp(&g_charybdis_config, &last_charybdis_config, sizeof(g_charybdis_config))) { + needs_sync = true; + memcpy(&last_charybdis_config, &g_charybdis_config, sizeof(g_charybdis_config)); + } + // Send to slave every 500ms regardless of state change. + if (timer_elapsed32(last_sync) > 500) { + needs_sync = true; + } + + // Perform the sync if requested. + if (needs_sync) { + if (transaction_rpc_send(RPC_ID_KB_CONFIG_SYNC, sizeof(g_charybdis_config), &g_charybdis_config)) { + last_sync = timer_read32(); + } + } + } + // No need to invoke the user-specific callback, as it's been called + // already. +} +# endif // CHARYBDIS_CONFIG_SYNC +#endif // POINTING_DEVICE_ENABLE + +#if defined(KEYBOARD_bastardkb_charybdis_3x5_blackpill) || defined(KEYBOARD_bastardkb_charybdis_4x6_blackpill) +void keyboard_pre_init_kb(void) { + setPinInputHigh(A0); + keyboard_pre_init_user(); +} + +void matrix_scan_kb(void) { + if (!readPin(A0)) { + reset_keyboard(); + } + matrix_scan_user(); +} +#endif // KEYBOARD_bastardkb_charybdis_3x5_blackpill || KEYBOARD_bastardkb_charybdis_4x6_blackpill diff --git a/keyboards/cyboard/cyboard.h b/keyboards/cyboard/cyboard.h new file mode 100644 index 00000000000..a8ee639d9a0 --- /dev/null +++ b/keyboards/cyboard/cyboard.h @@ -0,0 +1,111 @@ +/* + * Copyright 2021 Quentin LEBASTARD + * Copyright 2021 Charly Delay (@0xcharly) + * + * 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 . + */ + +#pragma once + +#include "quantum.h" + +#ifdef POINTING_DEVICE_ENABLE +# ifndef NO_CHARYBDIS_KEYCODES +enum charybdis_keycodes { + POINTER_DEFAULT_DPI_FORWARD = QK_KB_0, + POINTER_DEFAULT_DPI_REVERSE, + POINTER_SNIPING_DPI_FORWARD, + POINTER_SNIPING_DPI_REVERSE, + SNIPING_MODE, + SNIPING_MODE_TOGGLE, + DRAGSCROLL_MODE, + DRAGSCROLL_MODE_TOGGLE, +}; + +# define DPI_MOD POINTER_DEFAULT_DPI_FORWARD +# define DPI_RMOD POINTER_DEFAULT_DPI_REVERSE +# define S_D_MOD POINTER_SNIPING_DPI_FORWARD +# define S_D_RMOD POINTER_SNIPING_DPI_REVERSE +# define SNIPING SNIPING_MODE +# define SNP_TOG SNIPING_MODE_TOGGLE +# define DRGSCRL DRAGSCROLL_MODE +# define DRG_TOG DRAGSCROLL_MODE_TOGGLE +# endif // !NO_CHARYBDIS_KEYCODES + +/** \brief Return the current DPI value for the pointer's default mode. */ +uint16_t charybdis_get_pointer_default_dpi(void); + +/** + * \brief Update the pointer's default DPI to the next or previous step. + * + * Increases the DPI value if `forward` is `true`, decreases it otherwise. + * The increment/decrement steps are equal to CHARYBDIS_DEFAULT_DPI_CONFIG_STEP. + * + * The new value is persisted in EEPROM. + */ +void charybdis_cycle_pointer_default_dpi(bool forward); + +/** + * \brief Same as `charybdis_cycle_pointer_default_dpi`, but do not write to + * EEPROM. + * + * This means that reseting the board will revert the value to the last + * persisted one. + */ +void charybdis_cycle_pointer_default_dpi_noeeprom(bool forward); + +/** \brief Return the current DPI value for the pointer's sniper-mode. */ +uint16_t charybdis_get_pointer_sniping_dpi(void); + +/** + * \brief Update the pointer's sniper-mode DPI to the next or previous step. + * + * Increases the DPI value if `forward` is `true`, decreases it otherwise. + * The increment/decrement steps are equal to CHARYBDIS_SNIPING_DPI_CONFIG_STEP. + * + * The new value is persisted in EEPROM. + */ +void charybdis_cycle_pointer_sniping_dpi(bool forward); + +/** + * \brief Same as `charybdis_cycle_pointer_sniping_dpi`, but do not write to + * EEPROM. + * + * This means that reseting the board will revert the value to the last + * persisted one. + */ +void charybdis_cycle_pointer_sniping_dpi_noeeprom(bool forward); + +/** \brief Whether sniper-mode is enabled. */ +bool charybdis_get_pointer_sniping_enabled(void); + +/** + * \brief Enable/disable sniper mode. + * + * When sniper mode is enabled the dpi is reduced to slow down the pointer for + * more accurate movements. + */ +void charybdis_set_pointer_sniping_enabled(bool enable); + +/** \brief Whether drag-scroll is enabled. */ +bool charybdis_get_pointer_dragscroll_enabled(void); + +/** + * \brief Enable/disable drag-scroll mode. + * + * When drag-scroll mode is enabled, horizontal and vertical pointer movements + * are translated into horizontal and vertical scroll movements. + */ +void charybdis_set_pointer_dragscroll_enabled(bool enable); +#endif // POINTING_DEVICE_ENABLE diff --git a/keyboards/cyboard/imprint/imprint_function_row/keymaps/vial/keymap.c b/keyboards/cyboard/imprint/imprint_function_row/keymaps/vial/keymap.c index 8eaa787acb6..26e7633c353 100644 --- a/keyboards/cyboard/imprint/imprint_function_row/keymaps/vial/keymap.c +++ b/keyboards/cyboard/imprint/imprint_function_row/keymaps/vial/keymap.c @@ -3,6 +3,7 @@ */ #include QMK_KEYBOARD_H +#include const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { @@ -13,7 +14,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_LGUI, KC_LALT, KC_LGUI, KC_ENT, KC_DEL, KC_BSPC, KC_SPC, MO(1), KC_LBRC, KC_RBRC, - KC_HOME, KC_END, KC_ESC, KC_GRAVE, KC_CAPS, KC_APP + DRGSCRL, KC_END, KC_ESC, KC_GRAVE, KC_CAPS, KC_APP ), [1] = LAYOUT_fun( diff --git a/keyboards/cyboard/imprint/imprint_function_row/keymaps/vial/vial.json b/keyboards/cyboard/imprint/imprint_function_row/keymaps/vial/vial.json index 81933911a8b..9d4466d8036 100644 --- a/keyboards/cyboard/imprint/imprint_function_row/keymaps/vial/vial.json +++ b/keyboards/cyboard/imprint/imprint_function_row/keymaps/vial/vial.json @@ -3,6 +3,40 @@ "vendorId": "0xFEED", "productId": "0x0000", "lighting": "vialrgb", + "customKeycodes": [ + {"name": "DPI_INC", + "title": "Increase trackball sensitivity", + "shortName": "POINTER_DEFAULT_DPI_FORWARD" + }, + {"name": "DPI_DEC", + "title": "Decrease trackball sensitivity", + "shortName": "POINTER_DEFAULT_DPI_REVERSE" + }, + {"name": "SNP_INC", + "title": "Increase trackball sensitivity when in sniping mode", + "shortName": "POINTER_SNIPING_DPI_FORWARD" + }, + {"name": "SNP_DEC", + "title": "Decrease trackball sensitivity when in sniping mode", + "shortName": "POINTER_SNIPING_DPI_REVERSE" + }, + {"name": "Snipe", + "title": "Reduce trackball sensitivity while held", + "shortName": "SNIPING_MODE" + }, + {"name": "SNP_TOG", + "title": "Toggle between normal and sniping mode", + "shortName": "SNIPING_MODE_TOGGLE" + }, + {"name": "DragScroll", + "title": "Make trackball behave as a scroll wheel while held", + "shortName": "DRAGSCROLL_MODE" + }, + {"name": "DragScroll_TOG", + "title": "Toggle between normal and drag scroll mode", + "shortName": "DRAGSCROLL_MODE_TOGGLE" + } + ], "matrix": { "rows": 14, "cols": 8 diff --git a/keyboards/cyboard/post_config.h b/keyboards/cyboard/post_config.h new file mode 100644 index 00000000000..4cfd24c4b6a --- /dev/null +++ b/keyboards/cyboard/post_config.h @@ -0,0 +1,114 @@ +/* + * Copyright 2012 Jun Wako + * Copyright 2015 Jack Humbert + * Copyright 2021 Quentin LEBASTARD + * Copyright 2021 Charly Delay (@0xcharly) + * + * 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 . + */ + +#pragma once + +// Enable syncing of charybdis config +#ifdef CHARYBDIS_CONFIG_SYNC +# define SPLIT_TRANSACTION_IDS_KB RPC_ID_KB_CONFIG_SYNC +#endif + +/* Mouse config. */ + +#ifndef MOUSEKEY_MOVE_DELTA +# ifndef MK_KINETIC_SPEED +# define MOUSEKEY_MOVE_DELTA 5 +# else // MK_KINETIC_SPEED +# define MOUSEKEY_MOVE_DELTA 25 +# endif // !MK_KINETIC_SPEED +#endif // !MOUSEKEY_MOVE_DELTA + +#ifndef MOUSEKEY_DELAY +# ifndef MK_KINETIC_SPEED +# define MOUSEKEY_DELAY 300 +# else // MK_KINETIC_SPEED +# define MOUSEKEY_DELAY 8 +# endif // !MK_KINETIC_SPEED +#endif // !MOUSEKEY_DELAY + +#ifndef MOUSEKEY_INTERVAL +# ifndef MK_KINETIC_SPEED +# define MOUSEKEY_INTERVAL 50 +# else // MK_KINETIC_SPEED +# define MOUSEKEY_INTERVAL 20 +# endif // !MK_KINETIC_SPEED +#endif // !MOUSEKEY_INTERNAL + +#ifndef MOUSEKEY_MAX_SPEED +# define MOUSEKEY_MAX_SPEED 7 +#endif // !MOUSEKEY_MAX_SPEED + +#ifndef MOUSEKEY_TIME_TO_MAX +# define MOUSEKEY_TIME_TO_MAX 60 +#endif // !MOUSEKEY_TIME_TO_MAX + +#ifndef MOUSEKEY_INITIAL_SPEED +# define MOUSEKEY_INITIAL_SPEED 100 +#endif // !MOUSEKEY_INITIAL_SPEED + +#ifndef MOUSEKEY_BASE_SPEED +# define MOUSEKEY_BASE_SPEED 1000 +#endif // !MOUSEKEY_BASE_SPEED + +#ifndef MOUSEKEY_DECELERATED_SPEED +# define MOUSEKEY_DECELERATED_SPEED 400 +#endif // !MOUSEKEY_DECELERATED_SPEED + +#ifndef MOUSEKEY_ACCELERATED_SPEED +# define MOUSEKEY_ACCELERATED_SPEED 3000 +#endif // !MOUSEKEY_ACCELERATED_SPEED + +/* Mouse scroll config. */ + +#ifndef MOUSEKEY_WHEEL_DELAY +# define MOUSEKEY_WHEEL_DELAY 15 +#endif // !MOUSEKEY_WHEEL_DELAY + +#ifndef MOUSEKEY_WHEEL_DELTA +# define MOUSEKEY_WHEEL_DELTA 1 +#endif // !MOUSEKEY_WHEEL_DELTA + +#ifndef MOUSEKEY_WHEEL_INTERVAL +# define MOUSEKEY_WHEEL_INTERVAL 50 +#endif // !MOUSEKEY_WHEEL_INTERVAL + +#ifndef MOUSEKEY_WHEEL_MAX_SPEED +# define MOUSEKEY_WHEEL_MAX_SPEED 8 +#endif // !MOUSEKEY_WHEEL_MAX_SPEED + +#ifndef MOUSEKEY_WHEEL_TIME_TO_MAX +# define MOUSEKEY_WHEEL_TIME_TO_MAX 80 +#endif // !MOUSEKEY_WHEEL_TIME_TO_MAX + +#ifndef MOUSEKEY_WHEEL_INITIAL_MOVEMENTS +# define MOUSEKEY_WHEEL_INITIAL_MOVEMENTS 8 +#endif // !MOUSEKEY_WHEEL_INITIAL_MOVEMENTS + +#ifndef MOUSEKEY_WHEEL_BASE_MOVEMENTS +# define MOUSEKEY_WHEEL_BASE_MOVEMENTS 48 +#endif // !MOUSEKEY_WHEEL_BASE_MOVEMENTS + +#ifndef MOUSEKEY_WHEEL_ACCELERATED_MOVEMENTS +# define MOUSEKEY_WHEEL_ACCELERATED_MOVEMENTS 48 +#endif // !MOUSEKEY_WHEEL_ACCELERATED_MOVEMENTS + +#ifndef MOUSEKEY_WHEEL_DECELERATED_MOVEMENTS +# define MOUSEKEY_WHEEL_DECELERATED_MOVEMENTS 8 +#endif // !MOUSEKEY_WHEEL_DECELERATED_MOVEMENTS