src/msw/evtloop.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/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 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #include "wx/evtloop.h"
  28
  29 #ifndef WX_PRECOMP
  30     #if wxUSE_GUI
  31         #include "wx/window.h"
  32     #endif
  33     #include "wx/app.h"
  34     #include "wx/log.h"
  35 #endif //WX_PRECOMP
  36
  37 #include "wx/thread.h"
  38 #include "wx/except.h"
  39 #include "wx/msw/private.h"
  40 #include "wx/scopeguard.h"
  41
  42 #if wxUSE_GUI
  43     #include "wx/tooltip.h"
  44     #if wxUSE_THREADS
  45         // define the list of MSG strutures
  46         WX_DECLARE_LIST(MSG, wxMsgList);
  47
  48         #include "wx/listimpl.cpp"
  49
  50         WX_DEFINE_LIST(wxMsgList)
  51     #endif // wxUSE_THREADS
  52 #endif //wxUSE_GUI
  53
  54 #if wxUSE_BASE
  55
  56 // ============================================================================
  57 // wxMSWEventLoopBase implementation
  58 // ============================================================================
  59
  60 // ----------------------------------------------------------------------------
  61 // ctor/dtor
  62 // ----------------------------------------------------------------------------
  63
  64 wxMSWEventLoopBase::wxMSWEventLoopBase()
  65 {
  66     m_shouldExit = false;
  67     m_exitcode = 0;
  68 }
  69
  70 // ----------------------------------------------------------------------------
  71 // wxEventLoop message processing dispatching
  72 // ----------------------------------------------------------------------------
  73
  74 bool wxMSWEventLoopBase::Pending() const
  75 {
  76     MSG msg;
  77     return ::PeekMessage(&msg, 0, 0, 0, PM_NOREMOVE) != 0;
  78 }
  79
  80 bool wxMSWEventLoopBase::GetNextMessage(WXMSG* msg)
  81 {
  82     const BOOL rc = ::GetMessage(msg, NULL, 0, 0);
  83
  84     if ( rc == 0 )
  85     {
  86         // got WM_QUIT
  87         return false;
  88     }
  89
  90     if ( rc == -1 )
  91     {
  92         // should never happen, but let's test for it nevertheless
  93         wxLogLastError(wxT("GetMessage"));
  94
  95         // still break from the loop
  96         return false;
  97     }
  98
  99     return true;
 100 }
 101
 102 int wxMSWEventLoopBase::GetNextMessageTimeout(WXMSG *msg, unsigned long timeout)
 103 {
 104     // MsgWaitForMultipleObjects() won't notice any input which was already
 105     // examined (e.g. using PeekMessage()) but not yet removed from the queue
 106     // so we need to remove any immediately messages manually
 107     //
 108     // NB: using MsgWaitForMultipleObjectsEx() could simplify the code here but
 109     //     it is not available in very old Windows versions
 110     if ( !::PeekMessage(msg, 0, 0, 0, PM_REMOVE) )
 111     {
 112         // we use this function just in order to not block longer than the
 113         // given timeout, so we don't pass any handles to it at all
 114         DWORD rc = ::MsgWaitForMultipleObjects
 115                      (
 116                         0, NULL,
 117                         FALSE,
 118                         timeout,
 119                         QS_ALLINPUT
 120                      );
 121
 122         switch ( rc )
 123         {
 124             default:
 125                 wxLogDebug("unexpected MsgWaitForMultipleObjects() return "
 126                            "value %lu", rc);
 127                 // fall through
 128
 129             case WAIT_TIMEOUT:
 130                 return -1;
 131
 132             case WAIT_OBJECT_0:
 133                 if ( !::PeekMessage(msg, 0, 0, 0, PM_REMOVE) )
 134                 {
 135                     // somehow it may happen that MsgWaitForMultipleObjects()
 136                     // returns true but there are no messages -- just treat it
 137                     // the same as timeout then
 138                     return -1;
 139                 }
 140                 break;
 141         }
 142     }
 143
 144     return msg->message != WM_QUIT;
 145 }
 146
 147
 148 #endif // wxUSE_BASE
 149
 150 #if wxUSE_GUI
 151
 152 // ============================================================================
 153 // GUI wxEventLoop implementation
 154 // ============================================================================
 155
 156 wxWindowMSW *wxGUIEventLoop::ms_winCritical = NULL;
 157
 158 bool wxGUIEventLoop::IsChildOfCriticalWindow(wxWindowMSW *win)
 159 {
 160     while ( win )
 161     {
 162         if ( win == ms_winCritical )
 163             return true;
 164
 165         win = win->GetParent();
 166     }
 167
 168     return false;
 169 }
 170
 171 bool wxGUIEventLoop::PreProcessMessage(WXMSG *msg)
 172 {
 173     HWND hwnd = msg->hwnd;
 174     wxWindow *wndThis = wxGetWindowFromHWND((WXHWND)hwnd);
 175     wxWindow *wnd;
 176
 177     // this might happen if we're in a modeless dialog, or if a wx control has
 178     // children which themselves were not created by wx (i.e. wxActiveX control children)
 179     if ( !wndThis )
 180     {
 181         while ( hwnd && (::GetWindowLong(hwnd, GWL_STYLE) & WS_CHILD ))
 182         {
 183             hwnd = ::GetParent(hwnd);
 184
 185             // If the control has a wx parent, break and give the parent a chance
 186             // to process the window message
 187             wndThis = wxGetWindowFromHWND((WXHWND)hwnd);
 188             if (wndThis != NULL)
 189                 break;
 190         }
 191
 192         if ( !wndThis )
 193         {
 194             // this may happen if the event occurred in a standard modeless dialog (the
 195             // only example of which I know of is the find/replace dialog) - then call
 196             // IsDialogMessage() to make TAB navigation in it work
 197
 198             // NOTE: IsDialogMessage() just eats all the messages (i.e. returns true for
 199             // them) if we call it for the control itself
 200             return hwnd && ::IsDialogMessage(hwnd, msg) != 0;
 201         }
 202     }
 203
 204     if ( !AllowProcessing(wndThis) )
 205     {
 206         // not a child of critical window, so we eat the event but take care to
 207         // stop an endless stream of WM_PAINTs which would have resulted if we
 208         // didn't validate the invalidated part of the window
 209         if ( msg->message == WM_PAINT )
 210             ::ValidateRect(hwnd, NULL);
 211
 212         return true;
 213     }
 214
 215 #if wxUSE_TOOLTIPS
 216     // we must relay WM_MOUSEMOVE events to the tooltip ctrl if we want it to
 217     // popup the tooltip bubbles
 218     if ( msg->message == WM_MOUSEMOVE )
 219     {
 220         // we should do it if one of window children has an associated tooltip
 221         // (and not just if the window has a tooltip itself)
 222         if ( wndThis->HasToolTips() )
 223             wxToolTip::RelayEvent((WXMSG *)msg);
 224     }
 225 #endif // wxUSE_TOOLTIPS
 226
 227     // allow the window to prevent certain messages from being
 228     // translated/processed (this is currently used by wxTextCtrl to always
 229     // grab Ctrl-C/V/X, even if they are also accelerators in some parent)
 230     if ( !wndThis->MSWShouldPreProcessMessage((WXMSG *)msg) )
 231     {
 232         return false;
 233     }
 234
 235     // try translations first: the accelerators override everything
 236     for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
 237     {
 238         if ( wnd->MSWTranslateMessage((WXMSG *)msg))
 239             return true;
 240
 241         // stop at first top level window, i.e. don't try to process the key
 242         // strokes originating in a dialog using the accelerators of the parent
 243         // frame - this doesn't make much sense
 244         if ( wnd->IsTopLevel() )
 245             break;
 246     }
 247
 248     // now try the other hooks (kbd navigation is handled here)
 249     for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
 250     {
 251         if ( wnd->MSWProcessMessage((WXMSG *)msg) )
 252             return true;
 253
 254         // also stop at first top level window here, just as above because
 255         // if we don't do this, pressing ESC on a modal dialog shown as child
 256         // of a modal dialog with wxID_CANCEL will cause the parent dialog to
 257         // be closed, for example
 258         if ( wnd->IsTopLevel() )
 259             break;
 260     }
 261
 262     // no special preprocessing for this message, dispatch it normally
 263     return false;
 264 }
 265
 266 void wxGUIEventLoop::ProcessMessage(WXMSG *msg)
 267 {
 268     // give us the chance to preprocess the message first
 269     if ( !PreProcessMessage(msg) )
 270     {
 271         // if it wasn't done, dispatch it to the corresponding window
 272         ::TranslateMessage(msg);
 273         ::DispatchMessage(msg);
 274     }
 275 }
 276
 277 bool wxGUIEventLoop::Dispatch()
 278 {
 279     MSG msg;
 280     if ( !GetNextMessage(&msg) )
 281         return false;
 282
 283 #if wxUSE_THREADS
 284     wxASSERT_MSG( wxThread::IsMain(),
 285                   wxT("only the main thread can process Windows messages") );
 286
 287     static bool s_hadGuiLock = true;
 288     static wxMsgList s_aSavedMessages;
 289
 290     // if a secondary thread owning the mutex is doing GUI calls, save all
 291     // messages for later processing - we can't process them right now because
 292     // it will lead to recursive library calls (and we're not reentrant)
 293     if ( !wxGuiOwnedByMainThread() )
 294     {
 295         s_hadGuiLock = false;
 296
 297         // leave out WM_COMMAND messages: too dangerous, sometimes
 298         // the message will be processed twice
 299         if ( !wxIsWaitingForThread() || msg.message != WM_COMMAND )
 300         {
 301             MSG* pMsg = new MSG(msg);
 302             s_aSavedMessages.Append(pMsg);
 303         }
 304
 305         return true;
 306     }
 307     else
 308     {
 309         // have we just regained the GUI lock? if so, post all of the saved
 310         // messages
 311         //
 312         // FIXME of course, it's not _exactly_ the same as processing the
 313         //       messages normally - expect some things to break...
 314         if ( !s_hadGuiLock )
 315         {
 316             s_hadGuiLock = true;
 317
 318             wxMsgList::compatibility_iterator node = s_aSavedMessages.GetFirst();
 319             while (node)
 320             {
 321                 MSG* pMsg = node->GetData();
 322                 s_aSavedMessages.Erase(node);
 323
 324                 ProcessMessage(pMsg);
 325                 delete pMsg;
 326
 327                 node = s_aSavedMessages.GetFirst();
 328             }
 329         }
 330     }
 331 #endif // wxUSE_THREADS
 332
 333     ProcessMessage(&msg);
 334
 335     return true;
 336 }
 337
 338 int wxGUIEventLoop::DispatchTimeout(unsigned long timeout)
 339 {
 340     MSG msg;
 341     int rc = GetNextMessageTimeout(&msg, timeout);
 342     if ( rc != 1 )
 343         return rc;
 344
 345     ProcessMessage(&msg);
 346
 347     return 1;
 348 }
 349
 350 void wxGUIEventLoop::OnNextIteration()
 351 {
 352 #if wxUSE_THREADS
 353     wxMutexGuiLeaveOrEnter();
 354 #endif // wxUSE_THREADS
 355 }
 356
 357 void wxGUIEventLoop::WakeUp()
 358 {
 359     ::PostMessage(NULL, WM_NULL, 0, 0);
 360 }
 361
 362
 363 // ----------------------------------------------------------------------------
 364 // Yield to incoming messages
 365 // ----------------------------------------------------------------------------
 366
 367 #include <wx/arrimpl.cpp>
 368 WX_DEFINE_OBJARRAY(wxMSGArray);
 369
 370 bool wxGUIEventLoop::YieldFor(long eventsToProcess)
 371 {
 372     // set the flag and don't forget to reset it before returning
 373     m_isInsideYield = true;
 374     m_eventsToProcessInsideYield = eventsToProcess;
 375
 376     wxON_BLOCK_EXIT_SET(m_isInsideYield, false);
 377
 378 #if wxUSE_LOG
 379     // disable log flushing from here because a call to wxYield() shouldn't
 380     // normally result in message boxes popping up &c
 381     wxLog::Suspend();
 382
 383     // ensure the logs will be flashed again when we exit
 384     wxON_BLOCK_EXIT0(wxLog::Resume);
 385 #endif // wxUSE_LOG
 386
 387     // we don't want to process WM_QUIT from here - it should be processed in
 388     // the main event loop in order to stop it
 389     MSG msg;
 390     int nPaintsReceived = 0;
 391     while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) &&
 392             msg.message != WM_QUIT )
 393     {
 394 #if wxUSE_THREADS
 395         wxMutexGuiLeaveOrEnter();
 396 #endif // wxUSE_THREADS
 397
 398         if (msg.message == WM_PAINT)
 399         {
 400             // NOTE: WM_PAINTs are categorized as wxEVT_CATEGORY_UI
 401             if ((eventsToProcess & wxEVT_CATEGORY_UI) == 0)
 402             {
 403                 // this msg is not going to be dispatched...
 404                 // however WM_PAINT is special: until there are damaged
 405                 // windows, Windows will keep sending it forever!
 406                 if (nPaintsReceived > 10)
 407                 {
 408                     // we got 10 WM_PAINT consecutive messages...
 409                     // we must have reached the tail of the message queue:
 410                     // we're now getting _only_ WM_PAINT events and this will
 411                     // continue forever (since we don't dispatch them
 412                     // because of the user-specified eventsToProcess mask)...
 413                     // break out of this loop!
 414                     break;
 415                 }
 416                 else
 417                     nPaintsReceived++;
 418             }
 419             //else: we're going to dispatch it below,
 420             //      so we don't need to take any special action
 421         }
 422         else
 423         {
 424             // reset the counter of consecutive WM_PAINT messages received:
 425             nPaintsReceived = 0;
 426         }
 427
 428         // choose a wxEventCategory for this Windows message
 429         bool processNow;
 430         switch (msg.message)
 431         {
 432 #if !defined(__WXWINCE__)
 433             case WM_NCMOUSEMOVE:
 434
 435             case WM_NCLBUTTONDOWN:
 436             case WM_NCLBUTTONUP:
 437             case WM_NCLBUTTONDBLCLK:
 438             case WM_NCRBUTTONDOWN:
 439             case WM_NCRBUTTONUP:
 440             case WM_NCRBUTTONDBLCLK:
 441             case WM_NCMBUTTONDOWN:
 442             case WM_NCMBUTTONUP:
 443             case WM_NCMBUTTONDBLCLK:
 444 #endif
 445
 446             case WM_KEYDOWN:
 447             case WM_KEYUP:
 448             case WM_CHAR:
 449             case WM_DEADCHAR:
 450             case WM_SYSKEYDOWN:
 451             case WM_SYSKEYUP:
 452             case WM_SYSCHAR:
 453             case WM_SYSDEADCHAR:
 454 #ifdef WM_UNICHAR
 455             case WM_UNICHAR:
 456 #endif
 457             case WM_HOTKEY:
 458             case WM_IME_STARTCOMPOSITION:
 459             case WM_IME_ENDCOMPOSITION:
 460             case WM_IME_COMPOSITION:
 461             case WM_COMMAND:
 462             case WM_SYSCOMMAND:
 463
 464             case WM_IME_SETCONTEXT:
 465             case WM_IME_NOTIFY:
 466             case WM_IME_CONTROL:
 467             case WM_IME_COMPOSITIONFULL:
 468             case WM_IME_SELECT:
 469             case WM_IME_CHAR:
 470             case WM_IME_KEYDOWN:
 471             case WM_IME_KEYUP:
 472
 473 #if !defined(__WXWINCE__)
 474             case WM_MOUSEHOVER:
 475             case WM_MOUSELEAVE:
 476 #endif
 477 #ifdef WM_NCMOUSELEAVE
 478             case WM_NCMOUSELEAVE:
 479 #endif
 480
 481             case WM_CUT:
 482             case WM_COPY:
 483             case WM_PASTE:
 484             case WM_CLEAR:
 485             case WM_UNDO:
 486
 487             case WM_MOUSEMOVE:
 488             case WM_LBUTTONDOWN:
 489             case WM_LBUTTONUP:
 490             case WM_LBUTTONDBLCLK:
 491             case WM_RBUTTONDOWN:
 492             case WM_RBUTTONUP:
 493             case WM_RBUTTONDBLCLK:
 494             case WM_MBUTTONDOWN:
 495             case WM_MBUTTONUP:
 496             case WM_MBUTTONDBLCLK:
 497             case WM_MOUSEWHEEL:
 498                 processNow = (eventsToProcess & wxEVT_CATEGORY_USER_INPUT) != 0;
 499                 break;
 500
 501             case WM_TIMER:
 502                 processNow = (eventsToProcess & wxEVT_CATEGORY_TIMER) != 0;
 503                 break;
 504
 505             default:
 506                 if (msg.message < WM_USER)
 507                 {
 508                     // 0;WM_USER-1 is the range of message IDs reserved for use
 509                     // by the system.
 510                     // there are too many of these types of messages to handle
 511                     // them in this switch
 512                     processNow = (eventsToProcess & wxEVT_CATEGORY_UI) != 0;
 513                 }
 514                 else
 515                 {
 516                     // Process all the unknown messages. We must do it because
 517                     // failure to process some of them can be fatal, e.g. if we
 518                     // don't dispatch WM_APP+2 then embedded IE ActiveX
 519                     // controls don't work any more, see #14027. And there may
 520                     // be more examples like this, so dispatch all unknown
 521                     // messages immediately to be safe.
 522                     processNow = true;
 523                 }
 524         }
 525
 526         // should we process this event now?
 527         if ( processNow )
 528         {
 529             if ( !wxTheApp->Dispatch() )
 530                 break;
 531         }
 532         else
 533         {
 534             // remove the message and store it
 535             ::GetMessage(&msg, NULL, 0, 0);
 536             m_arrMSG.Add(msg);
 537         }
 538     }
 539
 540     // if there are pending events, we must process them.
 541     if (wxTheApp)
 542         wxTheApp->ProcessPendingEvents();
 543
 544     // put back unprocessed events in the queue
 545     DWORD id = GetCurrentThreadId();
 546     for (size_t i=0; i<m_arrMSG.GetCount(); i++)
 547     {
 548         PostThreadMessage(id, m_arrMSG[i].message,
 549                           m_arrMSG[i].wParam, m_arrMSG[i].lParam);
 550     }
 551
 552     m_arrMSG.Clear();
 553
 554     return true;
 555 }
 556
 557
 558 #else // !wxUSE_GUI
 559
 560
 561 // ============================================================================
 562 // wxConsoleEventLoop implementation
 563 // ============================================================================
 564
 565 #if wxUSE_CONSOLE_EVENTLOOP
 566
 567 void wxConsoleEventLoop::WakeUp()
 568 {
 569 #if wxUSE_THREADS
 570     wxWakeUpMainThread();
 571 #endif
 572 }
 573
 574 void wxConsoleEventLoop::ProcessMessage(WXMSG *msg)
 575 {
 576     ::DispatchMessage(msg);
 577 }
 578
 579 bool wxConsoleEventLoop::Dispatch()
 580 {
 581     MSG msg;
 582     if ( !GetNextMessage(&msg) )
 583         return false;
 584
 585     ProcessMessage(&msg);
 586
 587     return !m_shouldExit;
 588 }
 589
 590 int wxConsoleEventLoop::DispatchTimeout(unsigned long timeout)
 591 {
 592     MSG msg;
 593     int rc = GetNextMessageTimeout(&msg, timeout);
 594     if ( rc != 1 )
 595         return rc;
 596
 597     ProcessMessage(&msg);
 598
 599     return !m_shouldExit;
 600 }
 601
 602 #endif // wxUSE_CONSOLE_EVENTLOOP
 603
 604 #endif //wxUSE_GUI