lib/input

Keyboard, pointer, touch, wheel, and gamepad capture on the stream element, sent to the server as the text messages of the input protocol.

Keyboard: every event resolves to an X11 keysym through noVNC's key tables and KeyboardUtil, and what is held server-side is tracked per physical code so a keyup releases what its keydown pressed. While anything is held a kh heartbeat repeats the held keysyms so the server can release keys whose keyup was lost, and modifiers a trusted event reports up are healed. IME composition streams the preedit as momentary presses diffed per codepoint; a shortcut chord pressed mid-composition is held until the commit lands so it applies after the text. A soft keyboard types into the off-screen assist field, whose value is mirrored to the server by the same diff and emptied once nothing composes in it. Chords on non-Latin layouts resolve from the physical key position, and a chord whose modifier keydown never reached the server is sent self-contained, wrapped in the missing modifiers. macOS Command is remapped onto Control, and Windows defers a ControlLeft keydown briefly to tell AltGr apart.

Pointer: absolute positions map through the presenting sink (the canvas or <video> box) where the stream has a fixed size, and through the element's window math otherwise; motion goes out as it arrives, from pointerrawupdate where the engine fires it, no closer together than MOTION_SEND_INTERVAL_MS apart. Under pointer lock the payload is a relative delta, scaled to server pixels and quantized with a carried remainder. Gaming mode is document fullscreen plus pointer and keyboard lock. Touch is direct (tap, drag, long-press right click, two-finger scroll and pinch) or a trackpad emulation. Wheel events are classified as discrete wheel or trackpad and accumulated in fractional notches so no distance is lost; a macOS wheel, whose deltas the system accelerates past any notch size, is one notch a detent (_isDetentWheel), and a WebKitGTK wheel, whose notch shrinks with the view, goes by the notches it reports (_webKitGtkWheelNotches). A pinch, on the touchscreen or a touchpad, reaches the session as Ctrl+wheel. The server-drawn cursor is painted on a page canvas or applied as a CSS cursor; in trackpad mode the canvas is drawn where the server echoes the pointer, moved on by the deltas sent since (onPointerEcho).

Wire messages: kd,<keysym>, ku,<keysym>, kh,<keysym>,..., kr; m,<x>,<y>,<mask>,<magnitude> (absolute) and m2,<dx>,<dy>,<mask>,<magnitude> (relative; scroll pulses ride mask bits 3 to 7); p,<0|1> and SET_NATIVE_CURSOR_RENDERING,<0|1> on pointer lock changes, the latter also where trackpad mode gets no pointer echo; js,c, js,d, js,b, js,a, and js,h for gamepads, whose rumble comes back as the system action rumble,<slot>,<strong>,<weak>,<ms> (rumble); _pointer_echo,<0|1> in trackpad mode, answered by the system action pointer,<display>,<x>,<y>,<scale>,<seq> or pointer,none; and, where the session takes a touchpad's scroll as a finger's, sf,<dx>,<dy> in stream pixels and sfe at its end (setFingerScroll).

ClassesCopy Anchor Link

InputCopy Anchor Link

Defined in: lib/input.js:1511

Captures input on the stream element and sends it to the server.

One instance is live per page: attach detaches any previous one. Hotkeys: Ctrl+Shift+M opens the dashboard menu (onmenuhotkey), Ctrl+Shift+F enters plain fullscreen (onfullscreenhotkey, enterFullscreen by default), Ctrl+Shift+X toggles gaming mode (ongaminghotkey, toggleGamingMode by default), Ctrl+Shift+G toggles the gamepad overlay (ongamepadhotkey), and Ctrl+Shift+Click takes pointer lock; shortcutsEnabled false passes every one of them to the session instead. Three quick Escape presses in a row also leave gaming mode (_escapeHatch), whatever that flag says. Elements carrying the allow-native-input class keep native keyboard and touch handling.

ConstructorsCopy Anchor Link

