# 3. Écriture de nouveaux greffons

Extension d'Accerciser avec vos propres fonctions
Eitan Isaacson
eitan@ascender.com
Peter Parente
pparent@us.ibm.com
Aline Bessa
alibezz@gmail.com

Creative Commons Partage des Conditions Initiales à l'Identique 3.0

Robert-André Mauchin
zebob.m@pengzone.org 2007
Claude Paroz
claude@2xlibre.net 2008
Julien Hardelin
jhardlin@orange.fr 2011
Bruno Brouard
annoa.b@gmail.com 2012

# Écriture de greffons pour Accerciser

L'extension d'Accerciser par de nouveaux greffons est devenue beaucoup plus simple depuis que ce tutoriel 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.

Accerciser prend en charge trois types de greffons :

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 à Accerciser.

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 Greffon console IPython fourni avec l'application.

Les greffons avec fenêtre d'affichage : c'est la majorité des greffons par défaut d'Accerciser. Ils offrent une interface graphique personnalisée dans un onglet.

# Création d'un greffon de base

We will create a simplified version of the Quick Select Plugin. This plugin will select the last focused accessible when pressing ctrl alt e.

Pour commencer, les lignes d'importation que nous utiliserons sont :

from accerciser.plugin import Plugin import gtk import pyatspi

Ensuite, nous dériverons une nouvelle classe depuis la classe de base Plugin et assignerons quelques attributs de classe obligatoires :

class FocusSelect(Plugin): plugin_name = 'Focus Select' plugin_description = 'Allows selecting last focused accessible.'

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 last_focused à None.

def init(self): pyatspi.Registry.registerEventListener(self.accEventFocusChanged, 'focus') self.global_hotkeys = [('Inspect last focused accessible', self.inspectLastFocused, gtk.keysyms.e, gtk.gdk.CONTROL_MASK | gtk.gdk.MOD1_MASK)] self.last_focused = None

Notez que la variable d'instance global_hotkeys 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.

Dans le rappel de l'événement « focus », nous attribuons la variable d'instance last_focused à l'élément accessible qui vient juste d'émettre l'événement « focus ».

def accEventFocusChanged(self, event): if not self.isMyApp(event.source): self.last_focused = event.source

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

def inspectLastFocused(self): if self.last_focused: self.node.update(self.last_focused)

# Création d'un greffon Console

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 Accerciser ; vous pouvez le faire dans le Panneau de l'arborescence des applications, par exemple.

Les lignes d'importation nécessaires sont :

from accerciser.plugin import ConsolePlugin import pyatspi

Puis nous ajoutons une définition de classe, avec un nom de greffon et une description :

class PushButtonFocus(ConsolePlugin): plugin_name = 'Push Button Focus' plugin_description = 'Print event when pushbutton get\'s focus.'

Nous redéfinissons la méthode init en ajoutant un listener de registre :

def init(self): pyatspi.Registry.registerEventListener(self.accEventFocusChanged, 'focus')

Dans la méthode de rappel, tous les événements des boutons poussoirs sont affichés.

def accEventFocusChanged(self, event): if event.source.getRole() == pyatspi.ROLE_PUSH_BUTTON: self.appendText(str(event)+'\n')

# Création d'un greffon avec fenêtre d'affichage

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.

Tout d'abord, quelques lignes d'importation obligatoires :

import gtk from accerciser.plugin import ViewportPlugin

Ensuite, une définition de classe, avec un nom et une description :

class Clicker(ViewportPlugin): plugin_name = 'Clicker' plugin_description = 'Test the "click" action in relevant accessibles.'

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 plugin_area contient un gtk.Frame qui peut être rempli de tous les composants graphiques du greffon.

def init(self): alignment = gtk.Alignment(0.5,0.5,0,0) self.click_button = gtk.Button('Click me!') alignment.add(self.click_button) self.plugin_area.add(alignment)

self.click_button.connect('clicked', self.onClick)

self.show_all()

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 :

def accSupportedActions(self): try: ai = self.node.acc.queryAction() except NotImplementedError: action_names = [] else: action_names = [ai.getName(i) for i in xrange(ai.nActions)] return action_names

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

def onAccChanged(self, acc): has_click = 'click' in self.accSupportedActions() self.click_button.set_sensitive(has_click)

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

def onClick(self, button): ai = self.node.acc.queryAction() action_names = [ai.getName(i) for i in xrange(ai.nActions)] ai.doAction(action_names.index('click'))