Gestione di due, tre, quattro dita Swipe Gestures in WinRT App

Question

ho il seguente codice:

private Point initialpoint; 

private void ManipulationStarted(object sender, ManipulationStartedRoutedEventArgs e) 
{ 
    initialpoint = e.Position; 
} 

private void ManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e) 
{ 
    Point currentpoint = e.Position; 
    if (currentpoint.X - initialpoint.X >= 100) 
    { 
     System.Diagnostics.Debug.WriteLine("Swipe Right"); 
     e.Complete(); 
    } 
} 

posso gestire 1 dito gesto di scorrimento molto facilmente, ma voglio gestire 2, 3, 4 dita strisciare gesti anche Qualcuno può dirmi come farlo?

Answer 1

In base a questo MSDN Forum Posting è necessario utilizzare le notifiche pointer. La documentazione con lavorare esempio di codice risiede nel MSDN Library

Da ultimo collegamento:

Un oggetto puntatore rappresenta un singolo ingresso unico "contatto" (un PointerPoint) da un dispositivo di ingresso (ad esempio un mouse, penna/stilo, dito singolo o più dita). Il sistema crea un puntatore quando viene rilevato per la prima volta un contatto e lo distrugge quando il puntatore abbandona (parte) il raggio di rilevamento o viene cancellato. Nel caso di più dispositivi o input multi-touch, ogni contatto viene considerato come un puntatore univoco.

---

Solo un avvertimento, non ho un dispositivo multitouch di Windows 8 per testare questo codice su. Quindi è stato testato in Simuator con tutti i suoi limiti e, come menzionato nei link sopra, Windows 8 non ha un supporto gestuale per rilevare più dita, è necessario utilizzare funzioni di livello inferiore.

Prima di tutto ho aggiunto altri due dizionari al codice di esempio MSDN sopra e due variabili per la soglia di scorrimento alle definizioni di classe.

Dictionary<uint, Point> startLocation; 
Dictionary<uint, bool> pointSwiped; 
int swipeThresholdX = 100; 
int swipeThresholdY = 100; 

Ho poi inizializzare i dictionarys nel costruttore del form

startLocation = new Dictionary<uint, Point>((int)SupportedContacts.Contacts); 
pointSwiped = new Dictionary<uint, bool>((int)SupportedContacts.Contacts); 

Poi ogni luogo che il dizionario originale è stato aggiunto o aveva un elemento rimosso ho fatto lo stesso con il nuovo Dizionario del

aggiungendo:

startLocation[pt.PointerId] = pt.Position; 
pointSwiped[pt.PointerId] = false; 

rimozione:

01.235.

startLocation.Remove(pt.PointerId); 
pointSwiped.Remove(pt.PointerId); 

Poi finalmente messi insieme nel PointerMovedEvent:

private void targetContainer_PointerMoved(object sender, PointerRoutedEventArgs e) 
{ 
    Windows.UI.Input.PointerPoint currentPoint = e.GetCurrentPoint(targetContainer); 
    if (currentPoint.IsInContact) 
    { 
     if (startLocation.ContainsKey(currentPoint.PointerId)) 
     { 
      Point startPoint = startLocation[currentPoint.PointerId]; 
      if (Math.Abs(currentPoint.Position.X - startPoint.X) > swipeThresholdX) // I only did one Axis for testing 
      { 
       pointSwiped[currentPoint.PointerId] = true; 
      } 
     } 
    } 
    updateInfoPop(e); 
}    

finale Modificato MSDN Esempio:

using System; 
using System.Collections.Generic; 
using System.IO; 
using System.Linq; 
using Windows.Foundation; 
using Windows.Foundation.Collections; 
using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
using Windows.UI.Xaml.Controls.Primitives; 
using Windows.UI.Xaml.Data; 
using Windows.UI.Xaml.Input; 
using Windows.UI.Xaml.Media; 
using Windows.UI.Xaml.Navigation; 

// The Blank Page item template is documented at http://go.microsoft.com/fwlink/?LinkId=234238 

