X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/0cd7d9b2355834dfabd0faeab0c5e812ebc3905a..07aaf32633ecf18ec3edfbb41793a112914792d0:/src/msw/evtloop.cpp?ds=inline diff --git a/src/msw/evtloop.cpp b/src/msw/evtloop.cpp index ed84e41c76..eb97f85bab 100644 --- a/src/msw/evtloop.cpp +++ b/src/msw/evtloop.cpp @@ -1,12 +1,12 @@ /////////////////////////////////////////////////////////////////////////////// -// Name: msw/evtloop.cpp -// Purpose: implements wxEventLoop for MSW +// Name: src/msw/evtloop.cpp +// Purpose: implements wxEventLoop for wxMSW port // Author: Vadim Zeitlin // Modified by: // Created: 01.06.01 // RCS-ID: $Id$ // Copyright: (c) 2001 Vadim Zeitlin -// License: wxWindows license +// Licence: wxWindows licence /////////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -17,10 +17,6 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "evtloop.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -28,262 +24,430 @@ #pragma hdrstop #endif +#include "wx/evtloop.h" + #ifndef WX_PRECOMP + #include "wx/window.h" + #include "wx/app.h" + #include "wx/log.h" #endif //WX_PRECOMP -#include "wx/evtloop.h" -#include "wx/window.h" -#include "wx/app.h" -#include "wx/tooltip.h" - +#include "wx/thread.h" +#include "wx/except.h" #include "wx/msw/private.h" +#include "wx/scopeguard.h" +#include "wx/tooltip.h" #if wxUSE_THREADS - // define the array of MSG strutures - WX_DECLARE_OBJARRAY(MSG, wxMsgArray); - // VS: this is a bit dirty - it duplicates same declaration in app.cpp - // (and there's no WX_DEFINE_OBJARRAY for that reason - it is already - // defined in app.cpp). -#endif + // define the list of MSG strutures + WX_DECLARE_LIST(MSG, wxMsgList); -// ---------------------------------------------------------------------------- -// wxEventLoopImpl -// ---------------------------------------------------------------------------- + #include "wx/listimpl.cpp" -class WXDLLEXPORT wxEventLoopImpl -{ -public: - // ctor - wxEventLoopImpl() { SetExitCode(0); } - - // process a message - void ProcessMessage(MSG *msg); - - // generate an idle message, return TRUE if more idle time requested - bool SendIdleMessage(); - - // set/get the exit code - void SetExitCode(int exitcode) { m_exitcode = exitcode; } - int GetExitCode() const { return m_exitcode; } - -private: - // preprocess a message, return TRUE if processed (i.e. no further - // dispatching required) - bool PreProcessMessage(MSG *msg); - - // the exit code of the event loop - int m_exitcode; -}; + WX_DEFINE_LIST(wxMsgList) +#endif // wxUSE_THREADS // ============================================================================ -// wxEventLoopImpl implementation +// GUI wxEventLoop implementation // ============================================================================ -// ---------------------------------------------------------------------------- -// wxEventLoopImpl message processing -// ---------------------------------------------------------------------------- +wxWindowMSW *wxGUIEventLoop::ms_winCritical = NULL; -void wxEventLoopImpl::ProcessMessage(MSG *msg) +bool wxGUIEventLoop::IsChildOfCriticalWindow(wxWindowMSW *win) { - // give us the chance to preprocess the message first - if ( !PreProcessMessage(msg) ) + while ( win ) { - // if it wasn't done, dispatch it to the corresponding window - ::TranslateMessage(msg); - ::DispatchMessage(msg); + if ( win == ms_winCritical ) + return true; + + win = win->GetParent(); } + + return false; } -bool wxEventLoopImpl::PreProcessMessage(MSG *msg) +bool wxGUIEventLoop::PreProcessMessage(WXMSG *msg) { - HWND hWnd = msg->hwnd; - wxWindow *wndThis = wxGetWindowFromHWND((WXHWND)hWnd); + HWND hwnd = msg->hwnd; + wxWindow *wndThis = wxGetWindowFromHWND((WXHWND)hwnd); + wxWindow *wnd; + + // this might happen if we're in a modeless dialog, or if a wx control has + // children which themselves were not created by wx (i.e. wxActiveX control children) + if ( !wndThis ) + { + while ( hwnd && (::GetWindowLong(hwnd, GWL_STYLE) & WS_CHILD )) + { + hwnd = ::GetParent(hwnd); + + // If the control has a wx parent, break and give the parent a chance + // to process the window message + wndThis = wxGetWindowFromHWND((WXHWND)hwnd); + if (wndThis != NULL) + break; + } + + if ( !wndThis ) + { + // this may happen if the event occurred in a standard modeless dialog (the + // only example of which I know of is the find/replace dialog) - then call + // IsDialogMessage() to make TAB navigation in it work + + // NOTE: IsDialogMessage() just eats all the messages (i.e. returns true for + // them) if we call it for the control itself + return hwnd && ::IsDialogMessage(hwnd, msg) != 0; + } + } + + if ( !AllowProcessing(wndThis) ) + { + // not a child of critical window, so we eat the event but take care to + // stop an endless stream of WM_PAINTs which would have resulted if we + // didn't validate the invalidated part of the window + if ( msg->message == WM_PAINT ) + ::ValidateRect(hwnd, NULL); + + return true; + } #if wxUSE_TOOLTIPS // we must relay WM_MOUSEMOVE events to the tooltip ctrl if we want it to // popup the tooltip bubbles - if ( wndThis && (msg->message == WM_MOUSEMOVE) ) + if ( msg->message == WM_MOUSEMOVE ) { - wxToolTip *tt = wndThis->GetToolTip(); - if ( tt ) - { - tt->RelayEvent((WXMSG *)msg); - } + // we should do it if one of window children has an associated tooltip + // (and not just if the window has a tooltip itself) + if ( wndThis->HasToolTips() ) + wxToolTip::RelayEvent((WXMSG *)msg); } #endif // wxUSE_TOOLTIPS - // try translations first; find the youngest window with a translation - // table. - wxWindow *wnd; + // allow the window to prevent certain messages from being + // translated/processed (this is currently used by wxTextCtrl to always + // grab Ctrl-C/V/X, even if they are also accelerators in some parent) + if ( !wndThis->MSWShouldPreProcessMessage((WXMSG *)msg) ) + { + return false; + } + + // try translations first: the accelerators override everything for ( wnd = wndThis; wnd; wnd = wnd->GetParent() ) { - if ( wnd->MSWTranslateMessage((WXMSG *)msg) ) - return TRUE; + if ( wnd->MSWTranslateMessage((WXMSG *)msg)) + return true; + + // stop at first top level window, i.e. don't try to process the key + // strokes originating in a dialog using the accelerators of the parent + // frame - this doesn't make much sense + if ( wnd->IsTopLevel() ) + break; } - // Anyone for a non-translation message? Try youngest descendants first. + // now try the other hooks (kbd navigation is handled here) for ( wnd = wndThis; wnd; wnd = wnd->GetParent() ) { if ( wnd->MSWProcessMessage((WXMSG *)msg) ) - return TRUE; + return true; + + // also stop at first top level window here, just as above because + // if we don't do this, pressing ESC on a modal dialog shown as child + // of a modal dialog with wxID_CANCEL will cause the parent dialog to + // be closed, for example + if ( wnd->IsTopLevel() ) + break; } - return FALSE; + // no special preprocessing for this message, dispatch it normally + return false; } -// ---------------------------------------------------------------------------- -// wxEventLoopImpl idle event processing -// ---------------------------------------------------------------------------- - -bool wxEventLoopImpl::SendIdleMessage() +void wxGUIEventLoop::ProcessMessage(WXMSG *msg) { - wxIdleEvent event; - - return wxTheApp->ProcessEvent(event) && event.MoreRequested(); -} - -// ============================================================================ -// wxEventLoop implementation -// ============================================================================ - -// ---------------------------------------------------------------------------- -// wxEventLoop running and exiting -// ---------------------------------------------------------------------------- - -wxEventLoop::~wxEventLoop() -{ - wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") ); + // give us the chance to preprocess the message first + if ( !PreProcessMessage(msg) ) + { + // if it wasn't done, dispatch it to the corresponding window + ::TranslateMessage(msg); + ::DispatchMessage(msg); + } } -bool wxEventLoop::IsRunning() const +bool wxGUIEventLoop::Dispatch() { - return m_impl != NULL; -} + MSG msg; + if ( !GetNextMessage(&msg) ) + return false; -int wxEventLoop::Run() -{ - // event loops are not recursive, you need to create another loop! - wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") ); +#if wxUSE_THREADS + wxASSERT_MSG( wxThread::IsMain(), + wxT("only the main thread can process Windows messages") ); - m_impl = new wxEventLoopImpl; + static bool s_hadGuiLock = true; + static wxMsgList s_aSavedMessages; - for ( ;; ) + // if a secondary thread owning the mutex is doing GUI calls, save all + // messages for later processing - we can't process them right now because + // it will lead to recursive library calls (and we're not reentrant) + if ( !wxGuiOwnedByMainThread() ) { -#if wxUSE_THREADS - wxMutexGuiLeaveOrEnter(); -#endif // wxUSE_THREADS + s_hadGuiLock = false; - // generate and process idle events for as long as we don't have - // anything else to do - while ( !Pending() && m_impl->SendIdleMessage() ) - ; + // leave out WM_COMMAND messages: too dangerous, sometimes + // the message will be processed twice + if ( !wxIsWaitingForThread() || msg.message != WM_COMMAND ) + { + MSG* pMsg = new MSG(msg); + s_aSavedMessages.Append(pMsg); + } - // a message came or no more idle processing to do, sit in Dispatch() - // waiting for the next message - if ( !Dispatch() ) + return true; + } + else + { + // have we just regained the GUI lock? if so, post all of the saved + // messages + // + // FIXME of course, it's not _exactly_ the same as processing the + // messages normally - expect some things to break... + if ( !s_hadGuiLock ) { - // we got WM_QUIT - break; + s_hadGuiLock = true; + + wxMsgList::compatibility_iterator node = s_aSavedMessages.GetFirst(); + while (node) + { + MSG* pMsg = node->GetData(); + s_aSavedMessages.Erase(node); + + ProcessMessage(pMsg); + delete pMsg; + + node = s_aSavedMessages.GetFirst(); + } } } +#endif // wxUSE_THREADS - int exitcode = m_impl->GetExitCode(); - delete m_impl; - m_impl = NULL; + ProcessMessage(&msg); - return exitcode; + return true; } -void wxEventLoop::Exit(int rc) +int wxGUIEventLoop::DispatchTimeout(unsigned long timeout) { - wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") ); + MSG msg; + int rc = GetNextMessageTimeout(&msg, timeout); + if ( rc != 1 ) + return rc; - m_impl->SetExitCode(rc); + ProcessMessage(&msg); - ::PostQuitMessage(rc); + return 1; } -// ---------------------------------------------------------------------------- -// wxEventLoop message processing dispatching -// ---------------------------------------------------------------------------- - -bool wxEventLoop::Pending() const +void wxGUIEventLoop::OnNextIteration() { - MSG msg; - return ::PeekMessage(&msg, 0, 0, 0, PM_NOREMOVE) != 0; +#if wxUSE_THREADS + wxMutexGuiLeaveOrEnter(); +#endif // wxUSE_THREADS } -bool wxEventLoop::Dispatch() +void wxGUIEventLoop::WakeUp() { - wxCHECK_MSG( IsRunning(), FALSE, _T("can't call Dispatch() if not running") ); + ::PostMessage(NULL, WM_NULL, 0, 0); +} - MSG msg; - BOOL rc = ::GetMessage(&msg, (HWND) NULL, 0, 0); - if ( rc == 0 ) - { - // got WM_QUIT - return FALSE; - } +// ---------------------------------------------------------------------------- +// Yield to incoming messages +// ---------------------------------------------------------------------------- - if ( rc == -1 ) - { - // should never happen, but let's test for it nevertheless - wxLogLastError(wxT("GetMessage")); +#include +WX_DEFINE_OBJARRAY(wxMSGArray); - // still break from the loop - return FALSE; - } +bool wxGUIEventLoop::YieldFor(long eventsToProcess) +{ + // set the flag and don't forget to reset it before returning + m_isInsideYield = true; + m_eventsToProcessInsideYield = eventsToProcess; -#if wxUSE_THREADS - wxASSERT_MSG( wxThread::IsMain(), - wxT("only the main thread can process Windows messages") ); + wxON_BLOCK_EXIT_SET(m_isInsideYield, false); - static bool s_hadGuiLock = TRUE; - static wxMsgArray s_aSavedMessages; +#if wxUSE_LOG + // disable log flushing from here because a call to wxYield() shouldn't + // normally result in message boxes popping up &c + wxLog::Suspend(); - // if a secondary thread owning the mutex is doing GUI calls, save all - // messages for later processing - we can't process them right now because - // it will lead to recursive library calls (and we're not reentrant) - if ( !wxGuiOwnedByMainThread() ) + // ensure the logs will be flashed again when we exit + wxON_BLOCK_EXIT0(wxLog::Resume); +#endif // wxUSE_LOG + + // we don't want to process WM_QUIT from here - it should be processed in + // the main event loop in order to stop it + MSG msg; + int nPaintsReceived = 0; + while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) && + msg.message != WM_QUIT ) { - s_hadGuiLock = FALSE; +#if wxUSE_THREADS + wxMutexGuiLeaveOrEnter(); +#endif // wxUSE_THREADS - // leave out WM_COMMAND messages: too dangerous, sometimes - // the message will be processed twice - if ( !wxIsWaitingForThread() || - msg.message != WM_COMMAND ) + if (msg.message == WM_PAINT) { - s_aSavedMessages.Add(msg); + // NOTE: WM_PAINTs are categorized as wxEVT_CATEGORY_UI + if ((eventsToProcess & wxEVT_CATEGORY_UI) == 0) + { + // this msg is not going to be dispatched... + // however WM_PAINT is special: until there are damaged + // windows, Windows will keep sending it forever! + if (nPaintsReceived > 10) + { + // we got 10 WM_PAINT consecutive messages... + // we must have reached the tail of the message queue: + // we're now getting _only_ WM_PAINT events and this will + // continue forever (since we don't dispatch them + // because of the user-specified eventsToProcess mask)... + // break out of this loop! + break; + } + else + nPaintsReceived++; + } + //else: we're going to dispatch it below, + // so we don't need to take any special action + } + else + { + // reset the counter of consecutive WM_PAINT messages received: + nPaintsReceived = 0; } - return TRUE; - } - else - { - // have we just regained the GUI lock? if so, post all of the saved - // messages - // - // FIXME of course, it's not _exactly_ the same as processing the - // messages normally - expect some things to break... - if ( !s_hadGuiLock ) + // choose a wxEventCategory for this Windows message + bool processNow; + switch (msg.message) { - s_hadGuiLock = TRUE; +#if !defined(__WXWINCE__) + case WM_NCMOUSEMOVE: + + case WM_NCLBUTTONDOWN: + case WM_NCLBUTTONUP: + case WM_NCLBUTTONDBLCLK: + case WM_NCRBUTTONDOWN: + case WM_NCRBUTTONUP: + case WM_NCRBUTTONDBLCLK: + case WM_NCMBUTTONDOWN: + case WM_NCMBUTTONUP: + case WM_NCMBUTTONDBLCLK: +#endif - size_t count = s_aSavedMessages.Count(); - for ( size_t n = 0; n < count; n++ ) - { - MSG& msg = s_aSavedMessages[n]; - m_impl->ProcessMessage(&msg); - } + case WM_KEYDOWN: + case WM_KEYUP: + case WM_CHAR: + case WM_DEADCHAR: + case WM_SYSKEYDOWN: + case WM_SYSKEYUP: + case WM_SYSCHAR: + case WM_SYSDEADCHAR: +#ifdef WM_UNICHAR + case WM_UNICHAR: +#endif + case WM_HOTKEY: + case WM_IME_STARTCOMPOSITION: + case WM_IME_ENDCOMPOSITION: + case WM_IME_COMPOSITION: + case WM_COMMAND: + case WM_SYSCOMMAND: + + case WM_IME_SETCONTEXT: + case WM_IME_NOTIFY: + case WM_IME_CONTROL: + case WM_IME_COMPOSITIONFULL: + case WM_IME_SELECT: + case WM_IME_CHAR: + case WM_IME_KEYDOWN: + case WM_IME_KEYUP: + +#if !defined(__WXWINCE__) + case WM_MOUSEHOVER: + case WM_MOUSELEAVE: +#endif +#ifdef WM_NCMOUSELEAVE + case WM_NCMOUSELEAVE: +#endif + + case WM_CUT: + case WM_COPY: + case WM_PASTE: + case WM_CLEAR: + case WM_UNDO: + + case WM_MOUSEMOVE: + case WM_LBUTTONDOWN: + case WM_LBUTTONUP: + case WM_LBUTTONDBLCLK: + case WM_RBUTTONDOWN: + case WM_RBUTTONUP: + case WM_RBUTTONDBLCLK: + case WM_MBUTTONDOWN: + case WM_MBUTTONUP: + case WM_MBUTTONDBLCLK: + case WM_MOUSEWHEEL: + processNow = (eventsToProcess & wxEVT_CATEGORY_USER_INPUT) != 0; + break; + + case WM_TIMER: + processNow = (eventsToProcess & wxEVT_CATEGORY_TIMER) != 0; + break; + + default: + if (msg.message < WM_USER) + { + // 0;WM_USER-1 is the range of message IDs reserved for use + // by the system. + // there are too many of these types of messages to handle + // them in this switch + processNow = (eventsToProcess & wxEVT_CATEGORY_UI) != 0; + } + else + { + // Process all the unknown messages. We must do it because + // failure to process some of them can be fatal, e.g. if we + // don't dispatch WM_APP+2 then embedded IE ActiveX + // controls don't work any more, see #14027. And there may + // be more examples like this, so dispatch all unknown + // messages immediately to be safe. + processNow = true; + } + } - s_aSavedMessages.Empty(); + // should we process this event now? + if ( processNow ) + { + if ( !wxTheApp->Dispatch() ) + break; + } + else + { + // remove the message and store it + ::GetMessage(&msg, NULL, 0, 0); + m_arrMSG.Add(msg); } } -#endif // wxUSE_THREADS - m_impl->ProcessMessage(&msg); + // if there are pending events, we must process them. + if (wxTheApp) + wxTheApp->ProcessPendingEvents(); - return TRUE; -} + // put back unprocessed events in the queue + DWORD id = GetCurrentThreadId(); + for (size_t i=0; i