remove streams tests: they're very basic and already-existing CppUnit stream tests...

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

diff --git a/src/motif/evtloop.cpp b/src/motif/evtloop.cpp
index 217cbfa0abd6e8c0a63693c767482fee6dcdd588..7fd2475e668067e98297fdfc4c3a864a9835d09b 100644 (file)
--- a/src/motif/evtloop.cpp
+++ b/src/motif/evtloop.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

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

 // Purpose:     implements wxEventLoop for Motif
 // Author:      Mattia Barbon
 // Modified by:
 // Purpose:     implements wxEventLoop for Motif
 // Author:      Mattia Barbon
 // Modified by:


@@ -17,36 +17,35 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma implementation "evtloop.h"
-#endif
-
-#ifdef __VMS
-#define XtParent XTPARENT
-#define XtDisplay XTDISPLAY
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifndef WX_PRECOMP
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifndef WX_PRECOMP

+    #include "wx/event.h"
+    #include "wx/app.h"
+    #include "wx/window.h"
+    #include "wx/module.h"

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

-#include "wx/event.h"
-#include "wx/app.h"
+#include "wx/thread.h"

 
 #ifdef __VMS__
 
 #ifdef __VMS__

-#pragma message disable nosimpint
+    #pragma message disable nosimpint

 #endif
 #include <Xm/Xm.h>
 #include <X11/Xlib.h>
 #ifdef __VMS__
 #endif
 #include <Xm/Xm.h>
 #include <X11/Xlib.h>
 #ifdef __VMS__

-#pragma message enable nosimpint
+    #pragma message enable nosimpint

 #endif
 
 #endif
 

+#include "wx/unix/private.h"

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

+#ifdef HAVE_SYS_SELECT_H
+#   include <sys/select.h>
+#endif
+

 static bool CheckForKeyUp(XEvent* event);
 static bool CheckForKeyDown(XEvent* event);
 static bool CheckForAccelerator(XEvent* event);
 static bool CheckForKeyUp(XEvent* event);
 static bool CheckForKeyDown(XEvent* event);
 static bool CheckForAccelerator(XEvent* event);


@@ -82,9 +81,7 @@ private:
 
 static bool SendIdleMessage()
 {
 
 static bool SendIdleMessage()
 {

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

 }
 
 bool wxEventLoopImpl::SendIdleMessage()
 }
 
 bool wxEventLoopImpl::SendIdleMessage()


@@ -100,25 +97,17 @@ bool wxEventLoopImpl::SendIdleMessage()
 // wxEventLoop running and exiting
 // ----------------------------------------------------------------------------
 
 // wxEventLoop running and exiting
 // ----------------------------------------------------------------------------
 

-wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
-
-wxEventLoop::~wxEventLoop()
-{
-    wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
-}
-
-bool wxEventLoop::IsRunning() const
+wxGUIEventLoop::~wxGUIEventLoop()

 {
 {

-    return m_impl != NULL;
+    wxASSERT_MSG( !m_impl, wxT("should have been deleted in Run()") );

 }
 
 }
 

-int wxEventLoop::Run()
+int wxGUIEventLoop::Run()

 {
     // event loops are not recursive, you need to create another loop!
 {
     // event loops are not recursive, you need to create another loop!

-    wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
+    wxCHECK_MSG( !IsRunning(), -1, wxT("can't reenter a message loop") );

 
 

-    wxEventLoop *oldLoop = ms_activeLoop;
-    ms_activeLoop = this;
+    wxEventLoopActivator activate(this);

 
     m_impl = new wxEventLoopImpl;
     m_impl->SetKeepGoing( true );
 
     m_impl = new wxEventLoopImpl;
     m_impl->SetKeepGoing( true );


@@ -129,18 +118,18 @@ int wxEventLoop::Run()
             break;
     }
 
             break;
     }
 

+    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") );
+    wxCHECK_RET( IsRunning(), wxT("can't call Exit() if not running") );

 
     m_impl->SetExitCode(rc);
     m_impl->SetKeepGoing( false );
 
     m_impl->SetExitCode(rc);
     m_impl->SetKeepGoing( false );


