Barrierefreiheit für QWidget-Anwendungen

Einführung

Wir werden uns auf die Qt-Zugänglichkeitsschnittstelle QAccessibleInterface und darauf konzentrieren, wie man Anwendungen zugänglich macht.

Zugänglichkeit in QWidget-basierten Anwendungen

Wenn wir mit unterstützenden Technologien kommunizieren, müssen wir die Qt-Benutzeroberfläche so beschreiben, dass sie für diese verständlich ist. Qt-Anwendungen verwenden QAccessibleInterface, um Informationen über die einzelnen UI-Elemente bereitzustellen. Derzeit bietet Qt Unterstützung für seine Widgets und Widget-Teile, z.B. Schieberegler, aber die Schnittstelle könnte auch für jedes beliebige QObject implementiert werden, falls erforderlich. QAccessible enthält Enums, die die Benutzeroberfläche beschreiben. Wir werden die Enums im weiteren Verlauf dieses Dokuments untersuchen.

Die Struktur der Benutzeroberfläche wird als ein Baum von QAccessibleInterface Unterklassen dargestellt. Dies ist oft ein Spiegelbild der Hierarchie von QWidgets, die die Benutzeroberfläche der Anwendung bilden.

Server benachrichtigen Clients über updateAccessibility() über Änderungen an Objekten, indem sie Ereignisse senden, und die Clients registrieren sich, um die Ereignisse zu empfangen. Die verfügbaren Ereignisse werden durch das QAccessible::Event enum definiert. Die Clients können dann über QAccessible::queryAccessibleInterface() das Objekt abfragen, das das Ereignis erzeugt hat.

Die Mitglieder und Enums in QAccessible werden verwendet, um zugängliche Objekte zu beschreiben:

• Role: Beschreibt die Rolle, die das Objekt in der Benutzeroberfläche einnimmt, z.B. ob es sich um ein Fenster, eine Texteingabe oder eine Zelle in einer Tabelle handelt.
• Relation: Beschreibt die Beziehung zwischen Objekten in der Objekthierarchie.
• State: Die Objekte können sich in einer Reihe von verschiedenen Zuständen befinden. Beispiele für Zustände sind, ob das Objekt deaktiviert ist, ob es den Fokus hat oder ob es ein Popup-Menü bietet.

Die Clients haben auch einige Möglichkeiten, den Inhalt von Objekten abzufragen, z. B. den Text einer Schaltfläche; das Objekt bietet Strings, die durch das QAccessible::Text enum definiert sind und Informationen über den Inhalt liefern.

Der zugängliche Objektbaum

Wie bereits erwähnt, wird eine Baumstruktur aus den zugänglichen Objekten einer Anwendung aufgebaut. Durch das Navigieren durch den Baum können die Clients auf alle Elemente der Benutzeroberfläche zugreifen. Objektbeziehungen geben den Clients Informationen über die Benutzeroberfläche. Zum Beispiel ist ein Schiebereglergriff ein Kind des Schiebereglers, zu dem er gehört. QAccessible::Relation beschreibt die verschiedenen Beziehungen, nach denen die Clients Objekte fragen können.

Beachten Sie, dass es kein direktes Mapping zwischen dem Qt QObject Baum und dem zugänglichen Objektbaum gibt. Zum Beispiel sind die Griffe der Bildlaufleisten zugängliche Objekte, aber keine Widgets oder Objekte in Qt.

AT-Clients haben Zugriff auf den Baum der barrierefreien Objekte über das Wurzelobjekt des Baums, das QApplication. Sie können mit den Funktionen QAccessibleInterface::parent(), QAccessibleInterface::childCount() und QAccessibleInterface::child() durch den Baum navigieren.

Qt bietet zugängliche Schnittstellen für seine Widgets und für Qt Quick Controls. Schnittstellen für jede QObject Unterklasse können über QAccessible::queryInterface() abgefragt werden. Eine Standard-Implementierung wird bereitgestellt, wenn keine speziellere Schnittstelle definiert ist. Ein AT-Client kann keine Schnittstelle für zugängliche Objekte abfragen, die keine äquivalente QObject haben, z. B. die Griffe von Bildlaufleisten, aber sie erscheinen als normale Objekte durch Schnittstellen von übergeordneten zugänglichen Objekten, z. B. können Sie ihre Beziehungen mit QAccessibleInterface::relations() abfragen.

