<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN" "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
<!ENTITY gnomeversion "2.24">
<!ENTITY manrevision "2.24.0">
<!ENTITY date "September 2008">
<!ENTITY LEGAL SYSTEM "legal.xml">
<!ENTITY gad SYSTEM "gad.xml">
<!ENTITY gtest SYSTEM "gtest.xml">
]>
<?db.chunk.max_depth 4?>
<book id="index" lang="pt-BR">
<title>Guia de accessibilidade para desenvolvedores GNOME</title>
<bookinfo>
<abstract role="description">
<para>O guia de accessibilidade do GNOME é para desenvolvedores que queiram assegurar que seus esforços de programação sejam acessíveis à maior audiência possível de usuários. Esse guia também cobre muitos requerimentos da Seção 508.</para>
</abstract>
<copyright><year>2008</year> <holder>Vincent Alexander</holder></copyright>
<copyright><year>2001, 2002</year> <holder>Calum Benson, Brian Cameron, Bill Haneman, Padraig O'Briain, Sharon Snider</holder></copyright>
<publisher role="maintainer"> 
<publishername>Projeto de Documentação do GNOME</publishername> 
</publisher>
<legalnotice id="legalnotice">
<para>Permissão é dada à cópia, distribuição e/ou modificação deste documento sob os termos da Licença de Documentação Livre GNU (GFDL), Versão 1.1 ou uma versão posterior publicada pela Fundação do Software Livre sem Seções Invariantes, sem textos de capa, e sem textos de fundo. Você pode achar uma cópia da GFDL <ulink type="help" url="ghelp:fdl"> aqui</ulink> ou no arquivo COPYING-DOCS distribuído neste manual.</para>
<para>Esse manual é parte de uma coleção de manuais GNOME distribuídos sob GFDL. Caso você queira distribuir este manual separado da coleção, você pode fazê-lo adicionando a cópia da licença ao manual, como descrito na Seção 6 da licença.</para>
<para>Muitos dos nomes usados por companhias para distinguir seus produtos e serviços são chamados de marcas. Aonde esses nomes aparecem em qualquer documentação GNOME, e os membros do Projeto de Documentação do GNOME estão cientes destas marcas, então os nomes aparecem em letras ou iniciais maiúsculas.</para>
<para>O DOCUMENTO E VERSÕES MODIFICADAS DO DOCUMENTO SÃO FORNECIDOS SOB OS TERMOS DA LICENÇA DE DOCUMENTAÇÃO LIVRE GNU COM O ENTENDIMENTO ADICIONAL DE QUE: <orderedlist>
<listitem>
<para>O DOCUMENTO É FORNECIDO NA BASE “COMO ESTÁ”, SEM GARANTIAS DE QUALQUER TIPO, TANTO EXPRESSA OU IMPLÍCITA, INCLUINDO, MAS NÃO LIMITADO A, GARANTIAS DE QUE O DOCUMENTO OU VERSÃO MODIFICADA DO DOCUMENTO SEJA COMERCIALIZÁVEL, LIVRE DE DEFEITOS, PRÓPRIO PARA UM PROPÓSITO ESPECÍFICO OU SEM INFRAÇÕES. TODO O RISCO A RESPEITO DA QUALIDADE, EXATIDÃO, E DESEMPENHO DO DOCUMENTO OU VERSÕES MODIFICADAS DO DOCUMENTO É DE SUA RESPONSABILIDADE. SE ALGUM DOCUMENTO OU VERSÃO MODIFICADA SE PROVAR DEFEITUOSO EM QUALQUER ASPECTO, VOCÊ (NÃO O ESCRITOR INICIAL, AUTOR OU QUALQUER CONTRIBUIDOR) ASSUME O CUSTO DE QUALQUER SERVIÇO NECESSÁRIO, REPARO OU CORREÇÃO. ESSA RENÚNCIA DE GARANTIAS CONSTITUI UMA PARTE ESSENCIAL DESTA LICENÇA. NENHUM USO DESTE DOCUMENTO OU VERSÃO MODIFICADA DESTE DOCUMENTO É AUTORIZADO SE NÃO FOR SOB ESSA RENÚNCIA; E</para>
</listitem>
<listitem>
<para>SOB NENHUMA CIRCUNSTÂNCIA E SOB NENHUMA TEORIA LEGAL, TANTO EM DANO (INCLUINDO NEGLIGÊNCIA), CONTRATO, OU OUTROS, DEVEM O AUTOR, ESCRITOR INICIAL, QUALQUER CONTRIBUIDOR, OU QUALQUER DISTRIBUIDOR DO DOCUMENTO OU VERSÃO MODIFICADA DO DOCUMENTO, OU QUALQUER FORNECEDOR DE ALGUMA DESSAS PARTES, SER CONSIDERADOS RESPONSÁVEIS A QUALQUER PESSOA POR QUALQUER DANO, SEJA DIRETO, INDIRETO, ESPECIAL, ACIDENTAL OU CONSEQUENCIAL DE QUALQUER INDIVÍDUO, INCLUINDO, MAS NÃO LIMITADO A, DANOS POR PERDA DE BOA VONTADE, TRABALHO PARADO, FALHA OU MAU FUNCIONAMENTO DO COMPUTADOR, OU QUALQUER E TODOS OS OUTROS DANOS OU PERDAS RESULTANTES OU RELACIONADOS AO USO DO DOCUMENTO E VERSÕES MODIFICADAS, MESMO QUE TAL PARTE TENHA SIDO INFORMADA DA POSSIBILIDADE DE TAIS DANOS.</para>
</listitem>
</orderedlist></para>
</legalnotice>
 
<authorgroup> 
<author><firstname>Vincent</firstname> <surname>Alexander</surname> <affiliation> <orgname>Projeto de Documentação do GNOME</orgname> </affiliation></author>
<author><firstname>Calum</firstname> <surname>Benson</surname> <affiliation> <orgname>Projeto de Documentação do GNOME</orgname> </affiliation></author>
<author><firstname>Brian</firstname> <surname>Cameron</surname> <affiliation> <orgname>Projeto de Documentação do GNOME</orgname> </affiliation></author>
<author><firstname>Bill</firstname> <surname>Haneman</surname> <affiliation> <orgname>Projeto de Documentação do GNOME</orgname> </affiliation></author>
<author><firstname>Padraig</firstname> <surname>O'Brian</surname> <affiliation> <orgname>Projeto de Documentação do GNOME</orgname> </affiliation></author> 
<author><firstname>Sharon</firstname> <surname>Snider</surname> <affiliation> <orgname>Projeto de Documentação do GNOME</orgname> </affiliation></author>
</authorgroup>
<revhistory>
<revision><revnumber> Guia de acessibilidade para desenvolvedores v2.24.0 do GNOME 2.24 </revnumber> <date>September 2008</date> <revdescription> 
<para role="author">Projeto de Documentação do GNOME</para> 
<para role="publisher">Projeto de Documentação do GNOME</para> 
</revdescription></revision>
<revision><revnumber> Guia de acessibilidade para desenvolvedores v2.24.0 do GNOME 2.24 </revnumber> <date>September 2008</date> <revdescription> 
<para role="author">Projeto de Documentação do GNOME</para> 
<para role="publisher">Projeto de Documentação do GNOME</para> 
</revdescription></revision>
</revhistory>
<releaseinfo>Esse manual descreve a versão 2.24 do Ambiente GNOME.</releaseinfo>
<legalnotice> 
<title>Feedback</title> 
<para>Para relatar um erro ou fazer uma sugestão em relação ao ambiente GNOME ou este manual, siga as direções em <ulink type="help" url="ghelp:user-guide?feedback">Página de Feedback do GNOME</ulink>.</para>
</legalnotice> 

    <othercredit class="translator">
      <personname>
        <firstname>Tatiana Wells</firstname>
      </personname>
      <email>tati.xx@gmail.com</email>
    </othercredit>
    <copyright>
      
        <year>2011</year>
      
      <holder>Tatiana Wells</holder>
    </copyright>
  
    <othercredit class="translator">
      <personname>
        <firstname>Rafael Fontenelle</firstname>
      </personname>
      <email>rafaelff@gnome.org</email>
    </othercredit>
    <copyright>
      
        <year>2017</year>
      
        <year>2018</year>
      
      <holder>Rafael Fontenelle</holder>
    </copyright>
  </bookinfo>
<chapter id="gad" status="draft">
<title>O que é acessibilidade?</title>
<para>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.</para>
<para>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.</para>
<para>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 <function>gtk_label_set_text()</function> ou <function>gtk_button_new_with_label()</function>). 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.</para>
<para>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.</para>

