mirror of
https://github.com/rustdesk/rustdesk.git
synced 2026-02-17 14:07:28 +08:00
998b75856d
* feat: Add relative mouse mode - Add "Relative Mouse Mode" toggle in desktop toolbar and bind to InputModel - Implement relative mouse movement path: Flutter pointer deltas -> `type: move_relative` -> new `MOUSE_TYPE_MOVE_RELATIVE` in Rust - In server input service, simulate relative movement via Enigo and keep latest cursor position in sync - Track pointer-lock center in Flutter (local widget + screen coordinates) and re-center OS cursor after each relative move - Update pointer-lock center on window move/resize/restore/maximize and when remote display geometry changes - Hide local cursor when relative mouse mode is active (both Flutter cursor and OS cursor), restore on leave/disable - On Windows, clip OS cursor to the window rect while in relative mode and release clip when leaving/turning off - Implement platform helpers: `get_cursor_pos`, `set_cursor_pos`, `show_cursor`, `clip_cursor` (no-op clip/hide on Linux for now) - Add keyboard shortcut Ctrl+Alt+Shift+M to toggle relative mode (enabled by default, works on all platforms) - Remove `enable-relative-mouse-shortcut` config option - shortcut is now always available when keyboard permission is granted - Handle window blur/focus/minimize events to properly release/restore cursor constraints - Add MOUSE_TYPE_MASK constant and unit tests for mouse event constants Note: Relative mouse mode state is NOT persisted to config (session-only). Note: On Linux, show_cursor and clip_cursor are no-ops; cursor hiding is handled by Flutter side. Signed-off-by: fufesou <linlong1266@gmail.com> * feat(mouse): relative mouse mode, exit hint Signed-off-by: fufesou <linlong1266@gmail.com> * refact(relative mouse): shortcut Signed-off-by: fufesou <linlong1266@gmail.com> --------- Signed-off-by: fufesou <linlong1266@gmail.com>
1055 lines
34 KiB
Dart
1055 lines
34 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:desktop_multi_window/desktop_multi_window.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:flutter/scheduler.dart';
|
|
import 'package:get/get.dart';
|
|
import 'package:provider/provider.dart';
|
|
import 'package:flutter_hbb/models/state_model.dart';
|
|
|
|
import '../../consts.dart';
|
|
import '../../common/widgets/overlay.dart';
|
|
import '../../common/widgets/remote_input.dart';
|
|
import '../../common.dart';
|
|
import '../../common/widgets/dialog.dart';
|
|
import '../../common/widgets/toolbar.dart';
|
|
import '../../models/model.dart';
|
|
import '../../models/input_model.dart';
|
|
import '../../models/platform_model.dart';
|
|
import '../../common/shared_state.dart';
|
|
import '../../utils/image.dart';
|
|
import '../widgets/remote_toolbar.dart';
|
|
import '../widgets/kb_layout_type_chooser.dart';
|
|
import '../widgets/tabbar_widget.dart';
|
|
|
|
import 'package:flutter_hbb/native/custom_cursor.dart'
|
|
if (dart.library.html) 'package:flutter_hbb/web/custom_cursor.dart';
|
|
|
|
final SimpleWrapper<bool> _firstEnterImage = SimpleWrapper(false);
|
|
|
|
// Used to skip session close if "move to new window" is clicked.
|
|
final Map<String, bool> closeSessionOnDispose = {};
|
|
|
|
class RemotePage extends StatefulWidget {
|
|
RemotePage({
|
|
Key? key,
|
|
required this.id,
|
|
required this.toolbarState,
|
|
this.sessionId,
|
|
this.tabWindowId,
|
|
this.password,
|
|
this.display,
|
|
this.displays,
|
|
this.tabController,
|
|
this.switchUuid,
|
|
this.forceRelay,
|
|
this.isSharedPassword,
|
|
}) : super(key: key) {
|
|
initSharedStates(id);
|
|
}
|
|
|
|
final String id;
|
|
final SessionID? sessionId;
|
|
final int? tabWindowId;
|
|
final int? display;
|
|
final List<int>? displays;
|
|
final String? password;
|
|
final ToolbarState toolbarState;
|
|
final String? switchUuid;
|
|
final bool? forceRelay;
|
|
final bool? isSharedPassword;
|
|
final SimpleWrapper<State<RemotePage>?> _lastState = SimpleWrapper(null);
|
|
final DesktopTabController? tabController;
|
|
|
|
FFI get ffi => (_lastState.value! as _RemotePageState)._ffi;
|
|
|
|
@override
|
|
State<RemotePage> createState() {
|
|
final state = _RemotePageState(id);
|
|
_lastState.value = state;
|
|
return state;
|
|
}
|
|
}
|
|
|
|
class _RemotePageState extends State<RemotePage>
|
|
with
|
|
AutomaticKeepAliveClientMixin,
|
|
MultiWindowListener,
|
|
TickerProviderStateMixin {
|
|
Timer? _timer;
|
|
String keyboardMode = "legacy";
|
|
bool _isWindowBlur = false;
|
|
final _cursorOverImage = false.obs;
|
|
late RxBool _showRemoteCursor;
|
|
late RxBool _zoomCursor;
|
|
late RxBool _remoteCursorMoved;
|
|
late RxBool _keyboardEnabled;
|
|
final _uniqueKey = UniqueKey();
|
|
|
|
var _blockableOverlayState = BlockableOverlayState();
|
|
|
|
final FocusNode _rawKeyFocusNode = FocusNode(debugLabel: "rawkeyFocusNode");
|
|
|
|
// Debounce timer for pointer lock center updates during window events.
|
|
// Uses kDefaultPointerLockCenterThrottleMs from consts.dart for the duration.
|
|
Timer? _pointerLockCenterDebounceTimer;
|
|
|
|
// We need `_instanceIdOnEnterOrLeaveImage4Toolbar` together with `_onEnterOrLeaveImage4Toolbar`
|
|
// to identify the toolbar instance and its callback function.
|
|
int? _instanceIdOnEnterOrLeaveImage4Toolbar;
|
|
Function(bool)? _onEnterOrLeaveImage4Toolbar;
|
|
|
|
late FFI _ffi;
|
|
|
|
SessionID get sessionId => _ffi.sessionId;
|
|
|
|
_RemotePageState(String id) {
|
|
_initStates(id);
|
|
}
|
|
|
|
void _initStates(String id) {
|
|
_zoomCursor = PeerBoolOption.find(id, kOptionZoomCursor);
|
|
_showRemoteCursor = ShowRemoteCursorState.find(id);
|
|
_keyboardEnabled = KeyboardEnabledState.find(id);
|
|
_remoteCursorMoved = RemoteCursorMovedState.find(id);
|
|
}
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_ffi = FFI(widget.sessionId);
|
|
Get.put<FFI>(_ffi, tag: widget.id);
|
|
_ffi.imageModel.addCallbackOnFirstImage((String peerId) {
|
|
_ffi.canvasModel.activateLocalCursor();
|
|
showKBLayoutTypeChooserIfNeeded(
|
|
_ffi.ffiModel.pi.platform, _ffi.dialogManager);
|
|
_ffi.recordingModel
|
|
.updateStatus(bind.sessionGetIsRecording(sessionId: _ffi.sessionId));
|
|
});
|
|
_ffi.canvasModel.initializeEdgeScrollFallback(this);
|
|
_ffi.start(
|
|
widget.id,
|
|
password: widget.password,
|
|
isSharedPassword: widget.isSharedPassword,
|
|
switchUuid: widget.switchUuid,
|
|
forceRelay: widget.forceRelay,
|
|
tabWindowId: widget.tabWindowId,
|
|
display: widget.display,
|
|
displays: widget.displays,
|
|
);
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
SystemChrome.setEnabledSystemUIMode(SystemUiMode.manual, overlays: []);
|
|
_ffi.dialogManager
|
|
.showLoading(translate('Connecting...'), onCancel: closeConnection);
|
|
});
|
|
WakelockManager.enable(_uniqueKey);
|
|
|
|
_ffi.ffiModel.updateEventListener(sessionId, widget.id);
|
|
if (!isWeb) bind.pluginSyncUi(syncTo: kAppTypeDesktopRemote);
|
|
_ffi.qualityMonitorModel.checkShowQualityMonitor(sessionId);
|
|
_ffi.dialogManager.loadMobileActionsOverlayVisible();
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
// Session option should be set after models.dart/FFI.start
|
|
_showRemoteCursor.value = bind.sessionGetToggleOptionSync(
|
|
sessionId: sessionId, arg: 'show-remote-cursor');
|
|
_zoomCursor.value = bind.sessionGetToggleOptionSync(
|
|
sessionId: sessionId, arg: kOptionZoomCursor);
|
|
});
|
|
DesktopMultiWindow.addListener(this);
|
|
// if (!_isCustomCursorInited) {
|
|
// customCursorController.registerNeedUpdateCursorCallback(
|
|
// (String? lastKey, String? currentKey) async {
|
|
// if (_firstEnterImage.value) {
|
|
// _firstEnterImage.value = false;
|
|
// return true;
|
|
// }
|
|
// return lastKey == null || lastKey != currentKey;
|
|
// });
|
|
// _isCustomCursorInited = true;
|
|
// }
|
|
|
|
_blockableOverlayState.applyFfi(_ffi);
|
|
// Call onSelected in post frame callback, since we cannot guarantee that the callback will not call setState.
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
widget.tabController?.onSelected?.call(widget.id);
|
|
});
|
|
|
|
// Register callback to cancel debounce timer when relative mouse mode is disabled
|
|
_ffi.inputModel.onRelativeMouseModeDisabled =
|
|
_cancelPointerLockCenterDebounceTimer;
|
|
}
|
|
|
|
/// Cancel the pointer lock center debounce timer
|
|
void _cancelPointerLockCenterDebounceTimer() {
|
|
_pointerLockCenterDebounceTimer?.cancel();
|
|
_pointerLockCenterDebounceTimer = null;
|
|
}
|
|
|
|
@override
|
|
void onWindowBlur() {
|
|
super.onWindowBlur();
|
|
// On windows, we use `focus` way to handle keyboard better.
|
|
// Now on Linux, there's some rdev issues which will break the input.
|
|
// We disable the `focus` way for non-Windows temporarily.
|
|
if (isWindows) {
|
|
_isWindowBlur = true;
|
|
// unfocus the primary-focus when the whole window is lost focus,
|
|
// and let OS to handle events instead.
|
|
_rawKeyFocusNode.unfocus();
|
|
}
|
|
stateGlobal.isFocused.value = false;
|
|
|
|
// When window loses focus, temporarily release relative mouse mode constraints
|
|
// to allow user to interact with other applications normally.
|
|
// The cursor will be re-hidden and re-centered when window regains focus.
|
|
if (_ffi.inputModel.relativeMouseMode.value) {
|
|
_ffi.inputModel.onWindowBlur();
|
|
}
|
|
}
|
|
|
|
@override
|
|
void onWindowFocus() {
|
|
super.onWindowFocus();
|
|
// See [onWindowBlur].
|
|
if (isWindows) {
|
|
_isWindowBlur = false;
|
|
}
|
|
stateGlobal.isFocused.value = true;
|
|
|
|
// Restore relative mouse mode constraints when window regains focus.
|
|
if (_ffi.inputModel.relativeMouseMode.value) {
|
|
_rawKeyFocusNode.requestFocus();
|
|
_ffi.inputModel.onWindowFocus();
|
|
}
|
|
}
|
|
|
|
@override
|
|
void onWindowRestore() {
|
|
super.onWindowRestore();
|
|
// On windows, we use `onWindowRestore` way to handle window restore from
|
|
// a minimized state.
|
|
if (isWindows) {
|
|
_isWindowBlur = false;
|
|
}
|
|
WakelockManager.enable(_uniqueKey);
|
|
// Update pointer lock center when window is restored
|
|
_updatePointerLockCenterIfNeeded();
|
|
}
|
|
|
|
// When the window is unminimized, onWindowMaximize or onWindowRestore can be called when the old state was maximized or not.
|
|
@override
|
|
void onWindowMaximize() {
|
|
super.onWindowMaximize();
|
|
WakelockManager.enable(_uniqueKey);
|
|
// Update pointer lock center when window is maximized
|
|
_updatePointerLockCenterIfNeeded();
|
|
}
|
|
|
|
@override
|
|
void onWindowResize() {
|
|
super.onWindowResize();
|
|
// Update pointer lock center when window is resized
|
|
_updatePointerLockCenterIfNeeded();
|
|
}
|
|
|
|
@override
|
|
void onWindowMove() {
|
|
super.onWindowMove();
|
|
// Update pointer lock center when window is moved
|
|
_updatePointerLockCenterIfNeeded();
|
|
}
|
|
|
|
/// Update pointer lock center with debouncing to avoid excessive updates
|
|
/// during rapid window move/resize events.
|
|
void _updatePointerLockCenterIfNeeded() {
|
|
if (!_ffi.inputModel.relativeMouseMode.value) return;
|
|
|
|
// Cancel any pending update and schedule a new one (debounce pattern)
|
|
_pointerLockCenterDebounceTimer?.cancel();
|
|
_pointerLockCenterDebounceTimer = Timer(
|
|
const Duration(milliseconds: kDefaultPointerLockCenterThrottleMs),
|
|
() {
|
|
if (!mounted) return;
|
|
if (_ffi.inputModel.relativeMouseMode.value) {
|
|
_ffi.inputModel.updatePointerLockCenter();
|
|
}
|
|
},
|
|
);
|
|
}
|
|
|
|
@override
|
|
void onWindowMinimize() {
|
|
super.onWindowMinimize();
|
|
WakelockManager.disable(_uniqueKey);
|
|
// Release cursor constraints when minimized
|
|
if (_ffi.inputModel.relativeMouseMode.value) {
|
|
_ffi.inputModel.onWindowBlur();
|
|
}
|
|
}
|
|
|
|
@override
|
|
void onWindowEnterFullScreen() {
|
|
super.onWindowEnterFullScreen();
|
|
if (isMacOS) {
|
|
stateGlobal.setFullscreen(true);
|
|
}
|
|
}
|
|
|
|
@override
|
|
void onWindowLeaveFullScreen() {
|
|
super.onWindowLeaveFullScreen();
|
|
if (isMacOS) {
|
|
stateGlobal.setFullscreen(false);
|
|
}
|
|
}
|
|
|
|
@override
|
|
Future<void> dispose() async {
|
|
final closeSession = closeSessionOnDispose.remove(widget.id) ?? true;
|
|
|
|
// https://github.com/flutter/flutter/issues/64935
|
|
super.dispose();
|
|
debugPrint("REMOTE PAGE dispose session $sessionId ${widget.id}");
|
|
|
|
// Defensive cleanup: ensure host system-key propagation is reset even if
|
|
// MouseRegion.onExit never fired (e.g., tab closed while cursor inside).
|
|
if (!isWeb) bind.hostStopSystemKeyPropagate(stopped: true);
|
|
|
|
_pointerLockCenterDebounceTimer?.cancel();
|
|
_pointerLockCenterDebounceTimer = null;
|
|
// Clear callback reference to prevent memory leaks and stale references
|
|
_ffi.inputModel.onRelativeMouseModeDisabled = null;
|
|
// Relative mouse mode cleanup is centralized in FFI.close(closeSession: ...).
|
|
_ffi.textureModel.onRemotePageDispose(closeSession);
|
|
if (closeSession) {
|
|
// ensure we leave this session, this is a double check
|
|
_ffi.inputModel.enterOrLeave(false);
|
|
}
|
|
DesktopMultiWindow.removeListener(this);
|
|
_ffi.dialogManager.hideMobileActionsOverlay();
|
|
_ffi.imageModel.disposeImage();
|
|
_ffi.cursorModel.disposeImages();
|
|
_rawKeyFocusNode.dispose();
|
|
await _ffi.close(closeSession: closeSession);
|
|
_timer?.cancel();
|
|
_ffi.dialogManager.dismissAll();
|
|
if (closeSession) {
|
|
await SystemChrome.setEnabledSystemUIMode(SystemUiMode.manual,
|
|
overlays: SystemUiOverlay.values);
|
|
}
|
|
WakelockManager.disable(_uniqueKey);
|
|
await Get.delete<FFI>(tag: widget.id);
|
|
removeSharedStates(widget.id);
|
|
}
|
|
|
|
Widget emptyOverlay() => BlockableOverlay(
|
|
/// the Overlay key will be set with _blockableOverlayState in BlockableOverlay
|
|
/// see override build() in [BlockableOverlay]
|
|
state: _blockableOverlayState,
|
|
underlying: Container(
|
|
color: Colors.transparent,
|
|
),
|
|
);
|
|
|
|
Widget buildBody(BuildContext context) {
|
|
remoteToolbar(BuildContext context) => RemoteToolbar(
|
|
id: widget.id,
|
|
ffi: _ffi,
|
|
state: widget.toolbarState,
|
|
onEnterOrLeaveImageSetter: (id, func) {
|
|
_instanceIdOnEnterOrLeaveImage4Toolbar = id;
|
|
_onEnterOrLeaveImage4Toolbar = func;
|
|
},
|
|
onEnterOrLeaveImageCleaner: (id) {
|
|
// If _instanceIdOnEnterOrLeaveImage4Toolbar != id
|
|
// it means `_onEnterOrLeaveImage4Toolbar` is not set or it has been changed to another toolbar.
|
|
if (_instanceIdOnEnterOrLeaveImage4Toolbar == id) {
|
|
_instanceIdOnEnterOrLeaveImage4Toolbar = null;
|
|
_onEnterOrLeaveImage4Toolbar = null;
|
|
}
|
|
},
|
|
setRemoteState: setState,
|
|
);
|
|
|
|
bodyWidget() {
|
|
return Stack(
|
|
children: [
|
|
Container(
|
|
color: kColorCanvas,
|
|
child: RawKeyFocusScope(
|
|
focusNode: _rawKeyFocusNode,
|
|
onFocusChange: (bool imageFocused) {
|
|
debugPrint(
|
|
"onFocusChange(window active:${!_isWindowBlur}) $imageFocused");
|
|
// See [onWindowBlur].
|
|
if (isWindows) {
|
|
if (_isWindowBlur) {
|
|
imageFocused = false;
|
|
Future.delayed(Duration.zero, () {
|
|
_rawKeyFocusNode.unfocus();
|
|
});
|
|
}
|
|
if (imageFocused) {
|
|
_ffi.inputModel.enterOrLeave(true);
|
|
} else {
|
|
_ffi.inputModel.enterOrLeave(false);
|
|
}
|
|
}
|
|
},
|
|
inputModel: _ffi.inputModel,
|
|
child: getBodyForDesktop(context))),
|
|
Stack(
|
|
children: [
|
|
_ffi.ffiModel.pi.isSet.isTrue &&
|
|
_ffi.ffiModel.waitForFirstImage.isTrue
|
|
? emptyOverlay()
|
|
: () {
|
|
if (!_ffi.ffiModel.isPeerAndroid) {
|
|
return Offstage();
|
|
} else {
|
|
return Obx(() => Offstage(
|
|
offstage: _ffi.dialogManager
|
|
.mobileActionsOverlayVisible.isFalse,
|
|
child: Overlay(initialEntries: [
|
|
makeMobileActionsOverlayEntry(
|
|
() => _ffi.dialogManager
|
|
.setMobileActionsOverlayVisible(false),
|
|
ffi: _ffi,
|
|
)
|
|
]),
|
|
));
|
|
}
|
|
}(),
|
|
// Use Overlay to enable rebuild every time on menu button click.
|
|
// Hide toolbar when relative mouse mode is active to prevent
|
|
// cursor from escaping to toolbar area.
|
|
Obx(() => _ffi.inputModel.relativeMouseMode.value
|
|
? const Offstage()
|
|
: _ffi.ffiModel.pi.isSet.isTrue
|
|
? Overlay(initialEntries: [
|
|
OverlayEntry(builder: remoteToolbar)
|
|
])
|
|
: remoteToolbar(context)),
|
|
_ffi.ffiModel.pi.isSet.isFalse ? emptyOverlay() : Offstage(),
|
|
],
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
return Scaffold(
|
|
backgroundColor: Theme.of(context).colorScheme.background,
|
|
body: Obx(() {
|
|
final imageReady = _ffi.ffiModel.pi.isSet.isTrue &&
|
|
_ffi.ffiModel.waitForFirstImage.isFalse;
|
|
if (imageReady) {
|
|
// If the privacy mode(disable physical displays) is switched,
|
|
// we should not dismiss the dialog immediately.
|
|
if (DateTime.now().difference(togglePrivacyModeTime) >
|
|
const Duration(milliseconds: 3000)) {
|
|
// `dismissAll()` is to ensure that the state is clean.
|
|
// It's ok to call dismissAll() here.
|
|
_ffi.dialogManager.dismissAll();
|
|
// Recreate the block state to refresh the state.
|
|
_blockableOverlayState = BlockableOverlayState();
|
|
_blockableOverlayState.applyFfi(_ffi);
|
|
}
|
|
// Block the whole `bodyWidget()` when dialog shows.
|
|
return BlockableOverlay(
|
|
underlying: bodyWidget(),
|
|
state: _blockableOverlayState,
|
|
);
|
|
} else {
|
|
// `_blockableOverlayState` is not recreated here.
|
|
// The toolbar's block state won't work properly when reconnecting, but that's okay.
|
|
return bodyWidget();
|
|
}
|
|
}),
|
|
);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
super.build(context);
|
|
return WillPopScope(
|
|
onWillPop: () async {
|
|
clientClose(sessionId, _ffi);
|
|
return false;
|
|
},
|
|
child: MultiProvider(providers: [
|
|
ChangeNotifierProvider.value(value: _ffi.ffiModel),
|
|
ChangeNotifierProvider.value(value: _ffi.imageModel),
|
|
ChangeNotifierProvider.value(value: _ffi.cursorModel),
|
|
ChangeNotifierProvider.value(value: _ffi.canvasModel),
|
|
ChangeNotifierProvider.value(value: _ffi.recordingModel),
|
|
], child: buildBody(context)));
|
|
}
|
|
|
|
void enterView(PointerEnterEvent evt) {
|
|
_ffi.canvasModel.rearmEdgeScroll();
|
|
|
|
_cursorOverImage.value = true;
|
|
_firstEnterImage.value = true;
|
|
if (_onEnterOrLeaveImage4Toolbar != null) {
|
|
try {
|
|
_onEnterOrLeaveImage4Toolbar!(true);
|
|
} catch (e) {
|
|
//
|
|
}
|
|
}
|
|
|
|
// See [onWindowBlur].
|
|
if (!isWindows) {
|
|
if (!_rawKeyFocusNode.hasFocus) {
|
|
_rawKeyFocusNode.requestFocus();
|
|
}
|
|
_ffi.inputModel.enterOrLeave(true);
|
|
}
|
|
}
|
|
|
|
void leaveView(PointerExitEvent evt) {
|
|
_ffi.canvasModel.disableEdgeScroll();
|
|
|
|
if (_ffi.ffiModel.keyboard) {
|
|
_ffi.inputModel.tryMoveEdgeOnExit(evt.position);
|
|
}
|
|
|
|
_cursorOverImage.value = false;
|
|
_firstEnterImage.value = false;
|
|
if (_onEnterOrLeaveImage4Toolbar != null) {
|
|
try {
|
|
_onEnterOrLeaveImage4Toolbar!(false);
|
|
} catch (e) {
|
|
//
|
|
}
|
|
}
|
|
|
|
// See [onWindowBlur].
|
|
if (!isWindows) {
|
|
_ffi.inputModel.enterOrLeave(false);
|
|
}
|
|
}
|
|
|
|
Widget _buildRawTouchAndPointerRegion(
|
|
Widget child,
|
|
PointerEnterEventListener? onEnter,
|
|
PointerExitEventListener? onExit,
|
|
) {
|
|
return RawTouchGestureDetectorRegion(
|
|
child: _buildRawPointerMouseRegion(child, onEnter, onExit),
|
|
ffi: _ffi,
|
|
);
|
|
}
|
|
|
|
Widget _buildRawPointerMouseRegion(
|
|
Widget child,
|
|
PointerEnterEventListener? onEnter,
|
|
PointerExitEventListener? onExit,
|
|
) {
|
|
return RawPointerMouseRegion(
|
|
onEnter: onEnter,
|
|
onExit: onExit,
|
|
onPointerDown: (event) {
|
|
// A double check for blur status.
|
|
// Note: If there's an `onPointerDown` event is triggered, `_isWindowBlur` is expected being false.
|
|
// Sometimes the system does not send the necessary focus event to flutter. We should manually
|
|
// handle this inconsistent status by setting `_isWindowBlur` to false. So we can
|
|
// ensure the grab-key thread is running when our users are clicking the remote canvas.
|
|
if (_isWindowBlur) {
|
|
debugPrint(
|
|
"Unexpected status: onPointerDown is triggered while the remote window is in blur status");
|
|
_isWindowBlur = false;
|
|
}
|
|
if (!_rawKeyFocusNode.hasFocus) {
|
|
_rawKeyFocusNode.requestFocus();
|
|
}
|
|
},
|
|
inputModel: _ffi.inputModel,
|
|
child: child,
|
|
);
|
|
}
|
|
|
|
Widget getBodyForDesktop(BuildContext context) {
|
|
var paints = <Widget>[
|
|
MouseRegion(
|
|
onEnter: (evt) {
|
|
if (!isWeb) bind.hostStopSystemKeyPropagate(stopped: false);
|
|
},
|
|
onExit: (evt) {
|
|
if (!isWeb) bind.hostStopSystemKeyPropagate(stopped: true);
|
|
},
|
|
child: _ViewStyleUpdater(
|
|
canvasModel: _ffi.canvasModel,
|
|
inputModel: _ffi.inputModel,
|
|
child: Builder(builder: (context) {
|
|
final peerDisplay = CurrentDisplayState.find(widget.id);
|
|
return Obx(
|
|
() => _ffi.ffiModel.pi.isSet.isFalse
|
|
? Container(color: Colors.transparent)
|
|
: Obx(() {
|
|
_ffi.textureModel.updateCurrentDisplay(peerDisplay.value);
|
|
return ImagePaint(
|
|
id: widget.id,
|
|
zoomCursor: _zoomCursor,
|
|
cursorOverImage: _cursorOverImage,
|
|
keyboardEnabled: _keyboardEnabled,
|
|
remoteCursorMoved: _remoteCursorMoved,
|
|
listenerBuilder: (child) =>
|
|
_buildRawTouchAndPointerRegion(
|
|
child, enterView, leaveView),
|
|
ffi: _ffi,
|
|
);
|
|
}),
|
|
);
|
|
}),
|
|
),
|
|
)
|
|
];
|
|
|
|
if (!_ffi.canvasModel.cursorEmbedded) {
|
|
paints
|
|
.add(Obx(() => _showRemoteCursor.isFalse || _remoteCursorMoved.isFalse
|
|
? Offstage()
|
|
: CursorPaint(
|
|
id: widget.id,
|
|
zoomCursor: _zoomCursor,
|
|
)));
|
|
}
|
|
paints.add(
|
|
Positioned(
|
|
top: 10,
|
|
right: 10,
|
|
child: _buildRawTouchAndPointerRegion(
|
|
QualityMonitor(_ffi.qualityMonitorModel), null, null),
|
|
),
|
|
);
|
|
return Stack(
|
|
children: paints,
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool get wantKeepAlive => true;
|
|
}
|
|
|
|
/// A widget that tracks the view size and updates CanvasModel.updateViewStyle()
|
|
/// and InputModel.updateImageWidgetSize() only when size actually changes.
|
|
/// This avoids scheduling post-frame callbacks on every LayoutBuilder rebuild.
|
|
class _ViewStyleUpdater extends StatefulWidget {
|
|
final CanvasModel canvasModel;
|
|
final InputModel inputModel;
|
|
final Widget child;
|
|
|
|
const _ViewStyleUpdater({
|
|
Key? key,
|
|
required this.canvasModel,
|
|
required this.inputModel,
|
|
required this.child,
|
|
}) : super(key: key);
|
|
|
|
@override
|
|
State<_ViewStyleUpdater> createState() => _ViewStyleUpdaterState();
|
|
}
|
|
|
|
class _ViewStyleUpdaterState extends State<_ViewStyleUpdater> {
|
|
Size? _lastSize;
|
|
bool _callbackScheduled = false;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return LayoutBuilder(
|
|
builder: (context, constraints) {
|
|
final maxWidth = constraints.maxWidth;
|
|
final maxHeight = constraints.maxHeight;
|
|
// Guard against infinite constraints (e.g., unconstrained ancestor).
|
|
if (!maxWidth.isFinite || !maxHeight.isFinite) {
|
|
return widget.child;
|
|
}
|
|
final newSize = Size(maxWidth, maxHeight);
|
|
if (_lastSize != newSize) {
|
|
_lastSize = newSize;
|
|
// Schedule the update for after the current frame to avoid setState during build.
|
|
// Use _callbackScheduled flag to prevent accumulating multiple callbacks
|
|
// when size changes rapidly before any callback executes.
|
|
if (!_callbackScheduled) {
|
|
_callbackScheduled = true;
|
|
SchedulerBinding.instance.addPostFrameCallback((_) {
|
|
_callbackScheduled = false;
|
|
final currentSize = _lastSize;
|
|
if (mounted && currentSize != null) {
|
|
widget.canvasModel.updateViewStyle();
|
|
widget.inputModel.updateImageWidgetSize(currentSize);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
return widget.child;
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
class ImagePaint extends StatefulWidget {
|
|
final FFI ffi;
|
|
final String id;
|
|
final RxBool zoomCursor;
|
|
final RxBool cursorOverImage;
|
|
final RxBool keyboardEnabled;
|
|
final RxBool remoteCursorMoved;
|
|
final Widget Function(Widget)? listenerBuilder;
|
|
|
|
ImagePaint(
|
|
{Key? key,
|
|
required this.ffi,
|
|
required this.id,
|
|
required this.zoomCursor,
|
|
required this.cursorOverImage,
|
|
required this.keyboardEnabled,
|
|
required this.remoteCursorMoved,
|
|
this.listenerBuilder})
|
|
: super(key: key);
|
|
|
|
@override
|
|
State<StatefulWidget> createState() => _ImagePaintState();
|
|
}
|
|
|
|
class _ImagePaintState extends State<ImagePaint> {
|
|
bool _lastRemoteCursorMoved = false;
|
|
|
|
String get id => widget.id;
|
|
RxBool get zoomCursor => widget.zoomCursor;
|
|
RxBool get cursorOverImage => widget.cursorOverImage;
|
|
RxBool get keyboardEnabled => widget.keyboardEnabled;
|
|
RxBool get remoteCursorMoved => widget.remoteCursorMoved;
|
|
Widget Function(Widget)? get listenerBuilder => widget.listenerBuilder;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final m = Provider.of<ImageModel>(context);
|
|
var c = Provider.of<CanvasModel>(context);
|
|
final s = c.scale;
|
|
|
|
bool isViewAdaptive() => c.viewStyle.style == kRemoteViewStyleAdaptive;
|
|
bool isViewOriginal() => c.viewStyle.style == kRemoteViewStyleOriginal;
|
|
|
|
mouseRegion({child}) => Obx(() {
|
|
double getCursorScale() {
|
|
var c = Provider.of<CanvasModel>(context);
|
|
var cursorScale = 1.0;
|
|
if (isWindows) {
|
|
// debug win10
|
|
if (zoomCursor.value && isViewAdaptive()) {
|
|
cursorScale = s * c.devicePixelRatio;
|
|
}
|
|
} else {
|
|
if (zoomCursor.value || isViewOriginal()) {
|
|
cursorScale = s;
|
|
}
|
|
}
|
|
return cursorScale;
|
|
}
|
|
|
|
return MouseRegion(
|
|
cursor: cursorOverImage.isTrue
|
|
? c.cursorEmbedded
|
|
? SystemMouseCursors.none
|
|
// Hide cursor when relative mouse mode is active
|
|
: widget.ffi.inputModel.relativeMouseMode.value
|
|
? SystemMouseCursors.none
|
|
: keyboardEnabled.isTrue
|
|
? (() {
|
|
if (remoteCursorMoved.isTrue) {
|
|
_lastRemoteCursorMoved = true;
|
|
return SystemMouseCursors.none;
|
|
} else {
|
|
if (_lastRemoteCursorMoved) {
|
|
_lastRemoteCursorMoved = false;
|
|
_firstEnterImage.value = true;
|
|
}
|
|
return _buildCustomCursor(
|
|
context, getCursorScale());
|
|
}
|
|
}())
|
|
: _buildDisabledCursor(context, getCursorScale())
|
|
: MouseCursor.defer,
|
|
onHover: (evt) {},
|
|
child: child);
|
|
});
|
|
if (c.imageOverflow.isTrue && c.scrollStyle != ScrollStyle.scrollauto) {
|
|
final paintWidth = c.getDisplayWidth() * s;
|
|
final paintHeight = c.getDisplayHeight() * s;
|
|
final paintSize = Size(paintWidth, paintHeight);
|
|
final paintWidget =
|
|
m.useTextureRender || widget.ffi.ffiModel.pi.forceTextureRender
|
|
? _BuildPaintTextureRender(
|
|
c, s, Offset.zero, paintSize, isViewOriginal())
|
|
: _buildScrollbarNonTextureRender(m, paintSize, s);
|
|
return NotificationListener<ScrollNotification>(
|
|
onNotification: (notification) {
|
|
c.updateScrollPercent();
|
|
return false;
|
|
},
|
|
child: mouseRegion(
|
|
child: Obx(() => _buildCrossScrollbarFromLayout(
|
|
context,
|
|
_buildListener(paintWidget),
|
|
c.size,
|
|
paintSize,
|
|
c.scrollHorizontal,
|
|
c.scrollVertical,
|
|
)),
|
|
));
|
|
} else {
|
|
if (c.size.width > 0 && c.size.height > 0) {
|
|
final paintWidget =
|
|
m.useTextureRender || widget.ffi.ffiModel.pi.forceTextureRender
|
|
? _BuildPaintTextureRender(
|
|
c,
|
|
s,
|
|
Offset(
|
|
isLinux ? c.x.toInt().toDouble() : c.x,
|
|
isLinux ? c.y.toInt().toDouble() : c.y,
|
|
),
|
|
c.size,
|
|
isViewOriginal())
|
|
: _buildScrollAutoNonTextureRender(m, c, s);
|
|
return mouseRegion(child: _buildListener(paintWidget));
|
|
} else {
|
|
return Container();
|
|
}
|
|
}
|
|
}
|
|
|
|
Widget _buildScrollbarNonTextureRender(
|
|
ImageModel m, Size imageSize, double s) {
|
|
return CustomPaint(
|
|
size: imageSize,
|
|
painter: ImagePainter(image: m.image, x: 0, y: 0, scale: s),
|
|
);
|
|
}
|
|
|
|
Widget _buildScrollAutoNonTextureRender(
|
|
ImageModel m, CanvasModel c, double s) {
|
|
double sizeScale = s;
|
|
if (widget.ffi.ffiModel.isPeerLinux) {
|
|
final displays = widget.ffi.ffiModel.pi.getCurDisplays();
|
|
if (displays.isNotEmpty) {
|
|
sizeScale = s / displays[0].scale;
|
|
}
|
|
}
|
|
return CustomPaint(
|
|
size: Size(c.size.width, c.size.height),
|
|
painter: ImagePainter(
|
|
image: m.image,
|
|
x: c.x / sizeScale,
|
|
y: c.y / sizeScale,
|
|
scale: sizeScale),
|
|
);
|
|
}
|
|
|
|
Widget _BuildPaintTextureRender(
|
|
CanvasModel c, double s, Offset offset, Size size, bool isViewOriginal) {
|
|
final ffiModel = c.parent.target!.ffiModel;
|
|
final displays = ffiModel.pi.getCurDisplays();
|
|
final children = <Widget>[];
|
|
final rect = ffiModel.rect;
|
|
if (rect == null) {
|
|
return Container();
|
|
}
|
|
final isPeerLinux = ffiModel.isPeerLinux;
|
|
final curDisplay = ffiModel.pi.currentDisplay;
|
|
for (var i = 0; i < displays.length; i++) {
|
|
final textureId = widget.ffi.textureModel
|
|
.getTextureId(curDisplay == kAllDisplayValue ? i : curDisplay);
|
|
if (true) {
|
|
// both "textureId.value != -1" and "true" seems ok
|
|
final sizeScale = isPeerLinux ? s / displays[i].scale : s;
|
|
children.add(Positioned(
|
|
left: (displays[i].x - rect.left) * s + offset.dx,
|
|
top: (displays[i].y - rect.top) * s + offset.dy,
|
|
width: displays[i].width * sizeScale,
|
|
height: displays[i].height * sizeScale,
|
|
child: Obx(() => Texture(
|
|
textureId: textureId.value,
|
|
filterQuality:
|
|
isViewOriginal ? FilterQuality.none : FilterQuality.low,
|
|
)),
|
|
));
|
|
}
|
|
}
|
|
return SizedBox(
|
|
width: size.width,
|
|
height: size.height,
|
|
child: Stack(children: children),
|
|
);
|
|
}
|
|
|
|
MouseCursor _buildCustomCursor(BuildContext context, double scale) {
|
|
final cursor = Provider.of<CursorModel>(context);
|
|
final cache = cursor.cache ?? preDefaultCursor.cache;
|
|
return buildCursorOfCache(cursor, scale, cache);
|
|
}
|
|
|
|
MouseCursor _buildDisabledCursor(BuildContext context, double scale) {
|
|
final cursor = Provider.of<CursorModel>(context);
|
|
final cache = preForbiddenCursor.cache;
|
|
return buildCursorOfCache(cursor, scale, cache);
|
|
}
|
|
|
|
Widget _buildCrossScrollbarFromLayout(
|
|
BuildContext context,
|
|
Widget child,
|
|
Size layoutSize,
|
|
Size size,
|
|
ScrollController horizontal,
|
|
ScrollController vertical,
|
|
) {
|
|
var widget = child;
|
|
if (layoutSize.width < size.width) {
|
|
widget = ScrollConfiguration(
|
|
behavior: ScrollConfiguration.of(context).copyWith(scrollbars: false),
|
|
child: SingleChildScrollView(
|
|
controller: horizontal,
|
|
scrollDirection: Axis.horizontal,
|
|
physics: cursorOverImage.isTrue
|
|
? const NeverScrollableScrollPhysics()
|
|
: null,
|
|
child: widget,
|
|
),
|
|
);
|
|
} else {
|
|
widget = Row(
|
|
children: [
|
|
Container(
|
|
width: ((layoutSize.width - size.width) ~/ 2).toDouble(),
|
|
),
|
|
widget,
|
|
],
|
|
);
|
|
}
|
|
if (layoutSize.height < size.height) {
|
|
widget = ScrollConfiguration(
|
|
behavior: ScrollConfiguration.of(context).copyWith(scrollbars: false),
|
|
child: SingleChildScrollView(
|
|
controller: vertical,
|
|
physics: cursorOverImage.isTrue
|
|
? const NeverScrollableScrollPhysics()
|
|
: null,
|
|
child: widget,
|
|
),
|
|
);
|
|
} else {
|
|
widget = Column(
|
|
children: [
|
|
Container(
|
|
height: ((layoutSize.height - size.height) ~/ 2).toDouble(),
|
|
),
|
|
widget,
|
|
],
|
|
);
|
|
}
|
|
if (layoutSize.width < size.width) {
|
|
widget = RawScrollbar(
|
|
thickness: kScrollbarThickness,
|
|
thumbColor: Colors.grey,
|
|
controller: horizontal,
|
|
thumbVisibility: false,
|
|
trackVisibility: false,
|
|
notificationPredicate: layoutSize.height < size.height
|
|
? (notification) => notification.depth == 1
|
|
: defaultScrollNotificationPredicate,
|
|
child: widget,
|
|
);
|
|
}
|
|
if (layoutSize.height < size.height) {
|
|
widget = RawScrollbar(
|
|
thickness: kScrollbarThickness,
|
|
thumbColor: Colors.grey,
|
|
controller: vertical,
|
|
thumbVisibility: false,
|
|
trackVisibility: false,
|
|
child: widget,
|
|
);
|
|
}
|
|
|
|
return Container(
|
|
child: widget,
|
|
width: layoutSize.width,
|
|
height: layoutSize.height,
|
|
);
|
|
}
|
|
|
|
Widget _buildListener(Widget child) {
|
|
if (listenerBuilder != null) {
|
|
return listenerBuilder!(child);
|
|
} else {
|
|
return child;
|
|
}
|
|
}
|
|
}
|
|
|
|
class CursorPaint extends StatelessWidget {
|
|
final String id;
|
|
final RxBool zoomCursor;
|
|
|
|
const CursorPaint({
|
|
Key? key,
|
|
required this.id,
|
|
required this.zoomCursor,
|
|
}) : super(key: key);
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final m = Provider.of<CursorModel>(context);
|
|
final c = Provider.of<CanvasModel>(context);
|
|
double hotx = m.hotx;
|
|
double hoty = m.hoty;
|
|
if (m.image == null) {
|
|
if (preDefaultCursor.image != null) {
|
|
hotx = preDefaultCursor.image!.width / 2;
|
|
hoty = preDefaultCursor.image!.height / 2;
|
|
}
|
|
}
|
|
|
|
double cx = c.x;
|
|
double cy = c.y;
|
|
if (c.viewStyle.style == kRemoteViewStyleOriginal &&
|
|
c.scrollStyle == ScrollStyle.scrollbar) {
|
|
final rect = c.parent.target!.ffiModel.rect;
|
|
if (rect == null) {
|
|
// unreachable!
|
|
debugPrint('unreachable! The displays rect is null.');
|
|
return Container();
|
|
}
|
|
if (cx < 0) {
|
|
final imageWidth = rect.width * c.scale;
|
|
cx = -imageWidth * c.scrollX;
|
|
}
|
|
if (cy < 0) {
|
|
final imageHeight = rect.height * c.scale;
|
|
cy = -imageHeight * c.scrollY;
|
|
}
|
|
}
|
|
|
|
double x = (m.x - hotx) * c.scale + cx;
|
|
double y = (m.y - hoty) * c.scale + cy;
|
|
double scale = 1.0;
|
|
final isViewOriginal = c.viewStyle.style == kRemoteViewStyleOriginal;
|
|
if (zoomCursor.value || isViewOriginal) {
|
|
x = m.x - hotx + cx / c.scale;
|
|
y = m.y - hoty + cy / c.scale;
|
|
scale = c.scale;
|
|
}
|
|
|
|
return CustomPaint(
|
|
painter: ImagePainter(
|
|
image: m.image ?? preDefaultCursor.image,
|
|
x: x,
|
|
y: y,
|
|
scale: scale,
|
|
),
|
|
);
|
|
}
|
|
}
|