logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

pointing_device.c (19509B)

    

  1. /* Copyright 2017 Joshua Broekhuijsen <snipeye+qmk@gmail.com>
  2.  * Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
  3.  * Copyright 2021 Dasky (@daskygit)
  4.  *
  5.  * This program is free software: you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation, either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17.  */
  19. #include "pointing_device.h"
  20. #include <string.h>
  21. #include "timer.h"
  22. #include "gpio.h"
  24. #ifdef MOUSEKEY_ENABLE
  25. #    include "mousekey.h"
  26. #endif
  28. #ifdef POINTING_DEVICE_HIRES_SCROLL_ENABLE
  29. #    include "usb_descriptor_common.h"
  30. #endif
  32. #if (defined(POINTING_DEVICE_ROTATION_90) + defined(POINTING_DEVICE_ROTATION_180) + defined(POINTING_DEVICE_ROTATION_270)) > 1
  33. #    error More than one rotation selected.  This is not supported.
  34. #endif
  36. #if defined(POINTING_DEVICE_LEFT) || defined(POINTING_DEVICE_RIGHT) || defined(POINTING_DEVICE_COMBINED)
  37. #    ifndef SPLIT_POINTING_ENABLE
  38. #        error "Using POINTING_DEVICE_LEFT or POINTING_DEVICE_RIGHT or POINTING_DEVICE_COMBINED, then SPLIT_POINTING_ENABLE is required but has not been defined"
  39. #    endif
  40. #endif
  42. #if defined(SPLIT_POINTING_ENABLE)
  43. #    include "transactions.h"
  44. #    include "keyboard.h"
  46. report_mouse_t shared_mouse_report = {};
  47. uint16_t       shared_cpi          = 0;
  49. /**
  50.  * @brief Sets the shared mouse report used be pointing device task
  51.  *
  52.  * NOTE : Only available when using SPLIT_POINTING_ENABLE
  53.  *
  54.  * @param[in] new_mouse_report report_mouse_t
  55.  */
  56. void pointing_device_set_shared_report(report_mouse_t new_mouse_report) {
  57.     shared_mouse_report = new_mouse_report;
  58. }
  60. /**
  61.  * @brief Gets current pointing device CPI if supported
  62.  *
  63.  * Gets current cpi of the shared report and returns it as uint16_t
  64.  *
  65.  * NOTE : Only available when using SPLIT_POINTING_ENABLE
  66.  *
  67.  * @return cpi value as uint16_t
  68.  */
  69. uint16_t pointing_device_get_shared_cpi(void) {
  70.     return shared_cpi;
  71. }
  73. #    if defined(POINTING_DEVICE_LEFT)
  74. #        define POINTING_DEVICE_THIS_SIDE is_keyboard_left()
  75. #    elif defined(POINTING_DEVICE_RIGHT)
  76. #        define POINTING_DEVICE_THIS_SIDE !is_keyboard_left()
  77. #    elif defined(POINTING_DEVICE_COMBINED)
  78. #        define POINTING_DEVICE_THIS_SIDE true
  79. #    endif
  81. #endif // defined(SPLIT_POINTING_ENABLE)
  83. static report_mouse_t local_mouse_report         = {};
  84. static bool           pointing_device_force_send = false;
  85. #ifdef POINTING_DEVICE_HIRES_SCROLL_ENABLE
  86. static uint16_t hires_scroll_resolution;
  87. #endif
  89. #define POINTING_DEVICE_DRIVER_CONCAT(name) name##_pointing_device_driver
  90. #define POINTING_DEVICE_DRIVER(name) POINTING_DEVICE_DRIVER_CONCAT(name)
  92. #ifdef POINTING_DEVICE_DRIVER_custom
  93. __attribute__((weak)) void           pointing_device_driver_init(void) {}
  94. __attribute__((weak)) report_mouse_t pointing_device_driver_get_report(report_mouse_t mouse_report) {
  95.     return mouse_report;
  96. }
  97. __attribute__((weak)) uint16_t pointing_device_driver_get_cpi(void) {
  98.     return 0;
  99. }
  100. __attribute__((weak)) void pointing_device_driver_set_cpi(uint16_t cpi) {}
  102. const pointing_device_driver_t custom_pointing_device_driver = {
  103.     .init       = pointing_device_driver_init,
  104.     .get_report = pointing_device_driver_get_report,
  105.     .get_cpi    = pointing_device_driver_get_cpi,
  106.     .set_cpi    = pointing_device_driver_set_cpi,
  107. };
  108. #endif
  110. const pointing_device_driver_t *pointing_device_driver = &POINTING_DEVICE_DRIVER(POINTING_DEVICE_DRIVER_NAME);
  112. __attribute__((weak)) void           pointing_device_init_modules(void) {}
  113. __attribute__((weak)) report_mouse_t pointing_device_task_modules(report_mouse_t mouse_report) {
  114.     return mouse_report;
  115. }
  117. /**
  118.  * @brief Keyboard level code pointing device initialisation
  119.  *
  120.  */
  121. __attribute__((weak)) void pointing_device_init_kb(void) {}
  123. /**
  124.  * @brief User level code pointing device initialisation
  125.  *
  126.  */
  127. __attribute__((weak)) void pointing_device_init_user(void) {}
  129. /**
  130.  * @brief Weak function allowing for keyboard level mouse report modification
  131.  *
  132.  * Takes report_mouse_t struct allowing modification at keyboard level then returns report_mouse_t.
  133.  *
  134.  * @param[in] mouse_report report_mouse_t
  135.  * @return report_mouse_t
  136.  */
  137. __attribute__((weak)) report_mouse_t pointing_device_task_kb(report_mouse_t mouse_report) {
  138.     return pointing_device_task_user(mouse_report);
  139. }
  141. /**
  142.  * @brief Weak function allowing for user level mouse report modification
  143.  *
  144.  * Takes report_mouse_t struct allowing modification at user level then returns report_mouse_t.
  145.  *
  146.  * @param[in] mouse_report report_mouse_t
  147.  * @return report_mouse_t
  148.  */
  149. __attribute__((weak)) report_mouse_t pointing_device_task_user(report_mouse_t mouse_report) {
  150.     return mouse_report;
  151. }
  153. /**
  154.  * @brief Handles pointing device buttons
  155.  *
  156.  * Returns modified button bitmask using bool pressed and selected pointing_device_buttons_t button in uint8_t buttons bitmask.
  157.  *
  158.  * @param buttons[in] uint8_t bitmask
  159.  * @param pressed[in] bool
  160.  * @param button[in] pointing_device_buttons_t value
  161.  * @return Modified uint8_t bitmask buttons
  162.  */
  163. __attribute__((weak)) uint8_t pointing_device_handle_buttons(uint8_t buttons, bool pressed, pointing_device_buttons_t button) {
  164.     if (pressed) {
  165.         buttons |= 1 << (button);
  166.     } else {
  167.         buttons &= ~(1 << (button));
  168.     }
  169.     return buttons;
  170. }
  172. /**
  173.  * @brief Initialises pointing device
  174.  *
  175.  * Initialises pointing device, perform driver init and optional keyboard/user level code.
  176.  */
  177. __attribute__((weak)) void pointing_device_init(void) {
  178. #if defined(SPLIT_POINTING_ENABLE)
  179.     if ((POINTING_DEVICE_THIS_SIDE))
  180. #endif
  181.     {
  182.         pointing_device_driver->init();
  183. #ifdef POINTING_DEVICE_MOTION_PIN
  184. #    ifdef POINTING_DEVICE_MOTION_PIN_ACTIVE_LOW
  185.         gpio_set_pin_input_high(POINTING_DEVICE_MOTION_PIN);
  186. #    else
  187.         gpio_set_pin_input(POINTING_DEVICE_MOTION_PIN);
  188. #    endif
  189. #endif
  190.     }
  191. #ifdef POINTING_DEVICE_HIRES_SCROLL_ENABLE
  192.     hires_scroll_resolution = POINTING_DEVICE_HIRES_SCROLL_MULTIPLIER;
  193.     for (int i = 0; i < POINTING_DEVICE_HIRES_SCROLL_EXPONENT; i++) {
  194.         hires_scroll_resolution *= 10;
  195.     }
  196. #endif
  198.     pointing_device_init_modules();
  199.     pointing_device_init_kb();
  200.     pointing_device_init_user();
  201. }
  203. /**
  204.  * @brief Sends processed mouse report to host
  205.  *
  206.  * This sends the mouse report generated by pointing_device_task if changed since the last report. Once send zeros mouse report except buttons.
  207.  *
  208.  */
  209. __attribute__((weak)) bool pointing_device_send(void) {
  210.     static report_mouse_t old_report         = {};
  211.     bool                  should_send_report = has_mouse_report_changed(&local_mouse_report, &old_report);
  213.     if (should_send_report) {
  214.         host_mouse_send(&local_mouse_report);
  215.     }
  216.     // send it and 0 it out except for buttons, so those stay until they are explicity over-ridden using update_pointing_device
  217.     uint8_t buttons = local_mouse_report.buttons;
  218.     memset(&local_mouse_report, 0, sizeof(local_mouse_report));
  219.     local_mouse_report.buttons = buttons;
  220.     memcpy(&old_report, &local_mouse_report, sizeof(local_mouse_report));
  222.     return should_send_report || buttons;
  223. }
  225. /**
  226.  * @brief Adjust mouse report by any optional common pointing configuration defines
  227.  *
  228.  * This applies rotation or inversion to the mouse report as selected by the pointing device common configuration defines.
  229.  *
  230.  * @param mouse_report[in] takes a report_mouse_t to be adjusted
  231.  * @return report_mouse_t with adjusted values
  232.  */
  233. report_mouse_t pointing_device_adjust_by_defines(report_mouse_t mouse_report) {
  234.     // Support rotation of the sensor data
  235. #if defined(POINTING_DEVICE_ROTATION_90) || defined(POINTING_DEVICE_ROTATION_180) || defined(POINTING_DEVICE_ROTATION_270)
  236.     mouse_xy_report_t x = mouse_report.x;
  237.     mouse_xy_report_t y = mouse_report.y;
  238. #    if defined(POINTING_DEVICE_ROTATION_90)
  239.     mouse_report.x = y;
  240.     mouse_report.y = -x;
  241. #    elif defined(POINTING_DEVICE_ROTATION_180)
  242.     mouse_report.x = -x;
  243.     mouse_report.y = -y;
  244. #    elif defined(POINTING_DEVICE_ROTATION_270)
  245.     mouse_report.x = -y;
  246.     mouse_report.y = x;
  247. #    else
  248. #        error "How the heck did you get here?!"
  249. #    endif
  250. #endif
  251.     // Support Inverting the X and Y Axises
  252. #if defined(POINTING_DEVICE_INVERT_X)
  253.     mouse_report.x = -mouse_report.x;
  254. #endif
  255. #if defined(POINTING_DEVICE_INVERT_Y)
  256.     mouse_report.y = -mouse_report.y;
  257. #endif
  258.     return mouse_report;
  259. }
  261. /**
  262.  * @brief Retrieves and processes pointing device data.
  263.  *
  264.  * This function is part of the keyboard loop and retrieves the mouse report from the pointing device driver.
  265.  * It applies any optional configuration e.g. rotation or axis inversion and then initiates a send.
  266.  *
  267.  */
  268. __attribute__((weak)) bool pointing_device_task(void) {
  269. #if defined(SPLIT_POINTING_ENABLE)
  270.     // Don't poll the target side pointing device.
  271.     if (!is_keyboard_master()) {
  272.         return false;
  273.     };
  274. #endif
  276. #if (POINTING_DEVICE_TASK_THROTTLE_MS > 0)
  277.     static uint32_t last_exec = 0;
  278.     if (timer_elapsed32(last_exec) < POINTING_DEVICE_TASK_THROTTLE_MS) {
  279.         return false;
  280.     }
  281.     last_exec = timer_read32();
  282. #endif
  284.     // Gather report info
  285. #ifdef POINTING_DEVICE_MOTION_PIN
  286. #    if defined(SPLIT_POINTING_ENABLE)
  287. #        error POINTING_DEVICE_MOTION_PIN not supported when sharing the pointing device report between sides.
  288. #    endif
  289. #    ifdef POINTING_DEVICE_MOTION_PIN_ACTIVE_LOW
  290.     if (!gpio_read_pin(POINTING_DEVICE_MOTION_PIN))
  291. #    else
  292.     if (gpio_read_pin(POINTING_DEVICE_MOTION_PIN))
  293. #    endif
  294.     {
  295. #endif
  297. #if defined(SPLIT_POINTING_ENABLE)
  298. #    if defined(POINTING_DEVICE_COMBINED)
  299.         static uint8_t old_buttons = 0;
  300.         local_mouse_report.buttons = old_buttons;
  301.         local_mouse_report         = pointing_device_driver->get_report(local_mouse_report);
  302.         old_buttons                = local_mouse_report.buttons;
  303. #    elif defined(POINTING_DEVICE_LEFT) || defined(POINTING_DEVICE_RIGHT)
  304.         local_mouse_report = POINTING_DEVICE_THIS_SIDE ? pointing_device_driver->get_report(local_mouse_report) : shared_mouse_report;
  305. #    else
  306. #        error "You need to define the side(s) the pointing device is on. POINTING_DEVICE_COMBINED / POINTING_DEVICE_LEFT / POINTING_DEVICE_RIGHT"
  307. #    endif
  308. #else
  309.     local_mouse_report = pointing_device_driver->get_report(local_mouse_report);
  310. #endif // defined(SPLIT_POINTING_ENABLE)
  312. #ifdef POINTING_DEVICE_MOTION_PIN
  313.     }
  314. #endif
  316.     // allow kb to intercept and modify report
  317. #if defined(SPLIT_POINTING_ENABLE) && defined(POINTING_DEVICE_COMBINED)
  318.     if (is_keyboard_left()) {
  319.         local_mouse_report  = pointing_device_adjust_by_defines(local_mouse_report);
  320.         shared_mouse_report = pointing_device_adjust_by_defines_right(shared_mouse_report);
  321.     } else {
  322.         local_mouse_report  = pointing_device_adjust_by_defines_right(local_mouse_report);
  323.         shared_mouse_report = pointing_device_adjust_by_defines(shared_mouse_report);
  324.     }
  325.     local_mouse_report = is_keyboard_left() ? pointing_device_task_combined_kb(local_mouse_report, shared_mouse_report) : pointing_device_task_combined_kb(shared_mouse_report, local_mouse_report);
  326. #else
  327.     local_mouse_report = pointing_device_adjust_by_defines(local_mouse_report);
  328. #endif
  329.     local_mouse_report = pointing_device_task_modules(local_mouse_report);
  330.     local_mouse_report = pointing_device_task_kb(local_mouse_report);
  331.     // automatic mouse layer function
  332. #ifdef POINTING_DEVICE_AUTO_MOUSE_ENABLE
  333.     pointing_device_task_auto_mouse(local_mouse_report);
  334. #endif
  335.     // combine with mouse report to ensure that the combined is sent correctly
  336. #ifdef MOUSEKEY_ENABLE
  337.     report_mouse_t mousekey_report = mousekey_get_report();
  338.     local_mouse_report.buttons     = local_mouse_report.buttons | mousekey_report.buttons;
  339. #endif
  341.     const bool send_report     = pointing_device_send() || pointing_device_force_send;
  342.     pointing_device_force_send = false;
  344.     return send_report;
  345. }
  347. /**
  348.  * @brief Gets current mouse report used by pointing device task
  349.  *
  350.  * @return report_mouse_t
  351.  */
  352. report_mouse_t pointing_device_get_report(void) {
  353.     return local_mouse_report;
  354. }
  356. /**
  357.  * @brief Sets mouse report used be pointing device task
  358.  *
  359.  * @param[in] mouse_report
  360.  */
  361. void pointing_device_set_report(report_mouse_t mouse_report) {
  362.     pointing_device_force_send = has_mouse_report_changed(&local_mouse_report, &mouse_report);
  363.     memcpy(&local_mouse_report, &mouse_report, sizeof(local_mouse_report));
  364. }
  366. /**
  367.  * @brief Gets current pointing device CPI if supported
  368.  *
  369.  * Gets current cpi from pointing device driver if supported and returns it as uint16_t
  370.  *
  371.  * @return cpi value as uint16_t
  372.  */
  373. uint16_t pointing_device_get_cpi(void) {
  374. #if defined(SPLIT_POINTING_ENABLE)
  375.     return POINTING_DEVICE_THIS_SIDE ? pointing_device_driver->get_cpi() : shared_cpi;
  376. #else
  377.     return pointing_device_driver->get_cpi();
  378. #endif
  379. }
  381. /**
  382.  * @brief Set pointing device CPI if supported
  383.  *
  384.  * Takes a uint16_t value to set pointing device cpi if supported by driver.
  385.  *
  386.  * @param[in] cpi uint16_t value.
  387.  */
  388. void pointing_device_set_cpi(uint16_t cpi) {
  389. #if defined(SPLIT_POINTING_ENABLE)
  390.     if (POINTING_DEVICE_THIS_SIDE) {
  391.         pointing_device_driver->set_cpi(cpi);
  392.     } else {
  393.         shared_cpi = cpi;
  394.     }
  395. #else
  396.     pointing_device_driver->set_cpi(cpi);
  397. #endif
  398. }
  400. #if defined(SPLIT_POINTING_ENABLE) && defined(POINTING_DEVICE_COMBINED)
  401. /**
  402.  * @brief Set pointing device CPI if supported
  403.  *
  404.  * Takes a bool and uint16_t and allows setting cpi for a single side when using 2 pointing devices with a split keyboard.
  405.  *
  406.  * NOTE: Only available when using SPLIT_POINTING_ENABLE and POINTING_DEVICE_COMBINED
  407.  *
  408.  * @param[in] left true = left, false = right.
  409.  * @param[in] cpi uint16_t value.
  410.  */
  411. void pointing_device_set_cpi_on_side(bool left, uint16_t cpi) {
  412.     bool local = (is_keyboard_left() == left);
  413.     if (local) {
  414.         pointing_device_driver->set_cpi(cpi);
  415.     } else {
  416.         shared_cpi = cpi;
  417.     }
  418. }
  420. /**
  421.  * @brief clamps int16_t to int8_t, or int32_t to int16_t
  422.  *
  423.  * @param[in] hv_clamp_range_t value
  424.  * @return mouse_hv_report_t clamped value
  425.  */
  426. static inline mouse_hv_report_t pointing_device_hv_clamp(hv_clamp_range_t value) {
  427.     if (value < MOUSE_REPORT_HV_MIN) {
  428.         return MOUSE_REPORT_HV_MIN;
  429.     } else if (value > MOUSE_REPORT_HV_MAX) {
  430.         return MOUSE_REPORT_HV_MAX;
  431.     } else {
  432.         return value;
  433.     }
  434. }
  436. /**
  437.  * @brief clamps int16_t to int8_t, or int32_t to int16_t
  438.  *
  439.  * @param[in] xy_clamp_range_t value
  440.  * @return mouse_xy_report_t clamped value
  441.  */
  442. static inline mouse_xy_report_t pointing_device_xy_clamp(xy_clamp_range_t value) {
  443.     if (value < MOUSE_REPORT_XY_MIN) {
  444.         return MOUSE_REPORT_XY_MIN;
  445.     } else if (value > MOUSE_REPORT_XY_MAX) {
  446.         return MOUSE_REPORT_XY_MAX;
  447.     } else {
  448.         return value;
  449.     }
  450. }
  451. /**
  452.  * @brief combines 2 mouse reports and returns 2
  453.  *
  454.  * Combines 2 report_mouse_t structs, clamping movement values to int8_t and ignores report_id then returns the resulting report_mouse_t struct.
  455.  *
  456.  * NOTE: Only available when using SPLIT_POINTING_ENABLE and POINTING_DEVICE_COMBINED
  457.  *
  458.  * @param[in] left_report left report_mouse_t
  459.  * @param[in] right_report right report_mouse_t
  460.  * @return combined report_mouse_t of left_report and right_report
  461.  */
  462. report_mouse_t pointing_device_combine_reports(report_mouse_t left_report, report_mouse_t right_report) {
  463.     left_report.x = pointing_device_xy_clamp((xy_clamp_range_t)left_report.x + right_report.x);
  464.     left_report.y = pointing_device_xy_clamp((xy_clamp_range_t)left_report.y + right_report.y);
  465.     left_report.h = pointing_device_hv_clamp((hv_clamp_range_t)left_report.h + right_report.h);
  466.     left_report.v = pointing_device_hv_clamp((hv_clamp_range_t)left_report.v + right_report.v);
  467.     left_report.buttons |= right_report.buttons;
  468.     return left_report;
  469. }
  471. /**
  472.  * @brief Adjust mouse report by any optional right pointing configuration defines
  473.  *
  474.  * This applies rotation or inversion to the mouse report as selected by the pointing device common configuration defines.
  475.  *
  476.  * NOTE: Only available when using SPLIT_POINTING_ENABLE and POINTING_DEVICE_COMBINED
  477.  *
  478.  * @param[in] mouse_report report_mouse_t to be adjusted
  479.  * @return report_mouse_t with adjusted values
  480.  */
  481. report_mouse_t pointing_device_adjust_by_defines_right(report_mouse_t mouse_report) {
  482.     // Support rotation of the sensor data
  483. #    if defined(POINTING_DEVICE_ROTATION_90_RIGHT) || defined(POINTING_DEVICE_ROTATION_180_RIGHT) || defined(POINTING_DEVICE_ROTATION_270_RIGHT)
  484.     mouse_xy_report_t x = mouse_report.x;
  485.     mouse_xy_report_t y = mouse_report.y;
  486. #        if defined(POINTING_DEVICE_ROTATION_90_RIGHT)
  487.     mouse_report.x = y;
  488.     mouse_report.y = -x;
  489. #        elif defined(POINTING_DEVICE_ROTATION_180_RIGHT)
  490.     mouse_report.x = -x;
  491.     mouse_report.y = -y;
  492. #        elif defined(POINTING_DEVICE_ROTATION_270_RIGHT)
  493.     mouse_report.x = -y;
  494.     mouse_report.y = x;
  495. #        else
  496. #            error "How the heck did you get here?!"
  497. #        endif
  498. #    endif
  499.     // Support Inverting the X and Y Axises
  500. #    if defined(POINTING_DEVICE_INVERT_X_RIGHT)
  501.     mouse_report.x = -mouse_report.x;
  502. #    endif
  503. #    if defined(POINTING_DEVICE_INVERT_Y_RIGHT)
  504.     mouse_report.y = -mouse_report.y;
  505. #    endif
  506.     return mouse_report;
  507. }
  509. /**
  510.  * @brief Weak function allowing for keyboard level mouse report modification
  511.  *
  512.  * Takes 2 report_mouse_t structs allowing individual modification of sides at keyboard level then returns pointing_device_task_combined_user.
  513.  *
  514.  * NOTE: Only available when using SPLIT_POINTING_ENABLE and POINTING_DEVICE_COMBINED
  515.  *
  516.  * @param[in] left_report report_mouse_t
  517.  * @param[in] right_report report_mouse_t
  518.  * @return pointing_device_task_combined_user(left_report, right_report) by default
  519.  */
  520. __attribute__((weak)) report_mouse_t pointing_device_task_combined_kb(report_mouse_t left_report, report_mouse_t right_report) {
  521.     return pointing_device_task_combined_user(left_report, right_report);
  522. }
  524. /**
  525.  * @brief Weak function allowing for user level mouse report modification
  526.  *
  527.  * Takes 2 report_mouse_t structs allowing individual modification of sides at user level then returns pointing_device_combine_reports.
  528.  *
  529.  * NOTE: Only available when using SPLIT_POINTING_ENABLE and POINTING_DEVICE_COMBINED
  530.  *
  531.  * @param[in] left_report report_mouse_t
  532.  * @param[in] right_report report_mouse_t
  533.  * @return pointing_device_combine_reports(left_report, right_report) by default
  534.  */
  535. __attribute__((weak)) report_mouse_t pointing_device_task_combined_user(report_mouse_t left_report, report_mouse_t right_report) {
  536.     return pointing_device_combine_reports(left_report, right_report);
  537. }
  538. #endif
  540. __attribute__((weak)) void pointing_device_keycode_handler(uint16_t keycode, bool pressed) {
  541.     if IS_MOUSEKEY_BUTTON (keycode) {
  542.         local_mouse_report.buttons = pointing_device_handle_buttons(local_mouse_report.buttons, pressed, keycode - QK_MOUSE_BUTTON_1);
  543.         pointing_device_send();
  544.     }
  545. }
  547. #ifdef POINTING_DEVICE_HIRES_SCROLL_ENABLE
  548. uint16_t pointing_device_get_hires_scroll_resolution(void) {
  549.     return hires_scroll_resolution;
  550. }
  551. #endif