gnome-devel-docs master - en to fr translation catalogue (471 entries)

note: (itstool) path: book/title
en: GNOME Accessibility Developers Guide
fr: Guide d'accessibilité du bureau GNOME pour les développeurs

note: (itstool) path: abstract/para
en: The GNOME Accessibility Guide is for developers who want to ensure their programming efforts are accessible to the widest audience of users. This guide also covers many of the Section 508 requirements.
fr: Le guide d'accessibilité du bureau GNOME est pour les développeurs qui souhaitent s'assurer que leurs programmes sont accessibles au plus grand nombre d'utilisateurs. Ce guide couvre aussi bon nombre des critères de la section 508 (États Unis).

note: (itstool) path: publisher/publishername (itstool) path: revdescription/para
en: GNOME Documentation Project
fr: Projet de documentation GNOME

note: (itstool) path: legalnotice/para
en: Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License (GFDL), Version 1.1 or any later version published by the Free Software Foundation with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. You can find a copy of the GFDL <ulink type="help" url="ghelp:fdl"> here</ulink> or in the file COPYING-DOCS distributed with this manual.
fr: Permission vous est donnée de copier, distribuer et/ou modifier ce document selon les termes de la Licence GNU Free Documentation License (GFDL), Version 1.1 ou ultérieure publiée par la Free Software Foundation sans section inaltérable, sans texte de première page de couverture ni texte de dernière page de couverture. Vous trouverez un exemplaire de cette licence en suivant ce <ulink type="help" url="ghelp:fdl">lien</ulink> ou dans le fichier COPYING-DOCS fourni avec le présent manuel.

note: (itstool) path: legalnotice/para
en: This manual is part of a collection of GNOME manuals distributed under the GFDL. If you want to distribute this manual separately from the collection, you can do so by adding a copy of the license to the manual, as described in Section 6 of the license.
fr: Ce manuel fait partie de la collection de manuels GNOME distribués selon les termes de la licence de documentation libre GNU. Si vous souhaitez distribuer ce manuel indépendamment de la collection, vous devez joindre un exemplaire de la licence au document, comme indiqué dans la section 6 de celle-ci.

note: (itstool) path: legalnotice/para
en: Many of the names used by companies to distinguish their products and services are claimed as trademarks. Where those names appear in any GNOME documentation, and the members of the GNOME Documentation Project are made aware of those trademarks, then the names are in capital letters or initial capital letters.
fr: La plupart des noms utilisés par les entreprises pour distinguer leurs produits et services sont des marques déposées. Lorsque ces noms apparaissent dans la documentation GNOME et que les membres du projet de Documentation GNOME sont informés de l'existence de ces marques déposées, soit ces noms entiers, soit leur première lettre est en majuscule.

note: (itstool) path: listitem/para
en: DOCUMENT IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE DOCUMENT OR MODIFIED VERSION OF THE DOCUMENT IS FREE OF DEFECTS MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY, ACCURACY, AND PERFORMANCE OF THE DOCUMENT OR MODIFIED VERSION OF THE DOCUMENT IS WITH YOU. SHOULD ANY DOCUMENT OR MODIFIED VERSION PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL WRITER, AUTHOR OR ANY CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY DOCUMENT OR MODIFIED VERSION OF THE DOCUMENT IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER; AND
fr: LE PRÉSENT DOCUMENT EST FOURNI « TEL QUEL », SANS AUCUNE GARANTIE, EXPRESSE OU IMPLICITE, Y COMPRIS, ET SANS LIMITATION, LES GARANTIES DE BONNE QUALITÉ MARCHANDE OU D'APTITUDE À UN EMPLOI PARTICULIER OU AUTORISÉ DU DOCUMENT OU DE SA VERSION MODIFIÉE. L'UTILISATEUR ASSUME TOUT RISQUE RELATIF À LA QUALITÉ, À LA PERTINENCE ET À LA PERFORMANCE DU DOCUMENT OU DE SA VERSION DE MISE À JOUR. SI LE DOCUMENT OU SA VERSION MODIFIÉE S'AVÉRAIT DÉFECTUEUSE, L'UTILISATEUR (ET NON LE RÉDACTEUR INITIAL, L'AUTEUR, NI TOUT AUTRE PARTICIPANT) ENDOSSERA LES COÛTS DE TOUTE INTERVENTION, RÉPARATION OU CORRECTION NÉCESSAIRE. CETTE DÉNÉGATION DE RESPONSABILITÉ CONSTITUE UNE PARTIE ESSENTIELLE DE CETTE LICENCE. AUCUNE UTILISATION DE CE DOCUMENT OU DE SA VERSION MODIFIÉE N'EST AUTORISÉE AUX TERMES DU PRÉSENT ACCORD, EXCEPTÉ SOUS CETTE DÉNÉGATION DE RESPONSABILITÉ ; ET

note: (itstool) path: listitem/para
en: UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE AUTHOR, INITIAL WRITER, ANY CONTRIBUTOR, OR ANY DISTRIBUTOR OF THE DOCUMENT OR MODIFIED VERSION OF THE DOCUMENT, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER DAMAGES OR LOSSES ARISING OUT OF OR RELATING TO USE OF THE DOCUMENT AND MODIFIED VERSIONS OF THE DOCUMENT, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES.
fr: EN AUCUNE CIRCONSTANCE ET SOUS AUCUNE INTERPRÉTATION DE LA LOI, QU'IL S'AGISSE D'UN DÉLIT CIVIL (Y COMPRIS LA NÉGLIGENCE), CONTRACTUEL OU AUTRE, L'AUTEUR, LE RÉDACTEUR INITIAL, TOUT PARTICIPANT OU TOUT DISTRIBUTEUR DE CE DOCUMENT OU DE SA VERSION MODIFIÉE, OU TOUT FOURNISSEUR DE L'UNE DE CES PARTIES NE POURRA ÊTRE TENU RESPONSABLE À L'ÉGARD DE QUICONQUE POUR TOUT DOMMAGE DIRECT, INDIRECT, PARTICULIER, OU ACCIDENTEL DE TOUT TYPE Y COMPRIS, SANS LIMITATION, LES DOMMAGES LIÉS À LA PERTE DE CLIENTÈLE, À UN ARRÊT DE TRAVAIL, À UNE DÉFAILLANCE OU UN MAUVAIS FONCTIONNEMENT INFORMATIQUE, OU À TOUT AUTRE DOMMAGE OU PERTE LIÉE À L'UTILISATION DU DOCUMENT ET DE SES VERSIONS MODIFIÉES, MÊME SI LADITE PARTIE A ÉTÉ INFORMÉE DE L'ÉVENTUALITÉ DE TELS DOMMAGES.

note: (itstool) path: legalnotice/para
en: DOCUMENT AND MODIFIED VERSIONS OF THE DOCUMENT ARE PROVIDED UNDER THE TERMS OF THE GNU FREE DOCUMENTATION LICENSE WITH THE FURTHER UNDERSTANDING THAT: <_:orderedlist-1/>
fr: LE PRÉSENT DOCUMENT ET SES VERSIONS MODIFIÉES SONT FOURNIS SELON LES TERMES DE LA LICENCE DE DOCUMENTATION LIBRE GNU SACHANT QUE : <_:orderedlist-1/>

note: (itstool) path: authorgroup/author
en: <firstname>Vincent</firstname> <surname>Alexander</surname> <affiliation> <orgname>GNOME Documentation Project</orgname> </affiliation>
fr: <firstname>Vincent</firstname> <surname>Alexander</surname> <affiliation> <orgname>Projet de documentation GNOME</orgname> </affiliation>

note: (itstool) path: authorgroup/author
en: <firstname>Calum</firstname> <surname>Benson</surname> <affiliation> <orgname>GNOME Documentation Project</orgname> </affiliation>
fr: <firstname>Calum</firstname> <surname>Benson</surname> <affiliation> <orgname>Projet de documentation GNOME</orgname> </affiliation>

note: (itstool) path: authorgroup/author
en: <firstname>Brian</firstname> <surname>Cameron</surname> <affiliation> <orgname>GNOME Documentation Project</orgname> </affiliation>
fr: <firstname>Brian</firstname> <surname>Cameron</surname> <affiliation> <orgname>Projet de documentation GNOME</orgname> </affiliation>

note: (itstool) path: authorgroup/author
en: <firstname>Bill</firstname> <surname>Haneman</surname> <affiliation> <orgname>GNOME Documentation Project</orgname> </affiliation>
fr: <firstname>Bill</firstname> <surname>Haneman</surname> <affiliation> <orgname>Projet de documentation GNOME</orgname> </affiliation>

note: (itstool) path: authorgroup/author
en: <firstname>Padraig</firstname> <surname>O'Briain</surname> <affiliation> <orgname>GNOME Documentation Project</orgname> </affiliation>
fr: <firstname>Padraig</firstname> <surname>O'Briain</surname> <affiliation> <orgname>Projet de documentation GNOME</orgname> </affiliation>

note: (itstool) path: authorgroup/author
en: <firstname>Sharon</firstname> <surname>Snider</surname> <affiliation> <orgname>GNOME Documentation Project</orgname> </affiliation>
fr: <firstname>Sharon</firstname> <surname>Snider</surname> <affiliation> <orgname>Projet de documentation GNOME</orgname> </affiliation>

note: (itstool) path: revhistory/revision
en: <revnumber> GNOME 2.24 Accessibility Developers Guide V2.24.0 </revnumber> <date>September 2008</date> <_:revdescription-1/>
fr: <revnumber> Guide d'accessibilité du bureau GNOME 2.24 pour les développeurs V2.24.0 </revnumber> <date>Septembre 2008</date> <_:revdescription-1/>

note: (itstool) path: bookinfo/releaseinfo
en: This manual describes version 2.24 of the GNOME Desktop.
fr: Ce manuel documente la version 2.24 du bureau GNOME.

note: (itstool) path: legalnotice/title
en: Feedback
fr: Votre avis

note: (itstool) path: legalnotice/para
en: To report a bug or make a suggestion regarding the GNOME Desktop or this manual, follow the directions in the <ulink type="help" url="ghelp:user-guide?feedback">GNOME Feedback Page</ulink>.
fr: Pour rapporter une anomalie ou faire une suggestion concernant le bureau GNOME ou ce manuel, suivez les indications de la <ulink url="ghelp:user-guide?feedback" type="help">Page de réactions sur GNOME</ulink>.

note: (itstool) path: chapter/title
en: What is Accessibility?
fr: Qu'est-ce que I'accessibilité ?

note: (itstool) path: chapter/para
en: Accessibility means helping people with disabilities to participate in substantial life activities. That includes work, and the use of services, products, and information. GNOME includes libraries and a support framework that allow people with disabilities to utilize all of the functionality of the GNOME user environment.
fr: L'accessibilité signifie l'assistance aux personnes handicapées pour qu'elles puissent participer aux activités substantielles de la vie. Cela inclut le travail, l'accès aux services, produits et informations. GNOME inclut des bibliothèques et une structure de prise en charge qui permettent aux personnes ayant des handicaps d'utiliser toutes les fonctionnalités de l'environnement utilisateur GNOME.

note: (itstool) path: chapter/para
en: In conjunction with assistive technologies if necessary - voice interfaces, screen readers, alternate input devices, and so on - people with permanent or temporary disabilities can therefore use the GNOME desktop and applications. Assistive technologies are also useful for people using computers outside their home or office. For example, if you're stuck in traffic, you might use voice input and output to check your email.
fr: En conjonction avec les technologies d'assistance, si nécessaire - interfaces vocales, lecteurs d'écran, périphériques de saisie alternatifs, et ainsi de suite - les personnes souffrant temporairement ou définitivement de handicaps peuvent donc utiliser le bureau GNOME et ses applications. Les technologies d'assistance sont aussi utiles pour les personnes utilisant un ordinateur en dehors de leur bureau ou de leur maison. Par exemple, si vous êtes pris dans un bouchon vous pouvez utiliser la commande vocale pour consulter votre courriel.

note: (itstool) path: chapter/para
en: Assistive technologies receive information from applications via the Accessibility Toolkit (ATK) API, which you can find in the atk module in the GNOME repositories. Because support for the accessibility API is built into the GNOME widgets, your GNOME program should function reasonably well with assistive technologies with no extra work on your part. For example, assistive technologies can automatically read the widget labels that you would normally set in your program anyway (e.g. with GTK function calls such as <function>gtk_label_set_text()</function> or <function>gtk_button_new_with_label()</function>). They can also find out if there is any tooltip text associated with a widget, and use that to describe the widget to the user.
fr: Les technologies d'assistance reçoivent des informations de l'application via l'API Accessibility Toolkit (ATK), que vous pouvez trouver dans le module atk des dépôts GNOME. Comme la prise en charge de l'API est incluse dans les éléments graphiques de GNOME, votre programme devrait fonctionner raisonnablement bien avec les technologies d'assistance sans que vous ayez à faire de travail supplémentaire. Par exemple, les technologies d'assistance peuvent lire automatiquement les étiquettes des éléments graphiques que vous utilisez normalement dans votre programme (par ex. avec des appels de fonctions GTK telles que <function>gtk_label_set_text()</function> ou <function>gtk_button_new_with_label()</function>). Elles peuvent aussi trouver si un texte d'infobulle est associé à un élément graphique et l'utiliser pour décrire l'élément graphique à l'utilisateur.

note: (itstool) path: chapter/para
en: With a little extra effort, however, you can make your program function even more smoothly with assistive technologies. Besides helping individual users, this will also make your product more attractive to government and education markets, many of which now require their applications to be accessible by law.
fr: Avec seulement un petit effort supplémentaire, vous pouvez faire fonctionner votre programme encore mieux grâce aux technologies d'assistance. En plus d'aider les utilisateurs, cela rendra votre programme plus attractif aux marchés gouvernementaux et éducatifs dont la plupart exigent que leurs applications soient légalement accessibles.

note: (itstool) path: section/title
en: Types of Disability
fr: Types de handicaps

note: (itstool) path: section/para
en: In the US alone, there are an estimated 30,000,000 people whose ability to use computers may be compromised by inaccessible design. Globally, around 8% of the people who use the worldwide web have some sort of disability. Disabilities fall into one of these categories:
fr: Il est estimé, rien qu'aux États Unis, qu'il y a 30 000 000 personnes dont la capacité d'accès aux ordinateurs est limitée par une conception non accessible. Globalement approximativement 8% des personnes qui utilisent Internet ont une forme de handicap. Ces handicaps sont classés comme suit :

note: (itstool) path: listitem/para
en: <emphasis>Visual Impairments</emphasis> - these can range from low-vision (including dim or hazy vision, extreme far- or near-sightedness, color-blindness, and tunnel vision, amongst others) to complete blindness. Poor choice of text size and color, and tasks that involve good hand-eye coordination (such as moving the mouse) can cause problems for these users.
fr: <emphasis>Déficience visuelle</emphasis> - Cela va de la mauvaise vue (vue faible ou floue, presbytie ou myopie extrême, daltonisme et rétrécissement du champ visuel entre autres) à la cécité complète. Un mauvais choix de taille de texte et de couleurs et des tâches requérant une bonne coordination main-œil (tel que le déplacement de la souris) peuvent causer des problèmes pour ces utilisateurs.

note: (itstool) path: listitem/para
en: <emphasis>Movement Impairments</emphasis> - users with poor muscle control or weaknesses can find it hard to use a standard keyboard or mouse. For example, they may be unable to hold down two keys simultaneously, or they may be more likely to strike keys accidentally.
fr: <emphasis>Handicaps moteur</emphasis> - Ce sont des utilisateurs qui ont des problèmes de contrôle musculaire ou des faiblesses qui rendent l'utilisation d'un clavier standard et d'une souris difficile. Par exemple, ils peuvent être incapables d'enfoncer deux touches simultanément ou il se peut qu'ils enfoncent des touches accidentellement.

note: (itstool) path: listitem/para
en: <emphasis>Hearing Impairments</emphasis> - these can range from being able to hear some sounds but not distinguish spoken words, to profound deafness. Applications that convey important information by sound alone will cause problems for these users.
fr: <emphasis>Altération auditive</emphasis> - Cela va de la capacité d'entendre certains sons mais pas de distinguer les mots parlés, à la surdité profonde. Les applications qui fournissent des informations importantes uniquement par messages sonores causent des problèmes à ces utilisateurs.

note: (itstool) path: listitem/para
en: <emphasis>Cognitive and Language Impairments</emphasis> - these can range from dyslexia to difficulties remembering things, solving problems or comprehending and using spoken or written language. Complex or inconsistent displays, or poor choice of words can make using computers difficult for these users.
fr: <emphasis>Difficultés d'expression et de raisonnement</emphasis> - Cela va de la dyslexie aux problèmes de mémoire, de résolution de problèmes, de compréhension et d'utilisation du langage écrit ou parlé. Un affichage complexe ou peu cohérent, un mauvais choix de mots peut rendre l'utilisation d'ordinateurs difficile pour ces utilisateurs.

note: (itstool) path: listitem/para
en: <emphasis>Seizure disorders</emphasis> - certain light or sound patterns can cause epileptic seizures in some susceptible users.
fr: <emphasis>Troubles convulsifs</emphasis> - Certains motifs lumineux ou répétitions sonores peuvent causer des crises épileptiques pour les utilisateurs qui y sont sensibles.

note: (itstool) path: section/title
en: How Accessibility Works in GNOME
fr: Fonctionnement de l'accessibilité dans GNOME

note: (itstool) path: section/para
en: The Accessibility Toolkit (ATK) describes a set of interfaces that need to be implemented by GUI components to make them accessible. The interfaces are toolkit-independent - implementations could be written for any widget set, such as GTK, Motif or Qt.
fr: La boîte à outils d'accessibilité (ATK) décrit un jeu d'interfaces qui doivent être implémentées dans les composants de l'interface graphique pour les rendre accessibles. Les interfaces sont indépendantes de la boîte à outils - les implémentations peuvent être écrites pour n'importe quel jeu de d'éléments graphiques, tel que GTK, Motif ou Qt.

note: (itstool) path: section/para
en: Most assistive technologies running on other desktops have historically found it necessary to maintain a complex off-screen model of the desktop applications, based on snooping of OS events, use of unsupported OS and application features and API, and other highly non-portable techniques. This has made assistive technology support somewhat "brittle" and highly OS- and application-specific, even application-version specific. In contrast, on the GNOME Desktop, all the information required by the ATs is provided by the running applications, via the GNOME Accessibility Framework, to a toolkit-independent Service Provider Interface (SPI). The SPI provides a means for UNIX-based ATs, such as screen readers and screen magnifiers, to obtain accessibility information from running applications via a consistent, stable API, and can eliminate the need for an off-screen model in many cases. Accessibility support for applications is "built in" to application toolkits via toolkit-appropriate APIs (for instance, ATK for most native C applications and the Java Accessibility API for Java apps), and exported to the common "AT-SPI" interface via the relevant "bridge" (see diagram below).
fr: La plupart des technologies d'assistance utilisées par d'autres bureaux ont historiquement nécessité de maintenir des modèles hors écran complexes des applications du bureau, basés sur la capture d'évènements du système d'exploitation (SE), l'utilisation de fonctionnalités et d'API non prises en charge par le SE et les applications, ainsi que d'autres techniques non transférables. Cela rend la prise en charge des technologies d'assistance quelque peu « fragile » et très spécifique au SE et aux applications. Par contraste, pour le bureau GNOME, toutes les informations nécessaires aux technologies d'assistance sont fournies par les applications en fonctionnement, via la boîte à outils d'accessibilité de GNOME, vers l'interface de fournisseur de services (Service Provider Interface : SPI) de la boîte à outils indépendante. L'interface SPI fournit les moyens aux technologies d'assistance basées sur UNIX, telles que les lecteurs d'écran et les loupes, d'obtenir les informations d'accessibilités depuis les applications en fonctionnement via une API stable et homogène, et peut éliminer le besoin d'un modèle hors écran dans de nombreux cas. La prise en charge des applications est « intégrée » dans les boîtes à outils via les API appropriées (par exemple, ATK pour la plupart des applications natives en C et l'API Java Accessibility pour les applications Java) et exportée vers l'interface « AT-SPI » commune via le « pont » correspondant (voir le diagramme ci-dessous).

note: (itstool) path: figure/title
en: GNOME Accessibility Architecture
fr: Architecture de l'accessibilité de GNOME

note: (itstool) path: figure/mediaobject
en: <imageobject> <imagedata fileref="figures/GNOME_desktop_Accessibility.png" format="PNG"/> </imageobject> <textobject> <phrase>Diagram of GNOME's accessibility architecture</phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/GNOME_desktop_Accessibility.png" format="PNG"/> </imageobject> <textobject> <phrase>Diagramme de l'architecture d'accessibilité de GNOME</phrase> </textobject>

