make cast from double to long explicit to suppress gcc warning (part of patch 1962992)

[wxWidgets.git] / src / x11 / evtloop.cpp

diff --git a/src/x11/evtloop.cpp b/src/x11/evtloop.cpp
index dd8a8f030ec59560324516b39206a510bc5a1259..eab9042841002696f901b3471fe326e8d5b77c4e 100644 (file)
--- a/src/x11/evtloop.cpp
+++ b/src/x11/evtloop.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        x11/evtloop.cpp
+// Name:        src/x11/evtloop.cpp

 // Purpose:     implements wxEventLoop for X11
 // Author:      Julian Smart
 // Modified by:
 // Purpose:     implements wxEventLoop for X11
 // Author:      Julian Smart
 // Modified by:


@@ -17,20 +17,34 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma implementation "evtloop.h"
-#endif
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"

 
 

-#include "wx/window.h"
-#include "wx/app.h"

 #include "wx/evtloop.h"
 #include "wx/evtloop.h"

-#include "wx/tooltip.h"
-#if wxUSE_THREADS
-#include "wx/thread.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/hash.h"
+    #include "wx/app.h"
+    #include "wx/window.h"
+    #include "wx/module.h"

 #endif
 #endif

-#include "wx/timer.h"
+
+#include "wx/private/fdiodispatcher.h"
+#include "wx/unix/private.h"

 #include "wx/x11/private.h"
 #include "wx/x11/private.h"

-#include "X11/Xlib.h"
+#include "wx/generic/private/timer.h"
+
+#if wxUSE_THREADS
+    #include "wx/thread.h"
+#endif
+
+#include <X11/Xlib.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#ifdef HAVE_SYS_SELECT_H
+#   include <sys/select.h>
+#endif

 
 // ----------------------------------------------------------------------------
 // wxEventLoopImpl
 
 // ----------------------------------------------------------------------------
 // wxEventLoopImpl


