Idioma: HTML | XAML

Respondendo a interações por teclado (XAML)

Applies to Windows and Windows Phone

Responda às ações de pressionamento de tecla de um hardware ou teclado de toque nos aplicativos usando o teclado e manipuladores de eventos de classe.

Importante  

Alguns controles de Tempo de Execução do Windows manipulam eventos de entrada internamente. Nestes casos, pode parecer que não ocorre um evento de entrada, porque o ouvinte de evento não chama o manipulador associado. Geralmente, este subconjunto de teclas é processado pelo manipulador de classe para proporcionar suporte interno de acessibilidade de teclado básico. Por exemplo, a classe Button sobrepõe os eventos OnKeyDown para a tecla Enter ou a barra de espaço (bem como OnPointerPressed) e os encaminha para o evento Click do controle. Quando uma tecla é manipulada pela classe de controle, os eventos KeyDown e KeyUp não são acionados.

Isso fornece um teclado integrado equivalente para invocar o botão, similar ao tocar com um dedo ou clicar com o mouse. Outras teclas além da tecla Enter e da barra de espaço, ainda acionam eventos KeyDown e KeyUp. Veja Visão geral de eventos e eventos roteados para obter mais informações sobre como a manipulação baseada em classes de eventos funciona (especificamente, Manipuladores de evento de entrada em controles).

Dica  As informações contidas neste tópico são específicas para o desenvolvimento de aplicativos em C++, C# ou Visual Basic.

Veja Respondendo a interações por teclado (HTML) para aplicativos em JavaScript.

Pré-requisitos:  Dê uma olhada nestes tópicos para se familiarizar com as tecnologias discutidas aqui.

Crie seu primeiro aplicativo da Windows Store em C# ou Visual Basic

Crie seu primeiro aplicativo da Windows Store em C++

Mapa de aplicativos da Windows Store em C# ou Visual Basic

Mapa de aplicativos da Windows Store em C++

Saiba mais sobre eventos em Visão geral de eventos e eventos roteados.

Recursos de aplicativos, do início ao fim:  Explore esse recurso mais profundamente como parte da nossa série sobre recursos para aplicativos, do início ao fim

Interação do usuário, do início ao fim (XAML)

Personalização da interação do usuário, do início ao fim (XAML)

Diretrizes de experiência do usuário:  

