@effindomv2/fui-as 0.1.50 → 0.2.0-alpha1

package/src/core/ContextMenuManager.ts

@@ -11,7 +11,10 @@ import {
   formatRedoShortcutLabel,
   formatShortcutLabel,
   formatUndoShortcutLabel,
+  getHostContext,
   getPlatformFamily,
+  HostCapability,
+  HostContext,
   PlatformFamily,
 } from "./Platform";
 import { ContextMenuEventArgs, Node, VisibilityChangedEventArgs } from "./Node";
@@ -101,18 +104,21 @@ export class ContextMenuManager {
     if (this.invokeCustomContextMenuHandler(targetNode, x, y)) {
       return;
     }
-    const items = this.buildBuiltInItems(handle, x, y, true);
+    const host = getHostContext();
+    const items = this.buildBuiltInItemsForHost(handle, x, y, true, host);
 
     const navigationItems = new Array<MenuItem>();
-    if (ffi.fui_can_navigate_back()) {
+    if (host.supports(HostCapability.BrowserHistory) && ffi.fui_can_navigate_back()) {
       navigationItems.push(new MenuItem("Back", ContextMenuAction.NavigateBack, null, 0, resolveHistoryShortcutLabel(false)));
     }
-    if (ffi.fui_can_navigate_forward()) {
+    if (host.supports(HostCapability.BrowserHistory) && ffi.fui_can_navigate_forward()) {
       navigationItems.push(new MenuItem("Forward", ContextMenuAction.NavigateForward, null, 0, resolveHistoryShortcutLabel(true)));
     }
-    navigationItems.push(
-      new MenuItem("Reload Page", ContextMenuAction.ReloadPage, null, 0, formatPrimaryShortcutLabel("r")),
-    );
+    if (host.supports(HostCapability.Reload)) {
+      navigationItems.push(
+        new MenuItem("Reload Page", ContextMenuAction.ReloadPage, null, 0, formatPrimaryShortcutLabel("r")),
+      );
+    }
     appendMenuSection(items, navigationItems);
     if (items.length == 0) {
       this.releaseActiveMenuLinkPreview();
@@ -123,7 +129,7 @@ export class ContextMenuManager {
   }
 
   static showForLongPress(handle: u64, x: f32, y: f32): bool {
-    const items = this.buildBuiltInItems(handle, x, y, false);
+    const items = this.buildBuiltInItemsForHost(handle, x, y, false, getHostContext());
     if (items.length == 0) {
       this.releaseActiveMenuLinkPreview();
       return false;
@@ -169,7 +175,7 @@ export class ContextMenuManager {
       }
       const handler = contextNode.contextMenuHandler;
       if (handler !== null) {
-        handler(new ContextMenuEventArgs(targetNode, x, y));
+        handler(new ContextMenuEventArgs(targetNode, x, y, getHostContext()));
         return true;
       }
       contextNode = contextNode.parentNode;
@@ -177,7 +183,14 @@ export class ContextMenuManager {
     return false;
   }
 
-  private static buildBuiltInItems(handle: u64, x: f32, y: f32, clearSelectionOnBackgroundMiss: bool): Array<MenuItem> {
+  /** @internal Exposed for deterministic host-policy tests; not part of the FUI public barrel. */
+  static buildBuiltInItemsForHost(
+    handle: u64,
+    x: f32,
+    y: f32,
+    clearSelectionOnBackgroundMiss: bool,
+    host: HostContext,
+  ): Array<MenuItem> {
     this.releaseActiveMenuLinkPreview();
     const targetNode = EventRouter.getRegisteredNode(handle);
     let contextNode = targetNode;
@@ -194,26 +207,34 @@ export class ContextMenuManager {
       link.pinPreviewForContextMenu();
       this.activeMenuLink = link;
       const linkItems = new Array<MenuItem>();
-      linkItems.push(new MenuItem("New Tab", ContextMenuAction.OpenLinkInNewTab, link.href));
-      linkItems.push(new MenuItem("Open", ContextMenuAction.OpenLink, link.href));
+      if (host.supports(HostCapability.NewBrowsingContext)) {
+        linkItems.push(new MenuItem("New Tab", ContextMenuAction.OpenLinkInNewTab, link.href));
+      }
+      if (host.supports(HostCapability.OpenExternalUri)) {
+        linkItems.push(new MenuItem("Open", ContextMenuAction.OpenLink, link.href));
+      }
       appendMenuSection(items, linkItems);
     }
 
     const textTarget = this.resolveTextTarget(targetNode);
     const selectionHit = ui.isPointInSelection(x, y) || this.selectionHintContainsHandle(handle);
     if (textTarget !== null) {
-      appendMenuSection(items, this.buildTextSection(textTarget, selectionHit ? this.currentSelectionText : ""));
+      appendMenuSection(items, this.buildTextSection(textTarget, selectionHit ? this.currentSelectionText : "", host));
     }
 
     const imageUrl = this.resolveImageUrl(targetNode, x, y);
     if (imageUrl !== null && imageUrl.length > 0) {
       const imageItems = new Array<MenuItem>();
-      imageItems.push(new MenuItem("New Tab", ContextMenuAction.OpenImageInNewTab, imageUrl));
-      imageItems.push(new MenuItem("Open", ContextMenuAction.OpenImage, imageUrl));
+      if (host.supports(HostCapability.NewBrowsingContext)) {
+        imageItems.push(new MenuItem("New Tab", ContextMenuAction.OpenImageInNewTab, imageUrl));
+      }
+      if (host.supports(HostCapability.OpenExternalUri)) {
+        imageItems.push(new MenuItem("Open", ContextMenuAction.OpenImage, imageUrl));
+      }
       appendMenuSection(items, imageItems);
     }
 
-    if (selectionHit && textTarget === null && this.currentSelectionText.length > 0) {
+    if (selectionHit && textTarget === null && this.currentSelectionText.length > 0 && host.supports(HostCapability.ClipboardWrite)) {
       const selectionItems = new Array<MenuItem>();
       selectionItems.push(new MenuItem("Copy", ContextMenuAction.CopyCurrentSelection, this.currentSelectionText));
       appendMenuSection(items, selectionItems);
@@ -266,7 +287,7 @@ export class ContextMenuManager {
     return null;
   }
 
-  private static buildTextSection(target: TextCore, currentSelectionText: string = ""): Array<MenuItem> {
+  private static buildTextSection(target: TextCore, currentSelectionText: string, host: HostContext): Array<MenuItem> {
     const items = new Array<MenuItem>();
     const handle = target.builtHandle;
     if (handle == <u64>HandleValue.Invalid || !target.isSelectableText) {
@@ -313,48 +334,52 @@ export class ContextMenuManager {
         ),
       );
       items.push(MenuItem.separator());
-      items.push(
-        new MenuItem(
-          "Cut",
-          ContextMenuAction.CutTextSelection,
-          selectedPayload,
-          0,
-          formatPrimaryShortcutLabel("x"),
-          !hasSelection,
-          handle,
-          0,
-          0,
-          true,
-        ).withSelectionRange(selectionStartByte, selectionEndByte),
-      );
-      items.push(
-        new MenuItem(
-          "Copy",
-          ContextMenuAction.CopyCurrentSelection,
-          selectedPayload,
-          0,
-          formatPrimaryShortcutLabel("c"),
-          !hasSelection,
-          handle,
-          0,
-          0,
-          true,
-        ),
-      );
-      items.push(
-        new MenuItem(
-          "Paste",
-          ContextMenuAction.PasteText,
-          null,
-          0,
-          formatPrimaryShortcutLabel("v"),
-          false,
-          handle,
-          0,
-          0,
-          true,
-        ),
-      );
+      if (host.supports(HostCapability.ClipboardWrite)) {
+        items.push(
+          new MenuItem(
+            "Cut",
+            ContextMenuAction.CutTextSelection,
+            selectedPayload,
+            0,
+            formatPrimaryShortcutLabel("x"),
+            !hasSelection,
+            handle,
+            0,
+            0,
+            true,
+          ).withSelectionRange(selectionStartByte, selectionEndByte),
+        );
+        items.push(
+          new MenuItem(
+            "Copy",
+            ContextMenuAction.CopyCurrentSelection,
+            selectedPayload,
+            0,
+            formatPrimaryShortcutLabel("c"),
+            !hasSelection,
+            handle,
+            0,
+            0,
+            true,
+          ),
+        );
+      }
+      if (host.supports(HostCapability.ClipboardRead)) {
+        items.push(
+          new MenuItem(
+            "Paste",
+            ContextMenuAction.PasteText,
+            null,
+            0,
+            formatPrimaryShortcutLabel("v"),
+            false,
+            handle,
+            0,
+            0,
+            true,
+          ),
+        );
+      }
       items.push(
         new MenuItem(
           "Select All",
@@ -372,6 +397,12 @@ export class ContextMenuManager {
       return items;
     }
 
+    if (!host.supports(HostCapability.ClipboardWrite)) {
+      items.push(
+        new MenuItem("Select All", ContextMenuAction.SelectAllText, null, 0, formatPrimaryShortcutLabel("a"), !hasText, handle),
+      );
+      return items;
+    }
     if (currentSelectionText.length > 0) {
       items.push(
         new MenuItem(

package/src/core/EventRouter.ts

@@ -24,6 +24,7 @@ import { NavLink } from "../controls/NavLink";
 import { TextInputCore } from "../controls/internal/TextInputCore";
 import { Image } from "../nodes/Image";
 import { Svg } from "../nodes/Svg";
+import { ContextMenu } from "../controls/ContextMenu";
 
 export interface GlobalKeyHandler {
   handleGlobalKeyEvent(eventType: KeyEventType, key: string, modifiers: u32): bool;
@@ -44,6 +45,7 @@ export class EventRouter {
   private static readonly keyFilterHandlers: Array<GlobalKeyHandler> = new Array<GlobalKeyHandler>();
   private static readonly keyFilterTokens: Array<u32> = new Array<u32>();
   private static capturedPointerHandle: u64 = <u64>HandleValue.Invalid;
+  private static selectionCursorHandle: u64 = <u64>HandleValue.Invalid;
   private static currentCursorStyle: CursorStyle = CursorStyle.Default;
   private static nextKeyFilterToken: u32 = 1;
   private static focusedNode: Node | null = null;
@@ -70,6 +72,9 @@ export class EventRouter {
     if (this.capturedPointerHandle == handle) {
       this.capturedPointerHandle = <u64>HandleValue.Invalid;
     }
+    if (this.selectionCursorHandle == handle) {
+      this.selectionCursorHandle = <u64>HandleValue.Invalid;
+    }
     const index = getHandleIndex(handle);
     this.nodes.delete(index);
     this.generations.delete(index);
@@ -94,6 +99,15 @@ export class EventRouter {
     showKeyboardFocusForPointerEvent(eventType);
     SelectionHandleAdornerManager.recordPointerEvent(eventType, pointerType);
     const pointedNode = this.resolveNode(handle);
+    if (
+      eventType == PointerEventType.Down &&
+      (button == 0 || pointerType == PointerType.Touch || pointerType == PointerType.Pen) &&
+      ContextMenu.dismissForOutsidePointerDown(x, y)
+    ) {
+      DragDropManager.handlePointerEvent(null, eventType, x, y, modifiers);
+      this.applyCurrentCursor();
+      return true;
+    }
     if (
       eventType == PointerEventType.Down &&
       !this.preservesSelectionOnPointerDownForRouting(pointedNode) &&
@@ -103,6 +117,14 @@ export class EventRouter {
       this.applyCurrentCursor();
       return true;
     }
+    if (eventType == PointerEventType.Down && button == 0 && pointerType != PointerType.Touch) {
+      const selectionCursorNode = this.resolveSelectionCursorNode(pointedNode);
+      this.selectionCursorHandle = selectionCursorNode === null
+        ? <u64>HandleValue.Invalid
+        : changetype<Node>(selectionCursorNode).builtHandle;
+    } else if (eventType == PointerEventType.Up || eventType == PointerEventType.Cancel) {
+      this.selectionCursorHandle = <u64>HandleValue.Invalid;
+    }
     if (eventType == PointerEventType.Up) {
       trackKeyboardScrollPointerUp(pointedNode, x, y);
     }
@@ -553,6 +575,7 @@ export class EventRouter {
     this.nodes.clear();
     this.generations.clear();
     this.capturedPointerHandle = <u64>HandleValue.Invalid;
+    this.selectionCursorHandle = <u64>HandleValue.Invalid;
     this.hoverStack.length = 0;
     this.focusedNode = null;
     this.keyFilterHandlers.length = 0;
@@ -687,6 +710,22 @@ export class EventRouter {
     return this.resolveNode(this.capturedPointerHandle);
   }
 
+  private static resolveSelectionCursorNode(node: Node | null): Node | null {
+    if (node === null || !node.isEnabled || !node.isVisible) {
+      return null;
+    }
+    if (node.isSelectableText || node.isEditableText) {
+      return node;
+    }
+    if (node instanceof TextInputCore) {
+      const editor = changetype<TextInputCore>(node).editorNode;
+      if (editor.isEnabled && editor.isVisible && (editor.isSelectableText || editor.isEditableText)) {
+        return editor;
+      }
+    }
+    return null;
+  }
+
   private static applyCurrentCursor(): void {
     const dragCursor = DragDropManager.cursorOverrideStyle();
     if (dragCursor != CursorStyle.Default) {
@@ -698,6 +737,11 @@ export class EventRouter {
       this.applyCursor(captured.cursorStyle);
       return;
     }
+    const selectionCursorNode = this.resolveNode(this.selectionCursorHandle);
+    if (selectionCursorNode !== null) {
+      this.applyCursor(changetype<Node>(selectionCursorNode).cursorStyle);
+      return;
+    }
     if (this.hoverStack.length == 0) {
       this.applyCursor(CursorStyle.Default);
       return;

package/src/core/Node.ts

@@ -23,6 +23,7 @@ import { storePersistedTextState, tryLoadPersistedTextState } from "./PersistedU
 import { ToolTip } from "./ToolTip";
 import { ToolTipManager } from "./ToolTipManager";
 import { throwNullArgument } from "./Errors";
+import { HostContext } from "./Platform";
 import { bind0, bind1, bind2, bindResult0, bindResult1 } from "./bind";
 import {
   CursorStyle,
@@ -435,11 +436,13 @@ export class ContextMenuEventArgs {
   readonly target: Node | null;
   readonly x: f32;
   readonly y: f32;
+  readonly host: HostContext;
 
-  constructor(target: Node | null, x: f32, y: f32) {
+  constructor(target: Node | null, x: f32, y: f32, host: HostContext) {
     this.target = target;
     this.x = x;
     this.y = y;
+    this.host = host;
   }
 }
 
@@ -684,6 +687,10 @@ export abstract class Node implements DragGestureHost, Disposable {
   private portalFlag: bool = false;
   private pointerClickCallback: ((event: PointerClickEventArgs) => void) | null = null;
   private pointerClickBinding: Callback1<PointerClickEventArgs> | null = null;
+  private pointerDoubleClickCallback: ((event: PointerClickEventArgs) => void) | null = null;
+  private pointerDoubleClickBinding: Callback1<PointerClickEventArgs> | null = null;
+  private pointerTripleClickCallback: ((event: PointerClickEventArgs) => void) | null = null;
+  private pointerTripleClickBinding: Callback1<PointerClickEventArgs> | null = null;
   private pointerDownEventCallback: ((event: PointerEventArgs) => void) | null = null;
   private pointerDownEventBinding: Callback1<PointerEventArgs> | null = null;
   private pointerMoveEventCallback: ((event: PointerEventArgs) => void) | null = null;
@@ -1104,6 +1111,44 @@ export abstract class Node implements DragGestureHost, Disposable {
     return this;
   }
 
+  onPointerDoubleClick(cb: (event: PointerClickEventArgs) => void): this {
+    this.pointerDoubleClickCallback = cb;
+    this.pointerDoubleClickBinding = null;
+    this.requireInteractive();
+    return this;
+  }
+
+  bindPointerDoubleClick<Owner>(owner: Owner, handler: Handler1<Owner, PointerClickEventArgs>): this {
+    this.pointerDoubleClickCallback = null;
+    this.pointerDoubleClickBinding = bind1<Owner, PointerClickEventArgs>(owner, handler);
+    this.requireInteractive();
+    return this;
+  }
+
+  onPointerDoubleClickWith<Owner>(owner: Owner, handler: Handler1<Owner, PointerClickEventArgs>): this {
+    this.bindPointerDoubleClick(owner, handler);
+    return this;
+  }
+
+  onPointerTripleClick(cb: (event: PointerClickEventArgs) => void): this {
+    this.pointerTripleClickCallback = cb;
+    this.pointerTripleClickBinding = null;
+    this.requireInteractive();
+    return this;
+  }
+
+  bindPointerTripleClick<Owner>(owner: Owner, handler: Handler1<Owner, PointerClickEventArgs>): this {
+    this.pointerTripleClickCallback = null;
+    this.pointerTripleClickBinding = bind1<Owner, PointerClickEventArgs>(owner, handler);
+    this.requireInteractive();
+    return this;
+  }
+
+  onPointerTripleClickWith<Owner>(owner: Owner, handler: Handler1<Owner, PointerClickEventArgs>): this {
+    this.bindPointerTripleClick(owner, handler);
+    return this;
+  }
+
   onPointerDown(cb: (event: PointerEventArgs) => void): this {
     this.pointerDownEventCallback = cb;
     this.pointerDownEventBinding = null;
@@ -2166,12 +2211,43 @@ export abstract class Node implements DragGestureHost, Disposable {
     const callback = this.pointerClickCallback;
     if (callback !== null) {
       callback(clickEvent);
-      return;
+    } else {
+      const binding = this.pointerClickBinding;
+      if (binding !== null) {
+        binding.invoke(clickEvent);
+      }
     }
-    const binding = this.pointerClickBinding;
-    if (binding !== null) {
-      binding.invoke(clickEvent);
+    if (clickEvent.clickCount == 2) {
+      const doubleCallback = this.pointerDoubleClickCallback;
+      if (doubleCallback !== null) {
+        doubleCallback(clickEvent);
+      } else {
+        const doubleBinding = this.pointerDoubleClickBinding;
+        if (doubleBinding !== null) {
+          doubleBinding.invoke(clickEvent);
+        }
+      }
+    } else if (clickEvent.clickCount == 3) {
+      const tripleCallback = this.pointerTripleClickCallback;
+      if (tripleCallback !== null) {
+        tripleCallback(clickEvent);
+      } else {
+        const tripleBinding = this.pointerTripleClickBinding;
+        if (tripleBinding !== null) {
+          tripleBinding.invoke(clickEvent);
+        }
+      }
     }
+    event.handled = clickEvent.handled;
+  }
+
+  private hasPointerClickHandler(): bool {
+    return this.pointerClickCallback !== null
+      || this.pointerClickBinding !== null
+      || this.pointerDoubleClickCallback !== null
+      || this.pointerDoubleClickBinding !== null
+      || this.pointerTripleClickCallback !== null
+      || this.pointerTripleClickBinding !== null;
   }
 
   private cancelDragState(): void {
@@ -2212,7 +2288,7 @@ export abstract class Node implements DragGestureHost, Disposable {
     if (!event.handled) {
       if (event.eventType == PointerEventType.Down) {
         const isPrimaryButton = isPrimaryActivationPointer(event);
-        this.clickPending = isPrimaryButton && (this.pointerClickCallback !== null || this.pointerClickBinding !== null);
+        this.clickPending = isPrimaryButton && this.hasPointerClickHandler();
         this.clickPendingCount = event.clickCount;
       } else if (event.eventType == PointerEventType.Up) {
         if (this.clickPending) {
@@ -2259,14 +2335,14 @@ export abstract class Node implements DragGestureHost, Disposable {
       if (dragGesture !== null && isPrimaryButton) {
         const waitForLongPress = event.pointerType == PointerType.Touch || event.pointerType == PointerType.Pen;
         dragGesture.handlePointerDown(nodeX, nodeY, _modifiers, waitForLongPress);
-        this.dragClickPending = this.pointerClickCallback !== null || this.pointerClickBinding !== null;
+        this.dragClickPending = this.hasPointerClickHandler();
         this.dragClickPendingCount = event.clickCount;
         this.clickPending = false;
         this.clickPendingCount = 0;
       } else {
         this.dragClickPending = false;
         this.dragClickPendingCount = 0;
-        this.clickPending = isPrimaryButton && (this.pointerClickCallback !== null || this.pointerClickBinding !== null);
+        this.clickPending = isPrimaryButton && this.hasPointerClickHandler();
         this.clickPendingCount = event.clickCount;
       }
       return;

package/src/core/Platform.ts

@@ -1,13 +1,58 @@
-import { fui_get_platform_family, fui_is_coarse_pointer, KeyModifier } from "./ffi";
+import {
+  fui_get_host_capabilities,
+  fui_get_host_environment,
+  fui_get_platform_family,
+  fui_is_coarse_pointer,
+  HostCapability,
+  HostEnvironment,
+  KeyModifier,
+  PlatformFamily,
+} from "./ffi";
 
-export enum PlatformFamily {
-  Unknown = 0,
-  Apple = 1,
-  Windows = 2,
-  Linux = 3,
+export { HostCapability, HostEnvironment, PlatformFamily } from "./ffi";
+
+const KNOWN_HOST_CAPABILITIES: u32 =
+  HostCapability.BrowserHistory |
+  HostCapability.Reload |
+  HostCapability.NewBrowsingContext |
+  HostCapability.OpenExternalUri |
+  HostCapability.ClipboardRead |
+  HostCapability.ClipboardWrite |
+  HostCapability.FileDialogs;
+
+function resolvePlatformFamily(value: u32): PlatformFamily {
+  if (value <= <u32>PlatformFamily.Linux) {
+    return <PlatformFamily>value;
+  }
+  return PlatformFamily.Unknown;
 }
 
-const detectedPlatformFamily = <PlatformFamily>fui_get_platform_family();
+function resolveHostEnvironment(value: u32): HostEnvironment {
+  if (value <= <u32>HostEnvironment.Headless) {
+    return <HostEnvironment>value;
+  }
+  return HostEnvironment.Unknown;
+}
+
+const detectedPlatformFamily = resolvePlatformFamily(fui_get_platform_family());
+const detectedHostEnvironment = resolveHostEnvironment(fui_get_host_environment());
+const detectedHostCapabilities = fui_get_host_capabilities() & KNOWN_HOST_CAPABILITIES;
+
+export class HostContext {
+  readonly platformFamily: PlatformFamily;
+  readonly environment: HostEnvironment;
+  private readonly capabilities: u32;
+
+  constructor(platformFamily: PlatformFamily, environment: HostEnvironment, capabilities: u32) {
+    this.platformFamily = resolvePlatformFamily(<u32>platformFamily);
+    this.environment = resolveHostEnvironment(<u32>environment);
+    this.capabilities = capabilities & KNOWN_HOST_CAPABILITIES;
+  }
+
+  supports(capability: HostCapability): bool {
+    return (this.capabilities & <u32>capability) != 0;
+  }
+}
 
 class KeyboardPolicy {
   constructor(
@@ -108,6 +153,18 @@ export function getPlatformFamily(): PlatformFamily {
   return detectedPlatformFamily;
 }
 
+export function getHostEnvironment(): HostEnvironment {
+  return detectedHostEnvironment;
+}
+
+export function getHostContext(): HostContext {
+  return new HostContext(detectedPlatformFamily, detectedHostEnvironment, detectedHostCapabilities);
+}
+
+export function hasHostCapability(capability: HostCapability): bool {
+  return (detectedHostCapabilities & <u32>capability) != 0;
+}
+
 export function isCoarsePointer(): bool {
   return fui_is_coarse_pointer();
 }

package/src/core/ffi.ts

@@ -1,5 +1,7 @@
 export {
   fui_get_accent_color,
+  fui_get_host_capabilities,
+  fui_get_host_environment,
   fui_get_platform_family,
   fui_is_coarse_pointer,
   fui_is_dark_mode,

package/src/core/generated/FrameworkHostServices.ts

@@ -8,6 +8,20 @@ export function fui_get_accent_color(): u32 {
   return __host_fui_get_accent_color();
 }
 
+@external("fui_host", "fui_get_host_capabilities")
+declare function __host_fui_get_host_capabilities(): u32;
+
+export function fui_get_host_capabilities(): u32 {
+  return __host_fui_get_host_capabilities();
+}
+
+@external("fui_host", "fui_get_host_environment")
+declare function __host_fui_get_host_environment(): u32;
+
+export function fui_get_host_environment(): u32 {
+  return __host_fui_get_host_environment();
+}
+
 @external("fui_host", "fui_get_platform_family")
 declare function __host_fui_get_platform_family(): u32;
 

package/src/core/generated/HostAbi.ts

@@ -15,6 +15,9 @@ export declare function get_viewport_height(): f32;
 @external("fui_host", "get_device_pixel_ratio")
 export declare function get_device_pixel_ratio(): f32;
 
+@external("fui_host", "fui_set_application_caption")
+export declare function fui_set_application_caption(captionPtr: usize, captionLen: u32): void;
+
 @external("fui_host", "fui_set_pointer_capture")
 export declare function fui_set_pointer_capture(handle: u64): void;
 
@@ -108,6 +111,12 @@ export declare function fui_get_accent_color(): u32;
 @external("fui_host", "fui_get_platform_family")
 export declare function fui_get_platform_family(): u32;
 
+@external("fui_host", "fui_get_host_environment")
+export declare function fui_get_host_environment(): u32;
+
+@external("fui_host", "fui_get_host_capabilities")
+export declare function fui_get_host_capabilities(): u32;
+
 @external("fui_host", "fui_is_coarse_pointer")
 export declare function fui_is_coarse_pointer(): bool;
 

package/src/core/generated/UiEnums.ts

@@ -166,6 +166,30 @@ export enum SemanticRole {
   ComboBox = 16,
 }
 
+export enum PlatformFamily {
+  Unknown = 0,
+  Apple = 1,
+  Windows = 2,
+  Linux = 3,
+}
+
+export enum HostEnvironment {
+  Unknown = 0,
+  Browser = 1,
+  Desktop = 2,
+  Headless = 3,
+}
+
+export enum HostCapability {
+  BrowserHistory = 1,
+  Reload = 2,
+  NewBrowsingContext = 4,
+  OpenExternalUri = 8,
+  ClipboardRead = 16,
+  ClipboardWrite = 32,
+  FileDialogs = 64,
+}
+
 export enum CursorStyle {
   Default = 0,
   Pointer = 1,

package/src/nodes/FlexBox.ts

@@ -619,6 +619,16 @@ export class FlexBox extends Node {
     return this;
   }
 
+  onPointerDoubleClick(cb: (event: PointerClickEventArgs) => void): this {
+    super.onPointerDoubleClick(cb);
+    return this;
+  }
+
+  onPointerTripleClick(cb: (event: PointerClickEventArgs) => void): this {
+    super.onPointerTripleClick(cb);
+    return this;
+  }
+
   onPointerEnter(cb: (event: PointerEventArgs) => void): this {
     super.onPointerEnter(cb);
     return this;