note: (itstool) path: section/para
en: GNOME's built-in accessibility support means that applications created using stock GNOME widgets get support for assistive technologies "for free", provided the widgets are not used in unusual ways which conflict with this built-in support.
fr: La prise en charge intégrée des technologies d'assistance par GNOME signifie que les applications créées en utilisant les éléments graphiques du magasin GNOME bénéficient de la prise en charge de ces technologies « gratuitement », à condition que l'utilisation des éléments graphiques ne soit pas en conflit avec la prise en charge intégrée.

note: (itstool) path: section/para
en: A gtk+/GNOME widget is accessible if its use follows the general accessibility guidelines elsewhere in this document, and it implements the ATK interfaces appropriate to its role in the user interface. ATK implementations are provided for the "stock" GNOME toolkit widgets (i.e. non-deprecated gtk+ and GNOME widgets), and in many cases new widgets which derive trivially from existing GTK+ or GNOME widgets will also inherit suitable accessibility support.
fr: Un élément graphique gtk+/GNOME est accessible si son utilisation suit les directives générales d'accessibilité décrites dans ce document, et que les interfaces ATK appropriées à son role sont implémentées dans l'interface utilisateur. Les implémentations ATK sont fournies pour les éléments graphiques de la boîte à outils du « magasin » de GNOME (par ex. les éléments graphiques non abandonnés de gtk+ et GNOME) et dans de nombreux cas, les nouveaux éléments graphiques qui sont de simples dérivés d'éléments graphiques GTK+ ou GNOME, héritent également d'une prise en charge d'accessibilité convenable.

note: (itstool) path: section/para
en: If your application uses custom widgets, you may have to do some work to expose those widgets' properties to assistive technologies. See <link linkend="gad-custom">Making Custom Components Accessible</link> and <link linkend="gad-api-examples">Examples that Use the Accessibility API</link> for more information.
fr: Si votre application utilise des éléments graphiques personnalisés, vous allez sûrement devoir faire un peu de travail pour fournir les propriétés de ces éléments graphiques aux technologies d'assistance. Pour plus d'informations, consultez la section <link linkend="gad-custom">rendre les composants personnalisés accessibles</link> et les <link linkend="gad-api-examples">exemples d'utilisation de l'API d'accessibilité</link>.

note: (itstool) path: section/para
en: For additional, in-depth information regarding GTK/GTK+, see the <ulink url="http://library.gnome.org/devel/gtk">GTK+ Reference Manual</ulink>, <ulink url="http://live.gnome.org/GAP/AtkGuide/Gtk">the GTK section of the ATK Guide</ulink>, the GNOME-hosted <ulink url="http://library.gnome.org/devel/gtk-tutorial/stable/">GTK+ 2.0 Tutorial</ulink> and the official <ulink url="http://library.gnome.org/devel/gtk-faq/stable/">GTK+ FAQ</ulink>.
fr: Pour des informations supplémentaires plus détaillées sur GTK/GTK+, consultez le <ulink url="http://library.gnome.org/devel/gtk">manuel de référence de GTK+</ulink>, la <ulink url="http://live.gnome.org/GAP/AtkGuide/Gtk">section GTK du guide de ATK</ulink>, le <ulink url="http://library.gnome.org/devel/gtk-tutorial/stable/">tutoriel GTK+ 2.0</ulink> hébergé par GNOME et la <ulink url="http://library.gnome.org/devel/gtk-faq/stable/">FAQ GTK+</ulink> officielle.

note: (itstool) path: section/title
en: Developer Quick Start
fr: Démarrage rapide pour le développeur

note: (itstool) path: section/para
en: Here are some common starting points:
fr: Voici quelques points de départ courants :

note: (itstool) path: section/title
en: How do I check to see if my application is accessible or not?
fr: Comment vérifier que mon application est accessible ?

note: (itstool) path: section/title
en: What are the common pitfalls?
fr: Pièges à éviter

note: (itstool) path: section/para
en: The <link linkend="gad-checklist">User Interface Checklist</link> covers all the areas that sometimes get overlooked in the design stage.
fr: La <link linkend="gad-checklist">liste de contrôle de l'interface utilisateur</link> couvre toutes les zones qui sont parfois oubliées lors de la phase de conception.

note: (itstool) path: section/title
en: How do I do common ATK things?
fr: Comment réaliser les fonctions ATK courantes ?

note: (itstool) path: section/para
en: An abbreviated listing of common ATK calls can be found <link linkend="gad-api">here</link>.
fr: Une liste abrégée des appels ATK courants se trouve <link linkend="gad-api">ici</link>.

note: (itstool) path: section/title
en: How do I do more complex ATK things?
fr: Comment réaliser les fonctions ATK plus complexes ?

note: (itstool) path: section/para
en: See <link linkend="gad-custom">Making Custom Components Accessible</link> and <link linkend="gad-api-examples">Examples that Use the Accessibility API</link> for more information.
fr: Pour plus d'informations, consultez la section <link linkend="gad-custom">rendre les composants personnalisés accessibles</link> et les <link linkend="gad-api-examples">exemples d'utilisation de l'API d'accessibilité</link>.

note: (itstool) path: section/title
en: Introducing ATK, AT-SPI, GAIL and GTK+
fr: Introduction à ATK, AT-SPI, GAIL et GTK+

note: (itstool) path: screenshot/mediaobject
en: <imageobject> <imagedata fileref="figures/gaa.jpg"/> </imageobject> <textobject> <phrase> GNOME Accessibility Architecture </phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/gaa.jpg"/> </imageobject> <textobject> <phrase> Architecture de l'accessibilité de GNOME </phrase> </textobject>

note: (itstool) path: section/para
en: AT-SPI is the primary service interface by which assistive technologies query and receive notifications from running applications. The full API can be explored <ulink url="http://library.gnome.org/devel/at-spi-cspi/stable/">here</ulink>. Additional material is available from <ulink url="http://accessibility.kde.org/developer/atk.php#coreclasses">the KDE Accessibility Development Community</ulink>.
fr: AT-SPI est l'interface de service principale par laquelle les technologies d'assistance effectuent leurs requêtes et reçoivent les notifications des applications en fonctionnement. L'API complète peut être explorée <ulink url="http://library.gnome.org/devel/at-spi-cspi/stable/">ici</ulink>. Plus d'informations sont disponibles via <ulink url="http://accessibility.kde.org/developer/atk.php#coreclasses">la communauté de développement de l'accessibilité KDE</ulink>.

note: (itstool) path: section/para
en: GAIL (GNOME Accessibility Implementation Library) is an implementation of the accessibility interfaces defined by ATK. GTK is a toolkit which is already mapped to ATK by the GAIL module. License, download and other information can be found <ulink url="http://www.t2-project.org/packages/gail.html">here</ulink>. The <ulink url="ftp://ftp.gnome.org/pub/GNOME/sources/gail/">GAIL source code</ulink> also serves as an excellent tutorial for advanced ATK usage. In addition, you may be interested in the <ulink url="http://library.gnome.org/devel/gail-libgail-util/stable/">GAIL Reference Manual</ulink>.
fr: GAIL (GNOME Accessibility Implementation Library) est une implémentation des interfaces d'accessibilité définies par ATK. GTK est une boîte à outils qui est déjà liée à ATK par le module GAIL. La licence, la procédure de téléchargement et d'autres informations sont disponibles <ulink url="http://www.t2-project.org/packages/gail.html">ici</ulink>. Le <ulink url="ftp://ftp.gnome.org/pub/GNOME/sources/gail/">code source de GAIL</ulink> est aussi un excellent tutoriel pour une utilisation avancée d'ATK. De plus, vous pouvez être intéressé par le <ulink url="http://library.gnome.org/devel/gail-libgail-util/stable/">manuel de référence de GAIL</ulink>.

note: (itstool) path: section/para
en: GTK+ is a library for creating graphical user interfaces. It works on many UNIX-like platforms, Windows, and on framebuffer devices. GTK+ is released under the GNU Library General Public License (GNU LGPL), which allows for flexible licensing of client applications. GTK+ has a C-based object-oriented architecture that allows for maximum flexibility. Bindings for other languages have been written, including C++, Objective-C, Guile/Scheme, Perl, Python, TOM, Ada95, Free Pascal, and Eiffel.
fr: GTK+ est une bibliothèque utilisée pour créer des interfaces graphiques. Elle fonctionne avec de nombreuses plateformes de type UNIX, Windows et avec des consoles graphiques. GTK+ est distribuée sous la licence de bibliothèque publique générale GNU (GNU LGPL), qui est une licence d'utilisation flexible pour les applications clientes. L'architecture de GTK+ se base sur le langage C orienté objet, qui permet une flexibilité maximum. Des liaisons vers d'autres langages existent pour le C++, Objective-C, Guile/Scheme, Perl, Python, TOM, Ada95, Free Pascal et Eiffel.

note: (itstool) path: section/title
en: Making a GNOME Application Accessible - Overview
fr: Rendre une application GNOME accessible - aperçu

note: (itstool) path: section/para
en: If your application only uses standard GTK widgets, you will probably have to do little or nothing to make your application (reasonably) accessible. But do watch out for objects in your GUI that don't have a textual description associated with them, such as graphical buttons or status indicators that don't have labels or tooltips.
fr: Si votre application n'utilise que des éléments graphiques GTK standards, vous aurez peu ou pas de travail pour que votre application soit (raisonnablement) accessible. Mais faites attention aux objets dans votre GUI qui n'ont pas de texte de description associé, tel que des boutons graphiques ou des indicateurs d'état qui n'ont pas d'étiquette ou d'infobulle.

note: (itstool) path: section/para
en: If your application uses custom widgets, you may have to do some work to expose those widgets' properties to assistive technologies. See <link linkend="gad-custom">Making Custom Components Accessible</link> and <link linkend="gad-api-examples">Examples that Use the Accessibility API</link> for more information. Additional detailed information can be found in Marc Mulcahy's 2002 GUADEC presentation, <ulink url="https://projects.gnome.org/accessibility/talks/GUAD3C/making-apps-accessible/start.html">"Making GNOME Applications Accessible".</ulink>
fr: Si votre application utilise des éléments graphiques personnalisés, vous allez sûrement devoir travailler un peu pour rendre leurs propriétés visibles par les technologies d'assistance. Pour plus d'informations, consultez la section pour <link linkend="gad-custom">rendre les composants personnalisés accessibles</link> et les <link linkend="gad-api-examples">exemples d'utilisation de l'API d'accessibilité</link>. Des informations plus détaillées peuvent être trouvées dans la présentation de Marc Mulcahy au GUADEC 2002 : « <ulink url="https://projects.gnome.org/accessibility/talks/GUAD3C/making-apps-accessible/start.html">Rendre les applications GNOME accessibles</ulink> ».

note: (itstool) path: section/title
en: Coding Guidelines for Supporting Accessibility
fr: Directives de codage pour la prise en charge de l'accessibilité

note: (itstool) path: section/para
en: Here are some things you can do in your code to make your program work as well as possible with assistive technologies. (You can find a list of things to consider when designing your GUI in the <link linkend="gad-ui-guidelines">User Interface Guidelines for Supporting Accessibility</link> section later in this document):
fr: Voici plusieurs choses que vous pouvez faire pour que votre programme fonctionne au mieux avec les technologies d'assistance (vous trouverez une liste des choses à considérer lorsque vous concevez votre GUI dans la section sur les <link linkend="gad-ui-guidelines">directives pour la prise en charge de l'accessibilité dans l'interface utilisateur</link> plus loin dans ce document) :

note: (itstool) path: listitem/para
en: For components that don't display a short string (such as a graphical button), specify a name for it with <function>atk_object_set_name()</function>. You might want to do this for image-only buttons, panels that provide logical groupings, text areas, and so on.
fr: Pour les composants qui n'affichent pas de chaîne de texte courte (tel qu'un bouton graphique), donnez lui un nom avec la fonction <function>atk_object_set_name()</function>. Vous pourriez utiliser cette fonction pour les boutons qui n'affichent qu'une image, les panneaux qui regroupent des fonctions de manière logique, les zones de texte...

note: (itstool) path: listitem/para
en: If you can't provide a tooltip for a component, use <function>atk_object_set_description()</function> instead to provide a description that assistive technologies can give the user. For example, to provide an accessible description for a <guibutton>Close</guibutton> button:
fr: Si vous ne pouvez pas fournir d'infobulle pour un composant, utilisez la fonction <function>atk_object_set_description()</function> à la place pour fournir une description que les technologies d'assistance peuvent renvoyer à l'utilisateur. Par exemple, pour fournir une description accessible pour un bouton <guibutton>Fermer</guibutton> :

note: (itstool) path: example/title
en: Providing an accessible description for a GtkButton
fr: Description accessible pour un bouton GtkButton

note: (itstool) path: example/programlisting
en: 
    {
      AtkObject *obj;
      obj = gtk_widget_get_accessible(button);
      atk_object_set_description(obj,_("Closes the window"));
    }
fr: 
    {
      AtkObject *obj;
      obj = gtk_widget_get_accessible(button);
      atk_object_set_description(obj,_("Ferme la fenêtre"));
    }

note: (itstool) path: listitem/para
en: Use <function>atk_image_set_description()</function> to provide a text description for all images and icons in your program.
fr: Utilisez la fonction <function>atk_image_set_description()</function> pour fournir le texte de description pour toutes les images et icônes de votre programme.

note: (itstool) path: listitem/para
en: If several components form a logical group, try to put them in one container.
fr: Si plusieurs composants forment un groupe logique, essayez de les mettre dans un même conteneur.

note: (itstool) path: listitem/para
en: Whenever you have a label that describes another component, use <function>atk_relation_set_add_relation()</function> so that assistive technologies can find the component with which the label is associated. (If you associate the label with the component using <function>gtk_label_set_mnemonic_widget()</function>, the <constant>ATK_RELATION_LABEL_FOR</constant> relation is generated automatically, so the following code would not be necessary):
fr: Quand vous avez une étiquette qui décrit un autre composant, utilisez la fonction <function>atk_relation_set_add_relation()</function> pour que les technologies d'assistance puissent trouver le composant associé à cette étiquette (si vous associez l'étiquette au composant avec la fonction <function>gtk_label_set_mnemonic_widget()</function>, la relation <constant>ATK_RELATION_LABEL_FOR</constant> est générée automatiquement, donc le code suivant n'est plus nécessaire) :

note: (itstool) path: example/title
en: Relating a GtkLabel to a GtkWidget
fr: Lien entre un GtkLabel et un GtkWidget

note: (itstool) path: listitem/para
en: If you create a custom widget, make sure it supports accessibility. Custom components that are descendants of other GTK widgets should override inherited accessibility information as necessary. For more information, see <link linkend="gad-custom">Making Custom Components Accessible</link>.
fr: Si vous créez un élément graphique personnalisé, assurez-vous qu'il prend en charge l'accessibilité. Les composants personnalisés qui sont des descendants d'éléments graphiques GTK doivent remplacer les informations d'accessibilité héritées quand c'est nécessaire. Pour plus d'informations, consultez la section pour <link linkend="gad-custom">rendre les composants personnalisés accessibles</link>.

note: (itstool) path: listitem/para
en: Don't break what you get for free! If your GUI has an inaccessible container, any components inside that container may become inaccessible.
fr: Ne cassez pas ce que vous pouvez obtenir sans effort ! Si votre GUI contient un conteneur inaccessible, tous les composants qu'il contient, risquent de l'être aussi.

note: (itstool) path: section/title
en: The Accessibility API
fr: API d'accessibilité

note: (itstool) path: section/para
en: Here are a few of the basic API calls you may need to use in your application to ensure it works well with assistive technologies. The full accessibility API is extensive, to allow you to write your own accessible custom widgets, for example.
fr: Voici quelques-uns des appels de base à l'API dont vous pouvez avoir besoin dans votre application pour vous assurer qu'elle fonctionne correctement avec les technologies d'assistance. L'API d'accessibilité complète est vaste pour vous permettre d'écrire vos propres éléments graphiques accessibles personnalisés.

note: (itstool) path: table/title
en: Commonly used ATK API calls
fr: Appels à l'API ATK couramment utilisés

note: (itstool) path: entry/para
en: Returns the accessible object that describes the specified GTK widget to an assistive technology.
fr: Renvoie l'objet accessible qui décrit l'élément graphique GTK spécifié, vers une technologie d'assistance.

note: (itstool) path: entry/para
en: Sets the name of the accessible object. For example, if the object is a graphical button that quits the application when pressed, the name might be "Quit".
fr: Définit le nom de l'objet accessible. Par exemple, si l'objet est un bouton graphique qui permet de quitter l'application quand on clique dessus, le nom peut être « Quitter ».

note: (itstool) path: entry/para
en: Sets the textual description of the accessible object. For example, if the object is a graphical "Close" button, the description might be "Closes the window".
fr: Définit le texte de description de l'objet accessible. Par exemple, si l'objet est un bouton graphique « Fermer », la description peut être « Ferme la fenêtre ».

note: (itstool) path: entry/para
en: Creates a new relation between the specified key and the specified list of target objects. A relationship normally indicates to the assistive technology that one widget is somehow related to another. For example, that a particular GtkLabel widget is the caption for a GtkTreeView in the same window.
fr: Crée une nouvelle relation entre la clé spécifiée et la liste d'objets cibles spécifiée. Une relation indique normalement à la technologie d'assistance qu'un élément graphique est connecté à un autre. Par exemple, un élément graphique GtkLabel particulier est la légende d'un élément graphique GtkTreeView dans la même fenêtre.

note: (itstool) path: entry/para
en: Sets the textual description of the accessible image object. For example, if the object is a thumbnail of a virtual desktop in a panel applet, the description might be "Image showing window arrangement on desktop 1".
fr: Définit le texte de description d'un objet image accessible. Par exemple, si l'objet est une miniature d'un bureau virtuel dans une applet de tableau de bord, la description peut être « Image montrant l'arrangement des fenêtres sur le bureau 1 ».

note: (itstool) path: section/title
en: Examples that Use the Accessibility API
fr: Exemples d'utilisation de l'API d'accessibilité

note: (itstool) path: section/para
en: As noted earlier, you should have little or no work to do to make your application accessible if you use the GTK widget set, or any other widget library that implements the ATK interfaces. The two most common things you may have to do in this case are:
fr: Comme remarqué plus tôt, vous avez peu ou pas de travail à faire pour rendre votre application accessible si vous utilisez les éléments graphiques de GTK, ou n'importe quel élément graphique provenant de bibliothèques qui implémentent les interfaces ATK. Les deux choses les plus courantes que vous allez faire dans ce cas sont :

note: (itstool) path: listitem/para
en: provide descriptions of some controls and images using <function>atk_object_set_description()</function> or <function>atk_image_set_description():</function>
fr: fournir des descriptions pour certains contrôles et images avec les fonctions <function>atk_object_set_description()</function> ou <function>atk_image_set_description()</function> :

note: (itstool) path: example/title
en: Setting the accessible description for a button
fr: Définition de la description d'accessibilité pour un bouton

note: (itstool) path: example/programlisting
en: 
    {
       AtkObject *obj;
       obj = gtk_widget_get_accessible(button);
       atk_object_set_description(obj,_("Opens Preferences dialog"));
    }
fr: 
    {
       AtkObject *obj;
       obj = gtk_widget_get_accessible(button);
       atk_object_set_description(obj,_("Ouvre la boîte de dialogue Préférences"));
    }

note: (itstool) path: listitem/para
en: Specify relationships between any unusual groupings of widgets using <function>atk_relation_new()</function> and <function>atk_relation_set_add()</function>:
fr: spécifier des relations entre tout regroupement inhabituel d'éléments graphiques en utilisant les fonctions <function>atk_relation_new()</function> et <function>atk_relation_set_add()</function> :

note: (itstool) path: example/title
en: Specifying accessible relationship between two controls
fr: Spécification des relations d'accessibilité entre deux contrôles

note: (itstool) path: section/para
en: The examples in the rest of this section are mostly to give you a flavor of the scope of the ATK. They cover techniques that you may never need to use as an application developer, although they may be of interest if you are writing your own custom widgets (see <link linkend="gad-custom">Making Custom Components Accessible</link>) or if you want to write an assistive technology application. Whatever the purpose, the <ulink url="ftp://ftp.gnome.org/pub/GNOME/sources/gail/">GAIL source code</ulink> serves as an excellent tutorial for advanced ATK usage. Please note that since GTK+ 3.1.10, Gail has been merged into GTK+ and is no longer a module on its own.
fr: Les exemples dans la suite de cette section, vont vous donner un aperçu de l'étendue d'ATK. Ils couvrent des techniques dont vous pouvez ne jamais avoir besoin en tant que développeur d'application, bien qu'elles puissent vous intéresser si vous écrivez vos propres éléments graphiques personnalisés (consultez la section pour <link linkend="gad-custom">rendre vos composants personnalisés accessibles</link>) ou si vous voulez écrire une application de technologie d'assistance. Quel que soit votre but, le <ulink url="ftp://ftp.gnome.org/pub/GNOME/sources/gail/">code source de GAIL</ulink> est un excellent tutoriel pour une utilisation avancée d'ATK. Notez que depuis GTK+ 3.1.10, le module Gail a été fusionné dans GTK+ et n'existe plus seul.

