@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/avm1/input.js

@@ -0,0 +1,483 @@
+// An AVM1 movie's input as its scripts see it: Key's state and its
+// listeners, keyPress's buttons and clips, Mouse's listeners and wheel,
+// and the pointer's button events to buttons and to clips in button mode,
+// in Ruffle's (https://github.com/ruffle-rs/ruffle) order (Avm1Button,
+// MovieClip's event_dispatch: MIT OR Apache-2.0, Copyright (c) 2018-2022
+// Ruffle LLC and Ruffle contributors). avm1/keyboard.ts and
+// avm1/pointer.ts turn the host's events into these.
+import { ButtonCondition, ClipEvent } from "../../format/index.js";
+import { avm1 } from "../../runtime/index.js";
+import { ButtonObject, Container, MovieClip } from "../display/display.js";
+import { ClipNative, nativeOf } from "./globals/MovieClip.js";
+import { BLOCK, NO_ARGS, NO_BLOCKS, NORMAL, NOTIFY, Queued } from "./queue.js";
+import { handlersOfButton, NO_HANDLERS } from "./swf.js";
+/** The pointer's events that make a clip a button where its clip actions have one (Ruffle's BUTTON_EVENT_FLAGS). */
+const BUTTON_EVENTS = ClipEvent.press |
+    ClipEvent.release |
+    ClipEvent.releaseOutside |
+    ClipEvent.rollOver |
+    ClipEvent.rollOut |
+    ClipEvent.dragOver |
+    ClipEvent.dragOut |
+    ClipEvent.keyPress;
+/** The AS2 methods that make a clip a button where its object, or what it inherits, has one. */
+const BUTTON_METHODS = [
+    "onPress",
+    "onRelease",
+    "onReleaseOutside",
+    "onRollOver",
+    "onRollOut",
+    "onDragOver",
+    "onDragOut",
+];
+/** BUTTON_METHODS as a SWF from 7 names them, and as one up to 6 does, folded. */
+const BUTTON_NAMES = new Set(BUTTON_METHODS);
+const BUTTON_NAMES_FOLDED = new Set(BUTTON_METHODS.map((name) => avm1.fold(name)));
+// Objects never given one of them are passed by (buttonMode).
+avm1.markNames(BUTTON_METHODS);
+/** The most prototypes a lookup walks, as the runtime's. */
+const DEPTH = 255;
+/** The button transition each of the pointer's events is, by the event's bit (Ruffle's Avm1Button). */
+const CONDITIONS = new Map([
+    [ClipEvent.rollOver, ButtonCondition.idleToOverUp],
+    [ClipEvent.rollOut, ButtonCondition.overUpToIdle],
+    [ClipEvent.press, ButtonCondition.overUpToOverDown],
+    [ClipEvent.release, ButtonCondition.overDownToOverUp],
+    [ClipEvent.releaseOutside, ButtonCondition.outDownToIdle],
+    [ClipEvent.dragOut, ButtonCondition.overDownToOutDown],
+    [ClipEvent.dragOver, ButtonCondition.outDownToOverDown],
+]);
+/** The frame label a clip in button mode goes to and stops at on each of the pointer's events. */
+const LABELS = new Map([
+    [ClipEvent.rollOut, "_up"],
+    [ClipEvent.releaseOutside, "_up"],
+    [ClipEvent.rollOver, "_over"],
+    [ClipEvent.release, "_over"],
+    [ClipEvent.dragOut, "_over"],
+    [ClipEvent.press, "_down"],
+    [ClipEvent.dragOver, "_down"],
+]);
+/** What Mouse's listeners hear of the pointer's clip events. */
+const MOUSE_MESSAGES = new Map([
+    [ClipEvent.mouseMove, "onMouseMove"],
+    [ClipEvent.mouseDown, "onMouseDown"],
+    [ClipEvent.mouseUp, "onMouseUp"],
+]);
+/** The state a button goes to on each of the pointer's events (Ruffle's Avm1Button: a drag out shows over). */
+const BUTTON_STATES = new Map([
+    [ClipEvent.rollOver, "over"],
+    [ClipEvent.rollOut, "up"],
+    [ClipEvent.press, "down"],
+    [ClipEvent.release, "over"],
+    [ClipEvent.releaseOutside, "up"],
+    [ClipEvent.dragOut, "over"],
+    [ClipEvent.dragOver, "down"],
+]);
+/** The movie's keys and pointer, as its scripts see them. */
+export class Avm1Input {
+    movie;
+    /** The keys down by Flash's codes, the mouse's buttons among them as 1, 2 and 4. */
+    keysDown = new Set();
+    /**
+     * The keys toggled on, by their codes: each press of a key, a mouse
+     * button's too, turns it on or off, Caps Lock's as any other's (the
+     * corpus's `key_isToggled`).
+     */
+    toggled = new Set();
+    keyCode = 0;
+    keyAscii = 0;
+    shown = true;
+    /** `_global.Key` and `_global.Mouse`, whose listeners the player sends their messages. */
+    keyFace = null;
+    mouseFace = null;
+    constructor(movie) {
+        this.movie = movie;
+    }
+    keyIsDown(code) {
+        return this.keysDown.has(code);
+    }
+    keyToggled(code) {
+        return this.toggled.has(code);
+    }
+    /**
+     * Every key let go, with no event, as the player loses focus
+     * (Player.setActive): their releases go elsewhere and never come. The
+     * mouse's buttons, 1, 2 and 4, stay the pointer's, which tells their
+     * releases. What is toggled stays, as a release toggles nothing.
+     */
+    releaseKeys() {
+        for (const code of this.keysDown) {
+            if (code !== 1 && code !== 2 && code !== 4) {
+                this.keysDown.delete(code);
+            }
+        }
+    }
+    get mouseShown() {
+        return this.shown;
+    }
+    set mouseShown(shown) {
+        this.shown = shown;
+        this.movie.pointer?.updateCursor();
+    }
+    /** A mouse button, as the pointer gives it (0 left, 1 middle, 2 right), down or up: Key's 1, 4 or 2. */
+    mouseButton(button, down) {
+        const code = button === 0 ? 1 : button === 1 ? 4 : button === 2 ? 2 : 0;
+        if (code === 0) {
+            return;
+        }
+        this.keyState(code, down);
+    }
+    /**
+     * A key down or up in Key's state: the last key, a press toggling it
+     * unless it was already down (a held key's repeats do not), as Ruffle's
+     * input state has it.
+     */
+    keyState(code, down) {
+        this.keyCode = code;
+        if (code === 0) {
+            return;
+        }
+        if (!down) {
+            this.keysDown.delete(code);
+            return;
+        }
+        if (!this.keysDown.has(code) && !this.toggled.delete(code)) {
+            this.toggled.add(code);
+        }
+        this.keysDown.add(code);
+    }
+    /**
+     * A key pressed or let go (avm1/keyboard.ts), as Ruffle orders it:
+     * every clip's keyDown or keyUp clip actions, as they are drawn, then Key's
+     * listeners' onKeyDown or onKeyUp; then, for a press of a key that
+     * `press` is a keyPress of, the first button or clip in the order they
+     * are drawn whose keyPress it is runs its actions for it. The queue runs
+     * once. Whether a keyPress ran.
+     */
+    key(down, keyCode, charCode, press, typed = 0, shift = false) {
+        if (this.movie.halted || !this.movie.loaded) {
+            return false;
+        }
+        this.keyState(keyCode, down);
+        this.keyAscii = charCode;
+        this.movie.timers.begin();
+        try {
+            // To the clips as they are drawn, the lowest first, what is in one before it (Ruffle's order).
+            // What has the focus also hears onKeyDown or onKeyUp, from SWF 6, while the highlight is active.
+            const event = down ? ClipEvent.keyDown : ClipEvent.keyUp;
+            const focused = this.movie.focusTracker.focusedObject;
+            const heard = this.movie.version >= 6 &&
+                this.movie.focusTracker.highlight !== "inactive" &&
+                focused !== null &&
+                this.flag(focused, "enabled")
+                ? focused
+                : null;
+            const visit = (d) => {
+                if (d instanceof Container) {
+                    for (const child of d.children) {
+                        visit(child);
+                    }
+                }
+                if (d instanceof MovieClip) {
+                    this.movie.dispatch(d, event, d === heard);
+                }
+                else if (d instanceof ButtonObject && d === heard) {
+                    this.movie.method(d, event, false);
+                }
+            };
+            for (const level of this.movie.levelClips()) {
+                visit(level);
+            }
+            this.notify(this.keyFace, down ? "onKeyDown" : "onKeyUp");
+            const pressed = down && press !== 0 && this.queueKeyPress(press);
+            // A key no keyPress took: Tab moves the focus, after what is queued runs; Enter and Space
+            // press what has it.
+            let used = pressed;
+            if (down && !pressed && keyCode === 9) {
+                this.movie.queue.run();
+                // A movie with nothing to tab to leaves Tab to the page.
+                used = this.movie.focusTracker.tab(shift);
+            }
+            else if (down && !pressed && (keyCode === 13 || typed === 32)) {
+                // A press it made keeps the page from acting on the key too: Space would scroll it.
+                used = this.movie.focusTracker.activate();
+            }
+            this.movie.queue.run();
+            return used;
+        }
+        finally {
+            this.movie.timers.end();
+        }
+    }
+    /** Text typed with no key events (avm1/keyboard.ts): a keyPress of its character, as `key` runs one. */
+    keyPress(press) {
+        if (this.movie.halted || !this.movie.loaded || press === 0) {
+            return false;
+        }
+        this.movie.timers.begin();
+        try {
+            const pressed = this.queueKeyPress(press) || (press === 32 && this.movie.focusTracker.activate());
+            this.movie.queue.run();
+            return pressed;
+        }
+        finally {
+            this.movie.timers.end();
+        }
+    }
+    /**
+     * The first button or clip, as they are drawn, the lowest first and what
+     * is in one before it, whose keyPress is `press`: a button's condition
+     * blocks with that key, enabled or not, with its parent as target; a
+     * clip's `on (keyPress)` clip actions. A hidden clip takes none, nor what
+     * is in it, a hidden button none while it is up, and a button in a button
+     * none. Whether one was queued.
+     */
+    queueKeyPress(press) {
+        const visit = (d, inButton) => {
+            const button = d instanceof ButtonObject ? d : null;
+            if (!d.visible && (button === null || button.state === "up")) {
+                return false;
+            }
+            if (d instanceof Container) {
+                for (const child of d.children) {
+                    if (visit(child, inButton || button !== null)) {
+                        return true;
+                    }
+                }
+            }
+            if (button) {
+                const id = button.character?.id;
+                let found = false;
+                if (!inButton && button.parent !== null && id !== undefined) {
+                    const swf = this.movie.swfOf(button);
+                    for (const h of handlersOfButton(swf, id)) {
+                        if (h.key === press) {
+                            this.movie.queue.enqueue(NORMAL, new Queued(BLOCK, button.parent, swf, h.block));
+                            found = true;
+                        }
+                    }
+                }
+                return found;
+            }
+            const native = d instanceof MovieClip ? nativeOf(d) : null;
+            if (native !== null && this.movie.swfOf(d).version >= 5) {
+                let found = false;
+                for (const h of native.handlers ?? NO_HANDLERS) {
+                    if (h.events & ClipEvent.keyPress && h.key === press) {
+                        this.movie.queue.enqueue(NORMAL, new Queued(BLOCK, d, native.swf, h.block));
+                        found = true;
+                    }
+                }
+                return found;
+            }
+            return false;
+        };
+        return this.movie.levelClips().some((level) => visit(level, false));
+    }
+    /** `object`'s listeners told `name` with `args`, queued after what is queued now. */
+    notify(object, name, args = NO_ARGS) {
+        if (object !== null && this.movie.root !== null) {
+            this.movie.queue.enqueue(NORMAL, new Queued(NOTIFY, this.movie.root, null, 0, 0, false, name, NO_BLOCKS, object, args));
+        }
+    }
+    /** Whether Mouse has listeners, which the wheel would tell: the page keeps it otherwise. */
+    get mouseHeard() {
+        const face = this.mouseFace;
+        const listeners = face === null ? undefined : avm1.get(face, "_listeners", this.movie.version);
+        return (listeners instanceof avm1.Avm1Object &&
+            avm1.toNumber(avm1.get(listeners, "length", this.movie.version), this.movie.version) > 0);
+    }
+    /** The wheel turned by `delta` lines over `target`: Mouse's listeners' onMouseWheel, then the queue runs. */
+    mouseWheel(delta, target) {
+        if (this.movie.halted || !this.movie.loaded) {
+            return;
+        }
+        this.movie.timers.begin();
+        try {
+            this.notify(this.mouseFace, "onMouseWheel", [delta, target?.avm1 ?? undefined]);
+            this.movie.queue.run();
+        }
+        finally {
+            this.movie.timers.end();
+        }
+    }
+    /**
+     * Whether the pointer takes `clip` as a button (Ruffle's is_button_mode):
+     * its clip actions have one of the pointer's button events, or, below
+     * the root, its object has one of their AS2 methods, its own or
+     * inherited, a class's among them.
+     */
+    buttonMode(clip) {
+        const native = nativeOf(clip);
+        for (const h of native?.handlers ?? NO_HANDLERS) {
+            if (h.events & BUTTON_EVENTS) {
+                return true;
+            }
+        }
+        const face = clip.avm1;
+        const version = this.movie.version;
+        if (face === null || clip === this.movie.root || version < 6) {
+            return false;
+        }
+        // avm1.has for each name, the pointer asking it of every clip it passes:
+        // the clip's children by name, which its object finds after its own
+        // properties, looked over once for all the names; then along the chain
+        // only the objects ever given one of them, and any with locals it
+        // makes as asked, an activation's, or a display object's own side.
+        const names = version > 6 ? BUTTON_NAMES : BUTTON_NAMES_FOLDED;
+        if (face.display !== null) {
+            for (const child of clip.children) {
+                const name = child.name;
+                if (name !== "" && names.has(version > 6 ? name : avm1.fold(name))) {
+                    return true;
+                }
+            }
+        }
+        let o = face;
+        for (let depth = 0; o instanceof avm1.Avm1Object && depth < DEPTH; depth++) {
+            if (o.marked || o.lazy !== null) {
+                for (const name of BUTTON_METHODS) {
+                    if (o.own(name, version) !== undefined) {
+                        return true;
+                    }
+                }
+            }
+            if (depth > 0 && o.display !== null) {
+                for (const name of BUTTON_METHODS) {
+                    if (o.display.get(name, version) !== avm1.ABSENT) {
+                        return true;
+                    }
+                }
+            }
+            o = o.protoFor(version);
+        }
+        return false;
+    }
+    /** A button's or clip's AS2 flag, `enabled` or `useHandCursor`: true where it is undefined, as Flash reads it. */
+    flag(d, name) {
+        const value = this.read(d, name);
+        return value === undefined || avm1.toBoolean(value, this.movie.version);
+    }
+    /** What a clip's `hitArea` names, a clip or button the pointer tests in its place; null for none. */
+    hitArea(clip) {
+        if (this.movie.version < 6) {
+            return null;
+        }
+        const area = this.read(clip, "hitArea");
+        const display = area instanceof avm1.Avm1Object ? area.display : null;
+        return display instanceof ClipNative ? display.target : null;
+    }
+    /**
+     * `d`'s AVM1 object's property `name`, read as code reads it, in an
+     * activation of `d`'s, as a getter `addProperty` gave it may be AVM1
+     * code; undefined where it has no object, or the read throws. Within
+     * a script, the begin and end go for nothing: the script's own hold.
+     */
+    read(d, name) {
+        const face = d.avm1;
+        const cx = this.movie.halted ? null : this.movie.activationOf(d);
+        if (face === null || cx === null) {
+            return undefined;
+        }
+        let value;
+        this.movie.timers.begin();
+        try {
+            this.movie.rt.call(cx, () => {
+                value = avm1.get(face, name, this.movie.version);
+            });
+        }
+        finally {
+            this.movie.timers.end();
+        }
+        return value;
+    }
+    /**
+     * The pointer's button events, each to its object, in the order given,
+     * then the queue runs once. A button runs its condition blocks for the
+     * transition, with its parent as target, plays the transition's sound
+     * and changes state, then, from SWF 6, its AS2 method; a clip in button
+     * mode goes to the event's frame label, if it has one, and stops, then
+     * runs its clip actions and method for it. Ruffle's order (Avm1Button
+     * and MovieClip's event_dispatch).
+     */
+    buttonEvents(events) {
+        if (this.movie.halted || !this.movie.loaded || events.length === 0) {
+            return;
+        }
+        this.movie.timers.begin();
+        try {
+            for (const [d, event] of events) {
+                this.buttonDispatch(d, event);
+            }
+            this.movie.queue.run();
+        }
+        finally {
+            this.movie.timers.end();
+        }
+    }
+    /** One of the pointer's button events to `d`, a button or a clip in button mode, queued. */
+    buttonDispatch(d, event) {
+        if (this.movie.removed(d)) {
+            return;
+        }
+        if (d instanceof ButtonObject) {
+            this.buttonEvent(d, event);
+        }
+        else if (d instanceof MovieClip) {
+            const label = LABELS.get(event);
+            const timeline = this.movie.timeline(d);
+            const frame = label === undefined ? undefined : timeline.labelFrame(label);
+            if (frame !== undefined) {
+                timeline.goto(frame, false);
+            }
+            this.movie.dispatch(d, event);
+        }
+    }
+    buttonEvent(button, event) {
+        const condition = CONDITIONS.get(event) ?? 0;
+        const parent = button.parent;
+        const id = button.character?.id;
+        if (parent !== null && id !== undefined) {
+            const swf = this.movie.swfOf(button);
+            for (const h of handlersOfButton(swf, id)) {
+                if (h.conditions & condition) {
+                    this.movie.queue.enqueue(NORMAL, new Queued(BLOCK, parent, swf, h.block));
+                }
+            }
+        }
+        const state = BUTTON_STATES.get(event);
+        if (state !== undefined && state !== button.state) {
+            // A drag's transitions are silent.
+            button.setState(state, event !== ClipEvent.dragOut && event !== ClipEvent.dragOver);
+        }
+        this.movie.method(button, event, false);
+    }
+    /**
+     * Broadcast a pointer's event (avm1/pointer.ts): every clip's clip
+     * actions for it, the newest first, then Mouse's listeners, then the
+     * queue runs. A key's go by `key`.
+     */
+    clipEvent(event) {
+        if (this.movie.halted || !this.movie.loaded) {
+            return;
+        }
+        this.movie.timers.begin();
+        try {
+            for (let i = this.movie.clips.length - 1; i >= 0; i--) {
+                const clip = this.movie.clips[i];
+                if (!this.movie.removed(clip)) {
+                    this.movie.dispatch(clip, event);
+                }
+            }
+            // Mouse's listeners after every clip's, as Ruffle queues them.
+            const message = MOUSE_MESSAGES.get(event);
+            if (message !== undefined) {
+                this.notify(this.mouseFace, message);
+            }
+            this.movie.queue.run();
+        }
+        finally {
+            this.movie.timers.end();
+        }
+    }
+}

