# Guia de accessibilidade para desenvolvedores GNOME

## O que é acessibilidade?

Acessibilidade significa ajudar pessoas com deficiências a participar em atividades substanciais da vida. Isso inclui trabalho, e o uso de serviços, produtos e informações. GNOME inclui bibliotecas e uma infraestrutura de apoio que permitem que pessoas com deficiências utilizem todas as funcionalidades do ambiente de usuário GNOME.

Em conjunto com tecnologias assistivas se necessário – interfaces de vozes, leitores de tela, dispositivos de entrada alternativos, e por aí vai - pessoas com deficiências permanentes ou temporárias podem, portanto, usar o ambiente e aplicativos do GNOME. Tecnologias assistivas também são úteis para pessoas usando computadores fora de casa ou escritório. Por exemplo, se você estiver preso no tráfego, você pode usar entrada e saída de voz para verificar seus e-mails.

Tecnologias assistivas recebem informações de aplicativos via a API do Accessibility Toolkit (ATK), ou kit de ferramenta de acessibilidade, a qual pode ser encontrada no módulo atk nos repositórios do GNOME. Por o suporte à API de acessibilidade ser compilado nos widgets do GNOME, seus programas GNOME deve funcionar razoavelmente bem com tecnologias assistivas com nenhum esforço extra de sua parte. Por exemplo, tecnologias assistivas podem ler automaticamente os rótulos dos widgets que você normalmente definiria em seu programa (ex.: com chamadas de função do GTK, tais como `gtk_label_set_text()` ou `gtk_button_new_with_label()`). Elas também podem descobrir se há algum texto de dica de ferramenta associada com um widget e usá-la para descrever o widget para o usuário.

Com um pouco de esforço extra, porém, você pode fazer seu programa funcionar ainda mais suave com tecnologias assistivas. Além de ajudar usuários individuais, isso também tornará seu produto mais atrativo para os mercados governamental e educacional, muitos dos quais agora exigem em lei que seus aplicativos seja acessíveis.

### Tipos de deficiências

Só nos EUA, estima-se que haja 30.000.000 pessoas cuja habilidade de usar computadores possa ser comprometida por um design inacessível. Globalmente, cerca de 8% de pessoas que usam a “world wide web” têm algum tipo de deficiência. Deficiências recaem em um desses dessas categorias:

- Deficiências visuais – essas podem variar desde baixa visão (incluindo visão embaçada ou nebulosa, hipermetropia ou miopia extremas, daltonismo e visão em túnel, dentre outras) até cegueira completa. Uma escolha ruim de tamanho e color do texto, e tarefas que envolvam boa coordenação olho/mão (tal como mover o mouse) podem causar problemas para esses usuários.

- Deficiências motoras – usuários com controle ruim dos músculos ou fraquezas musculares podem ter dificuldade para usar um teclado ou um mouse comuns. Por exemplo, eles podem não ser capazes de segurar duas teclas simultaneamente, ou eles podem ser mais propensos a pressionar teclas acidentalmente.

- Deficiências auditivas – essas podem variar entre ser capaz de ouvir alguns sons, mas não distinguir palavras faladas, até surdez profunda. Aplicativos que transportam informações importantes apenas por som causarão problemas para esses usuários.

- Deficiência cognitiva e de linguagem – essas podem variar entre dislexia até dificuldades em se lembrar de coisas, resolver problemas ou compreensão e usar linguagens faladas ou escritas. Telas complexas ou inconsistentes, ou escolha ruim de palavras, podem dificultar o uso de computadores para esses usuários.

- Transtornos convulsivos – alguns padrões de luz e som podem causar convulsões epilépticas em alguns usuários suscetíveis.

### Como a acessibilidade funciona no GNOME

O Accessibility Toolkit (ATK) descreve um conjunto de interfaces que precisam ser implementadas por componentes de GUI para torná-las acessíveis. As interfaces independem de kit de ferramentas – implementações poderiam ser escritas para qualquer conjunto de widget, tais como GTK, Motif ou Qt.

The implementation for the GTK widgets is done via the GtkAccessible class. It is the base class for accessible implementations for GtkWidget subclasses. It is a thin wrapper around AtkObject, which adds facilities for associating a widget with its accessible object. Those parts of your application that use standard GTK widgets will have a basic level of accessibility, without you having to modify your application at all.

A maioria das tecnologias assistivas funcionando em outros ambientes tem, historicamente, achado necessário manter um modelo off-screen (ou fora da tela) complexo dos aplicativos, baseado em monitoramento de eventos do SO, uso de recursos de SO e aplicativo sem suporte e API, e outras técnicas altamente não-portáveis. Isso criou suporte a recursos de tecnologia assistiva de alguma forma “frágeis” e altamente específicos para cada SO e aplicativo, até mesmo específico por versão de aplicativo. Em contraste, no ambiente GNOME, toda informação exigida pelas ATs (tecnologias assistivas) é fornecida pelos aplicativos em execução, via GNOME Accessibility Framework, para o Service Provider Interface (SPI) independente do kit de ferramentas. O SPI fornece uma forma para ATs baseadas em UNIX, tais como leitores de tela e lupas de aumento de tela e, em muitos casos, pode eliminar a necessidade por um modelo off-screen. Suporte a acessibilidade para aplicativos é “embarcado” em kits de ferramenta de aplicativos via APIs de kit de ferramentas adequados (por exemplo, ATK para a maioria dos aplicativos nativos em C e a Java Accessibility API para aplicativos em Java), e exportados para uma interface comum “AT-SPI” via a “ponte” relevante (veja o diagrama abaixo).

O suporte de acessibilidade embutida do GNOME significa que os aplicativos criados usando os widgets pré-definidos do GNOME recebem suporte para tecnologias assistivas “gratuitas”, contanto que os componentes não sejam usados de formas não-usuais que possam entrar em conflito com o apoio embutido.

Um widget gtk+/GNOME é acessível se seu uso segue as diretrizes gerais de acessibilidade em outro lugar neste documento, e ele implementa as interfaces ATK apropriadas para seu papel na interface de usuário. Implementações ATK são fornecidas para os widgets de kit de ferramentas pré-definidos do GNOME (ex.: widgets gtk+ e GNOME não obsoletos), e em muitos casos novos widgets que trivialmente derivam de widgets GTK+ e GNOME existentes também herdarão suporte de acessibilidade adequado.

Embora o suporte a acessibilidade embutido do GNOME forneça funcionalidade significante sem qualquer alterações de código específicas para acessibilidade dos aplicativos, eles podem geralmente melhorar as descrições padrões fornecidas para alguns dos widgets, e adaptá-las ao propósito específico daquele widget em seu aplicativo, via chamadas diretas aos métodos ATK no aplicativo. Por exemplo, em muitos casos, aplicativos devem adicionar ou alterar as descrições textuais para esses widgets com a chamada de função ATK apropriada, de forma que uma tecnologia assistiva possa descrever seu propósito ou declará-lo para o usuário. Veja Diretrizes de codificação para suporte a acessibilidade para mais informações.

Se seu aplicativo usa widgets personalizados, você pode ter que fazer algum trabalho para expor as propriedades dos widgets para as tecnologias assistivas. Veja Criando componentes acessíveis personalizados e Exemplos que usam a API de acessibilidade para mais informações.

For additional, in-depth information regarding GTK/GTK+, see the GTK+ Reference Manual, the outdated GTK+ 2.0 Tutorial and the official GTK+ FAQ.

### Início rápido para desenvolvedores

Aqui estão alguns pontos comuns de início:

#### Como eu faço para verificar se meu aplicativo é acessível ou não?

Para começar bem, veja Criando um aplicativo acessível para o GNOME – Visão geral. Para uma perspectiva de pré-codificação, veja Diretrizes de interface de usuário para suporte a acessibilidade ou Diretrizes de codificação para suporte a acessibilidade. Para uma lista de verificação de itens para teste pós-design, veja Lista de verificação de interface de usuário.

#### Quais são as armadilhas comuns?

A Lista de verificação de interface de usuário cobre todas as áreas que algumas vezes acabam esquecidos no estágio de design.

#### Como eu faço as coisas comuns do ATK?

Uma listagem abreviada de chamados ATK comuns pode ser localizada aqui.

#### Como eu faço as coisas mais complexas do ATK?

Veja Criando componentes acessíveis personalizados e Exemplos que usam a API de acessibilidade para mais informações.

#### Introducing ATK, AT-SPI and GTK+

Arquitetura de acessibilidade do GNOME

ATK is the toolkit that GNOME uses to enable accessibility for users needing extra support to make the most of their computers. ATK is used by tools such as screen readers, magnifiers, and input devices to permit a rich interaction with the desktop through alternative means. See the ATK SourceForge Project and the ATK Library for more information.

