qaccessiblebridgeutils.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 "qaccessiblebridgeutils_p.h"
#include <QtCore/qmath.h>
#include <QtGui/qwindow.h>
 
QT_BEGIN_NAMESPACE
 
namespace QAccessibleBridgeUtils {
 
static bool performAction(QAccessibleInterface *iface, const QString &actionName)
{
    if (QAccessibleActionInterface *actionIface = iface->actionInterface()) {
        if (actionIface->actionNames().contains(actionName)) {
            actionIface->doAction(actionName);
            return true;
        }
    }
    return false;
}
 
QStringList effectiveActionNames(QAccessibleInterface *iface)
{
    QStringList actions;
    if (QAccessibleActionInterface *actionIface = iface->actionInterface())
        actions = actionIface->actionNames();
 
    if (iface->valueInterface()) {
        if (!actions.contains(QAccessibleActionInterface::increaseAction()))
            actions << QAccessibleActionInterface::increaseAction();
        if (!actions.contains(QAccessibleActionInterface::decreaseAction()))
            actions << QAccessibleActionInterface::decreaseAction();
    }
    return actions;
}
 
bool performEffectiveAction(QAccessibleInterface *iface, const QString &actionName)
{
    if (!iface)
        return false;
    if (performAction(iface, actionName))
        return true;
    if (actionName != QAccessibleActionInterface::increaseAction()
        && actionName != QAccessibleActionInterface::decreaseAction())
        return false;
 
    QAccessibleValueInterface *valueIface = iface->valueInterface();
    if (!valueIface)
        return false;
    bool success;
    const QVariant currentVariant = valueIface->currentValue();
    double stepSize = valueIface->minimumStepSize().toDouble(&success);
    if (!success || qFuzzyIsNull(stepSize)) {
        const double min = valueIface->minimumValue().toDouble(&success);
        if (!success)
            return false;
        const double max = valueIface->maximumValue().toDouble(&success);
        if (!success)
            return false;
        stepSize = (max - min) / 10;  // this is pretty arbitrary, we just need to provide something
        const int typ = currentVariant.userType();
        if (typ != QMetaType::Float && typ != QMetaType::Double) {
            // currentValue is an integer. Round it up to ensure stepping in case it was below 1
            stepSize = qCeil(stepSize);
        }
    }
    const double current = currentVariant.toDouble(&success);
    if (!success)
        return false;
    if (actionName == QAccessibleActionInterface::decreaseAction())
        stepSize = -stepSize;
    valueIface->setCurrentValue(current + stepSize);
    return true;
}
 
QString accessibleId(QAccessibleInterface *accessible) {
    QString result;
    if (!accessible)
        return result;
    result = accessible->text(QAccessible::Identifier);
    if (!result.isEmpty())
        return result;
    while (accessible) {
        if (!result.isEmpty())
            result.prepend(u'.');
        if (auto obj = accessible->object()) {
            const QString name = obj->objectName();
            if (!name.isEmpty())
                result.prepend(name);
            else
                result.prepend(QString::fromUtf8(obj->metaObject()->className()));
        }
        accessible = accessible->parent();
    }
    return result;
}
 
/*
    Returns the window whose native handle is responsible for \a iface.
 
    Not every interface implements window(), so we walk up the ancestors until
    one does, as the documentation asks of the backend. The first ancestor to
    answer gives the closest window, since a window's root interface sits on this
    chain and reports its own window.
 
    A caller that already knows the window of an ancestor passes the ancestor as
    \a ancestorInterface and its window as \a ancestorWindow. The walk then stops
    at that ancestor and answers with \a ancestorWindow. The full walk ends up at
    the same window, so the two arguments only skip the part the caller has
    already walked.
 
    The two arguments also let us reject an answer that can not be true. An
    interface below \a ancestorInterface can not live in a window that contains
    \a ancestorWindow. A bridge that substituted the native view of such a window
    would hand back a view that contains \a ancestorWindow's own view, and the
    native accessibility tree would loop. An interface that answers window() with
    the top level instead of the window containing it gives such an answer, so we
    discard it and keep walking.
 
    We do however accept a window that is not a descendant of \a ancestorWindow. A
    QWindowContainer inside a child QWindow hands its contained window to the top
    level, and the two windows are then siblings. Move the container further down
    the QWindow hierarchy and \a ancestorWindow becomes a descendant of a sibling
    of the window we return.
 
    Callers that have specific demands on the accepted window hierarchy beyond
    the loop detection must handle those cases at the call site.
*/
QWindow *windowFor(const QAccessibleInterface *iface,
                   const QAccessibleInterface *ancestorInterface,
                   QWindow *ancestorWindow)
{
    Q_ASSERT(bool(ancestorInterface) == bool(ancestorWindow));
 
    for (const auto *candidate = iface; candidate && candidate != ancestorInterface;
         candidate = candidate->parent()) {
        QWindow *window = candidate->window();
        if (!window)
            continue;
 
        // We found a window before reaching ancestorInterface. It can only
        // represent the interface if it does not contain ancestorWindow,
        // as otherwise the native accessibility tree would loop.
        if (ancestorWindow && window->isAncestorOf(ancestorWindow, QWindow::ExcludeTransients))
            continue;
 
        return window;
    }
 
    return ancestorWindow;
}
 
}   //namespace
 
QT_END_NAMESPACE