juce_ModalComponentManager.h

Go to the documentation of this file.

/*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2015 - ROLI Ltd.
 
   Permission is granted to use this software under the terms of either:
   a) the GPL v2 (or any later version)
   b) the Affero GPL v3
 
   Details of these licenses can be found at: www.gnu.org/licenses
 
   JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
 
   ------------------------------------------------------------------------------
 
   To release a closed-source product which uses JUCE, commercial licenses are
   available: visit www.juce.com for more information.
 
  ==============================================================================
*/
 
#ifndef JUCE_MODALCOMPONENTMANAGER_H_INCLUDED
#define JUCE_MODALCOMPONENTMANAGER_H_INCLUDED
 
 
//==============================================================================
class JUCE_API  ModalComponentManager   : private AsyncUpdater,
                                          private DeletedAtShutdown
{
public:
    //==============================================================================
    class Callback
    {
    public:
        Callback() {}
 
        virtual ~Callback() {}
 
        virtual void modalStateFinished (int returnValue) = 0;
    };
 
    //==============================================================================
    juce_DeclareSingleton_SingleThreaded_Minimal (ModalComponentManager)
 
    //==============================================================================
    int getNumModalComponents() const;
 
    Component* getModalComponent (int index) const;
 
    bool isModal (Component* component) const;
 
    bool isFrontModalComponent (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();
 
    void handleAsyncUpdate() override;
 
private:
    //==============================================================================
    class ModalItem;
    class ReturnValueRetriever;
 
    friend class Component;
    friend struct ContainerDeletePolicy<ModalItem>;
    OwnedArray<ModalItem> stack;
 
    void startModal (Component*, bool autoDelete);
    void endModal (Component*, int returnValue);
    void endModal (Component*);
 
    JUCE_DECLARE_NON_COPYABLE (ModalComponentManager)
};
 
//==============================================================================
class ModalCallbackFunction
{
public:
    //==============================================================================
    template <typename ParamType>
    static ModalComponentManager::Callback* create (void (*functionToCall) (int, ParamType),
                                                    ParamType parameterValue)
    {
        return new FunctionCaller1 <ParamType> (functionToCall, parameterValue);
    }
 
    //==============================================================================
    template <typename ParamType1, typename ParamType2>
    static ModalComponentManager::Callback* withParam (void (*functionToCall) (int, ParamType1, ParamType2),
                                                       ParamType1 parameterValue1,
                                                       ParamType2 parameterValue2)
    {
        return new FunctionCaller2 <ParamType1, ParamType2> (functionToCall, parameterValue1, parameterValue2);
    }
 
    //==============================================================================
    template <class ComponentType>
    static ModalComponentManager::Callback* forComponent (void (*functionToCall) (int, ComponentType*),
                                                          ComponentType* component)
    {
        return new ComponentCaller1 <ComponentType> (functionToCall, component);
    }
 
    //==============================================================================
    template <class ComponentType, typename ParamType>
    static ModalComponentManager::Callback* forComponent (void (*functionToCall) (int, ComponentType*, ParamType),
                                                          ComponentType* component,
                                                          ParamType param)
    {
        return new ComponentCaller2 <ComponentType, ParamType> (functionToCall, component, param);
    }
 
private:
    //==============================================================================
    template <typename ParamType>
    class FunctionCaller1  : public ModalComponentManager::Callback
    {
    public:
        typedef void (*FunctionType) (int, ParamType);
 
        FunctionCaller1 (FunctionType& f, ParamType& p1)
            : function (f), param (p1) {}
 
        void modalStateFinished (int returnValue)  { function (returnValue, param); }
 
    private:
        const FunctionType function;
        ParamType param;
 
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (FunctionCaller1)
    };
 
    template <typename ParamType1, typename ParamType2>
    class FunctionCaller2  : public ModalComponentManager::Callback
    {
    public:
        typedef void (*FunctionType) (int, ParamType1, ParamType2);
 
        FunctionCaller2 (FunctionType& f, ParamType1& p1, ParamType2& p2)
            : function (f), param1 (p1), param2 (p2) {}
 
        void modalStateFinished (int returnValue)   { function (returnValue, param1, param2); }
 
    private:
        const FunctionType function;
        ParamType1 param1;
        ParamType2 param2;
 
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (FunctionCaller2)
    };
 
    template <typename ComponentType>
    class ComponentCaller1  : public ModalComponentManager::Callback
    {
    public:
        typedef void (*FunctionType) (int, ComponentType*);
 
        ComponentCaller1 (FunctionType& f, ComponentType* c)
            : function (f), comp (c) {}
 
        void modalStateFinished (int returnValue)
        {
            function (returnValue, static_cast <ComponentType*> (comp.get()));
        }
 
    private:
        const FunctionType function;
        WeakReference<Component> comp;
 
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ComponentCaller1)
    };
 
    template <typename ComponentType, typename ParamType1>
    class ComponentCaller2  : public ModalComponentManager::Callback
    {
    public:
        typedef void (*FunctionType) (int, ComponentType*, ParamType1);
 
        ComponentCaller2 (FunctionType& f, ComponentType* c, ParamType1 p1)
            : function (f), comp (c), param1 (p1) {}
 
        void modalStateFinished (int returnValue)
        {
            function (returnValue, static_cast <ComponentType*> (comp.get()), param1);
        }
 
    private:
        const FunctionType function;
        WeakReference<Component> comp;
        ParamType1 param1;
 
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ComponentCaller2)
    };
 
    ModalCallbackFunction();
    ~ModalCallbackFunction();
    JUCE_DECLARE_NON_COPYABLE (ModalCallbackFunction)
};
 
 
#endif   // JUCE_MODALCOMPONENTMANAGER_H_INCLUDED