Zur Veranschaulichung zeigen wir ein Bild eines zugänglichen Objektbaums. Unterhalb des Baums befindet sich eine Tabelle mit Beispielen für Objektbeziehungen.

Die Beschriftungen in der Reihenfolge von oben nach unten sind: der Klassenname QAccessibleInterface, das Widget, für das eine Schnittstelle bereitgestellt wird, und die Role des Objekts. Position, PageLeft und PageRight entsprechen jeweils dem Schiebereglergriff, der Schiebereglerrille links und der Schiebereglerrille rechts. Für diese zugänglichen Objekte gibt es keine entsprechende QObject.

Die statischen QAccessible-Funktionen

Die Zugänglichkeit wird von den statischen Funktionen von QAccessible verwaltet, die wir in Kürze untersuchen werden. Sie erzeugen QAccessible Schnittstellen, bauen den Objektbaum auf und initiieren die Verbindung mit MSAA oder den anderen plattformspezifischen Technologien. Wenn Sie nur daran interessiert sind, zu erfahren, wie Sie Ihre Anwendung barrierefrei gestalten, können Sie diesen Abschnitt getrost überspringen und zur Implementierung der Barrierefreiheit übergehen.

Die Kommunikation zwischen Clients und dem Server wird durch den Aufruf von setRootObject() eingeleitet. Dies geschieht, wenn die Instanz QApplication instanziiert wird, und Sie sollten dies nicht selbst tun müssen.

Wenn QObject updateAccessibility () aufruft, werden die Clients, die auf Ereignisse warten, über die Änderung informiert. Die Funktion wird verwendet, um Ereignisse an die unterstützende Technologie zu übermitteln, und die zugänglichen events werden von updateAccessibility() übermittelt.

queryAccessibleInterface() gibt zugängliche Schnittstellen für QObjects zurück. Alle Widgets in Qt bieten Schnittstellen; wenn Sie Schnittstellen benötigen, um das Verhalten anderer QObject Unterklassen zu steuern, müssen Sie die Schnittstellen selbst implementieren, obwohl die QAccessibleObject Komfortklasse Teile der Funktionalität für Sie implementiert.

Die Fabrik, die Zugänglichkeitsschnittstellen für QObjects erzeugt, ist eine Funktion vom Typ QAccessible::InterfaceFactory. Es ist möglich, mehrere Fabriken zu installieren. Die zuletzt installierte Fabrik ist die erste, die nach Schnittstellen gefragt wird. queryAccessibleInterface() verwendet die Fabriken, um Schnittstellen für QObjects zu erzeugen. Normalerweise brauchen Sie sich nicht um Fabriken zu kümmern, da Sie Plugins implementieren können, die Schnittstellen erzeugen. Wir werden später Beispiele für beide Ansätze geben.

Implementierung der Barrierefreiheit

Um Unterstützung für die Barrierefreiheit eines Widgets oder eines anderen Elements der Benutzeroberfläche bereitzustellen, müssen Sie QAccessibleInterface implementieren und in einer QAccessiblePlugin verteilen. Es ist auch möglich, die Schnittstelle in die Anwendung zu kompilieren und eine QAccessible::InterfaceFactory dafür bereitzustellen. Die Factory kann verwendet werden, wenn Sie statisch verlinken oder die zusätzliche Komplexität von Plugins nicht wünschen. Dies kann von Vorteil sein, wenn Sie z.B. eine 3-Parteien-Bibliothek ausliefern.

Alle Widgets und andere Elemente der Benutzeroberfläche sollten über Schnittstellen und Plugins verfügen. Wenn Sie möchten, dass Ihre Anwendung die Barrierefreiheit unterstützt, müssen Sie Folgendes beachten:

• Qt implementiert bereits Barrierefreiheit für seine eigenen Widgets. Wir empfehlen Ihnen daher, wenn möglich Qt Widgets zu verwenden.
• Ein QAccessibleInterface muss für jedes Element implementiert werden, das Sie für barrierefreie Clients verfügbar machen wollen.
• Sie müssen Barrierefreiheitsereignisse von den benutzerdefinierten Benutzeroberflächenelementen, die Sie implementieren, senden.