<section>
<title>Tipos de deficiências</title>
<para>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:</para>
<itemizedlist>
<listitem>
<para><emphasis>Deficiências visuais</emphasis> – 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.</para>
</listitem>
<listitem>
<para><emphasis>Deficiências motoras</emphasis> – 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.</para>
</listitem>
<listitem>
<para><emphasis>Deficiências auditivas</emphasis> – 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.</para>
</listitem>
<listitem>
<para><emphasis>Deficiência cognitiva e de linguagem</emphasis> – 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.</para>
</listitem>
<listitem>
<para><emphasis>Transtornos convulsivos</emphasis> – alguns padrões de luz e som podem causar convulsões epilépticas em alguns usuários suscetíveis.</para>
</listitem>
</itemizedlist>
</section>

<section id="gad-how-it-works">
<title>Como a acessibilidade funciona no GNOME</title>
<para>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.</para>
<para>A implementação para os widgets GTK está em um módulo chamado GAIL (GNOME Accessibility Implementation Library, ou biblioteca de implementação de acessibilidade do GNOME), o que é carregável dinamicamente em tempo de execução por um aplicativo GTK. Uma vez carregado, aquelas partes de seu aplicativo que usam widgets padrões do GTK terão um nível básico de acessibilidade, sem que você tenha que modificar seu aplicativo. Se GAIL não for carregável, widgets GTK terão uma implementação de acessibilidade padrão que essencialmente retorna nenhuma informação, apesar dele, nominalmente, estar em conformidade com a API do ATK. Aplicativos que usam controles do Bonobo, especialmente aqueles fora de processo, também carregam código com suporte a acessibilidade do módulo libgail-gnome. Se aplicativos no ambiente do GNOME carregam automaticamente essas bibliotecas de suporte a acessibilidade dependem do valor de uma chave <application>gconf</application>, “/desktop/gnome/interface/accessibility”; um valor booleano de “verdadeiro” habilita suporte a tecnologias assistivas, e aplicativos que chamam gnome_program_init carregarão automaticamente as bibliotecas de acessibilidade apropriadas em tempo de execução. “Aplicativos GTK+ puros”, como aqueles que usam gtk+ sem se vincular a libgnome, dependem do valor da variável de ambiente GTK_MODULES, que deve ser definida para “gail:atk-bridge” para habilitar suporte a tecnologia assistiva.</para>
<para>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).</para>
<figure id="gad-architecture">
<title>Arquitetura de acessibilidade do GNOME</title>
<mediaobject><imageobject> <imagedata fileref="figures/GNOME_desktop_Accessibility.png" format="PNG"/> </imageobject> <textobject> <phrase>Diagrama da arquitetura de acessibilidade do GNOME</phrase> </textobject></mediaobject>
</figure>
<para>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.</para>
<para>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.</para>
<para>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 <link linkend="gad-coding-guidelines">Diretrizes de codificação para suporte a acessibilidade</link> para mais informações.</para>
<para>Se seu aplicativo usa widgets personalizados, você pode ter que fazer algum trabalho para expor as propriedades dos widgets para as tecnologias assistivas. Veja <link linkend="gad-custom">Criando componentes acessíveis personalizados</link> e <link linkend="gad-api-examples">Exemplos que usam a API de acessibilidade</link> para mais informações.</para>
<para>Para informações adicionais e aprofundadas sobre GTK/GTK+, veja o <ulink url="http://library.gnome.org/devel/gtk">manual de referência do GTK+</ulink>, <ulink url="http://live.gnome.org/GAP/AtkGuide/Gtk">a seção do GTK no guia do ATK</ulink>, o <ulink url="http://library.gnome.org/devel/gtk-tutorial/stable/">tutorial do GTK+ 2.0</ulink> hospedado pelo GNOME e as <ulink url="http://library.gnome.org/devel/gtk-faq/stable/">perguntas frequentes do GTK+</ulink>.</para>
</section>

<section id="dev-start">
<title>Início rápido para desenvolvedores</title>
<para>Aqui estão alguns pontos comuns de início:</para>

<section id="dev-start-1">
<title>Como eu faço para verificar se meu aplicativo é acessível ou não?</title>
<para>Para começar bem, veja <link linkend="gad-overview">Criando um aplicativo acessível para o GNOME – Visão geral</link>. Para uma perspectiva de pré-codificação, veja <link linkend="gad-ui-guidelines">Diretrizes de interface de usuário para suporte a acessibilidade</link> ou <link linkend="gad-coding-guidelines">Diretrizes de codificação para suporte a acessibilidade</link>. Para uma lista de verificação de itens para teste pós-design, veja <link linkend="gad-checklist">Lista de verificação de interface de usuário</link>.</para>
</section>

<section id="dev-start-2">
<title>Quais são as armadilhas comuns?</title>
<para>A <link linkend="gad-checklist">Lista de verificação de interface de usuário</link> cobre todas as áreas que algumas vezes acabam esquecidos no estágio de design.</para>
</section>

<section id="dev-start-3">
<title>Como eu faço as coisas comuns do ATK?</title>
<para>Uma listagem abreviada de chamados ATK comuns pode ser localizada <link linkend="gad-api">aqui</link>.</para>
</section>

<section id="dev-start-4">
<title>Como eu faço as coisas mais complexas do ATK?</title>
<para>Veja <link linkend="gad-custom">Criando componentes acessíveis personalizados</link> e <link linkend="gad-api-examples">Exemplos que usam a API de acessibilidade</link> para mais informações.</para>
</section>

<section id="dev-start-5">
<title>Introdução ao ATK, AT-SPI, GAIL e GTK+</title>
<screenshot>
<mediaobject><imageobject> <imagedata fileref="figures/gaa.jpg"/> </imageobject> <textobject> <phrase> Arquitetura de acessibilidade do GNOME </phrase> </textobject></mediaobject>
</screenshot>
<para>ATK é o kit de ferramenta que o GNOME usa para habilitar acessibilidade para usuários precisando de suporte extra para fazer a maioria de sua computação. ATK é usado por ferramentas tais como leitores de tela, ampliadores e dispositivos de entrada para permitir uma interação rica com o ambiente por meio de alternativos. Veja <ulink url="http://java-gnome.sourceforge.net/4.0/doc/api/org/gnome/atk/package-summary.html">o projeto SourceForge do ATK</ulink> e <ulink url="http://library.gnome.org/devel/atk/stable/">a biblioteca ATK</ulink> para mais informações.</para>
<para>AT-SPI é a interface de serviço principal pela qual as tecnologias assistivas consulta ou recebem notificações de aplicativos em execução. A API completa pode ser explorada <ulink url="http://library.gnome.org/devel/at-spi-cspi/stable/">aqui</ulink>. Material adicional está disponível <ulink url="http://accessibility.kde.org/developer/atk.php#coreclasses">na comunidade de desenvolvimento de acessibilidade do KDE</ulink>.</para>
<para>GAIL (GNOME Accessibility Implementation Library) é uma implementação das interfaces de acessibilidade definidas pelo ATK. GTK é um kit de ferramentas que já é mapeado para ATK pelo módulo GAIL. Licença, download e outras informações podem ser encontradas <ulink url="http://www.t2-project.org/packages/gail.html">aqui</ulink>. O <ulink url="ftp://ftp.gnome.org/pub/GNOME/sources/gail/">código-fonte do GAIL</ulink> também serve como um excelente tutorial para usado avançado do ATK. Além disso, você pode estar interessado no <ulink url="http://library.gnome.org/devel/gail-libgail-util/stable/">manual de referência do GAIL</ulink>.</para>
<para>GTK+ é uma biblioteca para criação de interfaces gráficas de usuário. Ela funciona em várias plataformas do tipo UNIX, Windows e em dispositivos de framebuffer. GTK+ é lançado sob a Licença Pública Geral de Biblioteca GNU (GNU LGPL), a qual permite licenciamento flexível de aplicativos de cliente. GTK+ possui uma arquitetura orientada a objeto baseada no C que permite uma flexibilidade máxima. Bindings para outras linguagens foram escritas, incluindo C++, Objective-C, Guile/Scheme, Perl, Python, TOM, Ada95, Free Pascal e Eiffel.</para>
<para>Para informações adicionais e aprofundadas sobre GTK/GTK+, veja o <ulink url="http://library.gnome.org/devel/gtk">manual de referência do GTK+</ulink>, a <ulink url="http://wiki.gnome.org/Accessibility/Documentation/GNOME2/AtkGuide/Gtk">seção do GTK no guia do ATK</ulink>, o <ulink url="http://library.gnome.org/devel/gtk-tutorial/stable/">tutorial do GTK+ 2.0</ulink> hospedado pelo GNOME e as <ulink url="http://library.gnome.org/devel/gtk-faq/stable/">perguntas frequentes do GTK+</ulink>.</para>
</section>
</section>

