]> git.saurik.com Git - wxWidgets.git/blobdiff - src/os2/app.cpp
submenu preparation in two methods encapsulated
[wxWidgets.git] / src / os2 / app.cpp
index e895010722c4d5dc1c43a96ed7d232bee0be2739..4d47ed155090c453d394595a8f36bbb5ffa47924 100644 (file)
@@ -9,6 +9,10 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
+#ifdef __GNUG__
+    #pragma implementation "app.h"
+#endif
+
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
@@ -27,8 +31,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"
 
 #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 <sys/ioctl.h>
+#include <sys/select.h>
+#include <sys/time.h>
+
+#endif //
+
+#ifndef __EMX__
+
+#define select(a,b,c,d,e) bsdselect(a,b,c,d,e)
+extern "C" 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"
 
     #include "wx/resource.h"
 #endif
 
     #include "wx/resource.h"
 #endif
 
+#if wxUSE_TOOLTIPS
+    #include "wx/tooltip.h"
+#endif // wxUSE_TOOLTIPS
+
 #include <string.h>
 #include <ctype.h>
 
 #include <string.h>
 #include <ctype.h>
 
 // ---------------------------------------------------------------------------
 
 extern wxChar*                      wxBuffer;
 // ---------------------------------------------------------------------------
 
 extern wxChar*                      wxBuffer;
-extern wxChar*                      wxOsVersion;
 extern wxList*                      wxWinHandleList;
 extern wxList WXDLLEXPORT           wxPendingDelete;
 extern wxCursor*                    g_globalCursor;
 
 extern wxList*                      wxWinHandleList;
 extern wxList WXDLLEXPORT           wxPendingDelete;
 extern wxCursor*                    g_globalCursor;
 
-HINSTANCE                           wxhInstance = 0;
+HAB                                 vHabmain = NULLHANDLE;
 QMSG                                svCurrentMsg;
 wxApp*                              wxTheApp = NULL;
 QMSG                                svCurrentMsg;
 wxApp*                              wxTheApp = NULL;
-HAB                                 vHabmain = NULL;
 
 
-// FIXME why not const? and not static?
-
-// NB: all "NoRedraw" classes must have the same names as the "normal" classes
-//     with NR suffix - wxWindow::OS2Create() supposes this
-wxChar wxFrameClassName[]                 = wxT("wxFrameClass");
-wxChar wxFrameClassNameNoRedraw[]         = wxT("wxFrameClassNR");
-wxChar wxMDIFrameClassName[]              = wxT("wxMDIFrameClass");
-wxChar wxMDIFrameClassNameNoRedraw[]      = wxT("wxMDIFrameClassNR");
-wxChar wxMDIChildFrameClassName[]         = wxT("wxMDIChildFrameClass");
-wxChar wxMDIChildFrameClassNameNoRedraw[] = wxT("wxMDIChildFrameClassNR");
-wxChar wxPanelClassName[]                 = wxT("wxPanelClass");
-wxChar wxCanvasClassName[]                = wxT("wxCanvasClass");
 
 HICON wxSTD_FRAME_ICON          = (HICON) NULL;
 HICON wxSTD_MDICHILDFRAME_ICON  = (HICON) NULL;
 
 HICON wxSTD_FRAME_ICON          = (HICON) NULL;
 HICON wxSTD_MDICHILDFRAME_ICON  = (HICON) NULL;
@@ -92,16 +111,111 @@ HICON wxDEFAULT_MDIPARENTFRAME_ICON  = (HICON) NULL;
 
 HBRUSH wxDisableButtonBrush = (HBRUSH) 0;
 
 
 HBRUSH wxDisableButtonBrush = (HBRUSH) 0;
 
-MRESULT wxWndProc( HWND
-                  ,ULONG
-                  ,MPARAM
-                  ,MPARAM
-                 );
+MRESULT EXPENTRY wxWndProc( HWND hWnd,ULONG message,MPARAM mp1,MPARAM mp2);
+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
 // ---------------------------------------------------------------------------
