added base parameter to wxString::To[U]Long

[wxWidgets.git] / src / os2 / app.cpp

diff --git a/src/os2/app.cpp b/src/os2/app.cpp
index 40ef90f53a65c063e333dc5ada8aaf323cf736ca..6ef2a2253d6e1220891dd821d2ab0e8d04d5440d 100644 (file)
--- a/src/os2/app.cpp
+++ b/src/os2/app.cpp
@@ -27,8 +27,9 @@
     #include "wx/msgdlg.h"
     #include "wx/intl.h"
     #include "wx/dynarray.h"
     #include "wx/msgdlg.h"
     #include "wx/intl.h"
     #include "wx/dynarray.h"

-#   include "wx/wxchar.h"
-#   include "wx/icon.h"
+    #include "wx/wxchar.h"
+    #include "wx/icon.h"
+    #include "wx/timer.h"

 #endif
 
 #include "wx/log.h"
 #endif
 
 #include "wx/log.h"


@@ -36,6 +37,30 @@
 
 #include "wx/os2/private.h"
 
 
 #include "wx/os2/private.h"
 

+#ifdef __EMX__
+
+#include <sys\ioctl.h>
+#include <sys\select.h>
+
+#else
+
+#include <nerrno.h>
+#include <ioctl.h>
+#include <select.h>
+
+#endif // ndef for __EMX__
+
+#ifndef __EMX__
+
+#define select(a,b,c,d,e) bsdselect(a,b,c,d,e)
+int _System bsdselect(int,
+                      struct fd_set *,
+                      struct fd_set *,
+                      struct fd_set *,
+                      struct timeval *);
+
+#endif
+

 #if wxUSE_THREADS
     #include "wx/thread.h"
 
 #if wxUSE_THREADS
     #include "wx/thread.h"
 


@@ -99,6 +124,104 @@ MRESULT EXPENTRY wxFrameWndProc( HWND hWnd,ULONG message,MPARAM mp1,MPARAM mp2);
 // implementation
 // ===========================================================================
 
 // implementation
 // ===========================================================================
 

+// ---------------------------------------------------------------------------
+// helper struct and functions for socket handling
+// ---------------------------------------------------------------------------
+
+struct GsocketCallbackInfo{
+    void (*proc)(void *);
+    int type;
+    int handle;
+    void* gsock;
+};
+
+// These defines and wrapper functions are used here and in gsockpm.c
+#define wxSockReadMask  0x01
+#define wxSockWriteMask 0x02
+
+#ifdef __EMX__
+extern "C"
+int wxAppAddSocketHandler(int handle, int mask,
+                           void (*callback)(void*), void * gsock)
+{
+    return wxTheApp->AddSocketHandler(handle, mask, callback, gsock);
+}
+extern "C"
+void wxAppRemoveSocketHandler(int handle)
+{
+    wxTheApp->RemoveSocketHandler(handle);
+}
+#else
+//  Linkage mode problems using callbacks with extern C in a .cpp module
+int wxAppAddSocketHandler(int handle, int mask,
+                           void (*callback)(void*), void * gsock)
+{
+    return wxTheApp->AddSocketHandler(handle, mask, callback, gsock);
+}
+void wxAppRemoveSocketHandler(int handle)
+{
+    wxTheApp->RemoveSocketHandler(handle);
+}
+#endif
+
+void wxApp::HandleSockets()
+{
+    bool pendingEvent = FALSE;
+
+    // Check whether it's time for Gsocket operation
+    if (m_maxSocketHandles > 0 && m_maxSocketNr > 0)
+    {
+        fd_set readfds = m_readfds;
+        fd_set writefds = m_writefds;
+        struct timeval timeout;
+        int i;
+        struct GsocketCallbackInfo
+          *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
+        int r = 0;
+        timeout.tv_sec = 0;
+        timeout.tv_usec = 0;
+        if ( select(m_maxSocketNr, &readfds, &writefds, 0, &timeout) > 0)
+        {
+            for (i = m_lastUsedHandle + 1; i != m_lastUsedHandle; i++)
+            {
+                if (i == m_maxSocketNr)
+                    i = 0;
+                if (FD_ISSET(i, &readfds))
+                {
+                    int r;
+                    for (r = 0; r < m_maxSocketHandles; r++){
+                        if(CallbackInfo[r].handle == i &&
+                           CallbackInfo[r].type == wxSockReadMask)
+                            break;
+                    }
+                    if (r < m_maxSocketHandles)
+                    {
+                        CallbackInfo[r].proc(CallbackInfo[r].gsock);
+                        pendingEvent = TRUE;
+                        wxYield();
+                    }
+                }
+                if (FD_ISSET(i, &writefds))
+                {
+                    int r;
+                    for (r = 0; r < m_maxSocketHandles; r++)
+                        if(CallbackInfo[r].handle == i &&
+                           CallbackInfo[r].type == wxSockWriteMask)
+                            break;
+                    if (r < m_maxSocketHandles)
+                    {
+                        CallbackInfo[r].proc(CallbackInfo[r].gsock);
+                        pendingEvent = TRUE;
+                        wxYield();
+                    }
+                }
+            }
+            m_lastUsedHandle = i;
+        }
+        if (pendingEvent)
+            wxYield();
+    }
+}

 // ---------------------------------------------------------------------------
 // wxApp
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // wxApp
 // ---------------------------------------------------------------------------


