flutter_desktop: new remote menu, mid commit

Signed-off-by: fufesou <shuanglongchen@yeah.net>

flutter/lib/desktop/widgets/popup_menu.dart

@@ -0,0 +1,375 @@
+import 'dart:core';
+
+import 'package:flutter/material.dart';
+import 'package:get/get.dart';
+import 'package:tuple/tuple.dart';
+
+import './material_mod_popup_menu.dart' as modMenu;
+
+const kInvalidValueStr = "InvalidValueStr";
+
+// https://stackoverflow.com/questions/68318314/flutter-popup-menu-inside-popup-menu
+class PopupMenuChildrenItem<T> extends modMenu.PopupMenuEntry<T> {
+  const PopupMenuChildrenItem({
+    key,
+    this.height = kMinInteractiveDimension,
+    this.padding,
+    this.enable = true,
+    this.textStyle,
+    this.onTap,
+    this.position = modMenu.PopupMenuPosition.overSide,
+    this.offset = Offset.zero,
+    required this.itemBuilder,
+    required this.child,
+  }) : super(key: key);
+
+  final modMenu.PopupMenuPosition position;
+  final Offset offset;
+  final TextStyle? textStyle;
+  final EdgeInsets? padding;
+  final bool enable;
+  final void Function()? onTap;
+  final List<modMenu.PopupMenuEntry<T>> Function(BuildContext) itemBuilder;
+  final Widget child;
+
+  @override
+  final double height;
+
+  @override
+  bool represents(T? value) => false;
+
+  @override
+  MyPopupMenuItemState<T, PopupMenuChildrenItem<T>> createState() =>
+      MyPopupMenuItemState<T, PopupMenuChildrenItem<T>>();
+}
+
+class MyPopupMenuItemState<T, W extends PopupMenuChildrenItem<T>>
+    extends State<W> {
+  @protected
+  void handleTap(T value) {
+    widget.onTap?.call();
+    Navigator.pop<T>(context, value);
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final ThemeData theme = Theme.of(context);
+    final PopupMenuThemeData popupMenuTheme = PopupMenuTheme.of(context);
+    TextStyle style = widget.textStyle ??
+        popupMenuTheme.textStyle ??
+        theme.textTheme.subtitle1!;
+
+    return modMenu.PopupMenuButton<T>(
+      enabled: widget.enable,
+      position: widget.position,
+      offset: widget.offset,
+      onSelected: handleTap,
+      itemBuilder: widget.itemBuilder,
+      padding: EdgeInsets.zero,
+      child: AnimatedDefaultTextStyle(
+        style: style,
+        duration: kThemeChangeDuration,
+        child: Container(
+          alignment: AlignmentDirectional.centerStart,
+          constraints: BoxConstraints(minHeight: widget.height),
+          padding: widget.padding ?? const EdgeInsets.symmetric(horizontal: 16),
+          child: widget.child,
+        ),
+      ),
+    );
+  }
+}
+
+class MenuConfig {
+  // adapt to the screen height
+  static const fontSize = 14.0;
+  static const midPadding = 10.0;
+  static const iconScale = 0.8;
+  static const iconWidth = 12.0;
+  static const iconHeight = 12.0;
+
+  final double secondMenuHeight;
+  final Color commonColor;
+
+  const MenuConfig(
+      {required this.commonColor,
+      this.secondMenuHeight = kMinInteractiveDimension});
+}
+
+abstract class MenuEntryBase<T> {
+  modMenu.PopupMenuEntry<T> build(BuildContext context, MenuConfig conf);
+}
+
+class MenuEntryDivider<T> extends MenuEntryBase<T> {
+  @override
+  modMenu.PopupMenuEntry<T> build(BuildContext context, MenuConfig conf) {
+    return const modMenu.PopupMenuDivider();
+  }
+}
+
+typedef RadioOptionsGetter = List<Tuple2<String, String>> Function();
+typedef RadioCurOptionGetter = Future<String> Function();
+typedef RadioOptionSetter = Future<void> Function(String);
+
+class MenuEntrySubRadios<T> extends MenuEntryBase<T> {
+  final String text;
+  final RadioOptionsGetter optionsGetter;
+  final RadioCurOptionGetter curOptionGetter;
+  final RadioOptionSetter optionSetter;
+  final RxString _curOption = "".obs;
+
+  MenuEntrySubRadios(
+      {required this.text,
+      required this.optionsGetter,
+      required this.curOptionGetter,
+      required this.optionSetter}) {
+    () async {
+      _curOption.value = await curOptionGetter();
+    }();
+  }
+
+  List<Tuple2<String, String>> get options => optionsGetter();
+  RxString get curOption => _curOption;
+  setOption(String option) async {
+    await optionSetter(option);
+    final opt = await curOptionGetter();
+    if (_curOption.value != opt) {
+      _curOption.value = opt;
+    }
+  }
+
+  modMenu.PopupMenuEntry<T> _buildSecondMenu(
+      BuildContext context, MenuConfig conf, Tuple2<String, String> opt) {
+    return modMenu.PopupMenuItem(
+      padding: EdgeInsets.zero,
+      child: TextButton(
+        child: Container(
+          alignment: AlignmentDirectional.centerStart,
+          constraints: BoxConstraints(minHeight: conf.secondMenuHeight),
+          child: Row(
+            children: [
+              SizedBox(
+                  width: 20.0,
+                  height: 20.0,
+                  child: Obx(() => opt.item2 == curOption.value
+                      ? Icon(
+                          Icons.check,
+                          color: conf.commonColor,
+                        )
+                      : SizedBox.shrink())),
+              const SizedBox(width: MenuConfig.midPadding),
+              Text(
+                opt.item1,
+                style: const TextStyle(
+                    color: Colors.black,
+                    fontSize: MenuConfig.fontSize,
+                    fontWeight: FontWeight.normal),
+              )
+            ],
+          ),
+        ),
+        onPressed: () {
+          if (opt.item2 != curOption.value) {
+            setOption(opt.item2);
+          }
+        },
+      ),
+    );
+  }
+
+  @override
+  modMenu.PopupMenuEntry<T> build(BuildContext context, MenuConfig conf) {
+    return PopupMenuChildrenItem(
+      height: conf.secondMenuHeight,
+      padding: EdgeInsets.zero,
+      itemBuilder: (BuildContext context) =>
+          options.map((opt) => _buildSecondMenu(context, conf, opt)).toList(),
+      child: Row(children: [
+        const SizedBox(width: MenuConfig.midPadding),
+        Text(
+          text,
+          style: const TextStyle(
+              color: Colors.black,
+              fontSize: MenuConfig.fontSize,
+              fontWeight: FontWeight.normal),
+        ),
+        Expanded(
+            child: Align(
+          alignment: Alignment.centerRight,
+          child: Icon(
+            Icons.keyboard_arrow_right,
+            color: conf.commonColor,
+          ),
+        ))
+      ]),
+    );
+  }
+}
+
+typedef SwitchGetter = Future<bool> Function();
+typedef SwitchSetter = Future<void> Function(bool);
+
+abstract class MenuEntrySwitchBase<T> extends MenuEntryBase<T> {
+  final String text;
+
+  MenuEntrySwitchBase({required this.text});
+
+  RxBool get curOption;
+  Future<void> setOption(bool option);
+
+  @override
+  modMenu.PopupMenuEntry<T> build(BuildContext context, MenuConfig conf) {
+    return modMenu.PopupMenuItem(
+      padding: EdgeInsets.zero,
+      child: Obx(
+        () => SwitchListTile(
+          value: curOption.value,
+          onChanged: (v) {
+            setOption(v);
+          },
+          title: Container(
+              alignment: AlignmentDirectional.centerStart,
+              constraints: BoxConstraints(minHeight: conf.secondMenuHeight),
+              child: Text(
+                text,
+                style: const TextStyle(
+                    color: Colors.black,
+                    fontSize: MenuConfig.fontSize,
+                    fontWeight: FontWeight.normal),
+              )),
+          dense: true,
+          visualDensity: const VisualDensity(
+            horizontal: VisualDensity.minimumDensity,
+            vertical: VisualDensity.minimumDensity,
+          ),
+          contentPadding: EdgeInsets.only(left: 8.0),
+        ),
+      ),
+    );
+  }
+}
+
+class MenuEntrySwitch<T> extends MenuEntrySwitchBase<T> {
+  final SwitchGetter getter;
+  final SwitchSetter setter;
+  final RxBool _curOption = false.obs;
+
+  MenuEntrySwitch(
+      {required String text, required this.getter, required this.setter})
+      : super(text: text) {
+    () async {
+      _curOption.value = await getter();
+    }();
+  }
+
+  @override
+  RxBool get curOption => _curOption;
+  @override
+  setOption(bool option) async {
+    await setter(option);
+    final opt = await getter();
+    if (_curOption.value != opt) {
+      _curOption.value = opt;
+    }
+  }
+}
+
+typedef Switch2Getter = RxBool Function();
+typedef Switch2Setter = Future<void> Function(bool);
+
+class MenuEntrySwitch2<T> extends MenuEntrySwitchBase<T> {
+  final Switch2Getter getter;
+  final SwitchSetter setter;
+
+  MenuEntrySwitch2(
+      {required String text, required this.getter, required this.setter})
+      : super(text: text);
+
+  @override
+  RxBool get curOption => getter();
+  @override
+  setOption(bool option) async {
+    await setter(option);
+  }
+}
+
+class MenuEntrySubMenu<T> extends MenuEntryBase<T> {
+  final String text;
+  final List<MenuEntryBase<T>> entries;
+
+  MenuEntrySubMenu({
+    required this.text,
+    required this.entries,
+  });
+
+  @override
+  modMenu.PopupMenuEntry<T> build(BuildContext context, MenuConfig conf) {
+    return PopupMenuChildrenItem(
+      height: conf.secondMenuHeight,
+      padding: EdgeInsets.zero,
+      position: modMenu.PopupMenuPosition.overSide,
+      itemBuilder: (BuildContext context) =>
+          entries.map((entry) => entry.build(context, conf)).toList(),
+      child: Row(children: [
+        const SizedBox(width: MenuConfig.midPadding),
+        Text(
+          text,
+          style: const TextStyle(
+              color: Colors.black,
+              fontSize: MenuConfig.fontSize,
+              fontWeight: FontWeight.normal),
+        ),
+        Expanded(
+            child: Align(
+          alignment: Alignment.centerRight,
+          child: Icon(
+            Icons.keyboard_arrow_right,
+            color: conf.commonColor,
+          ),
+        ))
+      ]),
+    );
+  }
+}
+
+class MenuEntryButton<T> extends MenuEntryBase<T> {
+  final Widget Function(TextStyle? style) childBuilder;
+  Function() proc;
+
+  MenuEntryButton({
+    required this.childBuilder,
+    required this.proc,
+  });
+
+  @override
+  modMenu.PopupMenuEntry<T> build(BuildContext context, MenuConfig conf) {
+    return modMenu.PopupMenuItem(
+      padding: EdgeInsets.zero,
+      child: TextButton(
+        child: Container(
+            alignment: AlignmentDirectional.centerStart,
+            constraints: BoxConstraints(minHeight: conf.secondMenuHeight),
+            child: childBuilder(
+              const TextStyle(
+                  color: Colors.black,
+                  fontSize: MenuConfig.fontSize,
+                  fontWeight: FontWeight.normal),
+            )),
+        onPressed: () {
+          proc();
+        },
+      ),
+    );
+  }
+}
+
+class CustomMenu<T> {
+  final List<MenuEntryBase<T>> entries;
+  final MenuConfig conf;
+
+  const CustomMenu({required this.entries, required this.conf});
+
+  List<modMenu.PopupMenuEntry<T>> build(BuildContext context) {
+    return entries.map((entry) => entry.build(context, conf)).toList();
+  }
+}