@@ -114,37 +228,43 @@ MRESULT wxWndProc( HWND
         EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
     END_EVENT_TABLE()
 
         EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
     END_EVENT_TABLE()
 
-//// Initialize
+//
+// Initialize
+//
 bool wxApp::Initialize(
   HAB                               vHab
 )
 {
 bool wxApp::Initialize(
   HAB                               vHab
 )
 {
-    //
-    // OS2 has to have an anchorblock
-    //
-    vHab = WinInitialize(0);
-
-    if (!vHab)
-        return FALSE;
-    else
-        vHabmain = vHab;
-
-    // Some people may wish to use this, but
-    // probably it shouldn't be here by default.
-#ifdef __WXDEBUG__
-    //    wxRedirectIOToConsole();
+#if defined(wxUSE_CONSOLEDEBUG)
+  #if wxUSE_CONSOLEDEBUG
+/***********************************************/
+/* Code for using stdout debug                 */
+/* To use it you mast link app as "Window" - EK*/
+/***********************************************/
+  {
+     PPIB pib;
+     PTIB tib;
+
+    printf("In console\n");
+
+  DosGetInfoBlocks(&tib, &pib);
+/* Try morphing into a PM application. */
+//  if(pib->pib_ultype == 2)    /* VIO */
+    pib->pib_ultype = 3;
+   }
+/**********************************************/
+/**********************************************/
+  #endif //wxUSE_CONSOLEDEBUG
 #endif
 
     wxBuffer = new wxChar[1500]; // FIXME; why?
 
     wxClassInfo::InitializeClasses();
 
 #endif
 
     wxBuffer = new wxChar[1500]; // FIXME; why?
 
     wxClassInfo::InitializeClasses();
 
-#if wxUSE_RESOURCES
-    wxGetResource(wxT("wxWindows"), wxT("OsVersion"), &wxOsVersion);
+#if wxUSE_THREADS
+    wxPendingEventsLocker = new wxCriticalSection;
 #endif
 
 #endif
 
-    // I'm annoyed ... I don't know where to put this and I don't want to
-    // create a module for that as it's part of the core.
     wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
     wxTheColourDatabase->Initialize();
 
     wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
     wxTheColourDatabase->Initialize();
 
@@ -157,18 +277,22 @@ bool wxApp::Initialize(
 
     wxBitmap::InitStandardHandlers();
 
 
     wxBitmap::InitStandardHandlers();
 
-    g_globalCursor = new wxCursor;
+    //
+    // OS2 has to have an anchorblock
+    //
+    vHab = WinInitialize(0);
 
 
-#if 0
-    wxSTD_FRAME_ICON = ::WinLoadFileIcon(wxT("wxSTD_FRAME"), TRUE);
-    wxSTD_MDIPARENTFRAME_ICON = ::WinLoadFileIcon(wxT("wxSTD_MDIPARENTFRAME"), TRUE);
-    wxSTD_MDICHILDFRAME_ICON = ::WinLoadFileIcon(wxT("wxSTD_MDICHILDFRAME"), TRUE);
+    if (!vHab)
+        return FALSE;
+    else
+        vHabmain = vHab;
 
 
-    wxDEFAULT_FRAME_ICON = ::WinLoadFileIcon(wxT("wxDEFAULT_FRAME"), TRUE);
-    wxDEFAULT_MDIPARENTFRAME_ICON = ::WinLoadFileIcon(wxT("wxDEFAULT_MDIPARENTFRAME"), TRUE);
-    wxDEFAULT_MDICHILDFRAME_ICON = ::WinLoadFileIcon(wxT("wxDEFAULT_MDICHILDFRAME"), TRUE);
+    // Some people may wish to use this, but
+    // probably it shouldn't be here by default.
+#ifdef __WXDEBUG__
+    //    wxRedirectIOToConsole();
 #endif
 #endif
-    RegisterWindowClasses(vHab);
+
     wxWinHandleList = new wxList(wxKEY_INTEGER);
 
     // This is to foil optimizations in Visual C++ that throw out dummy.obj.
     wxWinHandleList = new wxList(wxKEY_INTEGER);
 
     // This is to foil optimizations in Visual C++ that throw out dummy.obj.
@@ -183,30 +307,28 @@ bool wxApp::Initialize(
     wxModule::RegisterModules();
     if (!wxModule::InitializeModules())
         return FALSE;
     wxModule::RegisterModules();
     if (!wxModule::InitializeModules())
         return FALSE;
+    RegisterWindowClasses(vHab);
     return TRUE;
     return TRUE;
-}
+} // end of wxApp::Initialize
 
 
+const char*                         CANTREGISTERCLASS = " Can't register Class ";
 // ---------------------------------------------------------------------------
 // RegisterWindowClasses
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // RegisterWindowClasses
 // ---------------------------------------------------------------------------
 
-// TODO we should only register classes really used by the app. For this it
-//      would be enough to just delay the class registration until an attempt
-//      to create a window of this class is made.
 bool wxApp::RegisterWindowClasses(
   HAB                               vHab
 )
 {
 bool wxApp::RegisterWindowClasses(
   HAB                               vHab
 )
 {
-    APIRET                          rc;
     ERRORID                         vError = 0L;
     wxString                        sError;
 
     ERRORID                         vError = 0L;
     wxString                        sError;
 
-    if ((rc = ::WinRegisterClass( vHab
-                                 ,wxFrameClassName
-                                 ,(PFNWP)wxWndProc
-                                 ,CS_SIZEREDRAW | CS_SYNCPAINT | CS_FRAME
-                                 ,0
-                                )) != 0)
+    if (!::WinRegisterClass( vHab
+                            ,wxFrameClassName
+                            ,wxFrameWndProc
+                            ,CS_SIZEREDRAW | CS_SYNCPAINT
+                            ,sizeof(ULONG)
+                           ))
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
@@ -214,12 +336,12 @@ bool wxApp::RegisterWindowClasses(
         return FALSE;
     }
 
         return FALSE;
     }
 
-    if ((rc = ::WinRegisterClass( vHab
-                                 ,wxFrameClassNameNoRedraw
-                                 ,(PFNWP)wxWndProc
-                                 ,CS_FRAME
-                                 ,0
-                                )) != 0)
+    if (!::WinRegisterClass( vHab
+                            ,wxFrameClassNameNoRedraw
+                            ,wxWndProc
+                            ,0
+                            ,sizeof(ULONG)
+                           ))
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
@@ -227,12 +349,12 @@ bool wxApp::RegisterWindowClasses(
         return FALSE;
     }
 
         return FALSE;
     }
 
-    if ((rc = ::WinRegisterClass( vHab
-                                 ,wxMDIFrameClassName
-                                 ,(PFNWP)wxWndProc
-                                 ,CS_SIZEREDRAW | CS_SYNCPAINT | CS_FRAME
-                                 ,0
-                                )) != 0)
+    if (!::WinRegisterClass( vHab
+                            ,wxMDIFrameClassName
+                            ,wxWndProc
+                            ,CS_SIZEREDRAW | CS_MOVENOTIFY | CS_SYNCPAINT
+                            ,sizeof(ULONG)
+                           ))
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
@@ -240,12 +362,12 @@ bool wxApp::RegisterWindowClasses(
         return FALSE;
     }
 
         return FALSE;
     }
 
-    if ((rc = ::WinRegisterClass( vHab
-                                 ,wxMDIFrameClassNameNoRedraw
-                                 ,(PFNWP)wxWndProc
-                                 ,CS_FRAME
-                                 ,0
-                                )) != 0)
+    if (!::WinRegisterClass( vHab
+                            ,wxMDIFrameClassNameNoRedraw
+                            ,wxWndProc
+                            ,0
+                            ,sizeof(ULONG)
+                           ))
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
@@ -253,12 +375,12 @@ bool wxApp::RegisterWindowClasses(
         return FALSE;
     }
 
         return FALSE;
     }
 
-    if ((rc = ::WinRegisterClass( vHab
-                                 ,wxMDIChildFrameClassName
-                                 ,(PFNWP)wxWndProc
-                                 ,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_SYNCPAINT | CS_HITTEST | CS_FRAME
-                                 ,0
-                                )) != 0)
+    if (!::WinRegisterClass( vHab
+                            ,wxMDIChildFrameClassName
+                            ,wxWndProc
+                            ,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_SYNCPAINT | CS_HITTEST
+                            ,sizeof(ULONG)
+                           ))
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
@@ -266,12 +388,12 @@ bool wxApp::RegisterWindowClasses(
         return FALSE;
     }
 
         return FALSE;
     }
 
-    if ((rc = ::WinRegisterClass( vHab
-                                 ,wxMDIChildFrameClassNameNoRedraw
-                                 ,(PFNWP)wxWndProc
-                                 ,CS_HITTEST | CS_FRAME
-                                 ,0
-                                )) != 0)
+    if (!::WinRegisterClass( vHab
+                            ,wxMDIChildFrameClassNameNoRedraw
+                            ,wxWndProc
+                            ,CS_HITTEST
+                            ,sizeof(ULONG)
+                           ))
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
@@ -279,12 +401,12 @@ bool wxApp::RegisterWindowClasses(
         return FALSE;
     }
 
         return FALSE;
     }
 
-    if ((rc = ::WinRegisterClass( vHab
-                                 ,wxPanelClassName
-                                 ,(PFNWP)wxWndProc
-                                 ,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_HITTEST | CS_SAVEBITS | CS_SYNCPAINT
-                                 ,0
-                                )) != 0)
+    if (!::WinRegisterClass( vHab
+                            ,wxPanelClassName
+                            ,wxWndProc
+                            ,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_HITTEST | CS_SAVEBITS | CS_SYNCPAINT
+                            ,sizeof(ULONG)
+                           ))
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
@@ -292,12 +414,24 @@ bool wxApp::RegisterWindowClasses(
         return FALSE;
     }
 
         return FALSE;
     }
 
-    if ((rc = ::WinRegisterClass( vHab
-                                 ,wxCanvasClassName
-                                 ,(PFNWP)wxWndProc
-                                 ,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_HITTEST | CS_SAVEBITS | CS_SYNCPAINT
-                                 ,0
-                                )) != 0)
+    if (!::WinRegisterClass( vHab
+                            ,wxCanvasClassName
+                            ,wxWndProc
+                            ,CS_SIZEREDRAW | CS_HITTEST | CS_SYNCPAINT
+                            ,sizeof(ULONG)
+                           ))
+    {
+        vError = ::WinGetLastError(vHab);
+        sError = wxPMErrorToStr(vError);
+        wxLogLastError(sError);
+        return FALSE;
+    }
+    if (!::WinRegisterClass( vHab
+                            ,wxCanvasClassNameNR
+                            ,wxWndProc
+                            ,CS_HITTEST | CS_SYNCPAINT
+                            ,sizeof(ULONG)
+                           ))
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
     {
         vError = ::WinGetLastError(vHab);
         sError = wxPMErrorToStr(vError);
@@ -305,46 +439,49 @@ bool wxApp::RegisterWindowClasses(
         return FALSE;
     }
     return TRUE;
         return FALSE;
     }
     return TRUE;
