Fix and build.

src/handlers.c

@@ -28,7 +28,7 @@ void output_toggle_hotkey_handler(device_t *state, hid_keyboard_report_t *report
     //     return;
 
     state->active_output ^= 1;
-    set_active_output(state, state->active_output);
+    switch_output(state, state->active_output);
 };
 
 void _get_border_position(device_t *state, border_size_t *border) {
@@ -354,9 +354,8 @@ void handle_heartbeat_msg(uart_packet_t *packet, device_t *state) {
         return;
 
     /* It is? Ok, kick off the firmware upgrade */
-    // state->fw = (fw_upgrade_state_t) {
-    state->fw = () {
-        // .upgrade_in_progress = true,
+    state->fw = (fw_upgrade_state_t) {
+        .upgrade_in_progress = true,
         .byte_done = true,
         .address = 0,
         .checksum = 0xffffffff,
@@ -369,7 +368,7 @@ void handle_heartbeat_msg(uart_packet_t *packet, device_t *state) {
  * ==================================================== */
 
 /* Update output variable, set LED on/off and notify the other board so they are in sync. */
-void set_active_output(device_t *state, uint8_t new_output) {
+void switch_output(device_t *state, uint8_t new_output) {
     state->active_output = new_output;
     restore_leds(state);
     send_value(new_output, OUTPUT_SELECT_MSG);

src/include/main.h

@@ -200,7 +200,6 @@ enum os_type_e {
 };
 
 enum screen_pos_e {
-    NONE   = 0,
     LEFT   = 1,
     RIGHT  = 2,
     MIDDLE = 3,
@@ -373,13 +372,13 @@ typedef struct {
 
 typedef enum { IDLE, READING_PACKET, PROCESSING_PACKET } receiver_state_t;
 
-// typedef struct {
-//     uint32_t address;         // Address we're sending to the other box
-//     uint32_t checksum;
-//     uint16_t version;
-//     bool byte_done;           // Has the byte been successfully transferred
-//     bool upgrade_in_progress; // True if firmware transfer from the other box is in progress
-// } fw_upgrade_state_t;
+typedef struct {
+    uint32_t address;         // Address we're sending to the other box
+    uint32_t checksum;
+    uint16_t version;
+    bool byte_done;           // Has the byte been successfully transferred
+    bool upgrade_in_progress; // True if firmware transfer from the other box is in progress
+} fw_upgrade_state_t;
 
 typedef struct {
     uint8_t kbd_dev_addr; // Address of the keyboard device
@@ -411,7 +410,7 @@ typedef struct {
     uint32_t dma_tx_channel;      // DMA TX channel we're using to send
 
     /* Firmware */
-    // fw_upgrade_state_t fw;           // State of the firmware upgrader
+    fw_upgrade_state_t fw;           // State of the firmware upgrader
     firmware_metadata_t _running_fw; // RAM copy of running fw metadata
     bool reboot_requested;           // If set, stop updating watchdog
     uint64_t config_mode_timer;      // Counts how long are we to remain in config mode
@@ -570,7 +569,7 @@ void handle_api_read_all_msg(uart_packet_t *, device_t *);
 void handle_toggle_gaming_msg(uart_packet_t *, device_t *);
 // void handle_screensaver_msg(uart_packet_t *, device_t *);
 
-void set_active_output(device_t *, uint8_t);
+void switch_output(device_t *, uint8_t);
 
 /*********  Global variables (don't judge)  **********/
 extern device_t global_state;

src/main.c

@@ -47,7 +47,7 @@ int main(void) {
     initial_setup(device);
 
     // Initial state, A is the default output
-    set_active_output(device, OUTPUT_A);
+    switch_output(device, OUTPUT_A);
 
     while (true) {
         for (int i = 0; i < NUM_TASKS; i++)

src/mouse.c

@@ -20,17 +20,6 @@
 #define MACOS_SWITCH_MOVE_X 10
 #define MACOS_SWITCH_MOVE_COUNT 5
 
-/* Check if our upcoming mouse movement would result in having to switch outputs */
-enum screen_pos_e is_screen_switch_needed(int position, int offset) {
-    if (position + offset < MIN_SCREEN_COORD - global_state.config.jump_treshold)
-        return LEFT;
-
-    if (position + offset > MAX_SCREEN_COORD + global_state.config.jump_treshold)
-        return RIGHT;
-
-    return NONE;
-}
-
 /* Move mouse coordinate 'position' by 'offset', but don't fall off the screen */
 int32_t move_and_keep_on_screen(int position, int offset) {
     /* Lowest we can go is 0 */
@@ -74,8 +63,7 @@ int32_t accelerate(int32_t offset) {
     return offset * acceleration[6].factor;
 }
 
-/* Returns LEFT if need to jump left, RIGHT if right, NONE otherwise */
-enum screen_pos_e update_mouse_position(device_t *state, mouse_values_t *values) {
+void update_mouse_position(device_t *state, mouse_values_t *values) {
     output_t *current    = &state->config.output[state->active_output];
     uint8_t reduce_speed = 0;
 
@@ -87,17 +75,12 @@ enum screen_pos_e update_mouse_position(device_t *state, mouse_values_t *values)
     int offset_x = accelerate(values->move_x) * (current->speed_x >> reduce_speed);
     int offset_y = accelerate(values->move_y) * (current->speed_y >> reduce_speed);
 
-    /* Determine if our upcoming movement would stay within the screen */
-    enum screen_pos_e switch_direction = is_screen_switch_needed(state->pointer_x, offset_x);
-
     /* Update movement */
     state->pointer_x = move_and_keep_on_screen(state->pointer_x, offset_x);
     state->pointer_y = move_and_keep_on_screen(state->pointer_y, offset_y);
 
     /* Update buttons state */
     state->mouse_buttons = values->buttons;
-
-    return switch_direction;
 }
 
 /* If we are active output, queue packet to mouse queue, else send them through UART */
@@ -141,7 +124,7 @@ int16_t scale_y_coordinate(int screen_from, int screen_to, device_t *state) {
     return ((state->pointer_y - from->border.top) * MAX_SCREEN_COORD) / size_from;
 }
 
-void switch_to_another_pc(
+void switch_screen(
     device_t *state, output_t *output, int output_to, int direction) {
     uint8_t *mouse_park_pos = &state->config.output[state->active_output].mouse_park_pos;
 
@@ -152,12 +135,12 @@ void switch_to_another_pc(
     mouse_report_t hidden_pointer = {.y = mouse_y, .x = MAX_SCREEN_COORD};
 
     output_mouse_report(&hidden_pointer, state);
-    set_active_output(state, output_to);
+    switch_output(state, output_to);
     state->pointer_x = (direction == LEFT) ? MAX_SCREEN_COORD : MIN_SCREEN_COORD;
     state->pointer_y = scale_y_coordinate(output->number, 1 - output->number, state);
 }
 
-void switch_virtual_desktop_macos(device_t *state, int direction) {
+void switch_desktop_macos(device_t *state, int direction) {
     /* Fix for MACOS: Send relative mouse movement here, one or two pixels in the
        direction of movement, BEFORE absolute report sets X to 0 */
     uint16_t move = (direction == LEFT) ? -MACOS_SWITCH_MOVE_X : MACOS_SWITCH_MOVE_X;
@@ -168,10 +151,10 @@ void switch_virtual_desktop_macos(device_t *state, int direction) {
         output_mouse_report(&move_relative_one, state);
 }
 
-void switch_virtual_desktop(device_t *state, output_t *output, int new_index, int direction) {
+void switch_desktop(device_t *state, output_t *output, int new_index, int direction) {
     switch (output->os) {
         case MACOS:
-            switch_virtual_desktop_macos(state, direction);
+            switch_desktop_macos(state, direction);
             break;
 
         case WINDOWS:
@@ -199,21 +182,22 @@ void switch_virtual_desktop(device_t *state, output_t *output, int new_index, in
        '---------'    '---------'  |  '---------'    '---------'    '---------'
           )___(          )___(     |     )___(          )___(          )___(
 */
-void do_screen_switch(device_t *state, int direction) {
+void check_screen_switch(const mouse_values_t *values, device_t *state) {
+    int new_x        = state->pointer_x + values->move_x;
     output_t *output = &state->config.output[state->active_output];
 
-    // bool jump_left  = new_x < MIN_SCREEN_COORD - state->config.jump_treshold;
-    // bool jump_right = new_x > MAX_SCREEN_COORD + state->config.jump_treshold;
+    bool jump_left  = new_x < MIN_SCREEN_COORD - state->config.jump_treshold;
+    bool jump_right = new_x > MAX_SCREEN_COORD + state->config.jump_treshold;
 
-    // int direction = jump_left ? LEFT : RIGHT;
+    int direction = jump_left ? LEFT : RIGHT;
 
     // /* No switching allowed if explicitly disabled or in gaming mode */
     // if (state->switch_lock)
     //     return;
 
     /* No jump condition met == nothing to do, return */
-    // if (!jump_left && !jump_right)
-    //     return;
+    if (!jump_left && !jump_right)
+        return;
 
     /* We want to jump in the direction of the other computer */
     if (output->pos != direction) {
@@ -222,16 +206,16 @@ void do_screen_switch(device_t *state, int direction) {
             if (state->mouse_buttons)
                 return;
 
-            switch_to_another_pc(state, output, 1 - state->active_output, direction);
+            switch_screen(state, output, 1 - state->active_output, direction);
         }
         /* If here, this output has multiple desktops and we are not on the main one */
         else
-            switch_virtual_desktop(state, output, output->screen_index - 1, direction);
+            switch_desktop(state, output, output->screen_index - 1, direction);
     }
 
     /* We want to jump away from the other computer, only possible if there is another screen to jump to */
     else if (output->screen_index < output->screen_count)
-        switch_virtual_desktop(state, output, output->screen_index + 1, direction);
+        switch_desktop(state, output, output->screen_index + 1, direction);
 }
 
 void extract_report_values(uint8_t *raw_report, device_t *state, mouse_values_t *values, hid_interface_t *iface) {
@@ -286,7 +270,7 @@ void process_mouse_report(uint8_t *raw_report, int len, uint8_t itf, hid_interfa
     extract_report_values(raw_report, state, &values, iface);
 
     /* Calculate and update mouse pointer movement. */
-    enum screen_pos_e switch_direction = update_mouse_position(state, &values);
+    update_mouse_position(state, &values);
 
     /* Create the report for the output PC based on the updated values */
     mouse_report_t report = create_mouse_report(state, &values);
@@ -294,9 +278,8 @@ void process_mouse_report(uint8_t *raw_report, int len, uint8_t itf, hid_interfa
     /* Move the mouse, depending where the output is supposed to go */
     output_mouse_report(&report, state);
 
-    /* We use the mouse to switch outputs, if switch_direction is LEFT or RIGHT */
-    if (switch_direction != NONE)
-        do_screen_switch(state, switch_direction);
+    /* We use the mouse to switch outputs, the logic is in check_screen_switch() */
+    check_screen_switch(&values, state);
 }
 
 /* ==================================================== *