As bibliotecas de controle de plataforma ( (HTML e XAML) fornecem a experiência de total interação do usuário, incluindo interações padrão, efeitos físicos animados e comentários visuais. Se não precisar de suporte para interação personalizado, use esses controles internos.

Se os controles de plataforma não forem suficientes, as seguintes diretrizes para interação do usuário podem ajudá-lo a proporcionar uma experiência de interação envolvente e imersiva, consistente entre os modos de entrada. Essas diretrizes têm como foco principal a entrada por toque, mas elas são também relevantes para a entrada por mouse e caneta.

Amostras:  Veja essa funcionalidade em ação nos exemplos de aplicativos.

Amostra de entrada

Entrada: exemplo de recursos de dispositivo

Entrada: amostra de teclado virtual

Respondendo ao aparecimento da amostra de teclado na tela

Visão geral

A entrada por teclado é uma parte importante da experiência geral da interação do usuário para aplicativos. O teclado é indispensável para pessoas portadoras de determinadas deficiências ou usuários que simplesmente o consideram um método mais eficiente de interagir com um aplicativo. Por exemplo, os usuários devem ser capazes de navegar pelo seu aplicativo usando as teclas Tab e de direção, de ativar elementos da interface do usuário ao usar as teclas Barra de Espaços e Enter, e acessar comandos ao usar atalhos de teclado.

Uma interface de usuário do teclado bem projetada é um aspecto importante da acessibilidade do software. Ela permite que os usuários com deficiência visual ou que possuam determinadas deficiências motoras naveguem em um aplicativo e a interagir com seus recursos. Esses usuários talvez não consigam usar um mouse e, em vez disso, usem diversas tecnologias assistenciais, como ferramentas avançadas de teclado, teclados virtuais, ampliadores de tela, leitores de tela e utilitários de entrada de voz.

O tipo mais comum de teclado é o externo, ou seja, um teclado de hardware fisicamente conectado a um dispositivo. Além de um teclado de hardware, o Windows 8 fornece dois teclados de software:

    • Applies to Windows

    Windows:

    O teclado virtual é um teclado de software visual, que você pode usar no lugar do teclado físico para digitar e entrar dados usando toque, mouse, caneta ou outro dispositivo apontador (uma tela sensível ao toque não é necessária). O teclado virtual é fornecido para sistemas que não têm um teclado físico ou para usuários cujos problemas de mobilidade impedem o uso de dispositivos de entrada físicos tradicionais. O teclado virtual emula a maior parte, se não toda a funcionalidades de um teclado de hardware.

    O teclado virtual

    • Applies to Windows

    Windows:

    O teclado de toque é um teclado de software visual usado para entrada de texto por toque. O teclado de toque não é uma substituição ao teclado virtual, pois é usado apenas para entrada de texto (ele não emula o teclado de hardware) e só aparece quando um campo de texto ou outro controle de texto editável é focalizado.

    Observação  O Teclado Virtual tem prioridade sobre o teclado virtual, que não será mostrado se o Teclado Virtual estiver presente.

    Veja aqui exemplos do teclado de toque. A primeira imagem ilustra o layout padrão; a segunda, o layout em miniatura (que pode não estar disponível em todos os idiomas).

    O teclado de toque em layout padrão

    O teclado de toque em layout em miniatura

Eventos de teclado

Os seguintes eventos podem ocorrer para teclados físicos e sensíveis ao toque.

EventoDescrição
KeyDown Ocorre quando uma tecla é pressionada.
KeyUp Ocorre quando uma tecla é solta.

 

Foco e eventos do teclado

Os controles em sua interface do usuário geram eventos de teclado apenas quando possuem foco de entrada. Um controle individual ganha foco quando o usuário clica ou toca diretamente nesse controle no layout, ou utiliza a tecla Tab para avançar na sequência de tabulação dentro da área de conteúdo.

Você também pode chamar um método Focus do controle para forçar o foco. Isso é necessário quando você implementa teclas de atalho, porque o foco do teclado não está definido por padrão quando a sua interface de usuário é carregada. Para obter mais informações, consulte Exemplos de tecla de atalho posteriormente neste tópico.

Para um controle receber o foco de entrada, ele deve estar habilitado, visível e apresentar valores de propriedade IsTabStop e HitTestVisible de true. Esse é o estado padrão da maioria dos controles. Quando um controle tem um foco de entrada, ele pode acionar e responder a eventos de entrada de teclado conforme descrito posteriormente neste tópico. Você também pode responder a um controle que recebe ou perde foco manipulando eventos GotFocus e LostFocus.

Por padrão, a sequência de tabulação de controles está na ordem que aparece no XAML. No entanto, é possível modificar esta ordem ao usar a propriedade de TabIndex. Para obter mais informações, consulte Implementando a acessibilidade de teclado.

Manipuladores de eventos do teclado

Um manipulador de eventos de entrada implementa um delegado que fornece as seguintes informações:

  • O remetente do evento. O remetente relata o objeto ao qual o manipulador de eventos está anexado.
  • Dados do evento. Para eventos do teclado, esses dados serão uma instância de KeyRoutedEventArgs. O delegado para manipuladores é KeyEventHandler. As propriedades mais relevantes de KeyRoutedEventArgs para a maioria dos cenários de manipulação são Key e, provavelmente, KeyStatus.
  • OriginalSource. Como eventos do teclado são eventos roteados, os dados dos eventos fornecem a OriginalSource. Se você deliberadamente permite que eventos subam a árvore de um objeto, OriginalSource é, por vezes, o objeto em questão em vez do remetente. No entanto, isso depende do seu design. Para obter mais informações sobre como você pode usar OriginalSource em vez do remetente, consulte a seção "Eventos roteados do teclado" deste tópico, ou Visão geral de eventos e eventos roteados.

Anexando um manipulador de eventos do teclado

Você pode anexar funções de manipulação de eventos do teclado a qualquer objeto que inclua o evento como um membro. Isso inclui qualquer classe derivada de UIElement. O exemplo de XAML a seguir mostra como anexar manipuladores ao evento KeyUp de um Grid.



<Grid KeyUp="Grid_KeyUp">
  ...
</Grid>


Você também pode anexar um manipulador de eventos em código. Para obter mais informações, consulte Visão geral de eventos e eventos roteados.

Definindo um manipulador de eventos do teclado

O exemplo a seguir mostra a definição do manipulador de eventos incompleta para o manipulador de eventos KeyUp que foi anexado no exemplo anterior.



void Grid_KeyUp(object sender, KeyRoutedEventArgs e)
{
    //handling code here
}


Usando KeyRoutedEventArgs

Todos os eventos do teclado usam KeyRoutedEventArgs para dados de eventos, e KeyRoutedEventArgs contém as seguintes propriedades:

Tecla

O evento KeyDown será acionado se a tecla for pressionada. Da mesma forma, KeyUp será acionado se a tecla for solta. Normalmente, você escuta eventos para processar um valor de uma tecla específico. Para determinar qual tecla é pressionada ou liberada, verifique o valor de Key nos dados do evento. Key retorna um valor VirtualKey. A enumeração VirtualKey inclui todas as teclas suportadas.

Teclas modificadoras

  • Applies to Windows

Windows:

As teclas modificadoras são teclas como Ctrl ou Shift que os usuários normalmente pressionam em combinação com outras teclas. Seu aplicativo pode usar essas combinações como atalhos de teclado para chamar comandos do aplicativo.

É possível detectar combinações de teclas de atalho usando os manipuladores de evento KeyDown e KeyUp. Você pode controlar o estado pressionado das teclas modificadoras em que tem interesse. Quando ocorre um evento de teclado para uma tecla não modificadora, é possível verificar se uma tecla modificadora está no estado pressionado ao mesmo tempo.

Observação  A tecla Alt é representada pelo valor VirtualKey.Menu.

Exemplo de teclas de atalho

  • Applies to Windows

Windows:

O exemplo a seguir mostra como implementar as teclas de atalho. Neste exemplo, os usuários podem controlar a reprodução de mídia usando os botões Play, Pause e Stop, ou os atalhos de teclado Ctrl+P, Ctrl+A e Ctrl+S. O XAML do botão mostra os atalhos usando dicas de ferramentas e propriedades AutomationProperties nos rótulos dos botões. Esta autodocumentação é importante para aumentar a usabilidade e acessibilidade de seu aplicativo. Para saber mais, veja Implementando a acessibilidade de teclado.

Observe também que a página define o foco de entrada para si própria quando é carregada. Sem essa etapa, nenhum controle terá foco de entrada inicial e o aplicativo não acionará eventos de entrada até que o usuário defina o foco de entrada manualmente (por exemplo, pressionando TAB ou clicando em um controle).


<Grid KeyDown="Grid_KeyDown">

  <Grid.RowDefinitions>
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
  </Grid.RowDefinitions>

  <MediaElement x:Name="DemoMovie" Source="xbox.wmv" 
    Width="500" Height="500" Margin="20" HorizontalAlignment="Center" />

  <StackPanel Grid.Row="1" Margin="10"
    Orientation="Horizontal" HorizontalAlignment="Center">

    <Button x:Name="PlayButton" Click="MediaButton_Click"
      ToolTipService.ToolTip="Shortcut key: Ctrl+P"
      AutomationProperties.AcceleratorKey="Control P">
      <TextBlock>Play</TextBlock>
    </Button>

    <Button x:Name="PauseButton" Click="MediaButton_Click"
      ToolTipService.ToolTip="Shortcut key: Ctrl+A" 
      AutomationProperties.AcceleratorKey="Control A">
      <TextBlock>Pause</TextBlock>
    </Button>

    <Button x:Name="StopButton" Click="MediaButton_Click"
      ToolTipService.ToolTip="Shortcut key: Ctrl+S" 
      AutomationProperties.AcceleratorKey="Control S">
      <TextBlock>Stop</TextBlock>
    </Button>

  </StackPanel>

</Grid>



protected override void OnNavigatedTo(NavigationEventArgs e)
{
    // Set the input focus to ensure that keyboard events are raised.
    this.Loaded += delegate { this.Focus(FocusState.Programmatic); };
}

private void Grid_KeyUp(object sender, KeyRoutedEventArgs e)
{
    if (e.Key == VirtualKey.Control) isCtrlKeyPressed = false;
}

private void Grid_KeyDown(object sender, KeyRoutedEventArgs e)
{
    if (e.Key == VirtualKey.Control) isCtrlKeyPressed = true;
    else if (isCtrlKeyPressed)
    {
        switch (e.Key)
        {
            case VirtualKey.P: DemoMovie.Play(); break;
            case VirtualKey.A: DemoMovie.Pause(); break;
            case VirtualKey.S: DemoMovie.Stop(); break;
        }
    }
}

private void MediaButton_Click(object sender, RoutedEventArgs e)
{
    switch ((sender as Button).Name)
    {
        case "PlayButton": DemoMovie.Play(); break;
        case "PauseButton": DemoMovie.Pause(); break;
        case "StopButton": DemoMovie.Stop(); break;
    }
}


Observação  A configuração de AutomationProperties.AcceleratorKey ou AutomationProperties.AccessKey no XAML oferece informações sobre cadeia de caracteres, que documentam a tecla de atalho para chamar a ação em particular. As .informações são capturadas por clientes de Automação de interface do usuário da Microsoft como o Narrador e são tipicamente fornecidas diretamente ao usuário. A configuração de AutomationProperties.AcceleratorKey ou de AutomationProperties.AccessKey não tem qualquer ação por conta própria. Você ainda precisa anexar manipuladores para eventos KeyDown ou KeyUp para realmente implementar o comportamento de atalho de teclado em seu aplicativo. Além disso, a decoração de texto sublinhado para uma tecla de acesso não é fornecida automaticamente. Você deve sublinhar explicitamente o texto para a tecla específica em seu mnemônico como formatação Underline embutida se quiser mostrar texto sublinhado na interface do usuário.

Eventos de teclado roteados

Alguns eventos são eventos roteados, inclusive KeyDown e KeyUp. Eventos roteados usam a estratégia de roteamento por propagação. A estratégia de roteamento por propagação indica que um evento se origina de um objeto filho e então é encaminhado para sucessivos objetos pai na árvore de objetos. Isso apresenta outra oportunidade para manipular o mesmo evento e interagir com os mesmos dados de eventos.

Considere o exemplo em XAML a seguir, que manipula eventos KeyUp para um objeto Canvas e dois objetos Button. Neste caso, se você soltar uma tecla enquanto o foco é mantido por cada objeto Button, ele aciona o evento KeyUp. O evento é, então, propagado para o Canvas pai.


<StackPanel KeyUp="StackPanel_KeyUp">
  <Button Name="ButtonA" Content="Button A"/>
  <Button Name="ButtonB" Content="Button B"/>
  <TextBlock Name="statusTextBlock"/>
</StackPanel>


O exemplo a seguir mostra como implementar o manipulador de eventos KeyUp no conteúdo XAML correspondente do exemplo anterior.


void StackPanel_KeyUp(object sender, KeyRoutedEventArgs e)
{
    statusTextBlock.Text = String.Format(
        "The key {0} was pressed while focus was on {1}",
        e.Key.ToString(), (e.OriginalSource as FrameworkElement).Name);
}


Observe o uso da propriedade OriginalSource no manipulador anterior. Aqui, OriginalSource relata o objeto que acionou o evento. O objeto não poderia ser o StackPanel, pois o StackPanel não é um controle e não pode ter foco. Apenas um dos dois botões dentro de StackPanel poderiam ter possivelmente acionado o evento, mas qual deles? Você usa OriginalSource para distinguir o objeto de origem do evento real se você estiver manipulando o evento em um objeto pai.

A propriedade Handled nos dados do evento

Dependendo da sua estratégia de manipulação de eventos, você pode querer que apenas um manipulador de eventos reaja a um evento propagado. Por exemplo, se você tiver um manipulador KeyUp específico anexado a um dos controles Button, ele teria a mesma oportunidade de manipular o evento. Nesse caso, talvez você não queira que o painel pai manipule também o evento. Nesse cenário, use a propriedade Handled nos dados do evento.

O objetivo da propriedade Handled em uma classe de dados de eventos roteados é informar que outro manipulador registrado por você anteriormente na rota do evento já atuou. Isso influencia o comportamento do sistema de eventos roteados. Quando você define Handled como true em um manipulador de eventos, o roteamento desse evento é parado e ele não é enviado para os elementos pais sucessivos.

AddHandler e eventos do teclado já manipulados

Você pode usar uma técnica especial para anexar manipuladores que podem atuar em eventos que já estão marcados como manipulados. Essa técnica usa o método AddHandler para registrar um manipulador, em vez de usar atributos XAML ou sintaxe específica de linguagem para adicionar manipuladores, como += em C#. Uma limitação dessa técnica, em geral, é que a API AddHandler obtém um parâmetro do tipo RoutedEvent que identifica o evento roteado em questão. Nem todos os eventos roteados fornecem um identificador RoutedEvent, e essa consideração afeta os eventos roteados que podem ainda ser manipulados no caso Handled. Os eventos KeyDown e KeyUp possuem identificadores de eventos roteados (KeyDownEvent e KeyUpEvent) em UIElement. Contudo, outros eventos de texto relacionados, tais como TextBox.TextChanged, não possuem identificadores de eventos roteados e, portanto, não podem ser usados com a técnica AddHandler.

Comando

Um pequeno número de elementos da interface do usuário fornece suporte interno para comandos. Comandos usam eventos roteados relacionados à entrada na sua implementação subjacente. Eles permitem o processamento de entrada relacionada da interface do usuário, como uma determinada ação do ponteiro ou uma tecla de aceleração específica, invocando um único manipulador de comandos.

Se comandos estiverem disponíveis para um elemento da interface do usuário, considere usar as respectivas APIs de comando em vez de qualquer evento de entrada à parte. Para saber mais, consulte ButtonBase.Command.

Também é possível implementar ICommand para encapsular a funcionalidade do comando que você invoca de manipuladores de eventos comuns. Isso permite usar comandos mesmo quando não há nenhuma propriedade de Command disponível.

Entrada de texto e controles

Certos controles reagem a eventos do teclado com a sua própria manipulação. Por exemplo, TextBox é um controle desenvolvido para capturar e depois representar visualmente o texto que foi inserido com o uso de um teclado. Ele usa KeyUp e KeyDown, na sua própria lógica, para capturar toques de tecla, depois ativa também seu próprio evento TextChanged caso o texto seja realmente alterado.

Geralmente, você ainda pode adicionar manipuladores para KeyUp e KeyDown a uma TextBox, ou a qualquer controle relacionado feito para processar entrada de texto. Contudo, de acordo com o seu design, um controle pode não responder a todos os valores de teclas a ele direcionados por eventos de teclas. Cada controle tem um comportamento específico.

Como exemplo, ButtonBase (a classe base para Button) processa KeyUp para que possa verificar a barra de espaço ou a tecla Enter. ButtonBase considera KeyUp equivalente a um botão esquerdo do mouse apertado para emitir um evento Click. Esse processamento do evento é realizado quando ButtonBase substitui o método virtual OnKeyUp. Em sua implementação, ele define Handled como true. O resultado é que qualquer pai de um botão que esteja ouvindo um evento de tecla, no caso de uma barra de espaço, não receberia o evento já manipulado pelos próprios manipuladores.

Outro exemplo é TextBox. Algumas teclas, como as teclas de SETA, não são consideradas texto por TextBox e são, em vez disso, consideradas específicas do comportamento da interface do usuário do controle. A TextBox marca esses casos de evento como manipulados.

Controles personalizados podem implementar o próprio comportamento de substituição para eventos de teclas substituindo OnKeyDown / OnKeyUp. Se o seu controle personalizado processa teclas aceleradoras específicas ou tem um comportamento de controle ou foco semelhante ao cenário descrito para TextBox, você deve colocar essa lógica no nas próprias substituições OnKeyDown / OnKeyUp.

O teclado virtual

Os controles de entrada de texto oferecem suporte automático para o teclado virtual. Quando o usuário define o foco de entrada como um controle de texto usando a entrada por toque, o teclado virtual aparece automaticamente. Quando o foco de entrada não está em um controle de texto, o teclado virtual é ocultado.

Quando o teclado virtual aparece, ele reposiciona automaticamente sua interface de usuário para garantir que elemento focado permaneça visível. Isso pode fazer com que outras áreas importantes de sua interface de usuário se movam para fora da tela. No entanto, você pode desabilitar o comportamento padrão e fazer seus próprios ajustes de interface de usuário quando o teclado virtual aparece. Para saber mais, veja Respondendo ao aparecimento da amostra de teclado na tela.

Se você criar um controle personalizado que exige entrada de texto, mas não deriva de um controle de entrada de texto padrão, será possível adicionar suporte de teclado virtual implementando os padrões corretos de controle de automação de interface do usuário. Para saber mais, veja a amostra do teclado virtual.

O pressionamento das teclas no teclado virtual aciona os eventos KeyDown e KeyUp assim como o pressionamento das teclas no teclado físico. No entanto, o teclado virtual não acionará eventos de entrada para Ctrl+A, Ctrl+Z, Ctrl+X, Ctrl+C e Ctrl+V, os quais são reservados para a manipulação de texto no controle de entrada.

Diretrizes da experiência do usuário para dar suporte a interações do teclado

Veja a seguir algumas diretrizes para dar suporte a interações via teclado.

Geral

    • Applies to Windows

    Windows:

    Os usuários devem conseguir realizar todas as tarefas com suporte em seu aplicativo usando somente o teclado físico ou o Teclado Virtual.

    Observação  O teclado de toque é usado somente para entrada de texto, e não para comandos de aplicativo ou do sistema.

  • Quando o aplicativo é iniciado, defina o foco de teclado inicial no elemento com o qual os usuários intuitivamente (ou mais provavelmente) vão interagir primeiro. Normalmente, o local mais apropriado é o modo de exibição de conteúdo principal do aplicativo para que um usuário possa rolar imediatamente o conteúdo usando as teclas de seta. Para saber mais sobre como definir o foco para controles específicos, veja Focus.
    • Applies to Windows

    Windows:

    Verifique se as teclas Tab e de orientação se movem pelo conteúdo em uma ordem lógica.
  • Defina a propriedade TabIndex com um valor superior ou igual a 0 para todos os elementos interativos da interface do usuário que não estejam na ordem de tabulação por padrão. É importante definir a propriedade TabIndex porque os usuários leitores de tela navegam entre os elementos da interface do usuário interativa usando a tecla Tab.
    • Applies to Windows

    Windows:

    Use as teclas de seta como atalhos de teclado para permitir uma navegação interna adequada entre elementos filho de elementos compostos. Se os nós de exibição de árvore tiverem elementos filho separados para lidar com expansão e recolhimento e ativação de nós, use as teclas de seta para esquerda e direita para obter a funcionalidade de expansão e recolhimento.
  • Permita que cada elemento da interface do usuário que pode ser clicado também possa ser chamado com o teclado.
    • Applies to Windows

    Windows:

    Implemente os atalhos de teclado para a funcionalidade principal do aplicativo. (Um atalho é uma combinação de teclas que aumenta a produtividade, fornecendo uma maneira eficiente para o usuário acessar a funcionalidade do aplicativo.)

    Uma tecla de acesso é um atalho para um elemento da interface do usuário em seu aplicativo. Ela consiste na tecla Alt e em uma tecla de letra.

    Uma tecla aceleradora é um atalho para um comando do aplicativo. O aplicativo pode ter uma interface do usuário que corresponde exatamente ao comando. Teclas aceleradoras consistem na tecla Ctrl e em uma tecla de letra.

    Você precisa oferecer aos usuários que dependem de leitores de tela e outras tecnologias auxiliares uma maneira fácil de descobrir atalhos de teclado em seu aplicativo. Declare atalhos de teclado na marcação HTML de seu aplicativo usando a propriedade AccessKey, e comunique os atalhos usando dicas de ferramenta, nomes acessíveis, descrições acessíveis ou outras formas de comunicação na tela. Lembre-se de documentar bem as teclas de atalhos no conteúdo de ajuda do seu aplicativo.

    Para obter as diretrizes sobre como implementar atalhos de teclado, veja Teclas de atalho nas Diretrizes de experiência do usuário do Windows.

    Não redefina os atalhos de teclado padrão que são esperados em cada aplicativo da Windows Store. Veja Atalhos de teclado para obter uma lista abrangente.

Hardware

Consulte os recursos do dispositivo de teclado (KeyboardCapabilities) para determinar se um teclado está conectado e para identificar os aspectos da interface do usuário do aplicativo que o hardware de teclado pode acessar diretamente. Para saber mais sobre como consultar os recursos do dispositivo, veja Guia de início rápido: identificando dispositivos de ponteiro.

Associe botões de teclado à interface do usuário adequada (botões Voltar e Avançar) no seu aplicativo.

Comentário visual

  • Use retângulos de foco somente com interações de teclado. Se o usuário iniciar uma interação por toque, faça com que a interface do usuário de teclado desapareça gradualmente. Dessa forma, a interface do usuário fica mais organizada.
  • Não exiba comentários visuais quando o elemento não permite manipulação (como texto estático).
  • Exiba comentários visuais simultaneamente para todos os elementos que representam o mesmo destino de entrada.
  • Forneça botões virtuais (por exemplo, + e -) como dicas para emulação de manipulações baseadas em toque, ou seja, movimento panorâmico, rotação, zoom etc.

Para obter diretrizes mais gerais sobre comentário visual, veja Diretrizes para comentários visuais.

Tópicos relacionados

Conceitual
Respondendo à interação do usuário
Guia de início rápido: adicionando controles HTML e manipulando eventos
Implementando acessibilidade de teclado
Acessibilidade nos aplicativos da Windows Store em C++, C# ou Visual Basic
Exibindo e editando texto
Gerenciador de Host de Entrada e o teclado virtual

 

 

Mostrar:
© 2014 Microsoft