Accessibilité des applications QWidget

Introduction

Nous nous concentrerons sur l'interface d'accessibilité Qt QAccessibleInterface et sur la manière de rendre les applications accessibles.

Accessibilité dans les applications basées sur QWidget

Lorsque nous communiquons avec les technologies d'assistance, nous devons décrire l'interface utilisateur de Qt d'une manière qu'elles puissent comprendre. Les applications Qt utilisent QAccessibleInterface pour exposer des informations sur les différents éléments de l’interface utilisateur. Actuellement, Qt prend en charge ses widgets et leurs composants (par exemple, les curseurs), mais l’interface pourrait également être implémentée pour n’importe quel QObject si nécessaire. QAccessible contient des énumérations qui décrivent l’interface utilisateur. Nous examinerons ces énumérations au fil de ce document.

La structure de l’interface utilisateur est représentée sous la forme d’une arborescence de sous-classes de ` QAccessibleInterface `. Celle-ci reflète souvent la hiérarchie des `QWidgets` qui composent l’interface utilisateur de l’application.

Les serveurs informent les clients, via la méthode ` updateAccessibility()`, des modifications apportées aux objets en envoyant des événements, et les clients s’enregistrent pour recevoir ces événements. Les événements disponibles sont définis par l’énumération ` QAccessible::Event `. Les clients peuvent ensuite rechercher l’objet à l’origine de l’événement via la méthode ` QAccessible::queryAccessibleInterface()`.

Les membres et les énumérations de ` QAccessible ` servent à décrire les objets accessibles :

• Role: Décrit le rôle que l’objet joue dans l’interface utilisateur, par exemple s’il s’agit d’une fenêtre, d’un champ de saisie de texte ou d’une cellule dans un tableau.
• Relation: Décrit la relation entre les objets dans la hiérarchie des objets.
• State: Les objets peuvent se trouver dans différents états. Par exemple, l’objet peut être désactivé, avoir le focus ou proposer un menu contextuel.

Les clients disposent également de certaines possibilités pour récupérer le contenu des objets, par exemple le texte d’un bouton ; l’objet fournit des chaînes définies par l’énumération « QAccessible::Text », qui fournissent des informations sur son contenu.

L’arborescence des objets accessibles

Comme mentionné précédemment, une structure arborescente est construite à partir des objets accessibles d’une application. En naviguant dans cette arborescence, les clients peuvent accéder à tous les éléments de l’interface utilisateur. Les relations entre objets fournissent aux clients des informations sur l’interface utilisateur. Par exemple, la poignée d’un curseur est un enfant du curseur auquel elle appartient. L’énumération ` QAccessible::Relation ` décrit les différentes relations que les clients peuvent demander aux objets.

Notez qu’il n’existe pas de correspondance directe entre l’arborescence « QObject » de Qt et l’arborescence des objets accessibles. Par exemple, les poignées de barre de défilement sont des objets accessibles, mais ne sont ni des widgets ni des objets dans Qt.

Les clients d’assistance technique ont accès à l’arborescence des objets d’accessibilité via l’objet racine de l’arborescence, qui est l’ QApplication. Ils peuvent parcourir l’arborescence à l’aide des fonctions QAccessibleInterface::parent(), QAccessibleInterface::childCount() et QAccessibleInterface::child().

Qt fournit des interfaces accessibles pour ses widgets et pour Qt Quick Controls. Les interfaces de toute sous-classe de QObject peuvent être demandées via QAccessible::queryInterface(). Une implémentation par défaut est fournie si aucune interface plus spécialisée n’est définie. Un client AT ne peut pas obtenir d’interface pour les objets accessibles qui ne disposent pas d’ QObject équivalent, par exemple les poignées de barre de défilement, mais ceux-ci apparaissent comme des objets normaux via les interfaces des objets accessibles parents ; par exemple, vous pouvez interroger leurs relations à l’aide de ` QAccessibleInterface::relations()`.

À titre d’illustration, nous présentons une image d’une arborescence d’objets accessibles. Sous l’arborescence se trouve un tableau contenant des exemples de relations entre objets.

Les libellés, classés de haut en bas, sont les suivants : le nom de la classe « QAccessibleInterface », le widget pour lequel une interface est fournie, et l’ Role de l’objet. Les éléments « Position », « PageLeft » et « PageRight » correspondent respectivement à la poignée du curseur, à la rainure gauche du curseur et à la rainure droite du curseur. Ces objets accessibles ne disposent pas d’une QObject équivalente.

