src/x11/evtloop.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 #ifdef __GNUG__
  21     #pragma implementation "evtloop.h"
  22 #endif
  23
  24 #include "wx/window.h"
  25 #include "wx/app.h"
  26 #include "wx/evtloop.h"
  27 #include "wx/tooltip.h"
  28
  29 #include "wx/x11/private.h"
  30 #include "X11/Xlib.h"
  31
  32 // ----------------------------------------------------------------------------
  33 // wxEventLoopImpl
  34 // ----------------------------------------------------------------------------
  35
  36 class WXDLLEXPORT wxEventLoopImpl
  37 {
  38 public:
  39     // ctor
  40     wxEventLoopImpl() { SetExitCode(0); m_keepGoing = FALSE; }
  41
  42     // process an XEvent
  43     void ProcessEvent(XEvent* event);
  44
  45     // generate an idle message, return TRUE if more idle time requested
  46     bool SendIdleEvent();
  47
  48     // set/get the exit code
  49     void SetExitCode(int exitcode) { m_exitcode = exitcode; }
  50     int GetExitCode() const { return m_exitcode; }
  51
  52 public:
  53     // preprocess an event, return TRUE if processed (i.e. no further
  54     // dispatching required)
  55     bool PreProcessMessage(XEvent* event);
  56
  57     // the exit code of the event loop
  58     int m_exitcode;
  59
  60     bool m_keepGoing;
  61 };
  62
  63 // ============================================================================
  64 // wxEventLoopImpl implementation
  65 // ============================================================================
  66
  67 // ----------------------------------------------------------------------------
  68 // wxEventLoopImpl message processing
  69 // ----------------------------------------------------------------------------
  70
  71 void wxEventLoopImpl::ProcessEvent(XEvent *event)
  72 {
  73     // give us the chance to preprocess the message first
  74     if ( !PreProcessEvent(event) )
  75     {
  76         // if it wasn't done, dispatch it to the corresponding window
  77         if (wxTheApp)
  78             wxTheApp->ProcessXEvent((WXEvent*) event);
  79     }
  80 }
  81
  82 bool wxEventLoopImpl::PreProcessEvent(XEvent *event)
  83 {
  84     // TODO
  85 #if 0
  86     HWND hWnd = msg->hwnd;
  87     wxWindow *wndThis = wxGetWindowFromHWND((WXHWND)hWnd);
  88
  89
  90     // try translations first; find the youngest window with a translation
  91     // table.
  92     wxWindow *wnd;
  93     for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
  94     {
  95         if ( wnd->MSWTranslateMessage((WXMSG *)msg) )
  96             return TRUE;
  97     }
  98
  99     // Anyone for a non-translation message? Try youngest descendants first.
 100     for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
 101     {
 102         if ( wnd->MSWProcessMessage((WXMSG *)msg) )
 103             return TRUE;
 104     }
 105 #endif
 106
 107     return FALSE;
 108 }
 109
 110 // ----------------------------------------------------------------------------
 111 // wxEventLoopImpl idle event processing
 112 // ----------------------------------------------------------------------------
 113
 114 bool wxEventLoopImpl::SendIdleEvent()
 115 {
 116     wxIdleEvent event;
 117     event.SetEventObject(wxTheApp);
 118
 119     return wxTheApp->ProcessEvent(event) && event.MoreRequested();
 120 }
 121
 122 // ============================================================================
 123 // wxEventLoop implementation
 124 // ============================================================================
 125
 126 wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
 127
 128 // ----------------------------------------------------------------------------
 129 // wxEventLoop running and exiting
 130 // ----------------------------------------------------------------------------
 131
 132 wxEventLoop::~wxEventLoop()
 133 {
 134     wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
 135 }
 136
 137 bool wxEventLoop::IsRunning() const
 138 {
 139     return m_impl != NULL;
 140 }
 141
 142 int wxEventLoop::Run()
 143 {
 144     // event loops are not recursive, you need to create another loop!
 145     wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
 146
 147     m_impl = new wxEventLoopImpl;
 148
 149     wxEventLoop *oldLoop = ms_activeLoop;
 150     ms_activeLoop = this;
 151
 152     m_impl->m_keepGoing = TRUE;
 153     while ( m_impl->m_keepGoing )
 154     {
 155 #if wxUSE_THREADS
 156         wxMutexGuiLeaveOrEnter();
 157 #endif // wxUSE_THREADS
 158
 159         // generate and process idle events for as long as we don't have
 160         // anything else to do
 161         while ( ! Pending() )
 162         {
 163             if (!m_impl->SendIdleEvent())
 164             {
 165 #if wxUSE_THREADS
 166                 // leave the main loop to give other threads a chance to
 167                 // perform their GUI work
 168                 wxMutexGuiLeave();
 169                 wxUsleep(20);
 170                 wxMutexGuiEnter();
 171 #endif
 172                 // Break out of while loop
 173                 break;
 174             }
 175         }
 176
 177         // a message came or no more idle processing to do, sit in Dispatch()
 178         // waiting for the next message
 179         if ( !Dispatch() )
 180         {
 181             break;
 182         }
 183     }
 184
 185     int exitcode = m_impl->GetExitCode();
 186     delete m_impl;
 187     m_impl = NULL;
 188
 189     ms_activeLoop = oldLoop;
 190
 191     return exitcode;
 192 }
 193
 194 void wxEventLoop::Exit(int rc)
 195 {
 196     wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
 197
 198     m_impl->SetExitCode(rc);
 199     m_impl->m_keepGoing = FALSE;
 200 }
 201
 202 // ----------------------------------------------------------------------------
 203 // wxEventLoop message processing dispatching
 204 // ----------------------------------------------------------------------------
 205
 206 bool wxEventLoop::Pending() const
 207 {
 208     XFlush(wxGetDisplay());
 209     return (XPending(wxGetDisplay()) > 0);
 210 }
 211
 212 bool wxEventLoop::Dispatch()
 213 {
 214     XEvent event;
 215
 216     // TODO allowing for threads, as per e.g. wxMSW
 217
 218     XNextEvent(wxGetDisplay(), & event);
 219     m_impl->ProcessEvent(& event);
 220     return TRUE;
 221 }
 222