note: (itstool) path: section/title
en: Gtk Modules
fr: Modules Gtk

note: (itstool) path: section/para
en: Programs that make use of GAIL (the accessibility implementation library for GTK widgets) are written as GTK modules. GTK modules are loaded into the program space if the <varname>GTK_MODULES</varname> environment variable specifies the module library name(s). If there are multiple module libraries, separate them with colons. For example:
fr: Les programmes qui utilisent GAIL (la bibliothèque d'implémentation d'accessibilité pour les éléments graphiques GTK) sont écrits sous la forme de modules GTK. Les modules GTK sont chargés dans l'espace du programme si la variable d'environnement <varname>GTK_MODULES</varname> spécifie le(s) nom(s) de la bibliothèque de module. S'il y a plusieurs bibliothèques de modules, séparez-les par des deux-points. Par exemple :

note: (itstool) path: section/para
en: All GTK modules have a <function>gtk_module_init()</function> function.
fr: Tous les modules GTK possèdent une fonction <function>gtk_module_init()</function>.

note: (itstool) path: section/title
en: Gathering accessibility information from an application
fr: Collecte des informations d'accessibilité depuis une application

note: (itstool) path: section/para
en: A program that wishes to make use of ATK calls would likely need to do one (or more) of the following things:
fr: Un programme qui souhaite utiliser des appels ATK doit faire une (ou plusieurs) des actions suivantes :

note: (itstool) path: listitem/para
en: Create an event watcher, for example with the <function>atk_add_focus_tracker()</function> function:
fr: Créer un moniteur d'évènement, par exemple avec la fonction <function>atk_add_focus_tracker()</function> :

note: (itstool) path: listitem/programlisting
en: atk_add_focus_tracker (_my_focus_tracker);
fr: atk_add_focus_tracker (_mon_moniteur_evenement);

note: (itstool) path: listitem/para
en: where <function>_my_focus_tracker()</function> is a function with this prototype:
fr: où <function>_mon_moniteur_evenement()</function> est une fonction qui utilise ce prototype :

note: (itstool) path: listitem/programlisting
en: void _my_focus_tracker (AtkObject *aobject);
fr: void _mon_moniteur_evenement (AtkObject *aobject);

note: (itstool) path: listitem/para
en: Set up a global event listener, with atk_add_global_event_listener():
fr: Définir un auditeur d'évènements global avec la fonction atk_add_global_event_listener() :

note: (itstool) path: listitem/programlisting
en: 
    mouse_watcher_focus_id =   atk_add_global_event_listener(_my_global_listener,"Gtk:GtkWidget:enter_notify_event");
fr: 
    mouse_watcher_focus_id =   atk_add_global_event_listener(_mon_auditeur_global,"Gtk:GtkWidget:enter_notify_event");

note: (itstool) path: listitem/para
en: where <function>_my_global_listener</function> has the prototype of a Glib <type>GSignalEmissionHook</type>. This example would cause the <function>_my_global_listener()</function> to be called whenever an enter_notify_even signal occurs on a <type>GtkWidget</type> object.
fr: où <function>_mon_auditeur_global</function> contient le prototype Glib <type>GSignalEmissionHook</type>. Cet exemple fait en sorte que la fonction <function>_mon_auditeur_global()</function> soit appelée quand un signal enter_notify_even se produit sur un objet <type>GtkWidget</type>.

note: (itstool) path: listitem/para
en: Access the ATK top-level object with the following function call.
fr: Accéder aux objets de niveau supérieur d'ATK avec l'appel de fonction suivant :

note: (itstool) path: section/title
en: Querying an <type>AtkObject</type>'s Interfaces
fr: Requête d'interfaces d'un <type>AtkObject</type>

note: (itstool) path: section/para
en: Having located the <type>AtkObject</type> associated with an object in the application (e.g. by using <function>gtk_widget_get_accessible()</function>), you can find out what interfaces it implements in various ways:
fr: Après avoir localisé l'objet <type>AtkObject</type> associé avec un objet dans l'application (par ex. avec la fonction <function>gtk_widget_get_accessible()</function>), vous pouvez trouver quelles interfaces il implémente de plusieurs façons :

note: (itstool) path: listitem/para
en: Use the supplied <function>ATK_IS_...</function> macros, for example:
fr: Utilisez les macros <function>ATK_IS_...</function> fournies, par exemple :

note: (itstool) path: listitem/para
en: etc. (there is one for each interface)
fr: etc. (il y en a une pour chaque interface)

note: (itstool) path: listitem/para
en: If the macro returns <function>TRUE</function>, the interface calls can safely be made on that ATK object.
fr: Si la macro renvoie <function>TRUE</function> (VRAI), les appels de l'interface peuvent être effectués sans problème sur cet objet ATK.

note: (itstool) path: listitem/para
en: Test the role of the <type>AtkObject</type> by calling <function>atk_object_get_role()</function>. Any given role implements a specific number of ATK APIs.
fr: Testez le rôle de l'objet <type>AtkObject</type> en appelant la fonction <function>atk_object_get_role()</function>. Chacun des rôles obtenus implémente un numéro spécifique d'API ATK.

note: (itstool) path: section/title
en: Setting up an ATK Signal Handler
fr: Configuration d'un gestionnaire de signal ATK

note: (itstool) path: section/para
en: Using the <constant>column_inserted</constant> signal as an example:
fr: Utilisez le signal <constant>column_inserted</constant> comme exemple :

note: (itstool) path: section/programlisting
en: 
    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);
fr: 
    table_column_inserted_id = g_signal_connect_closure_by_id (mon_obj_atk, 
    g_signal_lookup("column_inserted", G_OBJECT_TYPE(mon_obj_atk)), 0, 
    g_cclosure_new(G_CALLBACK (_ma_fonct_tableau_colonne_inseree), NULL, NULL), FALSE);

note: (itstool) path: section/para
en: This will cause <function>_my_table_column_inserted_func()</function> to be called whenever a column_inserted signal is emitted on the <type>AtkObject</type> <varname>my_atk_object</varname>.
fr: La fonction <function>_ma_fonct_tableau_colonne_inseree()</function> est alors appelée à chaque fois qu'un signal column_inserted est émis sur l'objet <type>AtkObject</type> <varname>mon_obj_atk</varname>.

note: (itstool) path: section/para
en: Connecting to a signal is slightly different if the signal supports detail. The <constant>children_changed</constant> signal supports the <parameter>add</parameter> detail. To connect to a signal when the <parameter>add</parameter> detail is also specified, this technique is used:
fr: La connexion à un signal est un peu différente si le signal prend en charge les détails. Le signal <constant>children_changed</constant> prend en charge le détail <parameter>add</parameter>. Pour se connecter à un signal quand le détail <parameter>add</parameter> est aussi spécifié, cette technique est utilisée :

note: (itstool) path: section/title
en: Implementing an ATK Object
fr: Implémentation d'un objet ATK

note: (itstool) path: section/para
en: You will need to implement your own ATK objects for any widgets that do not already have an accessible implementation in GAIL (or the equivalent library for other widget sets). This should be implemented as a GTK module, which, as before, should be included in the <envar>GTK_MODULES</envar> environment variable so it is loaded at runtime.
fr: Vous devrez implémenter vos propres objets ATK pour tous les éléments graphiques qui n'ont pas déjà une implémentation accessible dans GAIL (ou la bibliothèque équivalente pour d'autres jeux d'éléments graphiques). Vous devez implémenter ceci sous la forme d'un module GTK, qui, comme précédemment, doit être inclus dans la variable d'environnement <envar>GTK_MODULES</envar> afin qu'il soit chargé au lancement.

note: (itstool) path: section/title
en: Registry
fr: Registre

note: (itstool) path: section/para
en: For this example we will assume there is an object called GTK_TYPE_MYTYPE. The ATK implementation will be called <type>MYATKIMP_TYPE_MYTYPE</type>. A factory will be needed which will be called <type>MYATKIMP_TYPE_MYTYPE_FACTORY</type>.
fr: Dans cet exemple nous allons supposer qu'il existe un objet appelé GTK_TYPE_MONTYPE. L'implémentation ATK est appelée <type>MON_IMP_ATK_TYPE_MONTYPE</type>. Une fabrique est nécessaire et est appelée <type>MON_IMP_ATK_TYPE_MONTYPE_FABRIQUE</type>.

note: (itstool) path: section/para
en: To register an ATK implementation of a GTK object, these steps must be followed in the module's <function>gtk_module_init()</function> function:
fr: Pour enregistrer l'implémentation ATK d'un objet GTK, les étapes suivantes doivent être suivies dans la fonction <function>gtk_module_init()</function> du module :

note: (itstool) path: listitem/para
en: Access the default registry:
fr: Accès au registre par défaut :

note: (itstool) path: listitem/para
en: Register the ATK object in the <function>gtk_module_init()</function> function of this module by making this function call:
fr: Enregistrement de l'objet ATK dans la fonction <function>gtk_module_init()</function> de ce module à l'aide de l'appel de fonction suivant :

note: (itstool) path: section/para
en: This will register the AtkObject implementation of <type>GTK_TYPE_MYTYPE</type> to <type>MYATKIMP_TYPE_MYTYPE_FACTORY</type>. This factory will be implemented so that it knows how to build objects of type <type>MYATKIMP_TYPE_MYTYPE</type>.
fr: Cela enregistre l'implémentation de l'AtkObject de <type>GTK_TYPE_MONTYPE</type> dans <type>MON_IMP_ATK_TYPE_MONTYPE_FABRIQUE</type>. Cette fabrique sera implémentée afin qu'elle sache construire les objets de type <type>MON_IMP_ATK_TYPE_MONTYPE</type>.

note: (itstool) path: section/title
en: Factory
fr: Fabrique

note: (itstool) path: section/para
en: The factory must be implemented as a child of class type <type>ATK_TYPE_OBJECT_FACTORY</type> and must implement the function <function>create_accessible()</function>. This function must create an appropriate <type>AtkObject</type>. A factory can be used to create more than one type of object, in which case its <function>create_accessible()</function> function will need to be smart enough to build and return the correct <type>AtkObject</type>.
fr: La fabrique doit être implémentée comme un enfant du type de classe <type>ATK_TYPE_OBJECT_FACTORY</type> et doit implémenter la fonction <function>create_accessible()</function>. Cette fonction doit créer un objet <type>AtkObject</type> approprié. Une fabrique peut être utilisée pour créer plus d'un type d'objet, dans ce cas sa fonction <function>create_accessible()</function> doit être suffisamment intelligente pour construire et renvoyer l'objet <type>AtkObject</type> correct.

note: (itstool) path: section/title
en: ATK Implementation for a Specific Object
fr: Implémentation ATK pour un objet spécifique

note: (itstool) path: section/para
en: All <type>GObject</type>s implement a <function>get_type()</function> function. Using the above example the naming convention for this function name would be <function>myatkimp_mytype_get_type()</function>.
fr: Tous les objets <type>GObject</type> implémentent une fonction <function>get_type()</function>. En utilisant l'exemple précédent, la convention d'attribution de nom pour cette fonction est <function>mon_imp_atk_montype_get_type()</function>.

note: (itstool) path: section/para
en: In this function, you specify which interfaces your object implements. If the following logic were included in this <function>get_type()</function> function, this object would implement the <type>ATK_TEXT</type> interface:
fr: Dans cette fonction, vous spécifiez quelles interfaces sont implémentées par votre objet. Si la logique suivante est incluse dans cette fonction <function>get_type()</function>, cet objet implémente alors l'interface <type>ATK_TEXT</type> :

note: (itstool) path: example/title
en: Sample <function>get_type()</function> function
fr: Exemple de fonction <function>get_type()</function>

note: (itstool) path: section/para
en: The function <function>atk_text_interface_init()</function>, which has the following prototype, would need to be implemented:
fr: La fonction <function>atk_text_interface_init()</function>, qui possède le prototype suivant, doit être implémentée :

note: (itstool) path: section/para
en: This function would connect the interface function calls to the specific implementation as follows:
fr: Cette fonction connecte les appels de la fonction d'interface à l'implémentation spécifique comme suit :

note: (itstool) path: example/title
en: Connecting custom interface calls to an AtkObject implementation
fr: Connexion des appels d'interface personnalisés à une implémentation d'AtkObject

note: (itstool) path: example/programlisting
en: 
    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; 
       ... 
    }
fr: 
    void 
    atk_text_interface_init (AtkTextIface *iface) 
    { 
       g_return_if_fail (iface != NULL); 
       iface-&gt;get_text = mon_imp_atk_montype_get_text; 
       iface-&gt;get_character_at_offset = mon_imp_atk_montype_get_character_at_offset; 
       ... 
    }

note: (itstool) path: section/para
en: Then the functions <function>myatkimp_mytype_get_text()</function>, <function>myatkimp_mytype_get_character_at_offset()</function>, and the rest of the <type>ATK_TEXT</type> interface functions would need to be implemented.
fr: Ensuite les fonctions <function>mon_imp_atk_montype_get_text()</function>, <function>mon_imp_atk_montype_get_character_at_offset()</function> et le reste des fonctions de l'interface <type>ATK_TEXT</type> doivent être implémentés.

note: (itstool) path: section/title
en: <type>AtkObject</type> Implementation
fr: Implémentation d'<type>AtkObject</type>

note: (itstool) path: section/para
en: <type>AtkObject</type>s are <type>GObjects</type>, and all <type>GObject</type>s need to specify the <function>get_type()</function> function. Here is an example that sets up a class and instance initializer. This <function>get_type()</function> function also specifies that the object implements <type>ATK_TEXT</type> and specifies the parent object to be <type>MYATKIMP_MYPARENTTYPE</type>.
fr: Les <type>AtkObject</type> sont des objets <type>GObjects</type> et tous les <type>GObject</type> doivent spécifier la fonction <function>get_type()</function>. Voici un exemple qui définit une classe et un initialisateur d'instance. Cette fonction <function>get_type()</function> spécifie aussi que l'objet implémente <type>ATK_TEXT</type> et spécifie l'objet parent comme un <type>MON_IMP_ATK_MONTYPEPARENT</type>.

note: (itstool) path: example/title
en: Sample <function>get_type()</function> implementation
fr: Exemple d'implémentation de <function>get_type()</function>

note: (itstool) path: example/programlisting
en: 
    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 */ 
          }; 
    
          /* Set up atk_text_info structure used below */ 
          static const GInterfaceInfo atk_text_info = 
          { 
             (GInterfaceInitFunc) atk_text_interface_init, 
             (GInterfaceFinalizeFunc) NULL, 
             NULL 
          }; 
    
          /* Set up typename and specify parent type */ 
          type = g_type_register_static (MYATKIMP_MYPARENTTYPE, 
                "MyatkimpMytype", &amp;tinfo, 0); 
    
          /* This class implements interface ATK_TYPE_TEXT */ 
          g_type_add_interface_static (type, ATK_TYPE_TEXT, 
                                       &amp;atk_text_info); 
       } 
       return type; 
    }
fr: 
    GType 
    mon_imp_atk_montype_get_type (void) 
    { 
       static GType type = 0; 
    
       if (!type) 
       { 
          static const GTypeInfo tinfo = 
          { 
             sizeof (GailLabelClass), 
             (GBaseInitFunc) NULL,                                  /* initialisation base */ 
             (GBaseFinalizeFunc) NULL,                              /* finalisation base */
             (GClassInitFunc) mon_imp_atk_montype_class_init,       /* class init */ 
             (GClassFinalizeFunc) NULL,                             /* class finalize */ 
             NULL,                                                  /* données de la classe */ 
             sizeof (GailLabel),                                    /* taille de l'instance */ 
             0,                                                     /* nbre préallocations */ 
             (GInstanceInitFunc) mon_imp_atk_montype_instance_init, /* instance init */ 
             NULL                                                   /* tableau de valeur */ 
          }; 
    
          /* Organisation de la structure atk_text_info utilisée ci-dessous */ 
          static const GInterfaceInfo atk_text_info = 
          { 
             (GInterfaceInitFunc) atk_text_interface_init, 
             (GInterfaceFinalizeFunc) NULL, 
             NULL 
          }; 
    
          /* Organisation du typename et spécification du type du parent */ 
          type = g_type_register_static (MON_IMP_ATK_MONTYPEPARENT, 
                "monimpatkmontype", &amp;tinfo, 0); 
    
          /* Cette classe implémente l'interface ATK_TYPE_TEXT */ 
          g_type_add_interface_static (type, ATK_TYPE_TEXT, 
                                       &amp;atk_text_info); 
       } 
       return type; 
    }

note: (itstool) path: section/title
en: Class/Instance Initializers
fr: Initialisateurs de classe/instance

note: (itstool) path: section/para
en: You will have to set up a class initializer for the <type>GObject</type> if your <type>AtkObject</type> implementation either:
fr: Vous allez devoir configurer un initialisateur de classe pour l'objet <type>GObject</type> dans l'un des deux cas suivants : si votre implémentation d'<type>AtkObject</type>

note: (itstool) path: listitem/para
en: Redefines any function calls defined by the object's parent. This is typically necessary when an object needs to implement a function like <function>atk_object_get_n_accessible_children()</function>. This is necessary if the object has children, but they are not represented with widgets.
fr: redéfinit un des appels de fonction défini par l'objet parent. C'est en général nécessaire quand un objet doit implémenter une fonction comme <function>atk_object_get_n_accessible_children()</function>. C'est nécessaire si l'objet possède des fils qui ne sont pas représentés par des éléments graphiques.

note: (itstool) path: listitem/para
en: For example, if your ATK implementation needs to over-ride the <type>AtkObject</type> function <function>get_name()</function>, then the class initializer would look like:
fr: Par exemple, si votre implémentation ATK doit remplacer la fonction <function>get_name()</function> d'<type>AtkObject</type> alors l'initialisateur de classe ressemblera à :

note: (itstool) path: example/title
en: Class initializer that overrides parent's <function>get_name()</function> function
fr: Initialisateur de classe qui remplace la fonction <function>get_name()</function> du parent.

note: (itstool) path: example/programlisting
en: 
    myatkimp_mytype_class_init (GailLabelClass *klass) 
    { 
      AtkObjectClass *class = ATK_OBJECT_CLASS (klass); 
      class-&gt;get_name = myatkimp_mytype_get_name; 
    }
fr: 
    mon_imp_atk_montype_class_init (GailLabelClass *klass) 
    { 
      AtkObjectClass *class = ATK_OBJECT_CLASS (klass); 
      class-&gt;get_name = mon_imp_atk_montype_get_name; 
    }

note: (itstool) path: listitem/para
en: Requires a <function>parent-&gt;init</function>, <function>parent-&gt;notify_gtk</function>, or <function>parent-&gt;finalize</function> function. This example defines all three:
fr: ou si elle requiert une fonction <function>parent-&gt;init</function>, <function>parent-&gt;notify_gtk</function> ou <function>parent-&gt;finalize</function>. Cet exemple définit les trois :

note: (itstool) path: example/title
en: Class initializer that defines its own <function>init()</function>, <function>notify_gtk()</function> and <function>finalize()</function> functions
fr: Initialisateur de classe qui définit ses propres fonctions <function>init()</function>, <function>notify_gtk()</function> et <function>finalize()</function>

note: (itstool) path: example/programlisting
en: 
    static ParentObjectType *parent_class = NULL; 
    
    myatkimp_mytype_class_init (GailLabelClass *klass) 
    { 
       ParentObjectType *parent_class = (ParentObjectType*)klass; 
    
       /* 
        * Caching the parent_class is necessary if the init, 
        * notify_gtk, or finalize functions are set up. 
        */ 
        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; 
    }
fr: 
    static ParentObjectType *parent_class = NULL; 
    
    mon_imp_atk_montype_class_init (GailLabelClass *klass) 
    { 
       ParentObjectType *parent_class = (ParentObjectType*)klass; 
    
       /* 
        * La mise en cache de parent_class est nécessaire si les fonctions 
        * init, notify_gtk ou finalize sont configurées. 
        */ 
        parent_class = g_type_class_ref (MONATKIMP_TYPE_PARENT); 
    
        parent_class-&gt;init = mon_imp_atk_montype_widget_init; 
        parent_class-&gt;notify_gtk = mon_imp_atk_montype_real_notify_gtk; 
        parent_class-&gt;finalize = mon_imp_atk_montype_finalize; 
    }