Im Allgemeinen wird empfohlen, dass Sie mit MSAA vertraut sind, für das die Unterstützung der Barrierefreiheit in Qt ursprünglich entwickelt wurde. Sie sollten auch die Enum-Werte von QAccessible studieren, die die Rollen, Aktionen, Beziehungen und Ereignisse beschreiben, die Sie berücksichtigen müssen.

Beachten Sie, dass Sie untersuchen können, wie die Widgets von Qt ihre Barrierefreiheit implementieren. Ein großes Problem des MSAA-Standards besteht darin, dass Schnittstellen oft auf inkonsistente Weise implementiert werden. Dies erschwert den Clients das Leben und führt oft zu Vermutungen über die Objektfunktionalität.

Es ist möglich, Schnittstellen zu implementieren, indem man QAccessibleInterface erbt und seine rein virtuellen Funktionen implementiert. In der Praxis ist es jedoch meist vorzuziehen, QAccessibleObject oder QAccessibleWidget zu erben, die einen Teil der Funktionalität für Sie implementieren. Im nächsten Abschnitt sehen wir ein Beispiel für die Implementierung von Barrierefreiheit für ein Widget durch Vererbung der Klasse QAccessibleWidget.

Die Convenience-Klassen QAccessibleObject und QAccessibleWidget

Bei der Implementierung einer Zugänglichkeitsschnittstelle für Widgets würde man in der Regel QAccessibleWidget erben, eine Convenience-Klasse für Widgets. Eine weitere verfügbare Convenience-Klasse, die von QAccessibleWidget geerbt wird, ist die QAccessibleObject, die einen Teil der Schnittstelle für QObjects implementiert.

Die Klasse QAccessibleWidget bietet die folgenden Funktionen:

• Sie handhabt die Navigation im Baum und die Trefferprüfung der Objekte.
• Sie verwaltet Ereignisse, Rollen und Aktionen, die für alle QWidgetgemeinsam sind.
• Es verwaltet Aktionen und Methoden, die auf allen Widgets ausgeführt werden können.
• Es berechnet begrenzende Rechtecke mit rect().
• Es gibt text() Zeichenketten, die für ein generisches Widget geeignet sind.
• Es setzt die states, die für alle Widgets gemeinsam sind.

QAccessibleWidget Beispiel

Anstatt ein benutzerdefiniertes Widget zu erstellen und eine Schnittstelle dafür zu implementieren, zeigen wir, wie die Zugänglichkeit für eines der Standard-Widgets von Qt implementiert wird: QSlider. Die zugängliche Schnittstelle, QAccessibleSlider, erbt von QAccessibleAbstractSlider, das wiederum von QAccessibleWidget erbt. Sie brauchen die Klasse QAccessibleAbstractSlider nicht zu untersuchen, um diesen Abschnitt zu lesen. Wenn Sie einen Blick darauf werfen wollen, finden Sie den Code für alle zugänglichen Schnittstellen von Qt in qtbase/src/widgets/accessible. Hier ist der Konstruktor von QAccessibleSlider:

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

Der Slider ist ein komplexes Steuerelement, das als Controller für seine zugänglichen Kinder fungiert. Diese Beziehung muss der Schnittstelle bekannt sein (für parent(), child() und relations()). Dies kann mit Hilfe eines Steuersignals geschehen, einem Mechanismus, der von QAccessibleWidget bereitgestellt wird. Wir tun dies im Konstruktor:

Die Wahl des gezeigten Signals ist nicht wichtig; die gleichen Prinzipien gelten für alle Signale, die auf diese Weise deklariert werden. Beachten Sie, dass wir QLatin1String verwenden, um sicherzustellen, dass der Signalname korrekt angegeben ist.

Wenn ein zugängliches Objekt in einer Weise geändert wird, von der die Benutzer wissen müssen, benachrichtigt es die Clients von der Änderung, indem es ihnen ein Ereignis über die zugängliche Schnittstelle sendet. So ruft QSlider updateAccessibility () auf, um anzuzeigen, dass sich sein Wert geändert hat:

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