ConstructorCopy Anchor Link

new Input(
   element, 
   send, 
   isSharedMode?, 
   playerIndex?, 
   useCssScaling?, 
   initialSlot?
): Input;

Defined in: lib/input.js:1521

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

Input

PropertiesCopy Anchor Link

elementCopy Anchor Link

element: HTMLElement;

Defined in: lib/input.js:1522

sendCopy Anchor Link

send: (message) => void;

Defined in: lib/input.js:1523

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

sendMotionCopy Anchor Link

sendMotion: (message) => void;

Defined in: lib/input.js:1530

Sends coalesced pointer motion where the transport has a channel that keeps no order for it, so a lost sample holds nothing behind it; null sends motion through send like every other message.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

motionBacklogCopy Anchor Link

motionBacklog: () => number;

Defined in: lib/input.js:1536

Bytes the transport still holds ahead of the next pointer motion message, or null where it cannot say.

ReturnsCopy Anchor Link

number

isSharedModeCopy Anchor Link

isSharedMode: boolean;

Defined in: lib/input.js:1539

controllerSlotsCopy Anchor Link

controllerSlots: number[];

Defined in: lib/input.js:1541

The one-based slots the server assigned, in the order the pads take them, or null (slotList).

playerIndexCopy Anchor Link

playerIndex: number;

Defined in: lib/input.js:1542

cursorDivCopy Anchor Link

cursorDiv: HTMLCanvasElement;

Defined in: lib/input.js:1543

cursorImgCopy Anchor Link

cursorImg: CanvasRenderingContext2D;

Defined in: lib/input.js:1552

cursorHotspotCopy Anchor Link

cursorHotspot: object;

Defined in: lib/input.js:1554

xCopy Anchor Link

x: number = 0;

yCopy Anchor Link

y: number = 0;

use_browser_cursorsCopy Anchor Link

use_browser_cursors: boolean;

Defined in: lib/input.js:1558

displayIdCopy Anchor Link

displayId: string;

Defined in: lib/input.js:1562

The display this page renders, which the pointer echo names (onPointerEcho).

fingerScrollCopy Anchor Link

fingerScroll: boolean;

Defined in: lib/input.js:1572

Whether the session takes a touchpad's scroll as a finger's (setFingerScroll).

useCssScalingCopy Anchor Link

useCssScaling: boolean;

Defined in: lib/input.js:1576

mCopy Anchor Link

m: object;

Defined in: lib/input.js:1578

mouseMultiXCopy Anchor Link

mouseMultiX: number;

mouseMultiYCopy Anchor Link

mouseMultiY: number;

mouseOffsetXCopy Anchor Link

mouseOffsetX: number = offsetX;

mouseOffsetYCopy Anchor Link

mouseOffsetY: number = offsetY;

elementClientXCopy Anchor Link

elementClientX: number = elementRect.left;

elementClientYCopy Anchor Link

elementClientY: number = elementRect.top;

frameWCopy Anchor Link

frameW: number;

frameHCopy Anchor Link

frameH: number;

buttonMaskCopy Anchor Link

buttonMask: number;

Defined in: lib/input.js:1591

gamepadManagerCopy Anchor Link

gamepadManager: GamepadManager;

Defined in: lib/input.js:1592

gamepadRumbleCopy Anchor Link

gamepadRumble: boolean;

Defined in: lib/input.js:1596

Pads play the rumble the server relays (setGamepadRumble).

xCopy Anchor Link

x: number;

Defined in: lib/input.js:1597

yCopy Anchor Link

y: number;

Defined in: lib/input.js:1598

onmenuhotkeyCopy Anchor Link

onmenuhotkey: any;

Defined in: lib/input.js:1608

gamingModeCopy Anchor Link

gamingMode: boolean;

Defined in: lib/input.js:1609

shortcutsEnabledCopy Anchor Link

shortcutsEnabled: boolean;

Defined in: lib/input.js:1612