note: (itstool) path: listitem/para
en: A <function>parent-&gt;init()</function> function may be necessary if the ATK implementation needs to do either of the following:
fr: Une fonction <function>parent-&gt;init()</function> peut être nécessaire si l'implémentation ATK a besoin d'effectuer l'une des actions suivantes :

note: (itstool) path: listitem/para
en: Cache any data obtained from a backing GTK widget.
fr: mettre en cache toutes les données obtenues à partir de l'élément graphique GTK auxiliaire,

note: (itstool) path: listitem/para
en: Listen to any signals from the backing GTK widget.
fr: écouter tous les signaux émis par l'élément graphique GTK auxiliaire.

note: (itstool) path: listitem/para
en: Here is an example of both:
fr: Voici un exemple des deux :

note: (itstool) path: example/title
en: A custom <function>init()</function> function
fr: Une fonction personnalisée <function>init()</function>

note: (itstool) path: example/programlisting
en: 
    void 
    gail_tree_view_widget_init (MyatkimpMytype  *mytype, 
                                GtkWidget       *gtk_widget) 
    { 
       /* Make sure to call the parent's init function */ 
       parent_class-&gt;init (widget, gtk_widget); 
       
       /* Cache a value in the ATK implementation */ 
       mytype-&gt;cached_value = gtk_widget_function_call(); 
    
       /* Listen to a signal */ 
       gtk_signal_connect (GTK_OBJECT (gtk_widget), 
                           "signal-type", 
                           GTK_SIGNAL_FUNC (_myatkimp_mytype_signal_type), 
                           NULL); 
    }
fr: 
    void 
    gail_tree_view_widget_init (Monimpatkmontype  *montype, 
                                GtkWidget       *gtk_widget) 
    { 
       /* Être sûr d'appeler la fonction init du parent */ 
       parent_class-&gt;init (widget, gtk_widget); 
       
       /* Mettre en cache une valeur dans l'implementation ATK */ 
       montype-&gt;cached_value = gtk_widget_function_call(); 
    
       /* Écouter un signal */ 
       gtk_signal_connect (GTK_OBJECT (gtk_widget), 
                           "type-signal", 
                           GTK_SIGNAL_FUNC (_mon_imp_atk_montype_signal_type), 
                           NULL); 
    }

note: (itstool) path: listitem/para
en: In this example, if the specified <type>signal-type</type> signal were generated on the backing <varname>gtk_widget</varname>, then the <function>_myatkimp_mytype_signal_type()</function> function would be called.
fr: Dans cet exemple, si le signal <type>type-signal</type> spécifié est généré par le <varname>gtk_widget</varname> auxiliaire alors la fonction <function>_mon_imp_atk_montype_signal_type()</function> est appelée.

note: (itstool) path: listitem/para
en: If the ATK implementation needs to listen to any property notifications on the backing GTK object, a <function>parent-&gt;notify_gtk()</function> function may be necessary. For example:
fr: Si l'implémentation d'ATK doit écouter toutes les notifications de propriété de l'objet GTK auxiliaire, une fonction  <function>parent-&gt;notify_gtk()</function> peut être nécessaire. Par exemple :

note: (itstool) path: example/title
en: A custom <function>notify_gtk()</function> function
fr: Une fonction personnalisée <function>notify_gtk()</function>

note: (itstool) path: example/programlisting
en: 
    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) 
       { 
          /* Handle the property change. */ 
       } 
       else 
       { 
          parent_class-&gt;notify_gtk (obj, pspec); 
       } 
    }
fr: 
    void 
    mon_imp_atk_montype_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, "propriété-concernée") == 0) 
       { 
          /* Gestion de la modification de propriété. */ 
       } 
       else 
       { 
          parent_class-&gt;notify_gtk (obj, pspec); 
       } 
    }

note: (itstool) path: listitem/para
en: If it is necessary to free any data when a <type>GObject</type> instance is destroyed, then a <function>finalize()</function> function is needed to free the memory. For example:
fr: S'il est nécessaire de libérer toutes les données quand une instance <type>GObject</type> est détruite alors il y a besoin d'une fonction <function>finalize()</function> pour libérer la mémoire. Par exemple :

note: (itstool) path: example/title
en: A custom <function>finalize()</function> function
fr: Une fonction personnalisée <function>finalize()</function>

note: (itstool) path: example/programlisting
en: 
    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); 
    }
fr: 
    void 
    mon_imp_atk_montype_finalize (GObject *object) 
    { 
       MonImpAtkMonType *mon_type = MONIMPATK_MONTYPE (object); 
    
       g_object_unref (mon_type-&gt;cached_value); 
       G_OBJECT_CLASS (parent_class)-&gt;finalize (object); 
    }

note: (itstool) path: section/title
en: Making Custom Components Accessible
fr: Rendre les composants personnalisés accessibles

note: (itstool) path: section/para
en: Adding ATK support to your custom widget will assure its cooperation with the accessibility infrastructure. These are the general steps that are required:
fr: L'ajout de la prise en charge ATK à votre élément graphique personnalisé assure de sa coopération avec les infrastructures d'accessibilité. Voici les étapes générales requises :

note: (itstool) path: listitem/para
en: assess a custom widget according to the applicable <link linkend="gad-ui-guidelines">User Interface Guidelines</link>;
fr: accéder à un élément graphique personnalisé en suivant les <link linkend="gad-ui-guidelines">directives d'interface utilisateur</link> concernées ;

note: (itstool) path: listitem/para
en: determine which <ulink url="http://library.gnome.org/devel/atk/stable/atk.html">ATK interfaces</ulink> a custom widget should implement, according to the widget's feature set and function;
fr: déterminer quelles <ulink url="http://library.gnome.org/devel/atk/stable/atk.html">interfaces ATK</ulink> un élément graphique personnalisé doit implémenter selon l'ensemble de ses fonctionnalités et la fonction de l'élément graphique ;

note: (itstool) path: listitem/para
en: assess which <ulink url="http://library.gnome.org/devel/atk/stable/atk.html">ATK interfaces</ulink> can be inherited from the parent widget class;
fr: évaluer quelles <ulink url="http://library.gnome.org/devel/atk/stable/atk.html">interfaces ATK</ulink> peuvent être héritées de la classe de l'élément graphique parent ;

note: (itstool) path: listitem/para
en: implement the appropriate ATK interfaces for the widget class in one of two ways:
fr: implémenter les interfaces ATK appropriées pour la classe d'élément graphique d'une des deux façons suivantes :

note: (itstool) path: listitem/para
en: directly by the custom widget, or
fr: directement par un élément graphique personnalisé ou

note: (itstool) path: listitem/para
en: in an <ulink url="http://library.gnome.org/devel/atk/stable/AtkObject.html"><type>AtkObject</type></ulink> subtype created by a new <ulink url="http://library.gnome.org/devel/atk/stable/AtkObjectFactory.html"><type>AtkObjectFactory</type></ulink> subclass
fr: dans un sous-type <ulink url="http://library.gnome.org/devel/atk/stable/AtkObject.html"><type>AtkObject</type></ulink> créé par une nouvelle sous-classe <ulink url="http://library.gnome.org/devel/atk/stable/AtkObjectFactory.html"><type>AtkObjectFactory</type></ulink>.

note: (itstool) path: listitem/para
en: If the second method is used, the appropriate factory type must be registered with the <type>AtkObjectFactoryRegistry</type> at runtime.
fr: Si la seconde méthode est utilisée, le type de fabrique approprié doit être enregistré avec l'objet <type>AtkObjectFactoryRegistry</type> à l'exécution.

note: (itstool) path: section/para
en: The <ulink url="ftp://ftp.gnome.org/pub/GNOME/sources/gail/">GAIL source code</ulink> serves as an excellent tutorial for advanced ATK usage.
fr: Le <ulink url="ftp://ftp.gnome.org/pub/GNOME/sources/gail/">code source GAIL</ulink> est un excellent tutoriel pour une utilisation avancée d'ATK.

note: (itstool) path: section/title
en: User Interface Guidelines for Supporting Accessibility
fr: Directives pour la prise en charge de l'accessibilité dans l'interface utilisateur

note: (itstool) path: section/para
en: When designing your application's GUI, there are a number of simple guidelines you should follow to ensure that it can be used by as wide an audience as possible, whether in conjunction with assistive technologies or not. Don't be fooled into thinking that this is just a case of "making your GUI usable by people with disabilities", though, and that you shouldn't bother if you know a disabled person is never going to use your application. Following these guidelines will improve the overall usability of your application for everyone who uses it - including you!
fr: Lors de la conception de l'interface graphique de votre application, il y a un certain nombre de directives simples que vous devez suivre pour être certain qu'elle puisse être utilisée par le plus grand nombre, que ce soit en conjonction avec des technologies d'assistance ou non. Ne faites pas l'erreur de penser qu'il s'agit seulement de « rendre l'interface graphique utilisable pour les personnes handicapées » et que vous n'avez pas à vous inquiéter de savoir si une personne possédant un handicap utilisera un jour votre application. Suivre ces directives améliorera l'ergonomie globale de votre application pour tous les utilisateurs, vous y compris.

note: (itstool) path: section/title
en: General
fr: Généralités

note: (itstool) path: section/para
en: We all get frustrated if we can't find a feature in an application, or make a mistake from which it takes a couple of minutes to recover, if it's possible to recover at all. If you have some sort of disability, the chances are the effort and time penalties involved will be several times worse. Following a few basic guidelines can help prevent these sorts of situations for all users.
fr: Nous sommes tous un jour ou l'autre frustrés de ne pas trouver une fonctionnalité dans une application ou de faire une erreur qui prend plusieurs minutes pour être corriger ; si c'est possible de la corriger. Si vous avez un handicap quelconque, il y a de bonnes chances que les efforts et la perte de temps soient bien plus importants. Suivez ces quelques directives de base pour prévenir ce type de situations pour tous les utilisateurs.

note: (itstool) path: listitem/para
en: Provide Undo for every action that changes the user's data or the application's settings. If possible, provide more than one level of undo and redo, and a history list to allow preview of what actions will be undone.
fr: Fournissez la possibilité d'annuler chacune des actions qui modifient les données de l'utilisateur ou les paramètres de l'application. Si possible, fournissez plusieurs niveaux d'annulation et de rétablissement, ainsi qu'un historique pour permettre de prévisualiser quelles actions seront annulées.

note: (itstool) path: listitem/para
en: Provide commands to restore default settings. If a particular setting could make the application completely unusable for an individual, e.g. by making the fonts very small, it would be useful to provide an option to restore the default settings outside the application itself. This could be done using a command line switch, for example.
fr: Fournissez des commandes pour restaurer les paramètres par défaut. Si un paramètre particulier peut rendre l'application complètement inutilisable pour un individu, par exemple en réduisant la taille des polices, il est alors utile de fournir une option de restauration des paramètres par défaut en dehors de l'application elle-même. Par exemple, à l'aide d'une option en ligne de commande.

note: (itstool) path: listitem/para
en: Help prevent users from doing the wrong thing. This is particularly important for actions that could be done by accident (e.g. mouse actions) or that cannot easily be undone (e.g. overwriting a file). Consider using confirmation dialogs or forcing the user to go into a particular mode to perform potentially destructive actions.
fr: Aidez les utilisateur à ne pas commettre d'erreurs. Ceci est particulièrement important pour des actions qui peuvent être lancées accidentellement (comme les actions avec la souris) ou qui ne sont pas faciles à annuler (comme l'écrasement d'un fichier). Considérez la possibilité d'utiliser des boîtes de dialogue de confirmation ou de forcer l'utilisation d'un mode particulier pour effectuer des actions potentiellement dangereuses.

note: (itstool) path: listitem/para
en: Minimize users' memory load. For example, let the user view multiple documents at the same time, and ensure online help or other instructions can remain visible while they carry out the procedure being described. Allow them to copy any information that is displayed, and paste it anywhere that data can be entered.
fr: Minimisez le travail mémoire des utilisateurs. Par exemple, permettez à l'utilisateur de regarder plusieurs documents en même temps et assurez-vous que l'aide en ligne ou d'autres instructions peuvent rester visibles pendant que la tâche décrite est effectuée. Permettez le copier-coller de toutes les informations affichées partout où des données peuvent être saisies.

note: (itstool) path: listitem/para
en: Don't make users insert disks. Depending on a user's particular disability, they may find it difficult to physically insert or change a disk, or they may find it hard to identify the correct disk in the first place. If your application is installed from CD-ROM, provide an option to copy all the files that will be required onto the user's hard drive.
fr: Ne faites pas insérer de disques aux utilisateurs. En fonction du handicap de l'utilisateur, il se peut qu'il lui soit difficile d'insérer physiquement un disque ou de le changer, il se peut aussi qu'il ne soit pas capable d'identifier le bon disque dans un premier temps. Si votre application est installée à partir d'un CD-ROM, fournissez l'option de copier tous les fichiers nécessaires sur le disque dur de l'utilisateur.

note: (itstool) path: listitem/para
en: Don't place frequently used functions deep in a menu structure. Whether you're using a mouse, keyboard or some other input device, deeply-nested menu items are best avoided. As well as the burden of remembering where to find them, they are always more difficult and time-consuming to access.
fr: Ne placez pas les fonctions utilisées fréquemment profondément dans la structure des menus. Que vous utilisiez une souris, le clavier ou tout autre périphérique de saisie, il vaut mieux éviter les éléments de menus placés profondément. En plus de l'effort de mémoire pour les trouver, ils sont toujours plus difficiles et longs à accéder.

note: (itstool) path: listitem/para
en: Don't lead users through unnecessary steps. For example, wizards are useful for users who have trouble handling large numbers of options at one time, but other users may need to minimize the amount of time or keystrokes they use. Such users benefit from being able to skip unnecessary steps or go directly to the one they need. Consider providing a <guibutton>Finish</guibutton> button in wizards that skips right to the end and assumes default responses for the intermediate steps. If the process has many steps, consider asking the user at the start if they want to run through all the steps, or just the most commonly-used ones.
fr: N'imposez pas aux utilisateurs des étapes inutiles. Par exemple, les assistants sont utiles pour des utilisateurs qui ont des problèmes pour manipuler un grand nombre d'options à la fois, mais d'autres utilisateurs ont besoin de minimiser le temps et le nombre de saisies au clavier. Ces utilisateurs sont aidés s'il est possible de sauter des étapes inutiles et d'aller directement à l'étape voulue. Pensez à fournir dans les assistants un bouton <guibutton>Terminer</guibutton> qui va directement à la fin et utilise les réponses par défaut pour les étapes intermédiaires. Si le processus contient de nombreuses étapes, pensez à demander à l'utilisateur s'il souhaite effectuer toutes les étapes ou seulement celles utilisées le plus fréquemment.

note: (itstool) path: section/title (itstool) path: row/entry
en: Keyboard Navigation
fr: Navigation au clavier

note: (itstool) path: section/para
en: A well-designed keyboard user interface plays a key role when you are designing accessible software. Blind users can navigate software more effectively using the keyboard, because using the mouse depends on visual feedback of the mouse pointer location. Also, mobility impairments can prevent a user from successfully navigating using the mouse, because of the fine motor control skills required.
fr: Une interface utilisateur clavier bien conçue joue un rôle important quand vous concevez un logiciel accessible. Les utilisateurs non-voyants peuvent naviguer plus efficacement dans le logiciel à l'aide du clavier, alors que l'utilisation de la souris dépend des retours d'informations visuels fonction de la position du pointeur. Il est aussi possible qu'un handicap moteur empêche un utilisateur d'utiliser la souris, à cause du degré de contrôle nécessaire à sa manipulation.

note: (itstool) path: section/para
en: It is therefore important to make all mouse actions available from the keyboard, and include keyboard access to all toolbars, menus, links and buttons. Every function your application provides should be available using the keyboard alone. Hide your mouse while you're testing your application if you have to!
fr: Il est donc important de rendre toutes les actions de la souris disponibles depuis le clavier et d'inclure une touche d'accès à toutes les barres d'outils, les menus, liens et boutons. Chaque fonction de votre application se doit d'être disponible en utilisant uniquement le clavier. Cachez votre souris lors de vos tests s'il le faut !

note: (itstool) path: section/para
en: Most functionality should be easy to make accessible by using keyboard mnemonics and accelerators, and the toolkit's built-in navigation features. However, operations that rely on drag-and-drop, for example, may require more thought.
fr: La plupart des fonctionnalités doivent être accessibles facilement à l'aide de mnémoniques et raccourcis clavier et de fonctions de navigation intégrées de la boîte à outils. Par contre, des opérations qui requièrent un glisser-déposer, par exemple, peuvent nécessiter plus de réflexion.

note: (itstool) path: listitem/para
en: Provide efficient keyboard access to all application features. Some users may be unable to use a mouse, and many "power-users" prefer to use the keyboard anyway. Also, some specialized assistive technology input devices may simulate keyboard events rather than mouse events. Since typing is difficult or even painful for some users, it is important to provide a keyboard interface that minimizes the number of keystrokes required for any given task.
fr: Fournissez un accès clavier efficace pour toutes les fonctionnalités de l'application. Certains utilisateurs ne peuvent pas se servir d'une souris, et de nombreux « utilisateurs avancés » préfèrent utiliser le clavier. De nombreux périphériques de technologie d'assistance simulent des évènements claviers plutôt que des évènements souris. Comme la frappe est difficile voire même douloureuse pour certains utilisateurs, il est important de fournir une interface clavier qui minimise le nombre de frappes de touches nécessaire pour une tâche donnée.

note: (itstool) path: listitem/para
en: Use a logical keyboard navigation order. When navigating around a window with the <keycap>Tab</keycap> key, keyboard focus should move between controls in a predictable order. In Western locales, this is normally left to right and top to bottom.
fr: Utilisez un ordre de navigation clavier logique. Lors d'une navigation dans une fenêtre avec la touche <keycap>Tab</keycap>, le focus clavier doit se déplacer entre les contrôles dans un ordre prévisible. Dans les environnements linguistiques occidentaux, c'est habituellement de la gauche vers la droite et de haut en bas.

note: (itstool) path: listitem/para
en: Ensure correct tab order for controls whose enabled state is dependent on checkbox, radio button or toggle button state. When such a button is selected, all its dependent controls should be enabled, and all the dependent controls of any other button in the group should be disabled. When the user selects a checkbox, radio button or toggle button that has dependent controls, do not automatically give focus to the first dependent control, but instead leave the focus on the button.
fr: Assurez-vous que l'ordre de parcours des contrôles avec la touche Tab reste correct pour ceux dont l'état activé dépend de l'état d'une case à cocher, d'un bouton radio et d'un bouton poussoir. Lorsqu'un bouton de ce type est sélectionné, tous les contrôles en dépendant doivent être activés et tous ceux qui dépendent d'un autre bouton du groupe doivent être désactivés. Lorsque l'utilisateur sélectionne une case à cocher, un bouton radio ou un bouton poussoir qui possèdent des contrôles en dépendance, ne donnez pas automatiquement le focus au premier contrôle dépendant mais laissez plutôt le focus sur le bouton qui commande cette dépendance.

note: (itstool) path: listitem/para
en: Don't override existing system-level accessibility features. For example, <ulink url="http://www.rehab.uiuc.edu/accessx/overview.html">AccessX</ulink> is an Xserver extension that has been supported since X11R6. The MouseKeys feature of this extension allows mouse movement and button clicks to be simulated using the keypad. Therefore you should not add features to your application that can only be accessed by pressing keys on the keypad, as users relying on the MouseKeys feature will not be able to use them.
fr: Ne sur-définissez pas les caractéristiques existantes d'accessibilité au niveau système. Par exemple, <ulink url="http://www.rehab.uiuc.edu/accessx/overview.html">AccessX</ulink> est une extension de Xserver qui est prise en charge depuis X11R6. La caractéristique MouseKeys de cette extension permet de simuler à l'aide du pavé numérique les déplacements de la souris et les clics de boutons. Par conséquent, vous ne pouvez pas ajouter des caractéristiques à l'application qui ne seraient atteintes qu'en utilisant le pavé numérique ; les utilisateurs comptant sur les fonctionnalités de MouseKeys ne pourraient plus les utiliser.

note: (itstool) path: listitem/para
en: Provide more than one method to perform keyboard tasks where possible. Some users may find some keys and key combinations easier to use than others.
fr: Fournissez plus d'une méthode pour réaliser les tâches au clavier lorsque c'est possible. Certains utilisateurs peuvent trouver certaines touches ou combinaisons plus faciles que d'autres.