Beachten Sie, dass der Aufruf erfolgt, nachdem sich der Wert des Schiebereglers geändert hat, da die Clients den neuen Wert unmittelbar nach Erhalt des Ereignisses abfragen können.

Die Schnittstelle muss in der Lage sein, begrenzende Rechtecke für sich selbst und alle untergeordneten Elemente zu berechnen, die keine eigene Schnittstelle bereitstellen. QAccessibleSlider hat drei solcher Kinder, die durch das private Enum SliderElements identifiziert werden, das die folgenden Werte hat: PageLeft (das Rechteck auf der linken Seite des Schiebereglergriffs), PageRight (das Rechteck auf der rechten Seite des Griffs) und Position (der Schiebereglergriff). Hier ist die Implementierung von 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);
    }
    ...

Der erste Teil der Funktion, den wir weggelassen haben, verwendet das aktuelle style, um das Begrenzungsrechteck des Schiebereglergriffs zu berechnen; es ist in srect gespeichert. Beachten Sie, dass das Kind 0, das im obigen Code standardmäßig abgedeckt ist, der Schieberegler selbst ist, so dass wir einfach das von der Superklasse erhaltene QSlider begrenzende Rechteck zurückgeben können, das praktisch der von QAccessibleWidget::rect() erhaltene Wert ist.

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

Bevor das Rechteck zurückgegeben wird, muss es auf Bildschirmkoordinaten abgebildet werden.

Der QAccessibleSlider muss QAccessibleInterface::childCount() reimplementieren, da er Kinder ohne Schnittstellen verwaltet.

Die Funktion text() gibt die QAccessible::Text Zeichenketten für den Schieberegler zurück:

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);
}

Die Funktion slider() gibt einen Zeiger auf die Schnittstelle QSlider zurück. Einige Werte werden der Implementierung der Oberklasse überlassen. Nicht alle Werte sind für alle zugänglichen Objekte geeignet, wie Sie im Fall von QAccessible::Value sehen können. Sie sollten einfach einen leeren String für die Werte zurückgeben, für die kein relevanter Text bereitgestellt werden kann.

Die Implementierung der Funktion role() ist sehr einfach:

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

Die Funktion role sollte von allen Objekten reimplementiert werden und beschreibt die Rolle von sich selbst und den untergeordneten Objekten, die keine eigenen zugänglichen Schnittstellen anbieten.

Als nächstes muss die zugängliche Schnittstelle die states zurückgeben, in der sich der Schieberegler befinden kann. Wir sehen uns Teile der Implementierung von state() an, um zu zeigen, wie nur einige der Zustände gehandhabt werden:

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

Die Superklassen-Implementierung von state() verwendet die Implementierung von QAccessibleInterface::state(). Wir müssen lediglich die Schaltflächen deaktivieren, wenn der Schieberegler auf seinem Minimum oder Maximum steht.

Wir haben nun die Informationen, die wir über den Schieberegler haben, an die Clients weitergegeben. Damit die Clients in der Lage sind, den Schieberegler zu verändern - z. B. um seinen Wert zu ändern - müssen wir Informationen über die möglichen Aktionen bereitstellen und diese auf Anfrage ausführen. Wir besprechen dies im nächsten Abschnitt.

Behandlung von Aktionsanfragen von Clients

Anwendungen können Aktionen bereitstellen, die vom Client aufgerufen werden können. Um Aktionen in einem Objekt zu unterstützen, erben Sie die QAccessibleActionInterface.

Interaktive Elemente sollten Funktionen bereitstellen, die z. B. durch Mausinteraktion ausgelöst werden. Eine Schaltfläche sollte z. B. eine Klick-Aktion implementieren.

Das Setzen des Fokus ist eine weitere Aktion, die für Widgets, die den Fokus erhalten, implementiert werden sollte.

Sie müssen actionNames() neu implementieren, um eine Liste aller Aktionen zurückzugeben, die das Objekt unterstützt. Diese Liste sollte nicht lokalisiert werden.

Es gibt zwei Funktionen, die Informationen über die Aktionen liefern, die lokalisierte Zeichenketten zurückgeben müssen: localizedActionName() und localizedActionDescription(). Diese Funktionen können vom Client verwendet werden, um dem Benutzer die Aktionen zu präsentieren. Im Allgemeinen sollte der Name prägnant sein und nur aus einem einzigen Wort bestehen, z. B. "press".

