1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Various utilities
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
34 #include "wx/apptrait.h"
35 #include "wx/dynlib.h"
36 #include "wx/dynload.h"
38 #include "wx/confbase.h" // for wxExpandEnvVars()
40 #include "wx/msw/private.h" // includes <windows.h>
41 #include "wx/msw/missing.h" // CHARSET_HANGUL
43 #if defined(__GNUWIN32_OLD__) || defined(__WXWINCE__) \
44 || defined(__CYGWIN32__)
45 // apparently we need to include winsock.h to get WSADATA and other stuff
46 // used in wxGetFullHostName() with the old mingw32 versions
52 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
60 #if defined(__CYGWIN__)
61 #include <sys/unistd.h>
63 #include <sys/cygwin.h> // for cygwin_conv_to_full_win32_path()
66 #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs
67 // this (3.1 I believe) and how to test for it.
68 // If this works for Borland 4.0 as well, then no worries.
72 // VZ: there is some code using NetXXX() functions to get the full user name:
73 // I don't think it's a good idea because they don't work under Win95 and
74 // seem to return the same as wxGetUserId() under NT. If you really want
75 // to use them, just #define USE_NET_API
82 #if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
93 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
98 // For wxKillAllChildren
101 // ----------------------------------------------------------------------------
103 // ----------------------------------------------------------------------------
105 // In the WIN.INI file
106 static const wxChar WX_SECTION
[] = wxT("wxWindows");
107 static const wxChar eUSERNAME
[] = wxT("UserName");
109 // ============================================================================
111 // ============================================================================
113 // ----------------------------------------------------------------------------
114 // get host name and related
115 // ----------------------------------------------------------------------------
117 // Get hostname only (without domain name)
118 bool wxGetHostName(wxChar
*buf
, int maxSize
)
120 #if defined(__WXWINCE__)
122 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
123 DWORD nSize
= maxSize
;
124 if ( !::GetComputerName(buf
, &nSize
) )
126 wxLogLastError(wxT("GetComputerName"));
134 const wxChar
*default_host
= wxT("noname");
136 if ((sysname
= wxGetenv(wxT("SYSTEM_NAME"))) == NULL
) {
137 GetProfileString(WX_SECTION
, eHOSTNAME
, default_host
, buf
, maxSize
- 1);
139 wxStrncpy(buf
, sysname
, maxSize
- 1);
140 buf
[maxSize
] = wxT('\0');
141 return *buf
? true : false;
145 // get full hostname (with domain name if possible)
146 bool wxGetFullHostName(wxChar
*buf
, int maxSize
)
148 #if !defined( __WXMICROWIN__) && wxUSE_DYNAMIC_LOADER
149 // TODO should use GetComputerNameEx() when available
151 // we don't want to always link with Winsock DLL as we might not use it at
152 // all, so load it dynamically here if needed (and don't complain if it is
153 // missing, we handle this)
156 wxDynamicLibrary
dllWinsock(_T("ws2_32.dll"), wxDL_VERBATIM
);
157 if ( dllWinsock
.IsLoaded() )
159 typedef int (PASCAL
*WSAStartup_t
)(WORD
, WSADATA
*);
160 typedef int (PASCAL
*gethostname_t
)(char *, int);
161 typedef hostent
* (PASCAL
*gethostbyname_t
)(const char *);
162 typedef hostent
* (PASCAL
*gethostbyaddr_t
)(const char *, int , int);
163 typedef int (PASCAL
*WSACleanup_t
)(void);
165 #define LOAD_WINSOCK_FUNC(func) \
167 pfn ## func = (func ## _t)dllWinsock.GetSymbol(_T(#func))
169 LOAD_WINSOCK_FUNC(WSAStartup
);
172 if ( pfnWSAStartup
&& pfnWSAStartup(MAKEWORD(1, 1), &wsa
) == 0 )
174 LOAD_WINSOCK_FUNC(gethostname
);
177 if ( pfngethostname
)
180 if ( pfngethostname(bufA
, WXSIZEOF(bufA
)) == 0 )
182 // gethostname() won't usually include the DNS domain name,
183 // for this we need to work a bit more
184 if ( !strchr(bufA
, '.') )
186 LOAD_WINSOCK_FUNC(gethostbyname
);
188 struct hostent
*pHostEnt
= pfngethostbyname
189 ? pfngethostbyname(bufA
)
194 // Windows will use DNS internally now
195 LOAD_WINSOCK_FUNC(gethostbyaddr
);
197 pHostEnt
= pfngethostbyaddr
198 ? pfngethostbyaddr(pHostEnt
->h_addr
,
205 host
= wxString::FromAscii(pHostEnt
->h_name
);
211 LOAD_WINSOCK_FUNC(WSACleanup
);
218 wxStrncpy(buf
, host
, maxSize
);
224 #endif // !__WXMICROWIN__
226 return wxGetHostName(buf
, maxSize
);
229 // Get user ID e.g. jacs
230 bool wxGetUserId(wxChar
*buf
, int maxSize
)
232 #if defined(__WXWINCE__)
234 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
235 DWORD nSize
= maxSize
;
236 if ( ::GetUserName(buf
, &nSize
) == 0 )
238 // actually, it does happen on Win9x if the user didn't log on
239 DWORD res
= ::GetEnvironmentVariable(wxT("username"), buf
, maxSize
);
248 #else // __WXMICROWIN__
250 const wxChar
*default_id
= wxT("anonymous");
252 // Can't assume we have NIS (PC-NFS) or some other ID daemon
254 if ( (user
= wxGetenv(wxT("USER"))) == NULL
&&
255 (user
= wxGetenv(wxT("LOGNAME"))) == NULL
)
257 // Use wxWidgets configuration data (comming soon)
258 GetProfileString(WX_SECTION
, eUSERID
, default_id
, buf
, maxSize
- 1);
262 wxStrncpy(buf
, user
, maxSize
- 1);
265 return *buf
? true : false;
269 // Get user name e.g. Julian Smart
270 bool wxGetUserName(wxChar
*buf
, int maxSize
)
272 #if defined(__WXWINCE__)
274 #elif defined(USE_NET_API)
275 CHAR szUserName
[256];
276 if ( !wxGetUserId(szUserName
, WXSIZEOF(szUserName
)) )
279 // TODO how to get the domain name?
282 // the code is based on the MSDN example (also see KB article Q119670)
283 WCHAR wszUserName
[256]; // Unicode user name
284 WCHAR wszDomain
[256];
287 USER_INFO_2
*ui2
; // User structure
289 // Convert ANSI user name and domain to Unicode
290 MultiByteToWideChar( CP_ACP
, 0, szUserName
, strlen(szUserName
)+1,
291 wszUserName
, WXSIZEOF(wszUserName
) );
292 MultiByteToWideChar( CP_ACP
, 0, szDomain
, strlen(szDomain
)+1,
293 wszDomain
, WXSIZEOF(wszDomain
) );
295 // Get the computer name of a DC for the domain.
296 if ( NetGetDCName( NULL
, wszDomain
, &ComputerName
) != NERR_Success
)
298 wxLogError(wxT("Can not find domain controller"));
303 // Look up the user on the DC
304 NET_API_STATUS status
= NetUserGetInfo( (LPWSTR
)ComputerName
,
305 (LPWSTR
)&wszUserName
,
306 2, // level - we want USER_INFO_2
314 case NERR_InvalidComputer
:
315 wxLogError(wxT("Invalid domain controller name."));
319 case NERR_UserNotFound
:
320 wxLogError(wxT("Invalid user name '%s'."), szUserName
);
325 wxLogSysError(wxT("Can't get information about user"));
330 // Convert the Unicode full name to ANSI
331 WideCharToMultiByte( CP_ACP
, 0, ui2
->usri2_full_name
, -1,
332 buf
, maxSize
, NULL
, NULL
);
337 wxLogError(wxT("Couldn't look up full user name."));
340 #else // !USE_NET_API
341 // Could use NIS, MS-Mail or other site specific programs
342 // Use wxWidgets configuration data
343 bool ok
= GetProfileString(WX_SECTION
, eUSERNAME
, wxEmptyString
, buf
, maxSize
- 1) != 0;
346 ok
= wxGetUserId(buf
, maxSize
);
351 wxStrncpy(buf
, wxT("Unknown User"), maxSize
);
358 const wxChar
* wxGetHomeDir(wxString
*pstr
)
360 wxString
& strDir
= *pstr
;
362 // first branch is for Cygwin
363 #if defined(__UNIX__)
364 const wxChar
*szHome
= wxGetenv("HOME");
365 if ( szHome
== NULL
) {
367 wxLogWarning(_("can't find user's HOME, using current directory."));
373 // add a trailing slash if needed
374 if ( strDir
.Last() != wxT('/') )
378 // Cygwin returns unix type path but that does not work well
379 static wxChar windowsPath
[MAX_PATH
];
380 cygwin_conv_to_full_win32_path(strDir
, windowsPath
);
381 strDir
= windowsPath
;
383 #elif defined(__WXWINCE__)
388 // If we have a valid HOME directory, as is used on many machines that
389 // have unix utilities on them, we should use that.
390 const wxChar
*szHome
= wxGetenv(wxT("HOME"));
392 if ( szHome
!= NULL
)
396 else // no HOME, try HOMEDRIVE/PATH
398 szHome
= wxGetenv(wxT("HOMEDRIVE"));
399 if ( szHome
!= NULL
)
401 szHome
= wxGetenv(wxT("HOMEPATH"));
403 if ( szHome
!= NULL
)
407 // the idea is that under NT these variables have default values
408 // of "%systemdrive%:" and "\\". As we don't want to create our
409 // config files in the root directory of the system drive, we will
410 // create it in our program's dir. However, if the user took care
411 // to set HOMEPATH to something other than "\\", we suppose that he
412 // knows what he is doing and use the supplied value.
413 if ( wxStrcmp(szHome
, wxT("\\")) == 0 )
418 if ( strDir
.empty() )
420 // If we have a valid USERPROFILE directory, as is the case in
421 // Windows NT, 2000 and XP, we should use that as our home directory.
422 szHome
= wxGetenv(wxT("USERPROFILE"));
424 if ( szHome
!= NULL
)
428 if ( !strDir
.empty() )
430 // sometimes the value of HOME may be "%USERPROFILE%", so reexpand the
431 // value once again, it shouldn't hurt anyhow
432 strDir
= wxExpandEnvVars(strDir
);
434 else // fall back to the program directory
436 // extract the directory component of the program file name
437 wxSplitPath(wxGetFullModuleName(), &strDir
, NULL
, NULL
);
441 return strDir
.c_str();
444 wxChar
*wxGetUserHome(const wxString
& WXUNUSED(user
))
446 // VZ: the old code here never worked for user != "" anyhow! Moreover, it
447 // returned sometimes a malloc()'d pointer, sometimes a pointer to a
448 // static buffer and sometimes I don't even know what.
449 static wxString s_home
;
451 return (wxChar
*)wxGetHomeDir(&s_home
);
454 bool wxDirExists(const wxString
& dir
)
456 #ifdef __WXMICROWIN__
457 return wxPathExist(dir
);
458 #elif defined(__WIN32__)
459 DWORD attribs
= GetFileAttributes(dir
);
460 return ((attribs
!= (DWORD
)-1) && (attribs
& FILE_ATTRIBUTE_DIRECTORY
));
461 #endif // Win32/__WXMICROWIN__
464 bool wxGetDiskSpace(const wxString
& path
, wxLongLong
*pTotal
, wxLongLong
*pFree
)
472 // old w32api don't have ULARGE_INTEGER
473 #if defined(__WIN32__) && \
474 (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION( 0, 3 ))
475 // GetDiskFreeSpaceEx() is not available under original Win95, check for
477 typedef BOOL (WINAPI
*GetDiskFreeSpaceEx_t
)(LPCTSTR
,
483 pGetDiskFreeSpaceEx
= (GetDiskFreeSpaceEx_t
)::GetProcAddress
485 ::GetModuleHandle(_T("kernel32.dll")),
487 "GetDiskFreeSpaceExW"
489 "GetDiskFreeSpaceExA"
493 if ( pGetDiskFreeSpaceEx
)
495 ULARGE_INTEGER bytesFree
, bytesTotal
;
497 // may pass the path as is, GetDiskFreeSpaceEx() is smart enough
498 if ( !pGetDiskFreeSpaceEx(path
,
503 wxLogLastError(_T("GetDiskFreeSpaceEx"));
508 // ULARGE_INTEGER is a union of a 64 bit value and a struct containing
509 // two 32 bit fields which may be or may be not named - try to make it
510 // compile in all cases
511 #if defined(__BORLANDC__) && !defined(_ANONYMOUS_STRUCT)
518 *pTotal
= wxLongLong(UL(bytesTotal
).HighPart
, UL(bytesTotal
).LowPart
);
523 *pFree
= wxLongLong(UL(bytesFree
).HighPart
, UL(bytesFree
).LowPart
);
529 // there's a problem with drives larger than 2GB, GetDiskFreeSpaceEx()
530 // should be used instead - but if it's not available, fall back on
531 // GetDiskFreeSpace() nevertheless...
533 DWORD lSectorsPerCluster
,
535 lNumberOfFreeClusters
,
536 lTotalNumberOfClusters
;
538 // FIXME: this is wrong, we should extract the root drive from path
539 // instead, but this is the job for wxFileName...
540 if ( !::GetDiskFreeSpace(path
,
543 &lNumberOfFreeClusters
,
544 &lTotalNumberOfClusters
) )
546 wxLogLastError(_T("GetDiskFreeSpace"));
551 wxLongLong lBytesPerCluster
= lSectorsPerCluster
;
552 lBytesPerCluster
*= lBytesPerSector
;
556 *pTotal
= lBytesPerCluster
;
557 *pTotal
*= lTotalNumberOfClusters
;
562 *pFree
= lBytesPerCluster
;
563 *pFree
*= lNumberOfFreeClusters
;
572 // ----------------------------------------------------------------------------
574 // ----------------------------------------------------------------------------
576 bool wxGetEnv(const wxString
& var
, wxString
*value
)
581 // first get the size of the buffer
582 DWORD dwRet
= ::GetEnvironmentVariable(var
, NULL
, 0);
585 // this means that there is no such variable
591 (void)::GetEnvironmentVariable(var
, wxStringBuffer(*value
, dwRet
),
599 bool wxSetEnv(const wxString
& var
, const wxChar
*value
)
601 // some compilers have putenv() or _putenv() or _wputenv() but it's better
602 // to always use Win32 function directly instead of dealing with them
603 #if defined(__WIN32__) && !defined(__WXWINCE__)
604 if ( !::SetEnvironmentVariable(var
, value
) )
606 wxLogLastError(_T("SetEnvironmentVariable"));
612 #else // no way to set env vars
617 // ----------------------------------------------------------------------------
618 // process management
619 // ----------------------------------------------------------------------------
621 // structure used to pass parameters from wxKill() to wxEnumFindByPidProc()
622 struct wxFindByPidParams
624 wxFindByPidParams() { hwnd
= 0; pid
= 0; }
626 // the HWND used to return the result
629 // the PID we're looking from
632 DECLARE_NO_COPY_CLASS(wxFindByPidParams
)
635 // wxKill helper: EnumWindows() callback which is used to find the first (top
636 // level) window belonging to the given process
637 BOOL CALLBACK
wxEnumFindByPidProc(HWND hwnd
, LPARAM lParam
)
640 (void)::GetWindowThreadProcessId(hwnd
, &pid
);
642 wxFindByPidParams
*params
= (wxFindByPidParams
*)lParam
;
643 if ( pid
== params
->pid
)
645 // remember the window we found
648 // return FALSE to stop the enumeration
652 // continue enumeration
656 int wxKillAllChildren(long pid
, wxSignal sig
, wxKillError
*krc
);
658 int wxKill(long pid
, wxSignal sig
, wxKillError
*krc
, int flags
)
660 if (flags
& wxKILL_CHILDREN
)
661 wxKillAllChildren(pid
, sig
, krc
);
663 // get the process handle to operate on
664 HANDLE hProcess
= ::OpenProcess(SYNCHRONIZE
|
666 PROCESS_QUERY_INFORMATION
,
667 FALSE
, // not inheritable
669 if ( hProcess
== NULL
)
673 if ( ::GetLastError() == ERROR_ACCESS_DENIED
)
675 *krc
= wxKILL_ACCESS_DENIED
;
679 *krc
= wxKILL_NO_PROCESS
;
690 // kill the process forcefully returning -1 as error code
691 if ( !::TerminateProcess(hProcess
, (UINT
)-1) )
693 wxLogSysError(_("Failed to kill process %d"), pid
);
697 // this is not supposed to happen if we could open the
707 // do nothing, we just want to test for process existence
711 // any other signal means "terminate"
713 wxFindByPidParams params
;
714 params
.pid
= (DWORD
)pid
;
716 // EnumWindows() has nice semantics: it returns 0 if it found
717 // something or if an error occured and non zero if it
718 // enumerated all the window
719 if ( !::EnumWindows(wxEnumFindByPidProc
, (LPARAM
)¶ms
) )
721 // did we find any window?
724 // tell the app to close
726 // NB: this is the harshest way, the app won't have
727 // opportunity to save any files, for example, but
728 // this is probably what we want here. If not we
729 // can also use SendMesageTimeout(WM_CLOSE)
730 if ( !::PostMessage(params
.hwnd
, WM_QUIT
, 0, 0) )
732 wxLogLastError(_T("PostMessage(WM_QUIT)"));
735 else // it was an error then
737 wxLogLastError(_T("EnumWindows"));
742 else // no windows for this PID
759 // as we wait for a short time, we can use just WaitForSingleObject()
760 // and not MsgWaitForMultipleObjects()
761 switch ( ::WaitForSingleObject(hProcess
, 500 /* msec */) )
764 // process terminated
765 if ( !::GetExitCodeProcess(hProcess
, &rc
) )
767 wxLogLastError(_T("GetExitCodeProcess"));
772 wxFAIL_MSG( _T("unexpected WaitForSingleObject() return") );
776 wxLogLastError(_T("WaitForSingleObject"));
791 // just to suppress the warnings about uninitialized variable
795 ::CloseHandle(hProcess
);
797 // the return code is the same as from Unix kill(): 0 if killed
798 // successfully or -1 on error
800 // be careful to interpret rc correctly: for wxSIGNONE we return success if
801 // the process exists, for all the other sig values -- if it doesn't
803 ((sig
== wxSIGNONE
) == (rc
== STILL_ACTIVE
)) )
817 HANDLE (WINAPI
*lpfCreateToolhelp32Snapshot
)(DWORD
,DWORD
) ;
818 BOOL (WINAPI
*lpfProcess32First
)(HANDLE
,LPPROCESSENTRY32
) ;
819 BOOL (WINAPI
*lpfProcess32Next
)(HANDLE
,LPPROCESSENTRY32
) ;
821 static void InitToolHelp32()
823 static bool s_initToolHelpDone
= false;
825 if (s_initToolHelpDone
)
828 s_initToolHelpDone
= true;
830 lpfCreateToolhelp32Snapshot
= NULL
;
831 lpfProcess32First
= NULL
;
832 lpfProcess32Next
= NULL
;
834 HINSTANCE hInstLib
= LoadLibrary( wxT("Kernel32.DLL") ) ;
835 if( hInstLib
== NULL
)
838 // Get procedure addresses.
839 // We are linking to these functions of Kernel32
840 // explicitly, because otherwise a module using
841 // this code would fail to load under Windows NT,
842 // which does not have the Toolhelp32
843 // functions in the Kernel 32.
844 lpfCreateToolhelp32Snapshot
=
845 (HANDLE(WINAPI
*)(DWORD
,DWORD
))
846 GetProcAddress( hInstLib
,
848 wxT("CreateToolhelp32Snapshot")
850 "CreateToolhelp32Snapshot"
855 (BOOL(WINAPI
*)(HANDLE
,LPPROCESSENTRY32
))
856 GetProcAddress( hInstLib
,
858 wxT("Process32First")
865 (BOOL(WINAPI
*)(HANDLE
,LPPROCESSENTRY32
))
866 GetProcAddress( hInstLib
,
874 FreeLibrary( hInstLib
) ;
878 int wxKillAllChildren(long pid
, wxSignal sig
, wxKillError
*krc
)
885 // If not implemented for this platform (e.g. NT 4.0), silently ignore
886 if (!lpfCreateToolhelp32Snapshot
|| !lpfProcess32First
|| !lpfProcess32Next
)
889 // Take a snapshot of all processes in the system.
890 HANDLE hProcessSnap
= lpfCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS
, 0);
891 if (hProcessSnap
== INVALID_HANDLE_VALUE
) {
897 //Fill in the size of the structure before using it.
898 PROCESSENTRY32 pe
= {0};
899 pe
.dwSize
= sizeof(PROCESSENTRY32
);
901 // Walk the snapshot of the processes, and for each process,
902 // kill it if its parent is pid.
903 if (!lpfProcess32First(hProcessSnap
, &pe
)) {
904 // Can't get first process.
907 CloseHandle (hProcessSnap
);
912 if (pe
.th32ParentProcessID
== (DWORD
) pid
) {
913 if (wxKill(pe
.th32ProcessID
, sig
, krc
))
916 } while (lpfProcess32Next (hProcessSnap
, &pe
));
922 // Execute a program in an Interactive Shell
923 bool wxShell(const wxString
& command
)
930 wxChar
*shell
= wxGetenv(wxT("COMSPEC"));
932 shell
= (wxChar
*) wxT("\\COMMAND.COM");
941 // pass the command to execute to the command processor
942 cmd
.Printf(wxT("%s /c %s"), shell
, command
.c_str());
946 return wxExecute(cmd
, wxEXEC_SYNC
) == 0;
949 // Shutdown or reboot the PC
950 bool wxShutdown(wxShutdownFlags wFlags
)
954 #elif defined(__WIN32__)
957 if ( wxGetOsVersion(NULL
, NULL
) == wxWINDOWS_NT
) // if is NT or 2K
959 // Get a token for this process.
961 bOK
= ::OpenProcessToken(GetCurrentProcess(),
962 TOKEN_ADJUST_PRIVILEGES
| TOKEN_QUERY
,
966 TOKEN_PRIVILEGES tkp
;
968 // Get the LUID for the shutdown privilege.
969 ::LookupPrivilegeValue(NULL
, SE_SHUTDOWN_NAME
,
970 &tkp
.Privileges
[0].Luid
);
972 tkp
.PrivilegeCount
= 1; // one privilege to set
973 tkp
.Privileges
[0].Attributes
= SE_PRIVILEGE_ENABLED
;
975 // Get the shutdown privilege for this process.
976 ::AdjustTokenPrivileges(hToken
, FALSE
, &tkp
, 0,
977 (PTOKEN_PRIVILEGES
)NULL
, 0);
979 // Cannot test the return value of AdjustTokenPrivileges.
980 bOK
= ::GetLastError() == ERROR_SUCCESS
;
986 UINT flags
= EWX_SHUTDOWN
| EWX_FORCE
;
989 case wxSHUTDOWN_POWEROFF
:
990 flags
|= EWX_POWEROFF
;
993 case wxSHUTDOWN_REBOOT
:
998 wxFAIL_MSG( _T("unknown wxShutdown() flag") );
1002 bOK
= ::ExitWindowsEx(flags
, 0) != 0;
1009 // ----------------------------------------------------------------------------
1011 // ----------------------------------------------------------------------------
1013 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
1014 wxMemorySize
wxGetFreeMemory()
1016 #if defined(__WIN64__)
1017 MEMORYSTATUSEX memStatex
;
1018 statex
.dwLength
= sizeof (statex
);
1019 ::GlobalMemoryStatusEx (&statex
);
1020 return (wxMemorySize
)memStatus
.ullAvailPhys
;
1021 #else /* if defined(__WIN32__) */
1022 MEMORYSTATUS memStatus
;
1023 memStatus
.dwLength
= sizeof(MEMORYSTATUS
);
1024 ::GlobalMemoryStatus(&memStatus
);
1025 return (wxMemorySize
)memStatus
.dwAvailPhys
;
1029 unsigned long wxGetProcessId()
1031 return ::GetCurrentProcessId();
1037 ::MessageBeep((UINT
)-1); // default sound
1040 bool wxIsDebuggerRunning()
1042 // IsDebuggerPresent() is not available under Win95, so load it dynamically
1043 wxDynamicLibrary
dll(_T("kernel32.dll"), wxDL_VERBATIM
);
1045 typedef BOOL (WINAPI
*IsDebuggerPresent_t
)();
1046 if ( !dll
.HasSymbol(_T("IsDebuggerPresent")) )
1048 // no way to know, assume no
1052 return (*(IsDebuggerPresent_t
)dll
.GetSymbol(_T("IsDebuggerPresent")))() != 0;
1055 // ----------------------------------------------------------------------------
1057 // ----------------------------------------------------------------------------
1059 wxString
wxGetOsDescription()
1066 info
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFO
);
1067 if ( ::GetVersionEx(&info
) )
1069 switch ( info
.dwPlatformId
)
1071 case VER_PLATFORM_WIN32s
:
1072 str
= _("Win32s on Windows 3.1");
1075 case VER_PLATFORM_WIN32_WINDOWS
:
1076 switch (info
.dwMinorVersion
)
1079 if ( info
.szCSDVersion
[1] == 'B' ||
1080 info
.szCSDVersion
[1] == 'C' )
1082 str
= _("Windows 95 OSR2");
1086 str
= _("Windows 95");
1090 if ( info
.szCSDVersion
[1] == 'B' ||
1091 info
.szCSDVersion
[1] == 'C' )
1093 str
= _("Windows 98 SE");
1097 str
= _("Windows 98");
1101 str
= _("Windows ME");
1104 str
.Printf(_("Windows 9x (%d.%d)"),
1105 info
.dwMajorVersion
,
1106 info
.dwMinorVersion
);
1109 if ( !wxIsEmpty(info
.szCSDVersion
) )
1111 str
<< _T(" (") << info
.szCSDVersion
<< _T(')');
1115 case VER_PLATFORM_WIN32_NT
:
1116 if ( info
.dwMajorVersion
== 5 )
1118 switch ( info
.dwMinorVersion
)
1121 str
.Printf(_("Windows 2000 (build %lu"),
1122 info
.dwBuildNumber
);
1125 str
.Printf(_("Windows XP (build %lu"),
1126 info
.dwBuildNumber
);
1129 str
.Printf(_("Windows Server 2003 (build %lu"),
1130 info
.dwBuildNumber
);
1134 if ( wxIsEmpty(str
) )
1136 str
.Printf(_("Windows NT %lu.%lu (build %lu"),
1137 info
.dwMajorVersion
,
1138 info
.dwMinorVersion
,
1139 info
.dwBuildNumber
);
1141 if ( !wxIsEmpty(info
.szCSDVersion
) )
1143 str
<< _T(", ") << info
.szCSDVersion
;
1151 wxFAIL_MSG( _T("GetVersionEx() failed") ); // should never happen
1157 wxToolkitInfo
& wxAppTraits::GetToolkitInfo()
1159 // cache the version info, it's not going to change
1161 // NB: this is MT-safe, we may use these static vars from different threads
1162 // but as they always have the same value it doesn't matter
1163 static int s_ver
= -1,
1173 info
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFO
);
1174 if ( ::GetVersionEx(&info
) )
1176 s_major
= info
.dwMajorVersion
;
1177 s_minor
= info
.dwMinorVersion
;
1179 switch ( info
.dwPlatformId
)
1181 case VER_PLATFORM_WIN32s
:
1185 case VER_PLATFORM_WIN32_WINDOWS
:
1189 case VER_PLATFORM_WIN32_NT
:
1190 s_ver
= wxWINDOWS_NT
;
1193 case VER_PLATFORM_WIN32_CE
:
1194 s_ver
= wxWINDOWS_CE
;
1201 static wxToolkitInfo info
;
1202 info
.versionMajor
= s_major
;
1203 info
.versionMinor
= s_minor
;
1205 info
.name
= _T("wxBase");
1209 // ----------------------------------------------------------------------------
1211 // ----------------------------------------------------------------------------
1213 void wxMilliSleep(unsigned long milliseconds
)
1215 ::Sleep(milliseconds
);
1218 void wxMicroSleep(unsigned long microseconds
)
1220 wxMilliSleep(microseconds
/1000);
1223 void wxSleep(int nSecs
)
1225 wxMilliSleep(1000*nSecs
);
1228 // ----------------------------------------------------------------------------
1229 // font encoding <-> Win32 codepage conversion functions
1230 // ----------------------------------------------------------------------------
1232 extern WXDLLIMPEXP_BASE
long wxEncodingToCharset(wxFontEncoding encoding
)
1236 // although this function is supposed to return an exact match, do do
1237 // some mappings here for the most common case of "standard" encoding
1238 case wxFONTENCODING_SYSTEM
:
1239 return DEFAULT_CHARSET
;
1241 case wxFONTENCODING_ISO8859_1
:
1242 case wxFONTENCODING_ISO8859_15
:
1243 case wxFONTENCODING_CP1252
:
1244 return ANSI_CHARSET
;
1246 #if !defined(__WXMICROWIN__)
1247 // The following four fonts are multi-byte charsets
1248 case wxFONTENCODING_CP932
:
1249 return SHIFTJIS_CHARSET
;
1251 case wxFONTENCODING_CP936
:
1252 return GB2312_CHARSET
;
1254 case wxFONTENCODING_CP949
:
1255 return HANGUL_CHARSET
;
1257 case wxFONTENCODING_CP950
:
1258 return CHINESEBIG5_CHARSET
;
1260 // The rest are single byte encodings
1261 case wxFONTENCODING_CP1250
:
1262 return EASTEUROPE_CHARSET
;
1264 case wxFONTENCODING_CP1251
:
1265 return RUSSIAN_CHARSET
;
1267 case wxFONTENCODING_CP1253
:
1268 return GREEK_CHARSET
;
1270 case wxFONTENCODING_CP1254
:
1271 return TURKISH_CHARSET
;
1273 case wxFONTENCODING_CP1255
:
1274 return HEBREW_CHARSET
;
1276 case wxFONTENCODING_CP1256
:
1277 return ARABIC_CHARSET
;
1279 case wxFONTENCODING_CP1257
:
1280 return BALTIC_CHARSET
;
1282 case wxFONTENCODING_CP874
:
1283 return THAI_CHARSET
;
1284 #endif // !__WXMICROWIN__
1286 case wxFONTENCODING_CP437
:
1290 // no way to translate this encoding into a Windows charset
1295 // we have 2 versions of wxCharsetToCodepage(): the old one which directly
1296 // looks up the vlaues in the registry and the new one which is more
1297 // politically correct and has more chances to work on other Windows versions
1298 // as well but the old version is still needed for !wxUSE_FONTMAP case
1301 #include "wx/fontmap.h"
1303 extern WXDLLIMPEXP_BASE
long wxEncodingToCodepage(wxFontEncoding encoding
)
1305 // There don't seem to be symbolic names for
1306 // these under Windows so I just copied the
1307 // values from MSDN.
1313 case wxFONTENCODING_ISO8859_1
: ret
= 28591; break;
1314 case wxFONTENCODING_ISO8859_2
: ret
= 28592; break;
1315 case wxFONTENCODING_ISO8859_3
: ret
= 28593; break;
1316 case wxFONTENCODING_ISO8859_4
: ret
= 28594; break;
1317 case wxFONTENCODING_ISO8859_5
: ret
= 28595; break;
1318 case wxFONTENCODING_ISO8859_6
: ret
= 28596; break;
1319 case wxFONTENCODING_ISO8859_7
: ret
= 28597; break;
1320 case wxFONTENCODING_ISO8859_8
: ret
= 28598; break;
1321 case wxFONTENCODING_ISO8859_9
: ret
= 28599; break;
1322 case wxFONTENCODING_ISO8859_10
: ret
= 28600; break;
1323 case wxFONTENCODING_ISO8859_11
: ret
= 28601; break;
1324 // case wxFONTENCODING_ISO8859_12, // doesn't exist currently, but put it
1325 case wxFONTENCODING_ISO8859_13
: ret
= 28603; break;
1326 case wxFONTENCODING_ISO8859_14
: ret
= 28604; break;
1327 case wxFONTENCODING_ISO8859_15
: ret
= 28605; break;
1328 case wxFONTENCODING_KOI8
: ret
= 20866; break;
1329 case wxFONTENCODING_KOI8_U
: ret
= 21866; break;
1330 case wxFONTENCODING_CP437
: ret
= 437; break;
1331 case wxFONTENCODING_CP850
: ret
= 850; break;
1332 case wxFONTENCODING_CP852
: ret
= 852; break;
1333 case wxFONTENCODING_CP855
: ret
= 855; break;
1334 case wxFONTENCODING_CP866
: ret
= 866; break;
1335 case wxFONTENCODING_CP874
: ret
= 874; break;
1336 case wxFONTENCODING_CP932
: ret
= 932; break;
1337 case wxFONTENCODING_CP936
: ret
= 936; break;
1338 case wxFONTENCODING_CP949
: ret
= 949; break;
1339 case wxFONTENCODING_CP950
: ret
= 950; break;
1340 case wxFONTENCODING_CP1250
: ret
= 1250; break;
1341 case wxFONTENCODING_CP1251
: ret
= 1251; break;
1342 case wxFONTENCODING_CP1252
: ret
= 1252; break;
1343 case wxFONTENCODING_CP1253
: ret
= 1253; break;
1344 case wxFONTENCODING_CP1254
: ret
= 1254; break;
1345 case wxFONTENCODING_CP1255
: ret
= 1255; break;
1346 case wxFONTENCODING_CP1256
: ret
= 1256; break;
1347 case wxFONTENCODING_CP1257
: ret
= 1257; break;
1348 case wxFONTENCODING_EUC_JP
: ret
= 51932; break;
1349 case wxFONTENCODING_MACROMAN
: ret
= 10000; break;
1350 case wxFONTENCODING_MACJAPANESE
: ret
= 10001; break;
1351 case wxFONTENCODING_MACCHINESETRAD
: ret
= 10002; break;
1352 case wxFONTENCODING_MACKOREAN
: ret
= 10003; break;
1353 case wxFONTENCODING_MACARABIC
: ret
= 10004; break;
1354 case wxFONTENCODING_MACHEBREW
: ret
= 10005; break;
1355 case wxFONTENCODING_MACGREEK
: ret
= 10006; break;
1356 case wxFONTENCODING_MACCYRILLIC
: ret
= 10007; break;
1357 case wxFONTENCODING_MACTHAI
: ret
= 10021; break;
1358 case wxFONTENCODING_MACCHINESESIMP
: ret
= 10008; break;
1359 case wxFONTENCODING_MACCENTRALEUR
: ret
= 10029; break;
1360 case wxFONTENCODING_MACCROATIAN
: ret
= 10082; break;
1361 case wxFONTENCODING_MACICELANDIC
: ret
= 10079; break;
1362 case wxFONTENCODING_MACROMANIAN
: ret
= 10009; break;
1363 case wxFONTENCODING_UTF7
: ret
= 65000; break;
1364 case wxFONTENCODING_UTF8
: ret
= 65001; break;
1368 if (::IsValidCodePage(ret
) == 0)
1372 if (::GetCPInfo(ret
, &info
) == 0)
1378 extern long wxCharsetToCodepage(const wxChar
*name
)
1380 // first get the font encoding for this charset
1384 wxFontEncoding enc
= wxFontMapper::Get()->CharsetToEncoding(name
, false);
1385 if ( enc
== wxFONTENCODING_SYSTEM
)
1388 // the use the helper function
1389 return wxEncodingToCodepage(enc
);
1392 #else // !wxUSE_FONTMAP
1394 #include "wx/msw/registry.h"
1396 // this should work if Internet Exploiter is installed
1397 extern long wxCharsetToCodepage(const wxChar
*name
)
1404 wxString
path(wxT("MIME\\Database\\Charset\\"));
1407 // follow the alias loop
1410 wxRegKey
key(wxRegKey::HKCR
, path
+ cn
);
1415 // two cases: either there's an AliasForCharset string,
1416 // or there are Codepage and InternetEncoding dwords.
1417 // The InternetEncoding gives us the actual encoding,
1418 // the Codepage just says which Windows character set to
1419 // use when displaying the data.
1420 if (key
.HasValue(wxT("InternetEncoding")) &&
1421 key
.QueryValue(wxT("InternetEncoding"), &CP
))
1424 // no encoding, see if it's an alias
1425 if (!key
.HasValue(wxT("AliasForCharset")) ||
1426 !key
.QueryValue(wxT("AliasForCharset"), cn
))
1433 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
1436 Creates a hidden window with supplied window proc registering the class for
1437 it if necesssary (i.e. the first time only). Caller is responsible for
1438 destroying the window and unregistering the class (note that this must be
1439 done because wxWidgets may be used as a DLL and so may be loaded/unloaded
1440 multiple times into/from the same process so we cna't rely on automatic
1441 Windows class unregistration).
1443 pclassname is a pointer to a caller stored classname, which must initially be
1444 NULL. classname is the desired wndclass classname. If function succesfully
1445 registers the class, pclassname will be set to classname.
1447 extern "C" WXDLLIMPEXP_BASE HWND
1448 wxCreateHiddenWindow(LPCTSTR
*pclassname
, LPCTSTR classname
, WNDPROC wndproc
)
1450 wxCHECK_MSG( classname
&& pclassname
&& wndproc
, NULL
,
1451 _T("NULL parameter in wxCreateHiddenWindow") );
1453 // register the class fi we need to first
1454 if ( *pclassname
== NULL
)
1457 wxZeroMemory(wndclass
);
1459 wndclass
.lpfnWndProc
= wndproc
;
1460 wndclass
.hInstance
= wxGetInstance();
1461 wndclass
.lpszClassName
= classname
;
1463 if ( !::RegisterClass(&wndclass
) )
1465 wxLogLastError(wxT("RegisterClass() in wxCreateHiddenWindow"));
1470 *pclassname
= classname
;
1473 // next create the window
1474 HWND hwnd
= ::CreateWindow
1488 wxLogLastError(wxT("CreateWindow() in wxCreateHiddenWindow"));