src/motif/evtloop.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/motif/evtloop.cpp
   3 // Purpose:     implements wxEventLoop for Motif
   4 // Author:      Mattia Barbon
   5 // Modified by:
   6 // Created:     01.11.02
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2002 Mattia Barbon
   9 // License:     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 __VMS
  24 #define XtParent XTPARENT
  25 #define XtDisplay XTDISPLAY
  26 #endif
  27
  28 #ifndef WX_PRECOMP
  29     #include "wx/event.h"
  30     #include "wx/app.h"
  31     #include "wx/window.h"
  32     #include "wx/module.h"
  33 #endif //WX_PRECOMP
  34
  35 #include "wx/evtloop.h"
  36 #include "wx/thread.h"
  37
  38 #ifdef __VMS__
  39     #pragma message disable nosimpint
  40 #endif
  41 #include <Xm/Xm.h>
  42 #include <X11/Xlib.h>
  43 #ifdef __VMS__
  44     #pragma message enable nosimpint
  45 #endif
  46
  47 #include "wx/unix/private.h"
  48 #include "wx/motif/private.h"
  49
  50 #ifdef HAVE_SYS_SELECT_H
  51 #   include <sys/select.h>
  52 #endif
  53
  54 static bool CheckForKeyUp(XEvent* event);
  55 static bool CheckForKeyDown(XEvent* event);
  56 static bool CheckForAccelerator(XEvent* event);
  57 static void ProcessXEvent(XEvent* event);
  58 static void wxBreakDispatch();
  59
  60 // ----------------------------------------------------------------------------
  61 // wxEventLoopImpl
  62 // ----------------------------------------------------------------------------
  63
  64 class WXDLLEXPORT wxEventLoopImpl
  65 {
  66 public:
  67     // ctor
  68     wxEventLoopImpl() { SetExitCode(0); }
  69
  70     // set/get the exit code
  71     void SetExitCode(int exitcode) { m_exitcode = exitcode; }
  72     int GetExitCode() const { return m_exitcode; }
  73
  74     bool SendIdleMessage();
  75     bool GetKeepGoing() const { return m_keepGoing; }
  76     void SetKeepGoing(bool keepGoing) { m_keepGoing = keepGoing; }
  77 private:
  78     // the exit code of the event loop
  79     int  m_exitcode;
  80     bool m_keepGoing;
  81 };
  82
  83 // ----------------------------------------------------------------------------
  84 // wxEventLoopImpl idle event processing
  85 // ----------------------------------------------------------------------------
  86
  87 static bool SendIdleMessage()
  88 {
  89     return wxTheApp->ProcessIdle();
  90 }
  91
  92 bool wxEventLoopImpl::SendIdleMessage()
  93 {
  94     return ::SendIdleMessage();
  95 }
  96
  97 // ============================================================================
  98 // wxEventLoop implementation
  99 // ============================================================================
 100
 101 // ----------------------------------------------------------------------------
 102 // wxEventLoop running and exiting
 103 // ----------------------------------------------------------------------------
 104
 105 wxGUIEventLoop::~wxGUIEventLoop()
 106 {
 107     wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
 108 }
 109
 110 int wxGUIEventLoop::Run()
 111 {
 112     // event loops are not recursive, you need to create another loop!
 113     wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
 114
 115     wxEventLoopActivator activate(this);
 116
 117     m_impl = new wxEventLoopImpl;
 118     m_impl->SetKeepGoing( true );
 119
 120     for( ;; )
 121     {
 122         if( !wxDoEventLoopIteration( *this ) )
 123             break;
 124     }
 125
 126     OnExit();
 127
 128     int exitcode = m_impl->GetExitCode();
 129     delete m_impl;
 130     m_impl = NULL;
 131
 132     return exitcode;
 133 }
 134
 135 void wxGUIEventLoop::Exit(int rc)
 136 {
 137     wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
 138
 139     m_impl->SetExitCode(rc);
 140     m_impl->SetKeepGoing( false );
 141
 142     ::wxBreakDispatch();
 143 }
 144
 145 // ----------------------------------------------------------------------------
 146 // wxEventLoop message processing dispatching
 147 // ----------------------------------------------------------------------------
 148
 149 bool wxGUIEventLoop::Pending() const
 150 {
 151     return XtAppPending( (XtAppContext)wxTheApp->GetAppContext() ) != 0;
 152 }
 153
 154 bool wxGUIEventLoop::Dispatch()
 155 {
 156     XEvent event;
 157     XtAppContext context = (XtAppContext)wxTheApp->GetAppContext();
 158
 159     if( XtAppPeekEvent( context, &event ) != 0 )
 160     {
 161         XtAppNextEvent( context, &event );
 162         ProcessXEvent( &event );
 163     }
 164     else
 165     {
 166         XtAppProcessEvent( context, XtIMTimer | XtIMAlternateInput
 167 #ifdef XtIMSignal
 168                            | XtIMSignal
 169 #endif
 170                          );
 171     }
 172
 173     return m_impl ? m_impl->GetKeepGoing() : true;
 174 }
 175
 176 // ----------------------------------------------------------------------------
 177 // Static functions (originally in app.cpp)
 178 // ----------------------------------------------------------------------------
 179
 180 void ProcessXEvent(XEvent* event)
 181 {
 182     if (event->type == KeyPress)
 183     {
 184         if (CheckForAccelerator(event))
 185         {
 186             // Do nothing! We intercepted and processed the event as an
 187             // accelerator.
 188             return;
 189         }
 190         // It seemed before that this hack was redundant and
 191         // key down events were being generated by wxCanvasInputEvent.
 192         // But no longer - why ???
 193         //
 194         else if (CheckForKeyDown(event))
 195         {
 196             // We intercepted and processed the key down event
 197             return;
 198         }
 199         else
 200         {
 201             XtDispatchEvent(event);
 202             return;
 203         }
 204     }
 205     else if (event->type == KeyRelease)
 206     {
 207         // TODO: work out why we still need this !  -michael
 208         //
 209         if (::CheckForKeyUp(event))
 210         {
 211             // We intercepted and processed the key up event
 212             return;
 213         }
 214         else
 215         {
 216             XtDispatchEvent(event);
 217             return;
 218         }
 219     }
 220     else if (event->type == PropertyNotify)
 221     {
 222         wxTheApp->HandlePropertyChange(event);
 223         return;
 224     }
 225     else if (event->type == ResizeRequest)
 226     {
 227         /* Terry Gitnick <terryg@scientech.com> - 1/21/98
 228          * If resize event, don't resize until the last resize event for this
 229          * window is recieved. Prevents flicker as windows are resized.
 230          */
 231
 232         Display *disp = event->xany.display;
 233         Window win = event->xany.window;
 234         XEvent report;
 235
 236         //  to avoid flicker
 237         report = * event;
 238         while( XCheckTypedWindowEvent (disp, win, ResizeRequest, &report));
 239
 240         // TODO: when implementing refresh optimization, we can use
 241         // XtAddExposureToRegion to expand the window's paint region.
 242
 243         XtDispatchEvent(event);
 244     }
 245     else
 246     {
 247         XtDispatchEvent(event);
 248     }
 249 }
 250
 251 // Returns true if an accelerator has been processed
 252 bool CheckForAccelerator(XEvent* event)
 253 {
 254     if (event->xany.type == KeyPress)
 255     {
 256         // Find a wxWindow for this window
 257         // TODO: should get display for the window, not the current display
 258         Widget widget = XtWindowToWidget(event->xany.display,
 259                                          event->xany.window);
 260         wxWindow* win = NULL;
 261
 262         // Find the first wxWindow that corresponds to this event window
 263         while (widget && ((win = wxGetWindowFromTable(widget))!=NULL))
 264             widget = XtParent(widget);
 265
 266         if (!widget || !win)
 267             return false;
 268
 269         wxKeyEvent keyEvent(wxEVT_CHAR);
 270         wxTranslateKeyEvent(keyEvent, win, (Widget) 0, event);
 271
 272         // Now we have a wxKeyEvent and we have a wxWindow.
 273         // Go up the hierarchy until we find a matching accelerator,
 274         // or we get to the top.
 275         while (win)
 276         {
 277             if (win->ProcessAccelerator(keyEvent))
 278                 return true;
 279             win = win->GetParent();
 280         }
 281         return false;
 282     }
 283     return false;
 284 }
 285
 286 // bool wxApp::CheckForKeyDown(WXEvent* event) { wxFAIL; return false; }
 287
 288 bool CheckForKeyDown(XEvent* event)
 289 {
 290     if (event->xany.type == KeyPress)
 291     {
 292         Widget widget = XtWindowToWidget(event->xany.display,
 293                                          event->xany.window);
 294         wxWindow* win = NULL;
 295
 296         // Find the first wxWindow that corresponds to this event window
 297         while (widget && ((win = wxGetWindowFromTable(widget))!=NULL))
 298             widget = XtParent(widget);
 299
 300         if (!widget || !win)
 301             return false;
 302
 303         wxKeyEvent keyEvent(wxEVT_KEY_DOWN);
 304         wxTranslateKeyEvent(keyEvent, win, (Widget) 0, event);
 305
 306         return win->HandleWindowEvent( keyEvent );
 307     }
 308
 309     return false;
 310 }
 311
 312 // bool wxApp::CheckForKeyUp(WXEvent* event) { wxFAIL; return false; }
 313
 314 bool CheckForKeyUp(XEvent* event)
 315 {
 316     if (event->xany.type == KeyRelease)
 317     {
 318         Widget widget = XtWindowToWidget(event->xany.display,
 319                                          event->xany.window);
 320         wxWindow* win = NULL;
 321
 322         // Find the first wxWindow that corresponds to this event window
 323         while (widget && ((win = wxGetWindowFromTable(widget))!=NULL))
 324                 widget = XtParent(widget);
 325
 326         if (!widget || !win)
 327             return false;
 328
 329         wxKeyEvent keyEvent(wxEVT_KEY_UP);
 330         wxTranslateKeyEvent(keyEvent, win, (Widget) 0, event);
 331
 332         return win->HandleWindowEvent( keyEvent );
 333     }
 334
 335     return false;
 336 }
 337
 338 // ----------------------------------------------------------------------------
 339 // executes one main loop iteration (declared in include/wx/motif/private.h)
 340 // ----------------------------------------------------------------------------
 341
 342 bool wxDoEventLoopIteration( wxGUIEventLoop& evtLoop )
 343 {
 344     bool moreRequested, pendingEvents;
 345
 346     for(;;)
 347     {
 348         pendingEvents = evtLoop.Pending();
 349         if( pendingEvents ) break;
 350         moreRequested = ::SendIdleMessage();
 351         if( !moreRequested ) break;
 352     }
 353
 354 #if wxUSE_THREADS
 355     if( !pendingEvents && !moreRequested )
 356     {
 357         // leave the main loop to give other threads a chance to
 358         // perform their GUI work
 359         wxMutexGuiLeave();
 360         wxMilliSleep(20);
 361         wxMutexGuiEnter();
 362     }
 363 #endif
 364
 365     if( !evtLoop.Dispatch() )
 366         return false;
 367
 368     return true;
 369 }
 370
 371 // ----------------------------------------------------------------------------
 372 // ::wxWakeUpIdle implementation
 373 // ----------------------------------------------------------------------------
 374
 375 // As per Vadim's suggestion, we open a pipe, and XtAppAddInputSource it;
 376 // writing a single byte to the pipe will cause wxEventLoop::Pending
 377 // to return true, and wxEventLoop::Dispatch to dispatch an input handler
 378 // that simply removes the byte(s), and to return, which will cause
 379 // an idle event to be sent
 380
 381 // also wxEventLoop::Exit is implemented that way, so that exiting an
 382 // event loop won't require an event being in the queue
 383
 384 #include <sys/types.h>
 385 #include <sys/time.h>
 386 #include <unistd.h>
 387
 388 static int idleFds[2] = { -1, -1 };
 389
 390 class wxIdlePipeModule : public wxModule
 391 {
 392 public:
 393     wxIdlePipeModule() {};
 394
 395     virtual bool OnInit()
 396     {
 397         // Must be done before modules are initialized
 398 #if 0
 399         if( pipe(idleFds) != 0 )
 400             return false;
 401 #endif
 402         return true;
 403     }
 404
 405     virtual void OnExit()
 406     {
 407         close( idleFds[0] );
 408         close( idleFds[1] );
 409     }
 410 private:
 411     DECLARE_DYNAMIC_CLASS(wxIdlePipeModule)
 412 };
 413
 414 IMPLEMENT_DYNAMIC_CLASS(wxIdlePipeModule, wxModule)
 415
 416 static void wxInputCallback( XtPointer, int* fd, XtInputId* )
 417 {
 418     char buffer[128];
 419
 420     // wxWakeUpIdle may have been called more than once
 421     for(;;)
 422     {
 423         fd_set in;
 424         struct timeval timeout;
 425
 426         timeout.tv_sec = 0;
 427         timeout.tv_usec = 0;
 428
 429         wxFD_ZERO( &in );
 430         wxFD_SET( *fd, &in );
 431
 432         if( select( *fd + 1, &in, NULL, NULL, &timeout ) <= 0 )
 433             break;
 434         if( read( *fd, buffer, sizeof(buffer) - 1 ) != sizeof(buffer) - 1 )
 435             break;
 436     }
 437 }
 438
 439 static void wxBreakDispatch()
 440 {
 441     char dummy = 0; // for valgrind
 442
 443     // check if wxWakeUpIdle has already been called
 444     fd_set in;
 445     struct timeval timeout;
 446
 447     timeout.tv_sec = 0;
 448     timeout.tv_usec = 0;
 449
 450     wxFD_ZERO( &in );
 451     wxFD_SET( idleFds[0], &in );
 452
 453     if( select( idleFds[0] + 1, &in, NULL, NULL, &timeout ) > 0 )
 454         return;
 455
 456     // write a single byte
 457     write( idleFds[1], &dummy, 1 );
 458 }
 459
 460 void wxApp::WakeUpIdle()
 461 {
 462     ::wxBreakDispatch();
 463 }
 464
 465 bool wxInitIdleFds()
 466 {
 467     if( pipe(idleFds) != 0 )
 468         return false;
 469     return true;
 470 }
 471
 472 bool wxAddIdleCallback()
 473 {
 474     if (!wxInitIdleFds())
 475         return false;
 476
 477     // install input handler for wxWakeUpIdle
 478     XtAppAddInput((XtAppContext) wxTheApp->GetAppContext(),
 479                   idleFds[0],
 480                   (XtPointer)XtInputReadMask,
 481                   wxInputCallback,
 482                   NULL);
 483
 484     return true;
 485 }