@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/display/SimpleButton.js

@@ -0,0 +1,522 @@
+import { __extends } from "tslib";
+import { FrameScriptManager } from '@awayjs/scene';
+import { MovieClip as AwayMovieClip } from '@awayjs/scene';
+import { Debug } from '@awayjs/core';
+import { InteractiveObject } from './InteractiveObject';
+import { constructClassFromSymbol } from '@awayfl/avm2';
+/**
+ * The SimpleButton class lets you control all instances of button symbols in a SWF
+ * file.
+ *
+ *   <p class="- topic/p ">In Flash Professional, you can give a button an instance name in the
+ * Property inspector. SimpleButton instance names are displayed in the Movie
+ * Explorer and in the Insert Target Path dialog box in the Actions
+ * panel. After you create an instance of a button in Flash Professional, you can
+ * use the methods and properties of the SimpleButton class to manipulate buttons
+ * with ActionScript.</p><p class="- topic/p ">In ActionScript 3.0,
+ * you use the <codeph class="+ topic/ph pr-d/codeph ">new SimpleButton()</codeph> constructor to create a
+ * SimpleButton instance.</p><p class="- topic/p ">The SimpleButton class inherits from the InteractiveObject class.</p>
+ *
+ *   EXAMPLE:
+ *
+ *   The following example uses the SimpleButtonExample class, which in
+ * turn uses the CustomSimpleButton class, and this class then instantiates four
+ * ButtonDisplayState objects.  The result is a button that is created in the shape of
+ * a square, whose background color changes based on the mouse state by overriding instance properties of
+ * the SimpleButton class.  This is accomplished by performing the following steps:
+ * <ol class="- topic/ol ">
+ * <li class="- topic/li ">In the <codeph class="+ topic/ph pr-d/codeph ">SimpleButtonExample()</codeph>
+ * constructor, a new CustomSimpleButton object of type
+ * SimpleButton, called <codeph class="+ topic/ph pr-d/codeph ">button</codeph>,
+ * is created, which calls the <codeph class="+ topic/ph pr-d/codeph ">CustomSimpleButton</codeph> constructor
+ * method.  The <codeph class="+ topic/ph pr-d/codeph ">button</codeph> object is the added to the display list.
+ * The button's color and size are
+ * determined in the steps that follow.</li><li class="- topic/li ">
+ * In the CustomSimpleButton class, instance properties are declared that are later used
+ * to control the size and background color of <codeph class="+ topic/ph pr-d/codeph ">button</codeph>,
+ * based on the state it is in (orange
+ * in the normal state, dark yellow in the mouse over state, an light blue in the mouse down state).
+ * In all of the <codeph class="+ topic/ph pr-d/codeph ">button</codeph>'s states,
+ * the size of the square is set to 80 pixels by using the
+ * <codeph class="+ topic/ph pr-d/codeph ">size</codeph> property.</li>
+ * <li class="- topic/li ">The constructor function for the CustomSimpleButton class sets the
+ * <codeph class="+ topic/ph pr-d/codeph ">downState</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">overState</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">upState</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">hitTestState</codeph>,
+ * and <codeph class="+ topic/ph pr-d/codeph ">useHandCursor</codeph> properties with
+ * four instances of the ButtonDisplayState class.</li>
+ * <li class="- topic/li ">In the ButtonDisplayState class, the constructor sets the value of the
+ * square's size and background color and calls the
+ * <codeph class="+ topic/ph pr-d/codeph ">draw()</codeph> method.</li>
+ * <li class="- topic/li ">The <codeph class="+ topic/ph pr-d/codeph ">draw()</codeph>
+ * method redraws the square with the size and background color set in
+ * the constructor based on the button's state.</li>
+ * </ol><codeblock xml:space="preserve" class="+ topic/pre pr-d/codeblock ">
+
+ */
+var SimpleButton = /** @class */ (function (_super) {
+    __extends(SimpleButton, _super);
+    /**
+     * Creates a new SimpleButton instance. Any or all of the display objects that represent
+     * the various button states can be set as parameters in the constructor.
+     * @param	upState	The initial value for the SimpleButton up state.
+     * @param	overState	The initial value for the SimpleButton over state.
+     * @param	downState	The initial value for the SimpleButton down state.
+     * @param	hitTestState	The initial value for the SimpleButton hitTest state.
+     */
+    function SimpleButton(upState, overState, downState, hitTestState) {
+        if (upState === void 0) { upState = null; }
+        if (overState === void 0) { overState = null; }
+        if (downState === void 0) { downState = null; }
+        if (hitTestState === void 0) { hitTestState = null; }
+        var _this = _super.call(this) || this;
+        _this._adaptee.addButtonListeners();
+        return _this;
+    }
+    // todo: this methods are also defined on Sprite
+    // in avm2 SimpleButton extends from InteractiveObject, not from MovieClip/Sprite
+    SimpleButton.prototype.addTimelineChildAtDepth = function (child, depth) {
+        child.reset();
+        var maxIndex = this.adaptee.numChildren - 1;
+        var index = maxIndex + 1;
+        var scriptChildsOffset = 0;
+        for (var i = maxIndex; i >= 0; i--) {
+            var current = this.adaptee.getChildAt(i);
+            if (current._avmDepthID == -1) {
+                scriptChildsOffset++;
+            }
+            if (current._avmDepthID > -1) {
+                if (current._avmDepthID < depth) {
+                    index = i + 1 + scriptChildsOffset;
+                    break;
+                }
+                scriptChildsOffset = 0;
+                index = i;
+            }
+        }
+        child._avmDepthID = depth;
+        child.just_added_to_timeline = true;
+        this.adaptee._sessionID_childs[child._sessionID] = child;
+        return this.adaptee.addChildAt(child, index);
+    };
+    SimpleButton.prototype.removeTimelineChildAt = function (value) {
+        // in as3 we remove by sessionID
+        var child = this.adaptee._sessionID_childs[value];
+        if (child) {
+            delete this.adaptee._sessionID_childs[value];
+            this.adaptee.removeChild(child);
+        }
+    };
+    /**
+     * queue the mc for executing framescripts
+     * this only queues the frame-index as a number,
+     * the actual framescripts will be retrieved in MovieClip.executeScripts
+     * @param timeline
+     * @param frame_idx
+     * @param scriptPass1
+     */
+    SimpleButton.prototype.queueFrameScripts = function (timeline, frame_idx, scriptPass1) {
+        //console.log("add framescript", target_mc, target_mc.name, keyframe_idx, scriptPass1 );
+        if (scriptPass1)
+            FrameScriptManager.add_script_to_queue(this.adaptee, frame_idx);
+        else
+            FrameScriptManager.add_script_to_queue_pass2(this.adaptee, frame_idx);
+    };
+    SimpleButton.prototype.removeAllTimelineChilds = function () {
+        var adaptee = this.adaptee;
+        for (var key in adaptee._sessionID_childs) {
+            var child = adaptee._sessionID_childs[key];
+            if (child) {
+                delete adaptee._sessionID_childs[key];
+                adaptee.removeChild(child);
+            }
+        }
+    };
+    SimpleButton.prototype.constructFrame = function (timeline, start_construct_idx, target_keyframe_idx, jump_forward, frame_idx, queue_pass2, queue_script) {
+        var adaptee = this.adaptee;
+        var len = adaptee.numChildren;
+        var virtualSceneGraph = [];
+        var existingSessionIDs = {};
+        for (var i_1 = 0; i_1 < len; i_1++) {
+            // collect the existing children into a virtual-scenegraph
+            var child = adaptee.getChildAt(i_1);
+            // if jumping forward, we continue from current frame, so we collect all objects
+            // if jumping back, we want to only collect script-children. timeline childs are ignored
+            if (jump_forward || child._sessionID == -1) {
+                virtualSceneGraph[virtualSceneGraph.length] = {
+                    sessionID: child._sessionID,
+                    as3DepthID: child._avmDepthID,
+                    addedOnTargetFrame: false,
+                    child: child
+                };
+            }
+            if (child._sessionID != -1)
+                existingSessionIDs[child._sessionID] = child;
+        }
+        var i;
+        var k;
+        // step1: apply remove / add commands to virtual scenegraph. collect update commands aswell
+        timeline._update_indices.length = 0;
+        timeline._update_frames.length = 0;
+        var update_cnt = 0;
+        var start_index;
+        var end_index;
+        for (k = start_construct_idx; k <= target_keyframe_idx; k++) {
+            var frame_command_idx = timeline.frame_command_indices[k];
+            var frame_recipe = timeline.frame_recipe[k];
+            if (frame_recipe & 2) {
+                start_index = timeline.command_index_stream[frame_command_idx];
+                end_index = start_index + timeline.command_length_stream[frame_command_idx++];
+                var removeSessionIDs = {};
+                for (i = start_index; i < end_index; i++) {
+                    removeSessionIDs[timeline.remove_child_stream[i]] = true;
+                }
+                var newVirtualSceneGraph = [];
+                len = virtualSceneGraph.length;
+                for (var i_2 = 0; i_2 < len; i_2++) {
+                    if (!removeSessionIDs[virtualSceneGraph[i_2].sessionID])
+                        newVirtualSceneGraph[newVirtualSceneGraph.length] = virtualSceneGraph[i_2];
+                }
+                virtualSceneGraph = newVirtualSceneGraph;
+            }
+            if (frame_recipe & 4) {
+                start_index = timeline.command_index_stream[frame_command_idx];
+                end_index = start_index + timeline.command_length_stream[frame_command_idx++];
+                for (i = start_index; i < end_index; i++) {
+                    var maxIndex = virtualSceneGraph.length - 1;
+                    var depth = timeline.add_child_stream[i * 3 + 1];
+                    var index = maxIndex + 1;
+                    var scriptChildsOffset = 0;
+                    for (var i_3 = maxIndex; i_3 >= 0; i_3--) {
+                        var current = virtualSceneGraph[i_3];
+                        if (current.as3DepthID == -1) {
+                            scriptChildsOffset++;
+                        }
+                        if (current.as3DepthID > -1) {
+                            if (current.as3DepthID == depth &&
+                                current.sessionID == timeline.add_child_stream[i_3 * 3]) {
+                                index = -1;
+                                break;
+                            }
+                            if (current.as3DepthID < depth) {
+                                index = i_3 + 1 + scriptChildsOffset;
+                                break;
+                            }
+                            scriptChildsOffset = 0;
+                            index = i_3;
+                        }
+                    }
+                    if (index >= virtualSceneGraph.length) {
+                        virtualSceneGraph[virtualSceneGraph.length] = {
+                            sessionID: timeline.add_child_stream[i * 3],
+                            addedOnTargetFrame: k == target_keyframe_idx,
+                            symbolID: timeline.add_child_stream[i * 3 + 2],
+                            as3DepthID: timeline.add_child_stream[i * 3 + 1],
+                        };
+                    }
+                    else if (index > -1) {
+                        virtualSceneGraph.splice(index, 0, {
+                            sessionID: timeline.add_child_stream[i * 3],
+                            addedOnTargetFrame: k == target_keyframe_idx,
+                            symbolID: timeline.add_child_stream[i * 3 + 2],
+                            as3DepthID: timeline.add_child_stream[i * 3 + 1],
+                        });
+                    }
+                }
+            }
+            if (frame_recipe & 8) {
+                timeline._update_frames[update_cnt] = timeline.keyframe_firstframes[k];
+                timeline._update_indices[update_cnt++] = frame_command_idx++; // execute update command later
+            }
+            if (frame_recipe & 16 && k == target_keyframe_idx) {
+                timeline.start_sounds(adaptee, frame_command_idx);
+            }
+        }
+        var newChildren = [];
+        var vsItem;
+        var newChilds = [];
+        var newChildsOnTargetFrame = [];
+        // step2: build new list of children from virtual-scenegraph
+        adaptee._sessionID_childs = {};
+        len = newChildren.length = virtualSceneGraph.length;
+        for (var i_4 = 0; i_4 < len; i_4++) {
+            vsItem = virtualSceneGraph[i_4];
+            if (vsItem.sessionID == -1 && vsItem.child) {
+                // this must be a script child
+                newChildren[i_4] = vsItem.child.adaptee;
+            }
+            else if (existingSessionIDs[vsItem.sessionID]) {
+                //	the same sessionID already is child of the mc
+                var existingChild = existingSessionIDs[vsItem.sessionID];
+                adaptee._sessionID_childs[vsItem.sessionID] = existingChild;
+                newChildren[i_4] = existingChild;
+                //console.log("vsItem.exists", vsItem);
+                if (!jump_forward) {
+                    if (newChildren[i_4]._adapter) {
+                        if (!newChildren[i_4].adapter.isColorTransformByScript()) {
+                            newChildren[i_4].transform.clearColorTransform();
+                        }
+                        if (!newChildren[i_4].adapter.isBlockedByScript()
+                            && !newChildren[i_4].noTimelineUpdate) {
+                            newChildren[i_4].transform.clearMatrix3D();
+                            newChildren[i_4].timelineMasks = undefined;
+                        }
+                        if (!newChildren[i_4].adapter.isVisibilityByScript()) {
+                            newChildren[i_4].visible = true;
+                        }
+                    }
+                    else {
+                        newChildren[i_4].transform.clearColorTransform();
+                        newChildren[i_4].transform.clearMatrix3D();
+                        newChildren[i_4].visible = true;
+                        newChildren[i_4].timelineMasks = undefined;
+                    }
+                }
+            }
+            else {
+                var newChild = timeline.getChildInstance(vsItem.symbolID, vsItem.sessionID);
+                if (this.adaptee.isSlice9ScaledMC && newChild.assetType == '[asset Sprite]') {
+                    newChild.isSlice9ScaledSprite = true;
+                }
+                newChild._sessionID = vsItem.sessionID;
+                newChild._avmDepthID = vsItem.as3DepthID;
+                adaptee._sessionID_childs[vsItem.sessionID] = newChild;
+                newChildren[i_4] = newChild;
+                if (vsItem.addedOnTargetFrame) {
+                    newChildsOnTargetFrame[newChildsOnTargetFrame.length] = newChild;
+                }
+                else {
+                    newChilds[newChilds.length] = newChild;
+                }
+            }
+        }
+        // step3: remove children that no longer exists
+        for (var i_5 = adaptee.numChildren - 1; i_5 >= 0; i_5--) {
+            if (newChildren.indexOf(adaptee.getChildAt(i_5)) < 0) {
+                adaptee.removeChildAt(i_5);
+            }
+        }
+        // step4: setup new children that have not been added on new frame (prevent frame-scripts)
+        for (var i_6 = 0; i_6 < newChildren.length; i_6++)
+            if (!adaptee.contains(newChildren[i_6]))
+                adaptee.addChildAt(newChildren[i_6], i_6);
+        adaptee.preventScript = true;
+        this.finalizeChildren(newChilds);
+        // step5: queue frame-script for new frame
+        if (queue_script)
+            this.queueFrameScripts(timeline, frame_idx, !queue_pass2);
+        // step6: setup children that have been added on new frame (allow frame-scripts)
+        adaptee.preventScript = true;
+        this.finalizeChildren(newChildsOnTargetFrame);
+    };
+    SimpleButton.prototype.finalizeChildren = function (children) {
+        var len = children.length;
+        for (var i = 0; i < len; i++) {
+            var newChild = children[i];
+            newChild.reset();
+        }
+    };
+    SimpleButton.prototype.initAdapter = function () { };
+    SimpleButton.prototype.registerScriptObject = function (child) {
+    };
+    SimpleButton.prototype.unregisterScriptObject = function (child) {
+    };
+    Object.defineProperty(SimpleButton.prototype, "downState", {
+        /**
+         * Specifies a display object that is used as the visual
+         * object for the button "Down" state —the state that the button is in when the user
+         * selects the hitTestState object.
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/SimpleButton', 'get downState', '');
+            return null;
+        },
+        set: function (value) {
+            // @todo
+            Debug.throwPIR('playerglobals/display/SimpleButton', 'set downState', '');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SimpleButton.prototype, "enabled", {
+        /**
+         * A Boolean value that specifies whether a button is enabled. When a
+         * button is disabled (the enabled property is set to false),
+         * the button is visible but cannot be clicked. The default value is
+         * true. This property is useful if you want to
+         * disable part of your navigation; for example, you might want to disable a
+         * button in the currently displayed page so that it can't be clicked and
+         * the page cannot be reloaded.
+         *
+         *   Note: To prevent mouseClicks on a button, set both the enabled
+         * and mouseEnabled properties to false.
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/SimpleButton', 'get enabled', '');
+            return false;
+        },
+        set: function (value) {
+            // @todo
+            Debug.throwPIR('playerglobals/display/SimpleButton', 'set enabled', '');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SimpleButton.prototype, "hitTestState", {
+        /**
+         * Specifies a display object that is used as the hit testing object for the button. For a basic button, set the
+         * hitTestState property to the same display object as the overState
+         * property. If you do not set the hitTestState property, the SimpleButton
+         * is inactive — it does not respond to user input events.
+         */
+        get: function () {
+            return this.adaptee.pickObject.adapter;
+        },
+        set: function (value) {
+            this.adaptee.pickObject = value.adaptee;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SimpleButton.prototype, "overState", {
+        /**
+         * Specifies a display object that is used as the visual
+         * object for the button over state — the state that the button is in when
+         * the pointer is positioned over the button.
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/SimpleButton', 'get overState', '');
+            return null;
+        },
+        set: function (value) {
+            // @todo
+            Debug.throwPIR('playerglobals/display/SimpleButton', 'set overState', '');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SimpleButton.prototype, "soundTransform", {
+        /**
+         * The SoundTransform object assigned to this button. A SoundTransform object
+         * includes properties for setting volume, panning, left speaker assignment, and right
+         * speaker assignment. This SoundTransform object applies to all states of the button.
+         * This SoundTransform object affects only embedded sounds.
+         * @internal	Should information from AS2 setTransform be here? e.g. percentage values indicating
+         *   how much of the left input to play in the left speaker or right speaker; it is generally
+         *   best to use 22-KHZ 6-bit mono sounds?
+         */
+        get: function () {
+            //	we not create this in the constructor, because it gets overwritten from Sound in most cases anyway
+            //	but we still need a Soundtransform to be available in the getter
+            if (!this._soundTransform) {
+                this._soundTransform = new this.sec.flash.media.SoundTransform();
+            }
+            this._soundTransform.volume = this.adaptee.soundVolume;
+            return this._soundTransform;
+        },
+        set: function (value) {
+            this.adaptee.soundVolume = value ? value.volume : 1;
+            this._soundTransform = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SimpleButton.prototype, "trackAsMenu", {
+        /**
+         * Indicates whether other display objects that are SimpleButton or MovieClip objects can receive
+         * user input release events. The trackAsMenu property lets you create menus. You
+         * can set the trackAsMenu property on any SimpleButton or MovieClip object.
+         * If the trackAsMenu property does not exist, the default behavior is
+         * false.
+         *
+         *   You can change the trackAsMenu property at any time; the
+         * modified button immediately takes on the new behavior.
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/SimpleButton', 'get trackAsMenu', '');
+            return false;
+        },
+        set: function (value) {
+            // @todo
+            Debug.throwPIR('playerglobals/display/SimpleButton', 'set trackAsMenu', '');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SimpleButton.prototype, "upState", {
+        /**
+         * Specifies a display object that is used as the visual
+         * object for the button up state — the state that the button is in when
+         * the pointer is not positioned over the button.
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/SimpleButton', 'get upState', '');
+            return null;
+        },
+        set: function (value) {
+            // @todo
+            Debug.throwPIR('playerglobals/display/SimpleButton', 'set upState', '');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SimpleButton.prototype, "useHandCursor", {
+        /**
+         * A Boolean value that, when set to true, indicates whether
+         * the hand cursor is shown when the pointer rolls over a button.
+         * If this property is set to false, the arrow pointer cursor is displayed
+         * instead. The default is true.
+         *
+         *   You can change the useHandCursor property at any time;
+         * the modified button immediately uses the new cursor behavior.
+         * @maelexample	Create two buttons on the Stage with the instance names
+         * <code>myBtn1_btn</code> and <code>myBtn2_btn</code>. Enter the following ActionScript in Frame 1 of the Timeline:
+         *   <listing>
+         *   myBtn1_btn.useHandCursor = false;
+         *   myBtn1_btn.onRelease = buttonClick;
+         *   myBtn2_btn.onRelease = buttonClick;
+         *   function buttonClick() {
+             *   trace(this._name);
+             *   }
+         *   </listing><p class="- topic/p ">When the mouse is over and clicks <code>myBtn1_btn</code>,
+         * there is no pointing hand. However, you see the pointing hand when the button is over and clicks
+         * <code>myBtn2_btn</code>.</p>
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/SimpleButton', 'get useHandCursor', '');
+            return false;
+        },
+        set: function (value) {
+            // @todo
+            Debug.throwPIR('playerglobals/display/SimpleButton', 'set useHandCursor', '');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    SimpleButton.prototype.clone = function () {
+        var anyThis = this;
+        if (!anyThis._symbol) {
+            throw ('_symbol not defined when cloning movieclip');
+        }
+        var clone = constructClassFromSymbol(anyThis._symbol, anyThis._symbol.symbolClass);
+        var adaptee = new AwayMovieClip(this.adaptee.timeline);
+        this.adaptee.copyTo(adaptee);
+        clone.adaptee = adaptee;
+        clone._stage = this.activeStage;
+        clone.executeConstructor = function () {
+            //adaptee.timeline.resetScripts();
+            clone.axInitializer();
+            clone.constructorHasRun = true;
+        };
+        return clone;
+    };
+    return SimpleButton;
+}(InteractiveObject));
+export { SimpleButton };