-}
-
-//// Cleans up any wxWindows internal structures left lying around
+} // end of wxApp::RegisterWindowClasses
 
 
+//
+// Cleans up any wxWindows internal structures left lying around
+//
 void wxApp::CleanUp()
 {
 void wxApp::CleanUp()
 {
-    //// COMMON CLEANUP
+    //
+    // COMMON CLEANUP
+    //
 
 #if wxUSE_LOG
 
 #if wxUSE_LOG
-    // flush the logged messages if any and install a 'safer' log target: the
+
+    //
+    // Flush the logged messages if any and install a 'safer' log target: the
     // default one (wxLogGui) can't be used after the resources are freed just
     // below and the user suppliedo ne might be even more unsafe (using any
     // wxWindows GUI function is unsafe starting from now)
     // default one (wxLogGui) can't be used after the resources are freed just
     // below and the user suppliedo ne might be even more unsafe (using any
     // wxWindows GUI function is unsafe starting from now)
+    //
     wxLog::DontCreateOnDemand();
 
     wxLog::DontCreateOnDemand();
 
-    // this will flush the old messages if any
+    //
+    // This will flush the old messages if any
+    //
     delete wxLog::SetActiveTarget(new wxLogStderr);
 #endif // wxUSE_LOG
 
     delete wxLog::SetActiveTarget(new wxLogStderr);
 #endif // wxUSE_LOG
 
+    //
     // One last chance for pending objects to be cleaned up
     // One last chance for pending objects to be cleaned up
+    //
     wxTheApp->DeletePendingObjects();
 
     wxModule::CleanUpModules();
 
 #if wxUSE_WX_RESOURCES
     wxCleanUpResourceSystem();
     wxTheApp->DeletePendingObjects();
 
     wxModule::CleanUpModules();
 
 #if wxUSE_WX_RESOURCES
     wxCleanUpResourceSystem();
-
-    //  wxDefaultResourceTable->ClearTable();
 #endif
 
 #endif
 
-    // Indicate that the cursor can be freed, so that cursor won't be deleted
-    // by deleting the bitmap list before g_globalCursor goes out of scope
-    // (double deletion of the cursor).
-    wxSetCursor(wxNullCursor);
-    delete g_globalCursor;
-    g_globalCursor = NULL;
-
     wxDeleteStockObjects();
 
     wxDeleteStockObjects();
 
+    //
     // Destroy all GDI lists, etc.
     // Destroy all GDI lists, etc.
+    //
     wxDeleteStockLists();
 
     delete wxTheColourDatabase;
     wxDeleteStockLists();
 
     delete wxTheColourDatabase;
@@ -355,7 +492,9 @@ void wxApp::CleanUp()
     delete[] wxBuffer;
     wxBuffer = NULL;
 
     delete[] wxBuffer;
     wxBuffer = NULL;
 
-    //// WINDOWS-SPECIFIC CLEANUP
+    //
+    // PM-SPECIFIC CLEANUP
+    //
 
     // wxSetKeyboardHook(FALSE);
 
 
     // wxSetKeyboardHook(FALSE);
 
@@ -381,10 +520,8 @@ void wxApp::CleanUp()
     if (wxWinHandleList)
         delete wxWinHandleList;
 
     if (wxWinHandleList)
         delete wxWinHandleList;
 
-    // GL: I'm annoyed ... I don't know where to put this and I don't want to
-    // create a module for that as it's part of the core.
-#if wxUSE_THREADS
     delete wxPendingEvents;
     delete wxPendingEvents;
+#if wxUSE_THREADS
     delete wxPendingEventsLocker;
     // If we don't do the following, we get an apparent memory leak.
     ((wxEvtHandler&) wxDefaultValidator).ClearEventLocker();
     delete wxPendingEventsLocker;
     // If we don't do the following, we get an apparent memory leak.
     ((wxEvtHandler&) wxDefaultValidator).ClearEventLocker();
@@ -392,6 +529,10 @@ void wxApp::CleanUp()
 
     wxClassInfo::CleanUpClasses();
 
 
     wxClassInfo::CleanUpClasses();
 
+    // Delete Message queue
+    if (wxTheApp->m_hMq)
+        ::WinDestroyMsgQueue(wxTheApp->m_hMq);
+
     delete wxTheApp;
     wxTheApp = NULL;
 
     delete wxTheApp;
     wxTheApp = NULL;
 
@@ -413,8 +554,11 @@ void wxApp::CleanUp()
     // do it as the very last thing because everything else can log messages
     delete wxLog::SetActiveTarget(NULL);
 #endif // wxUSE_LOG
     // do it as the very last thing because everything else can log messages
     delete wxLog::SetActiveTarget(NULL);
 #endif // wxUSE_LOG
-}
+} // end of wxApp::CleanUp
 
 
+//----------------------------------------------------------------------
+// Main wxWindows entry point
+//----------------------------------------------------------------------
 int wxEntry(
   int                               argc
 , char*                             argv[]
 int wxEntry(
   int                               argc
 , char*                             argv[]
@@ -430,17 +574,14 @@ int wxEntry(
     //
     if (!wxTheApp)
     {
     //
     if (!wxTheApp)
     {
-        wxCHECK_MSG( wxApp::GetInitializerFunction()
-                    ,-1
-                    ,wxT("wxWindows error: No initializer - use IMPLEMENT_APP macro.\n")
-                   );
-
-        wxAppInitializerFunction    fnAppIni = wxApp::GetInitializerFunction();
-        wxObject*                   pTest_app = fnAppIni();
-
-        wxTheApp = (wxApp*)pTest_app;
+        // The app may have declared a global application object, but we recommend
+        // the IMPLEMENT_APP macro is used instead, which sets an initializer
+        // function for delayed, dynamic app object construction.
+        wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
+                     wxT("No initializer - use IMPLEMENT_APP macro.") );
+        wxTheApp = (*wxApp::GetInitializerFunction()) ();
     }
     }
-    wxCHECK_MSG( wxTheApp, -1, wxT("wxWindows error: no application object") );
+    wxCHECK_MSG( wxTheApp, 0, wxT("You have to define an instance of wxApp!") );
     wxTheApp->argc = argc;
 
 #if wxUSE_UNICODE
     wxTheApp->argc = argc;
 
 #if wxUSE_UNICODE
@@ -472,14 +613,10 @@ int wxEntry(
     {
         if (wxTheApp->OnInit())
         {
     {
         if (wxTheApp->OnInit())
         {
-            nRetValue = -1;
+            wxTheApp->OnRun();
         }
         }
-    }
-
-    if (nRetValue == 0)
-    {
+        // Normal exit
         wxWindow*                   pTopWindow = wxTheApp->GetTopWindow();
         wxWindow*                   pTopWindow = wxTheApp->GetTopWindow();
-
         if (pTopWindow)
         {
             // Forcibly delete the window.
         if (pTopWindow)
         {
             // Forcibly delete the window.
@@ -496,17 +633,36 @@ int wxEntry(
             }
         }
     }
             }
         }
     }
-    wxTheApp->OnExit();
+    else // app initialization failed
+    {
+        wxLogLastError(" Gui initialization failed, exitting");
+    }
+#if wxUSE_CONSOLEDEBUG
+    printf("wxTheApp->OnExit ");
+    fflush(stdout);
+#endif
+    nRetValue = wxTheApp->OnExit();
+#if wxUSE_CONSOLEDEBUG
+    printf("wxApp::CleanUp ");
+    fflush(stdout);
+#endif
     wxApp::CleanUp();
     wxApp::CleanUp();
+#if wxUSE_CONSOLEDEBUG
+    printf("return %i ", nRetValue);
+    fflush(stdout);
+#endif
     return(nRetValue);
     return(nRetValue);
-}
+} // end of wxEntry
 
 bool wxApp::OnInitGui()
 {
     ERRORID                         vError;
     wxString                        sError;
 
 
 bool wxApp::OnInitGui()
 {
     ERRORID                         vError;
     wxString                        sError;
 
-    m_hMq    = WinCreateMsgQueue(vHabmain, 0);
+    if (!wxAppBase::OnInitGui())
+        return FALSE;
+
+    m_hMq = ::WinCreateMsgQueue(vHabmain, 0);
     if (!m_hMq)
     {
         vError = ::WinGetLastError(vHabmain);
     if (!m_hMq)
     {
         vError = ::WinGetLastError(vHabmain);
@@ -514,8 +670,9 @@ bool wxApp::OnInitGui()
         wxLogDebug(sError);
         return FALSE;
     }
         wxLogDebug(sError);
         return FALSE;
     }
+
     return TRUE;
     return TRUE;
-}
+} // end of wxApp::OnInitGui
 
 //
 // Static member initialization
 
 //
 // Static member initialization
