scratchfoundation/Gestouch
1
0
Fork 0
mirror of https://github.com/scratchfoundation/Gestouch.git synced 2025-04-02 23:49:45 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Initial commit for the new architecture

Browse source
This commit is contained in:
Pavel fljot 2011-11-22 02:54:11 +02:00
parent 9144538e46
commit a036db1aef
35 changed files with 1972 additions and 1954 deletions

4
README.textile
View file

@ -46,6 +46,10 @@ h3. News:
h3. Other Resources
* "Apple WWDC 2011: Making the Most of Multi-Touch on iOS":https://developer.apple.com/videos/wwdc/2011/?id=118
* "Apple WWDC 2010: Simplifying Touch Event Handling with Gesture Recognizers":https://developer.apple.com/videos/wwdc/2010/?id=120
* "Apple WWDC 2010: Advanced Gesture Recognition":https://developer.apple.com/videos/wwdc/2010/?id=121
* "GestureWorks":http://www.gestureworks.com
* "TUIO":http://www.tuio.org

17
src/org/gestouch/Direction.as
View file

@ -1,17 +0,0 @@
package org.gestouch
{
public class Direction
{
public static const NONE:String = "none";
public static const LEFT:String = "left";
public static const RIGHT:String = "right";
public static const UP:String = "up";
public static const DOWN:String = "down";
public static const HORIZONTAL:String = "horizontal";
public static const VERTICAL:String = "vertical";
public static const STRAIGHT_AXES:String = "straightsAxes";
public static const DIAGONAL_AXES:String = "diagonalAxes";
public static const OCTO:String = "octo";
public static const ALL:String = "all";
}
}

16
src/org/gestouch/core/GestureState.as Normal file
View file

@ -0,0 +1,16 @@
package org.gestouch.core
{
/**
* @author Pavel fljot
*/
public class GestureState
{
public static const POSSIBLE:uint = 1 << 0;//1
public static const BEGAN:uint = 1 << 1;//2
public static const CHANGED:uint = 1 << 2;//4
public static const ENDED:uint = 1 << 3;//8
public static const CANCELLED:uint = 1 << 4;//16
public static const FAILED:uint = 1 << 5;//32
public static const RECOGNIZED:uint = 1 << 6;//64
}
}

604
src/org/gestouch/core/GesturesManager.as
View file

@ -1,371 +1,419 @@
package org.gestouch.core
{
import org.gestouch.events.MouseTouchEvent;
import org.gestouch.utils.ObjectPool;
import org.gestouch.gestures.Gesture;
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.display.InteractiveObject;
import flash.display.Stage;
import flash.errors.IllegalOperationError;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.events.TouchEvent;
import flash.ui.Multitouch;
import flash.ui.MultitouchInputMode;
import flash.utils.Dictionary;
import flash.utils.getTimer;
/**
* @author Pavel fljot
*/
public class GesturesManager implements IGesturesManager
{
public static var implementation:IGesturesManager;
protected static var _impl:IGesturesManager;
protected static var _initialized:Boolean = false;
private static var _instance:IGesturesManager;
private static var _allowInstantiation:Boolean;
protected const _touchesManager:ITouchesManager = TouchesManager.getInstance();
protected var _stage:Stage;
protected var _gestures:Vector.<IGesture> = new Vector.<IGesture>();
protected var _currGestures:Vector.<IGesture> = new Vector.<IGesture>();
/**
* Maps (Dictionary[target] = gesture) by gesture type.
*/
protected var _gestureMapsByType:Dictionary = new Dictionary();
protected var _touchPoints:Vector.<TouchPoint> = new Vector.<TouchPoint>(Multitouch.maxTouchPoints);
protected var _touchPointsPool:ObjectPool = new ObjectPool(TouchPoint);
protected var _gestures:Vector.<Gesture> = new Vector.<Gesture>();
protected var _gesturesForTouchMap:Array = [];
protected var _gesturesForTargetMap:Dictionary = new Dictionary(true);
protected var _dirtyGestures:Vector.<Gesture> = new Vector.<Gesture>();
protected var _dirtyGesturesLength:uint = 0;
protected var _dirtyGesturesMap:Dictionary = new Dictionary(true);
gestouch_internal static function addGesture(gesture:IGesture):IGesture
public function GesturesManager()
{
if (!_impl)
if (Object(this).constructor == GesturesManager && !_allowInstantiation)
{
_impl = implementation || new GesturesManager();
throw new Error("Do not instantiate GesturesManager directly.");
}
return _impl.addGesture(gesture);
}
public static function setImplementation(value:IGesturesManager):void
{
if (!value)
{
throw new ArgumentError("value cannot be null.");
}
if (_instance)
{
throw new Error("Instance of GesturesManager is already created. If you want to have own implementation of single GesturesManager instace, you should set it earlier.");
}
_instance = value;
}
gestouch_internal static function removeGesture(gesture:IGesture):IGesture
public static function getInstance():IGesturesManager
{
return _impl.removeGesture(gesture);
if (!_instance)
{
_allowInstantiation = true;
_instance = new GesturesManager();
_allowInstantiation = false;
}
return _instance;
}
gestouch_internal static function removeGestureByTarget(gestureType:Class, target:InteractiveObject):IGesture
{
return _impl.removeGestureByTarget(gestureType, target);
}
gestouch_internal static function cancelGesture(gesture:IGesture):void
{
_impl.cancelGesture(gesture);
}
gestouch_internal static function addCurrentGesture(gesture:IGesture):void
{
_impl.addCurrentGesture(gesture);
}
gestouch_internal static function updateGestureTarget(gesture:IGesture, oldTarget:InteractiveObject, newTarget:InteractiveObject):void
{
_impl.updateGestureTarget(gesture, oldTarget, newTarget);
}
public function init(stage:Stage):void
{
Multitouch.inputMode = MultitouchInputMode.TOUCH_POINT;
_stage = stage;
_stage.addEventListener(MouseEvent.MOUSE_DOWN, stage_mouseDownHandler);
_stage.addEventListener(TouchEvent.TOUCH_BEGIN, stage_touchBeginHandler);
_stage.addEventListener(TouchEvent.TOUCH_MOVE, stage_touchMoveHandler);
_stage.addEventListener(TouchEvent.TOUCH_END, stage_touchEndHandler, true);
}
public static function getTouchPoint(touchPointID:int):TouchPoint
{
return _impl.getTouchPoint(touchPointID);
}
public function addGesture(gesture:IGesture):IGesture
public function addGesture(gesture:Gesture):void
{
if (!gesture)
{
throw new ArgumentError("Argument 'gesture' must be not null.");
}
if (_gestures.indexOf(gesture) > -1)
{
throw new IllegalOperationError("Gesture instace '" + gesture + "' is already registered.");
throw new Error("This gesture is already registered.. something wrong.");
}
var targetGestures:Vector.<Gesture> = _gesturesForTargetMap[gesture.target] as Vector.<Gesture>;
if (!targetGestures)
{
targetGestures = _gesturesForTargetMap[gesture.target] = new Vector.<Gesture>();
}
targetGestures.push(gesture);
_gestures.push(gesture);
return gesture;
}
public function removeGesture(gesture:IGesture):IGesture
{
var index:int = _gestures.indexOf(gesture);
if (index == -1)
if (!_stage && gesture.target.stage)
{
throw new IllegalOperationError("Gesture instace '" + gesture + "' is not registered.");
installStage(gesture.target.stage);
}
else
{
gesture.target.addEventListener(Event.ADDED_TO_STAGE, gestureTarget_addedToStageHandler);
}
}
public function removeGesture(gesture:Gesture):void
{
if (!gesture)
{
throw new ArgumentError("Argument 'gesture' must be not null.");
}
_gestures.splice(index, 1);
index = _currGestures.indexOf(gesture);
var target:InteractiveObject = gesture.target;
var targetGestures:Vector.<Gesture> = _gesturesForTargetMap[target] as Vector.<Gesture>;
targetGestures.splice(targetGestures.indexOf(gesture), 1);
if (targetGestures.length == 0)
{
delete _gesturesForTargetMap[target];
gesture.target.removeEventListener(Event.ADDED_TO_STAGE, gestureTarget_addedToStageHandler);
}
var index:int = _gestures.indexOf(gesture);
if (index > -1)
{
_currGestures.splice(index, 1);
_gestures.splice(index, 1);
}
gesture.dispose();
return gesture;
}
public function removeGestureByTarget(gestureType:Class, target:InteractiveObject):IGesture
{
var gesture:IGesture = getGestureByTarget(gestureType, target);
return removeGesture(gesture);
}
public function getGestureByTarget(gestureType:Class, target:InteractiveObject):IGesture
{
var gesturesOfTypeByTarget:Dictionary = _gestureMapsByType[gestureType] as Dictionary;
var gesture:IGesture = gesturesOfTypeByTarget ? gesturesOfTypeByTarget[target] as IGesture : null;
return gesture;
//TODO: decide about gesture state and _dirtyGestures
}
public function cancelGesture(gesture:IGesture):void
public function scheduleGestureStateReset(gesture:Gesture):void
{
var index:int = _currGestures.indexOf(gesture);
if (index == -1)
if (!_dirtyGesturesMap[gesture])
{
return;// don't see point in throwing error
}
_currGestures.splice(index, 1);
gesture.onCancel();
}
public function addCurrentGesture(gesture:IGesture):void
{
if (_currGestures.indexOf(gesture) == -1)
{
_currGestures.push(gesture);
_dirtyGestures.push(gesture);
_dirtyGesturesLength++;
_stage.addEventListener(Event.ENTER_FRAME, stage_enterFrameHandler);
}
}
public function updateGestureTarget(gesture:IGesture, oldTarget:InteractiveObject, newTarget:InteractiveObject):void
{
if (!_initialized && newTarget)
public function onGestureRecognized(gesture:Gesture):void
{
for each (var otherGesture:Gesture in _gestures)
{
var stage:Stage = newTarget.stage;
if (stage)
// conditions for otherGesture "own properties"
if (otherGesture != gesture &&
otherGesture.enabled &&
otherGesture.state == GestureState.POSSIBLE)
{
_impl.init(stage);
_initialized = true;
}
else
{
newTarget.addEventListener(Event.ADDED_TO_STAGE, target_addedToStageHandler, false, 0, true);
// conditions for otherGesture target
if (otherGesture.target == gesture.target ||
(gesture.target is DisplayObjectContainer && (gesture.target as DisplayObjectContainer).contains(otherGesture.target)) ||
(otherGesture.target is DisplayObjectContainer && (otherGesture.target as DisplayObjectContainer).contains(gesture.target))
)
{
// conditions for gestures relations
if (gesture.canPreventGesture(otherGesture) &&
otherGesture.canBePreventedByGesture(gesture) &&
(!gesture.delegate || !gesture.delegate.gesturesShouldRecognizeSimultaneously(gesture, otherGesture)) &&
(!otherGesture.delegate || !otherGesture.delegate.gesturesShouldRecognizeSimultaneously(otherGesture, gesture)))
{
otherGesture.gestouch_internal::setState_internal(GestureState.FAILED);
}
}
}
}
}
//--------------------------------------------------------------------------
//
// Private methods
//
//--------------------------------------------------------------------------
protected function installStage(stage:Stage):void
{
_touchesManager.init(stage);
_stage = stage;
var gesturesOfTypeByTarget:Dictionary = _gestureMapsByType[gesture.reflect()] as Dictionary;
if (!gesturesOfTypeByTarget)
if (Multitouch.supportsTouchEvents)
{
gesturesOfTypeByTarget = _gestureMapsByType[gesture.reflect()] = new Dictionary();
stage.addEventListener(TouchEvent.TOUCH_BEGIN, touchBeginHandler);
}
else if (gesturesOfTypeByTarget[newTarget])
else
{
throw new IllegalOperationError("You cannot add two gestures of the same type to one target (it makes no sence).");
}
if (oldTarget)
{
oldTarget.addEventListener(Event.ADDED_TO_STAGE, target_addedToStageHandler);
delete gesturesOfTypeByTarget[oldTarget];
}
if (newTarget)
{
gesturesOfTypeByTarget[newTarget] = gesture;
stage.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);
}
}
public function getTouchPoint(touchPointID:int):TouchPoint
{
var p:TouchPoint = _touchPoints[touchPointID];
if (!p)
{
throw new ArgumentError("No touch point with ID " + touchPointID + " found.");
}
return p.clone() as TouchPoint;
}
private static function target_addedToStageHandler(event:Event):void
{
var target:InteractiveObject = event.currentTarget as InteractiveObject;
target.removeEventListener(Event.ADDED_TO_STAGE, target_addedToStageHandler);
if (!_initialized)
{
_impl.init(target.stage);
_initialized = true;
}
}
protected function stage_mouseDownHandler(event:MouseEvent):void
protected function installStageListeners():void
{
if (Multitouch.supportsTouchEvents)
{
return;
_stage.addEventListener(TouchEvent.TOUCH_MOVE, touchMoveHandler);
_stage.addEventListener(TouchEvent.TOUCH_END, touchEndHandler, true);
}
_stage.addEventListener(MouseEvent.MOUSE_MOVE, stage_mouseMoveHandler);
_stage.addEventListener(MouseEvent.MOUSE_UP, stage_mouseUpHandler);
stage_touchBeginHandler(new MouseTouchEvent(TouchEvent.TOUCH_BEGIN, event));
}
protected function stage_mouseMoveHandler(event:MouseEvent):void
{
stage_touchMoveHandler(new MouseTouchEvent(TouchEvent.TOUCH_MOVE, event));
}
protected function stage_mouseUpHandler(event:MouseEvent):void
{
_stage.removeEventListener(MouseEvent.MOUSE_MOVE, stage_mouseMoveHandler);
_stage.removeEventListener(MouseEvent.MOUSE_UP, stage_mouseUpHandler);
stage_touchEndHandler(new MouseTouchEvent(TouchEvent.TOUCH_END, event));
}
protected function stage_touchBeginHandler(event:TouchEvent):void
{
var outOfRange:Boolean = (_touchPoints.length <= event.touchPointID);
var tp:TouchPoint = outOfRange ? null : _touchPoints[event.touchPointID];
if (!tp)
else
{
tp = _touchPointsPool.getObject() as TouchPoint;
tp.id = event.touchPointID;
if (outOfRange)
{
_touchPoints.length = tp.id + 1;
}
_touchPoints[tp.id] = tp;
}
tp.reset();
tp.x = event.stageX;
tp.y = event.stageY;
tp.sizeX = event.sizeX;
tp.sizeY = event.sizeY;
tp.pressure = event.pressure;
tp.touchBeginPos.x = tp.x;
tp.touchBeginPos.y = tp.y;
tp.touchBeginTime = tp.lastTime = getTimer();
tp.moveOffset.x = tp.moveOffset.y = 0;
tp.lastMove.x = tp.lastMove.y = 0;
tp.velocity.x = tp.velocity.y = 0;
for each (var gesture:IGesture in _gestures)
{
if (gesture.enabled && gesture.target && gesture.shouldTrackPoint(event, tp))
{
gesture.onTouchBegin(tp);
}
}
// add gestures that are being tracked to the current gestures list
var n:uint = _gestures.length;
while (n-- > 0)
{
gesture = _gestures[n];
//TODO: which condition first (performance-wise)?
if (_currGestures.indexOf(gesture) == -1 && gesture.isTracking(tp.id))
{
_currGestures.push(gesture);
}
_stage.addEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
_stage.addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler, true);
}
}
protected function stage_touchMoveHandler(event:TouchEvent):void
protected function uninstallStageListeners():void
{
var tp:TouchPoint = _touchPoints[event.touchPointID];
var oldX:Number = tp.x;
var oldY:Number = tp.y;
tp.x = event.stageX;
tp.y = event.stageY;
tp.sizeX = event.sizeX;
tp.sizeY = event.sizeY;
tp.pressure = event.pressure;
// tp.moveOffset = tp.subtract(tp.touchBeginPos);
tp.moveOffset.x = tp.x - tp.touchBeginPos.x;
tp.moveOffset.y = tp.y - tp.touchBeginPos.y;
tp.lastMove.x = tp.x - oldX;
tp.lastMove.y = tp.y - oldY;
var now:uint = getTimer();
var dt:uint = now - tp.lastTime;
tp.lastTime = now;
tp.velocity.x = tp.lastMove.x / dt;
tp.velocity.y = tp.lastMove.y / dt;
for each (var gesture:IGesture in _currGestures)
if (Multitouch.supportsTouchEvents)
{
if (gesture.isTracking(tp.id))
{
gesture.onTouchMove(tp);
}
_stage.removeEventListener(TouchEvent.TOUCH_MOVE, touchMoveHandler);
_stage.removeEventListener(TouchEvent.TOUCH_END, touchEndHandler, true);
}
else
{
_stage.removeEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
_stage.removeEventListener(MouseEvent.MOUSE_UP, mouseUpHandler, true);
}
}
protected function stage_touchEndHandler(event:TouchEvent):void
protected function resetDirtyGestures():void
{
var tp:TouchPoint = _touchPoints[event.touchPointID];
tp.x = event.stageX;
tp.y = event.stageY;
tp.sizeX = event.sizeX;
tp.sizeY = event.sizeY;
tp.pressure = event.pressure;
tp.moveOffset = tp.subtract(tp.touchBeginPos);
for each (var gesture:IGesture in _currGestures)
for each (var gesture:Gesture in _dirtyGestures)
{
if (gesture.isTracking(tp.id))
{
gesture.onTouchEnd(tp);
}
gesture.reset();
}
_dirtyGestures.length = 0;
_dirtyGesturesLength = 0;
_dirtyGesturesMap = new Dictionary(true);
_stage.removeEventListener(Event.ENTER_FRAME, stage_enterFrameHandler);
}
//--------------------------------------------------------------------------
//
// Event handlers
//
//--------------------------------------------------------------------------
protected function gestureTarget_addedToStageHandler(event:Event):void
{
var target:DisplayObject = event.target as DisplayObject;
target.removeEventListener(Event.ADDED_TO_STAGE, gestureTarget_addedToStageHandler);
if (!_stage)
{
installStage(target.stage);
}
var i:uint = 0;
for each (gesture in _currGestures.concat())
var depth:uint = 1;//NB! not using 0-based for sorting function
var targetParent:DisplayObjectContainer = target.parent;
while (targetParent)
{
if (gesture.trackingPointsCount == 0)
depth++;
targetParent = targetParent.parent;
}
}
protected function touchBeginHandler(event:TouchEvent):void
{
if (_dirtyGesturesLength > 0)
{
resetDirtyGestures();
}
var touch:Touch = _touchesManager.getTouch(event.touchPointID);
var gesture:Gesture;
var i:uint;
// This vector will contain active gestures for specific touch (ID) during all touch session.
var gesturesForTouch:Vector.<Gesture> = _gesturesForTouchMap[touch.id] as Vector.<Gesture>;
if (!gesturesForTouch)
{
gesturesForTouch = new Vector.<Gesture>();
_gesturesForTouchMap[touch.id] = gesturesForTouch;
}
else
{
gesturesForTouch.length = 0;
}
// Create a sorted(!) list of gestures which are interested in this touch.
// Sorting priority: deeper target has higher priority, recently added gesture has higher priority.
var target:InteractiveObject = touch.target;
var gesturesForTarget:Vector.<Gesture>;
while (target)
{
gesturesForTarget = _gesturesForTargetMap[target] as Vector.<Gesture>;
if (gesturesForTarget)
{
_currGestures.splice(i, 1);
i = gesturesForTarget.length;
while (i-- > 0)
{
gesture = gesturesForTarget[i] as Gesture;
if (gesture.enabled &&
(!gesture.delegate || gesture.delegate.gestureShouldReceiveTouch(gesture, touch)))
{
//TODO: optimize performance! decide between unshift() vs [i++] = gesture + reverse()
gesturesForTouch.unshift(gesture);
}
}
}
target = target.parent;
}
// Then we populate them with this touch and event.
// They might start tracking this touch or ignore it (via Gesture#ignoreTouch())
i = gesturesForTouch.length;
while (i-- > 0)
{
gesture = gesturesForTouch[i] as Gesture;
// Check for state because previous (i+1) gesture may already abort current (i) one
if (gesture.state != GestureState.FAILED)
{
gesture.gestouch_internal::touchBeginHandler(touch, event);
}
else
{
i++;
{
gesturesForTouch.splice(i, 1);
}
}
installStageListeners();
}
protected function mouseDownHandler(event:MouseEvent):void
{
touchBeginHandler(MouseTouchEvent.createMouseTouchEvent(event));
}
protected function touchMoveHandler(event:TouchEvent):void
{
if (_dirtyGesturesLength > 0)
{
resetDirtyGestures();
}
var touch:Touch = _touchesManager.getTouch(event.touchPointID);
var gesturesForTouch:Vector.<Gesture> = _gesturesForTouchMap[touch.id] as Vector.<Gesture>;
var gesture:Gesture;
var i:int = gesturesForTouch.length;
while (i-- > 0)
{
gesture = gesturesForTouch[i] as Gesture;
if (gesture.state != GestureState.FAILED && gesture.isTrackingTouch(touch.id))
{
gesture.gestouch_internal::touchMoveHandler(touch, event);
}
else
{
// gesture is no more interested in this touch (e.g. ignoreTouch was called)
gesturesForTouch.splice(i, 1);
}
}
}
protected function mouseMoveHandler(event:MouseEvent):void
{
//TODO: copy code from touchMoveHandler: save 1 function call?
touchMoveHandler(MouseTouchEvent.createMouseTouchEvent(event));
}
protected function touchEndHandler(event:TouchEvent):void
{
if (_dirtyGesturesLength > 0)
{
resetDirtyGestures();
}
var touch:Touch = _touchesManager.getTouch(event.touchPointID);
var gesturesForTouch:Vector.<Gesture> = _gesturesForTouchMap[touch.id] as Vector.<Gesture>;
var gesture:Gesture;
var i:int = gesturesForTouch.length;
while (i-- > 0)
{
gesture = gesturesForTouch[i] as Gesture;
// TODO: handle cancelled touch:
// if (event.hasOwnProperty("isTouchPointCanceled") && event["isTouchPointCanceled"] && ...
if (gesture.state != GestureState.FAILED && gesture.isTrackingTouch(touch.id))
{
gesture.gestouch_internal::touchEndHandler(touch, event);
}
}
if (_touchesManager.activeTouchesCount == 0)
{
uninstallStageListeners();
}
}
protected function mouseUpHandler(event:MouseEvent):void
{
touchEndHandler(MouseTouchEvent.createMouseTouchEvent(event));
}
private function stage_enterFrameHandler(event:Event):void
{
resetDirtyGestures();
}
}
}