AT-SPI is the primary service interface by which assistive technologies query and receive notifications from running applications. The full API can be explored here.

GTK+ is a library for creating graphical user interfaces. It works on many UNIX-like platforms, Windows, and on framebuffer devices. GTK+ is released under the GNU Library General Public License (GNU LGPL), which allows for flexible licensing of client applications. GTK+ has a C-based object-oriented architecture that allows for maximum flexibility. Bindings for other languages have been written, including C++, Objective-C, Guile/Scheme, Perl, Python, TOM, Ada95, Free Pascal, and Eiffel. Its GtkAccessible class is the base class for accessible implementations for GtkWidget subclasses. It is a thin wrapper around AtkObject, which adds facilities for associating a widget with its accessible object.

For additional, in-depth information regarding GTK/GTK+, see the GTK+ Reference Manual, the GTK section of the ATK Guide, the outdated GNOME-hosted GTK+ 2.0 Tutorial and the official GTK+ FAQ.

### Criando um aplicativo acessível para o GNOME – Visão geral

Se seu aplicativo usa apenas widgets GTK padrão, você provavelmente terá que fazer um pouco ou nada para criar seu aplicativo (razoavelmente) acessível. Mas cuidado com objetos em sua GUI que não possuem descrição textual associada a eles, tais como botões gráficos ou indicadores de estado que não possuem rótulos ou dicas.

Provavelmente, você também pode melhorar nas descrições padrões fornecidas por alguns widgets, e adaptá-las para aquele propósito específico em seu aplicativo. Você deve adicionar ou alterar as descrições textuais para esses widgets com a chamada de função ATK adequada, de forma que uma tecnologia assistiva possa descrever seu propósito ou estado para o usuário. Veja Diretrizes de codificação para suporte a acessibilidade para mais informações.

Se seu aplicativo usa widgets personalizados, você pode ter que fazer algum trabalho para expor as propriedades dos widgets para as tecnologias assistivas. Veja Criando componentes acessíveis personalizados e Exemplos que usam a API de acessibilidade para mais informações.

### Diretrizes de codificação para suporte a acessibilidade

Aqui estão algumas coisas que você pode fazer em seu código para fazer seu programa funcionar o melhor possível com tecnologias assistivas. (Você pode encontrar uma lista de coisas para considerar ao projetar sua GUI na seção Diretrizes de interface de usuário para suporte a acessibilidade afrente do seu documento):

- Para componentes que não exibem um texto curto (tal como um botão gráfico), especifique um nome para ele com `atk_object_set_name()`. Você pode se interessar em fazer isso para botões com apenas imagens, painéis que fornecem agrupamentos lógicos, áreas de texto e por aí vai.

- Se você não conseguir fornecer uma dica de ferramenta para um componente, use `atk_object_set_description()` para fornecer uma descrição que tecnologias assistivas possam fornecer ao usuário. Por exemplo, para fornecer uma descrição de acessibilidade para um botão de fechar, com rótulo Close:

  #### Fornecendo uma descrição de acessibilidade para um GtkButton

      {
        AtkObject *obj;
        obj = gtk_widget_get_accessible(button);
        atk_object_set_description(obj,_("Closes the window"));
      }

- Use `atk_image_set_description()` para fornecer uma descrição para todas as imagens e ícones em seu programa.

- Se vários componentes formam um grupo lógico, tente colocá-los em um contêiner.

- Quando você tiver um rótulo que descreve outro componente, use `atk_relation_set_add_relation()` de forma que as tecnologias assistivas possam localizar o componente com o qual o rótulo está associado. (Se você associar o rótulo com o componente usando `gtk_label_set_mnemonic_widget()`, a relação `ATK_RELATION_LABEL_FOR` é gerada automaticamente, então o seguinte código não mais seria necessário):

  #### Relacionando um GtkLabel a um GtkWidget

      {
        GtkWidget *widget;
        GtkLabel *label;

        AtkObject *atk_widget, *atk_label;
        AtkRelationSet *relation_set;
        AtkRelation *relation;
        AtkObject *targets[1];

        atk_widget = gtk_widget_get_accessible(widget);
        atk_label = gtk_widget_get_accessible (GTK_WIDGET(label));

        relation_set = atk_object_ref_relation_set (atk_label);
        targets[0] = atk_widget;

        relation = atk_relation_new(targets,1, ATK_RELATION_LABEL_FOR);
        atk_relation_set_add(relation_set,relation);
        g_object_unref(G_OBJECT(relation));
      }

- Se você criou um widget personalizado, certifique-se de que ele ofereça suporte a acessibilidade. Componentes personalizados que são descendentes de outros widgets GTK devem sobrescrever as informações de acessibilidade conformidade necessário. Para mais informações, veja Criando componentes acessíveis personalizados.

- Não quebre o que você consegue de graça! Se sua GUI tiver um contêiner inacessível, quaisquer componentes dentro daquele contêiner podem ficar inacessível.

### A API de acessibilidade

Aqui estão algumas das chamadas básicas de API que você pode precisar usar em seu aplicativo para se certificar de que ele funcione bem com tecnologias assistivas. A API de acessibilidade completa é extensível, para permitir que você escreva seus widgets personalizados de acessibilidade, por exemplo.

### Chamadas de API do ATK comumente usadas

API | Descrição
`AtkObject* gtk_widget_get_accessible (GtkWidget*)` | Retorna o objeto acessível que descreve o widget GTK especificado para uma tecnologia assistiva.
`void atk_object_set_name (AtkObject*, const gchar*)` | Define o nome do objeto acessível. Por exemplo, se o objeto é um botão gráfico que sai do aplicativo quando pressionado, o nome pode ser “Quit”.
`void atk_object_set_description (AtkObject*, const gchar*)` | Define a descrição textual do objeto acessível. Por exemplo, se o objeto é um botão gráfico “Close”, a descrição pode ser “Closes the window”.
`AtkRelation* atk_relation_new (AtkObject**, gint, AtkRelationType)` | Cria uma nova relação entre a chave especificada e a lista especificada de objetos alvos. Uma relação geralmente indica à tecnologia assistiva que um widget está, de alguma forma, relacionado. Por exemplo, que um widget GtkLabel em particular é o texto para um GtkTreeView na mesma janela.
`void atk_image_set_description (AtkImage*, const gchar*)` | Define a descrição textual do objeto imagem acessível. Por exemplo, se o objeto for uma miniatura de uma ambiente virtual em um applet do painel, a descrição pode ser “Image showing window arrangement on desktop 1”.

### Exemplos que usam a API de acessibilidade

Como notado anteriormente, você pode ter um pouco ou nenhum trabalho para tornar o aplicativo acessível se você usar o conjunto de widgets do GTK, ou qualquer outra biblioteca de widgets que implementa as interfaces do ATK. As duas coisas mais comuns que você pode ter que fazer neste caso são:

- fornece descrições de alguns controles e imagem usando `atk_object_set_description()` ou `atk_image_set_description():`

  #### Configurar a descrição de acessibilidade para um botão

      {
         AtkObject *obj;
         obj = gtk_widget_get_accessible(button);
         atk_object_set_description(obj,_("Opens Preferences dialog"));
      }

- Especificar relações entre quaisquer agrupamentos incomuns de widgets usando `atk_relation_new()` and `atk_relation_set_add()`:

  #### Especificar relações acessíveis entre dois controles

      {
        GtkWidget *widget;
        GtkLabel *label;

        AtkObject *atk_widget, *atk_label;
        AtkRelationSet *relation_set;
        AtkRelation *relation;
        AtkObject *targets[1];

        atk_widget = gtk_widget_get_accessible (widget);
        atk_label = gtk_widget_get_accessible (GTK_WIDGET(label));

        relation_set = atk_object_ref_relation_set (atk_label);
        targets[0] = atk_widget;

        relation = atk_relation_new(targets,1, ATK_RELATION_LABEL_FOR);
        atk_relation_set_add(relation_set,relation);
        g_object_unref(G_OBJECT(relation));
      }

The examples in the rest of this section are mostly to give you a flavor of the scope of the ATK. They cover techniques that you may never need to use as an application developer, although they may be of interest if you are writing your own custom widgets (see Making Custom Components Accessible) or if you want to write an assistive technology application.

#### Juntando informações de acessibilidade de um aplicativo

Um programa que deseja fazer uso de chamadas de ATK provavelmente precisaria de uma (ou mais) das seguintes coisas:

1. Criar um monitorador de evento, por exemplo com a função `atk_add_focus_tracker()`:

       atk_add_focus_tracker (_my_focus_tracker);

   sendo `_my_focus_tracker()` uma função com esse protótipo:

       void _my_focus_tracker (AtkObject *aobject);