<section id="gad-overview">
<title>Criando um aplicativo acessível para o GNOME – Visão geral</title>
<para>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.</para>
<para>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 <link linkend="gad-coding-guidelines">Diretrizes de codificação para suporte a acessibilidade</link> para mais informações.</para>
<para>Se seu aplicativo usa widgets personalizados, você pode ter que fazer algum trabalho para expor as propriedades dos widgets para as tecnologias assistivas. Veja <link linkend="gad-custom">Criando componentes acessíveis personalizados</link> e <link linkend="gad-api-examples">Exemplos que usam a API de acessibilidade</link> para mais informações. Informações detalhadas adicionais podem ser localizadas na apresentação de Marc Mulcahy no GUADEC 2002, <ulink url="https://projects.gnome.org/accessibility/talks/GUAD3C/making-apps-accessible/start.html">"Tornando aplicativos do GNOME acessíveis"</ulink> (em inglês).</para>
</section>

<section id="gad-coding-guidelines">
<title>Diretrizes de codificação para suporte a acessibilidade</title>
<para>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 <link linkend="gad-ui-guidelines">Diretrizes de interface de usuário para suporte a acessibilidade</link> afrente do seu documento):</para>
<itemizedlist>
<listitem>
<para>Para componentes que não exibem um texto curto (tal como um botão gráfico), especifique um nome para ele com <function>atk_object_set_name()</function>. 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.</para>
</listitem>
<listitem>
<para>Se você não conseguir fornecer uma dica de ferramenta para um componente, use <function>atk_object_set_description()</function> 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 <guibutton>Close</guibutton>:</para>
<example>
<title>Fornecendo uma descrição de acessibilidade para um GtkButton</title>
<programlisting>
{
  AtkObject *obj;
  obj = gtk_widget_get_accessible(button);
  atk_object_set_description(obj,_("Closes the window"));
}
</programlisting>
</example>
</listitem>
<listitem>
<para>Use <function>atk_image_set_description()</function> para fornecer uma descrição para todas as imagens e ícones em seu programa.</para>
</listitem>
<listitem>
<para>Se vários componentes formam um grupo lógico, tente colocá-los em um contêiner.</para>
</listitem>
<listitem>
<para>Quando você tiver um rótulo que descreve outro componente, use <function>atk_relation_set_add_relation()</function> 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 <function>gtk_label_set_mnemonic_widget()</function>, a relação <constant>ATK_RELATION_LABEL_FOR</constant> é gerada automaticamente, então o seguinte código não mais seria necessário):</para>
<example>
<title>Relacionando um GtkLabel a um GtkWidget</title>
<programlisting>
{
  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));
}
</programlisting>
</example>
</listitem>
<listitem>
<para>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 <link linkend="gad-custom">Criando componentes acessíveis personalizados</link>.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
</itemizedlist>
</section>

<section id="gad-api">
<title>A API de acessibilidade</title>
<para>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.</para>
<table frame="all">
<title>Chamadas de API do ATK comumente usadas</title>
<tgroup cols="2" align="left">
<thead>
<row>
<entry>API</entry>
<entry>Descrição</entry>
</row>
</thead>
<tbody>
<row>
<entry>
<para><function>AtkObject* gtk_widget_get_accessible (GtkWidget*)</function></para>
</entry>
<entry>
<para>Retorna o objeto acessível que descreve o widget GTK especificado para uma tecnologia assistiva.</para>
</entry>
</row>
<row>
<entry>
<para><function>void atk_object_set_name (AtkObject*, const gchar*)</function></para>
</entry>
<entry>
<para>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”.</para>
</entry>
</row>
<row>
<entry>
<para><function>void atk_object_set_description (AtkObject*, const gchar*)</function></para>
</entry>
<entry>
<para>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”.</para>
</entry>
</row>
<row>
<entry>
<para><function>AtkRelation* atk_relation_new (AtkObject**, gint, AtkRelationType)</function></para>
</entry>
<entry>
<para>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.</para>
</entry>
</row>
<row>
<entry>
<para><function>void atk_image_set_description (AtkImage*, const gchar*)</function></para>
</entry>
<entry>
<para>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”.</para>
</entry>
</row>
</tbody>
</tgroup>
</table>
</section>

<section id="gad-api-examples">
<title>Exemplos que usam a API de acessibilidade</title>
<para>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:</para>
<itemizedlist>
<listitem>
<para>fornece descrições de alguns controles e imagem usando <function>atk_object_set_description()</function> ou <function>atk_image_set_description():</function></para>
<example>
<title>Configurar a descrição de acessibilidade para um botão</title>
<programlisting>
{
   AtkObject *obj;
   obj = gtk_widget_get_accessible(button);
   atk_object_set_description(obj,_("Opens Preferences dialog"));
}
</programlisting>
</example>
<para>
</para>
</listitem>
<listitem>
<para>Especificar relações entre quaisquer agrupamentos incomuns de widgets usando <function>atk_relation_new()</function> and <function>atk_relation_set_add()</function>:</para>
<example>
<title>Especificar relações acessíveis entre dois controles</title>
<programlisting>
{
  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));
}
</programlisting>
</example>
</listitem>
</itemizedlist>
<para>Os exemplos no resto desta seção são, em sua maioria, para dar a você o sabor do escopo do ATK. Eles cobrem as técnicas  que você pode nunca precisar usar como um desenvolvedor de aplicativos, apesar de que eles podem ser interessantes se você está escrevendo seus próprios widets personalizados (veja <link linkend="gad-custom">Criando componentes acessíveis personalizados</link>) ou se você deseja escrever um aplicativo de tecnologia assistiva. Seja qual for o propósito, o <ulink url="ftp://ftp.gnome.org/pub/GNOME/sources/gail/">código-fonte do GAIL</ulink> serve como um tutorial excelente para uso avançado do ATK. Por favor, note que desde o GTK+ 3.1.10, Gail foi mesclado com GTK+ e deixou de ser um módulo autônomo.</para>

<section>
<title>Módulos do Gtk</title>
<para>Programas que fazem uso do GAIL (a biblioteca de implementação de acessibilidade para widgets GTK) são escritos como módulos GTK. Módulos GTK são carregados no espaço do programa se a variável de ambiente <varname>GTK_MODULES</varname> especifica o módulo do(s) nome(s) da biblioteca do módulo. Se há múltiplas bibliotecas de módulo, separe-os com caractere de dois pontos. Por exemplo:</para>
<para><userinput>setenv GTK_MODULES "libgail:libtestprops"</userinput></para>
<para>Todos os módulos GTK possuem uma função <function>gtk_module_init()</function>.</para>
</section>

<section>
<title>Juntando informações de acessibilidade de um aplicativo</title>
<para>Um programa que deseja fazer uso de chamadas de ATK provavelmente precisaria de uma (ou mais) das seguintes coisas:</para>
<orderedlist>
<listitem>
<para>Criar um monitorador de evento, por exemplo com a função <function>atk_add_focus_tracker()</function>:</para>
<programlisting>atk_add_focus_tracker (_my_focus_tracker);</programlisting>
<para>sendo <function>_my_focus_tracker()</function> uma função com esse protótipo:</para>
<programlisting>void _my_focus_tracker (AtkObject *aobject);</programlisting>
</listitem>
<listitem>
<para>Configurar um listener de eventos globais, com atk_add_global_event_listener():</para>
<programlisting>
mouse_watcher_focus_id =   atk_add_global_event_listener(_my_global_listener,"Gtk:GtkWidget:enter_notify_event");
</programlisting>
<para>sendo que <function>_my_global_listener</function> tem o protótipo de um Glib <type>GSignalEmissionHook</type>. Esse exemplo faria com que <function>_my_global_listener()</function> fosse chamado sempre que um sinal enter_notify_even ocorrer em um objeto <type>GtkWidget</type>.</para>
</listitem>
<listitem>
<para>Acessar o objeto de nível superior do ATK com a chamada de função a seguir.</para>
<programlisting>AtkObject *root_obj = atk_get_root();</programlisting>
<para>Isso retorna um <type>AtkObject</type> 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.</para>
</listitem>
</orderedlist>
</section>

<section>
<title>Consultando as interfaces de um <type>AtkObject</type></title>
<para>Tendo localizado o <type>AtkObject</type> associado com um objeto no aplicativo (ex.: usando <function>gtk_widget_get_accessible()</function>), você pode descobrir quais interfaces ele implementa de várias formas:</para>
<orderedlist>
<listitem>
<para>Use as macros <function>ATK_IS_...</function> fornecidas, por exemplo:</para>
<itemizedlist>
<listitem>
<para><function>ATK_IS_ACTION(atkobj)</function></para>
</listitem>
<listitem>
<para><function>ATK_IS_COMPONENT(atkobj)</function></para>
</listitem>
<listitem>
<para>etc. (há um para cada interface)</para>
</listitem>
</itemizedlist>
<para>Se a macro retorna <function>TRUE</function>, as chamadas de interface podem ser feitas com segurança naquele objeto ATK.</para>
</listitem>
<listitem>
<para>Teste a função do <type>AtkObject</type> chamando <function>atk_object_get_role()</function>. Qualquer papel dado implementa um número específico de APIs ATK.</para>
</listitem>
</orderedlist>
</section>