ongamingmodeCopy Anchor Link

ongamingmode: any;

Defined in: lib/input.js:1615

onnoticeCopy Anchor Link

onnotice: any;

Defined in: lib/input.js:1616

onfullscreenhotkeyCopy Anchor Link

onfullscreenhotkey: () => void;

Defined in: lib/input.js:1617

Fullscreen with no lock, leaving the pointer and the keyboard to the browser: the dashboard button and the Ctrl+Shift+F chord land here. The whole document goes fullscreen, not the stream container: the dashboard overlay is a body-level sibling, which container fullscreen would hide.

ReturnsCopy Anchor Link

void

ongaminghotkeyCopy Anchor Link

ongaminghotkey: () => void;

Defined in: lib/input.js:1618

Gaming mode on the Ctrl+Shift+X chord. Leaving it drops fullscreen, which is what releases both locks through the fullscreenchange handler; a mode left set without fullscreen (a refused request) is cleared directly.

ReturnsCopy Anchor Link

void

ongamepadhotkeyCopy Anchor Link

ongamepadhotkey: any;

Defined in: lib/input.js:1619

ongamepadconnectedCopy Anchor Link

ongamepadconnected: any;

Defined in: lib/input.js:1620

ongamepaddisconnectedCopy Anchor Link

ongamepaddisconnected: any;

Defined in: lib/input.js:1621

listenersCopy Anchor Link

listeners: any[];

Defined in: lib/input.js:1622

listeners_contextCopy Anchor Link

listeners_context: any[];

Defined in: lib/input.js:1623

cursorScaleFactorCopy Anchor Link

cursorScaleFactor: any;

Defined in: lib/input.js:1658

isComposingCopy Anchor Link

isComposing: boolean;

Defined in: lib/input.js:1680

compositionStringCopy Anchor Link

compositionString: string;

Defined in: lib/input.js:1681

keyboardInputAssistCopy Anchor Link

keyboardInputAssist: HTMLElement;

Defined in: lib/input.js:1695

trackpadSpeedCopy Anchor Link

trackpadSpeed: number;

Defined in: lib/input.js:1716

The dashboards' trackpad speed, scaling the accelerated travel (setTrackpadSpeed).

inputAttachedCopy Anchor Link

inputAttached: boolean;

Defined in: lib/input.js:1717

rawPointerMotionCopy Anchor Link

static rawPointerMotion: boolean;

Defined in: lib/input.js:1765

Whether pointer lock asks for raw movement: the raw_pointer_motion setting, which the core resolves and pushes through setRawPointerMotion. Until it does, the platform decides: off on macOS, where the engine grants the option instead of refusing it and nothing replaces the acceleration curve it takes away. The client scales a locked delta by the stream box and quantizes it (_relativeToServer), but that gain is the same at every speed, so the slow motion the curve used to expand now covers far less of the remote screen and the pointer feels heavy. Windows grants it as well and is left on it: raw deltas are what pointer lock is for, and nobody has reported the same there.

macCmdAsCtrlCopy Anchor Link

static macCmdAsCtrl: boolean = true;

Defined in: lib/input.js:1776

Whether a macOS Command chord reaches the session as its Control chord: the mac_cmd_as_ctrl setting, which the core pushes through setMacCmdAsCtrl. On by default, so Cmd+C copies in the remote application the way it does locally. Off sends Command as the Super it physically is, which is what a session whose window manager takes Super as its own modifier needs: remapped, its Cmd+Return arrives as Ctrl+Return and its Cmd+C interrupts the foreground program.

MethodsCopy Anchor Link

setSharedMode()Copy Anchor Link

setSharedMode(enabled): void;

Defined in: lib/input.js:1721

Sets whether this is a viewer-only session.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

updateControllerSlot()Copy Anchor Link

updateControllerSlot(newSlot): void;

Defined in: lib/input.js:1732

