rustdesk/flutter/lib/mobile/pages/remote_page.dart

1403 lines
45 KiB
Dart
Raw Normal View History

import 'dart:async';
import 'dart:ui' as ui;
2022-04-25 18:25:25 +08:00
import 'package:flutter/gestures.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
2022-05-24 23:33:00 +08:00
import 'package:flutter_hbb/mobile/widgets/gesture_help.dart';
import 'package:flutter_hbb/models/chat_model.dart';
2020-11-18 23:15:59 +08:00
import 'package:provider/provider.dart';
2020-11-23 13:03:51 +08:00
import 'package:wakelock/wakelock.dart';
2022-05-24 23:33:00 +08:00
import '../../common.dart';
import '../../models/model.dart';
2022-08-05 20:29:43 +08:00
import '../../models/platform_model.dart';
2022-03-07 22:54:34 +08:00
import '../widgets/dialog.dart';
import '../widgets/gestures.dart';
2020-11-28 18:06:27 +08:00
final initText = '\1' * 1024;
class RemotePage extends StatefulWidget {
2022-02-17 15:22:14 +08:00
RemotePage({Key? key, required this.id}) : super(key: key);
final String id;
@override
_RemotePageState createState() => _RemotePageState();
}
class _RemotePageState extends State<RemotePage> {
2022-02-17 15:22:14 +08:00
Timer? _interval;
Timer? _timer;
2022-05-23 16:02:37 +08:00
bool _showBar = !isWebDesktop;
double _bottom = 0;
2020-11-25 16:28:46 +08:00
String _value = '';
2020-11-23 23:18:42 +08:00
double _scale = 1;
2022-05-12 20:05:59 +08:00
double _mouseScrollIntegral = 0; // mouse scroll speed controller
2022-06-02 17:16:23 +08:00
Orientation? _currentOrientation;
var _more = true;
2020-11-25 16:28:46 +08:00
var _fn = false;
2022-04-25 18:25:25 +08:00
final FocusNode _mobileFocusNode = FocusNode();
final FocusNode _physicalFocusNode = FocusNode();
var _showEdit = false; // use soft keyboard
var _isPhysicalMouse = false;
2020-11-17 11:12:55 +08:00
@override
void initState() {
super.initState();
gFFI.connect(widget.id);
2022-05-26 18:25:16 +08:00
WidgetsBinding.instance.addPostFrameCallback((_) {
2022-02-24 18:24:52 +08:00
SystemChrome.setEnabledSystemUIMode(SystemUiMode.manual, overlays: []);
2022-08-12 18:42:02 +08:00
gFFI.dialogManager
.showLoading(translate('Connecting...'), onCancel: closeConnection);
_interval =
Timer.periodic(Duration(milliseconds: 30), (timer) => interval());
});
2020-11-23 12:00:56 +08:00
Wakelock.enable();
2022-04-25 18:25:25 +08:00
_physicalFocusNode.requestFocus();
gFFI.ffiModel.updateEventListener(widget.id);
gFFI.listenToMouse(true);
gFFI.qualityMonitorModel.checkShowQualityMonitor(widget.id);
}
@override
void dispose() {
gFFI.dialogManager.hideMobileActionsOverlay();
gFFI.listenToMouse(false);
gFFI.invokeMethod("enable_soft_keyboard", true);
2022-04-25 18:25:25 +08:00
_mobileFocusNode.dispose();
_physicalFocusNode.dispose();
gFFI.close();
2022-02-17 15:22:14 +08:00
_interval?.cancel();
2020-11-27 16:06:35 +08:00
_timer?.cancel();
2022-08-12 18:42:02 +08:00
gFFI.dialogManager.dismissAll();
2022-02-24 18:24:52 +08:00
SystemChrome.setEnabledSystemUIMode(SystemUiMode.manual,
overlays: SystemUiOverlay.values);
2020-11-23 12:00:56 +08:00
Wakelock.disable();
2021-08-18 02:01:03 +08:00
super.dispose();
}
2020-11-25 16:28:46 +08:00
void resetTool() {
gFFI.resetModifiers();
2020-11-25 16:28:46 +08:00
}
bool isKeyboardShown() {
return _bottom >= 100;
}
2022-02-24 18:24:52 +08:00
// crash on web before widget initiated.
2022-01-26 19:00:23 +08:00
void intervalUnsafe() {
var v = MediaQuery.of(context).viewInsets.bottom;
if (v != _bottom) {
2020-11-25 16:28:46 +08:00
resetTool();
setState(() {
_bottom = v;
2020-11-25 16:28:46 +08:00
if (v < 100) {
2022-02-24 18:24:52 +08:00
SystemChrome.setEnabledSystemUIMode(SystemUiMode.manual,
overlays: []);
2022-08-11 10:19:12 +08:00
// [pi.version.isNotEmpty] -> check ready or not, avoid login without soft-keyboard
if (gFFI.chatModel.chatWindowOverlayEntry == null &&
gFFI.ffiModel.pi.version.isNotEmpty) {
gFFI.invokeMethod("enable_soft_keyboard", false);
}
}
});
}
2020-11-19 21:59:49 +08:00
}
2022-01-26 19:00:23 +08:00
void interval() {
try {
intervalUnsafe();
} catch (e) {}
}
2022-04-25 18:25:25 +08:00
// handle mobile virtual keyboard
2020-11-28 18:06:27 +08:00
void handleInput(String newValue) {
2021-08-17 22:57:35 +08:00
var oldValue = _value;
_value = newValue;
2022-01-25 18:13:11 +08:00
if (isIOS) {
2021-08-17 22:57:35 +08:00
var i = newValue.length - 1;
for (; i >= 0 && newValue[i] != '\1'; --i) {}
var j = oldValue.length - 1;
for (; j >= 0 && oldValue[j] != '\1'; --j) {}
if (i < j) j = i;
newValue = newValue.substring(j + 1);
oldValue = oldValue.substring(j + 1);
var common = 0;
for (;
common < oldValue.length &&
common < newValue.length &&
newValue[common] == oldValue[common];
++common) {}
2021-08-17 22:57:35 +08:00
for (i = 0; i < oldValue.length - common; ++i) {
gFFI.inputKey('VK_BACK');
2021-08-17 22:57:35 +08:00
}
if (newValue.length > common) {
var s = newValue.substring(common);
if (s.length > 1) {
2022-08-05 20:29:43 +08:00
bind.sessionInputString(id: widget.id, value: s);
2021-08-17 22:57:35 +08:00
} else {
inputChar(s);
}
}
return;
}
if (oldValue.length > 0 &&
newValue.length > 0 &&
oldValue[0] == '\1' &&
newValue[0] != '\1') {
2020-11-28 18:06:27 +08:00
// clipboard
2021-08-17 22:57:35 +08:00
oldValue = '';
2020-11-28 18:06:27 +08:00
}
if (newValue.length == oldValue.length) {
// ?
} else if (newValue.length < oldValue.length) {
2020-11-28 18:06:27 +08:00
final char = 'VK_BACK';
gFFI.inputKey(char);
2020-11-28 18:06:27 +08:00
} else {
2021-08-17 22:57:35 +08:00
final content = newValue.substring(oldValue.length);
2020-11-28 18:06:27 +08:00
if (content.length > 1) {
2021-08-17 22:57:35 +08:00
if (oldValue != '' &&
2020-12-22 16:00:10 +08:00
content.length == 2 &&
(content == '""' ||
content == '()' ||
content == '[]' ||
content == '<>' ||
content == "{}" ||
content == '”“' ||
content == '《》' ||
content == '' ||
content == '【】')) {
2020-12-22 16:07:48 +08:00
// can not only input content[0], because when input ], [ are also auo insert, which cause ] never be input
2022-08-05 20:29:43 +08:00
bind.sessionInputString(id: widget.id, value: content);
2020-12-22 16:00:10 +08:00
openKeyboard();
return;
}
2022-08-05 20:29:43 +08:00
bind.sessionInputString(id: widget.id, value: content);
2020-11-28 18:06:27 +08:00
} else {
2021-08-17 22:57:35 +08:00
inputChar(content);
2020-11-28 18:06:27 +08:00
}
}
2021-08-17 22:57:35 +08:00
}
void inputChar(String char) {
if (char == '\n') {
char = 'VK_RETURN';
} else if (char == ' ') {
char = 'VK_SPACE';
}
gFFI.inputKey(char);
2020-11-28 18:06:27 +08:00
}
void openKeyboard() {
gFFI.invokeMethod("enable_soft_keyboard", true);
2020-11-28 18:06:27 +08:00
// destroy first, so that our _value trick can work
2020-12-22 15:26:35 +08:00
_value = initText;
setState(() => _showEdit = false);
2020-11-28 18:06:27 +08:00
_timer?.cancel();
_timer = Timer(Duration(milliseconds: 30), () {
// show now, and sleep a while to requestFocus to
// make sure edit ready, so that keyboard wont show/hide/show/hide happen
setState(() => _showEdit = true);
2020-11-28 18:06:27 +08:00
_timer?.cancel();
_timer = Timer(Duration(milliseconds: 30), () {
2022-02-24 18:24:52 +08:00
SystemChrome.setEnabledSystemUIMode(SystemUiMode.manual,
overlays: SystemUiOverlay.values);
2022-04-25 18:25:25 +08:00
_mobileFocusNode.requestFocus();
2020-11-28 18:06:27 +08:00
});
});
}
2022-05-07 18:04:00 +08:00
void sendRawKey(RawKeyEvent e, {bool? down, bool? press}) {
// for maximum compatibility
final label = _logicalKeyMap[e.logicalKey.keyId] ??
_physicalKeyMap[e.physicalKey.usbHidUsage] ??
e.logicalKey.keyLabel;
gFFI.inputKey(label, down: down, press: press ?? false);
2022-04-25 18:25:25 +08:00
}
@override
Widget build(BuildContext context) {
2020-11-29 14:28:07 +08:00
final pi = Provider.of<FfiModel>(context).pi;
final hideKeyboard = isKeyboardShown() && _showEdit;
2021-08-17 15:07:01 +08:00
final showActionButton = !_showBar || hideKeyboard;
final keyboard = gFFI.ffiModel.permissions['keyboard'] != false;
2020-11-22 18:29:04 +08:00
return WillPopScope(
onWillPop: () async {
2022-08-12 18:42:02 +08:00
clientClose(gFFI.dialogManager);
return false;
},
child: getRawPointerAndKeyBody(
keyboard,
Scaffold(
// resizeToAvoidBottomInset: true,
floatingActionButton: !showActionButton
? null
: FloatingActionButton(
mini: !hideKeyboard,
child: Icon(
hideKeyboard ? Icons.expand_more : Icons.expand_less),
backgroundColor: MyTheme.accent,
onPressed: () {
setState(() {
if (hideKeyboard) {
_showEdit = false;
gFFI.invokeMethod("enable_soft_keyboard", false);
_mobileFocusNode.unfocus();
_physicalFocusNode.requestFocus();
} else {
_showBar = !_showBar;
}
});
}),
bottomNavigationBar: _showBar && pi.displays.length > 0
? getBottomAppBar(keyboard)
: null,
body: Overlay(
initialEntries: [
OverlayEntry(builder: (context) {
return Container(
color: Colors.black,
2022-05-23 16:02:37 +08:00
child: isWebDesktop
? getBodyForDesktopWithListener(keyboard)
2022-06-02 17:16:23 +08:00
: SafeArea(child:
OrientationBuilder(builder: (ctx, orientation) {
2022-06-02 17:16:23 +08:00
if (_currentOrientation != orientation) {
Timer(const Duration(milliseconds: 200), () {
gFFI.dialogManager
.resetMobileActionsOverlay(ffi: gFFI);
2022-06-02 17:16:23 +08:00
_currentOrientation = orientation;
gFFI.canvasModel.updateViewStyle();
2022-06-02 17:16:23 +08:00
});
}
return Container(
color: MyTheme.canvasColor,
child: _isPhysicalMouse
? getBodyForMobile()
: getBodyForMobileWithGesture());
2022-06-02 17:16:23 +08:00
})));
})
],
))),
);
2020-11-20 16:37:48 +08:00
}
Widget getRawPointerAndKeyBody(bool keyboard, Widget child) {
2022-04-25 18:25:25 +08:00
return Listener(
onPointerHover: (e) {
if (e.kind != ui.PointerDeviceKind.mouse) return;
if (!_isPhysicalMouse) {
2022-04-25 18:25:25 +08:00
setState(() {
_isPhysicalMouse = true;
2022-04-25 18:25:25 +08:00
});
}
if (_isPhysicalMouse) {
gFFI.handleMouse(getEvent(e, 'mousemove'));
2022-04-25 18:25:25 +08:00
}
},
onPointerDown: (e) {
if (e.kind != ui.PointerDeviceKind.mouse) {
if (_isPhysicalMouse) {
2022-04-25 18:25:25 +08:00
setState(() {
_isPhysicalMouse = false;
2022-04-25 18:25:25 +08:00
});
}
}
if (_isPhysicalMouse) {
gFFI.handleMouse(getEvent(e, 'mousedown'));
2022-04-25 18:25:25 +08:00
}
},
onPointerUp: (e) {
if (e.kind != ui.PointerDeviceKind.mouse) return;
if (_isPhysicalMouse) {
gFFI.handleMouse(getEvent(e, 'mouseup'));
2022-04-25 18:25:25 +08:00
}
},
onPointerMove: (e) {
if (e.kind != ui.PointerDeviceKind.mouse) return;
if (_isPhysicalMouse) {
gFFI.handleMouse(getEvent(e, 'mousemove'));
2022-04-25 18:25:25 +08:00
}
},
onPointerSignal: (e) {
if (e is PointerScrollEvent) {
var dx = e.scrollDelta.dx;
var dy = e.scrollDelta.dy;
if (dx > 0)
dx = -1;
else if (dx < 0) dx = 1;
if (dy > 0)
dy = -1;
else if (dy < 0) dy = 1;
bind.sessionSendMouse(
id: widget.id,
msg: '{"type": "wheel", "x": "$dx", "y": "$dy"}');
2022-04-25 18:25:25 +08:00
}
},
child: MouseRegion(
cursor: keyboard ? SystemMouseCursors.none : MouseCursor.defer,
child: FocusScope(
autofocus: true,
child: Focus(
autofocus: true,
canRequestFocus: true,
focusNode: _physicalFocusNode,
onKey: (data, e) {
final key = e.logicalKey;
if (e is RawKeyDownEvent) {
if (e.repeat &&
!e.isAltPressed &&
!e.isControlPressed &&
!e.isShiftPressed &&
!e.isMetaPressed) {
2022-05-07 18:04:00 +08:00
sendRawKey(e, press: true);
} else {
sendRawKey(e, down: true);
if (e.isAltPressed && !gFFI.alt) {
gFFI.alt = true;
} else if (e.isControlPressed && !gFFI.ctrl) {
gFFI.ctrl = true;
} else if (e.isShiftPressed && !gFFI.shift) {
gFFI.shift = true;
} else if (e.isMetaPressed && !gFFI.command) {
gFFI.command = true;
2022-05-07 18:04:00 +08:00
}
2022-04-25 18:25:25 +08:00
}
}
// [!_showEdit] workaround for soft-keyboard's control_key like Backspace / Enter
if (!_showEdit && e is RawKeyUpEvent) {
2022-04-25 18:25:25 +08:00
if (key == LogicalKeyboardKey.altLeft ||
key == LogicalKeyboardKey.altRight) {
gFFI.alt = false;
2022-05-07 18:04:00 +08:00
} else if (key == LogicalKeyboardKey.controlLeft ||
2022-04-25 18:25:25 +08:00
key == LogicalKeyboardKey.controlRight) {
gFFI.ctrl = false;
2022-05-07 18:04:00 +08:00
} else if (key == LogicalKeyboardKey.shiftRight ||
2022-04-25 18:25:25 +08:00
key == LogicalKeyboardKey.shiftLeft) {
gFFI.shift = false;
2022-05-07 18:04:00 +08:00
} else if (key == LogicalKeyboardKey.metaLeft ||
2022-04-25 18:25:25 +08:00
key == LogicalKeyboardKey.metaRight) {
gFFI.command = false;
2022-04-25 18:25:25 +08:00
}
sendRawKey(e);
}
return KeyEventResult.handled;
},
child: child))));
2022-04-25 18:25:25 +08:00
}
Widget getBottomAppBar(bool keyboard) {
2022-02-02 01:20:14 +08:00
return BottomAppBar(
elevation: 10,
color: MyTheme.accent,
child: Row(
mainAxisSize: MainAxisSize.max,
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: <Widget>[
Row(
children: <Widget>[
IconButton(
color: Colors.white,
icon: Icon(Icons.clear),
onPressed: () {
2022-08-12 18:42:02 +08:00
clientClose(gFFI.dialogManager);
},
)
] +
2022-02-02 01:20:14 +08:00
<Widget>[
IconButton(
color: Colors.white,
icon: Icon(Icons.tv),
onPressed: () {
setState(() => _showEdit = false);
2022-08-12 18:42:02 +08:00
showOptions(widget.id, gFFI.dialogManager);
2022-02-02 01:20:14 +08:00
},
)
] +
2022-05-23 16:02:37 +08:00
(isWebDesktop
2022-02-02 01:20:14 +08:00
? []
: gFFI.ffiModel.isPeerAndroid
? [
IconButton(
color: Colors.white,
icon: const Icon(Icons.build),
onPressed: () => gFFI.dialogManager
.toggleMobileActionsOverlay(ffi: gFFI),
)
]
: [
IconButton(
color: Colors.white,
icon: Icon(Icons.keyboard),
onPressed: openKeyboard),
IconButton(
color: Colors.white,
icon: Icon(gFFI.ffiModel.touchMode
? Icons.touch_app
: Icons.mouse),
onPressed: changeTouchMode,
),
]) +
2022-03-28 00:36:53 +08:00
(isWeb
? []
: <Widget>[
IconButton(
color: Colors.white,
icon: Icon(Icons.message),
onPressed: () {
gFFI.chatModel
.changeCurrentID(ChatModel.clientModeID);
2022-08-11 10:19:12 +08:00
gFFI.chatModel.toggleChatOverlay();
},
)
]) +
2022-03-28 00:36:53 +08:00
[
2022-02-02 01:20:14 +08:00
IconButton(
color: Colors.white,
icon: Icon(Icons.more_vert),
onPressed: () {
setState(() => _showEdit = false);
2022-08-05 20:29:43 +08:00
showActions(widget.id);
2022-02-02 01:20:14 +08:00
},
),
]),
IconButton(
color: Colors.white,
icon: Icon(Icons.expand_more),
onPressed: () {
setState(() => _showBar = !_showBar);
}),
],
),
);
}
/// touchMode only:
/// LongPress -> right click
/// OneFingerPan -> start/end -> left down start/end
/// onDoubleTapDown -> move to
/// onLongPressDown => move to
///
/// mouseMode only:
/// DoubleFiner -> right click
/// HoldDrag -> left drag
Offset _cacheLongPressPosition = Offset(0, 0);
2022-02-16 23:08:23 +08:00
Widget getBodyForMobileWithGesture() {
final touchMode = gFFI.ffiModel.touchMode;
2022-02-16 23:08:23 +08:00
return getMixinGestureDetector(
child: getBodyForMobile(),
onTapUp: (d) {
if (touchMode) {
gFFI.cursorModel.touch(
d.localPosition.dx, d.localPosition.dy, MouseButtons.left);
2022-02-16 23:08:23 +08:00
} else {
gFFI.tap(MouseButtons.left);
}
},
2022-02-23 21:32:33 +08:00
onDoubleTapDown: (d) {
if (touchMode) {
gFFI.cursorModel.move(d.localPosition.dx, d.localPosition.dy);
2022-02-16 23:08:23 +08:00
}
},
onDoubleTap: () {
gFFI.tap(MouseButtons.left);
gFFI.tap(MouseButtons.left);
},
2022-02-23 21:32:33 +08:00
onLongPressDown: (d) {
if (touchMode) {
gFFI.cursorModel.move(d.localPosition.dx, d.localPosition.dy);
_cacheLongPressPosition = d.localPosition;
}
},
onLongPress: () {
if (touchMode) {
2022-08-01 14:33:08 +08:00
gFFI.cursorModel
.move(_cacheLongPressPosition.dx, _cacheLongPressPosition.dy);
}
2022-08-01 14:33:08 +08:00
gFFI.tap(MouseButtons.right);
2022-02-16 23:08:23 +08:00
},
onDoubleFinerTap: (d) {
if (!touchMode) {
gFFI.tap(MouseButtons.right);
}
2022-02-16 23:08:23 +08:00
},
onHoldDragStart: (d) {
if (!touchMode) {
gFFI.sendMouse('down', MouseButtons.left);
}
2022-02-16 23:08:23 +08:00
},
onHoldDragUpdate: (d) {
if (!touchMode) {
gFFI.cursorModel.updatePan(d.delta.dx, d.delta.dy, touchMode);
}
2022-02-16 23:08:23 +08:00
},
onHoldDragEnd: (_) {
if (!touchMode) {
gFFI.sendMouse('up', MouseButtons.left);
}
2022-02-16 23:08:23 +08:00
},
onOneFingerPanStart: (d) {
if (touchMode) {
gFFI.cursorModel.move(d.localPosition.dx, d.localPosition.dy);
gFFI.sendMouse('down', MouseButtons.left);
} else {
2022-08-01 14:33:08 +08:00
final cursorX = gFFI.cursorModel.x;
final cursorY = gFFI.cursorModel.y;
final visible =
2022-08-01 14:33:08 +08:00
gFFI.cursorModel.getVisibleRect().inflate(1); // extend edges
final size = MediaQueryData.fromWindow(ui.window).size;
if (!visible.contains(Offset(cursorX, cursorY))) {
2022-08-01 14:33:08 +08:00
gFFI.cursorModel.move(size.width / 2, size.height / 2);
}
}
2022-02-16 23:08:23 +08:00
},
onOneFingerPanUpdate: (d) {
gFFI.cursorModel.updatePan(d.delta.dx, d.delta.dy, touchMode);
},
onOneFingerPanEnd: (d) {
if (touchMode) {
gFFI.sendMouse('up', MouseButtons.left);
}
2022-02-16 23:08:23 +08:00
},
2022-05-10 11:27:16 +08:00
// scale + pan event
2022-02-16 23:08:23 +08:00
onTwoFingerScaleUpdate: (d) {
gFFI.canvasModel.updateScale(d.scale / _scale);
2022-02-17 15:22:14 +08:00
_scale = d.scale;
gFFI.canvasModel.panX(d.focalPointDelta.dx);
gFFI.canvasModel.panY(d.focalPointDelta.dy);
2022-02-16 23:08:23 +08:00
},
onTwoFingerScaleEnd: (d) {
_scale = 1;
2022-08-05 20:29:43 +08:00
bind.sessionPeerOption(id: widget.id, name: "view-style", value: "");
},
onThreeFingerVerticalDragUpdate: gFFI.ffiModel.isPeerAndroid
? null
: (d) {
_mouseScrollIntegral += d.delta.dy / 4;
if (_mouseScrollIntegral > 1) {
gFFI.scroll(1);
_mouseScrollIntegral = 0;
} else if (_mouseScrollIntegral < -1) {
gFFI.scroll(-1);
_mouseScrollIntegral = 0;
}
});
2022-02-02 01:20:14 +08:00
}
2022-02-03 00:53:59 +08:00
Widget getBodyForMobile() {
return Container(
color: MyTheme.canvasColor,
child: Stack(children: [
ImagePaint(),
CursorPaint(),
2022-08-04 17:24:02 +08:00
QualityMonitor(),
2022-02-03 00:53:59 +08:00
getHelpTools(),
SizedBox(
width: 0,
height: 0,
child: !_showEdit
? Container()
: TextFormField(
textInputAction: TextInputAction.newline,
autocorrect: false,
enableSuggestions: false,
autofocus: true,
focusNode: _mobileFocusNode,
maxLines: null,
initialValue: _value,
// trick way to make backspace work always
keyboardType: TextInputType.multiline,
onChanged: handleInput,
),
2022-02-03 00:53:59 +08:00
),
]));
}
2022-04-25 18:25:25 +08:00
Widget getBodyForDesktopWithListener(bool keyboard) {
2022-02-06 16:29:56 +08:00
var paints = <Widget>[ImagePaint()];
2022-08-16 15:22:57 +08:00
final cursor = bind.sessionGetToggleOptionSync(
2022-08-05 20:29:43 +08:00
id: widget.id, arg: 'show-remote-cursor');
if (keyboard || cursor) {
2022-02-06 16:29:56 +08:00
paints.add(CursorPaint());
}
2022-04-25 18:25:25 +08:00
return Container(
color: MyTheme.canvasColor, child: Stack(children: paints));
}
int lastMouseDownButtons = 0;
2022-04-25 18:25:25 +08:00
Map<String, dynamic> getEvent(PointerEvent evt, String type) {
final Map<String, dynamic> out = {};
out['type'] = type;
out['x'] = evt.position.dx;
out['y'] = evt.position.dy;
if (gFFI.alt) out['alt'] = 'true';
if (gFFI.shift) out['shift'] = 'true';
if (gFFI.ctrl) out['ctrl'] = 'true';
if (gFFI.command) out['command'] = 'true';
2022-04-25 18:25:25 +08:00
out['buttons'] = evt
.buttons; // left button: 1, right button: 2, middle button: 4, 1 | 2 = 3 (left + right)
if (evt.buttons != 0) {
lastMouseDownButtons = evt.buttons;
} else {
out['buttons'] = lastMouseDownButtons;
}
return out;
2022-02-02 01:20:14 +08:00
}
2022-08-05 20:29:43 +08:00
void showActions(String id) async {
2021-08-21 17:18:14 +08:00
final size = MediaQuery.of(context).size;
final x = 120.0;
final y = size.height;
final more = <PopupMenuItem<String>>[];
final pi = gFFI.ffiModel.pi;
final perms = gFFI.ffiModel.permissions;
2022-02-02 00:46:21 +08:00
if (pi.version.isNotEmpty) {
2021-08-21 17:18:14 +08:00
more.add(PopupMenuItem<String>(
child: Text(translate('Refresh')), value: 'refresh'));
}
more.add(PopupMenuItem<String>(
child: Row(
children: ([
2022-08-04 17:24:02 +08:00
Text(translate('OS Password')),
TextButton(
style: flatButtonStyle,
onPressed: () {
2022-08-12 18:42:02 +08:00
showSetOSPassword(id, false, gFFI.dialogManager);
},
child: Icon(Icons.edit, color: MyTheme.accent),
)
])),
2021-08-21 17:18:14 +08:00
value: 'enter_os_password'));
2022-05-23 16:02:37 +08:00
if (!isWebDesktop) {
2022-02-02 00:46:21 +08:00
if (perms['keyboard'] != false && perms['clipboard'] != false) {
more.add(PopupMenuItem<String>(
child: Text(translate('Paste')), value: 'paste'));
}
more.add(PopupMenuItem<String>(
child: Text(translate('Reset canvas')), value: 'reset_canvas'));
}
if (perms['keyboard'] != false) {
if (pi.platform == 'Linux' || pi.sasEnabled) {
more.add(PopupMenuItem<String>(
child: Text(translate('Insert') + ' Ctrl + Alt + Del'),
value: 'cad'));
}
more.add(PopupMenuItem<String>(
child: Text(translate('Insert Lock')), value: 'lock'));
if (pi.platform == 'Windows' &&
2022-08-16 15:22:57 +08:00
await bind.sessionGetToggleOption(id: id, arg: 'privacy-mode') !=
2022-08-05 20:29:43 +08:00
true) {
2022-02-02 00:46:21 +08:00
more.add(PopupMenuItem<String>(
child: Text(translate((gFFI.ffiModel.inputBlocked ? 'Unb' : 'B') +
'lock user input')),
2022-02-02 00:46:21 +08:00
value: 'block-input'));
}
}
2022-08-04 17:24:02 +08:00
if (gFFI.ffiModel.permissions["restart"] != false &&
(pi.platform == "Linux" ||
pi.platform == "Windows" ||
pi.platform == "Mac OS")) {
more.add(PopupMenuItem<String>(
child: Text(translate('Restart Remote Device')), value: 'restart'));
}
() async {
2021-08-21 17:18:14 +08:00
var value = await showMenu(
context: context,
position: RelativeRect.fromLTRB(x, y, x, y),
2022-02-02 00:46:21 +08:00
items: more,
2021-08-21 17:18:14 +08:00
elevation: 8,
);
if (value == 'cad') {
2022-08-05 20:29:43 +08:00
bind.sessionCtrlAltDel(id: widget.id);
2021-08-21 17:18:14 +08:00
} else if (value == 'lock') {
2022-08-05 20:29:43 +08:00
bind.sessionLockScreen(id: widget.id);
2022-02-02 00:46:21 +08:00
} else if (value == 'block-input') {
2022-08-05 20:29:43 +08:00
bind.sessionToggleOption(
id: widget.id,
value: (gFFI.ffiModel.inputBlocked ? 'un' : '') + 'block-input');
gFFI.ffiModel.inputBlocked = !gFFI.ffiModel.inputBlocked;
2021-08-21 17:18:14 +08:00
} else if (value == 'refresh') {
2022-08-05 20:29:43 +08:00
bind.sessionRefresh(id: widget.id);
2021-08-21 17:18:14 +08:00
} else if (value == 'paste') {
() async {
2022-02-17 15:22:14 +08:00
ClipboardData? data = await Clipboard.getData(Clipboard.kTextPlain);
if (data != null && data.text != null) {
2022-08-05 20:29:43 +08:00
bind.sessionInputString(id: widget.id, value: data.text ?? "");
2021-08-21 17:18:14 +08:00
}
}();
} else if (value == 'enter_os_password') {
// FIXME:
// null means no session of id
// empty string means no password
2022-08-16 15:22:57 +08:00
var password = await bind.sessionGetOption(id: id, arg: "os-password");
2022-08-05 20:29:43 +08:00
if (password != null) {
bind.sessionInputOsPassword(id: widget.id, value: password);
2021-08-21 17:18:14 +08:00
} else {
2022-08-12 18:42:02 +08:00
showSetOSPassword(id, true, gFFI.dialogManager);
2021-08-21 17:18:14 +08:00
}
} else if (value == 'reset_canvas') {
gFFI.cursorModel.reset();
2022-08-04 17:24:02 +08:00
} else if (value == 'restart') {
2022-08-12 18:42:02 +08:00
showRestartRemoteDevice(pi, widget.id, gFFI.dialogManager);
2021-08-21 17:18:14 +08:00
}
}();
}
2022-02-24 15:59:03 +08:00
void changeTouchMode() {
setState(() => _showEdit = false);
showModalBottomSheet(
backgroundColor: MyTheme.grayBg,
isScrollControlled: true,
context: context,
shape: const RoundedRectangleBorder(
borderRadius: BorderRadius.vertical(top: Radius.circular(5))),
builder: (context) => DraggableScrollableSheet(
expand: false,
builder: (context, scrollController) {
return SingleChildScrollView(
controller: ScrollController(),
2022-02-24 15:59:03 +08:00
padding: EdgeInsets.symmetric(vertical: 10),
child: GestureHelp(
touchMode: gFFI.ffiModel.touchMode,
2022-02-24 15:59:03 +08:00
onTouchModeChange: (t) {
gFFI.ffiModel.toggleTouchMode();
final v = gFFI.ffiModel.touchMode ? 'Y' : '';
2022-08-05 20:29:43 +08:00
bind.sessionPeerOption(
id: widget.id, name: "touch", value: v);
2022-02-24 15:59:03 +08:00
}));
}));
}
2020-11-25 13:03:48 +08:00
Widget getHelpTools() {
final keyboard = isKeyboardShown();
2022-02-24 15:59:03 +08:00
if (!keyboard) {
2020-11-25 13:03:48 +08:00
return SizedBox();
}
2021-08-17 15:07:01 +08:00
final size = MediaQuery.of(context).size;
2022-02-17 15:22:14 +08:00
var wrap = (String text, void Function() onPressed,
[bool? active, IconData? icon]) {
return TextButton(
style: TextButton.styleFrom(
minimumSize: Size(0, 0),
2022-02-16 23:08:23 +08:00
padding: EdgeInsets.symmetric(vertical: 10, horizontal: 9.75),
//adds padding inside the button
tapTargetSize: MaterialTapTargetSize.shrinkWrap,
//limits the touch area to the button area
shape: RoundedRectangleBorder(
borderRadius: BorderRadius.circular(5.0),
),
backgroundColor: active == true ? MyTheme.accent80 : null,
),
child: icon != null
? Icon(icon, size: 17, color: Colors.white)
: Text(translate(text),
style: TextStyle(color: Colors.white, fontSize: 11)),
onPressed: onPressed);
2020-11-25 13:03:48 +08:00
};
final pi = gFFI.ffiModel.pi;
2021-08-11 00:22:47 +08:00
final isMac = pi.platform == "Mac OS";
2020-11-25 16:28:46 +08:00
final modifiers = <Widget>[
2021-08-17 15:07:01 +08:00
wrap('Ctrl ', () {
setState(() => gFFI.ctrl = !gFFI.ctrl);
}, gFFI.ctrl),
2021-08-17 15:07:01 +08:00
wrap(' Alt ', () {
setState(() => gFFI.alt = !gFFI.alt);
}, gFFI.alt),
2020-11-25 16:28:46 +08:00
wrap('Shift', () {
setState(() => gFFI.shift = !gFFI.shift);
}, gFFI.shift),
2021-08-17 15:07:01 +08:00
wrap(isMac ? ' Cmd ' : ' Win ', () {
setState(() => gFFI.command = !gFFI.command);
}, gFFI.command),
2020-11-25 16:28:46 +08:00
];
final keys = <Widget>[
wrap(
2021-08-17 15:07:01 +08:00
' Fn ',
() => setState(
2020-11-25 16:28:46 +08:00
() {
_fn = !_fn;
if (_fn) {
_more = false;
}
},
),
2020-11-25 16:28:46 +08:00
_fn),
wrap(
2021-08-17 15:07:01 +08:00
' ... ',
() => setState(
2020-11-25 16:28:46 +08:00
() {
_more = !_more;
if (_more) {
_fn = false;
}
},
),
2020-11-25 16:28:46 +08:00
_more),
];
final fn = <Widget>[
SizedBox(width: 9999),
];
for (var i = 1; i <= 12; ++i) {
final name = 'F' + i.toString();
fn.add(wrap(name, () {
gFFI.inputKey('VK_' + name);
2020-11-25 16:28:46 +08:00
}));
}
final more = <Widget>[
SizedBox(width: 9999),
wrap('Esc', () {
gFFI.inputKey('VK_ESCAPE');
2020-11-25 16:28:46 +08:00
}),
wrap('Tab', () {
gFFI.inputKey('VK_TAB');
2020-11-25 16:28:46 +08:00
}),
wrap('Home', () {
gFFI.inputKey('VK_HOME');
2020-11-25 16:28:46 +08:00
}),
wrap('End', () {
gFFI.inputKey('VK_END');
2020-11-25 16:28:46 +08:00
}),
wrap('Del', () {
gFFI.inputKey('VK_DELETE');
2020-11-25 16:28:46 +08:00
}),
2020-11-27 02:14:27 +08:00
wrap('PgUp', () {
gFFI.inputKey('VK_PRIOR');
2020-11-25 16:28:46 +08:00
}),
2021-08-17 15:07:01 +08:00
wrap('PgDn', () {
gFFI.inputKey('VK_NEXT');
2020-11-25 16:28:46 +08:00
}),
SizedBox(width: 9999),
wrap('', () {
gFFI.inputKey('VK_LEFT');
}, false, Icons.keyboard_arrow_left),
wrap('', () {
gFFI.inputKey('VK_UP');
}, false, Icons.keyboard_arrow_up),
wrap('', () {
gFFI.inputKey('VK_DOWN');
}, false, Icons.keyboard_arrow_down),
wrap('', () {
gFFI.inputKey('VK_RIGHT');
}, false, Icons.keyboard_arrow_right),
2021-08-11 00:22:47 +08:00
wrap(isMac ? 'Cmd+C' : 'Ctrl+C', () {
sendPrompt(isMac, 'VK_C');
}),
2021-08-11 00:22:47 +08:00
wrap(isMac ? 'Cmd+V' : 'Ctrl+V', () {
sendPrompt(isMac, 'VK_V');
2021-08-06 22:45:45 +08:00
}),
2021-08-11 00:22:47 +08:00
wrap(isMac ? 'Cmd+S' : 'Ctrl+S', () {
sendPrompt(isMac, 'VK_S');
}),
2020-11-25 16:28:46 +08:00
];
2021-08-17 15:07:01 +08:00
final space = size.width > 320 ? 4.0 : 2.0;
2020-11-25 16:28:46 +08:00
return Container(
2020-11-27 02:14:27 +08:00
color: Color(0xAA000000),
2020-11-25 16:28:46 +08:00
padding: EdgeInsets.only(
2021-08-17 15:07:01 +08:00
top: keyboard ? 24 : 4, left: 0, right: 0, bottom: 8),
2020-11-25 16:28:46 +08:00
child: Wrap(
2021-08-17 15:07:01 +08:00
spacing: space,
runSpacing: space,
2020-11-25 16:28:46 +08:00
children: <Widget>[SizedBox(width: 9999)] +
(keyboard
? modifiers + keys + (_fn ? fn : []) + (_more ? more : [])
: modifiers),
2020-11-25 16:28:46 +08:00
));
2020-11-25 13:03:48 +08:00
}
2020-11-17 11:12:55 +08:00
}
2020-11-18 23:15:59 +08:00
class ImagePaint extends StatelessWidget {
@override
Widget build(BuildContext context) {
final m = Provider.of<ImageModel>(context);
2020-11-23 23:18:42 +08:00
final c = Provider.of<CanvasModel>(context);
final adjust = gFFI.cursorModel.adjustForKeyboard();
2020-11-23 23:18:42 +08:00
var s = c.scale;
2020-11-18 23:15:59 +08:00
return CustomPaint(
2020-11-25 11:20:40 +08:00
painter: new ImagePainter(
image: m.image, x: c.x / s, y: (c.y - adjust) / s, scale: s),
2020-11-19 18:22:06 +08:00
);
}
}
class CursorPaint extends StatelessWidget {
@override
Widget build(BuildContext context) {
final m = Provider.of<CursorModel>(context);
2020-11-23 23:18:42 +08:00
final c = Provider.of<CanvasModel>(context);
final adjust = gFFI.cursorModel.adjustForKeyboard();
2020-11-23 23:18:42 +08:00
var s = c.scale;
2020-11-19 18:22:06 +08:00
return CustomPaint(
2020-11-23 23:18:42 +08:00
painter: new ImagePainter(
image: m.image,
x: m.x * s - m.hotx + c.x,
2020-11-25 11:20:40 +08:00
y: m.y * s - m.hoty + c.y - adjust,
2020-11-23 23:18:42 +08:00
scale: 1),
2020-11-18 23:15:59 +08:00
);
}
}
class ImagePainter extends CustomPainter {
ImagePainter({
2022-02-17 15:22:14 +08:00
required this.image,
required this.x,
required this.y,
required this.scale,
2020-11-17 11:12:55 +08:00
});
2022-02-17 15:22:14 +08:00
ui.Image? image;
2020-11-19 18:22:06 +08:00
double x;
double y;
2020-11-23 23:18:42 +08:00
double scale;
2020-11-17 11:12:55 +08:00
@override
void paint(Canvas canvas, Size size) {
if (image == null) return;
2020-11-23 23:18:42 +08:00
canvas.scale(scale, scale);
2022-02-17 15:22:14 +08:00
canvas.drawImage(image!, new Offset(x, y), new Paint());
2020-11-17 11:12:55 +08:00
}
@override
bool shouldRepaint(CustomPainter oldDelegate) {
return oldDelegate != this;
}
}
2020-11-19 21:59:49 +08:00
2022-08-04 17:24:02 +08:00
class QualityMonitor extends StatelessWidget {
@override
Widget build(BuildContext context) => ChangeNotifierProvider.value(
value: gFFI.qualityMonitorModel,
child: Consumer<QualityMonitorModel>(
builder: (context, qualityMonitorModel, child) => Positioned(
top: 10,
right: 10,
child: qualityMonitorModel.show
? Container(
padding: EdgeInsets.all(8),
color: MyTheme.canvasColor.withAlpha(120),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
2022-08-05 20:29:43 +08:00
"Speed: ${qualityMonitorModel.data.speed ?? ''}",
2022-08-04 17:24:02 +08:00
style: TextStyle(color: MyTheme.grayBg),
),
Text(
2022-08-05 20:29:43 +08:00
"FPS: ${qualityMonitorModel.data.fps ?? ''}",
2022-08-04 17:24:02 +08:00
style: TextStyle(color: MyTheme.grayBg),
),
Text(
2022-08-05 20:29:43 +08:00
"Delay: ${qualityMonitorModel.data.delay ?? ''} ms",
2022-08-04 17:24:02 +08:00
style: TextStyle(color: MyTheme.grayBg),
),
Text(
2022-08-05 20:29:43 +08:00
"Target Bitrate: ${qualityMonitorModel.data.targetBitrate ?? ''}kb",
2022-08-04 17:24:02 +08:00
style: TextStyle(color: MyTheme.grayBg),
),
Text(
2022-08-05 20:29:43 +08:00
"Codec: ${qualityMonitorModel.data.codecFormat ?? ''}",
2022-08-04 17:24:02 +08:00
style: TextStyle(color: MyTheme.grayBg),
),
],
),
)
: SizedBox.shrink())));
}
2022-08-12 18:42:02 +08:00
void showOptions(String id, OverlayDialogManager dialogManager) async {
2022-08-16 15:22:57 +08:00
String quality = await bind.sessionGetImageQuality(id: id) ?? 'balanced';
2020-11-20 13:06:52 +08:00
if (quality == '') quality = 'balanced';
2022-08-05 20:29:43 +08:00
String viewStyle =
2022-08-16 15:22:57 +08:00
await bind.sessionGetOption(id: id, arg: 'view-style') ?? '';
2020-11-25 23:52:58 +08:00
var displays = <Widget>[];
final pi = gFFI.ffiModel.pi;
final image = gFFI.ffiModel.getConnectionImage();
if (image != null)
displays.add(Padding(padding: const EdgeInsets.only(top: 8), child: image));
2020-11-25 23:52:58 +08:00
if (pi.displays.length > 1) {
final cur = pi.currentDisplay;
final children = <Widget>[];
for (var i = 0; i < pi.displays.length; ++i)
children.add(InkWell(
onTap: () {
if (i == cur) return;
2022-08-05 20:29:43 +08:00
bind.sessionSwitchDisplay(id: id, value: i);
2022-08-12 18:42:02 +08:00
gFFI.dialogManager.dismissAll();
2020-11-25 23:52:58 +08:00
},
child: Ink(
width: 40,
height: 40,
decoration: BoxDecoration(
border: Border.all(color: Colors.black87),
color: i == cur ? Colors.black87 : Colors.white),
child: Center(
child: Text((i + 1).toString(),
style: TextStyle(
color: i == cur ? Colors.white : Colors.black87))))));
displays.add(Padding(
padding: const EdgeInsets.only(top: 8),
child: Wrap(
alignment: WrapAlignment.center,
spacing: 8,
children: children,
)));
}
if (displays.isNotEmpty) {
2020-11-25 23:52:58 +08:00
displays.add(Divider(color: MyTheme.border));
}
final perms = gFFI.ffiModel.permissions;
2022-03-13 00:32:44 +08:00
2022-08-12 18:42:02 +08:00
dialogManager.show((setState, close) {
2020-11-28 15:24:44 +08:00
final more = <Widget>[];
2022-02-02 00:46:21 +08:00
if (perms['audio'] != false) {
2022-08-05 20:29:43 +08:00
more.add(getToggle(id, setState, 'disable-audio', 'Mute'));
2020-11-28 13:34:59 +08:00
}
2022-02-02 00:46:21 +08:00
if (perms['keyboard'] != false) {
if (perms['clipboard'] != false)
2022-08-05 20:29:43 +08:00
more.add(
getToggle(id, setState, 'disable-clipboard', 'Disable clipboard'));
2022-02-02 00:46:21 +08:00
more.add(getToggle(
2022-08-05 20:29:43 +08:00
id, setState, 'lock-after-session-end', 'Lock after session end'));
2022-02-02 00:46:21 +08:00
if (pi.platform == 'Windows') {
2022-08-05 20:29:43 +08:00
more.add(getToggle(id, setState, 'privacy-mode', 'Privacy mode'));
2022-02-02 00:46:21 +08:00
}
}
2022-02-17 15:22:14 +08:00
var setQuality = (String? value) {
if (value == null) return;
2022-02-02 00:46:21 +08:00
setState(() {
quality = value;
2022-08-05 20:29:43 +08:00
bind.sessionSetImageQuality(id: id, value: value);
2022-02-02 00:46:21 +08:00
});
};
2022-02-17 15:22:14 +08:00
var setViewStyle = (String? value) {
if (value == null) return;
2022-02-02 00:46:21 +08:00
setState(() {
viewStyle = value;
2022-08-05 20:29:43 +08:00
bind.sessionPeerOption(id: id, name: "view-style", value: value);
gFFI.canvasModel.updateViewStyle();
2022-02-02 00:46:21 +08:00
});
};
2022-03-13 00:32:44 +08:00
return CustomAlertDialog(
2022-03-13 23:07:52 +08:00
title: SizedBox.shrink(),
content: Column(
mainAxisSize: MainAxisSize.min,
children: displays +
<Widget>[
getRadio('Scale Original', 'original', viewStyle, setViewStyle),
getRadio('Scale adaptive', 'adaptive', viewStyle, setViewStyle),
2022-04-25 18:25:25 +08:00
Divider(color: MyTheme.border),
2022-03-13 23:07:52 +08:00
getRadio('Good image quality', 'best', quality, setQuality),
getRadio('Balanced', 'balanced', quality, setQuality),
getRadio('Optimize reaction time', 'low', quality, setQuality),
Divider(color: MyTheme.border),
2022-07-14 21:46:40 +08:00
getToggle(
2022-08-05 20:29:43 +08:00
id, setState, 'show-remote-cursor', 'Show remote cursor'),
getToggle(id, setState, 'show-quality-monitor',
'Show quality monitor'),
2022-03-13 23:07:52 +08:00
] +
more),
actions: [],
contentPadding: 0,
2022-03-13 00:32:44 +08:00
);
2022-04-21 10:02:47 +08:00
}, clickMaskDismiss: true, backDismiss: true);
2022-08-04 17:24:02 +08:00
}
2022-08-12 18:42:02 +08:00
void showSetOSPassword(
String id, bool login, OverlayDialogManager dialogManager) async {
2020-12-21 19:05:31 +08:00
final controller = TextEditingController();
2022-08-16 15:22:57 +08:00
var password = await bind.sessionGetOption(id: id, arg: "os-password") ?? "";
var autoLogin = await bind.sessionGetOption(id: id, arg: "auto-login") != "";
2020-12-21 19:05:31 +08:00
controller.text = password;
2022-08-12 18:42:02 +08:00
dialogManager.show((setState, close) {
2022-03-13 00:32:44 +08:00
return CustomAlertDialog(
title: Text(translate('OS Password')),
content: Column(mainAxisSize: MainAxisSize.min, children: [
2022-02-28 16:11:21 +08:00
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);
},
),
]),
2022-03-13 00:32:44 +08:00
actions: [
2022-02-28 16:11:21 +08:00
TextButton(
style: flatButtonStyle,
onPressed: () {
2022-03-13 23:07:52 +08:00
close();
2022-02-28 16:11:21 +08:00
},
child: Text(translate('Cancel')),
),
TextButton(
style: flatButtonStyle,
onPressed: () {
var text = controller.text.trim();
2022-08-05 20:29:43 +08:00
bind.sessionPeerOption(id: id, name: "os-password", value: text);
bind.sessionPeerOption(
id: id, name: "auto-login", value: autoLogin ? 'Y' : '');
2022-02-28 16:11:21 +08:00
if (text != "" && login) {
2022-08-05 20:29:43 +08:00
bind.sessionInputOsPassword(id: id, value: text);
2022-02-28 16:11:21 +08:00
}
2022-03-13 23:07:52 +08:00
close();
2022-02-28 16:11:21 +08:00
},
child: Text(translate('OK')),
),
2022-03-13 00:32:44 +08:00
]);
});
2020-12-21 19:05:31 +08:00
}
2021-08-11 00:22:47 +08:00
void sendPrompt(bool isMac, String key) {
final old = isMac ? gFFI.command : gFFI.ctrl;
2021-08-11 00:22:47 +08:00
if (isMac) {
gFFI.command = true;
2021-08-11 00:22:47 +08:00
} else {
gFFI.ctrl = true;
2021-08-11 00:22:47 +08:00
}
gFFI.inputKey(key);
2021-08-11 00:22:47 +08:00
if (isMac) {
gFFI.command = old;
2021-08-11 00:22:47 +08:00
} else {
gFFI.ctrl = old;
2021-08-11 00:22:47 +08:00
}
}
2022-04-25 18:25:25 +08:00
/// flutter/packages/flutter/lib/src/services/keyboard_key.dart -> _keyLabels
/// see [LogicalKeyboardKey.keyLabel]
2022-05-07 18:04:00 +08:00
const Map<int, String> _logicalKeyMap = <int, String>{
2022-04-25 18:25:25 +08:00
0x00000000020: 'VK_SPACE',
0x00000000022: 'VK_QUOTE',
0x0000000002c: 'VK_COMMA',
0x0000000002d: 'VK_MINUS',
0x0000000002f: 'VK_SLASH',
0x00000000030: 'VK_0',
0x00000000031: 'VK_1',
0x00000000032: 'VK_2',
0x00000000033: 'VK_3',
0x00000000034: 'VK_4',
0x00000000035: 'VK_5',
0x00000000036: 'VK_6',
0x00000000037: 'VK_7',
0x00000000038: 'VK_8',
0x00000000039: 'VK_9',
0x0000000003b: 'VK_SEMICOLON',
0x0000000003d: 'VK_PLUS', // it is =
0x0000000005b: 'VK_LBRACKET',
0x0000000005c: 'VK_BACKSLASH',
0x0000000005d: 'VK_RBRACKET',
0x00000000061: 'VK_A',
0x00000000062: 'VK_B',
0x00000000063: 'VK_C',
0x00000000064: 'VK_D',
0x00000000065: 'VK_E',
0x00000000066: 'VK_F',
0x00000000067: 'VK_G',
0x00000000068: 'VK_H',
0x00000000069: 'VK_I',
0x0000000006a: 'VK_J',
0x0000000006b: 'VK_K',
0x0000000006c: 'VK_L',
0x0000000006d: 'VK_M',
0x0000000006e: 'VK_N',
0x0000000006f: 'VK_O',
0x00000000070: 'VK_P',
0x00000000071: 'VK_Q',
0x00000000072: 'VK_R',
0x00000000073: 'VK_S',
0x00000000074: 'VK_T',
0x00000000075: 'VK_U',
0x00000000076: 'VK_V',
0x00000000077: 'VK_W',
0x00000000078: 'VK_X',
0x00000000079: 'VK_Y',
0x0000000007a: 'VK_Z',
0x00100000008: 'VK_BACK',
0x00100000009: 'VK_TAB',
0x0010000000d: 'VK_ENTER',
0x0010000001b: 'VK_ESCAPE',
0x0010000007f: 'VK_DELETE',
0x00100000104: 'VK_CAPITAL',
0x00100000301: 'VK_DOWN',
0x00100000302: 'VK_LEFT',
0x00100000303: 'VK_RIGHT',
0x00100000304: 'VK_UP',
0x00100000305: 'VK_END',
0x00100000306: 'VK_HOME',
0x00100000307: 'VK_NEXT',
0x00100000308: 'VK_PRIOR',
0x00100000401: 'VK_CLEAR',
0x00100000407: 'VK_INSERT',
0x00100000504: 'VK_CANCEL',
0x00100000506: 'VK_EXECUTE',
0x00100000508: 'VK_HELP',
0x00100000509: 'VK_PAUSE',
0x0010000050c: 'VK_SELECT',
0x00100000608: 'VK_PRINT',
0x00100000705: 'VK_CONVERT',
0x00100000706: 'VK_FINAL',
0x00100000711: 'VK_HANGUL',
0x00100000712: 'VK_HANJA',
0x00100000713: 'VK_JUNJA',
0x00100000718: 'VK_KANA',
0x00100000719: 'VK_KANJI',
0x00100000801: 'VK_F1',
0x00100000802: 'VK_F2',
0x00100000803: 'VK_F3',
0x00100000804: 'VK_F4',
0x00100000805: 'VK_F5',
0x00100000806: 'VK_F6',
0x00100000807: 'VK_F7',
0x00100000808: 'VK_F8',
0x00100000809: 'VK_F9',
0x0010000080a: 'VK_F10',
0x0010000080b: 'VK_F11',
0x0010000080c: 'VK_F12',
0x00100000d2b: 'Apps',
0x00200000002: 'VK_SLEEP',
0x00200000100: 'VK_CONTROL',
0x00200000101: 'RControl',
0x00200000102: 'VK_SHIFT',
0x00200000103: 'RShift',
0x00200000104: 'VK_MENU',
0x00200000105: 'RAlt',
0x002000001f0: 'VK_CONTROL',
0x002000001f2: 'VK_SHIFT',
0x002000001f4: 'VK_MENU',
0x002000001f6: 'Meta',
0x0020000022a: 'VK_MULTIPLY',
0x0020000022b: 'VK_ADD',
0x0020000022d: 'VK_SUBTRACT',
0x0020000022e: 'VK_DECIMAL',
0x0020000022f: 'VK_DIVIDE',
0x00200000230: 'VK_NUMPAD0',
0x00200000231: 'VK_NUMPAD1',
0x00200000232: 'VK_NUMPAD2',
0x00200000233: 'VK_NUMPAD3',
0x00200000234: 'VK_NUMPAD4',
0x00200000235: 'VK_NUMPAD5',
0x00200000236: 'VK_NUMPAD6',
0x00200000237: 'VK_NUMPAD7',
0x00200000238: 'VK_NUMPAD8',
0x00200000239: 'VK_NUMPAD9',
2022-05-07 18:04:00 +08:00
};
/// flutter/packages/flutter/lib/src/services/keyboard_key.dart -> _debugName
/// see [PhysicalKeyboardKey.debugName] -> _debugName
const Map<int, String> _physicalKeyMap = <int, String>{
0x00010082: 'VK_SLEEP',
0x00070004: 'VK_A',
0x00070005: 'VK_B',
0x00070006: 'VK_C',
0x00070007: 'VK_D',
0x00070008: 'VK_E',
0x00070009: 'VK_F',
0x0007000a: 'VK_G',
0x0007000b: 'VK_H',
0x0007000c: 'VK_I',
0x0007000d: 'VK_J',
0x0007000e: 'VK_K',
0x0007000f: 'VK_L',
0x00070010: 'VK_M',
0x00070011: 'VK_N',
0x00070012: 'VK_O',
0x00070013: 'VK_P',
0x00070014: 'VK_Q',
0x00070015: 'VK_R',
0x00070016: 'VK_S',
0x00070017: 'VK_T',
0x00070018: 'VK_U',
0x00070019: 'VK_V',
0x0007001a: 'VK_W',
0x0007001b: 'VK_X',
0x0007001c: 'VK_Y',
0x0007001d: 'VK_Z',
0x0007001e: 'VK_1',
0x0007001f: 'VK_2',
0x00070020: 'VK_3',
0x00070021: 'VK_4',
0x00070022: 'VK_5',
0x00070023: 'VK_6',
0x00070024: 'VK_7',
0x00070025: 'VK_8',
0x00070026: 'VK_9',
0x00070027: 'VK_0',
0x00070028: 'VK_ENTER',
0x00070029: 'VK_ESCAPE',
0x0007002a: 'VK_BACK',
0x0007002b: 'VK_TAB',
0x0007002c: 'VK_SPACE',
0x0007002d: 'VK_MINUS',
0x0007002e: 'VK_PLUS', // it is =
0x0007002f: 'VK_LBRACKET',
0x00070030: 'VK_RBRACKET',
0x00070033: 'VK_SEMICOLON',
0x00070034: 'VK_QUOTE',
0x00070036: 'VK_COMMA',
0x00070038: 'VK_SLASH',
0x00070039: 'VK_CAPITAL',
0x0007003a: 'VK_F1',
0x0007003b: 'VK_F2',
0x0007003c: 'VK_F3',
0x0007003d: 'VK_F4',
0x0007003e: 'VK_F5',
0x0007003f: 'VK_F6',
0x00070040: 'VK_F7',
0x00070041: 'VK_F8',
0x00070042: 'VK_F9',
0x00070043: 'VK_F10',
0x00070044: 'VK_F11',
0x00070045: 'VK_F12',
0x00070049: 'VK_INSERT',
0x0007004a: 'VK_HOME',
0x0007004b: 'VK_PRIOR', // Page Up
0x0007004c: 'VK_DELETE',
0x0007004d: 'VK_END',
0x0007004e: 'VK_NEXT', // Page Down
0x0007004f: 'VK_RIGHT',
0x00070050: 'VK_LEFT',
0x00070051: 'VK_DOWN',
0x00070052: 'VK_UP',
0x00070053: 'Num Lock', // TODO rust not impl
0x00070054: 'VK_DIVIDE', // numpad
0x00070055: 'VK_MULTIPLY',
0x00070056: 'VK_SUBTRACT',
0x00070057: 'VK_ADD',
0x00070058: 'VK_ENTER', // num enter
0x00070059: 'VK_NUMPAD0',
0x0007005a: 'VK_NUMPAD1',
0x0007005b: 'VK_NUMPAD2',
0x0007005c: 'VK_NUMPAD3',
0x0007005d: 'VK_NUMPAD4',
0x0007005e: 'VK_NUMPAD5',
0x0007005f: 'VK_NUMPAD6',
0x00070060: 'VK_NUMPAD7',
0x00070061: 'VK_NUMPAD8',
0x00070062: 'VK_NUMPAD9',
0x00070063: 'VK_DECIMAL',
0x00070075: 'VK_HELP',
0x00070077: 'VK_SELECT',
0x00070088: 'VK_KANA',
0x0007008a: 'VK_CONVERT',
0x000700e0: 'VK_CONTROL',
0x000700e1: 'VK_SHIFT',
0x000700e2: 'VK_MENU',
0x000700e3: 'Meta',
0x000700e4: 'RControl',
0x000700e5: 'RShift',
0x000700e6: 'RAlt',
0x000700e7: 'RWin',
0x000c00b1: 'VK_PAUSE',
0x000c00cd: 'VK_PAUSE',
0x000c019e: 'LOCK_SCREEN',
0x000c0208: 'VK_PRINT',
2022-04-25 18:25:25 +08:00
};