merge mobile/desktop remote toobar code

Signed-off-by: 21pages <pages21@163.com>

flutter/lib/common/shared_state.dart

@@ -261,3 +261,23 @@ class PeerStringOption {
   static RxString find(String id, String opt) =>
       Get.find<RxString>(tag: tag(id, opt));
 }
+
+initSharedStates(String id) {
+  PrivacyModeState.init(id);
+  BlockInputState.init(id);
+  CurrentDisplayState.init(id);
+  KeyboardEnabledState.init(id);
+  ShowRemoteCursorState.init(id);
+  RemoteCursorMovedState.init(id);
+  PeerBoolOption.init(id, 'zoom-cursor', () => false);
+}
+
+removeSharedStates(String id) {
+  PrivacyModeState.delete(id);
+  BlockInputState.delete(id);
+  CurrentDisplayState.delete(id);
+  ShowRemoteCursorState.delete(id);
+  KeyboardEnabledState.delete(id);
+  RemoteCursorMovedState.delete(id);
+  PeerBoolOption.delete(id, 'zoom-cursor');
+}

flutter/lib/common/widgets/dialog.dart

@@ -1,7 +1,9 @@
 import 'dart:async';
 
+import 'package:debounce_throttle/debounce_throttle.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
+import 'package:flutter_hbb/common/shared_state.dart';
 import 'package:get/get.dart';
 
 import '../../common.dart';
@@ -879,7 +881,9 @@ void showRestartRemoteDevice(
       await dialogManager.show<bool>((setState, close) => CustomAlertDialog(
             title: Row(children: [
               Icon(Icons.warning_rounded, color: Colors.redAccent, size: 28),
-              Text(translate("Restart Remote Device")).paddingOnly(left: 10),
+              Flexible(
+                  child: Text(translate("Restart Remote Device"))
+                      .paddingOnly(left: 10)),
             ]),
             content: Text(
                 "${translate('Are you sure you want to restart')} \n${pi.username}@${pi.hostname}($id) ?"),
@@ -1047,3 +1051,221 @@ showSetOSAccount(
     );
   });
 }
