accerciser manual fr - en to fr translation catalogue (177 entries)

[ctx: sort]
note: (itstool) path: info/title
en: 1. API Browser Plugin
fr: 1. Le greffon « Navigateur d'API »

note: (itstool) path: info/desc
en: Verifying interfaces, methods, and properties
fr: Vérifier les interfaces, les méthodes et les propriétés

note: (itstool) path: license/p
en: Creative Commons Share Alike 3.0
fr: Creative Commons Partage des Conditions Initiales à l'Identique 3.0

note: (itstool) path: page/title (itstool) path: figure/title
en: API Browser Plugin
fr: Greffon « Navigateur d'API »

note: (itstool) path: page/p
en: Given an accessible widget selected in the <link xref="desktop_tree_view">Application Tree View</link>, the API Browser Plugin shows its implemented AT-SPI interfaces along with its methods and properties.
fr: Étant donné un composant graphique accessible sélectionné dans le <link xref="desktop_tree_view">Panneau de l'arborescence des applications</link>, le greffon « Navigateur d'API » affiche les interfaces AT-SPI qu'il met en œuvre, ainsi que ses méthodes et ses propriétés.

note: (itstool) path: figure/desc (itstool) path: media/p
en: The API Browser Plugin allows you to verify interfaces, methods, and properties of a target accessible widget in an application.
fr: Le greffon « Navigateur d'API » permet de vérifier les interfaces, les méthodes et les propriétés d'un composant graphique accessible cible dans une application.

note: (itstool) path: section/title
en: Running the API Browser Plugin
fr: Exécution du greffon Navigateur d'API

note: (itstool) path: section/p
en: To run the API Browser Plugin, select an accessible widget in the Application Tree View. Double-clicking a widget highlights it in the application's interface, so you can be sure whether a certain widget were the one you were looking for.
fr: Pour exécuter le greffon « navigateur d'API », sélectionnez un composant graphique accessible dans le panneau de l'arborescence des applications. Le fait de double-cliquer sur un composant graphique le met en surbrillance dans l'interface de l'application et vous pouvez ainsi être sûr qu'un certain composant graphique est bien celui que vous recherchiez.

note: (itstool) path: section/p
en: After that, select one of the widget's interfaces in the combobox. All public methods of the selected interface will be listed in the plugin's leftmost column. All public properties, with their corresponding values, will be listed in the plugin's rightmost column.
fr: Après cela, sélectionnez l'une des interfaces du composant graphique dans la liste déroulante. Toutes les méthodes publiques de l'interface sélectionnée sont visibles dans la colonne de gauche du greffon. Toutes les propriétés publiques et leur valeur correspondante, s'affichent dans la colonne de droite du greffon.

note: (itstool) path: section/p
en: By default, the API Browser Plugin hides private methods and properties. To see them listed, unselect the checkbox <cmd>Hide Private Attributes</cmd>. To hide them again, re-select this checkbox.
fr: Par défaut, le « Navigateur d'API » masque les méthodes privées et les propriétés. Pour les voir, décochez la case <cmd>Masquer les attributs privés</cmd>. Pour les masquer à nouveau, cochez la case.

[ctx: sort]
note: (itstool) path: info/title
en: 1. Application Tree View
fr: 1. Le panneau de l'arborescence des applications

note: (itstool) path: info/desc
en: Exploring the accessible hierarchy of the desktop
fr: Explorer la hiérarchie des accessibles de l'ordinateur

note: (itstool) path: page/title (itstool) path: figure/title
en: Application Tree View
fr: Panneau de l'arborescence des applications

note: (itstool) path: page/p
en: <app>Accerciser</app>'s interface contains a tree view, namely Application Tree View, that covers all accessible applications currently running on the desktop. To create this tree view, <app>Accerciser</app> uses the AT-SPI's registry daemon. This daemon is responsible for keeping track of all the accessible applications on the desktop and forwarding X events over the AT-SPI D-Bus. After getting all accessible applications, <app>Accerciser</app> represents each one of them as a hierarchical structure with expanding nodes.
fr: L'interface <app>Accerciser</app> possède une vue arborescente, appelée <gui>Panneau de l'arborescence des applications</gui> qui couvre toutes les applications accessibles en cours d'exécution sur l'ordinateur. Pour créer cette arborescence, <app>Accerciser</app> utilise le démon de registre de AT-SPI. Ce démon est responsable de la conservation de la trace de toutes les applications accessibles sur le bureau et de l'envoi des événements X sur le D-Bus ST-SPI. Après avoir obtenu toutes les applications accessibles, <app>Accerciser</app> les représentent selon une structure hiérarchique avec des nœuds de développement.

note: (itstool) path: figure/desc (itstool) path: media/p
en: <app>Accerciser</app>'s Application Tree View represents the interface of each accessible application running on the desktop as a widget hierarchical structure.
fr: Le Panneau de l'arborescence des applications d'<app>Accerciser</app> représente l'interface de chaque application accessible en cours d'exécution sur l'ordinateur selon une structure hiérarchique des composants graphiques.

note: (itstool) path: page/p
en: The first node of each application represented in this tree view is the application itself. When you expand a node, you can see all of its child widgets, which allows a hierarchical view of the application's interface. For each node, <app>Accerciser</app> provides some basic information, such as its name, role and number of children.
fr: Le premier nœud de chaque application représentée dans l'arborescence est l'application elle-même. Lorsque vous développez un nœud, vous pouvez voir tous ses composants graphiques fils. Pour chaque nœud, <app>Accerciser</app> fournit quelques informations de base comme son nom, son rôle et le nombre de ses fils.

note: (itstool) path: note/p
en: Be aware that nodes with many children take a long time to expand.
fr: Sachez que les nœuds avec de nombreux fils demandent beaucoup de temps pour se développer.

note: (itstool) path: section/title
en: Bookmarking items in the Application Tree View
fr: Création de signets dans le panneau de l'arborescence des applications

note: (itstool) path: section/p
en: <app>Accerciser</app> allows bookmarking items in the Application Tree View for later examining. This is helpful when the target application must be restarted - after rebuilding it, for example. To bookmark an item, select it and do <guiseq><gui>Bookmarks</gui><gui>Add Bookmark</gui></guiseq> or press <key>Ctrl</key>+<key>d</key>.
fr: <app>Accerciser</app> permet d'insérer des signets dans le panneau de l'arborescence des applications afin de les examiner ultérieurement. C'est pratique si l'application cible doit être redémarrée, par exemple après l'avoir reconstruite. Pour insérer un signet sur un élément, sélectionnez-le et cliquez sur <guiseq><gui>Signets</gui><gui>Ajouter un signet</gui></guiseq> ou pressez <key>Ctrl</key>+<key>d</key>.

note: (itstool) path: section/p
en: Bookmarks to accessible items in <app>Accerciser</app> are defined by an application name and a "path" in the application's internal accessible hierarchy to the bookmarked accessible. When the target application is in a different state - i.e. multiple top level frames -, the path might not be correct. Bookmarks could be managed by accessing the bookmark editing dialog through <guiseq><gui>Bookmarks</gui><gui>Edit Bookmarks</gui></guiseq>.
fr: Dans <app>Accerciser</app>, les signets vers les éléments accessibles sont définis par un nom d'application et un « chemin » vers l'élément accessible dans la hiérarchie des éléments accessibles internes à l'application. Quand l'application cible est dans un état différent (par ex. plusieurs fenêtres de niveau supérieur), le chemin peut ne pas être correct. La gestion des signets se fait dans la boîte de dialogue <guiseq><gui>Signets</gui><gui>Modifier les signets</gui></guiseq>.

[ctx: sort]
note: (itstool) path: info/title
en: 4. Event Monitor Plugin
fr: 4. Le greffon « Détecteur d'événements »