31
src/org/gestouch/core/IGesture.as
View file

@ -1,31 +0,0 @@
package org.gestouch.core
{
import flash.events.IEventDispatcher;
import flash.display.InteractiveObject;
import flash.events.TouchEvent;
/**
* @author Pavel fljot
*/
public interface IGesture extends IEventDispatcher
{
function get target():InteractiveObject;
function get trackingPoints():Vector.<TouchPoint>;
function get trackingPointsCount():uint;
function get enabled():Boolean;
function set enabled(value:Boolean):void;
function shouldTrackPoint(event:TouchEvent, tp:TouchPoint):Boolean;
function isTracking(touchPointID:uint):Boolean;
function cancel():void;
function pickAndContinue(gesture:IGesture):void;
function reflect():Class;
function dispose():void;
function onTouchBegin(touchPoint:TouchPoint):void;
function onTouchMove(touchPoint:TouchPoint):void;
function onTouchEnd(touchPoint:TouchPoint):void;
function onCancel():void;
}
}

13
src/org/gestouch/core/IGestureDelegate.as Normal file
View file

@ -0,0 +1,13 @@
package org.gestouch.core
{
import org.gestouch.gestures.Gesture;
/**
* @author Pavel fljot
*/
public interface IGestureDelegate
{
function gestureShouldReceiveTouch(gesture:Gesture, touch:Touch):Boolean;
function gestureShouldBegin(gesture:Gesture):Boolean;
function gesturesShouldRecognizeSimultaneously(gesture:Gesture, otherGesture:Gesture):Boolean;
}
}

17
src/org/gestouch/core/IGesturesManager.as
View file

@ -1,24 +1,17 @@
package org.gestouch.core
{
import flash.display.InteractiveObject;
import flash.display.Stage;
import org.gestouch.gestures.Gesture;
/**
* @author Pavel fljot
*/
public interface IGesturesManager
{
function init(stage:Stage):void;
function addGesture(gesture:Gesture):void;
function addGesture(gesture:IGesture):IGesture;
function removeGesture(gesture:IGesture):IGesture;
function removeGestureByTarget(gestureType:Class, target:InteractiveObject):IGesture;
function getGestureByTarget(gestureType:Class, target:InteractiveObject):IGesture;
function cancelGesture(gesture:IGesture):void;
function addCurrentGesture(gesture:IGesture):void;
function removeGesture(gesture:Gesture):void;
function updateGestureTarget(gesture:IGesture, oldTarget:InteractiveObject, newTarget:InteractiveObject):void;
function scheduleGestureStateReset(gesture:Gesture):void;
function getTouchPoint(touchPointID:int):TouchPoint;
function onGestureRecognized(gesture:Gesture):void;
}
}

14
src/org/gestouch/core/ITouchesManager.as Normal file
View file

@ -0,0 +1,14 @@
package org.gestouch.core
{
import flash.display.Stage;
/**
* @author Pavel fljot
*/
public interface ITouchesManager
{
function get activeTouchesCount():uint;
function init(stage:Stage):void;
function getTouch(touchPointID:int):Touch;
}
}

63
src/org/gestouch/core/Touch.as Normal file
View file

@ -0,0 +1,63 @@
package org.gestouch.core
{
import flash.display.InteractiveObject;
/**
* TODO:
* - maybe add "phase" (began, moved, stationary, ended)?
*
* @author Pavel fljot
*/
public class Touch
{
/**
* Touch point ID.
*/
public var id:uint;
/**
* The original event target for this touch (touch began with).
*/
public var target:InteractiveObject;
public var x:Number;
public var y:Number;
public var sizeX:Number;
public var sizeY:Number;
public var pressure:Number;
public var time:uint;
// public var touchBeginPos:Point;
// public var touchBeginTime:uint;
// public var moveOffset:Point;
// public var lastMove:Point;
// public var velocity:Point;
public function Touch(id:uint = 0)
{
this.id = id;
}
public function clone():Touch
{
var touch:Touch = new Touch(id);
touch.x = x;
touch.y = y;
touch.target = target;
touch.sizeX = sizeX;
touch.sizeY = sizeY;
touch.pressure = pressure;
touch.time = time;
return touch;
}
public function toString():String
{
return "Touch [id: " + id + ", x: " + x + ", y: " + y + ", ...]";
}
}
}

68
src/org/gestouch/core/TouchPoint.as
View file

@ -1,68 +0,0 @@
package org.gestouch.core
{
import flash.geom.Point;
/**
* @author Pavel fljot
*/
public class TouchPoint extends Point
{
public var id:uint;
public var localX:Number;
public var localY:Number;
public var sizeX:Number;
public var sizeY:Number;
public var pressure:Number;
public var touchBeginPos:Point;
public var touchBeginTime:uint;
public var moveOffset:Point;
public var lastMove:Point;
public var lastTime:uint;
public var velocity:Point;
public function TouchPoint(id:uint = 0, x:Number = 0, y:Number = 0,
sizeX:Number = NaN, sizeY:Number = NaN,
pressure:Number = NaN,
touchBeginPos:Point = null, touchBeginTime:uint = 0,
moveOffset:Point = null,
lastMove:Point = null, lastTime:uint = 0, velocity:Point = null)
{
super(x, y);
this.id = id;
this.sizeX = sizeX;
this.sizeY = sizeY;
this.pressure = pressure;
this.touchBeginPos = touchBeginPos || new Point();
this.touchBeginTime = touchBeginTime;
this.moveOffset = moveOffset || new Point();
this.lastMove = lastMove || new Point();
this.lastTime = lastTime;
this.velocity = velocity || new Point();
}
override public function clone():Point
{
var p:TouchPoint = new TouchPoint(id, x, y, sizeX, sizeY, pressure,
touchBeginPos.clone(), touchBeginTime,
moveOffset.clone(),
lastMove.clone(), lastTime, velocity.clone());
return p;
}
public function reset():void
{
}
override public function toString():String
{
return "Touch point [id: " + id + ", x: " + x + ", y: " + y + ", ...]";
}
}
}

204
src/org/gestouch/core/TouchesManager.as Normal file
View file

@ -0,0 +1,204 @@
package org.gestouch.core
{
import flash.display.InteractiveObject;
import flash.display.Stage;
import flash.events.MouseEvent;
import flash.events.TouchEvent;
import flash.ui.Multitouch;
import flash.ui.MultitouchInputMode;
import flash.utils.getTimer;
/**
* @author Pavel fljot
*/
public class TouchesManager implements ITouchesManager
{
private static var _instance:ITouchesManager;
private static var _allowInstantiation:Boolean;
protected var _stage:Stage;
protected var _touchesMap:Object = {};
{
Multitouch.inputMode = MultitouchInputMode.TOUCH_POINT;
}
public function TouchesManager()
{
if (Object(this).constructor == TouchesManager && !_allowInstantiation)
{
throw new Error("Do not instantiate TouchesManager directly.");
}
}
protected var _activeTouchesCount:uint;
public function get activeTouchesCount():uint
{
return _activeTouchesCount;
}
public static function setImplementation(value:ITouchesManager):void
{
if (!value)
{
throw new ArgumentError("value cannot be null.");
}
if (_instance)
{
throw new Error("Instance of TouchesManager is already created. If you want to have own implementation of single TouchesManager instace, you should set it earlier.");
}
_instance = value;
}
public static function getInstance():ITouchesManager
{
if (!_instance)
{
_allowInstantiation = true;
_instance = new TouchesManager();
_allowInstantiation = false;
}
return _instance;
}
public function init(stage:Stage):void
{
_stage = stage;
if (Multitouch.supportsTouchEvents)
{
stage.addEventListener(TouchEvent.TOUCH_BEGIN, stage_touchBeginHandler, true, int.MAX_VALUE);
stage.addEventListener(TouchEvent.TOUCH_MOVE, stage_touchMoveHandler, true, int.MAX_VALUE);
stage.addEventListener(TouchEvent.TOUCH_END, stage_touchEndHandler, true, int.MAX_VALUE);
}
else
{
stage.addEventListener(MouseEvent.MOUSE_DOWN, stage_mouseDownHandler, true, int.MAX_VALUE);
stage.addEventListener(MouseEvent.MOUSE_MOVE, stage_mouseMoveHandler, true, int.MAX_VALUE);
stage.addEventListener(MouseEvent.MOUSE_UP, stage_mouseUpHandler, true, int.MAX_VALUE);
}
}
public function getTouch(touchPointID:int):Touch
{
var touch:Touch = _touchesMap[touchPointID] as Touch;
return touch ? touch.clone() : null;
}
//--------------------------------------------------------------------------
//
// Event handlers
//
//--------------------------------------------------------------------------
protected function stage_touchBeginHandler(event:TouchEvent):void
{
var touch:Touch = new Touch(event.touchPointID);
_touchesMap[event.touchPointID] = touch;
touch.target = event.target as InteractiveObject;
touch.x = event.stageX;
touch.y = event.stageY;
touch.sizeX = event.sizeX;
touch.sizeY = event.sizeY;
touch.pressure = event.pressure;
touch.time = getTimer();//TODO: conditional compilation + event.timestamp
_activeTouchesCount++;
}
protected function stage_mouseDownHandler(event:MouseEvent):void
{
var touch:Touch = new Touch(0);
_touchesMap[0] = touch;
touch.target = event.target as InteractiveObject;
touch.x = event.stageX;
touch.y = event.stageY;
touch.sizeX = NaN;
touch.sizeY = NaN;
touch.pressure = NaN;
touch.time = getTimer();//TODO: conditional compilation + event.timestamp
_activeTouchesCount++;
}
protected function stage_touchMoveHandler(event:TouchEvent):void
{
var touch:Touch = _touchesMap[event.touchPointID] as Touch;
if (!touch)
{
// some fake event?
return;
}
touch.x = event.stageX;
touch.y = event.stageY;
touch.sizeX = event.sizeX;
touch.sizeY = event.sizeY;
touch.pressure = event.pressure;
touch.time = getTimer();//TODO: conditional compilation + event.timestamp
}
protected function stage_mouseMoveHandler(event:MouseEvent):void
{
var touch:Touch = _touchesMap[0] as Touch;
if (!touch)
{
// some fake event?
return;
}
touch.x = event.stageX;
touch.y = event.stageY;
touch.time = getTimer();//TODO: conditional compilation + event.timestamp
}
protected function stage_touchEndHandler(event:TouchEvent):void
{
var touch:Touch = _touchesMap[event.touchPointID] as Touch;
if (!touch)
{
// some fake event?
return;
}
touch.x = event.stageX;
touch.y = event.stageY;
touch.sizeX = event.sizeX;
touch.sizeY = event.sizeY;
touch.pressure = event.pressure;
touch.time = getTimer();//TODO: conditional compilation + event.timestamp
_activeTouchesCount--;
}
protected function stage_mouseUpHandler(event:MouseEvent):void
{
var touch:Touch = _touchesMap[0] as Touch;
if (!touch)
{
// some fake event?
return;
}
touch.x = event.stageX;
touch.y = event.stageY;
touch.time = getTimer();//TODO: conditional compilation + event.timestamp
_activeTouchesCount--;
}
}
}