Assigns the one-based controller slot the server gave this client, or the list of them, and announces the pads that drive them there: a js,c sent before the slot was known was refused by the server's slot gate, which left the pad unassociated.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

updateServerCursor()Copy Anchor Link

updateServerCursor(cursorData): Promise<void>;

Defined in: lib/input.js:1910

Applies a cursor update from the server; an empty or null-handle update hides the cursor. A new PNG invalidates the cached canvas bitmap even while CSS renders it, so changing modes retains the current shape and size. Trackpad mode always paints the canvas, at the pointer echo, since no local pointer shows where the remote one is.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

Promise<void>

setSynth()Copy Anchor Link

setSynth(isSynth): void;

Defined in: lib/input.js:1946

Marks input as synthetic (tests), which disables the keydown stuck-modifier heal.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

updateCssScaling()Copy Anchor Link

updateCssScaling(newUseCssScalingValue): void;

Defined in: lib/input.js:1952

Switches CSS-pixel scaling and re-derives the window math and cursor.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

resetKeyboard()Copy Anchor Link

resetKeyboard(): void;

Defined in: lib/input.js:2110

Releases every held key and stops the heartbeat. The armed Windows AltGr timer is canceled so it cannot synthesize a Control keydown after the reset, while the page is hidden or detached.

ReturnsCopy Anchor Link

void

releaseInput()Copy Anchor Link

releaseInput(): void;

Defined in: lib/input.js:2129

Releases every held key and pointer button, and a trackpad tap's pending release. A press whose release goes to another tab or app (a tab switched mid-press, a touch the system took for a gesture) left the remote button down: every motion after it dragged, and the next press went to a button already down and did nothing, until a motion over the stream stated the buttons again.

ReturnsCopy Anchor Link

void

setTrackpadSpeed()Copy Anchor Link

setTrackpadSpeed(speed): void;

Defined in: lib/input.js:3436

Sets how far the trackpad moves the pointer for a finger's travel, as a factor on the accelerated gain; the dashboards' setting, persisted by the core as trackpad_speed.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

setDisplayLayouts()Copy Anchor Link

setDisplayLayouts(layouts, ownId): void;

Defined in: lib/input.js:3695

Sets the extended-desktop layout the mapping above uses: display rectangles in remote pixels, keyed by display id, each carrying the owning page's CSS-to-remote scale where known, and its stream box in desktop coordinates where that page has published one. Fewer than two valid rectangles (or no entry for ownId) disables cross-display mapping.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

setStreamDensity()Copy Anchor Link

setStreamDensity(density): void;

Defined in: lib/input.js:3922

Sets the density the core streams this page at, or null to derive it from the page's own; the window math and cursor follow it.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

setTrackpadMode()Copy Anchor Link

setTrackpadMode(enabled): void;

Defined in: lib/input.js:4031

Switches trackpad emulation, clearing touch state and any held button.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

resumePointerEcho()Copy Anchor Link

resumePointerEcho(): void;

Defined in: lib/input.js:4063

The transport connected again: a trackpad page asks the new connection for the pointer echo, since the last one's ended with it.

ReturnsCopy Anchor Link

void

onPointerEcho()Copy Anchor Link

onPointerEcho(action): void;

Defined in: lib/input.js:4128

Takes a pointer echo: the system action pointer,<display>,<x>,<y>,<scale>,<seq>, the position in that display's server pixels, the physical pixels a relative one moves it there, and the last pointer message of this page the position includes; or pointer,none from a session that cannot say where its pointer is.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

setRawPointerMotion()Copy Anchor Link

setRawPointerMotion(enabled): void;

Defined in: lib/input.js:4195

Applies the raw pointer motion setting. A lock the stream already holds is re-requested with the new option, which switches the running lock in place on engines that allow it rather than deferring the change to the next lock; an engine that refuses the option falls back the way a first request does.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

setShortcutsEnabled()Copy Anchor Link

setShortcutsEnabled(enabled): void;

Defined in: lib/input.js:4216

