@next2d/player 1.14.7 → 1.14.8

package/dist/player/next2d/events/EventDispatcher.js

@@ -0,0 +1,624 @@
+import { Event } from "./Event";
+import { EventPhase } from "./EventPhase";
+import { $setCurrentLoaderInfo } from "../../util/Global";
+import { $currentPlayer } from "../../util/Util";
+import { $getMap, $poolMap, $getArray, $poolArray } from "../../util/RenderUtil";
+/**
+ * EventDispatcher クラスは、イベントを送出するすべてのクラスの基本クラスです。
+ *
+ * The EventDispatcher class is the base class for all classes that dispatch events.
+ *
+ * @example <caption>Example usage of EventDispatcher.</caption>
+ * // new ColorTransform
+ * const {EventDispatcher} = next2d.events;
+ * const eventDispatcher   = new EventDispatcher();
+ * eventDispatcher.addEventListener(Event.ENTER_FRAME, function (event)
+ * {
+ *     // more...
+ * });
+ *
+ * @class
+ * @memberOf next2d.events
+ */
+export class EventDispatcher {
+    _$events;
+    /**
+     * @constructor
+     * @public
+     */
+    constructor() {
+        /**
+         * @type {Map}
+         * @default null
+         * @private
+         */
+        this._$events = null;
+    }
+    /**
+     * 指定されたクラスのストリングを返します。
+     * Returns the string representation of the specified class.
+     *
+     * @return  {string}
+     * @default [class EventDispatcher]
+     * @method
+     * @static
+     */
+    static toString() {
+        return "[class EventDispatcher]";
+    }
+    /**
+     * @description 指定されたクラスの空間名を返します。
+     *              Returns the space name of the specified class.
+     *
+     * @member  {string}
+     * @default next2d.events.EventDispatcher
+     * @const
+     * @static
+     */
+    static get namespace() {
+        return "next2d.events.EventDispatcher";
+    }
+    /**
+     * @description 指定されたオブジェクトのストリングを返します。
+     *              Returns the string representation of the specified object.
+     *
+     * @return {string}
+     * @method
+     * @public
+     */
+    toString() {
+        return "[object EventDispatcher]";
+    }
+    /**
+     * @description 指定されたオブジェクトの空間名を返します。
+     *              Returns the space name of the specified object.
+     *
+     * @member  {string}
+     * @default next2d.events.EventDispatcher
+     * @const
+     * @public
+     */
+    get namespace() {
+        return "next2d.events.EventDispatcher";
+    }
+    /**
+     * @description イベントリスナーオブジェクトを EventDispatcher オブジェクトに登録し、
+     *              リスナーがイベントの通知を受け取るようにします。
+     *              Registers an event listener object with an EventDispatcher object
+     *              so that the listener receives notification of an event.
+     *
+     * @param  {string}   type
+     * @param  {function} listener
+     * @param  {boolean}  [use_capture=false]
+     * @param  {number}   [priority=0]
+     * @return {void}
+     * @method
+     * @public
+     */
+    addEventListener(type, listener, use_capture = false, priority = 0) {
+        const player = $currentPlayer();
+        let events;
+        let isBroadcast = false;
+        type = `${type}`;
+        switch (type) {
+            // broadcast event
+            case Event.ENTER_FRAME:
+            case Event.EXIT_FRAME:
+            case Event.FRAME_CONSTRUCTED:
+            case Event.RENDER:
+            case Event.ACTIVATE:
+            case Event.DEACTIVATE:
+            case "keyDown":
+            case "keyUp":
+                if (!player.broadcastEvents.size
+                    || !player.broadcastEvents.has(type)) {
+                    player.broadcastEvents.set(type, $getArray());
+                }
+                events = player.broadcastEvents.get(type) || $getArray();
+                isBroadcast = true;
+                break;
+            // normal event
+            default:
+                // init
+                if (!this._$events) {
+                    this._$events = $getMap();
+                }
+                if (!this._$events.size || !this._$events.has(type)) {
+                    this._$events.set(type, $getArray());
+                }
+                events = this._$events.get(type) || $getArray();
+                break;
+        }
+        // duplicate check
+        let length = events.length;
+        for (let idx = 0; idx < length; ++idx) {
+            const event = events[idx];
+            if (use_capture !== event.useCapture) {
+                continue;
+            }
+            if (event.target !== this) {
+                continue;
+            }
+            if (event.listener === listener) {
+                length = idx;
+            }
+        }
+        // add or overwrite
+        events[length] = {
+            "listener": listener,
+            "priority": priority,
+            "useCapture": use_capture,
+            "target": this
+        };
+        if (events.length > 1) {
+            // sort(DESC)
+            events.sort(function (a, b) {
+                switch (true) {
+                    case a.priority > b.priority:
+                        return -1;
+                    case a.priority < b.priority:
+                        return 1;
+                    default:
+                        return 0;
+                }
+            });
+        }
+        // set new event
+        if (isBroadcast) {
+            player.broadcastEvents.set(type, events);
+        }
+        else {
+            if (!this._$events) {
+                this._$events = $getMap();
+            }
+            this._$events.set(type, events);
+        }
+    }
+    /**
+     * @description イベントをイベントフローに送出します。
+     *              Dispatches an event into the event flow.
+     *
+     * @param  {Event} event
+     * @return {boolean}
+     * @method
+     * @public
+     */
+    dispatchEvent(event) {
+        switch (event.type) {
+            case Event.ENTER_FRAME:
+            case Event.EXIT_FRAME:
+            case Event.FRAME_CONSTRUCTED:
+            case Event.RENDER:
+            case Event.ACTIVATE:
+            case Event.DEACTIVATE:
+            case "keyDown":
+            case "keyUp":
+                {
+                    const player = $currentPlayer();
+                    if (player && player.broadcastEvents.size
+                        && player.broadcastEvents.has(event.type)) {
+                        const events = player.broadcastEvents.get(event.type);
+                        for (let idx = 0; idx < events.length; ++idx) {
+                            const obj = events[idx];
+                            if (obj.target !== this) {
+                                continue;
+                            }
+                            // start target
+                            event.eventPhase = EventPhase.AT_TARGET;
+                            // event execute
+                            event.currentTarget = obj.target;
+                            try {
+                                event.listener = obj.listener;
+                                obj.listener.call(null, event);
+                            }
+                            catch (e) {
+                                console.error(e);
+                                return false;
+                            }
+                        }
+                        return true;
+                    }
+                }
+                break;
+            default:
+                {
+                    let events = null;
+                    if (this._$events
+                        && this._$events.size
+                        && this._$events.has(event.type)) {
+                        events = this._$events.get(event.type);
+                        if (events) {
+                            events = events.slice(0);
+                        }
+                    }
+                    if (!events) {
+                        events = $getArray();
+                    }
+                    // parent
+                    const parentEvents = $getArray();
+                    if ("parent" in this) {
+                        let parent = this.parent;
+                        while (parent) {
+                            if (parent.hasEventListener(event.type)) {
+                                const events = parent._$events
+                                    ? parent._$events.get(event.type)
+                                    : undefined;
+                                if (events) {
+                                    parentEvents.push(events);
+                                }
+                            }
+                            parent = parent.parent;
+                        }
+                    }
+                    event.target = this;
+                    if (events.length || parentEvents.length) {
+                        // start capture
+                        event.eventPhase = EventPhase.CAPTURING_PHASE;
+                        // stage => parent... end
+                        if (parentEvents.length) {
+                            switch (true) {
+                                case event._$stopImmediatePropagation:
+                                case event._$stopPropagation:
+                                    break;
+                                default:
+                                    parentEvents.reverse();
+                                    for (let idx = 0; idx < parentEvents.length; ++idx) {
+                                        const targets = parentEvents[idx];
+                                        for (let idx = 0; idx < targets.length; ++idx) {
+                                            const obj = targets[idx];
+                                            if (!obj.useCapture) {
+                                                continue;
+                                            }
+                                            // event execute
+                                            event.currentTarget = obj.target;
+                                            $setCurrentLoaderInfo(obj.target.loaderInfo);
+                                            try {
+                                                event.listener = obj.listener;
+                                                obj.listener.call(null, event);
+                                            }
+                                            catch (e) {
+                                                console.error(e);
+                                                return false;
+                                            }
+                                            if (event._$stopImmediatePropagation) {
+                                                break;
+                                            }
+                                        }
+                                        if (event._$stopImmediatePropagation) {
+                                            break;
+                                        }
+                                    }
+                                    parentEvents.reverse();
+                                    break;
+                            }
+                        }
+                        // start target
+                        event.eventPhase = EventPhase.AT_TARGET;
+                        if (!event._$stopImmediatePropagation
+                            && !event._$stopPropagation) {
+                            const length = events.length;
+                            for (let idx = 0; idx < length; ++idx) {
+                                const obj = events[idx];
+                                if (obj.useCapture) {
+                                    continue;
+                                }
+                                // event execute
+                                event.currentTarget = obj.target;
+                                $setCurrentLoaderInfo(obj.target.loaderInfo);
+                                try {
+                                    event.listener = obj.listener;
+                                    obj.listener.call(null, event);
+                                }
+                                catch (e) {
+                                    console.error(e);
+                                    return false;
+                                }
+                                if (event._$stopImmediatePropagation) {
+                                    break;
+                                }
+                            }
+                        }
+                        // start bubbling
+                        event.eventPhase = EventPhase.BUBBLING_PHASE;
+                        switch (true) {
+                            case event._$stopImmediatePropagation:
+                            case event._$stopPropagation:
+                            case !event.bubbles:
+                                break;
+                            default:
+                                // this => parent... => stage end
+                                for (let idx = 0; idx < parentEvents.length; ++idx) {
+                                    const targets = parentEvents[idx];
+                                    for (let idx = 0; idx < targets.length; ++idx) {
+                                        const obj = targets[idx];
+                                        if (obj.useCapture) {
+                                            continue;
+                                        }
+                                        // event execute
+                                        event.currentTarget = obj.target;
+                                        $setCurrentLoaderInfo(obj.target.loaderInfo);
+                                        try {
+                                            event.listener = obj.listener;
+                                            obj.listener.call(null, event);
+                                        }
+                                        catch (e) {
+                                            console.error(e);
+                                            return false;
+                                        }
+                                        if (event._$stopImmediatePropagation) {
+                                            break;
+                                        }
+                                    }
+                                    if (event._$stopImmediatePropagation) {
+                                        break;
+                                    }
+                                }
+                                break;
+                        }
+                        $poolArray(events);
+                        $poolArray(parentEvents);
+                        return true;
+                    }
+                    $poolArray(events);
+                    $poolArray(parentEvents);
+                }
+                break;
+        }
+        return false;
+    }
+    /**
+     * @description EventDispatcher オブジェクトに、特定のイベントタイプに対して登録されたリスナーがあるかどうかを確認します。
+     *              Checks whether the EventDispatcher object has any listeners registered for a specific type of event.
+     *
+     * @param  {string} type
+     * @return {boolean}
+     * @method
+     * @public
+     */
+    hasEventListener(type) {
+        type = `${type}`;
+        switch (type) {
+            case Event.ENTER_FRAME:
+            case Event.EXIT_FRAME:
+            case Event.FRAME_CONSTRUCTED:
+            case Event.RENDER:
+            case Event.ACTIVATE:
+            case Event.DEACTIVATE:
+            case "keyDown":
+            case "keyUp":
+                {
+                    const player = $currentPlayer();
+                    if (player
+                        && player.broadcastEvents.size
+                        && player.broadcastEvents.has(type)) {
+                        const events = player.broadcastEvents.get(type) || $getArray();
+                        for (let idx = 0; idx < events.length; idx++) {
+                            if (events[idx].target === this) {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                }
+            default:
+                return !!(this._$events
+                    && this._$events.size
+                    && this._$events.has(type));
+        }
+    }
+    /**
+     * @description EventDispatcher オブジェクトからリスナーを削除します。
+     *              Removes a listener from the EventDispatcher object.
+     *
+     * @param  {string}   type
+     * @param  {function} [listener = null]
+     * @param  {boolean}  [use_capture = false]
+     * @return {void}
+     * @method
+     * @public
+     */
+    removeEventListener(type, listener, use_capture = false) {
+        if (!listener) {
+            return;
+        }
+        type = `${type}`;
+        if (!this.hasEventListener(type)) {
+            return;
+        }
+        const player = $currentPlayer();
+        let events = null;
+        let isBroadcast = false;
+        switch (type) {
+            case Event.ENTER_FRAME:
+            case Event.EXIT_FRAME:
+            case Event.FRAME_CONSTRUCTED:
+            case Event.RENDER:
+            case Event.ACTIVATE:
+            case Event.DEACTIVATE:
+            case "keyDown":
+            case "keyUp":
+                isBroadcast = true;
+                if (player) {
+                    events = player.broadcastEvents.get(type) || $getArray();
+                }
+                break;
+            default:
+                if (this._$events
+                    && this._$events.size
+                    && this._$events.has(type)) {
+                    events = this._$events.get(type) || $getArray();
+                }
+                break;
+        }
+        if (!events) {
+            return;
+        }
+        // remove listener
+        for (let idx = 0; idx < events.length; ++idx) {
+            // event object
+            const obj = events[idx];
+            if (use_capture === obj.useCapture
+                && obj.listener === listener) {
+                events.splice(idx, 1);
+                break;
+            }
+        }
+        if (!events.length) {
+            if (isBroadcast) {
+                player.broadcastEvents.delete(type);
+            }
+            else {
+                if (!this._$events) {
+                    return;
+                }
+                this._$events.delete(type);
+                if (!this._$events.size) {
+                    $poolMap(this._$events);
+                    this._$events = null;
+                }
+            }
+            return;
+        }
+        if (events.length > 1) {
+            // event sort(DESC)
+            events.sort(function (a, b) {
+                switch (true) {
+                    case a.priority > b.priority:
+                        return -1;
+                    case a.priority < b.priority:
+                        return 1;
+                    default:
+                        return 0;
+                }
+            });
+        }
+        if (isBroadcast) {
+            player.broadcastEvents.set(type, events);
+        }
+        else {
+            if (!this._$events) {
+                this._$events = $getMap();
+            }
+            this._$events.set(type, events);
+        }
+    }
+    /**
+     * @description EventDispatcherオブジェクトから指定したタイプのリスナーを全て削除します。
+     *              Removes all listeners of the specified type from the EventDispatcher object.
+     *
+     * @param  {string}   type
+     * @param  {boolean}  [use_capture=false]
+     * @return {void}
+     * @method
+     * @public
+     */
+    removeAllEventListener(type, use_capture = false) {
+        type = `${type}`;
+        if (!this.hasEventListener(type)) {
+            return;
+        }
+        const player = $currentPlayer();
+        let events = null;
+        let isBroadcast = false;
+        switch (type) {
+            case Event.ENTER_FRAME:
+            case Event.EXIT_FRAME:
+            case Event.FRAME_CONSTRUCTED:
+            case Event.RENDER:
+            case Event.ACTIVATE:
+            case Event.DEACTIVATE:
+            case "keyDown":
+            case "keyUp":
+                isBroadcast = true;
+                if (player) {
+                    events = player.broadcastEvents.get(type) || $getArray();
+                }
+                break;
+            default:
+                if (this._$events
+                    && this._$events.size
+                    && this._$events.has(type)) {
+                    events = this._$events.get(type) || $getArray();
+                }
+                break;
+        }
+        if (!events) {
+            return;
+        }
+        // remove listener
+        const results = $getArray();
+        for (let idx = 0; idx < events.length; ++idx) {
+            // event object
+            const obj = events[idx];
+            if (use_capture !== obj.useCapture) {
+                results.push(obj);
+            }
+        }
+        if (!results.length) {
+            if (isBroadcast) {
+                player.broadcastEvents.delete(type);
+            }
+            else {
+                if (!this._$events) {
+                    return;
+                }
+                this._$events.delete(type);
+                if (!this._$events.size) {
+                    $poolMap(this._$events);
+                    this._$events = null;
+                }
+            }
+            return;
+        }
+        if (results.length > 1) {
+            // event sort (DESC)
+            results.sort(function (a, b) {
+                switch (true) {
+                    case a.priority > b.priority:
+                        return -1;
+                    case a.priority < b.priority:
+                        return 1;
+                    default:
+                        return 0;
+                }
+            });
+        }
+        if (isBroadcast) {
+            player.broadcastEvents.set(type, results);
+        }
+        else {
+            if (!this._$events) {
+                this._$events = $getMap();
+            }
+            this._$events.set(type, results);
+        }
+    }
+    /**
+     * @description 指定されたイベントタイプについて、
+     *              この EventDispatcher オブジェクトまたはその祖先にイベントリスナーが
+     *              登録されているかどうかを確認します。
+     *              Checks whether an event listener is registered
+     *              with this EventDispatcher object or
+     *              any of its ancestors for the specified event type.
+     *
+     * @param  {string}  type
+     * @return {boolean}
+     * @method
+     * @public
+     */
+    willTrigger(type) {
+        if (this.hasEventListener(type)) {
+            return true;
+        }
+        if ("parent" in this) {
+            let parent = this.parent;
+            while (parent) {
+                if (parent.hasEventListener(type)) {
+                    return true;
+                }
+                parent = parent.parent;
+            }
+        }
+        return false;
+    }
+}

package/dist/player/next2d/events/EventPhase.d.ts

@@ -0,0 +1,80 @@
+/**
+ * EventPhase クラスは、Event クラスの eventPhase プロパティの値を提供します。
+ *
+ * The EventPhase class provides values for the eventPhase property of the Event class.
+ *
+ * @class
+ * @memberOf next2d.events
+ */
+export declare class EventPhase {
+    /**
+     * 指定されたクラスのストリングを返します。
+     * Returns the string representation of the specified class.
+     *
+     * @return  {string}
+     * @default [class EventPhase]
+     * @method
+     * @static
+     */
+    static toString(): string;
+    /**
+     * @description 指定されたクラスの空間名を返します。
+     *              Returns the space name of the specified class.
+     *
+     * @member  {string}
+     * @default next2d.events.EventPhase
+     * @const
+     * @static
+     */
+    static get namespace(): string;
+    /**
+     * @description 指定されたオブジェクトのストリングを返します。
+     *              Returns the string representation of the specified object.
+     *
+     * @return {string}
+     * @default [object EventPhase]
+     * @method
+     * @public
+     */
+    toString(): string;
+    /**
+     * @description 指定されたオブジェクトの空間名を返します。
+     *              Returns the space name of the specified object.
+     *
+     * @member  {string}
+     * @default next2d.events.EventPhase
+     * @const
+     * @public
+     */
+    get namespace(): string;
+    /**
+     * @description ターゲット段階（イベントフローの 2 番目の段階）です。
+     *              The target phase, which is the second phase of the event flow.
+     *
+     * @return  {number}
+     * @default 2
+     * @const
+     * @static
+     */
+    static get AT_TARGET(): number;
+    /**
+     * @description ターゲット段階（イベントフローの 2 番目の段階）です。
+     *              The target phase, which is the second phase of the event flow.
+     *
+     * @return  {number}
+     * @default 3
+     * @const
+     * @static
+     */
+    static get BUBBLING_PHASE(): number;
+    /**
+     * @description キャプチャ段階（イベントフローの最初の段階）です。
+     *              The capturing phase, which is the first phase of the event flow.
+     *
+     * @return  {number}
+     * @default 1
+     * @const
+     * @static
+     */
+    static get CAPTURING_PHASE(): number;
+}