private void TapGestureRecognizer_Tapped_nivel(object sender, EventArgs e)
{
IGestureRecognizer tgrIcon = ((Label)sender).GestureRecognizers[0];
VarGlobal.pro_hallazgo = ((TapGestureRecognizer)tgrIcon).CommandParameter as lc_pro_hallazgo;
var entidad = new ent_mensaje()
{
ico_mensaje = "fa-exclamation-circle",
tit_mensaje = "Nivel de riesgo",
tex_mensaje = VarGlobal.pro_hallazgo.nom_tblnivelriesgo
};
switch (VarGlobal.pro_hallazgo.nom_tblnivelriesgo)
{
case "ALTO":
entidad.col_mensaje = "#FF0000";
break;
case "MEDIO":
entidad.col_mensaje = "#FF8000";
break;
case "BAJO":
entidad.col_mensaje = "#FFBF00";
break;
}
VarGlobal._mensaje = new pg_mensaje(entidad);
Navigation.PushPopupAsync(VarGlobal._mensaje);
}
GestureHandler CreateHandler(IGestureRecognizer recognizer)
{
if (recognizer is TapGestureRecognizer)
{
return(new TapGestureHandler(recognizer));
}
else if (recognizer is PinchGestureRecognizer)
{
return(new PinchGestureHandler(recognizer));
}
else if (recognizer is PanGestureRecognizer)
{
return(new PanGestureHandler(recognizer));
}
else if (recognizer is SwipeGestureRecognizer)
{
return(new SwipeGestureHandler(recognizer));
}
else if (recognizer is DragGestureRecognizer)
{
return(new DragGestureHandler(recognizer, _renderer));
}
else if (recognizer is DropGestureRecognizer)
{
return(new DropGestureHandler(recognizer, _renderer));
}
return(Forms.GetHandlerForObject <GestureHandler>(recognizer, recognizer));
}
GestureHandler CreateHandler(IGestureRecognizer recognizer)
{
if (recognizer is TapGestureRecognizer)
{
return(new TapGestureHandler(recognizer));
}
else if (recognizer is PinchGestureRecognizer)
{
return(new PinchGestureHandler(recognizer, _handler));
}
else if (recognizer is PanGestureRecognizer)
{
return(new PanGestureHandler(recognizer));
}
else if (recognizer is SwipeGestureRecognizer)
{
return(new SwipeGestureHandler(recognizer));
}
else if (recognizer is DragGestureRecognizer)
{
return(new DragGestureHandler(recognizer, _handler));
}
else if (recognizer is DropGestureRecognizer)
{
return(new DropGestureHandler(recognizer, _handler));
}
return(Registrar.Registered.GetHandlerForObject <GestureHandler>(recognizer, recognizer));
}
public DropGestureHandler(IGestureRecognizer recognizer, IViewHandler handler) : base(recognizer)
{
_dragEnterCallback = OnEnterCallback;
_dragLeaveCallback = OnLeaveCallback;
_dropCallback = OnDropCallback;
Handler = handler;
}
void KinectListener(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == "IsClutched")
{
//Console.Beep();
IGestureRecognizer gr_sender = (IGestureRecognizer)sender;
if (gr_sender.IsClutched)
{
foreach (IGestureRecognizer gr in this.recognizers)
{
if (gr != sender)
{
gr.Disable();
}
}
}
else
{
foreach (IGestureRecognizer gr in this.recognizers)
{
gr.Enable();
}
}
}
}
public DragGestureHandler(IGestureRecognizer recognizer, IVisualElementRenderer renderer) : base(recognizer)
{
_iconCallback = OnIconCallback;
_dragDoneCallback = OnDragDoneCallback;
_isApi4 = DotnetUtil.TizenAPIVersion <= 4;
Renderer = renderer;
}
void Start()
{
playerInfoFileHandler = new FileHandler <int>(pathToPlayerInfoFile);
templatesFileHandler = new FileHandler <List <GestureTemplate> >(pathToTemplatesFile);
Trail.SetActive(false);
PlayerInfo.GetInfo(playerInfoFileHandler);
allTemplates = templatesFileHandler.Load();
foreach (GestureTemplate g in allTemplates)
{
g.AfterSerializing();
}
points = new List <Vector2>();
gestureRecognizer = new RecognizerWithFormCoeficient();
scoreUI.text = "0";
timeUI.text = "30:00";
Debug.Log("Templates loaded.");
template = allTemplates[Randomizer()];
Debug.Log(template.ToString());
PlayerInfo.CurrentScore = 0;
gestureRecognizer.Template = template.Points;
TemplateName.text = template.Name;
// DrawTemplate(template.Points);
}
protected override void OnAttachedTo(View bindable)
{
base.OnAttachedTo(bindable);
_gestureRecognizer = new TapGestureRecognizer {
Command = new Command(ShowControl)
};
AssociatedObject.GestureRecognizers.Add(_gestureRecognizer);
}
public DropGestureHandler(IGestureRecognizer recognizer, IVisualElementRenderer renderer) : base(recognizer)
{
_dragEnterCallback = OnEnterCallback;
_dragLeaveCallback = OnLeaveCallback;
_dropCallback = OnDropCallback;
_isApi4 = DotnetUtil.TizenAPIVersion <= 4;
Renderer = renderer;
}
public static void AddGestureRecognizer(this View view, IGestureRecognizer recognizer)
{
view.GestureRecognizers.Add (recognizer);
var baseGestureRecognizer = recognizer as BaseGestureRecognizer;
if (baseGestureRecognizer != null) {
view.ProcessGestureRecognizer (baseGestureRecognizer);
}
}
public static void AddGestureRecognizer(this View view, IGestureRecognizer recognizer)
{
view.GestureRecognizers.Add(recognizer);
var baseGestureRecognizer = recognizer as BaseGestureRecognizer;
if (baseGestureRecognizer != null)
{
view.ProcessGestureRecognizer(baseGestureRecognizer);
}
}
protected virtual NativeGestureRecognizer GetNativeRecognizer(IGestureRecognizer recognizer)
{
if (recognizer == null)
{
return(null);
}
var weakRecognizer = new WeakReference(recognizer);
var weakEventTracker = new WeakReference(this);
var tapRecognizer = recognizer as TapGestureRecognizer;
if (tapRecognizer != null && tapRecognizer.NumberOfTapsRequired == 1)
{
var returnAction = new TargetEventHandler((s, e) =>
{
var tapGestureRecognizer = weakRecognizer.Target as TapGestureRecognizer;
var eventTracker = weakEventTracker.Target as EventTracker;
var view = eventTracker?._renderer?.Element as View;
if (tapGestureRecognizer != null && view != null)
{
tapGestureRecognizer.SendTapped(view);
}
});
var uiRecognizer = new NativeGestureRecognizer
{
EventType = "click",
Handler = returnAction,
};
return(uiRecognizer);
}
if (tapRecognizer != null && tapRecognizer.NumberOfTapsRequired == 2)
{
var returnAction = new TargetEventHandler((s, e) =>
{
var tapGestureRecognizer = weakRecognizer.Target as TapGestureRecognizer;
var eventTracker = weakEventTracker.Target as EventTracker;
var view = eventTracker?._renderer?.Element as View;
if (tapGestureRecognizer != null && view != null)
{
tapGestureRecognizer.SendTapped(view);
}
});
var uiRecognizer = new NativeGestureRecognizer
{
EventType = "dblclick",
Handler = returnAction,
};
return(uiRecognizer);
}
return(null);
}
void ValidateGesture(IGestureRecognizer gesture)
{
if (gesture == null)
{
return;
}
if (gesture is PinchGestureRecognizer && _gestureRecognizers.GetGesturesFor <PinchGestureRecognizer>().Count() > 1)
{
throw new InvalidOperationException($"Only one {nameof(PinchGestureRecognizer)} per view is allowed");
}
}
GestureHandler CreateHandler(IGestureRecognizer recognizer)
{
var handlerType = Registrar.Registered.GetHandlerTypeForObject(recognizer);
if (handlerType != null)
{
return((GestureHandler)Activator.CreateInstance(handlerType, recognizer));
}
else
{
return(null);
}
}
public static bool ShouldBeMadeClickable(this View view)
{
for (var i = 0; i < view.GestureRecognizers.Count; i++)
{
IGestureRecognizer gesture = view.GestureRecognizers[i];
if (gesture is TapGestureRecognizer || gesture is PinchGestureRecognizer || gesture is PanGestureRecognizer)
{
return(true);
}
}
return(false);
}
internal override void ValidateGesture(IGestureRecognizer gesture)
{
switch (gesture)
{
case ClickGestureRecognizer click:
case TapGestureRecognizer tap:
case null:
break;
default:
throw new InvalidOperationException($"{gesture.GetType().Name} is not supported on a {nameof(Span)}");
}
}
void RemoveGesture(IGestureRecognizer recognizer)
{
var cache = _handlerCache;
var handler = LookupHandler(recognizer);
if (handler == null)
{
return;
}
var gestureType = cache.FirstOrDefault(x => x.Value.Contains(handler)).Key;
handler.PropertyChanged -= OnGestureRecognizerPropertyChanged;
cache[gestureType].Remove(handler);
if (cache[gestureType].Count == 0)
{
switch (gestureType)
{
case EGestureType.Tap:
case EGestureType.DoubleTap:
case EGestureType.TripleTap:
case EGestureType.LongTap:
RemoveTapGesture(gestureType);
break;
case EGestureType.Line:
RemoveLineGesture();
break;
case EGestureType.Flick:
RemoveFlickGesture();
break;
case EGestureType.Rotate:
RemoveRotateGesture();
break;
case EGestureType.Momentum:
RemoveMomentumGesture();
break;
case EGestureType.Zoom:
RemovePinchGesture();
break;
default:
break;
}
}
}
internal override void ValidateGesture(IGestureRecognizer gesture)
{
if (gesture == null)
{
return;
}
if (gesture is PanGestureRecognizer)
{
throw new InvalidOperationException($"{nameof(PanGestureRecognizer)} is not supported on a {nameof(Span)}");
}
if (gesture is PinchGestureRecognizer)
{
throw new InvalidOperationException($"{nameof(PinchGestureRecognizer)} is not supported on a {nameof(Span)}");
}
}
private static void AddGesture(View view, IGestureRecognizer gesture)
{
view.GestureRecognizers.Add(gesture);
var layout = view as Layout <View>;
if (layout == null)
{
return;
}
foreach (var child in layout.Children)
{
AddGesture(child, gesture);
}
}
GestureHandler LookupHandler(IGestureRecognizer recognizer)
{
var cache = _handlerCache;
foreach (var handlers in cache.Values)
{
foreach (var handler in handlers)
{
if (handler.Recognizer == recognizer)
{
return(handler);
}
}
}
return(null);
}
void LoadRecognizers()
{
if (ElementGestureRecognizers == null)
{
return;
}
#if __MOBILE__
if (_shouldReceiveTouch == null)
{
// Cache this so we don't create a new UITouchEventArgs instance for every recognizer
_shouldReceiveTouch = ShouldReceiveTouch;
}
#endif
for (int i = 0; i < ElementGestureRecognizers.Count; i++)
{
IGestureRecognizer recognizer = ElementGestureRecognizers[i];
if (_gestureRecognizers.ContainsKey(recognizer))
{
continue;
}
var nativeRecognizer = GetNativeRecognizer(recognizer);
if (nativeRecognizer != null)
{
#if __MOBILE__
nativeRecognizer.ShouldReceiveTouch = _shouldReceiveTouch;
#endif
_handler.AddGestureRecognizer(nativeRecognizer);
_gestureRecognizers[recognizer] = nativeRecognizer;
}
}
var toRemove = _gestureRecognizers.Keys.Where(key => !ElementGestureRecognizers.Contains(key)).ToArray();
for (int i = 0; i < toRemove.Length; i++)
{
IGestureRecognizer gestureRecognizer = toRemove[i];
var uiRecognizer = _gestureRecognizers[gestureRecognizer];
_gestureRecognizers.Remove(gestureRecognizer);
_handler.RemoveGestureRecognizer(uiRecognizer);
uiRecognizer.Dispose();
}
}
private void TapGestureRecognizer_Tapped_sincro(object sender, EventArgs e)
{
IGestureRecognizer tgrIcon = ((Label)sender).GestureRecognizers[0];
VarGlobal.pro_inspeccion = ((TapGestureRecognizer)tgrIcon).CommandParameter as lc_pro_inspeccion;
var entidad = new ent_mensaje()
{
ico_mensaje = "fa-cloud-upload",
tit_mensaje = "Sincronizado",
tex_mensaje = VarGlobal.pro_inspeccion.sincronizado ? "Registro Sincronizado" : "Registro NO Sincronizado",
col_mensaje = VarGlobal.pro_inspeccion.sincronizado ? "#04B404" : "#DF0101"
};
VarGlobal._mensaje = new pg_mensaje(entidad);
Navigation.PushPopupAsync(VarGlobal._mensaje);
}
protected virtual NativeGestureRecognizer GetNativeRecognizer(IGestureRecognizer recognizer)
{
//if (recognizer == null)
// return null;
//var weakRecognizer = new WeakReference(recognizer);
//var weakEventTracker = new WeakReference(this);
//var tapRecognizer = recognizer as TapGestureRecognizer;
//if (tapRecognizer != null && tapRecognizer.NumberOfTapsRequired == 1)
//{
// var returnAction = new TargetEventHandler((s, e) => {
// var tapGestureRecognizer = weakRecognizer.Target as TapGestureRecognizer;
// var eventTracker = weakEventTracker.Target as EventTracker;
// var view = eventTracker?._renderer?.Element as View;
// if (tapGestureRecognizer != null && view != null)
// tapGestureRecognizer.SendTapped(view);
// });
// var uiRecognizer = new NativeGestureRecognizer
// {
// EventType = "click",
// Handler = returnAction,
// };
// return uiRecognizer;
//}
//if (tapRecognizer != null && tapRecognizer.NumberOfTapsRequired == 2)
//{
// var returnAction = new TargetEventHandler((s, e) => {
// var tapGestureRecognizer = weakRecognizer.Target as TapGestureRecognizer;
// var eventTracker = weakEventTracker.Target as EventTracker;
// var view = eventTracker?._renderer?.Element as View;
// if (tapGestureRecognizer != null && view != null)
// tapGestureRecognizer.SendTapped(view);
// });
// var uiRecognizer = new NativeGestureRecognizer
// {
// EventType = "dblclick",
// Handler = returnAction,
// };
// return uiRecognizer;
//}
return(null);
}
public GamePresenter(
IGameEngine gameEngine,
IPhotoView photoView,
IGameResultView gameResultView,
ICurrentScoreView currentScoreView,
IEnumerable <IBucketView> bucketViews,
ITicker ticker,
IGestureRecognizer gestureRecognizer)
{
_gameEngine = gameEngine;
_photoView = photoView;
_gameResultView = gameResultView;
_currentScoreView = currentScoreView;
_bucketViews = bucketViews;
_ticker = ticker;
_gestureRecognizer = gestureRecognizer;
}
GestureHandler CreateHandler(IGestureRecognizer recognizer)
{
if (recognizer is TapGestureRecognizer)
{
return(new TapGestureHandler(recognizer));
}
else if (recognizer is PinchGestureRecognizer)
{
return(new PinchGestureHandler(recognizer));
}
else if (recognizer is PanGestureRecognizer)
{
return(new PanGestureHandler(recognizer));
}
else if (recognizer is SwipeGestureRecognizer)
{
return(new SwipeGestureHandler(recognizer));
}
return(System.Maui.Maui.GetHandlerForObject <GestureHandler>(recognizer, recognizer));
}
public static bool ShouldBeMadeClickable(this View view)
{
var shouldBeClickable = false;
for (var i = 0; i < view.GestureRecognizers.Count; i++)
{
IGestureRecognizer gesture = view.GestureRecognizers[i];
if (gesture is TapGestureRecognizer || gesture is PinchGestureRecognizer || gesture is PanGestureRecognizer)
{
shouldBeClickable = true;
break;
}
}
// do some evil
// This is required so that a layout only absorbs click events if it is not fully transparent
// However this is not desirable behavior in a ViewCell because it prevents the ViewCell from activating
if (view is Layout && view.BackgroundColor != Color.Transparent && view.BackgroundColor != Color.Default)
{
Element parent = view.RealParent;
var skip = false;
while (parent != null)
{
if (parent is ViewCell)
{
skip = true;
break;
}
parent = parent.RealParent;
}
if (!skip)
{
shouldBeClickable = true;
}
}
return(shouldBeClickable);
}
void Start()
{
try
{
templatesFileHandler = new FileHandler <List <GestureTemplate> >(pathToTemplatesFile);
allTemplates = templatesFileHandler.Load();
foreach (GestureTemplate g in allTemplates)
{
g.AfterSerializing();
}
}
catch
{
allTemplates = new List <GestureTemplate>();
}
points = new List <Vector2>();
trail = GameObject.Find("Trail");
gestureRecognizer = new RecognizerWithFormCoeficient();
brush = GameObject.Find("Brush");
trail.SetActive(false);
}
void LoadRecognizers()
{
if (ElementGestureRecognizers == null)
{
return;
}
#if __MOBILE__
if (_shouldReceiveTouch == null)
{
// Cache this so we don't create a new UITouchEventArgs instance for every recognizer
_shouldReceiveTouch = ShouldReceiveTouch;
}
#endif
#if __MOBILE__
UIDragInteraction uIDragInteraction = null;
UIDropInteraction uIDropInteraction = null;
if (_dragAndDropDelegate != null)
{
foreach (var interaction in _renderer.NativeView.Interactions)
{
if (interaction is UIDragInteraction uIDrag && uIDrag.Delegate == _dragAndDropDelegate)
{
uIDragInteraction = uIDrag;
}
if (interaction is UIDropInteraction uiDrop && uiDrop.Delegate == _dragAndDropDelegate)
{
uIDropInteraction = uiDrop;
}
}
}
bool dragFound = false;
bool dropFound = false;
#endif
for (int i = 0; i < ElementGestureRecognizers.Count; i++)
{
IGestureRecognizer recognizer = ElementGestureRecognizers[i];
if (_gestureRecognizers.ContainsKey(recognizer))
{
continue;
}
var nativeRecognizer = GetNativeRecognizer(recognizer);
if (nativeRecognizer != null && _handler != null)
{
#if __MOBILE__
nativeRecognizer.ShouldReceiveTouch = _shouldReceiveTouch;
#endif
_handler.AddGestureRecognizer(nativeRecognizer);
_gestureRecognizers[recognizer] = nativeRecognizer;
}
#if __MOBILE__
if (Forms.IsiOS11OrNewer && recognizer is DragGestureRecognizer)
{
dragFound = true;
_dragAndDropDelegate = _dragAndDropDelegate ?? new DragAndDropDelegate();
if (uIDragInteraction == null)
{
var interaction = new UIDragInteraction(_dragAndDropDelegate);
interaction.Enabled = true;
_renderer.NativeView.AddInteraction(interaction);
}
}
if (Forms.IsiOS11OrNewer && recognizer is DropGestureRecognizer)
{
dropFound = true;
_dragAndDropDelegate = _dragAndDropDelegate ?? new DragAndDropDelegate();
if (uIDropInteraction == null)
{
var interaction = new UIDropInteraction(_dragAndDropDelegate);
_renderer.NativeView.AddInteraction(interaction);
}
}
#endif
}
#if __MOBILE__
if (!dragFound && uIDragInteraction != null)
{
_renderer.NativeView.RemoveInteraction(uIDragInteraction);
}
if (!dropFound && uIDropInteraction != null)
{
_renderer.NativeView.RemoveInteraction(uIDropInteraction);
}
#endif
var toRemove = _gestureRecognizers.Keys.Where(key => !ElementGestureRecognizers.Contains(key)).ToArray();
for (int i = 0; i < toRemove.Length; i++)
{
IGestureRecognizer gestureRecognizer = toRemove[i];
var uiRecognizer = _gestureRecognizers[gestureRecognizer];
_gestureRecognizers.Remove(gestureRecognizer);
_handler.RemoveGestureRecognizer(uiRecognizer);
uiRecognizer.Dispose();
}
}
public TapGestureHandler(IGestureRecognizer recognizer) : base(recognizer)
{
}
public ZoomAndRotationGesture(IGestureRecognizer zoomIdentifier, IRotationGripGesture rotationIdentifier)
{
this.zoomIdentifier = zoomIdentifier;
this.rotationIdentifier = rotationIdentifier;
AngleControl = 5;
}
protected virtual NativeGestureRecognizer GetNativeRecognizer(IGestureRecognizer recognizer)
{
if (recognizer == null)
{
return(null);
}
var weakRecognizer = new WeakReference(recognizer);
var weakEventTracker = new WeakReference(this);
var tapRecognizer = recognizer as TapGestureRecognizer;
#if !__MOBILE__
if (recognizer is ClickGestureRecognizer clickRecognizer)
{
var returnAction = CreateRecognizerHandler(weakEventTracker, weakRecognizer, clickRecognizer);
var uiRecognizer = CreateClickRecognizer((int)clickRecognizer.Buttons, clickRecognizer.NumberOfClicksRequired, returnAction);
return(uiRecognizer);
}
if (tapRecognizer != null)
{
var returnAction = CreateTapRecognizerHandler(weakEventTracker, weakRecognizer);
var uiRecognizer = CreateTapRecognizer(tapRecognizer.NumberOfTapsRequired, returnAction);
return(uiRecognizer);
}
#else
if (tapRecognizer != null)
{
var returnAction = CreateRecognizerHandler(weakEventTracker, weakRecognizer, tapRecognizer);
var uiRecognizer = CreateTapRecognizer(tapRecognizer.NumberOfTapsRequired, returnAction);
return(uiRecognizer);
}
var swipeRecognizer = recognizer as SwipeGestureRecognizer;
if (swipeRecognizer != null)
{
var returnAction = new Action <SwipeDirection>((direction) =>
{
var swipeGestureRecognizer = weakRecognizer.Target as SwipeGestureRecognizer;
var eventTracker = weakEventTracker.Target as EventTracker;
var view = eventTracker?._renderer.Element as View;
if (swipeGestureRecognizer != null && view != null)
{
swipeGestureRecognizer.SendSwiped(view, direction);
}
});
var uiRecognizer = CreateSwipeRecognizer(swipeRecognizer.Direction, returnAction, 1);
return(uiRecognizer);
}
#endif
if (recognizer is ChildGestureRecognizer childRecognizer)
{
#if !__MOBILE__
if (childRecognizer.GestureRecognizer is ClickGestureRecognizer clickChildRecognizer)
{
var returnAction = CreateChildRecognizerHandler(weakEventTracker, weakRecognizer);
var uiRecognizer = CreateClickRecognizer((int)clickChildRecognizer.Buttons, clickChildRecognizer.NumberOfClicksRequired, returnAction);
return(uiRecognizer);
}
if (childRecognizer.GestureRecognizer is TapGestureRecognizer tapChildRecognizer)
{
var returnAction = CreateChildTapRecognizerHandler(weakEventTracker, weakRecognizer);
var uiRecognizer = CreateTapRecognizer(tapChildRecognizer.NumberOfTapsRequired, returnAction);
return(uiRecognizer);
}
#else
if (childRecognizer.GestureRecognizer is TapGestureRecognizer tapChildRecognizer)
{
var returnAction = CreateChildRecognizerHandler(weakEventTracker, weakRecognizer);
var uiRecognizer = CreateTapRecognizer(tapChildRecognizer.NumberOfTapsRequired, returnAction);
return(uiRecognizer);
}
#endif
}
var pinchRecognizer = recognizer as PinchGestureRecognizer;
if (pinchRecognizer != null)
{
double startingScale = 1;
var uiRecognizer = CreatePinchRecognizer(r =>
{
var pinchGestureRecognizer = weakRecognizer.Target as PinchGestureRecognizer;
var eventTracker = weakEventTracker.Target as EventTracker;
var view = eventTracker?._renderer?.Element as View;
if (pinchGestureRecognizer != null && eventTracker != null && view != null)
{
var oldScale = eventTracker._previousScale;
var originPoint = r.LocationInView(null);
#if __MOBILE__
originPoint = UIApplication.SharedApplication.GetKeyWindow().ConvertPointToView(originPoint, eventTracker._renderer.NativeView);
#else
originPoint = NSApplication.SharedApplication.KeyWindow.ContentView.ConvertPointToView(originPoint, eventTracker._renderer.NativeView);
#endif
var scaledPoint = new Point(originPoint.X / view.Width, originPoint.Y / view.Height);
switch (r.State)
{
case NativeGestureRecognizerState.Began:
#if __MOBILE__
if (r.NumberOfTouches < 2)
{
return;
}
#endif
pinchGestureRecognizer.SendPinchStarted(view, scaledPoint);
startingScale = view.Scale;
break;
case NativeGestureRecognizerState.Changed:
#if __MOBILE__
if (r.NumberOfTouches < 2 && pinchGestureRecognizer.IsPinching)
{
r.State = NativeGestureRecognizerState.Ended;
pinchGestureRecognizer.SendPinchEnded(view);
return;
}
var scale = r.Scale;
#else
var scale = r.Magnification;
#endif
var delta = 1.0;
var dif = Math.Abs(scale - oldScale) * startingScale;
if (oldScale < scale)
{
delta = 1 + dif;
}
if (oldScale > scale)
{
delta = 1 - dif;
}
pinchGestureRecognizer.SendPinch(view, delta, scaledPoint);
eventTracker._previousScale = scale;
break;
case NativeGestureRecognizerState.Cancelled:
case NativeGestureRecognizerState.Failed:
if (pinchGestureRecognizer.IsPinching)
{
pinchGestureRecognizer.SendPinchCanceled(view);
}
break;
case NativeGestureRecognizerState.Ended:
if (pinchGestureRecognizer.IsPinching)
{
pinchGestureRecognizer.SendPinchEnded(view);
}
eventTracker._previousScale = 1;
break;
}
}
});
return(uiRecognizer);
}
var panRecognizer = recognizer as PanGestureRecognizer;
if (panRecognizer != null)
{
var uiRecognizer = CreatePanRecognizer(panRecognizer.TouchPoints, r =>
{
var eventTracker = weakEventTracker.Target as EventTracker;
var view = eventTracker?._renderer?.Element as View;
var panGestureRecognizer = weakRecognizer.Target as PanGestureRecognizer;
if (panGestureRecognizer != null && view != null)
{
switch (r.State)
{
case NativeGestureRecognizerState.Began:
#if __MOBILE__
if (r.NumberOfTouches != panRecognizer.TouchPoints)
{
return;
}
#endif
panGestureRecognizer.SendPanStarted(view, Application.Current.PanGestureId);
break;
case NativeGestureRecognizerState.Changed:
#if __MOBILE__
if (r.NumberOfTouches != panRecognizer.TouchPoints)
{
r.State = NativeGestureRecognizerState.Ended;
panGestureRecognizer.SendPanCompleted(view, Application.Current.PanGestureId);
Application.Current.PanGestureId++;
return;
}
#endif
var translationInView = r.TranslationInView(_handler);
panGestureRecognizer.SendPan(view, translationInView.X, translationInView.Y, Application.Current.PanGestureId);
break;
case NativeGestureRecognizerState.Cancelled:
case NativeGestureRecognizerState.Failed:
panGestureRecognizer.SendPanCanceled(view, Application.Current.PanGestureId);
Application.Current.PanGestureId++;
break;
case NativeGestureRecognizerState.Ended:
#if __MOBILE__
if (r.NumberOfTouches != panRecognizer.TouchPoints)
{
panGestureRecognizer.SendPanCompleted(view, Application.Current.PanGestureId);
Application.Current.PanGestureId++;
}
#else
panGestureRecognizer.SendPanCompleted(view, Application.Current.PanGestureId);
Application.Current.PanGestureId++;
#endif
break;
}
}
});
return(uiRecognizer);
}
return(null);
}
public ZoomAndRotationGesture()
{
zoomIdentifier = new ZoomGripGesture();
rotationIdentifier = new RotationGripGesture();
AngleControl = 5;
}
internal virtual void ValidateGesture(IGestureRecognizer gesture)
{
}
public void Add(IGestureRecognizer recognizer)
{
recognizer.PropertyChanged += KinectListener;
this.recognizers.Add(recognizer);
}
public CalibrationWindow(IGestureRecognizer rec, GesturePack gestures)
{
model = new CalibrationModel(new ModelToViewAdapter(() => { return view; }), rec, gestures);
view = new CalibrationView();
}
public ConfigurationWindow(IGestureRecognizer rec, GesturePack gestures)
{
// Take advantage of closure to get reference to the uninitialized view
model = new ConfigurationModel(new ModelToViewAdapter(() => { return view; }), rec, gestures);
view = new ConfigurationView(new ViewToModelAdapter(() => { return model; }));
}
void ValidateGesture(IGestureRecognizer gesture)
{
if (gesture == null)
return;
if (gesture is PinchGestureRecognizer && _gestureRecognizers.GetGesturesFor<PinchGestureRecognizer>().Count() > 1)
throw new InvalidOperationException($"Only one {nameof(PinchGestureRecognizer)} per view is allowed");
}
protected virtual UIGestureRecognizer GetNativeRecognizer(IGestureRecognizer recognizer)
{
if (recognizer == null)
return null;
var weakRecognizer = new WeakReference(recognizer);
var weakEventTracker = new WeakReference(this);
var tapRecognizer = recognizer as TapGestureRecognizer;
if (tapRecognizer != null)
{
var uiRecognizer = CreateTapRecognizer(1, tapRecognizer.NumberOfTapsRequired, r =>
{
var tapGestureRecognizer = weakRecognizer.Target as TapGestureRecognizer;
var eventTracker = weakEventTracker.Target as EventTracker;
var view = eventTracker?._renderer?.Element as View;
if (tapGestureRecognizer != null && view != null)
tapGestureRecognizer.SendTapped(view);
});
return uiRecognizer;
}
var pinchRecognizer = recognizer as PinchGestureRecognizer;
if (pinchRecognizer != null)
{
double startingScale = 1;
var uiRecognizer = CreatePinchRecognizer(r =>
{
var pinchGestureRecognizer = weakRecognizer.Target as IPinchGestureController;
var eventTracker = weakEventTracker.Target as EventTracker;
var view = eventTracker?._renderer?.Element as View;
if (pinchGestureRecognizer != null && eventTracker != null && view != null)
{
var oldScale = eventTracker._previousScale;
var originPoint = r.LocationInView(null);
originPoint = UIApplication.SharedApplication.KeyWindow.ConvertPointToView(originPoint, eventTracker._renderer.NativeView);
var scaledPoint = new Point(originPoint.X / view.Width, originPoint.Y / view.Height);
switch (r.State)
{
case UIGestureRecognizerState.Began:
if (r.NumberOfTouches < 2)
return;
pinchGestureRecognizer.SendPinchStarted(view, scaledPoint);
startingScale = view.Scale;
break;
case UIGestureRecognizerState.Changed:
if (r.NumberOfTouches < 2 && pinchGestureRecognizer.IsPinching)
{
r.State = UIGestureRecognizerState.Ended;
pinchGestureRecognizer.SendPinchEnded(view);
return;
}
var delta = 1.0;
var dif = Math.Abs(r.Scale - oldScale) * startingScale;
if (oldScale < r.Scale)
delta = 1 + dif;
if (oldScale > r.Scale)
delta = 1 - dif;
pinchGestureRecognizer.SendPinch(view, delta, scaledPoint);
eventTracker._previousScale = r.Scale;
break;
case UIGestureRecognizerState.Cancelled:
case UIGestureRecognizerState.Failed:
if (pinchGestureRecognizer.IsPinching)
pinchGestureRecognizer.SendPinchCanceled(view);
break;
case UIGestureRecognizerState.Ended:
if (pinchGestureRecognizer.IsPinching)
pinchGestureRecognizer.SendPinchEnded(view);
eventTracker._previousScale = 1;
break;
}
}
});
return uiRecognizer;
}
var panRecognizer = recognizer as PanGestureRecognizer;
if (panRecognizer != null)
{
var uiRecognizer = CreatePanRecognizer(panRecognizer.TouchPoints, r =>
{
var eventTracker = weakEventTracker.Target as EventTracker;
var view = eventTracker?._renderer?.Element as View;
var panGestureRecognizer = weakRecognizer.Target as IPanGestureController;
if (panGestureRecognizer != null && view != null)
{
switch (r.State)
{
case UIGestureRecognizerState.Began:
if (r.NumberOfTouches != panRecognizer.TouchPoints)
return;
panGestureRecognizer.SendPanStarted(view, Application.Current.PanGestureId);
break;
case UIGestureRecognizerState.Changed:
if (r.NumberOfTouches != panRecognizer.TouchPoints)
{
r.State = UIGestureRecognizerState.Ended;
panGestureRecognizer.SendPanCompleted(view, Application.Current.PanGestureId);
Application.Current.PanGestureId++;
return;
}
var translationInView = r.TranslationInView(_handler);
panGestureRecognizer.SendPan(view, translationInView.X, translationInView.Y, Application.Current.PanGestureId);
break;
case UIGestureRecognizerState.Cancelled:
case UIGestureRecognizerState.Failed:
panGestureRecognizer.SendPanCanceled(view, Application.Current.PanGestureId);
Application.Current.PanGestureId++;
break;
case UIGestureRecognizerState.Ended:
if (r.NumberOfTouches != panRecognizer.TouchPoints)
{
panGestureRecognizer.SendPanCompleted(view, Application.Current.PanGestureId);
Application.Current.PanGestureId++;
}
break;
}
}
});
return uiRecognizer;
}
return null;
}