Es gibt eine Liste von Standard-Aktionsnamen und Lokalisierungen, die verwendet werden sollten, wenn die Aktion passt. Das macht es für Clients einfacher, die Semantik zu verstehen, und Qt wird versuchen, sie auf den verschiedenen Plattformen korrekt darzustellen.

Natürlich braucht die Aktion auch einen Weg, um ausgelöst zu werden. doAction() sollte die Aktion so aufrufen, wie sie durch Name und Beschreibung angekündigt wird.

Um Beispiele für die Implementierung von Aktionen und Methoden zu sehen, können Sie sich die Implementierungen für die Standard-Widgets von Qt wie QAccessiblePushButton ansehen.

Implementierung von zugänglichen Plugins

In diesem Abschnitt wird das Verfahren zur Implementierung barrierefreier Plugins für Ihre Schnittstellen erläutert. Ein Plugin ist eine Klasse, die in einer Shared Library gespeichert ist und zur Laufzeit geladen werden kann. Es ist praktisch, Schnittstellen als Plugins zu verteilen, da sie nur bei Bedarf geladen werden.

Die Erstellung eines zugänglichen Plugins erfolgt durch die Vererbung von QAccessiblePlugin, die Definition der unterstützten Klassennamen in der JSON-Beschreibung des Plugins und die Neuimplementierung von create() von QAccessiblePlugin. Die Datei .pro muss geändert werden, um die Plugin-Vorlage zu verwenden, und die Bibliothek, die das Plugin enthält, muss in einem Pfad platziert werden, in dem Qt nach zugänglichen Plugins sucht.

Wir werden die Implementierung von SliderPlugin durchgehen, das ein barrierefreies Plugin ist, das die Schnittstelle QAccessibleSlider aus dem QAccessibleWidget-Beispiel erzeugt. Wir beginnen mit der Funktion key():

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

Wir müssen lediglich den Klassennamen der einzigen Schnittstelle zurückgeben, für die unser Plugin eine zugängliche Schnittstelle erstellen kann. Ein Plugin kann eine beliebige Anzahl von Klassen unterstützen; fügen Sie einfach weitere Klassennamen zur Stringliste hinzu. Weiter geht es mit der Funktion 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;
}

Wir prüfen, ob die angeforderte Schnittstelle für QSlider ist; wenn ja, erstellen wir eine Schnittstelle für sie und geben sie zurück. Beachten Sie, dass object immer eine Instanz von classname sein wird. Sie müssen 0 zurückgeben, wenn Sie die Klasse nicht unterstützen. updateAccessibility() prüft die verfügbaren Zugänglichkeits-Plugins, bis es eines findet, das nicht 0 zurückgibt.

Schließlich müssen Sie Makros in die cpp-Datei aufnehmen:

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

Das Makro Q_PLUGIN_METADATA exportiert das Plugin der Klasse SliderPlugin in die Bibliothek acc_sliderplugin. Das erste Argument ist die IID des Plugins und das zweite ist eine optionale json-Datei, die Metadaten für das Plugin enthält. Weitere Informationen zu Plugins finden Sie im Dokument Plugins im Überblick.

Es spielt keine Rolle, ob das Plugin statisch oder dynamisch mit der Anwendung verknüpft werden soll.

Implementierung von Interface Factories

Wenn Sie keine Plugins für Ihre barrierefreien Schnittstellen bereitstellen möchten, können Sie eine Schnittstellenfabrik (QAccessible::InterfaceFactory) verwenden, die die empfohlene Methode ist, um barrierefreie Schnittstellen in einer statisch verknüpften Anwendung bereitzustellen.

Eine Fabrik ist ein Funktionszeiger für eine Funktion, die die gleichen Parameter wie QAccessiblePlugin's create() - ein QString und ein QObject- annimmt. Sie funktioniert auch auf die gleiche Weise. Sie installieren die Fabrik mit der Funktion installFactory(). Wir geben ein Beispiel dafür, wie man eine Fabrik für die Schnittstelle QAccessibleSlider erstellt:

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);
    ...
}

Verwandte Klassen