@@ -526,27 +683,32 @@ wxApp::wxApp()
 {
     m_topWindow = NULL;
     wxTheApp = this;
 {
     m_topWindow = NULL;
     wxTheApp = this;
-    m_wantDebugOutput = TRUE;
 
     argc = 0;
     argv = NULL;
     m_nPrintMode = wxPRINT_WINDOWS;
 
     argc = 0;
     argv = NULL;
     m_nPrintMode = wxPRINT_WINDOWS;
-    m_exitOnFrameDelete = TRUE;
     m_bAuto3D = TRUE;
     m_bAuto3D = TRUE;
-}
+    m_hMq = 0;
+    m_maxSocketHandles = 0;
+    m_maxSocketNr = 0;
+    m_sockCallbackInfo = 0;
+} // end of wxApp::wxApp
 
 wxApp::~wxApp()
 {
 
 wxApp::~wxApp()
 {
-#if wxUSE_UNICODE
+    //
     // Delete command-line args
     // Delete command-line args
-    int i;
+    //
+#if wxUSE_UNICODE
+    int                             i;
+
     for (i = 0; i < argc; i++)
     {
         delete[] argv[i];
     }
     delete[] argv;
 #endif
     for (i = 0; i < argc; i++)
     {
         delete[] argv[i];
     }
     delete[] argv;
 #endif
-}
+} // end of wxApp::~wxApp
 
 bool wxApp::Initialized()
 {
 
 bool wxApp::Initialized()
 {
@@ -554,15 +716,16 @@ bool wxApp::Initialized()
         return TRUE;
     else
         return FALSE;
         return TRUE;
     else
         return FALSE;
-}
+} // end of 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 wxApp::DoMessage()
 {
-    BOOL                            bRc = ::WinGetMsg(vHabmain, &m_vMsg, HWND(NULL), 0, 0);
+    BOOL                            bRc = ::WinGetMsg(vHabmain, &svCurrentMsg, HWND(NULL), 0, 0);
 
     if (bRc == 0)
     {
 
     if (bRc == 0)
     {
@@ -586,7 +749,7 @@ bool wxApp::DoMessage()
         static wxMsgArray           svSavedMessages;
 
         //
         static wxMsgArray           svSavedMessages;
 
         //
-        // if a secondary thread owns is doing GUI calls, save all messages for
+        // If a secondary thread owns is doing GUI calls, save all messages for
         // later processing - we can't process them right now because it will
         // lead to recursive library calls (and we're not reentrant)
         //
         // later processing - we can't process them right now because it will
         // lead to recursive library calls (and we're not reentrant)
         //
@@ -594,8 +757,10 @@ bool wxApp::DoMessage()
         {
             sbHadGuiLock = FALSE;
 
         {
             sbHadGuiLock = FALSE;
 
-            // leave out WM_COMMAND messages: too dangerous, sometimes
+            //
+            // Leave out WM_COMMAND messages: too dangerous, sometimes
             // the message will be processed twice
             // the message will be processed twice
+            //
             if ( !wxIsWaitingForThread() ||
                     svCurrentMsg.msg != WM_COMMAND )
             {
             if ( !wxIsWaitingForThread() ||
                     svCurrentMsg.msg != WM_COMMAND )
             {
@@ -606,12 +771,9 @@ bool wxApp::DoMessage()
         else
         {
             //
         else
         {
             //
-            // have we just regained the GUI lock? if so, post all of the saved
+            // Have we just regained the GUI lock? if so, post all of the saved
             // messages
             //
             // messages
             //
-            // FIXME of course, it's not _exactly_ the same as processing the
-            //       messages normally - expect some things to break...
-            //
             if (!sbHadGuiLock )
             {
                 sbHadGuiLock = TRUE;
             if (!sbHadGuiLock )
             {
                 sbHadGuiLock = TRUE;
@@ -622,24 +784,30 @@ bool wxApp::DoMessage()
                 {
                     QMSG            vMsg = svSavedMessages[n];
 
                 {
                     QMSG            vMsg = svSavedMessages[n];
 
-                    if ( !ProcessMessage((WXMSG *)&vMsg) )
-                    {
-                        ::WinDispatchMsg(vHabmain, &vMsg);
-                    }
+                    DoMessage((WXMSG*)&vMsg);
                 }
                 svSavedMessages.Empty();
             }
         }
 #endif // wxUSE_THREADS
 
                 }
                 svSavedMessages.Empty();
             }
         }
 #endif // wxUSE_THREADS
 
+        //
         // Process the message
         // Process the message
-        if (!ProcessMessage((WXMSG *)&svCurrentMsg) )
-        {
-            ::WinDispatchMsg(vHabmain, (PQMSG)&svCurrentMsg);
-        }
+        //
+        DoMessage((WXMSG *)&svCurrentMsg);
     }
     return TRUE;
     }
     return TRUE;
-}
+} // end of wxApp::DoMessage
+
+void wxApp::DoMessage(
+  WXMSG*                            pMsg
+)
+{
+    if (!ProcessMessage((WXMSG *)&svCurrentMsg))
+    {
+        ::WinDispatchMsg(vHabmain, (PQMSG)&svCurrentMsg);
+    }
+} // end of wxApp::DoMessage
 
 //////////////////////////////////////////////////////////////////////////////
 //
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -665,14 +833,20 @@ int wxApp::MainLoop()
 #if wxUSE_THREADS
         wxMutexGuiLeaveOrEnter();
 #endif // wxUSE_THREADS
 #if wxUSE_THREADS
         wxMutexGuiLeaveOrEnter();
 #endif // wxUSE_THREADS
-        while (!::WinPeekMsg(vHabmain, &svCurrentMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) &&
-                ProcessIdle() )
+        while (!Pending() && ProcessIdle())
         {
         {
+            HandleSockets();
+            wxUsleep(10000);
         }
         }
-        DoMessage();
+        HandleSockets();
+        if (Pending())
+            DoMessage();
+        else
+            wxUsleep(10000);
+
     }
     return (int)svCurrentMsg.mp1;
     }
     return (int)svCurrentMsg.mp1;
-}
+} // end of wxApp::MainLoop
 
 //
 // Returns TRUE if more time is needed.
 
 //
 // Returns TRUE if more time is needed.