Les fonctions statiques de QAccessible

L'accessibilité est gérée par les fonctions statiques de ` QAccessible`, que nous examinerons sous peu. Elles génèrent des interfaces ` QAccessible `, construisent l'arborescence des objets et établissent la connexion avec MSAA ou d'autres technologies spécifiques à la plateforme. Si vous souhaitez uniquement apprendre à rendre votre application accessible, vous pouvez sans problème passer cette section et vous rendre directement à la section « Mise en œuvre de l'accessibilité ».

La communication entre les clients et le serveur est établie lors de l’appel de la fonction setRootObject(). Cela se produit lors de l’instanciation de l’instance QApplication et vous ne devriez pas avoir à vous en charger vous-même.

Lorsqu’un ` QObject ` appelle ` updateAccessibility()`, les clients à l’écoute des événements sont informés du changement. Cette fonction sert à envoyer des événements à la technologie d’assistance, tandis que les ` events ` accessibles sont envoyés par ` updateAccessibility()`.

queryAccessibleInterface() renvoie des interfaces accessibles pour les objets de type ` QObject`. Tous les widgets de Qt fournissent des interfaces ; si vous avez besoin d’interfaces pour contrôler le comportement d’autres sous-classes de ` QObject `, vous devez implémenter ces interfaces vous-même, bien que la classe de commodité ` QAccessibleObject ` implémente une partie de cette fonctionnalité à votre place.

L'usine qui génère les interfaces d'accessibilité pour les QObjects est une fonction de type QAccessible::InterfaceFactory. Il est possible d'installer plusieurs usines. La dernière usine installée sera la première à laquelle on demandera des interfaces. La fonction queryAccessibleInterface() utilise ces usines pour créer des interfaces pour les QObjects. En règle générale, vous n'avez pas à vous soucier des usines, car vous pouvez implémenter des plugins qui génèrent eux-mêmes des interfaces. Nous donnerons plus loin des exemples des deux approches.

Implémentation de l’accessibilité

Pour fournir une prise en charge de l’accessibilité pour un widget ou un autre élément d’interface utilisateur, vous devez implémenter l’interface QAccessibleInterface et la distribuer dans un QAccessiblePlugin. Il est également possible de compiler l’interface dans l’application et de fournir une QAccessible::InterfaceFactory pour celle-ci. La factory peut être utilisée si vous effectuez une liaison statique ou si vous ne souhaitez pas la complexité supplémentaire liée aux plugins. Cela peut constituer un avantage si, par exemple, vous fournissez une bibliothèque tierce.

Tous les widgets et autres éléments de l'interface utilisateur doivent disposer d'interfaces et de plugins. Si vous souhaitez que votre application prenne en charge l'accessibilité, vous devrez tenir compte des points suivants :

• Qt implémente déjà l’accessibilité pour ses propres widgets. Nous vous recommandons donc d’utiliser les Qt Widgets dans la mesure du possible.
• Un « QAccessibleInterface » doit être implémenté pour chaque élément que vous souhaitez rendre accessible aux clients d’accessibilité.
• Vous devez envoyer des événements d’accessibilité à partir des éléments d’interface utilisateur personnalisés que vous implémentez.

En général, il est recommandé d’avoir une certaine familiarité avec MSAA, pour lequel la prise en charge de l’accessibilité de Qt a été initialement conçue. Vous devriez également étudier les valeurs d’énumération de ` QAccessible`, qui décrivent les rôles, les actions, les relations et les événements à prendre en compte.

Notez que vous pouvez examiner comment les Qt Widgets implémentent leur accessibilité. L’un des principaux problèmes de la norme MSAA réside dans le fait que les interfaces sont souvent implémentées de manière incohérente. Cela complique la tâche des clients et conduit souvent à des conjectures sur les fonctionnalités des objets.

Il est possible d’implémenter des interfaces en héritant de ` QAccessibleInterface ` et en implémentant ses fonctions virtuelles pures. Dans la pratique, cependant, il est généralement préférable d’hériter de ` QAccessibleObject ` ou de ` QAccessibleWidget`, qui implémentent une partie des fonctionnalités à votre place. Dans la section suivante, nous verrons un exemple d’implémentation de l’accessibilité pour un widget en héritant de la classe ` QAccessibleWidget `.

Les classes de commodité QAccessibleObject et QAccessibleWidget