@@ -40,12 +54,12 @@ class WXDLLEXPORT wxEventLoopImpl
 {
 public:
     // ctor
 {
 public:
     // ctor

-    wxEventLoopImpl() { SetExitCode(0); m_keepGoing = FALSE; }
+    wxEventLoopImpl() { SetExitCode(0); m_keepGoing = false; }

 
 

-    // process an XEvent
-    void ProcessEvent(XEvent* event);
+    // process an XEvent, return true if it was processed
+    bool ProcessEvent(XEvent* event);

 
 

-    // generate an idle message, return TRUE if more idle time requested
+    // generate an idle message, return true if more idle time requested

     bool SendIdleEvent();
 
     // set/get the exit code
     bool SendIdleEvent();
 
     // set/get the exit code


@@ -53,7 +67,7 @@ public:
     int GetExitCode() const { return m_exitcode; }
 
 public:
     int GetExitCode() const { return m_exitcode; }
 
 public:

-    // preprocess an event, return TRUE if processed (i.e. no further
+    // preprocess an event, return true if processed (i.e. no further

     // dispatching required)
     bool PreProcessEvent(XEvent* event);
 
     // dispatching required)
     bool PreProcessEvent(XEvent* event);
 


@@ -71,43 +85,22 @@ public:
 // wxEventLoopImpl message processing
 // ----------------------------------------------------------------------------
 
 // wxEventLoopImpl message processing
 // ----------------------------------------------------------------------------
 

-void wxEventLoopImpl::ProcessEvent(XEvent *event)
+bool wxEventLoopImpl::ProcessEvent(XEvent *event)

 {
     // give us the chance to preprocess the message first
 {
     // give us the chance to preprocess the message first

-    if ( !PreProcessEvent(event) )
-    {
-        // if it wasn't done, dispatch it to the corresponding window
-        if (wxTheApp)
-            wxTheApp->ProcessXEvent((WXEvent*) event);
-    }
-}
-
-bool wxEventLoopImpl::PreProcessEvent(XEvent *event)
-{
-    // TODO
-#if 0
-    HWND hWnd = msg->hwnd;
-    wxWindow *wndThis = wxGetWindowFromHWND((WXHWND)hWnd);
+    if ( PreProcessEvent(event) )
+        return true;

 
 

+    // if it wasn't done, dispatch it to the corresponding window
+    if (wxTheApp)
+        return wxTheApp->ProcessXEvent((WXEvent*) event);

 
 

-    // try translations first; find the youngest window with a translation
-    // table.
-    wxWindow *wnd;
-    for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
-    {
-        if ( wnd->MSWTranslateMessage((WXMSG *)msg) )
-            return TRUE;
-    }
-
-    // Anyone for a non-translation message? Try youngest descendants first.
-    for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
-    {
-        if ( wnd->MSWProcessMessage((WXMSG *)msg) )
-            return TRUE;
-    }
-#endif
+    return false;
+}

 
 

-    return FALSE;
+bool wxEventLoopImpl::PreProcessEvent(XEvent *WXUNUSED(event))
+{
+    return false;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -116,65 +109,43 @@ bool wxEventLoopImpl::PreProcessEvent(XEvent *event)
 
 bool wxEventLoopImpl::SendIdleEvent()
 {
 
 bool wxEventLoopImpl::SendIdleEvent()
 {

-    wxIdleEvent event;
-    event.SetEventObject(wxTheApp);
-
-    return wxTheApp->ProcessEvent(event) && event.MoreRequested();
+    return wxTheApp->ProcessIdle();

 }
 
 // ============================================================================
 // wxEventLoop implementation
 // ============================================================================
 
 }
 
 // ============================================================================
 // wxEventLoop implementation
 // ============================================================================
 

-wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
-

 // ----------------------------------------------------------------------------
 // wxEventLoop running and exiting
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxEventLoop running and exiting
 // ----------------------------------------------------------------------------
 

-wxEventLoop::~wxEventLoop()
+wxGUIEventLoop::~wxGUIEventLoop()

 {
     wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
 }
 
 {
     wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
 }
 

-bool wxEventLoop::IsRunning() const
-{
-    return m_impl != NULL;
-}
-
-int wxEventLoop::Run()
+int wxGUIEventLoop::Run()

 {
     // event loops are not recursive, you need to create another loop!
     wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
 
     m_impl = new wxEventLoopImpl;
 {
     // event loops are not recursive, you need to create another loop!
     wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
 
     m_impl = new wxEventLoopImpl;

-    
-    wxEventLoop *oldLoop = ms_activeLoop;
-    ms_activeLoop = this;

 
 

-    m_impl->m_keepGoing = TRUE;
+    wxEventLoopActivator activate(this);
+
+    m_impl->m_keepGoing = true;

     while ( m_impl->m_keepGoing )
     {
     while ( m_impl->m_keepGoing )
     {

-#if 0 // wxUSE_THREADS
-       wxMutexGuiLeaveOrEnter();
-#endif // wxUSE_THREADS
-

         // generate and process idle events for as long as we don't have
         // anything else to do
         while ( ! Pending() )
         {
 #if wxUSE_TIMER
         // generate and process idle events for as long as we don't have
         // anything else to do
         while ( ! Pending() )
         {
 #if wxUSE_TIMER

-            wxTimer::NotifyTimers(); // TODO: is this the correct place for it?
+            wxGenericTimerImpl::NotifyTimers(); // TODO: is this the correct place for it?

 #endif
             if (!m_impl->SendIdleEvent())
             {
 #endif
             if (!m_impl->SendIdleEvent())
             {

-#if 0 // wxUSE_THREADS
-                // leave the main loop to give other threads a chance to
-                // perform their GUI work
-                wxMutexGuiLeave();
-                wxUsleep(20);
-                wxMutexGuiEnter();
-#endif

                 // Break out of while loop
                 break;
             }
                 // Break out of while loop
                 break;
             }


@@ -188,41 +159,87 @@ int wxEventLoop::Run()
         }
     }
 
         }
     }
 

+    OnExit();
+

     int exitcode = m_impl->GetExitCode();
     delete m_impl;
     m_impl = NULL;
 
     int exitcode = m_impl->GetExitCode();
     delete m_impl;
     m_impl = NULL;
 

-    ms_activeLoop = oldLoop;
-

     return exitcode;
 }
 
     return exitcode;
 }
 

-void wxEventLoop::Exit(int rc)
+void wxGUIEventLoop::Exit(int rc)

 {
     wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
 
     m_impl->SetExitCode(rc);
 {
     wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
 
     m_impl->SetExitCode(rc);

-    m_impl->m_keepGoing = FALSE;
+    m_impl->m_keepGoing = false;

 }
 
 // ----------------------------------------------------------------------------
 // wxEventLoop message processing dispatching
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // wxEventLoop message processing dispatching
 // ----------------------------------------------------------------------------
 

-bool wxEventLoop::Pending() const
+bool wxGUIEventLoop::Pending() const

 {
 {

-    XFlush((Display*) wxGetDisplay());
-    return (XPending((Display*) wxGetDisplay()) > 0);
+    XFlush( wxGlobalDisplay() );
+    return (XPending( wxGlobalDisplay() ) > 0);

 }
 
 }
 

-bool wxEventLoop::Dispatch()
+bool wxGUIEventLoop::Dispatch()

 {
     XEvent event;
 
     // TODO allowing for threads, as per e.g. wxMSW
 
 {
     XEvent event;
 
     // TODO allowing for threads, as per e.g. wxMSW
 

-    XNextEvent((Display*) wxGetDisplay(), & event);
-    m_impl->ProcessEvent(& event);
-    return TRUE;
-}
+    // This now waits until either an X event is received,
+    // or the select times out. So we should now process
+    // wxTimers in a reasonably timely fashion. However it
+    // does also mean that idle processing will happen more
+    // often, so we should probably limit idle processing to
+    // not be repeated more than every N milliseconds.

 
 

+    if (XPending( wxGlobalDisplay() ) == 0)
+    {
+#if wxUSE_NANOX
+        GR_TIMEOUT timeout = 10; // Milliseconds
+        // Wait for next event, or timeout
+        GrGetNextEventTimeout(& event, timeout);
+
+        // Fall through to ProcessEvent.
+        // we'll assume that ProcessEvent will just ignore
+        // the event if there was a timeout and no event.
+
+#else
+        struct timeval tv;
+        tv.tv_sec=0;
+        tv.tv_usec=10000; // TODO make this configurable
+        int fd = ConnectionNumber( wxGlobalDisplay() );
+
+        fd_set readset;
+        fd_set writeset;
+        wxFD_ZERO(&readset);
+        wxFD_ZERO(&writeset);
+        wxFD_SET(fd, &readset);
+
+        if (select( fd+1, &readset, &writeset, NULL, &tv ) != 0)
+        {
+            // An X11 event was pending, get it
+            if (wxFD_ISSET( fd, &readset ))
+                XNextEvent( wxGlobalDisplay(), &event );
+        }
+#endif
+    }
+    else
+    {
+        XNextEvent( wxGlobalDisplay(), &event );
+    }
+
+#if wxUSE_SOCKETS
+    // handle any pending socket events:
+    wxFDIODispatcher::DispatchPending();
+#endif
+
+    (void) m_impl->ProcessEvent( &event );
+    return true;
+}