2. Configurar um listener de eventos globais, com atk_add_global_event_listener():

       mouse_watcher_focus_id =   atk_add_global_event_listener(_my_global_listener,"Gtk:GtkWidget:enter_notify_event");

   sendo que `_my_global_listener` tem o protótipo de um Glib `GSignalEmissionHook`. Esse exemplo faria com que `_my_global_listener()` fosse chamado sempre que um sinal enter_notify_even ocorrer em um objeto `GtkWidget`.

3. Acessar o objeto de nível superior do ATK com a chamada de função a seguir.

       AtkObject *root_obj = atk_get_root();

   Isso retorna um `AtkObject` que contém todas as janelas de nível superior no programa atualmente em execução. O usuário poderia, então, navegar pela hierarquia de objeto acessando o filho do objeto raiz, o qual corresponde às janelas de nível superior.

#### Consultando as interfaces de um `AtkObject`

Tendo localizado o `AtkObject` associado com um objeto no aplicativo (ex.: usando `gtk_widget_get_accessible()`), você pode descobrir quais interfaces ele implementa de várias formas:

1. Use as macros `ATK_IS_...` fornecidas, por exemplo:

   - `ATK_IS_ACTION(atkobj)`

   - `ATK_IS_COMPONENT(atkobj)`

   - etc. (há um para cada interface)

   Se a macro retorna `TRUE`, as chamadas de interface podem ser feitas com segurança naquele objeto ATK.

2. Teste a função do `AtkObject` chamando `atk_object_get_role()`. Qualquer papel dado implementa um número específico de APIs ATK.

#### Configurando uma manipulador de signal ATK

Usando o sinal `column_inserted` como um exemplo:

    table_column_inserted_id = g_signal_connect_closure_by_id (my_atk_obj,
    g_signal_lookup("column_inserted", G_OBJECT_TYPE(my_atk_obj)), 0,
    g_cclosure_new(G_CALLBACK (_my_table_column_inserted_func), NULL, NULL), FALSE);

Isso fará com que `_my_table_column_inserted_func()` seja chamado sempre que um sinal column_inserted seja emitido no `AtkObject` `my_atk_object`

A conexão com um sinal é um pouco diferente se o sinal oferece suporte a detalhes. O sinal `children_changed` oferece suporte o detalhe `add`. Para conectar com um sinal quando o detalhe `add` também é especificado, essa técnica é usada:

    child_added_id = g_signal_connect_closure (my_atk_obj,"children_changed::add",
    g_cclosure_new (G_CALLBACK(_my_children_changed_func), NULL, NULL), FALSE);

Isso fará com que `_my_children_changed_func()` seja chamada sempre que um sinal `children_changed` com o detalhe `add` seja emitido no `AtkObject` `my_atk_obj`.

#### Implementando um objeto ATK

##### Registro

Para esse exemplo nós presumiremos que haja um objeto chamado GTK_TYPE_MYTYPE. A implementação ATK será chamada de `MYATKIMP_TYPE_MYTYPE`. Uma fábrica será necessária, a qual será chamada de `MYATKIMP_TYPE_MYTYPE_FACTORY`.

Para registrar uma implementação ATK de um objeto GTK, essas etapas devem ser seguidas na função `gtk_module_init()` do módulo:

1. Acesse o registro padrão:

       default_registry = atk_get_default_registry();

2. Registre o objeto ATK na função `gtk_module_init()` deste módulo fazendo essa chamada de função:

       atk_registry_set_factory_type (default_registry, GTK_TYPE_MYTYPE,
       MYATKIMP_TYPE_MYTYPE_FACTORY);

Isso vai registrar a implementação AtkObject de `GTK_TYPE_MYTYPE` para `MYATKIMP_TYPE_MYTYPE_FACTORY`. Essa fábrica será implementada de forma que saiba como construir objetos do tipo `MYATKIMP_TYPE_MYTYPE`.

##### Fábrica

A fábrica deve ser implementada como uma filha da classe tipo `ATK_TYPE_OBJECT_FACTORY` e deve implementar a função `create_accessible()`. Essa função deve criar um `AtkObject` apropriado. Uma fábrica pode ser usada para criar mais do que um tipo de objeto, caso em que sua função `create_accessible()` precisará ser inteligente o suficiente para construir e retornar o `AtkObject` correto.

##### Implementação ATK para um objeto específico

Todos `GObject`s implementam uma função `get_type()`. Usando o exemplo acima, a convenção de nome para esse nome de função seria `myatkimp_mytype_get_type()`.

Nesta função, você especificaria quais interfaces seu objeto implementa. Se a seguinte lógica estivesse incluída nesta função `get_type()`, esse objeto implementaria a interface `ATK_TEXT`:

###### Exemplo de função `get_type()`

    static const GInterfaceInfo atk_text_info =
    {
       (GInterfaceInitFunc) atk_text_interface_init,
       (GInterfaceFinalizeFunc) NULL,
       NULL
    };

    g_type_add_interface_static (type, ATK_TYPE_TEXT,
                                 &atk_text_info);

A função `atk_text_interface_init()`, que possui o protótipo a seguir, precisaria ser implementado:

    void atk_text_interface_init (AtkTextIface *iface);

Essa função conectaria as chamadas de função de interface com a implementação específica a seguir:

###### Conectando chamadas personalizadas de interface a uma implementação AtkObject

    void
    atk_text_interface_init (AtkTextIface *iface)
    {
       g_return_if_fail (iface != NULL);
       iface->get_text = myatkimp_mytype_get_text;
       iface->get_character_at_offset = myatkimp_mytype_get_character_at_offset;
       ...
    }

Então, as funções `myatkimp_mytype_get_text()`, `myatkimp_mytype_get_character_at_offset()` e o resto das funções de interface `ATK_TEXT` precisariam ser implementadas.

##### Implementação de `AtkObject`

`AtkObject`s são `GObject`s e todos `GObject`s precisam especificar a função `get_type()`. Aqui está um exemplo que configura uma classe e inicializador de instância. Essa função `get_type()` também especifica que o objeto implementa `ATK_TEXT` e especifica o objeto pai para ser `MYATKIMP_MYPARENTTYPE`.

##### Inicializadores de classe/instância

Você precisará configurar um inicializador de classe para o `GObject` se sua implementação `AtkObject`:

1. Redefine quaisquer chamadas de função definidas pelo pai do objeto. Isso geralmente é necessário quando um objeto precisa implementar uma função como `atk_object_get_n_accessible_children()`. Isso é necessário se o objeto possui um filho, mas eles não são representados com widgets.

2. Requires a `parent->init`, `parent->notify_gtk`, or `parent->finalize` function.

   1. parent->init

      Uma função `parent->init()` pode ser necessária se a implementação ATK precisar sfazer uma das duas coisas:

      1. Fazer cache de quaisquer dados obtidos do widget GTK backup.

      2. Ouve quaisquer sinais do widget GTK backup.

   2. parent->notify_gtk

      Se a implementação ATK precisa ouvir a quaisquer notificações de propriedade no objeto GTK backup, uma função `parent->notify_gtk()` pode ser necessário. Por exemplo:

      ###### Uma função `notify_gtk()` personalizada

          void
          myatkimp_mytype_real_notify_gtk (GObject    *obj,
                                           GParamSpec *pspec)
          {
             GtkWidget *widget = GTK_WIDGET (obj);
             AtkObject* atk_obj = gtk_widget_get_accessible (widget);

             if (strcmp (pspec->name, "property-of-interest") == 0)
             {
                /* Lida com a alteração de propósito. */
             }
             else
             {
                parent_class->notify_gtk (obj, pspec);
             }
          }

   3. parent->finalize

      Se for necessário liberar quaisquer dados quando uma instância `GObject` é destruída, então uma função `finalize()` é necessária para liberar a memória. Por exemplo:

      ###### Uma função `finalize()` personalizada

          void
          myatkimp_mytype_finalize (GObject *object)
          {
             MyAtkimpMyType *my_type = MYATKIMP_MYTYPE (object);

             g_object_unref (my_type->cached_value);
             G_OBJECT_CLASS (parent_class)->finalize (object);
          }

### Criando componentes acessíveis personalizados

Adicionar suporte ATK ao seu widget personalizado vai garantir que sua cooperação com a infraestrutura de acessibilidade. Esses são os passos gerais que são necessários:

- avaliar um widget personalizado de acordo com as Diretrizes de interface de usuário;

- determinar quais interfaces ATK um widget personalizado deve implementar, conforme o conjunto de recursos e função do widget;

- avaliar quais interfaces ATK podem ser herdados a partir da classe widget pai;