note: (itstool) path: listitem/para
en: Provide both keyboard and mouse access to functions where possible. Some users may only be able to use either the mouse or the keyboard, but not both.
fr: Fournissez si possible la possibilité d'utiliser à la fois le clavier et la souris pour accéder à une fonction. Certains utilisateurs ne peuvent utiliser que le clavier ou la souris, mais pas les deux.

note: (itstool) path: listitem/para
en: Don't assign awkward reaches to frequently performed keyboard operations. Some people may only be able to use one hand on the keyboard, so shortcuts that can be easily used with one hand are preferable for common operations. In any case, having to frequently perform long or difficult reaches on the keyboard can increase muscle strain for all users, increasing the risk of pain or injury.
fr: N'attribuez pas de moyens d'accès complexes aux opérations clavier fréquemment utilisées. Certaines personnes ne peuvent utiliser qu'une seule main sur le clavier, donc les raccourcis utilisables facilement d'une seule main sont préférables pour les opérations courantes. Dans tous les cas, avoir à réaliser des extensions ou des positionnements difficiles sur le clavier augmente pour tous les utilisateurs le risque de se froisser un muscle, donc de douleurs ou de blessures.

note: (itstool) path: listitem/para
en: Don't require repetitive use of simultaneous keypresses. Some users are only able to press and hold one key at a time. Assistive technologies such as AccessX may allow users to press the keys sequentially rather than simultaneously, but this of course means the operation will take longer for them.
fr: N'exigez pas des utilisations répétées d'appuis simultanés de touches. Certains utilisateurs ne sont capables que d'appuyer et tenir une seule touche enfoncée à la fois. Les technologies d'assistance telles que celles d'AccessX permettent aux utilisateurs d'appuyer sur les touches de manière séquentielle plutôt que simultanément, mais bien sûr cela signifie que l'opération prendra plus de temps pour eux.

note: (itstool) path: listitem/para
en: Ensure that any text that can be selected with the mouse can also be selected with the keyboard. This is a convenience for all users, but especially for those for whom fine control of the mouse is difficult.
fr: Assurez-vous que tout texte pouvant être sélectionné avec la souris puisse également l'être avec le clavier. C'est une facilité pour tous les utilisateurs, mais elle s'adresse plus spécialement à ceux qui ont des difficultés à contrôler finement le mouvement de la souris.

note: (itstool) path: listitem/para
en: Ensure that objects that can be resized or moved by drag and drop can also be resized or moved with the keyboard. For example, icons and windows on the desktop. Where precision sizing and placement is potentially important, e.g. shapes in a diagram, also consider providing a dialog into which you can type co-ordinates, or a means of snapping objects to a user-definable grid.
fr: Assurez-vous que les objets qui peuvent être redimensionnés ou déplacés par un glisser-déposer peuvent également l'être avec le clavier, par exemple les icônes ou les fenêtres sur le bureau. Lorsqu'un positionnement et un redimensionnement précis peut se révéler important (par ex. les formes dans un diagramme), pensez également à fournir, soit une boîte de dialogue dans laquelle l'utilisateur peut saisir des coordonnées, soit un moyen de placer les objets sur une grille définie par ce dernier.

note: (itstool) path: listitem/para
en: Don't use general navigation functions to trigger operations. For example, do not use basic <keycap>Tab</keycap> keyboard navigation in a dialog to activate any actions associated with a control.
fr: N'utilisez pas de fonctions générales de navigation pour déclencher des actions. Par exemple, n'utilisez pas l'usuelle navigation clavier avec la touche <keycap>Tab</keycap> dans une boîte de dialogue pour activer une action associée à un contrôle.

note: (itstool) path: listitem/para
en: Show keyboard-invoked menus, windows and tooltips near the object they relate to. In GNOME 2.0, users can call up popup menus with <keycombo><keycap>Shift</keycap><keycap>F10</keycap></keycombo>, and tooltips with <keycombo><keycap>Shift</keycap><keycap>F1</keycap></keycombo>. Do not completely hide or obscure the object to which the menu or tooltip refers, however.
fr: Affichez les menus appelés par le clavier, les fenêtres et les infobulles auprès des objets auxquels ils sont associés. Dans GNOME 2.0, les utilisateurs peuvent activer les menus contextuels avec <keycombo><keycap>Maj</keycap><keycap>F10</keycap></keycombo> et les infobulles avec <keycombo><keycap>Maj</keycap><keycap>F1</keycap></keycombo>. Toutefois, ne masquez ou n'obscurcissez pas entièrement l'objet auquel le menu ou l'infobulle se rapporte.

note: (itstool) path: section/title (itstool) path: row/entry
en: Mouse Interaction
fr: Interaction avec la souris

note: (itstool) path: section/para
en: Remember that not everybody can use a mouse with equal dexterity, and that some users may have difficulty seeing or following the mouse pointer.
fr: Prenez en compte le fait que tous les utilisateurs ne peuvent pas utiliser une souris avec la même dextérité et que certains d'entre eux peuvent aussi avoir des difficultés pour voir ou suivre le pointeur de la souris.

note: (itstool) path: listitem/para
en: Don't depend on input from mouse button 2 or button 3. As well as being physically more difficult to click, some pointing devices and many assistive technology devices only support button 1. Some assistive technologies may not emulate the mouse at all, but generate keyboard events instead.
fr: Les entrées ne doivent pas dépendre du bouton central ou de droite. En plus d'être physiquement plus difficils à cliquer, certains dispositifs de pointage et de nombreux dispositifs de technologies d'assistance ne prennent en charge ou n'émulent que le bouton gauche de la souris 1. Certaines technologies d'assistance n'émulent même pas du tout la souris mais génèrent des évènements clavier à la place.

note: (itstool) path: listitem/para
en: Allow all mouse operations to be cancelled. Pressing the <keycap>Esc</keycap> key should cancel any mouse operation in progress, such as dragging and dropping a file in a file manager, or drawing a shape in a drawing program.
fr: Permettez à toutes les opérations d'être annulées avant leur fin. Un appui sur la touche <keycap>Échap</keycap> doit annuler toutes opérations de la souris en cours telles qu'une action de glisser-déposer d'un fichier ou le dessin d'une forme dans une application de dessin.

note: (itstool) path: listitem/para
en: Provide visual feedback throughout a drag and drop operation. As the mouse passes over valid targets, highlight them and change the mouse pointer. Use the "no drop" mouse pointer when passing over invalid drop targets. See <link linkend="gad-mouse-examples">Mouse Interaction Examples</link>.
fr: Fournissez un retour visuel pendant toute la durée d'une opération de glisser-déposer. Quand la souris passe au-dessus de cibles valides, mettez-les en évidence et modifiez le pointeur de la souris. Utilisez le pointeur de souris « dépôt impossible » lorsque vous passez au-dessus de cibles de dépôt non valides. Consultez également les <link linkend="gad-mouse-examples">exemples d'interaction avec la souris</link>.

note: (itstool) path: listitem/para
en: Don't warp the mouse pointer, or restrict mouse movement to part of the screen. This can interfere with assistive technologies, and is usually confusing even for users who don't rely on ATs.
fr: Ne déformez pas le pointeur de la souris ou ne restreignez pas le mouvement de la souris à une partie de l'écran. Cela peut interférer avec les technologies d'assistance et est habituellement perturbant pour les utilisateurs qui n'utilisent pas les technologies d'assistance.

note: (itstool) path: listitem/para
en: Don't make mouse targets too small. In general, mouse targets should be at least the size of the "hot area" around the resizable window border in the current window manager/theme - bearing in mind that a user with impaired dexterity or vision may be using a window manager with larger areas than the default.
fr: Ne créez pas de cibles trop petites pour la souris. En général, les cibles doivent être au minimum de la taille de la « zone sensible » autour de la bordure d'une fenêtre redimensionnable dans le gestionnaire/thème de fenêtres actuel ; en gardant à l'esprit qu'un utilisateur à mobilité ou vision réduite peut utiliser un gestionnaire de fenêtres avec des zones plus grandes que celles par défaut.

note: (itstool) path: section/title
en: Mouse Interaction Examples
fr: Exemples d'interaction avec la souris

note: (itstool) path: figure/title
en: Example of "no-drop" pointer from CDE/Motif
fr: Exemple de pointeur « dépôt impossible » de CDE/Motif

note: (itstool) path: figure/mediaobject
en: <imageobject> <imagedata fileref="figures/nodrop.png" format="PNG"/> </imageobject> <textobject> <phrase>Example of an "invalid drop target" pointer shape</phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/nodrop.png" format="PNG"/> </imageobject> <textobject> <phrase>Exemple d'une forme de pointeur de « cible de dépôt non valide »</phrase> </textobject>

note: (itstool) path: section/title (itstool) path: row/entry
en: Graphical Elements
fr: Éléments graphiques

note: (itstool) path: section/para
en: Provide options to customize the presentation of all the important graphical elements in your application. This will make it easier for people with visual or cognitive impairments to use.
fr: Fournissez une option pour personnaliser la présentation de tous les éléments graphiques importants de votre application. Cela la rend plus facile d'utilisation pour des personnes ayant des problèmes visuels ou des difficultés de raisonnement.

note: (itstool) path: listitem/para
en: Don't hard-code graphic attributes such as line, border or shadow thickness. These elements should ideally be read from the GTK or window manager theme. If this is not possible, provide options within your application to change them.
fr: Ne codez pas de manière permanente les attributs graphiques tel que ligne, bordure ou largeur des ombres. Ces éléments devraient être idéalement lus depuis le thème GTK ou celui du gestionnaire de fenêtres. Si ce n'est pas possible, fournissez des options dans votre application pour les modifier.

note: (itstool) path: listitem/para
en: Provide descriptive names for all interface components. The GAIL library provides default accessible descriptions for many GTK widgets, but you will still need to add your own in some cases, such as for widgets that use graphics instead of text (e.g. a well in a color palette, or an icon without a label). Consider overriding the defaults with more helpful or application-specific descriptions where possible.
fr: Fournissez des noms descriptifs pour tous les composants de l'interface. La bibliothèque GAIL fournit des descriptions accessibles par défaut pour de nombreux éléments graphiques GTK, mais vous devrez ajouter vos propres descriptions dans certains cas, par exemple les éléments graphiques qui utilisent une image au lieu d'un texte (par ex. un pot dans une palette de couleurs ou une icône sans étiquette). Pensez à remplacer les valeurs par défaut avec d'autres plus utiles ou plus spécifiques à l'application quand c'est possible.

note: (itstool) path: listitem/para
en: Allow multi-color graphical elements (e.g. toolbar icons) to be shown in monochrome only, if possible. These monochrome images should be shown in the system foreground and background colors, which the user will have chosen for themselves (by their choice of GTK theme) for maximum legibility.
fr: Permettez, si possible, l'affichage monochrome des éléments graphiques en couleurs (par ex. les icônes de barre d'outils). Ces images monochromes doivent s'afficher avec les couleurs de premier et d'arrière-plan que l'utilisateur a lui-même choisi (via son choix de thème GTK) pour une lisibilité maximale.

note: (itstool) path: listitem/para
en: Make interactive GUI elements easily identifiable. For example, do not make the user hover the mouse over an object to determine whether it is clickable or not. Leave sufficient space between objects and clearly delineate object boundaries. Don't show GUI elements that look pretty but don't actually do anything, unless you also provide an option to switch them off.
fr: Rendez les éléments de l'interface graphique facilement reconnaissables. Par exemple, ne forcez pas l'utilisateur à survoler un objet pour déterminer s'il est cliquable ou pas. Laissez suffisamment d'espace entre les objets et délimitez clairement les limites des objets. N'affichez pas d'élément dans l'interface graphique qui soient beaux mais ne servent à rien, sauf si vous fournissez une option pour les désactiver.

note: (itstool) path: listitem/para
en: Provide an option to hide graphics that don't convey essential information. Graphical images can be distracting to users with some cognitive disorders. The icons on the GNOME foot menu, for example, can be switched off whilst still leaving the menus fully functional.
fr: Fournissez une option pour cacher les graphiques qui ne sont pas nécessaires à la compréhension. Les images peuvent distraire les utilisateurs ayant des difficultés de raisonnement. Les icônes du menu GNOME, par exemple, peuvent être désactivées tout en laissant les menu fonctionnels.

note: (itstool) path: section/title (itstool) path: row/entry
en: Fonts and Text
fr: Police et texte

note: (itstool) path: listitem/para
en: Don't hard-code font styles and sizes. The user should be able to adjust all sizes and typefaces. If for some reason you cannot make this functionality available, never hardcode any font sizes smaller than 10 points.
fr: Ne codez pas de manière permanente les styles et tailles des polices de caractères. L'utilisateur doit être capable d'adapter toutes les tailles et tous les styles. Si pour une raison quelconque vous ne pouvez pas rendre cette fonctionnalité disponible, ne codez jamais des tailles de police inférieures à 10 points.

note: (itstool) path: listitem/para
en: Provide options to turn off any graphical backdrops or "watermarks" behind text. Such images interfere with the contrast between the text and its background, which can cause difficulty for users with visual impairments.
fr: Fournissez l'option de désactiver toutes les toiles de fond graphiques ou « filigranes » placés derrière le texte. Ces images interfèrent avec le contraste entre le texte et l'arrière-plan, ce qui peut causer des difficultés pour les utilisateurs qui ont des problèmes de vision.

note: (itstool) path: listitem/para
en: Label objects with names that make sense when taken out of context. Users relying on screen readers or similar assistive technologies will not necessarily be able to immediately understand the relationship between a control and those surrounding it.
fr: Donnez aux objets un nom porteur de sens, même pris hors contexte. Les utilisateurs qui utilisent des lecteurs d'écran ou d'autres technologies d'assistance ne sont pas nécessairement capables de comprendre immédiatement la relation entre un contrôle et son environnement.

note: (itstool) path: listitem/para
en: Don't use the same label more than once in the same window. If you use the same label in different windows, it will help if it means the same thing in both windows. Also, don't use labels that are spelled differently but sound the same, e.g. "Read" and "Red", as this could be confusing for users relying on screen-readers.
fr: N'utilisez pas la même étiquette plus d'une fois dans la même fenêtre. Si vous utilisez la même étiquette dans des fenêtres différentes, il est préférable qu'elles aient le même sens. Pour la même raison, n'utilisez pas d'étiquettes qui s'épellent différemment, mais qui se prononcent d'une façon proche, par ex. « emprunte » et « empreinte », car cela peut troubler les utilisateurs qui utilisent des lecteurs d'écran.

note: (itstool) path: listitem/para
en: Position labels consistently throughout your application. This normally means immediately below large icons, immediately to the right of small icons, and immediately above or to the left of other controls. See <link linkend="gad-font-examples">Fonts and Text Examples</link>.
fr: Positionnez les étiquettes de façon consistante partout dans votre application. En général immédiatement sous les grandes icônes, à droite des petites icônes et au-dessus ou à gauche des autres contrôles. Consultez les <link linkend="gad-font-examples">exemples de polices et de texte</link>.

note: (itstool) path: listitem/para
en: When you use static text to label a control, end the label with a colon. For example, <guilabel>Username:</guilabel> to label a text field into which the user should type their username. This helps identify it as a control's label rather than an independent item of text.
fr: Quand vous utilisez un texte statique pour nommer un contrôle, terminez l'étiquette par deux-points. Par exemple, <guilabel>Nom d'utilisateur :</guilabel> pour nommer une zone de texte dans lequel l'utilisateur doit saisir son nom d'utilisateur. Cela aide à l'identifier comme étiquette du contrôle plutôt que comme élément indépendant.

note: (itstool) path: listitem/para
en: When you use static text to label a control, ensure that the label immediately precedes that control in the Tab order. This will ensure that the mnemonic (underlined character) you assign to the label will move focus to or activate the correct control when pressed.
fr: Quand vous utilisez un texte statique pour nommer un contrôle, assurez-vous que l'étiquette précède le contrôle dans l'ordre de parcours des contrôles avec la touche Tab. Cela assure que le mnémonique (caractère souligné) que vous attribuez à l'étiquette active ou déplace le focus vers le contrôle correct quand il est utilisé.

note: (itstool) path: listitem/para
en: Provide alternatives to WYSIWYG. Some users may need to print text in a small font but edit in a larger screen font, for example. Possible alternatives include displaying all text in the same font and size (both of which are chosen by the user); a "wrap-to-window" option that allows you to read all the text in a window without scrolling horizontally; a single column view that shows the window's contents in a single column even if they will be printed in multiple columns; and a text-only view, where graphics are shown as placeholders or text descriptions. If the application has panels with child controls, consider allowing the panels to resize along with the parent window.
fr: Fournissez des alternatives au WYSIWYG (What You See Is What You Get). Certains utilisateurs peuvent par exemple avoir besoin d'imprimer le texte avec des petites polices, mais d'utiliser des grandes polices d'écran pour l'édition. Les alternatives possibles sont soit l'affichage de tout le texte dans la même police et taille (toutes deux choisies par l'utilisateur), soit une option « retour à la ligne automatique » qui permet de lire tout le texte d'une fenêtre sans défilement horizontal, soit un affichage en colonne unique (le contenu de la fenêtre est sur une seule colonne bien qu'il soit imprimé sur plusieurs colonnes), soit un affichage texte-seulement pour lequel les graphiques sont remplacés par des substituants ou des descriptions textuelles. Si l'application possède des panneaux contenant des contrôles fils, pensez à permettre aux panneaux de se redimensionner en même temps que la fenêtre parente.

note: (itstool) path: section/title
en: Fonts and Text Examples
fr: Exemples de polices et de texte

note: (itstool) path: figure/title
en: Correct label placement for various GUI elements
fr: Placement correct des étiquettes pour divers éléments de l'interface graphique

note: (itstool) path: entry/mediaobject
en: <imageobject> <imagedata fileref="figures/label_above.png" format="PNG"/> </imageobject> <textobject> <phrase>List control with label above</phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/label_above.png" format="PNG"/> </imageobject> <textobject> <phrase>Contrôle liste avec une étiquette au-dessus</phrase> </textobject>

note: (itstool) path: row/entry
en: <_:mediaobject-1/> List control with label above
fr: <_:mediaobject-1/> Contrôle liste avec une étiquette au-dessus

note: (itstool) path: entry/mediaobject
en: <imageobject> <imagedata fileref="figures/label_below.png" format="PNG"/> </imageobject> <textobject> <phrase>Large file manager icon with label underneath</phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/label_below.png" format="PNG"/> </imageobject> <textobject> <phrase>Grande icône de gestionnaire de fichiers avec une étiquette au-dessous</phrase> </textobject>

note: (itstool) path: row/entry
en: <_:mediaobject-1/> Large file manager icon with label underneath
fr: <_:mediaobject-1/>Grande icône de gestionnaire de fichiers avec une étiquette au-dessous

note: (itstool) path: entry/mediaobject
en: <imageobject> <imagedata fileref="figures/label_right.png" format="PNG"/> </imageobject> <textobject> <phrase>Small toolbar icon with label to its right</phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/label_right.png" format="PNG"/> </imageobject> <textobject> <phrase>Petite icône de barre d'outils avec une étiquette à droite </phrase> </textobject>

note: (itstool) path: row/entry
en: <_:mediaobject-1/> Small toolbar icon with label to its right
fr: <_:mediaobject-1/>Petite icône de barre d'outils avec une étiquette à droite

note: (itstool) path: entry/mediaobject
en: <imageobject> <imagedata fileref="figures/label_left.png" format="PNG"/> </imageobject> <textobject> <phrase>Spinbox control with label to its left</phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/label_left.png" format="PNG"/> </imageobject> <textobject> <phrase>Contrôle de zone de sélection numérique avec une étiquette à sa gauche</phrase> </textobject>

note: (itstool) path: row/entry
en: <_:mediaobject-1/> Spinbox control with label to its left
fr: <_:mediaobject-1/> Contrôle de zone de sélection numérique avec une étiquette à sa gauche

note: (itstool) path: section/title (itstool) path: row/entry
en: Color and Contrast
fr: Couleur et contraste

note: (itstool) path: section/para
en: Poor choice of colors on the screen can cause problems for users with color blindness (for whom hue is important) or low-vision (for whom brightness/contrast is important). Generally, you should allow the user to customize the colors in any part of your application that conveys important information.
fr: Un mauvais choix de couleurs à l'écran peut poser des problèmes pour les utilisateurs atteint de daltonisme (pour qui la teinte est importante) ou les mal-voyants (pour lesquels la luminosité/le contraste sont importants). En général, vous devez laisser à l'utilisateur la possibilité de personnaliser les couleurs dans toutes les parties de votre application qui transmettent des informations importantes.

