GNOME Portal:手机控制端拖动滚动、按住选中、短按点击 (#134)

Replayed as touch, a phone drag scrolled in browsers but still selected
text in VTE terminals (Ptyxis, GNOME Terminal), as on a real touchscreen.
By default on the portal backend the host now decides per press: moving
past 12 px within 450 ms scrolls smoothly (NotifyPointerAxis or EIS
scroll, content follows the finger, `finish` on release so clients may
coast), holding still selects with button 1 down, and a short press
clicks. This works in terminals too and needs no touchscreen consent.
UU_TOUCH_INPUT=touch keeps the touchscreen replay (with its one-time
consent upgrade); UU_TOUCH_INPUT=0 keeps plain mouse drags.
This commit is contained in:
Its.spixy authored and GitHub committed 2026-10-29 23:34:30 +08:00
1 parent 11097b5847
commit c0b0ca6afb
10 files changed
+172 -17

No files matched your search

+1 -1
View File
@@ -125,7 +125,7 @@ viewer does not reconnect them automatically.
| `UU_X11_MULTISCREEN=1`, `UU_X11_OUTPUT` | X11: advertise each RandR monitor (`xrandr --listmonitors`, read once at start; primary or `UU_X11_OUTPUT` is id 0) through the same screen-switch path as `UU_WAYLAND_MULTISCREEN` (`wayland::outputs`/`select`). x11grab reads `display+x,y` at the monitor size, XTest/uinput absolute input adds the monitor offset, the in-process engine and `desktop_mode` resize are skipped (分辨率 scales). Needs two or more monitors |
| `UU_DESKTOP_RESIZE=0` | X11: the viewer's 分辨率 choice scales the encoded stream instead of changing the display mode. Default: `src/desktop_mode.rs` switches the primary output via xrandr (adds a CVT-RB mode when missing, re-applies once if mutter resets it), restores the original mode for resolution_type 3 and 2 s after the last desktop stream ends |
| `UU_NVENC_RGB=0` / `=1` | NVENC 4:2:0 without scaling takes packed BGRA/BGR0 directly (no CPU swscale). Default: on, except when a connected DRM connector belongs to an nvidia-bound card (desktop composited on the encoding GPU; #16 measured 82.6 vs 98 fps at 4K). `0` forces CPU conversion, `1` forces the direct path |
| `UU_TOUCH_INPUT=0` | keep left-button drags of Android/iOS controllers (connect header `controller_platform` 2/3) as mouse drags. Default: with the portal touchscreen device type granted (requested where `AvailableDeviceTypes` offers it), a drag that follows absolute motion is replayed as one finger (`NotifyTouch*` / EIS touch), so GNOME scrolls and taps as on a touch screen; consents saved before touch support restore keyboard+pointer only, so the first mobile drag asks once per run in the background (`PortalSession::upgrade_touch`: fresh consent for the same monitor, swapped in only with the touchscreen granted; the saved consent is never removed first) |
| `UU_TOUCH_INPUT` | Android/iOS controllers (connect header `controller_platform` 2/3) send a finger as a left-button drag at absolute positions. Default on the portal backend (gesture): per press, moving past 12 px within 450 ms scrolls (`NotifyPointerAxis` / EIS scroll, content follows the finger, `finish` on release), holding still selects with button 1 down, a short press clicks; needs no touchscreen consent. `touch`: replay as one finger on the portal touchscreen (`NotifyTouch*` / EIS touch; requested where `AvailableDeviceTypes` offers it; consents saved before touch support restore keyboard+pointer only, so the first mobile drag asks once per run in the background via `PortalSession::upgrade_touch`, swapped in only with the touchscreen granted for the same monitor; the saved consent is never removed first). `0`: plain mouse drags |
| `UU_INPUT_BACKEND` | `auto` (uinput on Wayland/portal when `/dev/uinput` is accessible, udev `uaccess` rule in README) / `uinput` / `native`. X11 keeps XTest (held-key autorepeat handling) |
| Mac viewer Cmd | With 「使用 macOS 快捷键」 off the Mac viewer sends Cmd=VK_LWIN 0x5B, Option=0xA4, Ctrl=0xA2; connect header `controller_platform`=4 is macOS. For Mac controllers Cmd is held back: Cmd+C/V/A/F/X/Z → Ctrl+key (terminal: Cmd+C/V → Ctrl+Shift+C/V), other combos/alone → Super |
| `UU_TERMINAL_SHORTCUTS=0` | disable Ctrl+V → Ctrl+Shift+V in focused X11 terminals (Mac Cmd and Ctrl both arrive as VK_LCONTROL) |
+1 -1
View File
@@ -100,7 +100,7 @@ plugins, permissions and encoders only, no account data, tokens or addresses) an
Wayland limits: captures one screen by default; Hyprland can enable monitor switching as described below. Resolution is fixed. The native Hyprland backend now pipelines two shm screencopy buffers and passes the viewer's requested fps to both capture pacing and the encoder. Actual fps remains limited by the compositor, rendering and readback (the old serial path measured about 16–22 fps at 2560x1600; the pipeline is VM-measured only, not a hardware guarantee). The portal backend does not support dynamic resolution; see below for GNOME wake and lock recovery; the clipboard syncs while the viewer's remote window has focus. On the first connection the desktop asks for "Remote Desktop / Screen Sharing"
permission; the permission is remembered once granted.
**Touch from mobile viewers (GNOME)**: in touch mode the Android/iOS viewers send a finger as a left-button drag, which on a desktop selects text. The host asks the portal for the touchscreen device type where it is offered and replays those drags from mobile controllers as one finger, so the desktop scrolls and taps as on a touch screen. A consent saved before this change restores keyboard and pointer only: the first drag from a phone then asks the host once more in the background (the GNOME share dialog, which the phone also sees in the picture; it closes after the consent timeout), and an approval for the same monitor switches to touch without reconnecting. The saved consent is never removed beforehand, and the host asks at most once per run. Without a touchscreen grant, drags stay mouse drags. `UU_TOUCH_INPUT=0` keeps mouse drags and never asks.
**Touch from mobile viewers (GNOME)**: in touch mode the Android/iOS viewers send a finger as a left-button drag, which on a desktop selects text. On the portal backend the host decides per press: a finger that moves more than a few pixels within 0.45 s scrolls smoothly (`NotifyPointerAxis`; the content follows the finger, also in terminals, and the last event lets clients coast), one held still selects like a mouse drag, and a short press clicks. This needs no touchscreen consent. `UU_TOUCH_INPUT=touch` instead replays drags as one finger on the portal touchscreen, which the host requests where the portal offers it; a consent saved before touch support restores keyboard and pointer only, so the first drag then asks the host once more in the background (the GNOME share dialog, which the phone also sees; it closes after the consent timeout), and an approval for the same monitor switches to touch without reconnecting. The saved consent is never removed beforehand, and the host asks at most once per run. `UU_TOUCH_INPUT=0` keeps mouse drags.
**Mobile IME typing and clipboard on Wayland**: Mobile IME text (`text_input`) on Wayland is typed through spare keycodes on wlroots compositors. On GNOME (Portal) printable ASCII is typed as keysyms when the active input source is a Latin xkb layout (Mutter picks the key and Shift level); other text, KDE and compositors where keycodes are exhausted fall back to "system clipboard write + `Shift+Insert` (or `UU_WAYLAND_PASTE_KEY=ctrl_v`)". VTE terminals paste the PRIMARY selection on `Shift+Insert`, which is why ASCII is typed instead. **Note**: This fallback replaces the host's existing clipboard contents and may echo back to the viewer's clipboard via two-way sync; set `UU_WAYLAND_TEXT=0` to completely disable Wayland mobile text input and clipboard paste fallback.
+1 -1
View File
@@ -90,7 +90,7 @@ GNOME Wayland 的 Portal/EIS 路径已在 Ubuntu 26.04、GNOME 50、单屏 4K/20
Wayland 下的限制:默认采集单屏,Hyprland 可按上文启用切屏;分辨率固定;Hyprland 原生后端默认使用双缓冲流水线 shm screencopy,控制端帧率设置会同步到采集节拍和编码器,但实际帧率仍受合成器、渲染和读回速度限制(旧串行路径在 2560x1600 曾测得约 16~22 帧;流水线只在虚拟机里测量过,不代表实机保证);portal 后端暂不支持动态分辨率;GNOME 的屏幕唤醒与锁屏恢复见下;剪贴板只在控制端的远控窗口处于前台时同步。
**手机控制端触控(GNOME)**:Android/iOS 控制端在触控模式下把手指当作左键拖动发送,在桌面上会选中文字。门户提供触摸屏设备类型时,被控端会一并申请,并把手机控制端的拖动按单指触控重放,桌面因此像触摸屏一样滚动和点按。此前保存的授权只恢复键盘和指针:手机第一次拖动时,被控端会在后台再申请一次(GNOME 共享对话框,手机画面中也能看到,授权超时后自动关闭),同意同一显示器后无需重连即切换为触控。不会预先删除已保存的授权,每次运行最多申请一次。未授予触摸屏时拖动仍是鼠标拖动。`UU_TOUCH_INPUT=0` 保持鼠标拖动且不申请。
**手机控制端触控(GNOME)**:Android/iOS 控制端在触控模式下把手指当作左键拖动发送,在桌面上会选中文字。Portal 后端下被控端按每次按下判断:0.45 秒内移动超过几个像素即平滑滚动(`NotifyPointerAxis`,内容跟随手指,终端里同样有效,最后一个事件让客户端可以惯性滑动);按住不动则像鼠标拖动一样选中;短按为点击。此模式无需触摸屏授权。`UU_TOUCH_INPUT=touch` 改为把拖动按单指触控在 Portal 触摸屏上重放,门户提供触摸屏设备类型时被控端会一并申请;此前保存的授权只恢复键盘和指针,因此第一次拖动时会在后台再申请一次(GNOME 共享对话框,手机画面中也能看到,授权超时后自动关闭),同意同一显示器后无需重连即切换为触控。不会预先删除已保存的授权,每次运行最多申请一次。`UU_TOUCH_INPUT=0` 保持鼠标拖动。
**Wayland 手机输入法打字与剪贴板**:Wayland 下手机端输入法提交的文字(`text_input`)优先通过虚拟键盘空闲键码上屏;GNOME(Portal)下,当前输入源为拉丁 xkb 布局时,可打印 ASCII 直接以 keysym 输入(由 Mutter 选择按键和 Shift 层级);其他文字、KDE 以及键码耗尽的环境自动通过「写系统剪贴板 + 触发 `Shift+Insert`(或 `UU_WAYLAND_PASTE_KEY=ctrl_v`)」兜底粘贴。VTE 终端的 `Shift+Insert` 粘贴的是 PRIMARY 选区,因此 ASCII 改为直接输入。**注意**:此兜底过程会覆盖被控端原有的剪贴板内容,且会被双向同步回传到控制端剪贴板;设置 `UU_WAYLAND_TEXT=0` 可完全关闭 Wayland 文字输入及该粘贴兜底。
+8
View File
@@ -161,6 +161,14 @@ static int portal_eis_button(struct uu_portal *p, int button, int pressed) {
ei_device_button_button(device, code, !!pressed);
return portal_eis_frame(p, device);
}
static int portal_eis_scroll(struct uu_portal *p, double dx, double dy, int finish) {
if (portal_eis_available(p)) return 9;
struct ei_device *device = portal_eis_device(p, EI_DEVICE_CAP_SCROLL);
if (!device) return 9;
if (dx != 0 || dy != 0) ei_device_scroll_delta(device, dx, dy);
if (finish) ei_device_scroll_stop(device, true, true);
return portal_eis_frame(p, device);
}
static int portal_eis_touch(struct uu_portal *p, int phase, double x, double y) {
if (portal_eis_available(p)) return 9;
if (phase == 2) {
+12
View File
@@ -680,6 +680,18 @@ int uu_portal_button(struct uu_portal *p, int button, int pressed) {
if (!code) return 11;
return notify(p, "NotifyPointerButton", g_variant_new("(o@a{sv}iu)", p->session, empty_options(), code, (guint)!!pressed));
}
/* Smooth scroll in stream pixels (positive scrolls down/right, like a touchpad); `finish` ends the
* gesture so clients may coast. */
int uu_portal_scroll(struct uu_portal *p, double dx, double dy, int finish) {
if (!p || !isfinite(dx) || !isfinite(dy)) return 11;
if (p->logical_width <= 0 || p->logical_height <= 0 || !p->width || !p->height) return 11;
int result = prepare_input(p); if (result) return result;
double lx = dx * p->logical_width / p->width, ly = dy * p->logical_height / p->height;
if (p->ei) return portal_eis_scroll(p, lx, ly, finish);
GVariantBuilder options; g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT);
if (finish) g_variant_builder_add(&options, "{sv}", "finish", g_variant_new_boolean(TRUE));
return notify(p, "NotifyPointerAxis", g_variant_new("(oa{sv}dd)", p->session, &options, lx, ly));
}
/* One finger (slot 0) in stream pixels: phase 0 down, 1 motion, 2 up. */
int uu_portal_touch_supported(struct uu_portal *p) { return p && (p->devices & 4); }
/* The portal offers a touchscreen this session's consent did not grant (restored from before touch). */
+1
View File
@@ -25,6 +25,7 @@ int uu_portal_capture(struct uu_portal *portal, uint8_t *bgra, size_t length);
int uu_portal_capture_since(struct uu_portal *portal, uint8_t *bgra, size_t length, uint64_t *revision);
int uu_portal_move(struct uu_portal *portal, double x, double y, int relative);
int uu_portal_button(struct uu_portal *portal, int button, int pressed);
int uu_portal_scroll(struct uu_portal *portal, double dx, double dy, int finish);
int uu_portal_touch_supported(struct uu_portal *portal);
int uu_portal_touch_available(struct uu_portal *portal);
int uu_portal_touch(struct uu_portal *portal, int phase, double x, double y);
+105 -12
View File
@@ -48,11 +48,36 @@ struct HeldInput { buttons: std::collections::BTreeSet<i32>, keys: std::collecti
struct Shortcuts { modifiers: u8, shifted: std::collections::BTreeSet<i32> }
/// Mobile viewers in touch mode send a finger as a left-button drag at absolute positions (observed:
/// Android sends press, a stream of mouse_move_absolute, release), which on a desktop selects text
/// instead of scrolling. With the portal touchscreen granted those drags are replayed as one finger,
/// so the desktop scrolls and taps as on a touch screen. `at` is the last absolute position; relative
/// motion (the viewers' trackpad mode) clears it and keeps mouse buttons.
/// instead of scrolling. By default (`Gesture`) the host decides per press: moving past `SLOP` before
/// `HOLD` scrolls smoothly (content follows the finger, also in terminals), holding still selects
/// like a mouse drag, and a short press is a click. `UU_TOUCH_INPUT=touch` replays drags as one finger
/// on the portal touchscreen instead; `=0` keeps mouse buttons. `at` is the last absolute position;
/// relative motion (the viewers' trackpad mode) clears it and keeps mouse buttons.
#[derive(Default)]
struct TouchDrag { mobile: bool, at: Option<(i32,i32)>, down: bool }
struct TouchDrag { mode: TouchMode, at: Option<(i32,i32)>, down: bool, finger: Finger }
#[derive(Clone, Copy, Debug, Default, PartialEq)]
enum TouchMode { #[default] Mouse, Gesture, Touch }
/// A mobile left press in gesture mode: not decided yet, scrolling, or selecting with button 1 down.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
enum Finger { #[default] Up, Pending { start: (i32,i32), at: std::time::Instant }, Scroll { last: (i32,i32) }, Select }
/// Pixels a finger may wander before a press becomes a scroll, and how long it holds still to select.
const SLOP: i32 = 12;
const HOLD: std::time::Duration = std::time::Duration::from_millis(450);
/// What an absolute position does to the finger: the next state and a scroll from→to or a pointer move.
#[derive(Debug, PartialEq)]
enum FingerStep { Scroll((i32,i32),(i32,i32)), Move(i32,i32), Stay }
fn finger_motion(finger: Finger, to: (i32,i32)) -> (Finger, FingerStep) {
match finger {
Finger::Pending { start, .. } if (to.0-start.0).abs().max((to.1-start.1).abs()) > SLOP => (Finger::Scroll { last: to }, FingerStep::Scroll(start, to)),
Finger::Pending { .. } => (finger, FingerStep::Stay),
Finger::Scroll { last } => (Finger::Scroll { last: to }, FingerStep::Scroll(last, to)),
Finger::Select | Finger::Up => (finger, FingerStep::Move(to.0, to.1)),
}
}
/// A pending press held still for `HOLD`: where the selection starts.
fn finger_held(finger: Finger, now: std::time::Instant) -> Option<(i32,i32)> {
match finger { Finger::Pending { start, at } if now.duration_since(at) >= HOLD => Some(start), _ => None }
}
/// Viewer platform from the connect header `controller_platform` (website enum: 1 windows, 2 android,
/// 3 ios, 4 macos, 5 tv).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
@@ -137,11 +162,25 @@ impl InputInjector {
let mut pending = self.pending.lock().unwrap();
let motion = std::mem::take(&mut *pending);
pending.scroll = (motion.scroll.0 % 120, motion.scroll.1 % 120);
let mut touch = self.touch.lock().unwrap();
if let Some((x,y)) = motion.absolute {
let mut touch = self.touch.lock().unwrap();
if touch.down { self.inject_touch(1,x,y); } else { self.inject_move(x,y,false); }
if touch.down { self.inject_touch(1,x,y); } else {
let (finger, step) = finger_motion(touch.finger, (x,y));
touch.finger = finger;
match step {
FingerStep::Scroll(from,to) => { self.inject_scroll(from,to,false); },
FingerStep::Move(x,y) => { self.inject_move(x,y,false); },
FingerStep::Stay => {},
}
}
touch.at = Some((x,y));
}
// Held still: select from where the finger went down, like a mouse drag.
if let Some((x,y)) = finger_held(touch.finger, std::time::Instant::now()) {
self.inject_move(x,y,false);
touch.finger = if self.inject_button(1,true) == 0 { Finger::Select } else { Finger::Up };
}
drop(touch);
if motion.relative != (0,0) {
self.touch.lock().unwrap().at = None;
self.inject_move(motion.relative.0 as i32,motion.relative.1 as i32,true);
@@ -206,18 +245,31 @@ impl InputInjector {
}
/// The current desktop controller's platform (connect header controller_platform).
/// `UU_TOUCH_INPUT=0` keeps mobile drags as mouse drags.
/// Mobile drags follow `UU_TOUCH_INPUT`: unset = gesture, `touch` = portal touchscreen, `0` = mouse.
pub fn set_controller(&self, controller: Controller) {
self.mac_controller.store(controller == Controller::Mac, std::sync::atomic::Ordering::Relaxed);
*self.cmd.lock().unwrap() = CmdState::default();
let mut touch = self.touch.lock().unwrap();
if touch.down { self.inject_touch(2,0,0); }
*touch = TouchDrag { mobile: controller == Controller::Mobile && std::env::var("UU_TOUCH_INPUT").as_deref() != Ok("0"), ..TouchDrag::default() };
self.lift_finger(&mut touch);
let mode = if controller != Controller::Mobile { TouchMode::Mouse } else {
match std::env::var("UU_TOUCH_INPUT").as_deref() { Ok("0") => TouchMode::Mouse, Ok("touch") => TouchMode::Touch, _ => TouchMode::Gesture }
};
*touch = TouchDrag { mode, ..TouchDrag::default() };
}
/// Ends whatever a finger holds: the touch point, a selection's button, a scroll gesture.
fn lift_finger(&self, touch: &mut TouchDrag) {
if std::mem::take(&mut touch.down) { self.inject_touch(2,0,0); }
match std::mem::take(&mut touch.finger) {
Finger::Select => { self.inject_button(1,false); },
Finger::Scroll { last } => { self.inject_scroll(last,last,true); },
Finger::Pending { .. } | Finger::Up => {},
}
}
/// Left button of a mobile controller: a finger down at the last absolute position, or up.
/// False leaves the button to the mouse path (no touchscreen, trackpad mode, other viewers).
fn touch_button(&self, pressed: bool) -> bool {
let mut touch = self.touch.lock().unwrap();
if touch.mode == TouchMode::Gesture { return self.gesture_button(&mut touch, pressed) }
if !pressed {
if !touch.down { return false; }
touch.down = false;
@@ -225,7 +277,7 @@ impl InputInjector {
return true;
}
if touch.down { return true; }
let Some((x,y)) = touch.at.filter(|_| touch.mobile) else { return false };
let Some((x,y)) = touch.at.filter(|_| touch.mode == TouchMode::Touch) else { return false };
let supported = self.backend == crate::desktop_backend::DesktopBackend::Portal
&& self.portal.lock().unwrap().as_ref().is_some_and(|portal| portal.touch_supported());
static REPORTED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
@@ -236,6 +288,33 @@ impl InputInjector {
touch.down = supported && self.inject_touch(0,x,y) == 0;
touch.down
}
/// Gesture mode (portal only, for its smooth scroll): a press waits for `finger_motion`/`finger_held`
/// to decide; releasing an undecided press is a click.
fn gesture_button(&self, touch: &mut TouchDrag, pressed: bool) -> bool {
if !pressed {
return match std::mem::take(&mut touch.finger) {
Finger::Up => false,
Finger::Pending { start, .. } => {
self.inject_move(start.0,start.1,false);
if self.inject_button(1,true) == 0 { self.inject_button(1,false); }
true
},
finger => { touch.finger = finger; self.lift_finger(touch); true },
};
}
if touch.finger != Finger::Up { return true }
let bound = self.backend == crate::desktop_backend::DesktopBackend::Portal && self.portal.lock().unwrap().is_some();
let Some(start) = touch.at.filter(|_| bound) else { return false };
static REPORTED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
if !REPORTED.swap(true, std::sync::atomic::Ordering::Relaxed) { log::info!("Mobile controller drag input: gesture (drag scrolls, hold selects)"); }
touch.finger = Finger::Pending { start, at: std::time::Instant::now() };
true
}
/// Content follows the finger: moving it up scrolls down.
fn inject_scroll(&self, from: (i32,i32), to: (i32,i32), finish: bool) -> i32 {
let Some(portal) = self.portal.lock().unwrap().clone() else { return -1 };
self.portal_result("scroll", portal.scroll(f64::from(from.0 - to.0), f64::from(from.1 - to.1), finish))
}
/// The portal offers a touchscreen the restored consent lacks: ask the host once per run, in the
/// background (GNOME's share dialog, visible to the phone too); drags stay mouse drags meanwhile.
fn offer_touch_consent(&self) {
@@ -342,7 +421,7 @@ impl InputInjector {
pub fn release_held(&self) {
let _serial=self.serial.lock().unwrap();
self.discard_pointer();
{ let mut touch=self.touch.lock().unwrap(); if std::mem::take(&mut touch.down) { self.inject_touch(2,0,0); } }
{ let mut touch=self.touch.lock().unwrap(); self.lift_finger(&mut touch); }
let mut held=self.held.lock().unwrap();
if let Some(uinput)=&self.uinput {
Self::uinput_result(uinput.release_all());
@@ -811,6 +890,20 @@ mod touch_tests {
assert_eq!(Controller::from_platform(None), Controller::Other);
}
#[test]
fn a_press_scrolls_past_the_slop_and_selects_when_held() {
let t0=std::time::Instant::now();
let pending=Finger::Pending{start:(100,100),at:t0};
// Small wander stays undecided; past SLOP the content follows the finger from the start.
assert_eq!(finger_motion(pending,(105,110)),(pending,FingerStep::Stay));
assert_eq!(finger_motion(pending,(100,100+SLOP+1)),(Finger::Scroll{last:(100,113)},FingerStep::Scroll((100,100),(100,113))));
assert_eq!(finger_motion(Finger::Scroll{last:(100,113)},(100,90)),(Finger::Scroll{last:(100,90)},FingerStep::Scroll((100,113),(100,90))));
assert_eq!(finger_motion(Finger::Select,(7,8)),(Finger::Select,FingerStep::Move(7,8)));
assert_eq!(finger_motion(Finger::Up,(7,8)),(Finger::Up,FingerStep::Move(7,8)));
assert_eq!(finger_held(pending,t0+HOLD-std::time::Duration::from_millis(1)),None);
assert_eq!(finger_held(pending,t0+HOLD),Some((100,100)));
assert_eq!(finger_held(Finger::Scroll{last:(1,1)},t0+HOLD*4),None);
}
#[test]
fn mobile_drag_without_touchscreen_stays_a_mouse_button() {
let input=InputInjector::without_desktop();
input.set_controller(Controller::Mobile);
@@ -821,7 +914,7 @@ mod touch_tests {
input.mouse_relative(1,1); input.flush_pointer();
assert!(input.touch.lock().unwrap().at.is_none());
input.set_controller(Controller::Other);
assert!(!input.touch.lock().unwrap().mobile);
assert_eq!(input.touch.lock().unwrap().mode,TouchMode::Mouse);
}
}
+8
View File
@@ -38,6 +38,7 @@ mod native {
fn uu_portal_move(portal: *mut c_void, x: f64, y: f64, relative: i32) -> i32;
fn uu_portal_button(portal: *mut c_void, button: i32, pressed: i32) -> i32;
fn uu_portal_key(portal: *mut c_void, keysym: u32, keycode: i32, pressed: i32) -> i32;
fn uu_portal_scroll(portal: *mut c_void, dx: f64, dy: f64, finish: i32) -> i32;
fn uu_portal_touch_supported(portal: *mut c_void) -> i32;
fn uu_portal_touch_available(portal: *mut c_void) -> i32;
fn uu_portal_touch(portal: *mut c_void, phase: i32, x: f64, y: f64) -> i32;
@@ -403,6 +404,12 @@ mod native {
super::check(unsafe { uu_portal_key(handle.0.as_ptr(), symbol, -1, 1) })?;
super::check(unsafe { uu_portal_key(handle.0.as_ptr(), symbol, -1, 0) })
}
/// Smooth scroll in stream pixels (positive scrolls down/right); `finish` ends the gesture.
pub fn scroll(&self, dx: f64, dy: f64, finish: bool) -> Result<(), String> {
if *self.locked.borrow() != Some(false) { return Err("Portal input blocked while locked".into()); }
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
super::check(unsafe { uu_portal_scroll(handle.0.as_ptr(), dx, dy, i32::from(finish)) })
}
/// The portal granted the touchscreen device type (requested where available).
pub fn touch_supported(&self) -> bool {
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_touch_supported(handle.0.as_ptr()) } != 0)
@@ -735,6 +742,7 @@ impl PortalSession {
pub fn move_pointer(&self, _: f64, _: f64, _: bool) -> Result<(), String> { Err(error(15)) }
pub fn button(&self, _: i32, _: bool) -> Result<(), String> { Err(error(15)) }
pub fn touch_supported(&self) -> bool { false }
pub fn scroll(&self, _: f64, _: f64, _: bool) -> Result<(), String> { Err(error(15)) }
pub fn upgrade_touch(&self) -> Result<bool, String> { Err(error(15)) }
pub fn type_keysym(&self, _: u32) -> Result<(), String> { Err(error(15)) }
pub fn touch(&self, _: i32, _: f64, _: f64) -> Result<(), String> { Err(error(15)) }
+15 -1
View File
@@ -168,7 +168,8 @@ static void handle_server_events(struct harness *h) {
} else if (type == EIS_EVENT_POINTER_MOTION || type == EIS_EVENT_POINTER_MOTION_ABSOLUTE ||
type == EIS_EVENT_BUTTON_BUTTON || type == EIS_EVENT_SCROLL_DISCRETE ||
type == EIS_EVENT_KEYBOARD_KEY || type == EIS_EVENT_TOUCH_DOWN ||
type == EIS_EVENT_TOUCH_MOTION || type == EIS_EVENT_TOUCH_UP) {
type == EIS_EVENT_TOUCH_MOTION || type == EIS_EVENT_TOUCH_UP ||
type == EIS_EVENT_SCROLL_DELTA || type == EIS_EVENT_SCROLL_STOP) {
assert(h->n_events < sizeof(h->events) / sizeof(h->events[0]));
struct received *got = &h->events[h->n_events++];
got->type = type;
@@ -189,6 +190,10 @@ static void handle_server_events(struct harness *h) {
got->dx = eis_event_scroll_get_discrete_dx(event);
got->dy = eis_event_scroll_get_discrete_dy(event);
break;
case EIS_EVENT_SCROLL_DELTA:
got->x = eis_event_scroll_get_dx(event);
got->y = eis_event_scroll_get_dy(event);
break;
case EIS_EVENT_TOUCH_DOWN:
case EIS_EVENT_TOUCH_MOTION:
got->x = eis_event_touch_get_x(event);
@@ -397,6 +402,15 @@ static void run_geometry(const struct geometry *geometry) {
assert(h.events[0].type == EIS_EVENT_SCROLL_DISCRETE);
assert(h.events[0].dx == 0 && h.events[0].dy == -120);
/* Smooth scroll maps like relative motion; finish ends the gesture with a scroll stop. */
clear_events(&h);
assert(uu_portal_scroll(h.portal, geometry->width / 8.0, -(double)geometry->height / 8.0, 1) == 0);
wait_for_input(&h);
assert(h.events[0].type == EIS_EVENT_SCROLL_DELTA);
assert(fabs(h.events[0].x - geometry->logical_width / 8.0) < 0.001 && fabs(h.events[0].y + geometry->logical_height / 8.0) < 0.001);
for (gint64 until = g_get_monotonic_time() + 300000; h.n_events < 2 && g_get_monotonic_time() < until; g_usleep(1000)) pump(&h);
assert(h.n_events == 2 && h.events[1].type == EIS_EVENT_SCROLL_STOP);
/* A touch drag lands in the stream's region; motion without a finger down is refused. */
assert(uu_portal_touch(h.portal, 1, 1, 1) == 11);
clear_events(&h);
+20 -1
View File
@@ -18,6 +18,7 @@ enum response_mode { UNKNOWN_METHOD, NOT_SUPPORTED, TEMPORARY_FAILURE, NO_FDS, B
static enum response_mode mode;
static unsigned connects, legacy_calls;
static double last_x, last_y;
static int last_finish;
static GVariant *test_call(GDBusConnection *bus, const gchar *dest, const gchar *path,
const gchar *interface, const gchar *method, GVariant *parameters,
@@ -27,7 +28,15 @@ static GVariant *test_call(GDBusConnection *bus, const gchar *dest, const gchar
assert(!strcmp(method, "NotifyKeyboardKeysym") || !strcmp(method, "NotifyPointerButton") ||
!strcmp(method, "NotifyPointerAxisDiscrete") || !strcmp(method, "NotifyPointerMotion") ||
!strcmp(method, "NotifyPointerMotionAbsolute") || !strcmp(method, "NotifyTouchDown") ||
!strcmp(method, "NotifyTouchMotion") || !strcmp(method, "NotifyTouchUp"));
!strcmp(method, "NotifyTouchMotion") || !strcmp(method, "NotifyTouchUp") || !strcmp(method, "NotifyPointerAxis"));
if (!strcmp(method, "NotifyPointerAxis")) {
assert(g_variant_is_of_type(parameters, G_VARIANT_TYPE("(oa{sv}dd)")));
GVariant *options = g_variant_get_child_value(parameters, 1);
GVariant *x = g_variant_get_child_value(parameters, 2), *y = g_variant_get_child_value(parameters, 3);
last_x = g_variant_get_double(x); last_y = g_variant_get_double(y);
gboolean finish = FALSE; last_finish = g_variant_lookup(options, "finish", "b", &finish) && finish;
g_variant_unref(options); g_variant_unref(x); g_variant_unref(y);
}
if (!strcmp(method, "NotifyTouchDown") || !strcmp(method, "NotifyTouchMotion")) {
assert(g_variant_is_of_type(parameters, G_VARIANT_TYPE("(oa{sv}uudd)")));
GVariant *x = g_variant_get_child_value(parameters, 4);
@@ -102,6 +111,14 @@ static void legacy_input(struct uu_portal *p) {
assert(legacy_calls == 7 && uu_portal_alive(p) && !p->ei);
}
/* Smooth scroll maps like relative motion; only the last event of a gesture carries "finish". */
static void legacy_scroll(struct uu_portal *p) {
unsigned before = legacy_calls;
assert(uu_portal_scroll(p, 20, -40, 0) == 0);
assert(last_x == 20. * p->logical_width / p->width && last_y == -40. * p->logical_height / p->height && !last_finish);
assert(uu_portal_scroll(p, 0, 0, 1) == 0 && last_finish && last_x == 0 && last_y == 0);
assert(uu_portal_scroll(p, NAN, 0, 0) == 11 && legacy_calls == before + 2);
}
/* Touch needs the granted touchscreen type and uses the same stream mapping as absolute motion. */
static void legacy_touch(struct uu_portal *p) {
p->devices = 3;
@@ -131,11 +148,13 @@ int main(void) {
p = session(0, 1, 1); /* Unscaled GNOME keeps Notify*. */
legacy_input(p);
legacy_touch(p);
legacy_scroll(p);
assert(!connects);
uu_portal_close(p);
p = session(1, 0, 1); /* KDE keeps its compositor-logical mapping. */
legacy_input(p);
legacy_touch(p);
legacy_scroll(p);
assert(!connects);
uu_portal_close(p);