19
src/org/gestouch/events/DoubleTapGestureEvent.as
View file

@ -1,19 +0,0 @@
package org.gestouch.events
{
import flash.events.GestureEvent;
/**
* @author Pavel fljot
*/
public class DoubleTapGestureEvent extends GestureEvent
{
public static const GESTURE_DOUBLE_TAP:String = "gestureDoubleTap";
public function DoubleTapGestureEvent(type:String, bubbles:Boolean = true, cancelable:Boolean = false, phase:String = null, localX:Number = 0, localY:Number = 0, ctrlKey:Boolean = false, altKey:Boolean = false, shiftKey:Boolean = false)
{
super(type, bubbles, cancelable, phase, localX, localY, ctrlKey, altKey, shiftKey);
}
}
}

19
src/org/gestouch/events/DragGestureEvent.as
View file

@ -1,19 +0,0 @@
package org.gestouch.events
{
import flash.events.TransformGestureEvent;
/**
* @author Pavel fljot
*/
public class DragGestureEvent extends TransformGestureEvent
{
public static const GESTURE_DRAG:String = "gestureDrag";
public function DragGestureEvent(type:String, bubbles:Boolean = true, cancelable:Boolean = false, phase:String = null, localX:Number = 0, localY:Number = 0, scaleX:Number = 1.0, scaleY:Number = 1.0, rotation:Number = 0, offsetX:Number = 0, offsetY:Number = 0, ctrlKey:Boolean = false, altKey:Boolean = false, shiftKey:Boolean = false, commandKey:Boolean = false, controlKey:Boolean = false)
{
super(type, bubbles, cancelable, phase, localX, localY, scaleX, scaleY, rotation, offsetX, offsetY, ctrlKey, altKey, shiftKey);
}
}
}

37
src/org/gestouch/events/GestureStateEvent.as Normal file
View file

@ -0,0 +1,37 @@
package org.gestouch.events
{
import flash.events.Event;
/**
* @author Pavel fljot
*/
public class GestureStateEvent extends Event
{
public static const STATE_CHANGE:String = "stateChange";
public var newState:uint;
public var oldState:uint;
public function GestureStateEvent(type:String, newState:uint, oldState:uint)
{
super(type, false, false);
this.newState = newState;
this.oldState = oldState;
}
override public function clone():Event
{
return new GestureStateEvent(type, newState, oldState);
}
override public function toString():String
{
return formatToString("GestureStateEvent", newState, oldState);
}
}
}

32
src/org/gestouch/events/GestureTrackingEvent.as
View file

@ -1,32 +0,0 @@
package org.gestouch.events
{
import flash.events.Event;
/**
* @author Pavel fljot
*/
public class GestureTrackingEvent extends Event
{
public static const GESTURE_TRACKING_BEGIN:String = "gestureTrackingBegin";
public static const GESTURE_TRACKING_END:String = "gestureTrackingEnd";
public function GestureTrackingEvent(type:String, bubbles:Boolean = false, cancelable:Boolean = false)
{
super(type, bubbles, cancelable);
}
override public function clone():Event
{
return new GestureTrackingEvent(type, bubbles, cancelable);
}
override public function toString():String
{
return formatToString("GestureTrackingEvent", "type", "bubbles", "cancelable", "eventPhase");
}
}
}

19
src/org/gestouch/events/LongPressGestureEvent.as
View file

@ -1,5 +1,6 @@
package org.gestouch.events
{
import flash.events.Event;
import flash.events.GestureEvent;
@ -10,10 +11,22 @@ package org.gestouch.events
{
public static const GESTURE_LONG_PRESS:String = "gestureLongPress";
//TODO: default
public function LongPressGestureEvent(type:String, bubbles:Boolean = true, cancelable:Boolean = false, phase:String = "begin", localX:Number = 0, localY:Number = 0, ctrlKey:Boolean = false, altKey:Boolean = false, shiftKey:Boolean = false)
public function LongPressGestureEvent(type:String, bubbles:Boolean = false, cancelable:Boolean = false, phase:String = null, localX:Number = 0, localY:Number = 0)
{
super(type, bubbles, cancelable, phase, localX, localY, ctrlKey, altKey, shiftKey);
super(type, bubbles, cancelable, phase, localX, localY);
}
override public function clone():Event
{
return new LongPressGestureEvent(type, bubbles, cancelable, phase, localX, localY);
}
override public function toString():String
{
return super.toString().replace("GestureEvent", "LongPressGestureEvent");
}
}
}

56
src/org/gestouch/events/MouseTouchEvent.as
View file

@ -10,34 +10,72 @@ package org.gestouch.events
*/
public class MouseTouchEvent extends TouchEvent
{
private static const typeMap:Object = {};
protected var _mouseEvent:MouseEvent;
{
MouseTouchEvent.typeMap[MouseEvent.MOUSE_DOWN] = TouchEvent.TOUCH_BEGIN;
MouseTouchEvent.typeMap[MouseEvent.MOUSE_MOVE] = TouchEvent.TOUCH_MOVE;
MouseTouchEvent.typeMap[MouseEvent.MOUSE_UP] = TouchEvent.TOUCH_END;
}
public function MouseTouchEvent(type:String, event:MouseEvent)
{
super(type, event.bubbles, event.cancelable, 0, true, event.localX, event.localY, NaN, NaN, NaN, event.relatedObject, event.ctrlKey, event.altKey, event.shiftKey);
_target = event.target;
_stageX = event.stageX;
_stageY = event.stageY;
_mouseEvent = event;
}
public static function createMouseTouchEvent(event:MouseEvent):MouseTouchEvent
{
var type:String = MouseTouchEvent.typeMap[event.type];
if (!type)
{
throw new Error("No match found for MouseEvent of type \"" + event.type + "\"");
}
return new MouseTouchEvent(type, event);
}
protected var _target:Object;
override public function get target():Object
{
return _target;
return _mouseEvent.target;
}
override public function get currentTarget():Object
{
return _mouseEvent.currentTarget;
}
protected var _stageX:Number;
override public function get stageX():Number
{
return _stageX;
return _mouseEvent.stageX;
}
protected var _stageY:Number;
override public function get stageY():Number
{
return _stageY;
return _mouseEvent.stageY;
}
override public function stopPropagation():void
{
super.stopPropagation();
_mouseEvent.stopPropagation();
}
override public function stopImmediatePropagation():void
{
super.stopImmediatePropagation();
_mouseEvent.stopImmediatePropagation();
}

32
src/org/gestouch/events/PanGestureEvent.as Normal file
View file

@ -0,0 +1,32 @@
package org.gestouch.events
{
import flash.events.Event;
import flash.events.TransformGestureEvent;
/**
* @author Pavel fljot
*/
public class PanGestureEvent extends TransformGestureEvent
{
public static const GESTURE_PAN:String = "gesturePan";
public function PanGestureEvent(type:String, bubbles:Boolean = false, cancelable:Boolean = false, phase:String = null, localX:Number = 0, localY:Number = 0, offsetX:Number = 0, offsetY:Number = 0)
{
super(type, bubbles, cancelable, phase, localX, localY, 1, 1, 0, offsetX, offsetY);
}
override public function clone():Event
{
return new PanGestureEvent(type, bubbles, cancelable, phase, localX, localY, offsetX, offsetY);
}
override public function toString():String
{
return super.toString().replace("TransformGestureEvent", "PanGestureEvent");
}
}
}

17
src/org/gestouch/events/RotateGestureEvent.as
View file

@ -1,5 +1,6 @@
package org.gestouch.events
{
import flash.events.Event;
import flash.events.TransformGestureEvent;
@ -11,9 +12,21 @@ package org.gestouch.events
public static const GESTURE_ROTATE:String = "gestureRotate";
public function RotateGestureEvent(type:String, bubbles:Boolean = true, cancelable:Boolean = false, phase:String = null, localX:Number = 0, localY:Number = 0, scaleX:Number = 1.0, scaleY:Number = 1.0, rotation:Number = 0, offsetX:Number = 0, offsetY:Number = 0, ctrlKey:Boolean = false, altKey:Boolean = false, shiftKey:Boolean = false, commandKey:Boolean = false, controlKey:Boolean = false)
public function RotateGestureEvent(type:String, bubbles:Boolean = false, cancelable:Boolean = false, phase:String = null, localX:Number = 0, localY:Number = 0, rotation:Number = 0)
{
super(type, bubbles, cancelable, phase, localX, localY, scaleX, scaleY, rotation, offsetX, offsetY, ctrlKey, altKey, shiftKey);
super(type, bubbles, cancelable, phase, localX, localY, 1, 1, rotation, localX, localY);
}
override public function clone():Event
{
return new RotateGestureEvent(type, bubbles, cancelable, phase, localX, localY, rotation);
}
override public function toString():String
{
return super.toString().replace("TransformGestureEvent", "RotateGestureEvent");
}
}
}

17
src/org/gestouch/events/SwipeGestureEvent.as
View file

@ -1,5 +1,6 @@
package org.gestouch.events
{
import flash.events.Event;
import flash.events.TransformGestureEvent;
@ -11,9 +12,21 @@ package org.gestouch.events
public static const GESTURE_SWIPE:String = "gestureSwipe";
public function SwipeGestureEvent(type:String, bubbles:Boolean = true, cancelable:Boolean = false, phase:String = null, localX:Number = 0, localY:Number = 0, scaleX:Number = 1.0, scaleY:Number = 1.0, rotation:Number = 0, offsetX:Number = 0, offsetY:Number = 0, ctrlKey:Boolean = false, altKey:Boolean = false, shiftKey:Boolean = false, commandKey:Boolean = false, controlKey:Boolean = false)
public function SwipeGestureEvent(type:String, bubbles:Boolean = false, cancelable:Boolean = false, phase:String = null, localX:Number = 0, localY:Number = 0, offsetX:Number = 0, offsetY:Number = 0)
{
super(type, bubbles, cancelable, phase, localX, localY, scaleX, scaleY, rotation, offsetX, offsetY, ctrlKey, altKey, shiftKey);
super(type, bubbles, cancelable, phase, localX, localY, 1, 1, 0, offsetX, offsetY);
}
override public function clone():Event
{
return new SwipeGestureEvent(type, bubbles, cancelable, phase, localX, localY, offsetX, offsetY);
}
override public function toString():String
{
return super.toString().replace("TransformGestureEvent", "SwipeGestureEvent");
}
}
}

32
src/org/gestouch/events/TapGestureEvent.as Normal file
View file

@ -0,0 +1,32 @@
package org.gestouch.events
{
import flash.events.Event;
import flash.events.GestureEvent;
/**
* @author Pavel fljot
*/
public class TapGestureEvent extends GestureEvent
{
public static const GESTURE_TAP:String = "gestureTap";
public function TapGestureEvent(type:String, bubbles:Boolean = false, cancelable:Boolean = false, phase:String = null, localX:Number = 0, localY:Number = 0)
{
super(type, bubbles, cancelable, phase, localX, localY);
}
override public function clone():Event
{
return new TapGestureEvent(type, bubbles, cancelable, phase, localX, localY);
}
override public function toString():String
{
return super.toString().replace("GestureEvent", "TapGestureEvent");
}
}
}

17
src/org/gestouch/events/ZoomGestureEvent.as
View file

@ -1,5 +1,6 @@
package org.gestouch.events
{
import flash.events.Event;
import flash.events.TransformGestureEvent;
@ -11,9 +12,21 @@ package org.gestouch.events
public static const GESTURE_ZOOM:String = "gestureZoom";
public function ZoomGestureEvent(type:String, bubbles:Boolean = true, cancelable:Boolean = false, phase:String = null, localX:Number = 0, localY:Number = 0, scaleX:Number = 1.0, scaleY:Number = 1.0, rotation:Number = 0, offsetX:Number = 0, offsetY:Number = 0, ctrlKey:Boolean = false, altKey:Boolean = false, shiftKey:Boolean = false, commandKey:Boolean = false, controlKey:Boolean = false)
public function ZoomGestureEvent(type:String, bubbles:Boolean = false, cancelable:Boolean = false, phase:String = null, localX:Number = 0, localY:Number = 0, scaleX:Number = 1, scaleY:Number = 1)
{
super(type, bubbles, cancelable, phase, localX, localY, scaleX, scaleY, rotation, offsetX, offsetY, ctrlKey, altKey, shiftKey);
super(type, bubbles, cancelable, phase, localX, localY, scaleX, scaleY);
}
override public function clone():Event
{
return new ZoomGestureEvent(type, bubbles, cancelable, phase, localX, localY, scaleX, scaleY);
}
override public function toString():String
{
return super.toString().replace("TransformGestureEvent", "ZoomGestureEvent");
}
}
}

226
src/org/gestouch/gestures/DoubleTapGesture.as
View file

