src/motif/evtloop.cpp

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