<section>
<title>Configurando uma manipulador de signal ATK</title>
<para>Usando o sinal <constant>column_inserted</constant> como um exemplo:</para>
<programlisting>
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);
</programlisting>
<para>Isso fará com que <function>_my_table_column_inserted_func()</function> seja chamado sempre que um sinal column_inserted seja emitido no <type>AtkObject</type> <varname>my_atk_object</varname></para>
<para>A conexão com um sinal é um pouco diferente se o sinal oferece suporte a detalhes. O sinal <constant>children_changed</constant> oferece suporte o detalhe <parameter>add</parameter>. Para conectar com um sinal quando o detalhe <parameter>add</parameter> também é especificado, essa técnica é usada:</para>
<programlisting>
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);
</programlisting>
<para>Isso fará com que <function>_my_children_changed_func()</function> seja chamada sempre que um sinal <constant>children_changed</constant> com o detalhe <parameter>add</parameter> seja emitido no <type>AtkObject</type> <varname>my_atk_obj</varname>.</para>
</section>

<section>
<title>Implementando um objeto ATK</title>
<para>Você precisará implementar seus próprios objetos ATK para quaisquer widgets que não tenham uma implementação acessível no GAIL (ou a biblioteca equivalente para outros conjuntos de widgets). Isso deve ser implementado como um módulo, o que, assim como anteriormente, deve ser incluído na variável de ambiente <envar>GTK_MODULES</envar> de forma que seja carregada em tempo de execução.</para>

<section>
<title>Registro</title>
<para>Para esse exemplo nós presumiremos que haja um objeto chamado GTK_TYPE_MYTYPE. A implementação ATK será chamada de <type>MYATKIMP_TYPE_MYTYPE</type>. Uma fábrica será necessária, a qual será chamada de <type>MYATKIMP_TYPE_MYTYPE_FACTORY</type>.</para>
<para>Para registrar uma implementação ATK de um objeto GTK, essas etapas devem ser seguidas na função <function>gtk_module_init()</function> do módulo:</para>
<orderedlist>
<listitem>
<para>Acesse o registro padrão:</para>
<programlisting>
default_registry = atk_get_default_registry();
</programlisting>
</listitem>
<listitem><para>Registre o objeto ATK na função <function>gtk_module_init()</function> deste módulo fazendo essa chamada de função:</para>
<programlisting>
atk_registry_set_factory_type (default_registry, GTK_TYPE_MYTYPE, 
MYATKIMP_TYPE_MYTYPE_FACTORY); 
</programlisting>
</listitem>
</orderedlist>
<para>Isso vai registrar a implementação AtkObject de <type>GTK_TYPE_MYTYPE</type> para <type>MYATKIMP_TYPE_MYTYPE_FACTORY</type>. Essa fábrica será implementada de forma que saiba como construir objetos do tipo <type>MYATKIMP_TYPE_MYTYPE</type>.</para>
</section>

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

<section>
<title>Implementação ATK para um objeto específico</title>
<para>Todos <type>GObject</type>s implementam uma função <function>get_type()</function>. Usando o exemplo acima, a convenção de nome para esse nome de função seria <function>myatkimp_mytype_get_type()</function>.</para>
<para>Nesta função, você especificaria quais interfaces seu objeto implementa. Se a seguinte lógica estivesse incluída nesta função <function>get_type()</function>, esse objeto implementaria a interface <type>ATK_TEXT</type>:</para>
<example>
<title>Exemplo de função <function>get_type()</function></title>
<programlisting>
static const GInterfaceInfo atk_text_info = 
{ 
   (GInterfaceInitFunc) atk_text_interface_init, 
   (GInterfaceFinalizeFunc) NULL, 
   NULL 
}; 

g_type_add_interface_static (type, ATK_TYPE_TEXT, 
                             &amp;atk_text_info); 
</programlisting>
</example>
<para>A função <function>atk_text_interface_init()</function>, que possui o protótipo a seguir, precisaria ser implementado:</para>
<programlisting>
void atk_text_interface_init (AtkTextIface *iface); 
</programlisting>
<para>Essa função conectaria as chamadas de função de interface com a implementação específica a seguir:</para>
<example>
<title>Conectando chamadas personalizadas de interface a uma implementação AtkObject</title>
<programlisting>
void 
atk_text_interface_init (AtkTextIface *iface) 
{ 
   g_return_if_fail (iface != NULL); 
   iface-&gt;get_text = myatkimp_mytype_get_text; 
   iface-&gt;get_character_at_offset = myatkimp_mytype_get_character_at_offset; 
   ... 
}
</programlisting>
</example>
<para>Então, as funções <function>myatkimp_mytype_get_text()</function>, <function>myatkimp_mytype_get_character_at_offset()</function> e o resto das funções de interface <type>ATK_TEXT</type> precisariam ser implementadas.</para>
</section>

<section>
<title>Implementação de <type>AtkObject</type></title>
<para><type>AtkObject</type>s são <type>GObject</type>s e todos <type>GObject</type>s precisam especificar a função <function>get_type()</function>. Aqui está um exemplo que configura uma classe e inicializador de instância. Essa função <function>get_type()</function> também especifica que o objeto implementa <type>ATK_TEXT</type> e especifica o objeto pai para ser <type>MYATKIMP_MYPARENTTYPE</type>.</para>
<example>
<title>Exemplo de implementação <function>get_type()</function></title>
<programlisting>
GType 
myatkimp_mytype_get_type (void) 
{ 
   static GType type = 0; 

   if (!type) 
   { 
      static const GTypeInfo tinfo = 
      { 
         sizeof (GailLabelClass), 
         (GBaseInitFunc) NULL,                              /* base init */ 
         (GBaseFinalizeFunc) NULL,                          /* base finalize */
         (GClassInitFunc) myatkimp_mytype_class_init,       /* class init */ 
         (GClassFinalizeFunc) NULL,                         /* class finalize */ 
         NULL,                                              /* class data */ 
         sizeof (GailLabel),                                /* instance size */ 
         0,                                                 /* nb preallocs */ 
         (GInstanceInitFunc) myatkimp_mytype_instance_init, /* instance init */ 
         NULL                                               /* value table */ 
      }; 

      /* Configura a estrutura atk_text_info usada abaixo */ 
      static const GInterfaceInfo atk_text_info = 
      { 
         (GInterfaceInitFunc) atk_text_interface_init, 
         (GInterfaceFinalizeFunc) NULL, 
         NULL 
      }; 

      /* Configura o nome de tipo e especifica o pai do tipo */ 
      type = g_type_register_static (MYATKIMP_MYPARENTTYPE, 
            "MyatkimpMytype", &amp;tinfo, 0); 

      /* Essa classe implementa uma interface ATK_TYPE_TEXT */ 
      g_type_add_interface_static (type, ATK_TYPE_TEXT, 
                                   &amp;atk_text_info); 
   } 
   return type; 
} 
</programlisting>
</example>
</section>

<section>
<title>Inicializadores de classe/instância</title>
<para>Você precisará configurar um inicializador de classe para o <type>GObject</type> se sua implementação <type>AtkObject</type>:</para>
<orderedlist>
<listitem>
<para>Redefine quaisquer chamadas de função definidas pelo pai do objeto. Isso geralmente é necessário quando um objeto precisa implementar uma função como <function>atk_object_get_n_accessible_children()</function>. Isso é necessário se o objeto possui um filho, mas eles não são representados com widgets.</para>
<para>Por exemplo, se sua implementação ATK precisa substituir a função <type>AtkObject</type> <function>get_name()</function> então o inicializador de classe seria algo como:</para>
<example>
<title>Inicializador de classe que substitui a função <function>get_name?()</function> do pai</title>
<programlisting>
myatkimp_mytype_class_init (GailLabelClass *klass) 
{ 
  AtkObjectClass *class = ATK_OBJECT_CLASS (klass); 
  class-&gt;get_name = myatkimp_mytype_get_name; 
} 
</programlisting>
</example>
</listitem>
<listitem><para>Requer uma função <function>parent-&gt;init</function>, <function>parent-&gt;notify_gtk</function> ou <function>parent-&gt;finalize</function>. Esse exemplo define todas as três:</para>
<example>
<title>Inicializador de classe que define suas próprias <function>init()</function>, <function>notify_gtk()</function> e <function>finalize()</function></title>
<programlisting>
static ParentObjectType *parent_class = NULL; 