@@ -684,34 +858,17 @@ bool wxApp::ProcessIdle()
     vEvent.SetEventObject(this);
     ProcessEvent(vEvent);
     return vEvent.MoreRequested();
     vEvent.SetEventObject(this);
     ProcessEvent(vEvent);
     return vEvent.MoreRequested();
-}
-
-#if wxUSE_THREADS
-void wxApp::ProcessPendingEvents()
-{
-    wxNode*                         pNode = wxPendingEvents->First();
-    wxCriticalSectionLocker         vLocker(*wxPendingEventsLocker);
-
-    while (pNode)
-    {
-        wxEvtHandler*               pHandler = (wxEvtHandler *)pNode->Data();
-        pHandler->ProcessPendingEvents();
-
-        delete pNode;
-        pNode = wxPendingEvents->First();
-    }
-}
-#endif
+} // end of wxApp::ProcessIdle
 
 void wxApp::ExitMainLoop()
 {
 
 void wxApp::ExitMainLoop()
 {
-    m_bKeepGoing = FALSE;
-}
+    ::WinPostMsg(NULL, WM_QUIT, 0, 0);
+} // end of wxApp::ExitMainLoop
 
 bool wxApp::Pending()
 {
     return (::WinPeekMsg(vHabmain, (PQMSG)&svCurrentMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) != 0);
 
 bool wxApp::Pending()
 {
     return (::WinPeekMsg(vHabmain, (PQMSG)&svCurrentMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) != 0);
-}
+} // end of wxApp::Pending
 
 void wxApp::Dispatch()
 {
 
 void wxApp::Dispatch()
 {
@@ -729,13 +886,34 @@ bool wxApp::ProcessMessage(
   WXMSG*                            pWxmsg
 )
 {
   WXMSG*                            pWxmsg
 )
 {
-    QMSG*                           vMsg = (PQMSG)pWxmsg;
-    HWND                            hWnd = vMsg->hwnd;
+    QMSG*                           pMsg = (PQMSG)pWxmsg;
+    HWND                            hWnd = pMsg->hwnd;
     wxWindow*                       pWndThis = wxFindWinFromHandle((WXHWND)hWnd);
     wxWindow*                       pWnd;
 
     //
     wxWindow*                       pWndThis = wxFindWinFromHandle((WXHWND)hWnd);
     wxWindow*                       pWnd;
 
     //
-    // for some composite controls (like a combobox), wndThis might be NULL
+    // Pass non-system timer messages to the wxTimerProc
+    //
+    if (pMsg->msg == WM_TIMER &&
+        (SHORT1FROMMP(pMsg->mp1) != TID_CURSOR &&
+         SHORT1FROMMP(pMsg->mp1) != TID_FLASHWINDOW &&
+         SHORT1FROMMP(pMsg->mp1) != TID_SCROLL &&
+         SHORT1FROMMP(pMsg->mp1) != 0x0000
+        ))
+        wxTimerProc(NULL, 0, (int)pMsg->mp1, 0);
+
+    //
+    // Allow the window to prevent certain messages from being
+    // translated/processed (this is currently used by wxTextCtrl to always
+    // grab Ctrl-C/V/X, even if they are also accelerators in some parent)
+    //
+    if (pWndThis && !pWndThis->OS2ShouldPreProcessMessage(pWxmsg))
+    {
+        return FALSE;
+    }
+
+    //
+    // For some composite controls (like a combobox), wndThis might be NULL
     // because the subcontrol is not a wxWindow, but only the control itself
     // is - try to catch this case
     //
     // because the subcontrol is not a wxWindow, but only the control itself
     // is - try to catch this case
     //
@@ -745,28 +923,69 @@ bool wxApp::ProcessMessage(
         pWndThis = wxFindWinFromHandle((WXHWND)hWnd);
     }
 
         pWndThis = wxFindWinFromHandle((WXHWND)hWnd);
     }
 
-    // Anyone for a non-translation message? Try youngest descendants first.
-    for (pWnd = pWndThis; pWnd; pWnd = pWnd->GetParent())
+    //
+    // Try translations first; find the youngest window with
+    // a translation table. OS/2 has case sensative accels, so
+    // this block, coded by BK, removes that and helps make them
+    // case insensative.
+    //
+    if(pMsg->msg == WM_CHAR)
     {
     {
-        if (pWnd->OS2ProcessMessage(pWxmsg))
-            return TRUE;
+       PBYTE                        pChmsg = (PBYTE)&(pMsg->msg);
+       USHORT                       uSch  = CHARMSG(pChmsg)->chr;
+       bool                         bRc;
+
+       //
+       // Do not process keyup events
+       //
+       if(!(CHARMSG(pChmsg)->fs & KC_KEYUP))
+       {
+           if((CHARMSG(pChmsg)->fs & (KC_ALT | KC_CTRL)) && CHARMSG(pChmsg)->chr != 0)
+                CHARMSG(pChmsg)->chr = (USHORT)wxToupper((UCHAR)uSch);
+
+
+           for(pWnd = pWndThis; pWnd; pWnd = pWnd->GetParent() )
+           {
+               if((bRc = pWnd->OS2TranslateMessage(pWxmsg)) == TRUE)
+                   break;
+           }
+
+            if(!bRc)    // untranslated, should restore original value
+                CHARMSG(pChmsg)->chr = uSch;
+        }
     }
     }
+    //
+    // Anyone for a non-translation message? Try youngest descendants first.
+    //
+//  for (pWnd = pWndThis; pWnd; pWnd = pWnd->GetParent())
+//  {
+//      if (pWnd->OS2ProcessMessage(pWxmsg))
+//          return TRUE;
+//  }
     return FALSE;
     return FALSE;
-}
+} // end of wxApp::ProcessMessage
+
+bool                                gbInOnIdle = FALSE;
 
 void wxApp::OnIdle(
   wxIdleEvent&                      rEvent
 )
 {
 
 void wxApp::OnIdle(
   wxIdleEvent&                      rEvent
 )
 {
-    static bool                     sbInOnIdle = FALSE;
 
     //
     // Avoid recursion (via ProcessEvent default case)
     //
 
     //
     // Avoid recursion (via ProcessEvent default case)
     //
-    if (sbInOnIdle )
+    if (gbInOnIdle)
         return;
 
         return;
 
-    sbInOnIdle = TRUE;
+    gbInOnIdle = TRUE;
+
+    //
+    // If there are pending events, we must process them: pending events
+    // are either events to the threads other than main or events posted
+    // with wxPostEvent() functions
+    //
+    ProcessPendingEvents();
 
     //
     // 'Garbage' collection of windows deleted with Close().
 
     //
     // 'Garbage' collection of windows deleted with Close().
@@ -774,14 +993,25 @@ void wxApp::OnIdle(
     DeletePendingObjects();
 
 #if wxUSE_LOG
     DeletePendingObjects();
 
 #if wxUSE_LOG
-    // flush the logged messages if any
-    wxLog*                          pLog = wxLog::GetActiveTarget();
-
-    if (pLog != NULL && pLog->HasPendingMessages())
-        pLog->Flush();
+    //
+    // Flush the logged messages if any
+    //
+    wxLog::FlushActive();
 #endif // wxUSE_LOG
 
 #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(HWND_DESKTOP, VK_BUTTON1) &&
+        !::WinGetKeyState(HWND_DESKTOP, VK_BUTTON3) &&
+        !::WinGetKeyState(HWND_DESKTOP, VK_BUTTON2))
+        wxDC::ClearCache();
+#endif // wxUSE_DC_CACHEING
+
+    //
     // Send OnIdle events to all windows
     // Send OnIdle events to all windows
+    //
     if (SendIdleEvents())
     {
         //
     if (SendIdleEvents())
     {
         //
@@ -790,21 +1020,8 @@ void wxApp::OnIdle(
         //
         rEvent.RequestMore(TRUE);
     }
         //
         rEvent.RequestMore(TRUE);
     }
-
-    //
-    // If they are pending events, we must process them.
-    //
-#if wxUSE_THREADS
-    ProcessPendingEvents();
-#endif
-    sbInOnIdle = FALSE;
-}
-
-void wxWakeUpIdle()
-{
-    // **** please implement me! ****
-    // Wake up the idle handler processor, even if it is in another thread...
-}
+    gbInOnIdle = FALSE;
+} // end of wxApp::OnIdle
 
 // Send idle event to all top-level windows
 bool wxApp::SendIdleEvents()
 
 // Send idle event to all top-level windows
 bool wxApp::SendIdleEvents()
@@ -821,7 +1038,7 @@ bool wxApp::SendIdleEvents()
         pNode = pNode->GetNext();
     }
     return bNeedMore;
         pNode = pNode->GetNext();
     }
     return bNeedMore;