- implementar as interfaces ATK adequadas para a classe widget em uma das duas formas:

  - diretamente pelo widget personalizado, ou

  - in an `AtkObject` subtype created by a new `AtkObjectFactory` subclass

  Se o segundo método for usado, o tipo de fábrica adequada deve ser registrada com o `AtkObjectFactoryRegistry` em tempo de execução.

### Diretrizes de interface de usuário para suporte a acessibilidade

Ao projetar a interface gráfica do aplicativo, há várias diretrizes simples que você deve seguir para garantir que ele possa ser usado pela maior audiência possível, seja em conjunto com tecnologias assistivas ou não. Porém, não se engane em achar que isso é apenas um caso de “tornar sua interface gráfica usável por pessoas com deficiências” e que você não deveria ser incomodar se você conhece uma pessoa com deficiência que nunca vai usar seu aplicativo. Seguir essas diretrizes via melhorar a usabilidade geral de seu aplicativo para todo muito que o usa – incluindo você!

#### Geral

Todos nós ficamos frustrados se não pudermos encontrar um recurso em um aplicativo ou se cometermos um erros dos quais leva alguns minutos para recuperar, se for possível recuperar. Se você tem algum tipo de deficiência, as chances são de que as penalidades de esforço e tempo envolvidas serão muitas vezes pior. Seguir umas diretrizes básicas pode ser útil para evitar esses tipos de situações para todos os usuários.

- Forneça “Desfazer” para toda ação que altera os dados do usuário ou as configurações do aplicativo. Se possível, forneça mais de um nível de desfazimento e refazimento, e uma lista de histórico para permitir pré-visualização de quais ações serão desfeitas.

- Forneça comandos para restaurar configurações padrões. Se uma configuração em particular poderia tornar o aplicativo completamente não usável para um indivíduo (ex.: tornando as fontes pequenas demais), seria útil fornecer uma opção para restaurar as configurações padrões fora do aplicativo em si. Isso poderia ser feito usando uma opção de linha de comando, por exemplo.

- Ajude a evitar que os usuários façam coisas erradas. Isso é particularmente importante para ações que poderiam ser feitas por acidente (ex.: ações com o mouse) ou que não podem ser facilmente desfeitas (ex.: sobrescrever um arquivo). Considere usar diálogos de confirmação ou forçar o usuário a ir para um modo em particular para realizar ações potencialmente destrutivas.

- Minimize a carga de memória dos usuários. Por exemplo, deixe o usuário ver múltiplos documentos de uma só vez e assegure-se de que ajuda on-line e outras instruções possa permanecer visíveis enquanto elas carregarem o procedimento sendo descrito. Permita-os copiar qualquer informação que é exibida, cole-a em qualquer lugar em que dados podem ser inseridos.

- Não faça usuários inserirem discos. Dependendo de uma deficiência específica do usuário, ele pode achar difícil inserir ou alterar fisicamente um disco ou identificar o disco correto em primeiro lugar. Se seu aplicativo é instalado a partir do CD-ROM, forneça uma opção de copiar todos os arquivos que serão exigidos para o disco rígido do usuário.

- Não coloque funções frequentemente usadas muito adentro em uma estrutura de menu. Esteja você usando um mouse, teclado ou algum outro dispositivo de entrada, itens de menu profundamente aninhados devem ser evitados. Assim como o esforço de lembrar onde localizá-los, eles são sempre muito difíceis e gastam tempo para acessar.

- Não leve usuários por meio de etapas desnecessárias. Por exemplo, assistentes são úteis para usuários que tem dificuldade em lidar com grande quantidade de opções de uma só vez, mas outros usuários podem precisar minimizar a quantidade de tempo ou teclas pressionadas que eles usam. Tais usuários se beneficiam de serem capaz de pular etapas desnecessárias ou de irem diretamente à etapa que eles desejam. Considere fornecer um botão Finalizar em assistentes que pula direto para o fim e presume as respostas padrões para as etapas intermediárias. Se o processo possui muitas etapas, considere perguntar ao usuário no começo se ele deseja seguir por todos as etapas, apenas aquelas mais comumente usadas.

#### Navegação do teclado

Uma interface de usuário de teclado bem projetada representa um papel chave quando você está projetando um software acessível. Usuários cegos podem navegar no software com muito mais eficiência usando o teclado porque o uso do mouse depende de um feedback visual da localização do ponteiro do mouse. Além disso, o comprometimento de mobilidades pode impedir que o usuário navegue com sucesso usando o mouse por causa da precisa habilidade de controle motor fino que é necessário.

Portanto, é importante disponibilizar todas as ações de mouse a partir do teclado e incluir o acesso do teclado às barras de ferramentas, menus, links e botões. Toda função que seu aplicativo fornecer deve estar disponível usando apenas o teclado. Oculte seu mouse enquanto você está testando seu aplicativo, se necessário!

A maioria das funcionalidades deve ser fácil de tornar acessível usando aceleradores e mnemônicos de teclado e usando os recursos de navegação embarcados do kit de ferramentas. Porém, as operações que dependem de arrastar e soltar, por exemplo, podem exigir mais esforço.

- Forneça acesso eficiente de teclado a todos os recursos de aplicativo. Alguns usuários podem não ser capazes de usar um mouse e muitos “usuários avançados” preferem usar o teclado mesmo assim. Também, alguns dispositivos de entrada especializados para tecnologia assistiva podem simular eventos de teclado em vez de eventos de mouse. Já que digitar é difícil ou até mesmo doloroso para alguns usuários, é importante fornecer uma interface de teclado que minimiza o número de pressionamentos de tecla exigidos para quaisquer tarefas dadas.

- Use uma ordem lógica de navegação de teclado. Ao navegar por uma janela com a tecla Tab, o foco do teclado deve mover entre controles em uma ordem previsível. Em localidades ocidentais, isso normalmente é da esquerda para direita e de cima para baixo.

- Garanta a ordem correta de tabulações para controles cujo estado habilitado é dependente de caixa de seleção, botão de opção ou botão de alternância que possui controles dependentes, não dê foco automaticamente ao primeiro controle dependente; em vez disso, deixe o foco no botão.

- Don't override existing system-level accessibility features. For example, AccessX is an Xserver extension that has been supported since X11R6. The MouseKeys feature of this extension allows mouse movement and button clicks to be simulated using the keypad. Therefore you should not add features to your application that can only be accessed by pressing keys on the keypad, as users relying on the MouseKeys feature will not be able to use them.

- Forneça mais do que um método para realizar tarefas de teclado quando possível. Alguns usuários podem achar algumas teclas ou combinações de teclas mais fáceis para usar do que outras.

- Forneça ambos acessos de teclado e mouse para funções quando possível. Alguns usuários podem apenas ser capazes de usar mouse ou teclado, mas não ambos.

- Não atribua distâncias estranhas para operações de teclado frequentemente realizadas. Algumas pessoas podem apenas ser capazes de usar uma mão no teclado, então atalhos que possam ser usados com uma mão são preferíveis para operações comuns. De qualquer forma, ter que frequentemente alcançar teclas longes ou de difícil acesso no teclado pode aumentar tensão muscular para todos usuários, aumentando o risco de dor ou dano.

- Não exija uso repetitivo de pressionamentos de teclas simultâneos. Alguns usuários só são capazes de pressionar e manter pressionada uma tecla por vez. Tecnologias assistivas tal como AccessX pode permitir que usuários pressionar teclas sequencialmente em vez de simultaneamente, mas isso significa, é claro, que a operação levará mais tempo para concluir.

- Certifique-se de que qualquer texto que possa ser selecionado com o mouse também possa ser selecionado com o teclado. Isso é uma conveniência para todos usuários, mas especialmente para aqueles cujo controle fino do mouse é difícil.

- Certifique-se de que objetos que possam ser redimensionados ou movidos usando arrastar e soltar também possam ser movidos com o teclado. Por exemplo, ícones e janelas na área de trabalho. Onde a precisão de redimensionamento ou colocação for potencialmente importante, como, por exemplo, formas em um diagrama, considere também fornecer um diálogo no qual você possa digitar coordenadas, ou uma forma de anexar objetos a uma grade definível pelo usuário.

- Não use funções de navegação geral para disparar operações. Por exemplo, não use navegação básica de teclado com Tab em um diálogo para ativar quaisquer ações associadas com um controle.

- Mostre menus, janelas e dicas chamáveis por teclado próximo ao objeto aos quais eles estão relacionados. No GNOME 2.0, usuários pode chamar menus suspensos com Shift F10 e dicas de ferramentas com Shift F1. Porém, não oculte ou obscureça completamente o objeto ao qual o menu ou a dica se refere.

#### Interação do mouse

Lembre-se que nem todo mundo pode usar um mouse com igual dexteridade e que alguns usuários podem ter dificuldade em ver ou seguir o ponteiro do mouse.