namespace PointerInput 
{ 
    /// <summary> 
    /// An empty page that can be used on its own or navigated to within a Frame. 
    /// </summary> 
    public sealed partial class MainPage : Page 
    { 
     Windows.Devices.Input.TouchCapabilities SupportedContacts = new Windows.Devices.Input.TouchCapabilities(); 

     uint numActiveContacts; 
     Dictionary<uint, Windows.UI.Input.PointerPoint> contacts; 
     Dictionary<uint, Point> startLocation; 
     Dictionary<uint, bool> pointSwiped; 
     int swipeThresholdX = 100; 
     int swipeThresholdY = 100; 

     public MainPage() 
     { 
      this.InitializeComponent(); 
      numActiveContacts = 0; 
      contacts = new Dictionary<uint, Windows.UI.Input.PointerPoint>((int)SupportedContacts.Contacts); 
      startLocation = new Dictionary<uint, Point>((int)SupportedContacts.Contacts); 
      pointSwiped = new Dictionary<uint, bool>((int)SupportedContacts.Contacts); 
      targetContainer.PointerPressed += new PointerEventHandler(targetContainer_PointerPressed); 
      targetContainer.PointerEntered += new PointerEventHandler(targetContainer_PointerEntered); 
      targetContainer.PointerReleased += new PointerEventHandler(targetContainer_PointerReleased); 
      targetContainer.PointerExited += new PointerEventHandler(targetContainer_PointerExited); 
      targetContainer.PointerCanceled += new PointerEventHandler(targetContainer_PointerCanceled); 
      targetContainer.PointerCaptureLost += new PointerEventHandler(targetContainer_PointerCaptureLost); 
      targetContainer.PointerMoved += new PointerEventHandler(targetContainer_PointerMoved); 
     } 

     // PointerPressed and PointerReleased events do not always occur in pairs. 
     // Your app should listen for and handle any event that might conclude a pointer down action 
     // (such as PointerExited, PointerCanceled, and PointerCaptureLost). 
     void targetContainer_PointerPressed(object sender, PointerRoutedEventArgs e) 
     { 
      if (Convert.ToBoolean(SupportedContacts.TouchPresent) && (numActiveContacts > SupportedContacts.Contacts)) 
      { 
       // cannot support more contacts 
       eventLog.Text += "\nNumber of contacts exceeds the number supported by the device."; 
       return; 
      } 

      Windows.UI.Input.PointerPoint pt = e.GetCurrentPoint(targetContainer); 

      // Update event sequence. 
      eventLog.Text += "\nDown: " + pt.PointerId; 

      // Change background color of target when pointer contact detected. 
      targetContainer.Fill = new SolidColorBrush(Windows.UI.Colors.Green); 

      // Check if pointer already exists (if enter occurred prior to down). 
      if (contacts.ContainsKey(pt.PointerId)) 
      { 
       return; 
      } 
      contacts[pt.PointerId] = pt; 
      startLocation[pt.PointerId] = pt.Position; 
      pointSwiped[pt.PointerId] = false; 
      ++numActiveContacts; 
      e.Handled = true; 

      // Display pointer details. 
      createInfoPop(e); 
     } 

     private void targetContainer_PointerEntered(object sender, PointerRoutedEventArgs e) 
     { 
      Windows.UI.Input.PointerPoint pt = e.GetCurrentPoint(targetContainer); 

      // Update event sequence. 
      eventLog.Text += "\nOver: " + pt.PointerId; 

      if (contacts.Count == 0) 
      { 
       // Change background color of target when pointer contact detected. 
       targetContainer.Fill = new SolidColorBrush(Windows.UI.Colors.Blue); 
      } 

      // Check if pointer already exists (if enter occurred prior to down). 
      if (contacts.ContainsKey(pt.PointerId)) 
      { 
       return; 
      } 

      // Push new pointer Id onto expando target pointers array. 
      contacts[pt.PointerId] = pt; 
      startLocation[pt.PointerId] = pt.Position; 
      pointSwiped[pt.PointerId] = false; 
      ++numActiveContacts; 
      e.Handled = true; 

      // Display pointer details. 
      createInfoPop(e); 
     } 