Lors de l’implémentation d’une interface d’accessibilité pour des widgets, on hérite en règle générale de QAccessibleWidget, qui est une classe de commodité pour les widgets. Une autre classe de commodité disponible, dont hérite QAccessibleWidget, est QAccessibleObject, qui implémente une partie de l’interface pour les QObjects.

La classe QAccessibleWidget offre les fonctionnalités suivantes :

• Elle gère la navigation dans l’arborescence et le test de collision des objets.
• Elle gère les événements, les rôles et les actions communs à tous les objets de type ` QWidget`.
• Elle gère les actions et les méthodes pouvant être exécutées sur tous les widgets.
• Elle calcule les rectangles englobants à l’aide de la méthode ` rect()`.
• Elle fournit à la méthode ` text()` des chaînes de caractères adaptées à un widget générique.
• Elle définit les states communes à tous les widgets.

Exemple de QAccessibleWidget

Au lieu de créer un widget personnalisé et d’implémenter une interface pour celui-ci, nous allons montrer comment l’accessibilité est implémentée pour l’un des widgets standard de Qt : le QSlider. L’interface accessible, QAccessibleSlider, hérite de QAccessibleAbstractSlider, qui hérite lui-même d QAccessibleWidget. Il n’est pas nécessaire d’examiner la classe `QAccessibleAbstractSlider` pour lire cette section. Si vous souhaitez y jeter un œil, le code de toutes les interfaces accessibles de Qt se trouve dans `qtbase/src/widgets/accessible`. Voici le constructeur de `QAccessibleSlider` :

QAccessibleSlider::QAccessibleSlider(QWidget *w)
: QAccessibleAbstractSlider(w)
{
    Q_ASSERT(slider());
    addControllingSignal(QLatin1String("valueChanged(int)"));
}

Le slider est un contrôle complexe qui fait office d’ Controller pour ses enfants accessibles. Cette relation doit être connue de l’interface (pour les méthodes parent(), child() et relations()). Cela peut être réalisé à l’aide d’un signal de contrôle, mécanisme fourni par QAccessibleWidget. Nous procédons ainsi dans le constructeur :

Le choix du signal présenté ici n’a pas d’importance ; les mêmes principes s’appliquent à tous les signaux déclarés de cette manière. Notez que nous utilisons ` QLatin1String ` pour nous assurer que le nom du signal est correctement spécifié.

Lorsqu’un objet accessible subit une modification dont les utilisateurs doivent être informés, il notifie cette modification aux clients en leur envoyant un événement via l’interface accessible. Voici comment QSlider appelle updateAccessibility() pour indiquer que sa valeur a changé :

void QAbstractSlider::setValue(int value)
    ...
    QAccessibleValueChangeEvent event(this, d->value);
    QAccessible::updateAccessibility(&event);
    ...
}

Notez que l’appel est effectué après que la valeur du curseur a changé, car les clients peuvent interroger la nouvelle valeur immédiatement après avoir reçu l’événement.

L’interface doit être capable de calculer les rectangles de délimitation de l’interface elle-même et de tous ses enfants qui ne fournissent pas d’interface propre. L’ QAccessibleSlider possède trois enfants de ce type, identifiés par l’énumération privée SliderElements, qui prend les valeurs suivantes : PageLeft (le rectangle situé à gauche de la poignée du curseur), PageRight (le rectangle situé à droite de la poignée) et Position (la poignée du curseur). Voici l’implémentation de la fonction rect() :

QRect QAccessibleSlider::rect(int child) const
{
    ...
    switch (child) {
    case PageLeft:
        if (slider()->orientation() == Qt::Vertical)
            rect = QRect(0, 0, slider()->width(), srect.y());
        else
            rect = QRect(0, 0, srect.x(), slider()->height());
        break;
    case Position:
        rect = srect;
        break;
    case PageRight:
        if (slider()->orientation() == Qt::Vertical)
            rect = QRect(0, srect.y() + srect.height(), slider()->width(), slider()->height()- srect.y() - srect.height());
        else
            rect = QRect(srect.x() + srect.width(), 0, slider()->width() - srect.x() - srect.width(), slider()->height());
        break;
    default:
        return QAccessibleAbstractSlider::rect(child);
    }
    ...

La première partie de la fonction, que nous avons omise, utilise l’ style e actuelle pour calculer le rectangle englobant de la poignée du curseur ; celui-ci est stocké dans srect. Notez que l’enfant 0, traité par défaut dans le code ci-dessus, correspond au curseur lui-même ; nous pouvons donc simplement renvoyer le rectangle de délimitation QSlider obtenu depuis la superclasse, qui correspond en fait à la valeur renvoyée par QAccessibleWidget::rect().

    QPoint tp = slider()->mapToGlobal(QPoint(0,0));
    return QRect(tp.x() + rect.x(), tp.y() + rect.y(), rect.width(), rect.height());
}

