Message Loop
A simple message loop consists of one function call to each of these three
functions:
GetMessage,
TranslateMessage, and
DispatchMessage.
MSG msg;
while( GetMessage( &msg, NULL, 0, 0 ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
The
GetMessage function retrieves a message from the queue and copies it to a structure of
type
MSG. It returns TRUE unless it encounters the
WM_QUIT message, in which case it returns FALSE and ends the loop. In a
single-threaded application, ending the message loop is often the first step in closing the
application. An application can end its own loop by using the
PostQuitMessage function, typically in response to the
WM_DESTROY message in the window procedure of the application's main window.
If you specify a window handle as the second parameter of
GetMessage, only messages for the specified window are retrieved from the queue.
GetMessage can also filter messages in the queue, retrieving only those messages that
fall within a specified range. For more information about filtering messages, see
Message Filtering.
A thread's message loop must include
TranslateMessage if the thread is to receive character input from the keyboard. Windows
generates virtual-key messages (
WM_KEYDOWN and
WM_KEYUP) each time the user presses a key. A virtual-key message contains a
virtual-key code that identifies which key was pressed, but not its character value. To
retrieve this value, the message loop must contain
TranslateMessage, which translates the virtual-key message into a character message (
WM_CHAR) and places it back into the application message queue. The character message
can then be removed upon a subsequent iteration of the message loop and
dispatched to a window procedure.
The
DispatchMessage function sends a message to the window procedure associated with the window
handle specified in the
MSG structure. If the window handle is HWND_TOPMOST,
DispatchMessage sends the message to the window procedures of all top-level windows in the
system. If the window handle is NULL,
DispatchMessage does nothing with the message.
An application's main thread starts its message loop after initializing the
application and creating at least one window. Once started, the message loop
continues to retrieve messages from the thread's message queue and to dispatch them
to the appropriate windows. The message loop ends when the
GetMessage function removes the
WM_QUIT message from the message queue.
Only one message loop is needed for a message queue, even if an application
contains many windows.
DispatchMessage always dispatches the message to the proper window; this is because each
message in the queue is an
MSG structure that contains the handle of the window to which the message
belongs.
You can modify a message loop in a variety of ways. For example, you can
retrieve messages from the queue without dispatching them to a window. This is
useful for applications that post messages not specifying a window. You can also
direct
GetMessage to search for specific messages, leaving other messages in the queue. This is
useful if you must temporarily bypass the usual FIFO order of the message
queue.
An application that uses accelerator keys must be able to translate keyboard
messages into command messages. To do this, the application's message loop must
include a call to the
TranslateAccelerator function. For more information about accelerator keys, see
Keyboard Accelerators.
If a thread uses a modeless dialog box, the message loop must include the
IsDialogMessage function so that the dialog box can receive keyboard input.
- Software for developers
-
Delphi Components
.Net Components
Software for Android Developers
- More information resources
-
MegaDetailed.Net
Unix Manual Pages
Delphi Examples
- Databases for Amazon shops developers
-
Amazon Categories Database
Browse Nodes Database
