Qt Reference Documentation

[Previous: The New Qt Designer] [Next: The Qt 4 Database GUI Layer]

# Cross-Platform Accessibility Support in Qt 4

Qt 4 allows developers to write cross-platform applications that are usable by visually impaired users as well as by users with other disabilities. Qt accessibility will make applications accessible to more users and opens the governmental market, where accessibility is often a requirement.

## General Overview

The accessibility classes have been extended in various ways since Qt 3. We added new functions and new enum values, and revised the API to make it more consistent with the rest of Qt. We also added two properties to QWidget, accessibleName and accessibleDescription, that can be set in Qt Designer to provide basic help texts without having to write any code.

Qt's accessibility architecture is as follows. Qt offers one generic interface, QAccessibleInterface, that can be used to wrap all widgets and objects (e.g., QPushButton). This single interface provides all the metadata necessary for the assistive technologies. Qt provides implementations of this interface for its built-in widgets as plugins.

A more detailed overview of the accessibility support in Qt can be found on the Accessibility page.

## Enabling Accessibility Support

By default, Qt applications are run with accessibility support enabled on Windows and Mac OS X. On Unix/X11 platforms, applications must be launched in an environment with the `QT_ACCESSIBILITY` variable set to 1. For example, this is set in the following way with the bash shell:

     export QT_ACCESSIBILITY=1

Accessibility features are built into Qt by default when the libraries are configured and built.

## Creating New Accessible Interfaces

When you develop custom widgets, you can create custom subclasses of QAccessibleInterface and distribute them as plugins (using QAccessiblePlugin) or compile them into the application. Likewise, Qt's predefined accessibility support can be built as plugin (the default) or directly into the Qt library. The main advantage of using plugins is that the accessibility classes are only loaded into memory if they are actually used; they don't slow down the common case where no assistive technology is being used.

In addition to QAccessibleInterface, Qt includes two convenience classes, QAccessibleObject and QAccessibleWidget, that provide the lowest common denominator of metadata (e.g., widget geometry, window title, basic help text). You can use them as base classes when wrapping your custom QObject or QWidget subclasses.

Another new feature in Qt 4 is that Qt can now support other backends in addition to the predefined ones. This is done by subclassing QAccessibleBridge.

## Example Code

The first example illustrates how to provide accessibility information for a custom widget. We can use QAccessibleWidget as a base class and reimplement various functions:

     class MyWidgetInterface : public QAccessibleWidget
     {
     public:
         MyWidgetInterface(QWidget *widget, Role role);

         QString text(Text text, int child) const;
         State state(int child) const;
         QString actionText(int action, Text text, int child) const;
         bool doAction(int action, int child, const QVariantList &params);
         ...
     };

Here's how we would implement the doAction() function to call a function named click() on the wrapped MyWidget object when the user invokes the object's default action or "presses" it.

     bool MyWidgetInterface::doAction(int action, int child,
                                      const QVariantList &params)
     {
         if (child || !widget()->isEnabled())
             return false;

         switch (action) {
         case DefaultAction:
         case Press:
             {
                 MyWidget *widget = qobject_cast<MyWidget *>(object());
                 if (widget)
                     widget->click();
             }
             return true;
         }
         return QAccessibleWidget::doAction(action, child, params);
     }

To export the widget interface as a plugin, we must subclass QAccessibleFactory:

     QStringList MyFactory::keys() const
     {
         return QStringList() << "MyWidget" << "MyOtherWidget";
     }

     QAccessibleInterface *MyFactory::create(const QString &className,
                                             QObject *object)
     {
         if (classname == "MyWidget")
             return new MyWidgetInterface(object);
         if (classname == "MyOtherWidget")
             return new MyOtherWidgetInterface(object);
         return 0;
     }

     Q_EXPORT_PLUGIN2(myfactory, MyFactory)