Whether the client keeps its own chords rather than passing them on.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

setMacCmdAsCtrl()Copy Anchor Link

setMacCmdAsCtrl(enabled): void;

Defined in: lib/input.js:4220

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

setUseBrowserCursors()Copy Anchor Link

setUseBrowserCursors(enabled): Promise<void>;

Defined in: lib/input.js:4233

Switches between the CSS cursor and the page-drawn cursor canvas.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

Promise<void>

setFingerScroll()Copy Anchor Link

setFingerScroll(enabled): void;

Defined in: lib/input.js:4938

Sets whether the session takes a touchpad's scroll as a finger's: the display config's finger_scroll, a Wayland session's. There a wheel classified as a touchpad sends its travel instead of notches (_isFingerScroll); a wheel's notches, line and page deltas, and X11 stay as they are.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

rumble()Copy Anchor Link

rumble(
   slot, 
   strong, 
   weak, 
   durationMs
): void;

Defined in: lib/input.js:5184

Plays the rumble the server relays for a pad slot, on this client's pads when the slot is the one they drive (GamepadManager.rumble); a client holding several slots plays it on the pad driving that one.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

setGamepadRumble()Copy Anchor Link

setGamepadRumble(on): void;

Defined in: lib/input.js:5201

Turns rumble on this client's pads on or off (the dashboards' toggle, persisted by the core as gamepad_rumble); off stops one playing.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

stopRumble()Copy Anchor Link

stopRumble(): void;

Defined in: lib/input.js:5207

Stops a rumble playing on this client's pads: its connection is gone.

ReturnsCopy Anchor Link

void

getWindowResolution()Copy Anchor Link

getWindowResolution(): number[];

Defined in: lib/input.js:5359

The page size in device pixels, rounded down to even.

ReturnsCopy Anchor Link

number[]

Width and height.

resize()Copy Anchor Link

resize(): void;

Defined in: lib/input.js:5369

Re-derives the window math after a layout change.

ReturnsCopy Anchor Link

void

isInputAttached()Copy Anchor Link

isInputAttached(): boolean;

Defined in: lib/input.js:5374

True while the full input context is attached.

ReturnsCopy Anchor Link

boolean

attach()Copy Anchor Link

attach(): void;

Defined in: lib/input.js:5388

Attaches the window and document listeners, and the input context unless this is a viewer-only session. Any previously attached instance is detached first: reconnect paths construct a fresh Input, whose predecessor's listeners and gamepad poller would otherwise keep firing alongside it. The overlay element takes focus, since browsers only run IME composition on the focused editable element, unless the user is in another field. Pads are adopted for every role, since a #playerN link grants a gamepad without the rest of the input context.

ReturnsCopy Anchor Link

void

attach_context()Copy Anchor Link

attach_context(): void;

Defined in: lib/input.js:5425

Attaches the keyboard, pointer, touch, wheel, and composition listeners and shows the cursor.

ReturnsCopy Anchor Link

void

resyncGamepads()Copy Anchor Link

resyncGamepads(): void;

Defined in: lib/input.js:5497

Adopts pads the browser already exposes: gamepadconnected fires only on physical connect (or first press), so a re-attach would otherwise leave the pad dead until re-plugged. Public because a channel that opens after attach must re-announce: the js,c it sent into a closed channel was dropped, leaving the server no association to release when the peer goes.

ReturnsCopy Anchor Link

void

detach()Copy Anchor Link

detach(): void;

Defined in: lib/input.js:5520

Removes every listener and the gamepad manager, then the input context.

ReturnsCopy Anchor Link

void

detach_context()Copy Anchor Link

detach_context(): void;

Defined in: lib/input.js:5539

Removes the input context listeners, releases every key and button, and exits pointer lock.

ReturnsCopy Anchor Link

void

enterFullscreen()Copy Anchor Link

enterFullscreen(): void;

Defined in: lib/input.js:5583

