| 1 | /////////////////////////////////////////////////////////////////////////////// |
| 2 | // Name: os2/evtloop.cpp |
| 3 | // Purpose: implements wxEventLoop for PM |
| 4 | // Author: Vadim Zeitlin |
| 5 | // Modified by: |
| 6 | // Created: 01.06.01 |
| 7 | // RCS-ID: $Id$ |
| 8 | // Copyright: (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr> |
| 9 | // License: wxWindows license |
| 10 | /////////////////////////////////////////////////////////////////////////////// |
| 11 | |
| 12 | // ============================================================================ |
| 13 | // declarations |
| 14 | // ============================================================================ |
| 15 | |
| 16 | // ---------------------------------------------------------------------------- |
| 17 | // headers |
| 18 | // ---------------------------------------------------------------------------- |
| 19 | |
| 20 | #ifdef __GNUG__ |
| 21 | #pragma implementation "evtloop.h" |
| 22 | #endif |
| 23 | |
| 24 | // For compilers that support precompilation, includes "wx.h". |
| 25 | #include "wx/wxprec.h" |
| 26 | |
| 27 | #ifdef __BORLANDC__ |
| 28 | #pragma hdrstop |
| 29 | #endif |
| 30 | |
| 31 | #ifndef WX_PRECOMP |
| 32 | #include "wx/window.h" |
| 33 | #include "wx/app.h" |
| 34 | #endif //WX_PRECOMP |
| 35 | |
| 36 | #include "wx/evtloop.h" |
| 37 | #include "wx/tooltip.h" |
| 38 | |
| 39 | #include "wx/os2/private.h" |
| 40 | |
| 41 | #if wxUSE_THREADS |
| 42 | // define the array of QMSG strutures |
| 43 | WX_DECLARE_OBJARRAY(QMSG, wxMsgArray); |
| 44 | // VS: this is a bit dirty - it duplicates same declaration in app.cpp |
| 45 | // (and there's no WX_DEFINE_OBJARRAY for that reason - it is already |
| 46 | // defined in app.cpp). |
| 47 | #endif |
| 48 | |
| 49 | extern HAB vHabMain; |
| 50 | |
| 51 | // ---------------------------------------------------------------------------- |
| 52 | // wxEventLoopImpl |
| 53 | // ---------------------------------------------------------------------------- |
| 54 | |
| 55 | class WXDLLEXPORT wxEventLoopImpl |
| 56 | { |
| 57 | public: |
| 58 | // ctor |
| 59 | wxEventLoopImpl() { SetExitCode(0); } |
| 60 | |
| 61 | // process a message |
| 62 | void ProcessMessage(QMSG *msg); |
| 63 | |
| 64 | // generate an idle message, return TRUE if more idle time requested |
| 65 | bool SendIdleMessage(); |
| 66 | |
| 67 | // set/get the exit code |
| 68 | void SetExitCode(int exitcode) { m_exitcode = exitcode; } |
| 69 | int GetExitCode() const { return m_exitcode; } |
| 70 | |
| 71 | private: |
| 72 | // preprocess a message, return TRUE if processed (i.e. no further |
| 73 | // dispatching required) |
| 74 | bool PreProcessMessage(QMSG *msg); |
| 75 | |
| 76 | // the exit code of the event loop |
| 77 | int m_exitcode; |
| 78 | }; |
| 79 | |
| 80 | // ============================================================================ |
| 81 | // wxEventLoopImpl implementation |
| 82 | // ============================================================================ |
| 83 | |
| 84 | // ---------------------------------------------------------------------------- |
| 85 | // wxEventLoopImpl message processing |
| 86 | // ---------------------------------------------------------------------------- |
| 87 | |
| 88 | void wxEventLoopImpl::ProcessMessage(QMSG *msg) |
| 89 | { |
| 90 | // give us the chance to preprocess the message first |
| 91 | if ( !PreProcessMessage(msg) ) |
| 92 | { |
| 93 | // if it wasn't done, dispatch it to the corresponding window |
| 94 | ::WinDispatchMsg(vHabMain, msg); |
| 95 | } |
| 96 | } |
| 97 | |
| 98 | bool wxEventLoopImpl::PreProcessMessage(QMSG *msg) |
| 99 | { |
| 100 | HWND hWnd = msg->hwnd; |
| 101 | wxWindow *wndThis = wxFindWinFromHandle((WXHWND)hWnd); |
| 102 | |
| 103 | #if wxUSE_TOOLTIPS |
| 104 | // we must relay WM_MOUSEMOVE events to the tooltip ctrl if we want it to |
| 105 | // popup the tooltip bubbles |
| 106 | if ( wndThis && (msg->message == WM_MOUSEMOVE) ) |
| 107 | { |
| 108 | wxToolTip *tt = wndThis->GetToolTip(); |
| 109 | if ( tt ) |
| 110 | { |
| 111 | tt->RelayEvent((WXMSG *)msg); |
| 112 | } |
| 113 | } |
| 114 | #endif // wxUSE_TOOLTIPS |
| 115 | |
| 116 | // try translations first; find the youngest window with a translation |
| 117 | // table. |
| 118 | wxWindow *wnd; |
| 119 | for ( wnd = wndThis; wnd; wnd = wnd->GetParent() ) |
| 120 | { |
| 121 | if ( wnd->OS2TranslateMessage((WXMSG *)msg) ) |
| 122 | return TRUE; |
| 123 | } |
| 124 | |
| 125 | // Anyone for a non-translation message? Try youngest descendants first. |
| 126 | for ( wnd = wndThis; wnd; wnd = wnd->GetParent() ) |
| 127 | { |
| 128 | if ( wnd->OS2ProcessMessage((WXMSG *)msg) ) |
| 129 | return TRUE; |
| 130 | } |
| 131 | |
| 132 | return FALSE; |
| 133 | } |
| 134 | |
| 135 | // ---------------------------------------------------------------------------- |
| 136 | // wxEventLoopImpl idle event processing |
| 137 | // ---------------------------------------------------------------------------- |
| 138 | |
| 139 | bool wxEventLoopImpl::SendIdleMessage() |
| 140 | { |
| 141 | wxIdleEvent event; |
| 142 | |
| 143 | return wxTheApp->ProcessEvent(event) && event.MoreRequested(); |
| 144 | } |
| 145 | |
| 146 | // ============================================================================ |
| 147 | // wxEventLoop implementation |
| 148 | // ============================================================================ |
| 149 | |
| 150 | wxEventLoop *wxEventLoop::ms_activeLoop = NULL; |
| 151 | |
| 152 | // ---------------------------------------------------------------------------- |
| 153 | // wxEventLoop running and exiting |
| 154 | // ---------------------------------------------------------------------------- |
| 155 | |
| 156 | wxEventLoop::~wxEventLoop() |
| 157 | { |
| 158 | wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") ); |
| 159 | } |
| 160 | |
| 161 | bool wxEventLoop::IsRunning() const |
| 162 | { |
| 163 | return m_impl != NULL; |
| 164 | } |
| 165 | |
| 166 | int wxEventLoop::Run() |
| 167 | { |
| 168 | // event loops are not recursive, you need to create another loop! |
| 169 | wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") ); |
| 170 | |
| 171 | m_impl = new wxEventLoopImpl; |
| 172 | |
| 173 | wxEventLoop *oldLoop = ms_activeLoop; |
| 174 | ms_activeLoop = this; |
| 175 | |
| 176 | for ( ;; ) |
| 177 | { |
| 178 | #if wxUSE_THREADS |
| 179 | wxMutexGuiLeaveOrEnter(); |
| 180 | #endif // wxUSE_THREADS |
| 181 | |
| 182 | // generate and process idle events for as long as we don't have |
| 183 | // anything else to do |
| 184 | while ( !Pending() && m_impl->SendIdleMessage() ) |
| 185 | ; |
| 186 | |
| 187 | // a message came or no more idle processing to do, sit in Dispatch() |
| 188 | // waiting for the next message |
| 189 | if ( !Dispatch() ) |
| 190 | { |
| 191 | // we got WM_QUIT |
| 192 | break; |
| 193 | } |
| 194 | } |
| 195 | |
| 196 | int exitcode = m_impl->GetExitCode(); |
| 197 | delete m_impl; |
| 198 | m_impl = NULL; |
| 199 | |
| 200 | ms_activeLoop = oldLoop; |
| 201 | |
| 202 | return exitcode; |
| 203 | } |
| 204 | |
| 205 | void wxEventLoop::Exit(int rc) |
| 206 | { |
| 207 | wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") ); |
| 208 | |
| 209 | m_impl->SetExitCode(rc); |
| 210 | |
| 211 | ::WinPostMsg(NULL, WM_QUIT, 0, 0); |
| 212 | } |
| 213 | |
| 214 | // ---------------------------------------------------------------------------- |
| 215 | // wxEventLoop message processing dispatching |
| 216 | // ---------------------------------------------------------------------------- |
| 217 | |
| 218 | bool wxEventLoop::Pending() const |
| 219 | { |
| 220 | QMSG msg; |
| 221 | return ::WinPeekMsg(vHabMain, &msg, 0, 0, 0, PM_NOREMOVE) != 0; |
| 222 | } |
| 223 | |
| 224 | bool wxEventLoop::Dispatch() |
| 225 | { |
| 226 | wxCHECK_MSG( IsRunning(), FALSE, _T("can't call Dispatch() if not running") ); |
| 227 | |
| 228 | QMSG msg; |
| 229 | BOOL rc = ::WinGetMsg(vHabMain, &msg, (HWND) NULL, 0, 0); |
| 230 | |
| 231 | if ( rc == 0 ) |
| 232 | { |
| 233 | // got WM_QUIT |
| 234 | return FALSE; |
| 235 | } |
| 236 | |
| 237 | if ( rc == -1 ) |
| 238 | { |
| 239 | // should never happen, but let's test for it nevertheless |
| 240 | wxLogLastError(wxT("GetMessage")); |
| 241 | |
| 242 | // still break from the loop |
| 243 | return FALSE; |
| 244 | } |
| 245 | |
| 246 | #if wxUSE_THREADS |
| 247 | wxASSERT_MSG( wxThread::IsMain(), |
| 248 | wxT("only the main thread can process Windows messages") ); |
| 249 | |
| 250 | static bool s_hadGuiLock = TRUE; |
| 251 | static wxMsgArray s_aSavedMessages; |
| 252 | |
| 253 | // if a secondary thread owning the mutex is doing GUI calls, save all |
| 254 | // messages for later processing - we can't process them right now because |
| 255 | // it will lead to recursive library calls (and we're not reentrant) |
| 256 | if ( !wxGuiOwnedByMainThread() ) |
| 257 | { |
| 258 | s_hadGuiLock = FALSE; |
| 259 | |
| 260 | // leave out WM_COMMAND messages: too dangerous, sometimes |
| 261 | // the message will be processed twice |
| 262 | if ( !wxIsWaitingForThread() || msg.message != WM_COMMAND ) |
| 263 | { |
| 264 | s_aSavedMessages.Add(msg); |
| 265 | } |
| 266 | |
| 267 | return TRUE; |
| 268 | } |
| 269 | else |
| 270 | { |
| 271 | // have we just regained the GUI lock? if so, post all of the saved |
| 272 | // messages |
| 273 | // |
| 274 | // FIXME of course, it's not _exactly_ the same as processing the |
| 275 | // messages normally - expect some things to break... |
| 276 | if ( !s_hadGuiLock ) |
| 277 | { |
| 278 | s_hadGuiLock = TRUE; |
| 279 | |
| 280 | size_t count = s_aSavedMessages.Count(); |
| 281 | for ( size_t n = 0; n < count; n++ ) |
| 282 | { |
| 283 | MSG& msg = s_aSavedMessages[n]; |
| 284 | m_impl->ProcessMessage(&msg); |
| 285 | } |
| 286 | |
| 287 | s_aSavedMessages.Empty(); |
| 288 | } |
| 289 | } |
| 290 | #endif // wxUSE_THREADS |
| 291 | |
| 292 | m_impl->ProcessMessage(&msg); |
| 293 | |
| 294 | return TRUE; |
| 295 | } |
| 296 | |