@ -1,226 +0,0 @@
package org.gestouch.gestures
{
import org.gestouch.core.GesturesManager;
import org.gestouch.core.TouchPoint;
import org.gestouch.core.gestouch_internal;
import org.gestouch.events.DoubleTapGestureEvent;
import flash.display.InteractiveObject;
import flash.events.GesturePhase;
import flash.events.TimerEvent;
import flash.geom.Point;
import flash.utils.Timer;
[Event(name="gestureDoubleTap", type="org.gestouch.events.DoubleTapGestureEvent")]
/**
* DoubleTapGesture tracks quick double-tap (double-click).
*
* <p>Gesture-specific configuratin properties:<br/><br/>
* timeThreshold — time between first touchBegin and second touchEnd events,<br/><br/>
* moveThreshold — maximum allowed distance between two taps.</p>
*
*
* @author Pavel fljot
*/
public class DoubleTapGesture extends Gesture
{
/**
* Time in milliseconds between touchBegin and touchEnd events for gesture to be detected.
*
* <p>For multitouch usage this is a bit more complex then "first touchBeing and second touchEnd":
* Taps are counted once <code>minTouchPointsCount</code> of touch points are down and then fully released.
* So it's time in milliseconds between full press and full release events for gesture to be detected.</p>
*
* @default 400
*/
public var timeThreshold:uint = 400;
/**
* Maximum allowed distance between two taps for gesture to be detected.
*
* @default Gesture.DEFAULT_SLOP &#42; 3
*
* @see org.gestouch.gestures.Gesture#DEFAULT_SLOP
*/
public var moveThreshold:Number = Gesture.DEFAULT_SLOP * 3;
/**
* Timer used to track time between taps.
*/
protected var _thresholdTimer:Timer;
/**
* Count taps (where tap is an action of changing _touchPointsCount from 0 to minTouchPointsCount
* and back to 0. For single touch gesture it would be common tap, for 2-touch gesture it would be
* both fingers down, then both fingers up, etc...)
*/
protected var _tapCounter:int = 0;
/**
* Flag to detect "complex tap".
*/
protected var _minTouchPointsCountReached:Boolean;
/**
* Used to check moveThreshold.
*/
protected var _prevCentralPoint:Point;
/**
* Used to check moveThreshold.
*/
protected var _lastCentralPoint:Point;
public function DoubleTapGesture(target:InteractiveObject = null, settings:Object = null)
{
super(target, settings);
}
//--------------------------------------------------------------------------
//
// Static methods
//
//--------------------------------------------------------------------------
public static function add(target:InteractiveObject, settings:Object = null):DoubleTapGesture
{
return new DoubleTapGesture(target, settings);
}
public static function remove(target:InteractiveObject):DoubleTapGesture
{
return GesturesManager.gestouch_internal::removeGestureByTarget(DoubleTapGesture, target) as DoubleTapGesture;
}
//--------------------------------------------------------------------------
//
// Public methods
//
//--------------------------------------------------------------------------
override public function reflect():Class
{
return DoubleTapGesture;
}
override public function onTouchBegin(touchPoint:TouchPoint):void
{
// No need to track more points than we need
if (_trackingPointsCount == maxTouchPointsCount)
{
return;
}
_trackPoint(touchPoint);
if (_trackingPointsCount == minTouchPointsCount)
{
if (!_thresholdTimer.running)
{
// first touchBegin combo (all the required fingers are on the screen)
_tapCounter = 0;
_thresholdTimer.reset();
_thresholdTimer.delay = timeThreshold;
_thresholdTimer.start();
_updateCentralPoint();
}
_minTouchPointsCountReached = true;
if (moveThreshold > 0)
{
// calculate central point for future moveThreshold comparsion
_updateCentralPoint();
// save points for later comparsion with moveThreshold
_prevCentralPoint = _lastCentralPoint;
_lastCentralPoint = _centralPoint.clone();
}
}
}
override public function onTouchMove(touchPoint:TouchPoint):void
{
// nothing to do here
}
override public function onTouchEnd(touchPoint:TouchPoint):void
{
// As we a here, this means timer hasn't fired yet (and therefore hasn't cancelled this gesture)
_forgetPoint(touchPoint);
// if last finger released
if (_trackingPointsCount == 0)
{
if (_minTouchPointsCountReached)
{
_tapCounter++;
// reset for next "all fingers down"
_minTouchPointsCountReached = false;
}
if (_tapCounter >= 2)
{
// double tap combo recognized
if ((moveThreshold > 0 && _lastCentralPoint.subtract(_prevCentralPoint).length < moveThreshold)
|| isNaN(moveThreshold) || moveThreshold <= 0)
{
_reset();
_dispatch(new DoubleTapGestureEvent(DoubleTapGestureEvent.GESTURE_DOUBLE_TAP, true, false, GesturePhase.ALL, _lastLocalCentralPoint.x, _lastLocalCentralPoint.y));
}
}
}
}
//--------------------------------------------------------------------------
//
// Protected methods
//
//--------------------------------------------------------------------------
override protected function _preinit():void
{
super._preinit();
_thresholdTimer = new Timer(timeThreshold, 1);
_thresholdTimer.addEventListener(TimerEvent.TIMER_COMPLETE, _thresholdTimer_timerCompleteHandler);
_propertyNames.push("timeThreshold", "moveThreshold");
}
override protected function _reset():void
{
super._reset();
_tapCounter = 0;
_minTouchPointsCountReached = false;
_thresholdTimer.reset();
}
//--------------------------------------------------------------------------
//
// Event handlers
//
//--------------------------------------------------------------------------
protected function _thresholdTimer_timerCompleteHandler(event:TimerEvent):void
{
cancel();
}
}
}

145
src/org/gestouch/gestures/DragGesture.as
View file

@ -1,145 +0,0 @@
package org.gestouch.gestures
{
import org.gestouch.core.GesturesManager;
import org.gestouch.core.TouchPoint;
import org.gestouch.core.gestouch_internal;
import org.gestouch.events.DragGestureEvent;
import flash.display.InteractiveObject;
import flash.events.GesturePhase;
import flash.geom.Point;
[Event(name="gestureDrag", type="org.gestouch.events.DragGestureEvent")]
/**
* Tracks the drag. Event works nice with minTouchPointsCount = 1 and maxTouchPoaintsCount > 1.
*
* <p>DragGestureEvent has 3 possible phases: GesturePhase.BEGIN, GesturePhase.UPDATE, GesturePhase.END</p>
*
* @see org.gestouch.events.DragGestureEvent
* @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/events/GestureEvent.html#phase
* @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/events/GesturePhase.html
*
* @author Pavel fljot
*/
public class DragGesture extends MovingGestureBase
{
public function DragGesture(target:InteractiveObject = null, settings:Object = null)
{
super(target, settings);
}
//--------------------------------------------------------------------------
//
// Static methods
//
//--------------------------------------------------------------------------
public static function add(target:InteractiveObject, settings:Object = null):DragGesture
{
return new DragGesture(target, settings);
}
public static function remove(target:InteractiveObject):DragGesture
{
return GesturesManager.gestouch_internal::removeGestureByTarget(DragGesture, target) as DragGesture;
}
//--------------------------------------------------------------------------
//
// Public methods
//
//--------------------------------------------------------------------------
override public function reflect():Class
{
return DragGesture;
}
override public function onTouchBegin(touchPoint:TouchPoint):void
{
// No need to track more points than we need
if (_trackingPointsCount == maxTouchPointsCount)
{
return;
}
_trackPoint(touchPoint);
if (_trackingPointsCount > 1)
{
_updateCentralPoint();
_centralPoint.lastMove.x = _centralPoint.lastMove.y = 0;
}
}
override public function onTouchMove(touchPoint:TouchPoint):void
{
// do calculations only when we track enough points
if (_trackingPointsCount < minTouchPointsCount)
{
return;
}
_updateCentralPoint();
if (!_slopPassed)
{
_slopPassed = _checkSlop(_centralPoint.moveOffset);
if (_slopPassed)
{
var slopVector:Point = slop > 0 ? null : new Point();
if (!slopVector)
{
if (_canMoveHorizontally && _canMoveVertically)
{
slopVector = _centralPoint.moveOffset.clone();
slopVector.normalize(slop);
slopVector.x = Math.round(slopVector.x);
slopVector.y = Math.round(slopVector.y);
}
else if (_canMoveVertically)
{
slopVector = new Point(0, _centralPoint.moveOffset.y >= slop ? slop : -slop);
}
else if (_canMoveHorizontally)
{
slopVector = new Point(_centralPoint.moveOffset.x >= slop ? slop : -slop, 0);
}
}
_centralPoint.lastMove = _centralPoint.moveOffset.subtract(slopVector);
_dispatch(new DragGestureEvent(DragGestureEvent.GESTURE_DRAG, true, false, GesturePhase.BEGIN, _lastLocalCentralPoint.x, _lastLocalCentralPoint.y, 1, 1, 0, _centralPoint.lastMove.x, _centralPoint.lastMove.y));
}
}
else
{
_dispatch(new DragGestureEvent(DragGestureEvent.GESTURE_DRAG, true, false, GesturePhase.UPDATE, _lastLocalCentralPoint.x, _lastLocalCentralPoint.y, 1, 1, 0, _centralPoint.lastMove.x, _centralPoint.lastMove.y));
}
}
override public function onTouchEnd(touchPoint:TouchPoint):void
{
var ending:Boolean = (_slopPassed && _trackingPointsCount == minTouchPointsCount);
_forgetPoint(touchPoint);
_updateCentralPoint();
if (ending)
{
_reset();
_dispatch(new DragGestureEvent(DragGestureEvent.GESTURE_DRAG, true, false, GesturePhase.END, _lastLocalCentralPoint.x, _lastLocalCentralPoint.y, 1, 1, 0, 0, 0));
}
}
}
}

618
src/org/gestouch/gestures/Gesture.as
View file

