@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/display/Sprite.js

@@ -0,0 +1,671 @@
+import { __extends } from "tslib";
+import { Sprite as AwaySprite, MovieClip as AwayMovieClip, FrameScriptManager, MouseEvent } from '@awayjs/scene';
+import { DisplayObjectContainer } from './DisplayObjectContainer';
+import { Point, Debug } from '@awayjs/core';
+import { constructClassFromSymbol } from '@awayfl/avm2';
+import { release, AVMStage } from '@awayfl/swf-loader';
+var Sprite = /** @class */ (function (_super) {
+    __extends(Sprite, _super);
+    /**
+     * The Sprite class is a basic display list building block: a display list node that can display
+     * graphics and can also contain children.
+     *
+     *   <p class="- topic/p ">A Sprite object is similar to a movie clip, but does not have a timeline. Sprite is an
+     * appropriate base class for objects that do not require timelines. For example, Sprite would be a
+     * logical base class for user numbererface (UI) components that typically do not use the timeline.</p>
+     * <p class="- topic/p ">The Sprite class is new in ActionScript 3.0.
+     * It provides an alternative to the functionality of
+     * the MovieClip class, which retains all the functionality of previous ActionScript releases to
+     * provide backward compatibility.</p>
+     *
+     * Creates a new Sprite instance. After you create the Sprite instance, call the
+     * DisplayObjectContainer.addChild() or DisplayObjectContainer.addChildAt()
+     * method to add the Sprite to a parent DisplayObjectContainer.
+     */
+    function Sprite() {
+        var _this = _super.call(this) || this;
+        _this.dragListenerDelegate = function (event) { return _this.dragListener(event); };
+        _this.stopDragDelegate = function (event) { return _this.stopDrag(event); };
+        _this._syncGraphics(_this._adaptee);
+        // our prototype is not MC (MC extends Sprite and we MUST check this)
+        if (!_this.sec.flash.display.MovieClip.axIsType(_this)
+            && _this.adaptee.isAsset(AwayMovieClip)) {
+            // trap MC to sprite mode for timeline
+            _this.adaptee.transformToSprite();
+        }
+        return _this;
+    }
+    Sprite.getNewSprite = function (adaptee) {
+        if (Sprite._sprites.length) {
+            var sprite = Sprite._sprites.pop();
+            sprite.adaptee = adaptee;
+            return sprite;
+        }
+        return new Sprite();
+    };
+    Sprite.prototype.initAdapter = function () { };
+    Sprite.prototype.setChildIndexInternal = function (child, index) {
+        // we should re-register child when swap indexes,
+        // because internally we call removeChildAt that unregister it
+        var isRegisteredChild = (this._registeredChildNames &&
+            this._registeredChildNames.indexOf(child.name) > -1);
+        _super.prototype.setChildIndexInternal.call(this, child, index);
+        if (isRegisteredChild) {
+            this.registerScriptObject(child.adaptee);
+        }
+    };
+    Sprite.prototype.createAdaptee = function () {
+        var newAdaptee = AwaySprite.getNewSprite();
+        //console.log("createAdaptee AwaySprite");
+        newAdaptee.reset();
+        //FrameScriptManager.execute_queue();
+        return newAdaptee;
+    };
+    Sprite.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);
+    };
+    Sprite.prototype.updateGraphics = function () {
+        this._syncGraphics(this._adaptee);
+    };
+    Sprite.prototype.mapAdaptee = function (adaptee) {
+        this._syncGraphics(adaptee);
+        return _super.prototype.mapAdaptee.call(this, adaptee);
+    };
+    /**
+     * Keep one AS3 Graphics wrapper per display object and point it at the
+     * current AwayJS graphics (timeline graphics swaps, copy-on-write clear).
+     */
+    Sprite.prototype._syncGraphics = function (adaptee) {
+        if (!adaptee)
+            return;
+        if (this._graphics)
+            this._graphics._setAdaptee(adaptee.graphics);
+        else
+            this._graphics = new this.sec.flash.display.Graphics(adaptee.graphics);
+    };
+    Sprite.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);
+        }
+    };
+    Sprite.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);
+            }
+        }
+    };
+    /**
+     * 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
+     */
+    Sprite.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);
+    };
+    Sprite.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);
+    };
+    Sprite.prototype.finalizeChildren = function (children) {
+        var len = children.length;
+        for (var i = 0; i < len; i++) {
+            var newChild = children[i];
+            newChild.just_added_to_timeline = true;
+            newChild.reset();
+        }
+    };
+    //---------------------------stuff added to make it work:
+    Sprite.prototype.registerScriptObject = function (child) {
+        if (child.adapter == child) {
+            release || console.log('warning: child registered for script that has no avms-adapter');
+            return;
+        }
+        if (!child.name) {
+            return;
+        }
+        if (child.name === 'mask') {
+            // explicit scripted mask assignment
+            this.adaptee.mask = child;
+            return;
+        }
+        this.axSetPublicProperty(child.name, child.adapter);
+        if (!this._registeredChildNames) {
+            this._registeredChildNames = [child.name];
+        }
+        else if (this._registeredChildNames.indexOf(child.name) === -1) {
+            this._registeredChildNames.push(child.name);
+        }
+    };
+    Sprite.prototype.unregisterScriptObject = function (child) {
+        if (this.axGetPublicProperty(child.name) == child.adapter) {
+            this.axDeletePublicProperty(child.name);
+            if (this._registeredChildNames) {
+                this._registeredChildNames.splice(this._registeredChildNames.indexOf(child.name), 1);
+            }
+        }
+        if (child.isAsset(AwayMovieClip))
+            child.removeButtonListeners();
+    };
+    Sprite.prototype.clone = function () {
+        var _this = this;
+        if (!this._symbol) {
+            throw ('_symbol not defined when cloning movieclip');
+        }
+        var clone = constructClassFromSymbol(this._symbol, this._symbol.symbolClass);
+        var adaptee = new AwaySprite();
+        this.adaptee.copyTo(adaptee);
+        clone.adaptee = adaptee;
+        clone._stage = this.activeStage;
+        clone.executeConstructor = function () {
+            clone.axInitializer();
+            _this.constructorHasRun = true;
+        };
+        clone.adaptee.graphics = this.graphics;
+        // in FP, a Sprite seem to always have only 1 frame:
+        var timeline = adaptee.timeline;
+        if (timeline) {
+            var targetTimeline = timeline;
+            targetTimeline.frame_command_indices = [timeline.frame_command_indices[0]];
+            targetTimeline.frame_recipe = [timeline.frame_recipe[0]];
+            targetTimeline.keyframe_constructframes = [timeline.keyframe_constructframes[0]];
+            targetTimeline.keyframe_durations = [timeline.keyframe_durations[0]];
+            targetTimeline.keyframe_firstframes = [timeline.keyframe_firstframes[0]];
+            targetTimeline.keyframe_indices = [timeline.keyframe_indices[0]];
+            if (this._registeredChildNames) {
+                for (var _i = 0, _a = this._registeredChildNames; _i < _a.length; _i++) {
+                    var name_1 = _a[_i];
+                    clone.registerScriptObject(this[name_1]);
+                }
+            }
+        }
+        return clone;
+    };
+    /**
+     * @inheritDoc
+     */
+    Sprite.prototype.dispose = function () {
+        this.disposeValues();
+        //Sprite._sprites.push(this);
+    };
+    Object.defineProperty(Sprite.prototype, "buttonMode", {
+        //---------------------------original as3 properties / methods:
+        /**
+         * Specifies the button mode of this sprite. If true, this
+         * sprite behaves as a button, which means that it triggers the display
+         * of the hand cursor when the ponumberer passes over the sprite and can
+         * receive a click event if the enter or space keys are pressed
+         * when the sprite has focus. You can suppress the display of the hand cursor
+         * by setting the useHandCursor property to false,
+         * in which case the ponumberer is displayed.
+         *
+         *   Although it is better to use the SimpleButton class to create buttons,
+         * you can use the buttonMode property to give a sprite
+         * some button-like functionality. To include a sprite in the tab order,
+         * set the tabEnabled property (inherited from the
+         * numbereractiveObject class and false by default) to
+         * true. Additionally, consider whether you want
+         * the children of your sprite to be user input enabled. Most buttons
+         * do not enable user input numbereractivity for their child objects because
+         * it confuses the event flow. To disable user input numbereractivity for all child
+         * objects, you must set the mouseChildren property (inherited
+         * from the DisplayObjectContainer class) to false.
+         * If you use the buttonMode property with the MovieClip class (which is a
+         * subclass of the Sprite class), your button might have some added
+         * functionality. If you include frames labeled _up, _over, and _down,
+         * Flash Player provides automatic state changes (functionality
+         * similar to that provided in previous versions of ActionScript for movie
+         * clips used as buttons). These automatic state changes are
+         * not available for sprites, which have no timeline, and thus no frames
+         * to label.
+         */
+        get: function () {
+            return this.adaptee.buttonMode;
+        },
+        set: function (value) {
+            this.adaptee.buttonMode = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Sprite.prototype.setDropTarget = function (dropTarget) {
+        if (dropTarget) {
+            this._dropTarget = dropTarget.adapter;
+            return;
+        }
+        this._dropTarget = null;
+    };
+    Object.defineProperty(Sprite.prototype, "dropTarget", {
+        /**
+         * Specifies the display object over which the sprite is being dragged, or on
+         * which the sprite was dropped.
+         */
+        get: function () {
+            return this._dropTarget;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Sprite.prototype, "graphics", {
+        /**
+         * Specifies the Graphics object that belongs to this sprite where vector
+         * drawing commands can occur.
+         */
+        get: function () {
+            return this._graphics;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Sprite.prototype, "hitArea", {
+        /**
+         * Designates another sprite to serve as the hit area for a sprite. If the hitArea
+         * property does not exist or the value is null or undefined, the
+         * sprite itself is used as the hit area. The value of the hitArea property can
+         * be a reference to a Sprite object.
+         *
+         *   You can change the hitArea property at any time; the modified sprite immediately
+         * uses the new hit area behavior. The sprite designated as the hit area does not need to be
+         * visible; its graphical shape, although not visible,
+         * is still detected as the hit area.Note: You must set to false the mouseEnabled
+         * property of the sprite designated as the hit area. Otherwise, your sprite button might
+         * not work because the sprite designated as the hit area receives the user input events instead
+         * of your sprite button.
+         */
+        get: function () {
+            var _a;
+            return ((_a = this.adaptee.pickObject) === null || _a === void 0 ? void 0 : _a.adapter) || null;
+        },
+        set: function (value) {
+            this.adaptee.pickObject = value.adaptee;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Sprite.prototype, "soundTransform", {
+        /**
+         * Controls sound within this sprite.
+         *
+         *   Note: This property does not affect HTML content in an HTMLControl object (in Adobe AIR).
+         */
+        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(Sprite.prototype, "useHandCursor", {
+        /**
+         * A boolean value that indicates whether the ponumbering hand (hand cursor) appears when the ponumberer rolls
+         * over a sprite in which the buttonMode property is set to true.
+         * The default value of the useHandCursor property is true.
+         * If useHandCursor is set to true, the ponumbering hand used for buttons
+         * appears when the ponumberer rolls over a button sprite. If useHandCursor is
+         * false, the arrow ponumberer is used instead.
+         *
+         *   You can change the useHandCursor property at any time; the modified sprite
+         * immediately takes on the new cursor appearance. Note: In Flex or Flash Builder,
+         * if your sprite has child sprites, you might want to
+         * set the mouseChildren property to false. For example, if you want a hand
+         * cursor to appear over a Flex <mx:Label> control, set the useHandCursor and
+         * buttonMode properties to true, and the mouseChildren property
+         * to false.
+         */
+        get: function () {
+            return this.adaptee._useHandCursor;
+        },
+        set: function (value) {
+            this.adaptee._useHandCursor = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Lets the user drag the specified sprite. The sprite remains draggable until explicitly
+     * stopped through a call to the Sprite.stopDrag() method, or until
+     * another sprite is made draggable. Only one sprite is draggable at a time.
+     * Three-dimensional display objects follow the ponumberer and
+     * Sprite.startDrag() moves the object within
+     * the three-dimensional plane defined by the display object. Or, if the display object is a two-dimensional object
+     * and the child of a three-dimensional object, the two-dimensional object
+     * moves within the three dimensional plane defined by the three-dimensional parent object.
+     * @param	lockCenter	Specifies whether the draggable sprite is locked to the center of
+     *   the ponumberer position (true), or locked to the ponumber where the user first clicked the
+     *   sprite (false).
+     * @param	bounds	Value relative to the coordinates of the Sprite's parent that specify a constranumber
+     *   rectangle for the Sprite.
+     */
+    Sprite.prototype.startDrag = function (lockCenter, bounds) {
+        if (lockCenter === void 0) { lockCenter = false; }
+        if (bounds === void 0) { bounds = null; }
+        if (Sprite.currentDraggedMC && Sprite.currentDraggedMC != this) {
+            Sprite.currentDraggedMC.stopDrag();
+        }
+        Sprite.currentDraggedMC = this;
+        this._dragBounds = bounds;
+        if (!this.isDragging) {
+            this.isDragging = true;
+            this.lockCenter = lockCenter;
+            if (this.adaptee.parent) {
+                this._setStartDragMCPosition(this._adaptee.parent);
+            }
+            if (this._dragBounds)
+                this.checkBounds();
+            var avmStage = AVMStage.instance();
+            var dragNode = avmStage.view.getNode(this.adaptee);
+            avmStage.mousePicker.dragNode = dragNode;
+            var collision = avmStage.mousePicker.pickGroup.abstractions
+                .getAbstraction(dragNode)
+                .pickingCollision;
+            // collision MUST has rootNode, otherwise will be drag bug
+            collision.rootNode = dragNode;
+            avmStage.mouseManager.startDragObject(collision);
+            avmStage.root.addEventListener(MouseEvent.MOUSE_MOVE, this.dragListenerDelegate);
+        }
+    };
+    Sprite.prototype.checkBounds = function () {
+        if (this._adaptee.x < (this._dragBounds.left)) {
+            this._adaptee.x = this._dragBounds.left;
+        }
+        if (this._adaptee.x > (this._dragBounds.right)) {
+            this._adaptee.x = (this._dragBounds.right);
+        }
+        if (this._adaptee.y < this._dragBounds.top) {
+            this._adaptee.y = this._dragBounds.top;
+        }
+        if (this._adaptee.y > (this._dragBounds.bottom)) {
+            this._adaptee.y = this._dragBounds.bottom;
+        }
+    };
+    Sprite.prototype.dragListener = function (e) {
+        //console.log("drag", e);
+        if (this._adaptee.parent) {
+            if (!this.startDragMCPosition) {
+                this._setStartDragMCPosition(this._adaptee.parent);
+            }
+            var tmpPoint = AVMStage.instance().view.getNode(this._adaptee.parent).globalToLocal(new Point(this._stage.mouseX, this._stage.mouseY));
+            this.adaptee.x = this.startDragMCPosition.x + tmpPoint.x;
+            this.adaptee.y = this.startDragMCPosition.y + tmpPoint.y;
+            if (this._dragBounds)
+                this.checkBounds();
+        }
+    };
+    /**
+     * Lets the user drag the specified sprite on a touch-enabled device. The sprite remains draggable until explicitly
+     * stopped through a call to the Sprite.stopTouchDrag() method, or until
+     * another sprite is made draggable. Only one sprite is draggable at a time.
+     * Three-dimensional display objects follow the ponumberer and
+     * Sprite.startTouchDrag() moves the object within
+     * the three-dimensional plane defined by the display object. Or, if the display object is a two-dimensional object
+     * and the child of a three-dimensional object, the two-dimensional object
+     * moves within the three dimensional plane defined by the three-dimensional parent object.
+     * @param	touchPonumberID	An numbereger to assign to the touch ponumber.
+     * @param	lockCenter	Specifies whether the draggable sprite is locked to the center of
+     *   the ponumberer position (true), or locked to the ponumber where the user first clicked the
+     *   sprite (false).
+     * @param	bounds	Value relative to the coordinates of the Sprite's parent that specify a constranumber
+     *   rectangle for the Sprite.
+     */
+    Sprite.prototype.startTouchDrag = function (touchPonumberID, lockCenter, bounds) {
+        if (lockCenter === void 0) { lockCenter = false; }
+        if (bounds === void 0) { bounds = null; }
+        // @todo
+        Debug.throwPIR('playerglobals/display/Sprite', 'startTouchDrag', '');
+    };
+    Sprite.prototype.stopDrag = function (e) {
+        if (e === void 0) { e = null; }
+        this.startDragMCPosition = null;
+        if (Sprite.currentDraggedMC && Sprite.currentDraggedMC != this) {
+            Sprite.currentDraggedMC.stopDrag();
+        }
+        this.isDragging = false;
+        Sprite.currentDraggedMC = null;
+        var avmStage = AVMStage.instance();
+        var dragNode = avmStage.view.getNode(this.adaptee);
+        avmStage.mousePicker.dragNode = null;
+        avmStage.mouseManager.stopDragObject();
+        avmStage.root.removeEventListener(MouseEvent.MOUSE_MOVE, this.dragListenerDelegate);
+    };
+    /**
+     * Ends the startTouchDrag() method, for use with touch-enabled devices. A sprite that was made draggable with the
+     * startTouchDrag() method remains draggable until a
+     * stopTouchDrag() method is added, or until another
+     * sprite becomes draggable. Only one sprite is draggable at a time.
+     * @param	touchPonumberID	The numbereger assigned to the touch ponumber in the startTouchDrag method.
+     */
+    Sprite.prototype.stopTouchDrag = function (touchPonumberID) {
+        // @todo
+        Debug.throwPIR('playerglobals/display/Sprite', 'stopTouchDrag', '');
+    };
+    Sprite.prototype._setStartDragMCPosition = function (parent) {
+        var startDragPoint = AVMStage.instance().view.getNode(parent).globalToLocal(new Point(this._stage.mouseX, this._stage.mouseY));
+        if (this.lockCenter) {
+            this.startDragMCPosition = new Point();
+            this._adaptee.x = startDragPoint.x;
+            this._adaptee.y = startDragPoint.y;
+        }
+        else {
+            this.startDragMCPosition = new Point(this._adaptee.x - startDragPoint.x, this._adaptee.y - startDragPoint.y);
+        }
+    };
+    Sprite._sprites = new Array();
+    return Sprite;
+}(DisplayObjectContainer));
+export { Sprite };