note: (itstool) path: section/para
en: Users with visual impairments may require a high level of contrast between the background and text colors. Often a black background and white text is used to prevent the background from "bleeding" over. These settings are critical for users with visual impairments.
fr: Les utilisateurs qui ont des problèmes de vision peuvent avoir besoin d'un fort niveau de contraste entre les couleurs de l'arrière-plan et du premier plan. Souvent un arrière-plan noir et du texte blanc empêche l'arrière-plan de « baver ». Ces paramètres sont critiques pour les utilisateurs malvoyants.

note: (itstool) path: listitem/para
en: Don't hard-code application colors. Some users need to use particular combinations of colors and levels of contrast to be able to read the screen comfortably. Therefore all the main colors you use in your GNOME application should be taken from the GTK theme, so the user can set the colors for all their applications to something legible just by changing the theme. If for some reason you do need to use colors that are not available in the theme, ensure they are customizable within the application itself.
fr: Ne codez pas de manière permanente les couleurs de l'application. Certains utilisateurs ont besoin de combinaisons de couleurs et de niveaux de contraste particuliers pour pouvoir lire l'écran confortablement. Les couleurs principales que vous utilisez dans votre application GNOME doivent donc provenir du thème GTK, pour que l'utilisateur puisse définir des couleurs lisibles pour toutes les applications simplement en changeant de thème. Si pour une raison quelconque, vous devez utiliser des couleurs qui ne sont pas disponibles dans le thème, assurez-vous qu'elles soient personnalisables dans l'application elle-même.

note: (itstool) path: listitem/para
en: Don't use color as the only means to distinguish items of information. All such information should be provided by at least one other method, such as shape, position or textual description. See <link linkend="gad-color-examples">Color and Contrast Examples</link>.
fr: N'utilisez pas la couleur comme seul moyen de distinguer les éléments d'informations. Toutes les informations doivent également être transmises par au moins une autre méthode parmi la forme, la position ou la description textuelle. Consultez la section <link linkend="gad-color-examples">exemples de couleurs et de contrastes</link>.

note: (itstool) path: listitem/para
en: Support all the high contrast GNOME themes. Ensure that when one of these themes is selected, all the text in your application appears in the high contrast foreground and background colors specified by the theme.
fr: Prenez en charge tous les thèmes à fort contraste de GNOME. Assurez-vous que lorsqu'un de ces thèmes est sélectionné, tous les textes de l'application s'affichent avec les couleurs de premier plan et d'arrière-plan de fort contraste spécifiées par le thème.

note: (itstool) path: listitem/para
en: Ensure your application is not dependent on a particular high-contrast theme. Test it with different high-contrast themes to ensure your application respects the settings.
fr: Assurez-vous que votre application n'est pas dépendante d'un thème à fort contraste particulier. Testez-la avec des différents thèmes à fort contraste pour vérifier que l'application respecte les réglages.

note: (itstool) path: section/title
en: Color and Contrast Examples
fr: Exemples de couleur et contraste

note: (itstool) path: example/title
en: Example illustrating redundant use of color
fr: Exemple d'utilisation redondante de couleurs

note: (itstool) path: entry/mediaobject
en: <imageobject> <imagedata fileref="figures/color_only.png" format="PNG"/> </imageobject> <textobject> <phrase>Example showing changes in stock price using color only</phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/color_only.png" format="PNG"/> </imageobject> <textobject> <phrase> Exemple montrant des modifications du prix d'action utilisant uniquement la couleur</phrase> </textobject>

note: (itstool) path: row/entry
en: This display could cause problems for a red-green color-blind user (color-blindness affects as many as 1 in 7 males in some parts of the world). The lack of contrast between the red text and black background would also make it hard to read for a user with low vision, even with a screen magnifier.
fr: Cet affichage peut causer des problèmes pour un utilisateur daltonien au rouge et vert (le daltonisme atteint jusqu'à un homme sur sept dans certaines parties du monde). Le manque de contraste entre le texte rouge et le fond noir rend aussi le texte peu lisible pour une personne ayant une vision faible, même en utilisant la loupe.

note: (itstool) path: entry/mediaobject
en: <imageobject> <imagedata fileref="figures/color_and_arrows.png" format="PNG"/> </imageobject> <textobject> <phrase>Example showing changes in stock price using both color and arrows</phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/color_and_arrows.png" format="PNG"/> </imageobject> <textobject> <phrase>Exemple montrant des modifications du prix d'action en utilisant la couleur et des flèches</phrase> </textobject>

note: (itstool) path: section/title (itstool) path: row/entry
en: Magnification
fr: Zoom

note: (itstool) path: section/para
en: Many users, even those not visually impaired, benefit from magnification of text and graphics. However, without magnification, a visually impaired user may not be able to access and use the program at all.
fr: De nombreux utilisateurs, même ceux qui n'ont pas de problème de vue, tirent profit d'un agrandissement du texte et des images. Par contre sans agrandissement, un utilisateur malvoyant ne pourra sûrement pas accéder et utiliser le programme.

note: (itstool) path: listitem/para
en: Provide the ability for the user to magnify the work area.
fr: Donnez la possibilité à l'utilisateur d'agrandir la zone de travail.

note: (itstool) path: listitem/para
en: Provide options in the application to scale the work area. Users need to have an option to magnify the work area 150% to 400% or more. Test the application to confirm the object you are viewing is not affected by changing the magnification settings.
fr: Fournissez des options dans l'application pour changer l'échelle de la zone de travail. Les utilisateurs ont besoin d'une option pour agrandir la zone de travail de 150 à 400% et même parfois plus. Testez l'application pour vérifier que l'objet visualisé reste insensible aux modifications de taille.

note: (itstool) path: section/para
en: People who have difficulty hearing, as well as those who work with the sound on their computers turned off, will be disadvantaged if your application relies on sound to convey information. In general, make sure that the user is able to have any audible information conveyed in other ways.
fr: Les personnes malentendantes, ainsi que celles qui coupent le son de l'ordinateur, seront désavantagées si votre application se base sur du son pour transmettre des informations. En général, assurez-vous que l'utilisateur puisse faire en sorte que les informations audio soient transmises d'une autre façon.

note: (itstool) path: listitem/para
en: Don't assume that a user will hear audio information. This applies as much to users with broken soundcards as it does to those with hearing impairments!
fr: Ne supposez pas qu'un utilisateur entendra les informations audio. Cela s'applique aussi bien aux utilisateurs dont la carte son est cassée qu'à ceux qui sont malentendants !

note: (itstool) path: listitem/para
en: Don't use audio as the only means of conveying information. Give the user the option to have all audio information provided in a visual way as well. This includes providing closed captioning or transcripts for any important spoken sound clips.
fr: N'utilisez pas l'audio comme seul moyen de transmettre les informations. Donnez la possibilité à l'utilisateur d'avoir aussi toutes les informations audio de façon visuelle. Ceci inclue la fourniture de légendes minutieuses ou de transcriptions de tous les messages sonores parlés importants.

note: (itstool) path: listitem/para
en: Allow users to configure frequency and volume of all warning beeps and other sounds. This includes being able to turn off sound altogether.
fr: Permettez aux utilisateurs de configurer la fréquence et le volume de toutes les alarmes sonores et des autres sons. Cela comprend aussi la possibilité d'une coupure complète du son.

note: (itstool) path: section/para
en: Used sparingly, animation can be useful for drawing attention to important information in your application - and it can look cool, too. However, it can be problematic for some users, so make sure they can turn it off.
fr: Utilisées avec parcimonie, les animations peuvent être utiles pour attirer l'attention vers des informations importantes dans votre application - et ça donne aussi un air branché. Cependant, cela peut causer des problèmes à certains utilisateurs donc, assurez-vous qu'ils puissent les désactiver.

note: (itstool) path: listitem/para
en: Don't use flashing or blinking elements having a frequency greater than 2 Hz and lower than 55 Hz. This includes text as well as any graphical objects. Anything in this frequency range may cause particular problems for users susceptible to visually-induced seizures. Note that there is no "safe" frequency, though. If flashing is essential, you should use the system's cursor blink frequency (which should itself be customizable), or allow users to configure the frequency themselves.
fr: N'utilisez pas d'éléments qui flashent ou qui clignotent à une fréquence supérieure à 2 Hz et inférieure à 55 Hz. Cela vaut pour le texte mais aussi pour les images. Toute valeur comprise entre ces fréquences peut causer des problèmes pour les utilisateurs susceptibles d'avoir des crises épileptiques induites par la vision. Notez qu'aucune gamme fréquentielle n'est sûre. Si le clignotement est essentiel, vous devez utiliser la fréquence de clignotement du curseur (qui devrait être personnalisable) ou permettre aux utilisateurs de choisir la fréquence eux-mêmes.

note: (itstool) path: listitem/para
en: Don't flash or blink large areas of the screen. Small areas are less likely to trigger seizures in those susceptible to them.
fr: Ne faites pas flasher ou clignoter de grandes zones de l'affichage. Des petites parties sont moins susceptibles de déclencher des crises chez les personnes sensibles.

note: (itstool) path: listitem/para
en: Make all animations optional. The animated information should be available in at least one non-animated format, at the user's request.
fr: Rendez toutes les animations optionnelles. Les informations animées doivent être disponibles au moins dans un format statique, à la demande de l'utilisateur.

note: (itstool) path: section/title (itstool) path: row/entry
en: Keyboard Focus
fr: Focus au clavier

note: (itstool) path: section/para
en: Showing the keyboard focus position clearly at all times is important, both for users with vision impairments as well as "power-users" who prefer to use the keyboard rather than the mouse. There should never be any confusion as to which control on the desktop has focus at any given time. You ought to be able to leave your computer with the focus on any widget in your application, then go off and phone your girlfriend or walk the dog until you've forgotten which widget you left it on. When you return, you should be able to tell straight away exactly which widget it was.
fr: Un affichage clair et permanent de la position du focus clavier est important pour les utilisateurs malvoyants ainsi que pour les « utilisateurs avancés » qui préfèrent utiliser le clavier plutôt que la souris. Il ne devrait jamais y avoir de confusion possible pour savoir lequel des contrôles sur le bureau possède le focus à un instant donné. Vous devez être capable de laisser votre ordinateur avec le focus sur n'importe quel élément graphique de l'application puis, d'aller téléphoner à votre ami(e), de sortir le chien jusqu'à ce que vous ayez oublié de quel élément graphique il s'agissait. Quand vous revenez, vous devez être capable de dire instantanément quel élément graphique possède le focus.

note: (itstool) path: listitem/para
en: Start focus at the most commonly used control. If no control in a window is deemed to be the "most" useful, start the focus at the first control in the window when that window is opened. Focus should not be started on the <guilabel>OK</guilabel> or <guilabel>Cancel</guilabel> buttons of a dialog even if they are the most commonly used controls, as they can always be activated immediately by pressing <keycap>Enter</keycap> or <keycap>Escape</keycap>.
fr: Au départ, donnez le focus au contrôle le plus utilisé. Si aucun contrôle ne peut être considéré comme le plus utilisé, donnez le focus au premier contrôle de la fenêtre quand celle-ci s'ouvre. Le focus ne doit pas être placé au départ sur les boutons <guilabel>Valider</guilabel> ou <guilabel>Annuler</guilabel> d'une boîte de dialogue, même si ce sont les plus utilisés, car ils peuvent toujours être activés immédiatement en appuyant sur <keycap>Entrée</keycap> ou <keycap>Échap</keycap>.

note: (itstool) path: listitem/para
en: Show current input focus clearly at all times. Remember that in controls that include a scrolling element, it is not always sufficient to highlight just the selected element inside that scrolling area, as it may not be visible. See <link linkend="gad-focus-examples">Keyboard Focus Examples</link>.
fr: Affichez le focus actuel de saisie clairement à tout moment. Rappelez-vous que dans les contrôles qui comprennent un élément de défilement, il n'est pas toujours suffisant de mettre en évidence l'élément sélectionné dans la zone de défilement car il peut ne pas être visible. Consultez les <link linkend="gad-focus-examples">exemples de focus clavier</link>.

note: (itstool) path: listitem/para
en: Show input focus only in the active window. Hide all primary visual focus indicators in all windows that do not have the focus and activation. If a single window has separate panes, only one pane should have the focus indicator, and focus indicators should be hidden in all other panes. If it's important to continue showing which item in an unfocused list is selected, for example, use a secondary focus indicator. See <link linkend="gad-focus-examples">Keyboard Focus Examples</link>.
fr: Affichez le focus de saisie seulement dans la fenêtre active. Masquez tous les indicateurs de focus visuel primaire de toutes les fenêtres qui ne sont pas actives ou n'ont pas le focus. Si une fenêtre possède plusieurs volets, un seul des volets doit avoir un indicateur de focus et les indicateurs de focus des autres volets doivent tous être cachés. S'il est important de continuer de montrer quel élément dans une liste sans focus est sélectionné, utilisez par exemple un indicateur de focus secondaire. Consultez les <link linkend="gad-focus-examples">exemples de focus clavier</link>.

note: (itstool) path: listitem/para
en: Provide appropriate feedback when the user attempts to navigate past the end of a group of related objects. When navigating a list, for example, stopping with audio feedback is usually preferable to moving the focus back to the first object in the list. Otherwise, users who are blind or have low vision may not realize they have returned to the beginning. In the case of a text search in a document, a dialog may pop up to indicate that the end of the document has been reached, and ask if you want to resume the search at the start of the document.
fr: Fournissez un retour d'information approprié lorsque l'utilisateur tente de naviguer au delà d'un groupe d'objets liés. Lors du parcours d'une liste, par exemple, s'arrêter avec l'émission d'un son est préférable au retour au début de la liste. Sinon les utilisateurs aveugles ou malvoyants peuvent ne pas s'apercevoir qu'ils sont retournés au début. Dans le cas d'une recherche de texte dans un document, une boite de dialogue peut être ouverte pour indiquer que la fin du document a été atteinte et demander si la recherche doit être reprise au début du document.

note: (itstool) path: listitem/para
en: Play the system default audio or visual warning signal when the user presses an inappropriate key, or when a navigation key fails to move the focus. For example, when the focus is on the first character in a text field and the user presses left arrow key, or the user tries to perform multiple selection in a single selection dialog. (Note that users with hearing difficulties should be able to configure a system-wide visual equivalent to the default warning sound.)
fr: Utilisez l'alerte audio ou visuelle par défaut du système lorsque l'utilisateur appuie sur une touche incorrecte, ou quand une touche de navigation ne peut déplacer le focus. Par exemple, quand le focus est sur le premier caractère dans un champ de texte et que l'utilisateur appuie sur la flèche gauche, ou quand l'utilisateur essaie de faire une sélection multiple dans un dialogue à sélection unique (notez que les utilisateurs ayant des problèmes auditifs doivent avoir la possibilité de configurer un équivalent visuel système à l'alerte sonore par défaut).

note: (itstool) path: section/title
en: Keyboard Focus Examples
fr: Exemples de focus clavier

note: (itstool) path: example/title
en: Example illustrating need to show focus clearly
fr: Exemple illustrant le besoin d'afficher le focus clairement

note: (itstool) path: entry/mediaobject
en: <imageobject> <imagedata fileref="figures/badfocus1.png" format="PNG"/> </imageobject> <textobject> <phrase>The focused item in this window cannot be seen because it has been scrolled off-screen</phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/badfocus1.png" format="PNG"/> </imageobject> <textobject> <phrase>L'élément ayant le focus dans cette fenêtre est invisible car il a été déplacé hors de vue à l'écran</phrase> </textobject>

note: (itstool) path: row/entry
en: One of the controls in this window has focus, but it's impossible to tell which...
fr: Un des contrôles dans cette fenêtre possède le focus, mais il est impossible de savoir lequel...

note: (itstool) path: entry/mediaobject
en: <imageobject> <imagedata fileref="figures/badfocus2.png" format="PNG"/> </imageobject> <textobject> <phrase>The focused item in the list has been brought into view by scrolling the list</phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/badfocus2.png" format="PNG"/> </imageobject> <textobject> <phrase>L'élément qui possède le focus dans la liste a été rendu visible en faisant défiler la liste</phrase> </textobject>

note: (itstool) path: row/entry
en: ...until you scroll the list, which reveals that one of its items is currently selected.
fr: ... jusqu'à ce que vous fassiez défiler la liste, ce qui montre qu'un des éléments de la liste est actuellement sélectionné.

note: (itstool) path: entry/mediaobject
en: <imageobject> <imagedata fileref="figures/goodfocus.png" format="PNG"/> </imageobject> <textobject> <phrase>The list control in this example has a solid border indicating focus, whether its selected item is currently visible or not</phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/goodfocus.png" format="PNG"/> </imageobject> <textobject> <phrase>Le contrôle de liste de cet exemple possède une bordure pleine indiquant le focus, que l'élément sélectionné soit visible ou non</phrase> </textobject>

note: (itstool) path: row/entry
en: If the list control itself is given a "focused" border, it's easy to tell it has focus even when the currently-selected item isn't visible.
fr: Si le contrôle de liste possède une bordure « de focus », il est facile de deviner qu'il possède le focus même si l'élément sélectionné n'est pas visible.

note: (itstool) path: example/title
en: Example illustrating use of secondary focus
fr: Exemple d'utilisation d'un focus secondaire

note: (itstool) path: entry/mediaobject
en: <imageobject> <imagedata fileref="figures/badfocus3.png" format="PNG"/> </imageobject> <textobject> <phrase>Split-paned window in which both panes seem to have focus</phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/badfocus3.png" format="PNG"/> </imageobject> <textobject> <phrase>Fenêtre séparée en deux volets dans laquelle les deux volets semblent avoir le focus</phrase> </textobject>

note: (itstool) path: row/entry
en: In this example, it's impossible to tell just by looking which of the two panes actually has keyboard focus.
fr: Dans cet exemple, il est impossible de dire, seulement en regardant, lequel des deux volets possède le focus clavier.

note: (itstool) path: entry/mediaobject
en: <imageobject> <imagedata fileref="figures/goodfocus3.png" format="PNG"/> </imageobject> <textobject> <phrase>Split-pane window in which secondary highlighting is used to show which pane has focus</phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/goodfocus3.png" format="PNG"/> </imageobject> <textobject> <phrase>Fenêtre séparée en deux volets dans laquelle la mise en évidence secondaire est utilisée pour indiquer le volet qui a le focus</phrase> </textobject>

note: (itstool) path: row/entry
en: By using a secondary selection highlight color in the inactive pane, it's immediately obvious that the tree control has focus here...
fr: Par l'utilisation d'une deuxième couleur de mise en évidence de sélection dans le volet inactif, il est immédiatement clair que le contrôle d'arborescence possède le focus ici...

note: (itstool) path: entry/mediaobject
en: <imageobject> <imagedata fileref="figures/goodfocus2.png" format="PNG"/> </imageobject> <textobject> <phrase>Split-pane window in which secondary highlighting is used to show which pane has focus</phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/goodfocus2.png" format="PNG"/> </imageobject> <textobject> <phrase>Fenêtre séparée en deux volets dans laquelle la mise en évidence secondaire est utilisée pour indiquer le volet qui a le focus</phrase> </textobject>

note: (itstool) path: row/entry
en: ...and that the list control has focus here.
fr: ... et que le contrôle de liste possède le focus ici.

note: (itstool) path: section/title (itstool) path: row/entry
en: Timing
fr: Synchronisation

note: (itstool) path: section/para
en: Interfaces in which things appear, disappear or happen according to some hard-coded time limit are often a hindrance to accessibility. Some users may read, type or react very slowly in comparison to others. If information they require is hidden before they are finished with it, or obscured by other information popping up which they didn't explicitly request, then your application will become very frustrating or even impossible to use.
fr: Les interfaces où des choses apparaissent, disparaissent ou se produisent à des instants figés de façon permanente causent souvent des problèmes d'accessibilité. Certains utilisateurs lisent, saisissent ou réagissent très lentement par rapport à d'autres. Si les informations dont ils ont besoin sont masquées avant d'en avoir terminé avec elles ou que d'autres informations les cachent, sans qu'elles aient été demandées explicitement, alors votre application est très frustrante ou même impossible à utiliser.

note: (itstool) path: listitem/para
en: Don't hard-code timeouts or other time-based features. Examples include automatic scrolling when dragging an object towards the edge of a window, holding down a scrollbar button, or automatically expanding a tree node when an object is dragged over it and held for a short time. These should either be customizable in the application, the GNOME control center, or at worst, manually editable from the command line via a configuration file or GConf entry.
fr: Ne codez pas de façon permanente des délais ou des fonctions basées sur le temps. Quelques exemples sont le défilement automatique lorsqu'un objet est déplacé près du bord d'une fenêtre, l'enfoncement du bouton d'une barre de défilement, ou le développement automatiquement d'une arborescence lorsqu'un objet est déplacé et laissé un court moment au-dessus d'elle. Ceux-ci doivent être configurables dans l'application, via le centre de contrôle de GNOME ou, au pire, modifiable manuellement depuis la ligne de commande, via un fichier de configuration ou une entrée Gconf.

note: (itstool) path: listitem/para
en: Don't briefly show or hide information based on the movement of the mouse pointer. (Exception: system-provided features such as tooltips, which the user can configure on a system-wide level). If you must provide such features, make them optional so users can turn them off when a screen-review utility is installed.
fr: N'affichez ou ne cachez pas brièvement des informations en fonction du mouvement du pointeur de souris (sauf pour les fonctions du système telles que les infobulles que l'utilisateur peut configurer au niveau du système). Si vous devez fournir de telles fonctions, assurez-vous qu'elles soient optionnelles afin que les utilisateurs puissent les désactiver quand un lecteur d'écran est installé.

note: (itstool) path: section/para
en: People with disabilities cannot use the application effectively if they do not have access to the required manuals and help files. Of particular importance is keyboard navigation, since this is the only way many users can navigate the application.
fr: Les personnes avec des handicaps ne peuvent pas utiliser l'application de manière efficace s'ils n'ont pas accès aux manuels et aux fichiers d'aide nécessaires. La navigation au clavier est particulièrement importante, car c'est le seul moyen pour de nombreux utilisateurs de parcourir l'application.

note: (itstool) path: listitem/para
en: Provide all documentation in an accessible format. ASCII text and HTML are both excellent formats for assistive technologies.
fr: Fournissez toute la documentation dans un format accessible. Le texte au format ASCII et HTML sont tous deux excellents pour les technologies d'assistance.

note: (itstool) path: listitem/para
en: Provide alternative text descriptions for all graphics in the documentation.
fr: Fournissez des descriptions alternatives textuelles pour toutes les illustrations de la documentation.

note: (itstool) path: listitem/para
en: Document all your application's accessibility features. Keyboard navigation and shortcuts are particularly important to document. Include an accessibility section in your documentation, where information on all the accessibility features can be found.
fr: Documentez toutes les fonctionnalités d'accessibilité de votre application. Il est particulièrement important de documenter la navigation au clavier et les raccourcis. Ajoutez une section accessibilité à votre documentation contenant les informations spécifiques à l'accessibilité.

note: (itstool) path: chapter/title
en: Testing
fr: Test

note: (itstool) path: chapter/para
en: There are several points of review to conduct before declaring an application accessible. Over the course of development you may want to consider automated testing techniques. <ulink url="http://ldtp.freedesktop.org/">LDTP</ulink>, for example, may complement your automated testing plan.
fr: Il y a de nombreux points de contrôles à vérifier avant de déclarer qu'une application est accessible. Au cours du développement, vous pouvez vouloir utiliser des techniques de tests automatisées. Par exemple, <ulink url="http://ldtp.freedesktop.org/">LDTP</ulink> peut compléter votre plan de test automatisé.

note: (itstool) path: chapter/para
en: This section describes a number of tests you can perform manually on an application to test its accessibility. Passing all the tests does not necessarily imply that the application is fully accessible, but if the application fails any of these tests, then further work may need to be done to improve that aspect of its accessibility.
fr: Cette section décrit un certain nombre de tests que vous pouvez effectuer manuellement sur une application pour tester son accessibilité. Même si tous les tests sont réussis, cela ne veut pas nécessairement dire que l'application est entièrement accessible, par contre si l'application ne passe pas un de ces tests, du travail complémentaire doit être fait pour améliorer cet aspect de son accessibilité.

note: (itstool) path: section/para
en: The following keyboard operations should be tested. Do not use the mouse in any part of this test.
fr: Les opérations au clavier suivantes doivent être testées. N'utilisez pas la souris dans ce qui suit.

note: (itstool) path: listitem/para
en: Using only keyboard commands, move the focus through all menu bars in the application.
fr: Uniquement à l'aide du clavier, déplacez le focus dans toutes les barres de menu de l'application.

note: (itstool) path: listitem/para
en: Confirm that:
fr: Vérifiez que :

note: (itstool) path: listitem/para
en: Context sensitive menus display correctly.
fr: les menus contextuels s'affichent correctement,

note: (itstool) path: listitem/para
en: Any functions listed on the toolbar can be performed using the keyboard.
fr: toutes les fonctions énumérées dans la barre d'outils peuvent être réalisées grâce au clavier,

note: (itstool) path: listitem/para
en: You can operate every control in the client area of the application and dialog boxes.
fr: vous pouvez actionner chaque contrôle dans la zone client de l'application et dans les boîtes de dialogue,

note: (itstool) path: listitem/para
en: Text and objects within the client area can be selected.
fr: le texte et les objets dans la zone client peuvent être sélectionnés,

note: (itstool) path: listitem/para
en: Any keyboard enhancements or shortcuts are working as designed.
fr: tous les raccourcis clavier ou touches de raccourci fonctionnent comme prévu.

note: (itstool) path: section/para
en: Test the application using a screen reader and confirm that:
fr: Testez l'application avec un lecteur d'écran et vérifiez que :

note: (itstool) path: listitem/para
en: Labels and text are being read correctly, including menus and toolbars.
fr: les étiquettes et le texte sont lus correctement, ainsi que les menus et les barres d'outils,

note: (itstool) path: listitem/para
en: Object information is read correctly.
fr: les informations des objets sont lues correctement.

note: (itstool) path: section/title
en: Visual Focus Indicator
fr: Indicateur de focus visuel

note: (itstool) path: listitem/para
en: Verify that when moving among objects that the visual focus indicator is easy to identify.
fr: Vérifiez que lors de déplacements parmi les objets, l'indicateur de focus visuel est facile à identifier.

note: (itstool) path: listitem/para
en: Keyboard navigation through the software and menus should be clearly visible when the focus moves.
fr: La navigation au clavier dans le logiciel et les menus doit être clairement visible lors du déplacement du focus.

note: (itstool) path: listitem/para
en: Confirm that the screen reader is tracking the visual focus indicator as you navigate using a keyboard.
fr: Vérifiez que le lecteur d'écran suit l'indicateur de focus visuel lors de vos déplacements à l'aide du clavier.

note: (itstool) path: listitem/para
en: Run a screen magnification program (if available) and verify that the magnifier can track the visual focus indicator as you navigate using the keyboard and mouse.
fr: Utilisez le programme de loupe d'écran (s'il est disponible) et vérifiez que la loupe suit l'indicateur de focus visuel quand vous naviguez avec le clavier et la souris.