myatkimp_mytype_class_init (GailLabelClass *klass) 
{ 
   ParentObjectType *parent_class = (ParentObjectType*)klass; 

   /* 
    * Pegar a classe pai é necessária se as funções 
    * init, notify_gtk ou finalize estiverem definidas. 
    */ 
    parent_class = g_type_class_ref (MYATKIMP_TYPE_PARENT); 

    parent_class-&gt;init = myatkimp_mytype_widget_init; 
    parent_class-&gt;notify_gtk = myatkimp_mytype_real_notify_gtk; 
    parent_class-&gt;finalize = myatkimp_mytype_finalize; 
}
</programlisting>
</example>
<orderedlist>
<listitem>
<para>parent-&gt;init</para>
<para>Uma função <function>parent-&gt;init()</function> pode ser necessária se a implementação ATK precisar sfazer uma das duas coisas:</para> 
<orderedlist>
<listitem>
<para>Fazer cache de quaisquer dados obtidos do widget GTK backup.</para>
</listitem>
<listitem>
<para>Ouve quaisquer sinais do widget GTK backup.</para>
</listitem>
</orderedlist>
<para>Aqui está um exemplo de ambos:</para>
<example>
<title>Uma função <function>init()</function> personalizada</title>
<programlisting>
void 
gail_tree_view_widget_init (MyatkimpMytype  *mytype, 
                            GtkWidget       *gtk_widget) 
{ 
   /* Certifica-se de chamar a função init do pai */ 
   parent_class-&gt;init (widget, gtk_widget); 
   
   /* Fazer cache de um valor na implementação ATK */ 
   mytype-&gt;cached_value = gtk_widget_function_call(); 

   /* Ouve um sinal */ 
   gtk_signal_connect (GTK_OBJECT (gtk_widget), 
                       "signal-type", 
                       GTK_SIGNAL_FUNC (_myatkimp_mytype_signal_type), 
                       NULL); 
} 
</programlisting>
</example>
<para>Neste exemplo, se o sinal <type>signal-type</type> especificado foi gerado no <varname>gtk_widget</varname> backup, então a função <function>_myatkimp_mytype_signal_type()</function> seria chamada.</para>
</listitem>
<listitem>
<para>parent-&gt;notify_gtk</para>
<para>Se a implementação ATK precisa ouvir a quaisquer notificações de propriedade no objeto GTK backup, uma função <function>parent-&gt;notify_gtk()</function> pode ser necessário. Por exemplo:</para>
<example>
<title>Uma função <function>notify_gtk()</function> personalizada</title>
<programlisting>
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-&gt;name, "property-of-interest") == 0) 
   { 
      /* Lida com a alteração de propósito. */ 
   } 
   else 
   { 
      parent_class-&gt;notify_gtk (obj, pspec); 
   } 
} 
</programlisting>
</example>
</listitem>
<listitem>
<para>parent-&gt;finalize</para>
<para>Se for necessário liberar quaisquer dados quando uma instância <type>GObject</type> é destruída, então uma função <function>finalize()</function> é necessária para liberar a memória. Por exemplo:</para>
<example>
<title>Uma função <function>finalize()</function> personalizada</title>
<programlisting>
void 
myatkimp_mytype_finalize (GObject *object) 
{ 
   MyAtkimpMyType *my_type = MYATKIMP_MYTYPE (object); 

   g_object_unref (my_type-&gt;cached_value); 
   G_OBJECT_CLASS (parent_class)-&gt;finalize (object); 
} 
</programlisting>
</example>
</listitem>
</orderedlist>
</listitem>
</orderedlist>
</section>
</section>
</section>

<section id="gad-custom">
<title>Criando componentes acessíveis personalizados</title>
<para>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:</para>
<itemizedlist>
<listitem>
<para>avaliar um widget personalizado de acordo com as <link linkend="gad-ui-guidelines">Diretrizes de interface de usuário</link>;</para>
</listitem>
<listitem>
<para>determinar quais <ulink url="https://developer.gnome.org/atk/stable/interfaces.html">interfaces ATK</ulink> um widget personalizado deve implementar, conforme o conjunto de recursos e função do widget;</para>
</listitem>
<listitem>
<para>avaliar quais <ulink url="https://developer.gnome.org/atk/stable/interfaces.html">interfaces ATK</ulink> podem ser herdados a partir da classe widget pai;</para>
</listitem>
<listitem>
<para>implementar as interfaces ATK adequadas para a classe widget em uma das duas formas:</para>
<itemizedlist>
<listitem>
<para>diretamente pelo widget personalizado, ou</para>
</listitem>
<listitem>
<para>em um subtipo de <ulink url="http://library.gnome.org/devel/atk/stable/AtkObject.html"><type>AtkObject</type></ulink> criado por uma nova subclasse de <ulink url="http://library.gnome.org/devel/atk/stable/AtkObjectFactory.html"><type>AtkObjectFactory</type></ulink></para>
</listitem>
</itemizedlist>
<para>Se o segundo método for usado, o tipo de fábrica adequada deve ser registrada com o <type>AtkObjectFactoryRegistry</type> em tempo de execução.</para>
</listitem>
</itemizedlist>
<para>O <ulink url="ftp://ftp.gnome.org/pub/GNOME/sources/gail/">código-fonte do GAIL</ulink> serve como um excelente tutorial para uso avançado do ATK.</para>
</section>

<section id="gad-ui-guidelines">
<title>Diretrizes de interface de usuário para suporte a acessibilidade</title>
<para>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ê!</para>

<section>
<title>Geral</title>
<para>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.</para>
<itemizedlist>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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 <guibutton>Finalizar</guibutton> 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.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Navegação do teclado</title>
<para>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.</para>
<para>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!</para>
<para>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.</para>
<itemizedlist>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>Use uma ordem lógica de navegação de teclado. Ao navegar por uma janela com a tecla <keycap>Tab</keycap>, 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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>Não sobrescreva recursos existentes de acessibilidade em nível de sistema. Por exemplo, <ulink url="http://www.rehab.uiuc.edu/accessx/overview.html">AccessX</ulink> é uma extensão do Xserver que tem suporte desde o X11R6. Os recursos de MouseKeys (teclas de mouse) desta extensão permite movimento e cliques de botão de mouse serem simulados usando o teclado numérico. Portanto, você não deve adicionar recursos a seu aplicativo que possam ser acessados apenas pressionando teclas no teclado numérico, já que usuários que dependem do recurso MouseKeys não poderão usá-los.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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 <keycap>Tab</keycap> em um diálogo para ativar quaisquer ações associadas com um controle.</para>
</listitem>
<listitem>
<para>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 <keycombo><keycap>Shift</keycap><keycap>F10</keycap></keycombo> e dicas de ferramentas com <keycombo><keycap>Shift</keycap><keycap>F1</keycap></keycombo>. Porém, não oculte ou obscureça completamente o objeto ao qual o menu ou a dica se refere.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Interação do mouse</title>
<para>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.</para>
<itemizedlist>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>Permita que todas as operações sejam canceladas. O pressionamento da tecla <keycap>Esc</keycap> 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.</para>
</listitem>
<listitem>
<para>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 <link linkend="gad-mouse-examples">Exemplos de interação do mouse</link>.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
</itemizedlist>

<section id="gad-mouse-examples">
<title>Exemplos de interação do mouse</title>
<figure>
<title>Exemplo de ponteiro “não soltar” do CDE/Motif</title>
<mediaobject><imageobject> <imagedata fileref="figures/nodrop.png" format="PNG"/> </imageobject> <textobject> <phrase>Exemplo de uma forma de ponteiro de “alvos inválidos para soltar”</phrase> </textobject></mediaobject>
</figure>
</section>
</section>

<section>
<title>Elementos gráficos</title>
<para>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.</para>
<itemizedlist>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>Forneça nomes descritivos para todos os componentes da interface. A biblioteca GAIL fornece descrições acessíveis padrões para muitos widgets GTK, mas você ainda precisará adicionar suas próprias em alguns casos, como para widgets que usam gráficos em vez de textos (ex.: um poço em uma paleta de cores, ou um ícone sem um rótulo). Considere sobrepôr os padrões com descrições mais úteis e específicas para seu aplicativos, onde possível.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Fontes e texto</title>
<para>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.</para>
<itemizedlist>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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 <link linkend="gad-font-examples">Exemplos de fontes e texto</link>.</para>
</listitem>
<listitem>
<para>Quando você usar texto estático para rotular um controle, termine o rótulo com um caractere de dois pontos. Por exemplo, <guilabel>Nome de usuário:</guilabel> 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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
</itemizedlist>

<section id="gad-font-examples">
<title>Exemplos de fontes e texto</title>
<figure id="label-placement-example">
<title>Posicionamento correto de rótulo para vários elementos da GUI</title>
<informaltable frame="all">
<tgroup cols="3" align="center">
<tbody>
<row>
<entry valign="middle"><mediaobject>
<imageobject>
<imagedata fileref="figures/label_above.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>List control with label above</phrase>
</textobject>
</mediaobject> Controle de lista com rótulo em cima</entry>
<entry valign="middle"><mediaobject>
<imageobject>
<imagedata fileref="figures/label_below.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>Large file manager icon with label underneath</phrase>
</textobject>
</mediaobject> Ícone grande do gerenciador de arquivos com rótulo embaixo</entry>
<entry valign="middle"><mediaobject>
<imageobject>
<imagedata fileref="figures/label_right.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>Small toolbar icon with label to its right</phrase>
</textobject>
</mediaobject> Ícone pequeno da barra de ferramentas com rótulo a sua direita</entry>
<entry valign="middle"><mediaobject>
<imageobject>
<imagedata fileref="figures/label_left.png" format="PNG"/>
</imageobject>
<textobject>
<phrase>Spinbox control with label to its left</phrase>
</textobject>
</mediaobject> Controle de caixa giratória com rótulo a sua esquerda</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</figure>
</section>
</section>

