Barrierefreiheit für QWidget-Anwendungen

Einführung

Wir konzentrieren uns auf die Qt-Barrierefreiheitsschnittstelle „ QAccessibleInterface “ und darauf, wie Anwendungen barrierefrei gestaltet werden können.

Barrierefreiheit in QWidget-basierten Anwendungen

Bei der Kommunikation mit assistiven Technologien müssen wir die Benutzeroberfläche von Qt so beschreiben, dass diese sie verstehen können. Qt-Anwendungen nutzen „ QAccessibleInterface “, um Informationen über die einzelnen UI-Elemente bereitzustellen. Derzeit bietet Qt Unterstützung für seine Widgets und Widget-Teile, z. B. Schieberegler-Griffe, aber die Schnittstelle könnte bei Bedarf auch für beliebige „ QObject “ implementiert werden. „ QAccessible “ enthält Aufzählungen (Enums), die die Benutzeroberfläche beschreiben. Wir werden diese Aufzählungen im Verlauf dieses Dokuments näher betrachten.

Die Struktur der Benutzeroberfläche wird als Baumstruktur aus Unterklassen von ` QAccessibleInterface ` dargestellt. Diese spiegelt häufig die Hierarchie der QWidgets wider, aus denen sich die Benutzeroberfläche der Anwendung zusammensetzt.

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 die Enumeration ` QAccessible::Event ` definiert. Die Clients können dann über ` QAccessible::queryAccessibleInterface()` nach dem Objekt fragen, das das Ereignis ausgelöst hat.

Die Elemente und Enums in ` QAccessible ` dienen zur Beschreibung der zugänglichen Objekte:

• Role: Beschreibt die Rolle, die das Objekt in der Benutzeroberfläche einnimmt, z. B. ob es sich um ein Fenster, ein Textfeld oder eine Zelle in einer Tabelle handelt.
• Relation: Beschreibt die Beziehung zwischen Objekten in der Objekthierarchie.
• State: Die Objekte können sich in 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ü bereitstellt.

Die Clients haben zudem einige Möglichkeiten, den Inhalt von Objekten abzurufen, z. B. den Text einer Schaltfläche; das Objekt stellt Zeichenfolgen bereit, die durch die Enumeration „ QAccessible::Text “ definiert sind und Informationen zum Inhalt liefern.

Der barrierefreie Objektbaum

Wie bereits erwähnt, wird aus den barrierefreien Objekten einer Anwendung eine Baumstruktur aufgebaut. Durch die Navigation durch den Baum können die Clients auf alle Elemente der Benutzeroberfläche zugreifen. Objektbeziehungen liefern den Clients Informationen über die Benutzeroberfläche. So ist beispielsweise der Schieberegler-Griff ein untergeordnetes Element des Schiebereglers, zu dem er gehört. „ QAccessible::Relation “ beschreibt die verschiedenen Beziehungen, die die Clients von Objekten abfragen können.

QObject Beachten Sie, dass es keine direkte Entsprechung zwischen dem Qt XML-ph-0000@deepl.internal-Baum und dem Baum der barrierefreien Objekte gibt. So sind beispielsweise Scrollleisten-Griffe barrierefreie Objekte, aber keine Widgets oder Objekte in Qt.

AT-Clients haben über das Wurzelobjekt des Baums, nämlich den „ QApplication “, Zugriff auf den Barrierefreiheits-Objektbaum. Sie können mit den Funktionen „ QAccessibleInterface::parent()“, „ QAccessibleInterface::childCount()“ und „ QAccessibleInterface::child()“ durch den Baum navigieren.

Qt stellt barrierefreie Schnittstellen für seine Widgets und für ` Qt Quick Controls` bereit. Schnittstellen für jede Unterklasse von ` QObject ` können über `QAccessible::queryInterface()` abgefragt werden. Ist keine speziellere Schnittstelle definiert, wird eine Standardimplementierung bereitgestellt. Ein AT-Client kann keine Schnittstelle für barrierefreie Objekte abrufen, die kein entsprechendes ` QObject` haben, z. B. Scrollbalken-Griffe; diese erscheinen jedoch als normale Objekte über die Schnittstellen ihrer übergeordneten barrierefreien Objekte – so können Sie beispielsweise ihre Beziehungen mit ` QAccessibleInterface::relations()` abfragen.

Zur Veranschaulichung zeigen wir eine Abbildung eines Baums barrierefreier Objekte. Unterhalb des Baums befindet sich eine Tabelle mit Beispielen für Objektbeziehungen.

Die Bezeichnungen in absteigender Reihenfolge lauten: der Name der Klasse „ QAccessibleInterface “, das Widget, für das eine Schnittstelle bereitgestellt wird, und die „ Role “ des Objekts. Die Werte „Position“, „PageLeft“ und „PageRight“ entsprechen dem Schiebereglergriff, der linken Schiebereglerrille bzw. der rechten Schiebereglerrille. Diese barrierefreien Objekte haben kein Äquivalent unter QObject.