Fullscreen with no lock, leaving the pointer and the keyboard to the browser: the dashboard button and the Ctrl+Shift+F chord land here. The whole document goes fullscreen, not the stream container: the dashboard overlay is a body-level sibling, which container fullscreen would hide.

ReturnsCopy Anchor Link

void

toggleGamingMode()Copy Anchor Link

toggleGamingMode(): void;

Defined in: lib/input.js:5596

Gaming mode on the Ctrl+Shift+X chord. Leaving it drops fullscreen, which is what releases both locks through the fullscreenchange handler; a mode left set without fullscreen (a refused request) is cleared directly.

ReturnsCopy Anchor Link

void

enterGamingMode()Copy Anchor Link

enterGamingMode(): void;

Defined in: lib/input.js:5633

Enters gaming mode: fullscreen that also holds the pointer and the keyboard, so a game sees Escape, Alt+Tab, and raw motion instead of the browser. A locked keyboard delivers a short Escape to the session, so holding it is what leaves this mode.

The pointer lock is asked for first, on the gesture that asked for the mode, and fullscreen once the lock settled (_lockOnGesture): a fullscreen request spends the gesture's transient activation, and Chromium refuses a lock asked for without one, in fullscreen as well (Edge on Windows on every entry); a lock taken first survives the switch to fullscreen. Gecko goes the other way round: it grants a lock in fullscreen without a gesture, and measures the first movement of a lock taken before the switch from where the viewport was, so there the fullscreenchange handler takes it once the viewport settled. That handler also asks again wherever the first request did not take, and arms the keyboard lock. A refused fullscreen takes the mode back down with it: left set, the next transition from any source would arm the locks. From a fullscreen the page holds already, an engine without the Keyboard Lock API asks for the same element again with the gaming options: by the Fullscreen spec that sets the element's keyboard lock with no transition (Firefox 156 holds Escape after it); it comes after the pointer lock request, since a fullscreen request consumes the gesture's transient activation.

ReturnsCopy Anchor Link

void

requestKeyboardLock()Copy Anchor Link

requestKeyboardLock(): void;

Defined in: lib/input.js:5775

Locks every key the browser or the system would otherwise take, its own shortcuts (Ctrl+W, Ctrl+T) among them, for gaming mode alone: through the Keyboard Lock API where it exists, else by the fullscreen request's own keyboardLock where the engine took it (_gamingFullscreenOptions), which holds the same keys. Only where neither holds the keys does the user hear that one Escape leaves the mode. A lock the engine refuses leaves the keys to the browser and the system, and only the console says so.

ReturnsCopy Anchor Link

void

releaseKeyboardLock()Copy Anchor Link

releaseKeyboardLock(): void;

Defined in: lib/input.js:5813

Hands the system keys back; a browser that never locked them ignores it.

ReturnsCopy Anchor Link

void

FunctionsCopy Anchor Link

trackpadGain()Copy Anchor Link

function trackpadGain(speed): number;

Defined in: lib/input.js:189

The trackpad's gain at a finger speed: 1, rising along a smoothstep to TRACKPAD_ACCEL_MAX between TRACKPAD_ACCEL_SLOW and TRACKPAD_ACCEL_FAST.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

number

slotList()Copy Anchor Link

function slotList(slot): number[];

Defined in: lib/input.js:202

The one-based gamepad slots a server verdict's slot names, in the order the client's pads take them: one number, a list of them (a token holding several), or none.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

number[]

addListener()Copy Anchor Link

function addListener(
   obj, 
   name, 
   func, 
   ctx, 
   useCapture?
): any[];

Defined in: lib/input.js:5842

Adds a listener bound to ctx, with passive: false so the handler keeps preventDefault().

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

any[]

The tuple removeListeners takes, or null for an invalid target.

removeListeners()Copy Anchor Link

function removeListeners(listeners): void;

Defined in: lib/input.js:5854

Removes listeners added by addListener and empties the list.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void