Avant de renvoyer le rectangle, il faut le convertir en coordonnées d’écran.

La classe `QAccessibleSlider` doit réimplémenter la méthode ` QAccessibleInterface::childCount()` puisqu’elle gère des enfants sans interface.

La fonction text() renvoie les chaînes QAccessible::Text correspondant au curseur :

QString QAccessibleSlider::text(Text t, int child) const
{
    if (!slider()->isVisible())
        return QString();
    switch (t) {
    case Value:
        if (!child || child == 2)
            return QString::number(slider()->value());
        return QString();
    case Name:
        switch (child) {
        case PageLeft:
            return slider()->orientation() == Qt::Horizontal ?
                QSlider::tr("Page left") : QSlider::tr("Page up");
        case Position:
            return QSlider::tr("Position");
        case PageRight:
            return slider()->orientation() == Qt::Horizontal ?
                QSlider::tr("Page right") : QSlider::tr("Page down");
        }
        break;
    default:
        break;
    }
    return QAccessibleAbstractSlider::text(t, child);
}

La fonction slider() renvoie un pointeur vers l’ QSlider de l’interface. Certaines valeurs sont laissées à la charge de l’implémentation de la superclasse. Toutes les valeurs ne conviennent pas à tous les objets accessibles, comme vous pouvez le constater dans le cas de QAccessible::Value. Vous devez simplement renvoyer une chaîne vide pour les valeurs pour lesquelles aucun texte pertinent ne peut être fourni.

L’implémentation de la fonction ` role()` est simple :

QAccessible::Role QAccessibleSlider::role(int child) const
{
    switch (child) {
    case PageLeft:
    case PageRight:
        return PushButton;
    case Position:
        return Indicator;
    default:
        return Slider;
    }
}

La fonction `role` doit être réimplémentée par tous les objets et décrit leur propre rôle ainsi que celui des enfants qui ne fournissent pas d’interface accessible.

Ensuite, l’interface accessible doit renvoyer les états ( states ) dans lesquels le curseur peut se trouver. Nous examinons certaines parties de l’implémentation de ` state() ` pour montrer comment quelques-uns de ces états sont gérés :

QAccessible::State QAccessibleSlider::state(int child) const
{
    const State parentState = QAccessibleAbstractSlider::state(0);
    ...
    switch (child) {
    case PageLeft:
        if (slider->value() <= slider->minimum())
            state |= Unavailable;
        break;
    case PageRight:
        if (slider->value() >= slider->maximum())
            state |= Unavailable;
        break;
    case Position:
    default:
        break;
    }

    return state;
}

L’implémentation de la superclasse de ` state()` utilise l’implémentation de ` QAccessibleInterface::state()`. Il suffit simplement de désactiver les boutons si le curseur se trouve à sa valeur minimale ou maximale.

Nous avons désormais exposé aux clients les informations dont nous disposons concernant le curseur. Pour que les clients puissent modifier le curseur — par exemple, pour changer sa valeur —, nous devons fournir des informations sur les actions pouvant être effectuées et les exécuter à la demande. Nous aborderons ce sujet dans la section suivante.

Gestion des demandes d’action provenant des clients

Les applications peuvent exposer des actions, qui peuvent être invoquées par le client. Pour prendre en charge les actions dans un objet, héritez de l’ QAccessibleActionInterface.

Les éléments interactifs doivent exposer des fonctionnalités déclenchées, par exemple, par une interaction avec la souris. Un bouton doit, par exemple, implémenter une action de clic.

La mise en focus est une autre action qui doit être implémentée pour les widgets pouvant recevoir le focus.

Vous devez réimplémenter la méthode ` actionNames()` afin de renvoyer une liste de toutes les actions prises en charge par l’objet. Cette liste ne doit pas être localisée.

Il existe deux fonctions qui fournissent des informations sur les actions et qui doivent renvoyer des chaînes localisées : ` localizedActionName()` et ` localizedActionDescription()`. Ces fonctions peuvent être utilisées par le client pour présenter les actions à l’utilisateur. En général, le nom doit être concis et ne comporter qu’un seul mot, tel que « press ».

