@effindomv2/fui-as 0.1.0

package/src/core/DragDropManager.ts

@@ -0,0 +1,179 @@
+import { CursorStyle, PointerEventType } from "./ffi";
+import { DragDropEffects, DragEventArgs, DragSession, DropProposal, Node } from "./Node";
+
+function normalizeEffect(candidate: DragDropEffects, allowed: DragDropEffects): DragDropEffects {
+  const masked = <i32>candidate & <i32>allowed;
+  if (masked == <i32>DragDropEffects.None) {
+    return DragDropEffects.None;
+  }
+  if ((masked & <i32>DragDropEffects.Move) != 0) {
+    return DragDropEffects.Move;
+  }
+  if ((masked & <i32>DragDropEffects.Copy) != 0) {
+    return DragDropEffects.Copy;
+  }
+  if ((masked & <i32>DragDropEffects.Link) != 0) {
+    return DragDropEffects.Link;
+  }
+  return DragDropEffects.None;
+}
+
+function isDefaultProposal(proposal: DropProposal): bool {
+  return proposal.effect == DragDropEffects.None && !proposal.showInsertionMarker;
+}
+
+export class DragDropManager {
+  private static activeSession: DragSession | null = null;
+  private static activeTarget: Node | null = null;
+
+  static cursorOverrideStyle(): CursorStyle {
+    const session = this.activeSession;
+    if (session === null || !session.isActive) {
+      return CursorStyle.Default;
+    }
+    return session.currentEffect == DragDropEffects.None ? CursorStyle.Grabbing : CursorStyle.Move;
+  }
+
+  static beginSession(source: Node): bool {
+    const existing = this.activeSession;
+    if (existing !== null) {
+      this.finishSession(existing, DragDropEffects.None, 0.0, 0.0, 0, true);
+    }
+    if (!source._hasDragSource()) {
+      return false;
+    }
+    const data = source._createDragDataObject();
+    if (data === null) {
+      return false;
+    }
+    const allowed = source._getDragAllowedEffects();
+    if (<i32>allowed == 0) {
+      return false;
+    }
+    this.activeTarget = null;
+    this.activeSession = new DragSession(source, data, allowed);
+    return true;
+  }
+
+  static cancelSession(session: DragSession): void {
+    if (this.activeSession !== session) {
+      return;
+    }
+    this.finishSession(session, DragDropEffects.None, 0.0, 0.0, 0, true);
+  }
+
+  static cancelSessionForSource(source: Node): void {
+    const session = this.activeSession;
+    if (session === null || session.source !== source) {
+      return;
+    }
+    this.finishSession(session, DragDropEffects.None, 0.0, 0.0, 0, true);
+  }
+
+  static handleNodeDestroyed(node: Node): void {
+    const session = this.activeSession;
+    if (session !== null && session.source === node) {
+      this.finishSession(session, DragDropEffects.None, 0.0, 0.0, 0, true);
+      return;
+    }
+    if (this.activeTarget === node) {
+      this.activeTarget = null;
+      if (session !== null) {
+        session._setCurrentEffect(DragDropEffects.None);
+      }
+    }
+  }
+
+  static handlePointerEvent(pointedNode: Node | null, eventType: PointerEventType, x: f32, y: f32, modifiers: u32): void {
+    const session = this.activeSession;
+    if (session === null || !session.isActive) {
+      return;
+    }
+    if (
+      eventType == PointerEventType.Down ||
+      eventType == PointerEventType.Enter ||
+      eventType == PointerEventType.Move ||
+      eventType == PointerEventType.Leave
+    ) {
+      this.updateTarget(pointedNode, session, x, y, modifiers);
+      return;
+    }
+    if (eventType != PointerEventType.Up) {
+      return;
+    }
+    const effect = this.updateTarget(pointedNode, session, x, y, modifiers);
+    const target = this.activeTarget;
+    if (target !== null && effect != DragDropEffects.None) {
+      target._handleDropEvent(new DragEventArgs(session, x, y, modifiers));
+    }
+    if (this.activeSession === session && session.isActive) {
+      this.finishSession(session, effect, x, y, modifiers, true);
+    }
+  }
+
+  static reset(): void {
+    this.activeSession = null;
+    this.activeTarget = null;
+  }
+
+  private static updateTarget(pointedNode: Node | null, session: DragSession, x: f32, y: f32, modifiers: u32): DragDropEffects {
+    const target = this.resolveDropTarget(pointedNode);
+    const args = new DragEventArgs(session, x, y, modifiers);
+    let proposal = DropProposal.none();
+    if (target !== this.activeTarget) {
+      const previousTarget = this.activeTarget;
+      if (previousTarget !== null) {
+        previousTarget._handleDragLeave(args);
+      }
+      this.activeTarget = target;
+      if (target !== null && target._hasDragEnterHandler()) {
+        proposal = target._handleDragEnter(args);
+      }
+    }
+    if (target === null) {
+      session._setCurrentEffect(DragDropEffects.None);
+      return DragDropEffects.None;
+    }
+    if (target._hasDragOverHandler()) {
+      proposal = target._handleDragOver(args);
+    } else if (target === this.activeTarget && isDefaultProposal(proposal)) {
+      return session.currentEffect;
+    }
+    const effect = normalizeEffect(proposal.effect, session.allowedEffects);
+    session._setCurrentEffect(effect);
+    return effect;
+  }
+
+  private static resolveDropTarget(pointedNode: Node | null): Node | null {
+    let current = pointedNode;
+    while (current !== null) {
+      if (current._allowsDrop()) {
+        return current;
+      }
+      current = current.parentNode;
+    }
+    return null;
+  }
+
+  private static finishSession(
+    session: DragSession,
+    effect: DragDropEffects,
+    x: f32,
+    y: f32,
+    modifiers: u32,
+    notifyTargetLeave: bool,
+  ): void {
+    if (this.activeSession !== session) {
+      return;
+    }
+    const target = this.activeTarget;
+    this.activeSession = null;
+    this.activeTarget = null;
+    session._setCurrentEffect(effect);
+    if (notifyTargetLeave && target !== null) {
+      target._handleDragLeave(new DragEventArgs(session, x, y, modifiers));
+    }
+    session._complete(effect);
+    session.source._notifyDragCompleted(effect);
+  }
+}

