swap key update

flutter/lib/desktop/pages/desktop_setting_page.dart

@@ -278,8 +278,6 @@ class _GeneralState extends State<_General> {
       _OptionCheckBox(context, 'Confirm before closing multiple tabs',
           'enable-confirm-closing-tabs'),
       _OptionCheckBox(context, 'Adaptive Bitrate', 'enable-abr'),
-      if (Platform.isMacOS)
-        _OptionCheckBox(context, 'Swap control-command key', 'allow-swap-key'),
       if (Platform.isLinux)
         Tooltip(
           message: translate('software_render_tip'),

flutter/lib/desktop/widgets/remote_menubar.dart

@@ -1580,6 +1580,9 @@ class _RemoteMenubarState extends State<RemoteMenubar> {
         ),
       );
     }
+    keyboardMenu.add(_createSwitchMenuEntry(
+        'Swap Control-Command  Key', 'allow_swap_key', EdgeInsets.zero, true));
+
     return keyboardMenu;
   }
 

libs/hbb_common/src/config.rs

@@ -223,6 +223,8 @@ pub struct PeerConfig {
     pub lock_after_session_end: LockAfterSessionEnd,
     #[serde(flatten)]
     pub privacy_mode: PrivacyMode,
+    #[serde(flatten)]
+    pub allow_swap_key: AllowSwapKey,
     #[serde(default)]
     pub port_forwards: Vec<(i32, String, i32)>,
     #[serde(default)]
@@ -1066,6 +1068,8 @@ serde_field_bool!(
 );
 serde_field_bool!(PrivacyMode, "privacy_mode", default_privacy_mode);
 
+serde_field_bool!(AllowSwapKey, "allow_swap_key", default_swap_key);
+
 #[derive(Debug, Default, Serialize, Deserialize, Clone)]
 pub struct LocalConfig {
     #[serde(default)]

src/client.rs

@@ -1121,6 +1121,8 @@ impl LoginConfigHandler {
             option.block_input = BoolOption::No.into();
         } else if name == "show-quality-monitor" {
             config.show_quality_monitor.v = !config.show_quality_monitor.v;
+        } else if name == "allow_swap_key" {
+            config.allow_swap_key.v = !config.allow_swap_key.v;
         } else {
             let is_set = self
                 .options
@@ -1274,6 +1276,8 @@ impl LoginConfigHandler {
             self.config.disable_clipboard.v
         } else if name == "show-quality-monitor" {
             self.config.show_quality_monitor.v
+        } else if name == "allow_swap_key" {
+            self.config.allow_swap_key.v
         } else {
             !self.get_option(name).is_empty()
         }

src/flutter.rs

@@ -428,10 +428,8 @@ pub fn session_add(
     let session_id = get_session_id(id.to_owned());
     LocalConfig::set_remote_id(&session_id);
 
-    let allow_swap_key = hbb_common::config::Config::get_option("allow-swap-key") == "Y";
     let session: Session<FlutterHandler> = Session {
         id: session_id.clone(),
-        allow_swap_key,
         ..Default::default()
     };
 

src/keyboard.rs

@@ -205,18 +205,16 @@ static mut IS_0X021D_DOWN: bool = false;
 pub fn start_grab_loop() {
     #[cfg(any(target_os = "windows", target_os = "macos"))]
     std::thread::spawn(move || {
-        let try_handle_keyboard = move |event: Event, key: Key, is_press: bool| -> Option<Event> {
+            let try_handle_keyboard = move |mut event: Event, key: Key, is_press: bool| -> Option<Event> {
             // fix #2211：CAPS LOCK don't work
             if key == Key::CapsLock || key == Key::NumLock {
                 return Some(event);
             }
-            #[cfg(target_os = "macos")] 
+            {
-            let mut event = event;
-            #[cfg(target_os = "macos")] {
                 let mut allow_swap_key = false;
                 #[cfg(not(any(feature = "flutter", feature = "cli")))]
                 if let Some(session) = CUR_SESSION.lock().unwrap().as_ref() {
-                    allow_swap_key = session.allow_swap_key;
+                    allow_swap_key = session.get_toggle_option("allow_swap_key".to_string());
                 }
                 #[cfg(feature = "flutter")]
                 if let Some(session) = SESSIONS
@@ -224,7 +222,7 @@ pub fn start_grab_loop() {
                     .unwrap()
                     .get(&*CUR_SESSION_ID.read().unwrap())
                 {
-                    allow_swap_key = session.allow_swap_key;
+                    allow_swap_key = session.get_toggle_option("allow_swap_key".to_string());
                 }
                 if allow_swap_key {
                     match event.event_type {
@@ -237,7 +235,11 @@ pub fn start_grab_loop() {
                                 _ => key,
                             };
                             event.event_type = EventType::KeyPress(key);
-                            event.scan_code = rdev::macos_keycode_from_key(key).unwrap_or_default();
+                            #[cfg(target_os = "windows")]
+                            let scan_code = rdev::win_scancode_from_key(key).unwrap_or_default();
+                            #[cfg(target_os = "macos")]
+                            let scan_code = rdev::macos_keycode_from_key(key).unwrap_or_default();
+                            event.scan_code = scan_code;
                             event.code = event.scan_code as _;
                         }
                         EventType::KeyRelease(key) => {
@@ -249,7 +251,11 @@ pub fn start_grab_loop() {
                                 _ => key,
                             };
                             event.event_type = EventType::KeyRelease(key);
-                            event.scan_code = rdev::macos_keycode_from_key(key).unwrap_or_default();
+                            #[cfg(target_os = "windows")]
+                            let scan_code = rdev::win_scancode_from_key(key).unwrap_or_default();
+                            #[cfg(target_os = "macos")]
+                            let scan_code = rdev::macos_keycode_from_key(key).unwrap_or_default();
+                            event.scan_code = scan_code;
                             event.code = event.scan_code as _;
                         }
                         _ => {}
@@ -257,7 +263,6 @@ pub fn start_grab_loop() {
                 };
             };
 
-
             let mut _keyboard_mode = KeyboardMode::Map;
             let _scan_code = event.scan_code;
             let res = if KEYBOARD_HOOKED.load(Ordering::SeqCst) {

src/server/connection.rs

@@ -539,9 +539,6 @@ impl Connection {
 
     #[cfg(not(any(target_os = "android", target_os = "ios")))]
     fn handle_input(receiver: std_mpsc::Receiver<MessageInput>, tx: Sender) {
-	    #[cfg(target_os = "macos")] 
-        let allow_swap_key = hbb_common::config::Config::get_option("allow-swap-key") == "Y";
-
         let mut block_input_mode = false;
         #[cfg(target_os = "windows")]
         {
@@ -554,66 +551,9 @@ impl Connection {
             match receiver.recv_timeout(std::time::Duration::from_millis(500)) {
                 Ok(v) => match v {
                     MessageInput::Mouse((msg, id)) => {
-                        #[cfg(target_os = "macos")]
-                        let msg = {
-                            let mut msg = msg;
-                            if allow_swap_key {
-                                msg.modifiers = msg.modifiers.iter().map(|ck| {
-                                    let ck = ck.enum_value_or_default();
-                                    let ck = match ck {
-                                        ControlKey::Control => ControlKey::Meta,
-                                        ControlKey::Meta => ControlKey::Control,
-                                        ControlKey::RControl => ControlKey::Meta,
-                                        ControlKey::RWin => ControlKey::Control,
-                                        _ => ck,
-                                    };
-                                    hbb_common::protobuf::EnumOrUnknown::new(ck)
-                                }).collect();
-                            }
-                            msg
-                        };
-
                         handle_mouse(&msg, id);
                     }
                     MessageInput::Key((mut msg, press)) => {
-                        #[cfg(target_os = "macos")]
-                        if allow_swap_key {
-                            if let Some(key_event::Union::ControlKey(ck)) = msg.union {
-                                let ck = ck.enum_value_or_default();
-                                let ck = match ck {
-                                    ControlKey::Control => ControlKey::Meta,
-                                    ControlKey::Meta => ControlKey::Control,
-                                    ControlKey::RControl => ControlKey::Meta,
-                                    ControlKey::RWin => ControlKey::Control,
-                                    _ => ck,
-                                };
-                                msg.set_control_key(ck);
-                            }
-                            msg.modifiers = msg.modifiers.iter().map(|ck| {
-                                let ck = ck.enum_value_or_default();
-                                let ck = match ck {
-                                    ControlKey::Control => ControlKey::Meta,
-                                    ControlKey::Meta => ControlKey::Control,
-                                    ControlKey::RControl => ControlKey::Meta,
-                                    ControlKey::RWin => ControlKey::Control,
-                                    _ => ck,
-                                };
-                                hbb_common::protobuf::EnumOrUnknown::new(ck)
-                            }).collect();
-                            
-                            let code = msg.chr();
-                            if code != 0 {
-                                let key = rdev::key_from_code(code);
-                                let key = match key {
-                                    rdev::Key::ControlLeft => rdev::Key::MetaLeft,
-                                    rdev::Key::MetaLeft => rdev::Key::ControlLeft,
-                                    rdev::Key::ControlRight => rdev::Key::MetaLeft,
-                                    rdev::Key::MetaRight => rdev::Key::ControlLeft,
-                                    _ => key,
-                                };
-                                msg.set_chr(rdev::macos_keycode_from_key(key).unwrap_or_default());
-                            }
-                        }
                         // todo: press and down have similar meanings.
                         if press && msg.mode.unwrap() == KeyboardMode::Legacy {
                             msg.down = true;

src/ui/header.tis

@@ -156,6 +156,7 @@ class Header: Reactor.Component {
             <menu.context #keyboard-options>
                 <li #legacy><span>{svg_checkmark}</span>{translate('Legacy mode')}</li> 
                 <li #map><span>{svg_checkmark}</span>{translate('Map mode')}</li> 
+                <li #allow_swap_key><span>{svg_checkmark}</span>{translate('Swap Control-Command Key')}</li>
             </menu>
         </popup>;
     }

src/ui/index.tis

@@ -214,7 +214,6 @@ class Enhancements: Reactor.Component {
                 {has_hwcodec ? <li #enable-hwcodec><span>{svg_checkmark}</span>{translate("Hardware Codec")} (beta)</li> : ""}
                 <li #enable-abr><span>{svg_checkmark}</span>{translate("Adaptive Bitrate")} (beta)</li>
                 <li #screen-recording>{translate("Recording")}</li>
-                {is_osx ? <li #allow-swap-key><span>{svg_checkmark}</span>{translate("Swap control-command key")} </li> : "" }
             </menu>
         </li>;
     }

src/ui/remote.rs

@@ -443,12 +443,10 @@ impl sciter::EventHandler for SciterSession {
 
 impl SciterSession {
     pub fn new(cmd: String, id: String, password: String, args: Vec<String>) -> Self {
-        let allow_swap_key = hbb_common::config::Config::get_option("allow-swap-key") == "Y";
         let session: Session<SciterHandler> = Session {
             id: id.clone(),
             password: password.clone(),
             args,
-            allow_swap_key,
             ..Default::default()
         };
 

src/ui_session_interface.rs

@@ -36,7 +36,6 @@ pub struct Session<T: InvokeUiSession> {
     pub sender: Arc<RwLock<Option<mpsc::UnboundedSender<Data>>>>,
     pub thread: Arc<Mutex<Option<std::thread::JoinHandle<()>>>>,
     pub ui_handler: T,
-    pub allow_swap_key: bool,
 }
 
 impl<T: InvokeUiSession> Session<T> {
@@ -506,9 +505,8 @@ impl<T: InvokeUiSession> Session<T> {
         shift: bool,
         command: bool,
     ) {
-        #[cfg(target_os = "macos")]
         let (ctrl, command) = 
-        if self.allow_swap_key {
+        if self.get_toggle_option("allow_swap_key".to_string()) {
             (command, ctrl)
         }
         else {