-}
+} // end of wxApp::SendIdleEvents
 
 //
 // Send idle event to window and all subwindows
 
 //
 // Send idle event to window and all subwindows
@@ -850,7 +1067,7 @@ bool wxApp::SendIdleEvents(
         pNode = pNode->Next();
     }
     return bNeedMore;
         pNode = pNode->Next();
     }
     return bNeedMore;
-}
+} // end of wxApp::SendIdleEvents
 
 void wxApp::DeletePendingObjects()
 {
 
 void wxApp::DeletePendingObjects()
 {
@@ -871,14 +1088,14 @@ void wxApp::DeletePendingObjects()
         //
         pNode = wxPendingDelete.First();
     }
         //
         pNode = wxPendingDelete.First();
     }
-}
+} // end of wxApp::DeletePendingObjects
 
 void wxApp::OnEndSession(
   wxCloseEvent&                     WXUNUSED(rEvent))
 {
     if (GetTopWindow())
         GetTopWindow()->Close(TRUE);
 
 void wxApp::OnEndSession(
   wxCloseEvent&                     WXUNUSED(rEvent))
 {
     if (GetTopWindow())
         GetTopWindow()->Close(TRUE);
-}
+} // end of wxApp::OnEndSession
 
 //
 // Default behaviour: close the application with prompts. The
 
 //
 // Default behaviour: close the application with prompts. The