note: (itstool) path: info/desc
en: Monitoring accessible events as they occur
fr: Surveiller les événements accessibles quand ils surviennent

note: (itstool) path: page/title (itstool) path: figure/title
en: Event Monitor Plugin
fr: Le greffon « Détecteur d'événements »

note: (itstool) path: page/p
en: The Event Monitor Plugin allows you to view <link href="http://accessibility.linuxfoundation.org/a11yspecs/atspi/adoc/atspi-events.html">AT-SPI events</link> as they occur on the applications exposed in <app>Accerciser</app>'s <link xref="desktop_tree_view">Application Tree View</link>. The plugin is useful to explore the dynamics of an application's interface and verify which accessible widgets are related to which AT-SPI events.
fr: Le greffon « Détecteur d'événements » affiche les <link href="http://accessibility.linuxfoundation.org/a11yspecs/atspi/adoc/atspi-events.html">événements AT-SPI</link> au fur et à mesure de leur survenue dans les applications figurant dans le <link xref="desktop_tree_view">Panneau de l'arborescence des applications</link> d'<app>Accerciser</app>. Ce greffon est utile pour explorer la dynamique d'une interface d'application et vérifier quels éléments accessibles sont en rapport avec quels événements AT-SPI.

note: (itstool) path: figure/desc (itstool) path: media/p
en: The Event Monitor Plugin allows you to view AT-SPI events and match them with accessible widgets.
fr: Le greffon « Détecteur d'événements » permet d'afficher les événements AT-SPI et d'établir leur relation avec des éléments accessibles.

note: (itstool) path: section/title
en: Running the Event Monitor Plugin
fr: Exécution du greffon « Détecteur d'événements »

note: (itstool) path: section/p
en: When you open the Event Monitor Plugin, you see a list of checkboxes representing all the different AT-SPI event classes covered by the plugin:
fr: Quand vous ouvrez le greffon « Détecteur d'événements », vous voyez une liste de cases à cocher représentant les différentes classes d'événements AT-SPI couverts par le greffon :

note: (itstool) path: section/p
en: If you check a class, all of its event types will be monitored by the plugin. The classes are exposed as tree structures; therefore, you can refine your selection by expanding them and checking only the event types you really care about.
fr: Si vous cochez une classe, tous ses types d'événements seront surveillés par le greffon. Les classes se présentent en structures arborescentes ; vous pouvez donc affiner votre sélection en les déployant et en ne sélectionnant que les types d'événements qui vous intéressent vraiment.

note: (itstool) path: section/p
en: If you want to monitor all possible types of AT-SPI events, press the <cmd>Select All</cmd> button. Similarly, if you want to clear all currently selected event types, press the <cmd>Clear Selection</cmd> button.
fr: Si vous voulez surveiller tous les types d'événements AT-SPI, cliquez sur le bouton <cmd>Tout sélectionner</cmd>. De même, si vous voulez effacer tous les types d'événements actuellement sélectionnés, cliquez sur le bouton <cmd>Effacer la sélection</cmd>.

note: (itstool) path: note/p
en: Selecting only a few event types per monitoring gives you a clearer output.
fr: En ne sélectionnant que quelques types d'événement par surveillance, vous aurez une sortie d'affichage plus claire.

note: (itstool) path: section/p
en: Another way to refine event monitoring is by the event source. By default, the Source option <cmd>Everything</cmd> is selected, indicating that AT-SPI events of all applications will be monitored. If you want to investigate a single application, select it in the Application Tree View and click the Source radio button <cmd>Selected application</cmd>. Likewise, if you want to monitor a single accessible widget and its corresponding descendants, select it in the Application Tree View and click the Source radio button <cmd>Selected accessible</cmd>.
fr: Un autre façon d'affiner la surveillance des événements est de sélectionner la source des événements. Par défaut, l'option Source <cmd>Tout</cmd> est sélectionnée, indiquant que les événements AT-SPI de toutes les applications seront surveillés. Si vous ne voulez surveiller qu'une seule application, sélectionnez-la dans le Panneau de l'arborescence des applications et cliquez sur le bouton radio Source <cmd>Application sélectionnée</cmd>. De même, si vous ne voulez sélectionner qu'un élément accessible et tous ses descendants correspondants, sélectionnez-le dans le Panneau de l'arborescence des applications et cliquez sur le bouton radio Source <cmd>Élément accessible sélectionné</cmd>.

note: (itstool) path: section/p
en: After selecting event types and specifying a Source option, the Event Monitor Plugin starts monitoring AT-SPI events automatically, because the <cmd>Monitor Events</cmd> button is pressed by default. Whenever you want to stop monitoring, click the <cmd>Monitor Events</cmd> button. To restart monitoring, press this button again.
fr: Après avoir sélectionné des types d'événements et défini une option Source, le greffon « Détecteur d'événements » démarre automatiquement la surveillance des événements AT-SPI parce que le bouton <cmd>Détecteur d'événements</cmd> est enfoncé par défaut. Quand vous voulez interrompre la surveillance, cliquez sur le bouton <cmd>Détecteur d'événements</cmd>. Cliquez à nouveau sur ce bouton pour relancer la surveillance.

note: (itstool) path: section/p
en: For each incoming event, the Event Monitor Plugin indicates the source and the application. Activating the link for either of these items will cause it to become selected in the Application Tree View.
fr: À chaque survenue d'événement, le greffon « Détecteur d'événements » indique la source et l'application. L'activation du lien pour l'un de ces éléments le sélectionnera dans le panneau des applications.

note: (itstool) path: section/p
en: If you want to save the output generated by the Event Monitor Plugin, just press the <cmd>Save</cmd> button. To clear the output screen, you just need to click the <cmd>Clear</cmd> button.
fr: Si vous voulez sauvegarder la sortie produite par le greffon « Détecteur d'événements », appuyez tout simplement sur le bouton <cmd>Enregistrer</cmd>. Pour effacer l'écran de sortie, cliquez sur le bouton <cmd>Effacer</cmd>.

[ctx: sort]
note: (itstool) path: info/title
en: 2. How to install and run <app>Accerciser</app>
fr: 2. Comment installer et lancer <app>Accerciser</app>

[ctx: link]
note: (itstool) path: info/title
en: Setting up <app>Accerciser</app>
fr: Paramétrage d'<app>Accerciser</app>

note: (itstool) path: info/desc
en: Installing and running <app>Accerciser</app> on your system
fr: Installer et exécuter <app>Accerciser</app> sur votre système

note: (itstool) path: page/title
en: Setting up <app>Accerciser</app>
fr: Paramétrage d'<app>Accerciser</app>

note: (itstool) path: page/p
en: Check if your distribution has <app>Accerciser</app> already packaged. If this is the case, you can install it via its package manager. Otherwise, you can follow the section below to install <app>Accerciser</app> manually.
fr: Vérifiez si un paquet <app>Accerciser</app> existe pour votre distribution. Si c'est le cas, vous pouvez l'installer en passant par votre gestionnaire de paquets, sinon suivez les instructions ci-dessous pour l'installer manuellement.

note: (itstool) path: section/title
en: Installing <app>Accerciser</app> manually
fr: Installation manuelle d'<app>Accerciser</app>

note: (itstool) path: section/p
en: To install <app>Accerciser</app> manually, you will need to download it first. <app>Accerciser</app>'s source code can either be downloaded from <link href="http://ftp.gnome.org/pub/GNOME/sources/accerciser/">the gnome.org FTP site</link> or cloned from <link href="http://git.gnome.org/browse/accerciser">the gnome.org GIT repository</link>.
fr: Pour installer <app>Accerciser</app> manuellement, vous devez d'abord le télécharger. Le code source peut être téléchargé à partir du <link href="http://ftp.gnome.org/pub/GNOME/sources/accerciser/">site FTP de gnome.org</link>, ou bien cloné depuis le <link href="http://git.gnome.org/browse/accerciser">dépôt GIT de gnome.org</link>.