<section>
<title>Cor e contraste</title>      
<para>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.</para>
<para>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.</para>
<itemizedlist>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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 <link linkend="gad-color-examples">Exemplos de cores e contraste</link>.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
</itemizedlist>

<section id="gad-color-examples">
<title>Exemplos de cor e contraste</title>
<example>
<title>Exemplo ilustrando uso redundante de cor</title>
<informaltable frame="all">
<tgroup cols="2">
<tbody>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/color_only.png" format="PNG"/> </imageobject> <textobject> <phrase>Exemplo mostrando alterações preços de ações usando apenas cor</phrase> </textobject></mediaobject>
</entry>
<entry>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.</entry>
</row>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/color_and_arrows.png" format="PNG"/> </imageobject> <textobject> <phrase>Exemplo mostrando alterações preços de ações usando cor e setas</phrase> </textobject></mediaobject>
</entry>
<entry>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 <guilabel>Preferências</guilabel> do aplicativo.</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</example>
</section>
</section>

<section>
<title>Ampliação</title>
<para>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.</para>
<itemizedlist>
<listitem>
<para>Forneça a capacidade do usuário para ampliar a área de trabalho.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Áudio</title>
<para>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.</para>
<itemizedlist>
<listitem>
<para>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!</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Animação</title>
<para>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.</para>
<itemizedlist>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Foco do teclado</title>
<para>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.</para>
<para>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.</para>
<itemizedlist>
<listitem>
<para>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 <guilabel>OK</guilabel> ou <guilabel>Cancelar</guilabel> de uma caixa de diálogo, mesmo que sejam os controles mais usados, pois eles sempre podem ser ativados imediatamente pressionando <keycap>Enter</keycap> ou <keycap>Escape</keycap>.</para>
</listitem>
<listitem>
<para>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 <link linkend="gad-focus-examples">Exemplos de foco do teclado</link>.</para>
</listitem>
<listitem>
<para>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 <link linkend="gad-focus-examples">Exemplos de foco do teclado</link>.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.)</para>
</listitem>
</itemizedlist>

<section id="gad-focus-examples">
<title>Exemplos de foco do teclado</title>
<example><title>Exemplo ilustrando a necessidade de mostrar o foco claramente</title>
<informaltable frame="all">
<tgroup cols="2">
<tbody>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/badfocus1.png" format="PNG"/> </imageobject> <textobject> <phrase>O item em foco nesta janela não pode ser visto porque ele foi deslocado para fora da tela</phrase> </textobject></mediaobject>
</entry>
<entry>Um dos controles desta janela tem foco, mas é impossível dizer qual…</entry>
</row>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/badfocus2.png" format="PNG"/> </imageobject> <textobject> <phrase>O item focado na lista foi exibido ao deslocar a lista</phrase> </textobject></mediaobject>
</entry>
<entry>…até você deslocar a lista, que revela que um de seus itens está atualmente selecionado.</entry>
</row>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/goodfocus.png" format="PNG"/> </imageobject> <textobject> <phrase>O controle da lista neste exemplo possui uma borda sólida indicando foco, se seu item selecionado está atualmente visível ou não</phrase> </textobject></mediaobject>
</entry>
<entry>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.</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</example>
<example>
<title>Exemplo ilustrando o uso de foco secundário</title>
<informaltable frame="all">
<tgroup cols="2">
<tbody>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/badfocus3.png" format="PNG"/> </imageobject> <textobject> <phrase>Janela divida em painéis em que ambos os painéis parecem ter foco</phrase> </textobject></mediaobject>
</entry>
<entry>Neste exemplo, é impossível dizer apenas olhando quais dos dois painéis realmente têm foco no teclado.</entry>
</row>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/goodfocus3.png" format="PNG"/> </imageobject> <textobject> <phrase>Janela dividida em painéis em que o destaque secundário é usado para mostrar qual painel tem foco</phrase> </textobject></mediaobject>
</entry>
<entry>Ao usar uma cor de destaque de seleção secundária no painel inativo, é imediatamente óbvio que o controle de árvore tem foco aqui…</entry>
</row>
<row>
<entry valign="middle">
<mediaobject><imageobject> <imagedata fileref="figures/goodfocus2.png" format="PNG"/> </imageobject> <textobject> <phrase>Janela dividida em painéis em que o destaque secundário é usado para mostrar qual painel tem foco</phrase> </textobject></mediaobject>
</entry>
<entry>…e que o controle da lista tem foco aqui.</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</example>
</section>
</section>

<section>
<title>Tempo</title>
<para>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.</para>
<itemizedlist>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Documentação</title>
<para>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.</para>
<itemizedlist>
<listitem>
<para>Forneça toda a documentação em um formato acessível. O texto ASCII e o HTML são formatos excelentes para tecnologias assistivas.</para>
</listitem>
<listitem>
<para>Forneça descrições de texto alternativas para todos os gráficos na documentação.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
</itemizedlist>
</section>
</section>
</chapter>

<chapter id="gtest" status="draft">
<title>Testes</title>
<para>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. <ulink url="http://ldtp.freedesktop.org/">LDTP</ulink>, por exemplo, pode complementar o seu plano de testes automatizado.</para>
<para>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.</para>

<section>
<title>Navegação do teclado</title>
<para>As seguintes operações de teclado devem ser testadas. Não use o mouse em nenhuma parte deste teste.</para>
<itemizedlist>
<listitem>
<para>Usando apenas comandos de teclado, mova o foco através de todas as barras de menu no aplicativo.</para>
</listitem>
<listitem>
<para>Confirme que:</para>
<itemizedlist>
<listitem>
<para>Os menus sensíveis ao contexto exibem corretamente.</para>
</listitem>
<listitem>
<para>Todas as funções listadas na barra de ferramentas podem ser executadas usando o teclado.</para>
</listitem>
<listitem>
<para>Você pode operar todos os controles na área do cliente do aplicativo e caixas de diálogo.</para>
</listitem>
<listitem>
<para>Texto e objetos dentro da área do cliente podem ser selecionados.</para>
</listitem>
<listitem>
<para>Quaisquer aprimoramentos ou atalhos de teclado estão funcionando como projetado.</para>
</listitem>
</itemizedlist>
</listitem>
</itemizedlist>
</section>

<section>
<title>Elementos gráficos</title>
<para>Teste o aplicativo usando um leitor de tela e confirme que:</para>
<itemizedlist>
<listitem>
<para>Os rótulos e o texto estão sendo lidos corretamente, incluindo menus e barras de ferramentas.</para>
</listitem>
<listitem>
<para>Informações do objeto são lidas corretamente.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Indicador de foto visual</title>
<itemizedlist>
<listitem>
<para>Verifique se, ao mover-se entre objetos, o indicador de foco visual é fácil de identificar.</para>
</listitem>
<listitem>
<para>A navegação do teclado através do software e dos menus deve ser claramente visível quando o foco se move.</para>
</listitem>
<listitem>
<para>Confirme se o leitor de tela está rastreando o indicador de foco visual à medida que você navega usando um teclado.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Fontes e texto</title>
<itemizedlist>
<listitem>
<para>Altere a fonte no aplicativo e confirme se as configurações são mantidas.</para>
</listitem>
<listitem>
<para>Teste o aplicativo alterando as cores e confirme que todas as configurações são mantidas.</para>
</listitem>
<listitem>
<para>Se a ampliação estiver disponível, teste a fonte, cor e tamanho usando a opção de ampliação.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Cor e contraste</title>
<itemizedlist>
<listitem>
<para>Imprima capturas de tela em uma impressora a preto e branco e confirme que todas as informações estão visíveis.</para>
</listitem>
<listitem>
<para>Teste aplicativos usando apenas configurações em preto e branco e alto contraste e confirme que todas as informações são transmitidas corretamente.</para>
</listitem>
<listitem>
<para>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).</para>
</listitem>
<listitem>
<para>Ative as configurações de alto contraste no Centro de Controle GNOME e confirme se o aplicativo respeita essas configurações.</para>
</listitem>
<listitem>
<para>Teste vários temas para garantir que o software esteja funcionando para todas as configurações disponíveis.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Áudio</title>
<para>Deve haver uma opção no aplicativo para exibir alertas de áudio visualmente.</para>
<para>Teste se o áudio está funcionando corretamente, ativando o som no Centro de Controle do GNOME e, em seguida, execute as seguintes ações:</para>
<itemizedlist>
<listitem>
<para>Execute uma ação que deve gerar um alerta de áudio e confirme se o aplicativo está funcionando como projetado.</para>
</listitem>
<listitem>
<para>Verifique se o aplicativo funciona corretamente ao aumentar ou diminuir o volume.</para>
</listitem>
<listitem>
<para>Confirme se as mensagens de aviso e alertas podem ser ouvidas corretamente em um ambiente de trabalho ruidoso.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Animação</title>
<para>Verifique se uma opção está disponível para interromper a animação e que está funcionando como projetado.</para>
<para>Desligue a animação. Confirme se todas as informações ainda são transmitidas corretamente.</para>
</section>