- Não dependa da entrada dos botões 2 ou 3 do mouse. Além de ser fisicamente mais difícil de clicar, alguns dispositivos de apontamento e muitos dispositivos de tecnologia assistiva oferecem suporte apenas ao botão 1. Algumas tecnologias assistivas podem até nem emular o mouse, mas geram eventos de teclado.

- Permita que todas as operações sejam canceladas. O pressionamento da tecla Esc deve cancelar qualquer operação do mouse em progresso, tal como arrastar e soltar um arquivo em um gerenciador de arquivos, ou desenhar uma forma em um programa de desenho.

- Forneça um feedback visual por toda uma operação de arrastar e soltar. Na medida em que o mouse passa por alvos válidos, realce-os e altere o ponteiro do mouse. Use o ponteiro de mouse “não soltar” ao passar por cima de alvos inválidos para soltar. Veja Exemplos de interação do mouse.

- Não altere o ponteiro do mouse, nem restrinja o movimento do mouse a uma parte da tela. Isso pode interferir com tecnologias assistivas, e é geralmente confuso mesmo para usuários que não dependem delas.

- Não faça dos alvos de mouse pequenas demais. Em geral, alvos de mouse devem pelo menos do tamanho da “área quente” em volta da borda redimensionável da janela no atual tema/gerenciador de janelas – tenha em mente que um usuário com destreza ou visão prejudicada pode estar usando um gerenciador de janelas com áreas maiores do que o padrão.

##### Exemplos de interação do mouse

###### Exemplo de ponteiro “não soltar” do CDE/Motif

Exemplo de uma forma de ponteiro de “alvos inválidos para soltar”

#### Elementos gráficos

Forneça opções para personalizar a apresentação de todos os elementos gráficos importantes em seu aplicativo. Isso facilitará para pessoas com dificuldades visuais ou cognitivas para suar.

- Não codifique os atributos gráficos, tal como espessura de linha, borda ou sombra. Esses elementos idealmente devem ser lidos a partir do tema de gerenciador de janelas ou GTK. Se isso não for possível, forneça opções dentro de seu aplicativo para alterá-los.

- Provide descriptive names for all interface components. GTK provides default accessible descriptions for many GTK widgets, but you will still need to add your own in some cases, such as for widgets that use graphics instead of text (e.g. a well in a color palette, or an icon without a label). Consider overriding the defaults with more helpful or application-specific descriptions where possible.

- Permita que elementos gráficos multicores (ex.: ícones de barra de tarefas) sejam mostrados em monocromáticos, se possível. Essas imagens monocromáticas devem ser mostradas nas cores de primeiro plano e de plano de fundo do sistema, as quais os usuários terão escolhidos para eles mesmos (por suas escolhas de tema GTK) para máxima legibilidade.

- Torne os elementos interativos da GUI facilmente identificáveis. Por exemplo, não faça o usuário flutuar o mouse sobre um objeto para determinar se ele é clicável ou não. Deixe espaço suficiente entre objetos e delineie claramente os limites do objeto. Não mostre elementos da GUI que parecem bonitos, mas que não servem para nada, a menos que você também forneça uma opção para desligá-los.

- Forneça uma opção para ocultar gráficos que não transmitam informações essenciais. Imagens gráficas podem ser distrativas para usuários com algumas deficiências cognitivas. Os ícones no menu de pé do GNOME, por exemplo, podem ser desligados enquanto deixa os menus completamente funcionais.

#### Fontes e texto

Até mesmo para um usuário com visão normal, a saída textual fornece a maioria de informações e feedback na maioria dos aplicativos. É, portanto, crítico escolher e posicionar o texto cuidadosamente na tela, e deixar a escolha da fonte e tamanho par ao usuário, para garantir que as pessoas com dificuldades visuais também possam usar seu aplicativos efetivamente.

- Não defina por código os estilos e tamanhos da fonte. O usuário deve ser capaz de ajustar todos os tamanhos e tipos de fonte. Se por algum motivo você não puder disponibilizar esta funcionalidade, nunca defina no código qualquer tamanho de fonte menor que 10 pontos.

- Forneça opções para desligar quaisquer “backdrops” gráficos ou “marcas d'água” atrás do texto. Tais imagens interferem com o contraste entre o texto e seu plano de fundo, que podem causar dificuldade para usuários com dificuldades visuais.

- Rotule objetos com nomes que farão sentido quando retirados do contexto. Usuários que dependam de leitores de tela ou tecnologias assistivas similares não necessariamente serão capazes de entender imediatamente a relação entre um controle e o que está em volta dele.

- Não use o mesmo rótulo mais de uma vez na mesma janela. Se você usa o mesmo rótulo em janelas diferentes, ajudará se significarem a mesma coisa em ambas janelas. Além disso, não use rótulos que são escritos diferentemente, mas tem o mesmo fonética, como “acento” e “assento”, pois isso poderia ser confuso para usuários que dependam de leitores de tela.

- Posicione rótulos de forma consistente por todo seu aplicativo. Isso normalmente significa imediatamente abaixo de ícones grandes, imediatamente à direita de ícones pequenos, e imediatamente acima ou para a esquerda de outros controles. Veja Exemplos de fontes e texto.

- Quando você usar texto estático para rotular um controle, termine o rótulo com um caractere de dois pontos. Por exemplo, Nome de usuário: para rotular um texto no qual o usuário deve digitar seu nome de usuário. Isso ajuda a identificá-lo como um rótulo do controle em vez de um item de texto independente.

- Quando você usar texto estático para rotular um controle, certifique-se que o rótulo preceda imediatamente aquele controle na ordem de Tab. Isso vai garantir que o mnemônico (caractere sublinhado) que você atribui ao rótulo vai mover o foco ou ativar o controle correto quando pressionado.

- Forneça alternativas a WYSIWYG. Alguns usuários podem precisar imprimir texto em uma fonte pequena, mas editar em uma fonte de tela maior, por exemplo. Alternativas possíveis incluem exibir todo texto na mesma fonte e tamanho (ambos os quais são escolhidos pelo usuário); uma opção “quebra-de-texto” que permite que você leia todo o texto em uma janela sem ter que rolar horizontalmente; uma visão de única coluna que mostra o conteúdo da janela em uma única coluna mesmo se for imprimido em múltiplas colunas; e uma visão somente texto, na qual gráficos são mostrados como marcadores de lugar e descrições de texto. Se o aplicativo possuir painéis com controles internos, considere permitir que os painéis sejam redimensionados junto com a janela pai.

##### Exemplos de fontes e texto

###### Posicionamento correto de rótulo para vários elementos da GUI

List control with label above Controle de lista com rótulo em cima | Large file manager icon with label underneath Ícone grande do gerenciador de arquivos com rótulo embaixo | Small toolbar icon with label to its right Ícone pequeno da barra de ferramentas com rótulo a sua direita | Spinbox control with label to its left Controle de caixa giratória com rótulo a sua esquerda

#### Cor e contraste

A má escolha de cores na tela pode causar problemas para usuários com daltonismo (para quem a matiz é importante) ou baixa visão (para quem o brilho/contraste é importante). Geralmente, você deve permitir que o usuário personalize as cores em qualquer parte do seu aplicativo que transmite informações importantes.

Os usuários com deficiências visuais podem exigir um alto nível de contraste entre as cores de fundo e texto. Muitas vezes, um fundo preto e texto branco é usado para evitar que o fundo seja “sangrando”. Essas configurações são críticas para usuários com deficiências visuais.

- Não defina cores do aplicativo por código rígido. Alguns usuários precisam usar combinações particulares de cores e níveis de contraste para poder ler a tela confortavelmente. Portanto, todas as cores principais que você usa no seu aplicativo GNOME devem ser tiradas do tema GTK, de modo que o usuário pode configurar as cores de todas as suas aplicações para algo legível, apenas mudando o tema. Se por algum motivo você precisa usar cores que não estão disponíveis no tema, assegure-se de serem personalizáveis dentro do próprio aplicativo.

- Não use a cor como o único meio para distinguir itens de informação. Todas essas informações devem ser fornecidas por pelo menos um outro método, como forma, posição ou descrição textual. Veja Exemplos de cores e contraste.

- Ofereça suporte a todos os temas do GNOME de alto contraste. Certifique-se de que, quando um desses temas for selecionado, todo o texto em seu aplicativo aparece nas cores de primeiro plano e de fundo de alto contraste especificadas pelo tema.

- Certifique-se de que seu aplicativo não depende de um determinado tema de alto contraste. Teste-o com diferentes temas de alto contraste para garantir que seu aplicativo respeite as configurações.

##### Exemplos de cor e contraste

###### Exemplo ilustrando uso redundante de cor