@ -1,14 +1,17 @@
package org.gestouch.gestures
{
import org.gestouch.core.GestureState;
import org.gestouch.core.GesturesManager;
import org.gestouch.core.IGesture;
import org.gestouch.core.TouchPoint;
import org.gestouch.core.IGestureDelegate;
import org.gestouch.core.IGesturesManager;
import org.gestouch.core.ITouchesManager;
import org.gestouch.core.Touch;
import org.gestouch.core.TouchesManager;
import org.gestouch.core.gestouch_internal;
import org.gestouch.events.GestureTrackingEvent;
import org.gestouch.events.GestureStateEvent;
import flash.display.DisplayObjectContainer;
import flash.display.InteractiveObject;
import flash.errors.IllegalOperationError;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.GestureEvent;
import flash.events.TouchEvent;
@ -16,15 +19,19 @@ package org.gestouch.gestures
import flash.system.Capabilities;
[Event(name="gestureTrackingBegin", type="org.gestouch.events.GestureTrackingEvent")]
[Event(name="gestureTrackingEnd", type="org.gestouch.events.GestureTrackingEvent")]
// [Event(name="gestureTrackingBegin", type="org.gestouch.events.GestureTrackingEvent")]
// [Event(name="gestureTrackingEnd", type="org.gestouch.events.GestureTrackingEvent")]
[Event(name="stateChange", type="org.gestouch.events.GestureStateEvent")]
/**
* Base class for all gestures. Gesture is essentially a detector that tracks touch points
* in order detect specific gesture motion and form gesture event on target.
*
* TODO: locationOfTouchPoint(touchPointID):Point
* - ignoreTouch(touch:Touch, event:TouchEvent) ?
*
* @author Pavel fljot
*/
public class Gesture extends EventDispatcher implements IGesture
public class Gesture extends EventDispatcher
{
/**
* Threshold for screen distance they must move to count as valid input
@ -32,82 +39,28 @@ package org.gestouch.gestures
* based on 20 pixels on a 252ppi device.
*/
public static const DEFAULT_SLOP:uint = Math.round(20 / 252 * flash.system.Capabilities.screenDPI);
public static const TOUCH_EVENT_CAPTURE_PRIORITY:int = 10;
/**
* Array of configuration properties (Strings).
*/
protected var _propertyNames:Array = ["minTouchPointsCount", "maxTouchPointsCount"];
public var delegate:IGestureDelegate;
protected const _touchesManager:ITouchesManager = TouchesManager.getInstance();
protected const _gesturesManager:IGesturesManager = GesturesManager.getInstance();
/**
* Map (generic object) of tracking touch points, where keys are touch points IDs.
*/
protected var _trackingPointsMap:Object = {};
protected var _trackingPointsCount:int = 0;
protected var _firstTouchPoint:TouchPoint;
protected var _lastLocalCentralPoint:Point;
protected var _touchesMap:Object = {};
protected var _centralPoint:Point = new Point();
protected var _localLocation:Point;
public function Gesture(target:InteractiveObject = null, settings:Object = null)
public function Gesture(target:InteractiveObject = null)
{
// Check if gesture reflects it's class properly
reflect();
_preinit();
super();
GesturesManager.gestouch_internal::addGesture(this);
preinit();
this.target = target;
if (settings != null)
{
_parseSettings(settings);
}
}
/** @private */
private var _minTouchPointsCount:uint = 1;
/**
* Minimum amount of touch points required for gesture.
*
* @default 1
*/
public function get minTouchPointsCount():uint
{
return _minTouchPointsCount;
}
public function set minTouchPointsCount(value:uint):void
{
if (_minTouchPointsCount == value) return;
_minTouchPointsCount = value;
if (maxTouchPointsCount < minTouchPointsCount)
{
maxTouchPointsCount = minTouchPointsCount;
}
}
/** @private */
private var _maxTouchPointsCount:uint = 1;
/**
* Maximum amount of touch points required for gesture.
*
* @default 1
*/
public function get maxTouchPointsCount():uint
{
return _maxTouchPointsCount;
}
public function set maxTouchPointsCount(value:uint):void
{
if (value < minTouchPointsCount)
{
throw new IllegalOperationError("maxTouchPointsCount can not be less then minTouchPointsCount");
}
if (_maxTouchPointsCount == value) return;
_maxTouchPointsCount = value;
}
@ -131,22 +84,19 @@ package org.gestouch.gestures
}
public function set target(value:InteractiveObject):void
{
if (target == value) return;
if (_target == value)
return;
GesturesManager.gestouch_internal::updateGestureTarget(this, target, value);
// if GesturesManager hasn't thrown any error we can safely continue
_uninstallTarget(target);
uninstallTarget(target);
_target = value;
_installTarget(target);
installTarget(target);
}
/** @private */
private var _enabled:Boolean = true;
protected var _enabled:Boolean = true;
/**
/**
* @default true
*/
public function get enabled():Boolean
@ -155,70 +105,68 @@ package org.gestouch.gestures
}
public function set enabled(value:Boolean):void
{
if (_enabled == value) return;
if (_enabled == value)
return;
_enabled = value;
if (!_enabled && trackingPointsCount > 0)
//TODO
if (!_enabled && touchesCount > 0)
{
cancel();
setState(GestureState.CANCELLED);
reset();
}
}
/**
* Storage for the trackingPoints property.
*/
protected var _trackingPoints:Vector.<TouchPoint> = new Vector.<TouchPoint>();
/**
* Vector of tracking touch points — touch points this gesture is interested in.
*
* <p>For the most gestures these points are which on top of the target.</p>
*
* @see #isTracking()
* @see #shouldTrackPoint()
*/
public function get trackingPoints():Vector.<TouchPoint>
protected var _state:uint = GestureState.POSSIBLE;
public function get state():uint
{
return _trackingPoints.concat();
return _state;
}
protected var _touchesCount:uint = 0;
/**
* Amount of currently tracked touch points. Cached value of trackingPoints.length
* Amount of currently tracked touch points.
*
* @see #trackingPoints
* @see #_touches
*/
public function get trackingPointsCount():uint
public function get touchesCount():uint
{
return _trackingPointsCount;
return _touchesCount;
}
/**
* Storage for centralPoint property.
*/
protected var _centralPoint:TouchPoint;
protected var _location:Point = new Point();
/**
* Virtual central touch point among all tracking touch points (geometrical center).
*
* <p>Designed for multitouch gestures, where center could be used for
* approximation or anchor. Use _adjustCentralPoint() method for updating centralPoint.</p>
*
* @see #_adjustCentralPoint()
*/
public function get centralPoint():TouchPoint
public function get location():Point
{
return _centralPoint;
//TODO: to clone or not clone? performance & convention or ...
return _location.clone();
}
//--------------------------------------------------------------------------
//
// Public methods
//
//--------------------------------------------------------------------------
override public function dispatchEvent(event:Event):Boolean
{
if (hasEventListener(event.type))
{
return super.dispatchEvent(event);
}
return true;
}
[Abstract]
/**
* Reflects gesture class (for better perfomance).
@ -233,44 +181,9 @@ package org.gestouch.gestures
}
/**
* Used by GesturesManager to check wether this gesture is interested in
* tracking this touch point upon this event (of type TouchEvent.TOUCH_BEGIN).
*
* <p>Most of the gestures check, if event.target is target or target contains event.target.</p>
*
* <p>No need to use it directly.</p>
*
* @see org.gestouch.core.GesturesManager
* @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/events/TouchEvent.html
*/
public function shouldTrackPoint(event:TouchEvent, tp:TouchPoint):Boolean
public function isTrackingTouch(touchID:uint):Boolean
{
// No need to track more points than we need
if (_trackingPointsCount == maxTouchPointsCount)
{
return false;
}
//By default gesture is interested only in those touchpoints on top of target
var touchTarget:InteractiveObject = event.target as InteractiveObject;
if (touchTarget != target && !(target is DisplayObjectContainer && (target as DisplayObjectContainer).contains(touchTarget)))
{
return false;
}
return true;
}
/**
* Used by GesturesManager to check wether this gesture is tracking this touch point.
* (Not to invoke onTouchBegin, onTouchMove and onTouchEnd methods with no need)
*
* @see org.gestouch.core.GesturesManager
*/
public function isTracking(touchPointID:uint):Boolean
{
return (_trackingPointsMap[touchPointID] === true);
return (_touchesMap[touchID] != undefined);
}
@ -279,23 +192,15 @@ package org.gestouch.gestures
*
* <p>Could be useful to "stop" gesture for the current interaction cycle.</p>
*/
public function cancel():void
public function reset():void
{
GesturesManager.gestouch_internal::cancelGesture(this);
}
/**
* TODO: write description, decide wethere this API is good.
*/
public function pickAndContinue(gesture:IGesture):void
{
GesturesManager.gestouch_internal::addCurrentGesture(this);
//TODO
_location.x = 0;
_location.y = 0;
_touchesMap = {};
_touchesCount = 0;
for each (var tp:TouchPoint in gesture.trackingPoints)
{
onTouchBegin(tp);
}
setState(GestureState.POSSIBLE);
}
@ -306,69 +211,30 @@ package org.gestouch.gestures
*/
public function dispose():void
{
_reset();
//TODO
reset();
target = null;
try
{
GesturesManager.gestouch_internal::removeGesture(this);
}
catch (err:Error)
{
// do nothing
// GesturesManager may throw Error if this gesture is already removed:
// in case dispose() is called by GesturesManager upon GestureClass.remove(target)
// this part smells a bit, eh?
}
}
[Abstract]
/**
* Internal method, used by GesturesManager.
*
* <p><b>NB!</b> This is abstract method and must be overridden.</p>
*/
public function onTouchBegin(touchPoint:TouchPoint):void
public function canBePreventedByGesture(preventingGesture:Gesture):Boolean
{
return true;
}
[Abstract]
/**
* Internal method, used by GesturesManager.
*
* <p><b>NB!</b> This is abstract method and must be overridden.</p>
*/
public function onTouchMove(touchPoint:TouchPoint):void
public function canPreventGesture(preventedGesture:Gesture):Boolean
{
return true;
}
[Abstract]
/**
* Internal method, used by GesturesManager.
*
* <p><b>NB!</b> This is abstract method and must be overridden.</p>
*/
public function onTouchEnd(touchPoint:TouchPoint):void
public function requireGestureToFail(gesture:Gesture):void
{
//TODO
}
/**
* Internal method, used by GesturesManager. Called upon gesture is cancelled.
*
* @see #cancel()
*/
public function onCancel():void
{
_reset();
}
// --------------------------------------------------------------------------
@ -379,14 +245,8 @@ package org.gestouch.gestures
/**
* First method, called in constructor.
*
* <p>Good place to put gesture configuration related code. For example (abstract):</p>
* <listing version="3.0">
minTouchPointsCount = 2;
_propertyNames.push("timeThreshold", "moveThreshold");
* </listing>
*/
protected function _preinit():void
protected function preinit():void
{
}
@ -396,214 +256,188 @@ _propertyNames.push("timeThreshold", "moveThreshold");
*
* @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/InteractiveObject.html
*/
protected function _installTarget(target:InteractiveObject):void
protected function installTarget(target:InteractiveObject):void
{
if (target)
{
_gesturesManager.addGesture(this);
}
}
/**
* Called internally when changing the target.
*
* <p>You should remove all listeners from target here.</p>
*
* @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/InteractiveObject.html
*/
protected function _uninstallTarget(target:InteractiveObject):void
protected function uninstallTarget(target:InteractiveObject):void
{
if (target)
{
_gesturesManager.removeGesture(this);
}
}
/**
* Dispatches gesture event on gesture and on target.
*
* <p>Why dispatching event on gesture? Because it make sense to dispatch event from
* detector object (gesture) and we can add [Event] metatag for better autocompletion.</p>
*
* <p>Why dispatching event on target? Becase it supposed to be like this in
* comparsion to native way, and it also make sense as similar to mouse and touch events.</p>
*
* @param event GestureEvent to be dispatched
*
* @see http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/events/GestureEvent.html
* TODO: clarify usage. For now it's supported to call this method in onTouchBegin with return.
*/
protected function _dispatch(event:GestureEvent):void
protected function ignoreTouch(touch:Touch, event:TouchEvent):void
{
if (hasEventListener(event.type))
if (_touchesMap.hasOwnProperty(touch.id))
{
delete _touchesMap[touch.id];
_touchesCount--;
}
}
[Abstract]
/**
* Internal method, used by GesturesManager.
*
* <p><b>NB!</b> This is abstract method and must be overridden.</p>
*/
protected function onTouchBegin(touch:Touch, event:TouchEvent):void
{
}
[Abstract]
/**
* Internal method, used by GesturesManager.
*
* <p><b>NB!</b> This is abstract method and must be overridden.</p>
*/
protected function onTouchMove(touch:Touch, event:TouchEvent):void
{
}
[Abstract]
/**
* Internal method, used by GesturesManager.
*
* <p><b>NB!</b> This is abstract method and must be overridden.</p>
*/
protected function onTouchEnd(touch:Touch, event:TouchEvent):void
{
}
protected function setState(newState:uint, event:GestureEvent = null):void
{
if (_state == newState)
{
if (_state == GestureState.CHANGED && event)
{
dispatchEvent(event);
}
return;
}
//TODO: is state sequence validation needed? e.g.:
//POSSIBLE should be followed by BEGAN or RECOGNIZED or FAILED
//BEGAN should be follwed by CHANGED or ENDED or CANCELLED
//CHANGED should be followed by CHANGED or ENDED or CANCELLED
//...
if (newState == GestureState.BEGAN || newState == GestureState.RECOGNIZED)
{
if (delegate && !delegate.gestureShouldBegin(this))
{
setState(GestureState.FAILED);
return;
}
}
var oldState:uint = _state;
_state = newState;
if (((GestureState.CANCELLED | GestureState.RECOGNIZED | GestureState.ENDED | GestureState.FAILED) & _state) > 0)
{
_gesturesManager.scheduleGestureStateReset(this);
}
//TODO: what if RTE happens in event handlers?
dispatchEvent(new GestureStateEvent(GestureStateEvent.STATE_CHANGE, _state, oldState));
if (event)
{
dispatchEvent(event);
}
// event is almost always bubbles, so no point for optimization
target.dispatchEvent(event);
}
/**
* Parses settings and configures the gesture.
*
* @param settings Generic object with configuration properties
*/
protected function _parseSettings(settings:Object):void
{
for each (var propertyName:String in _propertyNames)
if (_state == GestureState.BEGAN || _state == GestureState.RECOGNIZED)
{
if (settings.hasOwnProperty(propertyName))
{
this[propertyName] = settings[propertyName];
}
_gesturesManager.onGestureRecognized(this);
}
}
/**
* Saves touchPoint for tracking for the current gesture cycle.
*
* <p>If this is the first touch point, it updates _firstTouchPoint and _centralPoint.</p>
*
* @see #_firstTouchPoint
* @see #centralPoint
* @see #trackingPointsCount
*/
protected function _trackPoint(touchPoint:TouchPoint):void
gestouch_internal function setState_internal(state:uint):void
{
_trackingPointsMap[touchPoint.id] = true;
var index:uint = _trackingPoints.push(touchPoint);
_trackingPointsCount++;
if (index == 1)
{
_firstTouchPoint = touchPoint;
_centralPoint = touchPoint.clone() as TouchPoint;
}
else if (_trackingPointsCount == minTouchPointsCount)
{
_updateCentralPoint();
_centralPoint.touchBeginPos.x = _centralPoint.x;
_centralPoint.touchBeginPos.y = _centralPoint.y;
_centralPoint.moveOffset.x = 0;
_centralPoint.moveOffset.y = 0;
_centralPoint.lastMove.x = 0;
_centralPoint.lastMove.y = 0;
}
else if (_trackingPointsCount > minTouchPointsCount)
{
_adjustCentralPoint();
}
if (_trackingPointsCount == minTouchPointsCount)
{
if (hasEventListener(GestureTrackingEvent.GESTURE_TRACKING_BEGIN))
{
dispatchEvent(new GestureTrackingEvent(GestureTrackingEvent.GESTURE_TRACKING_BEGIN));
}
}
setState(state);
}
/**
* Removes touchPoint from the list of tracking points.
*
* <p>If this is the first touch point, it updates _firstTouchPoint and _centralPoint.</p>
*
* @see #trackingPoints
* @see #_trackingPointsMap
* @see #trackingPointsCount
*/
protected function _forgetPoint(touchPoint:TouchPoint):void
{
delete _trackingPointsMap[touchPoint.id];
_trackingPoints.splice(_trackingPoints.indexOf(touchPoint), 1);
_trackingPointsCount--;
_adjustCentralPoint();
if (_trackingPointsCount == minTouchPointsCount - 1)
{
if (hasEventListener(GestureTrackingEvent.GESTURE_TRACKING_END))
{
dispatchEvent(new GestureTrackingEvent(GestureTrackingEvent.GESTURE_TRACKING_END));
}
}
}
/**
* Updates _centralPoint and all it's properties
* (such as positions, offsets, velocity, etc...).
* Also updates _lastLocalCentralPoint (used for dispatching events).
*
* @see #centralPoint
* @see #_lastLocalCentralPoint
* @see #trackingPoints
*/
protected function _updateCentralPoint():void
protected function updateCentralPoint():void
{
var touch:Touch;
var x:Number = 0;
var y:Number = 0;
var velX:Number = 0;
var velY:Number = 0;
for each (var tp:TouchPoint in _trackingPoints)
for (var touchID:String in _touchesMap)
{
x += tp.x;
y += tp.y;
velX += tp.velocity.x;
velY += tp.velocity.y;
touch = _touchesMap[int(touchID)] as Touch;
x += touch.x;
y += touch.y;
}
x /= _trackingPointsCount;
y /= _trackingPointsCount;
var lastMoveX:Number = x - _centralPoint.x;
var lastMoveY:Number = y - _centralPoint.y;
velX /= _trackingPointsCount;
velY /= _trackingPointsCount;
_centralPoint.x = x;
_centralPoint.y = y;
_centralPoint.lastMove.x = lastMoveX;
_centralPoint.lastMove.y = lastMoveY;
_centralPoint.velocity.x = velX;
_centralPoint.velocity.y = velY;
// tp.moveOffset = tp.subtract(tp.touchBeginPos);
_centralPoint.moveOffset.x = x - _centralPoint.touchBeginPos.x;
_centralPoint.moveOffset.y = y - _centralPoint.touchBeginPos.y;
_lastLocalCentralPoint = target.globalToLocal(_centralPoint);
}
protected function _adjustCentralPoint():void
{
var oldCentralPoint:TouchPoint = _centralPoint.clone() as TouchPoint;
_updateCentralPoint();
var centralPointChange:Point = _centralPoint.subtract(oldCentralPoint);
_centralPoint.touchBeginPos = _centralPoint.touchBeginPos.add(centralPointChange);
// fix moveOffset according to fixed touchBeginPos
_centralPoint.moveOffset.x = _centralPoint.x - _centralPoint.touchBeginPos.x;
_centralPoint.moveOffset.y = _centralPoint.y - _centralPoint.touchBeginPos.y;
// restore original lastMove
_centralPoint.lastMove.x = oldCentralPoint.lastMove.x;
_centralPoint.lastMove.y = oldCentralPoint.lastMove.y;
// faster then Math.round(x / _touchesCount)
_centralPoint.x = x > 0 ? (x / _touchesCount + 0.5) >> 0 : (x / _touchesCount - 0.5) >> 0;
_centralPoint.y = y > 0 ? (y / _touchesCount + 0.5) >> 0 : (y / _touchesCount - 0.5) >> 0;
}
/**
* Reset data for the current tracking (interaction) cycle.
*
* <p>Clears up _trackingPointsMap, _trackingPoints, _trackingPointsCount
* and other custom gestures-specific things.</p>
*
* <p>Generally invoked in onCancel method and when certain conditions of gesture
* have been failed and gesture doesn't need to continue processsing
* (e.g. timer has completed in DoubleTapGesture)</p>
*
* @see #trackingPoints
* @see #trackingPointsCount
* @see #onCancel()
*/
protected function _reset():void
protected function updateLocation():void
{
// forget all touch points
_trackingPointsMap = {};
_trackingPoints.length = 0;
_trackingPointsCount = 0;
updateCentralPoint();
_location.x = _centralPoint.x;
_location.y = _centralPoint.y;
_localLocation = target.globalToLocal(_location);
}
//--------------------------------------------------------------------------
//
// Event handlers
//
//--------------------------------------------------------------------------
gestouch_internal function touchBeginHandler(touch:Touch, event:TouchEvent):void
{
_touchesMap[touch.id] = touch;
_touchesCount++;
onTouchBegin(touch, event);
}
gestouch_internal function touchMoveHandler(touch:Touch, event:TouchEvent):void
{
_touchesMap[touch.id] = touch;
onTouchMove(touch, event);
}
gestouch_internal function touchEndHandler(touch:Touch, event:TouchEvent):void
{
delete _touchesMap[touch.id];
_touchesCount--;
onTouchEnd(touch, event);
}
}
}

208
src/org/gestouch/gestures/LongPressGesture.as
View file