<section>
<title>Foco do teclado</title>
<itemizedlist>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>Certifique-se de que uma opção foi incluída para ajustar o tempo de resposta e confirmar que ele está funcionando como projetado.</para>
</listitem>
</itemizedlist>
</section>

<section>
<title>Documentação</title>
<para>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.</para>
<para>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.</para>
<para>Nota: Existem diretrizes de acessibilidade web disponíveis em <ulink url="http://www.w3.org/TR/WAI-WEBCONTENT/">http://www.w3.org/TR/WAI-WEBCONTENT/</ulink>.</para>
<para>Confirme que a seguinte informação está incluída na documentação:</para>
<itemizedlist>
<listitem>
<para>Indique se o aplicativo não oferece suporte ao acesso padrão ao teclado usado pelo sistema operacional.</para>
</listitem>
<listitem>
<para>Identifique se existem comandos de teclado exclusivos.</para>
</listitem>
<listitem>
<para>Identifique quaisquer recursos exclusivos de acessibilidade.</para>
</listitem>
<listitem>
<para>Se uma ação for documentada para o mouse, verifique se há uma alternativa para usar o teclado.</para>
</listitem>
</itemizedlist>
</section>

<section id="gad-checklist">
<title>Lista de verificação de interface de usuário</title>
<para>Essa seção resume as diretrizes dadas em <link linkend="gad-ui-guidelines">Diretrizes de interface de usuário para suporte a acessibilidade</link>. Você deveria acessar aquela seção do guia para informações mais detalhadas em qualquer um dos itens da lista de verificação dada.</para>
<para>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.</para>
<table frame="all" pgwide="1">
<title>Lista de verificação de princípios da gerais</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>PG</entry>
<entry>Princípios gerais</entry>
<entry>Passou/Falhou/ND</entry>
</row>
</thead>
<tbody>
<row>
<entry>PG.1</entry>
<entry>Todas as ações que alteram os dados do usuário ou as configurações do aplicativo podem ser desfeitas.</entry>
</row>
<row>
<entry>PG.2</entry>
<entry>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.</entry>
</row>
<row>
<entry>PG.3</entry>
<entry>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.</entry>
</row>
<row><entry>PG.4</entry>
<entry>As funções mais utilizadas são encontradas no nível superior da estrutura do menu.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Lista de verificação de navegação do teclado</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>NT</entry>
<entry>Navegação do teclado</entry>
<entry>Passou/Falhou/ND</entry>
</row>
</thead>
<tbody>
<row>
<entry>NT.1</entry>
<entry>Um acesso eficiente ao teclado é fornecido a todos os recursos do aplicativo.</entry>
</row>
<row>
<entry>NT.2</entry>
<entry>Todas as janelas possuem uma ordem lógica de navegação no teclado.</entry>
</row>
<row><entry>NT.3</entry>
<entry>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.</entry>
</row>
<row><entry>NT.4</entry>
<entry>O acesso do teclado a funções específicas do aplicativo não substitui os recursos existentes de acessibilidade do sistema.</entry>
</row>
<row><entry>NT.5</entry>
<entry>O aplicativo fornece mais de um método para executar tarefas de teclado sempre que possível.</entry>
</row>
<row><entry>NT.6</entry>
<entry>Existem combinações de teclas alternativas sempre que possível.</entry>
</row>
<row><entry>NT.7</entry>
<entry>Não há abordagens estranhas para operações de teclado realizadas com frequência.</entry>
</row>
<row><entry>NT.8</entry>
<entry>O aplicativo não usa pressionamentos de teclas repetitivos e simultâneos.</entry>
</row>
<row><entry>NT.9</entry>
<entry>O aplicativo fornece equivalentes de teclado para todas as funções do mouse.</entry>
</row>
<row><entry>NT.10</entry>
<entry>Qualquer texto ou objeto que pode ser selecionado com o mouse também pode ser selecionado com o teclado sozinho.</entry>
</row>
<row><entry>NT.11</entry>
<entry>Qualquer objeto que pode ser redimensionado ou movido com o mouse também pode ser redimensionado ou movido com o teclado sozinho.</entry>
</row>
<row><entry>NT.12</entry>
<entry>O aplicativo não usa nenhuma função de navegação geral para ativar operações.</entry>
</row>
<row><entry>NT.13</entry>
<entry>Todos os menus, janelas e dicas de ferramentas invocadas pelo teclado aparecem perto do objeto com o qual se relacionam.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Lista de verificação de interação do mouse</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>IM</entry>
<entry>Interação do mouse</entry>
<entry>Passou/Falhou/ND</entry>
</row>
</thead>
<tbody>
<row><entry>IM.1</entry>
<entry>Nenhuma operação depende da entrada do botão <mousebutton>direito</mousebutton> ou <mousebutton>meio</mousebutton> botões do mouse.</entry>
</row>
<row><entry>IM.2</entry>
<entry>Todas as operações do mouse podem ser canceladas antes de serem concluídas.</entry>
</row>
<row><entry>IM.3</entry>
<entry>O feedback visual é fornecido ao longo das operações de arrastar e soltar</entry>
</row>
<row><entry>IM.4</entry>
<entry>O ponteiro do mouse nunca é alterado sob o controle do aplicativo, ou seu movimento é restrito a parte da tela pelo aplicativo.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Lista de verificação de elementos gráficos</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>EG</entry>
<entry>Elementos gráficos</entry>
<entry>Passou/Falhou/ND</entry>
</row>
</thead>
<tbody>
<row><entry>EG.1</entry>
<entry>Não há atributos gráficos codificados, como a espessura da linha, da borda ou da sombra.</entry>
</row>
<row><entry>EG.2</entry>
<entry>Todos os elementos gráficos multicoloridos podem ser mostrados apenas em monocromático, sempre que possível.</entry>
</row>
<row><entry>EG.3</entry>
<entry>Todos os elementos interativos da interface gráfica são facilmente distinguíveis dos estáticos.</entry>
</row>
<row><entry>EG.4</entry>
<entry>É fornecida uma opção para ocultar gráficos não essenciais.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Lista de verificação de fontes e texto</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>FT</entry>
<entry>Fontes e texto</entry>
<entry>Passou/Falhou/ND</entry>
</row>
</thead>
<tbody>
<row><entry>FT.1</entry>
<entry>Nenhum estilo ou tamanho de fonte é codificado.</entry>
</row>
<row><entry>FT.2</entry>
<entry>É fornecida uma opção para desativar os “backdrops” gráficos por trás do texto.</entry>
</row>
<row><entry>FT.3</entry>
<entry>Todos os rótulos possuem nomes que fazem sentido quando são retirados do contexto.</entry>
</row>
<row><entry>FT.4</entry>
<entry>Nenhum nome de rótulo é usado mais de uma vez na mesma janela.</entry>
</row>
<row><entry>FT.5</entry>
<entry>O posicionamento do rótulo é consistente ao longo do aplicativo.</entry>
</row>
<row><entry>FT.6</entry>
<entry>Todos os rótulos de texto estático que identificam outros controles terminam em dois pontos (:).</entry>
</row>
<row><entry>FT.7</entry>
<entry>Os rótulos de texto estático que identificam outros controles imediatamente precedem esses controles na ordem de tabulação.</entry>
</row>
<row><entry>FT.8</entry>
<entry>Uma alternativa ao WYSIWYG é fornecida. Por exemplo, a capacidade de especificar diferentes fontes de tela e impressora em um editor de texto.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Lista de verificação de cor e contraste</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>CC</entry>
<entry>Cor e contraste</entry>
<entry>Passou/Falhou/ND</entry>
</row>
</thead>
<tbody>
<row><entry>CC.1</entry>
<entry>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.</entry>
</row>
<row><entry>CC.2</entry>
<entry>A cor é usada apenas como um aprimoramento e não como o único meio para transmitir informações ou ações.</entry>
</row>
<row>
<entry>CC.3</entry>
<entry>O aplicativo oferece suporte a todos os temas e configurações de alto contraste disponíveis.</entry>
</row>
<row><entry>CC.4</entry>
<entry>O software não depende de nenhum dos temas ou configurações particulares de alto contraste.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Lista de verificação de ampliação</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>AM</entry>
<entry>Ampliação</entry>
<entry>Passou/Falhou/ND</entry>
</row>
</thead>
<tbody>
<row><entry>AM.1</entry>
<entry>O aplicativo oferece a capacidade de ampliar a área de trabalho.</entry>
</row>
<row><entry>AM.2</entry>
<entry>O aplicativo oferece a opção de dimensionar a área de trabalho.</entry>
</row>
<row><entry>AM.3</entry>
<entry>A funcionalidade do aplicativo não é afetada pela alteração das configurações de ampliação ou escala.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Lista de verificação de áudio</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>AU</entry>
<entry>Áudio</entry>
<entry>Passou/Falhou/ND</entry>
</row>
</thead>
<tbody>
<row><entry>AU.1</entry>
<entry>O som não é usado como o único meio de transmitir qualquer item de informação.</entry>
</row>
<row><entry>AU.2</entry>
<entry>O usuário pode configurar a frequência e o volume de todos os sons e sinais sonoros de aviso.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Lista de verificação de animação</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>AN</entry>
<entry>Animação</entry>
<entry>Passou/Falhou/ND</entry>
</row>
</thead>
<tbody>
<row><entry>AN.1</entry>
<entry>Não há elementos de clarão ou piscantes com uma frequência maior que 2Hz ou inferior a 55Hz.</entry>
</row>
<row><entry>AN.2</entry>
<entry>Qualquer clarão ou piscada esteja confinado a pequenas áreas da tela.</entry>
</row>
<row><entry>AN.3</entry>
<entry>Se a animação é usada, uma opção está disponível para desligá-la antes que ela seja mostrada pela primeira vez.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Lista de verificação de foco de teclado</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>FC</entry>
<entry>Foco do teclado</entry>
<entry>Passou/Falhou/ND</entry>
</row>
</thead>
<tbody>
<row><entry>FC.1</entry>
<entry>Quando uma janela é aberta, o foco começa no controle mais comum.</entry>
</row>
<row><entry>FC.2</entry>
<entry>A posição de foco de entrada atual é claramente exibida em todos os momentos.</entry>
</row>
<row><entry>FC.3</entry>
<entry>O foco de entrada é mostrado exatamente em uma janela em todos os momentos.</entry>
</row>
<row><entry>FC.4</entry>
<entry>O feedback apropriado de áudio ou visual é fornecido quando o usuário tenta navegar após qualquer extremidade de um grupo de objetos relacionados.</entry>
</row>
<row><entry>FC.5</entry>
<entry>O sinal de aviso de áudio ou visual padrão é reproduzido quando o usuário pressiona uma tecla inadequada.</entry>
</row>
<row><entry>FC.6</entry>
<entry>Há informações de áudio suficientes para o foco visual que o usuário pode descobrir o que fazer a seguir.</entry>
</row>
<row><entry>FC.7</entry>
<entry>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.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Lista de verificação de tempo</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>TM</entry>
<entry>Tempo</entry>
<entry>Passou/Falhou/ND</entry>
</row>
</thead>
<tbody>
<row><entry>TM.1</entry>
<entry>Não há tempo limite codificado ou recursos baseados no tempo na aplicação.</entry>
</row>
<row><entry>TM.2</entry>
<entry>A exibição ou o ocultação de informações importantes não são desencadeadas unicamente pelo movimento do ponteiro do mouse.</entry>
</row>
</tbody>
</tgroup>
</table>
<table frame="all" pgwide="1">
<title>Lista de verificação de documentação</title>
<tgroup cols="3" align="left">
<thead>
<row>
<entry>DC</entry>
<entry>Documentação</entry>
<entry>Passou/Falhou/ND</entry>
</row>
</thead>
<tbody>
<row><entry>DC.1</entry>
<entry>Toda a documentação está em um formato acessível, com descrições alternativas de texto fornecidas para todas as figuras e diagramas.</entry>
</row>
<row><entry>DC.2</entry>
<entry>A documentação inclui uma seção que cobre todos os recursos de acessibilidade da aplicação.</entry>
</row>
</tbody>
</tgroup>
</table>
</section>

