complete restructure

builddefs/common_features.mk

@@ -132,7 +132,7 @@ ifeq ($(strip $(POINTING_DEVICE_ENABLE)), yes)
         SRC += $(QUANTUM_DIR)/pointing_device/pointing_device.c
         SRC += $(QUANTUM_DIR)/pointing_device/pointing_device_auto_mouse.c
         SRC += $(QUANTUM_DIR)/pointing_device/pointing_device_modes.c
-        SRC += $(QUANTUM_DIR)/process_keycode/process_pointing_mode_records.c
+        SRC += $(QUANTUM_DIR)/process_keycode/process_pointing_modes.c
         ifneq ($(strip $(POINTING_DEVICE_DRIVER)), custom)
             SRC += drivers/sensors/$(strip $(POINTING_DEVICE_DRIVER)).c
             OPT_DEFS += -DPOINTING_DEVICE_DRIVER_$(strip $(shell echo $(POINTING_DEVICE_DRIVER) | tr '[:lower:]' '[:upper:]'))

data/constants/keycodes/keycodes_0.0.1.hjson

@@ -36,7 +36,7 @@
         "0x52C0/0x001F": {
             "define": "QK_LAYER_TAP_TOGGLE"
         },
-        // 0x5344/0x02BB - UNUSED
+        // 0x5346/0x02B9 - UNUSED
         "0x5600/0x00FF": {
             "define": "QK_SWAP_HANDS"
         },

data/constants/keycodes/keycodes_0.0.4.hjson

@@ -1,13 +0,0 @@
-{
-    "ranges": {
-        "0x52E0/0x000F": {
-            "define": "QK_POINTING_MODE_MO"
-        },
-        "0x52F0/0x000F": {
-            "define": "QK_POINTING_MODE_TG"
-        },
-        "0x5300/0x0003": {
-            "define": "QK_POINTING_MODE_UTIL"
-        }
-    }
-}

data/constants/keycodes/keycodes_0.0.7.hjson

@@ -1,13 +1 @@
-{
-    "ranges": {
-        "0x5302/0x001F": {
-            "define": "QK_POINTING_MODE_MO"
-        },
-        "0x5322/0x001F": {
-            "define": "QK_POINTING_MODE_TG"
-        },
-        "0x5342/0x0002": {
-            "define": "QK_POINTING_MODE_UTIL"
-        }
-    }
-}
+

data/constants/keycodes/keycodes_0.0.7_pointing_modes.hjson

@@ -0,0 +1,31 @@
+{
+    "ranges": {
+        "0x5302/0x001F": {
+            "define": "QK_POINTING_MODES_MO"
+        },
+        "0x5322/0x001F": {
+            "define": "QK_POINTING_MODES_TG"
+        },
+        "0x5342/0x0001": {
+            "define": "QK_POINTING_MODES_UTIL"
+        }
+    },
+    "keycodes": {
+        "0x5342": {
+            "group": "pointing_modes_util",
+            "key": "QK_PM_CYCLE_DEVICES",
+            "label": "Cycle pointing mode device",
+            "aliases": [
+                "PM_CYDEV"
+            ]
+        },
+        "0x5343":{
+            "group": "pointing_modes_util",
+            "key": "QK_PM_CYCLE_PRECISION",
+            "label": "Cycle through precision values for active device",
+            "aliases": [
+                "PM_CYCPRE"
+            ]
+        }
+    }
+}

quantum/keyboard.h

@@ -32,7 +32,7 @@ typedef struct {
     uint8_t row;
 } keypos_t;
 
