mirror of
https://github.com/photonstorm/phaser
synced 2024-12-22 02:53:27 +00:00
732 lines
No EOL
25 KiB
TypeScript
732 lines
No EOL
25 KiB
TypeScript
/// <reference path="../_definitions.ts" />
|
|
|
|
/**
|
|
* Phaser - Components - InputHandler
|
|
*
|
|
* Input detection component
|
|
*/
|
|
|
|
module Phaser.Components {
|
|
|
|
export class InputHandler {
|
|
|
|
/**
|
|
* Sprite Input component constructor
|
|
* @param parent The Sprite using this Input component
|
|
*/
|
|
constructor(parent: Phaser.Sprite) {
|
|
|
|
this.game = parent.game;
|
|
this._parent = parent;
|
|
this.enabled = false;
|
|
|
|
}
|
|
|
|
/**
|
|
* Reference to Phaser.Game
|
|
*/
|
|
public game: Phaser.Game;
|
|
|
|
/**
|
|
* Local private reference to its parent game object.
|
|
*/
|
|
private _parent: Phaser.Sprite;
|
|
|
|
private _pointerData;
|
|
|
|
/**
|
|
* If enabled the Input component will be updated by the parent Sprite
|
|
* @type {bool}
|
|
*/
|
|
public enabled: bool;
|
|
|
|
/**
|
|
* The PriorityID controls which Sprite receives an Input event first if they should overlap.
|
|
*/
|
|
public priorityID: number = 0;
|
|
|
|
/**
|
|
* The index of this Input component entry in the Game.Input manager.
|
|
*/
|
|
public indexID: number = 0;
|
|
|
|
private _dragPoint: Point;
|
|
private _draggedPointerID: number;
|
|
public dragOffset: Point;
|
|
public isDragged: bool = false;
|
|
public dragFromCenter: bool;
|
|
public dragPixelPerfect: bool = false;
|
|
public dragPixelPerfectAlpha: number;
|
|
|
|
public allowHorizontalDrag: bool = true;
|
|
public allowVerticalDrag: bool = true;
|
|
public bringToTop: bool = false;
|
|
|
|
public snapOnDrag: bool = false;
|
|
public snapOnRelease: bool = false;
|
|
public snapOffset: Point;
|
|
public snapX: number = 0;
|
|
public snapY: number = 0;
|
|
|
|
|
|
/**
|
|
* Is this sprite allowed to be dragged by the mouse? true = yes, false = no
|
|
* @default false
|
|
*/
|
|
public draggable: bool = false;
|
|
|
|
/**
|
|
* A region of the game world within which the sprite is restricted during drag
|
|
* @default null
|
|
*/
|
|
public boundsRect: Rectangle = null;
|
|
|
|
/**
|
|
* An Sprite the bounds of which this sprite is restricted during drag
|
|
* @default null
|
|
*/
|
|
public boundsSprite: Phaser.Sprite = null;
|
|
|
|
/**
|
|
* The Input component can monitor either the physics body of the Sprite or the frameBounds
|
|
* If checkBody is set to true it will monitor the bounds of the physics body.
|
|
* @type {bool}
|
|
*/
|
|
public checkBody: bool;
|
|
|
|
/**
|
|
* Turn the mouse pointer into a hand image by temporarily setting the CSS style of the Game canvas
|
|
* on Input over. Only works on desktop browsers or browsers with a visible input pointer.
|
|
* @type {bool}
|
|
*/
|
|
public useHandCursor: bool;
|
|
|
|
/**
|
|
* If this object is set to consume the pointer event then it will stop all propogation from this object on.
|
|
* For example if you had a stack of 6 sprites with the same priority IDs and one consumed the event, none of the others would receive it.
|
|
* @type {bool}
|
|
*/
|
|
public consumePointerEvent: bool = false;
|
|
|
|
/**
|
|
* The x coordinate of the Input pointer, relative to the top-left of the parent Sprite.
|
|
* This value is only set when the pointer is over this Sprite.
|
|
* @type {number}
|
|
*/
|
|
public pointerX(pointer: number = 0): number {
|
|
return this._pointerData[pointer].x;
|
|
}
|
|
|
|
/**
|
|
* The y coordinate of the Input pointer, relative to the top-left of the parent Sprite
|
|
* This value is only set when the pointer is over this Sprite.
|
|
* @type {number}
|
|
*/
|
|
public pointerY(pointer: number = 0): number {
|
|
return this._pointerData[pointer].y;
|
|
}
|
|
|
|
/**
|
|
* If the Pointer is touching the touchscreen, or the mouse button is held down, isDown is set to true
|
|
* @property isDown
|
|
* @type {bool}
|
|
**/
|
|
public pointerDown(pointer: number = 0): bool {
|
|
return this._pointerData[pointer].isDown;
|
|
}
|
|
|
|
/**
|
|
* If the Pointer is not touching the touchscreen, or the mouse button is up, isUp is set to true
|
|
* @property isUp
|
|
* @type {bool}
|
|
**/
|
|
public pointerUp(pointer: number = 0): bool {
|
|
return this._pointerData[pointer].isUp;
|
|
}
|
|
|
|
/**
|
|
* A timestamp representing when the Pointer first touched the touchscreen.
|
|
* @property timeDown
|
|
* @type {Number}
|
|
**/
|
|
public pointerTimeDown(pointer: number = 0): bool {
|
|
return this._pointerData[pointer].timeDown;
|
|
}
|
|
|
|
/**
|
|
* A timestamp representing when the Pointer left the touchscreen.
|
|
* @property timeUp
|
|
* @type {Number}
|
|
**/
|
|
public pointerTimeUp(pointer: number = 0): bool {
|
|
return this._pointerData[pointer].timeUp;
|
|
}
|
|
|
|
/**
|
|
* Is the Pointer over this Sprite
|
|
* @property isOver
|
|
* @type {bool}
|
|
**/
|
|
public pointerOver(pointer: number = 0): bool {
|
|
return this._pointerData[pointer].isOver;
|
|
}
|
|
|
|
/**
|
|
* Is the Pointer outside of this Sprite
|
|
* @property isOut
|
|
* @type {bool}
|
|
**/
|
|
public pointerOut(pointer: number = 0): bool {
|
|
return this._pointerData[pointer].isOut;
|
|
}
|
|
|
|
/**
|
|
* A timestamp representing when the Pointer first touched the touchscreen.
|
|
* @property timeDown
|
|
* @type {Number}
|
|
**/
|
|
public pointerTimeOver(pointer: number = 0): bool {
|
|
return this._pointerData[pointer].timeOver;
|
|
}
|
|
|
|
/**
|
|
* A timestamp representing when the Pointer left the touchscreen.
|
|
* @property timeUp
|
|
* @type {Number}
|
|
**/
|
|
public pointerTimeOut(pointer: number = 0): bool {
|
|
return this._pointerData[pointer].timeOut;
|
|
}
|
|
|
|
/**
|
|
* Is this sprite being dragged by the mouse or not?
|
|
* @default false
|
|
*/
|
|
public pointerDragged(pointer: number = 0): bool {
|
|
return this._pointerData[pointer].isDragged;
|
|
}
|
|
|
|
public start(priority: number = 0, checkBody: bool = false, useHandCursor: bool = false): Phaser.Sprite {
|
|
|
|
// Turning on
|
|
if (this.enabled == false)
|
|
{
|
|
// Register, etc
|
|
this.checkBody = checkBody;
|
|
this.useHandCursor = useHandCursor;
|
|
this.priorityID = priority;
|
|
|
|
this._pointerData = [];
|
|
|
|
for (var i = 0; i < 10; i++)
|
|
{
|
|
this._pointerData.push({ id: i, x: 0, y: 0, isDown: false, isUp: false, isOver: false, isOut: false, timeOver: 0, timeOut: 0, timeDown: 0, timeUp: 0, downDuration: 0, isDragged: false });
|
|
}
|
|
|
|
this.snapOffset = new Point;
|
|
this.enabled = true;
|
|
|
|
this.game.input.addGameObject(this._parent);
|
|
|
|
// Create the signals the Input component will emit
|
|
if (this._parent.events.onInputOver == null)
|
|
{
|
|
this._parent.events.onInputOver = new Phaser.Signal;
|
|
this._parent.events.onInputOut = new Phaser.Signal;
|
|
this._parent.events.onInputDown = new Phaser.Signal;
|
|
this._parent.events.onInputUp = new Phaser.Signal;
|
|
this._parent.events.onDragStart = new Phaser.Signal;
|
|
this._parent.events.onDragStop = new Phaser.Signal;
|
|
}
|
|
}
|
|
|
|
return this._parent;
|
|
|
|
}
|
|
|
|
public reset() {
|
|
|
|
this.enabled = false;
|
|
|
|
for (var i = 0; i < 10; i++)
|
|
{
|
|
this._pointerData[i] = { id: i, x: 0, y: 0, isDown: false, isUp: false, isOver: false, isOut: false, timeOver: 0, timeOut: 0, timeDown: 0, timeUp: 0, downDuration: 0, isDragged: false };
|
|
}
|
|
|
|
}
|
|
|
|
public stop() {
|
|
|
|
// Turning off
|
|
if (this.enabled == false)
|
|
{
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
// De-register, etc
|
|
this.enabled = false;
|
|
this.game.input.removeGameObject(this.indexID);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Clean up memory.
|
|
*/
|
|
public destroy() {
|
|
|
|
if (this.enabled)
|
|
{
|
|
this.enabled = false;
|
|
this.game.input.removeGameObject(this.indexID);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Checks if the given pointer is over this Sprite. All checks are done in world coordinates.
|
|
*/
|
|
public checkPointerOver(pointer: Phaser.Pointer): bool {
|
|
|
|
if (this.enabled == false || this._parent.visible == false)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
//return SpriteUtils.overlapsXY(this._parent, pointer.worldX, pointer.worldY);
|
|
//return SpriteUtils.overlapsXY(this._parent, pointer.screenX, pointer.screenY);
|
|
return SpriteUtils.overlapsPointer(this._parent, pointer);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Update
|
|
*/
|
|
public update(pointer: Phaser.Pointer): bool {
|
|
|
|
if (this.enabled == false || this._parent.visible == false)
|
|
{
|
|
this._pointerOutHandler(pointer);
|
|
return false;
|
|
}
|
|
|
|
if (this.draggable && this._draggedPointerID == pointer.id)
|
|
{
|
|
return this.updateDrag(pointer);
|
|
}
|
|
else if (this._pointerData[pointer.id].isOver == true)
|
|
{
|
|
//if (SpriteUtils.overlapsXY(this._parent, pointer.worldX, pointer.worldY))
|
|
if (SpriteUtils.overlapsPointer(this._parent, pointer))
|
|
{
|
|
this._pointerData[pointer.id].x = pointer.x - this._parent.x;
|
|
this._pointerData[pointer.id].y = pointer.y - this._parent.y;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
this._pointerOutHandler(pointer);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public _pointerOverHandler(pointer: Pointer) {
|
|
|
|
if (this._pointerData[pointer.id].isOver == false)
|
|
{
|
|
this._pointerData[pointer.id].isOver = true;
|
|
this._pointerData[pointer.id].isOut = false;
|
|
this._pointerData[pointer.id].timeOver = this.game.time.now;
|
|
this._pointerData[pointer.id].x = pointer.x - this._parent.x;
|
|
this._pointerData[pointer.id].y = pointer.y - this._parent.y;
|
|
|
|
if (this.useHandCursor && this._pointerData[pointer.id].isDragged == false)
|
|
{
|
|
this.game.stage.canvas.style.cursor = "pointer";
|
|
}
|
|
|
|
this._parent.events.onInputOver.dispatch(this._parent, pointer);
|
|
}
|
|
|
|
}
|
|
|
|
public _pointerOutHandler(pointer: Pointer) {
|
|
|
|
this._pointerData[pointer.id].isOver = false;
|
|
this._pointerData[pointer.id].isOut = true;
|
|
this._pointerData[pointer.id].timeOut = this.game.time.now;
|
|
|
|
if (this.useHandCursor && this._pointerData[pointer.id].isDragged == false)
|
|
{
|
|
this.game.stage.canvas.style.cursor = "default";
|
|
}
|
|
|
|
this._parent.events.onInputOut.dispatch(this._parent, pointer);
|
|
|
|
}
|
|
|
|
public _touchedHandler(pointer: Pointer): bool {
|
|
|
|
if (this._pointerData[pointer.id].isDown == false && this._pointerData[pointer.id].isOver == true)
|
|
{
|
|
this._pointerData[pointer.id].isDown = true;
|
|
this._pointerData[pointer.id].isUp = false;
|
|
this._pointerData[pointer.id].timeDown = this.game.time.now;
|
|
|
|
//console.log('touchedHandler: ' + Date.now());
|
|
this._parent.events.onInputDown.dispatch(this._parent, pointer);
|
|
|
|
// Start drag
|
|
//if (this.draggable && this.isDragged == false && pointer.targetObject == null)
|
|
if (this.draggable && this.isDragged == false)
|
|
{
|
|
this.startDrag(pointer);
|
|
}
|
|
|
|
if (this.bringToTop)
|
|
{
|
|
this._parent.bringToTop();
|
|
//this._parent.game.world.group.bringToTop(this._parent);
|
|
}
|
|
|
|
}
|
|
|
|
// Consume the event?
|
|
return this.consumePointerEvent;
|
|
|
|
}
|
|
|
|
public _releasedHandler(pointer: Pointer) {
|
|
|
|
// If was previously touched by this Pointer, check if still is AND still over this item
|
|
if (this._pointerData[pointer.id].isDown && pointer.isUp)
|
|
{
|
|
this._pointerData[pointer.id].isDown = false;
|
|
this._pointerData[pointer.id].isUp = true;
|
|
this._pointerData[pointer.id].timeUp = this.game.time.now;
|
|
this._pointerData[pointer.id].downDuration = this._pointerData[pointer.id].timeUp - this._pointerData[pointer.id].timeDown;
|
|
|
|
// Only release the InputUp signal if the pointer is still over this sprite
|
|
//if (SpriteUtils.overlapsXY(this._parent, pointer.worldX, pointer.worldY))
|
|
if (SpriteUtils.overlapsPointer(this._parent, pointer))
|
|
{
|
|
//console.log('releasedHandler: ' + Date.now());
|
|
this._parent.events.onInputUp.dispatch(this._parent, pointer);
|
|
}
|
|
else
|
|
{
|
|
// Pointer outside the sprite? Reset the cursor
|
|
if (this.useHandCursor)
|
|
{
|
|
this.game.stage.canvas.style.cursor = "default";
|
|
}
|
|
}
|
|
|
|
// Stop drag
|
|
if (this.draggable && this.isDragged && this._draggedPointerID == pointer.id)
|
|
{
|
|
this.stopDrag(pointer);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Updates the Pointer drag on this Sprite.
|
|
*/
|
|
private updateDrag(pointer: Pointer): bool {
|
|
|
|
if (pointer.isUp)
|
|
{
|
|
this.stopDrag(pointer);
|
|
return false;
|
|
}
|
|
|
|
if (this.allowHorizontalDrag)
|
|
{
|
|
this._parent.x = pointer.x + this._dragPoint.x + this.dragOffset.x;
|
|
}
|
|
|
|
if (this.allowVerticalDrag)
|
|
{
|
|
this._parent.y = pointer.y + this._dragPoint.y + this.dragOffset.y;
|
|
}
|
|
|
|
if (this.boundsRect)
|
|
{
|
|
this.checkBoundsRect();
|
|
}
|
|
|
|
if (this.boundsSprite)
|
|
{
|
|
this.checkBoundsSprite();
|
|
}
|
|
|
|
if (this.snapOnDrag)
|
|
{
|
|
this._parent.x = Math.floor(this._parent.x / this.snapX) * this.snapX;
|
|
this._parent.y = Math.floor(this._parent.y / this.snapY) * this.snapY;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the pointer has entered the Sprite within the specified delay time (defaults to 500ms, half a second)
|
|
* @param delay The time below which the pointer is considered as just over.
|
|
* @returns {bool}
|
|
*/
|
|
public justOver(pointer: number = 0, delay: number = 500): bool {
|
|
return (this._pointerData[pointer].isOver && this.overDuration(pointer) < delay);
|
|
}
|
|
|
|
/**
|
|
* Returns true if the pointer has left the Sprite within the specified delay time (defaults to 500ms, half a second)
|
|
* @param delay The time below which the pointer is considered as just out.
|
|
* @returns {bool}
|
|
*/
|
|
public justOut(pointer: number = 0, delay: number = 500): bool {
|
|
return (this._pointerData[pointer].isOut && (this.game.time.now - this._pointerData[pointer].timeOut < delay));
|
|
}
|
|
|
|
/**
|
|
* Returns true if the pointer has entered the Sprite within the specified delay time (defaults to 500ms, half a second)
|
|
* @param delay The time below which the pointer is considered as just over.
|
|
* @returns {bool}
|
|
*/
|
|
public justPressed(pointer: number = 0, delay: number = 500): bool {
|
|
return (this._pointerData[pointer].isDown && this.downDuration(pointer) < delay);
|
|
}
|
|
|
|
/**
|
|
* Returns true if the pointer has left the Sprite within the specified delay time (defaults to 500ms, half a second)
|
|
* @param delay The time below which the pointer is considered as just out.
|
|
* @returns {bool}
|
|
*/
|
|
public justReleased(pointer: number = 0, delay: number = 500): bool {
|
|
return (this._pointerData[pointer].isUp && (this.game.time.now - this._pointerData[pointer].timeUp < delay));
|
|
}
|
|
|
|
/**
|
|
* If the pointer is currently over this Sprite this returns how long it has been there for in milliseconds.
|
|
* @returns {number} The number of milliseconds the pointer has been over the Sprite, or -1 if not over.
|
|
*/
|
|
public overDuration(pointer: number = 0): number {
|
|
|
|
if (this._pointerData[pointer].isOver)
|
|
{
|
|
return this.game.time.now - this._pointerData[pointer].timeOver;
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
/**
|
|
* If the pointer is currently over this Sprite this returns how long it has been there for in milliseconds.
|
|
* @returns {number} The number of milliseconds the pointer has been pressed down on the Sprite, or -1 if not over.
|
|
*/
|
|
public downDuration(pointer: number = 0): number {
|
|
|
|
if (this._pointerData[pointer].isDown)
|
|
{
|
|
return this.game.time.now - this._pointerData[pointer].timeDown;
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
/**
|
|
* Make this Sprite draggable by the mouse. You can also optionally set mouseStartDragCallback and mouseStopDragCallback
|
|
*
|
|
* @param lockCenter If false the Sprite will drag from where you click it minus the dragOffset. If true it will center itself to the tip of the mouse pointer.
|
|
* @param bringToTop If true the Sprite will be bought to the top of the rendering list in its current Group.
|
|
* @param pixelPerfect If true it will use a pixel perfect test to see if you clicked the Sprite. False uses the bounding box.
|
|
* @param alphaThreshold If using pixel perfect collision this specifies the alpha level from 0 to 255 above which a collision is processed (default 255)
|
|
* @param boundsRect If you want to restrict the drag of this sprite to a specific FlxRect, pass the FlxRect here, otherwise it's free to drag anywhere
|
|
* @param boundsSprite If you want to restrict the drag of this sprite to within the bounding box of another sprite, pass it here
|
|
*/
|
|
public enableDrag(lockCenter: bool = false, bringToTop: bool = false, pixelPerfect: bool = false, alphaThreshold: number = 255, boundsRect: Rectangle = null, boundsSprite: Phaser.Sprite = null) {
|
|
|
|
this._dragPoint = new Point;
|
|
|
|
this.draggable = true;
|
|
this.bringToTop = bringToTop;
|
|
|
|
this.dragOffset = new Point;
|
|
this.dragFromCenter = lockCenter;
|
|
this.dragPixelPerfect = pixelPerfect;
|
|
this.dragPixelPerfectAlpha = alphaThreshold;
|
|
|
|
if (boundsRect)
|
|
{
|
|
this.boundsRect = boundsRect;
|
|
}
|
|
|
|
if (boundsSprite)
|
|
{
|
|
this.boundsSprite = boundsSprite;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Stops this sprite from being able to be dragged. If it is currently the target of an active drag it will be stopped immediately. Also disables any set callbacks.
|
|
*/
|
|
public disableDrag() {
|
|
|
|
if (this._pointerData)
|
|
{
|
|
for (var i = 0; i < 10; i++)
|
|
{
|
|
this._pointerData[i].isDragged = false;
|
|
}
|
|
}
|
|
|
|
this.draggable = false;
|
|
this.isDragged = false;
|
|
this._draggedPointerID = -1;
|
|
|
|
}
|
|
|
|
/**
|
|
* Called by Pointer when drag starts on this Sprite. Should not usually be called directly.
|
|
*/
|
|
public startDrag(pointer: Pointer) {
|
|
|
|
this.isDragged = true;
|
|
this._draggedPointerID = pointer.id;
|
|
this._pointerData[pointer.id].isDragged = true;
|
|
|
|
if (this.dragFromCenter)
|
|
{
|
|
this._parent.transform.centerOn(pointer.worldX, pointer.worldY);
|
|
this._dragPoint.setTo(this._parent.x - pointer.x, this._parent.y - pointer.y);
|
|
}
|
|
else
|
|
{
|
|
this._dragPoint.setTo(this._parent.x - pointer.x, this._parent.y - pointer.y);
|
|
}
|
|
|
|
this.updateDrag(pointer);
|
|
|
|
if (this.bringToTop)
|
|
{
|
|
this._parent.bringToTop();
|
|
}
|
|
|
|
this._parent.events.onDragStart.dispatch(this._parent, pointer);
|
|
|
|
}
|
|
|
|
/**
|
|
* Called by Pointer when drag is stopped on this Sprite. Should not usually be called directly.
|
|
*/
|
|
public stopDrag(pointer: Pointer) {
|
|
|
|
this.isDragged = false;
|
|
this._draggedPointerID = -1;
|
|
this._pointerData[pointer.id].isDragged = false;
|
|
|
|
if (this.snapOnRelease)
|
|
{
|
|
this._parent.x = Math.floor(this._parent.x / this.snapX) * this.snapX;
|
|
this._parent.y = Math.floor(this._parent.y / this.snapY) * this.snapY;
|
|
}
|
|
|
|
this._parent.events.onDragStop.dispatch(this._parent, pointer);
|
|
this._parent.events.onInputUp.dispatch(this._parent, pointer);
|
|
|
|
}
|
|
|
|
/**
|
|
* Restricts this sprite to drag movement only on the given axis. Note: If both are set to false the sprite will never move!
|
|
*
|
|
* @param allowHorizontal To enable the sprite to be dragged horizontally set to true, otherwise false
|
|
* @param allowVertical To enable the sprite to be dragged vertically set to true, otherwise false
|
|
*/
|
|
public setDragLock(allowHorizontal: bool = true, allowVertical: bool = true) {
|
|
this.allowHorizontalDrag = allowHorizontal;
|
|
this.allowVerticalDrag = allowVertical;
|
|
}
|
|
|
|
/**
|
|
* Make this Sprite snap to the given grid either during drag or when it's released.
|
|
* For example 16x16 as the snapX and snapY would make the sprite snap to every 16 pixels.
|
|
*
|
|
* @param snapX The width of the grid cell in pixels
|
|
* @param snapY The height of the grid cell in pixels
|
|
* @param onDrag If true the sprite will snap to the grid while being dragged
|
|
* @param onRelease If true the sprite will snap to the grid when released
|
|
*/
|
|
public enableSnap(snapX: number, snapY: number, onDrag: bool = true, onRelease: bool = false) {
|
|
this.snapOnDrag = onDrag;
|
|
this.snapOnRelease = onRelease;
|
|
this.snapX = snapX;
|
|
this.snapY = snapY;
|
|
}
|
|
|
|
/**
|
|
* Stops the sprite from snapping to a grid during drag or release.
|
|
*/
|
|
public disableSnap() {
|
|
this.snapOnDrag = false;
|
|
this.snapOnRelease = false;
|
|
}
|
|
|
|
/**
|
|
* Bounds Rect check for the sprite drag
|
|
*/
|
|
private checkBoundsRect() {
|
|
if (this._parent.x < this.boundsRect.left)
|
|
{
|
|
this._parent.x = this.boundsRect.x;
|
|
}
|
|
else if ((this._parent.x + this._parent.width) > this.boundsRect.right)
|
|
{
|
|
this._parent.x = this.boundsRect.right - this._parent.width;
|
|
}
|
|
|
|
if (this._parent.y < this.boundsRect.top)
|
|
{
|
|
this._parent.y = this.boundsRect.top;
|
|
}
|
|
else if ((this._parent.y + this._parent.height) > this.boundsRect.bottom)
|
|
{
|
|
this._parent.y = this.boundsRect.bottom - this._parent.height;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Parent Sprite Bounds check for the sprite drag
|
|
*/
|
|
private checkBoundsSprite() {
|
|
if (this._parent.x < this.boundsSprite.x)
|
|
{
|
|
this._parent.x = this.boundsSprite.x;
|
|
}
|
|
else if ((this._parent.x + this._parent.width) > (this.boundsSprite.x + this.boundsSprite.width))
|
|
{
|
|
this._parent.x = (this.boundsSprite.x + this.boundsSprite.width) - this._parent.width;
|
|
}
|
|
|
|
if (this._parent.y < this.boundsSprite.y)
|
|
{
|
|
this._parent.y = this.boundsSprite.y;
|
|
}
|
|
else if ((this._parent.y + this._parent.height) > (this.boundsSprite.y + this.boundsSprite.height))
|
|
{
|
|
this._parent.y = (this.boundsSprite.y + this.boundsSprite.height) - this._parent.height;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
} |