@swf2es/player 0.0.0-stage → 0.1.1

package/src/playerglobal/flash/desktop/Clipboard.ts

@@ -0,0 +1,217 @@
+// flash.desktop.Clipboard as Flash Player has it: one Clipboard, the
+// system's, generalClipboard, over the player's (scripting/clipboard.ts).
+// playerglobal's AS3 maps formats to these natives and checks access with
+// canReadContents and canWriteContents: a script reads only in a paste,
+// writes only in a user's event. Flash Player carries text, HTML, rich
+// text, a script's own formats as references and serialized objects; a
+// URL is kept as AIR keeps it, but bitmaps and files are AIR's alone.
+import { avm2 } from "@swf2es/runtime";
+import { HTML, TEXT } from "../../../scripting/clipboard.js";
+import type { Scripting } from "../../../scripting.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+const RTF = "air:rtf";
+const URL_FORMAT = "air:url";
+const REFERENCE = "air:reference:";
+const SERIALIZATION = "air:serialization:";
+
+/** Whether `format` is one of Flash's own, which keeps its name, rather than a script's. */
+const system = (format: string) => format.startsWith("air:") || format.startsWith("flash:");
+
+export function clipboardNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  const clipboard = () => s.clipboard;
+  const str = (v: Value) => s.rt.toString(v);
+  /** clear and clearData check their own access, as no AS3 does it for them. */
+  const writing = () => {
+    if (!clipboard().writable) {
+      throw s.rt.error("SecurityError", 2191);
+    }
+  };
+  /** A stored ByteArray from its start, as each read deserializes it anew. */
+  const rewound = (v: Value): Value => {
+    if (v) {
+      avm2.bytesOf(s.rt, v as AsObject).position = 0;
+    }
+
+    return v ?? null;
+  };
+
+  class ClipboardNatives {
+    static get generalClipboard(): Value {
+      return general(s);
+    }
+
+    /** Its formats, a script's own by the names it gave them. */
+    get formats(): Value {
+      const names = clipboard().formats.map((f) =>
+        f.startsWith(REFERENCE)
+          ? f.slice(REFERENCE.length)
+          : f.startsWith(SERIALIZATION)
+            ? f.slice(SERIALIZATION.length)
+            : f,
+      );
+      return s.rt.array([...new Set(names)]);
+    }
+
+    clear(): void {
+      writing();
+      clipboard().clear();
+    }
+
+    clearData(format: Value): void {
+      writing();
+      const name = str(format);
+      if (system(name)) {
+        clipboard().delete(name);
+      } else {
+        clipboard().delete(REFERENCE + name);
+        clipboard().delete(SERIALIZATION + name);
+      }
+    }
+
+    // A dead clipboard is AIR's, one let go of after a drag.
+    get "flash.desktop:Clipboard::alive"(): boolean {
+      return true;
+    }
+
+    get "flash.desktop:Clipboard::canReadContents"(): boolean {
+      return clipboard().readable;
+    }
+
+    get "flash.desktop:Clipboard::canWriteContents"(): boolean {
+      return clipboard().writable;
+    }
+
+    "flash.desktop:Clipboard::nativeSetHandler"(format: Value, handler: Value): void {
+      clipboard().setHandler(str(format), () => {
+        s.rt.call(handler, null);
+      });
+    }
+
+    "flash.desktop:Clipboard::setHandlerStoringData"(storing: Value): void {
+      clipboard().storing = !!storing;
+    }
+
+    "flash.desktop:Clipboard::getObjectReference"(format: Value): Value {
+      return clipboard().get(str(format));
+    }
+
+    "flash.desktop:Clipboard::putObjectReference"(format: Value, value: Value): void {
+      clipboard().set(str(format), value);
+    }
+
+    "flash.desktop:Clipboard::getString"(): Value {
+      return clipboard().get(TEXT) ?? null;
+    }
+
+    "flash.desktop:Clipboard::putString"(text: Value): void {
+      clipboard().set(TEXT, str(text));
+    }
+
+    "flash.desktop:Clipboard::getHTML"(): Value {
+      return clipboard().get(HTML) ?? null;
+    }
+
+    "flash.desktop:Clipboard::putHTML"(html: Value): void {
+      clipboard().set(HTML, str(html));
+    }
+
+    "flash.desktop:Clipboard::getRTF"(): Value {
+      return rewound(clipboard().get(RTF));
+    }
+
+    "flash.desktop:Clipboard::putRTF"(bytes: Value): void {
+      clipboard().set(RTF, bytes);
+    }
+
+    "flash.desktop:Clipboard::getByteArray"(format: Value): Value {
+      return rewound(clipboard().get(str(format)));
+    }
+
+    "flash.desktop:Clipboard::putByteArray"(format: Value, bytes: Value): void {
+      clipboard().set(str(format), bytes);
+    }
+
+    get "flash.desktop:Clipboard::swfVersion"(): number {
+      return s.rt.swfVersion;
+    }
+
+    get supportsFilePromise(): boolean {
+      return false;
+    }
+
+    "flash.desktop:Clipboard::getURL"(): Value {
+      return clipboard().get(URL_FORMAT) ?? null;
+    }
+
+    "flash.desktop:Clipboard::putURL"(url: Value): void {
+      clipboard().set(URL_FORMAT, str(url));
+    }
+
+    // Bitmaps and files go only through AIR's clipboard.
+    "flash.desktop:Clipboard::getBitmapData"(): Value {
+      return null;
+    }
+
+    "flash.desktop:Clipboard::putBitmapData"(): void {}
+
+    "flash.desktop:Clipboard::getFileList"(): Value {
+      return null;
+    }
+
+    "flash.desktop:Clipboard::nativePutFileList"(): void {}
+
+    "flash.desktop:Clipboard::nativeGetFilePromiseList"(): Value {
+      return null;
+    }
+
+    "flash.desktop:Clipboard::nativePutFilePromiseList"(): void {}
+  }
+
+  avm2.registerNativeClass(natives, "flash.desktop::Clipboard", ClipboardNatives);
+  return natives;
+}
+
+/** Each player's generalClipboard, made on first use. */
+const generals = new WeakMap<Scripting, AsObject>();
+/** Whether the player is making its generalClipboard, the one Clipboard `new` may make. */
+let making = false;
+
+function general(s: Scripting): AsObject {
+  let o = generals.get(s);
+  if (!o) {
+    making = true;
+    try {
+      o = s.rt.constructClass(s.rt.classNamed("flash.desktop::Clipboard"), []) as AsObject;
+    } finally {
+      making = false;
+    }
+
+    generals.set(s, o);
+  }
+
+  return o;
+}
+
+/**
+ * `new Clipboard()` is AIR's: Flash Player has the system's alone, and
+ * refuses another with IllegalOperationError #2178.
+ */
+export function clipboardHooks(): Record<string, avm2.ClassHook> {
+  return {
+    "flash.desktop::Clipboard": {
+      construct(rt: avm2.Runtime, cls: AsObject, args: Value[]): Value {
+        if (!making) {
+          throw rt.error("flash.errors::IllegalOperationError", 2178);
+        }
+
+        const o = cls.$it.instance() as AsObject;
+        cls.$it.proto.$init.apply(o, args);
+        return o;
+      },
+    },
+  };
+}