Exemplo mostrando alterações preços de ações usando apenas cor | Esta exibição pode causar problemas para um usuário com daltonismo de vermelho-verde (daltonismo afeta 1 em cada 7 homens em algumas partes do mundo). A falta de contraste entre o texto vermelho e o fundo preto também tornaria difícil a leitura para um usuário com baixa visão, mesmo com um amplificador de tela.
Exemplo mostrando alterações preços de ações usando cor e setas | Esta exibição reforça a codificação de cores com setas para mostrar o movimento do preço das ações, e usa tons mais escuros de verde e vermelho em um fundo mais claro para fornecer mais contraste. Esse não precisa ser o esquema de cores padrão se os testes mostrarem que isso é muita distração para a maioria dos usuários, mas deve ser possível personalizá-lo dessa maneira, seja por meio de temas ou através do diálogo Preferências do aplicativo.

#### Ampliação

Muitos usuários, mesmo aqueles que não são deficientes visuais, se beneficiam com a ampliação de texto e gráficos. No entanto, sem ampliação, um usuário com deficiência visual pode não conseguir acessar e usar o programa.

- Forneça a capacidade do usuário para ampliar a área de trabalho.

- Forneça opções no aplicativo para dimensionar a área de trabalho. Os usuários precisam ter uma opção para ampliar a área de trabalho 150% a 400% ou mais. Teste o aplicativo para confirmar que o objeto que você está visualizando não é afetado alterando as configurações de ampliação.

#### Áudio

As pessoas que têm dificuldade de ouvir, bem como aqueles que trabalham com o som em seus computadores desligados, serão prejudicadas se seu aplicativo se basear em som para transmitir informações. Em geral, certifique-se de que o usuário possa ter qualquer informação audível transmitida de outras maneiras.

- Não presuma que um usuário ouvirá informações de áudio. Isto aplica-se tanto aos usuários com placas de som quebradas como a pessoas com deficiência auditiva!

- Não use o áudio como o único meio de transmitir informações. Dê ao usuário a opção de ter todas as informações de áudio fornecidas de forma visual também. Isso inclui o fornecimento de legendas fechadas ou transcrições para quaisquer clipes de som falados importantes.

- Permita aos usuários configurar a frequência e o volume de todos os bips de aviso e outros sons. Isso inclui poder desligar completamente o som.

#### Animação

Usado com moderação, a animação pode ser útil para chamar a atenção para informações importantes em sua aplicação – e também pode parecer legal. No entanto, pode ser problemático para alguns usuários, portanto, certifique-se de que eles podem desligá-la.

- Não use elementos piscando ou piscando com uma frequência maior do que 2 Hz e inferior a 55 Hz. Isso inclui texto, bem como qualquer objeto gráfico. Qualquer coisa nesta faixa de frequência pode causar problemas particulares para usuários suscetíveis a convulsões induzidas visualmente. Note-se que não existe uma frequência “segura”. Se o piscar é essencial, você deve usar a frequência de pisca do cursor do sistema (que deve ser customizável) ou permitir que os usuários configurem a própria frequência.

- Não exiba um clarão nem pisque em grandes áreas da tela. Pequenas áreas são menos propensas a desencadear convulsões naqueles suscetíveis a eles.

- Torne todas as animações opcionais. A informação animada deve estar disponível em pelo menos um formato não animado, a pedido do usuário.

#### Foco do teclado

Mostrar a posição do foco do teclado claramente em todos os momentos é importante, tanto para usuários com deficiências de visão quanto para “usuários avançados” que preferem usar o teclado e não o mouse. Nunca deve haver confusão quanto ao controle que o controle na área de trabalho tenha foco em qualquer momento. Você deve poder deixar seu computador com foco em qualquer widget em seu aplicativo, depois desligar e telefonar para sua namorada ou caminhar até o cachorro até você se esquecer de qual widget você deixou. Quando você retornar, você deve saber imediatamente o widget.

Um indicador de foco visual é uma representação de áudio da posição do cursor em relação aos outros objetos na área de trabalho. Isso permite que o usuário se mova entre objetos de forma interativa à medida que o foco muda. O foco visual deve ser programaticamente exposto a tecnologias assistivas. Observe que, na maioria dos casos, este é tratado automaticamente pelo ATK, sem exigir que você faça qualquer trabalho adicional. No entanto, você precisará estar ciente deste requisito ao redigir seus próprios widgets personalizados, por exemplo.

- Inicie o foco no controle mais comum. Se nenhum controle em uma janela for considerado “mais” útil, inicie o foco no primeiro controle na janela quando essa janela for aberta. O foco não deve ser iniciado nos botões OK ou Cancelar de uma caixa de diálogo, mesmo que sejam os controles mais usados, pois eles sempre podem ser ativados imediatamente pressionando Enter ou Escape.

- Mostre o foco de entrada atual claramente em todos os momentos. Lembre-se de que em controles que incluem um elemento de rolagem, nem sempre é suficiente para destacar apenas o elemento selecionado dentro dessa área de rolagem, pois pode não ser visível. Veja Exemplos de foco do teclado.

- Mostre o foco de entrada apenas na janela ativa. Oculte todos os indicadores de foco visual primário em todas as janelas que não tenham foco e ativação. Se uma única janela tiver painéis separados, apenas um painel deve ter o indicador de foco e os indicadores de foco devem estar ocultos em todos os outros painéis. Se for importante continuar a mostrar qual item em uma lista não focada é selecionado, por exemplo, use um indicador de foco secundário. Veja Exemplos de foco do teclado.

- Forneça feedback adequado quando o usuário tentar navegar após o fim de um grupo de objetos relacionados. Ao navegar uma lista, por exemplo, parar com feedback de áudio geralmente é preferível a mover o foco de volta para o primeiro objeto na lista. Caso contrário, os usuários que são cegos ou têm baixa visão podem não perceber que eles voltaram ao início. No caso de uma pesquisa de texto em um documento, uma caixa de diálogo pode aparecer para indicar que o final do documento foi alcançado e perguntar se você deseja retomar a busca no início do documento.

- Reproduza o sinal de aviso de áudio ou visual padrão do sistema quando o usuário pressiona uma tecla inadequada ou quando uma tecla de navegação não consegue mover o foco. Por exemplo, quando o foco está no primeiro caractere em um campo de texto e o usuário pressiona a tecla de seta para a esquerda, ou o usuário tenta executar múltiplas seleções em uma única seleção de diálogo. (Note que os usuários com dificuldades de audição devem ser capazes de configurar um equivalente visual do sistema ao som de aviso padrão.)

##### Exemplos de foco do teclado

###### Exemplo ilustrando a necessidade de mostrar o foco claramente

O item em foco nesta janela não pode ser visto porque ele foi deslocado para fora da tela | Um dos controles desta janela tem foco, mas é impossível dizer qual…
O item focado na lista foi exibido ao deslocar a lista | …até você deslocar a lista, que revela que um de seus itens está atualmente selecionado.
O controle da lista neste exemplo possui uma borda sólida indicando foco, se seu item selecionado está atualmente visível ou não | Se o controle da lista em si tiver uma borda “focada”, é fácil dizer que ele tem foco mesmo quando o item atualmente selecionado não está visível.

###### Exemplo ilustrando o uso de foco secundário

Janela divida em painéis em que ambos os painéis parecem ter foco | Neste exemplo, é impossível dizer apenas olhando quais dos dois painéis realmente têm foco no teclado.
Janela dividida em painéis em que o destaque secundário é usado para mostrar qual painel tem foco | Ao usar uma cor de destaque de seleção secundária no painel inativo, é imediatamente óbvio que o controle de árvore tem foco aqui…
Janela dividida em painéis em que o destaque secundário é usado para mostrar qual painel tem foco | …e que o controle da lista tem foco aqui.

#### Tempo

As interfaces nas quais as coisas aparecem, desaparecem ou ocorrem de acordo com um limite de tempo codificado são muitas vezes um obstáculo para a acessibilidade. Alguns usuários podem ler, digitar ou reagir muito lentamente em comparação com outros. Se a informação que eles exigem está escondida antes de terminarem com ela ou obscurecida por outras informações que não foram solicitadas explicitamente, seu aplicativo ficará muito frustrante ou mesmo impossível de usar.

- Não codifique um tempo limite ou outros recursos baseados no tempo. Os exemplos incluem a rolagem automática ao arrastar um objeto para a borda de uma janela, mantendo pressionado o botão da barra de rolagem ou expandir automaticamente um nó de árvore quando um objeto é arrastado sobre ele e mantido por um curto período de tempo. Estes devem ser personalizáveis no aplicativo, no centro de controle do GNOME ou, na pior das hipóteses, editáveis manualmente a partir da linha de comando por meio de um arquivo de configuração ou entrada do GConf.

