src/msw/evtloop.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/evtloop.cpp
   3 // Purpose:     implements wxEventLoop for MSW
   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 licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  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
  38 #include "wx/tooltip.h"
  39 #include "wx/except.h"
  40 #include "wx/ptr_scpd.h"
  41
  42 #include "wx/msw/private.h"
  43
  44 #if wxUSE_THREADS
  45     #include "wx/thread.h"
  46
  47     // define the list of MSG strutures
  48     WX_DECLARE_LIST(MSG, wxMsgList);
  49
  50     #include "wx/listimpl.cpp"
  51
  52     WX_DEFINE_LIST(wxMsgList);
  53 #endif // wxUSE_THREADS
  54
  55 // ----------------------------------------------------------------------------
  56 // helper class
  57 // ----------------------------------------------------------------------------
  58
  59 // this object sets the wxEventLoop given to the ctor as the currently active
  60 // one and unsets it in its dtor
  61 class wxEventLoopActivator
  62 {
  63 public:
  64     wxEventLoopActivator(wxEventLoop **pActive,
  65                          wxEventLoop *evtLoop)
  66     {
  67         m_pActive = pActive;
  68         m_evtLoopOld = *pActive;
  69         *pActive = evtLoop;
  70     }
  71
  72     ~wxEventLoopActivator()
  73     {
  74         // restore the previously active event loop
  75         *m_pActive = m_evtLoopOld;
  76     }
  77
  78 private:
  79     wxEventLoop *m_evtLoopOld;
  80     wxEventLoop **m_pActive;
  81 };
  82
  83 // ============================================================================
  84 // wxEventLoop implementation
  85 // ============================================================================
  86
  87 wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL;
  88 wxWindowMSW *wxEventLoop::ms_winCritical = NULL;
  89
  90 // ----------------------------------------------------------------------------
  91 // ctor/dtor
  92 // ----------------------------------------------------------------------------
  93
  94 wxEventLoop::wxEventLoop()
  95 {
  96     m_shouldExit = false;
  97     m_exitcode = 0;
  98 }
  99
 100 // ----------------------------------------------------------------------------
 101 // wxEventLoop message processing
 102 // ----------------------------------------------------------------------------
 103
 104 void wxEventLoop::ProcessMessage(WXMSG *msg)
 105 {
 106     // give us the chance to preprocess the message first
 107     if ( !PreProcessMessage(msg) )
 108     {
 109         // if it wasn't done, dispatch it to the corresponding window
 110         ::TranslateMessage(msg);
 111         ::DispatchMessage(msg);
 112     }
 113 }
 114
 115 bool wxEventLoop::IsChildOfCriticalWindow(wxWindowMSW *win)
 116 {
 117     while ( win )
 118     {
 119         if ( win == ms_winCritical )
 120             return true;
 121
 122         win = win->GetParent();
 123     }
 124
 125     return false;
 126 }
 127
 128 bool wxEventLoop::PreProcessMessage(WXMSG *msg)
 129 {
 130     HWND hwnd = msg->hwnd;
 131     wxWindow * const wndThis = wxGetWindowFromHWND((WXHWND)hwnd);
 132     wxWindow *wnd;
 133
 134     // this may happen if the event occurred in a standard modeless dialog (the
 135     // only example of which I know of is the find/replace dialog) - then call
 136     // IsDialogMessage() to make TAB navigation in it work
 137     if ( !wndThis )
 138     {
 139         // we need to find the dialog containing this control as
 140         // IsDialogMessage() just eats all the messages (i.e. returns true for
 141         // them) if we call it for the control itself
 142         while ( hwnd && ::GetWindowLong(hwnd, GWL_STYLE) & WS_CHILD )
 143         {
 144             hwnd = ::GetParent(hwnd);
 145         }
 146
 147         return hwnd && ::IsDialogMessage(hwnd, msg) != 0;
 148     }
 149
 150     if ( !AllowProcessing(wndThis) )
 151     {
 152         // not a child of critical window, so we eat the event but take care to
 153         // stop an endless stream of WM_PAINTs which would have resulted if we
 154         // didn't validate the invalidated part of the window
 155         if ( msg->message == WM_PAINT )
 156             ::ValidateRect(hwnd, NULL);
 157
 158         return true;
 159     }
 160
 161 #if wxUSE_TOOLTIPS
 162     // we must relay WM_MOUSEMOVE events to the tooltip ctrl if we want it to
 163     // popup the tooltip bubbles
 164     if ( msg->message == WM_MOUSEMOVE )
 165     {
 166         wxToolTip *tt = wndThis->GetToolTip();
 167         if ( tt )
 168         {
 169             tt->RelayEvent((WXMSG *)msg);
 170         }
 171     }
 172 #endif // wxUSE_TOOLTIPS
 173
 174     // allow the window to prevent certain messages from being
 175     // translated/processed (this is currently used by wxTextCtrl to always
 176     // grab Ctrl-C/V/X, even if they are also accelerators in some parent)
 177     if ( !wndThis->MSWShouldPreProcessMessage((WXMSG *)msg) )
 178     {
 179         return false;
 180     }
 181
 182     // try translations first: the accelerators override everything
 183     for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
 184     {
 185         if ( wnd->MSWTranslateMessage((WXMSG *)msg))
 186             return true;
 187
 188         // stop at first top level window, i.e. don't try to process the key
 189         // strokes originating in a dialog using the accelerators of the parent
 190         // frame - this doesn't make much sense
 191         if ( wnd->IsTopLevel() )
 192             break;
 193     }
 194
 195     // now try the other hooks (kbd navigation is handled here)
 196     for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
 197     {
 198         if (wnd != wndThis) // Skip the first since wndThis->MSWProcessMessage() was called above
 199         {
 200             if ( wnd->MSWProcessMessage((WXMSG *)msg) )
 201                 return true;
 202         }
 203
 204         // Stop at first top level window (as per comment above).
 205         // If we don't do this, pressing ESC on a modal dialog shown as child of a modal
 206         // dialog with wxID_CANCEL will cause the parent dialog to be closed, for example
 207         if (wnd->IsTopLevel())
 208             break;
 209     }
 210
 211     // no special preprocessing for this message, dispatch it normally
 212     return false;
 213 }
 214
 215 // ----------------------------------------------------------------------------
 216 // wxEventLoop running and exiting
 217 // ----------------------------------------------------------------------------
 218
 219 bool wxEventLoop::IsRunning() const
 220 {
 221     return ms_activeLoop == this;
 222 }
 223
 224 int wxEventLoop::Run()
 225 {
 226     // event loops are not recursive, you need to create another loop!
 227     wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
 228
 229     // ProcessIdle() and Dispatch() below may throw so the code here should
 230     // be exception-safe, hence we must use local objects for all actions we
 231     // should undo
 232     wxEventLoopActivator activate(&ms_activeLoop, this);
 233
 234     // we must ensure that OnExit() is called even if an exception is thrown
 235     // from inside Dispatch() but we must call it from Exit() in normal
 236     // situations because it is supposed to be called synchronously,
 237     // wxModalEventLoop depends on this (so we can't just use ON_BLOCK_EXIT or
 238     // something similar here)
 239 #if wxUSE_EXCEPTIONS
 240     for ( ;; )
 241     {
 242         try
 243         {
 244 #endif // wxUSE_EXCEPTIONS
 245
 246             // this is the event loop itself
 247             for ( ;; )
 248             {
 249                 #if wxUSE_THREADS
 250                     wxMutexGuiLeaveOrEnter();
 251                 #endif // wxUSE_THREADS
 252
 253                 // generate and process idle events for as long as we don't
 254                 // have anything else to do
 255                 while ( !Pending() && (wxTheApp && wxTheApp->ProcessIdle()) )
 256                     ;
 257
 258                 // if the "should exit" flag is set, the loop should terminate
 259                 // but not before processing any remaining messages so while
 260                 // Pending() returns true, do process them
 261                 if ( m_shouldExit )
 262                 {
 263                     while ( Pending() )
 264                         Dispatch();
 265
 266                     break;
 267                 }
 268
 269                 // a message came or no more idle processing to do, sit in
 270                 // Dispatch() waiting for the next message
 271                 if ( !Dispatch() )
 272                 {
 273                     // we got WM_QUIT
 274                     break;
 275                 }
 276             }
 277
 278 #if wxUSE_EXCEPTIONS
 279             // exit the outer loop as well
 280             break;
 281         }
 282         catch ( ... )
 283         {
 284             try
 285             {
 286                 if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() )
 287                 {
 288                     OnExit();
 289                     break;
 290                 }
 291                 //else: continue running the event loop
 292             }
 293             catch ( ... )
 294             {
 295                 // OnException() throwed, possibly rethrowing the same
 296                 // exception again: very good, but we still need OnExit() to
 297                 // be called
 298                 OnExit();
 299                 throw;
 300             }
 301         }
 302     }
 303 #endif // wxUSE_EXCEPTIONS
 304
 305     return m_exitcode;
 306 }
 307
 308 void wxEventLoop::Exit(int rc)
 309 {
 310     wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
 311
 312     m_exitcode = rc;
 313     m_shouldExit = true;
 314
 315     OnExit();
 316
 317     // all we have to do to exit from the loop is to (maybe) wake it up so that
 318     // it can notice that Exit() had been called
 319     //
 320     // in particular, we do *not* use PostQuitMessage() here because we're not
 321     // sure that WM_QUIT is going to be processed by the correct event loop: it
 322     // is possible that another one is started before this one has a chance to
 323     // process WM_QUIT
 324     ::PostMessage(NULL, WM_NULL, 0, 0);
 325 }
 326
 327 // ----------------------------------------------------------------------------
 328 // wxEventLoop message processing dispatching
 329 // ----------------------------------------------------------------------------
 330
 331 bool wxEventLoop::Pending() const
 332 {
 333     MSG msg;
 334     return ::PeekMessage(&msg, 0, 0, 0, PM_NOREMOVE) != 0;
 335 }
 336
 337 bool wxEventLoop::Dispatch()
 338 {
 339     wxCHECK_MSG( IsRunning(), false, _T("can't call Dispatch() if not running") );
 340
 341     MSG msg;
 342     BOOL rc = ::GetMessage(&msg, (HWND) NULL, 0, 0);
 343
 344     if ( rc == 0 )
 345     {
 346         // got WM_QUIT
 347         return false;
 348     }
 349
 350     if ( rc == -1 )
 351     {
 352         // should never happen, but let's test for it nevertheless
 353         wxLogLastError(wxT("GetMessage"));
 354
 355         // still break from the loop
 356         return false;
 357     }
 358
 359 #if wxUSE_THREADS
 360     wxASSERT_MSG( wxThread::IsMain(),
 361                   wxT("only the main thread can process Windows messages") );
 362
 363     static bool s_hadGuiLock = true;
 364     static wxMsgList s_aSavedMessages;
 365
 366     // if a secondary thread owning the mutex is doing GUI calls, save all
 367     // messages for later processing - we can't process them right now because
 368     // it will lead to recursive library calls (and we're not reentrant)
 369     if ( !wxGuiOwnedByMainThread() )
 370     {
 371         s_hadGuiLock = false;
 372
 373         // leave out WM_COMMAND messages: too dangerous, sometimes
 374         // the message will be processed twice
 375         if ( !wxIsWaitingForThread() || msg.message != WM_COMMAND )
 376         {
 377             MSG* pMsg = new MSG(msg);
 378             s_aSavedMessages.Append(pMsg);
 379         }
 380
 381         return true;
 382     }
 383     else
 384     {
 385         // have we just regained the GUI lock? if so, post all of the saved
 386         // messages
 387         //
 388         // FIXME of course, it's not _exactly_ the same as processing the
 389         //       messages normally - expect some things to break...
 390         if ( !s_hadGuiLock )
 391         {
 392             s_hadGuiLock = true;
 393
 394             wxMsgList::compatibility_iterator node = s_aSavedMessages.GetFirst();
 395             while (node)
 396             {
 397                 MSG* pMsg = node->GetData();
 398                 s_aSavedMessages.Erase(node);
 399
 400                 ProcessMessage(pMsg);
 401                 delete pMsg;
 402
 403                 node = s_aSavedMessages.GetFirst();
 404             }
 405         }
 406     }
 407 #endif // wxUSE_THREADS
 408
 409     ProcessMessage(&msg);
 410
 411     return true;
 412 }
 413