]> git.saurik.com Git - wxWidgets.git/blobdiff - src/msw/utils.cpp
Also allow key events for Shift-Tab when wxWANTS_CHARS style is used
[wxWidgets.git] / src / msw / utils.cpp
index aec073c7e5ab1fe8211f10188b5165e5cf6a97d6..7da8065ba3b4c1b7ff1c99ab6279fe40a33c0575 100644 (file)
 #endif  //WX_PRECOMP
 
 #include "wx/apptrait.h"
+#include "wx/dynload.h"
+
+#include "wx/confbase.h"        // for wxExpandEnvVars()
 
 #include "wx/msw/private.h"     // includes <windows.h>
 #include "wx/msw/missing.h"     // CHARSET_HANGUL
 
-#ifdef __GNUWIN32_OLD__
+#if defined(__GNUWIN32_OLD__) || defined(__WXWINCE__) \
+    || defined(__CYGWIN32__)
     // apparently we need to include winsock.h to get WSADATA and other stuff
     // used in wxGetFullHostName() with the old mingw32 versions
     #include <winsock.h>
     #endif
 #endif
 
-// ----------------------------------------------------------------------------
-// module globals
-// ----------------------------------------------------------------------------
-
-#if wxUSE_ON_FATAL_EXCEPTION
-    static bool gs_handleExceptions = FALSE;
+// 260 was taken from windef.h
+#ifndef MAX_PATH
+    #define MAX_PATH  260
 #endif
 
 // ----------------------------------------------------------------------------
