@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/display/Sprite.ts

@@ -0,0 +1,774 @@
+import { Sprite as AwaySprite, DisplayObjectContainer as AwayDisplayObjectContainer,
+	DisplayObject as AwayDisplayObject, MovieClip as AwayMovieClip,
+	FrameScriptManager, MovieClip, Timeline,
+	IDisplayObjectAdapter,
+	MouseEvent } from '@awayjs/scene';
+import { DisplayObjectContainer } from './DisplayObjectContainer';
+import { DisplayObject } from './DisplayObject';
+import { Rectangle, Point, Debug } from '@awayjs/core';
+import { Graphics } from './Graphics';
+import { IVirtualSceneGraphItem } from './IVirtualSceneGraphItem';
+import { constructClassFromSymbol } from '@awayfl/avm2';
+import { SecurityDomain } from '../SecurityDomain';
+import { release, AVMStage } from '@awayfl/swf-loader';
+import { PickEntity } from '@awayjs/view';
+import { SoundTransform } from '../media/SoundTransform';
+
+export class Sprite extends DisplayObjectContainer {
+
+	private static _sprites: Array<Sprite> = new Array<Sprite>();
+
+	public static getNewSprite(adaptee: AwaySprite): Sprite {
+		if (Sprite._sprites.length) {
+			const sprite: Sprite = Sprite._sprites.pop();
+			sprite.adaptee = adaptee;
+			return sprite;
+		}
+
+		return new Sprite();
+	}
+
+	public initAdapter(): void {}
+
+	private _graphics: Graphics;
+	private _soundTransform: SoundTransform;
+
+	protected _registeredChildNames: Array<string>;
+
+	/**
+	 * 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.
+	 */
+	constructor() {
+		super();
+
+		this.dragListenerDelegate = (event) => this.dragListener(event);
+		this.stopDragDelegate = (event) => this.stopDrag(event);
+		this._syncGraphics(<AwaySprite> this._adaptee);
+
+		// our prototype is not MC (MC extends Sprite and we MUST check this)
+		if (
+			!(<SecurityDomain> this.sec).flash.display.MovieClip.axIsType(this)
+			&& this.adaptee.isAsset(AwayMovieClip)
+		) {
+			// trap MC to sprite mode for timeline
+			(<AwayMovieClip> this.adaptee).transformToSprite();
+		}
+	}
+
+	protected setChildIndexInternal(child: DisplayObject, index: number) {
+		// we should re-register child when swap indexes,
+		// because internally we call removeChildAt that unregister it
+		const isRegisteredChild = (
+			this._registeredChildNames &&
+			this._registeredChildNames.indexOf(child.name) > -1);
+
+		super.setChildIndexInternal(child, index);
+
+		if (isRegisteredChild) {
+			this.registerScriptObject(child.adaptee);
+		}
+	}
+
+	protected createAdaptee(): AwayDisplayObject {
+		const newAdaptee = AwaySprite.getNewSprite();
+
+		//console.log("createAdaptee AwaySprite");
+		newAdaptee.reset();
+		//FrameScriptManager.execute_queue();
+		return newAdaptee;
+	}
+
+	public addTimelineChildAtDepth(child: AwayDisplayObject, depth: number): AwayDisplayObject {
+
+		child.reset();
+
+		const maxIndex = (<AwayDisplayObjectContainer> this.adaptee).numChildren - 1;
+		let index = maxIndex + 1;
+		let scriptChildsOffset = 0;
+		for (let i = maxIndex; i >= 0; i--) {
+			const current = (<AwayDisplayObjectContainer> 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;
+
+		(<any>child).just_added_to_timeline = true;
+		(<AwayMovieClip> this.adaptee)._sessionID_childs[child._sessionID] = child;
+		return (<AwayMovieClip> this.adaptee).addChildAt(child, index);
+	}
+
+	public updateGraphics(): void {
+		this._syncGraphics(<AwaySprite> this._adaptee);
+	}
+
+	protected mapAdaptee(adaptee: AwaySprite) {
+		this._syncGraphics(adaptee);
+
+		return super.mapAdaptee(adaptee);
+	}
+
+	/**
+	 * Keep one AS3 Graphics wrapper per display object and point it at the
+	 * current AwayJS graphics (timeline graphics swaps, copy-on-write clear).
+	 */
+	private _syncGraphics(adaptee: AwaySprite): void {
+		if (!adaptee)
+			return;
+
+		if (this._graphics)
+			this._graphics._setAdaptee(adaptee.graphics);
+		else
+			this._graphics = new (<SecurityDomain> this.sec).flash.display.Graphics(adaptee.graphics);
+	}
+
+	public removeTimelineChildAt(value: number): void {
+		// in as3 we remove by sessionID
+		const child = (<AwayMovieClip> this.adaptee)._sessionID_childs[value];
+		if (child) {
+			delete (<AwayMovieClip> this.adaptee)._sessionID_childs[value];
+			(<AwayMovieClip> this.adaptee).removeChild(child);
+		}
+	}
+
+	public removeAllTimelineChilds(): void {
+		const adaptee: AwayMovieClip = <AwayMovieClip> this.adaptee;
+		for (const key in adaptee._sessionID_childs) {
+			const 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
+	 */
+	public queueFrameScripts(timeline: Timeline, frame_idx: number, scriptPass1: boolean) {
+		//console.log("add framescript", target_mc, target_mc.name, keyframe_idx, scriptPass1 );
+		if (scriptPass1)
+			FrameScriptManager.add_script_to_queue(<AwayMovieClip> this.adaptee, frame_idx);
+		else
+			FrameScriptManager.add_script_to_queue_pass2(<AwayMovieClip> this.adaptee, frame_idx);
+	}
+
+	public constructFrame(timeline: Timeline, start_construct_idx: number,
+		target_keyframe_idx: number, jump_forward: boolean,
+		frame_idx: number, queue_pass2: boolean, queue_script: boolean) {
+
+		const adaptee: AwayMovieClip = <AwayMovieClip> this.adaptee;
+		let len = adaptee.numChildren;
+
+		let virtualSceneGraph = [];
+		const existingSessionIDs = {};
+
+		for (let i = 0; i < len; i++) {
+			// collect the existing children into a virtual-scenegraph
+			const child = adaptee.getChildAt(i);
+			// 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;
+		}
+
+		let i: number;
+		let k: number;
+
+		// step1: apply remove / add commands to virtual scenegraph. collect update commands aswell
+
+		timeline._update_indices.length = 0;
+		timeline._update_frames.length = 0;
+		let update_cnt = 0;
+		let start_index: number;
+		let end_index: number;
+		for (k = start_construct_idx; k <= target_keyframe_idx; k++) {
+			let frame_command_idx: number = timeline.frame_command_indices[k];
+			const frame_recipe: number = 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++];
+				const removeSessionIDs = {};
+				for (i = start_index; i < end_index; i++) {
+					removeSessionIDs[timeline.remove_child_stream[i]] = true;
+				}
+				const newVirtualSceneGraph = [];
+				len = virtualSceneGraph.length;
+				for (let i = 0; i < len; i++) {
+					if (!removeSessionIDs[virtualSceneGraph[i].sessionID])
+						newVirtualSceneGraph[newVirtualSceneGraph.length] = virtualSceneGraph[i];
+				}
+				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++) {
+					const maxIndex = virtualSceneGraph.length - 1;
+					const depth = timeline.add_child_stream[i * 3 + 1];
+					let index = maxIndex + 1;
+					let scriptChildsOffset = 0;
+					for (let i = maxIndex; i >= 0; i--) {
+						const current = virtualSceneGraph[i];
+						if (current.as3DepthID == -1) {
+							scriptChildsOffset++;
+						}
+						if (current.as3DepthID > -1) {
+							if (current.as3DepthID ==  depth &&
+								current.sessionID == timeline.add_child_stream[i * 3]) {
+								index = -1;
+								break;
+							}
+							if (current.as3DepthID < depth) {
+								index = i + 1 + scriptChildsOffset;
+								break;
+							}
+							scriptChildsOffset = 0;
+							index = i;
+						}
+					}
+					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);
+			}
+		}
+
+		const newChildren: AwayDisplayObject[] = [];
+		let vsItem: IVirtualSceneGraphItem;
+		const newChilds: AwayDisplayObject[] = [];
+		const newChildsOnTargetFrame: AwayDisplayObject[] = [];
+
+		// step2: build new list of children from virtual-scenegraph
+
+		adaptee._sessionID_childs = {};
+		len = newChildren.length = virtualSceneGraph.length;
+		for (let i = 0; i < len; i++) {
+			vsItem = virtualSceneGraph[i];
+			if (vsItem.sessionID == -1 && vsItem.child) {
+				// this must be a script child
+				newChildren[i] = vsItem.child.adaptee;
+			} else if (existingSessionIDs[vsItem.sessionID]) {
+				//	the same sessionID already is child of the mc
+				const existingChild = existingSessionIDs[vsItem.sessionID];
+				adaptee._sessionID_childs[vsItem.sessionID] = existingChild;
+				newChildren[i] = existingChild;
+				//console.log("vsItem.exists", vsItem);
+				if (!jump_forward) {
+					if (newChildren[i]._adapter) {
+						if (!(<IDisplayObjectAdapter> newChildren[i].adapter).isColorTransformByScript()) {
+							newChildren[i].transform.clearColorTransform();
+						}
+						if (!(<IDisplayObjectAdapter> newChildren[i].adapter).isBlockedByScript()
+							&& !(<any>newChildren[i]).noTimelineUpdate) {
+							newChildren[i].transform.clearMatrix3D();
+							newChildren[i].timelineMasks = undefined;
+						}
+						if (!(<IDisplayObjectAdapter> newChildren[i].adapter).isVisibilityByScript()) {
+							newChildren[i].visible = true;
+						}
+					} else {
+						newChildren[i].transform.clearColorTransform();
+						newChildren[i].transform.clearMatrix3D();
+						newChildren[i].visible = true;
+						newChildren[i].timelineMasks = undefined;
+					}
+				}
+			} else {
+				const newChild = <AwayDisplayObject>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] = newChild;
+				if (vsItem.addedOnTargetFrame) {
+					newChildsOnTargetFrame[newChildsOnTargetFrame.length] = newChild;
+				} else {
+					newChilds[newChilds.length] = newChild;
+				}
+			}
+		}
+
+		// step3: remove children that no longer exists
+
+		for (let i = adaptee.numChildren - 1; i >= 0; i--) {
+			if (newChildren.indexOf(adaptee.getChildAt(i)) < 0) {
+				adaptee.removeChildAt(i);
+			}
+		}
+
+		// step4: setup new children that have not been added on new frame (prevent frame-scripts)
+
+		for (let i = 0; i < newChildren.length; i++)
+			if (!adaptee.contains(newChildren[i]))
+				adaptee.addChildAt(newChildren[i], i);
+
+		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);
+	}
+
+	public finalizeChildren(children: AwayDisplayObject[]) {
+		const len = children.length;
+		for (let i = 0; i < len; i++) {
+			const newChild = children[i];
+			(<any>newChild).just_added_to_timeline = true;
+			newChild.reset();
+		}
+	}
+
+	//---------------------------stuff added to make it work:
+
+	public registerScriptObject(child: AwayDisplayObject): void {
+
+		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);
+		}
+	}
+
+	public unregisterScriptObject(child: AwayDisplayObject): void {
+		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))
+			(<AwayMovieClip>child).removeButtonListeners();
+	}
+
+	public clone(): Sprite {
+
+		if (!(<any> this)._symbol) {
+			throw ('_symbol not defined when cloning movieclip');
+		}
+
+		const clone = constructClassFromSymbol((<any> this)._symbol, (<any> this)._symbol.symbolClass);
+		const adaptee = new AwaySprite();
+
+		this.adaptee.copyTo(adaptee);
+
+		clone.adaptee = adaptee;
+		clone._stage = this.activeStage;
+
+		(<any>clone).executeConstructor = () => {
+			(<any>clone).axInitializer();
+			(<any> this).constructorHasRun = true;
+		};
+		clone.adaptee.graphics = this.graphics;
+
+		// in FP, a Sprite seem to always have only 1 frame:
+		const timeline = (<AwayMovieClip>adaptee).timeline;
+
+		if (timeline) {
+			const targetTimeline = timeline;
+
+			targetTimeline.frame_command_indices = <any>[timeline.frame_command_indices[0]];
+			targetTimeline.frame_recipe = <any>[timeline.frame_recipe[0]];
+			targetTimeline.keyframe_constructframes = [timeline.keyframe_constructframes[0]];
+			targetTimeline.keyframe_durations = <any>[timeline.keyframe_durations[0]];
+			targetTimeline.keyframe_firstframes = [timeline.keyframe_firstframes[0]];
+			targetTimeline.keyframe_indices = [timeline.keyframe_indices[0]];
+
+			if (this._registeredChildNames) {
+				for (const name of this._registeredChildNames) {
+					clone.registerScriptObject(this[name]);
+				}
+			}
+		}
+
+		return clone;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	public dispose(): void {
+		this.disposeValues();
+
+		//Sprite._sprites.push(this);
+	}
+
+	//---------------------------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.
+	 */
+	public get buttonMode(): boolean {
+		return (<MovieClip> this.adaptee).buttonMode;
+	}
+
+	public set buttonMode(value: boolean) {
+		(<MovieClip> this.adaptee).buttonMode = value;
+	}
+
+	private _dropTarget: DisplayObject;
+	public setDropTarget(dropTarget: AwayDisplayObject) {
+		if (dropTarget) {
+			this._dropTarget = <DisplayObject>dropTarget.adapter;
+			return;
+
+		}
+		this._dropTarget = null;
+	}
+
+	/**
+	 * Specifies the display object over which the sprite is being dragged, or on
+	 * which the sprite was dropped.
+	 */
+	public get dropTarget(): DisplayObject {
+		return this._dropTarget;
+
+	}
+
+	/**
+	 * Specifies the Graphics object that belongs to this sprite where vector
+	 * drawing commands can occur.
+	 */
+	public get graphics(): Graphics {
+		return this._graphics;
+	}
+
+	/**
+	 * 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.
+	 */
+	public get hitArea(): Sprite {
+		return <Sprite> this.adaptee.pickObject?.adapter || null;
+	}
+
+	public set hitArea(value: Sprite) {
+		this.adaptee.pickObject = <AwayDisplayObjectContainer>value.adaptee;
+	}
+
+	/**
+	 * Controls sound within this sprite.
+	 *
+	 *   Note: This property does not affect HTML content in an HTMLControl object (in Adobe AIR).
+	 */
+	public get soundTransform(): SoundTransform {
+		//	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 (<any> this.sec).flash.media.SoundTransform();
+		}
+
+		this._soundTransform.volume = (<AwayMovieClip> this.adaptee).soundVolume;
+
+		return this._soundTransform;
+	}
+
+	public set soundTransform(value: SoundTransform) {
+
+		(<AwayMovieClip> this.adaptee).soundVolume = value ? value.volume : 1;
+
+		this._soundTransform = value;
+	}
+
+	/**
+	 * 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.
+	 */
+	public get useHandCursor(): boolean {
+		return (<AwayMovieClip> this.adaptee)._useHandCursor;
+	}
+
+	public set useHandCursor(value: boolean) {
+		(<AwayMovieClip> this.adaptee)._useHandCursor = value;
+	}
+
+	/**
+	 * 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.
+	 */
+	public startDrag(lockCenter: boolean = false, bounds: Rectangle = 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();
+
+			const avmStage = AVMStage.instance();
+			const dragNode = avmStage.view.getNode(this.adaptee);
+			avmStage.mousePicker.dragNode = dragNode;
+
+			const collision = avmStage.mousePicker.pickGroup.abstractions
+				.getAbstraction<PickEntity>(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);
+		}
+	}
+
+	public checkBounds() {
+
+		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;
+		}
+	}
+
+	private isDragging: boolean;
+	private lockCenter: boolean;
+	private static currentDraggedMC: Sprite;
+	private startDragMCPosition: Point;
+	private _dragBounds: any;
+	public dragListenerDelegate: (e) => void;
+
+	public dragListener(e) {
+		//console.log("drag", e);
+
+		if (this._adaptee.parent) {
+			if (!this.startDragMCPosition) {
+				this._setStartDragMCPosition(this._adaptee.parent);
+			}
+
+			const 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.
+	 */
+	public startTouchDrag(touchPonumberID: number, lockCenter: boolean = false, bounds: Rectangle = null) {
+		// @todo
+		Debug.throwPIR('playerglobals/display/Sprite', 'startTouchDrag', '');
+	}
+
+	/**
+	 * Ends the startDrag() method. A sprite that was made draggable with the
+	 * startDrag() method remains draggable until a
+	 * stopDrag() method is added, or until another
+	 * sprite becomes draggable. Only one sprite is draggable at a time.
+	 */
+
+	public stopDragDelegate: (e) => void;
+	public stopDrag(e = null) {
+		this.startDragMCPosition = null;
+		if (Sprite.currentDraggedMC && Sprite.currentDraggedMC != this) {
+			Sprite.currentDraggedMC.stopDrag();
+		}
+		this.isDragging = false;
+		Sprite.currentDraggedMC = null;
+		const avmStage = AVMStage.instance();
+		const 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.
+	 */
+	public stopTouchDrag(touchPonumberID: number) {
+		// @todo
+		Debug.throwPIR('playerglobals/display/Sprite', 'stopTouchDrag', '');
+	}
+
+	private _setStartDragMCPosition(parent: AwayDisplayObjectContainer): void {
+		const 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
+			);
+		}
+	}
+}