flutter/lib/desktop/widgets/remote_menubar.dart

@@ -0,0 +1,560 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_hbb/models/chat_model.dart';
+import 'package:get/get.dart';
+import 'package:tuple/tuple.dart';
+
+import '../../common.dart';
+import '../../mobile/widgets/dialog.dart';
+import '../../mobile/widgets/overlay.dart';
+import '../../models/model.dart';
+import '../../models/platform_model.dart';
+import './popup_menu.dart';
+import './material_mod_popup_menu.dart' as modMenu;
+
+class _MenubarTheme {
+  static const Color commonColor = MyTheme.accent;
+  static const double height = kMinInteractiveDimension;
+}
+
+class RemoteMenubar extends StatefulWidget {
+  final String id;
+  final FFI ffi;
+
+  const RemoteMenubar({
+    Key? key,
+    required this.id,
+    required this.ffi,
+  }) : super(key: key);
+
+  @override
+  State<RemoteMenubar> createState() => _RemoteMenubarState();
+}
+
+class _RemoteMenubarState extends State<RemoteMenubar> {
+  final RxBool _show = false.obs;
+  final Rx<Color> _hideColor = Colors.white12.obs;
+
+  bool get isFullscreen => Get.find<RxBool>(tag: 'fullscreen').isTrue;
+  void setFullscreen(bool v) {
+    Get.find<RxBool>(tag: 'fullscreen').value = v;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Align(
+      alignment: Alignment.topCenter,
+      child: Obx(
+          () => _show.value ? _buildMenubar(context) : _buildShowHide(context)),
+    );
+  }
+
+  Widget _buildShowHide(BuildContext context) {
+    return SizedBox(
+        width: 100,
+        height: 5,
+        child: TextButton(
+            onHover: (bool v) {
+              _hideColor.value = v ? Colors.white60 : Colors.white24;
+            },
+            onPressed: () {
+              _show.value = !_show.value;
+            },
+            child: Obx(() => Container(
+                  color: _hideColor.value,
+                ))));
+  }
+
+  Widget _buildMenubar(BuildContext context) {
+    final List<Widget> menubarItems = [];
+    if (!isWebDesktop) {
+      menubarItems.add(_buildFullscreen(context));
+      if (widget.ffi.ffiModel.isPeerAndroid) {
+        menubarItems.add(IconButton(
+          tooltip: translate('Mobile Actions'),
+          color: _MenubarTheme.commonColor,
+          icon: Icon(Icons.build),
+          onPressed: () {
+            if (mobileActionsOverlayEntry == null) {
+              showMobileActionsOverlay();
+            } else {
+              hideMobileActionsOverlay();
+            }
+          },
+        ));
+      }
+    }
+    menubarItems.add(_buildMonitor(context));
+    menubarItems.add(_buildControl(context));
+    menubarItems.add(_buildDisplay(context));
+    if (!isWeb) {
+      menubarItems.add(_buildChat(context));
+    }
+    menubarItems.add(_buildClose(context));
+    return PopupMenuTheme(
+        data: PopupMenuThemeData(
+            textStyle: TextStyle(color: _MenubarTheme.commonColor)),
+        child: Column(mainAxisSize: MainAxisSize.min, children: [
+          Container(
+              color: Colors.white,
+              child: Row(
+                mainAxisSize: MainAxisSize.min,
+                children: menubarItems,
+              )),
+          _buildShowHide(context),
+        ]));
+  }
+
+  Widget _buildFullscreen(BuildContext context) {
+    return IconButton(
+      tooltip: translate(isFullscreen ? 'Exit Fullscreen' : 'Fullscreen'),
+      onPressed: () {
+        setFullscreen(!isFullscreen);
+      },
+      icon: Obx(() => isFullscreen
+          ? Icon(
+              Icons.fullscreen_exit,
+              color: _MenubarTheme.commonColor,
+            )
+          : Icon(
+              Icons.fullscreen,
+              color: _MenubarTheme.commonColor,
+            )),
+    );
+  }
+
+  Widget _buildChat(BuildContext context) {
+    return IconButton(
+      tooltip: translate('Chat'),
+      onPressed: () {
+        widget.ffi.chatModel.changeCurrentID(ChatModel.clientModeID);
+        widget.ffi.chatModel.toggleChatOverlay();
+      },
+      icon: Icon(
+        Icons.message,
+        color: _MenubarTheme.commonColor,
+      ),
+    );
+  }
+
+  Widget _buildMonitor(BuildContext context) {
+    final pi = widget.ffi.ffiModel.pi;
+    return modMenu.PopupMenuButton(
+      tooltip: translate('Select Monitor'),
+      padding: EdgeInsets.zero,
+      position: modMenu.PopupMenuPosition.under,
+      icon: Stack(
+        alignment: Alignment.center,
+        children: [
+          Icon(
+            Icons.personal_video,
+            color: _MenubarTheme.commonColor,
+          ),
+          Padding(
+            padding: EdgeInsets.only(bottom: 3.9),
+            child: Obx(() {
+              RxInt display = CurrentDisplayState.find(widget.id);
+              return Text(
+                "${display.value + 1}/${pi.displays.length}",
+                style: TextStyle(color: _MenubarTheme.commonColor, fontSize: 8),
+              );
+            }),
+          )
+        ],
+      ),
+      itemBuilder: (BuildContext context) {
+        final List<Widget> rowChildren = [];
+        final double selectorScale = 1.3;
+        for (int i = 0; i < pi.displays.length; i++) {
+          rowChildren.add(Transform.scale(
+            scale: selectorScale,
+            child: Stack(
+              alignment: Alignment.center,
+              children: [
+                Icon(
+                  Icons.personal_video,
+                  color: _MenubarTheme.commonColor,
+                ),
+                TextButton(
+                  child: Container(
+                      alignment: AlignmentDirectional.center,
+                      constraints:
+                          BoxConstraints(minHeight: _MenubarTheme.height),
+                      child: Padding(
+                        padding: EdgeInsets.only(bottom: 2.5),
+                        child: Text(
+                          (i + 1).toString(),
+                          style: TextStyle(color: _MenubarTheme.commonColor),
+                        ),
+                      )),
+                  onPressed: () {
+                    RxInt display = CurrentDisplayState.find(widget.id);
+                    if (display.value != i) {
+                      bind.sessionSwitchDisplay(id: widget.id, value: i);
+                      pi.currentDisplay = i;
+                      display.value = i;
+                    }
+                  },
+                )
+              ],
+            ),
+          ));
+        }
+        return <modMenu.PopupMenuEntry<String>>[
+          modMenu.PopupMenuItem<String>(
+            height: _MenubarTheme.height,
+            padding: EdgeInsets.zero,
+            child: Row(
+                mainAxisAlignment: MainAxisAlignment.center,
+                children: rowChildren),
+          )
+        ];
+      },
+    );
+  }
+
+  Widget _buildControl(BuildContext context) {
+    return modMenu.PopupMenuButton(
+      padding: EdgeInsets.zero,
+      icon: Icon(
+        Icons.bolt,
+        color: _MenubarTheme.commonColor,
+      ),
+      tooltip: translate('Control Actions'),
+      position: modMenu.PopupMenuPosition.under,
+      itemBuilder: (BuildContext context) => _getControlMenu()
+          .map((entry) => entry.build(
+              context,
+              MenuConfig(
+                commonColor: _MenubarTheme.commonColor,
+                secondMenuHeight: _MenubarTheme.height,
+              )))
+          .toList(),
+    );
+  }
+
+  Widget _buildDisplay(BuildContext context) {
+    return modMenu.PopupMenuButton(
+      padding: EdgeInsets.zero,
+      icon: Icon(
+        Icons.tv,
+        color: _MenubarTheme.commonColor,
+      ),
+      tooltip: translate('Display Settings'),
+      position: modMenu.PopupMenuPosition.under,
+      onSelected: (String item) {},
+      itemBuilder: (BuildContext context) => _getDisplayMenu()
+          .map((entry) => entry.build(
+              context,
+              MenuConfig(
+                commonColor: _MenubarTheme.commonColor,
+                secondMenuHeight: _MenubarTheme.height,
+              )))
+          .toList(),
+    );
+  }
+
+  Widget _buildClose(BuildContext context) {
+    return IconButton(
+      tooltip: translate('Close'),
+      onPressed: () {
+        clientClose(widget.ffi.dialogManager);
+      },
+      icon: Icon(
+        Icons.close,
+        color: _MenubarTheme.commonColor,
+      ),
+    );
+  }
+
+  List<MenuEntryBase<String>> _getControlMenu() {
+    final pi = widget.ffi.ffiModel.pi;
+    final perms = widget.ffi.ffiModel.permissions;
+
+    final List<MenuEntryBase<String>> displayMenu = [];
+
+    if (pi.version.isNotEmpty) {
+      displayMenu.add(MenuEntryButton<String>(
+        childBuilder: (TextStyle? style) => Text(
+          translate('Refresh'),
+          style: style,
+        ),
+        proc: () {
+          Navigator.pop(context);
+          bind.sessionRefresh(id: widget.id);
+        },
+      ));
+    }
+    displayMenu.add(MenuEntryButton<String>(
+      childBuilder: (TextStyle? style) => Text(
+        translate('OS Password'),
+        style: style,
+      ),
+      proc: () {
+        Navigator.pop(context);
+        showSetOSPassword(widget.id, false, widget.ffi.dialogManager);
+      },
+    ));
+
+    if (!isWebDesktop) {
+      if (perms['keyboard'] != false && perms['clipboard'] != false) {
+        displayMenu.add(MenuEntryButton<String>(
+          childBuilder: (TextStyle? style) => Text(
+            translate('Paste'),
+            style: style,
+          ),
+          proc: () {
+            Navigator.pop(context);
+            () async {
+              ClipboardData? data =
+                  await Clipboard.getData(Clipboard.kTextPlain);
+              if (data != null && data.text != null) {
+                bind.sessionInputString(id: widget.id, value: data.text ?? "");
+              }
+            }();
+          },
+        ));
+      }
+
+      displayMenu.add(MenuEntryButton<String>(
+        childBuilder: (TextStyle? style) => Text(
+          translate('Reset canvas'),
+          style: style,
+        ),
+        proc: () {
+          Navigator.pop(context);
+          widget.ffi.cursorModel.reset();
+        },
+      ));
+    }
+
+    if (perms['keyboard'] != false) {
+      if (pi.platform == 'Linux' || pi.sasEnabled) {
+        displayMenu.add(MenuEntryButton<String>(
+          childBuilder: (TextStyle? style) => Text(
+            translate('Insert') + ' Ctrl + Alt + Del',
+            style: style,
+          ),
+          proc: () {
+            Navigator.pop(context);
+            bind.sessionCtrlAltDel(id: widget.id);
+          },
+        ));
+      }
+
+      displayMenu.add(MenuEntryButton<String>(
+        childBuilder: (TextStyle? style) => Text(
+          translate('Insert Lock'),
+          style: style,
+        ),
+        proc: () {
+          Navigator.pop(context);
+          bind.sessionLockScreen(id: widget.id);
+        },
+      ));
+
+      if (pi.platform == 'Windows') {
+        displayMenu.add(MenuEntryButton<String>(
+          childBuilder: (TextStyle? style) => Obx(() => Text(
+                translate(
+                    (BlockInputState.find(widget.id).value ? 'Unb' : 'B') +
+                        'lock user input'),
+                style: style,
+              )),
+          proc: () {
+            Navigator.pop(context);
+            RxBool blockInput = BlockInputState.find(widget.id);
+            bind.sessionToggleOption(
+                id: widget.id,
+                value: (blockInput.value ? 'un' : '') + 'block-input');
+            blockInput.value = !blockInput.value;
+          },
+        ));
+      }
+    }
+
+    if (gFFI.ffiModel.permissions["restart"] != false &&
+        (pi.platform == "Linux" ||
+            pi.platform == "Windows" ||
+            pi.platform == "Mac OS")) {
+      displayMenu.add(MenuEntryButton<String>(
+        childBuilder: (TextStyle? style) => Text(
+          translate('Restart Remote Device'),
+          style: style,
+        ),
+        proc: () {
+          Navigator.pop(context);
+          showRestartRemoteDevice(pi, widget.id, gFFI.dialogManager);
+        },
+      ));
+    }
+
+    return displayMenu;
+  }
+
+  List<MenuEntryBase<String>> _getDisplayMenu() {
+    final displayMenu = [
+      MenuEntrySubRadios<String>(
+          text: translate('Ratio'),
+          optionsGetter: () => [
+                Tuple2<String, String>(translate('Original'), 'original'),
+                Tuple2<String, String>(translate('Shrink'), 'shrink'),
+                Tuple2<String, String>(translate('Stretch'), 'stretch'),
+              ],
+          curOptionGetter: () async {
+            return await bind.sessionGetOption(
+                    id: widget.id, arg: 'view-style') ??
+                '';
+          },
+          optionSetter: (String v) async {
+            await bind.sessionPeerOption(
+                id: widget.id, name: "view-style", value: v);
+            widget.ffi.canvasModel.updateViewStyle();
+          }),
+      MenuEntrySubRadios<String>(
+          text: translate('Scroll Style'),
+          optionsGetter: () => [
+                Tuple2<String, String>(translate('ScrollAuto'), 'scrollauto'),
+                Tuple2<String, String>(translate('Scrollbar'), 'scrollbar'),
+              ],
+          curOptionGetter: () async {
+            return await bind.sessionGetOption(
+                    id: widget.id, arg: 'scroll-style') ??
+                '';
+          },
+          optionSetter: (String v) async {
+            await bind.sessionPeerOption(
+                id: widget.id, name: "scroll-style", value: v);
+            widget.ffi.canvasModel.updateScrollStyle();
+          }),
+      MenuEntrySubRadios<String>(
+          text: translate('Image Quality'),
+          optionsGetter: () => [
+                Tuple2<String, String>(translate('Good image quality'), 'best'),
+                Tuple2<String, String>(translate('Balanced'), 'balanced'),
+                Tuple2<String, String>(
+                    translate('Optimize reaction time'), 'low'),
+              ],
+          curOptionGetter: () async {
+            String quality =
+                await bind.sessionGetImageQuality(id: widget.id) ?? 'balanced';
+            if (quality == '') quality = 'balanced';
+            return quality;
+          },
+          optionSetter: (String v) async {
+            await bind.sessionSetImageQuality(id: widget.id, value: v);
+          }),
+      MenuEntrySwitch<String>(
+          text: translate('Show remote cursor'),
+          getter: () async {
+            return await bind.sessionGetToggleOptionSync(
+                id: widget.id, arg: 'show-remote-cursor');
+          },
+          setter: (bool v) async {
+            await bind.sessionToggleOption(
+                id: widget.id, value: 'show-remote-cursor');
+          }),
+      MenuEntrySwitch<String>(
+          text: translate('Show quality monitor'),
+          getter: () async {
+            return await bind.sessionGetToggleOptionSync(
+                id: widget.id, arg: 'show-quality-monitor');
+          },
+          setter: (bool v) async {
+            await bind.sessionToggleOption(
+                id: widget.id, value: 'show-quality-monitor');
+            widget.ffi.qualityMonitorModel.checkShowQualityMonitor(widget.id);
+          }),
+    ];
+
+    final perms = widget.ffi.ffiModel.permissions;
+    final pi = widget.ffi.ffiModel.pi;
+
+    if (perms['audio'] != false) {
+      displayMenu.add(_createSwitchMenuEntry('Mute', 'disable-audio'));
+    }
+    if (perms['keyboard'] != false) {
+      if (perms['clipboard'] != false) {
+        displayMenu.add(
+            _createSwitchMenuEntry('Disable clipboard', 'disable-clipboard'));
+      }
+      displayMenu.add(_createSwitchMenuEntry(
+          'Lock after session end', 'lock-after-session-end'));
+      if (pi.platform == 'Windows') {
+        displayMenu.add(MenuEntrySwitch2<String>(
+            text: translate('Privacy mode'),
+            getter: () {
+              return PrivacyModeState.find(widget.id);
+            },
+            setter: (bool v) async {
+              Navigator.pop(context);
+              await bind.sessionToggleOption(
+                  id: widget.id, value: 'privacy-mode');
+            }));
+      }
+    }
+    return displayMenu;
+  }
+
+  MenuEntrySwitch<String> _createSwitchMenuEntry(String text, String option) {
+    return MenuEntrySwitch<String>(
+        text: translate(text),
+        getter: () async {
+          return bind.sessionGetToggleOptionSync(id: widget.id, arg: option);
+        },
+        setter: (bool v) async {
+          await bind.sessionToggleOption(id: widget.id, value: option);
+        });
+  }
+}
+
+void showSetOSPassword(
+    String id, bool login, OverlayDialogManager dialogManager) async {
+  final controller = TextEditingController();
+  var password = await bind.sessionGetOption(id: id, arg: "os-password") ?? "";
+  var autoLogin = await bind.sessionGetOption(id: id, arg: "auto-login") != "";
+  controller.text = password;
+  dialogManager.show((setState, close) {
+    return CustomAlertDialog(
+        title: Text(translate('OS Password')),
+        content: Column(mainAxisSize: MainAxisSize.min, children: [
+          PasswordWidget(controller: controller),
+          CheckboxListTile(
+            contentPadding: const EdgeInsets.all(0),
+            dense: true,
+            controlAffinity: ListTileControlAffinity.leading,
+            title: Text(
+              translate('Auto Login'),
+            ),
+            value: autoLogin,
+            onChanged: (v) {
+              if (v == null) return;
+              setState(() => autoLogin = v);
+            },
+          ),
+        ]),
+        actions: [
+          TextButton(
+            style: flatButtonStyle,
+            onPressed: () {
+              close();
+            },
+            child: Text(translate('Cancel')),
+          ),
+          TextButton(
+            style: flatButtonStyle,
+            onPressed: () {
+              var text = controller.text.trim();
+              bind.sessionPeerOption(id: id, name: "os-password", value: text);
+              bind.sessionPeerOption(
+                  id: id, name: "auto-login", value: autoLogin ? 'Y' : '');
+              if (text != "" && login) {
+                bind.sessionInputOsPassword(id: id, value: text);
+              }
+              close();
+            },
+            child: Text(translate('OK')),
+          ),
+        ]);
+  });
+}