package/src/playerglobal/flash/desktop/NativeApplication.ts

@@ -0,0 +1,241 @@
+// flash.desktop.NativeApplication, AIR's one application object, over the
+// host's AirApplication (hosts.ts): its descriptor, its window and its
+// launch, which adl hands each InvokeEvent listener once it listens. A
+// listener added in the document class's constructor has it before the
+// first frame's ENTER_FRAME; one added in a frame's scripts, at that
+// frame's end; each once, those that had it before not again, with the
+// directory it was launched from as a File. Without a host the application
+// has no window and was launched with no arguments, from nowhere.
+// What the values are where no host says: adl's (AIR 51.3).
+import { avm2 } from "@swf2es/runtime";
+import { dispatchEvent, dispatchToListener } from "../../../scripting/events.js";
+import type { Scripting } from "../../../scripting.js";
+import { nativeWindowOf } from "../display/NativeWindow.js";
+import { addListener, removeListener } from "../events/EventDispatcher.js";
+import { fileAt } from "../filesystem/File.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+/** NativeApplication.runtimeVersion, and its patch level: the AIR these natives follow. */
+export const AIR_RUNTIME_VERSION = "51.3.1.2";
+const AIR_PATCH_LEVEL = 2;
+
+const INVOKE = "invoke";
+
+export function nativeApplicationNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  let application: AsObject | null = null;
+  /** InvokeEvent listeners added since the launch was last handed out, in the order added. */
+  const awaiting: Value[] = [];
+  let autoExit = true;
+  let idleThreshold = 300;
+  let systemIdleMode = "normal";
+  let executeInBackground = false;
+
+  /** The launch, to each listener added since it was last handed out, at the frame's end. */
+  const handOut = () => {
+    const app = application as AsObject;
+    const listening = app.$listeners?.get(INVOKE) ?? [];
+    for (const fn of awaiting.splice(0)) {
+      // Taken off again before the frame ended, it hears nothing.
+      if (!listening.some((l: { fn: Value; capture: boolean }) => l.fn === fn && !l.capture)) {
+        continue;
+      }
+
+      const event = s.rt.construct(
+        s.rt.classNamed("flash.events::InvokeEvent"),
+        INVOKE,
+        false,
+        false,
+        s.application?.currentDirectory ? fileAt(s, s.application.currentDirectory) : null,
+        s.rt.array([...(s.application?.arguments ?? [])]),
+        "standard",
+      ) as AsObject;
+      dispatchToListener(s, app, event, fn);
+    }
+  };
+
+  class NativeApplicationNatives {
+    static get nativeApplication(): Value {
+      application ??= s.rt.construct(
+        s.rt.classNamed("flash.desktop::NativeApplication"),
+      ) as AsObject;
+      return application;
+    }
+
+    // A browser's or Electron's window has no menu, dock or tray of AIR's.
+    static get supportsMenu(): boolean {
+      return false;
+    }
+
+    static get supportsDockIcon(): boolean {
+      return false;
+    }
+
+    static get supportsSystemTrayIcon(): boolean {
+      return false;
+    }
+
+    static get supportsDefaultApplication(): boolean {
+      return false;
+    }
+
+    static get supportsStartAtLogin(): boolean {
+      return false;
+    }
+
+    addEventListener(type: Value, fn: Value, useCapture: Value, priority: Value): void {
+      const added = addListener(s, this as unknown as AsObject, type, fn, useCapture, priority);
+      if (added && type === INVOKE && !useCapture) {
+        if (awaiting.length === 0) {
+          s.afterExitFrame.push(handOut);
+        }
+
+        awaiting.push(fn);
+      }
+    }
+
+    removeEventListener(type: Value, fn: Value, useCapture: Value): void {
+      removeListener(s, this as unknown as AsObject, type, fn, useCapture);
+    }
+
+    dispatchEvent(event: Value): boolean {
+      return dispatchEvent(s, this as unknown as AsObject, event as AsObject);
+    }
+
+    exit(code: Value): void {
+      s.application?.exit?.(Number(code) | 0);
+    }
+
+    get runtimeVersion(): string {
+      return AIR_RUNTIME_VERSION;
+    }
+
+    get runtimePatchLevel(): number {
+      return AIR_PATCH_LEVEL;
+    }
+
+    get applicationID(): string {
+      return s.application?.id ?? "";
+    }
+
+    get publisherID(): string {
+      return "";
+    }
+
+    get applicationDescriptor(): Value {
+      const text = s.application?.descriptor;
+      return text ? s.rt.constructClass(s.rt.builtinClass("XML"), [text]) : null;
+    }
+
+    get menu(): Value {
+      return null;
+    }
+
+    set menu(_v: Value) {}
+
+    get icon(): Value {
+      return null;
+    }
+
+    get autoExit(): boolean {
+      return autoExit;
+    }
+
+    set autoExit(v: Value) {
+      autoExit = !!v;
+    }
+
+    get idleThreshold(): number {
+      return idleThreshold;
+    }
+
+    set idleThreshold(v: Value) {
+      idleThreshold = Number(v) | 0;
+    }
+
+    get timeSinceLastUserInput(): number {
+      return 0;
+    }
+
+    get systemIdleMode(): string {
+      return systemIdleMode;
+    }
+
+    set systemIdleMode(v: Value) {
+      systemIdleMode = String(v);
+    }
+
+    get executeInBackground(): boolean {
+      return executeInBackground;
+    }
+
+    set executeInBackground(v: Value) {
+      executeInBackground = !!v;
+    }
+
+    // adl refuses it, being no installed application; so does a host.
+    get startAtLogin(): boolean {
+      throw s.rt.error("Error", 2014);
+    }
+
+    set startAtLogin(_v: Value) {
+      throw s.rt.error("Error", 2014);
+    }
+
+    get activeWindow(): Value {
+      const window = nativeWindowOf(s);
+      return window && s.application?.window?.active() ? window : null;
+    }
+
+    get openedWindows(): Value {
+      const window = nativeWindowOf(s);
+      return s.rt.array(window ? [window] : []);
+    }
+
+    activate(_window: Value): void {
+      s.application?.window?.activate?.();
+    }
+
+    // The edit commands go to the focused text, which the player's keyboard handles itself.
+    copy(): boolean {
+      return false;
+    }
+
+    cut(): boolean {
+      return false;
+    }
+
+    paste(): boolean {
+      return false;
+    }
+
+    clear(): boolean {
+      return false;
+    }
+
+    selectAll(): boolean {
+      return false;
+    }
+
+    getDefaultApplication(_extension: Value): Value {
+      return null;
+    }
+
+    isSetAsDefaultApplication(_extension: Value): boolean {
+      return false;
+    }
+
+    setAsDefaultApplication(_extension: Value): void {
+      throw s.rt.error("Error", 2014);
+    }
+
+    removeAsDefaultApplication(_extension: Value): void {
+      throw s.rt.error("Error", 2014);
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.desktop::NativeApplication", NativeApplicationNatives);
+  return natives;
+}

package/src/playerglobal/flash/display/AVM1Movie.ts

@@ -0,0 +1,24 @@
+// flash.display.AVM1Movie: an AVM1 SWF's root as an AS3 Loader's content
+// (Loads.requestLoad), a display object AS3 cannot script into. Its
+// `call` and `addCallback` are playerglobal's own code, which throws Error
+// #2014 while interop is unavailable; with no AVM1 interpreter it always
+// is, so nothing ever crosses to the AVM1 side.
+import { avm2 } from "@swf2es/runtime";
+
+export function avm1MovieNatives(): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  class AVM1MovieNatives {
+    get "flash.display:AVM1Movie::_interopAvailable"(): boolean {
+      return false;
+    }
+
+    "flash.display:AVM1Movie::_callAS2"(): void {}
+
+    // Its constructor hands over the closure an AVM1 call would reach AS3 by; no AVM1 code calls it.
+    "flash.display:AVM1Movie::_setCallAS3"(): void {}
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::AVM1Movie", AVM1MovieNatives);
+  return natives;
+}

package/src/playerglobal/flash/display/Bitmap.ts

@@ -0,0 +1,76 @@
+// flash.display.Bitmap: a display object showing a BitmapData, its node a
+// BitmapObject (display/display.ts) that the renderer draws as a textured sprite.
+import { avm2 } from "@swf2es/runtime";
+import { type BitmapObject, CONTENT } from "../../../display/display.js";
+import type { Scripting } from "../../../scripting.js";
+
+type Value = avm2.Value;
+type AsObject = avm2.AsObject;
+
+export function bitmapNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+
+  // A native runs with the AS3 object as `this`, so the constructor sets
+  // what the setters set through the same helpers, not through them.
+  const setData = (o: AsObject, v: Value) => {
+    const data = v === null || v === undefined ? null : (v as AsObject);
+    o.$bitmapData = data;
+    const display: BitmapObject = o.$display;
+    display.store = data?.$store ?? null;
+    display.invalidate(CONTENT);
+  };
+  const setSnapping = (o: AsObject, v: Value) => {
+    const mode = v === null || v === undefined ? "auto" : s.rt.toString(v);
+    if (mode !== "auto" && mode !== "always" && mode !== "never") {
+      throw s.rt.error("ArgumentError", 2008, "pixelSnapping");
+    }
+
+    (o.$display as BitmapObject).pixelSnapping = mode;
+  };
+  const setSmoothing = (o: AsObject, v: Value) => {
+    const display: BitmapObject = o.$display;
+    display.smoothing = !!v;
+    display.invalidate(CONTENT);
+  };
+
+  class BitmapNatives {
+    declare $display: BitmapObject;
+    declare $bitmapData: AsObject | null;
+
+    "flash.display:Bitmap::ctor"(bitmapData: Value, pixelSnapping: Value, smoothing: Value): void {
+      // One of a bitmap's class, or placed by a timeline, shows a new BitmapData of its pixels.
+      const character = this.$display.character;
+      const none = bitmapData === null || bitmapData === undefined;
+      setData(this, none && character ? s.symbols.bitmapDataOf(character) : bitmapData);
+      setSnapping(this, pixelSnapping);
+      setSmoothing(this, smoothing);
+    }
+
+    get bitmapData(): Value {
+      return this.$bitmapData ?? null;
+    }
+
+    set bitmapData(v: Value) {
+      setData(this, v);
+    }
+
+    get pixelSnapping(): string {
+      return this.$display.pixelSnapping;
+    }
+
+    set pixelSnapping(v: Value) {
+      setSnapping(this, v);
+    }
+
+    get smoothing(): boolean {
+      return this.$display.smoothing;
+    }
+
+    set smoothing(v: Value) {
+      setSmoothing(this, v);
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.display::Bitmap", BitmapNatives);
+  return natives;
+}