@illgrenoble/webx-client 1.13.0 → 1.14.0

package/dist/WebXClient.d.ts

@@ -29,8 +29,11 @@ export declare class WebXClient {
     private _mouse;
     private _keyboard;
     private _clipboardHandler;
+    private _keyboardLayoutHandler;
     private _connectionHandler;
     private _maxQualityIndex;
+    private _canResizeScreen;
+    private _keyboardLayoutName;
     /**
      * Gets the WebXTunnel instance used for communication with the WebX Engine.
      */
@@ -56,10 +59,19 @@ export declare class WebXClient {
      * @param handler the handler when clipboard data is received from the server
      */
     set clipboardHandler(handler: (clipboardContent: string) => void);
+    /**
+     * Handles notification that the keyboard layout has been changed in the server.
+     * @param handler the handler when the keyboard layout changes in the server
+     */
+    set keyboardLayoutHandler(value: (keyboardLayoutName: string) => void);
     /**
      * Gets the max quality index of the display.
      */
     get maxQualityIndex(): number;
+    /**
+     * Gets the keyboard layout name
+     */
+    get keyboardLayoutName(): string;
     /**
      * Creates a new instance of the WebXClient.
      *
@@ -169,6 +181,26 @@ export declare class WebXClient {
      * @returns A promise that resolves to image data in Blob form.
      */
     createScreenshot(type: string, quality: number): Promise<Blob>;
+    /**
+     * Requests a change in the screen size. If successful a message will be sent
+     * asynchronously from the engine with the new screen size.
+     *
+     * @param width The requested width of the screen
+     * @param height The requested height of the screen
+     */
+    resizeScreen(width: number, height: number): void;
+    /**
+     * Returns true if the WebXEngine is capable of resizing the screen
+     *
+     * @returns True if screen resizing is available
+     */
+    canResizeScreen(): boolean;
+    /**
+     * Requests a change in the keyboard layout.
+     *
+     * @param layout the keyboard layout
+     */
+    setKeyboardLayout(layout: string): void;
     /**
      * Retrieves the screen message from the WebX Engine.
      *

package/dist/display/WebXDisplay.d.ts

@@ -18,11 +18,11 @@ export declare class WebXDisplay {
     private readonly _scene;
     private readonly _camera;
     private readonly _renderer;
-    private readonly _filter;
+    private _filter;
     private readonly _screen;
     private readonly _isWebGL;
-    private readonly _screenWidth;
-    private readonly _screenHeight;
+    private _screenWidth;
+    private _screenHeight;
     private readonly _options;
     private readonly _windowImageFactory;
     private readonly _containerElement;
@@ -41,6 +41,11 @@ export declare class WebXDisplay {
      * @returns The WebGLRenderer instance.
      */
     get renderer(): THREE.WebGLRenderer | WebXCanvasRenderer;
+    /**
+     * Gets the active filter name if there is one
+     */
+    get filter(): string;
+    set filter(filter: string);
     /**
      * Gets the width of the screen.
      *
@@ -106,6 +111,13 @@ export declare class WebXDisplay {
      * Hides the screen by removing it from the scene.
      */
     hideScreen(): void;
+    /**
+     * Resizes the display to the new screen size
+     *
+     * @param width the new screen width
+     * @param height the new screen height
+     */
+    onScreenResized(width: number, height: number): void;
     /**
      * Disposes of all resources used by the display.
      *
@@ -241,4 +253,8 @@ export declare class WebXDisplay {
      * Returns details about the availability and type of WebGL2 rendering
      */
     private _detectWebGL2;
+    /**
+     * Returns an object with parameters for the filter
+     */
+    private _getFilterParams;
 }

package/dist/display/filter/WebXFilter.d.ts

@@ -9,10 +9,14 @@ import { WebXFilterMaterial } from "./WebXFilterMaterial";
  * effect to the entire screen.
  */
 export declare class WebXFilter {
+    /**
+     * The name of the filter
+     */
+    private readonly _name;
     /**
      * Renderer used for both offscreen and final compositing passes.
      */
-    private _renderer;
+    private readonly _renderer;
     /**
      * Scene containing the single mesh used to draw the filter pass.
      *
@@ -28,6 +32,10 @@ export declare class WebXFilter {
      * May be `null` if no `filterMaterial` was provided.
      */
     private readonly _rtTexture;
+    /**
+     * Returns the name of the filter
+     */
+    get name(): string;
     /**
      * Create a new WebXFilter.
      *
@@ -35,12 +43,13 @@ export declare class WebXFilter {
      * - An offscreen `WebGLRenderTarget` is created with the given width/height.
      * - The filter material's `tDiffuse` is set to the render target's texture (the fully rendered scene of windows)
      *
+     * @param name - The name of the filter
      * @param renderer - WebGL renderer used to perform rendering.
      * @param screenWidth - Width to use for the offscreen render target and screen plane.
      * @param screenHeight - Height to use for the offscreen render target and screen plane.
      * @param filterMaterial - Optional filter material; when omitted the filter pass is disabled.
      */
-    constructor(renderer: THREE.WebGLRenderer, screenWidth: number, screenHeight: number, filterMaterial?: WebXFilterMaterial);
+    constructor(name: string, renderer: THREE.WebGLRenderer, screenWidth: number, screenHeight: number, filterMaterial?: WebXFilterMaterial);
     /**
      * Render the scene with optional post-processing filter. If the scene is dirty then all the webx windows
      * are redrawn. The rendering is done on the render texture if present or the default framebuffer otherwise.
@@ -52,4 +61,8 @@ export declare class WebXFilter {
      * @param isSceneDirty - When true the main scene will be re-rendered.
      */
     render(scene: Scene, camera: Camera, isSceneDirty: boolean): void;
+    /**
+     * Disposes of WebGL elements
+     */
+    dispose(): void;
 }

package/dist/display/filter/WebXFilterFactory.d.ts

@@ -1,5 +1,6 @@
 import { WebXFilter } from "./WebXFilter";
 import { WebGLRenderer } from "three";
+import { WebXCanvasRenderer } from "../../renderer";
 /**
  * WebXFilterFactory
  *
@@ -12,14 +13,14 @@ export declare class WebXFilterFactory {
     /**
      * Build a `WebXFilter` configured with a named filter material.
      *
-     * @param renderer - Three.js WebGLRenderer used for rendering passes.
+     * @param renderer - Three.js WebGLRenderer or WebXCanvasRenderer used for rendering passes (filter is only applied for WebGLRenderer).
      * @param screenWidth - Width in pixels for the offscreen render target and screen plane.
      * @param screenHeight - Height in pixels for the offscreen render target and screen plane.
      * @param name - Name of the filter to create (e.g. `test`, `crt`).
      * @param params - Optional parameters forwarded to the chosen filter material constructor.
      * @returns A `WebXFilter` configured with the selected filter material, or a `WebXFilter` with no filter if the name is unknown.
      */
-    static Build(renderer: WebGLRenderer, screenWidth: number, screenHeight: number, name: string, params: any): WebXFilter;
+    static Build(renderer: WebGLRenderer | WebXCanvasRenderer, screenWidth: number, screenHeight: number, name: string, params?: any): WebXFilter;
     /**
      * Create an instance of a filter material by name.
      *

package/dist/instruction/WebXInstructionType.d.ts

@@ -51,7 +51,15 @@ export declare enum WebXInstructionType {
     /**
      * Instruction to request the window shape image (stencil image).
      */
-    SHAPE = 12
+    SHAPE = 12,
+    /**
+     * Instruction to request a screen resize
+     */
+    SCREEN_RESIZE = 13,
+    /**
+     * Instruction to request a change in keyboard layouts
+     */
+    KEYBOARD_LAYOUT = 14
 }
 export declare namespace WebXInstructionType {
     /**

package/dist/instruction/WebXKeyboardLayoutInstruction.d.ts

@@ -0,0 +1,16 @@
+import { WebXInstruction } from './WebXInstruction';
+/**
+ * This instruction is used to request a change in keyboards in the engine
+ */
+export declare class WebXKeyboardLayoutInstruction extends WebXInstruction {
+    /**
+     * The keyboard layout.
+     */
+    readonly keyboardLayout: string;
+    /**
+     * Constructs a new WebXKeyboardLayoutInstruction.
+     *
+     * @param keyboardLayout The keyboard layout
+     */
+    constructor(keyboardLayout: string);
+}

package/dist/instruction/WebXScreenResizeInstruction.d.ts

@@ -0,0 +1,21 @@
+import { WebXInstruction } from './WebXInstruction';
+/**
+ * Represents an instruction to request a screen resize
+ */
+export declare class WebXScreenResizeInstruction extends WebXInstruction {
+    /**
+     * The requested width of the screen.
+     */
+    readonly width: number;
+    /**
+     * The requested height of the screen.
+     */
+    readonly height: number;
+    /**
+     * Constructs a new WebXScreenResizeInstruction.
+     *
+     * @param width The requested width of the screen
+     * @param height The requested height of the screen
+     */
+    constructor(width: number, height: number);
+}

package/dist/instruction/index.d.ts

@@ -13,3 +13,5 @@ export * from './WebXPongInstruction';
 export * from './WebXDataAckInstruction';
 export * from './WebXClipboardInstruction';
 export * from './WebXShapeInstruction';
+export * from './WebXScreenResizeInstruction';
+export * from './WebXKeyboardLayoutInstruction';

package/dist/message/WebXKeyboardLayoutMessage.d.ts

@@ -0,0 +1,19 @@
+import { WebXMessage } from './WebXMessage';
+/**
+ * Represents a message containing the keyboard layout name.
+ *
+ * This message is received from the WebX Engine when a client changes the keyboard layout
+ */
+export declare class WebXKeyboardLayoutMessage extends WebXMessage {
+    /**
+     * The keyboard layout name.
+     * @private
+     */
+    readonly keyboardLayoutName: string;
+    /**
+     * Constructs a new WebXKeyboardLayoutMessage.
+     *
+     * @param keyboardLayoutName The content of the clipboard.
+     */
+    constructor(keyboardLayoutName: string);
+}

package/dist/message/WebXMessageType.d.ts

@@ -55,5 +55,13 @@ export declare enum WebXMessageType {
     /**
      * Message containing window shape information (stencil image).
      */
-    SHAPE = 12
+    SHAPE = 12,
+    /**
+     * Message containing window resize information.
+     */
+    SCREEN_RESIZE = 13,
+    /**
+     * Message containing keyboard layout name
+     */
+    KEYBOARD_LAYOUT = 14
 }

package/dist/message/WebXScreenMessage.d.ts

@@ -22,16 +22,26 @@ export declare class WebXScreenMessage extends WebXMessage {
      * The version of the WebX Engine.
      */
     readonly engineVersion: WebXVersion;
+    /**
+     * Whether the screen can be resized
+     */
+    readonly canResizeScreen: boolean;
+    /**
+     * The name of the current keyboard layout
+     */
+    readonly keyboardLayoutName: string;
     /**
      * Constructs a new WebXScreenMessage.
      *
+     * @param commandId The ID of the command associated with this message.
      * @param screenSize The size of the screen.
      * @param maxQualityIndex The maximum quality index for the display.
      * @param engineVersion The version of the WebX Engine.
-     * @param commandId The ID of the command associated with this message.
+     * @param canResizeScreen Whether the screen can be resized
+     * @param keyboardLayoutName The name of the current keyboard layout
      */
-    constructor(screenSize: {
+    constructor(commandId: number, screenSize: {
         width: number;
         height: number;
-    }, maxQualityIndex: number, engineVersion: WebXVersion, commandId: number);
+    }, maxQualityIndex: number, engineVersion: WebXVersion, canResizeScreen: boolean, keyboardLayoutName: string);
 }

package/dist/message/WebXScreenResizeMessage.d.ts

@@ -0,0 +1,22 @@
+import { WebXMessage } from './WebXMessage';
+/**
+ * This message is received from the WebX Engine when the screen is resized
+ */
+export declare class WebXScreenResizeMessage extends WebXMessage {
+    /**
+     * The size of the screen.
+     */
+    readonly screenSize: {
+        width: number;
+        height: number;
+    };
+    /**
+     * Constructs a new WebXScreenResizeMessage.
+     *
+     * @param screenSize The size of the screen.
+     */
+    constructor(screenSize: {
+        width: number;
+        height: number;
+    });
+}

package/dist/message/index.d.ts

@@ -12,3 +12,5 @@ export * from './WebXClipboardMessage';
 export * from './WebXConnectionMessage';
 export * from './WebXNopMessage';
 export * from './WebXShapeMessage';
+export * from './WebXScreenResizeMessage';
+export * from './WebXKeyboardLayoutMessage';

package/dist/tracer/WebXKeyboardCombinationHandler.d.ts

@@ -0,0 +1,22 @@
+import { WebXInstructionHandler } from "./WebXInstructionHandler";
+import { WebXHandler } from "./WebXHandler";
+import { WebXInstruction } from "../instruction";
+/**
+ * Provides a callback method when a specific combination of keys is pressed.
+ */
+export declare class WebXKeyboardCombinationHandler extends WebXInstructionHandler implements WebXHandler {
+    private _combination;
+    private _callback;
+    private _keys;
+    constructor(_combination: number[], _callback: () => void);
+    /**
+     * Handles the instruction, recording key presses and determining if they match the provided combination. If they
+     * do then the callback is called.
+     * @param instruction The WebX instruction
+     */
+    handle(instruction: WebXInstruction): void;
+    /**
+     * Called when removed to clean up any resources: not needed here.
+     */
+    destroy(): void;
+}

package/dist/tracer/index.d.ts

@@ -3,3 +3,4 @@ export * from './WebXMessageHandler';
 export * from './WebXStatsHandler';
 export * from './WebXDebugImageMessageHandler';
 export * from './WebXHandler';
+export * from './WebXKeyboardCombinationHandler';

package/dist/transport/WebXInstructionEncoder.d.ts

@@ -178,4 +178,34 @@ export declare class WebXInstructionEncoder {
      *    windowId: 4 bytes
      */
     private _createShapeInstruction;
+    /**
+     * Create a new screen resize instruction
+     * @param instruction the screen resize instruction to encode
+     * Structure:
+     *   Header: 32 bytes
+     *    sessionId: 16 bytes
+     *    clientId: 4 bytes
+     *    type: 4 bytes
+     *    id: 4 bytes
+     *    padding: 4 bytes
+     *   Content: 4 bytes
+     *     width: 4 bytes
+     *     height: 4 bytes
+     */
+    private _createScreenResizeInstruction;
+    /**
+     * Create a new keyboard layout instruction
+     * @param instruction the keyboard layout instruction to encode
+     * Structure:
+     *   Header: 32 bytes
+     *    sessionId: 16 bytes
+     *    clientId: 4 bytes
+     *    type: 4 bytes
+     *    id: 4 bytes
+     *    padding: 4 bytes
+     *   Content:
+     *     keyboardLayoutLength: 4 bytes
+     *     keyboardLayout: N bytes
+     */
+    private _createKeyboardLayoutInstruction;
 }

package/dist/transport/WebXMessageDecoder.d.ts

@@ -102,4 +102,18 @@ export declare class WebXMessageDecoder {
      * @returns A promise that resolves to a WebXShapeMessage.
      */
     private _createShapeMessage;
+    /**
+     * Decodes a buffer into a WebXScreenResizeMessage containing the new screen dimensions
+     *
+     * @param buffer The binary message buffer to decode.
+     * @returns A promise that resolves to a WebXScreenResizeMessage.
+     */
+    private _createScreenResizeMessage;
+    /**
+     * Decodes a buffer into a WebxKeyboardLayoutMessage, which contains updated keyboard layout name.
+     *
+     * @param buffer The binary message buffer to decode.
+     * @returns A promise that resolves to a WebxKeyboardLayoutMessage.
+     */
+    private _createKeyboardLayoutMessage;
 }

package/dist/tunnel/WebXTunnel.d.ts

@@ -64,7 +64,7 @@ export declare abstract class WebXTunnel {
      *
      * @param message The received message.
      */
-    handleMessage(message: WebXMessage): void;
+    handleMessage(message: WebXMessage): Promise<void>;
     /**
      * Handles received bytes from the WebX Engine.
      *