GestureRecognizer Classe

Definição

Namespace:

Windows.UI.Input

Fornece reconhecimento de gestos e manipulação, ouvintes de eventos e configurações.

public ref class GestureRecognizer sealed

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.None)]
/// [Windows.Foundation.Metadata.Activatable(65536, "Windows.Foundation.UniversalApiContract")]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
class GestureRecognizer final

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.None)]
[Windows.Foundation.Metadata.Activatable(65536, "Windows.Foundation.UniversalApiContract")]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public sealed class GestureRecognizer

function GestureRecognizer()

Public NotInheritable Class GestureRecognizer

Herança

Object Platform::Object IInspectable GestureRecognizer

Atributos

ActivatableAttribute ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Requisitos do Windows

Família de dispositivos	Windows 10 (introduzida na 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (introduzida na v1.0)

Exemplos

Aqui, configuramos um objeto GestureRecognizer com uma coleção de manipuladores de eventos de entrada para processar a entrada de ponteiro e gesto. Para obter mais informações sobre como escutar e lidar com eventos Windows Runtime, consulte Visão geral de eventos e eventos roteado. Consulte o Exemplo de entrada básico para obter a implementação completa.

class ManipulationInputProcessor
{
    GestureRecognizer recognizer;
    UIElement element;
    UIElement reference;
    TransformGroup cumulativeTransform;
    MatrixTransform previousTransform;
    CompositeTransform deltaTransform;

    public ManipulationInputProcessor(GestureRecognizer gestureRecognizer, UIElement target, UIElement referenceFrame)
    {
        recognizer = gestureRecognizer;
        element = target;
        reference = referenceFrame;
        // Initialize the transforms that will be used to manipulate the shape
        InitializeTransforms();
        // The GestureSettings property dictates what manipulation events the
        // Gesture Recognizer will listen to.  This will set it to a limited
        // subset of these events.
        recognizer.GestureSettings = GenerateDefaultSettings();
        // Set up pointer event handlers. These receive input events that are used by the gesture recognizer.
        element.PointerPressed += OnPointerPressed;
        element.PointerMoved += OnPointerMoved;
        element.PointerReleased += OnPointerReleased;
        element.PointerCanceled += OnPointerCanceled;
        // Set up event handlers to respond to gesture recognizer output
        recognizer.ManipulationStarted += OnManipulationStarted;
        recognizer.ManipulationUpdated += OnManipulationUpdated;
        recognizer.ManipulationCompleted += OnManipulationCompleted;
        recognizer.ManipulationInertiaStarting += OnManipulationInertiaStarting;
    }

    public void InitializeTransforms()
    {
        cumulativeTransform = new TransformGroup();
        deltaTransform = new CompositeTransform();
        previousTransform = new MatrixTransform() { Matrix = Matrix.Identity };
        cumulativeTransform.Children.Add(previousTransform);
        cumulativeTransform.Children.Add(deltaTransform);
        element.RenderTransform = cumulativeTransform;
    }

    // Return the default GestureSettings for this sample
    GestureSettings GenerateDefaultSettings()
    {
        return GestureSettings.ManipulationTranslateX |
            GestureSettings.ManipulationTranslateY |
            GestureSettings.ManipulationRotate |
            GestureSettings.ManipulationTranslateInertia |
            GestureSettings.ManipulationRotateInertia;
    }

    // Route the pointer pressed event to the gesture recognizer.
    // The points are in the reference frame of the canvas that contains the rectangle element.
    void OnPointerPressed(object sender, PointerRoutedEventArgs args)
    {
        // Set the pointer capture to the element being interacted with so that only it
        // will fire pointer-related events
        element.CapturePointer(args.Pointer);
        // Feed the current point into the gesture recognizer as a down event
        recognizer.ProcessDownEvent(args.GetCurrentPoint(reference));
    }

    // Route the pointer moved event to the gesture recognizer.
    // The points are in the reference frame of the canvas that contains the rectangle element.
    void OnPointerMoved(object sender, PointerRoutedEventArgs args)
    {
        // Feed the set of points into the gesture recognizer as a move event
        recognizer.ProcessMoveEvents(args.GetIntermediatePoints(reference));
    }

    // Route the pointer released event to the gesture recognizer.
    // The points are in the reference frame of the canvas that contains the rectangle element.
    void OnPointerReleased(object sender, PointerRoutedEventArgs args)
    {
        // Feed the current point into the gesture recognizer as an up event
        recognizer.ProcessUpEvent(args.GetCurrentPoint(reference));
        // Release the pointer
        element.ReleasePointerCapture(args.Pointer);
    }

    // Route the pointer canceled event to the gesture recognizer.
    // The points are in the reference frame of the canvas that contains the rectangle element.
    void OnPointerCanceled(object sender, PointerRoutedEventArgs args)
    {
        recognizer.CompleteGesture();
        element.ReleasePointerCapture(args.Pointer);
    }

    // When a manipulation begins, change the color of the object to reflect
    // that a manipulation is in progress
    void OnManipulationStarted(object sender, ManipulationStartedEventArgs e)
    {
        Border b = element as Border;
        b.Background = new SolidColorBrush(Windows.UI.Colors.DeepSkyBlue);
    }

    // Process the change resulting from a manipulation
    void OnManipulationUpdated(object sender, ManipulationUpdatedEventArgs e)
    {
        previousTransform.Matrix = cumulativeTransform.Value;
        // Get the center point of the manipulation for rotation
        Point center = new Point(e.Position.X, e.Position.Y);
        deltaTransform.CenterX = center.X;
        deltaTransform.CenterY = center.Y;
        // Look at the Delta property of the ManipulationDeltaRoutedEventArgs to retrieve
        // the rotation, X, and Y changes
        deltaTransform.Rotation = e.Delta.Rotation;
        deltaTransform.TranslateX = e.Delta.Translation.X;
        deltaTransform.TranslateY = e.Delta.Translation.Y;
    }

    // When a manipulation that's a result of inertia begins, change the color of the
    // the object to reflect that inertia has taken over
    void OnManipulationInertiaStarting(object sender, ManipulationInertiaStartingEventArgs e)
    {
        Border b = element as Border;
        b.Background = new SolidColorBrush(Windows.UI.Colors.RoyalBlue);
    }

    // When a manipulation has finished, reset the color of the object
    void OnManipulationCompleted(object sender, ManipulationCompletedEventArgs e)
    {
        Border b = element as Border;
        b.Background = new SolidColorBrush(Windows.UI.Colors.LightGray);
    }

    // Modify the GestureSettings property to only allow movement on the X axis
    public void LockToXAxis()
    {
        recognizer.CompleteGesture();
        recognizer.GestureSettings |= GestureSettings.ManipulationTranslateY | GestureSettings.ManipulationTranslateX;
        recognizer.GestureSettings ^= GestureSettings.ManipulationTranslateY;
    }

    // Modify the GestureSettings property to only allow movement on the Y axis
    public void LockToYAxis()
    {
        recognizer.CompleteGesture();
        recognizer.GestureSettings |= GestureSettings.ManipulationTranslateY | GestureSettings.ManipulationTranslateX;
        recognizer.GestureSettings ^= GestureSettings.ManipulationTranslateX;
    }

    // Modify the GestureSettings property to allow movement on both the X and Y axes
    public void MoveOnXAndYAxes()
    {
        recognizer.CompleteGesture();
        recognizer.GestureSettings |= GestureSettings.ManipulationTranslateX | GestureSettings.ManipulationTranslateY;
    }

    // Modify the GestureSettings property to enable or disable inertia based on the passed-in value
    public void UseInertia(bool inertia)
    {
        if (!inertia)
        {
            recognizer.CompleteGesture();
            recognizer.GestureSettings ^= GestureSettings.ManipulationTranslateInertia | GestureSettings.ManipulationRotateInertia;
        }
        else
        {
            recognizer.GestureSettings |= GestureSettings.ManipulationTranslateInertia | GestureSettings.ManipulationRotateInertia;
        }
    }

    public void Reset()
    {
        element.RenderTransform = null;
        recognizer.CompleteGesture();
        InitializeTransforms();
        recognizer.GestureSettings = GenerateDefaultSettings();
    }
}

Exemplos

• Amostra do modo de interação do usuário
• Amostra de visuais de foco
• Amostra de entrada básica
• Exemplo de jogo direct3D
• Exemplo de jogo DirectX e XAML

Exemplos arquivados

• Entrada: exemplo de manipulações e gestos
• Entrada: amostra de eventos de entrada do usuário XAML
• Exemplo de rolagem, movimento panorâmico e zoom de XAML
• Amostra de entrada por toque do DirectX

Comentários

Você pode criar um objeto de gesto para cada elemento apropriado quando o aplicativo é iniciado. No entanto, essa abordagem pode não ser bem dimensionada dependendo do número de objetos de gesto que você precisa criar (por exemplo, um quebra-cabeça com centenas de peças).

Nesse caso, você pode criar objetos de gesto dinamicamente em um evento de ponteiro e destruí-los em um evento MSGestureEnd . Essa abordagem é bem dimensionada, mas incorre em alguma sobrecarga devido à criação e liberação desses objetos.

Como alternativa, você pode alocar e gerenciar dinamicamente um pool de objetos de gesto reutilizáveis.

Observação

Essa classe não é ágil, o que significa que você precisa considerar seu modelo de threading e o comportamento de marshaling. Para obter mais informações, consulte Threading and Marshaling (C++/CX) e Using Windows Runtime objects in a multithreaded environment (.NET).

Para obter mais detalhes sobre como usar a funcionalidade de slide cruzado, consulte Diretrizes para slide cruzado. As distâncias de limite usadas pela interação de deslizamento transversal são mostradas no diagrama a seguir.

As propriedades PivotRadius e PivotCenter são usadas somente quando a entrada de ponteiro único é detectada. Eles não têm nenhum efeito sobre a entrada de vários ponteiros. O valor dessas propriedades deve ser atualizado regularmente durante a interação.

A rotação tem suporte de um GestureRecognizer somente quando manipulationRotate é definido por meio da propriedade GestureSettings .

Não há suporte para rotação para entrada de ponteiro único se o valor de PivotRadius estiver definido como 0.

Histórico de versão

Versão do Windows	Versão do SDK	Valor adicionado
2004	19041	HoldMaxContactCount
2004	19041	HoldMinContactCount
2004	19041	HoldRadius
2004	19041	HoldStartDelay
2004	19041	TapMaxContactCount
2004	19041	TapMinContactCount
2004	19041	TranslationMaxContactCount
2004	19041	TranslationMinContactCount

Construtores

GestureRecognizer()

Inicializa uma nova instância de um objeto GestureRecognizer .

Propriedades

AutoProcessInertia	Obtém ou define um valor que indica se as manipulações durante a inércia são geradas automaticamente.
CrossSlideExact	Obtém ou define um valor que indica se a distância exata do contato inicial até o final da interação entre slides é relatada. Por padrão, um pequeno limite de distância é subtraído da primeira posição relatada pelo sistema para interações entre slides. Se esse sinalizador for definido, o limite de distância não será subtraído da posição inicial. Observação Esse limite de distância destina-se a considerar qualquer movimento leve do contato após a detecção inicial. Ele ajuda o sistema a diferenciar entre deslizamento cruzado e movimento panorâmico e ajuda a garantir que um gesto de toque não seja interpretado como qualquer um.
CrossSlideHorizontally	Obtém ou define um valor que indica se o eixo entre slides é horizontal.
CrossSlideThresholds	Obtém ou define valores que indicam os limites de distância para uma interação crossSliding .
GestureSettings	Obtém ou define um valor que indica as configurações de gesto e manipulação compatíveis com um aplicativo.
HoldMaxContactCount	Obtém ou define o número máximo de pontos de contato necessários para reconhecer um evento Windows.UI.Input.GestureRecognizer.Holding .
HoldMinContactCount	Obtém ou define o número mínimo de pontos de contato necessários para reconhecer um evento Windows.UI.Input.GestureRecognizer.Holding .
HoldRadius	Obtém ou define o raio dos pontos de contato reconhecidos para o evento Windows.UI.Input.GestureRecognizer.Holding .
HoldStartDelay	Obtém ou define o limite de tempo no qual os contatos são reconhecidos para o evento Windows.UI.Input.GestureRecognizer.Holding .
InertiaExpansion	Obtém ou define um valor que indica a alteração relativa no tamanho de um objeto desde o início da inércia até o final da inércia (quando o redimensionamento, ou dimensionamento, é concluído).
InertiaExpansionDeceleration	Obtém ou define um valor que indica a taxa de desaceleração do início da inércia até o final da inércia (quando a manipulação de redimensionamento ou expansão é concluída).
InertiaRotationAngle	Obtém ou define um valor que indica o ângulo final de rotação de um objeto no final da inércia (quando a manipulação de rotação é concluída).
InertiaRotationDeceleration	Obtém ou define um valor que indica a taxa de desaceleração do início da inércia até o final da inércia (quando a manipulação de rotação é concluída).
InertiaTranslationDeceleration	Obtém ou define um valor que indica a taxa de desaceleração do início da inércia até o final da inércia (quando a manipulação de tradução é concluída).
InertiaTranslationDisplacement	Obtém ou define um valor que indica a alteração relativa no local da tela de um objeto desde o início da inércia até o final da inércia (quando a manipulação de tradução é concluída).
IsActive	Obtém um valor que indica se uma interação está sendo processada.
IsInertial	Obtém um valor que indica se uma manipulação ainda está sendo processada durante a inércia (nenhum ponto de entrada está ativo).
ManipulationExact	Obtém ou define um valor que indica se a distância exata do contato inicial até o final da interação é relatada. Por padrão, um pequeno limite de distância é subtraído do primeiro delta relatado pelo sistema. Esse limite de distância destina-se a considerar pequenos movimentos do contato ao processar um gesto de toque. Se esse sinalizador for definido, o limite de distância não será subtraído do primeiro delta.
MouseWheelParameters	Obtém um conjunto de propriedades associadas ao botão de roda de um dispositivo de mouse.
PivotCenter	Obtém ou define o ponto central para uma interação de rotação quando uma entrada de ponteiro único é detectada.
PivotRadius	Obtém ou define o raio, do PivotCenter à entrada do ponteiro, para uma interação de rotação quando a entrada de ponteiro único é detectada.
ShowGestureFeedback	Obtém ou define um valor que indica se os comentários visuais são exibidos durante uma interação.
TapMaxContactCount	Obtém ou define o número máximo de pontos de contato necessários para reconhecer um evento Windows.UI.Input.GestureRecognizer.Tapped .
TapMinContactCount	Obtém ou define o número mínimo de pontos de contato necessários para reconhecer um evento Windows.UI.Input.GestureRecognizer.Tapped .
TranslationMaxContactCount	Obtém ou define o número máximo de pontos de contato necessários para reconhecer um evento de tradução (ou movimento panorâmico).
TranslationMinContactCount	Obtém ou define o número mínimo de pontos de contato necessários para reconhecer um evento de tradução (ou movimento panorâmico).

Métodos

CanBeDoubleTap(PointerPoint)	Identifica se um toque ainda pode ser interpretado como o segundo toque de um gesto de toque duplo.
CompleteGesture()	Faz com que o reconhecedor de gestos finalize uma interação.
ProcessDownEvent(PointerPoint)	Processa a entrada do ponteiro e gera os eventos GestureRecognizer apropriados para uma ação de ponteiro para baixo para os gestos e manipulações especificados pela propriedade GestureSettings .
ProcessInertia()	Executa cálculos de inércia e gera os vários eventos de inércia.
ProcessMouseWheelEvent(PointerPoint, Boolean, Boolean)	Processa a entrada do ponteiro e gera os eventos GestureRecognizer apropriados a uma ação de roda do mouse para os gestos e manipulações especificados pela propriedade GestureSettings .
ProcessMoveEvents(IVector<PointerPoint>)	Processa a entrada do ponteiro e gera os eventos GestureRecognizer apropriados para uma ação de movimentação de ponteiro para os gestos e manipulações especificados pela propriedade GestureSettings .
ProcessUpEvent(PointerPoint)	Processa a entrada do ponteiro e gera os eventos GestureRecognizer apropriados para uma ação de ponteiro para cima para os gestos e manipulações especificados pela propriedade GestureSettings .

Eventos

CrossSliding	Ocorre quando um usuário executa um gesto de deslizar ou deslizar o dedo (por meio de um único contato de toque) em uma área de conteúdo que dá suporte ao movimento panorâmico apenas em um único eixo. O gesto deve ocorrer em uma direção perpendicular a esse eixo panorâmico. Observação Um passar o dedo é um gesto deslizante curto que resulta em uma ação de seleção enquanto o gesto de slide mais longo cruza um limite de distância e resulta em uma ação de reorganização. Os gestos de deslizar o dedo e o slide são demonstrados no diagrama a seguir.
Dragging	Ocorre quando um usuário executa um gesto de deslizar ou deslizar o dedo com um mouse ou caneta/caneta (contato único).
Holding	Ocorre quando um usuário executa um gesto de pressionar e segurar (com um único contato de toque, mouse ou caneta).
ManipulationCompleted	Ocorre quando os pontos de entrada são levantados e todo o movimento subsequente (tradução, expansão ou rotação) por inércia foi encerrado.
ManipulationInertiaStarting	Ocorre quando todos os pontos de contato são levantados durante uma manipulação e a velocidade da manipulação é significativa o suficiente para iniciar o comportamento de inércia (a tradução, a expansão ou a rotação continuam depois que os ponteiros de entrada são levantados).
ManipulationStarted	Ocorre quando um ou mais pontos de entrada foram iniciados e o movimento subsequente (tradução, expansão ou rotação) foi iniciado.
ManipulationUpdated	Ocorre depois que um ou mais pontos de entrada são iniciados e o movimento subsequente (tradução, expansão ou rotação) está em andamento.
RightTapped	Ocorre quando a entrada do ponteiro é interpretada como um gesto de toque à direita, independentemente do dispositivo de entrada. Clique no botão direito do mouse Clique no botão do barril da caneta Tocar ou pressionar a caneta e segurar
Tapped	Ocorre quando a entrada do ponteiro é interpretada como um gesto de toque.

Confira também

• Windows.UI.Input
• Windows.Devices.Input
• Windows.UI.Core
• Windows.UI.Input.Inking
• Windows.UI.Xaml.Input
• Interações personalizadas do usuário
• Diretrizes de experiência do usuário para interações personalizadas do usuário
• Diretrizes de design de toque