VisualInteractionSource.TryRedirectForManipulation(PointerPoint) Método

Definición

Espacio de nombres:

Windows.UI.Composition.Interactions

Indica que las manipulaciones configuradas para la secuencia de puntero determinada se deben enviar a InteractionTracker, no al subproceso de interfaz de usuario de la aplicación, empezando en el pointerPoint especificado.

TryRedirectForManipulation permite que VisualInteractionSource redirija la secuencia de puntero a InteractionTracker si el gesto coincide con la configuración en VisualInteractionSource. Solo se debe llamar a este método con la entrada pointer de 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)

Parámetros

pointerPoint

PointerPoint

Indica que las manipulaciones configuradas para la secuencia de puntero determinada se deben enviar a InteractionTracker, no al subproceso de interfaz de usuario de la aplicación, empezando en el pointerPoint especificado.

Ejemplos

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

Comentarios

Este método permite a la aplicación indicar que el sistema (Compositor) debe asumir las manipulaciones configuradas para un objeto VisualInteractionSource determinado. Cuando se llama a TryRedirectForManipulation, el marco del objeto pasado en PointerPoint se usa como punto de partida para el control de entrada de InteractionTracker . Si el gesto del usuario se prueba en el objeto visual asociado a VisualInteractionSource (o a uno de sus elementos secundarios) y el usuario realiza un gesto configurado, el sistema manipulará. Si la entrada se prueba en otro objeto visual o el usuario realiza un gesto no configurado, la entrada se enviará a CoreWindow y a través del enrutamiento de entrada normal de XAML.

Si VisualInteractionSource vuelve a enrutar el flujo de entrada a InteractionTracker, la aplicación recibirá pointerCaptureLost en UIElement o pointerRoutedAway en CoreWindow. Estos mensajes indican que la entrada se ha enviado lejos del subproceso de la interfaz de usuario de la aplicación. Este método se llamará normalmente en PointerPressed.

La entrada PrecisionTouchpad no requiere esta llamada y se enrutará automáticamente a InteractionTracker para los gestos adecuados si inputRedirectionMode se ha establecido para incluir la entrada CapableTouchpad.

Limitaciones

Naturaleza asincrónica

La naturaleza de este sistema es asincrónica. En el momento en que la aplicación llama a TryRedirectForManipulation y la llamada llega al compositor, habrá eventos de entrada adicionales que podrían haberlo realizado en el subproceso de interfaz de usuario de la aplicación. En la mayoría de los casos, no es perjudicial que la aplicación haya recibido estos eventos, y el desarrollador puede optar por detectar el lado de la aplicación para determinar cómo controlar la entrada y mitigar los problemas. La aplicación sabrá si la manipulación del sistema se encarga de recibir un PointerCaptureLost, el mismo evento recibido cuando ScrollViewer toma el control de entrada hoy mismo. Una complicacion aquí es que es posible un gesto como un "parpadeo rápido" (solo un movimiento panorámico corto) para enviar toda la secuencia de entrada, incluido pointerReleased, a la aplicación antes de que el compositor pueda responder. Si la aplicación se ve afectada por estas limitaciones, puede optar por realizar alguna cantidad de detección de gestos en su lado para garantizar el comportamiento correcto.

Integración con la lógica de controles XAML

En el escenario de parpadeo rápido descrito anteriormente en el que el movimiento panorámico se encuentra en un control como un botón, el botón detectará el movimiento panorámico como un clic si se encuentra dentro del botón. Esto es ligeramente diferente de cómo el sistema GestureRecognizer (que está realizando el enrutamiento) detecta gestos. Para garantizar que los escenarios de tipo de parpadeo rápido funcionen correctamente con XAML, los desarrolladores tendrán que escuchar OnTapped en el botón en lugar de hacer clic solo si se encuentra dentro de un área de interacción del compositor.

Prueba de aciertos de Compositor

El resultado de la prueba de posicionamiento usado para determinar si la manipulación está ocurriendo en el objeto visual correcto se basará en las pruebas de posicionamiento del compositor. Las pruebas de posicionamiento de Compositor no son tan sólidas como pruebas de posicionamiento xaml, por lo que hay casos en los que los resultados podrían tener una ligera discrepancia.

Consulte la documentación de VisualInteractionSourcepara obtener más detalles.

Integración con reconocedores de gestos personalizados en conflicto

Internamente, el sistema GestureRecognizer se usa para enrutar la entrada. Por lo general, las aplicaciones pueden obtener el comportamiento que desean siempre que usen el reconocimiento de gestos del sistema. Si una aplicación intenta usar un reconocedor personalizado que entra en conflicto con el reconocedor del sistema, podría haber conflictos en los que la aplicación espera que el compositor se haga cargo y no lo haga.