juce_ModalComponentManager.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 JUCE_API  ModalComponentManager   : private AsyncUpdater,
                                          private DeletedAtShutdown
{
public:
    //==============================================================================
    class JUCE_API  Callback
    {
    public:
        Callback() = default;
 
        virtual ~Callback() = default;
 
        virtual void modalStateFinished (int returnValue) = 0;
    };
 
    //==============================================================================
   #ifndef DOXYGEN
    JUCE_DECLARE_SINGLETON_SINGLETHREADED_MINIMAL (ModalComponentManager)
   #endif
 
    //==============================================================================
    int getNumModalComponents() const;
 
    Component* getModalComponent (int index) const;
 
    bool isModal (const Component* component) const;
 
    bool isFrontModalComponent (const Component* component) const;
 
    void attachCallback (Component* component, Callback* callback);
 
    void bringModalComponentsToFront (bool topOneShouldGrabFocus = true);
 
    bool cancelAllModalComponents();
 
   #if JUCE_MODAL_LOOPS_PERMITTED
    int runEventLoopForCurrentComponent();
   #endif
 
protected:
    ModalComponentManager();
 
    ~ModalComponentManager() override;
 
    void handleAsyncUpdate() override;
 
private:
    //==============================================================================
    friend class Component;
 
    struct ModalItem;
    OwnedArray<ModalItem> stack;
 
    void startModal (Component*, bool autoDelete);
    void endModal (Component*, int returnValue);
    void endModal (Component*);
 
    JUCE_DECLARE_NON_COPYABLE (ModalComponentManager)
};
 
//==============================================================================
class JUCE_API ModalCallbackFunction
{
public:
    template <typename CallbackFn>
    static ModalComponentManager::Callback* create (CallbackFn&& fn)
    {
        struct Callable  : public ModalComponentManager::Callback
        {
            explicit Callable (CallbackFn&& f)  : fn (std::forward<CallbackFn> (f)) {}
            void modalStateFinished (int result) override  { NullCheckedInvocation::invoke (std::move (fn), result); }
 
            std::remove_reference_t<CallbackFn> fn;
        };
 
        return new Callable (std::forward<CallbackFn> (fn));
    }
 
    //==============================================================================
    template <typename ParamType>
    static ModalComponentManager::Callback* create (void (*functionToCall) (int, ParamType),
                                                    ParamType parameterValue)
    {
        return create ([functionToCall, parameterValue] (int r)
        {
            functionToCall (r, parameterValue);
        });
    }
 
    //==============================================================================
    template <typename ParamType1, typename ParamType2>
    static ModalComponentManager::Callback* withParam (void (*functionToCall) (int, ParamType1, ParamType2),
                                                       ParamType1 parameterValue1,
                                                       ParamType2 parameterValue2)
    {
        return create ([functionToCall, parameterValue1, parameterValue2] (int r)
        {
            functionToCall (r, parameterValue1, parameterValue2);
        });
    }
 
    //==============================================================================
    template <class ComponentType>
    static ModalComponentManager::Callback* forComponent (void (*functionToCall) (int, ComponentType*),
                                                          ComponentType* component)
    {
        return create ([functionToCall, comp = WeakReference<Component> { component }] (int r)
        {
            functionToCall (r, static_cast<ComponentType*> (comp.get()));
        });
    }
 
    //==============================================================================
    template <class ComponentType, typename ParamType>
    static ModalComponentManager::Callback* forComponent (void (*functionToCall) (int, ComponentType*, ParamType),
                                                          ComponentType* component,
                                                          ParamType param)
    {
        return create ([functionToCall, param, comp = WeakReference<Component> { component }] (int r)
        {
            functionToCall (r, static_cast<ComponentType*> (comp.get()), param);
        });
    }
 
private:
    ModalCallbackFunction() = delete;
    ~ModalCallbackFunction() = delete;
};
 
} // namespace juce