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/dynload.h"
37 #include "wx/confbase.h" // for wxExpandEnvVars()
39 #include "wx/msw/private.h" // includes <windows.h>
40 #include "wx/msw/missing.h" // CHARSET_HANGUL
42 #if defined(__GNUWIN32_OLD__) || defined(__WXWINCE__) \
43 || defined(__CYGWIN32__)
44 // apparently we need to include winsock.h to get WSADATA and other stuff
45 // used in wxGetFullHostName() with the old mingw32 versions
51 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
59 #if defined(__CYGWIN__)
60 #include <sys/unistd.h>
62 #include <sys/cygwin.h> // for cygwin_conv_to_full_win32_path()
65 #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs
66 // this (3.1 I believe) and how to test for it.
67 // If this works for Borland 4.0 as well, then no worries.
71 // VZ: there is some code using NetXXX() functions to get the full user name:
72 // I don't think it's a good idea because they don't work under Win95 and
73 // seem to return the same as wxGetUserId() under NT. If you really want
74 // to use them, just #define USE_NET_API
81 #if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
92 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
97 // For wxKillAllChildren
100 // ----------------------------------------------------------------------------
102 // ----------------------------------------------------------------------------
104 // In the WIN.INI file
105 static const wxChar WX_SECTION
[] = wxT("wxWindows");
106 static const wxChar eUSERNAME
[] = wxT("UserName");
108 // ============================================================================
110 // ============================================================================
112 // ----------------------------------------------------------------------------
113 // get host name and related
114 // ----------------------------------------------------------------------------
116 // Get hostname only (without domain name)
117 bool wxGetHostName(wxChar
*buf
, int maxSize
)
119 #if defined(__WXWINCE__)
121 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
122 DWORD nSize
= maxSize
;
123 if ( !::GetComputerName(buf
, &nSize
) )
125 wxLogLastError(wxT("GetComputerName"));
133 const wxChar
*default_host
= wxT("noname");
135 if ((sysname
= wxGetenv(wxT("SYSTEM_NAME"))) == NULL
) {
136 GetProfileString(WX_SECTION
, eHOSTNAME
, default_host
, buf
, maxSize
- 1);
138 wxStrncpy(buf
, sysname
, maxSize
- 1);
139 buf
[maxSize
] = wxT('\0');
140 return *buf
? true : false;
144 // get full hostname (with domain name if possible)
145 bool wxGetFullHostName(wxChar
*buf
, int maxSize
)
147 #if !defined( __WXMICROWIN__) && wxUSE_DYNAMIC_LOADER
148 // TODO should use GetComputerNameEx() when available
150 // we don't want to always link with Winsock DLL as we might not use it at
151 // all, so load it dynamically here if needed (and don't complain if it is
152 // missing, we handle this)
155 wxDynamicLibrary
dllWinsock(_T("ws2_32.dll"), wxDL_VERBATIM
);
156 if ( dllWinsock
.IsLoaded() )
158 typedef int (PASCAL
*WSAStartup_t
)(WORD
, WSADATA
*);
159 typedef int (PASCAL
*gethostname_t
)(char *, int);
160 typedef hostent
* (PASCAL
*gethostbyname_t
)(const char *);
161 typedef hostent
* (PASCAL
*gethostbyaddr_t
)(const char *, int , int);
162 typedef int (PASCAL
*WSACleanup_t
)(void);
164 #define LOAD_WINSOCK_FUNC(func) \
166 pfn ## func = (func ## _t)dllWinsock.GetSymbol(_T(#func))
168 LOAD_WINSOCK_FUNC(WSAStartup
);
171 if ( pfnWSAStartup
&& pfnWSAStartup(MAKEWORD(1, 1), &wsa
) == 0 )
173 LOAD_WINSOCK_FUNC(gethostname
);
176 if ( pfngethostname
)
179 if ( pfngethostname(bufA
, WXSIZEOF(bufA
)) == 0 )
181 // gethostname() won't usually include the DNS domain name,
182 // for this we need to work a bit more
183 if ( !strchr(bufA
, '.') )
185 LOAD_WINSOCK_FUNC(gethostbyname
);
187 struct hostent
*pHostEnt
= pfngethostbyname
188 ? pfngethostbyname(bufA
)
193 // Windows will use DNS internally now
194 LOAD_WINSOCK_FUNC(gethostbyaddr
);
196 pHostEnt
= pfngethostbyaddr
197 ? pfngethostbyaddr(pHostEnt
->h_addr
,
204 host
= wxString::FromAscii(pHostEnt
->h_name
);
210 LOAD_WINSOCK_FUNC(WSACleanup
);
217 wxStrncpy(buf
, host
, maxSize
);
223 #endif // !__WXMICROWIN__
225 return wxGetHostName(buf
, maxSize
);
228 // Get user ID e.g. jacs
229 bool wxGetUserId(wxChar
*buf
, int maxSize
)
231 #if defined(__WXWINCE__)
233 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
234 DWORD nSize
= maxSize
;
235 if ( ::GetUserName(buf
, &nSize
) == 0 )
237 // actually, it does happen on Win9x if the user didn't log on
238 DWORD res
= ::GetEnvironmentVariable(wxT("username"), buf
, maxSize
);
247 #else // __WXMICROWIN__
249 const wxChar
*default_id
= wxT("anonymous");
251 // Can't assume we have NIS (PC-NFS) or some other ID daemon
253 if ( (user
= wxGetenv(wxT("USER"))) == NULL
&&
254 (user
= wxGetenv(wxT("LOGNAME"))) == NULL
)
256 // Use wxWidgets configuration data (comming soon)
257 GetProfileString(WX_SECTION
, eUSERID
, default_id
, buf
, maxSize
- 1);
261 wxStrncpy(buf
, user
, maxSize
- 1);
264 return *buf
? true : false;
268 // Get user name e.g. Julian Smart
269 bool wxGetUserName(wxChar
*buf
, int maxSize
)
271 #if defined(__WXWINCE__)
273 #elif defined(USE_NET_API)
274 CHAR szUserName
[256];
275 if ( !wxGetUserId(szUserName
, WXSIZEOF(szUserName
)) )
278 // TODO how to get the domain name?
281 // the code is based on the MSDN example (also see KB article Q119670)
282 WCHAR wszUserName
[256]; // Unicode user name
283 WCHAR wszDomain
[256];
286 USER_INFO_2
*ui2
; // User structure
288 // Convert ANSI user name and domain to Unicode
289 MultiByteToWideChar( CP_ACP
, 0, szUserName
, strlen(szUserName
)+1,
290 wszUserName
, WXSIZEOF(wszUserName
) );
291 MultiByteToWideChar( CP_ACP
, 0, szDomain
, strlen(szDomain
)+1,
292 wszDomain
, WXSIZEOF(wszDomain
) );
294 // Get the computer name of a DC for the domain.
295 if ( NetGetDCName( NULL
, wszDomain
, &ComputerName
) != NERR_Success
)
297 wxLogError(wxT("Can not find domain controller"));
302 // Look up the user on the DC
303 NET_API_STATUS status
= NetUserGetInfo( (LPWSTR
)ComputerName
,
304 (LPWSTR
)&wszUserName
,
305 2, // level - we want USER_INFO_2
313 case NERR_InvalidComputer
:
314 wxLogError(wxT("Invalid domain controller name."));
318 case NERR_UserNotFound
:
319 wxLogError(wxT("Invalid user name '%s'."), szUserName
);
324 wxLogSysError(wxT("Can't get information about user"));
329 // Convert the Unicode full name to ANSI
330 WideCharToMultiByte( CP_ACP
, 0, ui2
->usri2_full_name
, -1,
331 buf
, maxSize
, NULL
, NULL
);
336 wxLogError(wxT("Couldn't look up full user name."));
339 #else // !USE_NET_API
340 // Could use NIS, MS-Mail or other site specific programs
341 // Use wxWidgets configuration data
342 bool ok
= GetProfileString(WX_SECTION
, eUSERNAME
, wxEmptyString
, buf
, maxSize
- 1) != 0;
345 ok
= wxGetUserId(buf
, maxSize
);
350 wxStrncpy(buf
, wxT("Unknown User"), maxSize
);
357 const wxChar
* wxGetHomeDir(wxString
*pstr
)
359 wxString
& strDir
= *pstr
;
361 // first branch is for Cygwin
362 #if defined(__UNIX__)
363 const wxChar
*szHome
= wxGetenv("HOME");
364 if ( szHome
== NULL
) {
366 wxLogWarning(_("can't find user's HOME, using current directory."));
372 // add a trailing slash if needed
373 if ( strDir
.Last() != wxT('/') )
377 // Cygwin returns unix type path but that does not work well
378 static wxChar windowsPath
[MAX_PATH
];
379 cygwin_conv_to_full_win32_path(strDir
, windowsPath
);
380 strDir
= windowsPath
;
382 #elif defined(__WXWINCE__)
387 // If we have a valid HOME directory, as is used on many machines that
388 // have unix utilities on them, we should use that.
389 const wxChar
*szHome
= wxGetenv(wxT("HOME"));
391 if ( szHome
!= NULL
)
395 else // no HOME, try HOMEDRIVE/PATH
397 szHome
= wxGetenv(wxT("HOMEDRIVE"));
398 if ( szHome
!= NULL
)
400 szHome
= wxGetenv(wxT("HOMEPATH"));
402 if ( szHome
!= NULL
)
406 // the idea is that under NT these variables have default values
407 // of "%systemdrive%:" and "\\". As we don't want to create our
408 // config files in the root directory of the system drive, we will
409 // create it in our program's dir. However, if the user took care
410 // to set HOMEPATH to something other than "\\", we suppose that he
411 // knows what he is doing and use the supplied value.
412 if ( wxStrcmp(szHome
, wxT("\\")) == 0 )
417 if ( strDir
.empty() )
419 // If we have a valid USERPROFILE directory, as is the case in
420 // Windows NT, 2000 and XP, we should use that as our home directory.
421 szHome
= wxGetenv(wxT("USERPROFILE"));
423 if ( szHome
!= NULL
)
427 if ( !strDir
.empty() )
429 // sometimes the value of HOME may be "%USERPROFILE%", so reexpand the
430 // value once again, it shouldn't hurt anyhow
431 strDir
= wxExpandEnvVars(strDir
);
433 else // fall back to the program directory
435 // extract the directory component of the program file name
436 wxSplitPath(wxGetFullModuleName(), &strDir
, NULL
, NULL
);
440 return strDir
.c_str();
443 wxChar
*wxGetUserHome(const wxString
& WXUNUSED(user
))
445 // VZ: the old code here never worked for user != "" anyhow! Moreover, it
446 // returned sometimes a malloc()'d pointer, sometimes a pointer to a
447 // static buffer and sometimes I don't even know what.
448 static wxString s_home
;
450 return (wxChar
*)wxGetHomeDir(&s_home
);
453 bool wxDirExists(const wxString
& dir
)
455 #ifdef __WXMICROWIN__
456 return wxPathExist(dir
);
457 #elif defined(__WIN32__)
458 DWORD attribs
= GetFileAttributes(dir
);
459 return ((attribs
!= (DWORD
)-1) && (attribs
& FILE_ATTRIBUTE_DIRECTORY
));
460 #endif // Win32/__WXMICROWIN__
463 bool wxGetDiskSpace(const wxString
& path
, wxLongLong
*pTotal
, wxLongLong
*pFree
)
471 // old w32api don't have ULARGE_INTEGER
472 #if defined(__WIN32__) && \
473 (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION( 0, 3 ))
474 // GetDiskFreeSpaceEx() is not available under original Win95, check for
476 typedef BOOL (WINAPI
*GetDiskFreeSpaceEx_t
)(LPCTSTR
,
482 pGetDiskFreeSpaceEx
= (GetDiskFreeSpaceEx_t
)::GetProcAddress
484 ::GetModuleHandle(_T("kernel32.dll")),
486 "GetDiskFreeSpaceExW"
488 "GetDiskFreeSpaceExA"
492 if ( pGetDiskFreeSpaceEx
)
494 ULARGE_INTEGER bytesFree
, bytesTotal
;
496 // may pass the path as is, GetDiskFreeSpaceEx() is smart enough
497 if ( !pGetDiskFreeSpaceEx(path
,
502 wxLogLastError(_T("GetDiskFreeSpaceEx"));
507 // ULARGE_INTEGER is a union of a 64 bit value and a struct containing
508 // two 32 bit fields which may be or may be not named - try to make it
509 // compile in all cases
510 #if defined(__BORLANDC__) && !defined(_ANONYMOUS_STRUCT)
517 *pTotal
= wxLongLong(UL(bytesTotal
).HighPart
, UL(bytesTotal
).LowPart
);
522 *pFree
= wxLongLong(UL(bytesFree
).HighPart
, UL(bytesFree
).LowPart
);
528 // there's a problem with drives larger than 2GB, GetDiskFreeSpaceEx()
529 // should be used instead - but if it's not available, fall back on
530 // GetDiskFreeSpace() nevertheless...
532 DWORD lSectorsPerCluster
,
534 lNumberOfFreeClusters
,
535 lTotalNumberOfClusters
;
537 // FIXME: this is wrong, we should extract the root drive from path
538 // instead, but this is the job for wxFileName...
539 if ( !::GetDiskFreeSpace(path
,
542 &lNumberOfFreeClusters
,
543 &lTotalNumberOfClusters
) )
545 wxLogLastError(_T("GetDiskFreeSpace"));
550 wxLongLong lBytesPerCluster
= lSectorsPerCluster
;
551 lBytesPerCluster
*= lBytesPerSector
;
555 *pTotal
= lBytesPerCluster
;
556 *pTotal
*= lTotalNumberOfClusters
;
561 *pFree
= lBytesPerCluster
;
562 *pFree
*= lNumberOfFreeClusters
;
571 // ----------------------------------------------------------------------------
573 // ----------------------------------------------------------------------------
575 bool wxGetEnv(const wxString
& var
, wxString
*value
)
580 // first get the size of the buffer
581 DWORD dwRet
= ::GetEnvironmentVariable(var
, NULL
, 0);
584 // this means that there is no such variable
590 (void)::GetEnvironmentVariable(var
, wxStringBuffer(*value
, dwRet
),
598 bool wxSetEnv(const wxString
& var
, const wxChar
*value
)
600 // some compilers have putenv() or _putenv() or _wputenv() but it's better
601 // to always use Win32 function directly instead of dealing with them
602 #if defined(__WIN32__) && !defined(__WXWINCE__)
603 if ( !::SetEnvironmentVariable(var
, value
) )
605 wxLogLastError(_T("SetEnvironmentVariable"));
611 #else // no way to set env vars
616 // ----------------------------------------------------------------------------
617 // process management
618 // ----------------------------------------------------------------------------
620 // structure used to pass parameters from wxKill() to wxEnumFindByPidProc()
621 struct wxFindByPidParams
623 wxFindByPidParams() { hwnd
= 0; pid
= 0; }
625 // the HWND used to return the result
628 // the PID we're looking from
631 DECLARE_NO_COPY_CLASS(wxFindByPidParams
)
634 // wxKill helper: EnumWindows() callback which is used to find the first (top
635 // level) window belonging to the given process
636 BOOL CALLBACK
wxEnumFindByPidProc(HWND hwnd
, LPARAM lParam
)
639 (void)::GetWindowThreadProcessId(hwnd
, &pid
);
641 wxFindByPidParams
*params
= (wxFindByPidParams
*)lParam
;
642 if ( pid
== params
->pid
)
644 // remember the window we found
647 // return FALSE to stop the enumeration
651 // continue enumeration
655 int wxKillAllChildren(long pid
, wxSignal sig
, wxKillError
*krc
);
657 int wxKill(long pid
, wxSignal sig
, wxKillError
*krc
, int flags
)
659 if (flags
& wxKILL_CHILDREN
)
660 wxKillAllChildren(pid
, sig
, krc
);
662 // get the process handle to operate on
663 HANDLE hProcess
= ::OpenProcess(SYNCHRONIZE
|
665 PROCESS_QUERY_INFORMATION
,
666 FALSE
, // not inheritable
668 if ( hProcess
== NULL
)
672 if ( ::GetLastError() == ERROR_ACCESS_DENIED
)
674 *krc
= wxKILL_ACCESS_DENIED
;
678 *krc
= wxKILL_NO_PROCESS
;
689 // kill the process forcefully returning -1 as error code
690 if ( !::TerminateProcess(hProcess
, (UINT
)-1) )
692 wxLogSysError(_("Failed to kill process %d"), pid
);
696 // this is not supposed to happen if we could open the
706 // do nothing, we just want to test for process existence
710 // any other signal means "terminate"
712 wxFindByPidParams params
;
713 params
.pid
= (DWORD
)pid
;
715 // EnumWindows() has nice semantics: it returns 0 if it found
716 // something or if an error occured and non zero if it
717 // enumerated all the window
718 if ( !::EnumWindows(wxEnumFindByPidProc
, (LPARAM
)¶ms
) )
720 // did we find any window?
723 // tell the app to close
725 // NB: this is the harshest way, the app won't have
726 // opportunity to save any files, for example, but
727 // this is probably what we want here. If not we
728 // can also use SendMesageTimeout(WM_CLOSE)
729 if ( !::PostMessage(params
.hwnd
, WM_QUIT
, 0, 0) )
731 wxLogLastError(_T("PostMessage(WM_QUIT)"));
734 else // it was an error then
736 wxLogLastError(_T("EnumWindows"));
741 else // no windows for this PID
758 // as we wait for a short time, we can use just WaitForSingleObject()
759 // and not MsgWaitForMultipleObjects()
760 switch ( ::WaitForSingleObject(hProcess
, 500 /* msec */) )
763 // process terminated
764 if ( !::GetExitCodeProcess(hProcess
, &rc
) )
766 wxLogLastError(_T("GetExitCodeProcess"));
771 wxFAIL_MSG( _T("unexpected WaitForSingleObject() return") );
775 wxLogLastError(_T("WaitForSingleObject"));
790 // just to suppress the warnings about uninitialized variable
794 ::CloseHandle(hProcess
);
796 // the return code is the same as from Unix kill(): 0 if killed
797 // successfully or -1 on error
799 // be careful to interpret rc correctly: for wxSIGNONE we return success if
800 // the process exists, for all the other sig values -- if it doesn't
802 ((sig
== wxSIGNONE
) == (rc
== STILL_ACTIVE
)) )
816 HANDLE (WINAPI
*lpfCreateToolhelp32Snapshot
)(DWORD
,DWORD
) ;
817 BOOL (WINAPI
*lpfProcess32First
)(HANDLE
,LPPROCESSENTRY32
) ;
818 BOOL (WINAPI
*lpfProcess32Next
)(HANDLE
,LPPROCESSENTRY32
) ;
820 static void InitToolHelp32()
822 static bool s_initToolHelpDone
= false;
824 if (s_initToolHelpDone
)
827 s_initToolHelpDone
= true;
829 lpfCreateToolhelp32Snapshot
= NULL
;
830 lpfProcess32First
= NULL
;
831 lpfProcess32Next
= NULL
;
833 HINSTANCE hInstLib
= LoadLibrary( wxT("Kernel32.DLL") ) ;
834 if( hInstLib
== NULL
)
837 // Get procedure addresses.
838 // We are linking to these functions of Kernel32
839 // explicitly, because otherwise a module using
840 // this code would fail to load under Windows NT,
841 // which does not have the Toolhelp32
842 // functions in the Kernel 32.
843 lpfCreateToolhelp32Snapshot
=
844 (HANDLE(WINAPI
*)(DWORD
,DWORD
))
845 GetProcAddress( hInstLib
,
847 wxT("CreateToolhelp32Snapshot")
849 "CreateToolhelp32Snapshot"
854 (BOOL(WINAPI
*)(HANDLE
,LPPROCESSENTRY32
))
855 GetProcAddress( hInstLib
,
857 wxT("Process32First")
864 (BOOL(WINAPI
*)(HANDLE
,LPPROCESSENTRY32
))
865 GetProcAddress( hInstLib
,
873 FreeLibrary( hInstLib
) ;
877 int wxKillAllChildren(long pid
, wxSignal sig
, wxKillError
*krc
)
884 // If not implemented for this platform (e.g. NT 4.0), silently ignore
885 if (!lpfCreateToolhelp32Snapshot
|| !lpfProcess32First
|| !lpfProcess32Next
)
888 // Take a snapshot of all processes in the system.
889 HANDLE hProcessSnap
= lpfCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS
, 0);
890 if (hProcessSnap
== INVALID_HANDLE_VALUE
) {
896 //Fill in the size of the structure before using it.
897 PROCESSENTRY32 pe
= {0};
898 pe
.dwSize
= sizeof(PROCESSENTRY32
);
900 // Walk the snapshot of the processes, and for each process,
901 // kill it if its parent is pid.
902 if (!lpfProcess32First(hProcessSnap
, &pe
)) {
903 // Can't get first process.
906 CloseHandle (hProcessSnap
);
911 if (pe
.th32ParentProcessID
== (DWORD
) pid
) {
912 if (wxKill(pe
.th32ProcessID
, sig
, krc
))
915 } while (lpfProcess32Next (hProcessSnap
, &pe
));
921 // Execute a program in an Interactive Shell
922 bool wxShell(const wxString
& command
)
929 wxChar
*shell
= wxGetenv(wxT("COMSPEC"));
931 shell
= (wxChar
*) wxT("\\COMMAND.COM");
940 // pass the command to execute to the command processor
941 cmd
.Printf(wxT("%s /c %s"), shell
, command
.c_str());
945 return wxExecute(cmd
, wxEXEC_SYNC
) == 0;
948 // Shutdown or reboot the PC
949 bool wxShutdown(wxShutdownFlags wFlags
)
953 #elif defined(__WIN32__)
956 if ( wxGetOsVersion(NULL
, NULL
) == wxWINDOWS_NT
) // if is NT or 2K
958 // Get a token for this process.
960 bOK
= ::OpenProcessToken(GetCurrentProcess(),
961 TOKEN_ADJUST_PRIVILEGES
| TOKEN_QUERY
,
965 TOKEN_PRIVILEGES tkp
;
967 // Get the LUID for the shutdown privilege.
968 ::LookupPrivilegeValue(NULL
, SE_SHUTDOWN_NAME
,
969 &tkp
.Privileges
[0].Luid
);
971 tkp
.PrivilegeCount
= 1; // one privilege to set
972 tkp
.Privileges
[0].Attributes
= SE_PRIVILEGE_ENABLED
;
974 // Get the shutdown privilege for this process.
975 ::AdjustTokenPrivileges(hToken
, FALSE
, &tkp
, 0,
976 (PTOKEN_PRIVILEGES
)NULL
, 0);
978 // Cannot test the return value of AdjustTokenPrivileges.
979 bOK
= ::GetLastError() == ERROR_SUCCESS
;
985 UINT flags
= EWX_SHUTDOWN
| EWX_FORCE
;
988 case wxSHUTDOWN_POWEROFF
:
989 flags
|= EWX_POWEROFF
;
992 case wxSHUTDOWN_REBOOT
:
997 wxFAIL_MSG( _T("unknown wxShutdown() flag") );
1001 bOK
= ::ExitWindowsEx(flags
, 0) != 0;
1008 // ----------------------------------------------------------------------------
1010 // ----------------------------------------------------------------------------
1012 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
1013 long wxGetFreeMemory()
1015 #if defined(__WIN32__) && !defined(__BORLANDC__)
1016 MEMORYSTATUS memStatus
;
1017 memStatus
.dwLength
= sizeof(MEMORYSTATUS
);
1018 GlobalMemoryStatus(&memStatus
);
1019 return memStatus
.dwAvailPhys
;
1021 return (long)GetFreeSpace(0);
1025 unsigned long wxGetProcessId()
1027 return ::GetCurrentProcessId();
1033 ::MessageBeep((UINT
)-1); // default sound
1036 wxString
wxGetOsDescription()
1043 info
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFO
);
1044 if ( ::GetVersionEx(&info
) )
1046 switch ( info
.dwPlatformId
)
1048 case VER_PLATFORM_WIN32s
:
1049 str
= _("Win32s on Windows 3.1");
1052 case VER_PLATFORM_WIN32_WINDOWS
:
1053 switch (info
.dwMinorVersion
)
1056 if ( info
.szCSDVersion
[1] == 'B' ||
1057 info
.szCSDVersion
[1] == 'C' )
1059 str
= _("Windows 95 OSR2");
1063 str
= _("Windows 95");
1067 if ( info
.szCSDVersion
[1] == 'B' ||
1068 info
.szCSDVersion
[1] == 'C' )
1070 str
= _("Windows 98 SE");
1074 str
= _("Windows 98");
1078 str
= _("Windows ME");
1081 str
.Printf(_("Windows 9x (%d.%d)"),
1082 info
.dwMajorVersion
,
1083 info
.dwMinorVersion
);
1086 if ( !wxIsEmpty(info
.szCSDVersion
) )
1088 str
<< _T(" (") << info
.szCSDVersion
<< _T(')');
1092 case VER_PLATFORM_WIN32_NT
:
1093 if ( info
.dwMajorVersion
== 5 )
1095 switch ( info
.dwMinorVersion
)
1098 str
.Printf(_("Windows 2000 (build %lu"),
1099 info
.dwBuildNumber
);
1102 str
.Printf(_("Windows XP (build %lu"),
1103 info
.dwBuildNumber
);
1106 str
.Printf(_("Windows Server 2003 (build %lu"),
1107 info
.dwBuildNumber
);
1111 if ( wxIsEmpty(str
) )
1113 str
.Printf(_("Windows NT %lu.%lu (build %lu"),
1114 info
.dwMajorVersion
,
1115 info
.dwMinorVersion
,
1116 info
.dwBuildNumber
);
1118 if ( !wxIsEmpty(info
.szCSDVersion
) )
1120 str
<< _T(", ") << info
.szCSDVersion
;
1128 wxFAIL_MSG( _T("GetVersionEx() failed") ); // should never happen
1134 wxToolkitInfo
& wxAppTraits::GetToolkitInfo()
1136 // cache the version info, it's not going to change
1138 // NB: this is MT-safe, we may use these static vars from different threads
1139 // but as they always have the same value it doesn't matter
1140 static int s_ver
= -1,
1150 info
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFO
);
1151 if ( ::GetVersionEx(&info
) )
1153 s_major
= info
.dwMajorVersion
;
1154 s_minor
= info
.dwMinorVersion
;
1156 switch ( info
.dwPlatformId
)
1158 case VER_PLATFORM_WIN32s
:
1162 case VER_PLATFORM_WIN32_WINDOWS
:
1166 case VER_PLATFORM_WIN32_NT
:
1167 s_ver
= wxWINDOWS_NT
;
1170 case VER_PLATFORM_WIN32_CE
:
1171 s_ver
= wxWINDOWS_CE
;
1178 static wxToolkitInfo info
;
1179 info
.versionMajor
= s_major
;
1180 info
.versionMinor
= s_minor
;
1182 info
.name
= _T("wxBase");
1186 // ----------------------------------------------------------------------------
1188 // ----------------------------------------------------------------------------
1190 void wxMilliSleep(unsigned long milliseconds
)
1192 ::Sleep(milliseconds
);
1195 void wxMicroSleep(unsigned long microseconds
)
1197 wxMilliSleep(microseconds
/1000);
1200 void wxSleep(int nSecs
)
1202 wxMilliSleep(1000*nSecs
);
1205 // ----------------------------------------------------------------------------
1206 // font encoding <-> Win32 codepage conversion functions
1207 // ----------------------------------------------------------------------------
1209 extern WXDLLIMPEXP_BASE
long wxEncodingToCharset(wxFontEncoding encoding
)
1213 // although this function is supposed to return an exact match, do do
1214 // some mappings here for the most common case of "standard" encoding
1215 case wxFONTENCODING_SYSTEM
:
1216 return DEFAULT_CHARSET
;
1218 case wxFONTENCODING_ISO8859_1
:
1219 case wxFONTENCODING_ISO8859_15
:
1220 case wxFONTENCODING_CP1252
:
1221 return ANSI_CHARSET
;
1223 #if !defined(__WXMICROWIN__)
1224 // The following four fonts are multi-byte charsets
1225 case wxFONTENCODING_CP932
:
1226 return SHIFTJIS_CHARSET
;
1228 case wxFONTENCODING_CP936
:
1229 return GB2312_CHARSET
;
1231 case wxFONTENCODING_CP949
:
1232 return HANGUL_CHARSET
;
1234 case wxFONTENCODING_CP950
:
1235 return CHINESEBIG5_CHARSET
;
1237 // The rest are single byte encodings
1238 case wxFONTENCODING_CP1250
:
1239 return EASTEUROPE_CHARSET
;
1241 case wxFONTENCODING_CP1251
:
1242 return RUSSIAN_CHARSET
;
1244 case wxFONTENCODING_CP1253
:
1245 return GREEK_CHARSET
;
1247 case wxFONTENCODING_CP1254
:
1248 return TURKISH_CHARSET
;
1250 case wxFONTENCODING_CP1255
:
1251 return HEBREW_CHARSET
;
1253 case wxFONTENCODING_CP1256
:
1254 return ARABIC_CHARSET
;
1256 case wxFONTENCODING_CP1257
:
1257 return BALTIC_CHARSET
;
1259 case wxFONTENCODING_CP874
:
1260 return THAI_CHARSET
;
1261 #endif // !__WXMICROWIN__
1263 case wxFONTENCODING_CP437
:
1267 // no way to translate this encoding into a Windows charset
1272 // we have 2 versions of wxCharsetToCodepage(): the old one which directly
1273 // looks up the vlaues in the registry and the new one which is more
1274 // politically correct and has more chances to work on other Windows versions
1275 // as well but the old version is still needed for !wxUSE_FONTMAP case
1278 #include "wx/fontmap.h"
1280 extern WXDLLIMPEXP_BASE
long wxEncodingToCodepage(wxFontEncoding encoding
)
1282 // translate encoding into the Windows CHARSET
1283 long charset
= wxEncodingToCharset(encoding
);
1284 if ( charset
== -1 )
1287 // translate CHARSET to code page
1288 CHARSETINFO csetInfo
;
1289 if ( !::TranslateCharsetInfo((DWORD
*)(DWORD
)charset
,
1293 wxLogLastError(_T("TranslateCharsetInfo(TCI_SRCCHARSET)"));
1298 return csetInfo
.ciACP
;
1301 extern long wxCharsetToCodepage(const wxChar
*name
)
1303 // first get the font encoding for this charset
1307 wxFontEncoding enc
= wxFontMapper::Get()->CharsetToEncoding(name
, false);
1308 if ( enc
== wxFONTENCODING_SYSTEM
)
1311 // the use the helper function
1312 return wxEncodingToCodepage(enc
);
1315 #else // !wxUSE_FONTMAP
1317 #include "wx/msw/registry.h"
1319 // this should work if Internet Exploiter is installed
1320 extern long wxCharsetToCodepage(const wxChar
*name
)
1327 wxString
path(wxT("MIME\\Database\\Charset\\"));
1330 // follow the alias loop
1333 wxRegKey
key(wxRegKey::HKCR
, path
+ cn
);
1338 // two cases: either there's an AliasForCharset string,
1339 // or there are Codepage and InternetEncoding dwords.
1340 // The InternetEncoding gives us the actual encoding,
1341 // the Codepage just says which Windows character set to
1342 // use when displaying the data.
1343 if (key
.HasValue(wxT("InternetEncoding")) &&
1344 key
.QueryValue(wxT("InternetEncoding"), &CP
))
1347 // no encoding, see if it's an alias
1348 if (!key
.HasValue(wxT("AliasForCharset")) ||
1349 !key
.QueryValue(wxT("AliasForCharset"), cn
))
1356 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
1359 Creates a hidden window with supplied window proc registering the class for
1360 it if necesssary (i.e. the first time only). Caller is responsible for
1361 destroying the window and unregistering the class (note that this must be
1362 done because wxWidgets may be used as a DLL and so may be loaded/unloaded
1363 multiple times into/from the same process so we cna't rely on automatic
1364 Windows class unregistration).
1366 pclassname is a pointer to a caller stored classname, which must initially be
1367 NULL. classname is the desired wndclass classname. If function succesfully
1368 registers the class, pclassname will be set to classname.
1370 extern "C" WXDLLIMPEXP_BASE HWND
1371 wxCreateHiddenWindow(LPCTSTR
*pclassname
, LPCTSTR classname
, WNDPROC wndproc
)
1373 wxCHECK_MSG( classname
&& pclassname
&& wndproc
, NULL
,
1374 _T("NULL parameter in wxCreateHiddenWindow") );
1376 // register the class fi we need to first
1377 if ( *pclassname
== NULL
)
1380 wxZeroMemory(wndclass
);
1382 wndclass
.lpfnWndProc
= wndproc
;
1383 wndclass
.hInstance
= wxGetInstance();
1384 wndclass
.lpszClassName
= classname
;
1386 if ( !::RegisterClass(&wndclass
) )
1388 wxLogLastError(wxT("RegisterClass() in wxCreateHiddenWindow"));
1393 *pclassname
= classname
;
1396 // next create the window
1397 HWND hwnd
= ::CreateWindow
1411 wxLogLastError(wxT("CreateWindow() in wxCreateHiddenWindow"));