note: (itstool) path: note/p
en: If you are not using GNOME 3, you may find that <app>Accerciser</app> version 3 or later is not compatible with your environment.
fr: Si vous n'utilisez pas GNOME 3, vous constaterez qu'<app>Accerciser</app> version 3 ou ultérieure n'est pas compatible avec votre environnement.

note: (itstool) path: section/p
en: After getting <app>Accerciser</app>, install it using the following commands:
fr: Après avoir téléchargé <app>Accerciser</app>, installez-le en utilisant les commandes suivantes :

note: (itstool) path: item/p
en: <cmd>sudo meson install -C _build # or meson install -C _build as root</cmd>
fr: <cmd>sudo meson install -C _build # ou meson install -C _build en tant que root</cmd>

note: (itstool) path: section/p
en: If you find any problems installing <app>Accerciser</app> on your system, it is likely that some of its dependencies are missing. Check <link href="https://live.gnome.org/Accerciser/#Requirements"> <app>Accerciser</app>'s wiki</link> to make sure you have all dependencies properly installed.
fr: Si vous rencontrez des problèmes lors de l'installation d'<app>Accerciser</app> sur votre système, il est vraisemblable que certaines de ses dépendances manquent. Consultez le <link href="https://live.gnome.org/Accerciser/#Requirements">wiki d'<app>Accerciser</app></link> pour vous assurer que vous avez bien installé toutes les dépendances.

note: (itstool) path: section/title
en: Running <app>Accerciser</app>
fr: Exécution d'<app>Accerciser</app>

note: (itstool) path: section/p
en: To start <app>Accerciser</app>, type <cmd>accerciser</cmd> in a terminal window or within the Run dialog and then press <key>Return</key>.
fr: Pour démarrer <app>Accerciser</app>, saisissez <cmd>accerciser</cmd> dans un terminal ou dans la boîte de dialogue Exécuter puis, appuyez sur <key>Entrée</key>.

note: (itstool) path: section/p
en: After that, you can use <app>Accerciser</app> to inspect any accessible item shown in the <link xref="desktop_tree_view">Application Tree View</link>'s hierarchy. Select an item and investigate it using one of <app>Accerciser</app>'s plugins.
fr: Après cela, vous pouvez utiliser <app>Accerciser</app> pour inspecter les éléments accessibles présents dans la hiérarchie du <link xref="desktop_tree_view">panneau de l'arborescence des applications</link>. Sélectionnez un élément et explorez-le en utilisant l'un des greffons d'<app>Accerciser</app>.

[ctx: sort]
note: (itstool) path: info/title
en: 3. Writing New Plugins
fr: 3. Écriture de nouveaux greffons

note: (itstool) path: info/desc
en: Extending <app>Accerciser</app> with your desired functionalities
fr: Extension d'<app>Accerciser</app> avec vos propres fonctions

note: (itstool) path: page/title
en: Writing Plugins for <app>Accerciser</app>
fr: Écriture de greffons pour <app>Accerciser</app>

note: (itstool) path: page/p
en: Extending <app>Accerciser</app> with new plugins became much simpler since <link href="https://wiki.gnome.org/Apps/Accerciser/PluginTutorial">this tutorial</link> was written. Given that it provides a very detailed explanation about the topic, this section consists basically of its original content - only simple editions and updates were done.
fr: L'extension d'<app>Accerciser</app> par de nouveaux greffons est devenue beaucoup plus simple depuis que <link href="http://wiki.gnome.org/Apps/Accerciser/PluginTutorial">ce tutoriel</link> a été écrit. Étant donné qu'il fournit des explications détaillées sur le sujet, la section présente reprend son contenu d'origine, avec seulement quelques petites modifications et mises à jour.

note: (itstool) path: page/p
en: <app>Accerciser</app> supports three basic types of plugins:
fr: <app>Accerciser</app> prend en charge trois types de greffons :

note: (itstool) path: item/p
en: Base plugins - These plugins are derived from the Plugin base class. They do not provide a visible interface, but could provide additional functionality to <app>Accerciser</app>.
fr: Les greffons de base : ces greffons dérivent de la classe de base des greffons. Ils ne fournissent pas d'interface visible mais peuvent apporter des fonctionnalités supplémentaires à <app>Accerciser</app>.

note: (itstool) path: item/p
en: Console plugins - These plugins provide simple console output into a text area in a plugin tab. Not to be confused with the packaged <link xref="ipython_plugin">IPython Console Plugin</link>.
fr: Les greffons de console : ces greffons offrent une simple sortie console dans une zone de texte d'un onglet du greffon. Ne pas confondre avec le <link xref="ipython_plugin">Greffon console IPython</link> fourni avec l'application.

note: (itstool) path: item/p
en: Viewport plugins - The majority of <app>Accerciser</app> default plugins. They provide a custom graphical interface in a tab.
fr: Les greffons avec fenêtre d'affichage : c'est la majorité des greffons par défaut d'<app>Accerciser</app>. Ils offrent une interface graphique personnalisée dans un onglet.

note: (itstool) path: section/title
en: Creating a Base Plugin
fr: Création d'un greffon de base

note: (itstool) path: section/p
en: We will create a simplified version of the <link xref="quick_select_plugin">Quick Select Plugin</link>. This plugin will select the last focused accessible when pressing <key>ctrl</key>+<key>alt</key>+<key>e</key>.
fr: Nous allons créer une version simplifiée du <link xref="quick_select_plugin">Greffon Sélection rapide</link>. Ce greffon sélectionnera le dernier accessible ayant eu le focus en appuyant sur <key>Ctrl</key>+<key>Alt</key>+<key>e</key>.

note: (itstool) path: section/p
en: First off, the import lines we will use are:
fr: Pour commencer, les lignes d'importation que nous utiliserons sont :

note: (itstool) path: section/p
en: Next we will derive a new class from the Plugin base class, and assign some mandatory class attributes:
fr: Ensuite, nous dériverons une nouvelle classe depuis la classe de base Plugin et assignerons quelques attributs de classe obligatoires :

note: (itstool) path: section/p
en: We will now override the init method, in which we will set a global key action for selecting the last focused accessible item, register an event listener for the "focus" event, and set the <cmd>last_focused</cmd> instance variable to <cmd>None</cmd>.
fr: Nous allons maintenant redéfinir la méthode init, dans laquelle nous paramétrerons une action de touche générale pour sélectionner le dernier élément accessible ayant été sélectionné, enregistrer un listener d'événement pour l'événement « focus », et fixer la variable d'instance <cmd>last_focused</cmd> à <cmd>None</cmd>.

note: (itstool) path: section/p
en: Notice that the <cmd>global_hotkeys</cmd> instance variable is a list of tuples. Each tuple is a global hotkey action, composed by an action description, a desired method to call, a key symbol of keypress, and a key modifier mask.
fr: Notez que la variable d'instance <cmd>global_hotkeys</cmd> est une liste de tuples. Chaque tuple est une action raccourci général, composée d'une description de l'action, de la méthode à appeler, d'un symbole de touche d'appui-touche, et d'un masque de modification de touche.

note: (itstool) path: section/p
en: In the "focus" event callback, we assign the <cmd>last_focused</cmd> instance variable with the accessible item that has just emitted the "focus" event.
fr: Dans le rappel de l'événement « focus », nous attribuons la variable d'instance <cmd>last_focused</cmd> à l'élément accessible qui vient juste d'émettre l'événement « focus ».

note: (itstool) path: section/p
en: In the hotkey action callback, we update the application wide node with the last focused accessible item, if we have recorded it:
fr: Dans l'appel en retour de l'action raccourci, nous mettons à jour le nœud global de l'application avec le dernier élément accessible sélectionné, si nous l'avons enregistré :

