#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>
#include "wx/timer.h"
-#if !defined(__GNUWIN32__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__)
+#if !defined(__GNUWIN32__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
#include <direct.h>
#ifndef __MWERKS__
#include <lm.h>
#endif // USE_NET_API
-#if defined(__WIN32__) && !defined(__WXMICROWIN__)
+#if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
#ifndef __UNIX__
#include <io.h>
#endif
#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
// ----------------------------------------------------------------------------
static const wxChar WX_SECTION[] = wxT("wxWindows");
static const wxChar eUSERNAME[] = wxT("UserName");
-// these are only used under Win16
-#if !defined(__WIN32__) && !defined(__WXMICROWIN__)
-static const wxChar eHOSTNAME[] = wxT("HostName");
-static const wxChar eUSERID[] = wxT("UserId");
-#endif // !Win32
-
// ============================================================================
// implementation
// ============================================================================
// Get hostname only (without domain name)
bool wxGetHostName(wxChar *buf, int maxSize)
{
-#if defined(__WIN32__) && !defined(__WXMICROWIN__)
+#if defined(__WXWINCE__)
+ return FALSE;
+#elif defined(__WIN32__) && !defined(__WXMICROWIN__)
DWORD nSize = maxSize;
if ( !::GetComputerName(buf, &nSize) )
{
// 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
+ // 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 (and don't complain if it is
+ // missing, we handle this)
+ wxLogNull noLog;
- WSADATA wsa;
- if ( WSAStartup(MAKEWORD(1, 1), &wsa) == 0 )
+ 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);
}
// Get user ID e.g. jacs
bool wxGetUserId(wxChar *buf, int maxSize)
{
-#if defined(__WIN32__) && !defined(__win32s__) && !defined(__WXMICROWIN__)
+#if defined(__WXWINCE__)
+ return FALSE;
+#elif defined(__WIN32__) && !defined(__WXMICROWIN__)
DWORD nSize = maxSize;
if ( ::GetUserName(buf, &nSize) == 0 )
{
}
return TRUE;
-#else // Win16 or Win32s
+#else // __WXMICROWIN__
wxChar *user;
const wxChar *default_id = wxT("anonymous");
// Get user name e.g. Julian Smart
bool wxGetUserName(wxChar *buf, int maxSize)
{
-#ifdef USE_NET_API
+#if defined(__WXWINCE__)
+ return FALSE;
+#elif defined(USE_NET_API)
CHAR szUserName[256];
if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )
return FALSE;
#else // !USE_NET_API
// Could use NIS, MS-Mail or other site specific programs
// Use wxWindows configuration data
- bool ok = GetProfileString(WX_SECTION, eUSERNAME, wxT(""), buf, maxSize - 1) != 0;
+ bool ok = GetProfileString(WX_SECTION, eUSERNAME, wxEmptyString, buf, maxSize - 1) != 0;
if ( !ok )
{
ok = wxGetUserId(buf, maxSize);
const wxChar* wxGetHomeDir(wxString *pstr)
{
- wxString& strDir = *pstr;
+ wxString& strDir = *pstr;
- #if defined(__UNIX__)
+ // first branch is for Cygwin
+#if defined(__UNIX__)
const wxChar *szHome = wxGetenv("HOME");
if ( szHome == NULL ) {
// we're homeless...
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
- #else // Windows
- #ifdef __WIN32__
- strDir.clear();
+#elif defined(__WXWINCE__)
+ // Nothing
+#else
+ 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
// 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);
- #endif // UNIX/Win
+ // 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))
#elif defined(__WIN32__)
DWORD attribs = GetFileAttributes(dir);
return ((attribs != (DWORD)-1) && (attribs & FILE_ATTRIBUTE_DIRECTORY));
-#else // Win16
- #ifdef __BORLANDC__
- struct ffblk fileInfo;
- #else
- struct find_t fileInfo;
- #endif
- // In Borland findfirst has a different argument
- // ordering from _dos_findfirst. But _dos_findfirst
- // _should_ be ok in both MS and Borland... why not?
- #ifdef __BORLANDC__
- return (findfirst(dir, &fileInfo, _A_SUBDIR) == 0 &&
- (fileInfo.ff_attrib & _A_SUBDIR) != 0);
- #else
- return (_dos_findfirst(dir, _A_SUBDIR, &fileInfo) == 0) &&
- ((fileInfo.attrib & _A_SUBDIR) != 0);
- #endif
-#endif // Win32/16
+#endif // Win32/__WXMICROWIN__
}
bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
{
+#ifdef __WXWINCE__
+ return FALSE;
+#else
if ( path.empty() )
return FALSE;
}
return TRUE;
+#endif
+ // __WXWINCE__
}
// ----------------------------------------------------------------------------
bool wxGetEnv(const wxString& var, wxString *value)
{
-#ifdef __WIN16__
- const wxChar* ret = wxGetenv(var);
- if ( !ret )
- return FALSE;
-
- if ( value )
- {
- *value = ret;
- }
-
- return TRUE;
+#ifdef __WXWINCE__
+ return FALSE;
#else // Win32
// first get the size of the buffer
DWORD dwRet = ::GetEnvironmentVariable(var, NULL, 0);
if ( value )
{
- (void)::GetEnvironmentVariable(var, value->GetWriteBuf(dwRet), dwRet);
- value->UngetWriteBuf();
+ (void)::GetEnvironmentVariable(var, wxStringBuffer(*value, dwRet),
+ dwRet);
}
return TRUE;
-#endif // Win16/32
+#endif // WinCE/32
}
bool wxSetEnv(const wxString& var, const wxChar *value)
{
// some compilers have putenv() or _putenv() or _wputenv() but it's better
// to always use Win32 function directly instead of dealing with them
-#if defined(__WIN32__)
+#if defined(__WIN32__) && !defined(__WXWINCE__)
if ( !::SetEnvironmentVariable(var, value) )
{
wxLogLastError(_T("SetEnvironmentVariable"));
// Execute a program in an Interactive Shell
bool wxShell(const wxString& command)
{
+#ifdef __WXWINCE__
+ return FALSE;
+#else
wxChar *shell = wxGetenv(wxT("COMSPEC"));
if ( !shell )
shell = (wxChar*) wxT("\\COMMAND.COM");
}
return wxExecute(cmd, wxEXEC_SYNC) == 0;
+#endif
}
// Shutdown or reboot the PC
bool wxShutdown(wxShutdownFlags wFlags)
{
-#ifdef __WIN32__
+#ifdef __WXWINCE__
+ return FALSE;
+#elif defined(__WIN32__)
bool bOK = TRUE;
if ( wxGetOsVersion(NULL, NULL) == wxWINDOWS_NT ) // if is NT or 2K
return FALSE;
}
- bOK = ::ExitWindowsEx(EWX_SHUTDOWN | EWX_FORCE | EWX_REBOOT, 0) != 0;
+ bOK = ::ExitWindowsEx(flags, 0) != 0;
}
return bOK;
-#else // Win16
- return FALSE;
#endif // Win32/16
}
unsigned long wxGetProcessId()
{
-#ifdef __WIN32__
return ::GetCurrentProcessId();
-#else
- return 0;
-#endif
}
// Emit a beeeeeep
wxString wxGetOsDescription()
{
-#ifdef __WIN32__
wxString str;
OSVERSIONINFO info;
}
return str;
-#else // Win16
- return _("Windows 3.1");
-#endif // Win32/16
}
-int wxAppTraits::GetOSVersion(int *verMaj, int *verMin)
+wxToolkitInfo& wxAppTraits::GetToolkitInfo()
{
// cache the version info, it's not going to change
//
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;
}
// ----------------------------------------------------------------------------
#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;
+}
projects / wxWidgets.git / blobdiff