Редактирование: Qt:Документация 4.3.2/accessible

{{Qt4.3.2_header}}

=Accessibility<br />=
==Introduction==
Accessibility in computer software is making applications usable for people with disabilities. This could be achieved by providing keyboard shortcuts, a high-contrast user interface that uses specially selected colors and fonts, or support for assistive tools such as screen readers and braille displays.

An application does not usually communicate directly with assistive tools but through an assistive technology, which is a bridge for exchange of information between the applications and the tools. Information about user interface elements, such as buttons and scroll bars, is exposed to the assistive technologies. Qt currently supports three technologies: Microsoft Active Accessibility (MSAA), Mac OS X Accessibility, and Unix/X11 AT-SPI. On Unix/X11, support is preliminary. The individual technologies are abstracted from Qt, and there is only a single interface to consider. We will use MSAA throughout this document when we need to address technology related issues.

In this overview document, we will examine the overall Qt accessibility architecture, and how to implement accessibility for custom widgets and elements.

==Architecture==
Providing accessibility is a collaboration between accessibility compliant applications, the assistive technology, and the assistive tools.

[[Image:accessibilityarchitecture.png|center]]

Accessibility compliant applications are called AT-Servers while assistive tools are called AT-Clients. A Qt application will typically be an AT-Server, but specialized programs might also function like AT-Clients. We will refer to clients and servers when talking about AT-Clients and AT-Servers in the rest of this document.

We will from now on focus on the Qt accessibility interface and how it is implemented to create Qt applications that support accessibility.

===Accessibility in Qt===
When we communicate with the assistive technologies, we need to describe Qt's user interface in a way that they can understand. Qt applications use [[Qt:Документация 4.3.2/qaccessibleinterface | QAccessibleInterface]] to expose information about the individual UI elements. Currently, Qt provides support for its widgets and widget parts, e.g&#x2e;, slider handles, but the interface could also be implemented for any [[Qt:Документация 4.3.2/qobject | QObject]] if necessary. [[Qt:Документация 4.3.2/qaccessible | QAccessible]] contains enums that describe the UI. The description is mainly based on MSAA and is independent of Qt. We will examine the enums in the course of this document.

The structure of the UI is represented as a tree of [[Qt:Документация 4.3.2/qaccessibleinterface | QAccessibleInterface]] subclasses. You can think of this as a representation of a UI like the [[Qt:Документация 4.3.2/qobject | QObject]] tree built by Qt. Objects can be widgets or widget parts (such as scroll bar handles). We examine the tree in detail in the next section.