- Não mostre ou oculte informações de forma breve com base no movimento do ponteiro do mouse. (Exceção: recursos fornecidos pelo sistema, como dicas de ferramentas, que o usuário pode configurar em um nível de todo o sistema). Se você deve fornecer esses recursos, torná-los opcionais para que os usuários possam desligá-los quando um utilitário de revisão de tela estiver instalado.

#### Documentação

Pessoas com deficiência podem não usar o aplicativo efetivamente se não tiverem acesso aos manuais e arquivos de ajuda necessários. De particular importância é a navegação por teclado, uma vez que esta é a única maneira que muitos usuários podem navegar no aplicativo.

- Forneça toda a documentação em um formato acessível. O texto ASCII e o HTML são formatos excelentes para tecnologias assistivas.

- Forneça descrições de texto alternativas para todos os gráficos na documentação.

- Documente todos os recursos de acessibilidade do seu aplicativo. A navegação no teclado e os atalhos são particularmente importantes para documentar. Inclua uma seção de acessibilidade em sua documentação, onde informações sobre todos os recursos de acessibilidade podem ser encontradas.

## Testes

Há vários pontos de revisão para conduzir antes de declarar um aplicativo acessível. Ao longo do desenvolvimento, você pode querer considerar técnicas de teste automatizadas. LDTP, por exemplo, pode complementar o seu plano de testes automatizado.

Esta seção descreve uma série de testes que você pode executar manualmente em um aplicativo para testar sua acessibilidade. Passar todos os testes não implica necessariamente que o aplicativo seja totalmente acessível, mas se o aplicativo falhar em nenhum desses testes, talvez seja necessário fazer mais trabalhos para melhorar esse aspecto de sua acessibilidade.

### Navegação do teclado

As seguintes operações de teclado devem ser testadas. Não use o mouse em nenhuma parte deste teste.

- Usando apenas comandos de teclado, mova o foco através de todas as barras de menu no aplicativo.

- Confirme que:

  - Os menus sensíveis ao contexto exibem corretamente.

  - Todas as funções listadas na barra de ferramentas podem ser executadas usando o teclado.

  - Você pode operar todos os controles na área do cliente do aplicativo e caixas de diálogo.

  - Texto e objetos dentro da área do cliente podem ser selecionados.

  - Quaisquer aprimoramentos ou atalhos de teclado estão funcionando como projetado.

### Elementos gráficos

Teste o aplicativo usando um leitor de tela e confirme que:

- Os rótulos e o texto estão sendo lidos corretamente, incluindo menus e barras de ferramentas.

- Informações do objeto são lidas corretamente.

### Indicador de foto visual

- Verifique se, ao mover-se entre objetos, o indicador de foco visual é fácil de identificar.

- A navegação do teclado através do software e dos menus deve ser claramente visível quando o foco se move.

- Confirme se o leitor de tela está rastreando o indicador de foco visual à medida que você navega usando um teclado.

- Execute um programa de ampliação de tela (se disponível) e verifique se o amplificador pode rastrear o indicador de foco visual à medida que você navega usando o teclado e o mouse.

### Fontes e texto

- Altere a fonte no aplicativo e confirme se as configurações são mantidas.

- Teste o aplicativo alterando as cores e confirme que todas as configurações são mantidas.

- Se a ampliação estiver disponível, teste a fonte, cor e tamanho usando a opção de ampliação.

### Cor e contraste

- Imprima capturas de tela em uma impressora a preto e branco e confirme que todas as informações estão visíveis.

- Teste aplicativos usando apenas configurações em preto e branco e alto contraste e confirme que todas as informações são transmitidas corretamente.

- Teste que o aplicativo forneça pelo menos três combinações de esquemas de cores e que esquemas de alto contraste estejam disponíveis (por exemplo, branco em preto ou amarelo em azul).

- Ative as configurações de alto contraste no Centro de Controle GNOME e confirme se o aplicativo respeita essas configurações.

- Teste vários temas para garantir que o software esteja funcionando para todas as configurações disponíveis.

### Áudio

Deve haver uma opção no aplicativo para exibir alertas de áudio visualmente.

Teste se o áudio está funcionando corretamente, ativando o som no Centro de Controle do GNOME e, em seguida, execute as seguintes ações:

- Execute uma ação que deve gerar um alerta de áudio e confirme se o aplicativo está funcionando como projetado.

- Verifique se o aplicativo funciona corretamente ao aumentar ou diminuir o volume.

- Confirme se as mensagens de aviso e alertas podem ser ouvidas corretamente em um ambiente de trabalho ruidoso.

### Animação

Verifique se uma opção está disponível para interromper a animação e que está funcionando como projetado.

Desligue a animação. Confirme se todas as informações ainda são transmitidas corretamente.

### Foco do teclado

- Teste todas as mensagens para confirmar que o usuário é notificado antes de uma mensagem expirar e tem a opção de indicar que é necessário mais tempo.

- Certifique-se de que uma opção foi incluída para ajustar o tempo de resposta e confirmar que ele está funcionando como projetado.

### Documentação

Teste a documentação de texto ASCII com um leitor de tela para confirmar que é claro e preciso e pode ser lido por tecnologias assistivas.

Teste aplicativos HTML usando um navegador da Web e um leitor de tela para confirmar que a documentação está acessível para tecnologias assistivas.

Nota: Existem diretrizes de acessibilidade web disponíveis em http://www.w3.org/TR/WAI-WEBCONTENT/.

Confirme que a seguinte informação está incluída na documentação:

- Indique se o aplicativo não oferece suporte ao acesso padrão ao teclado usado pelo sistema operacional.

- Identifique se existem comandos de teclado exclusivos.

- Identifique quaisquer recursos exclusivos de acessibilidade.

- Se uma ação for documentada para o mouse, verifique se há uma alternativa para usar o teclado.

### Lista de verificação de interface de usuário

Essa seção resume as diretrizes dadas em Diretrizes de interface de usuário para suporte a acessibilidade. Você deveria acessar aquela seção do guia para informações mais detalhadas em qualquer um dos itens da lista de verificação dada.

Ao testar um aplicativo para acessibilidade, você deve passar por cada um dos itens da lista. Observe se o aplicativo passa ou falha em cada teste, ou não se aplica a esse pedido.

### Lista de verificação de princípios da gerais

PG | Princípios gerais | Passou/Falhou/ND
PG.1 | Todas as ações que alteram os dados do usuário ou as configurações do aplicativo podem ser desfeitas.
PG.2 | Todas as configurações do aplicativo podem ser restauradas para seus padrões, sem que o usuário tenha que lembrar quais foram esses padrões.
PG.3 | Após a instalação, o aplicativo pode ser usado sem que o usuário tenha que inserir um disco ou CD a qualquer momento.
PG.4 | As funções mais utilizadas são encontradas no nível superior da estrutura do menu.

### Lista de verificação de navegação do teclado

NT | Navegação do teclado | Passou/Falhou/ND
NT.1 | Um acesso eficiente ao teclado é fornecido a todos os recursos do aplicativo.
NT.2 | Todas as janelas possuem uma ordem lógica de navegação no teclado.
NT.3 | A ordem correta de abas é usada para controles cujo estado habilitado é dependente de caixas de seleção, botões de opção ou botões alternativos.
NT.4 | O acesso do teclado a funções específicas do aplicativo não substitui os recursos existentes de acessibilidade do sistema.
NT.5 | O aplicativo fornece mais de um método para executar tarefas de teclado sempre que possível.
NT.6 | Existem combinações de teclas alternativas sempre que possível.
NT.7 | Não há abordagens estranhas para operações de teclado realizadas com frequência.
NT.8 | O aplicativo não usa pressionamentos de teclas repetitivos e simultâneos.
NT.9 | O aplicativo fornece equivalentes de teclado para todas as funções do mouse.
NT.10 | Qualquer texto ou objeto que pode ser selecionado com o mouse também pode ser selecionado com o teclado sozinho.
NT.11 | Qualquer objeto que pode ser redimensionado ou movido com o mouse também pode ser redimensionado ou movido com o teclado sozinho.
NT.12 | O aplicativo não usa nenhuma função de navegação geral para ativar operações.
NT.13 | Todos os menus, janelas e dicas de ferramentas invocadas pelo teclado aparecem perto do objeto com o qual se relacionam.

### Lista de verificação de interação do mouse

IM | Interação do mouse | Passou/Falhou/ND
IM.1 | Nenhuma operação depende da entrada do botão direito ou meio botões do mouse.
IM.2 | Todas as operações do mouse podem ser canceladas antes de serem concluídas.
IM.3 | O feedback visual é fornecido ao longo das operações de arrastar e soltar
IM.4 | O ponteiro do mouse nunca é alterado sob o controle do aplicativo, ou seu movimento é restrito a parte da tela pelo aplicativo.

