X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/a7b7500c4f51834f2cf69d05e6a95e9048a8faf5..73799292cab3e8fa4873a5aecd2d312ad2fbf5e5:/src/msw/evtloop.cpp?ds=sidebyside diff --git a/src/msw/evtloop.cpp b/src/msw/evtloop.cpp index f87129486a..0d57104c33 100644 --- a/src/msw/evtloop.cpp +++ b/src/msw/evtloop.cpp @@ -17,10 +17,6 @@ // headers // ---------------------------------------------------------------------------- -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) - #pragma implementation "evtloop.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -28,91 +24,138 @@ #pragma hdrstop #endif +#include "wx/evtloop.h" + #ifndef WX_PRECOMP - #include "wx/window.h" + #if wxUSE_GUI + #include "wx/window.h" + #endif #include "wx/app.h" + #include "wx/log.h" #endif //WX_PRECOMP -#include "wx/evtloop.h" - -#include "wx/tooltip.h" +#include "wx/thread.h" #include "wx/except.h" -#include "wx/ptr_scpd.h" - #include "wx/msw/private.h" +#include "wx/scopeguard.h" -#if wxUSE_THREADS - #include "wx/thread.h" - - // define the list of MSG strutures - WX_DECLARE_LIST(MSG, wxMsgList); - - #include "wx/listimpl.cpp" +#if wxUSE_GUI + #include "wx/tooltip.h" + #if wxUSE_THREADS + // define the list of MSG strutures + WX_DECLARE_LIST(MSG, wxMsgList); - WX_DEFINE_LIST(wxMsgList); -#endif // wxUSE_THREADS + #include "wx/listimpl.cpp" -// ---------------------------------------------------------------------------- -// helper class -// ---------------------------------------------------------------------------- + WX_DEFINE_LIST(wxMsgList) + #endif // wxUSE_THREADS +#endif //wxUSE_GUI -// this object sets the wxEventLoop given to the ctor as the currently active -// one and unsets it in its dtor -class wxEventLoopActivator -{ -public: - wxEventLoopActivator(wxEventLoop **pActive, - wxEventLoop *evtLoop) - { - m_pActive = pActive; - m_evtLoopOld = *pActive; - *pActive = evtLoop; - } - - ~wxEventLoopActivator() - { - // restore the previously active event loop - *m_pActive = m_evtLoopOld; - } - -private: - wxEventLoop *m_evtLoopOld; - wxEventLoop **m_pActive; -}; +#if wxUSE_BASE // ============================================================================ -// wxEventLoop implementation +// wxMSWEventLoopBase implementation // ============================================================================ -wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL; -wxWindow *wxEventLoop::ms_winCritical = NULL; - // ---------------------------------------------------------------------------- // ctor/dtor // ---------------------------------------------------------------------------- -wxEventLoop::wxEventLoop() +wxMSWEventLoopBase::wxMSWEventLoopBase() { m_shouldExit = false; m_exitcode = 0; } // ---------------------------------------------------------------------------- -// wxEventLoop message processing +// wxEventLoop message processing dispatching // ---------------------------------------------------------------------------- -void wxEventLoop::ProcessMessage(WXMSG *msg) +bool wxMSWEventLoopBase::Pending() const { - // give us the chance to preprocess the message first - if ( !PreProcessMessage(msg) ) + MSG msg; + return ::PeekMessage(&msg, 0, 0, 0, PM_NOREMOVE) != 0; +} + +bool wxMSWEventLoopBase::GetNextMessage(WXMSG* msg) +{ + const BOOL rc = ::GetMessage(msg, NULL, 0, 0); + + if ( rc == 0 ) { - // if it wasn't done, dispatch it to the corresponding window - ::TranslateMessage(msg); - ::DispatchMessage(msg); + // got WM_QUIT + return false; + } + + if ( rc == -1 ) + { + // should never happen, but let's test for it nevertheless + wxLogLastError(wxT("GetMessage")); + + // still break from the loop + return false; } + + return true; } -bool wxEventLoop::IsChildOfCriticalWindow(wxWindow *win) +int wxMSWEventLoopBase::GetNextMessageTimeout(WXMSG *msg, unsigned long timeout) +{ + // MsgWaitForMultipleObjects() won't notice any input which was already + // examined (e.g. using PeekMessage()) but not yet removed from the queue + // so we need to remove any immediately messages manually + // + // NB: using MsgWaitForMultipleObjectsEx() could simplify the code here but + // it is not available in very old Windows versions + if ( !::PeekMessage(msg, 0, 0, 0, PM_REMOVE) ) + { + // we use this function just in order to not block longer than the + // given timeout, so we don't pass any handles to it at all + DWORD rc = ::MsgWaitForMultipleObjects + ( + 0, NULL, + FALSE, + timeout, + QS_ALLINPUT + ); + + switch ( rc ) + { + default: + wxLogDebug("unexpected MsgWaitForMultipleObjects() return " + "value %lu", rc); + // fall through + + case WAIT_TIMEOUT: + return -1; + + case WAIT_OBJECT_0: + if ( !::PeekMessage(msg, 0, 0, 0, PM_REMOVE) ) + { + // somehow it may happen that MsgWaitForMultipleObjects() + // returns true but there are no messages -- just treat it + // the same as timeout then + return -1; + } + break; + } + } + + return msg->message != WM_QUIT; +} + + +#endif // wxUSE_BASE + +#if wxUSE_GUI + +// ============================================================================ +// GUI wxEventLoop implementation +// ============================================================================ + +wxWindowMSW *wxGUIEventLoop::ms_winCritical = NULL; + +bool wxGUIEventLoop::IsChildOfCriticalWindow(wxWindowMSW *win) { while ( win ) { @@ -125,26 +168,37 @@ bool wxEventLoop::IsChildOfCriticalWindow(wxWindow *win) return false; } -bool wxEventLoop::PreProcessMessage(WXMSG *msg) +bool wxGUIEventLoop::PreProcessMessage(WXMSG *msg) { HWND hwnd = msg->hwnd; - wxWindow * const wndThis = wxGetWindowFromHWND((WXHWND)hwnd); + wxWindow *wndThis = wxGetWindowFromHWND((WXHWND)hwnd); wxWindow *wnd; - // 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 + // 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 ) { - // we need to find the dialog containing this control as - // IsDialogMessage() just eats all the messages (i.e. returns true for - // them) if we call it for the control itself - while ( hwnd && ::GetWindowLong(hwnd, GWL_STYLE) & WS_CHILD ) + 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; } - return hwnd && ::IsDialogMessage(hwnd, msg) != 0; + 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) ) @@ -163,11 +217,10 @@ bool wxEventLoop::PreProcessMessage(WXMSG *msg) // popup the tooltip bubbles 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 @@ -195,16 +248,14 @@ bool wxEventLoop::PreProcessMessage(WXMSG *msg) // now try the other hooks (kbd navigation is handled here) for ( wnd = wndThis; wnd; wnd = wnd->GetParent() ) { - if (wnd != wndThis) // Skip the first since wndThis->MSWProcessMessage() was called above - { - if ( wnd->MSWProcessMessage((WXMSG *)msg) ) - return true; - } - - // Stop at first top level window (as per comment above). - // 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()) + if ( wnd->MSWProcessMessage((WXMSG *)msg) ) + 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; } @@ -212,149 +263,22 @@ bool wxEventLoop::PreProcessMessage(WXMSG *msg) return false; } -// ---------------------------------------------------------------------------- -// wxEventLoop running and exiting -// ---------------------------------------------------------------------------- - -bool wxEventLoop::IsRunning() const -{ - return ms_activeLoop == this; -} - -int wxEventLoop::Run() +void wxGUIEventLoop::ProcessMessage(WXMSG *msg) { - // event loops are not recursive, you need to create another loop! - wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") ); - - // ProcessIdle() and Dispatch() below may throw so the code here should - // be exception-safe, hence we must use local objects for all actions we - // should undo - wxEventLoopActivator activate(&ms_activeLoop, this); - - // we must ensure that OnExit() is called even if an exception is thrown - // from inside Dispatch() but we must call it from Exit() in normal - // situations because it is supposed to be called synchronously, - // wxModalEventLoop depends on this (so we can't just use ON_BLOCK_EXIT or - // something similar here) -#if wxUSE_EXCEPTIONS - for ( ;; ) + // give us the chance to preprocess the message first + if ( !PreProcessMessage(msg) ) { - try - { -#endif // wxUSE_EXCEPTIONS - - // this is the event loop itself - for ( ;; ) - { - #if wxUSE_THREADS - wxMutexGuiLeaveOrEnter(); - #endif // wxUSE_THREADS - - // generate and process idle events for as long as we don't - // have anything else to do - while ( !Pending() && (wxTheApp && wxTheApp->ProcessIdle()) ) - ; - - // if the "should exit" flag is set, the loop should terminate - // but not before processing any remaining messages so while - // Pending() returns true, do process them - if ( m_shouldExit ) - { - while ( Pending() ) - Dispatch(); - - break; - } - - // a message came or no more idle processing to do, sit in - // Dispatch() waiting for the next message - if ( !Dispatch() ) - { - // we got WM_QUIT - break; - } - } - -#if wxUSE_EXCEPTIONS - // exit the outer loop as well - break; - } - catch ( ... ) - { - try - { - if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() ) - { - OnExit(); - break; - } - //else: continue running the event loop - } - catch ( ... ) - { - // OnException() throwed, possibly rethrowing the same - // exception again: very good, but we still need OnExit() to - // be called - OnExit(); - throw; - } - } + // if it wasn't done, dispatch it to the corresponding window + ::TranslateMessage(msg); + ::DispatchMessage(msg); } -#endif // wxUSE_EXCEPTIONS - - return m_exitcode; } -void wxEventLoop::Exit(int rc) +bool wxGUIEventLoop::Dispatch() { - wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") ); - - m_exitcode = rc; - m_shouldExit = true; - - OnExit(); - - // all we have to do to exit from the loop is to (maybe) wake it up so that - // it can notice that Exit() had been called - // - // in particular, we do *not* use PostQuitMessage() here because we're not - // sure that WM_QUIT is going to be processed by the correct event loop: it - // is possible that another one is started before this one has a chance to - // process WM_QUIT - ::PostMessage(NULL, WM_NULL, 0, 0); -} - -// ---------------------------------------------------------------------------- -// wxEventLoop message processing dispatching -// ---------------------------------------------------------------------------- - -bool wxEventLoop::Pending() const -{ - MSG msg; - return ::PeekMessage(&msg, 0, 0, 0, PM_NOREMOVE) != 0; -} - -bool wxEventLoop::Dispatch() -{ - wxCHECK_MSG( IsRunning(), false, _T("can't call Dispatch() if not running") ); - MSG msg; - BOOL rc = ::GetMessage(&msg, (HWND) NULL, 0, 0); - - if ( rc == 0 ) - { - // got WM_QUIT + if ( !GetNextMessage(&msg) ) return false; - } - - if ( rc == -1 ) - { - // should never happen, but let's test for it nevertheless - wxLogLastError(wxT("GetMessage")); - - // still break from the loop - return false; - } #if wxUSE_THREADS wxASSERT_MSG( wxThread::IsMain(), @@ -411,3 +335,266 @@ bool wxEventLoop::Dispatch() return true; } +int wxGUIEventLoop::DispatchTimeout(unsigned long timeout) +{ + MSG msg; + int rc = GetNextMessageTimeout(&msg, timeout); + if ( rc != 1 ) + return rc; + + ProcessMessage(&msg); + + return 1; +} + +void wxGUIEventLoop::OnNextIteration() +{ +#if wxUSE_THREADS + wxMutexGuiLeaveOrEnter(); +#endif // wxUSE_THREADS +} + +void wxGUIEventLoop::WakeUp() +{ + ::PostMessage(NULL, WM_NULL, 0, 0); +} + + +// ---------------------------------------------------------------------------- +// Yield to incoming messages +// ---------------------------------------------------------------------------- + +#include +WX_DEFINE_OBJARRAY(wxMSGArray); + +bool wxGUIEventLoop::YieldFor(long eventsToProcess) +{ + // set the flag and don't forget to reset it before returning + m_isInsideYield = true; + m_eventsToProcessInsideYield = eventsToProcess; + + wxON_BLOCK_EXIT_SET(m_isInsideYield, false); + +#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(); + + // 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 ) + { +#if wxUSE_THREADS + wxMutexGuiLeaveOrEnter(); +#endif // wxUSE_THREADS + + if (msg.message == WM_PAINT) + { + // 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; + } + + // choose a wxEventCategory for this Windows message + wxEventCategory cat; + switch (msg.message) + { + 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: + + 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: + + case WM_MOUSEHOVER: +#ifdef WM_NCMOUSELEAVE + case WM_NCMOUSELEAVE: +#endif + case WM_MOUSELEAVE: + + 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: + cat = wxEVT_CATEGORY_USER_INPUT; + break; + + case WM_TIMER: + cat = wxEVT_CATEGORY_TIMER; + 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 + cat = wxEVT_CATEGORY_UI; + } + else + cat = wxEVT_CATEGORY_UNKNOWN; + } + + // should we process this event now? + if (cat & eventsToProcess) + { + if ( !wxTheApp->Dispatch() ) + break; + } + else + { + // remove the message and store it + ::GetMessage(&msg, NULL, 0, 0); + m_arrMSG.Add(msg); + } + } + + // if there are pending events, we must process them. + if (wxTheApp) + wxTheApp->ProcessPendingEvents(); + + // put back unprocessed events in the queue + DWORD id = GetCurrentThreadId(); + for (size_t i=0; imessage == WM_TIMER ) + { + TIMERPROC proc = (TIMERPROC)msg->lParam; + if ( proc ) + (*proc)(NULL, 0, msg->wParam, 0); + } + else + { + ::DispatchMessage(msg); + } +} + +bool wxConsoleEventLoop::Dispatch() +{ + MSG msg; + if ( !GetNextMessage(&msg) ) + return false; + + ProcessMessage(&msg); + + return !m_shouldExit; +} + +int wxConsoleEventLoop::DispatchTimeout(unsigned long timeout) +{ + MSG msg; + int rc = GetNextMessageTimeout(&msg, timeout); + if ( rc != 1 ) + return rc; + + ProcessMessage(&msg); + + return !m_shouldExit; +} + +#endif // wxUSE_CONSOLE_EVENTLOOP + +#endif //wxUSE_GUI