note: (itstool) path: section/title
en: Creating a Console Plugin
fr: Création d'un greffon Console

note: (itstool) path: section/p
en: We will create a console plugin to display focus changes emitted by an accessible item with a "push button" role - remember that it is easy to check what is the role of any item with <app>Accerciser</app>; you can verify it in the <link xref="desktop_tree_view">Application Tree View</link>, for example.
fr: Nous allons créer un greffon console pour afficher les changements de focus émis par un élément accessible avec un rôle « bouton-poussoir ». Souvenez-vous qu'il est facile de vérifier le rôle d'un quelconque élément avec <app>Accerciser</app> ; vous pouvez le faire dans le <link xref="desktop_tree_view">Panneau de l'arborescence des applications</link>, par exemple.

note: (itstool) path: section/p
en: The needed import lines are:
fr: Les lignes d'importation nécessaires sont :

note: (itstool) path: section/p
en: Then we add a class definition, with a plugin name and description:
fr: Puis nous ajoutons une définition de classe, avec un nom de greffon et une description :

note: (itstool) path: section/p
en: We override the init method adding a register listener:
fr: Nous redéfinissons la méthode init en ajoutant un listener de registre :

note: (itstool) path: section/p
en: In the callback method, all push button events are printed.
fr: Dans la méthode de rappel, tous les événements des boutons poussoirs sont affichés.

note: (itstool) path: section/title
en: Creating a Viewport Plugin
fr: Création d'un greffon avec fenêtre d'affichage

note: (itstool) path: section/p
en: We will create a viewport plugin that allows quick testing of the "click" action in accessible items that support the AT-SPI Action interface and have an action named "click". It will be a simple button that, once clicked, does the "click" action in the accessible.
fr: Nous allons créer un greffon avec fenêtre d'affichage qui permet de tester rapidement l'action « click » dans les éléments accessibles qui prennent en charge l'interface AT-SPI Action et qui possèdent une action appelée « click ». Ce sera un simple bouton qui, une fois cliqué, effectue l'action « click » dans l'accessible.

note: (itstool) path: section/p
en: First off, some mandatory import lines:
fr: Tout d'abord, quelques lignes d'importation obligatoires :

note: (itstool) path: section/p
en: Next, a class definition, with a name and description:
fr: Ensuite, une définition de classe, avec un nom et une description :

note: (itstool) path: section/p
en: We override the init method with some UI building, and connecting a callback to a signal for the button. We use the alignment container to allow the button to be centered in the plugin tab, and not monstrously take up the entire plugin space. Notice that the <cmd>plugin_area</cmd> instance variable contains a gtk.Frame that could be populated with all the plugin's widgets.
fr: Nous redéfinissons la méthode init en ajoutant quelques termes de construction d'UI et en connectant un rappel à un signal pour le bouton. Nous utilisons un conteneur d'alignement pour permettre le centrage du bouton dans l'onglet greffon et ne pas occuper tout l'espace du greffon. Notez que la variable d'instance <cmd>plugin_area</cmd> contient un gtk.Frame qui peut être rempli de tous les composants graphiques du greffon.

note: (itstool) path: section/p
en: We also created a convenience method that returns a list of supported actions of the currently selected accessible item - if it does not support the Action interface, it returns an empty list:
fr: Nous avons aussi créé une méthode pratique qui renvoie une liste des actions gérées par l'élément accessible actuellement sélectionné. S'il ne gère pas l'interface Action, cela renvoie une liste vide :

note: (itstool) path: section/p
en: The base plugin class has a method call onAccChanged that is called everytime the target application's selected accessible item changes. We will override it setting the button to be sensitive only when the current accessible item has the "click" action:
fr: La classe greffon de base possède une méthode appelée onAccChanged qui est appelée à chaque fois que l'élément accessible sélectionné dans l'application cible change. Nous allons la redéfinir pour que le bouton ne soit réactif que lorsque l'élément accessible actuel possède l'action « click » :

note: (itstool) path: section/p
en: The callback method for button "clicked" performs the "click" action on the accessible item. Since this callback could only be called when the button is sensitive, we don't need to worry about checking if the current accessible has the "click" action?
fr: La méthode de rappel pour le bouton cliqué réalise l'action « click » sur l'élément accessible. Puisque ce rappel ne peut être effectué que lorsque le bouton est réactif, nous ne devons pas nous préoccuper de savoir si l'accessible actuel possède l'action « click » :

[ctx: link]
note: (itstool) path: info/title
en: Introduction to <app>Accerciser</app>
fr: Introduction à <app>Accerciser</app>

note: (itstool) path: media/span
en: <app>Accerciser</app>'s logo
fr: Logo d'<app>Accerciser</app>

note: (itstool) path: note/title
en: Before You Begin
fr: Avant de commencer

note: (itstool) path: note/p
en: Read the <link xref="help:gnome-help/a11y">Universal Access Help</link>
fr: Lisez l'<link xref="help:gnome-help/a11y">aide de l'accès universel</link>

note: (itstool) path: section/title
en: Getting Started
fr: Premiers pas

note: (itstool) path: section/title
en: Examining the Accessibility of an Application
fr: Examen de l'accessibilité d'une application

note: (itstool) path: section/title
en: Advanced Topics
fr: Thèmes avancés

[ctx: sort]
note: (itstool) path: info/title
en: 2. Interface Viewer Plugin
fr: 2. Le greffon « Navigateur d'interface »

note: (itstool) path: info/desc
en: Examining your accessibility implementation
fr: Examiner votre mise en œuvre de l'accessibilité

note: (itstool) path: page/title
en: Interface Viewer Plugin
fr: Greffon « Navigateur d'interface »

note: (itstool) path: page/p
en: The Interface Viewer Plugin shows the information and controls provided by the AT-SPI interfaces present in each accessible item from the <link xref="desktop_tree_view">Application Tree View</link>. After selecting an item, you can use this plugin to quickly review its supported interfaces, to retrieve each interface's information, and to manipulate the item through all the interface’s methods.
fr: Le greffon « Navigateur d'interface » affiche les informations et les contrôles fournis par les interfaces AT-SPI présentes dans chaque élément accessible du <link xref="desktop_tree_view">Panneau de l'arborescence des applications</link>. Après avoir sélectionné un élément, utilisez ce greffon pour passer rapidement en revue les interfaces prises en charge par cet élément, pour récupérer toutes les informations des interfaces et pour manipuler l'élément en utilisant toutes les méthodes des interfaces.

note: (itstool) path: figure/title
en: Examining a Menu with the Interface Viewer Plugin
fr: Examen d'un menu avec le greffon « Navigateur d'interface »

note: (itstool) path: figure/desc (itstool) path: media/p
en: Given a selected item in the Application Tree View, all of its AT-SPI interfaces will be shown as sensitive in the Interface Viewer Plugin. Those unsupported will appear grayed out, such as the Application and Collection interfaces in the figure above.
fr: Un élément étant sélectionné dans le Panneau de l'arborescence des applications, toutes ses interfaces AT-SPI s'affichent comme réactives dans le greffon « Navigateur d'interface ». Celles qui ne sont pas prises en compte sont grisés, comme les interfaces Application et Collection dans la figure ci-dessus.

note: (itstool) path: section/title
en: Running the Interface Viewer Plugin
fr: Exécution du greffon « Navigateur d'interface  »

