VisualInteractionSource.TryRedirectForManipulation(PointerPoint) Método

Definição

Namespace:

Windows.UI.Composition.Interactions

Indica que as manipulações configuradas para o fluxo de ponteiro fornecido devem ser enviadas para o InteractionTracker, não para o thread de interface do usuário do aplicativo, começando no PointerPoint fornecido.

TryRedirectForManipulation permite que o VisualInteractionSource redirecione o fluxo de ponteiro para o InteractionTracker se o gesto corresponder à configuração no VisualInteractionSource. Esse método só deve ser chamado com a entrada Pointer do 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 as manipulações configuradas para o fluxo de ponteiro fornecido devem ser enviadas para o InteractionTracker, não para o thread de interface do usuário do aplicativo, começando no PointerPoint fornecido.

Exemplos

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

Comentários

Esse método permite que o aplicativo indique que o sistema (Compositor) deve assumir as manipulações configuradas para um determinado VisualInteractionSource. Quando TryRedirectForManipulation é chamado, o quadro do ponteiro passado é usado como o ponto de partida para o tratamento de entrada do InteractionTracker . Se o gesto do usuário for testado para o visual associado ao VisualInteractionSource (ou um de seus filhos) e o usuário executar um gesto configurado, o sistema manipulará. Se a entrada for testada para outro visual ou o usuário executar um gesto não configurado, a entrada será enviada para o CoreWindow e por meio do roteamento de entrada normal do XAML.

Se o VisualInteractionSource redirecionar o fluxo de entrada para o InteractionTracker, o aplicativo receberá um PointerCaptureLost no UIElement ou um PointerRoutedAway no CoreWindow. Essas mensagens indicam que a entrada foi enviada para longe do thread da interface do usuário do aplicativo. Esse método será mais comumente chamado em PointerPressed.

A entrada PrecisionTouchpad não requer essa chamada e será roteada automaticamente para o InteractionTracker para os gestos apropriados se InputRedirectionMode tiver sido definido para incluir a entrada CapableTouchpad.

Limitações

Natureza assíncrona

A natureza deste sistema é assíncrona. Quando o aplicativo chamar TryRedirectForManipulation e a chamada atingir o compositor, haverá eventos de entrada adicionais que poderiam ter chegado ao thread de interface do usuário do aplicativo. Na maioria dos casos, não é prejudicial para o aplicativo ter recebido esses eventos, e o desenvolvedor pode optar por detectar o lado do aplicativo por gestos para determinar como lidar com a entrada e atenuar as preocupações. O aplicativo saberá se a manipulação do sistema assume o controle recebendo um PointerCaptureLost — o mesmo evento recebido quando ScrollViewer assume a manipulação de entrada hoje. Uma complicação aqui é que é possível para um gesto como um "movimento rápido" (apenas uma panorâmica curta) enviar todo o fluxo de entrada, incluindo o PointerReleased, para o aplicativo antes que o compositor possa responder. Se o aplicativo for afetado por essas limitações, ele poderá optar por fazer alguma quantidade de detecção de gestos ao seu lado para garantir o comportamento certo.

Integração com a lógica de controles XAML

No cenário de movimento rápido descrito acima, em que a panorâmica está em um controle como um botão, o botão detectará a panorâmica como um clique se ela estiver contida no botão. Isso é um pouco diferente de como o GestureRecognizer do sistema (que está fazendo o roteamento) detecta gestos. Para garantir que cenários de tipo de movimento rápido funcionem corretamente com XAML, os desenvolvedores precisarão escutar OnTapped no botão em vez de apenas Clicar se ele estiver dentro de uma área de interação compositora.

Compositor Hit-testing

O resultado do teste de clique usado para determinar se a manipulação está acontecendo no visual certo será baseado no teste de clique do compositor. O teste de clique do compositor não é tão robusto quanto o teste de ocorrência de XAML, portanto, há casos em que os resultados podem ter uma pequena discrepância.

Consulte a documentação do VisualInteractionSourcepara obter mais detalhes.

Integração com reconhecedores de gestos personalizados conflitantes

Internamente, o GestureRecognizer do sistema está sendo usado para rotear a entrada. Os aplicativos geralmente podem obter o comportamento desejado, desde que estejam usando o reconhecimento de gestos do sistema. Se um aplicativo estiver tentando usar um reconhecedor personalizado que entre em conflito com o reconhecedor do sistema, poderá haver conflitos em que o aplicativo espera que o compositor assuma o controle e não o faz.