AccessibilityTools.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#pragma once
 
#include <test/testdllapi.hxx>
 
#include <functional>
#include <string>
 
#include <cppunit/TestAssert.h>
 
#include <com/sun/star/accessibility/AccessibleEventObject.hpp>
#include <com/sun/star/accessibility/XAccessible.hpp>
#include <com/sun/star/accessibility/XAccessibleAction.hpp>
#include <com/sun/star/accessibility/XAccessibleContext.hpp>
#include <com/sun/star/accessibility/XAccessibleText.hpp>
 
class OOO_DLLPUBLIC_TEST AccessibilityTools
{
public:
    static const sal_Int32 MAX_CHILDREN = 500;
 
    static css::uno::Reference<css::accessibility::XAccessibleContext>
    getAccessibleObjectForPredicate(
        const css::uno::Reference<css::accessibility::XAccessibleContext>& xCtx,
        const std::function<
            bool(const css::uno::Reference<css::accessibility::XAccessibleContext>&)>& cPredicate);
    static css::uno::Reference<css::accessibility::XAccessibleContext>
    getAccessibleObjectForPredicate(
        const css::uno::Reference<css::accessibility::XAccessible>& xAcc,
        const std::function<
            bool(const css::uno::Reference<css::accessibility::XAccessibleContext>&)>& cPredicate);
    static css::uno::Reference<css::accessibility::XAccessibleContext> getAccessibleObjectForRole(
        const css::uno::Reference<css::accessibility::XAccessibleContext>& xCtx, sal_Int16 role);
    static css::uno::Reference<css::accessibility::XAccessibleContext>
    getAccessibleObjectForRole(const css::uno::Reference<css::accessibility::XAccessible>& xacc,
                               sal_Int16 role);
 
    static css::uno::Reference<css::accessibility::XAccessibleContext> getAccessibleObjectForName(
        const css::uno::Reference<css::accessibility::XAccessibleContext>& xCtx,
        const sal_Int16 role, std::u16string_view name);
    static inline css::uno::Reference<css::accessibility::XAccessibleContext>
    getAccessibleObjectForName(const css::uno::Reference<css::accessibility::XAccessible>& xAcc,
                               const sal_Int16 role, std::u16string_view name)
    {
        return getAccessibleObjectForName(xAcc->getAccessibleContext(), role, name);
    }
 
    /* TODO: reimplement as IDDFS or BFS?  Not sure the additional complexity/performance costs
     *       warrant it. */
    template <typename... Ts>
    static css::uno::Reference<css::accessibility::XAccessibleContext> getAccessibleObjectForName(
        const css::uno::Reference<css::accessibility::XAccessibleContext>& xCtx,
        const sal_Int16 role, std::u16string_view name, Ts... args)
    {
        auto nChildren = xCtx->getAccessibleChildCount();
 
        // try self first
        if (xCtx->getAccessibleRole() == role && nameEquals(xCtx, name))
        {
            for (decltype(nChildren) i = 0; i < nChildren && i < MAX_CHILDREN; i++)
            {
                if (auto xMatchChild
                    = getAccessibleObjectForName(xCtx->getAccessibleChild(i), args...))
                    return xMatchChild;
            }
        }
 
        // if not found, try at a deeper level
        for (decltype(nChildren) i = 0; i < nChildren && i < MAX_CHILDREN; i++)
        {
            if (auto xMatchChild
                = getAccessibleObjectForName(xCtx->getAccessibleChild(i), role, name, args...))
                return xMatchChild;
        }
 
        return nullptr;
    }
 
    template <typename... Ts>
    static inline css::uno::Reference<css::accessibility::XAccessibleContext>
    getAccessibleObjectForName(const css::uno::Reference<css::accessibility::XAccessible>& xAcc,
                               const sal_Int16 role, std::u16string_view name, Ts... args)
    {
        return getAccessibleObjectForName(xAcc->getAccessibleContext(), role, name, args...);
    }
 
    static bool equals(const css::uno::Reference<css::accessibility::XAccessible>& xacc1,
                       const css::uno::Reference<css::accessibility::XAccessible>& xacc2);
    static bool equals(const css::uno::Reference<css::accessibility::XAccessibleContext>& xctx1,
                       const css::uno::Reference<css::accessibility::XAccessibleContext>& xctx2);
 
    static bool nameEquals(const css::uno::Reference<css::accessibility::XAccessibleContext>& xCtx,
                           const std::u16string_view name);
    static bool nameEquals(const css::uno::Reference<css::accessibility::XAccessible>& xAcc,
                           const std::u16string_view name)
    {
        return nameEquals(xAcc->getAccessibleContext(), name);
    }
 
    static OUString getRoleName(const sal_Int16 role);
    static OUString getEventIdName(const sal_Int16 event_id);
    static OUString getRelationTypeName(const sal_Int16 rel_type);
 
    template <typename T> static std::string debugString(const css::uno::Reference<T>& x)
    {
        return debugString(x.get());
    }
 
    template <typename T> static std::string debugString(const T& x) { return debugString(&x); }
 
    template <typename T> static std::string debugString(const T* p)
    {
        /* only the forwarding to debugName() might actually dereference @c p,
         * and we rely on specializations to be as constant as possible and not
         * violate the cast here.  In practice it'll be the case for all types
         * handle if we carefully write the specializations.  In most case the
         * specialization could take a const itself if the methods were
         * properly marked const, but well. */
        return debugString(const_cast<T*>(p));
    }
 
    template <typename T> static std::string debugString(T* p)
    {
        CPPUNIT_NS::OStringStream ost;
 
        ost << "(" << static_cast<const void*>(p) << ")";
        if (p != nullptr)
            ost << " " << debugName(p);
 
        return ost.str();
    }
 
    static OUString debugAccessibleStateSet(sal_Int64 p);
 
    static bool Await(const std::function<bool()>& cUntilCallback, sal_uInt64 nTimeoutMs = 3000);
 
    static void Wait(sal_uInt64 nTimeoutMs);
 
private:
    static OUString debugName(css::accessibility::XAccessibleContext* xctx);
    static OUString debugName(css::accessibility::XAccessible* xacc);
    static OUString debugName(const css::accessibility::AccessibleEventObject* evobj);
    static OUString debugName(css::accessibility::XAccessibleAction* xAct);
    static OUString debugName(css::accessibility::XAccessibleText* xTxt);
};
 
CPPUNIT_NS_BEGIN
/* How to generate those automatically?  We don't want to match all types
 * not to mess up cppunit for types we don't support */
#define AT_ASSERTION_TRAITS(T)                                                                     \
    template <> struct assertion_traits<css::uno::Reference<T>>                                    \
    {                                                                                              \
        static bool equal(const css::uno::Reference<T>& x, const css::uno::Reference<T>& y)        \
        {                                                                                          \
            return AccessibilityTools::equals(x, y);                                               \
        }                                                                                          \
                                                                                                   \
        static std::string toString(const css::uno::Reference<T>& x)                               \
        {                                                                                          \
            return AccessibilityTools::debugString(x);                                             \
        }                                                                                          \
    }
 
AT_ASSERTION_TRAITS(css::accessibility::XAccessible);
AT_ASSERTION_TRAITS(css::accessibility::XAccessibleContext);
 
#undef AT_ASSERTION_TRAITS
 
CPPUNIT_NS_END
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */