qaccessiblecache.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qaccessiblecache_p.h"
#include <QtCore/qdebug.h>
#include <QtCore/qloggingcategory.h>
#include <private/qguiapplication_p.h>
 
#if QT_CONFIG(accessibility)
 
QT_BEGIN_NAMESPACE
 
Q_STATIC_LOGGING_CATEGORY(lcAccessibilityCache, "qt.accessibility.cache");
 
/*!
    \class QAccessibleCache
    \internal
    \brief Maintains a cache of accessible interfaces.
*/
 
static QAccessibleCache *accessibleCache = nullptr;
static bool inCacheDestructor = false;
 
static void cleanupAccessibleCache()
{
    delete accessibleCache;
    accessibleCache = nullptr;
}
 
QAccessibleObjectDestroyedEvent::~QAccessibleObjectDestroyedEvent()
{
}
 
QAccessibleCache::~QAccessibleCache()
{
    inCacheDestructor = true;
 
    for (QAccessible::Id id: idToInterface.keys())
        deleteInterface(id);
}
 
QAccessibleCache *QAccessibleCache::instance()
{
    if (!accessibleCache) {
        accessibleCache = new QAccessibleCache;
        qAddPostRoutine(cleanupAccessibleCache);
    }
    return accessibleCache;
}
 
/*
  The ID is always in the range [INT_MAX+1, UINT_MAX].
  This makes it easy on windows to reserve the positive integer range
  for the index of a child and not clash with the unique ids.
*/
QAccessible::Id QAccessibleCache::acquireId() const
{
    static const QAccessible::Id FirstId = QAccessible::Id(INT_MAX) + 1;
    static QAccessible::Id nextId = FirstId;
 
    while (idToInterface.contains(nextId)) {
        // (wrap back when when we reach UINT_MAX - 1)
        // -1 because on Android -1 is taken for the "View" so just avoid it completely for consistency
        if (nextId == UINT_MAX - 1)
            nextId = FirstId;
        else
            ++nextId;
    }
 
    return nextId++;
}
 
QAccessibleInterface *QAccessibleCache::interfaceForId(QAccessible::Id id) const
{
    return idToInterface.value(id);
}
 
QAccessible::Id QAccessibleCache::idForInterface(QAccessibleInterface *iface) const
{
    return interfaceToId.value(iface);
}
 
QAccessible::Id QAccessibleCache::idForObject(QObject *obj) const
{
    if (obj) {
        const QMetaObject *mo = obj->metaObject();
        for (auto pair : objectToId.values(obj)) {
            if (pair.second == mo) {
                return pair.first;
            }
        }
    }
    return 0;
}
 
/*!
 * \internal
 *
 * returns true if the cache has an interface for the object and its corresponding QMetaObject
 */
bool QAccessibleCache::containsObject(QObject *obj) const
{
    if (obj) {
        const QMetaObject *mo = obj->metaObject();
        for (auto pair : objectToId.values(obj)) {
            if (pair.second == mo) {
                return true;
            }
        }
    }
    return false;
}
 
QAccessible::Id QAccessibleCache::insert(QObject *object, QAccessibleInterface *iface) const
{
    Q_ASSERT(iface);
    Q_UNUSED(object);
 
    // object might be 0
    Q_ASSERT(!containsObject(object));
    Q_ASSERT_X(!interfaceToId.contains(iface), "", "Accessible interface inserted into cache twice!");
 
    QAccessible::Id id = acquireId();
    QObject *obj = iface->object();
    Q_ASSERT(object == obj);
    if (obj) {
        objectToId.insert(obj, std::pair(id, obj->metaObject()));
        connect(obj, &QObject::destroyed, this, &QAccessibleCache::objectDestroyed);
    }
    idToInterface.insert(id, iface);
    interfaceToId.insert(iface, id);
    qCDebug(lcAccessibilityCache) << "insert - id:" << id << " iface:" << iface;
    return id;
}
 
void QAccessibleCache::objectDestroyed(QObject* obj)
{
    /*
    In some cases we might add a not fully-constructed object to the cache. This might happen with
    for instance QWidget subclasses that are in the construction phase. If updateAccessibility() is
    called in the constructor of QWidget (directly or indirectly), it will end up asking for the
    classname of that widget in order to know which accessibility interface subclass the
    accessibility factory should instantiate and return. However, since that requires a virtual
    call to metaObject(), it will return the metaObject() of QWidget (not for the subclass), and so
    the factory will ultimately return a rather generic QAccessibleWidget instead of a more
    specialized interface. Even though it is a "incomplete" interface it will be put in the cache
    and it will be usable as if the object is a widget. In order for the cache to not just return
    the same generic QAccessibleWidget for that object, we have to check if the cache matches
    the objects QMetaObject. We therefore use a QMultiHash and also store the QMetaObject * in
    the value. We therefore might potentially store several values for the corresponding object
    (in theory one for each level in the class inheritance chain)
 
    This means that after the object have been fully constructed, we will at some point again query
    for the interface for the same object, but now its metaObject() returns the correct
    QMetaObject, so it won't return the QAccessibleWidget that is associated with the object in the
    cache. Instead it will go to the factory and create the _correct_ specialized interface for the
    object. If that succeeded, it will also put that entry in the cache. We will therefore in those
    cases insert *two* cache entries for the same object (using QMultiHash). They both must live
    until the object is destroyed.
 
    So when the object is destroyed we might have to delete two entries from the cache.
    */
    for (auto pair : objectToId.values(obj)) {
        QAccessible::Id id = pair.first;
        Q_ASSERT_X(idToInterface.contains(id), "", "QObject with accessible interface deleted, where interface not in cache!");
        deleteInterface(id, obj);
    }
}
 
void QAccessibleCache::sendObjectDestroyedEvent(QObject *obj)
{
    for (auto pair : objectToId.values(obj)) {
        QAccessible::Id id = pair.first;
        Q_ASSERT_X(idToInterface.contains(id), "", "QObject with accessible interface deleted, where interface not in cache!");
 
        QAccessibleObjectDestroyedEvent event(id);
        QAccessible::updateAccessibility(&event);
    }
}
 
void QAccessibleCache::deleteInterface(QAccessible::Id id, QObject *obj)
{
    const auto it = idToInterface.find(id);
    if (it == idToInterface.end()) // the interface may be deleted already
        return;
 
    QAccessibleInterface *iface = *it;
    qCDebug(lcAccessibilityCache) << "delete - id:" << id << " iface:" << iface;
    if (!iface) {
        idToInterface.erase(it);
        return;
    }
 
    // QObjects send this from their destructors, but the interfaces
    // with no associated object call deleteInterface directly.
    if (!inCacheDestructor && !obj && !iface->object()) {
        if (QGuiApplicationPrivate::is_app_running && !QGuiApplicationPrivate::is_app_closing && QAccessible::isActive()) {
            QAccessibleObjectDestroyedEvent event(id);
            QAccessible::updateAccessibility(&event);
        }
    }
 
    idToInterface.erase(it);
    interfaceToId.take(iface);
    if (!obj)
        obj = iface->object();
    if (obj)
        objectToId.remove(obj);
    delete iface;
 
#ifdef Q_OS_APPLE
    removeAccessibleElement(id);
#endif
}
 
QT_END_NAMESPACE
 
#include "moc_qaccessiblecache_p.cpp"
 
#endif