@ -1,149 +1,162 @@
package org.gestouch.gestures
{
import org.gestouch.core.GesturesManager;
import org.gestouch.core.TouchPoint;
import org.gestouch.core.gestouch_internal;
import org.gestouch.core.GestureState;
import org.gestouch.core.Touch;
import org.gestouch.events.LongPressGestureEvent;
import flash.display.InteractiveObject;
import flash.events.GesturePhase;
import flash.events.TimerEvent;
import flash.events.TouchEvent;
import flash.utils.Timer;
[Event(name="gestureLongPress", type="org.gestouch.events.LongPressGestureEvent")]
/**
*
* TODO: -location
* - check on iOS (Obj-C) what happens when numTouchesRequired=2, two finger down, then quickly release one.
*
* @author Pavel fljot
*/
public class LongPressGesture extends Gesture
{
public var numTouchesRequired:uint = 1;
/**
* Default value 1000ms
*/
public var timeThreshold:uint = 500;
/**
* Deafult value is Gesture.DEFAULT_SLOP
* @see org.gestouchers.core.Gesture#DEFAULT_SLOP
*/
* The minimum time interval in millisecond fingers must press on the target for the gesture to be recognized.
*
* @default 500
*/
public var minPressDuration:uint = 500;
public var slop:Number = Gesture.DEFAULT_SLOP;
protected var _thresholdTimer:Timer;
protected var _timer:Timer;
protected var _touchBeginX:Array = [];
protected var _touchBeginY:Array = [];
protected var _numTouchesRequiredReached:Boolean;
public function LongPressGesture(target:InteractiveObject = null, settings:Object = null)
public function LongPressGesture(target:InteractiveObject = null)
{
super(target, settings);
super(target);
}
//--------------------------------------------------------------------------
// --------------------------------------------------------------------------
//
// Static methods
// Public methods
//
//--------------------------------------------------------------------------
public static function add(target:InteractiveObject, settings:Object = null):LongPressGesture
{
return new LongPressGesture(target, settings);
}
public static function remove(target:InteractiveObject):LongPressGesture
{
return GesturesManager.gestouch_internal::removeGestureByTarget(LongPressGesture, target) as LongPressGesture;
}
//--------------------------------------------------------------------------
//
// Public methods
//
//--------------------------------------------------------------------------
// --------------------------------------------------------------------------
override public function reflect():Class
{
return LongPressGesture;
return TapGesture;
}
override public function reset():void
{
super.reset();
_touchBeginX.length = 0;
_touchBeginY.length = 0;
_numTouchesRequiredReached = false;
_timer.reset();
}
override public function onTouchBegin(touchPoint:TouchPoint):void
// --------------------------------------------------------------------------
//
// Protected methods
//
// --------------------------------------------------------------------------
override protected function preinit():void
{
// No need to track more points than we need
if (_trackingPointsCount == maxTouchPointsCount)
super.preinit();
_timer = new Timer(minPressDuration, 1);
_timer.addEventListener(TimerEvent.TIMER_COMPLETE, timer_timerCompleteHandler);
}
override protected function onTouchBegin(touch:Touch, event:TouchEvent):void
{
if (touchesCount > numTouchesRequired)
{
if (state == GestureState.BEGAN || state == GestureState.CHANGED)
{
ignoreTouch(touch, event);
}
else
{
setState(GestureState.FAILED);
}
return;
}
_trackPoint(touchPoint);
_touchBeginX[touch.id] = touch.x;
_touchBeginY[touch.id] = touch.y;
if (_trackingPointsCount == minTouchPointsCount)
if (touchesCount == numTouchesRequired)
{
_thresholdTimer.reset();
_thresholdTimer.delay = timeThreshold;
_thresholdTimer.start();
}
}
override public function onTouchMove(touchPoint:TouchPoint):void
{
// faster isNaN
if (_thresholdTimer.currentCount == 0 && slop == slop)
{
if (touchPoint.moveOffset.length > slop)
_numTouchesRequiredReached = true;
_timer.reset();
_timer.delay = minPressDuration;
if (minPressDuration > 0)
{
cancel();
_timer.start();
}
else
{
timer_timerCompleteHandler();
}
}
}
override public function onTouchEnd(touchPoint:TouchPoint):void
{
_forgetPoint(touchPoint);
var held:Boolean = (_thresholdTimer.currentCount > 0);
_thresholdTimer.reset();
if (held)
override protected function onTouchMove(touch:Touch, event:TouchEvent):void
{
if (state == GestureState.POSSIBLE && slop > 0)
{
_updateCentralPoint();
_reset();
_dispatch(new LongPressGestureEvent(LongPressGestureEvent.GESTURE_LONG_PRESS, true, false, GesturePhase.END, _lastLocalCentralPoint.x, _lastLocalCentralPoint.y));
// Fail if touch overcome slop distance
var dx:Number = Number(_touchBeginX[touch.id]) - touch.x;
var dy:Number = Number(_touchBeginY[touch.id]) - touch.y;
if (Math.sqrt(dx*dx + dy*dy) > slop)
{
setState(GestureState.FAILED);
return;
}
}
else if (state == GestureState.BEGAN || state == GestureState.CHANGED)
{
updateLocation();
setState(GestureState.CHANGED, new LongPressGestureEvent(LongPressGestureEvent.GESTURE_LONG_PRESS, false, false, GesturePhase.UPDATE, _localLocation.x, _localLocation.y));
}
}
//--------------------------------------------------------------------------
//
// Protected methods
//
//--------------------------------------------------------------------------
override protected function _preinit():void
override protected function onTouchEnd(touch:Touch, event:TouchEvent):void
{
super._preinit();
_thresholdTimer = new Timer(timeThreshold, 1);
_thresholdTimer.addEventListener(TimerEvent.TIMER_COMPLETE, _onThresholdTimerComplete);
_propertyNames.push("timeThreshold", "slop");
}
override protected function _reset():void
{
super._reset();
_thresholdTimer.reset();
//TODO: check proper condition (behavior) on iOS native
if (_numTouchesRequiredReached)
{
if (((GestureState.BEGAN | GestureState.CHANGED) & state) > 0)
{
updateLocation();
setState(GestureState.ENDED, new LongPressGestureEvent(LongPressGestureEvent.GESTURE_LONG_PRESS, false, false, GesturePhase.END, _localLocation.x, _localLocation.y));
}
else
{
setState(GestureState.FAILED);
}
}
else
{
setState(GestureState.FAILED);
}
}
@ -154,11 +167,14 @@ package org.gestouch.gestures
// Event handlers
//
//--------------------------------------------------------------------------
protected function _onThresholdTimerComplete(event:TimerEvent):void
protected function timer_timerCompleteHandler(event:TimerEvent = null):void
{
_updateCentralPoint();
_dispatch(new LongPressGestureEvent(LongPressGestureEvent.GESTURE_LONG_PRESS, true, false, GesturePhase.BEGIN, _lastLocalCentralPoint.x, _lastLocalCentralPoint.y));
if (state == GestureState.POSSIBLE)
{
updateLocation();
setState(GestureState.BEGAN, new LongPressGestureEvent(LongPressGestureEvent.GESTURE_LONG_PRESS, false, false, GesturePhase.BEGIN, _localLocation.x, _localLocation.y));
}
}
}
}

178
src/org/gestouch/gestures/MovingGestureBase.as
View file

@ -1,178 +0,0 @@
package org.gestouch.gestures
{
import flash.display.InteractiveObject;
import flash.geom.Point;
import org.gestouch.Direction;
/**
* Base class for those gestures where you have to move finger/mouse,
* i.e. DragGesture, SwipeGesture
*
* @author Pavel fljot
*/
public class MovingGestureBase extends Gesture
{
/**
* Threshold for screen distance they must move to count as valid input
* (not an accidental offset on touch). Once this distance is passed,
* gesture starts more intensive and specific processing in onTouchMove() method.
*
* @default Gesture.DEFAULT_SLOP
*
* @see org.gestouch.gestures.Gesture#DEFAULT_SLOP
*/
public var slop:Number = Gesture.DEFAULT_SLOP;
protected var _slopPassed:Boolean = false;
protected var _canMoveHorizontally:Boolean = true;
protected var _canMoveVertically:Boolean = true;
public function MovingGestureBase(target:InteractiveObject = null, settings:Object = null)
{
super(target, settings);
if (reflect() == MovingGestureBase)
{
dispose();
throw new Error("This is abstract class and cannot be instantiated.");
}
}
/**
* @private
* Storage for direction property.
*/
protected var _direction:String = Direction.ALL;
/**
* Allowed direction for this gesture. Used to determine slop overcome
* and could be used for specific calculations (as in SwipeGesture for example).
*
* @default Direction.ALL
*
* @see org.gestouch.Direction
* @see org.gestouch.gestures.SwipeGesture
*/
public function get direction():String
{
return _direction;
}
public function set direction(value:String):void
{
if (_direction == value) return;
_validateDirection(value);
_direction = value;
_canMoveHorizontally = (_direction != Direction.VERTICAL);
_canMoveVertically = (_direction != Direction.HORIZONTAL);
}
//--------------------------------------------------------------------------
//
// Protected methods
//
//--------------------------------------------------------------------------
override protected function _preinit():void
{
super._preinit();
_propertyNames.push("slop", "direction");
}
override protected function _reset():void
{
super._reset();
_slopPassed = false;
}
/**
* Validates direction property (in setter) to help
* developer prevent accidental mistake (Strings suck).
*
* @see org.gestouch.Direction
*/
protected function _validateDirection(value:String):void
{
if (value != Direction.HORIZONTAL &&
value != Direction.VERTICAL &&
value != Direction.STRAIGHT_AXES &&
value != Direction.DIAGONAL_AXES &&
value != Direction.OCTO &&
value != Direction.ALL)
{
throw new ArgumentError("Invalid direction value \"" + value + "\".");
}
}
/**
* Checks wether slop has been overcome.
* Typically used in onTouchMove() method.
*
* @param moveDelta offset of touch point / central point
* starting from beginning of interaction cycle.
*
* @see #onTouchMove()
*/
protected function _checkSlop(moveDelta:Point):Boolean
{
var slopPassed:Boolean = false;
if (!(slop > 0))
{
// return true immideately if slop is 0 or NaN
return true;
}
if (_canMoveHorizontally && _canMoveVertically)
{
slopPassed = moveDelta.length > slop;
}
else if (_canMoveHorizontally)
{
slopPassed = Math.abs(moveDelta.x) > slop;
}
else if (_canMoveVertically)
{
slopPassed = Math.abs(moveDelta.y) > slop;
}
if (slopPassed)
{
var slopVector:Point;
if (_canMoveHorizontally && _canMoveVertically)
{
slopVector = moveDelta.clone();
slopVector.normalize(slop);
slopVector.x = Math.round(slopVector.x);
slopVector.y = Math.round(slopVector.y);
}
else if (_canMoveHorizontally)
{
slopVector = new Point(moveDelta.x >= slop ? slop : -slop, 0);
}
else if (_canMoveVertically)
{
slopVector = new Point(0, moveDelta.y >= slop ? slop : -slop);
}
// _gestureAnchorPoint = _touchPoint.add(slopVector);
// startGestureTrack();
}
return slopPassed;
}
}
}

196
src/org/gestouch/gestures/PanGesture.as Normal file
View file

@ -0,0 +1,196 @@
package org.gestouch.gestures
{
import org.gestouch.events.PanGestureEvent;
import org.gestouch.core.GestureState;
import org.gestouch.core.Touch;
import org.gestouch.events.ZoomGestureEvent;
import flash.display.InteractiveObject;
import flash.events.GesturePhase;
import flash.events.TouchEvent;
import flash.geom.Point;
[Event(name="gesturePan", type="org.gestouch.events.PanGestureEvent")]
/**
* TODO:
* -location
* -check native behavior on iDevice
*
* @author Pavel fljot
*/
public class PanGesture extends Gesture
{
public var slop:Number = Gesture.DEFAULT_SLOP;
protected var _touchBeginX:Array = [];
protected var _touchBeginY:Array = [];
public function PanGesture(target:InteractiveObject = null)
{
super(target);
}
/** @private */
private var _maxNumTouchesRequired:uint = 1;
/**
*
*/
public function get maxNumTouchesRequired():uint
{
return _maxNumTouchesRequired;
}
public function set maxNumTouchesRequired(value:uint):void
{
if (_maxNumTouchesRequired == value)
return;
if (value < minNumTouchesRequired)
throw ArgumentError("maxNumTouchesRequired must be not less then minNumTouchesRequired");
_maxNumTouchesRequired = value;
}
/** @private */
private var _minNumTouchesRequired:uint = 1;
/**
*
*/
public function get minNumTouchesRequired():uint
{
return _minNumTouchesRequired;
}
public function set minNumTouchesRequired(value:uint):void
{
if (_minNumTouchesRequired == value)
return;
if (value > maxNumTouchesRequired)
throw ArgumentError("minNumTouchesRequired must be not greater then maxNumTouchesRequired");
_minNumTouchesRequired = value;
}
// --------------------------------------------------------------------------
//
// Public methods
//
// --------------------------------------------------------------------------
override public function reflect():Class
{
return PanGesture;
}
override public function reset():void
{
_touchBeginX.length = 0;
_touchBeginY.length = 0;
super.reset();
}
// --------------------------------------------------------------------------
//
// Protected methods
//
// --------------------------------------------------------------------------
override protected function onTouchBegin(touch:Touch, event:TouchEvent):void
{
if (touchesCount > maxNumTouchesRequired)
{
//TODO
ignoreTouch(touch, event);
return;
}
_touchBeginX[touch.id] = touch.x;
_touchBeginY[touch.id] = touch.y;
if (touchesCount >= minNumTouchesRequired)
{
updateLocation();
}
}
override protected function onTouchMove(touch:Touch, event:TouchEvent):void
{
if (touchesCount < minNumTouchesRequired)
return;
var prevLocationX:Number;
var prevLocationY:Number;
var offsetX:Number;
var offsetY:Number;
if (state == GestureState.POSSIBLE)
{
// Check if finger moved enough for gesture to be recognized
var dx:Number = Number(_touchBeginX[touch.id]) - touch.x;
var dy:Number = Number(_touchBeginY[touch.id]) - touch.y;
if (Math.sqrt(dx*dx + dy*dy) > slop || slop != slop)//faster isNaN(slop)
{
prevLocationX = _location.x;
prevLocationY = _location.y;
updateLocation();
offsetX = _location.x - prevLocationX;
offsetY = _location.y - prevLocationY;
// Unfortunately we create several new point instances here,
// but thats not a big deal since this code executed only once per recognition session
var offset:Point = new Point(_location.x - prevLocationX, _location.y - prevLocationY);
if (offset.length > slop)
{
var slopVector:Point = offset.clone();
slopVector.normalize(slop);
offset = offset.subtract(slopVector);
}
setState(GestureState.BEGAN, new PanGestureEvent(PanGestureEvent.GESTURE_PAN, false, false, GesturePhase.BEGIN, _localLocation.x, _localLocation.y, offset.x, offset.y));
}
}
else if (state == GestureState.BEGAN || state == GestureState.CHANGED)
{
prevLocationX = _location.x;
prevLocationY = _location.y;
updateLocation();
offsetX = _location.x - prevLocationX;
offsetY = _location.y - prevLocationY;
setState(GestureState.CHANGED, new PanGestureEvent(PanGestureEvent.GESTURE_PAN, false, false, GesturePhase.UPDATE, _localLocation.x, _localLocation.y, offsetX, offsetY));
}
}
override protected function onTouchEnd(touch:Touch, event:TouchEvent):void
{
if (touchesCount < minNumTouchesRequired)
{
if (state == GestureState.POSSIBLE)
{
setState(GestureState.FAILED);
}
else
{
setState(GestureState.ENDED, new PanGestureEvent(PanGestureEvent.GESTURE_PAN, false, false, GesturePhase.END, _localLocation.x, _localLocation.y, 0, 0));
}
}
else
{
updateLocation();
}
}
}
}

208
src/org/gestouch/gestures/RotateGesture.as
View file

@ -1,139 +1,179 @@
package org.gestouch.gestures
{
import org.gestouch.GestureUtils;
import org.gestouch.core.GesturesManager;
import org.gestouch.core.TouchPoint;
import org.gestouch.core.gestouch_internal;
import org.gestouch.core.GestureState;
import org.gestouch.core.Touch;
import org.gestouch.events.RotateGestureEvent;
import org.gestouch.utils.GestureUtils;
import flash.display.InteractiveObject;
import flash.events.GesturePhase;
import flash.events.TouchEvent;
import flash.geom.Point;
[Event(name="gestureRotate", type="org.gestouch.events.RotateGestureEvent")]
/**
* TODO:
* -location
* -check native behavior on iDevice
*
* @author Pavel fljot
*/
public class RotateGesture extends Gesture
{
{
public var slop:Number = Gesture.DEFAULT_SLOP >> 1;
protected var _currVector:Point = new Point();
protected var _lastVector:Point = new Point();
protected var _touchBeginX:Array = [];
protected var _touchBeginY:Array = [];
protected var _rotationVector:Point = new Point();
protected var _firstTouch:Touch;
protected var _secondTouch:Touch;
public function RotateGesture(target:InteractiveObject, settings:Object = null)
public function RotateGesture(target:InteractiveObject = null)
{
super(target, settings);
super(target);
}
//--------------------------------------------------------------------------
// --------------------------------------------------------------------------
//
// Static methods
// Public methods
//
//--------------------------------------------------------------------------
public static function add(target:InteractiveObject = null, settings:Object = null):RotateGesture
{
return new RotateGesture(target, settings);
}
public static function remove(target:InteractiveObject):RotateGesture
{
return GesturesManager.gestouch_internal::removeGestureByTarget(RotateGesture, target) as RotateGesture;
}
//--------------------------------------------------------------------------
//
// Public methods
//
//--------------------------------------------------------------------------
override public function onCancel():void
{
super.onCancel();
}
// --------------------------------------------------------------------------
override public function reflect():Class
{
return RotateGesture;
}
override public function reset():void
{
_touchBeginX.length = 0;
_touchBeginY.length = 0;
super.reset();
}
override public function onTouchBegin(touchPoint:TouchPoint):void
// --------------------------------------------------------------------------
//
// Protected methods
//
// --------------------------------------------------------------------------
override protected function onTouchBegin(touch:Touch, event:TouchEvent):void
{
// No need to track more points than we need
if (_trackingPointsCount == maxTouchPointsCount)
if (touchesCount > 2)
{
//TODO
ignoreTouch(touch, event);
return;
}
_trackPoint(touchPoint);
if (_trackingPointsCount == minTouchPointsCount)
if (touchesCount == 1)
{
_lastVector.x = _trackingPoints[1].x - _trackingPoints[0].x;
_lastVector.y = _trackingPoints[1].y - _trackingPoints[0].y;
_firstTouch = touch;
}
else
{
_secondTouch = touch;
_updateCentralPoint();
_touchBeginX[_firstTouch.id] = _firstTouch.x;
_touchBeginY[_firstTouch.id] = _firstTouch.y;
_touchBeginX[_secondTouch.id] = _secondTouch.x;
_touchBeginY[_secondTouch.id] = _secondTouch.y;
_dispatch(new RotateGestureEvent(RotateGestureEvent.GESTURE_ROTATE, true, false, GesturePhase.BEGIN, _lastLocalCentralPoint.x, _lastLocalCentralPoint.y));
_rotationVector.x = _secondTouch.x - _firstTouch.x;
_rotationVector.y = _secondTouch.y - _firstTouch.y;
}
}
override public function onTouchMove(touchPoint:TouchPoint):void
override protected function onTouchMove(touch:Touch, event:TouchEvent):void
{
// do calculations only when we track enough points
if (_trackingPointsCount < minTouchPointsCount)
if (touch.id == _firstTouch.id)
{
return;
_firstTouch = touch;
}
_updateCentralPoint();
_currVector.x = _trackingPoints[1].x - _trackingPoints[0].x;
_currVector.y = _trackingPoints[1].y - _trackingPoints[0].y;
var a1:Number = Math.atan2(_lastVector.y, _lastVector.x);
var a2:Number = Math.atan2(_currVector.y, _currVector.x);
var angle:Number = a2 - a1;
angle *= GestureUtils.RADIANS_TO_DEGREES;
_lastVector.x = _currVector.x;
_lastVector.y = _currVector.y;
_dispatch(new RotateGestureEvent(RotateGestureEvent.GESTURE_ROTATE, true, false, GesturePhase.UPDATE, _lastLocalCentralPoint.x, _lastLocalCentralPoint.y, 1, 1, angle));
}
override public function onTouchEnd(touchPoint:TouchPoint):void
{
var ending:Boolean = (_trackingPointsCount == minTouchPointsCount);
_forgetPoint(touchPoint);
if (ending)
else
{
_dispatch(new RotateGestureEvent(RotateGestureEvent.GESTURE_ROTATE, true, false, GesturePhase.END, _lastLocalCentralPoint.x, _lastLocalCentralPoint.y));
_secondTouch = touch;
}
if (touchesCount == 2)
{
var currRotationVector:Point = new Point(_secondTouch.x - _firstTouch.x, _secondTouch.y - _firstTouch.y);
var recognized:Boolean;
if (state == GestureState.POSSIBLE)
{
// we start once any finger moved enough
var dx:Number = Number(_touchBeginX[touch.id]) - touch.x;
var dy:Number = Number(_touchBeginY[touch.id]) - touch.y;
if (Math.sqrt(dx*dx + dy*dy) > slop || slop != slop)//faster isNaN(slop)
{
recognized = true;
_rotationVector.x = _secondTouch.x - _firstTouch.x;
_rotationVector.y = _secondTouch.y - _firstTouch.y;
}
}
else
{
recognized = true;
}
if (recognized)
{
updateLocation();
var rotation:Number = Math.atan2(currRotationVector.y, currRotationVector.x) - Math.atan2(_rotationVector.y, _rotationVector.x);
rotation *= GestureUtils.RADIANS_TO_DEGREES;
_rotationVector.x = currRotationVector.x;
_rotationVector.y = currRotationVector.y;
if (state == GestureState.POSSIBLE)
{
setState(GestureState.BEGAN, new RotateGestureEvent(RotateGestureEvent.GESTURE_ROTATE, false, false, GesturePhase.BEGIN, _localLocation.x, _localLocation.y, rotation));
}
else
{
setState(GestureState.CHANGED, new RotateGestureEvent(RotateGestureEvent.GESTURE_ROTATE, false, false, GesturePhase.UPDATE, _localLocation.x, _localLocation.y, rotation));
}
}
}
}
override protected function _preinit():void
override protected function onTouchEnd(touch:Touch, event:TouchEvent):void
{
super._preinit();
minTouchPointsCount = 2;
if (touchesCount == 0)
{
if (state == GestureState.BEGAN || state == GestureState.CHANGED)
{
setState(GestureState.ENDED, new RotateGestureEvent(RotateGestureEvent.GESTURE_ROTATE, false, false, GesturePhase.END, _localLocation.x, _localLocation.y, 0));
}
else if (state == GestureState.POSSIBLE)
{
setState(GestureState.FAILED);
}
}
else// == 1
{
if (touch.id == _firstTouch.id)
{
_firstTouch = _secondTouch;
}
if (state == GestureState.BEGAN || state == GestureState.CHANGED)
{
updateLocation();
setState(GestureState.CHANGED, new RotateGestureEvent(RotateGestureEvent.GESTURE_ROTATE, false, false, GesturePhase.UPDATE, _localLocation.x, _localLocation.y, 0));
}
}
}
}
}

258
src/org/gestouch/gestures/SwipeGesture.as
View file

@ -1,180 +1,184 @@
package org.gestouch.gestures
{
import org.gestouch.Direction;
import org.gestouch.GestureUtils;
import org.gestouch.core.GesturesManager;
import org.gestouch.core.TouchPoint;
import org.gestouch.core.gestouch_internal;
import org.gestouch.core.GestureState;
import org.gestouch.core.Touch;
import org.gestouch.events.SwipeGestureEvent;
import flash.display.InteractiveObject;
import flash.events.GesturePhase;
import flash.events.TouchEvent;
import flash.geom.Point;
import flash.utils.getTimer;
import flash.system.Capabilities;
[Event(name="gestureSwipe", type="org.gestouch.events.SwipeGestureEvent")]
/**
* SwipeGesture detects <i>swipe</i> motion (also known as <i>flick</i> or <i>flig</i>).
*
* <p>I couldn't find any certain definition of <i>Swipe</i> except for it's defined as <i>quick</i>.
* So I've implemented detection via two threshold velocities — one is in the direction of the movement,
* and second is the "side"-one (orthogonal). They form a velocity rectangle, where you have to move
* with a velocity greater then velocityThreshold value and less then sideVelocityThreshold.</p>
* TODO:
* -check native behavior on iDevice
*
* @author Pavel fljot
*/
public class SwipeGesture extends MovingGestureBase
public class SwipeGesture extends Gesture
{
public var moveThreshold:Number = Gesture.DEFAULT_SLOP;
public var minTimeThreshold:uint = 50;
public var velocityThreshold:Number = 7 * GestureUtils.IPS_TO_PPMS;
public var sideVelocityThreshold:Number = 2 * GestureUtils.IPS_TO_PPMS;
public var numTouchesRequired:uint = 1;
public var velocityThreshold:Number = 0.1;
public var minVelocity:Number = 1.5;
public var minDistance:Number = Capabilities.screenDPI * 0.5;
protected var _startTime:uint;
public var direction:uint = SwipeGestureDirection.ORTHOGONAL;
protected var _offset:Point = new Point();
protected var _startTime:int;
protected var _noDirection:Boolean;
public function SwipeGesture(target:InteractiveObject = null, settings:Object = null)
public function SwipeGesture(target:InteractiveObject = null)
{
super(target, settings);
super(target);
}
//--------------------------------------------------------------------------
// --------------------------------------------------------------------------
//
// Static methods
// Public methods
//
//--------------------------------------------------------------------------
// --------------------------------------------------------------------------
public static function add(target:InteractiveObject, settings:Object = null):SwipeGesture
{
return new SwipeGesture(target, settings);
}
public static function remove(target:InteractiveObject):SwipeGesture
{
return GesturesManager.gestouch_internal::removeGestureByTarget(SwipeGesture, target) as SwipeGesture;
}
//--------------------------------------------------------------------------
//
// Public methods
//
//--------------------------------------------------------------------------
override public function reflect():Class
{
return SwipeGesture;
}
override public function onTouchBegin(touchPoint:TouchPoint):void
{
// No need to track more points than we need
if (_trackingPointsCount == maxTouchPointsCount)
{
return;
}
_trackPoint(touchPoint);
override public function reset():void
{
_startTime = 0;
_offset.x = 0;
_offset.y = 0;
super.reset();
}
override public function onTouchMove(touchPoint:TouchPoint):void
// --------------------------------------------------------------------------
//
// Protected methods
//
// --------------------------------------------------------------------------
override protected function onTouchBegin(touch:Touch, event:TouchEvent):void
{
// do calculations only when we track enought points
if (_trackingPointsCount < minTouchPointsCount)
if (touchesCount > numTouchesRequired)
{
setState(GestureState.FAILED);
return;
}
_updateCentralPoint();
if (!_slopPassed)
if (touchesCount == numTouchesRequired)
{
_slopPassed = _checkSlop(_centralPoint.moveOffset);
updateLocation();
_startTime = touch.time;
// cache direction condition for performance
_noDirection = (SwipeGestureDirection.ORTHOGONAL & direction) == 0;
}
}
override protected function onTouchMove(touch:Touch, event:TouchEvent):void
{
if (touchesCount < numTouchesRequired)
return;
updateCentralPoint();
_offset.x = _centralPoint.x - _location.x;
_offset.y = _centralPoint.y - _location.y;
var offsetLength:Number = _offset.length;
var timeDelta:int = touch.time - _startTime;
var vel:Number = offsetLength / timeDelta;
var absVel:Number = vel > 0 ? vel : -vel;//faster Math.abs()
// trace(_offset, _offset.length, ".....velocity:", vel);
if (offsetLength > Gesture.DEFAULT_SLOP && absVel < velocityThreshold)
{
setState(GestureState.FAILED);
return;
}
if (_slopPassed)
var velX:Number = _offset.x / timeDelta;
var velY:Number = _offset.y / timeDelta;
if (_noDirection)
{
var velocity:Point = _centralPoint.velocity;
var foo:Number = _centralPoint.moveOffset.length;//FIXME!
var swipeDetected:Boolean = false;
if (getTimer() - _startTime > minTimeThreshold && foo > 10)
if (absVel >= minVelocity || (minDistance != minDistance || offsetLength >= minDistance))
{
var lastMoveX:Number = 0;
var lastMoveY:Number = 0;
if (_canMoveHorizontally && _canMoveVertically)
{
lastMoveX = _centralPoint.lastMove.x;
lastMoveY = _centralPoint.lastMove.y;
if (direction == Direction.STRAIGHT_AXES)
{
// go to logic below: if (!swipeDetected && _canMove*)..
}
else if (direction == Direction.OCTO)
{
swipeDetected = velocity.length >= velocityThreshold;
if (Math.abs(velocity.y) < sideVelocityThreshold)
{
// horizontal swipe
lastMoveY = 0;
}
else if (Math.abs(velocity.x) < sideVelocityThreshold)
{
// vertical swipe
lastMoveX = 0;
}
}
else
{
// free direction swipe
swipeDetected = velocity.length >= velocityThreshold;
}
}
if (!swipeDetected && _canMoveHorizontally)
{
swipeDetected = Math.abs(velocity.x) >= velocityThreshold &&
Math.abs(velocity.y) < sideVelocityThreshold;
lastMoveX = _centralPoint.lastMove.x;
lastMoveY = 0;
}
if (!swipeDetected && _canMoveVertically)
{
swipeDetected = Math.abs(velocity.y) >= velocityThreshold &&
Math.abs(velocity.x) < sideVelocityThreshold;
lastMoveX = 0;
lastMoveY = _centralPoint.lastMove.y;
}
if (swipeDetected)
{
_reset();
// trace("swipe detected:", lastMoveX, lastMoveY);
_dispatch(new SwipeGestureEvent(SwipeGestureEvent.GESTURE_SWIPE, true, false, GesturePhase.ALL, target.mouseX, target.mouseY, 1, 1, 0, lastMoveX, lastMoveY));
}
setState(GestureState.RECOGNIZED, new SwipeGestureEvent(SwipeGestureEvent.GESTURE_SWIPE, false, false, GesturePhase.ALL, _localLocation.x, _localLocation.y, _offset.x, _offset.y));
}
}
}
else
{
//faster Math.abs()
var absVelX:Number = velX > 0 ? velX : -velX;
var absVelY:Number = velY > 0 ? velY : -velY;
var absOffsetX:Number = _offset.x > 0 ? _offset.x : -_offset.x;
var absOffsetY:Number = _offset.y > 0 ? _offset.y : -_offset.y;
if (absVelX > absVelY)
{
if ((SwipeGestureDirection.HORIZONTAL & direction) == 0)
{
// horizontal velocity is greater then vertical, but we're not interested in any horizontal direction
setState(GestureState.FAILED);
}
else if (velX < 0 && (direction & SwipeGestureDirection.LEFT) == 0)
{
setState(GestureState.FAILED);
}
else if (velX > 0 && (direction & SwipeGestureDirection.RIGHT) == 0)
{
setState(GestureState.FAILED);
}
else if (absVelX >= minVelocity || (minDistance != minDistance || absOffsetX >= minDistance))
{
setState(GestureState.RECOGNIZED, new SwipeGestureEvent(SwipeGestureEvent.GESTURE_SWIPE, false, false, GesturePhase.ALL, _localLocation.x, _localLocation.y, _offset.x, 0));
}
}
else if (absVelY > absVelX)
{
if ((SwipeGestureDirection.VERTICAL & direction) == 0)
{
// horizontal velocity is greater then vertical, but we're not interested in any horizontal direction
setState(GestureState.FAILED);
}
else if (velY < 0 && (direction & SwipeGestureDirection.UP) == 0)
{
setState(GestureState.FAILED);
}
else if (velY > 0 && (direction & SwipeGestureDirection.DOWN) == 0)
{
setState(GestureState.FAILED);
}
else if (absVelY >= minVelocity || (minDistance != minDistance || absOffsetY >= minDistance))
{
setState(GestureState.RECOGNIZED, new SwipeGestureEvent(SwipeGestureEvent.GESTURE_SWIPE, false, false, GesturePhase.ALL, _localLocation.x, _localLocation.y, 0, _offset.y));
}
}
else
{
setState(GestureState.FAILED);
}
}
}
override public function onTouchEnd(touchPoint:TouchPoint):void
override protected function onTouchEnd(touch:Touch, event:TouchEvent):void
{
_forgetPoint(touchPoint);
setState(GestureState.FAILED);
}
}
}

18
src/org/gestouch/gestures/SwipeGestureDirection.as Normal file
View file

@ -0,0 +1,18 @@
package org.gestouch.gestures
{
/**
* @author Pavel fljot
*/
public class SwipeGestureDirection
{
public static const RIGHT:uint = 1 << 0;
public static const LEFT:uint = 1 << 1;
public static const UP:uint = 1 << 2;
public static const DOWN:uint = 1 << 3;
public static const NO_DIRECTION:uint = 0;
public static const HORIZONTAL:uint = RIGHT | LEFT;
public static const VERTICAL:uint = UP | DOWN;
public static const ORTHOGONAL:uint = RIGHT | LEFT | UP | DOWN;
}
}

181
src/org/gestouch/gestures/TapGesture.as Normal file
View file

@ -0,0 +1,181 @@
package org.gestouch.gestures
{
import org.gestouch.core.GestureState;
import org.gestouch.core.Touch;
import org.gestouch.events.TapGestureEvent;
import flash.display.InteractiveObject;
import flash.events.GesturePhase;
import flash.events.TimerEvent;
import flash.events.TouchEvent;
import flash.utils.Timer;
/**
* TODO: check failing conditions (iDevice)
*
* @author Pavel fljot
*/
public class TapGesture extends Gesture
{
public var numTouchesRequired:uint = 1;
public var numTapsRequired:uint = 1;
public var slop:Number = Gesture.DEFAULT_SLOP;
public var maxTapDelay:uint = 400;
public var maxTapDuration:uint = 1500;
protected var _timer:Timer;
protected var _touchBeginX:Array = [];
protected var _touchBeginY:Array = [];
protected var _numTouchesRequiredReached:Boolean;
protected var _tapCounter:uint = 0;
public function TapGesture(target:InteractiveObject = null)
{
super(target);
}
// --------------------------------------------------------------------------
//
// Public methods
//
// --------------------------------------------------------------------------
override public function reflect():Class
{
return TapGesture;
}
override public function reset():void
{
_touchBeginX.length = 0;
_touchBeginY.length = 0;
_numTouchesRequiredReached = false;
_tapCounter = 0;
_timer.reset();
super.reset();
}
override public function canPreventGesture(preventedGesture:Gesture):Boolean
{
if (preventedGesture is TapGesture &&
(preventedGesture as TapGesture).numTapsRequired > this.numTapsRequired)
{
return false;
}
return true;
}
// --------------------------------------------------------------------------
//
// Protected methods
//
// --------------------------------------------------------------------------
override protected function preinit():void
{
super.preinit();
_timer = new Timer(maxTapDelay, 1);
_timer.addEventListener(TimerEvent.TIMER_COMPLETE, timer_timerCompleteHandler);
}
override protected function onTouchBegin(touch:Touch, event:TouchEvent):void
{
if (touchesCount > numTouchesRequired)
{
// We put more fingers then required at the same time,
// so treat that as failed
setState(GestureState.FAILED);
return;
}
_touchBeginX[touch.id] = touch.x;
_touchBeginY[touch.id] = touch.y;
if (touchesCount == 1)
{
_timer.reset();
_timer.delay = maxTapDuration;
_timer.start();
}
if (touchesCount == numTouchesRequired)
{
_numTouchesRequiredReached = true;
}
}
override protected function onTouchMove(touch:Touch, event:TouchEvent):void
{
if (slop >= 0)
{
// Fail if touch overcome slop distance
var dx:Number = Number(_touchBeginX[touch.id]) - touch.x;
var dy:Number = Number(_touchBeginY[touch.id]) - touch.y;
if (Math.sqrt(dx*dx + dy*dy) > slop)
{
setState(GestureState.FAILED);
}
}
}
override protected function onTouchEnd(touch:Touch, event:TouchEvent):void
{
if (!_numTouchesRequiredReached)
{
//TODO: check this condition on iDevice
setState(GestureState.FAILED);
}
else if (touchesCount == 0)
{
// reset flag for the next "full press" cycle
_numTouchesRequiredReached = false;
_tapCounter++;
_timer.reset();
if (_tapCounter == numTapsRequired)
{
updateLocation();
setState(GestureState.RECOGNIZED, new TapGestureEvent(TapGestureEvent.GESTURE_TAP, false, false, GesturePhase.ALL, _localLocation.x, _localLocation.y));
}
else
{
_timer.delay = maxTapDelay;
_timer.start();
}
}
}
//--------------------------------------------------------------------------
//
// Event handlers
//
//--------------------------------------------------------------------------
protected function timer_timerCompleteHandler(event:TimerEvent):void
{
if (state == GestureState.POSSIBLE)
{
setState(GestureState.FAILED);
}
}
}
}

209
src/org/gestouch/gestures/ZoomGesture.as
View file

@ -1,140 +1,189 @@
package org.gestouch.gestures
{
import org.gestouch.core.GesturesManager;
import org.gestouch.core.TouchPoint;
import org.gestouch.core.gestouch_internal;
import org.gestouch.core.GestureState;
import org.gestouch.core.Touch;
import org.gestouch.events.ZoomGestureEvent;
import flash.display.InteractiveObject;
import flash.events.GesturePhase;
import flash.events.TouchEvent;
import flash.geom.Point;
[Event(name="gestureZoom", type="org.gestouch.events.ZoomGestureEvent")]
/**
* TODO:
* -location
* -check native behavior on iDevice
*
* @author Pavel fljot
*/
public class ZoomGesture extends Gesture
{
{
public var slop:Number = Gesture.DEFAULT_SLOP >> 1;
public var lockAspectRatio:Boolean = true;
protected var _currVector:Point = new Point();
protected var _lastVector:Point = new Point();
protected var _touchBeginX:Array = [];
protected var _touchBeginY:Array = [];
protected var _scaleVector:Point = new Point();
protected var _firstTouch:Touch;
protected var _secondTouch:Touch;
public function ZoomGesture(target:InteractiveObject, settings:Object = null)
public function ZoomGesture(target:InteractiveObject = null)
{
super(target, settings);
super(target);
}
//--------------------------------------------------------------------------
// --------------------------------------------------------------------------
//
// Static methods
// Public methods
//
//--------------------------------------------------------------------------
public static function add(target:InteractiveObject = null, settings:Object = null):ZoomGesture
{
return new ZoomGesture(target, settings);
}
public static function remove(target:InteractiveObject):ZoomGesture
{
return GesturesManager.gestouch_internal::removeGestureByTarget(ZoomGesture, target) as ZoomGesture;
}
//--------------------------------------------------------------------------
//
// Public methods
//
//--------------------------------------------------------------------------
// --------------------------------------------------------------------------
override public function reflect():Class
{
return ZoomGesture;
}
override public function reset():void
{
_touchBeginX.length = 0;
_touchBeginY.length = 0;
super.reset();
}
override public function onTouchBegin(touchPoint:TouchPoint):void
// --------------------------------------------------------------------------
//
// Protected methods
//
// --------------------------------------------------------------------------
override protected function onTouchBegin(touch:Touch, event:TouchEvent):void
{
// No need to track more points than we need
if (_trackingPointsCount == maxTouchPointsCount)
if (touchesCount > 2)
{
//TODO
ignoreTouch(touch, event);
return;
}
_trackPoint(touchPoint);
if (_trackingPointsCount == minTouchPointsCount)
if (touchesCount == 1)
{
_lastVector.x = _trackingPoints[1].x - _trackingPoints[0].x;
_lastVector.y = _trackingPoints[1].y - _trackingPoints[0].y;
_firstTouch = touch;
}
else// == 2
{
_secondTouch = touch;
_updateCentralPoint();
_touchBeginX[_firstTouch.id] = _firstTouch.x;
_touchBeginY[_firstTouch.id] = _firstTouch.y;
_touchBeginX[_secondTouch.id] = _secondTouch.x;
_touchBeginY[_secondTouch.id] = _secondTouch.y;
_dispatch(new ZoomGestureEvent(ZoomGestureEvent.GESTURE_ZOOM, true, false, GesturePhase.BEGIN, _lastLocalCentralPoint.x, _lastLocalCentralPoint.y));
_scaleVector.x = _secondTouch.x - _firstTouch.x;
_scaleVector.y = _secondTouch.y - _firstTouch.y;
}
}
override public function onTouchMove(touchPoint:TouchPoint):void
override protected function onTouchMove(touch:Touch, event:TouchEvent):void
{
// do calculations only when we track enought points
if (_trackingPointsCount < minTouchPointsCount)
if (touch.id == _firstTouch.id)
{
return;
}
_updateCentralPoint();
_currVector.x = _trackingPoints[1].x - _trackingPoints[0].x;
_currVector.y = _trackingPoints[1].y - _trackingPoints[0].y;
var scaleX:Number = _currVector.x / _lastVector.x;
var scaleY:Number = _currVector.y / _lastVector.y;
if (lockAspectRatio)
{
scaleX = scaleY = _currVector.length / _lastVector.length;
_firstTouch = touch;
}
else
{
scaleX = _currVector.x / _lastVector.x;
scaleY = _currVector.y / _lastVector.y;
_secondTouch = touch;
}
_lastVector.x = _currVector.x;
_lastVector.y = _currVector.y;
_dispatch(new ZoomGestureEvent(ZoomGestureEvent.GESTURE_ZOOM, true, false, GesturePhase.UPDATE, _lastLocalCentralPoint.x, _lastLocalCentralPoint.y, scaleX, scaleY));
}
override public function onTouchEnd(touchPoint:TouchPoint):void
{
var ending:Boolean = (_trackingPointsCount == minTouchPointsCount);
_forgetPoint(touchPoint);
if (ending)
if (touchesCount == 2)
{
_dispatch(new ZoomGestureEvent(ZoomGestureEvent.GESTURE_ZOOM, true, false, GesturePhase.END, _lastLocalCentralPoint.x, _lastLocalCentralPoint.y));
var currScaleVector:Point = new Point(_secondTouch.x - _firstTouch.x, _secondTouch.y - _firstTouch.y);
var recognized:Boolean;
if (state == GestureState.POSSIBLE)
{
// Check if finger moved enough for gesture to be recognized
var dx:Number = Number(_touchBeginX[touch.id]) - touch.x;
var dy:Number = Number(_touchBeginY[touch.id]) - touch.y;
if (Math.sqrt(dx*dx + dy*dy) > slop || slop != slop)//faster isNaN(slop)
{
recognized = true;
_scaleVector.x = _secondTouch.x - _firstTouch.x;
_scaleVector.y = _secondTouch.y - _firstTouch.y;
}
}
else
{
recognized = true;
}
if (recognized)
{
updateLocation();
var scaleX:Number;
var scaleY:Number;
if (lockAspectRatio)
{
scaleX = scaleY = currScaleVector.length / _scaleVector.length;
}
else
{
scaleX = currScaleVector.x / _scaleVector.x;
scaleY = currScaleVector.y / _scaleVector.y;
}
_scaleVector.x = currScaleVector.x;
_scaleVector.y = currScaleVector.y;
if (state == GestureState.POSSIBLE)
{
setState(GestureState.BEGAN, new ZoomGestureEvent(ZoomGestureEvent.GESTURE_ZOOM, false, false, GesturePhase.BEGIN, _localLocation.x, _localLocation.y, scaleX, scaleY));
}
else
{
setState(GestureState.CHANGED, new ZoomGestureEvent(ZoomGestureEvent.GESTURE_ZOOM, false, false, GesturePhase.UPDATE, _localLocation.x, _localLocation.y, scaleX, scaleY));
}
}
}
}
override protected function _preinit():void
override protected function onTouchEnd(touch:Touch, event:TouchEvent):void
{
super._preinit();
minTouchPointsCount = 2;
_propertyNames.push("lockAspectRatio");
if (touchesCount == 0)
{
if (state == GestureState.BEGAN || state == GestureState.CHANGED)
{
setState(GestureState.ENDED, new ZoomGestureEvent(ZoomGestureEvent.GESTURE_ZOOM, false, false, GesturePhase.END, _localLocation.x, _localLocation.y, 1, 1));
}
else if (state == GestureState.POSSIBLE)
{
setState(GestureState.FAILED);
}
}
else//== 1
{
if (touch.id == _firstTouch.id)
{
_firstTouch = _secondTouch;
}
if (state == GestureState.BEGAN || state == GestureState.CHANGED)
{
updateLocation();
setState(GestureState.CHANGED, new ZoomGestureEvent(ZoomGestureEvent.GESTURE_ZOOM, false, false, GesturePhase.UPDATE, _localLocation.x, _localLocation.y, 1, 1));
}
}
}
}
}

2
src/org/gestouch/GestureUtils.as → src/org/gestouch/utils/GestureUtils.as
View file

@ -1,4 +1,4 @@
package org.gestouch
package org.gestouch.utils
{
import flash.system.Capabilities;
/**

131
src/org/gestouch/utils/ObjectPool.as
View file

@ -1,131 +0,0 @@
package org.gestouch.utils
{
import flash.utils.getQualifiedClassName;
/**
* @author Pavel fljot
*
* "inspired" by Jonnie Hallman
* @link http://destroytoday.com
* @link https://github.com/destroytoday
*
* Added some optimization and changes.
*/
public class ObjectPool
{
// --------------------------------------------------------------------------
//
// Properties
//
// --------------------------------------------------------------------------
protected var _type:Class;
protected var objectList:Array = [];
// --------------------------------------------------------------------------
//
// Constructor
//
// --------------------------------------------------------------------------
public function ObjectPool(type:Class, size:uint = 0)
{
_type = type;
if (size > 0)
{
allocate(size);
}
}
// --------------------------------------------------------------------------
//
// Getters / Setters
//
// --------------------------------------------------------------------------
public function get type():Class
{
return _type;
}
public function get numObjects():uint
{
return objectList.length;
}
// --------------------------------------------------------------------------
//
// Public Methods
//
// --------------------------------------------------------------------------
public function hasObject(object:Object):Boolean
{
return objectList.indexOf(object) > -1;
}
public function getObject():*
{
return numObjects > 0 ? objectList.pop() : createObject();
}
public function disposeObject(object:Object):void
{
if (!(object is type))
{
throw new TypeError("Disposed object type mismatch. Expected " + type + ", got " + getQualifiedClassName(object));
}
addObject(object);
}
public function empty():void
{
objectList.length = 0;
}
//--------------------------------------------------------------------------
//
// Protected methods
//
//--------------------------------------------------------------------------
protected function addObject(object:Object):*
{
if (!hasObject(object))
objectList[objectList.length] = object;
return object;
}
protected function createObject():*
{
return new type();
}
protected function allocate(value:uint):void
{
var n:int = value - numObjects;
while (n-- > 0)
{
addObject(createObject());
}
}
}
}