     // Fires for for various reasons, including: 
     // - User interactions 
     // - Programmatic caputre of another pointer 
     // - Captured pointer was deliberately released 
     // PointerCaptureLost can fire instead of PointerReleased. 
     private void targetContainer_PointerCaptureLost(object sender, PointerRoutedEventArgs e) 
     { 
      Windows.UI.Input.PointerPoint pt = e.GetCurrentPoint(targetContainer); 

      // Update event sequence. 
      eventLog.Text += "\nPointer capture lost: " + pt.PointerId; 

      if (contacts.ContainsKey(pt.PointerId)) 
      { 
       checkSwipe(); 
       contacts[pt.PointerId] = null; 
       contacts.Remove(pt.PointerId); 
       startLocation.Remove(pt.PointerId); 
       if (pointSwiped.ContainsKey(pt.PointerId)) 
        pointSwiped.Remove(pt.PointerId); 

       --numActiveContacts; 
      } 

      // Update the UI and pointer details. 
      foreach (TextBlock tb in pointerInfo.Children) 
      { 
       if (tb.Name == e.Pointer.PointerId.ToString()) 
       { 
        pointerInfo.Children.Remove(tb); 
       } 
      } 

      if (contacts.Count == 0) 
      { 
       targetContainer.Fill = new SolidColorBrush(Windows.UI.Colors.Black); 
      } 

      e.Handled = true; 
     } 

     // Fires for for various reasons, including: 
     // - A touch contact is canceled by a pen coming into range of the surface. 
     // - The device doesn't report an active contact for more than 100ms. 
     // - The desktop is locked or the user logged off. 
     // - The number of simultaneous contacts exceeded the number supported by the device. 
     private void targetContainer_PointerCanceled(object sender, PointerRoutedEventArgs e) 
     { 
      Windows.UI.Input.PointerPoint pt = e.GetCurrentPoint(targetContainer); 

      // Update event sequence. 
      eventLog.Text += "\nPointer canceled: " + pt.PointerId; 

      if (contacts.ContainsKey(pt.PointerId)) 
      { 
       checkSwipe(); 
       contacts[pt.PointerId] = null; 
       contacts.Remove(pt.PointerId); 
       startLocation.Remove(pt.PointerId); 
       if (pointSwiped.ContainsKey(pt.PointerId)) 
        pointSwiped.Remove(pt.PointerId); 

       --numActiveContacts; 
      } 

      // Update the UI and pointer details. 
      foreach (TextBlock tb in pointerInfo.Children) 
      { 
       if (tb.Name == e.Pointer.PointerId.ToString()) 
       { 
        pointerInfo.Children.Remove(tb); 
       } 
      } 

      if (contacts.Count == 0) 
      { 
       targetContainer.Fill = new SolidColorBrush(Windows.UI.Colors.Black); 
      } 

      e.Handled = true; 
     } 

     private void targetContainer_PointerExited(object sender, PointerRoutedEventArgs e) 
     { 
      Windows.UI.Input.PointerPoint pt = e.GetCurrentPoint(targetContainer); 

      // Update event sequence. 
      eventLog.Text += "\nPointer exited: " + pt.PointerId; 

      if (contacts.ContainsKey(pt.PointerId)) 
      { 
       checkSwipe(); 
       contacts[pt.PointerId] = null; 
       contacts.Remove(pt.PointerId); 
       startLocation.Remove(pt.PointerId); 
       if (pointSwiped.ContainsKey(pt.PointerId)) 
        pointSwiped.Remove(pt.PointerId); 

       --numActiveContacts; 
      } 

      // Update the UI and pointer details. 
      foreach (TextBlock tb in pointerInfo.Children) 
      { 
       if (tb.Name == e.Pointer.PointerId.ToString()) 
       { 
        pointerInfo.Children.Remove(tb); 
       } 
      } 

      if (contacts.Count == 0) 
      { 
       targetContainer.Fill = new SolidColorBrush(Windows.UI.Colors.Gray); 

      } 
      e.Handled = true; 
     } 

     /// <summary> 
     /// Invoked when this page is about to be displayed in a Frame. 
     /// </summary> 
     /// <param name="e">Event data that describes how this page was reached. The Parameter 
     /// property is typically used to configure the page.</param> 
     protected override void OnNavigatedTo(NavigationEventArgs e) 
     { 
     } 

     void targetContainer_PointerReleased(object sender, PointerRoutedEventArgs e) 
     { 
      foreach (TextBlock tb in pointerInfo.Children) 
      { 
       if (tb.Name == e.Pointer.PointerId.ToString()) 
       { 
        pointerInfo.Children.Remove(tb); 
       } 
      } 

      Windows.UI.Input.PointerPoint pt = e.GetCurrentPoint(targetContainer); 

      // Update event sequence. 
      eventLog.Text += "\nUp: " + pt.PointerId; 

      // Change background color of target when pointer contact detected. 
      targetContainer.Fill = new SolidColorBrush(Windows.UI.Colors.Red); 

      if (contacts.ContainsKey(pt.PointerId)) 
      { 
       checkSwipe(); 
       contacts[pt.PointerId] = null; 
       contacts.Remove(pt.PointerId); 
       startLocation.Remove(pt.PointerId); 
       if(pointSwiped.ContainsKey(pt.PointerId)) 
        pointSwiped.Remove(pt.PointerId); 

       --numActiveContacts; 
      } 
      e.Handled = true; 
     } 

     private void targetContainer_PointerMoved(object sender, PointerRoutedEventArgs e) 
     { 
      Windows.UI.Input.PointerPoint currentPoint = e.GetCurrentPoint(targetContainer); 
      if (currentPoint.IsInContact) 
      { 
       if (startLocation.ContainsKey(currentPoint.PointerId)) 
       { 
        Point startPoint = startLocation[currentPoint.PointerId]; 
        if (Math.Abs(currentPoint.Position.X - startPoint.X) > swipeThresholdX) // I only did one Axis for testing 
        { 
         pointSwiped[currentPoint.PointerId] = true; 
        } 
       } 

      } 
      updateInfoPop(e); 
     } 

     int numberOfSwipedFingers() 
     { 
      int count = 0; 
      foreach (var item in pointSwiped) 
      { 
       if (item.Value) { count += 1; } 
      } 
      return count; 
     } 

     void checkSwipe() 
     { 
      int fingers = numberOfSwipedFingers(); 
      if (fingers > 1) 
      { 
       eventLog.Text += "\nNumber of Swiped fingers = " + fingers; 
      } 
      else if (fingers == 1) 
      { 
       eventLog.Text += "\nNumber of Swiped fingers = " + fingers; 
      } 
      if(fingers > 0) 
       pointSwiped.Clear(); 
     }    

     void createInfoPop(PointerRoutedEventArgs e) 
     { 
      Windows.UI.Input.PointerPoint currentPoint = e.GetCurrentPoint(targetContainer); 
      TextBlock pointerDetails = new TextBlock(); 
      pointerDetails.Name = currentPoint.PointerId.ToString(); 
      pointerDetails.Foreground = new SolidColorBrush(Windows.UI.Colors.White); 
      pointerInfo.Children.Add(pointerDetails); 
      pointerDetails.Text = queryPointer(e); 
     } 

     void updateInfoPop(PointerRoutedEventArgs e) 
     { 
      foreach (TextBlock pointerDetails in pointerInfo.Children) 
      { 
       if (pointerDetails.Name == e.Pointer.PointerId.ToString()) 
       { 
        pointerDetails.Text = queryPointer(e); 
       } 
      } 
     } 

     String queryPointer(PointerRoutedEventArgs e) 
     { 
      Windows.UI.Input.PointerPoint currentPoint = e.GetCurrentPoint(targetContainer); 
      String details = ""; 
      switch (e.Pointer.PointerDeviceType) 
      { 
       case Windows.Devices.Input.PointerDeviceType.Mouse: 
        details += "\nPointer type: mouse"; 
        break; 
       case Windows.Devices.Input.PointerDeviceType.Pen: 
        details += "\nPointer type: pen"; 
        if (e.Pointer.IsInContact) 
        { 
         details += "\nPressure: " + currentPoint.Properties.Pressure; 
         details += "\nrotation: " + currentPoint.Properties.Orientation; 
         details += "\nTilt X: " + currentPoint.Properties.XTilt; 
         details += "\nTilt Y: " + currentPoint.Properties.YTilt; 
         details += "\nBarrel button pressed: " + currentPoint.Properties.IsBarrelButtonPressed; 
        } 
        break; 
       case Windows.Devices.Input.PointerDeviceType.Touch: 
        details += "\nPointer type: touch"; 
        details += "\nrotation: " + currentPoint.Properties.Orientation; 
        details += "\nTilt X: " + currentPoint.Properties.XTilt; 
        details += "\nTilt Y: " + currentPoint.Properties.YTilt; 
        break; 
       default: 
        details += "\nPointer type: n/a"; 
        break; 
      } 

      GeneralTransform gt = targetContainer.TransformToVisual(page); 
      Point screenPoint; 

      screenPoint = gt.TransformPoint(new Point(currentPoint.Position.X, currentPoint.Position.Y)); 
      details += "\nPointer Id: " + currentPoint.PointerId.ToString() + 
       "\nPointer location (parent): " + currentPoint.Position.X + ", " + currentPoint.Position.Y + 
       "\nPointer location (screen): " + screenPoint.X + ", " + screenPoint.Y; 
      return details; 
     } 
    } 
} 

Answer 2

ho adattato risposta da Mark Hall a una classe separata e di trattare con colpi fino , in basso, a sinistra ea destra.Ha ancora dei problemi in cui è possibile sollevare le dita in tempi diversi e ottenere più eventi e potrebbe essere migliorata, anche se funziona per le mie esigenze:

public enum DirectionSwiped 
{ 
    None, 
    Up, 
    Down, 
    Left, 
    Right 
} 


public class SwipeEventArgs : EventArgs 
{ 
    public DirectionSwiped Direction { get; set; } 
    public int NumberOfTouches { get; set; } 
} 


public class SwipeGestureDetector 
{ 
    public EventHandler<SwipeEventArgs> SwipeDetected; 




    // How much of the grid needs to be covered by the swipe? 
    private const double SWIPE_THRESHOLD = 0.5; 

    // How much drift is allowed in the opposite axis? 
    private const int ALLOWED_DRIFT = 100; 

    Windows.Devices.Input.TouchCapabilities SupportedContacts = new Windows.Devices.Input.TouchCapabilities(); 

    uint numActiveContacts; 
    Dictionary<uint, Windows.UI.Input.PointerPoint> contacts; 
    Dictionary<uint, Point> startLocation; 
    Dictionary<uint, DirectionSwiped> pointSwiped; 

    private Grid mGrid; 





    public SwipeGestureDetector(Grid grid) 
    { 
     mGrid = grid; 

     numActiveContacts = 0; 
     contacts = new Dictionary<uint, Windows.UI.Input.PointerPoint>((int)SupportedContacts.Contacts); 
     startLocation = new Dictionary<uint, Point>((int)SupportedContacts.Contacts); 
     pointSwiped = new Dictionary<uint, DirectionSwiped>((int)SupportedContacts.Contacts); 
     grid.PointerPressed += new PointerEventHandler(Grid_PointerPressed); 
     grid.PointerEntered += new PointerEventHandler(Grid_PointerEntered); 
     grid.PointerReleased += new PointerEventHandler(Grid_PointerReleased); 
     grid.PointerExited += new PointerEventHandler(Grid_PointerExited); 
     grid.PointerCanceled += new PointerEventHandler(Grid_PointerCanceled); 
     grid.PointerCaptureLost += new PointerEventHandler(Grid_PointerCaptureLost); 
     grid.PointerMoved += new PointerEventHandler(Grid_PointerMoved); 
    } 