+
+showAuditDialog(String id, dialogManager) async {
+  final controller = TextEditingController();
+  dialogManager.show((setState, close) {
+    submit() {
+      var text = controller.text.trim();
+      if (text != '') {
+        bind.sessionSendNote(id: id, note: text);
+      }
+      close();
+    }
+
+    late final focusNode = FocusNode(
+      onKey: (FocusNode node, RawKeyEvent evt) {
+        if (evt.logicalKey.keyLabel == 'Enter') {
+          if (evt is RawKeyDownEvent) {
+            int pos = controller.selection.base.offset;
+            controller.text =
+                '${controller.text.substring(0, pos)}\n${controller.text.substring(pos)}';
+            controller.selection =
+                TextSelection.fromPosition(TextPosition(offset: pos + 1));
+          }
+          return KeyEventResult.handled;
+        }
+        if (evt.logicalKey.keyLabel == 'Esc') {
+          if (evt is RawKeyDownEvent) {
+            close();
+          }
+          return KeyEventResult.handled;
+        } else {
+          return KeyEventResult.ignored;
+        }
+      },
+    );
+
+    return CustomAlertDialog(
+      title: Text(translate('Note')),
+      content: SizedBox(
+          width: 250,
+          height: 120,
+          child: TextField(
+            autofocus: true,
+            keyboardType: TextInputType.multiline,
+            textInputAction: TextInputAction.newline,
+            decoration: const InputDecoration.collapsed(
+              hintText: 'input note here',
+            ),
+            maxLines: null,
+            maxLength: 256,
+            controller: controller,
+            focusNode: focusNode,
+          )),
+      actions: [
+        dialogButton('Cancel', onPressed: close, isOutline: true),
+        dialogButton('OK', onPressed: submit)
+      ],
+      onSubmit: submit,
+      onCancel: close,
+    );
+  });
+}
+
+void showConfirmSwitchSidesDialog(
+    String id, OverlayDialogManager dialogManager) async {
+  dialogManager.show((setState, close) {
+    submit() async {
+      await bind.sessionSwitchSides(id: id);
+      closeConnection(id: id);
+    }
+
+    return CustomAlertDialog(
+      content: msgboxContent('info', 'Switch Sides',
+          'Please confirm if you want to share your desktop?'),
+      actions: [
+        dialogButton('Cancel', onPressed: close, isOutline: true),
+        dialogButton('OK', onPressed: submit),
+      ],
+      onSubmit: submit,
+      onCancel: close,
+    );
+  });
+}
+
+customImageQualityDialog(String id, FFI ffi) async {
+  double qualityInitValue = 50;
+  double fpsInitValue = 30;
+  bool qualitySet = false;
+  bool fpsSet = false;
+  setCustomValues({double? quality, double? fps}) async {
+    if (quality != null) {
+      qualitySet = true;
+      await bind.sessionSetCustomImageQuality(id: id, value: quality.toInt());
+    }
+    if (fps != null) {
+      fpsSet = true;
+      await bind.sessionSetCustomFps(id: id, fps: fps.toInt());
+    }
+    if (!qualitySet) {
+      qualitySet = true;
+      await bind.sessionSetCustomImageQuality(
+          id: id, value: qualityInitValue.toInt());
+    }
+    if (!fpsSet) {
+      fpsSet = true;
+      await bind.sessionSetCustomFps(id: id, fps: fpsInitValue.toInt());
+    }
+  }
+
+  final btnClose = dialogButton('Close', onPressed: () async {
+    await setCustomValues();
+    ffi.dialogManager.dismissAll();
+  });
+
+  // quality
+  final quality = await bind.sessionGetCustomImageQuality(id: id);
+  qualityInitValue =
+      quality != null && quality.isNotEmpty ? quality[0].toDouble() : 50.0;
+  const qualityMinValue = 10.0;
+  const qualityMaxValue = 100.0;
+  if (qualityInitValue < qualityMinValue) {
+    qualityInitValue = qualityMinValue;
+  }
+  if (qualityInitValue > qualityMaxValue) {
+    qualityInitValue = qualityMaxValue;
+  }
+  final RxDouble qualitySliderValue = RxDouble(qualityInitValue);
+  final debouncerQuality = Debouncer<double>(
+    Duration(milliseconds: 1000),
+    onChanged: (double v) {
+      setCustomValues(quality: v);
+    },
+    initialValue: qualityInitValue,
+  );
+  final qualitySlider = Obx(() => Row(
+        children: [
+          Expanded(
+              flex: 3,
+              child: Slider(
+                value: qualitySliderValue.value,
+                min: qualityMinValue,
+                max: qualityMaxValue,
+                divisions: 18,
+                onChanged: (double value) {
+                  qualitySliderValue.value = value;
+                  debouncerQuality.value = value;
+                },
+              )),
+          Expanded(
+              flex: 1,
+              child: Text(
+                '${qualitySliderValue.value.round()}%',
+                style: const TextStyle(fontSize: 15),
+              )),
+          Expanded(
+              flex: 2,
+              child: Text(
+                translate('Bitrate'),
+                style: const TextStyle(fontSize: 15),
+              )),
+        ],
+      ));
+  // fps
+  final fpsOption = await bind.sessionGetOption(id: id, arg: 'custom-fps');
+  fpsInitValue = fpsOption == null ? 30 : double.tryParse(fpsOption) ?? 30;
+  if (fpsInitValue < 5 || fpsInitValue > 120) {
+    fpsInitValue = 30;
+  }
+  final RxDouble fpsSliderValue = RxDouble(fpsInitValue);
+  final debouncerFps = Debouncer<double>(
+    Duration(milliseconds: 1000),
+    onChanged: (double v) {
+      setCustomValues(fps: v);
+    },
+    initialValue: qualityInitValue,
+  );
+  bool? direct;
+  try {
+    direct =
+        ConnectionTypeState.find(id).direct.value == ConnectionType.strDirect;
+  } catch (_) {}
+  final fpsSlider = Offstage(
+    offstage: (await bind.mainIsUsingPublicServer() && direct != true) ||
+        version_cmp(ffi.ffiModel.pi.version, '1.2.0') < 0,
+    child: Row(
+      children: [
+        Expanded(
+            flex: 3,
+            child: Obx((() => Slider(
+                  value: fpsSliderValue.value,
+                  min: 5,
+                  max: 120,
+                  divisions: 23,
+                  onChanged: (double value) {
+                    fpsSliderValue.value = value;
+                    debouncerFps.value = value;
+                  },
+                )))),
+        Expanded(
+            flex: 1,
+            child: Obx(() => Text(
+                  '${fpsSliderValue.value.round()}',
+                  style: const TextStyle(fontSize: 15),
+                ))),
+        Expanded(
+            flex: 2,
+            child: Text(
+              translate('FPS'),
+              style: const TextStyle(fontSize: 15),
+            ))
+      ],
+    ),
+  );
+
+  final content = Column(
+    children: [qualitySlider, fpsSlider],
+  );
+  msgBoxCommon(ffi.dialogManager, 'Custom Image Quality', content, [btnClose]);
+}

