X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/51d78461fa34267925e31291e2371390611d0d0e..884a37aed25b5cdabcc6f9f7604878aa97ecb031:/src/msw/evtloop.cpp diff --git a/src/msw/evtloop.cpp b/src/msw/evtloop.cpp index 1909600fa7..d01f77b1b6 100644 --- a/src/msw/evtloop.cpp +++ b/src/msw/evtloop.cpp @@ -41,68 +41,21 @@ #include "wx/msw/private.h" -// For MB_TASKMODAL -#ifdef __WXWINCE__ -#include "wx/msw/wince/missing.h" -#endif - #if wxUSE_THREADS #include "wx/thread.h" - // define the array of MSG strutures - WX_DECLARE_OBJARRAY(MSG, wxMsgArray); + // define the list of MSG strutures + WX_DECLARE_LIST(MSG, wxMsgList); - #include "wx/arrimpl.cpp" + #include "wx/listimpl.cpp" - WX_DEFINE_OBJARRAY(wxMsgArray); + WX_DEFINE_LIST(wxMsgList); #endif // wxUSE_THREADS -// ---------------------------------------------------------------------------- -// wxEventLoopImpl -// ---------------------------------------------------------------------------- - -class WXDLLEXPORT wxEventLoopImpl -{ -public: - // ctor - wxEventLoopImpl() { m_exitcode = 0; m_shouldExit = false; } - - // 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 Exit(int exitcode) { m_exitcode = exitcode; m_shouldExit = true; } - int GetExitCode() const { return m_exitcode; } - bool ShouldExit() const { return m_shouldExit; } - - enum wxCatchAllResponse { - catch_continue, - catch_exit, - catch_rethrow - }; - wxCatchAllResponse OnCatchAll(); - -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; - - // true if we were asked to terminate - bool m_shouldExit; -}; - // ---------------------------------------------------------------------------- // helper class // ---------------------------------------------------------------------------- -wxDEFINE_TIED_SCOPED_PTR_TYPE(wxEventLoopImpl); - // this object sets the wxEventLoop given to the ctor as the currently active // one and unsets it in its dtor class wxEventLoopActivator @@ -128,14 +81,26 @@ private: }; // ============================================================================ -// wxEventLoopImpl implementation +// wxEventLoop implementation // ============================================================================ +wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL; + +// ---------------------------------------------------------------------------- +// ctor/dtor +// ---------------------------------------------------------------------------- + +wxEventLoop::wxEventLoop() +{ + m_shouldExit = false; + m_exitcode = 0; +} + // ---------------------------------------------------------------------------- -// wxEventLoopImpl message processing +// wxEventLoop message processing // ---------------------------------------------------------------------------- -void wxEventLoopImpl::ProcessMessage(MSG *msg) +void wxEventLoop::ProcessMessage(WXMSG *msg) { // give us the chance to preprocess the message first if ( !PreProcessMessage(msg) ) @@ -146,7 +111,7 @@ void wxEventLoopImpl::ProcessMessage(MSG *msg) } } -bool wxEventLoopImpl::PreProcessMessage(MSG *msg) +bool wxEventLoop::PreProcessMessage(WXMSG *msg) { HWND hwnd = msg->hwnd; wxWindow *wndThis = wxGetWindowFromHWND((WXHWND)hwnd); @@ -157,7 +122,7 @@ bool wxEventLoopImpl::PreProcessMessage(MSG *msg) if ( !wndThis ) { // we need to find the dialog containing this control as - // IsDialogMessage() just eats all the messages (i.e. returns TRUE for + // 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 ) { @@ -185,7 +150,7 @@ bool wxEventLoopImpl::PreProcessMessage(MSG *msg) // grab Ctrl-C/V/X, even if they are also accelerators in some parent) if ( !wndThis->MSWShouldPreProcessMessage((WXMSG *)msg) ) { - return FALSE; + return false; } // try translations first: the accelerators override everything @@ -194,7 +159,7 @@ bool wxEventLoopImpl::PreProcessMessage(MSG *msg) for ( wnd = wndThis; wnd; wnd = wnd->GetParent() ) { if ( wnd->MSWTranslateMessage((WXMSG *)msg)) - return TRUE; + 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 @@ -203,65 +168,33 @@ bool wxEventLoopImpl::PreProcessMessage(MSG *msg) break; } - // now try the other hooks (kbd navigation is handled here): we start from - // wndThis->GetParent() because wndThis->MSWProcessMessage() was already - // called above - for ( wnd = wndThis->GetParent(); wnd; wnd = wnd->GetParent() ) + // now try the other hooks (kbd navigation is handled here) + for ( wnd = wndThis; wnd; wnd = wnd->GetParent() ) { - if ( wnd->MSWProcessMessage((WXMSG *)msg) ) - return TRUE; + 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()) + break; } // no special preprocessing for this message, dispatch it normally - return FALSE; -} - -// ---------------------------------------------------------------------------- -// wxEventLoopImpl idle event processing -// ---------------------------------------------------------------------------- - -bool wxEventLoopImpl::SendIdleMessage() -{ - return wxTheApp->ProcessIdle(); -} - -// ---------------------------------------------------------------------------- -// wxEventLoopImpl exception handling -// ---------------------------------------------------------------------------- - -wxEventLoopImpl::wxCatchAllResponse wxEventLoopImpl::OnCatchAll() -{ - switch (::MessageBox(NULL, - _T("An unhandled exception occurred. 'Abort' will terminate the program,\r\n\ -'Retry' will close the current dialog, 'Ignore' will try to continue."), - _T("Unhandled exception"), - MB_ABORTRETRYIGNORE|MB_ICONERROR|MB_TASKMODAL)) - { - case IDABORT: return catch_rethrow; - case IDRETRY: return catch_exit; - case IDIGNORE: return catch_continue; - } - return catch_rethrow; + return false; } -// ============================================================================ -// wxEventLoop implementation -// ============================================================================ - -wxEventLoop *wxEventLoop::ms_activeLoop = NULL; - // ---------------------------------------------------------------------------- // wxEventLoop running and exiting // ---------------------------------------------------------------------------- -wxEventLoop::~wxEventLoop() -{ - wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") ); -} - bool wxEventLoop::IsRunning() const { - return m_impl != NULL; + return ms_activeLoop == this; } int wxEventLoop::Run() @@ -269,11 +202,10 @@ 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") ); - // SendIdleMessage() and Dispatch() below may throw so the code here should + // 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); - wxEventLoopImplTiedPtr impl(&m_impl, new wxEventLoopImpl); // 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 @@ -281,74 +213,80 @@ int wxEventLoop::Run() // wxModalEventLoop depends on this (so we can't just use ON_BLOCK_EXIT or // something similar here) #if wxUSE_EXCEPTIONS - bool retryAfterException = false; - do { - retryAfterException=false; -#endif - wxTRY + for ( ;; ) { - for ( ;; ) + try { - #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() && m_impl->SendIdleMessage() ) - ; - - // 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_impl->ShouldExit() ) +#endif // wxUSE_EXCEPTIONS + + // this is the event loop itself + for ( ;; ) { - while ( Pending() ) - Dispatch(); + #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; - } + 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; + // 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; } - } - wxCATCH_ALL( - switch (m_impl->OnCatchAll()) { - case wxEventLoopImpl::catch_continue: - retryAfterException=true; - break; - case wxEventLoopImpl::catch_exit: - OnExit(); - break; - case wxEventLoopImpl::catch_rethrow: + catch ( ... ) + { + try + { + if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() ) + { OnExit(); - // should be replaced with wx macro, but - // there is none yet. OTOH, wxCATCH_ALL isn't - // expanded unless wxUSE_EXCEPTIONS, so its - // safe to use throw here. - throw; - default: 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 wxUSE_EXCEPTIONS - } while (retryAfterException); -#endif +#endif // wxUSE_EXCEPTIONS - return m_impl->GetExitCode(); + return m_exitcode; } void wxEventLoop::Exit(int rc) { wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") ); - m_impl->Exit(rc); + m_exitcode = rc; + m_shouldExit = true; OnExit(); @@ -374,7 +312,7 @@ bool wxEventLoop::Pending() const bool wxEventLoop::Dispatch() { - wxCHECK_MSG( IsRunning(), FALSE, _T("can't call Dispatch() if not running") ); + wxCHECK_MSG( IsRunning(), false, _T("can't call Dispatch() if not running") ); MSG msg; BOOL rc = ::GetMessage(&msg, (HWND) NULL, 0, 0); @@ -382,7 +320,7 @@ bool wxEventLoop::Dispatch() if ( rc == 0 ) { // got WM_QUIT - return FALSE; + return false; } if ( rc == -1 ) @@ -391,31 +329,32 @@ bool wxEventLoop::Dispatch() wxLogLastError(wxT("GetMessage")); // still break from the loop - return FALSE; + return false; } #if wxUSE_THREADS wxASSERT_MSG( wxThread::IsMain(), wxT("only the main thread can process Windows messages") ); - static bool s_hadGuiLock = TRUE; - static wxMsgArray s_aSavedMessages; + static bool s_hadGuiLock = true; + static wxMsgList s_aSavedMessages; // 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() ) { - s_hadGuiLock = FALSE; + s_hadGuiLock = false; // leave out WM_COMMAND messages: too dangerous, sometimes // the message will be processed twice if ( !wxIsWaitingForThread() || msg.message != WM_COMMAND ) { - s_aSavedMessages.Add(msg); + MSG* pMsg = new MSG(msg); + s_aSavedMessages.Append(pMsg); } - return TRUE; + return true; } else { @@ -426,22 +365,25 @@ bool wxEventLoop::Dispatch() // messages normally - expect some things to break... if ( !s_hadGuiLock ) { - s_hadGuiLock = TRUE; + s_hadGuiLock = true; - size_t count = s_aSavedMessages.Count(); - for ( size_t n = 0; n < count; n++ ) + wxMsgList::compatibility_iterator node = s_aSavedMessages.GetFirst(); + while (node) { - MSG& msg = s_aSavedMessages[n]; - m_impl->ProcessMessage(&msg); - } + MSG* pMsg = node->GetData(); + s_aSavedMessages.Erase(node); - s_aSavedMessages.Empty(); + ProcessMessage(pMsg); + delete pMsg; + + node = s_aSavedMessages.GetFirst(); + } } } #endif // wxUSE_THREADS - m_impl->ProcessMessage(&msg); + ProcessMessage(&msg); - return TRUE; + return true; }