@@ -893,66 +1110,152 @@ void wxApp::OnQueryEndSession(
         if (!GetTopWindow()->Close(!rEvent.CanVeto()))
             rEvent.Veto(TRUE);
     }
         if (!GetTopWindow()->Close(!rEvent.CanVeto()))
             rEvent.Veto(TRUE);
     }
-}
+} // end of wxApp::OnQueryEndSession
 
 void wxExit()
 {
     wxLogError(_("Fatal error: exiting"));
 
     wxApp::CleanUp();
 
 void wxExit()
 {
     wxLogError(_("Fatal error: exiting"));
 
     wxApp::CleanUp();
-}
+} // end of wxExit
 
 
+//
 // Yield to incoming messages
 // Yield to incoming messages
-bool wxYield()
+//
+bool wxApp::Yield(bool onlyIfNeeded)
 {
 {
+    static bool s_inYield = FALSE;
+
+    if ( s_inYield )
+    {
+        if ( !onlyIfNeeded )
+        {
+            wxFAIL_MSG( _T("wxYield() called recursively") );
+        }
+
+        return FALSE;
+    }
+
     HAB                             vHab = 0;
     QMSG                            vMsg;
     HAB                             vHab = 0;
     QMSG                            vMsg;
+
+    //
+    // Disable log flushing from here because a call to wxYield() shouldn't
+    // normally result in message boxes popping up &c
+    //
+    wxLog::Suspend();
+
+    s_inYield = TRUE;
+
+    //
     // We want to go back to the main message loop
     // if we see a WM_QUIT. (?)
     // We want to go back to the main message loop
     // if we see a WM_QUIT. (?)
+    //
     while (::WinPeekMsg(vHab, &vMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) && vMsg.msg != WM_QUIT)
     {
     while (::WinPeekMsg(vHab, &vMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) && vMsg.msg != WM_QUIT)
     {
+#if wxUSE_THREADS
+        wxMutexGuiLeaveOrEnter();
+#endif // wxUSE_THREADS
         if (!wxTheApp->DoMessage())
             break;
     }
         if (!wxTheApp->DoMessage())
             break;
     }
+    //
     // If they are pending events, we must process them.
     // If they are pending events, we must process them.
-#if wxUSE_THREADS
-    wxTheApp->ProcessPendingEvents();
-#endif
+    //
+    if (wxTheApp)
+        wxTheApp->ProcessPendingEvents();
+
+    //
+    // Let the logs be flashed again
+    //
+    wxLog::Resume();
+    s_inYield = FALSE;
     return TRUE;
     return TRUE;
-}
+} // end of wxYield
 
 
-wxIcon wxApp::GetStdIcon(
-  int                               nWhich
-) const
+int wxApp::AddSocketHandler(int handle, int mask,
+                            void (*callback)(void*), void * gsock)
 {
 {
-    switch(nWhich)
+    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)
     {
     {
-        case wxICON_INFORMATION:
-            return wxIcon("wxICON_INFO");
+        // 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;
+}
 
 
-        case wxICON_QUESTION:
-            return wxIcon("wxICON_QUESTION");
+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;
+    }
+}
 
 
-        case wxICON_EXCLAMATION:
-            return wxIcon("wxICON_WARNING");
+//-----------------------------------------------------------------------------
+// wxWakeUpIdle
+//-----------------------------------------------------------------------------
 
 
-        default:
-            wxFAIL_MSG(wxT("requested non existent standard icon"));
-            // still fall through
+void wxWakeUpIdle()
+{
+    //
+    // Send the top window a dummy message so idle handler processing will
+    // start up again.  Doing it this way ensures that the idle handler
+    // wakes up in the right thread (see also wxWakeUpMainThread() which does
+    // the same for the main app thread only)
+    //
+    wxWindow*                       pTopWindow = wxTheApp->GetTopWindow();
 
 
-        case wxICON_HAND:
-            return wxIcon("wxICON_ERROR");
+    if (pTopWindow)
+    {
+        if ( !::WinPostMsg(GetHwndOf(pTopWindow), WM_NULL, (MPARAM)0, (MPARAM)0))
+        {
+            //
+            // Should never happen
+            //
+            wxLogLastError("PostMessage(WM_NULL)");
+        }
     }
     }
-    return wxIcon("wxICON_ERROR");
-}
+} // end of wxWakeUpIdle
 
 
-HINSTANCE wxGetInstance()
+HAB wxGetInstance()
 {
 {
-    return wxhInstance;
+    return vHabmain;
 }
 
 }
 
-void wxSetInstance(HINSTANCE hInst)
+void wxSetInstance(
+  HAB                               vHab
+)
 {
 {
-    wxhInstance = hInst;
+    vHabmain = vHab;
 }
 
 }