Die statischen QAccessible-Funktionen

Die Barrierefreiheit wird durch die statischen Funktionen von ` QAccessible` verwaltet, auf die wir in Kürze eingehen werden. Sie erzeugen ` QAccessible `-Schnittstellen, bauen den Objektbaum auf und initiieren die Verbindung mit MSAA oder anderen plattformspezifischen Technologien. Wenn Sie lediglich daran interessiert sind, zu erfahren, wie Sie Ihre Anwendung barrierefrei gestalten können, können Sie diesen Abschnitt getrost überspringen und direkt zum Abschnitt „Implementierung der Barrierefreiheit“ weitergehen.

Die Kommunikation zwischen Clients und dem Server wird durch den Aufruf von ` setRootObject()` initiiert. Dies geschieht bei der Instanziierung der ` QApplication `-Instanz, sodass Sie diesen Schritt nicht selbst durchführen müssen.

Wenn ein ` QObject ` die Methode ` updateAccessibility()` aufruft, werden Clients, die auf Ereignisse warten, über die Änderung benachrichtigt. Die Funktion dient dazu, Ereignisse an die assistive Technologie zu senden, und barrierefreie ` events ` werden über ` updateAccessibility()` gesendet.

queryAccessibleInterface() gibt barrierefreie Schnittstellen für „ QObject“ zurück. Alle Widgets in Qt stellen Schnittstellen bereit; wenn Sie Schnittstellen benötigen, um das Verhalten anderer Unterklassen von „ QObject “ zu steuern, müssen Sie die Schnittstellen selbst implementieren, obwohl die Convenience-Klasse „ QAccessibleObject “ Teile der Funktionalität für Sie übernimmt.

Die Factory, die Barrierefreiheitsschnittstellen für `QObjects` erzeugt, ist eine Funktion vom Typ ` QAccessible::InterfaceFactory`. Es ist möglich, mehrere Factories zu installieren. Die zuletzt installierte Factory wird als Erste nach Schnittstellen abgefragt. ` queryAccessibleInterface()` nutzt die Factories, um Schnittstellen für ` QObjects` zu erstellen. Normalerweise müssen Sie sich keine Gedanken über Factories machen, da Sie Plugins implementieren können, die Schnittstellen erzeugen. Wir werden später Beispiele für beide Ansätze geben.

Implementierung der Barrierefreiheit

Um Barrierefreiheit für ein Widget oder ein anderes Element der Benutzeroberfläche zu gewährleisten, müssen Sie die Schnittstelle „ QAccessibleInterface “ implementieren und diese in einem „ QAccessiblePlugin “ bereitstellen. Es ist auch möglich, die Schnittstelle in die Anwendung einzubinden und dafür eine „ QAccessible::InterfaceFactory “ bereitzustellen. Die Factory kann verwendet werden, wenn Sie statisch verknüpfen oder die zusätzliche Komplexität von Plugins vermeiden möchten. Dies kann von Vorteil sein, wenn Sie beispielsweise eine Bibliothek eines Drittanbieters bereitstellen.

Alle Widgets und sonstigen Elemente der Benutzeroberfläche sollten über Schnittstellen und Plugins verfügen. Wenn Ihre Anwendung Barrierefreiheit unterstützen soll, müssen Sie Folgendes beachten:

• Qt implementiert bereits Barrierefreiheit für seine eigenen Widgets. Wir empfehlen daher, nach Möglichkeit Qt Widgets zu verwenden.
• Für jedes Element, das Sie Barrierefreiheits-Clients zur Verfügung stellen möchten, muss ein „ QAccessibleInterface “ implementiert werden.
• Sie müssen Barrierefreiheitsereignisse von den benutzerdefinierten Elementen der Benutzeroberfläche senden, die Sie implementieren.

Generell wird empfohlen, dass Sie sich einigermaßen mit MSAA auskennen, für das die Barrierefreiheitsunterstützung von Qt ursprünglich entwickelt wurde. Sie sollten sich außerdem mit den Enum-Werten von ` QAccessible` vertraut machen, die die Rollen, Aktionen, Beziehungen und Ereignisse beschreiben, die Sie berücksichtigen müssen.

Beachten Sie, dass Sie untersuchen können, wie die Qt Widgets ihre Barrierefreiheit umsetzen. Ein großes Problem des MSAA-Standards besteht darin, dass Schnittstellen oft inkonsistent implementiert werden. Dies erschwert die Arbeit für Clients und führt häufig zu Spekulationen über die Funktionalität von Objekten.

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

Die Komfortklassen „QAccessibleObject“ und „QAccessibleWidget“