flutter/lib/common/widgets/toolbar.dart

@@ -0,0 +1,449 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_hbb/common.dart';
+import 'package:flutter_hbb/common/shared_state.dart';
+import 'package:flutter_hbb/common/widgets/dialog.dart';
+import 'package:flutter_hbb/consts.dart';
+import 'package:flutter_hbb/models/model.dart';
+import 'package:flutter_hbb/models/platform_model.dart';
+import 'package:get/get.dart';
+
+class TTextMenu {
+  final Widget child;
+  final VoidCallback onPressed;
+  Widget? trailingIcon;
+  bool divider;
+  TTextMenu(
+      {required this.child,
+      required this.onPressed,
+      this.trailingIcon,
+      this.divider = false});
+}
+
+class TRadioMenu<T> {
+  final Widget child;
+  final T value;
+  final T groupValue;
+  final ValueChanged<T?>? onChanged;
+
+  TRadioMenu(
+      {required this.child,
+      required this.value,
+      required this.groupValue,
+      required this.onChanged});
+}
+
+class TToggleMenu {
+  final Widget child;
+  final bool value;
+  final ValueChanged<bool?>? onChanged;
+  TToggleMenu(
+      {required this.child, required this.value, required this.onChanged});
+}
+
+List<TTextMenu> toolbarControls(BuildContext context, String id, FFI ffi) {
+  final ffiModel = ffi.ffiModel;
+  final pi = ffiModel.pi;
+  final perms = ffiModel.permissions;
+
+  List<TTextMenu> v = [];
+  // elevation
+  if (ffi.elevationModel.showRequestMenu) {
+    v.add(
+      TTextMenu(
+          child: Text(translate('Request Elevation')),
+          onPressed: () => showRequestElevationDialog(id, ffi.dialogManager)),
+    );
+  }
+  // osAccount / osPassword
+  v.add(
+    TTextMenu(
+        child: Row(children: [
+          Text(translate(pi.is_headless ? 'OS Account' : 'OS Password')),
+          Offstage(
+              offstage: isDesktop,
+              child:
+                  Icon(Icons.edit, color: MyTheme.accent).marginOnly(left: 12))
+        ]),
+        trailingIcon: Transform.scale(scale: 0.8, child: Icon(Icons.edit)),
+        onPressed: () => pi.is_headless
+            ? showSetOSAccount(id, ffi.dialogManager)
+            : showSetOSPassword(id, false, ffi.dialogManager)),
+  );
+  // paste
+  if (isMobile && perms['keyboard'] != false && perms['clipboard'] != false) {
+    v.add(TTextMenu(
+        child: Text(translate('Paste')),
+        onPressed: () async {
+          ClipboardData? data = await Clipboard.getData(Clipboard.kTextPlain);
+          if (data != null && data.text != null) {
+            bind.sessionInputString(id: id, value: data.text ?? "");
+          }
+        }));
+  }
+  // reset canvas
+  if (isMobile) {
+    v.add(TTextMenu(
+        child: Text(translate('Reset canvas')),
+        onPressed: () => ffi.cursorModel.reset()));
+  }
+  // transferFile
+  if (isDesktop) {
+    v.add(
+      TTextMenu(
+          child: Text(translate('Transfer File')),
+          onPressed: () => connect(context, id, isFileTransfer: true)),
+    );
+  }
+  // tcpTunneling
+  if (isDesktop) {
+    v.add(
+      TTextMenu(
+          child: Text(translate('TCP Tunneling')),
+          onPressed: () => connect(context, id, isTcpTunneling: true)),
+    );
+  }
+  // note
+  if (bind.sessionGetAuditServerSync(id: id, typ: "conn").isNotEmpty) {
+    v.add(
+      TTextMenu(
+          child: Text(translate('Note')),
+          onPressed: () => showAuditDialog(id, ffi.dialogManager)),
+    );
+  }
+  // divider
+  if (isDesktop) {
+    v.add(TTextMenu(child: Offstage(), onPressed: () {}, divider: true));
+  }
+  // ctrlAltDel
+  if (!ffiModel.viewOnly &&
+      ffiModel.keyboard &&
+      (pi.platform == kPeerPlatformLinux || pi.sasEnabled)) {
+    v.add(
+      TTextMenu(
+          child: Text('${translate("Insert")} Ctrl + Alt + Del'),
+          onPressed: () => bind.sessionCtrlAltDel(id: id)),
+    );
+  }
+  // restart
+  if (perms['restart'] != false &&
+      (pi.platform == kPeerPlatformLinux ||
+          pi.platform == kPeerPlatformWindows ||
+          pi.platform == kPeerPlatformMacOS)) {
+    v.add(
+      TTextMenu(
+          child: Text(translate('Restart Remote Device')),
+          onPressed: () => showRestartRemoteDevice(pi, id, ffi.dialogManager)),
+    );
+  }
+  // insertLock
+  if (!ffiModel.viewOnly && ffi.ffiModel.keyboard) {
+    v.add(
+      TTextMenu(
+          child: Text(translate('Insert Lock')),
+          onPressed: () => bind.sessionLockScreen(id: id)),
+    );
+  }
+  // blockUserInput
+  if (ffi.ffiModel.keyboard &&
+      pi.platform == kPeerPlatformWindows) // privacy-mode != true ??
+  {
+    v.add(TTextMenu(
+        child: Obx(() => Text(translate(
+            '${BlockInputState.find(id).value ? 'Unb' : 'B'}lock user input'))),
+        onPressed: () {
+          RxBool blockInput = BlockInputState.find(id);
+          bind.sessionToggleOption(
+              id: id, value: '${blockInput.value ? 'un' : ''}block-input');
+          blockInput.value = !blockInput.value;
+        }));
+  }
+  // switchSides
+  if (isDesktop &&
+      ffiModel.keyboard &&
+      pi.platform != kPeerPlatformAndroid &&
+      pi.platform != kPeerPlatformMacOS &&
+      version_cmp(pi.version, '1.2.0') >= 0) {
+    v.add(TTextMenu(
+        child: Text(translate('Switch Sides')),
+        onPressed: () => showConfirmSwitchSidesDialog(id, ffi.dialogManager)));
+  }
+  // refresh
+  if (pi.version.isNotEmpty) {
+    v.add(TTextMenu(
+        child: Text(translate('Refresh')),
+        onPressed: () => bind.sessionRefresh(id: id)));
+  }
+  // record
+  var codecFormat = ffi.qualityMonitorModel.data.codecFormat;
+  if (!isDesktop &&
+      (ffi.recordingModel.start ||
+          (perms["recording"] != false &&
+              (codecFormat == "VP8" || codecFormat == "VP9")))) {
+    v.add(TTextMenu(
+        child: Row(
+          children: [
+            Text(translate(ffi.recordingModel.start
+                ? 'Stop session recording'
+                : 'Start session recording')),
+            Padding(
+              padding: EdgeInsets.only(left: 12),
+              child: Icon(
+                  ffi.recordingModel.start
+                      ? Icons.pause_circle_filled
+                      : Icons.videocam_outlined,
+                  color: MyTheme.accent),
+            )
+          ],
+        ),
+        onPressed: () => ffi.recordingModel.toggle()));
+  }
+  return v;
+}
+
+Future<List<TRadioMenu<String>>> toolbarViewStyle(
+    BuildContext context, String id, FFI ffi) async {
+  final groupValue = await bind.sessionGetViewStyle(id: id) ?? '';
+  void onChanged(String? value) async {
+    if (value == null) return;
+    bind
+        .sessionSetViewStyle(id: id, value: value)
+        .then((_) => ffi.canvasModel.updateViewStyle());
+  }
+
+  return [
+    TRadioMenu<String>(
+        child: Text(translate('Scale original')),
+        value: kRemoteViewStyleOriginal,
+        groupValue: groupValue,
+        onChanged: onChanged),
+    TRadioMenu<String>(
+        child: Text(translate('Scale adaptive')),
+        value: kRemoteViewStyleAdaptive,
+        groupValue: groupValue,
+        onChanged: onChanged)
+  ];
+}
+
+Future<List<TRadioMenu<String>>> toolbarImageQuality(
+    BuildContext context, String id, FFI ffi) async {
+  final groupValue = await bind.sessionGetImageQuality(id: id) ?? '';
+  onChanged(String? value) async {
+    if (value == null) return;
+    await bind.sessionSetImageQuality(id: id, value: value);
+  }
+
+  return [
+    TRadioMenu<String>(
+        child: Text(translate('Good image quality')),
+        value: kRemoteImageQualityBest,
+        groupValue: groupValue,
+        onChanged: onChanged),
+    TRadioMenu<String>(
+        child: Text(translate('Balanced')),
+        value: kRemoteImageQualityBalanced,
+        groupValue: groupValue,
+        onChanged: onChanged),
+    TRadioMenu<String>(
+        child: Text(translate('Optimize reaction time')),
+        value: kRemoteImageQualityLow,
+        groupValue: groupValue,
+        onChanged: onChanged),
+    TRadioMenu<String>(
+      child: Text(translate('Custom')),
+      value: kRemoteImageQualityCustom,
+      groupValue: groupValue,
+      onChanged: (value) {
+        onChanged(value);
+        customImageQualityDialog(id, ffi);
+      },
+    ),
+  ];
+}
+
+Future<List<TRadioMenu<String>>> toolbarCodec(
+    BuildContext context, String id, FFI ffi) async {
+  final alternativeCodecs = await bind.sessionAlternativeCodecs(id: id);
+  final groupValue =
+      await bind.sessionGetOption(id: id, arg: 'codec-preference') ?? '';
+  final List<bool> codecs = [];
+  try {
+    final Map codecsJson = jsonDecode(alternativeCodecs);
+    final vp8 = codecsJson['vp8'] ?? false;
+    final h264 = codecsJson['h264'] ?? false;
+    final h265 = codecsJson['h265'] ?? false;
+    codecs.add(vp8);
+    codecs.add(h264);
+    codecs.add(h265);
+  } catch (e) {
+    debugPrint("Show Codec Preference err=$e");
+  }
+  final visible = codecs.length == 3 && (codecs[0] || codecs[1] || codecs[2]);
+  if (!visible) return [];
+  onChanged(String? value) async {
+    if (value == null) return;
+    await bind.sessionPeerOption(
+        id: id, name: 'codec-preference', value: value);
+    bind.sessionChangePreferCodec(id: id);
+  }
+
+  TRadioMenu<String> radio(String label, String value, bool enabled) {
+    return TRadioMenu<String>(
+        child: Text(translate(label)),
+        value: value,
+        groupValue: groupValue,
+        onChanged: enabled ? onChanged : null);
+  }
+
+  return [
+    radio('Auto', 'auto', true),
+    if (isDesktop || codecs[0]) radio('VP8', 'vp8', codecs[0]),
+    radio('VP9', 'vp9', true),
+    if (isDesktop || codecs[1]) radio('H264', 'h264', codecs[1]),
+    if (isDesktop || codecs[2]) radio('H265', 'h265', codecs[2]),
+  ];
+}
+
+Future<List<TToggleMenu>> toolbarDisplayToggle(
+    BuildContext context, String id, FFI ffi) async {
+  List<TToggleMenu> v = [];
+  final ffiModel = ffi.ffiModel;
+  final pi = ffiModel.pi;
+  final perms = ffiModel.permissions;
+
+  // show remote cursor
+  if (pi.platform != kPeerPlatformAndroid &&
+      !ffi.canvasModel.cursorEmbedded &&
+      !pi.is_wayland) {
+    final state = ShowRemoteCursorState.find(id);
+    final enabled = !ffiModel.viewOnly;
+    final option = 'show-remote-cursor';
+    v.add(TToggleMenu(
+        child: Text(translate('Show remote cursor')),
+        value: state.value,
+        onChanged: enabled
+            ? (value) async {
+                if (value == null) return;
+                await bind.sessionToggleOption(id: id, value: option);
+                state.value =
+                    bind.sessionGetToggleOptionSync(id: id, arg: option);
+              }
+            : null));
+  }
+  // zoom cursor
+  final viewStyle = await bind.sessionGetViewStyle(id: id) ?? '';
+  if (!isMobile &&
+      pi.platform != kPeerPlatformAndroid &&
+      viewStyle != kRemoteViewStyleOriginal) {
+    final option = 'zoom-cursor';
+    final peerState = PeerBoolOption.find(id, option);
+    v.add(TToggleMenu(
+      child: Text(translate('Zoom cursor')),
+      value: peerState.value,
+      onChanged: (value) async {
+        if (value == null) return;
+        await bind.sessionToggleOption(id: id, value: option);
+        peerState.value = bind.sessionGetToggleOptionSync(id: id, arg: option);
+      },
+    ));
+  }
+  // show quality monitor
+  final option = 'show-quality-monitor';
+  v.add(TToggleMenu(
+      value: bind.sessionGetToggleOptionSync(id: id, arg: option),
+      onChanged: (value) async {
+        if (value == null) return;
+        await bind.sessionToggleOption(id: id, value: option);
+        ffi.qualityMonitorModel.checkShowQualityMonitor(id);
+      },
+      child: Text(translate('Show quality monitor'))));
+  // mute
+  if (perms['audio'] != false) {
+    final option = 'disable-audio';
+    final value = bind.sessionGetToggleOptionSync(id: id, arg: option);
+    v.add(TToggleMenu(
+        value: value,
+        onChanged: (value) {
+          if (value == null) return;
+          bind.sessionToggleOption(id: id, value: option);
+        },
+        child: Text(translate('Mute'))));
+  }
+  // file copy and paste
+  if (Platform.isWindows &&
+      pi.platform == kPeerPlatformWindows &&
+      perms['file'] != false) {
+    final option = 'enable-file-transfer';
+    final value = bind.sessionGetToggleOptionSync(id: id, arg: option);
+    v.add(TToggleMenu(
+        value: value,
+        onChanged: (value) {
+          if (value == null) return;
+          bind.sessionToggleOption(id: id, value: option);
+        },
+        child: Text(translate('Allow file copy and paste'))));
+  }
+  // disable clipboard
+  if (ffiModel.keyboard && perms['clipboard'] != false) {
+    final enabled = !ffiModel.viewOnly;
+    final option = 'disable-clipboard';
+    var value = bind.sessionGetToggleOptionSync(id: id, arg: option);
+    if (ffiModel.viewOnly) value = true;
+    v.add(TToggleMenu(
+        value: value,
+        onChanged: enabled
+            ? (value) {
+                if (value == null) return;
+                bind.sessionToggleOption(id: id, value: option);
+              }
+            : null,
+        child: Text(translate('Disable clipboard'))));
+  }
+  // lock after session end
+  if (ffiModel.keyboard) {
+    final option = 'lock-after-session-end';
+    final value = bind.sessionGetToggleOptionSync(id: id, arg: option);
+    v.add(TToggleMenu(
+        value: value,
+        onChanged: (value) {
+          if (value == null) return;
+          bind.sessionToggleOption(id: id, value: option);
+        },
+        child: Text(translate('Lock after session end'))));
+  }
+  // privacy mode
+  if (ffiModel.keyboard && pi.features.privacyMode) {
+    final option = 'privacy-mode';
+    final rxValue = PrivacyModeState.find(id);
+    v.add(TToggleMenu(
+        value: rxValue.value,
+        onChanged: (value) {
+          if (value == null) return;
+          if (ffiModel.pi.currentDisplay != 0) {
+            msgBox(id, 'custom-nook-nocancel-hasclose', 'info',
+                'Please switch to Display 1 first', '', ffi.dialogManager);
+            return;
+          }
+          bind.sessionToggleOption(id: id, value: option);
+        },
+        child: Text(translate('Privacy mode'))));
+  }
+  // swap key
+  if (ffiModel.keyboard &&
+      ((Platform.isMacOS && pi.platform != kPeerPlatformMacOS) ||
+          (!Platform.isMacOS && pi.platform == kPeerPlatformMacOS))) {
+    final option = 'allow_swap_key';
+    final value = bind.sessionGetToggleOptionSync(id: id, arg: option);
+    v.add(TToggleMenu(
+        value: value,
+        onChanged: (value) {
+          if (value == null) return;
+          bind.sessionToggleOption(id: id, value: option);
+        },
+        child: Text(translate('Swap control-command key'))));
+  }
+  return v;
+}