-typedef enum keyevent_type_t { TICK_EVENT = 0, KEY_EVENT = 1, ENCODER_CW_EVENT = 2, ENCODER_CCW_EVENT = 3, COMBO_EVENT = 4, DIP_SWITCH_ON_EVENT = 5, DIP_SWITCH_OFF_EVENT = 6, POINTING_MODE_EVENT = 7} keyevent_type_t;
+typedef enum keyevent_type_t { TICK_EVENT = 0, KEY_EVENT = 1, ENCODER_CW_EVENT = 2, ENCODER_CCW_EVENT = 3, COMBO_EVENT = 4, DIP_SWITCH_ON_EVENT = 5, DIP_SWITCH_OFF_EVENT = 6, POINTING_MODES_EVENT = 7} keyevent_type_t;
 
 /* key event */
 typedef struct {
@@ -50,7 +50,7 @@ typedef struct {
 #define KEYLOC_ENCODER_CCW 252
 #define KEYLOC_DIP_SWITCH_ON 251
 #define KEYLOC_DIP_SWITCH_OFF 250
-#define KEYLOC_POINTING_MODE 249
+#define KEYLOC_POINTING_MODES 249
 
 static inline bool IS_NOEVENT(const keyevent_t event) {
     return event.type == TICK_EVENT;
@@ -71,7 +71,7 @@ static inline bool IS_DIPSWITCHEVENT(const keyevent_t event) {
     return event.type == DIP_SWITCH_ON_EVENT || event.type == DIP_SWITCH_OFF_EVENT;
 }
 static inline bool IS_POINTINGEVENT(const keyevent_t event) {
-    return event.type == POINTING_MODE_EVENT;
+    return event.type == POINTING_MODES_EVENT;
 }
 
 /* Common keypos_t object factory */
@@ -107,10 +107,14 @@ static inline bool IS_POINTINGEVENT(const keyevent_t event) {
 #    define MAKE_DIPSWITCH_OFF_EVENT(switch_id, press) MAKE_EVENT(KEYLOC_DIP_SWITCH_OFF, (switch_id), (press), DIP_SWITCH_OFF_EVENT)
 #endif // DIP_SWITCH_MAP_ENABLE
 
-#ifdef POINTING_MODE_MAP_ENABLE
+#ifdef POINTING_DEVICE_MODES_ENABLE
 /* Pointing mode events */
-#    define MAKE_POINTING_MODE_EVENT(map_id, dir, press) MAKE_EVENT(KEYLOC_POINTING_MODE, (uint8_t)(((map_id) << 2) | (dir)), (press), POINTING_MODE_EVENT)
-#endif
+#    ifdef POINTING_MODES_8WAY_MAP_ENABLE
+#        define MAKE_POINTING_MODES_EVENT(map_id, dir, press) MAKE_EVENT(KEYLOC_POINTING_MODES, (uint8_t)(((map_id) << 3) | (dir)), (press), POINTING_MODES_EVENT)
+#    else
+#        define MAKE_POINTING_MODES_EVENT(map_id, dir, press) MAKE_EVENT(KEYLOC_POINTING_MODES, (uint8_t)(((map_id) << 2) | (dir)), (press), POINTING_MODES_EVENT)
+#    endif // POINTING_MODES_8WAY_MAP_ENABLE
+#endif // POINTING_DEVICE_MODES_ENABLE
 
 /* it runs once at early stage of startup before keyboard_init. */
 void keyboard_setup(void);

quantum/keycodes.h

@@ -52,20 +52,14 @@ enum qk_keycode_ranges {
     QK_ONE_SHOT_MOD_MAX            = 0x52BF,
     QK_LAYER_TAP_TOGGLE            = 0x52C0,
     QK_LAYER_TAP_TOGGLE_MAX        = 0x52DF,
-    QK_POINTING_MODE_MO            = 0x52E0,
-    QK_POINTING_MODE_MO_MAX        = 0x52EF,
     QK_PERSISTENT_DEF_LAYER        = 0x52E0,
     QK_PERSISTENT_DEF_LAYER_MAX    = 0x52FF,
-    QK_POINTING_MODE_TG            = 0x52F0,
-    QK_POINTING_MODE_TG_MAX        = 0x52FF,
-    QK_POINTING_MODE_UTIL          = 0x5300,
-    QK_POINTING_MODE_UTIL_MAX      = 0x5303,
-    QK_POINTING_MODE_MO            = 0x5302,
-    QK_POINTING_MODE_MO_MAX        = 0x5321,
-    QK_POINTING_MODE_TG            = 0x5322,
-    QK_POINTING_MODE_TG_MAX        = 0x5341,
-    QK_POINTING_MODE_UTIL          = 0x5342,
-    QK_POINTING_MODE_UTIL_MAX      = 0x5344,
+    QK_POINTING_MODES_MO           = 0x5302,
+    QK_POINTING_MODES_MO_MAX       = 0x5321,
+    QK_POINTING_MODES_TG           = 0x5322,
+    QK_POINTING_MODES_TG_MAX       = 0x5341,
+    QK_POINTING_MODES_UTIL         = 0x5342,
+    QK_POINTING_MODES_UTIL_MAX     = 0x5343,
     QK_SWAP_HANDS                  = 0x5600,
     QK_SWAP_HANDS_MAX              = 0x56FF,
     QK_TAP_DANCE                   = 0x5700,
@@ -327,8 +321,7 @@ enum qk_keycode_defines {
     KC_RIGHT_ALT = 0x00E6,
     KC_RIGHT_GUI = 0x00E7,
     QK_PM_CYCLE_DEVICES = 0x5342,
-    QK_PM_DEVICE_RIGHT = 0x5343,
-    QK_PM_DEVICE_LEFT = 0x5344,
+    QK_PM_CYCLE_PRECISION = 0x5343,
     QK_SWAP_HANDS_TOGGLE = 0x56F0,
     QK_SWAP_HANDS_TAP_TOGGLE = 0x56F1,
     QK_SWAP_HANDS_MOMENTARY_ON = 0x56F2,
@@ -992,9 +985,8 @@ enum qk_keycode_defines {
     KC_RGUI    = KC_RIGHT_GUI,
     KC_RCMD    = KC_RIGHT_GUI,
     KC_RWIN    = KC_RIGHT_GUI,
-    PMR_CYD    = QK_PM_CYCLE_DEVICES,
-    PMR_RGHT   = QK_PM_DEVICE_RIGHT,
-    PMR_LEFT   = QK_PM_DEVICE_LEFT,
+    PM_CYDEV   = QK_PM_CYCLE_DEVICES,
+    PM_CYCPRE  = QK_PM_CYCLE_PRECISION,
     SH_TOGG    = QK_SWAP_HANDS_TOGGLE,
     SH_TT      = QK_SWAP_HANDS_TAP_TOGGLE,
     SH_MON     = QK_SWAP_HANDS_MOMENTARY_ON,
@@ -1482,13 +1474,10 @@ enum qk_keycode_defines {
 #define IS_QK_ONE_SHOT_LAYER(code) ((code) >= QK_ONE_SHOT_LAYER && (code) <= QK_ONE_SHOT_LAYER_MAX)
 #define IS_QK_ONE_SHOT_MOD(code) ((code) >= QK_ONE_SHOT_MOD && (code) <= QK_ONE_SHOT_MOD_MAX)
 #define IS_QK_LAYER_TAP_TOGGLE(code) ((code) >= QK_LAYER_TAP_TOGGLE && (code) <= QK_LAYER_TAP_TOGGLE_MAX)
-#define IS_QK_POINTING_MODE_MO(code) ((code) >= QK_POINTING_MODE_MO && (code) <= QK_POINTING_MODE_MO_MAX)
 #define IS_QK_PERSISTENT_DEF_LAYER(code) ((code) >= QK_PERSISTENT_DEF_LAYER && (code) <= QK_PERSISTENT_DEF_LAYER_MAX)
-#define IS_QK_POINTING_MODE_TG(code) ((code) >= QK_POINTING_MODE_TG && (code) <= QK_POINTING_MODE_TG_MAX)
-#define IS_QK_POINTING_MODE_UTIL(code) ((code) >= QK_POINTING_MODE_UTIL && (code) <= QK_POINTING_MODE_UTIL_MAX)
-#define IS_QK_POINTING_MODE_MO(code) ((code) >= QK_POINTING_MODE_MO && (code) <= QK_POINTING_MODE_MO_MAX)
-#define IS_QK_POINTING_MODE_TG(code) ((code) >= QK_POINTING_MODE_TG && (code) <= QK_POINTING_MODE_TG_MAX)
-#define IS_QK_POINTING_MODE_UTIL(code) ((code) >= QK_POINTING_MODE_UTIL && (code) <= QK_POINTING_MODE_UTIL_MAX)
+#define IS_QK_POINTING_MODES_MO(code) ((code) >= QK_POINTING_MODES_MO && (code) <= QK_POINTING_MODES_MO_MAX)
+#define IS_QK_POINTING_MODES_TG(code) ((code) >= QK_POINTING_MODES_TG && (code) <= QK_POINTING_MODES_TG_MAX)
+#define IS_QK_POINTING_MODES_UTIL(code) ((code) >= QK_POINTING_MODES_UTIL && (code) <= QK_POINTING_MODES_UTIL_MAX)
 #define IS_QK_SWAP_HANDS(code) ((code) >= QK_SWAP_HANDS && (code) <= QK_SWAP_HANDS_MAX)
 #define IS_QK_TAP_DANCE(code) ((code) >= QK_TAP_DANCE && (code) <= QK_TAP_DANCE_MAX)
 #define IS_QK_MAGIC(code) ((code) >= QK_MAGIC && (code) <= QK_MAGIC_MAX)
@@ -1515,7 +1504,7 @@ enum qk_keycode_defines {
 #define IS_CONSUMER_KEYCODE(code) ((code) >= KC_AUDIO_MUTE && (code) <= KC_LAUNCHPAD)
 #define IS_MOUSE_KEYCODE(code) ((code) >= QK_MOUSE_CURSOR_UP && (code) <= QK_MOUSE_ACCELERATION_2)
 #define IS_MODIFIER_KEYCODE(code) ((code) >= KC_LEFT_CTRL && (code) <= KC_RIGHT_GUI)
-#define IS_POINTING_MODE_UTIL_KEYCODE(code) ((code) >= QK_PM_CYCLE_DEVICES && (code) <= QK_PM_DEVICE_LEFT)
+#define IS_POINTING_MODES_UTIL_KEYCODE(code) ((code) >= QK_PM_CYCLE_DEVICES && (code) <= QK_PM_CYCLE_PRECISION)
 #define IS_SWAP_HANDS_KEYCODE(code) ((code) >= QK_SWAP_HANDS_TOGGLE && (code) <= QK_SWAP_HANDS_ONE_SHOT)
 #define IS_MAGIC_KEYCODE(code) ((code) >= QK_MAGIC_SWAP_CONTROL_CAPS_LOCK && (code) <= QK_MAGIC_TOGGLE_ESCAPE_CAPS_LOCK)
 #define IS_MIDI_KEYCODE(code) ((code) >= QK_MIDI_ON && (code) <= QK_MIDI_PITCH_BEND_UP)
@@ -1542,7 +1531,7 @@ enum qk_keycode_defines {
 #define CONSUMER_KEYCODE_RANGE              KC_AUDIO_MUTE ... KC_LAUNCHPAD
 #define MOUSE_KEYCODE_RANGE                 QK_MOUSE_CURSOR_UP ... QK_MOUSE_ACCELERATION_2
 #define MODIFIER_KEYCODE_RANGE              KC_LEFT_CTRL ... KC_RIGHT_GUI
-#define POINTING_MODE_UTIL_KEYCODE_RANGE    QK_PM_CYCLE_DEVICES ... QK_PM_DEVICE_LEFT
+#define POINTING_MODES_UTIL_KEYCODE_RANGE   QK_PM_CYCLE_DEVICES ... QK_PM_CYCLE_PRECISION
 #define SWAP_HANDS_KEYCODE_RANGE            QK_SWAP_HANDS_TOGGLE ... QK_SWAP_HANDS_ONE_SHOT
 #define MAGIC_KEYCODE_RANGE                 QK_MAGIC_SWAP_CONTROL_CAPS_LOCK ... QK_MAGIC_TOGGLE_ESCAPE_CAPS_LOCK
 #define MIDI_KEYCODE_RANGE                  QK_MIDI_ON ... QK_MIDI_PITCH_BEND_UP

quantum/keymap_common.c

@@ -217,11 +217,17 @@ __attribute__((weak)) uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t key
     }
 #endif // DIP_SWITCH_MAP_ENABLE
 
-#ifdef POINTING_MODE_MAP_ENABLE
-    else if (key.row == KEYLOC_POINTING_MODE && key.col < ((pointing_mode_map_count() << 2) | 0x03)) {
-        return keycode_at_pointing_mode_map_location(key.col);
+#ifdef POINTING_DEVICE_MODES_ENABLE
+#    ifdef POINTING_MODES_8WAY_MAP_ENABLE
+    else if (key.row == KEYLOC_POINTING_MODES && key.col < ((pointing_modes_map_count() << 3) | 0x07)) {
+        return keycode_at_pointing_modes_map_location(key.col);
     }
-#endif // defined(POINTING_MODE_MAP_ENABLE)
+#    else
+    else if (key.row == KEYLOC_POINTING_MODES && key.col < ((pointing_modes_map_count() << 2) | 0x03)) {
+        return keycode_at_pointing_modes_map_location(key.col);
+    }
+#    endif
+#endif // POINTING_DEVICE_MODES_ENABLE
 
     return KC_NO;
 }

quantum/keymap_introspection.c

@@ -175,16 +175,16 @@ __attribute__((weak)) const key_override_t* key_override_get(uint16_t key_overri
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Pointing mode mapping
 
-#ifdef POINTING_MODE_MAP_ENABLE
+#ifdef POINTING_DEVICE_MODES_ENABLE
 
-#    define POINTING_MODE_MAP_COUNT_RAW (uint8_t)(sizeof(pointing_mode_maps) / ((POINTING_MODE_NUM_DIRECTIONS) * sizeof(uint16_t)))
+#    define POINTING_MODES_MAP_COUNT_RAW (uint8_t)(sizeof(pointing_modes_maps) / ((POINTING_MODES_NUM_DIRECTIONS) * sizeof(uint16_t)))
 
-uint8_t pointing_mode_map_count_raw(void) {
-    return POINTING_MODE_MAP_COUNT_RAW;
+uint8_t pointing_modes_map_count_raw(void) {
+    return POINTING_MODES_MAP_COUNT_RAW;
 }
 
-__attribute__((weak)) uint8_t pointing_mode_map_count(void) {
-    return pointing_mode_map_count_raw();
+__attribute__((weak)) uint8_t pointing_modes_map_count(void) {
+    return pointing_modes_map_count_raw();
 }
 
 /*
@@ -201,12 +201,17 @@ __attribute__((weak)) uint8_t pointing_mode_map_count(void) {
  *
  * @return uint16_t keycode at pointing mode map location
  */
-uint16_t keycode_at_pointing_mode_map_location_raw(uint8_t map_loc) {
+uint16_t keycode_at_pointing_modes_map_location_raw(uint8_t map_loc) {
+#    ifdef POINTING_MODES_8WAY_MAP_ENABLE
+    uint8_t map_id = map_loc >> 3;
+    uint8_t dir    = map_loc & 0x07;
+#    else
     uint8_t map_id = map_loc >> 2;
     uint8_t dir    = map_loc & 0x03;
+#    endif // POINTING_MODES_8WAY_MAP_ENABLE
 
-    if (map_id < pointing_mode_map_count()) {
-        return pgm_read_word(&pointing_mode_maps[map_id][dir]);
+    if (map_id < pointing_modes_map_count()) {
+        return pgm_read_word(&pointing_modes_maps[map_id][dir]);
     }
     return KC_NO;
 }
@@ -221,8 +226,8 @@ uint16_t keycode_at_pointing_mode_map_location_raw(uint8_t map_loc) {
  *
  * @return uint16_t keycode at pointing mode map location
  */
-__attribute__((weak)) uint16_t keycode_at_pointing_mode_map_location(uint8_t map_loc) {
-    return keycode_at_pointing_mode_map_location_raw(map_loc);
+__attribute__((weak)) uint16_t keycode_at_pointing_modes_map_location(uint8_t map_loc) {
+    return keycode_at_pointing_modes_map_location_raw(map_loc);
 }
 
-#endif // defined(POINTING_MODE_MAP_ENABLE)
+#endif // POINTING_DEVICE_MODES_ENABLE

quantum/keymap_introspection.h

@@ -112,16 +112,16 @@ const key_override_t* key_override_get(uint16_t key_override_idx);
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Pointing Mode Mapping
 
-#if defined(POINTING_MODE_MAP_ENABLE)
+#if defined(POINTING_DEVICE_MODES_ENABLE)
 
 // Get the number of pointing mode maps, stored in firmware
-uint8_t pointing_mode_map_count_raw(void);
+uint8_t pointing_modes_map_count_raw(void);
 // Get the number of pointing mode maps, potentially stored dynamically
-uint8_t pointing_mode_map_count(void);
+uint8_t pointing_modes_map_count(void);
 
 // Get the keycode for the pointing mode map location, stored in firmware
-uint16_t keycode_at_pointing_mode_map_location_raw(uint8_t map_loc);
+uint16_t keycode_at_pointing_modes_map_location_raw(uint8_t map_loc);
 // Get the keycode for the encoder mapping location, potentially stored dynamically
-uint16_t keycode_at_pointing_mode_map_location(uint8_t map_loc);
+uint16_t keycode_at_pointing_modes_map_location(uint8_t map_loc);
 
-#endif // defined(POINTING_MODE_MAP_ENABLE)
+#endif // defined(POINTING_DEVICE_MODES_ENABLE)

quantum/pointing_device/pointing_device.c

@@ -315,7 +315,7 @@ __attribute__((weak)) bool pointing_device_task(void) {
 #endif
     // pointing device modes handling for single pointing device
 #if defined(POINTING_DEVICE_MODES_ENABLE) && !(defined(SPLIT_POINTING_ENABLE) && defined(POINTING_DEVICE_COMBINED))
-    local_mouse_report = pointing_device_modes_task(local_mouse_report);
+    local_mouse_report = pointing_modes_device_task(local_mouse_report);
 #endif
     // combine with mouse report to ensure that the combined is sent correctly
 #ifdef MOUSEKEY_ENABLE
@@ -504,26 +504,26 @@ report_mouse_t pointing_device_adjust_by_defines_right(report_mouse_t mouse_repo
  */
 report_mouse_t pointing_device_task_combined(report_mouse_t left_report, report_mouse_t right_report) {
 #    ifdef POINTING_DEVICE_MODE_ENABLE
-#        if POINTING_MODE_SINGLE_CONTROL
+#        if POINTING_MODES_SINGLE_CONTROL
     // only one side controlled at any one time
-    switch (pointing_mode_get_active_device()) {
+    switch (pointing_modes_get_active_device()) {
         case PM_RIGHT_DEVICE:
-            right_report = pointing_device_modes_task(right_report);
+            right_report = pointing_modes_device_task(right_report);
             break;
         default:
-            left_report = pointing_device_modes_task(left_report);
+            left_report = pointing_modes_device_task(left_report);
     }
 #        else
     // both sides controlled independently
     // save current device id
-    uint8_t active_device = pointing_mode_get_active_device();
-    pointing_mode_set_active_device(PM_RIGHT_DEVICE);
-    right_report = pointing_device_modes_task(right_report);
+    uint8_t active_device = pointing_modes_get_active_device();
+    pointing_modes_set_active_device(PM_RIGHT_DEVICE);
+    right_report = pointing_modes_device_task(right_report);
 
-    pointing_mode_set_active_device(PM_LEFT_DEVICE);
-    left_report = pointing_device_modes_task(left_report);
+    pointing_modes_set_active_device(PM_LEFT_DEVICE);
+    left_report = pointing_modes_device_task(left_report);
     // set device id back
-    pointing_mode_set_active_device(active_device);
+    pointing_modes_set_active_device(active_device);
 #        endif
 #    endif
     return pointing_device_task_combined_kb(left_report, right_report);

quantum/pointing_device/pointing_device_auto_mouse.c

@@ -432,7 +432,7 @@ static bool is_mouse_record(uint16_t keycode, keyrecord_t* record) {
     // allow for keyboard to hook in and override if need be
     if (is_mouse_record_kb(keycode, record) || IS_MOUSEKEY(keycode) ||
 #    ifdef POINTING_DEVICE_MODES_ENABLE
-        IS_QK_POINTING_MODE_MO(keycode) || IS_QK_POINTING_MODE_TG(keycode) ||
+        IS_QK_POINTING_MODES_MO(keycode) || IS_QK_POINTING_MODES_TG(keycode) ||
 #    endif
         false)
         return true;