### Lista de verificação de elementos gráficos

EG | Elementos gráficos | Passou/Falhou/ND
EG.1 | Não há atributos gráficos codificados, como a espessura da linha, da borda ou da sombra.
EG.2 | Todos os elementos gráficos multicoloridos podem ser mostrados apenas em monocromático, sempre que possível.
EG.3 | Todos os elementos interativos da interface gráfica são facilmente distinguíveis dos estáticos.
EG.4 | É fornecida uma opção para ocultar gráficos não essenciais.

### Lista de verificação de fontes e texto

FT | Fontes e texto | Passou/Falhou/ND
FT.1 | Nenhum estilo ou tamanho de fonte é codificado.
FT.2 | É fornecida uma opção para desativar os “backdrops” gráficos por trás do texto.
FT.3 | Todos os rótulos possuem nomes que fazem sentido quando são retirados do contexto.
FT.4 | Nenhum nome de rótulo é usado mais de uma vez na mesma janela.
FT.5 | O posicionamento do rótulo é consistente ao longo do aplicativo.
FT.6 | Todos os rótulos de texto estático que identificam outros controles terminam em dois pontos (:).
FT.7 | Os rótulos de texto estático que identificam outros controles imediatamente precedem esses controles na ordem de tabulação.
FT.8 | Uma alternativa ao WYSIWYG é fornecida. Por exemplo, a capacidade de especificar diferentes fontes de tela e impressora em um editor de texto.

### Lista de verificação de cor e contraste

CC | Cor e contraste | Passou/Falhou/ND
CC.1 | As cores do aplicativo não são codificadas, mas são desenhadas a partir do tema atual da área de trabalho ou de uma configuração de aplicativo.
CC.2 | A cor é usada apenas como um aprimoramento e não como o único meio para transmitir informações ou ações.
CC.3 | O aplicativo oferece suporte a todos os temas e configurações de alto contraste disponíveis.
CC.4 | O software não depende de nenhum dos temas ou configurações particulares de alto contraste.

### Lista de verificação de ampliação

AM | Ampliação | Passou/Falhou/ND
AM.1 | O aplicativo oferece a capacidade de ampliar a área de trabalho.
AM.2 | O aplicativo oferece a opção de dimensionar a área de trabalho.
AM.3 | A funcionalidade do aplicativo não é afetada pela alteração das configurações de ampliação ou escala.

### Lista de verificação de áudio

AU | Áudio | Passou/Falhou/ND
AU.1 | O som não é usado como o único meio de transmitir qualquer item de informação.
AU.2 | O usuário pode configurar a frequência e o volume de todos os sons e sinais sonoros de aviso.

### Lista de verificação de animação

AN | Animação | Passou/Falhou/ND
AN.1 | Não há elementos de clarão ou piscantes com uma frequência maior que 2Hz ou inferior a 55Hz.
AN.2 | Qualquer clarão ou piscada esteja confinado a pequenas áreas da tela.
AN.3 | Se a animação é usada, uma opção está disponível para desligá-la antes que ela seja mostrada pela primeira vez.

### Lista de verificação de foco de teclado

FC | Foco do teclado | Passou/Falhou/ND
FC.1 | Quando uma janela é aberta, o foco começa no controle mais comum.
FC.2 | A posição de foco de entrada atual é claramente exibida em todos os momentos.
FC.3 | O foco de entrada é mostrado exatamente em uma janela em todos os momentos.
FC.4 | O feedback apropriado de áudio ou visual é fornecido quando o usuário tenta navegar após qualquer extremidade de um grupo de objetos relacionados.
FC.5 | O sinal de aviso de áudio ou visual padrão é reproduzido quando o usuário pressiona uma tecla inadequada.
FC.6 | Há informações de áudio suficientes para o foco visual que o usuário pode descobrir o que fazer a seguir.
FC.7 | Ao usar tecnologias assistivas, como um leitor de tela ou um dispositivo braille, o programa atual indica a posição e o conteúdo do indicador de foco visual.

### Lista de verificação de tempo

TM | Tempo | Passou/Falhou/ND
TM.1 | Não há tempo limite codificado ou recursos baseados no tempo na aplicação.
TM.2 | A exibição ou o ocultação de informações importantes não são desencadeadas unicamente pelo movimento do ponteiro do mouse.

### Lista de verificação de documentação

DC | Documentação | Passou/Falhou/ND
DC.1 | Toda a documentação está em um formato acessível, com descrições alternativas de texto fornecidas para todas as figuras e diagramas.
DC.2 | A documentação inclui uma seção que cobre todos os recursos de acessibilidade da aplicação.

### GOK (teclado em tela do GNOME)

A informação nesta página está parcialmente desatualizada: Caribou do GNOME 3 substitui com sucesso o gok do GNOME 2.

Seu aplicativo deve ser usável através do gok; a entrada de tecla deve ser gerada inteiramente pelo gok, e não no teclado. O objetivo aqui seria trabalhar com seu aplicativo e a área de trabalho em geral, garantindo que qualquer tipo de entrada de caractere possa ser executada com o teclado na tela.

O aplicativo gok vem com o ambiente GNOME, então já deve estar presente. Para a documentação completa, veja o site oficial do gok.

Siga essas etapas para verificar a operação correta do gok com seu aplicativo:

1. Inicie uma sessão no ambiente GNOME

2. Execute gok

3. Inicie seu aplicativo

4. Forneça entrada ao seu aplicativo com um dispositivo de apontamento (por exemplo, mouse ou tracker principal) e gok.

5. Trabalhe usando os recursos de autocompletamento e previsão de palavras de gok.

6. Verifique se o gok ativa ou desativa os botões de Menus e Barras de ferramentas baseado no tipo de aplicativo que é invocado; por exemplo, os botões de Menus e Barras de ferramentas são desabilitados para o miniaplicativo “Propriedades de fonte”, mas os mesmos botões são ativados para o aplicativo Gedit.

7. Verifique se o teclado em tela do gok fornecido pelo botão Compor pode ser usado para digitar em qualquer texto para o aplicativo selecionado; execute Gedit, clique na área de texto e então clique no botão de Compor no gok. Selecione as teclas necessárias do teclado em tela. Os caracteres devem aparecer na área de texto do Gedit.

8. Verifique se o botão Inicializar permite que o usuário inicie qualquer um dos aplicativos Terminal, Navegador web ou Editor de texto.

9. Verifique se o botão Ativar permite que o usuário ative qualquer das janelas de aplicativos atualmente em execução no sistema do usuário, incluindo painéis do GNOME e o ambiente do GNOME.

10. Verifique se o botão Menus lista todos os menus disponíveis no aplicativo atual. Verifique se clicar no botão de menu exibe o submenu e itens de menu contidos no submenu. Finalmente, verifique se clicar em um item de menu ativa o item de menu. Por exemplo, clique no aplicativo Navegação de ajuda e clique no botão Menus. A janela do GOK agora exibe os botões Arquivo, Ir e Ajuda (os menus do Navegador de ajuda). Clique no botão Arquivo e ele exibe os botões Nova janela e Fechar janela (itens de menu).

11. Verifique se o botão Barras de ferramentas lista todos os botões disponíveis na barra de ferramentas do aplicativo. Por exemplo, clique no aplicativo Navegador de ajuda e clique no botão Barras de ferramentas. A janela GOK agora exibe os botões Voltar, Avançar e Início.

12. Verifique se o botão Capturar UI mostra todos os itens de objetos para a janela do aplicativo selecionado. Por exemplo, abra o miniaplicativo “Propriedades de fonte” e clique no botão Capturar UI na janela GOK. A janela do aplicativo GOK deve mostrar os nomes de botões no miniaplicativo – Sans, Sans-serif, Fechar e Ajuda.

### Accerciser

Accerciser e a arquitetura de acessibilidade do GNOME

Accerciser é um explorador de acessibilidade Python para o ambiente de trabalho GNOME. Usa AT-SPI para inspecionar e controlar componentes, permitindo que você verifique se um aplicativo está provendo a informação correta para as tecnologias assistivas e infraestruturas automáticas de teste. Accerciser tem uma estrutura simples de plug-in que você pode usar para criar visualizações customizadas da informação de acessibilidade. A documentação completa pode ser vista no manual oficial do Accerciser . Para uma demonstração do Accerciser e PyATSPI (Python-wrappered acesso e uso do AT-SPI), veja esse artigo. Para uma excelente introdução do autor, veja o artigo intitulado Faça seu aplicativo acessível com Accerciser.

Accerciser efetivamente substituiu a antiga ferramenta at-poke.