juce_AccessibilityHandler.h

Go to the documentation of this file.

/*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2022 - Raw Material Software Limited
 
   JUCE is an open source library subject to commercial or open-source
   licensing.
 
   By using JUCE, you agree to the terms of both the JUCE 7 End-User License
   Agreement and JUCE Privacy Policy.
 
   End User License Agreement: www.juce.com/juce-7-licence
   Privacy Policy: www.juce.com/juce-privacy-policy
 
   Or: You may also use this code under the terms of the GPL v3 (see
   www.gnu.org/licenses).
 
   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
   DISCLAIMED.
 
  ==============================================================================
*/
 
namespace juce
{
 
class AccessibilityNativeHandle;

class JUCE_API  AccessibilityHandler
{
public:
    struct JUCE_API  Interfaces
    {
        Interfaces() = default;
 
        Interfaces (std::unique_ptr<AccessibilityValueInterface> ptr)  : value (std::move (ptr))  {}
        Interfaces (std::unique_ptr<AccessibilityTextInterface>  ptr)  : text  (std::move (ptr))  {}
        Interfaces (std::unique_ptr<AccessibilityTableInterface> ptr)  : table (std::move (ptr))  {}
        Interfaces (std::unique_ptr<AccessibilityCellInterface>  ptr)  : cell  (std::move (ptr))  {}
 
        Interfaces (std::unique_ptr<AccessibilityValueInterface> valueIn,
                    std::unique_ptr<AccessibilityTextInterface>  textIn,
                    std::unique_ptr<AccessibilityTableInterface> tableIn,
                    std::unique_ptr<AccessibilityCellInterface>  cellIn)
            : value (std::move (valueIn)),
              text  (std::move (textIn)),
              table (std::move (tableIn)),
              cell  (std::move (cellIn))
        {
        }
 
        std::unique_ptr<AccessibilityValueInterface> value;
        std::unique_ptr<AccessibilityTextInterface>  text;
        std::unique_ptr<AccessibilityTableInterface> table;
        std::unique_ptr<AccessibilityCellInterface>  cell;
    };

    AccessibilityHandler (Component& componentToWrap,
                          AccessibilityRole accessibilityRole,
                          AccessibilityActions actions = {},
                          Interfaces interfaces = {});

    virtual ~AccessibilityHandler();
 
    //==============================================================================
    const Component& getComponent() const noexcept   { return component; }

    Component& getComponent() noexcept               { return component; }
 
    //==============================================================================
    AccessibilityRole getRole() const noexcept       { return role; }

    virtual String getTitle() const                  { return component.getTitle(); }

    virtual String getDescription() const            { return component.getDescription(); }

    virtual String getHelp() const                   { return component.getHelpText(); }

    virtual AccessibleState getCurrentState() const;

    bool isIgnored() const;

    bool isVisibleWithinParent() const;
 
    //==============================================================================
    const AccessibilityActions& getActions() const noexcept;

    AccessibilityValueInterface* getValueInterface() const;

    AccessibilityTableInterface* getTableInterface() const;

    AccessibilityCellInterface* getCellInterface() const;

    AccessibilityTextInterface* getTextInterface() const;
 
    //==============================================================================
    AccessibilityHandler* getParent() const;

    std::vector<AccessibilityHandler*> getChildren() const;

    bool isParentOf (const AccessibilityHandler* possibleChild) const noexcept;

    AccessibilityHandler* getChildAt (Point<int> screenPoint);

    AccessibilityHandler* getChildFocus();

    bool hasFocus (bool trueIfChildFocused) const;

    void grabFocus();

    void giveAwayFocus() const;
 
    //==============================================================================
    void notifyAccessibilityEvent (AccessibilityEvent event) const;

    enum class AnnouncementPriority
    {
        low,
        medium,
        high
    };

    static void postAnnouncement (const String& announcementString, AnnouncementPriority priority);
 
    //==============================================================================
    AccessibilityNativeHandle* getNativeImplementation() const;
    std::type_index getTypeIndex() const  { return typeIndex; }
 
private:
    //==============================================================================
    friend class AccessibilityNativeHandle;
 
    //==============================================================================
    void grabFocusInternal (bool);
    void giveAwayFocusInternal() const;
    void takeFocus();
 
    static AccessibilityHandler* currentlyFocusedHandler;
 
    //==============================================================================
    Component& component;
    std::type_index typeIndex;
 
    const AccessibilityRole role;
    AccessibilityActions actions;
 
    Interfaces interfaces;
 
    //==============================================================================
    class AccessibilityNativeImpl;
    std::unique_ptr<AccessibilityNativeImpl> nativeImpl;
 
    static std::unique_ptr<AccessibilityNativeImpl> createNativeImpl (AccessibilityHandler&);
 
    //==============================================================================
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AccessibilityHandler)
};
 
} // namespace juce