    // PointerPressed and PointerReleased events do not always occur in pairs. 
    // Your app should listen for and handle any event that might conclude a pointer down action 
    // (such as PointerExited, PointerCanceled, and PointerCaptureLost). 
    void Grid_PointerPressed(object sender, PointerRoutedEventArgs e) 
    { 
     if (Convert.ToBoolean(SupportedContacts.TouchPresent) && (numActiveContacts > SupportedContacts.Contacts)) 
     { 
      // cannot support more contacts 
      Debug.WriteLine("\nNumber of contacts exceeds the number supported by the device."); 
      return; 
     } 

     Windows.UI.Input.PointerPoint pt = e.GetCurrentPoint(mGrid); 

     // Check if pointer already exists (if enter occurred prior to down). 
     if (contacts.ContainsKey(pt.PointerId)) 
     { 
      return; 
     } 
     contacts[pt.PointerId] = pt; 
     startLocation[pt.PointerId] = pt.Position; 
     pointSwiped[pt.PointerId] = DirectionSwiped.None; 
     ++numActiveContacts; 
     e.Handled = true; 
    } 


    private void Grid_PointerEntered(object sender, PointerRoutedEventArgs e) 
    { 
     Windows.UI.Input.PointerPoint pt = e.GetCurrentPoint(mGrid); 

     // Check if pointer already exists (if enter occurred prior to down). 
     if (contacts.ContainsKey(pt.PointerId)) 
     { 
      return; 
     } 

     // Push new pointer Id onto expando target pointers array. 
     contacts[pt.PointerId] = pt; 
     startLocation[pt.PointerId] = pt.Position; 
     pointSwiped[pt.PointerId] = DirectionSwiped.None; 
     ++numActiveContacts; 
     e.Handled = true; 

    } 


    // Fires for for various reasons, including: 
    // - User interactions 
    // - Programmatic caputre of another pointer 
    // - Captured pointer was deliberately released 
    // PointerCaptureLost can fire instead of PointerReleased. 
    private void Grid_PointerCaptureLost(object sender, PointerRoutedEventArgs e) 
    { 
     Windows.UI.Input.PointerPoint pt = e.GetCurrentPoint(mGrid); 

     if (contacts.ContainsKey(pt.PointerId)) 
     { 
      checkSwipe(); 
      contacts[pt.PointerId] = null; 
      contacts.Remove(pt.PointerId); 
      startLocation.Remove(pt.PointerId); 
      if (pointSwiped.ContainsKey(pt.PointerId)) 
       pointSwiped.Remove(pt.PointerId); 

      --numActiveContacts; 
     } 

     e.Handled = true; 
    } 


    // Fires for for various reasons, including: 
    // - A touch contact is canceled by a pen coming into range of the surface. 
    // - The device doesn't report an active contact for more than 100ms. 
    // - The desktop is locked or the user logged off. 
    // - The number of simultaneous contacts exceeded the number supported by the device. 
    private void Grid_PointerCanceled(object sender, PointerRoutedEventArgs e) 
    { 
     Windows.UI.Input.PointerPoint pt = e.GetCurrentPoint(mGrid); 

     if (contacts.ContainsKey(pt.PointerId)) 
     { 
      checkSwipe(); 
      contacts[pt.PointerId] = null; 
      contacts.Remove(pt.PointerId); 
      startLocation.Remove(pt.PointerId); 
      if (pointSwiped.ContainsKey(pt.PointerId)) 
       pointSwiped.Remove(pt.PointerId); 

      --numActiveContacts; 
     } 

     e.Handled = true; 
    } 


    private void Grid_PointerExited(object sender, PointerRoutedEventArgs e) 
    { 
     Windows.UI.Input.PointerPoint pt = e.GetCurrentPoint(mGrid); 

     if (contacts.ContainsKey(pt.PointerId)) 
     { 
      checkSwipe(); 
      contacts[pt.PointerId] = null; 
      contacts.Remove(pt.PointerId); 
      startLocation.Remove(pt.PointerId); 
      if (pointSwiped.ContainsKey(pt.PointerId)) 
       pointSwiped.Remove(pt.PointerId); 

      --numActiveContacts; 
     } 
     e.Handled = true; 
    } 



