added an option to change the mouse speed

Author: sidit77

Readme.md

@@ -71,10 +71,10 @@ During the first run the client will generate a config file called `inputshare-c
 
 * `host_address`: The address of the raspberry pi that runs the sever
 * `hotkey`: The hotkey that toggles input between the local and remote pc. The hotkey has two parts: the trigger key which triggers the swap and a variable amount of modifier keys which also have to be pressed for the trigger to work. Supported values: [Possible key codes](#appendix-a-possible-key-codes).
-* `backlist`: All keys included in in this list will be ignored by the client. Supported values: [Possible key codes](#appendix-a-possible-key-codes).
+* `blacklist`: All keys included in in this list will be ignored by the client. Supported values: [Possible key codes](#appendix-a-possible-key-codes).
 * `show_network_info`: When set to `true` the client will display the round-trip-time and packet loss to the server. This call also be toggled at runtime by pressing `F1`.
 * `network_send_rate`: The number of packets per second that the client will send to the server while transmitting. Higher values mean lower latency and smoother mouse movement while lower values mean less network activity. Note that if the send rate is set to high it will flood the connection and cause massive delays / packet loss. Consider that the `mouse-tesselation-factor` option of the server has a similar effect and should be tuned in tandem.
-
+* `mouse_speed_factor`: changes the mouse speed of the remote device
 
 
 ### Server

inputshare-client/src/main.rs

@@ -128,7 +128,7 @@ fn client() -> Result<()> {
                 match event {
                     ClientEvent::Connected(id) => {
                         println!("Connected as {}", id);
-                        input_transmitter = Some(InputTransmitter::new(&config.hotkey, &config.backlist)?);
+                        input_transmitter = Some(InputTransmitter::new(&config)?);
                         app.connect_button.set_text("Disconnect");
                         app.connect_button.set_enabled(true);
                         app.set_status(StatusText::Local);
@@ -191,8 +191,8 @@ struct InputTransmitter<'a> {
 
 impl<'a> InputTransmitter<'a> {
 
-    fn new(hotkey: &Hotkey, blacklist: &HashSet<VirtualKey>) -> Result<Self> {
-        let sender = Rc::new(RefCell::new(InputSender::new()));
+    fn new(config: &Config) -> Result<Self> {
+        let sender = Rc::new(RefCell::new(InputSender::new(config.mouse_speed_factor)));
         let hook = {
             let input_events = sender.clone();
             let mut old_mouse_pos = unsafe {
@@ -201,10 +201,10 @@ impl<'a> InputTransmitter<'a> {
                 (point.x, point.y)
             };
 
-            let blacklist = blacklist.clone();
+            let blacklist = config.blacklist.clone();
+            let hotkey = config.hotkey.clone();
 
             let mut captured = false;
-            let hotkey = hotkey.clone();
             let mut pressed_keys = HashSet::new();
 
             InputHook::new(move |event|{
@@ -418,17 +418,18 @@ impl<const N: usize> From<[VirtualKey; N]> for Hotkey {
 pub struct Config {
     pub host_address: String,
     pub hotkey: Hotkey,
-    pub backlist: HashSet<VirtualKey>,
+    pub blacklist: HashSet<VirtualKey>,
     pub show_network_info: bool,
-    pub network_send_rate: u32
+    pub network_send_rate: u32,
+    pub mouse_speed_factor: f32
 }
 
 impl Default for Config {
     fn default() -> Self {
         Self {
             host_address: String::from("raspberrypi.local:60067"),
             hotkey: Hotkey::from([VirtualKey::Apps]),
-            backlist: HashSet::from([
+            blacklist: HashSet::from([
                 VirtualKey::VolumeDown,
                 VirtualKey::VolumeUp,
                 VirtualKey::VolumeMute,
@@ -438,7 +439,8 @@ impl Default for Config {
                 VirtualKey::MediaNextTrack
             ]),
             show_network_info: false,
-            network_send_rate: 100
+            network_send_rate: 100,
+            mouse_speed_factor: 1.0
         }
     }
 }

inputshare-client/src/sender.rs

@@ -9,26 +9,38 @@ type MouseType = i64;
 pub struct InputSender {
     packet_buffer: Vec<u8>,
     local_mouse_pos: Vec2<MouseType>,
+    local_mouse_pos_raw: Vec2<MouseType>,
+    mouse_speed_factor: f64,
     remote_mouse_pos: Vec2<MouseType>,
     message_queue: VecDeque<[u8; 2]>,
     last_message: u64
 }
 
 impl InputSender {
 
-    pub fn new() -> Self {
+    pub fn new(mouse_speed_factor: f32) -> Self {
         Self{
             packet_buffer: Vec::new(),
             local_mouse_pos: Vec2::new(0, 0),
+            local_mouse_pos_raw: Vec2::new(0, 0),
+            mouse_speed_factor: mouse_speed_factor.into(),
             remote_mouse_pos: Vec2::new(0, 0),
             message_queue: VecDeque::new(),
             last_message: 0
         }
     }
 
     pub fn move_mouse(&mut self, x: MouseType, y: MouseType) {
-        self.local_mouse_pos.x += x;
-        self.local_mouse_pos.y += y;
+        if (self.mouse_speed_factor - 1.0).abs() > f64::EPSILON {
+            self.local_mouse_pos_raw.x += x;
+            self.local_mouse_pos_raw.y += y;
+            self.local_mouse_pos.x = f64::round(self.local_mouse_pos_raw.x as f64 * self.mouse_speed_factor) as MouseType;
+            self.local_mouse_pos.y = f64::round(self.local_mouse_pos_raw.y as f64 * self.mouse_speed_factor) as MouseType;
+        } else {
+            self.local_mouse_pos.x += x;
+            self.local_mouse_pos.y += y;
+        }
+
     }
 
     pub fn reset(&mut self) {