@@ -148,16 +137,30 @@ void wxEventLoop::Exit(int rc)
     ::wxBreakDispatch();
 }
 
     ::wxBreakDispatch();
 }
 

+bool wxGUIEventLoop::YieldFor(long eventsToProcess)
+{
+    m_isInsideYield = true;
+    m_eventsToProcessInsideYield = eventsToProcess;
+
+    while (wxTheApp && wxTheApp->Pending())
+        // TODO: implement event filtering using the eventsToProcess mask
+        wxTheApp->Dispatch();
+
+    m_isInsideYield = false;
+
+    return true;
+}
+

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

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

 {
     return XtAppPending( (XtAppContext)wxTheApp->GetAppContext() ) != 0;
 }
 
 {
     return XtAppPending( (XtAppContext)wxTheApp->GetAppContext() ) != 0;
 }
 

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

 {
     XEvent event;
     XtAppContext context = (XtAppContext)wxTheApp->GetAppContext();
 {
     XEvent event;
     XtAppContext context = (XtAppContext)wxTheApp->GetAppContext();


@@ -168,11 +171,13 @@ bool wxEventLoop::Dispatch()
         ProcessXEvent( &event );
     }
     else
         ProcessXEvent( &event );
     }
     else

-#ifdef __VMS
-     XtAppProcessEvent( context, XtIMTimer|XtIMAlternateInput );
-#else
-     XtAppProcessEvent( context, XtIMTimer|XtIMAlternateInput|XtIMSignal );
+    {
+        XtAppProcessEvent( context, XtIMTimer | XtIMAlternateInput
+#ifdef XtIMSignal
+                           | XtIMSignal

 #endif
 #endif

+                         );
+    }

 
     return m_impl ? m_impl->GetKeepGoing() : true;
 }
 
     return m_impl ? m_impl->GetKeepGoing() : true;
 }


@@ -233,7 +238,7 @@ void ProcessXEvent(XEvent* event)
          * window is recieved. Prevents flicker as windows are resized.
          */
 
          * window is recieved. Prevents flicker as windows are resized.
          */
 

-        Display *disp = XtDisplay((Widget) wxTheApp->GetTopLevelWidget());
+        Display *disp = event->xany.display;

         Window win = event->xany.window;
         XEvent report;
 
         Window win = event->xany.window;
         XEvent report;
 


