src/os2/evtloop.cpp

   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 licence
  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     bool processed = wxTheApp->ProcessEvent(event) ;
 144
 145     wxUpdateUIEvent::ResetUpdateTime();
 146
 147     return processed && event.MoreRequested();
 148 }
 149
 150 // ============================================================================
 151 // wxEventLoop implementation
 152 // ============================================================================
 153
 154 wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
 155
 156 // ----------------------------------------------------------------------------
 157 // wxEventLoop running and exiting
 158 // ----------------------------------------------------------------------------
 159
 160 wxEventLoop::~wxEventLoop()
 161 {
 162     wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
 163 }
 164
 165 bool wxEventLoop::IsRunning() const
 166 {
 167     return m_impl != NULL;
 168 }
 169
 170 int wxEventLoop::Run()
 171 {
 172     // event loops are not recursive, you need to create another loop!
 173     wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
 174
 175     m_impl = new wxEventLoopImpl;
 176
 177     wxEventLoop *oldLoop = ms_activeLoop;
 178     ms_activeLoop = this;
 179
 180     for ( ;; )
 181     {
 182 #if wxUSE_THREADS
 183         wxMutexGuiLeaveOrEnter();
 184 #endif // wxUSE_THREADS
 185
 186         // generate and process idle events for as long as we don't have
 187         // anything else to do
 188         while ( !Pending() && m_impl->SendIdleMessage() )
 189             ;
 190
 191         // a message came or no more idle processing to do, sit in Dispatch()
 192         // waiting for the next message
 193         if ( !Dispatch() )
 194         {
 195             // we got WM_QUIT
 196             break;
 197         }
 198     }
 199
 200     int exitcode = m_impl->GetExitCode();
 201     delete m_impl;
 202     m_impl = NULL;
 203
 204     ms_activeLoop = oldLoop;
 205
 206     return exitcode;
 207 }
 208
 209 void wxEventLoop::Exit(int rc)
 210 {
 211     wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
 212
 213     m_impl->SetExitCode(rc);
 214
 215     ::WinPostMsg(NULL, WM_QUIT, 0, 0);
 216 }
 217
 218 // ----------------------------------------------------------------------------
 219 // wxEventLoop message processing dispatching
 220 // ----------------------------------------------------------------------------
 221
 222 bool wxEventLoop::Pending() const
 223 {
 224     QMSG msg;
 225     return ::WinPeekMsg(vHabMain, &msg, 0, 0, 0, PM_NOREMOVE) != 0;
 226 }
 227
 228 bool wxEventLoop::Dispatch()
 229 {
 230     wxCHECK_MSG( IsRunning(), FALSE, _T("can't call Dispatch() if not running") );
 231
 232     QMSG msg;
 233     BOOL rc = ::WinGetMsg(vHabMain, &msg, (HWND) NULL, 0, 0);
 234
 235     if ( rc == 0 )
 236     {
 237         // got WM_QUIT
 238         return FALSE;
 239     }
 240
 241     if ( rc == -1 )
 242     {
 243         // should never happen, but let's test for it nevertheless
 244         wxLogLastError(wxT("GetMessage"));
 245
 246         // still break from the loop
 247         return FALSE;
 248     }
 249
 250 #if wxUSE_THREADS
 251     wxASSERT_MSG( wxThread::IsMain(),
 252                   wxT("only the main thread can process Windows messages") );
 253
 254     static bool s_hadGuiLock = TRUE;
 255     static wxMsgArray s_aSavedMessages;
 256
 257     // if a secondary thread owning the mutex is doing GUI calls, save all
 258     // messages for later processing - we can't process them right now because
 259     // it will lead to recursive library calls (and we're not reentrant)
 260     if ( !wxGuiOwnedByMainThread() )
 261     {
 262         s_hadGuiLock = FALSE;
 263
 264         // leave out WM_COMMAND messages: too dangerous, sometimes
 265         // the message will be processed twice
 266         if ( !wxIsWaitingForThread() || msg.message != WM_COMMAND )
 267         {
 268             s_aSavedMessages.Add(msg);
 269         }
 270
 271         return TRUE;
 272     }
 273     else
 274     {
 275         // have we just regained the GUI lock? if so, post all of the saved
 276         // messages
 277         //
 278         // FIXME of course, it's not _exactly_ the same as processing the
 279         //       messages normally - expect some things to break...
 280         if ( !s_hadGuiLock )
 281         {
 282             s_hadGuiLock = TRUE;
 283
 284             size_t count = s_aSavedMessages.Count();
 285             for ( size_t n = 0; n < count; n++ )
 286             {
 287                 MSG& msg = s_aSavedMessages[n];
 288                 m_impl->ProcessMessage(&msg);
 289             }
 290
 291             s_aSavedMessages.Empty();
 292         }
 293     }
 294 #endif // wxUSE_THREADS
 295
 296     m_impl->ProcessMessage(&msg);
 297
 298     return TRUE;
 299 }
 300