VisualInteractionSource.TryRedirectForManipulation(PointerPoint) Methode

Definition

Namespace:

Windows.UI.Composition.Interactions

Gibt an, dass konfigurierte Bearbeitungen für den angegebenen Zeigerdatenstrom ab dem angegebenen PointerPoint an den InteractionTracker und nicht an den UI-Thread der App gesendet werden sollen.

TryRedirectForManipulation ermöglicht es visualInteractionSource , den Zeigerdatenstrom an den InteractionTracker umzuleiten, wenn die Geste mit der Konfiguration auf der VisualInteractionSource übereinstimmt. Diese Methode sollte nur mit der Zeigereingabe des DeviceType Touch aufgerufen werden.

public:
 virtual void TryRedirectForManipulation(PointerPoint ^ pointerPoint) = TryRedirectForManipulation;

void TryRedirectForManipulation(PointerPoint const& pointerPoint);

public void TryRedirectForManipulation(PointerPoint pointerPoint);

function tryRedirectForManipulation(pointerPoint)

Public Sub TryRedirectForManipulation (pointerPoint As PointerPoint)

Parameter

pointerPoint

PointerPoint

Gibt an, dass konfigurierte Bearbeitungen für den angegebenen Zeigerdatenstrom ab dem angegebenen PointerPoint an den InteractionTracker und nicht an den UI-Thread der App gesendet werden sollen.

Beispiele

///////////////////////////////////////////////////////////////////////////////////////////////
//
// The following sample describes how to configure a visual to follow input/gestures.  
//
// This is accomplished in three main steps:
//
// 1) Creating a InteractionTracker and setting (or binding) its boundaries.
//
// 2) Creating at least one Interaction source and associating it with the InteractionTracker.
//
// 3) Taking the output of the InteractionTracker and applying it to a Visual's Offset and Scale 
//    properties.
//
// 4) Telling the system to try to handle the manipulation when the PointerPressed occurs
//
///////////////////////////////////////////////////////////////////////////////////////////////

void SetupSimpleInteractionTracker(Visual containerVisual, Visual contentVisual)
{
  //
  // Create the InteractionTracker and set its min/max position and scale.  These could 
  // also be bound to expressions.  Note: The scrollable area can be changed from either 
  // end to facilitate content updates/virtualization.
  //

  _tracker = InteractionTracker.Create(_compositor);

  _tracker.MaxPosition = new Vector3(
  contentVisual.Size.X - containerVisual.Size.X,
  contentVisual.Size.Y - containerVisual.Size.Y,
  0.0f);

  _tracker.MinScale = 0.5f;
  _tracker.MaxScale = 4.0f;


  //
  // Configure the interaction source.  Enable input with inertia on all axes.
  //

  _interactionSource = VisualInteractionSource.Create(_compositor, containerVisual);

  _interactionSource.PositionXSourceMode = InteractionSourceMode.EnabledWithInertia;
  _interactionSource.PositionYSourceMode = InteractionSourceMode.EnabledWithInertia;
  _interactionSource.ScaleSourceMode = InteractionSourceMode.EnabledWithInertia;

  _tracker.InteractionSources.Add(_interactionSource);

  //
  // Register for the pointer pressed event so that we can tell the system to handle the
  // manipulations.
  //

  _rootElement.PointerPressed += OnPointerPressedBasic;

  //
  // Bind the InteractionTracker outputs to the contentVisual.
  //

  var positionExpression = _compositor.CreateExpressionAnimation("-tracker.Position");
  positionExpression.SetReferenceParameter("tracker", _tracker);

  contentVisual.StartAnimation("Offset", positionExpression);


  var scaleExpression = _compositor.CreateExpressionAnimation("Vector3(tracker.Scale, tracker.Scale, 1.0)");

  scaleExpression.SetReferenceParameter("tracker", _tracker);

  contentVisual.StartAnimation("Scale", scaleExpression);
}

private void OnPointerPressedBasic(object sender, PointerRoutedEventArgs e)
{
  //
  // Try to handle the manipulation in the system.
  //
  if (e.Pointer.PointerDeviceType == Windows.Devices.Input.PointerDeviceType.Touch)
  {       
    _interactionSource.TryRedirectForManipulation(
    e.CurrentPoint.GetCurrentPoint(_rootElement));
  }
}

Compositor _compositor = null;
InteractionTracker _tracker = null;
UIElement _rootElement = null;
VisualInteractionSource _interactionSource;

Hinweise