@@ -259,12 +264,12 @@ bool CheckForAccelerator(XEvent* event)
     {
         // Find a wxWindow for this window
         // TODO: should get display for the window, not the current display
     {
         // Find a wxWindow for this window
         // TODO: should get display for the window, not the current display

-        Widget widget = XtWindowToWidget((Display*) wxGetDisplay(),
+        Widget widget = XtWindowToWidget(event->xany.display,

                                          event->xany.window);
         wxWindow* win = NULL;
 
         // Find the first wxWindow that corresponds to this event window
                                          event->xany.window);
         wxWindow* win = NULL;
 
         // Find the first wxWindow that corresponds to this event window

-        while (widget && !(win = wxGetWindowFromTable(widget)))
+        while (widget && ((win = wxGetWindowFromTable(widget))!=NULL))

             widget = XtParent(widget);
 
         if (!widget || !win)
             widget = XtParent(widget);
 
         if (!widget || !win)


@@ -293,12 +298,12 @@ bool CheckForKeyDown(XEvent* event)
 {
     if (event->xany.type == KeyPress)
     {
 {
     if (event->xany.type == KeyPress)
     {

-        Widget widget = XtWindowToWidget((Display*) wxGetDisplay(),
-                     event->xany.window);
+        Widget widget = XtWindowToWidget(event->xany.display,
+                                         event->xany.window);

         wxWindow* win = NULL;
 
         // Find the first wxWindow that corresponds to this event window
         wxWindow* win = NULL;
 
         // Find the first wxWindow that corresponds to this event window

-        while (widget && !(win = wxGetWindowFromTable(widget)))
+        while (widget && ((win = wxGetWindowFromTable(widget))!=NULL))

             widget = XtParent(widget);
 
         if (!widget || !win)
             widget = XtParent(widget);
 
         if (!widget || !win)


@@ -307,7 +312,7 @@ bool CheckForKeyDown(XEvent* event)
         wxKeyEvent keyEvent(wxEVT_KEY_DOWN);
         wxTranslateKeyEvent(keyEvent, win, (Widget) 0, event);
 
         wxKeyEvent keyEvent(wxEVT_KEY_DOWN);
         wxTranslateKeyEvent(keyEvent, win, (Widget) 0, event);
 

-        return win->ProcessEvent( keyEvent );
+        return win->HandleWindowEvent( keyEvent );

     }
 
     return false;
     }
 
     return false;


@@ -319,12 +324,12 @@ bool CheckForKeyUp(XEvent* event)
 {
     if (event->xany.type == KeyRelease)
     {
 {
     if (event->xany.type == KeyRelease)
     {

-        Widget widget = XtWindowToWidget((Display*) wxGetDisplay(),
-                         event->xany.window);
+        Widget widget = XtWindowToWidget(event->xany.display,
+                                         event->xany.window);

         wxWindow* win = NULL;
 
         // Find the first wxWindow that corresponds to this event window
         wxWindow* win = NULL;
 
         // Find the first wxWindow that corresponds to this event window

-        while (widget && !(win = wxGetWindowFromTable(widget)))
+        while (widget && ((win = wxGetWindowFromTable(widget))!=NULL))

                 widget = XtParent(widget);
 
         if (!widget || !win)
                 widget = XtParent(widget);
 
         if (!widget || !win)


@@ -333,7 +338,7 @@ bool CheckForKeyUp(XEvent* event)
         wxKeyEvent keyEvent(wxEVT_KEY_UP);
         wxTranslateKeyEvent(keyEvent, win, (Widget) 0, event);
 
         wxKeyEvent keyEvent(wxEVT_KEY_UP);
         wxTranslateKeyEvent(keyEvent, win, (Widget) 0, event);
 

-        return win->ProcessEvent( keyEvent );
+        return win->HandleWindowEvent( keyEvent );

     }
 
     return false;
     }
 
     return false;


@@ -343,7 +348,7 @@ bool CheckForKeyUp(XEvent* event)
 // executes one main loop iteration (declared in include/wx/motif/private.h)
 // ----------------------------------------------------------------------------
 
 // executes one main loop iteration (declared in include/wx/motif/private.h)
 // ----------------------------------------------------------------------------
 

-bool wxDoEventLoopIteration( wxEventLoop& evtLoop )
+bool wxDoEventLoopIteration( wxGUIEventLoop& evtLoop )

 {
     bool moreRequested, pendingEvents;
 
 {
     bool moreRequested, pendingEvents;
 


@@ -361,7 +366,7 @@ bool wxDoEventLoopIteration( wxEventLoop& evtLoop )
         // leave the main loop to give other threads a chance to
         // perform their GUI work
         wxMutexGuiLeave();
         // leave the main loop to give other threads a chance to
         // perform their GUI work
         wxMutexGuiLeave();

-        wxUsleep(20);
+        wxMilliSleep(20);

         wxMutexGuiEnter();
     }
 #endif
         wxMutexGuiEnter();
     }
 #endif


@@ -385,13 +390,10 @@ bool wxDoEventLoopIteration( wxEventLoop& evtLoop )
 // also wxEventLoop::Exit is implemented that way, so that exiting an
 // event loop won't require an event being in the queue
 
 // also wxEventLoop::Exit is implemented that way, so that exiting an
 // event loop won't require an event being in the queue
 

-#include "wx/module.h"
-

 #include <sys/types.h>
 #include <sys/time.h>
 #include <unistd.h>
 
 #include <sys/types.h>
 #include <sys/time.h>
 #include <unistd.h>
 

-static XtInputId inputId;

 static int idleFds[2] = { -1, -1 };
 
 class wxIdlePipeModule : public wxModule
 static int idleFds[2] = { -1, -1 };
 
 class wxIdlePipeModule : public wxModule


@@ -401,9 +403,11 @@ public:
 
     virtual bool OnInit()
     {
 
     virtual bool OnInit()
     {

+        // Must be done before modules are initialized
+#if 0

         if( pipe(idleFds) != 0 )
             return false;
         if( pipe(idleFds) != 0 )
             return false;

-
+#endif

         return true;
     }
 
         return true;
     }
 


@@ -413,10 +417,10 @@ public:
         close( idleFds[1] );
     }
 private:
         close( idleFds[1] );
     }
 private:

-    DECLARE_DYNAMIC_CLASS(wxIdlePipeModule);
+    DECLARE_DYNAMIC_CLASS(wxIdlePipeModule)

 };
 
 };
 

-IMPLEMENT_DYNAMIC_CLASS(wxIdlePipeModule, wxModule);
+IMPLEMENT_DYNAMIC_CLASS(wxIdlePipeModule, wxModule)

 
 static void wxInputCallback( XtPointer, int* fd, XtInputId* )
 {
 
 static void wxInputCallback( XtPointer, int* fd, XtInputId* )
 {


@@ -431,8 +435,8 @@ static void wxInputCallback( XtPointer, int* fd, XtInputId* )
         timeout.tv_sec = 0;
         timeout.tv_usec = 0;
 
         timeout.tv_sec = 0;
         timeout.tv_usec = 0;
 

-        FD_ZERO( &in );
-        FD_SET( *fd, &in );
+        wxFD_ZERO( &in );
+        wxFD_SET( *fd, &in );

 
         if( select( *fd + 1, &in, NULL, NULL, &timeout ) <= 0 )
             break;
 
         if( select( *fd + 1, &in, NULL, NULL, &timeout ) <= 0 )
             break;


@@ -443,7 +447,7 @@ static void wxInputCallback( XtPointer, int* fd, XtInputId* )
 
 static void wxBreakDispatch()
 {
 
 static void wxBreakDispatch()
 {

-    char dummy;
+    char dummy = 0; // for valgrind

 
     // check if wxWakeUpIdle has already been called
     fd_set in;
 
     // check if wxWakeUpIdle has already been called
     fd_set in;


@@ -452,8 +456,8 @@ static void wxBreakDispatch()
     timeout.tv_sec = 0;
     timeout.tv_usec = 0;
 
     timeout.tv_sec = 0;
     timeout.tv_usec = 0;
 

-    FD_ZERO( &in );
-    FD_SET( idleFds[0], &in );
+    wxFD_ZERO( &in );
+    wxFD_SET( idleFds[0], &in );

 
     if( select( idleFds[0] + 1, &in, NULL, NULL, &timeout ) > 0 )
         return;
 
     if( select( idleFds[0] + 1, &in, NULL, NULL, &timeout ) > 0 )
         return;


@@ -462,20 +466,29 @@ static void wxBreakDispatch()
     write( idleFds[1], &dummy, 1 );
 }
 
     write( idleFds[1], &dummy, 1 );
 }
 

-void wxWakeUpIdle()
+void wxApp::WakeUpIdle()

 {
     ::wxBreakDispatch();
 }
 
 {
     ::wxBreakDispatch();
 }
 

+bool wxInitIdleFds()
+{
+    if( pipe(idleFds) != 0 )
+        return false;
+    return true;
+}
+

 bool wxAddIdleCallback()
 {
 bool wxAddIdleCallback()
 {

+    if (!wxInitIdleFds())
+        return false;
+

     // install input handler for wxWakeUpIdle
     // install input handler for wxWakeUpIdle

-    inputId = XtAppAddInput( (XtAppContext) wxTheApp->GetAppContext(),
-                             idleFds[0],
-                             (XtPointer)XtInputReadMask,
-                             wxInputCallback,
-                             NULL );
+    XtAppAddInput((XtAppContext) wxTheApp->GetAppContext(),
+                  idleFds[0],
+                  (XtPointer)XtInputReadMask,
+                  wxInputCallback,
+                  NULL);

 
     return true;
 }
 
     return true;
 }

-