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     #include "wx/timer.h"
  35 #endif //WX_PRECOMP
  36
  37 #include "wx/evtloop.h"
  38 #include "wx/log.h"
  39 #include "wx/tooltip.h"
  40 #include "wx/ptr_scpd.h"
  41
  42 #include "wx/os2/private.h"
  43
  44 #if wxUSE_THREADS
  45     // define the array of QMSG strutures
  46     WX_DECLARE_OBJARRAY(QMSG, wxMsgArray);
  47
  48     #include "wx/arrimpl.cpp"
  49
  50     WX_DEFINE_OBJARRAY(wxMsgArray);
  51 #endif
  52
  53 extern HAB vHabmain;
  54
  55 // ----------------------------------------------------------------------------
  56 // wxEventLoopImpl
  57 // ----------------------------------------------------------------------------
  58
  59 class WXDLLEXPORT wxEventLoopImpl
  60 {
  61 public:
  62     // ctor
  63     wxEventLoopImpl() { SetExitCode(0); }
  64
  65     // process a message
  66     void ProcessMessage(QMSG *msg);
  67
  68     // generate an idle message, return TRUE if more idle time requested
  69     bool SendIdleMessage();
  70
  71     // set/get the exit code
  72     void SetExitCode(int exitcode) { m_exitcode = exitcode; }
  73     int GetExitCode() const { return m_exitcode; }
  74
  75 private:
  76     // preprocess a message, return TRUE if processed (i.e. no further
  77     // dispatching required)
  78     bool PreProcessMessage(QMSG *msg);
  79
  80     // the exit code of the event loop
  81     int m_exitcode;
  82 };
  83
  84 // ----------------------------------------------------------------------------
  85 // helper class
  86 // ----------------------------------------------------------------------------
  87
  88 wxDEFINE_TIED_SCOPED_PTR_TYPE(wxEventLoopImpl);
  89
  90 // this object sets the wxEventLoop given to the ctor as the currently active
  91 // one and unsets it in its dtor
  92 class wxEventLoopActivator
  93 {
  94 public:
  95     wxEventLoopActivator(wxEventLoop **pActive,
  96                          wxEventLoop *evtLoop)
  97     {
  98         m_pActive = pActive;
  99         m_evtLoopOld = *pActive;
 100         *pActive = evtLoop;
 101     }
 102
 103     ~wxEventLoopActivator()
 104     {
 105         // restore the previously active event loop
 106         *m_pActive = m_evtLoopOld;
 107     }
 108
 109 private:
 110     wxEventLoop *m_evtLoopOld;
 111     wxEventLoop **m_pActive;
 112 };
 113
 114 // ============================================================================
 115 // wxEventLoopImpl implementation
 116 // ============================================================================
 117
 118 // ----------------------------------------------------------------------------
 119 // wxEventLoopImpl message processing
 120 // ----------------------------------------------------------------------------
 121
 122 void wxEventLoopImpl::ProcessMessage(QMSG *msg)
 123 {
 124     // give us the chance to preprocess the message first
 125     if ( !PreProcessMessage(msg) )
 126     {
 127         // if it wasn't done, dispatch it to the corresponding window
 128         ::WinDispatchMsg(vHabmain, msg);
 129     }
 130 }
 131
 132 bool wxEventLoopImpl::PreProcessMessage(QMSG *pMsg)
 133 {
 134     HWND hWnd = pMsg->hwnd;
 135     wxWindow *pWndThis = wxFindWinFromHandle((WXHWND)hWnd);
 136     wxWindow *pWnd;
 137
 138     //
 139     // Pass non-system timer messages to the wxTimerProc
 140     //
 141     if (pMsg->msg == WM_TIMER &&
 142         (SHORT1FROMMP(pMsg->mp1) != TID_CURSOR &&
 143          SHORT1FROMMP(pMsg->mp1) != TID_FLASHWINDOW &&
 144          SHORT1FROMMP(pMsg->mp1) != TID_SCROLL &&
 145          SHORT1FROMMP(pMsg->mp1) != 0x0000
 146         ))
 147         wxTimerProc(NULL, 0, (int)pMsg->mp1, 0);
 148
 149     // Allow the window to prevent certain messages from being
 150     // translated/processed (this is currently used by wxTextCtrl to always
 151     // grab Ctrl-C/V/X, even if they are also accelerators in some parent)
 152     //
 153     if (pWndThis && !pWndThis->OS2ShouldPreProcessMessage((WXMSG*)pMsg))
 154     {
 155         return FALSE;
 156     }
 157
 158     //
 159     // For some composite controls (like a combobox), wndThis might be NULL
 160     // because the subcontrol is not a wxWindow, but only the control itself
 161     // is - try to catch this case
 162     //
 163     while (hWnd && !pWndThis)
 164     {
 165         hWnd = ::WinQueryWindow(hWnd, QW_PARENT);
 166         pWndThis = wxFindWinFromHandle((WXHWND)hWnd);
 167     }
 168
 169
 170     //
 171     // Try translations first; find the youngest window with
 172     // a translation table. OS/2 has case sensiive accels, so
 173     // this block, coded by BK, removes that and helps make them
 174     // case insensitive.
 175     //
 176     if(pMsg->msg == WM_CHAR)
 177     {
 178        PBYTE                        pChmsg = (PBYTE)&(pMsg->msg);
 179        USHORT                       uSch  = CHARMSG(pChmsg)->chr;
 180        bool                         bRc = FALSE;
 181
 182        //
 183        // Do not process keyup events
 184        //
 185        if(!(CHARMSG(pChmsg)->fs & KC_KEYUP))
 186        {
 187            if((CHARMSG(pChmsg)->fs & (KC_ALT | KC_CTRL)) && CHARMSG(pChmsg)->chr != 0)
 188                 CHARMSG(pChmsg)->chr = (USHORT)wxToupper((UCHAR)uSch);
 189
 190
 191            for(pWnd = pWndThis; pWnd; pWnd = pWnd->GetParent() )
 192            {
 193                if((bRc = pWnd->OS2TranslateMessage((WXMSG*)pMsg)) == TRUE)
 194                    break;
 195             // stop at first top level window, i.e. don't try to process the
 196             // key strokes originating in a dialog using the accelerators of
 197             // the parent frame - this doesn't make much sense
 198             if ( pWnd->IsTopLevel() )
 199                 break;
 200            }
 201
 202             if(!bRc)    // untranslated, should restore original value
 203                 CHARMSG(pChmsg)->chr = uSch;
 204         }
 205     }
 206     //
 207     // Anyone for a non-translation message? Try youngest descendants first.
 208     //
 209 //  for (pWnd = pWndThis->GetParent(); pWnd; pWnd = pWnd->GetParent())
 210 //  {
 211 //      if (pWnd->OS2ProcessMessage(pWxmsg))
 212 //          return TRUE;
 213 //  }
 214     return FALSE;
 215 }
 216
 217 // ----------------------------------------------------------------------------
 218 // wxEventLoopImpl idle event processing
 219 // ----------------------------------------------------------------------------
 220
 221 bool wxEventLoopImpl::SendIdleMessage()
 222 {
 223     return wxTheApp->ProcessIdle() ;
 224 }
 225
 226 // ============================================================================
 227 // wxEventLoop implementation
 228 // ============================================================================
 229
 230 wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL;
 231
 232 // ----------------------------------------------------------------------------
 233 // wxEventLoop running and exiting
 234 // ----------------------------------------------------------------------------
 235
 236 wxEventLoop::~wxEventLoop()
 237 {
 238     wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
 239 }
 240
 241 //////////////////////////////////////////////////////////////////////////////
 242 //
 243 // Keep trying to process messages until WM_QUIT
 244 // received.
 245 //
 246 // If there are messages to be processed, they will all be
 247 // processed and OnIdle will not be called.
 248 // When there are no more messages, OnIdle is called.
 249 // If OnIdle requests more time,
 250 // it will be repeatedly called so long as there are no pending messages.
 251 // A 'feature' of this is that once OnIdle has decided that no more processing
 252 // is required, then it won't get processing time until further messages
 253 // are processed (it'll sit in Dispatch).
 254 //
 255 //////////////////////////////////////////////////////////////////////////////
 256 class CallEventLoopMethod
 257 {
 258 public:
 259     typedef void (wxEventLoop::*FuncType)();
 260
 261     CallEventLoopMethod(wxEventLoop *evtLoop, FuncType fn)
 262         : m_evtLoop(evtLoop), m_fn(fn) { }
 263     ~CallEventLoopMethod() { (m_evtLoop->*m_fn)(); }
 264
 265 private:
 266     wxEventLoop *m_evtLoop;
 267     FuncType m_fn;
 268 };
 269
 270 int wxEventLoop::Run()
 271 {
 272     // event loops are not recursive, you need to create another loop!
 273     wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
 274
 275     // SendIdleMessage() and Dispatch() below may throw so the code here should
 276     // be exception-safe, hence we must use local objects for all actions we
 277     // should undo
 278     wxEventLoopActivator activate(&ms_activeLoop, this);
 279     wxEventLoopImplTiedPtr impl(&m_impl, new wxEventLoopImpl);
 280
 281     CallEventLoopMethod  callOnExit(this, &wxEventLoop::OnExit);
 282
 283     for ( ;; )
 284     {
 285 #if wxUSE_THREADS
 286         wxMutexGuiLeaveOrEnter();
 287 #endif // wxUSE_THREADS
 288
 289         // generate and process idle events for as long as we don't have
 290         // anything else to do
 291         while ( !Pending() && m_impl->SendIdleMessage() )
 292         {
 293             wxTheApp->HandleSockets();
 294             wxMilliSleep(10);
 295         }
 296
 297         wxTheApp->HandleSockets();
 298         if (Pending())
 299         {
 300             if ( !Dispatch() )
 301             {
 302                 // we got WM_QUIT
 303                 break;
 304             }
 305         }
 306         else
 307             wxMilliSleep(10);
 308     }
 309
 310     return m_impl->GetExitCode();
 311 }
 312
 313 void wxEventLoop::Exit(int rc)
 314 {
 315     wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
 316
 317     m_impl->SetExitCode(rc);
 318
 319     ::WinPostMsg(NULL, WM_QUIT, 0, 0);
 320 }
 321
 322 // ----------------------------------------------------------------------------
 323 // wxEventLoop message processing dispatching
 324 // ----------------------------------------------------------------------------
 325
 326 bool wxEventLoop::Pending() const
 327 {
 328     QMSG msg;
 329     return ::WinPeekMsg(vHabmain, &msg, 0, 0, 0, PM_NOREMOVE) != 0;
 330 }
 331
 332 bool wxEventLoop::Dispatch()
 333 {
 334     wxCHECK_MSG( IsRunning(), FALSE, _T("can't call Dispatch() if not running") );
 335
 336     QMSG msg;
 337     BOOL bRc = ::WinGetMsg(vHabmain, &msg, (HWND) NULL, 0, 0);
 338
 339     if ( bRc == 0 )
 340     {
 341         // got WM_QUIT
 342         return FALSE;
 343     }
 344
 345 #if wxUSE_THREADS
 346     wxASSERT_MSG( wxThread::IsMain(),
 347                   wxT("only the main thread can process Windows messages") );
 348
 349     static bool s_hadGuiLock = TRUE;
 350     static wxMsgArray s_aSavedMessages;
 351
 352     // if a secondary thread owning the mutex is doing GUI calls, save all
 353     // messages for later processing - we can't process them right now because
 354     // it will lead to recursive library calls (and we're not reentrant)
 355     if ( !wxGuiOwnedByMainThread() )
 356     {
 357         s_hadGuiLock = FALSE;
 358
 359         // leave out WM_COMMAND messages: too dangerous, sometimes
 360         // the message will be processed twice
 361         if ( !wxIsWaitingForThread() || msg.msg != WM_COMMAND )
 362         {
 363             s_aSavedMessages.Add(msg);
 364         }
 365
 366         return TRUE;
 367     }
 368     else
 369     {
 370         // have we just regained the GUI lock? if so, post all of the saved
 371         // messages
 372         //
 373         // FIXME of course, it's not _exactly_ the same as processing the
 374         //       messages normally - expect some things to break...
 375         if ( !s_hadGuiLock )
 376         {
 377             s_hadGuiLock = TRUE;
 378
 379             size_t count = s_aSavedMessages.Count();
 380             for ( size_t n = 0; n < count; n++ )
 381             {
 382                 QMSG& msg = s_aSavedMessages[n];
 383                 m_impl->ProcessMessage(&msg);
 384             }
 385
 386             s_aSavedMessages.Empty();
 387         }
 388     }
 389 #endif // wxUSE_THREADS
 390
 391     m_impl->ProcessMessage(&msg);
 392
 393     return TRUE;
 394 }
 395