]>

<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>

<title>Chamadas de API do ATK comumente usadas</title>

<tgroup cols="2" align="left">

<row>

<entry>API</entry>

<entry>Descrição</entry>

</row>

<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>

</tgroup>

</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, 

                             &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->get_text = myatkimp_mytype_get_text; 

   iface->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", &tinfo, 0); 

      /* Essa classe implementa uma interface ATK_TYPE_TEXT */ 

      g_type_add_interface_static (type, ATK_TYPE_TEXT, 

                                   &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->get_name = myatkimp_mytype_get_name; 

} 

</programlisting>

</example>

</listitem>

<listitem><para>Requer uma função <function>parent->init</function>, <function>parent->notify_gtk</function> ou <function>parent->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->init = myatkimp_mytype_widget_init; 

    parent_class->notify_gtk = myatkimp_mytype_real_notify_gtk; 

    parent_class->finalize = myatkimp_mytype_finalize; 

}

</programlisting>

</example>

<orderedlist>

<listitem>

<para>parent->init</para>

<para>Uma função <function>parent->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->init (widget, gtk_widget); 

   /* Fazer cache de um valor na implementação ATK */ 

   mytype->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->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->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->name, "property-of-interest") == 0) 

   { 

      /* Lida com a alteração de propósito. */ 

   } 

   else 

   { 

      parent_class->notify_gtk (obj, pspec); 

   } 

} 

</programlisting>

</example>

</listitem>

<listitem>

<para>parent->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->cached_value); 

   G_OBJECT_CLASS (parent_class)->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">

<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>