internal _TapTracker(
PointerDownEvent evt = null,
GestureArenaEntry entry = null) {
this.pointer = evt.pointer;
this._initialPosition = evt.position;
this.entry = entry;
}
public override void addAllowedPointer(PointerDownEvent evt)
{
startTrackingPointer(evt.pointer, evt.transform);
_velocityTrackers[evt.pointer] = new VelocityTracker();
if (_state == _DragState.ready)
{
_state = _DragState.possible;
_initialPosition = new OffsetPair(global: evt.position, local: evt.localPosition);
_pendingDragOffset = OffsetPair.zero;
_globalDistanceMoved = 0f;
_lastPendingEventTimestamp = evt.timeStamp;
_lastTransform = evt.transform;
if (onDown != null)
{
invokeCallback <object>("onDown",
() => {
onDown(new DragDownDetails(
globalPosition: _initialPosition.global,
localPosition: _initialPosition.local));
return(null);
});
}
}
else if (_state == _DragState.accepted)
{
resolve(GestureDisposition.accepted);
}
}
void _reset()
{
_sentTapDown = false;
_wonArenaForPrimaryPointer = false;
_up = null;
_down = null;
}
protected override void handleTapUp(PointerDownEvent down, PointerUpEvent up)
{
TapUpDetails details = new TapUpDetails(
globalPosition: up.position,
localPosition: up.localPosition,
kind: up.kind,
device: up.device
);
if (this.onTapUp != null)
{
this.invokeCallback <object>("onTapUp", () => {
this.onTapUp(details);
return(null);
});
}
if (this.onTap != null)
{
this.invokeCallback <object>("onTap", () => {
this.onTap();
return(null);
});
}
}
void _reset()
{
this._sentTapDown = false;
this._wonArenaForPrimaryPointer = false;
this._up = null;
this._down = null;
}
public override void addAllowedPointer(PointerDownEvent evt)
{
if (this.state == GestureRecognizerState.ready)
{
this._down = evt;
}
base.addAllowedPointer(evt);
}
protected override void handleTapCancel(PointerDownEvent down, PointerCancelEvent cancel, string note)
{
if (this.onTapCancel != null)
{
this.invokeCallback <object>("onTapCancel", () => {
this.onTapCancel();
return(null);
});
}
}
public void addPointer(PointerDownEvent evt)
{
if (this.isPointerAllowed(evt))
{
this.addAllowedPointer(evt);
}
else
{
this.handleNonAllowedPointer(evt);
}
}
public override void addAllowedPointer(PointerEvent evt)
{
var _evt = (PointerDownEvent)evt;
D.assert(_evt != null);
if (state == GestureRecognizerState.ready)
{
_down = _evt;
}
base.addAllowedPointer(_evt);
}
internal _TapTracker(
PointerDownEvent evt,
TimeSpan doubleTapMinTime,
GestureArenaEntry entry = null
)
{
this.pointer = evt.pointer;
this._initialGlobalPosition = evt.position;
this._doubleTapMinTimeCountdown = new _CountdownZoned(duration: doubleTapMinTime);
this.entry = entry;
}
public void addPointer(PointerDownEvent evt)
{
_pointerToKind[evt.pointer] = evt.kind;
if (isPointerAllowed(evt))
{
addAllowedPointer(evt);
}
else
{
handleNonAllowedPointer(evt);
}
}
public void addPointer(PointerDownEvent evt)
{
this._pointerToKind[evt.pointer] = evt.kind;
if (this.isPointerAllowed(evt))
{
this.addAllowedPointer(evt);
}
else
{
this.handleNonAllowedPointer(evt);
}
}
protected override bool isPointerAllowed(PointerDownEvent evt)
{
if (this.onTapDown == null &&
this.onTap == null &&
this.onTapUp == null &&
this.onTapCancel == null)
{
return(false);
}
return(base.isPointerAllowed(evt));
}
public override void addAllowedPointer(PointerDownEvent pEvent)
{
D.assert(this._pointers != null);
D.assert(pEvent.position != null);
D.assert(!this._pointers.ContainsKey(pEvent.pointer));
T state = this.createNewPointerState(pEvent);
this._pointers[pEvent.pointer] = state;
GestureBinding.instance.pointerRouter.addRoute(pEvent.pointer, this._handleEvent);
state._setArenaEntry(GestureBinding.instance.gestureArena.add(pEvent.pointer, this));
}
internal _TapTracker(
PointerDownEvent evt,
TimeSpan doubleTapMinTime,
GestureArenaEntry entry = null
)
{
D.assert(evt != null);
pointer = evt.pointer;
_initialGlobalPosition = evt.position;
initialButtons = evt.buttons;
_doubleTapMinTimeCountdown = new _CountdownZoned(duration: doubleTapMinTime);
this.entry = entry;
}
public override void addAllowedPointer(PointerDownEvent evt)
{
this.startTrackingPointer(evt.pointer, evt.transform);
if (this.state == GestureRecognizerState.ready)
{
this.state = GestureRecognizerState.possible;
this.primaryPointer = evt.pointer;
this.initialPosition = new OffsetPair(local: evt.localPosition, global: evt.position);
if (this.deadline != null)
{
this._timer = Window.instance.run(this.deadline.Value, () => didExceedDeadlineWithEvent(evt));
}
}
}
public override void addAllowedPointer(PointerDownEvent evt)
{
startTrackingPointer(evt.pointer, evt.transform);
if (state == GestureRecognizerState.ready)
{
state = GestureRecognizerState.possible;
primaryPointer = evt.pointer;
initialPosition = new OffsetPair(local: evt.localPosition, global: evt.position);
if (deadline != null)
{
_timer = Timer.create(deadline.Value, () => didExceedDeadlineWithEvent(evt));
}
}
}
public override void addAllowedPointer(PointerDownEvent evt) {
if (this._firstTap != null &&
!this._firstTap.isWithinTolerance(evt, Constants.kDoubleTapSlop)) {
return;
}
this._stopDoubleTapTimer();
_TapTracker tracker = new _TapTracker(
evt: evt,
entry: GestureBinding.instance.gestureArena.add(evt.pointer, this)
);
this._trackers[evt.pointer] = tracker;
tracker.startTrackingPointer(this._handleEvent);
}
public override void addAllowedPointer(PointerDownEvent evt)
{
this.startTrackingPointer(evt.pointer);
if (this.state == GestureRecognizerState.ready)
{
this.state = GestureRecognizerState.possible;
this.primaryPointer = evt.pointer;
this.initialPosition = evt.position;
if (this.deadline != null)
{
this._timer = Window.instance.run(this.deadline.Value, this.didExceedDeadline);
}
}
}
protected override void handleTapDown(PointerDownEvent down)
{
if (this.onTapDown != null)
{
TapDownDetails details = new TapDownDetails(
globalPosition: down.position,
kind: down.kind,
device: down.device
);
this.invokeCallback <object>("onTapDown", () => {
this.onTapDown(details);
return(null);
});
}
}
public override void addAllowedPointer(PointerDownEvent Event)
{
if (!(Event is PointerUpEvent) && Event.pressureMax <= 1.0f)
{
resolve(GestureDisposition.rejected);
}
else
{
startTrackingPointer(Event.pointer, Event.transform);
if (_state == _ForceState.ready)
{
_state = _ForceState.possible;
_lastPosition = OffsetPair.fromEventPosition(Event);
}
}
}
public override void addAllowedPointer(PointerDownEvent evt)
{
D.assert(!this._gestureMap.ContainsKey(evt.pointer));
this._gestureMap[evt.pointer] = new _TapGesture(
gestureRecognizer: this,
evt: evt,
longTapDelay: this.longTapDelay
);
if (this.onTapDown != null)
{
this.invokeCallback <object>("onTapDown", () => {
this.onTapDown(evt.pointer, new TapDownDetails(globalPosition: evt.position));
return(null);
});
}
}
public override void addAllowedPointer(PointerDownEvent evt)
{
this.startTrackingPointer(evt.pointer);
this._velocityTrackers[evt.pointer] = new VelocityTracker();
if (this._state == _ScaleState.ready)
{
this._state = _ScaleState.possible;
this._initialSpan = 0.0f;
this._currentSpan = 0.0f;
this._initialHorizontalSpan = 0.0f;
this._currentHorizontalSpan = 0.0f;
this._initialVerticalSpan = 0.0f;
this._currentVerticalSpan = 0.0f;
this._pointerLocations = new Dictionary <int, Offset>();
this._pointerQueue = new List <int>();
}
}
protected override bool isPointerAllowed(PointerDownEvent evt)
{
if (_firstTap == null)
{
switch (evt.buttons)
{
case gesture_.kPrimaryButton:
if (onDoubleTap == null)
{
return(false);
}
break;
default:
return(false);
}
}
return(base.isPointerAllowed(evt as PointerDownEvent));
}
public override void addAllowedPointer(PointerDownEvent evt)
{
if (_firstTap != null)
{
if (!_firstTap.isWithinGlobalTolerance(evt, Constants.kDoubleTapSlop))
{
// Ignore out-of-bounds second taps.
return;
}
else if (!_firstTap.hasElapsedMinTime() ||
!_firstTap.hasSameButton(evt as PointerDownEvent))
{
// Restart when the second tap is too close to the first, or when buttons
// mismatch.
_reset();
_trackFirstTap(evt);
return;
}
}
_trackFirstTap(evt);
}
public override void addAllowedPointer(PointerDownEvent evt)
{
this.startTrackingPointer(evt.pointer);
this._velocityTrackers[evt.pointer] = new VelocityTracker();
if (this._state == _DragState.ready)
{
this._state = _DragState.possible;
this._initialPosition = evt.position;
this._pendingDragOffset = Offset.zero;
this._lastPendingEventTimestamp = evt.timeStamp;
if (this.onDown != null)
{
this.invokeCallback <object>("onDown",
() => {
this.onDown(new DragDownDetails(globalPosition: this._initialPosition));
return(null);
});
}
}
else if (this._state == _DragState.accepted)
{
this.resolve(GestureDisposition.accepted);
}
}
protected bool isPointerAllowed(PointerDownEvent evt)
{
return(this._kind == null || this._kind == evt.kind);
}
protected virtual void handleNonAllowedPointer(PointerDownEvent evt)
{
}
public abstract void addAllowedPointer(PointerDownEvent evt);
protected abstract void handleTapCancel(PointerDownEvent down, PointerCancelEvent cancel, string reason);