Servers notify clients through [[Qt:Документация 4.3.2/qaccessible#updateAccessibility | updateAccessibility()]] about changes in objects by sending events, and the clients register to receive the events. The available events are defined by the [[Qt:Документация 4.3.2/qaccessible#Event-enum | QAccessible::Event]] enum. The clients may then query for the object that generated the event through [[Qt:Документация 4.3.2/qaccessible#queryAccessibleInterface | QAccessible::queryAccessibleInterface]]().

Three of the enums in [[Qt:Документация 4.3.2/qaccessible | QAccessible]] help clients query and alter accessible objects:

*[[Qt:Документация 4.3.2/qaccessible#Role-enum | Role]]: Describes the role the object fills in the user interface, e.g&#x2e;, if it is a main window, a text caret, or a cell in an item view.
*[[Qt:Документация 4.3.2/qaccessible#Action-enum | Action]]: The actions that the clients can perform on the objects, e.g&#x2e;, pushing a button.
*[[Qt:Документация 4.3.2/qaccessible#RelationFlag-enum | Relation]]: Describes the relationship between objects in the object tree. This is used for navigation.

The clients also have some possibilities to get the content of objects, e.g&#x2e;, a button's text; the object provides strings defined by the [[Qt:Документация 4.3.2/qaccessible#Text-enum | QAccessible::Text]] enum, that give information about content.

The objects can be in a number of different states as defined by the [[Qt:Документация 4.3.2/qaccessible#StateFlag-enum | State]] enum. Examples of states are whether the object is disabled, if it has focus, or if it provides a popup menu.

===The Accessible Object Tree===
As mentioned, a tree structure is built from the accessible objects of an application. By navigating through the tree, the clients can access all elements in the UI. Object relations give clients information about the UI. For instance, a slider handle is a child of the slider to which it belongs. [[Qt:Документация 4.3.2/qaccessible#RelationFlag-enum | QAccessible::Relation]] describes the various relationships the clients can ask objects for.

Note that there are no direct mapping between the Qt [[Qt:Документация 4.3.2/qobject | QObject]] tree and the accessible object tree. For instance, scroll bar handles are accessible objects but are not widgets or objects in Qt.

AT-Clients have access to the accessibility object tree through the root object in the tree, which is the [[Qt:Документация 4.3.2/qapplication | QApplication]]. They can query other objects through QAccessible::navigate(), which fetches objects based on [[Qt:Документация 4.3.2/qaccessible#RelationFlag-enum | Relation]]s. The children of any node is 1-based numbered. The child numbered 0 is the object itself. The children of all interfaces are numbered this way, i.e&#x2e;, it is not a fixed numbering from the root node in the entire tree.

Qt provides accessible interfaces for its widgets. Interfaces for any [[Qt:Документация 4.3.2/qobject | QObject]] subclass can be requested through QAccessible::queryInterface(). A default implementation is provided if a more specialized interface is not defined. An AT-Client cannot acquire an interface for accessible objects that do not have an equivalent [[Qt:Документация 4.3.2/qobject | QObject]], e.g&#x2e;, scroll bar handles, but they appear as normal objects through interfaces of parent accessible objects, e.g&#x2e;, you can query their relationships with QAccessible::relationTo().

To illustrate, we present an image of an accessible object tree. Beneath the tree is a table with examples of object relationships.

[[Image:accessibleobjecttree.png|center]]

The labels in top-down order are: the [[Qt:Документация 4.3.2/qaccessibleinterface | QAccessibleInterface]] class name, the widget for which an interface is provided, and the [[Qt:Документация 4.3.2/qaccessible#Role-enum | Role]] of the object. The Position, PageLeft, and PageRight are the slider handle, the sldier groove left and right of the handle; these accessible objects do not have an equivalent [[Qt:Документация 4.3.2/qobject | QObject]].


{|  width="40%" align="center" cellpadding="2" cellspacing="1" border="0"
|- valign="top" class="qt-style" | 
!Source Object
!Target Object
!Relation
|- valign="top" class="odd" | 
|Slider
|Indicator
|Controller
|- valign="top" class="even" | 
|Indicator
|Slider
|Controlled
|- valign="top" class="odd" | 
|Slider
|Application
|Ancestor
|- valign="top" class="even" | 
|Application
|Slider
|Child
|- valign="top" class="odd" | 
|PushButton
|Indicator
|Sibling
|}

===The Static QAccessible Functions===
The accessibility is managed by [[Qt:Документация 4.3.2/qaccessible | QAccessible]]'s static functions, which we will examine shortly. They produce [[Qt:Документация 4.3.2/qaccessible | QAccessible]] interfaces, build the object tree, and initiate the connection with MSAA or the other platform specific technologies. If you are only interested in learning how to make your application accessible, you can safely skip over this section to [[#implementing-accessibility | Implementing Accessibility]].

The communication between clients and the server is initiated when [[Qt:Документация 4.3.2/qaccessible#setRootObject | setRootObject()]] is called. This is done when the [[Qt:Документация 4.3.2/qapplication | QApplication]] instance is instantiated and you should not have to do this yourself.

When a [[Qt:Документация 4.3.2/qobject | QObject]] calls [[Qt:Документация 4.3.2/qaccessible#updateAccessibility | updateAccessibility()]], clients that are listening to events are notified of the change. The function is used to post events to the assistive technology, and accessible [[Qt:Документация 4.3.2/qaccessible#Event-enum | events]] are posted by [[Qt:Документация 4.3.2/qaccessible#updateAccessibility | updateAccessibility()]].

[[Qt:Документация 4.3.2/qaccessible#queryAccessibleInterface | queryAccessibleInterface()]] returns accessible interfaces for [[Qt:Документация 4.3.2/qobject | QObject]]s. All widgets in Qt provide interfaces; if you need interfaces to control the behavior of other [[Qt:Документация 4.3.2/qobject | QObject]] subclasses, you must implement the interfaces yourself, although the [[Qt:Документация 4.3.2/qaccessibleobject | QAccessibleObject]] convenience class implements parts of the functionality for you.

The factory that produces accessibility interfaces for QObjects is a function of type [[Qt:Документация 4.3.2/qaccessible#InterfaceFactory-typedef | QAccessible::InterfaceFactory]]. It is possible to have several factories installed. The last factory installed will be the first to be asked for interfaces. [[Qt:Документация 4.3.2/qaccessible#queryAccessibleInterface | queryAccessibleInterface()]] uses the factories to create interfaces for [[Qt:Документация 4.3.2/qobject | QObject]]s. Normally, you need not be concerned about factories because you can implement plugins that produce interfaces. We will give examples of both approaches later.

==Implementing Accessibility==
To provide accessibility support for a widget or other user interface element, you need to implement the [[Qt:Документация 4.3.2/qaccessibleinterface | QAccessibleInterface]] and distribute it in a [[Qt:Документация 4.3.2/qaccessibleplugin | QAccessiblePlugin]]. It is also possible to compile the interface into the application and provide a [[Qt:Документация 4.3.2/qaccessible#InterfaceFactory-typedef | QAccessible::InterfaceFactory]] for it. The factory can be used if you link statically or do not want the added complexity of plugins. This can be an advantage if you, for instance, are delivering a 3-rd party library.

All widgets and other user interface elements should have interfaces and plugins. If you want your application to support accessibility, you will need to consider the following:

*Qt already supports accessibility for its own widgets. A good way to ensure accessibility compliance is to use Qt's widgets as much as possible.
*You need to send accessibility events from the custom user interface elements that you implement, which are usually custom widgets.
*[[Qt:Документация 4.3.2/qaccessibleinterface | QAccessibleInterface]] needs to be implemented for widgets that you want to make available to accessibility clients.

In general, it is recommended that you are somewhat familiar with MSAA, which Qt originally was built for. You should also study the enum values of [[Qt:Документация 4.3.2/qaccessible | QAccessible]], which describe the roles, actions, relationships, and events that you need to consider.

Note that you can examine how Qt's widgets implement their accessibility. One major problem with the MSAA standard is that interfaces are often implemented in an inconsistent way. This makes life difficult for clients and often leads to guesswork on object functionality.

It is possible to implement interfaces by inheriting [[Qt:Документация 4.3.2/qaccessibleinterface | QAccessibleInterface]] and implementing its pure virtual functions. In practice, however, it is usually preferable to inherit [[Qt:Документация 4.3.2/qaccessibleobject | QAccessibleObject]] or [[Qt:Документация 4.3.2/qaccessiblewidget | QAccessibleWidget]], which implement part of the functionality for you. In the next section, we will see an example of implementing accessibility for a widget by inheriting the [[Qt:Документация 4.3.2/qaccessiblewidget | QAccessibleWidget]] class.

===The QAccessibleObject and QAccessibleWidget Convenience Classes===
When implementing an accessibility interface for widgets, one would as a rule inherit [[Qt:Документация 4.3.2/qaccessiblewidget | QAccessibleWidget]], which is a convenience class for widgets. Another available convenience class, which is inherited by [[Qt:Документация 4.3.2/qaccessiblewidget | QAccessibleWidget]], is the [[Qt:Документация 4.3.2/qaccessibleobject | QAccessibleObject]], which implements part of the interface for QObjects.

The [[Qt:Документация 4.3.2/qaccessiblewidget | QAccessibleWidget]] provides the following functionality:

*It handles the navigation of the tree and hit testing of the objects.
*It handles events, roles, and actions that are common for all [[Qt:Документация 4.3.2/qwidget | QWidget]]s.
*It handles action and methods that can be performed on all widgets.
*It calculates bounding rectangles with [[Qt:Документация 4.3.2/qaccessibleinterface#rect | rect()]].
*It gives [[Qt:Документация 4.3.2/qaccessibleinterface#text | text()]] strings that are appropriate for a generic widget.
*It sets the [[Qt:Документация 4.3.2/qaccessible#StateFlag-enum | states]] that are common for all widgets.

===QAccessibleWidget Example===
Instead of creating a custom widget and implementing an interface for it, we will show how accessibility can be implemented for one of Qt's standard widgets: [[Qt:Документация 4.3.2/qslider | QSlider]]. Making this widget accessible demonstrates many of the issues that need to be faced when making a custom widget accessible.

The slider is a complex control that functions as a [[Qt:Документация 4.3.2/qaccessible#RelationFlag-enum | Controller]] for its accessible children. This relationship must be known by the interface (for [[Qt:Документация 4.3.2/qaccessibleinterface#relationTo | relationTo()]] and [[Qt:Документация 4.3.2/qaccessibleinterface#navigate | navigate()]]). This can be done using a controlling signal, which is a mechanism provided by [[Qt:Документация 4.3.2/qaccessiblewidget | QAccessibleWidget]]. We do this in the constructor:
<source lang="cpp-qt"> AccessibleSlider::QAccessibleSlider(QWidget *w)
 : QAccessibleAbstractSlider(w)
 {
     Q_ASSERT(slider());
     addControllingSignal(QLatin1String("valueChanged(int)"));
 }</source> 
The choice of signal shown is not important; the same principles apply to all signals that are declared in this way. Note that we use [[Qt:Документация 4.3.2/qlatin1string | QLatin1String]] to ensure that the signal name is correctly specified.

When an accessible object is changed in a way that users need to know about, it notifies clients of the change by sending them an event via the accessible interface. This is how [[Qt:Документация 4.3.2/qslider | QSlider]] calls [[Qt:Документация 4.3.2/qaccessible#updateAccessibility | updateAccessibility()]] to indicate that its value has changed:
<source lang="cpp-qt"> void QAbstractSlider::setValue(int value)
     ...
     QAccessible::updateAccessibility(this, 0, QAccessible::ValueChanged);
     ...
 }</source> 
Note that the call is made after the value of the slider has changed because clients may query the new value immediately after receiving the event.

The interface must be able to calculate bounding rectangles of itself and any children that do not provide an interface of their own. The <tt>QAccessibleSlider</tt> has three such children identified by the private enum, <tt>SliderElements</tt>, which has the following values: <tt>PageLeft</tt> (the rectangle on the left hand side of the slider handle), <tt>PageRight</tt> (the rectangle on the right hand side of the handle), and <tt>Position</tt> (the slider handle). Here is the implementation of [[Qt:Документация 4.3.2/qaccessibleinterface#rect | rect()]]:
<source lang="cpp-qt"> 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);
     }
     ...</source> 
The first part of the function, which we have omitted, uses the current [[Qt:Документация 4.3.2/qstyle | style]] to calculate the slider handle's bounding rectangle; it is stored in <tt>srect</tt>. Notice that child 0, covered in the default case in the above code, is the slider itself, so we can simply return the [[Qt:Документация 4.3.2/qslider | QSlider]] bounding rectangle obtained from the superclass, which is effectively the value obtained from [[Qt:Документация 4.3.2/qaccessibleinterface#rect | QAccessibleWidget::rect]]().
<source lang="cpp-qt">     QPoint tp = slider()->mapToGlobal(QPoint(0,0));
     return QRect(tp.x() + rect.x(), tp.y() + rect.y(), rect.width(), rect.height());
 }</source> 
Before the rectangle is returned it must be mapped to screen coordinates.

The QAccessibleSlider must reimplement [[Qt:Документация 4.3.2/qaccessibleinterface#childCount | QAccessibleInterface::childCount]]() since it manages children without interfaces.

The [[Qt:Документация 4.3.2/qaccessibleinterface#text | text()]] function returns the [[Qt:Документация 4.3.2/qaccessible#Text-enum | QAccessible::Text]] strings for the slider:
<source lang="cpp-qt"> 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);
 }</source> 
The <tt>slider()</tt> function returns a pointer to the interface's [[Qt:Документация 4.3.2/qslider | QSlider]]. Some values are left for the superclass's implementation. Not all values are appropriate for all accessible objects, as you can see for [[Qt:Документация 4.3.2/qaccessible#Text-enum | QAccessible::Value]] case. You should just return an empty string for those values where no relevant text can be provided.

The implementation of the [[Qt:Документация 4.3.2/qaccessibleinterface#role | role()]] function is straightforward:
<source lang="cpp-qt"> QAccessible::Role QAccessibleSlider::role(int child) const
 {
     switch (child) {
     case PageLeft:
     case PageRight:
         return PushButton;
     case Position:
         return Indicator;
     default:
         return Slider;
     }
 }</source> 
The role function should be reimplemented by all objects and describes the role of themselves and the children that do not provide accessible interfaces of their own.

Next, the accessible interface needs to return the [[Qt:Документация 4.3.2/qaccessible#StateFlag-enum | states]] that the slider can be in. We look at parts of the <tt>state()</tt> implementation to show how just a few of the states are handled:
<source lang="cpp-qt"> 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;
 }</source> 
The superclass implementation of [[Qt:Документация 4.3.2/qaccessibleinterface#state | state()]], uses the [[Qt:Документация 4.3.2/qaccessibleinterface#state | QAccessibleInterface::state]]() implementation. We simply need to disable the buttons if the slider is at its minimum or maximum.

We have now exposed the information we have about the slider to the clients. For the clients to be able to alter the slider - for example, to change its value - we must provide information about the actions that can be performed and perform them upon request. We discuss this in the next section.

===Handling Action Requests from Clients===
[[Qt:Документация 4.3.2/qaccessible | QAccessible]] provides a number of [[Qt:Документация 4.3.2/qaccessible#Action-enum | Action]]s that can be performed on request from clients. If an accessible object supports actions, it should reimplement the following functions from [[Qt:Документация 4.3.2/qaccessibleinterface | QAccessibleInterface]]:

*[[Qt:Документация 4.3.2/qaccessibleinterface#actionText | actionText()]] returns strings that describe each action. The descriptions to be made available are one for each [[Qt:Документация 4.3.2/qaccessible#Text-enum | Text]] enum value.
*[[Qt:Документация 4.3.2/qaccessibleinterface#doAction | doAction()]] executes requests from clients to perform actions.

Note that a client can request any action from an object. If the object does not support the action, it returns false from [[Qt:Документация 4.3.2/qaccessibleinterface#doAction | doAction()]].

None of the standard actions take any parameters. It is possible to provide user-defined actions that can take parameters. The interface must then also reimplement [[Qt:Документация 4.3.2/qaccessibleinterface#userActionCount | userActionCount()]]. Since this is not defined in the MSAA specification, it is probably only useful to use this if you know which specific AT-Clients will use the application.

[[Qt:Документация 4.3.2/qaccessibleinterface | QAccessibleInterface]] gives another technique for clients to handle accessible objects. It works basically the same way, but uses the concept of methods in place of actions. The available methods are defined by the [[Qt:Документация 4.3.2/qaccessible#Method-enum | QAccessible::Method]] enum. The following functions need to be reimplemented from [[Qt:Документация 4.3.2/qaccessibleinterface | QAccessibleInterface]] if the accessible object is to support methods:

*[[Qt:Документация 4.3.2/qaccessibleinterface#supportedMethods | supportedMethods()]] returns a [[Qt:Документация 4.3.2/qset | QSet]] of [[Qt:Документация 4.3.2/qaccessible#Method-enum | Method]] values that are supported by the object.
*[[Qt:Документация 4.3.2/qaccessibleinterface#invokeMethod | invokeMethod()]] executes methods requested by clients.

The action mechanism will probably be substituted by providing methods in place of the standard actions.

To see examples on how to implement actions and methods, you could examine the [[Qt:Документация 4.3.2/qaccessibleobject | QAccessibleObject]] and [[Qt:Документация 4.3.2/qaccessiblewidget | QAccessibleWidget]] implementations. You might also want to take a look at the MSAA documentation.

===Implementing Accessible Plugins===
In this section we will explain the procedure of implementing accessible plugins for your interfaces. A plugin is a class stored in a shared library that can be loaded at run-time. It is convenient to distribute interfaces as plugins since they will only be loaded when required.

Creating an accessible plugin is achieved by inheriting [[Qt:Документация 4.3.2/qaccessibleplugin | QAccessiblePlugin]], reimplementing [[Qt:Документация 4.3.2/qaccessibleplugin#keys | keys()]] and [[Qt:Документация 4.3.2/qaccessibleplugin#create | create()]] from that class, and adding one or two macros. The <tt>.pro</tt> file must be altered to use the plugin template, and the library containing the plugin must be placed on a path where Qt searches for accessible plugins.

We will go through the implementation of <tt>SliderPlugin</tt>, which is an accessible plugin that produces interfaces for the QAccessibleSlider we implemented in the [[#qaccessiblewidget-example | QAccessibleWidget Example]]. We start with the <tt>key()</tt> function:
<source lang="cpp-qt"> QStringList SliderPlugin::keys() const
 {
     return QStringList() << "QSlider";
 }</source> 
We simply need to return the class name of the single interface our plugin can create an accessible interface for. A plugin can support any number of classes; just add more class names to the string list. We move on to the <tt>create()</tt> function:
<source lang="cpp-qt"> QAccessibleInterface *SliderPlugin::create(const QString &amp;classname, QObject *object)
 {
     QAccessibleInterface *interface = 0;

     if (classname == "QSlider" &amp;&amp; object &amp;&amp; object->isWidgetType())
         interface = new AccessibleSlider(classname, static_cast<QWidget *>(object));

     return interface;
 }</source> 
We check whether the interface requested is for the [[Qt:Документация 4.3.2/qslider | QSlider]]; if it is, we create and return an interface for it. Note that <tt>object</tt> will always be an instance of <tt>classname</tt>. You must return 0 if you do not support the class. [[Qt:Документация 4.3.2/qaccessible#updateAccessibility | updateAccessibility()]] checks with the available accessibility plugins until it finds one that does not return 0.

Finally, you need to include macros in the cpp file:
<source lang="cpp-qt"> Q_EXPORT_STATIC_PLUGIN(SliderPlugin)
 Q_EXPORT_PLUGIN2(acc_sliderplugin, SliderPlugin)</source> 
The [[Qt:Документация 4.3.2/qtplugin#Q_EXPORT_PLUGIN2#q-export-plugin2 | Q_EXPORT_PLUGIN2]] macro exports the plugin in the <tt>SliderPlugin</tt> class into the <tt>acc_sliderplugin</tt> library. The first argument is the name of the plugin library file, excluding the file suffix, and the second is the class name. For more information on plugins, consult the plugins [[Qt:Документация 4.3.2/plugins-howto | overview document]].

You can omit the the first macro unless you want the plugin to be statically linked with the application.

===Implementing Interface Factories===
If you do not want to provide plugins for your accessibility interfaces, you can use an interface factory ([[Qt:Документация 4.3.2/qaccessible#InterfaceFactory-typedef | QAccessible::InterfaceFactory]]), which is the recommended way to provide accessible interfaces in a statically-linked application.

A factory is a function pointer for a function that takes the same parameters as [[Qt:Документация 4.3.2/qaccessibleplugin | QAccessiblePlugin]]'s [[Qt:Документация 4.3.2/qaccessibleplugin#create | create()]] - a [[Qt:Документация 4.3.2/qstring | QString]] and a [[Qt:Документация 4.3.2/qobject | QObject]]. It also works the same way. You install the factory with the [[Qt:Документация 4.3.2/qaccessible#installFactory | installFactory()]] function. We give an example of how to create a factory for the <tt>SliderPlugin</tt> class:
<source lang="cpp-qt"> QAccessibleInterface *sliderFactory(const QString &amp;classname, QObject *object)
 {
     QAccessibleInterface *interface = 0;

     if (classname == "QSlider" &amp;&amp; object &amp;&amp; object->isWidgetType())
         interface = new SliderInterface(classname,
                                         static_cast<QWidget *>(object));

     return interface;
 }

 int main(int argv, char **args)
 {
     QApplication app(argv, args);
     QAccessible::installFactory(sliderFactory);
     ...
 }</source> 

{{Qt4.3.2_footer}}