@@ -151,53 +152,80 @@ bool wxGetHostName(wxChar *buf, int maxSize)
 // get full hostname (with domain name if possible)
 bool wxGetFullHostName(wxChar *buf, int maxSize)
 {
-#if defined(__WIN32__) && !defined(__WXMICROWIN__) && ! (defined(__GNUWIN32__) && !defined(__MINGW32__))
+#if !defined( __WXMICROWIN__) && wxUSE_DYNAMIC_LOADER
     // TODO should use GetComputerNameEx() when available
 
-    // the idea is that if someone had set wxUSE_SOCKETS to 0 the code
-    // shouldn't use winsock.dll (a.k.a. ws2_32.dll) at all so only use this
-    // code if we link with it anyhow
-#if wxUSE_SOCKETS
-
-    WSADATA wsa;
-    if ( WSAStartup(MAKEWORD(1, 1), &wsa) == 0 )
+    // we don't want to always link with Winsock DLL as we might not use it at
+    // all, so load it dynamically here if needed
+    wxDynamicLibrary dllWinsock(_T("ws2_32.dll"), wxDL_VERBATIM);
+    if ( dllWinsock.IsLoaded() )
     {
-        wxString host;
-        char bufA[256];
-        if ( gethostname(bufA, WXSIZEOF(bufA)) == 0 )
+        typedef int (PASCAL *WSAStartup_t)(WORD, WSADATA *);
+        typedef int (PASCAL *gethostname_t)(char *, int);
+        typedef hostent* (PASCAL *gethostbyname_t)(const char *);
+        typedef hostent* (PASCAL *gethostbyaddr_t)(const char *, int , int);
+        typedef int (PASCAL *WSACleanup_t)(void);
+
+        #define LOAD_WINSOCK_FUNC(func)                                       \
+            func ## _t                                                        \
+                pfn ## func = (func ## _t)dllWinsock.GetSymbol(_T(#func))
+
+        LOAD_WINSOCK_FUNC(WSAStartup);
+
+        WSADATA wsa;
+        if ( pfnWSAStartup && pfnWSAStartup(MAKEWORD(1, 1), &wsa) == 0 )
         {
-            // gethostname() won't usually include the DNS domain name, for
-            // this we need to work a bit more
-            if ( !strchr(bufA, '.') )
-            {
-                struct hostent *pHostEnt =  gethostbyname(bufA);
+            LOAD_WINSOCK_FUNC(gethostname);
 
-                if ( pHostEnt )
+            wxString host;
+            if ( pfngethostname )
+            {
+                char bufA[256];
+                if ( pfngethostname(bufA, WXSIZEOF(bufA)) == 0 )
                 {
-                    // Windows will use DNS internally now
-                    pHostEnt = gethostbyaddr(pHostEnt->h_addr, 4, AF_INET);
-                }
+                    // gethostname() won't usually include the DNS domain name,
+                    // for this we need to work a bit more
+                    if ( !strchr(bufA, '.') )
+                    {
+                        LOAD_WINSOCK_FUNC(gethostbyname);
 
-                if ( pHostEnt )
-                {
-                    host = wxString::FromAscii(pHostEnt->h_name);
+                        struct hostent *pHostEnt = pfngethostbyname
+                                                    ? pfngethostbyname(bufA)
+                                                    : NULL;
+
+                        if ( pHostEnt )
+                        {
+                            // Windows will use DNS internally now
+                            LOAD_WINSOCK_FUNC(gethostbyaddr);
+
+                            pHostEnt = pfngethostbyaddr
+                                        ? pfngethostbyaddr(pHostEnt->h_addr,
+                                                           4, AF_INET)
+                                        : NULL;
+                        }
+
+                        if ( pHostEnt )
+                        {
+                            host = wxString::FromAscii(pHostEnt->h_name);
+                        }
+                    }
                 }
             }
-        }
 
-        WSACleanup();
+            LOAD_WINSOCK_FUNC(WSACleanup);
+            if ( pfnWSACleanup )
+                pfnWSACleanup();
 
-        if ( !host.empty() )
-        {
-            wxStrncpy(buf, host, maxSize);
 
-            return TRUE;
+            if ( !host.empty() )
+            {
+                wxStrncpy(buf, host, maxSize);
+
+                return TRUE;
+            }
         }
     }
-
-#endif // wxUSE_SOCKETS
-
-#endif // Win32
+#endif // !__WXMICROWIN__
 
     return wxGetHostName(buf, maxSize);
 }
@@ -333,8 +361,9 @@ error:
 
 const wxChar* wxGetHomeDir(wxString *pstr)
 {
-  wxString& strDir = *pstr;
+    wxString& strDir = *pstr;
 
+    // first branch is for Cygwin
 #if defined(__UNIX__)
     const wxChar *szHome = wxGetenv("HOME");
     if ( szHome == NULL ) {
@@ -350,34 +379,33 @@ const wxChar* wxGetHomeDir(wxString *pstr)
       strDir << wxT('/');
 
     #ifdef __CYGWIN__
-      // Cygwin returns unix type path but that does not work well
-      static wxChar windowsPath[MAX_PATH];
-      cygwin_conv_to_full_win32_path(strDir, windowsPath);
-      strDir = windowsPath;
+        // Cygwin returns unix type path but that does not work well
+        static wxChar windowsPath[MAX_PATH];
+        cygwin_conv_to_full_win32_path(strDir, windowsPath);
+        strDir = windowsPath;
     #endif
 #elif defined(__WXWINCE__)
       // Nothing
 #else
-    #ifdef  __WIN32__
-      strDir.clear();
+    strDir.clear();
 
-      // If we have a valid HOME directory, as is used on many machines that
-      // have unix utilities on them, we should use that.
-      const wxChar *szHome = wxGetenv(wxT("HOME"));
+    // If we have a valid HOME directory, as is used on many machines that
+    // have unix utilities on them, we should use that.
+    const wxChar *szHome = wxGetenv(wxT("HOME"));
 
-      if ( szHome != NULL )
-      {
+    if ( szHome != NULL )
+    {
         strDir = szHome;
-      }
-      else // no HOME, try HOMEDRIVE/PATH
-      {
-          szHome = wxGetenv(wxT("HOMEDRIVE"));
-          if ( szHome != NULL )
+    }
+    else // no HOME, try HOMEDRIVE/PATH
+    {
+        szHome = wxGetenv(wxT("HOMEDRIVE"));
+        if ( szHome != NULL )
             strDir << szHome;
-          szHome = wxGetenv(wxT("HOMEPATH"));
+        szHome = wxGetenv(wxT("HOMEPATH"));
 
-          if ( szHome != NULL )
-          {
+        if ( szHome != NULL )
+        {
             strDir << szHome;
 
             // the idea is that under NT these variables have default values
@@ -387,45 +415,38 @@ const wxChar* wxGetHomeDir(wxString *pstr)
             // to set HOMEPATH to something other than "\\", we suppose that he
             // knows what he is doing and use the supplied value.
             if ( wxStrcmp(szHome, wxT("\\")) == 0 )
-              strDir.clear();
-          }
-      }
+                strDir.clear();
+        }
+    }
 
-      if ( strDir.empty() )
-      {
-          // If we have a valid USERPROFILE directory, as is the case in
-          // Windows NT, 2000 and XP, we should use that as our home directory.
-          szHome = wxGetenv(wxT("USERPROFILE"));
+    if ( strDir.empty() )
+    {
+        // If we have a valid USERPROFILE directory, as is the case in
+        // Windows NT, 2000 and XP, we should use that as our home directory.
+        szHome = wxGetenv(wxT("USERPROFILE"));
 
-          if ( szHome != NULL )
+        if ( szHome != NULL )
             strDir = szHome;
-      }
-
-      if ( !strDir.empty() )
-      {
-          return strDir.c_str();
-      }
-      //else: fall back to the prograrm directory
-    #else   // Win16
-      // Win16 has no idea about home, so use the executable directory instead
-    #endif  // WIN16/32
-
-    // 260 was taken from windef.h
-    #ifndef MAX_PATH
-      #define MAX_PATH  260
-    #endif
-
-    wxString strPath;
-    ::GetModuleFileName(::GetModuleHandle(NULL),
-                        strPath.GetWriteBuf(MAX_PATH), MAX_PATH);
-    strPath.UngetWriteBuf();
+    }
 
-    // extract the dir name
-    wxSplitPath(strPath, &strDir, NULL, NULL);
+    if ( !strDir.empty() )
+    {
+        // sometimes the value of HOME may be "%USERPROFILE%", so reexpand the
+        // value once again, it shouldn't hurt anyhow
+        strDir = wxExpandEnvVars(strDir);
+    }
+    else // fall back to the program directory
+    {
+        wxString strPath;
+        ::GetModuleFileName(::GetModuleHandle(NULL),
+                            wxStringBuffer(strPath, MAX_PATH), MAX_PATH);
 
+        // extract the dir name
+        wxSplitPath(strPath, &strDir, NULL, NULL);
+    }
 #endif  // UNIX/Win
 
-  return strDir.c_str();
+    return strDir.c_str();
 }
 
 wxChar *wxGetUserHome(const wxString& WXUNUSED(user))
@@ -602,8 +623,8 @@ bool wxGetEnv(const wxString& var, wxString *value)
 
     if ( value )
     {
-        (void)::GetEnvironmentVariable(var, value->GetWriteBuf(dwRet), dwRet);
-        value->UngetWriteBuf();
+        (void)::GetEnvironmentVariable(var, wxStringBuffer(*value, dwRet),
+                                       dwRet);
     }
 
     return TRUE;
@@ -902,7 +923,7 @@ bool wxShutdown(wxShutdownFlags wFlags)
                 return FALSE;
         }
 
-        bOK = ::ExitWindowsEx(EWX_SHUTDOWN | EWX_FORCE | EWX_REBOOT, 0) != 0;
+        bOK = ::ExitWindowsEx(flags, 0) != 0;
     }
 
     return bOK;
