juce_MessageManager.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_MESSAGEMANAGER_H_INCLUDED
#define JUCE_MESSAGEMANAGER_H_INCLUDED
 
class MessageManagerLock;
class ThreadPoolJob;
class ActionListener;
class ActionBroadcaster;
 
 
//==============================================================================
typedef void* (MessageCallbackFunction) (void* userData);
 
 
//==============================================================================
class JUCE_API  MessageManager
{
public:
    //==============================================================================
    static MessageManager* getInstance();
 
    static MessageManager* getInstanceWithoutCreating() noexcept;
 
    static void deleteInstance();
 
    //==============================================================================
    void runDispatchLoop();
 
    void stopDispatchLoop();
 
    bool hasStopMessageBeenSent() const noexcept        { return quitMessagePosted; }
 
   #if JUCE_MODAL_LOOPS_PERMITTED || DOXYGEN
 
    bool runDispatchLoopUntil (int millisecondsToRunFor);
   #endif
 
    //==============================================================================
   #if JUCE_COMPILER_SUPPORTS_LAMBDAS
 
    static void callAsync (std::function<void(void)>);
   #endif
 
    void* callFunctionOnMessageThread (MessageCallbackFunction* callback, void* userData);
 
    bool isThisTheMessageThread() const noexcept;
 
    void setCurrentThreadAsMessageThread();
 
    Thread::ThreadID getCurrentMessageThread() const noexcept            { return messageThreadId; }
 
    bool currentThreadHasLockedMessageManager() const noexcept;
 
    //==============================================================================
    static void broadcastMessage (const String& messageText);
 
    void registerBroadcastListener (ActionListener* listener);
 
    void deregisterBroadcastListener (ActionListener* listener);
 
    //==============================================================================
    class JUCE_API  MessageBase  : public ReferenceCountedObject
    {
    public:
        MessageBase() noexcept {}
        virtual ~MessageBase() {}
 
        virtual void messageCallback() = 0;
        bool post();
 
        typedef ReferenceCountedObjectPtr<MessageBase> Ptr;
 
        JUCE_DECLARE_NON_COPYABLE (MessageBase)
    };
 
    //==============================================================================
   #ifndef DOXYGEN
    // Internal methods - do not use!
    void deliverBroadcastMessage (const String&);
    ~MessageManager() noexcept;
   #endif
 
private:
    //==============================================================================
    MessageManager() noexcept;
 
    static MessageManager* instance;
 
    friend class MessageBase;
    class QuitMessage;
    friend class QuitMessage;
    friend class MessageManagerLock;
 
    ScopedPointer <ActionBroadcaster> broadcaster;
    bool quitMessagePosted, quitMessageReceived;
    Thread::ThreadID messageThreadId;
    Thread::ThreadID volatile threadWithLock;
    CriticalSection lockingLock;
 
    static bool postMessageToSystemQueue (MessageBase*);
    static void* exitModalLoopCallback (void*);
    static void doPlatformSpecificInitialisation();
    static void doPlatformSpecificShutdown();
    static bool dispatchNextMessageOnSystemQueue (bool returnIfNoPendingMessages);
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MessageManager)
};
 
 
//==============================================================================
class JUCE_API MessageManagerLock
{
public:
    //==============================================================================
    MessageManagerLock (Thread* threadToCheckForExitSignal = nullptr);
 
    //==============================================================================
    MessageManagerLock (ThreadPoolJob* jobToCheckForExitSignal);
 
 
    //==============================================================================
    ~MessageManagerLock() noexcept;
 
    //==============================================================================
    bool lockWasGained() const noexcept                     { return locked; }
 
private:
    class BlockingMessage;
    friend class ReferenceCountedObjectPtr<BlockingMessage>;
    ReferenceCountedObjectPtr<BlockingMessage> blockingMessage;
    bool locked;
 
    bool attemptLock (Thread*, ThreadPoolJob*);
 
    JUCE_DECLARE_NON_COPYABLE (MessageManagerLock)
};
 
 
#endif   // JUCE_MESSAGEMANAGER_H_INCLUDED