GestureRecognizer Klasse

Definition

Namespace:

Windows.UI.Input

Bietet Gesten- und Manipulationserkennung, Ereignislistener und Einstellungen.

public ref class GestureRecognizer sealed

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.None)]
/// [Windows.Foundation.Metadata.Activatable(65536, "Windows.Foundation.UniversalApiContract")]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
class GestureRecognizer final

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.None)]
[Windows.Foundation.Metadata.Activatable(65536, "Windows.Foundation.UniversalApiContract")]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public sealed class GestureRecognizer

function GestureRecognizer()

Public NotInheritable Class GestureRecognizer

Vererbung

Object Platform::Object IInspectable GestureRecognizer

Attribute

ActivatableAttribute ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Windows-Anforderungen

Gerätefamilie	Windows 10 (eingeführt in 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (eingeführt in v1.0)

Beispiele

Hier richten wir ein GestureRecognizer-Objekt mit einer Auflistung von Eingabeereignishandlern zum Verarbeiten von Zeiger- und Gesteneingaben ein. Weitere Informationen zum Lauschen und Behandeln von Windows-Runtime Ereignissen finden Sie unter Übersicht über Ereignisse und Routingereignisse. Die vollständige Implementierung finden Sie im Basic-Eingabebeispiel .

class ManipulationInputProcessor
{
    GestureRecognizer recognizer;
    UIElement element;
    UIElement reference;
    TransformGroup cumulativeTransform;
    MatrixTransform previousTransform;
    CompositeTransform deltaTransform;

    public ManipulationInputProcessor(GestureRecognizer gestureRecognizer, UIElement target, UIElement referenceFrame)
    {
        recognizer = gestureRecognizer;
        element = target;
        reference = referenceFrame;
        // Initialize the transforms that will be used to manipulate the shape
        InitializeTransforms();
        // The GestureSettings property dictates what manipulation events the
        // Gesture Recognizer will listen to.  This will set it to a limited
        // subset of these events.
        recognizer.GestureSettings = GenerateDefaultSettings();
        // Set up pointer event handlers. These receive input events that are used by the gesture recognizer.
        element.PointerPressed += OnPointerPressed;
        element.PointerMoved += OnPointerMoved;
        element.PointerReleased += OnPointerReleased;
        element.PointerCanceled += OnPointerCanceled;
        // Set up event handlers to respond to gesture recognizer output
        recognizer.ManipulationStarted += OnManipulationStarted;
        recognizer.ManipulationUpdated += OnManipulationUpdated;
        recognizer.ManipulationCompleted += OnManipulationCompleted;
        recognizer.ManipulationInertiaStarting += OnManipulationInertiaStarting;
    }

    public void InitializeTransforms()
    {
        cumulativeTransform = new TransformGroup();
        deltaTransform = new CompositeTransform();
        previousTransform = new MatrixTransform() { Matrix = Matrix.Identity };
        cumulativeTransform.Children.Add(previousTransform);
        cumulativeTransform.Children.Add(deltaTransform);
        element.RenderTransform = cumulativeTransform;
    }

    // Return the default GestureSettings for this sample
    GestureSettings GenerateDefaultSettings()
    {
        return GestureSettings.ManipulationTranslateX |
            GestureSettings.ManipulationTranslateY |
            GestureSettings.ManipulationRotate |
            GestureSettings.ManipulationTranslateInertia |
            GestureSettings.ManipulationRotateInertia;
    }

    // Route the pointer pressed event to the gesture recognizer.
    // The points are in the reference frame of the canvas that contains the rectangle element.
    void OnPointerPressed(object sender, PointerRoutedEventArgs args)
    {
        // Set the pointer capture to the element being interacted with so that only it
        // will fire pointer-related events
        element.CapturePointer(args.Pointer);
        // Feed the current point into the gesture recognizer as a down event
        recognizer.ProcessDownEvent(args.GetCurrentPoint(reference));
    }

    // Route the pointer moved event to the gesture recognizer.
    // The points are in the reference frame of the canvas that contains the rectangle element.
    void OnPointerMoved(object sender, PointerRoutedEventArgs args)
    {
        // Feed the set of points into the gesture recognizer as a move event
        recognizer.ProcessMoveEvents(args.GetIntermediatePoints(reference));
    }

    // Route the pointer released event to the gesture recognizer.
    // The points are in the reference frame of the canvas that contains the rectangle element.
    void OnPointerReleased(object sender, PointerRoutedEventArgs args)
    {
        // Feed the current point into the gesture recognizer as an up event
        recognizer.ProcessUpEvent(args.GetCurrentPoint(reference));
        // Release the pointer
        element.ReleasePointerCapture(args.Pointer);
    }

    // Route the pointer canceled event to the gesture recognizer.
    // The points are in the reference frame of the canvas that contains the rectangle element.
    void OnPointerCanceled(object sender, PointerRoutedEventArgs args)
    {
        recognizer.CompleteGesture();
        element.ReleasePointerCapture(args.Pointer);
    }

    // When a manipulation begins, change the color of the object to reflect
    // that a manipulation is in progress
    void OnManipulationStarted(object sender, ManipulationStartedEventArgs e)
    {
        Border b = element as Border;
        b.Background = new SolidColorBrush(Windows.UI.Colors.DeepSkyBlue);
    }

    // Process the change resulting from a manipulation
    void OnManipulationUpdated(object sender, ManipulationUpdatedEventArgs e)
    {
        previousTransform.Matrix = cumulativeTransform.Value;
        // Get the center point of the manipulation for rotation
        Point center = new Point(e.Position.X, e.Position.Y);
        deltaTransform.CenterX = center.X;
        deltaTransform.CenterY = center.Y;
        // Look at the Delta property of the ManipulationDeltaRoutedEventArgs to retrieve
        // the rotation, X, and Y changes
        deltaTransform.Rotation = e.Delta.Rotation;
        deltaTransform.TranslateX = e.Delta.Translation.X;
        deltaTransform.TranslateY = e.Delta.Translation.Y;
    }

    // When a manipulation that's a result of inertia begins, change the color of the
    // the object to reflect that inertia has taken over
    void OnManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
    {
        Border b = element as Border;
        b.Background = new SolidColorBrush(Windows.UI.Colors.RoyalBlue);
    }

    // When a manipulation has finished, reset the color of the object
    void OnManipulationCompleted(object sender, ManipulationCompletedEventArgs e)
    {
        Border b = element as Border;
        b.Background = new SolidColorBrush(Windows.UI.Colors.LightGray);
    }

    // Modify the GestureSettings property to only allow movement on the X axis
    public void LockToXAxis()
    {
        recognizer.CompleteGesture();
        recognizer.GestureSettings |= GestureSettings.ManipulationTranslateY | GestureSettings.ManipulationTranslateX;
        recognizer.GestureSettings ^= GestureSettings.ManipulationTranslateY;
    }

    // Modify the GestureSettings property to only allow movement on the Y axis
    public void LockToYAxis()
    {
        recognizer.CompleteGesture();
        recognizer.GestureSettings |= GestureSettings.ManipulationTranslateY | GestureSettings.ManipulationTranslateX;
        recognizer.GestureSettings ^= GestureSettings.ManipulationTranslateX;
    }

    // Modify the GestureSettings property to allow movement on both the X and Y axes
    public void MoveOnXAndYAxes()
    {
        recognizer.CompleteGesture();
        recognizer.GestureSettings |= GestureSettings.ManipulationTranslateX | GestureSettings.ManipulationTranslateY;
    }

    // Modify the GestureSettings property to enable or disable inertia based on the passed-in value
    public void UseInertia(bool inertia)
    {
        if (!inertia)
        {
            recognizer.CompleteGesture();
            recognizer.GestureSettings ^= GestureSettings.ManipulationTranslateInertia | GestureSettings.ManipulationRotateInertia;
        }
        else
        {
            recognizer.GestureSettings |= GestureSettings.ManipulationTranslateInertia | GestureSettings.ManipulationRotateInertia;
        }
    }

    public void Reset()
    {
        element.RenderTransform = null;
        recognizer.CompleteGesture();
        InitializeTransforms();
        recognizer.GestureSettings = GenerateDefaultSettings();
    }
}

Beispiele

• Beispiel für den Benutzerinteraktionsmodus
• Beispiel für visuelle Fokuselemente
• Einfaches Eingabebeispiel
• Direct3D-Spielbeispiel
• DirectX- und XAML-Spielbeispiel

Archivierte Beispiele

• Eingabe: Beispiel für Manipulationen und Gesten
• Eingabe: Beispiel für XAML-Benutzereingabeereignisse
• Beispiel für XAML-Bildlauf, Schwenken und Zoomen
• Beispiel für die DirectX-Fingereingabe

Hinweise

Sie können ein Gestenobjekt für jedes geeignete Element erstellen, wenn Ihre App gestartet wird. Dieser Ansatz kann jedoch abhängig von der Anzahl der Gestenobjekte, die Sie erstellen müssen, nicht gut skaliert werden (z. B. ein Puzzle mit Hunderten von Teilen).

In diesem Fall können Sie Gestenobjekte dynamisch für ein Pointerdownereignis erstellen und sie in einem MSGestureEnd-Ereignis zerstören. Dieser Ansatz lässt sich gut skalieren, verursacht jedoch einen gewissen Mehraufwand durch das Erstellen und Freigeben dieser Objekte.

Alternativ können Sie einen Pool wiederverwendbarer Gestenobjekte statisch zuordnen und dynamisch verwalten.

Hinweis

Diese Klasse ist nicht agil, was bedeutet, dass Sie das Threadingmodell und das Marshallingverhalten berücksichtigen müssen. Weitere Informationen finden Sie unter Threading and Marshaling (C++/CX) und Using Windows-Runtime objects in a multithreaded environment (.NET).

Weitere Informationen zur Verwendung von folienübergreifender Funktionalität finden Sie unter Richtlinien für querfolien. Das folgende Diagramm zeigt Distanzschwellen, die bei der Interaktion des Querziehens verwendet werden.

Die Eigenschaften PivotRadius und PivotCenter werden nur verwendet, wenn eine einzelne Zeigereingabe erkannt wird. Sie haben keine Auswirkungen auf die Eingabe mehrerer Zeiger. Der Wert für diese Eigenschaften sollte während der Interaktion regelmäßig aktualisiert werden.

Die Drehung wird von einem GestureRecognizer nur unterstützt, wenn manipulationRotate über die GestureSettings-Eigenschaft festgelegt wird.

Die Drehung wird für die Eingabe mit nur einem Zeiger nicht unterstützt, wenn der Wert von PivotRadius auf 0 festgelegt ist.

Versionsverlauf

Windows-Version	SDK-Version	Wertschöpfung
2004	19041	HoldMaxContactCount
2004	19041	HoldMinContactCount
2004	19041	HoldRadius
2004	19041	HoldStartDelay
2004	19041	TapMaxContactCount
2004	19041	TapMinContactCount
2004	19041	TranslationMaxContactCount
2004	19041	TranslationMinContactCount

Konstruktoren

GestureRecognizer()

Initialisiert eine neue instance eines GestureRecognizer-Objekts.

Eigenschaften

AutoProcessInertia	Ruft einen Wert ab, der angibt, ob Manipulationen während der Unbewegheit automatisch generiert werden, oder legt diesen fest.
CrossSlideExact	Ruft einen Wert ab, der angibt, ob der genaue Abstand zwischen dem ersten Kontakt und dem Ende der Querpräsentationsinteraktion gemeldet wird, oder legt diesen fest. Standardmäßig wird ein kleiner Abstandsschwellenwert von der ersten Position subtrahiert, die vom System für übergreifende Interaktionen gemeldet wird. Wenn dieses Flag festgelegt ist, wird der Entfernungsschwellenwert nicht von der ausgangsposition subtrahiert. Hinweis Dieser Abstandsschwellenwert soll jede leichte Bewegung des Kontakts nach der ersten Erkennung berücksichtigen. Es hilft dem System, zwischen Kreuzschiebung und Schwenken zu unterscheiden, und stellt sicher, dass eine Tippgeste nicht als interpretiert wird.
CrossSlideHorizontally	Ruft einen Wert ab, der angibt, ob die Querschiebeachse horizontal ist, oder legt diesen fest.
CrossSlideThresholds	Ruft Werte ab, die die Entfernungsschwellenwerte für eine CrossSliding-Interaktion angeben, oder legt diese fest.
GestureSettings	Ruft einen Wert ab, der die von einer Anwendung unterstützten Gesten- und Bearbeitungseinstellungen angibt, oder legt diesen fest.
HoldMaxContactCount	Ruft die maximale Anzahl von Kontaktpunkten ab, die zum Erkennen eines Windows.UI.Input.GestureRecognizer.Holding-Ereignisses erforderlich sind, oder legt diese fest.
HoldMinContactCount	Ruft die Mindestanzahl von Kontaktpunkten ab, die zum Erkennen eines Windows.UI.Input.GestureRecognizer.Holding-Ereignisses erforderlich sind, oder legt diese fest.
HoldRadius	Ruft den Radius der Kontaktpunkte ab, die für das Windows.UI.Input.GestureRecognizer.Holding-Ereignis erkannt werden, oder legt den Radius fest.
HoldStartDelay	Ruft den Zeitschwellenwert ab, ab dem die Kontakte für das Windows.UI.Input.GestureRecognizer.Holding-Ereignis erkannt werden, oder legt diesen fest.
InertiaExpansion	Ruft einen Wert ab, der die relative Größenänderung eines Objekts vom Anfang der Rägheit bis zum Ende der Tia angibt (wenn die Größenänderung oder Skalierung abgeschlossen ist), oder legt diesen fest.
InertiaExpansionDeceleration	Ruft einen Wert ab, der die Verlangsamungsrate vom Trägheitsbeginn bis zum Ende der Trägheit angibt (wenn die Größenänderung oder Erweiterung der Bearbeitung abgeschlossen ist) oder legt diesen fest.
InertiaRotationAngle	Ruft einen Wert ab, der den letzten Drehwinkel eines Objekts am Ende der Schwungzeit (nach Abschluss der Drehungsbearbeitung) angibt, oder legt diesen fest.
InertiaRotationDeceleration	Ruft einen Wert ab, der die Verlangsamungsrate vom Trägheitsbeginn bis zum Ende der Trägheit (wenn die Drehungsbearbeitung abgeschlossen ist) angibt, oder legt diesen fest.
InertiaTranslationDeceleration	Ruft einen Wert ab, der die Verlangsamungsrate vom Trägheitsbeginn bis zum Ende der Trägheit (nach Abschluss der Übersetzungsbearbeitung) angibt, oder legt diesen fest.
InertiaTranslationDisplacement	Ruft einen Wert ab, der die relative Änderung der Bildschirmposition eines Objekts vom Anfang der Tia bis zum Ende der Tia (nach Abschluss der Übersetzungsbearbeitung) angibt, oder legt diesen fest.
IsActive	Ruft einen Wert ab, der angibt, ob eine Interaktion verarbeitet wird.
IsInertial	Ruft einen Wert ab, der angibt, ob während der Erträgheit noch eine Bearbeitung verarbeitet wird (es sind keine Eingabepunkte aktiv).
ManipulationExact	Ruft einen Wert ab, der angibt, ob der genaue Abstand zwischen dem ersten Kontakt und dem Ende der Interaktion gemeldet wird, oder legt diesen fest. Standardmäßig wird ein kleiner Entfernungsschwellenwert vom ersten vom System gemeldeten Delta subtrahiert. Dieser Abstandsschwellenwert soll leichte Bewegungen des Kontakts bei der Verarbeitung einer Tippgeste berücksichtigen. Wenn dieses Flag festgelegt ist, wird der Entfernungsschwellenwert nicht vom ersten Delta subtrahiert.
MouseWheelParameters	Ruft einen Satz von Eigenschaften ab, die der Radtaste eines Mausgeräts zugeordnet sind.
PivotCenter	Ruft den Mittelpunkt für eine Drehungsinteraktion ab, wenn eine einzelne Zeigereingabe erkannt wird, oder legt diesen fest.
PivotRadius	Ruft den Radius vom PivotCenter bis zur Zeigereingabe für eine Drehungsinteraktion ab, wenn eine einzelne Zeigereingabe erkannt wird, oder legt diesen fest.
ShowGestureFeedback	Ruft einen Wert ab, der angibt, ob während einer Interaktion visuelles Feedback angezeigt wird, oder legt diesen fest.
TapMaxContactCount	Ruft die maximale Anzahl von Kontaktpunkten ab, die zum Erkennen eines Windows.UI.Input.GestureRecognizer.Tapped-Ereignisses erforderlich sind, oder legt diese fest.
TapMinContactCount	Ruft die Mindestanzahl von Kontaktpunkten ab, die zum Erkennen eines Windows.UI.Input.GestureRecognizer.Tapped-Ereignisses erforderlich sind, oder legt diese fest.
TranslationMaxContactCount	Ruft die maximale Anzahl von Kontaktpunkten ab, die zum Erkennen eines Übersetzungsereignisses (oder Verschiebungsereignis) erforderlich sind, oder legt diese fest.
TranslationMinContactCount	Ruft die Mindestanzahl von Kontaktpunkten ab, die zum Erkennen eines Übersetzungsereignisses (oder Verschiebungsereignisses) erforderlich sind, oder legt diese fest.

Methoden

CanBeDoubleTap(PointerPoint)	Gibt an, ob ein Tippen weiterhin als zweiter Tippen einer Doppeltippgeste interpretiert werden kann.
CompleteGesture()	Bewirkt, dass die Gestenerkennung eine Interaktion beendet.
ProcessDownEvent(PointerPoint)	Verarbeitet die Zeigereingabe und löst die GestureRecognizer-Ereignisse aus, die für eine Zeiger-Down-Aktion für die gesten- und manipulationsspezifischen Gesten und Bearbeitungen geeignet sind, die durch die GestureSettings-Eigenschaft angegeben werden.
ProcessInertia()	Führt Inertia-Berechnungen aus und löst die verschiedenen Inertiätsereignisse aus.
ProcessMouseWheelEvent(PointerPoint, Boolean, Boolean)	Verarbeitet zeigereingaben und löst die GestureRecognizer-Ereignisse aus, die für eine Mausradaktion für die von der GestureSettings-Eigenschaft angegebenen Gesten und Bearbeitungen geeignet sind.
ProcessMoveEvents(IVector<PointerPoint>)	Verarbeitet die Zeigereingabe und löst die GestureRecognizer-Ereignisse aus, die für eine Zeigerverschiebungsaktion für die von der GestureSettings-Eigenschaft angegebenen Gesten und Bearbeitungen geeignet sind.
ProcessUpEvent(PointerPoint)	Verarbeitet die Zeigereingabe und löst die GestureRecognizer-Ereignisse aus, die für eine Zeigeraktion für die von der GestureSettings-Eigenschaft angegebenen Gesten und Bearbeitungen geeignet sind.

Ereignisse

CrossSliding	Tritt auf, wenn ein Benutzer eine Folie oder Wischbewegung (über einen einzelnen Touchkontakt) innerhalb eines Inhaltsbereichs ausführt, der das Schwenken nur entlang einer einzelnen Achse unterstützt. Die Geste muss in einer Richtung erfolgen, die senkrecht zu dieser Schwenkachse liegt. Hinweis Ein Wischen ist eine kurze gleitende Geste, die zu einer Auswahlaktion führt, während die längere Schiebegeste einen Entfernungsschwellenwert überschreitet und zu einer Neuordnungsaktion führt. Die Wisch- und Foliengesten werden im folgenden Diagramm veranschaulicht.
Dragging	Tritt auf, wenn ein Benutzer eine Schiebe- oder Wischbewegung mit einer Maus oder einem Stift/Eingabestift (einzelner Kontakt) ausführt.
Holding	Tritt auf, wenn ein Benutzer eine Gedrückthalten-Geste ausführt (mit einer einzigen Berührung, Maus oder Einem Stift-/Eingabestiftkontakt).
ManipulationCompleted	Tritt auf, wenn die Eingabepunkte angehoben werden und alle nachfolgenden Bewegungen (Übersetzung, Erweiterung oder Drehung) durch DieTrägheit beendet wurden.
ManipulationInertiaStarting	Tritt auf, wenn alle Kontaktpunkte während einer Manipulation angehoben werden und die Geschwindigkeit der Manipulation signifikant genug ist, um das Erträgheitsverhalten zu initiieren (Übersetzung, Erweiterung oder Drehung werden fortgesetzt, nachdem die Eingabezeiger angehoben wurden).
ManipulationStarted	Tritt auf, wenn ein oder mehrere Eingabepunkte initiiert wurden und die nachfolgende Bewegung (Übersetzung, Erweiterung oder Drehung) begonnen wurde.
ManipulationUpdated	Tritt auf, nachdem ein oder mehrere Eingabepunkte initiiert wurden und die nachfolgende Bewegung (Übersetzung, Erweiterung oder Drehung) ausgeführt wurde.
RightTapped	Tritt auf, wenn die Zeigereingabe unabhängig vom Eingabegerät als rechts tippende Geste interpretiert wird. Klicken mit der rechten Maustaste Schaltfläche "Stiftfass" klicken Drücken und halten Sie die Fingereingabe oder den Stift
Tapped	Tritt auf, wenn die Zeigereingabe als Tippgeste interpretiert wird.

Weitere Informationen

• Windows.UI.Input
• Windows.Devices.Input
• Windows.UI.Core
• Windows.UI.Input.Inking
• Windows.UI.Xaml.Input
• Benutzerdefinierte Benutzerinteraktionen
• UX-Richtlinien für benutzerdefinierte Benutzerinteraktionen
• Entwurfsrichtlinien für Toucheingaben