X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/a6c7a0f826d5e156c177b4755365c3eb33e9b933..dd9f8b6bb6935360a8271dc3e8749fb026b601a8:/src/msw/evtloop.cpp diff --git a/src/msw/evtloop.cpp b/src/msw/evtloop.cpp index 1d52ec45f3..601b8b870b 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" @@ -29,142 +25,145 @@ #endif #ifndef WX_PRECOMP - #include "wx/window.h" + #if wxUSE_GUI + #include "wx/window.h" + #endif #include "wx/app.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" -// For MB_TASKMODAL -#ifdef __WXWINCE__ -#include "wx/msw/wince/missing.h" -#endif +#if wxUSE_GUI + #include "wx/tooltip.h" + #if wxUSE_THREADS + // define the list of MSG strutures + WX_DECLARE_LIST(MSG, wxMsgList); -#if wxUSE_THREADS - #include "wx/thread.h" + #include "wx/listimpl.cpp" - // define the array of MSG strutures - WX_DECLARE_OBJARRAY(MSG, wxMsgArray); + WX_DEFINE_LIST(wxMsgList) + #endif // wxUSE_THREADS +#endif //wxUSE_GUI - #include "wx/arrimpl.cpp" +#if wxUSE_BASE - WX_DEFINE_OBJARRAY(wxMsgArray); -#endif // wxUSE_THREADS +// ============================================================================ +// wxMSWEventLoopBase implementation +// ============================================================================ // ---------------------------------------------------------------------------- -// wxEventLoopImpl +// ctor/dtor // ---------------------------------------------------------------------------- -class WXDLLEXPORT wxEventLoopImpl +wxMSWEventLoopBase::wxMSWEventLoopBase() { -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; -}; + m_shouldExit = false; + m_exitcode = 0; +} // ---------------------------------------------------------------------------- -// helper class +// wxEventLoop message processing dispatching // ---------------------------------------------------------------------------- -wxDEFINE_TIED_SCOPED_PTR_TYPE(wxEventLoopImpl); +bool wxMSWEventLoopBase::Pending() const +{ + MSG msg; + return ::PeekMessage(&msg, 0, 0, 0, PM_NOREMOVE) != 0; +} -// this object sets the wxEventLoop given to the ctor as the currently active -// one and unsets it in its dtor -class wxEventLoopActivator +bool wxMSWEventLoopBase::GetNextMessage(WXMSG* msg) { -public: - wxEventLoopActivator(wxEventLoop **pActive, - wxEventLoop *evtLoop) + wxCHECK_MSG( IsRunning(), false, _T("can't get messages if not running") ); + + const BOOL rc = ::GetMessage(msg, NULL, 0, 0); + + if ( rc == 0 ) { - m_pActive = pActive; - m_evtLoopOld = *pActive; - *pActive = evtLoop; + // got WM_QUIT + return false; } - ~wxEventLoopActivator() + if ( rc == -1 ) { - // restore the previously active event loop - *m_pActive = m_evtLoopOld; + // should never happen, but let's test for it nevertheless + wxLogLastError(wxT("GetMessage")); + + // still break from the loop + return false; } -private: - wxEventLoop *m_evtLoopOld; - wxEventLoop **m_pActive; -}; + return true; +} + +#endif // wxUSE_BASE + +#if wxUSE_GUI // ============================================================================ -// 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); + wxWindow *wnd; - // this may happen if the event occured 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) ) + { + // 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 @@ -172,11 +171,10 @@ bool wxEventLoopImpl::PreProcessMessage(MSG *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 @@ -185,16 +183,14 @@ 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 - wxWindow *wnd; - 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,218 +199,64 @@ 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; - } - - // no special preprocessing for this message, dispatch it normally - return FALSE; -} - -// ---------------------------------------------------------------------------- -// wxEventLoopImpl idle event processing -// ---------------------------------------------------------------------------- + return true; -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; + // 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 catch_rethrow; -} -// ============================================================================ -// 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; + // no special preprocessing for this message, dispatch it normally + return false; } -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") ); - - // SendIdleMessage() 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 - // 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 - bool retryAfterException = false; - do { - retryAfterException=false; -#endif - wxTRY + // give us the chance to preprocess the message first + if ( !PreProcessMessage(msg) ) { - 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() && 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() ) - { - 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; - } - } - } - wxCATCH_ALL( - switch (m_impl->OnCatchAll()) { - case wxEventLoopImpl::catch_continue: - retryAfterException=true; - break; - case wxEventLoopImpl::catch_exit: - OnExit(); - break; - case wxEventLoopImpl::catch_rethrow: - 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; - break; + // if it wasn't done, dispatch it to the corresponding window + ::TranslateMessage(msg); + ::DispatchMessage(msg); } - ) -#if wxUSE_EXCEPTIONS - } while (retryAfterException); -#endif - - return m_impl->GetExitCode(); -} - -void wxEventLoop::Exit(int rc) -{ - wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") ); - - m_impl->Exit(rc); - - 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() +bool wxGUIEventLoop::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 - 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 ( !GetNextMessage(&msg) ) + 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 { @@ -425,22 +267,77 @@ 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; +} + +void wxGUIEventLoop::OnNextIteration() +{ +#if wxUSE_THREADS + wxMutexGuiLeaveOrEnter(); +#endif // wxUSE_THREADS +} + +void wxGUIEventLoop::WakeUp() +{ + ::PostMessage(NULL, WM_NULL, 0, 0); +} + +#else // !wxUSE_GUI + +#if wxUSE_CONSOLE_EVENTLOOP + +void wxConsoleEventLoop::OnNextIteration() +{ + if ( wxTheApp ) + wxTheApp->ProcessPendingEvents(); +} + +void wxConsoleEventLoop::WakeUp() +{ +#if wxUSE_THREADS + wxWakeUpMainThread(); +#endif +} + +bool wxConsoleEventLoop::Dispatch() +{ + MSG msg; + if ( !GetNextMessage(&msg) ) + return false; - return TRUE; + if ( msg.message == WM_TIMER ) + { + TIMERPROC proc = (TIMERPROC)msg.lParam; + if ( proc ) + (*proc)(NULL, 0, msg.wParam, 0); + } + else + { + ::DispatchMessage(&msg); + } + + return !m_shouldExit; } +#endif // wxUSE_CONSOLE_EVENTLOOP + +#endif //wxUSE_GUI