@@ -993,7 +1014,7 @@ wxString wxGetOsDescription()
 #endif // Win32/16
 }
 
-int wxAppTraits::GetOSVersion(int *verMaj, int *verMin)
+wxToolkitInfo& wxAppTraits::GetToolkitInfo()
 {
     // cache the version info, it's not going to change
     //
@@ -1028,20 +1049,21 @@ int wxAppTraits::GetOSVersion(int *verMaj, int *verMin)
                 case VER_PLATFORM_WIN32_NT:
                     s_ver = wxWINDOWS_NT;
                     break;
-
+#ifdef __WXWINCE__
                 case VER_PLATFORM_WIN32_CE:
                     s_ver = wxWINDOWS_CE;
                     break;
+#endif
             }
         }
     }
 
-    if ( verMaj )
-        *verMaj = s_major;
-    if ( verMin )
-        *verMin = s_minor;
-
-    return s_ver;
+    static wxToolkitInfo info;
+    info.versionMajor = s_major;
+    info.versionMinor = s_minor;
+    info.os = s_ver;
+    info.name = _T("wxBase");
+    return info;
 }
 
 // ----------------------------------------------------------------------------
@@ -1211,40 +1233,62 @@ extern long wxCharsetToCodepage(const wxChar *name)
 
 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
 