note: (itstool) path: section/p
en: The first step to run the Interface Viewer Plugin is to select an item in the <link xref="desktop_tree_view"> Application Tree View</link>. After that, all AT-SPI interfaces covered by the plugin will be listed in the plugin's panel. The interfaces implemented by the selected item will be sensitive, so you can click each one of them to either retrieve their provided information or to interact with available methods. The following interfaces can be explored in <app>Accerciser</app>, assuming the selected item implements them:
fr: La première étape pour l'exécution du greffon « Navigateur d'interface » est la sélection d'un élément dans le <link xref="desktop_tree_view"> Panneau de l'arborescence des applications</link>. Après cela, toutes les interfaces couvertes par le greffon s'affichent dans le panneau des greffons. Les interfaces mises en œuvre par l'élément sélectionné sont réactives et vous pourrez ainsi cliquer sur chacune d'elles pour récupérer ses informations ou interagir avec les méthodes disponibles. Les interfaces suivantes peuvent être explorées dans <app>Accerciser</app>, en supposant que l'élément sélectionné les met en œuvre :

note: (itstool) path: item/p
en: Accessible - This interface shows the selected item's child count (number of child widgets), description, states, relations, and attributes.
fr: Accessible : cette interface affiche le nombre des fils de l'élément sélectionné (nombre d'éléments fils), la description, les états, les relations et les attributs.

note: (itstool) path: item/p
en: Action - This interface shows all the actions that can be performed by the selected item. For each interface, you will see its name, such as "press" or "click", followed by a description and a key binding, if there are any. If you select an action, a "Perform action" button will become sensitive. Press this button to see the item performing the selected action.
fr: Action : cette interface affiche toutes les actions pouvant être réalisées par l'élément sélectionné. Pour chaque interface, vous verrez son nom, comme « Appuyer (press) » ou « Cliquer (click) », suivi d'une description et d'une touche associée, si elles existent. Si vous sélectionnez une action, le bouton « Effectuer l'action » devient réactif. Appuyez sur ce bouton pour voir l'élément effectuer l'action sélectionnée.

note: (itstool) path: item/p
en: Application - This interface can be implemented by items with role "application". It is worth to point out that items with role "application" not necessarily implement this interface. If the selected item implements it, the interface will show its ID and, if there are any, its toolkit and version.
fr: Application  : cette interface peut être mise en œuvre par les éléments ayant un rôle « application ». Il est bon de souligner que les éléments avec un rôle « application » n'implémentent pas forcément cette interface. Si l'élément sélectionné la gère, l'interface affichera son ID et, si elles existent, sa boîte à outils et sa version.

note: (itstool) path: item/p
en: Component - This interface shows the selected item's absolute position (with respect to the desktop coordinate system), relative position (with respect to the window coordinate system), size, layer type, MDI-Z-order (a short integer indicating the stacking order of the component in the MDI layer), and alpha (if alpha blending is used).
fr: Composant : cette interface affiche la position absolue de l'élément sélectionné (selon le système de coordonnées du bureau), la position relative (selon le système de coordonnées de la fenêtre), la taille, le type de couche, le MDI-Z-order (un entier court indiquant l'ordre d'empilage du composant dans la couche MDI), et l'alpha (si « l'alpha blending » (simulation de transparence) est utilisé).

note: (itstool) path: item/p
en: Document - This interface shows the selected item's document attributes and locale description, if there is one.
fr: Document : cette interface affiche les attributs de document de l'élément sélectionné et une description de son emplacement, si elle existe.

note: (itstool) path: item/p
en: Hypertext - This interface shows a list with all the selected item's hypertext hyperlinks. For each hyperlink, the interface provides its name, URI, start (the index in the hypertext at which the hyperlink begins) and end (the index in the hypertext at which this hyperlink ends).
fr: Hypertexte : cette interface affiche la liste de tous les hyperliens hypertextes de l'élément sélectionné. Pour chaque hyperlien, l'interface fournit le nom, l'URI, le début (l'indice de début de l'hyperlien dans l'hypertexte) et la fin (l'indice de fin de l'hyperlien dans l'hypertexte).

note: (itstool) path: item/p
en: Image - This interface shows the selected item's description (or "no description" if unspecified), size, position (with respect to the desktop coordinate system), and locale, if there is one.
fr: Image : cette interface affiche la description de l'élément sélectionné (ou « aucune description » si elle n'est pas définie), la taille, la position (selon le système de coordonnées du bureau) et la locale (langue), si elle existe.

note: (itstool) path: item/p
en: Selection - This interface shows all selectable child items of the selected item. If the selected item is a menu bar with options "File", "Edit", "View", and "Help", and all of them are selectable, then they will be listed in this interface. If you click a listed option - "File", for example - and want to clear it, just press the "Clear" button below the list.
fr: Sélection : cette interface affiche tous les éléments fils sélectionnables de l'élément sélectionné. Si l'élément sélectionné est une barre de menu avec les options « Fichier », « Édition », « Affichage » et « Aide », et que toutes sont sélectionnables, alors elles seront listées dans cette interface. Si vous cliquez sur l'une des options de la liste, par exemple « Fichier », et que vous voulez la supprimer, cliquez simplement sur le bouton « Effacer » en dessous de la liste.

note: (itstool) path: item/p
en: Streamable Content - This interface shows the selected item's content types and their corresponding URIs.
fr: Contenu de flux : cette interface affiche les types de contenu de l'élément sélectionné et leurs URI correspondantes.

note: (itstool) path: item/p
en: Table - This interface shows the selected item's caption and summary, rows (number of rows), columns (number of columns), selected rows (number of selected rows), and selected columns (number of selected columns). For a selected cell, the interface shows its row's and column's header and extents.
fr: Tableau : cette interface affiche la légende et le résumé de l'élément sélectionné, les lignes (nombre de lignes), les colonnes (nombre de colonnes), les lignes sélectionnées (nombre de lignes sélectionnées) et les colonnes sélectionnées (nombre de colonnes sélectionnées). Pour une cellule sélectionnée, l'interface affiche son en-tête de ligne et de colonne et ses extensions.

note: (itstool) path: item/p
en: Text - This interface shows the selected item's text content, that can be editable, and its attributes. The basic attributes are offset (the number of characters the text has) and justification. To see possible CSS attributes, click the "Include defaults" check box.
fr: Texte : cette interface affiche le contenu du texte de l'élément sélectionné, qui peut être modifié, et ses attributs. Les attributs de base sont le décalage (le nombre de caractères du texte) et la justification. Pour voir d'éventuels attributs CSS, cochez la case « Inclure les valeurs par défaut ».

note: (itstool) path: item/p
en: Value - This interface shows the selected item's current value, minimum allowed value, maximum allowed value, and the minimum increment by which the value may be changed (or zero if this value cannot be determined). The current value can be manually changed via a spin button.
fr: Valeur : cette interface affiche la valeur actuelle de l'élément sélectionné, la valeur minimale autorisée, la valeur maximale autorisée et l'incrément minimal lors d'une modification de valeur (ou zéro si cette valeur ne peut pas être déterminée). La valeur actuelle peut être changée manuellement grâce à un bouton compteur.

[ctx: sort]
note: (itstool) path: info/title
en: 1. What is Accerciser?
fr: 1. À propos d'« Accerciser »

note: (itstool) path: info/desc
en: An interactive accessibility explorer
fr: Un explorateur d'accessibilité interactif

note: (itstool) path: page/title
en: What is <app>Accerciser</app>?
fr: À propos d'<app>Accerciser</app>

note: (itstool) path: page/p
en: <app>Accerciser</app> is an interactive Python accessibility explorer. It uses the AT-SPI library to inspect, examine, and interact with widgets, allowing you to check if an application is providing correct information to assistive technologies and automated testing frameworks. <app>Accerciser</app> comes with a set of plugins that you can use to create custom views of accessibility information.
fr: <app>Accerciser</app> est un explorateur d'accessibilité interactif écrit en langage Python. Il utilise la bibliothèque AT-SPI pour inspecter, examiner et interagir avec les éléments graphiques, vous permettant ainsi de vérifier si une application fournit des informations correctes aux techniques d'assistance et aux environnements de tests automatisés. <app>Accerciser</app> est fourni avec un lot de greffons que vous pouvez utiliser pour créer un affichage personnalisé des informations d'accessibilité.

