VisualInteractionSource.TryRedirectForManipulation Metodo

Definizione

Spazio dei nomi:

Microsoft.UI.Composition.Interactions

Overload

TryRedirectForManipulation(PointerPoint)

Tenta di inviare modifiche configurate per il flusso del puntatore specificato a InteractionTracker, non al thread dell'interfaccia utente dell'app, a partire dal puntoerpoint specificato. Importante Questo metodo deve essere chiamato solo con un PointerDeviceType di Touch.

TryRedirectForManipulation(PointerPoint)

Tenta di inviare modifiche configurate per il flusso del puntatore specificato a InteractionTracker, non al thread dell'interfaccia utente dell'app, a partire dal puntoerpoint specificato.

Importante

Questo metodo deve essere chiamato solo con un PointerDeviceType di 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

Punto di input.

Esempio

Il frammento di codice seguente illustra come configurare un oggetto visivo per seguire input/movimenti.

Questa operazione viene eseguita tramite tre passaggi principali:

1. La creazione di un InteractionTracker e l'impostazione (o l'associazione) sono limiti.
2. Creazione di almeno un oggetto VisualInteractionSource e associazione a InteractionTracker.
3. Prendendo l'output di InteractionTracker e applicandolo alle proprietà Offset e Scale di un oggetto Visivo.
4. Indicare al sistema di provare a gestire la manipolazione quando si verifica PointerPressed

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 for 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 da 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 routing di input standard.

Se VisualInteractionSource reindirizza il flusso di input a InteractionTracker, l'applicazione riceverà un inputPointerSource.PointerCaptureLost su UIElement o inputPointerSource.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.

Nota

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.

Comportamento asincrono

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 puoi scegliere di rilevare i movimenti nella tua app per determinare come gestire l'input. L'app saprà se la manipolazione del sistema assume il controllo ricevendo un pointerCaptureLost (lo stesso evento ricevuto quando ScrollViewer assume la gestione dell'input). Una complicazione è che è possibile un gesto come un "rapido scorrimento" (scorrimento rapido) per inviare l'intero flusso di input, incluso PointerReleased, all'applicazione prima che il compositor possa rispondere. Se l'app è interessata da queste limitazioni, potrebbe essere necessario eseguire alcune operazioni di rilevamento dei movimenti per garantire il comportamento corretto.

Integrazione con la logica dei controlli XAML

Nello scenario di scorrimento rapido descritto in precedenza, 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 esegue il routing rileva i movimenti. Per garantire il corretto funzionamento degli scenari di tipo di spostamento rapido con XAML, è necessario ascoltare OnTapped sul pulsante anziché fare clic solo 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.

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 l'app sta tentando di usare un riconoscitore personalizzato in conflitto con lo strumento di riconoscimento del sistema, potrebbero verificarsi conflitti in cui l'app prevede che il compositore assuma il controllo e non lo faccia.