@@ -559,6 +682,9 @@ wxApp::wxApp()
     m_exitOnFrameDelete = TRUE;
     m_bAuto3D = TRUE;
     m_hMq = 0;
     m_exitOnFrameDelete = TRUE;
     m_bAuto3D = TRUE;
     m_hMq = 0;

+    m_maxSocketHandles = 0;
+    m_maxSocketNr = 0;
+    m_sockCallbackInfo = 0;

 } // end of wxApp::wxApp
 
 wxApp::~wxApp()
 } // end of wxApp::wxApp
 
 wxApp::~wxApp()


@@ -589,6 +715,7 @@ bool wxApp::Initialized()
 // Get and process a message, returning FALSE if WM_QUIT
 // received (and also set the flag telling the app to exit the main loop)
 //
 // Get and process a message, returning FALSE if WM_QUIT
 // received (and also set the flag telling the app to exit the main loop)
 //

+

 bool wxApp::DoMessage()
 {
     BOOL                            bRc = ::WinGetMsg(vHabmain, &svCurrentMsg, HWND(NULL), 0, 0);
 bool wxApp::DoMessage()
 {
     BOOL                            bRc = ::WinGetMsg(vHabmain, &svCurrentMsg, HWND(NULL), 0, 0);


@@ -660,15 +787,24 @@ bool wxApp::DoMessage()
         }
 #endif // wxUSE_THREADS
 
         }
 #endif // wxUSE_THREADS
 

+        //

         // Process the message
         // Process the message

-        if (!ProcessMessage((WXMSG *)&svCurrentMsg))
-        {
-            ::WinDispatchMsg(vHabmain, (PQMSG)&svCurrentMsg);
-        }
+        //
+        DoMessage((WXMSG *)&svCurrentMsg);

     }
     return TRUE;
 } // end of wxApp::DoMessage
 
     }
     return TRUE;
 } // end of wxApp::DoMessage
 

+void wxApp::DoMessage(
+  WXMSG*                            pMsg
+)
+{
+    if (!ProcessMessage((WXMSG *)&svCurrentMsg))
+    {
+        ::WinDispatchMsg(vHabmain, (PQMSG)&svCurrentMsg);
+    }
+} // end of wxApp::DoMessage
+

 //////////////////////////////////////////////////////////////////////////////
 //
 // Keep trying to process messages until WM_QUIT
 //////////////////////////////////////////////////////////////////////////////
 //
 // Keep trying to process messages until WM_QUIT


@@ -693,11 +829,17 @@ int wxApp::MainLoop()
 #if wxUSE_THREADS
         wxMutexGuiLeaveOrEnter();
 #endif // wxUSE_THREADS
 #if wxUSE_THREADS
         wxMutexGuiLeaveOrEnter();
 #endif // wxUSE_THREADS