-// ----------------------------------------------------------------------------
-// wxApp::OnFatalException() support
-// ----------------------------------------------------------------------------
-
-bool wxHandleFatalExceptions(bool doit)
+/*
+  Creates a hidden window with supplied window proc registering the class for
+  it if necesssary (i.e. the first time only). Caller is responsible for
+  destroying the window and unregistering the class (note that this must be
+  done because wxWindows may be used as a DLL and so may be loaded/unloaded
+  multiple times into/from the same process so we cna't rely on automatic
+  Windows class unregistration).
+
+  pclassname is a pointer to a caller stored classname, which must initially be
+  NULL. classname is the desired wndclass classname. If function succesfully
+  registers the class, pclassname will be set to classname.
+ */
+extern "C" WXDLLIMPEXP_BASE HWND
+wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc)
 {
-#if wxUSE_ON_FATAL_EXCEPTION
-    // assume this can only be called from the main thread
-    gs_handleExceptions = doit;
+    wxCHECK_MSG( classname && pclassname && wndproc, NULL,
+                    _T("NULL parameter in wxCreateHiddenWindow") );
 
-    return TRUE;
-#else
-    wxFAIL_MSG(_T("set wxUSE_ON_FATAL_EXCEPTION to 1 to use this function"));
+    // register the class fi we need to first
+    if ( *pclassname == NULL )
+    {
+        WNDCLASS wndclass;
+        wxZeroMemory(wndclass);
 
-    (void)doit;
-    return FALSE;
-#endif
-}
+        wndclass.lpfnWndProc   = wndproc;
+        wndclass.hInstance     = wxGetInstance();
+        wndclass.lpszClassName = classname;
 
-#if wxUSE_ON_FATAL_EXCEPTION
+        if ( !::RegisterClass(&wndclass) )
+        {
+            wxLogLastError(wxT("RegisterClass() in wxCreateHiddenWindow"));
 
-extern unsigned long wxGlobalSEHandler()
-{
-    if ( gs_handleExceptions && wxTheApp )
-    {
-        // give the user a chance to do something special about this
-        wxTheApp->OnFatalException();
+            return NULL;
+        }
 
-        // this will execute our handler and terminate the process
-        return EXCEPTION_EXECUTE_HANDLER;
+        *pclassname = classname;
     }
 
-    return EXCEPTION_CONTINUE_SEARCH;
-}
+    // next create the window
+    HWND hwnd = ::CreateWindow
+                  (
+                    *pclassname,
+                    NULL,
+                    0, 0, 0, 0,
+                    0,
+                    (HWND) NULL,
+                    (HMENU)NULL,
+                    wxGetInstance(),
+                    (LPVOID) NULL
+                  );
+
+    if ( !hwnd )
+    {
+        wxLogLastError(wxT("CreateWindow() in wxCreateHiddenWindow"));
+    }
 
-#endif // wxUSE_ON_FATAL_EXCEPTION
+    return hwnd;
+}