package/src/core/DragGesture.ts

@@ -0,0 +1,184 @@
+import { Signal } from "./Signal";
+
+const DEFAULT_DRAG_THRESHOLD: f32 = 4.0;
+
+export interface DragGestureHost {
+  _captureDragPointer(): void;
+  _releaseDragPointer(): void;
+}
+
+export class DragStartedEvent {
+  constructor(
+    readonly x: f32 = 0.0,
+    readonly y: f32 = 0.0,
+    readonly modifiers: u32 = 0,
+  ) {}
+}
+
+export class DragDeltaEvent {
+  constructor(
+    readonly x: f32 = 0.0,
+    readonly y: f32 = 0.0,
+    readonly deltaX: f32 = 0.0,
+    readonly deltaY: f32 = 0.0,
+    readonly totalDeltaX: f32 = 0.0,
+    readonly totalDeltaY: f32 = 0.0,
+    readonly modifiers: u32 = 0,
+  ) {}
+}
+
+export class DragCompletedEvent {
+  constructor(
+    readonly x: f32 = 0.0,
+    readonly y: f32 = 0.0,
+    readonly totalDeltaX: f32 = 0.0,
+    readonly totalDeltaY: f32 = 0.0,
+    readonly modifiers: u32 = 0,
+    readonly cancelled: bool = false,
+  ) {}
+}
+
+export class DragGesture {
+  readonly dragging: Signal<bool> = new Signal<bool>(false);
+  readonly started: Signal<DragStartedEvent> = new Signal<DragStartedEvent>(new DragStartedEvent());
+  readonly delta: Signal<DragDeltaEvent> = new Signal<DragDeltaEvent>(new DragDeltaEvent());
+  readonly completed: Signal<DragCompletedEvent> = new Signal<DragCompletedEvent>(new DragCompletedEvent());
+
+  private thresholdValue: f32 = DEFAULT_DRAG_THRESHOLD;
+  private pointerDownValue: bool = false;
+  private dragStartedValue: bool = false;
+  private startX: f32 = 0.0;
+  private startY: f32 = 0.0;
+  private lastPointerX: f32 = 0.0;
+  private lastPointerY: f32 = 0.0;
+  private lastDispatchedX: f32 = 0.0;
+  private lastDispatchedY: f32 = 0.0;
+  private lastModifiers: u32 = 0;
+
+  constructor(private readonly host: DragGestureHost) {}
+
+  get isDragging(): bool {
+    return this.dragging.value;
+  }
+
+  threshold(value: f32): this {
+    this.thresholdValue = value > 0.0 ? value : 0.0;
+    return this;
+  }
+
+  handlePointerDown(x: f32, y: f32, modifiers: u32 = 0): void {
+    if (this.pointerDownValue) {
+      this.cancel();
+    }
+    this.pointerDownValue = true;
+    this.dragStartedValue = false;
+    this.startX = x;
+    this.startY = y;
+    this.lastPointerX = x;
+    this.lastPointerY = y;
+    this.lastDispatchedX = x;
+    this.lastDispatchedY = y;
+    this.lastModifiers = modifiers;
+    this.host._captureDragPointer();
+    if (this.thresholdValue <= 0.0) {
+      this.beginDrag(x, y, modifiers);
+    }
+  }
+
+  handlePointerMove(x: f32, y: f32, modifiers: u32 = 0): void {
+    if (!this.pointerDownValue) {
+      return;
+    }
+    this.lastPointerX = x;
+    this.lastPointerY = y;
+    this.lastModifiers = modifiers;
+    if (!this.dragStartedValue) {
+      if (!this.hasExceededThreshold(x - this.startX, y - this.startY)) {
+        return;
+      }
+      this.beginDrag(x, y, modifiers);
+    }
+    this.emitDelta(x, y, modifiers);
+  }
+
+  handlePointerUp(x: f32, y: f32, modifiers: u32 = 0): void {
+    if (!this.pointerDownValue) {
+      return;
+    }
+    this.lastPointerX = x;
+    this.lastPointerY = y;
+    this.lastModifiers = modifiers;
+    if (this.dragStartedValue) {
+      this.emitDelta(x, y, modifiers);
+      this.dragging.value = false;
+      this.completed.value = new DragCompletedEvent(
+        x,
+        y,
+        x - this.startX,
+        y - this.startY,
+        modifiers,
+        false,
+      );
+    }
+    this.pointerDownValue = false;
+    this.dragStartedValue = false;
+    this.host._releaseDragPointer();
+  }
+
+  cancel(): void {
+    if (!this.pointerDownValue) {
+      return;
+    }
+    if (this.dragStartedValue) {
+      this.dragging.value = false;
+      this.completed.value = new DragCompletedEvent(
+        this.lastPointerX,
+        this.lastPointerY,
+        this.lastPointerX - this.startX,
+        this.lastPointerY - this.startY,
+        this.lastModifiers,
+        true,
+      );
+    }
+    this.pointerDownValue = false;
+    this.dragStartedValue = false;
+    this.host._releaseDragPointer();
+  }
+
+  private beginDrag(x: f32, y: f32, modifiers: u32): void {
+    if (this.dragStartedValue) {
+      return;
+    }
+    this.dragStartedValue = true;
+    this.lastDispatchedX = this.startX;
+    this.lastDispatchedY = this.startY;
+    this.dragging.value = true;
+    this.started.value = new DragStartedEvent(x, y, modifiers);
+  }
+
+  private emitDelta(x: f32, y: f32, modifiers: u32): void {
+    if (x == this.lastDispatchedX && y == this.lastDispatchedY) {
+      return;
+    }
+    const deltaX = x - this.lastDispatchedX;
+    const deltaY = y - this.lastDispatchedY;
+    this.lastDispatchedX = x;
+    this.lastDispatchedY = y;
+    this.delta.value = new DragDeltaEvent(
+      x,
+      y,
+      deltaX,
+      deltaY,
+      x - this.startX,
+      y - this.startY,
+      modifiers,
+    );
+  }
+
+  private hasExceededThreshold(totalDeltaX: f32, totalDeltaY: f32): bool {
+    if (this.thresholdValue <= 0.0) {
+      return true;
+    }
+    return ((totalDeltaX * totalDeltaX) + (totalDeltaY * totalDeltaY)) >= (this.thresholdValue * this.thresholdValue);
+  }
+}