Il existe une liste de noms d'actions standard et de leurs localisations, qu'il convient d'utiliser lorsque l'action s'y prête. Cela permet aux clients de mieux comprendre la sémantique, et Qt s'efforcera de les afficher correctement sur les différentes plateformes.

Bien sûr, l'action doit également pouvoir être déclenchée. La méthode ` doAction()` doit invoquer l'action telle qu'elle est définie par son nom et sa description.

Pour voir des exemples d'implémentation d'actions et de méthodes, vous pouvez consulter les implémentations des widgets standard de Qt, tels que QAccessiblePushButton.

Implémentation de plugins accessibles

Dans cette section, nous allons expliquer la procédure à suivre pour implémenter des plugins accessibles pour vos interfaces. Un plugin est une classe stockée dans une bibliothèque partagée qui peut être chargée à l’exécution. Il est pratique de distribuer les interfaces sous forme de plugins, car celles-ci ne seront chargées qu’en cas de besoin.

La création d’un plugin accessible s’effectue en héritant de ` QAccessiblePlugin`, en définissant les noms de classes pris en charge dans la description JSON du plugin et en réimplémentant la méthode ` create()` à partir de ` QAccessiblePlugin`. Le fichier ` .pro ` doit être modifié pour utiliser le modèle de plugin, et la bibliothèque contenant le plugin doit être placée sur un chemin où Qt recherche les plugins accessibles.

Nous allons passer en revue l’implémentation de SliderPlugin, qui est un plugin d’accessibilité générant l’interface `QAccessibleSlider` à partir de l’exemple `QAccessibleWidget`. Commençons par la fonction ` key() ` :

QStringList SliderPlugin::keys() const
{
    return QStringList() << QLatin1String("QSlider");
}

Il suffit de renvoyer le nom de la classe correspondant à la seule interface pour laquelle notre plugin peut créer une interface accessible. Un plugin peut prendre en charge un nombre illimité de classes ; il suffit d’ajouter d’autres noms de classes à la liste de chaînes. Passons à la fonction ` create() ` :

QAccessibleInterface *SliderPlugin::create(const QString &classname, QObject *object)
{
    QAccessibleInterface *interface = 0;

    if (classname == QLatin1String("QSlider") && object && object->isWidgetType())
        interface = new QAccessibleSlider(static_cast<QWidget *>(object));

    return interface;
}

Nous vérifions si l'interface demandée correspond à QSlider; si c'est le cas, nous créons et renvoyons une interface pour celle-ci. Notez que object sera toujours une instance de classname. Vous devez renvoyer 0 si vous ne prenez pas en charge la classe. La fonction updateAccessibility() interroge les plugins d'accessibilité disponibles jusqu'à ce qu'elle en trouve un qui ne renvoie pas 0.

Enfin, vous devez inclure des macros dans le fichier cpp :

    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.Examples.Accessibility.SliderPlugin" FILE "slider.json")

La macro Q_PLUGIN_METADATA exporte le plugin de la classe SliderPlugin vers la bibliothèque acc_sliderplugin. Le premier argument est l’IID du plugin et le second est un fichier JSON facultatif contenant les métadonnées du plugin. Pour plus d’informations sur les plugins, vous pouvez consulter le document de présentation des plugins.

Peu importe que le plugin soit lié de manière statique ou dynamique à l’application.

Implémentation des fabriques d’interfaces

Si vous ne souhaitez pas fournir de plugins pour vos interfaces d’accessibilité, vous pouvez utiliser une usine d’interfaces (QAccessible::InterfaceFactory), ce qui constitue la méthode recommandée pour fournir des interfaces accessibles dans une application liée de manière statique.

Une fabrique est un pointeur vers une fonction qui prend les mêmes paramètres que la méthode create() de QAccessiblePlugin: un QString et un QObject. Son fonctionnement est également identique. Vous installez la fabrique à l’aide de la fonction installFactory(). Voici un exemple illustrant comment créer une fabrique pour l’interface QAccessibleSlider:

QAccessibleInterface *sliderFactory(const QString &classname, QObject *object)
{
    QAccessibleInterface *interface = 0;

    if (classname == QLatin1String("QSlider") && object && object->isWidgetType())
        interface = new QAccessibleSlider(static_cast<QWidget *>(object));

    return interface;
}

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    QAccessible::installFactory(sliderFactory);
    ...
}

Classes associées