note: (itstool) path: listitem/para
en: Change the font in the application and confirm that the settings are maintained.
fr: Modifiez la police de l'application et vérifiez que les réglages sont conservés.

note: (itstool) path: listitem/para
en: Test the application by changing colors and confirm that all settings are maintained.
fr: Testez l'application en changeant les couleurs et vérifiez que tous les réglages sont conservés.

note: (itstool) path: listitem/para
en: If magnification is available, test the font, color, and size using the magnification option.
fr: Si un zoom est possible, testez la police, la couleur et la taille en utilisant les options de zoom.

note: (itstool) path: listitem/para
en: Print screenshots to a black and white printer and confirm that all information is visible.
fr: Imprimez des captures d'écran en noir et blanc et vérifiez que toutes les informations sont visibles.

note: (itstool) path: listitem/para
en: Test applications using only black and white, high-contrast settings and confirm that all information is conveyed correctly.
fr: Testez l'application en utilisant des réglages en noir et blanc uniquement et un fort contraste et vérifiez que toutes les informations sont transmises correctement.

note: (itstool) path: listitem/para
en: Test that the application provides at least three combinations of color schemes and that high-contrast schemes are available (e.g. white on black or yellow on blue).
fr: Testez que l'application fournit au moins trois combinaisons de schémas de couleurs et que des thèmes à fort contraste sont disponibles (par ex. blanc sur noir ou jaune sur bleu).

note: (itstool) path: listitem/para
en: Turn on high-contrast settings in the GNOME Control Center and confirm that the application respects these settings.
fr: Activez les paramètres à fort contraste dans le centre de contrôle de GNOME et vérifiez que l'application respecte ces paramètres.

note: (itstool) path: listitem/para
en: Test various themes to ensure that the software is working for all the available settings.
fr: Testez plusieurs thèmes pour vous assurer que le logiciel fonctionne pour tous les réglages disponibles.

note: (itstool) path: section/para
en: There should be an option in the application to show audio alerts visually.
fr: L'application doit posséder une option pour afficher à l'écran les alertes sonores.

note: (itstool) path: section/para
en: Test that the audio is working correctly by enabling sound in the GNOME Control Center and then perform the following actions:
fr: Vérifiez que le son fonctionne correctement en activant le son dans le centre de contrôle GNOME puis effectuez les tâches suivantes :

note: (itstool) path: listitem/para
en: Perform an action that should generate an audio alert and confirm that the application is working as designed.
fr: effectuez une action qui doit générer une alerte sonore et vérifiez que l'application fonctionne comme prévu,

note: (itstool) path: listitem/para
en: Verify that the application works correctly when increasing or decreasing the volume.
fr: vérifiez que l'application fonctionne correctement quand vous baissez ou augmentez le volume,

note: (itstool) path: listitem/para
en: Confirm that warning messages and alerts can be heard correctly in a noisy work environment.
fr: vérifiez que les messages d'avertissement et les alertes peuvent être entendus correctement dans un environnement de travail bruyant.

note: (itstool) path: section/para
en: Verify that an option is available to stop animation and that it is working as designed.
fr: Vérifiez qu'une option est disponible pour arrêter les animations et qu'elle fonctionne comme prévu.

note: (itstool) path: section/para
en: Turn the animation off. Confirm that all information is still conveyed correctly.
fr: Désactivez les animations. Vérifiez que toutes les informations sont toujours transmises correctement.

note: (itstool) path: listitem/para
en: Test all messages to confirm that the user is notified before a message times out and is given the option to indicate that more time is needed.
fr: Testez tous les messages pour vérifier que l'utilisateur est averti avant qu'il ne disparaisse et que l'option pour augmenter ce délai est disponible.

note: (itstool) path: listitem/para
en: Make sure an option has been included to adjust the response time and confirm that it is working as designed.
fr: Assurez-vous qu'il existe une option pour ajuster le temps de réponse et vérifiez qu'elle fonctionne comme prévu.

note: (itstool) path: section/para
en: Test ASCII text documentation with a screen reader to confirm that it is clear and precise and can be read by assistive technologies.
fr: Testez la documentation en texte ASCII avec un lecteur d'écran pour vérifier qu'elle est claire et précise et peut être lue par les technologies d'assistance.

note: (itstool) path: section/para
en: Test HTML applications using a web browser and screen reader to confirm that the documentation is accessible to assistive technologies.
fr: Testez les applications HTML en utilisant un navigateur Web et un lecteur d'écran pour vérifiez que la documentation est accessible aux technologies d'assistance.

note: (itstool) path: section/para
en: Note: There are web accessibility guidelines available at <ulink url="http://www.w3.org/TR/WAI-WEBCONTENT/">http://www.w3.org/TR/WAI-WEBCONTENT/</ulink>.
fr: Note : des directives pour l'accessibilité Web sont disponibles à l'adresse : <ulink url="http://www.w3.org/TR/WAI-WEBCONTENT/">http://www.w3.org/TR/WAI-WEBCONTENT/</ulink>.

note: (itstool) path: section/para
en: Confirm the following information is included in the documentation:
fr: Vérifiez que les informations suivantes sont contenues dans la documentation :

note: (itstool) path: listitem/para
en: State if the application does not support the standard keyboard access used by the OS.
fr: Indication si l'application ne prend pas en charge l'accès clavier standard utilisé par le système d'exploitation.

note: (itstool) path: listitem/para
en: Identify if there are unique keyboard commands.
fr: Identification des commandes clavier particulières.

note: (itstool) path: listitem/para
en: Identify any unique accessibility features.
fr: Identification de toutes les fonctions d'accessibilité particulières.

note: (itstool) path: listitem/para
en: If an action is documented for the mouse, make sure there is an alternative for using the keyboard.
fr: Si une action est documentée pour la souris, assurez-vous qu'il y ait une alternative au clavier.

note: (itstool) path: section/title
en: User Interface Checklist
fr: Liste de contrôle de l'interface utilisateur

note: (itstool) path: section/para
en: This section summarizes the guidelines given in <link linkend="gad-ui-guidelines">User Interface Guidelines for Supporting Accessibility</link>. You should refer to that section of the guide for more detailed information on any of the checklist items given here.
fr: Cette section résume les directives données par les <link linkend="gad-ui-guidelines">directives pour la prise en charge de l'accessibilité dans l'interface utilisateur</link>. Vous devez vous référer à cette section du guide pour plus d'informations sur les éléments de la liste de contrôle donnés ici.

note: (itstool) path: section/para
en: When testing an application for accessibility, you should go through each of the items in the list. Note whether the application passes or fails each test, or does not apply to that application.
fr: Quand vous testez une application pour l'accessibilité, vous devez valider chaque élément de la liste. Pour chaque test, notez si l'application passe ou échoue ou si cela ne s'applique pas à l'application.

note: (itstool) path: table/title
en: General Principles checklist
fr: Liste de contrôle des principes généraux

note: (itstool) path: row/entry
en: GP
fr: PG

note: (itstool) path: row/entry
en: General Principles
fr: Principes généraux

note: (itstool) path: row/entry
en: Pass/Fail/NA
fr: Succès/échec/NA

note: (itstool) path: row/entry
en: GP.1
fr: PG.1

note: (itstool) path: row/entry
en: Every action that alters the user's data or application's settings can be undone.
fr: Toutes les actions qui modifient les données de l'utilisateur ou les paramètres de l'application peuvent être annulées.

note: (itstool) path: row/entry
en: GP.2
fr: PG.2

note: (itstool) path: row/entry
en: All application settings can be restored to their defaults without the user having to remember what those defaults were.
fr: Tous les paramètres de l'application peuvent être restaurés sans que l'utilisateur n'ait à se rappeler quels étaient les paramètres par défaut.

note: (itstool) path: row/entry
en: GP.3
fr: PG.3

note: (itstool) path: row/entry
en: After installation, the application can be used without the user having to insert a disk or CD at any time.
fr: Après l'installation, l'application peut être utilisée sans que l'utilisateur n'ait à aucun moment à insérer une disquette ou un CD.

note: (itstool) path: row/entry
en: GP.4
fr: PG.4

note: (itstool) path: row/entry
en: The most frequently used functions are found at the top level of the menu structure.
fr: Les fonctions les plus fréquemment utilisées se trouvent au premier niveau de la structure des menus.

note: (itstool) path: table/title
en: Keyboard navigation checklist
fr: Liste de contrôle de la navigation à l'aide du clavier

note: (itstool) path: row/entry
en: KN
fr: NC

note: (itstool) path: row/entry
en: KN.1
fr: NC.1

note: (itstool) path: row/entry
en: Efficient keyboard access is provided to all application features.
fr: Toutes les fonctions de l'application sont disponibles de manière efficace avec le clavier.

note: (itstool) path: row/entry
en: KN.2
fr: NC.2

note: (itstool) path: row/entry
en: All windows have a logical keyboard navigation order.
fr: L'ordre de navigation au clavier est logique dans toutes les fenêtres.

note: (itstool) path: row/entry
en: KN.3
fr: NC.3

note: (itstool) path: row/entry
en: The correct tab order is used for controls whose enabled state is dependent on checkboxes, radio buttons or toggle buttons.
fr: L'ordre de tabulation correct est utilisé pour les contrôles dont l'activation dépend de cases à cocher, boutons radio ou boutons poussoir.

note: (itstool) path: row/entry
en: KN.4
fr: NC.4

note: (itstool) path: row/entry
en: Keyboard access to application-specific functions does not override existing system accessibility features.
fr: Les touches d'accès clavier spécifiques de l'application ne supplantent pas les fonctions d'accessibilité du système.

note: (itstool) path: row/entry
en: KN.5
fr: NC.5

note: (itstool) path: row/entry
en: The application provides more than one method to perform keyboard tasks whenever possible.
fr: L'application fournit, quand c'est possible, plus d'une méthode pour effectuer les tâches au clavier.

note: (itstool) path: row/entry
en: KN.6
fr: NC.6

note: (itstool) path: row/entry
en: There are alternative key combinations wherever possible.
fr: Il existe des combinaisons de touches alternatives partout où c'est possible.

note: (itstool) path: row/entry
en: KN.7
fr: NC.7

note: (itstool) path: row/entry
en: There are no awkward reaches for frequently performed keyboard operations.
fr: Il n'y a pas de combinaisons de touches difficiles à effectuer pour les opérations clavier fréquentes.

note: (itstool) path: row/entry
en: KN.8
fr: NC.8

note: (itstool) path: row/entry
en: The application does not use repetitive, simultaneous keypresses.
fr: L'application n'utilise pas de combinaisons d'enfoncements de touches simultanés et répétitifs.

note: (itstool) path: row/entry
en: KN.9
fr: NC.9

note: (itstool) path: row/entry
en: The application provides keyboard equivalents for all mouse functions.
fr: L'application fournit un accès au clavier équivalent pour toutes les fonctions de la souris.

note: (itstool) path: row/entry
en: KN.10
fr: NC.10

note: (itstool) path: row/entry
en: Any text or object that can be selected with the mouse can also be selected with the keyboard alone.
fr: Tous les textes ou objets qui peuvent être sélectionnés avec la souris, peuvent l'être aussi uniquement à l'aide du clavier.

note: (itstool) path: row/entry
en: KN.11
fr: NC.11

note: (itstool) path: row/entry
en: Any object that can be resized or moved with the mouse can also be resized or moved with the keyboard alone.
fr: Tous les texte ou objets qui peuvent être redimensionnés ou déplacés avec la souris peuvent l'être aussi uniquement avec le clavier.

note: (itstool) path: row/entry
en: KN.12
fr: NC.12

note: (itstool) path: row/entry
en: The application does not use any general navigation functions to trigger operations.
fr: L'application n'utilise pas de fonctions de navigation générales pour déclencher des opérations.

note: (itstool) path: row/entry
en: KN.13
fr: NC.13

note: (itstool) path: row/entry
en: All keyboard-invoked menus, windows and tooltips appear near the object they relate to.
fr: Tous les menus appelés via le clavier, toutes les fenêtres et les infobulles apparaissent près des objets auxquels ils sont liés.

note: (itstool) path: table/title
en: Mouse Interaction checklist
fr: Liste de contrôle de l'interaction avec la souris

note: (itstool) path: row/entry
en: MI
fr: IS

note: (itstool) path: row/entry
en: MI.1
fr: IS.1

note: (itstool) path: row/entry
en: No operations depend on input from the <mousebutton>right</mousebutton> or <mousebutton>middle</mousebutton> mouse buttons.
fr: Aucune opération ne dépend d'appui sur les boutons <mousebutton>droit</mousebutton> ou <mousebutton>central</mousebutton> de la souris.

note: (itstool) path: row/entry
en: MI.2
fr: IS.2

note: (itstool) path: row/entry
en: All mouse operations can be cancelled before they are complete.
fr: Toutes les opérations de la souris peuvent être annulées avant qu'elles ne se terminent.

note: (itstool) path: row/entry
en: MI.3
fr: IS.3

note: (itstool) path: row/entry
en: Visual feedback is provided throughout drag and drop operations
fr: Un retour visuel d'informations est fourni pendant les opérations de glisser-déposer.

note: (itstool) path: row/entry
en: MI.4
fr: IS.4

note: (itstool) path: row/entry
en: The mouse pointer is never warped under application control, or its movement restricted to part of the screen by the application.
fr: Le pointeur de souris n'est jamais mis sous contrôle de l'application ou son mouvement n'est pas restreint à une partie de l'écran par l'application.

note: (itstool) path: table/title
en: Graphical Elements checklist
fr: Liste de contrôle des éléments graphiques

note: (itstool) path: row/entry
en: GE
fr: EG

note: (itstool) path: row/entry
en: GE.1
fr: EG.1

note: (itstool) path: row/entry
en: There are no hard-coded graphical attributes such as line, border or shadow thickness.
fr: Il n'y a pas d'attribut graphique codé de manière permanente comme l'épaisseur des lignes, bordures ou ombres.

note: (itstool) path: row/entry
en: GE.2
fr: EG.2

note: (itstool) path: row/entry
en: All multi-color graphical elements can be shown in monochrome only, where possible.
fr: Tous les éléments graphiques multicolores peuvent être affichés, si possible, en monochrome.