note: (itstool) path: page/p
en: By default, <app>Accerciser</app>'s main interface is comprised of three sections: a tree view of the entire desktop accessible hierarchy, namely <link xref="desktop_tree_view"> Application Tree View</link>, and two plugin areas. If you prefer to see all plugins in a single area, dividing <app>Accerciser</app>'s interface in two sections instead of three, type <key>ctrl </key>+<key>t</key>. To re-divide it in three sections, just press <key>ctrl</key>+<key>t</key> again.
fr: Par défaut, l'interface principale d'<app>Accerciser</app> se compose de trois sections : une arborescence de toute la hiérarchie accessible de l'ordinateur, à savoir le <link xref="desktop_tree_view">Panneau de l'arborescence des applications</link>, et deux zones pour les greffons. Si vous préférez avoir tous les greffons dans une même zone, divisant ainsi <app>Accerciser</app> en deux sections au lieu de trois, pressez <key>Ctrl </key>+<key>t</key>. Pour repasser en trois sections, pressez <key>ctrl </key>+<key>t</key> à nouveau.

note: (itstool) path: note/p
en: Make sure that accessibility support is enabled in your desktop - otherwise, <app>Accerciser</app> will not work as expected.
fr: Assurez-vous que la prise en charge de l'accessibilité est activée pour votre ordinateur, sinon <app>Accerciser</app> ne fonctionnera pas comme prévu.

note: (itstool) path: figure/desc (itstool) path: media/p
en: <app>Accerciser</app>'s default interface.
fr: Interface par défaut d'<app>Accerciser</app>.

note: (itstool) path: section/title
en: <app>Accerciser</app>'s intended audience
fr: Public visé par <app>Accerciser</app>

note: (itstool) path: section/p
en: <app>Accerciser</app> fits the needs of many different audiences. User interface developers use it to ensure that their applications are providing all of their features through AT-SPI. Assistive technology developers are able to see what AT-SPI is providing to their applications. Automated UI test developers find <app>Accerciser</app> beneficial since it exposes different events that could be expected from their target application.
fr: <app>Accerciser</app> répond aux besoins de publics variés. Les développeurs d'interface utilisateur l'utilisent pour s'assurer que tous les éléments de leurs applications sont transmis à AT-SPI. Les développeurs de technologies d'assistance peuvent voir ce que AT-SPI fournit à leurs applications. Les développeurs de testeurs d'interfaces utilisateur automatisés trouvent avantage à utiliser <app>Accerciser</app> puisqu'il montre les différents événements qui pourraient être attendus de leur application cible.

note: (itstool) path: section/title
en: <app>Accerciser</app>'s plugin architecture
fr: L'architecture greffon d'<app>Accerciser</app>

note: (itstool) path: section/p
en: <app>Accerciser</app> has an extensible, plugin-based architecture. Its core code is fairly small and most of its features are part of default plugins:
fr: <app>Accerciser</app> a une architecture extensible, basée sur des greffons. Le noyau de son code est particulièrement petit et la plupart de ses caractéristiques proviennent des greffons par défaut :

note: (itstool) path: item/p
en: <link xref="interface_viewer">Interface Viewer</link> - A plugin that lets you explore the AT-SPI interfaces provided by each accessible widget of a target application.
fr: <link xref="interface_viewer">Navigateur d'interface</link>  : un greffon qui vous permet d'explorer les interfaces AT-SPI fournies par chacun des composants graphiques accessibles d'une application cible.

note: (itstool) path: item/p
en: <link xref="validator_plugin">AT-SPI Validator</link> - A plugin that applies tests to verify the accessibility of a target application.
fr: <link xref="validator_plugin">Validateur AT-SPI</link> : un greffon qui effectue des tests pour vérifier l'accessibilité d'une application cible.

note: (itstool) path: item/p
en: <link xref="event_monitor_plugin">Event Monitor</link> - A plugin that displays AT-SPI events emitted by a target application as they occur.
fr: <link xref="event_monitor_plugin">Détecteur d'événements</link> : un greffon qui affiche les événements AT-SPI émis par une application cible au fur et à mesure.

note: (itstool) path: item/p
en: <link xref="quick_select_plugin">Quick Select</link> - A plugin that provides global hotkeys for quickly selecting accessible widgets in <app>Accerciser</app>'s Application Tree View.
fr: <link xref="quick_select_plugin">Sélection rapide</link> : un greffon qui fournit des raccourcis clavier globaux pour la sélection rapide de composants graphiques accessibles dans le panneau de l'arborescence des applications d'<app>Accerciser</app>.

note: (itstool) path: item/p
en: <link xref="api_browser_plugin">API Browser</link> - A plugin that shows the interfaces, methods, and attributes available on each accessible widget of a target application.
fr: <link xref="api_browser_plugin">Navigateur d'API</link> : un greffon qui affiche les interfaces, les méthodes et les attributs disponibles sur chaque composant graphique accessible d'une application cible.

note: (itstool) path: item/p
en: <link xref="ipython_plugin">IPython Console</link> - A plugin that provides a full, interactive Python shell with access to selected accessible widgets of a target application.
fr: <link xref="ipython_plugin">Console IPython</link> : un greffon qui fournit un shell Python interactif, complet, avec accès aux composants graphiques sélectionnés d'une application cible.

note: (itstool) path: section/title
en: More about Accessibility
fr: Informations supplémentaires sur l'accessibilité

note: (itstool) path: section/p
en: Accessibility is a core value that should touch all aspects of a Desktop Environment. To help achieve it in GNOME, some libraries were developed, such as ATK and AT-SPI. Though originated in GNOME, these libraries are now also used in other Desktop Environments. To learn more about Accessibility Libraries for GNU/UNIX systems, you can consult:
fr: L'accessibilité est une valeur fondamentale qui touche tous les aspects d'un environnement de bureau. Pour favoriser son application à GNOME, des bibliothèques ont été développées, comme ATK et AT-SPI. Bien qu'elles tirent leur origine de GNOME, ces bibliothèques sont maintenant utilisées par d'autres environnements de bureau. Pour en savoir plus à propos des bibliothèques d'accessibilité, consultez :

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/atk/">ATK Accessibility Toolkit</link> - ATK provides the set of accessibility interfaces that are implemented by other toolkits and applications. Using the ATK interfaces, accessibility tools have full access to view and control running applications.
fr: <link href="http://developer.gnome.org/atk/">ATK Accessibility Toolkit</link> : ATK fournit l'ensemble des interfaces d'accessibilité mises en œuvre par d'autres boîtes à outils et applications. En utilisant les interfaces ATK, les outils d'accessibilité accèdent pleinement à la visualisation et au contrôle des applications en cours de fonctionnement.

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/at-spi-cspi/stable/">AT-SPI</link> - AT-SPI is the primary service interface by which assistive technologies query and receive notifications from running applications. Additional material is available from the <link href="http://accessibility.kde.org/developer/atk.php#coreclasses">KDE Accessibility Development Community</link>.
fr: <link href="http://developer.gnome.org/at-spi-cspi/stable/">AT-SPI</link> : AT-SPI est l'interface de service principale par laquelle les technologies d'assistance questionnent et reçoivent des notifications des applications en cours de fonctionnement. Une documentation complémentaire est disponible dans <link href="http://accessibility.kde.org/developer/atk.php#coreclasses">KDE Accessibility Development Community</link>.

note: (itstool) path: item/p
en: <link href="https://help.gnome.org/users/gnome-help/stable/a11y.html">GNOME Desktop Accessibility Guide</link> - A guide for anyone interested in how the GNOME Desktop supports the needs of users with disabilities.
fr: <link href="http://help.gnome.org/users/gnome-access-guide/stable/">Guide d'accessibilité du bureau GNOME</link> : un guide pour tous ceux qui sont intéressés par la façon dont le bureau GNOME prend en charge les besoins des utilisateurs souffrant de handicaps.

