VisualInteractionSource.TryRedirectForManipulation(PointerPoint) Metodo

Definizione

Spazio dei nomi:

Windows.UI.Composition.Interactions

Indica che le manipolazioni configurate per il flusso del puntatore specificato devono essere inviate a InteractionTracker, non al thread dell'interfaccia utente dell'app, a partire dal puntoerpoint specificato.

TryRedirectForManipulation consente a VisualInteractionSource di reindirizzare il flusso del puntatore a InteractionTracker se il movimento corrisponde alla configurazione in VisualInteractionSource. Questo metodo deve essere chiamato solo con l'input Pointer di 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)

Parametri

pointerPoint

PointerPoint

Indica che le manipolazioni configurate per il flusso del puntatore specificato devono essere inviate a InteractionTracker, non al thread dell'interfaccia utente dell'app, a partire dal puntoerpoint specificato.

Esempio

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

Commenti

Questo metodo consente all'app di indicare che il sistema (Compositor) deve assumere le modifiche configurate per un oggetto VisualInteractionSource specificato. Quando viene chiamato TryRedirectForManipulation, il frame dell'oggetto passato in PointerPoint viene usato come punto di partenza per la gestione dell'input di InteractionTracker . Se il movimento dell'utente viene sottoposto a hit test per l'oggetto visivo associato a VisualInteractionSource (o uno dei relativi elementi figlio) e l'utente esegue un gesto configurato, il sistema modificherà. Se l'input viene sottoposto a hit test in un altro oggetto visivo o l'utente esegue un movimento non configurato, l'input verrà inviato a CoreWindow e tramite il normale routing di input xaml.

Se VisualInteractionSource reindirizza il flusso di input a InteractionTracker, l'applicazione riceverà un PointerCaptureLost su UIElement o pointerRoutedAway in CoreWindow. Questi messaggi indicano che l'input è stato inviato dal thread dell'interfaccia utente dell'applicazione. Questo metodo verrà chiamato più comunemente in PointerPressed.

L'input PrecisionTouchpad non richiede questa chiamata e verrà automaticamente instradato all'InteractionTracker per i movimenti appropriati se InputRedirectionMode è stato impostato per includere l'input CapableTouchpad.

Limitazioni

Natura asincrona

La natura di questo sistema è asincrona. Quando l'app chiama TryRedirectForManipulation e la chiamata raggiunge il programma di composizione, ci saranno altri eventi di input che potrebbero averla apportata al thread dell'interfaccia utente dell'applicazione. Nella maggior parte dei casi, non è dannoso che l'app abbia ricevuto questi eventi e lo sviluppatore può scegliere di rilevare il lato app per determinare come gestire l'input e attenuare i problemi. L'app saprà se la manipolazione del sistema assume il controllo ricevendo un pointerCaptureLost, lo stesso evento ricevuto quando ScrollViewer assume oggi la gestione degli input. Una complicazione qui è che è possibile un gesto come un "tocco rapido" (solo una breve panoramica) per inviare l'intero flusso di input, incluso PointerReleased, all'applicazione prima che il compositor possa rispondere. Se l'app è interessata da queste limitazioni, può scegliere di eseguire una certa quantità di rilevamento dei movimenti sul lato per garantire il comportamento corretto.

Integrazione con la logica dei controlli XAML

Nello scenario di scorrimento rapido descritto sopra in cui la panoramica si trova su un controllo come un pulsante, il pulsante rileverà la panoramica come clic se è contenuta all'interno del pulsante. Questo è leggermente diverso da come il sistema GestureRecognizer (che sta eseguendo il routing) rileva i movimenti. Per garantire il corretto funzionamento degli scenari di tipi di tocco rapido con XAML, gli sviluppatori dovranno restare in ascolto di OnTapped sul pulsante anziché semplicemente Fare clic se si trova all'interno di un'area di interazione del compositore.

Hit testing di Compositor

Il risultato dell'hit test usato per determinare se la manipolazione avviene sull'oggetto visivo corretto si basa sull'hit testing del compositore. L'hit testing di Compositor non è affidabile come l'hit testing XAML, quindi esistono casi in cui i risultati potrebbero avere una leggera discrepanza.

Per altri dettagli, vedere la documentazione di VisualInteractionSource.

Integrazione con riconoscitori movimenti personalizzati in conflitto

Internamente, il sistema GestureRecognizer viene usato per instradare l'input. Le app possono in genere ottenere il comportamento desiderato purché usino il riconoscimento dei movimenti di sistema. Se un'app tenta di usare un riconoscitore personalizzato in conflitto con lo strumento di riconoscimento del sistema, potrebbe verificarsi un conflitto in cui l'app prevede che il compositor possa assumere il controllo e non lo fa.