    void Grid_PointerReleased(object sender, PointerRoutedEventArgs e) 
    { 
     Windows.UI.Input.PointerPoint pt = e.GetCurrentPoint(mGrid); 

     if (contacts.ContainsKey(pt.PointerId)) 
     { 
      checkSwipe(); 
      contacts[pt.PointerId] = null; 
      contacts.Remove(pt.PointerId); 
      startLocation.Remove(pt.PointerId); 
      if (pointSwiped.ContainsKey(pt.PointerId)) 
       pointSwiped.Remove(pt.PointerId); 

      --numActiveContacts; 
     } 
     e.Handled = true; 
    } 


    private void Grid_PointerMoved(object sender, PointerRoutedEventArgs e) 
    { 
     Windows.UI.Input.PointerPoint currentPoint = e.GetCurrentPoint(mGrid); 
     if (currentPoint.IsInContact) 
     { 
      if (startLocation.ContainsKey(currentPoint.PointerId)) 
      { 
       Point startPoint = startLocation[currentPoint.PointerId]; 

       // Compare startPoint to current location and determine if that point did a swipe? 

       double horizontalMovement = currentPoint.Position.X - startPoint.X; 
       double verticalMovement = currentPoint.Position.Y - startPoint.Y; 

       double horizontalDistance = Math.Abs(horizontalMovement); 
       double verticalDistance = Math.Abs(verticalMovement); 

       double requiredLeftMovement = mGrid.ActualWidth * SWIPE_THRESHOLD * -1; 
       double requiredRightMovement = mGrid.ActualWidth * SWIPE_THRESHOLD; 

       double requiredUpMovement = mGrid.ActualHeight * SWIPE_THRESHOLD * -1; 
       double requiredDownMovement = mGrid.ActualHeight * SWIPE_THRESHOLD; 

       if (verticalMovement < requiredUpMovement && horizontalDistance < 100) 
       { 
        pointSwiped[currentPoint.PointerId] = DirectionSwiped.Up; 
       } 
       else if (verticalMovement > requiredDownMovement && horizontalDistance < ALLOWED_DRIFT) 
       { 
        pointSwiped[currentPoint.PointerId] = DirectionSwiped.Down; 
       } 
       else if (horizontalMovement > requiredRightMovement && verticalDistance < ALLOWED_DRIFT) 
       { 
        pointSwiped[currentPoint.PointerId] = DirectionSwiped.Right; 
       } 
       else if (horizontalMovement < requiredLeftMovement && verticalDistance < ALLOWED_DRIFT) 
       { 
        pointSwiped[currentPoint.PointerId] = DirectionSwiped.Left; 
       } 
      } 
     } 
    } 





    void checkSwipe() 
    { 
     NotififyListenerIfSwiped(DirectionSwiped.Up); 
     NotififyListenerIfSwiped(DirectionSwiped.Down); 
     NotififyListenerIfSwiped(DirectionSwiped.Left); 
     NotififyListenerIfSwiped(DirectionSwiped.Right); 
    } 


    private void NotififyListenerIfSwiped(DirectionSwiped direction) 
    { 
     int fingers = numberOfSwipedFingers(direction); 
     if (fingers >= 1) 
     { 
      if (SwipeDetected != null) 
      { 
       SwipeDetected(this, new SwipeEventArgs() { Direction = direction, NumberOfTouches = fingers }); 
      } 
     } 

     if (fingers > 0) 
      pointSwiped.Clear(); 
    } 


    int numberOfSwipedFingers(DirectionSwiped direction) 
    { 
     int count = 0; 
     foreach (var item in pointSwiped) 
     { 
      DirectionSwiped swipe = item.Value; 
      if (swipe == direction) 
      { 
       count += 1; 
      } 
     } 
     return count; 
    } 


} 

---

utilizzo

public void Gesture_Detected(Object sender, SwipeEventArgs e) 
    { 
     Debug.WriteLine("Number of touches: " + e.NumberOfTouches + " Direction: " + e.Direction); 
    } 


    public MainPage() 
    { 
     this.InitializeComponent(); 

     SwipeGestureDetector gestureDetector = new SwipeGestureDetector(this.rootGrid); 
     gestureDetector.SwipeDetected += Gesture_Detected;