Mit dieser Methode kann die App angeben, dass das System (Compositor) alle konfigurierten Bearbeitungen für eine bestimmte VisualInteractionSource übernimmt. Wenn TryRedirectForManipulation aufgerufen wird, wird der Frame aus dem in PointerPoint übergebenen als Ausgangspunkt für die Eingabebehandlung von InteractionTracker verwendet. Wenn die Geste des Benutzers auf das Visual getestet wird, das der VisualInteractionSource (oder einer seiner untergeordneten Elemente) zugeordnet ist, und der Benutzer eine konfigurierte Geste ausführt, wird das System bearbeitet. Wenn die Eingabe für ein anderes Visual treffergetestet wird oder der Benutzer eine nicht konfigurierte Geste ausführt, wird die Eingabe an coreWindow und über das normale Eingaberouting von XAML gesendet.

Wenn VisualInteractionSource den Eingabedatenstrom an interactionTracker umgeleitet, erhält die Anwendung einen PointerCaptureLost auf dem UIElement oder einen PointerRoutedAway auf dem CoreWindow. Diese Meldungen weisen darauf hin, dass die Eingabe vom Anwendungs-UI-Thread weggesendet wurde. Diese Methode wird am häufigsten auf PointerPressed aufgerufen.

Die PrecisionTouchpad-Eingabe erfordert diesen Aufruf nicht und wird automatisch an den InteractionTracker für die entsprechenden Gesten weitergeleitet, wenn der InputRedirectionMode auf die Eingabe "CapableTouchpad" festgelegt wurde.

Einschränkungen

Asynchrone Natur

Die Art dieses Systems ist asynchron. Wenn die App TryRedirectForManipulation aufruft und der Aufruf den Compositor erreicht, gibt es zusätzliche Eingabeereignisse, die es in den UI-Thread der Anwendung geschafft haben könnten. In den meisten Fällen ist es nicht schädlich für die App, diese Ereignisse empfangen zu haben, und der Entwickler kann die App-Seite der Gestenerkennung auswählen, um zu bestimmen, wie die Eingabe behandelt und Bedenken entschärft werden soll. Die App weiß, ob die Systembearbeitung übernimmt, indem sie ein PointerCaptureLost empfängt – das gleiche Ereignis, das empfangen wird, wenn ScrollViewer die Eingabeverarbeitung heute übernimmt. Eine Komplikation besteht darin, dass es möglich ist, dass eine Geste wie ein "Quick Flick" (nur eine kurze Verschiebung) den gesamten Eingabedatenstrom, einschließlich des PointerReleased, an die Anwendung senden kann, bevor der Compositor reagieren kann. Wenn die App von diesen Einschränkungen betroffen ist, kann sie eine gewisse Gestenerkennung auf ihrer Seite durchführen, um das richtige Verhalten sicherzustellen.

Integration in XAML-Steuerelementlogik

In dem oben beschriebenen Schnellfliemmerszenario, bei dem sich die Schwenkung auf einem Steuerelement wie einer Schaltfläche befindet, erkennt die Schaltfläche das Schwenken als Klick, wenn sie in der Schaltfläche enthalten ist. Dies unterscheidet sich geringfügig von der Art und Weise, wie das System GestureRecognizer (das das Routing durchführt) Gesten erkennt. Um sicherzustellen, dass Schnelle Flicktypszenarien mit XAML ordnungsgemäß funktionieren, müssen Entwickler auf OnTapped auf der Schaltfläche lauschen und nicht nur klicken, wenn es sich innerhalb eines Compositorinteraktionsbereichs befindet.

Compositor Hit-testing

Das Treffertestergebnis, das verwendet wird, um zu bestimmen, ob die Manipulation im richtigen Visual erfolgt, basiert auf dem Treffertest des Komppositors. Compositor-Treffertests sind nicht so robust wie XAML-Treffertests, daher gibt es Fälle, in denen die Ergebnisse eine geringfügige Diskrepanz aufweisen können.

Weitere Informationen finden Sie in der VisualInteractionSource-Dokumentation.

Integration in konfliktierende benutzerdefinierte Gestenerkennungserkennungen

Intern wird das System GestureRecognizer verwendet, um Eingaben weiterzuleiten. Apps können im Allgemeinen das gewünschte Verhalten erhalten, solange sie die Systemgestenerkennung verwenden. Wenn eine App versucht, eine benutzerdefinierte Erkennung zu verwenden, die mit der Systemerkennung in Konflikt steht, kann es zu Konflikten kommen, bei denen die App erwartet, dass der Compositor die Übernahme übernimmt, und dies nicht.