note: (itstool) path: item/p
en: <link href="http://developer.gnome.org/accessibility-devel-guide/stable/">GNOME Accessibility Developer's Guide</link> - A guide for developers who want to ensure their applications are accessible to the widest audience of users.
fr: <link href="http://developer.gnome.org/accessibility-devel-guide/stable/">Guide d'accessibilité du bureau GNOME pour les développeurs</link> : un guide pour les développeurs qui veulent s'assurer que leurs applications sont accessibles au plus grand nombre d'utilisateurs.

note: (itstool) path: item/p
en: <link href="https://wiki.gnome.org/Accessibility">GNOME Accessibility Project</link> - The GNOME Accessibility Project includes the guides listed above along with many other useful links for users, developers and system administrators.
fr: <link href="http://wiki.gnome.org/Accessibility">GNOME Accessibility Project</link> : le projet d'accessibilité GNOME comprend les guides décrits plus haut ainsi que beaucoup d'autres liens utiles pour les utilisateurs, les développeurs et les administrateurs de systèmes.

[ctx: sort]
note: (itstool) path: info/title
en: 2. IPython Plugin
fr: 2. Le greffon IPython

note: (itstool) path: info/desc
en: When all else fails
fr: Quand tout le reste a échoué

note: (itstool) path: page/title
en: IPython Console Plugin
fr: Le greffon Console IPython

note: (itstool) path: page/p
en: The IPython Console Plugin allows real-time interaction with a selected item in the <link xref="desktop_tree_view"> Application Tree View</link>. Since the IPython Console Plugin is an interactive Python shell, you can import any Python modules you want.
fr: Le greffon « Console IPython » permet une interaction en temps réel avec un élément sélectionné dans le <link xref="desktop_tree_view">Panneau de l'arborescence des applications</link>. Comme ce greffon est un terminal interactif Python, vous pouvez importer les modules Python que vous voulez.

note: (itstool) path: note/p
en: Make sure you have the standalone package IPython installed in your system. Otherwise, the IPython Console Plugin will not work properly.
fr: Assurez-vous que le paquetage autonome IPython est bien installé sur votre système sinon, la « Console IPython » ne fonctionnera pas correctement.

note: (itstool) path: section/title
en: Running the IPython Console Plugin
fr: Exécution du greffon « Console IPython »

note: (itstool) path: section/p
en: To run the IPython Console Plugin, select one of the accessible items listed in the Application Tree View - either an application or a widget. In the plugin, the selected item will correspond to the variable 'acc'.
fr: Pour exécuter le greffon « Console IPython », sélectionnez l'un des éléments affichés dans le Panneau de l'arborescence des applications, une application ou un autre type d'élément. Dans le greffon, l'élément sélectionné correspond à la variable « acc ».

note: (itstool) path: section/p
en: Pressing <key>Tab</key> shows completions for the current command in the console, what can be useful for discovering pyatspi methods.
fr: Un appui sur la touche <key>Tab</key> affiche les résultats de la commande actuelle dans la console, ce qui peut être utile pour découvrir les méthodes pyatspi.

note: (itstool) path: figure/title
en: Investigating selected items with the IPython Console Plugin
fr: Investigation des éléments sélectionnés avec le greffon « Console IPython »

note: (itstool) path: figure/desc (itstool) path: media/p
en: The IPython Console Plugin lets you investigate methods, constants, and properties related to a selected item in the Application Tree View.
fr: Le greffon « Console IPython » permet de vous informer sur les méthodes, constantes et propriétés en rapport avec l'élément sélectionné dans le Panneau de l'arborescence des applications.

note: (itstool) path: note/p
en: Typing <cmd>help(acc)</cmd> in the IPython Console Plugin shows some useful documentation about the corresponding selected accessible item.
fr: La commande <cmd>help(acc)</cmd> saisie dans console IPython donne des indications utiles sur l'élément accessible sélectionné correspondant.

[ctx: sort]
note: (itstool) path: info/title
en: 4. Preferences
fr: 4. Préférences

note: (itstool) path: info/desc
en: Customizing <app>Accerciser</app>'s preferences
fr: Personnaliser les préférences d'<app>Accerciser</app>

note: (itstool) path: page/title
en: Configuring <app>Accerciser</app>
fr: Configuration d'<app>Accerciser</app>

note: (itstool) path: page/p
en: To configure plugins, hotkeys, and highlighting, do either <key>ctrl</key>+<key>p</key> or <guiseq><gui>Edit</gui> <gui>Preferences</gui></guiseq> to open a dialog.
fr: Pour configurer les greffons, les raccourcis clavier et la mise en surbrillance, faites <key>Ctrl</key>+<key>p</key> ou <guiseq><gui>Édition</gui><gui>Préférences</gui></guiseq> pour ouvrir une boîte de dialogue.

note: (itstool) path: figure/title
en: <app>Accerciser</app> preferences
fr: Préférences d'<app>Accerciser</app>

note: (itstool) path: figure/desc (itstool) path: media/p
en: <app>Accerciser</app> allows you to configure plugins, global hotkeys, and widget's highlighting.
fr: <app>Accerciser</app> vous permet de configurer greffons, raccourcis clavier globaux et mise en surbrillance des éléments.

note: (itstool) path: section/title
en: Configuring plugins
fr: Configuration des greffons

note: (itstool) path: section/p
en: After opening the Preferences Dialog, you will find a list of all available plugins, with corresponding checkboxes, under the "Plugins" tab. To enable or disable a plugin, toggle its checkbox. Only active plugins can be accessed via <app>Accerciser</app>'s interface.
fr: Après l'ouverture de la boîte de dialogue des préférences, vous trouverez, dans l'onglet « Greffons », la liste de tous les greffons disponibles, avec les cases à cocher correspondantes. Pour activer ou désactiver un greffon, cochez ou décochez sa case. L'interface <app>Accerciser</app> n'autorise l'accès qu'aux seuls greffons actifs.

note: (itstool) path: section/p
en: Right-clicking on any given plugin allows you to choose its location: "Top Panel", "Bottom Panel", and "New View". Selecting "New View" creates a new window for the plugin.
fr: Le clic-droit sur un greffon permet de choisir son emplacement : « Tableau de bord du haut », « Tableau de bord du bas » et « Nouvelle vue ». Le choix « Nouvelle vue » crée une nouvelle fenêtre pour le greffon.

note: (itstool) path: figure/title
en: Configuring plugins' preferences
fr: Configuration des préférences des greffons

note: (itstool) path: figure/desc (itstool) path: media/p
en: <app>Accerciser</app> allows you to adjust your plugins' preferences.
fr: <app>Accerciser</app> vous permet d'ajuster vos préférences pour les greffons.

note: (itstool) path: note/p
en: You may bypass the Preferences dialog by using drag and drop to move a plugin from a location to another.
fr: Il est possible de court-circuiter le dialogue des préférences en utilisant le glisser-déposer pour déplacer un greffon d'un emplacement à un autre.

note: (itstool) path: section/title
en: Configuring global hotkeys
fr: Configuration des raccourcis clavier globaux

note: (itstool) path: section/p
en: Some elements in <app>Accerciser</app> may enable certain functionalities via hotkeys. An example is the <link xref="quick_select_plugin">Quick Select Plugin</link>. The hotkey combination for each functionality can be changed via the Preferences dialog, under the "Global Hotkeys" tab. Under this tab, you will find a list of all features for which hotkeys can be configured. Use the <cmd>ctrl</cmd>, <cmd>alt</cmd>, and <cmd>shift</cmd> checkboxes to enable or disable these modifiers.
fr: Certains éléments d'<app>Accerciser</app> activent des fonctions par l'intermédiaire de raccourcis clavier. Un exemple est le greffon <link xref="quick_select_plugin">Sélection rapide</link>. La combinaison de touches pour chaque fonction peut être modifiée en passant par la boîte de dialogue des Préférences, dans l'onglet « Raccourcis généraux ». Dans cet onglet, on trouve une liste de tous les composants susceptibles d'être configurés pour un raccourci clavier. Utilisez les cases <cmd>Ctrl</cmd>, <cmd>Alt</cmd> et <cmd>Maj</cmd> pour activer ou désactiver ces modificateurs.

