VisualInteractionSource.TryRedirectForManipulation Método

Definição

Namespace:

Microsoft.UI.Composition.Interactions

Sobrecargas

TryRedirectForManipulation(PointerPoint)

Tenta enviar manipulações configuradas para o fluxo de ponteiro fornecido para o InteractionTracker, não para o thread de interface do usuário do aplicativo, começando no PointerPoint fornecido. Importante Esse método só deve ser chamado com um PointerDeviceType de Touch.

TryRedirectForManipulation(PointerPoint)

Tenta enviar manipulações configuradas para o fluxo de ponteiro fornecido para o InteractionTracker, não para o thread de interface do usuário do aplicativo, começando no PointerPoint fornecido.

Importante

Esse método só deve ser chamado com um PointerDeviceType de 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

O ponto de entrada.

Exemplos

O snippet de código a seguir mostra como configurar um visual para seguir entrada/gestos.

Isso é feito por meio de três etapas principais:

1. Criar um InteractionTracker e definir (ou associar) seus limites.
2. Criar pelo menos um VisualInteractionSource e associá-lo ao InteractionTracker.
3. Pegando a saída do InteractionTracker e aplicando-a às propriedades Offset e Scale de um Visual.
4. Dizendo ao sistema para tentar lidar com a manipulação quando o PointerPressed ocorrer

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;

Comentários

Esse método permite que o aplicativo indique que o sistema (Compositor) deve assumir todas as manipulações configuradas para um determinado VisualInteractionSource. Quando TryRedirectForManipulation é chamado, o quadro do ponteiro passado é usado como o ponto de partida para tratamento de entrada pelo InteractionTracker. Se o gesto do usuário for testado com clique no 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 com clique em 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 padrão.

Se o VisualInteractionSource redirecionar o fluxo de entrada para o InteractionTracker, o aplicativo receberá um InputPointerSource.PointerCaptureLost no UIElement ou um InputPointerSource.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.

Observação

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

Comportamento assíncrono

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 da interface do usuário do aplicativo. Na maioria dos casos, não é prejudicial para o aplicativo ter recebido esses eventos e você pode optar por detectar por gestos em seu aplicativo para determinar como lidar com a entrada. O aplicativo saberá se a manipulação do sistema assume o controle ao receber um PointerCaptureLost (o mesmo evento recebido quando ScrollViewer assume a manipulação de entrada). Uma complicação é que é possível que um gesto como um "movimento rápido" (um deslize curto) envie todo o fluxo de entrada, incluindo PointerReleased, para o aplicativo antes que o compositor possa responder. Se o aplicativo for afetado por essas limitações, talvez seja necessário fazer alguma detecção de gestos para garantir o comportamento certo.

Lógica de integração com controles XAML

No cenário de movimento rápido descrito acima, em que a panela está em um controle como um botão, o botão detectará a panela 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 os cenários de tipo de movimento rápido funcionem corretamente com XAML, você precisa escutar OnTapped no botão em vez de apenas Clicar se ele estiver dentro de uma área de interação compositor.

Teste de ocorrência do Compositor

O resultado do teste de ocorrência usado para determinar se a manipulação está acontecendo no visual certo será baseado no teste de ocorrência do compositor. O teste de ocorrência 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.

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 o aplicativo estiver tentando usar um reconhecedor personalizado que está em conflito com o reconhecedor do sistema, pode haver conflitos em que o aplicativo espera que o compositor assuma o controle e não o faz.