note: (itstool) path: row/entry
en: GE.3
fr: EG.3

note: (itstool) path: row/entry
en: All interactive GUI elements are easily distinguishable from static GUI elements.
fr: Tous les éléments interactifs de l'interface graphique sont facilement différentiables des éléments statiques.

note: (itstool) path: row/entry
en: GE.4
fr: EG.4

note: (itstool) path: row/entry
en: An option to hide non-essential graphics is provided.
fr: Il existe une option pour masquer les images non essentielles.

note: (itstool) path: table/title
en: Fonts and Text checklist
fr: Liste de contrôle de la police et du texte

note: (itstool) path: row/entry
en: FT
fr: PT

note: (itstool) path: row/entry
en: FT.1
fr: PT.1

note: (itstool) path: row/entry
en: No font styles or sizes are hard-coded.
fr: Le style et la taille des polices ne sont pas codés de manière permanente.

note: (itstool) path: row/entry
en: FT.2
fr: PT.2

note: (itstool) path: row/entry
en: An option to turn off graphical backdrops behind text is provided.
fr: Il existe une option pour désactiver les toiles de fond graphiques derrière le texte.

note: (itstool) path: row/entry
en: FT.3
fr: PT.3

note: (itstool) path: row/entry
en: All labels have names that make sense when taken out of context.
fr: Toutes les étiquettes possèdent des noms compréhensibles hors contexte.

note: (itstool) path: row/entry
en: FT.4
fr: PT.4

note: (itstool) path: row/entry
en: No label names are used more than once in the same window.
fr: Aucun nom d'étiquette n'est utilisé plusieurs fois dans la même fenêtre.

note: (itstool) path: row/entry
en: FT.5
fr: PT.5

note: (itstool) path: row/entry
en: Label positioning is consistent throughout the application.
fr: La position des étiquettes est homogène dans toute l'application.

note: (itstool) path: row/entry
en: FT.6
fr: PT.6

note: (itstool) path: row/entry
en: All static text labels that identify other controls end in a colon (:).
fr: Toutes les étiquettes textuelles statiques qui identifient d'autres contrôles se terminent par deux points (:).

note: (itstool) path: row/entry
en: FT.7
fr: PT.7

note: (itstool) path: row/entry
en: Static text labels that identify other controls immediately precede those controls in the tab order.
fr: Les étiquettes textuelles statiques qui décrivent d'autres contrôles, précèdent immédiatement ceux-ci dans l'ordre de tabulation.

note: (itstool) path: row/entry
en: FT.8
fr: PT.8

note: (itstool) path: row/entry
en: An alternative to WYSIWYG is provided. For example, the ability to specify different screen and printer fonts in a text editor.
fr: Il existe une alternative au WYSIWYG. Par exemple, la possibilité de spécifier des polices d'affichage et d'impression différentes pour un éditeur de texte.

note: (itstool) path: table/title
en: Color and Contrast checklist
fr: Liste de contrôle des couleurs et du contraste

note: (itstool) path: row/entry
en: Application colors are not hard-coded, but are drawn either from the current desktop theme or an application setting.
fr: Les couleurs de l'application ne sont pas codées de manière permanente, mais sont extraites du thème de bureau actuel ou des paramètres de l'application.

note: (itstool) path: row/entry
en: Color is only used as an enhancement, and not as the only means to convey information or actions.
fr: La couleur n'est utilisée que pour mettre en évidence et non pas comme seul moyen de transmettre des informations ou des actions.

note: (itstool) path: row/entry
en: The application supports all available high- contrast themes and settings.
fr: L'application prend en charge tous les thèmes et paramètres à fort contraste disponibles.

note: (itstool) path: row/entry
en: The software is not dependent on any particular high-contrast themes or settings.
fr: Le logiciel ne dépend pas d'un thème ou de paramètres à fort contraste particuliers.

note: (itstool) path: table/title
en: Magnification checklist
fr: Liste de contrôle des agrandissements

note: (itstool) path: row/entry
en: MG
fr: AG

note: (itstool) path: row/entry
en: MG.1
fr: AG.1

note: (itstool) path: row/entry
en: The application provides the ability to magnify the work area.
fr: L'application fournit la possibilité à l'utilisateur de faire un zoom de la zone de travail.

note: (itstool) path: row/entry
en: MG.2
fr: AG.2

note: (itstool) path: row/entry
en: The application provides the option to scale the work area.
fr: L'application fournit l'option de modifier l'échelle de la zone de travail.

note: (itstool) path: row/entry
en: MG.3
fr: AG.3

note: (itstool) path: row/entry
en: The application's functionality is not affected by changing the magnification or scale settings.
fr: Les fonctionnalités de l'application ne sont pas affectées par l'utilisation d'un agrandissement ou des paramètres d'échelles.

note: (itstool) path: table/title
en: Audio checklist
fr: Liste de contrôle audio

note: (itstool) path: row/entry
en: Sound is not used as the only means of conveying any items of information.
fr: Le son n'est pas utilisé comme seul moyen de transmettre une partie des informations.

note: (itstool) path: row/entry
en: The user can configure the frequency and volume of all sounds and warning beeps.
fr: L'utilisateur peut configurer la fréquence et le volume de tous les sons et les messages sonores d'alerte.

note: (itstool) path: table/title
en: Animation checklist
fr: Liste de contrôle des animations

note: (itstool) path: row/entry
en: There are no flashing or blinking elements with a frequency greater than 2Hz or lower than 55Hz.
fr: Il n'y a pas d'élément qui flashe ou clignote à une fréquence comprise entre 2 et 55 Hz.

note: (itstool) path: row/entry
en: Any flashing or blinking is confined to small areas of the screen.
fr: Tout flash ou clignotement est restreint à une petite partie de l'écran.

note: (itstool) path: row/entry
en: If animation is used, an option is available to turn it off before it is first shown.
fr: Si une animation est utilisée, il existe une option pour la désactiver avant qu'elle ne soit affichée.

note: (itstool) path: table/title
en: Keyboard Focus checklist
fr: Liste de contrôle du focus clavier

note: (itstool) path: row/entry
en: KF
fr: FC

note: (itstool) path: row/entry
en: KF.1
fr: FC.1

note: (itstool) path: row/entry
en: When a window is opened, focus starts at the most commonly-used control.
fr: Quand une fenêtre est ouverte, le focus est donné au contrôle le plus utilisé.

note: (itstool) path: row/entry
en: KF.2
fr: FC.2

note: (itstool) path: row/entry
en: Current input focus position is clearly displayed at all times.
fr: La position actuelle du focus de saisie est clairement affichée à tout moment.

note: (itstool) path: row/entry
en: KF.3
fr: FC.3

note: (itstool) path: row/entry
en: Input focus is shown in exactly one window at all times.
fr: La position du focus de saisie n'est affichée que dans une seule fenêtre à la fois.

note: (itstool) path: row/entry
en: KF.4
fr: FC.4

note: (itstool) path: row/entry
en: Appropriate audio or visual feedback is provided when the user attempts to navigate past either end of a group of related objects.
fr: Un retour d'information sonore ou visuel est fourni quand l'utilisateur tente de naviguer au delà du début ou de la fin d'un groupe d'objets liés.

note: (itstool) path: row/entry
en: KF.5
fr: FC.5

note: (itstool) path: row/entry
en: The default audio or visual warning signal is played when the user presses an inappropriate key.
fr: Le signal d'avertissement sonore ou visuel par défaut est utilisé lorsque l'utilisateur appuie sur une touche incorrecte.

note: (itstool) path: row/entry
en: KF.6
fr: FC.6

note: (itstool) path: row/entry
en: There is sufficient audio information for the visual focus that the user can figure out what to do next.
fr: Il y a suffisamment d'informations audio concernant le focus visuel pour que l'utilisateur sache ce qu'il doit faire ensuite.

note: (itstool) path: row/entry
en: KF.7
fr: FC.7

note: (itstool) path: row/entry
en: When using assistive technologies, such as a screen reader or braille device, the current program indicates the position and content of the visual focus indicator.
fr: Pendant l'utilisation de technologies d'assistance, comme un lecteur d'écran ou un périphérique pour le braille, le programme actuel indique la position et le contenu de l'indicateur de focus visuel.

note: (itstool) path: table/title
en: Timing checklist
fr: Liste de contrôle pour la synchronisation

note: (itstool) path: row/entry
en: TM
fr: SC

note: (itstool) path: row/entry
en: TM.1
fr: SC.1

note: (itstool) path: row/entry
en: There are no hard-coded time-outs or time-based features in the application.
fr: Il n'y a pas de délai ou de fonction basée sur le temps, codés de manière permanente dans l'application.

note: (itstool) path: row/entry
en: TM.2
fr: SC.2

note: (itstool) path: row/entry
en: The display or hiding of important information is not triggered solely by movement of the mouse pointer.
fr: L'affichage ou le masquage d'informations importantes ne sont pas déclenchés uniquement par des déplacements de la souris.

note: (itstool) path: table/title
en: Documentation checklist
fr: Liste de contrôle de la documentation

note: (itstool) path: row/entry
en: All documentation is in an accessible format, with textual alternate descriptions provided for all figures and diagrams.
fr: Toute la documentation est dans un format accessible, avec des descriptions alternatives fournies pour toutes les figures et diagrammes.

note: (itstool) path: row/entry
en: The documentation includes a section that covers all the application's accessibility features.
fr: La documentation contient une section décrivant toutes les fonctions d'accessibilité.

note: (itstool) path: section/title
en: GOK (GNOME Onscreen Keyboard)
fr: GOK (GNOME Onscreen Keyboard) : clavier visuel GNOME

note: (itstool) path: note/para
en: The information on this page is partially outdated: GNOME 3's <application><ulink url="http://wiki.gnome.org/Caribou">Caribou</ulink></application> has effectively replaced GNOME 2's <application>gok</application>.
fr: Les informations sur cette page sont partiellement dépassées : <application><ulink url="http://wiki.gnome.org/Caribou">Caribou</ulink></application> de GNOME 3 a efficacement remplacé <application>gok</application> de GNOME 2.

note: (itstool) path: section/para
en: Your application should be usable via <application>gok</application>; key input should be generated entirely by <application>gok</application>, not the keyboard. The aim here would be to work with your application and the desktop in general, ensuring any type of character input can be performed with the on-screen keyboard.
fr: Votre application doit être utilisable avec <application>gok</application> ; la saisie clavier doit être entièrement réalisée par <application>gok</application> et pas par le clavier. Le but ici est de travailler avec votre application, et le bureau en général, pour vous assurer que la saisie de tous types de caractères est possible avec le clavier visuel.

note: (itstool) path: section/para
en: The <application>gok</application> application ships with the GNOME Desktop so should already be present. For full documentation, refer to <ulink url="http://www.gok.ca">the official gok site</ulink>.
fr: L'application <application>gok</application> est fournie avec le bureau GNOME et devrait donc déjà être présente. Pour une documentation complète, consultez le <ulink url="http://www.gok.ca">site officiel de gok</ulink>.

note: (itstool) path: section/para
en: Follow these steps to verify the correct operation of <application>gok</application> with your application:
fr: Suivez les étapes suivantes pour vérifier le fonctionnement correct de <application>gok</application> avec votre application :

note: (itstool) path: step/para
en: Login into the GNOME desktop
fr: Connectez-vous au bureau GNOME

note: (itstool) path: step/para
en: Run <application>gok</application>
fr: Lancez <application>gok</application>

note: (itstool) path: step/para
en: Start your application
fr: Démarrez votre programme

note: (itstool) path: step/para
en: Provide input to your application with a pointing device (e.g., mouse or head-tracker) and <application>gok</application>.
fr: Fournissez des entrées à votre application à l'aide d'un périphérique de pointage (par ex. souris ou capteur de mouvements de tête) et <application>gok</application>.

note: (itstool) path: step/para
en: Work using the auto-completion and word prediction features of <application>gok</application>.
fr: Utilisez les fonctions de prédiction de mot et d'auto-complétion de <application>gok</application>.

note: (itstool) path: step/para
en: Verify that <application>gok</application> enables and disables the <guibutton>Menus</guibutton> and <guibutton>Toolbars</guibutton> buttons based on the kind of application invoked; for example, the <guibutton>Menus</guibutton> and <guibutton>Toolbars</guibutton> buttons are disabled for the 'Font properties' capplet, but the same buttons are enabled for the <application>Gedit</application> application.
fr: Vérifiez que <application>gok</application> active et désactive les <guibutton>menus</guibutton> et les boutons des <guibutton>barres d'outils</guibutton> en fonction du type d'application appelée ; par exemple, les <guibutton>menus</guibutton> et les boutons des <guibutton>barres d'outils</guibutton> sont désactivés pour la capplet « Propriétés de la police » , mais ces mêmes boutons sont activés pour l'application <application>Gedit</application>.

note: (itstool) path: step/para
en: Verify that the <application>gok</application> on-screen keyboard provided by the <guibutton>Compose</guibutton> button can be used to type in any text for the selected application; run <application>Gedit</application>, click on the text area, and then click on the <guibutton>Compose</guibutton> button in <application>gok</application>. Select the required keys from the on-screen keyboard. The characters should appear in the <application>Gedit</application> text area.
fr: Vérifiez que la touche <guibutton>Composition</guibutton> fournie par le clavier visuel de l'application <application>gok</application> peut être utilisée pour saisir n'importe quel texte dans l'application sélectionnée ; lancez <application>Gedit</application>, cliquez sur la zone de texte puis, cliquez sur la touche de <guibutton>composition</guibutton> dans l'application <application>gok</application>. Sélectionnez les touches requises depuis le clavier visuel. Les caractères doivent s'afficher dans la zone de texte de <application>Gedit</application>.

note: (itstool) path: step/para
en: Verify that the <guibutton>Launcher</guibutton> button allows the user to launch any of the <application>Terminal</application>, <application>Web Browser</application> or <application>Text Editor</application> applications.
fr: Vérifiez que le bouton <guibutton>Lanceur</guibutton> permet à l'utilisateur de lancer n'importe laquelle des applications parmi <application>Terminal</application>, <application>Navigateur Web</application> ou <application>Éditeur de texte</application>.

note: (itstool) path: step/para
en: Verify that the <guibutton>Activate</guibutton> button allows the user to activate any of the currently running application windows on the user's desktop, including GNOME panels and the GNOME desktop.
fr: Vérifiez que le bouton <guibutton>Activer</guibutton> permet à l'utilisateur d'activer n'importe quelle fenêtre d'une application actuellement en cours sur le bureau de l'utilisateur, ainsi que les tableaux de bord et le bureau GNOME.

note: (itstool) path: step/para
en: Verify that the <guibutton>Menus</guibutton> button lists all the available menus in the current application. Verify that clicking on a menu button displays the sub-menu and menu items contained within the sub-menu. Finally, verify that clicking on a menu item activates the menu item. For example, click on the <application>Help Browser</application> application and click on the <guibutton>Menus</guibutton> button. The <application>GOK</application> window now displays the <guibutton>File</guibutton>, <guibutton>Go</guibutton> and <guibutton>Help</guibutton> buttons (the <application>Help Browser</application> menus). Click on the <guibutton>File</guibutton> button and it displays the <guibutton>New Window</guibutton> and <guibutton>Close Window</guibutton> buttons (menu items).
fr: Vérifiez que le bouton <guibutton>Menus</guibutton> affiche tous les menus disponibles dans l'application actuelle. Vérifiez qu'un clic sur un bouton de menu affiche le sous-menu et ses éléments. Enfin, vérifiez qu'un clic sur un élément de menu active cet élément. Par exemple, cliquez sur l'application <application>Aide et soutien</application> et cliquez sur le bouton <guibutton>Menus</guibutton>. La fenêtre <application>GOK</application> affiche maintenant les boutons <guibutton>Fichier</guibutton>, <guibutton>Aller à</guibutton> et <guibutton>Aide</guibutton> (les menus de l'application <application>Aide et soutien</application>). Cliquez sur le bouton <guibutton>Fichier</guibutton> et les boutons <guibutton>Nouvelle fenêtre</guibutton> et <guibutton>Fermer la fenêtre</guibutton> s'affichent (éléments du menu).

note: (itstool) path: step/para
en: Verify that the <guibutton>Toolbars</guibutton> button lists all the available buttons in the application toolbar. For example, click on the <application>Help Browser</application> application and then click on the <guibutton>Toolbars</guibutton> button. The <application>GOK</application> window now displays the <guibutton>Back</guibutton>, <guibutton>Forward</guibutton> and <guibutton>Home</guibutton> buttons.
fr: Vérifiez que la liste des boutons des <guibutton>Barres d'outils</guibutton> est complète. Par exemple, cliquez sur l'application <application>Aide et soutien</application> puis, cliquez sur le bouton <guibutton>Barres d'outils</guibutton>. La fenêtre <application>GOK</application> affiche maintenant les boutons <guibutton>Précédent</guibutton>, <guibutton>Suivant</guibutton> et <guibutton>Sommaire</guibutton>.

note: (itstool) path: step/para
en: Verify that the <guibutton>UI Grab</guibutton> button displays all the button objects for the selected application window. For example, open the 'Font Properties' capplet and click on the <guibutton>UI Grab</guibutton> button in the <application>GOK</application> window. The <application>GOK</application> window should now display the names of the buttons in the capplet - <guibutton>Sans</guibutton>, <guibutton>Sans-serif</guibutton>, <guibutton>Close</guibutton> and <guibutton>Help</guibutton>.
fr: Vérifiez que le bouton <guibutton>Capturer l'IU</guibutton> affiche tous les objets boutons de la fenêtre d'application sélectionnée. Par exemple, ouvrez la capplet « Propriétés de la police » et cliquez sur le bouton <guibutton>Capturer l'IU</guibutton> dans la fenêtre <application>GOK</application>. La fenêtre <application>GOK</application> doit maintenant afficher les noms des boutons de la capplet : <guibutton>Sans</guibutton>, <guibutton>Sans-serif</guibutton>, <guibutton>Fermer</guibutton> et <guibutton>Aide</guibutton>.

note: (itstool) path: screenshot/mediaobject
en: <imageobject> <imagedata fileref="figures/at-arch.png" format="PNG"/> </imageobject> <textobject> <phrase> Accerciser and the GNOME Accessibility Architecture </phrase> </textobject>
fr: <imageobject> <imagedata fileref="figures/at-arch.png" format="PNG"/> </imageobject> <textobject> <phrase> Accerciser et l'architecture d'accessibilité de GNOME </phrase> </textobject>

note: (itstool) path: section/para
en: <application>Accerciser</application> is an interactive Python accessibility explorer for the GNOME Desktop. It uses AT-SPI to inspect and control widgets, allowing you to check if an application is providing correct information to assistive technologies and automated test frameworks. <application>Accerciser</application> has a simple plugin framework which you can use to create custom views of accessibility information. Full documentation can be found <ulink url="http://library.gnome.org/devel/accerciser/stable">in the Official Accerciser Manual</ulink>. For a demonstration of <application>Accerciser</application> and <application>PyATSPI</application> (Python-wrappered access and usage of AT-SPI), see <ulink url="http://live.gnome.org/Accessibility/PythonPoweredAccessibility">this article</ulink>. For an excellent walkthrough from the author, see the article titled <ulink url="http://www.linuxjournal.com/article/9991">Make Your Application Accessible with Accerciser</ulink>.
fr: <application>Accerciser</application> est un explorateur d'accessibilité interactif Python pour le bureau GNOME. Il utilise AT-SPI pour inspecter et contrôler les éléments graphiques, il vous permet de vérifier si une application fournit les informations correctes aux technologies d'assistance et aux structures de tests automatiques. <application>Accerciser</application> utilise une structure de greffons que vous pouvez utiliser pour créer des visualisations personnalisées des informations d'accessibilité. La documentation complète se trouve <ulink url="http://library.gnome.org/devel/accerciser/stable">dans le manuel officiel d'Accerciser</ulink>. Pour une démonstration d'<application>Accerciser</application> et de <application>PyATSPI</application> (Python-wrappered access and usage of AT-SPI : accès Python-wrappered et utilisation de AT-SPI), consultez <ulink url="http://live.gnome.org/Accessibility/PythonPoweredAccessibility">cet article</ulink>. Pour une excellente visite guidée par son auteur, consultez l'article <ulink url="http://www.linuxjournal.com/article/9991">Make Your Application Accessible with Accerciser (Rendre son application accessible avec Accerciser)</ulink>.

note: (itstool) path: note/para
en: <application>Accerciser</application> has effectively replaced the older <application>at-poke</application> tool.
fr: <application>Accerciser</application> a en réalité remplacé l'outil <application>at-poke</application> plus ancien.
