This class is in charge of the application's event-dispatch loop.
More...
#include <juce_MessageManager.h>
|
class | Lock |
| A lock you can use to lock the message manager. More...
|
|
class | MessageBase |
| Internal class used as the base class for all message objects. More...
|
|
This class is in charge of the application's event-dispatch loop.
- See also
- Message, CallbackMessage, MessageManagerLock, JUCEApplication, JUCEApplicationBase
@tags{Events}
◆ MessageManager()
juce::MessageManager::MessageManager |
( |
| ) |
|
|
privatenoexcept |
◆ broadcastMessage()
static void juce::MessageManager::broadcastMessage |
( |
const String & |
messageText | ) |
|
|
static |
Sends a message to all other JUCE applications that are running.
- Parameters
-
messageText | the string that will be passed to the actionListenerCallback() method of the broadcast listeners in the other app. |
- See also
- registerBroadcastListener, ActionListener
◆ callAsync()
static bool juce::MessageManager::callAsync |
( |
std::function< void()> |
functionToCall | ) |
|
|
static |
Asynchronously invokes a function or C++11 lambda on the message thread.
- Returns
- true if the message was successfully posted to the message queue, or false otherwise.
◆ callFunctionOnMessageThread()
Calls a function using the message-thread.
This can be used by any thread to cause this function to be called-back by the message thread. If it's the message-thread that's calling this method, then the function will just be called; if another thread is calling, a message will be posted to the queue, and this method will block until that message is delivered, the function is called, and the result is returned.
Be careful not to cause any deadlocks with this! It's easy to do - e.g. if the caller thread has a critical section locked, which an unrelated message callback then tries to lock before the message thread gets round to processing this callback.
- Parameters
-
callback | the function to call - its signature must bevoid* myCallbackFunction (void*)
|
userData | a user-defined pointer that will be passed to the function that gets called |
- Returns
- the value that the callback function returns.
- See also
- MessageManagerLock
◆ currentThreadHasLockedMessageManager()
bool juce::MessageManager::currentThreadHasLockedMessageManager |
( |
| ) |
const |
|
noexcept |
Returns true if the caller thread has currently got the message manager locked.
see the MessageManagerLock class for more info about this.
This will be true if the caller is the message thread, because that automatically gains a lock while a message is being dispatched.
◆ deleteInstance()
static void juce::MessageManager::deleteInstance |
( |
| ) |
|
|
static |
Deletes the global MessageManager instance.
Does nothing if no instance had been created.
◆ deregisterBroadcastListener()
void juce::MessageManager::deregisterBroadcastListener |
( |
ActionListener * |
listener | ) |
|
Deregisters a broadcast listener.
◆ doPlatformSpecificInitialisation()
static void juce::MessageManager::doPlatformSpecificInitialisation |
( |
| ) |
|
|
staticprivate |
◆ doPlatformSpecificShutdown()
static void juce::MessageManager::doPlatformSpecificShutdown |
( |
| ) |
|
|
staticprivate |
◆ existsAndIsCurrentThread()
static bool juce::MessageManager::existsAndIsCurrentThread |
( |
| ) |
|
|
staticnoexcept |
Returns true if there's an instance of the MessageManager, and if the current thread is running it.
◆ existsAndIsLockedByCurrentThread()
static bool juce::MessageManager::existsAndIsLockedByCurrentThread |
( |
| ) |
|
|
staticnoexcept |
Returns true if there's an instance of the MessageManager, and if the current thread has the lock on it.
◆ exitModalLoopCallback()
static void* juce::MessageManager::exitModalLoopCallback |
( |
void * |
| ) |
|
|
staticprivate |
◆ getCurrentMessageThread()
◆ getInstance()
◆ getInstanceWithoutCreating()
static MessageManager* juce::MessageManager::getInstanceWithoutCreating |
( |
| ) |
|
|
staticnoexcept |
Returns the global instance of the MessageManager, or nullptr if it doesn't exist.
◆ hasStopMessageBeenSent()
bool juce::MessageManager::hasStopMessageBeenSent |
( |
| ) |
const |
|
inlinenoexcept |
◆ isThisTheMessageThread()
bool juce::MessageManager::isThisTheMessageThread |
( |
| ) |
const |
|
noexcept |
Returns true if the caller-thread is the message thread.
◆ postMessageToSystemQueue()
static bool juce::MessageManager::postMessageToSystemQueue |
( |
MessageBase * |
| ) |
|
|
staticprivate |
◆ registerBroadcastListener()
void juce::MessageManager::registerBroadcastListener |
( |
ActionListener * |
listener | ) |
|
Registers a listener to get told about broadcast messages.
The actionListenerCallback() callback's string parameter is the message passed into broadcastMessage().
- See also
- broadcastMessage
◆ runDispatchLoop()
void juce::MessageManager::runDispatchLoop |
( |
| ) |
|
Runs the event dispatch loop until a stop message is posted.
This method is only intended to be run by the application's startup routine, as it blocks, and will only return after the stopDispatchLoop() method has been used.
- See also
- stopDispatchLoop
◆ runDispatchLoopUntil()
bool juce::MessageManager::runDispatchLoopUntil |
( |
int |
millisecondsToRunFor | ) |
|
Synchronously dispatches messages until a given time has elapsed.
Returns false if a quit message has been posted by a call to stopDispatchLoop(), otherwise returns true.
◆ setCurrentThreadAsMessageThread()
void juce::MessageManager::setCurrentThreadAsMessageThread |
( |
| ) |
|
◆ stopDispatchLoop()
void juce::MessageManager::stopDispatchLoop |
( |
| ) |
|
◆ MessageBase
◆ MessageManagerLock
◆ QuitMessage
◆ broadcaster
◆ instance
◆ messageThreadId
◆ quitMessagePosted
Atomic<int> juce::MessageManager::quitMessagePosted { 0 } |
|
private |
◆ quitMessageReceived
Atomic<int> juce::MessageManager::quitMessageReceived { 0 } |
|
private |
◆ threadWithLock
The documentation for this class was generated from the following file: