Revision control
++ // 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