<section>
<title>GOK (teclado em tela do GNOME)</title>
<note>
<para>A informação nesta página está parcialmente desatualizada: <application><ulink url="http://wiki.gnome.org/Caribou">Caribou</ulink></application> do GNOME 3 substitui com sucesso o <application>gok</application> do GNOME 2.</para>
</note>

<para>Seu aplicativo deve ser usável através do <application>gok</application>; a entrada de tecla deve ser gerada inteiramente pelo <application>gok</application>, 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.</para>
<para>O aplicativo <application>gok</application> vem com o ambiente GNOME, então já deve estar presente. Para a documentação completa, veja o <ulink url="http://www.gok.ca">site oficial do gok</ulink>.</para>
<para>Siga essas etapas para verificar a operação correta do <application>gok</application> com seu aplicativo:</para>
<procedure>
<step>
<para>Inicie uma sessão no ambiente GNOME</para>
</step>
<step>
<para>Execute <application>gok</application></para>
</step>
<step>
<para>Inicie seu aplicativo</para>
</step>
<step>
<para>Forneça entrada ao seu aplicativo com um dispositivo de apontamento (por exemplo, mouse ou tracker principal) e <application>gok</application>.</para>
</step>
<step>
<para>Trabalhe usando os recursos de autocompletamento e previsão de palavras de <application>gok</application>.</para>
</step>
<step>
<para>Verifique se o <application>gok</application> ativa ou desativa os botões de <guibutton>Menus</guibutton> e <guibutton>Barras de ferramentas</guibutton> baseado no tipo de aplicativo que é invocado; por exemplo, os botões de <guibutton>Menus</guibutton> e <guibutton>Barras de ferramentas</guibutton> são desabilitados para o miniaplicativo “Propriedades de fonte”, mas os mesmos botões são ativados para o aplicativo <application>Gedit</application>.</para>
</step>
<step>
<para>Verifique se o teclado em tela do <application>gok</application> fornecido pelo botão <guibutton>Compor</guibutton> pode ser usado para digitar em qualquer texto para o aplicativo selecionado; execute <application>Gedit</application>, clique na área de texto e então clique no botão de <guibutton>Compor</guibutton> no <application>gok</application>. Selecione as teclas necessárias do teclado em tela. Os caracteres devem aparecer na área de texto do <application>Gedit</application>.</para>
</step>
<step>
<para>Verifique se o botão <guibutton>Inicializar</guibutton> permite que o usuário inicie qualquer um dos aplicativos <application>Terminal</application>, <application>Navegador web</application> ou <application>Editor de texto</application>.</para>
</step>
<step>
<para>Verifique se o botão <guibutton>Ativar</guibutton> 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.</para>
</step>
<step>
<para>Verifique se o botão <guibutton>Menus</guibutton> 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 <application>Navegação de ajuda</application> e clique no botão <guibutton>Menus</guibutton>. A janela do <application>GOK</application> agora exibe os botões <guibutton>Arquivo</guibutton>, <guibutton>Ir</guibutton> e <guibutton>Ajuda</guibutton> (os menus do <application>Navegador de ajuda</application>). Clique no botão <guibutton>Arquivo</guibutton> e ele exibe os botões <guibutton>Nova janela</guibutton> e <guibutton>Fechar janela</guibutton> (itens de menu).</para>
</step>
<step>
<para>Verifique se o botão <guibutton>Barras de ferramentas</guibutton> lista todos os botões disponíveis na barra de ferramentas do aplicativo. Por exemplo, clique no aplicativo <application>Navegador de ajuda</application> e clique no botão <guibutton>Barras de ferramentas</guibutton>. A janela <application>GOK</application> agora exibe os botões <guibutton>Voltar</guibutton>, <guibutton>Avançar</guibutton> e <guibutton>Início</guibutton>.</para>
</step>
<step>
<para>Verifique se o botão <guibutton>Capturar UI</guibutton> 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 <guibutton>Capturar UI</guibutton> na janela <application>GOK</application>. A janela do aplicativo <application>GOK</application> deve mostrar os nomes de botões no miniaplicativo – <guibutton>Sans</guibutton>, <guibutton>Sans-serif</guibutton>, <guibutton>Fechar</guibutton> e <guibutton>Ajuda</guibutton>.</para>
</step>
</procedure>
</section>

<section>
<title>Accerciser</title>
<screenshot>
<mediaobject><imageobject> <imagedata fileref="figures/at-arch.png" format="PNG"/> </imageobject> <textobject> <phrase> Accerciser e a arquitetura de acessibilidade do GNOME</phrase> </textobject></mediaobject>
</screenshot>

<para><application>Accerciser</application> é 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. <application>Accerciser</application> 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 <ulink url="http://library.gnome.org/devel/accerciser/stable">no manual oficial do Accerciser </ulink>. Para uma demonstração do <application>Accerciser</application> e <application>PyATSPI</application> (Python-wrappered acesso e uso do AT-SPI), veja <ulink url="http://live.gnome.org/Accessibility/PythonPoweredAccessibility">esse artigo</ulink>. Para uma excelente introdução do autor, veja o artigo intitulado <ulink url="http://www.linuxjournal.com/article/9991">Faça seu aplicativo acessível com Accerciser</ulink>.</para>
<note>
<para><application>Accerciser</application> efetivamente substituiu a antiga ferramenta <application>at-poke</application>.</para>
</note>
</section>

</chapter>

</book>