note: (itstool) path: figure/title
en: Configuring global hotkeys' preferences
fr: Configuration des préférences des raccourcis généraux

note: (itstool) path: figure/desc
en: <app>Accerciser</app> allows you to adjust your hotkeys' preferences.
fr: <app>Accerciser</app> vous permet d'ajuster les préférences pour les raccourcis clavier.

note: (itstool) path: media/p
en: <app>Accerciser</app> allows you to adjust your plugin's preferences.
fr: <app>Accerciser</app> vous permet d'ajuster les préférences pour les greffons.

note: (itstool) path: section/title
en: Configuring widget's highlighting
fr: Configuration de la surbrillance des éléments

note: (itstool) path: section/p
en: Some of <app>Accerciser</app>'s elements, such as the global hotkey <key>ctrl</key>+<key>alt</key>+<key>/</key>, highlight a specific widget in a target application. The highlighting duration, border color, and fill color can be customized via the Preferences dialog, under the "Highlighting" tab.
fr: Certains éléments d'<app>Accerciser</app>, comme le raccourci général <key>Ctrl</key>+<key>Alt</key>+<key>/</key>, mettent en surbrillance un élément particulier dans une application cible. La durée de la surbrillance, la couleur de la bordure et la couleur de remplissage peuvent être personnalisées dans la boîte de dialogue des Préférences à l'onglet « Surbrillance ».

note: (itstool) path: figure/title
en: Configuring highlighting preferences
fr: Configuration des préférences de surbrillance

note: (itstool) path: figure/desc (itstool) path: media/p
en: <app>Accerciser</app> allows you to adjust your highlighting preferences.
fr: <app>Accerciser</app> vous permet d'ajuster les préférences pour la surbrillance.

[ctx: sort]
note: (itstool) path: info/title
en: 5. Quick Select Plugin
fr: 5. Le greffon « Sélection rapide »

note: (itstool) path: info/desc
en: Locating the object you need
fr: Localiser l'objet que vous recherchez

note: (itstool) path: page/title
en: Quick Select Plugin
fr: Greffon « Sélection rapide »

note: (itstool) path: page/p
en: The Quick Select Plugin does not provide a visible interface like the other default <app>Accerciser</app> plugins - instead, it adds facilities for quickly selecting items in the <link xref="desktop_tree_view">Application Tree View</link> via global hotkeys. Originally, these hotkeys were part of <app>Accerciser</app>'s core code, turning into the Quick Select Plugin later.
fr: Le greffon « Sélection rapide » ne possède pas d'interface visible comme les autres greffons par défaut d'<app>Accerciser</app>. À la place, il offre des fonctions pour sélectionner rapidement des éléments dans le <link xref="desktop_tree_view">Panneau de l'arborescence des applications</link> au moyen de raccourcis clavier globaux. À l'origine, ces raccourcis faisaient partie du code du noyau d'<app>Accerciser</app> et sont devenus le greffon de Sélection rapide plus tard.

note: (itstool) path: page/p
en: The Quick Select Plugin provides two global hotkeys. Pressing <key>ctrl</key>+<key>alt</key>+<key>a</key> selects the last focused accessible widget in the Application Tree View. Pressing <key>ctrl</key>+<key>alt</key>+<key>/</key> selects the accessible widget under the pointer in the Application Tree View and highlights it in the target application.
fr: Le greffon « Sélection rapide » fournit deux raccourcis clavier globaux. L'appui sur <key>Ctrl</key>+<key>Alt</key>+<key>a</key> sélectionne l'élément pointé en dernier dans le Panneau de l'arborescence des applications. L'appui sur <key>Ctrl</key>+<key>Alt</key>+<key>/</key> sélectionne l'élément situé sous le pointeur dans le Panneau de l'arborescence des applications et le met en surbrillance dans l'application cible.

[ctx: sort]
note: (itstool) path: info/title
en: 3. Validator Default Plugin
fr: 3. Greffon par défaut « Validateur »

note: (itstool) path: info/desc
en: Testing an application for accessibility
fr: Tester l'accessibilité d'une application

note: (itstool) path: page/title (itstool) path: figure/title
en: AT-SPI Validator Plugin
fr: Greffon Validateur AT-SPI

note: (itstool) path: page/p
en: The AT-SPI Validator Plugin generates a report with accessibility issues related to a target application. For each error, the report includes the severity level and a brief description.
fr: Le greffon « Validateur AT-SPI » produit un rapport contenant les problèmes d'accessibilité concernant une application cible. Pour chaque erreur, le rapport donne le niveau de sécurité et une brève description.

note: (itstool) path: figure/desc (itstool) path: media/p
en: The AT-SPI Validator Plugin generates useful reports for verifying the accessibility of a target application.
fr: Le greffon « Validateur AT-SPI » génère d'utiles rapports pour vérifier l'accessibilité d'une application cible.

note: (itstool) path: section/title
en: Running the AT-SPI Validator Plugin
fr: Exécution du greffon « Validateur AT-SPI »

note: (itstool) path: section/p
en: To run the AT-SPI Validator Plugin, select an item in the Application Tree View. The validator will generate the report with respect to the selected item and all of its descendant widgets in the tree hierarchy.
fr: Pour exécuter le greffon « Validateur AT-SPI », sélectionnez un élément dans le volet de l'arborescence des applications actives. Le validateur produira le rapport sur l'élément sélectionné et tous ses descendants dans la hiérarchie de son arborescence.

note: (itstool) path: section/p
en: After selecting an item, choose a validation schema in the combobox and press the <cmd>Validate</cmd> button to start generating the report. If you want to cancel the execution, just press the <cmd>Validate</cmd> button again.
fr: Après avoir sélectionné un élément, choisissez un schéma de validation dans la liste déroulante et cliquez sur le bouton <cmd>Valider</cmd> pour lancer la production du rapport. Pour interrompre l'exécution, cliquez à nouveau sur le bouton <cmd>Valider</cmd>.

note: (itstool) path: section/p
en: The generated report is interactive. Therefore, you can double-click any error found to check which of the target application widgets is causing it. The corresponding widget will then appear selected in the <link xref="desktop_tree_view"> Application Tree View</link> and highlighted in the target application.
fr: Le rapport produit est interactif. Vous pouvez donc faire un double-clic sur n'importe quelle erreur trouvée pour déterminer l'élément de l'application cible qui en est la cause. L'élément correspondant apparaît alors sélectionné dans le <link xref="desktop_tree_view">Panneau de l'arborescence des applications</link> et en surbrillance dans l'application cible.

note: (itstool) path: section/p
en: If you want to save the generated report in your system, just click the <cmd>Save</cmd> button. To clear the validation screen, press the <cmd>Clear</cmd> button.
fr: Pour enregistrer le rapport produit dans votre système, cliquez sur le bouton <cmd>Enregistrer</cmd>. Pour effacer l'écran de validation, cliquez sur le bouton <cmd>Effacer</cmd>.

note: (itstool) path: section/p
en: To get more information about an error in the generated report, make sure the corresponding item is selected and press the <cmd>Help</cmd> button. It will open a Help Page in your default browser.
fr: Pour obtenir plus d'informations sur une erreur dans le rapport produit, assurez-vous que l'élément correspondant est sélectionné et appuyez sur le bouton <cmd>Aide</cmd>. Une page d'aide s'affiche alors dans votre navigateur par défaut.