package/dist/thread/player/avm1/keyboard.js

@@ -0,0 +1,113 @@
+// The keyboard of an AVM1 movie: each key goes to Key, its clips' keyDown
+// and keyUp clip actions, and a press to the first button or clip whose
+// keyPress it is (input.ts's key). A keyPress's key is Flash's own code, as
+// Ruffle's ButtonKeyCode has it (https://github.com/ruffle-rs/ruffle,
+// core/src/events.rs: MIT OR Apache-2.0, Copyright (c) 2018-2022 Ruffle
+// LLC and Ruffle contributors): a printable character's ASCII code, or one
+// of the editing keys' below 20. A host whose text comes apart from its
+// keys (the corpus's replay) gives the character by `text`.
+import { TextObject } from "../display/display.js";
+import { pasteable, TextEditor } from "../input/text-editor.js";
+/** The editing keys' keyPress codes, by Flash's key codes. */
+const KEY_PRESSES = new Map([
+    [37, 1], // Left
+    [39, 2], // Right
+    [36, 3], // Home
+    [35, 4], // End
+    [45, 5], // Insert
+    [46, 6], // Delete
+    [8, 8], // Backspace
+    [13, 13], // Enter
+    [38, 14], // Up
+    [40, 15], // Down
+    [33, 16], // Page Up
+    [34, 17], // Page Down
+    [9, 18], // Tab
+    [27, 19], // Escape
+]);
+/** A printable ASCII character's keyPress code, its own; 0 for any other. */
+const printable = (charCode) => (charCode >= 32 && charCode <= 126 ? charCode : 0);
+export class Avm1Keyboard {
+    avm1;
+    handled = 0;
+    editor = new TextEditor((field) => {
+        const movie = this.avm1;
+        movie.timers.begin();
+        try {
+            field.fit();
+            movie.textChanged(field);
+            if (field.avm1) {
+                movie.callback(field.avm1, "broadcastMessage", ["onChanged", field.avm1]);
+            }
+            movie.queue.run();
+        }
+        finally {
+            movie.timers.end();
+        }
+    });
+    constructor(avm1) {
+        this.avm1 = avm1;
+    }
+    /** A key: its keyPress, where it is one, the editing key's, else, with edits, its character's. */
+    handle(type, k, edits = true) {
+        this.handled++;
+        if (type === "up") {
+            this.avm1.input.key(false, k.keyCode, k.charCode, 0);
+            return false;
+        }
+        const typed = edits ? printable(k.charCode) : 0;
+        const press = KEY_PRESSES.get(k.keyCode) ?? typed;
+        const used = this.avm1.input.key(true, k.keyCode, k.charCode, press, typed, !!k.shiftKey);
+        return used || (edits && k.keyCode !== 9 && this.edit(k));
+    }
+    text(k) {
+        this.handled++;
+        const used = this.avm1.input.keyPress(printable(k.charCode));
+        return used || this.edit(k);
+    }
+    field() {
+        const d = this.avm1.focused;
+        return !this.avm1.halted && d instanceof TextObject && !this.avm1.removed(d) ? d : null;
+    }
+    edit(k) {
+        const field = this.field();
+        if (!field || (field.type !== "input" && !field.selectable)) {
+            return false;
+        }
+        if (k.ctrlKey && !k.altKey && k.keyCode === 65) {
+            if (field.selectable) {
+                field.select(0, field.model.text.length);
+            }
+            return true;
+        }
+        return this.editor.edit(field, k);
+    }
+    copy(cut = false) {
+        this.handled++;
+        const field = this.field();
+        if (!field || field.displayAsPassword || (cut && field.type !== "input")) {
+            return null;
+        }
+        const [from, to] = field.selection;
+        if (from === to) {
+            return null;
+        }
+        const data = { text: field.model.text.slice(from, to).replace(/\r\n?/g, "\n") };
+        if (cut) {
+            this.editor.replace(field, from, to, "");
+        }
+        return data;
+    }
+    paste(data = null) {
+        this.handled++;
+        const field = this.field();
+        if (field?.type !== "input" || !data) {
+            return false;
+        }
+        const text = pasteable(field.multiline, data.text);
+        if (text !== "") {
+            this.editor.type(field, text);
+        }
+        return true;
+    }
+}