package/src/core/DynamicAssetIds.ts

@@ -0,0 +1,24 @@
+const FIRST_DYNAMIC_SVG_ID: u32 = 0x10000000;
+const FIRST_DYNAMIC_TEXTURE_ID: u32 = 0x20000000;
+const MAX_DYNAMIC_ASSET_ID: u32 = 0xffffffff;
+
+let nextDynamicSvgId: u32 = FIRST_DYNAMIC_SVG_ID;
+let nextDynamicTextureId: u32 = FIRST_DYNAMIC_TEXTURE_ID;
+
+export function allocateDynamicSvgId(): u32 {
+  if (nextDynamicSvgId == MAX_DYNAMIC_ASSET_ID) {
+    throw new Error("Dynamic SVG asset id space exhausted.");
+  }
+  const allocated = nextDynamicSvgId;
+  nextDynamicSvgId += 1;
+  return allocated;
+}
+
+export function allocateDynamicTextureId(): u32 {
+  if (nextDynamicTextureId == MAX_DYNAMIC_ASSET_ID) {
+    throw new Error("Dynamic texture asset id space exhausted.");
+  }
+  const allocated = nextDynamicTextureId;
+  nextDynamicTextureId += 1;
+  return allocated;
+}

package/src/core/Errors.ts

@@ -0,0 +1,48 @@
+import { error } from "./Logger";
+
+export class ObjectDisposedError extends Error {
+  constructor(functionName: string, objectName: string) {
+    const message = functionName + ": " + objectName + " was disposed";
+    super(message);
+    this.name = "ObjectDisposedError";
+  }
+}
+
+export function throwNullArgument(functionName: string, argumentName: string): void {
+  error("Validation", functionName + ": " + argumentName + " must not be null");
+  throw new TypeError(functionName + ": " + argumentName + " must not be null");
+}
+
+export function throwRangeError(functionName: string, argumentName: string, index: i32, min: i32, max: i32): void {
+  error(
+    "Validation",
+    functionName +
+      ": " +
+      argumentName +
+      " must be between " +
+      min.toString() +
+      " and " +
+      max.toString() +
+      " (received " +
+      index.toString() +
+      ")",
+  );
+  throw new RangeError(
+    functionName +
+      ": " +
+      argumentName +
+      " must be between " +
+      min.toString() +
+      " and " +
+      max.toString() +
+      " (received " +
+      index.toString() +
+      ")",
+  );
+}
+
+export function throwObjectDisposed(functionName: string, objectName: string): void {
+  const message = functionName + ": " + objectName + " was disposed";
+  error("Lifecycle", message);
+  throw new ObjectDisposedError(functionName, objectName);
+}