Compartilhar via


GestureRecognizer Classe

Definição

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

public ref class GestureRecognizer sealed
/// [Windows.Foundation.Metadata.Activatable(65536, Windows.Foundation.UniversalApiContract)]
/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.None)]
class GestureRecognizer final
/// [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")]
class GestureRecognizer final
/// [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.Activatable(65536, typeof(Windows.Foundation.UniversalApiContract))]
[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.None)]
public sealed class GestureRecognizer
[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")]
public sealed class GestureRecognizer
[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

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

Exemplos arquivados

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.

Captura de tela mostrando os processos de selecionar e arrastar e soltar.

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. Diagrama mostrando as ações selecionar e arrastar.

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.

Aplica-se a

Confira também