Bei der Implementierung einer Barrierefreiheitsschnittstelle für Widgets sollte man in der Regel von ` QAccessibleWidget` erben, einer Hilfsklasse für Widgets. Eine weitere verfügbare Hilfsklasse, von der ` QAccessibleWidget` erbt, ist ` QAccessibleObject`, die einen Teil der Schnittstelle für `QObjects` implementiert.

QAccessibleWidget bietet die folgenden Funktionen:

• Sie übernimmt die Navigation im Baum und die Hit-Prüfung der Objekte.
• Sie verarbeitet Ereignisse, Rollen und Aktionen, die allen „ QWidgets“ gemeinsam sind.
• Es verarbeitet Aktionen und Methoden, die auf allen Widgets ausgeführt werden können.
• Es berechnet Begrenzungsrechtecke mit ` rect()`.
• Es liefert Zeichenfolgen für ` text()`, die für ein generisches Widget geeignet sind.
• Es legt die „ states “ fest, die für alle Widgets gemeinsam sind.

Beispiel für QAccessibleWidget

Anstatt ein benutzerdefiniertes Widget zu erstellen und eine Schnittstelle dafür zu implementieren, zeigen wir, wie die Barrierefreiheit für eines der Standard-Widgets von Qt implementiert wird: den „ QSlider “. Die barrierefreie Schnittstelle, QAccessibleSlider, erbt von QAccessibleAbstractSlider, das wiederum QAccessibleWidget erbt. Sie müssen die Klasse `QAccessibleAbstractSlider` nicht genauer untersuchen, um diesen Abschnitt zu verstehen. Falls Sie einen Blick darauf werfen möchten: Der Code für alle barrierefreien Schnittstellen von Qt befindet sich 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 Schieberegler ist ein komplexes Steuerelement, das für seine barrierefreien untergeordneten Elemente als „ Controller “ fungiert. Diese Beziehung muss der Schnittstelle bekannt sein (für parent(), child() und relations()). Dies kann mithilfe eines Steuerungssignals erfolgen, 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 wird.

