src/x11/evtloop.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/x11/evtloop.cpp
   3 // Purpose:     implements wxEventLoop for X11
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01.06.01
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2002 Julian Smart
   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 #include "wx/evtloop.h"
  24
  25 #ifndef WX_PRECOMP
  26     #include "wx/hash.h"
  27     #include "wx/app.h"
  28     #include "wx/window.h"
  29     #include "wx/module.h"
  30 #endif
  31
  32 #include "wx/private/fdiodispatcher.h"
  33 #include "wx/unix/private.h"
  34 #include "wx/x11/private.h"
  35 #include "wx/generic/private/timer.h"
  36
  37 #if wxUSE_THREADS
  38     #include "wx/thread.h"
  39 #endif
  40
  41 #include <X11/Xlib.h>
  42 #include <sys/time.h>
  43 #include <unistd.h>
  44
  45 #ifdef HAVE_SYS_SELECT_H
  46 #   include <sys/select.h>
  47 #endif
  48
  49 // ----------------------------------------------------------------------------
  50 // wxEventLoopImpl
  51 // ----------------------------------------------------------------------------
  52
  53 class WXDLLEXPORT wxEventLoopImpl
  54 {
  55 public:
  56     // ctor
  57     wxEventLoopImpl() { SetExitCode(0); m_keepGoing = false; }
  58
  59     // process an XEvent, return true if it was processed
  60     bool ProcessEvent(XEvent* event);
  61
  62     // generate an idle message, return true if more idle time requested
  63     bool SendIdleEvent();
  64
  65     // set/get the exit code
  66     void SetExitCode(int exitcode) { m_exitcode = exitcode; }
  67     int GetExitCode() const { return m_exitcode; }
  68
  69 public:
  70     // preprocess an event, return true if processed (i.e. no further
  71     // dispatching required)
  72     bool PreProcessEvent(XEvent* event);
  73
  74     // the exit code of the event loop
  75     int m_exitcode;
  76
  77     bool m_keepGoing;
  78 };
  79
  80 // ============================================================================
  81 // wxEventLoopImpl implementation
  82 // ============================================================================
  83
  84 // ----------------------------------------------------------------------------
  85 // wxEventLoopImpl message processing
  86 // ----------------------------------------------------------------------------
  87
  88 bool wxEventLoopImpl::ProcessEvent(XEvent *event)
  89 {
  90     // give us the chance to preprocess the message first
  91     if ( PreProcessEvent(event) )
  92         return true;
  93
  94     // if it wasn't done, dispatch it to the corresponding window
  95     if (wxTheApp)
  96         return wxTheApp->ProcessXEvent((WXEvent*) event);
  97
  98     return false;
  99 }
 100
 101 bool wxEventLoopImpl::PreProcessEvent(XEvent *WXUNUSED(event))
 102 {
 103     return false;
 104 }
 105
 106 // ----------------------------------------------------------------------------
 107 // wxEventLoopImpl idle event processing
 108 // ----------------------------------------------------------------------------
 109
 110 bool wxEventLoopImpl::SendIdleEvent()
 111 {
 112     return wxTheApp->ProcessIdle();
 113 }
 114
 115 // ============================================================================
 116 // wxEventLoop implementation
 117 // ============================================================================
 118
 119 // ----------------------------------------------------------------------------
 120 // wxEventLoop running and exiting
 121 // ----------------------------------------------------------------------------
 122
 123 wxGUIEventLoop::~wxGUIEventLoop()
 124 {
 125     wxASSERT_MSG( !m_impl, wxT("should have been deleted in Run()") );
 126 }
 127
 128 int wxGUIEventLoop::Run()
 129 {
 130     // event loops are not recursive, you need to create another loop!
 131     wxCHECK_MSG( !IsRunning(), -1, wxT("can't reenter a message loop") );
 132
 133     m_impl = new wxEventLoopImpl;
 134
 135     wxEventLoopActivator activate(this);
 136
 137     m_impl->m_keepGoing = true;
 138     while ( m_impl->m_keepGoing )
 139     {
 140         // generate and process idle events for as long as we don't have
 141         // anything else to do
 142         while ( ! Pending() )
 143         {
 144 #if wxUSE_TIMER
 145             wxGenericTimerImpl::NotifyTimers(); // TODO: is this the correct place for it?
 146 #endif
 147             if (!m_impl->SendIdleEvent())
 148             {
 149                 // Break out of while loop
 150                 break;
 151             }
 152         }
 153
 154         // a message came or no more idle processing to do, sit in Dispatch()
 155         // waiting for the next message
 156         if ( !Dispatch() )
 157         {
 158             break;
 159         }
 160     }
 161
 162     OnExit();
 163
 164     int exitcode = m_impl->GetExitCode();
 165     delete m_impl;
 166     m_impl = NULL;
 167
 168     return exitcode;
 169 }
 170
 171 void wxGUIEventLoop::Exit(int rc)
 172 {
 173     wxCHECK_RET( IsRunning(), wxT("can't call Exit() if not running") );
 174
 175     m_impl->SetExitCode(rc);
 176     m_impl->m_keepGoing = false;
 177 }
 178
 179 // ----------------------------------------------------------------------------
 180 // wxEventLoop message processing dispatching
 181 // ----------------------------------------------------------------------------
 182
 183 bool wxGUIEventLoop::Pending() const
 184 {
 185     XFlush( wxGlobalDisplay() );
 186     return (XPending( wxGlobalDisplay() ) > 0);
 187 }
 188
 189 bool wxGUIEventLoop::Dispatch()
 190 {
 191     // see comment in wxEventLoopManual::ProcessEvents()
 192     if ( wxTheApp )
 193         wxTheApp->ProcessPendingEvents();
 194
 195     XEvent event;
 196
 197     // TODO allowing for threads, as per e.g. wxMSW
 198
 199     // This now waits until either an X event is received,
 200     // or the select times out. So we should now process
 201     // wxTimers in a reasonably timely fashion. However it
 202     // does also mean that idle processing will happen more
 203     // often, so we should probably limit idle processing to
 204     // not be repeated more than every N milliseconds.
 205
 206     if (XPending( wxGlobalDisplay() ) == 0)
 207     {
 208 #if wxUSE_NANOX
 209         GR_TIMEOUT timeout = 10; // Milliseconds
 210         // Wait for next event, or timeout
 211         GrGetNextEventTimeout(& event, timeout);
 212
 213         // Fall through to ProcessEvent.
 214         // we'll assume that ProcessEvent will just ignore
 215         // the event if there was a timeout and no event.
 216
 217 #else
 218         struct timeval tv;
 219         tv.tv_sec=0;
 220         tv.tv_usec=10000; // TODO make this configurable
 221         int fd = ConnectionNumber( wxGlobalDisplay() );
 222
 223         fd_set readset;
 224         fd_set writeset;
 225         wxFD_ZERO(&readset);
 226         wxFD_ZERO(&writeset);
 227         wxFD_SET(fd, &readset);
 228
 229         if (select( fd+1, &readset, &writeset, NULL, &tv ) != 0)
 230         {
 231             // An X11 event was pending, get it
 232             if (wxFD_ISSET( fd, &readset ))
 233                 XNextEvent( wxGlobalDisplay(), &event );
 234         }
 235 #endif
 236     }
 237     else
 238     {
 239         XNextEvent( wxGlobalDisplay(), &event );
 240     }
 241
 242 #if wxUSE_SOCKETS
 243     // handle any pending socket events:
 244     wxFDIODispatcher::DispatchPending();
 245 #endif
 246
 247     (void) m_impl->ProcessEvent( &event );
 248     return true;
 249 }
 250
 251 bool wxGUIEventLoop::YieldFor(long eventsToProcess)
 252 {
 253     // Sometimes only 2 yields seem
 254     // to do the trick, e.g. in the
 255     // progress dialog
 256     int i;
 257     for (i = 0; i < 2; i++)
 258     {
 259         m_isInsideYield = true;
 260         m_eventsToProcessInsideYield = eventsToProcess;
 261
 262         // Call dispatch at least once so that sockets
 263         // can be tested
 264         wxTheApp->Dispatch();
 265
 266         // TODO: implement event filtering using the eventsToProcess mask
 267         while (wxTheApp && wxTheApp->Pending())
 268             wxTheApp->Dispatch();
 269
 270 #if wxUSE_TIMER
 271         wxGenericTimerImpl::NotifyTimers();
 272 #endif
 273         ProcessIdle();
 274
 275         m_isInsideYield = false;
 276     }
 277
 278     return true;
 279 }