VisualInteractionSource.TryRedirectForManipulation(PointerPoint) Méthode

Définition

Espace de noms:

Windows.UI.Composition.Interactions

Indique que les manipulations configurées pour le flux de pointeur donné doivent être envoyées à InteractionTracker, et non au thread d’interface utilisateur de l’application, en commençant par le Pointeur donné.

TryRedirectForManipulation permet à VisualInteractionSource de rediriger le flux de pointeur vers InteractionTracker si le mouvement correspond à la configuration sur le VisualInteractionSource. Cette méthode ne doit être appelée qu’avec l’entrée Pointeur de l’appareil DeviceType Touch.

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)

Paramètres

pointerPoint

PointerPoint

Indique que les manipulations configurées pour le flux de pointeur donné doivent être envoyées à InteractionTracker, et non au thread d’interface utilisateur de l’application, en commençant par le Pointeur donné.

Exemples

///////////////////////////////////////////////////////////////////////////////////////////////
//
// 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;

Remarques

Cette méthode permet à l’application d’indiquer que le système (Compositor) doit prendre en charge toutes les manipulations configurées pour un VisualInteractionSource donné. Lorsque TryRedirectForManipulation est appelé, le frame du passé dans PointerPoint est utilisé comme point de départ pour la gestion des entrées d’InteractionTracker . Si le mouvement de l’utilisateur est testé sur le visuel associé à VisualInteractionSource (ou à l’un de ses enfants) et que l’utilisateur effectue un mouvement configuré, le système manipule. Si l’entrée est testée sur un autre visuel ou si l’utilisateur effectue un mouvement non configuré, l’entrée est envoyée à CoreWindow et via le routage d’entrée normal de XAML.

Si VisualInteractionSource redirige à nouveau le flux d’entrée vers InteractionTracker, l’application reçoit un PointerCaptureLost sur l’UIElement ou un PointerRoutedAway sur coreWindow. Ces messages indiquent que l’entrée a été envoyée à partir du thread d’interface utilisateur de l’application. Cette méthode est généralement appelée sur PointerPressed.

L’entrée PrecisionTouchpad ne nécessite pas cet appel et est automatiquement routée vers InteractionTracker pour les mouvements appropriés si inputRedirectionMode a été défini pour inclure l’entrée CapableTouchpad.

Limites

Nature asynchrone

La nature de ce système est asynchrone. Au moment où l’application appelle TryRedirectForManipulation et que l’appel atteint le compositeur, d’autres événements d’entrée peuvent avoir atteint le thread d’interface utilisateur de l’application. Dans la plupart des cas, il n’est pas dangereux pour l’application d’avoir reçu ces événements, et le développeur peut choisir de détecter les mouvements côté application pour déterminer comment gérer l’entrée et atténuer les problèmes. L’application sait si la manipulation du système prend le dessus en recevant un PointerCaptureLost, le même événement que celui reçu lorsque ScrollViewer prend aujourd’hui la gestion des entrées. Une complication ici est qu’il est possible pour un mouvement comme un « mouvement rapide » (juste un bref panoramique) d’envoyer l’intégralité du flux d’entrée, y compris le PointerReleased, à l’application avant que le compositeur puisse répondre. Si l’application est impactée par ces limitations, elle peut choisir d’effectuer une certaine quantité de détection de mouvement de son côté pour garantir le bon comportement.

Intégration à la logique des contrôles XAML

Dans le scénario de mouvement rapide décrit ci-dessus où le panoramique se trouve sur un contrôle comme un bouton, le bouton détecte le panoramique en tant que clic s’il est contenu dans le bouton. Cela diffère légèrement de la façon dont le système GestureRecognizer (qui effectue le routage) détecte les mouvements. Pour s’assurer que les scénarios de type de séquence rapide fonctionnent correctement avec XAML, les développeurs devront écouter OnTapped sur le bouton plutôt que simplement Cliquer s’il se trouve dans une zone d’interaction du compositeur.

Compositor Hit-testing

Le résultat du test de positionnement utilisé pour déterminer si la manipulation se produit sur le visuel approprié sera basé sur les tests de positionnement du compositeur. Le test de positionnement du compositeur n’est pas aussi robuste que le test d’accès XAML. Il existe donc des cas où les résultats peuvent avoir une légère différence.

Pour plus d’informations, consultez la documentation VisualInteractionSource.

Intégration à des modules de reconnaissance de mouvements personnalisés en conflit

En interne, le système GestureRecognizer est utilisé pour acheminer l’entrée. Les applications peuvent généralement obtenir le comportement qu’elles souhaitent tant qu’elles utilisent la reconnaissance des mouvements système. Si une application tente d’utiliser un module de reconnaissance personnalisé qui est en conflit avec le module de reconnaissance système, il peut y avoir des conflits où l’application s’attend à ce que le compositeur prenne le relais, ce qui n’est pas le cas.