@swf2es/player 0.0.0-stage → 0.1.0

package/src/playerglobal/flash/text/TextRenderer.ts

@@ -0,0 +1,104 @@
+// flash.text.TextRenderer: settings for advanced anti-aliasing, kept for the
+// SWF to read back, with the values adl takes and ignores, and the tables
+// of cutoffs a font's advanced text is drawn by (text/csm.ts).
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+import { setCsmTable } from "../../../text/csm.js";
+
+type Value = avm2.Value;
+
+export function textRendererNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  let displayMode = "default";
+  let maxLevel = 4;
+  let antiAliasType = "default";
+
+  class TextRendererNatives {
+    /** "default" reads as the mode it stands for, "crt" in adl. */
+    static get displayMode(): string {
+      return displayMode === "default" ? "crt" : displayMode;
+    }
+
+    /** "lcd" and "crt" set; null leaves it, anything else is "default". */
+    static set displayMode(v: Value) {
+      if (v === null || v === undefined) {
+        return;
+      }
+
+      const mode = s.rt.toString(v);
+      displayMode = mode === "lcd" || mode === "crt" ? mode : "default";
+    }
+
+    static get maxLevel(): number {
+      return maxLevel;
+    }
+
+    /** Only 3, 4 and 7 are levels; others leave it. */
+    static set maxLevel(v: Value) {
+      const level = s.rt.toInt(v);
+      if (level === 3 || level === 4 || level === 7) {
+        maxLevel = level;
+      }
+    }
+
+    static get antiAliasType(): string {
+      return antiAliasType;
+    }
+
+    /** "on" and "default" set, anything else is "off"; null TypeError #2007. */
+    static set antiAliasType(v: Value) {
+      if (v === null || v === undefined) {
+        // adl spells the parameter so.
+        throw s.rt.error("TypeError", 2007, "antialiasType");
+      }
+
+      const type = s.rt.toString(v);
+      antiAliasType = type === "on" || type === "default" ? type : "off";
+    }
+
+    /** Checked as adl checks it; then the font's table, for its light and dark text alike, as adl takes it. */
+    static setAdvancedAntiAliasingTable(
+      fontName: Value,
+      fontStyle: Value,
+      colorType: Value,
+      table: Value,
+    ): void {
+      for (const [name, v] of [
+        ["fontName", fontName],
+        ["fontStyle", fontStyle],
+        ["colorType", colorType],
+      ]) {
+        if (v === null || v === undefined) {
+          throw s.rt.error("TypeError", 2007, name);
+        }
+      }
+
+      const entries = (table as avm2.AsObject | null)?.$a as Value[] | undefined;
+      if (!entries) {
+        return;
+      }
+
+      const settings = s.rt.classNamed("flash.text::CSMSettings");
+      for (const entry of entries) {
+        if (!s.rt.isInstance(entry, settings)) {
+          throw s.rt.error("TypeError", 2005, 4, "CSMSettings");
+        }
+      }
+
+      const read = (entry: Value, k: string) =>
+        s.rt.toNumber(s.rt.getProperty(entry as avm2.AsObject, s.rt.publicName(k)));
+      setCsmTable(
+        s.rt.toString(fontName),
+        s.rt.toString(fontStyle),
+        entries.map((entry) => [
+          read(entry, "fontSize"),
+          read(entry, "insideCutoff"),
+          read(entry, "outsideCutoff"),
+        ]),
+      );
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.text::TextRenderer", TextRendererNatives);
+  return natives;
+}

package/src/playerglobal/flash/text/engine/FontDescription.ts

@@ -0,0 +1,198 @@
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../../scripting.js";
+import { deviceMetrics } from "../../../../text/fonts.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+type StringProperty =
+  | "fontName"
+  | "fontWeight"
+  | "fontPosture"
+  | "fontLookup"
+  | "renderingMode"
+  | "cffHinting";
+
+interface FontDescriptionData {
+  fontName: string;
+  fontWeight: string;
+  fontPosture: string;
+  fontLookup: string;
+  renderingMode: string;
+  cffHinting: string;
+  locked: boolean;
+}
+
+const accepted: Partial<Record<StringProperty, readonly string[]>> = {
+  fontWeight: ["normal", "bold"],
+  fontPosture: ["normal", "italic"],
+  fontLookup: ["device", "embeddedCFF"],
+  renderingMode: ["normal", "cff"],
+  cffHinting: ["none", "horizontalStem"],
+};
+
+function data(o: AsObject): FontDescriptionData {
+  if (!o.$fontDescription) {
+    o.$fontDescription = {
+      fontName: "_serif",
+      fontWeight: "normal",
+      fontPosture: "normal",
+      fontLookup: "device",
+      renderingMode: "cff",
+      cffHinting: "horizontalStem",
+      locked: false,
+    };
+  }
+
+  return o.$fontDescription;
+}
+
+export function fontDescriptionNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  const checked = (value: Value, name: StringProperty): string => {
+    if (value === null || value === undefined) {
+      throw s.rt.error("TypeError", 2007, name);
+    }
+
+    const string = s.rt.toString(value);
+    if (accepted[name] && !accepted[name].includes(string)) {
+      throw s.rt.error("ArgumentError", 2008, name);
+    }
+
+    return string;
+  };
+
+  const set = (o: AsObject, name: StringProperty, value: Value): void => {
+    const state = data(o);
+    if (state.locked) {
+      throw s.rt.error("Error", 2185);
+    }
+
+    state[name] = checked(value, name);
+  };
+
+  const compatible = (name: Value, weight: Value, posture: Value, device: boolean): boolean => {
+    if (!device && (name === null || name === undefined)) {
+      return false;
+    }
+
+    const fontName = checked(name, "fontName");
+    const fontWeight = checked(weight, "fontWeight");
+    const fontPosture = checked(posture, "fontPosture");
+    const bold = fontWeight === "bold";
+    const italic = fontPosture === "italic";
+
+    if (!device) {
+      const fonts = [
+        ...(s.code.codeLibrary()?.characters.values() ?? []),
+        ...s.symbols.registeredFonts.values(),
+      ];
+      return fonts.some(
+        (font) =>
+          font.type === "fontCff" &&
+          font.name.toLowerCase() === fontName.toLowerCase() &&
+          font.bold === bold &&
+          font.italic === italic,
+      );
+    }
+
+    if (["_sans", "_serif", "_typewriter"].includes(fontName.toLowerCase())) {
+      return false;
+    }
+
+    // A missing face resolves to the same fallback metrics on every sample.
+    const font = deviceMetrics(fontName, 48, bold, italic);
+    const sample = ["M", "W", "i", "1", "@"];
+    if (s.platform.os === "Linux") {
+      const substitutes: Record<string, string> = {
+        arial: "Liberation Sans",
+        "times new roman": "Liberation Serif",
+        "courier new": "Liberation Mono",
+      };
+      const substitute = substitutes[fontName.toLowerCase()];
+      if (substitute) {
+        const mapped = deviceMetrics(substitute, 48, bold, italic);
+        if (sample.every((char) => font.advance(char) === mapped.advance(char))) {
+          return false;
+        }
+      }
+    }
+
+    const fallback = deviceMetrics("__swf2es_missing_font__", 48, bold, italic);
+    return sample.some((char) => font.advance(char) !== fallback.advance(char));
+  };
+
+  class FontDescriptionNatives {
+    get fontName(): string {
+      return data(this as AsObject).fontName;
+    }
+
+    set fontName(value: Value) {
+      set(this as AsObject, "fontName", value);
+    }
+
+    get fontWeight(): string {
+      return data(this as AsObject).fontWeight;
+    }
+
+    set fontWeight(value: Value) {
+      set(this as AsObject, "fontWeight", value);
+    }
+
+    get fontPosture(): string {
+      return data(this as AsObject).fontPosture;
+    }
+
+    set fontPosture(value: Value) {
+      set(this as AsObject, "fontPosture", value);
+    }
+
+    get fontLookup(): string {
+      return data(this as AsObject).fontLookup;
+    }
+
+    set fontLookup(value: Value) {
+      set(this as AsObject, "fontLookup", value);
+    }
+
+    get renderingMode(): string {
+      return data(this as AsObject).renderingMode;
+    }
+
+    set renderingMode(value: Value) {
+      set(this as AsObject, "renderingMode", value);
+    }
+
+    get cffHinting(): string {
+      return data(this as AsObject).cffHinting;
+    }
+
+    set cffHinting(value: Value) {
+      set(this as AsObject, "cffHinting", value);
+    }
+
+    get locked(): boolean {
+      return data(this as AsObject).locked;
+    }
+
+    set locked(value: Value) {
+      const state = data(this as AsObject);
+      if (state.locked) {
+        throw s.rt.error("Error", 2185);
+      }
+
+      state.locked = !!value;
+    }
+
+    static isFontCompatible(name: Value, weight: Value, posture: Value): boolean {
+      return compatible(name, weight, posture, false);
+    }
+
+    static isDeviceFontCompatible(name: Value, weight: Value, posture: Value): boolean {
+      return compatible(name, weight, posture, true);
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.text.engine::FontDescription", FontDescriptionNatives);
+  return natives;
+}

package/src/playerglobal/flash/text/engine/TabStop.ts

@@ -0,0 +1,70 @@
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../../scripting.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+interface TabStopData {
+  alignment: string;
+  position: number;
+  decimalAlignmentToken: string;
+}
+
+function data(o: AsObject): TabStopData {
+  if (!o.$tabStop) {
+    o.$tabStop = { alignment: "start", position: 0, decimalAlignmentToken: "" };
+  }
+
+  return o.$tabStop;
+}
+
+export function tabStopNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class TabStopNatives {
+    get alignment(): string {
+      return data(this as AsObject).alignment;
+    }
+
+    set alignment(value: Value) {
+      if (value === null || value === undefined) {
+        throw s.rt.error("TypeError", 2007, "alignment");
+      }
+
+      const alignment = s.rt.toString(value);
+      if (!["start", "center", "end", "decimal"].includes(alignment)) {
+        throw s.rt.error("ArgumentError", 2008, "alignment");
+      }
+
+      data(this as AsObject).alignment = alignment;
+    }
+
+    get position(): number {
+      return data(this as AsObject).position;
+    }
+
+    set position(value: Value) {
+      const position = Number(value);
+      if (position < 0) {
+        throw s.rt.error("ArgumentError", 2004);
+      }
+
+      data(this as AsObject).position = position;
+    }
+
+    get decimalAlignmentToken(): string {
+      return data(this as AsObject).decimalAlignmentToken;
+    }
+
+    set decimalAlignmentToken(value: Value) {
+      if (value === null || value === undefined) {
+        throw s.rt.error("TypeError", 2007, "decimalAlignmentToken");
+      }
+
+      data(this as AsObject).decimalAlignmentToken = s.rt.toString(value);
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.text.engine::TabStop", TabStopNatives);
+  return natives;
+}

package/src/playerglobal/flash/trace/Trace.ts

@@ -0,0 +1,25 @@
+// Release Flash Player does not expose its trace listener or levels to SWFs.
+import { avm2 } from "@swf2es/runtime";
+
+type Value = avm2.Value;
+
+export function traceNatives(): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class TraceNatives {
+    static setLevel(_level: number, _target: number): void {}
+
+    static getLevel(_target: number): number {
+      return 0;
+    }
+
+    static setListener(_listener: Value): void {}
+
+    static getListener(): null {
+      return null;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.trace::Trace", TraceNatives);
+  return natives;
+}

package/src/playerglobal/flash/ui/ContextMenu.ts

@@ -0,0 +1,26 @@
+// flash.ui.ContextMenu: AS3 keeps the items; input/context-menu.ts snapshots them on opening.
+// Links are kept for readback; link-specific built-in actions are not offered yet.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+import { coerceArgument } from "../display/InteractiveObject.js";
+
+type Value = avm2.Value;
+
+export function contextMenuNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class ContextMenuNatives {
+    declare $link: Value;
+
+    get link(): Value {
+      return this.$link ?? null;
+    }
+
+    set link(v: Value) {
+      this.$link = coerceArgument(s, v, "flash.net::URLRequest");
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.ui::ContextMenu", ContextMenuNatives);
+  return natives;
+}

package/src/playerglobal/flash/ui/GameInput.ts

@@ -0,0 +1,27 @@
+// flash.ui.GameInput without game controllers: none are found, so there is
+// no device to get, RangeError 1506 as Flash's for an index past them.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+
+export function gameInputNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class GameInputNatives {
+    static get isSupported(): boolean {
+      return false;
+    }
+
+    static get numDevices(): number {
+      return 0;
+    }
+
+    static getDeviceAt(_index: Value): Value {
+      throw s.rt.error("RangeError", 1506);
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.ui::GameInput", GameInputNatives);
+  return natives;
+}

package/src/playerglobal/flash/ui/Keyboard.ts

@@ -0,0 +1,34 @@
+// flash.ui.Keyboard's statics of the keyboard itself: a desktop's,
+// alphanumeric, not virtual, its locks reported off, as a browser keeps
+// their state from a page until a key event carries it.
+import { avm2 } from "@swf2es/runtime";
+
+export function keyboardNatives(): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class KeyboardNatives {
+    static get capsLock(): boolean {
+      return false;
+    }
+
+    static get numLock(): boolean {
+      return false;
+    }
+
+    static get hasVirtualKeyboard(): boolean {
+      return false;
+    }
+
+    static get physicalKeyboardType(): string {
+      return "alphanumeric";
+    }
+
+    /** Whether the keys may be read: no screen reader is in the way. */
+    static isAccessible(): boolean {
+      return true;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.ui::Keyboard", KeyboardNatives);
+  return natives;
+}

package/src/playerglobal/flash/ui/Mouse.ts

@@ -0,0 +1,170 @@
+// flash.ui.Mouse controls the cursor the host shows: whether it shows one,
+// which of Flash's own it forces, and bitmap cursors registered by name.
+// MouseCursorData holds a cursor's frames, hot spot and frame rate.
+import { avm2 } from "@swf2es/runtime";
+import { encodePng } from "../../../bitmap/png.js";
+import type { Scripting } from "../../../scripting.js";
+import { storeOf } from "../display/BitmapData.js";
+
+type Value = avm2.Value;
+type AsObject = avm2.AsObject;
+
+/** The names Mouse.cursor takes besides registered ones, as flash.ui.MouseCursor has them. */
+const BUILT_IN: ReadonlySet<string> = new Set(["auto", "arrow", "button", "hand", "ibeam"]);
+
+/** The largest cursor Flash takes, a side. */
+const MAX_SIZE = 32;
+
+export function mouseNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class MouseNatives {
+    static hide(): void {
+      s.mouseVisible = false;
+      s.pointer?.updateCursor();
+    }
+
+    static show(): void {
+      s.mouseVisible = true;
+      s.pointer?.updateCursor();
+    }
+
+    // Desktop Flash Player and AIR report both.
+    static get supportsCursor(): boolean {
+      return true;
+    }
+
+    static get supportsNativeCursor(): boolean {
+      return true;
+    }
+
+    static get cursor(): string {
+      return s.mouseCursor;
+    }
+
+    static set cursor(value: Value) {
+      if (value === null || value === undefined) {
+        throw s.rt.error("TypeError", 2007, "cursor");
+      }
+
+      const name = s.rt.toString(value);
+      if (!BUILT_IN.has(name) && !s.cursors.has(name)) {
+        throw s.rt.error("ArgumentError", 2008, "cursor");
+      }
+
+      s.mouseCursor = name;
+      s.pointer?.updateCursor();
+    }
+
+    static registerCursor(name: Value, cursorData: Value): void {
+      if (cursorData === null || cursorData === undefined) {
+        throw s.rt.error("TypeError", 2007, "cursorData");
+      }
+
+      if (name === null || name === undefined) {
+        throw s.rt.error("TypeError", 2007, "name");
+      }
+
+      // Flash registers nothing, and says nothing, for data never set.
+      const d = cursorData as AsObject;
+      const data = d.$cursorFrames as AsObject | null | undefined;
+      if (!data) {
+        return;
+      }
+
+      const frames: Value[] = data.$a;
+      if (frames.length === 0) {
+        throw s.rt.error("ArgumentError", 2008, "cursorData");
+      }
+
+      // Within the largest cursor's pixels, whatever its frames' sizes.
+      const x: number = d.$cursorHotX ?? 0;
+      const y: number = d.$cursorHotY ?? 0;
+      if (x < 0 || x > MAX_SIZE - 1 || y < 0 || y > MAX_SIZE - 1) {
+        throw s.rt.error("ArgumentError", 2008, "hotSpot");
+      }
+
+      for (const frame of frames) {
+        if (frame === null || frame === undefined) {
+          throw s.rt.error("ArgumentError", 2004);
+        }
+
+        const store = storeOf(s, frame as AsObject);
+        if (store.width > MAX_SIZE || store.height > MAX_SIZE) {
+          throw s.rt.error("ArgumentError", 2004);
+        }
+      }
+
+      // The first frame alone: a CSS cursor does not animate.
+      const first = storeOf(s, frames[0] as AsObject);
+      const png = encodePng(first, { x: 0, y: 0, width: first.width, height: first.height }, true);
+      // A hot spot past the image would make the browser refuse the cursor.
+      const hotX = Math.min(Math.floor(x) || 0, first.width - 1);
+      const hotY = Math.min(Math.floor(y) || 0, first.height - 1);
+      const url = `data:image/png;base64,${btoa(String.fromCharCode(...png))}`;
+      s.cursors.set(s.rt.toString(name), `url("${url}") ${hotX} ${hotY}, default`);
+      s.pointer?.updateCursor();
+    }
+
+    static unregisterCursor(name: Value): void {
+      if (name === null || name === undefined) {
+        throw s.rt.error("TypeError", 2007, "name");
+      }
+
+      const key = s.rt.toString(name);
+      if (s.cursors.delete(key) && s.mouseCursor === key) {
+        s.mouseCursor = "auto";
+      }
+
+      s.pointer?.updateCursor();
+    }
+  }
+
+  class MouseCursorDataNatives {
+    declare $cursorFrames: Value;
+    declare $cursorHotX: number | undefined;
+    declare $cursorHotY: number | undefined;
+    declare $cursorFrameRate: number | undefined;
+
+    get data(): Value {
+      return this.$cursorFrames ?? null;
+    }
+
+    set data(value: Value) {
+      this.$cursorFrames = value;
+    }
+
+    // A copy each way, as Flash keeps the values and not the Point.
+    get hotSpot(): Value {
+      return s.rt.construct(
+        s.rt.classNamed("flash.geom::Point"),
+        this.$cursorHotX ?? 0,
+        this.$cursorHotY ?? 0,
+      );
+    }
+
+    set hotSpot(value: Value) {
+      if (value === null || value === undefined) {
+        throw s.rt.error("TypeError", 2007, "hotSpot");
+      }
+
+      const p = value as AsObject;
+      this.$cursorHotX = s.rt.toNumber(s.rt.getProperty(p, s.rt.publicName("x")));
+      this.$cursorHotY = s.rt.toNumber(s.rt.getProperty(p, s.rt.publicName("y")));
+    }
+
+    get frameRate(): number {
+      return this.$cursorFrameRate ?? 0;
+    }
+
+    // A negative rate is 0; NaN stays.
+    set frameRate(value: Value) {
+      const rate = s.rt.toNumber(value);
+      this.$cursorFrameRate = rate < 0 ? 0 : rate;
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.ui::Mouse", MouseNatives);
+  avm2.registerNativeClass(natives, "flash.ui::MouseCursorData", MouseCursorDataNatives);
+  return natives;
+}