-        while (/*Pending() &&*/ ProcessIdle())
+        while (!Pending() && ProcessIdle())

         {
         {

-//          wxUsleep(10000);
+            HandleSockets();
+            wxUsleep(10000);

         }
         }

-        DoMessage();
+        HandleSockets();
+        if (Pending())
+            DoMessage();
+        else
+            wxUsleep(10000);
+

     }
     return (int)svCurrentMsg.mp1;
 } // end of wxApp::MainLoop
     }
     return (int)svCurrentMsg.mp1;
 } // end of wxApp::MainLoop


@@ -852,6 +994,16 @@ void wxApp::OnIdle(
     wxLog::FlushActive();
 #endif // wxUSE_LOG
 
     wxLog::FlushActive();
 #endif // wxUSE_LOG
 

+#if wxUSE_DC_CACHEING
+    // automated DC cache management: clear the cached DCs and bitmap
+    // if it's likely that the app has finished with them, that is, we
+    // get an idle event and we're not dragging anything.
+    if (!::WinGetKeyState(MK_LBUTTON) &&
+        !::WinGetKeyState(MK_MBUTTON) &&
+        !::WinGetKeyState(MK_RBUTTON))
+        wxDC::ClearCache();
+#endif // wxUSE_DC_CACHEING
+

     //
     // Send OnIdle events to all windows
     //
     //
     // Send OnIdle events to all windows
     //


@@ -1011,7 +1163,7 @@ bool wxYieldIfNeeded()
 {
     if (gs_inYield)
         return FALSE;
 {
     if (gs_inYield)
         return FALSE;

-        
+

     return wxYield();
 }
 
     return wxYield();
 }
 


@@ -1040,6 +1192,54 @@ wxIcon wxApp::GetStdIcon(
     return wxIcon("wxICON_ERROR");
 } // end of wxApp::GetStdIcon
 
     return wxIcon("wxICON_ERROR");
 } // end of wxApp::GetStdIcon
 

+int wxApp::AddSocketHandler(int handle, int mask,
+                            void (*callback)(void*), void * gsock)
+{
+    int find;
+    struct GsocketCallbackInfo
+        *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
+
+    for (find = 0; find < m_maxSocketHandles; find++)
+        if (CallbackInfo[find].handle == -1)
+            break;
+    if (find == m_maxSocketHandles)
+    {
+        // Allocate new memory
+        m_sockCallbackInfo = realloc(m_sockCallbackInfo,
+                                     (m_maxSocketHandles+=10)*
+                                     sizeof(struct GsocketCallbackInfo));
+        CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
+        for (find = m_maxSocketHandles - 10; find < m_maxSocketHandles; find++)
+            CallbackInfo[find].handle = -1;
+        find = m_maxSocketHandles - 10;
+    }
+    CallbackInfo[find].proc = callback;
+    CallbackInfo[find].type = mask;
+    CallbackInfo[find].handle = handle;
+    CallbackInfo[find].gsock = gsock;
+    if (mask & wxSockReadMask)
+        FD_SET(handle, &m_readfds);
+    if (mask & wxSockWriteMask)
+        FD_SET(handle, &m_writefds);
+    if (handle >= m_maxSocketNr)
+        m_maxSocketNr = handle + 1;
+    return find;
+}
+
+void wxApp::RemoveSocketHandler(int handle)
+{
+    struct GsocketCallbackInfo
+        *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
+    if (handle < m_maxSocketHandles)
+    {
+        if (CallbackInfo[handle].type & wxSockReadMask)
+            FD_CLR(CallbackInfo[handle].handle, &m_readfds);
+        if (CallbackInfo[handle].type & wxSockWriteMask)
+            FD_CLR(CallbackInfo[handle].handle, &m_writefds);
+        CallbackInfo[handle].handle = -1;
+    }
+}
+

 //-----------------------------------------------------------------------------
 // wxWakeUpIdle
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxWakeUpIdle
 //-----------------------------------------------------------------------------