Wenn sich ein barrierefreies Objekt so ändert, dass die Nutzer davon erfahren müssen, benachrichtigt es die Clients über die Änderung, indem es ihnen über die barrierefreie Schnittstelle ein Ereignis sendet. So ruft ` QSlider ` die Methode ` 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 erst erfolgt, nachdem sich der Wert des Schiebereglers geändert hat, da Clients den neuen Wert unmittelbar nach Erhalt des Ereignisses abfragen könnten.

Die Schnittstelle muss in der Lage sein, Begrenzungsrechtecke für sich selbst und alle untergeordneten Elemente zu berechnen, die keine eigene Schnittstelle bereitstellen. Der ` QAccessibleSlider ` hat drei solcher untergeordneten Elemente, die durch die private Enumeration ` SliderElements` identifiziert werden, die folgende Werte hat: ` PageLeft ` (das Rechteck auf der linken Seite des Schieberegler-Griffs), ` PageRight ` (das Rechteck auf der rechten Seite des Griffs) und ` Position ` (der Schieberegler-Griff). 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, berechnet anhand des aktuellen ` style ` das Begrenzungsrechteck des Schieberegler-Griffs; dieses wird in ` srect` gespeichert. Beachten Sie, dass „child 0“, das im Standardfall im obigen Code behandelt wird, der Schieberegler selbst ist. Daher können wir einfach das von der Oberklasse erhaltene Begrenzungsrechteck „ QSlider “ zurückgeben, was effektiv dem Wert entspricht, der von „ QAccessibleWidget::rect()“ zurückgegeben wird.

    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 die Methode ` QAccessibleInterface::childCount()` neu implementieren, da er Kinder ohne Schnittstellen verwaltet.

Die Funktion ` text()` gibt die Zeichenfolgen ` QAccessible::Text ` 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 ` QSlider` der Schnittstelle zurück. Einige Werte werden der Implementierung der Oberklasse überlassen. Nicht alle Werte sind für alle barrierefreien Objekte geeignet, wie Sie am Fall von ` QAccessible::Value ` sehen können. Für jene Werte, für die kein relevanter Text bereitgestellt werden kann, sollten Sie einfach eine leere Zeichenkette zurückgeben.

Die Implementierung der Funktion „ role()“ ist unkompliziert:

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

Die Rolle-Funktion sollte von allen Objekten neu implementiert werden und beschreibt die Rolle des jeweiligen Objekts sowie der untergeordneten Elemente, die keine eigenen barrierefreien Schnittstellen bereitstellen.

Als Nächstes muss die barrierefreie Schnittstelle die Zustände ( states ) zurückgeben, die der Schieberegler einnehmen kann. Wir betrachten Teile der Implementierung von „ state() “, um zu zeigen, wie einige dieser Zustände behandelt 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 Implementierung von ` state()` in der Oberklasse nutzt die Implementierung von ` QAccessibleInterface::state()`. Wir müssen lediglich die Schaltflächen deaktivieren, wenn sich der Schieberegler an seinem Minimal- oder Maximalwert befindet.

Wir haben nun die Informationen, die wir über den Schieberegler haben, den Clients zur Verfügung gestellt. Damit die Clients den Schieberegler verändern können – zum Beispiel, um seinen Wert zu ändern –, müssen wir Informationen über die ausführbaren 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 von der Klasse „ QAccessibleActionInterface “.

Interaktive Elemente sollten beispielsweise Funktionen bereitstellen, die durch Mausinteraktion ausgelöst werden. Eine Schaltfläche sollte beispielsweise eine Klickaktion implementieren.

Das Setzen des Fokus ist eine weitere Aktion, die für Widgets implementiert werden sollte, die den Fokus annehmen können.

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 und lokalisierte Zeichenfolgen zurückgeben müssen: ` localizedActionName()` und ` localizedActionDescription()`. Diese Funktionen können vom Client verwendet werden, um dem Benutzer die Aktionen anzuzeigen. Im Allgemeinen sollte der Name prägnant sein und nur aus einem einzigen Wort bestehen, wie beispielsweise „drücken“.

Es gibt eine Liste mit Standard-Aktionsnamen und Lokalisierungen, die verwendet werden sollten, wenn die Aktion dazu passt. Dies erleichtert es den Clients, die Semantik zu verstehen, und Qt wird versuchen, sie auf den verschiedenen Plattformen korrekt darzustellen.

Natürlich muss die Aktion auch ausgelöst werden können. ` doAction()` sollte die Aktion entsprechend dem angegebenen Namen und der Beschreibung aufrufen.

Beispiele für die Implementierung von Aktionen und Methoden finden Sie in den Implementierungen der Qt-Standard-Widgets wie beispielsweise QAccessiblePushButton.

Implementierung barrierefreier Plugins

In diesem Abschnitt erläutern wir die Vorgehensweise bei der Implementierung barrierefreier Plugins für Ihre Schnittstellen. Ein Plugin ist eine Klasse, die in einer gemeinsam genutzten Bibliothek gespeichert ist und zur Laufzeit geladen werden kann. Es ist praktisch, Schnittstellen als Plugins zu verteilen, da sie nur bei Bedarf geladen werden.

Das Erstellen eines barrierefreien Plugins erfolgt durch Vererbung von ` QAccessiblePlugin`, die Definition der unterstützten Klassennamen in der JSON-Beschreibung des Plugins und die Neuimplementierung von ` create()` aus ` QAccessiblePlugin`. Die Datei ` .pro ` muss angepasst werden, um die Plugin-Vorlage zu verwenden, und die Bibliothek, die das Plugin enthält, muss in einem Pfad abgelegt werden, in dem Qt nach barrierefreien Plugins sucht.

Wir werden die Implementierung von SliderPlugin durchgehen, einem barrierefreien Plugin, das die Schnittstelle `QAccessibleSlider` aus dem Beispiel `QAccessibleWidget` generiert. 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 barrierefreie Schnittstelle erstellen kann. Ein Plugin kann eine beliebige Anzahl von Klassen unterstützen; fügen Sie einfach weitere Klassennamen zur Zeichenfolgenliste hinzu. Wir fahren mit der Funktion ` create() ` fort:

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 “ bestimmt ist; ist dies der Fall, erstellen wir eine Schnittstelle dafür und geben sie zurück. Beachten Sie, dass „ object “ immer eine Instanz von „ classname “ ist. Sie müssen 0 zurückgeben, wenn Sie die Klasse nicht unterstützen. „ updateAccessibility()“ durchsucht die verfügbaren Barrierefreiheits-Plugins, bis es eines findet, das nicht 0 zurückgibt.

Abschließend müssen Sie Makros in die cpp-Datei einfügen:

    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 Metadateninformationen für das Plugin enthält. Weitere Informationen zu Plugins finden Sie im Dokument „Pl ugins-Übersicht“.

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 Barrierefreiheitsschnittstellen bereitstellen möchten, können Sie eine Schnittstellenfabrik (QAccessible::InterfaceFactory) verwenden. Dies ist die empfohlene Methode, um barrierefreie Schnittstellen in einer statisch verknüpften Anwendung bereitzustellen.

Eine Factory ist ein Funktionszeiger auf eine Funktion, die dieselben Parameter wie die Methode ` create()` von ` QAccessiblePlugin` akzeptiert – einen ` QString ` und einen ` QObject`. Sie funktioniert auch auf dieselbe Weise. Sie installieren die Factory mit der Funktion ` installFactory()`. Hier ein Beispiel für die Erstellung einer Factory für die Schnittstelle ` 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);
    ...
}

Verwandte Klassen