1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/utils.cpp
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/msw/registry.h"
35 #include "wx/apptrait.h"
36 #include "wx/dynlib.h"
37 #include "wx/dynload.h"
38 #include "wx/scopeguard.h"
40 #include "wx/confbase.h" // for wxExpandEnvVars()
42 #include "wx/msw/private.h" // includes <windows.h>
43 #include "wx/msw/missing.h" // for CHARSET_HANGUL
45 #if defined(__CYGWIN__)
46 //CYGWIN gives annoying warning about runtime stuff if we don't do this
47 # define USE_SYS_TYPES_FD_SET
48 # include <sys/types.h>
51 // Doesn't work with Cygwin at present
52 #if wxUSE_SOCKETS && (defined(__GNUWIN32_OLD__) || defined(__WXWINCE__) || defined(__CYGWIN32__))
53 // apparently we need to include winsock.h to get WSADATA and other stuff
54 // used in wxGetFullHostName() with the old mingw32 versions
58 #if !defined(__GNUWIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
66 #if defined(__CYGWIN__)
67 #include <sys/unistd.h>
69 #include <sys/cygwin.h> // for cygwin_conv_to_full_win32_path()
72 #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs
73 // this (3.1 I believe) and how to test for it.
74 // If this works for Borland 4.0 as well, then no worries.
78 // VZ: there is some code using NetXXX() functions to get the full user name:
79 // I don't think it's a good idea because they don't work under Win95 and
80 // seem to return the same as wxGetUserId() under NT. If you really want
81 // to use them, just #define USE_NET_API
88 #if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
99 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
104 // For wxKillAllChildren
105 #include <tlhelp32.h>
107 // ----------------------------------------------------------------------------
109 // ----------------------------------------------------------------------------
111 // In the WIN.INI file
112 #if (!defined(USE_NET_API) && !defined(__WXWINCE__)) || defined(__WXMICROWIN__)
113 static const wxChar WX_SECTION
[] = wxT("wxWindows");
116 #if (!defined(USE_NET_API) && !defined(__WXWINCE__))
117 static const wxChar eUSERNAME
[] = wxT("UserName");
120 // ============================================================================
122 // ============================================================================
124 // ----------------------------------------------------------------------------
125 // get host name and related
126 // ----------------------------------------------------------------------------
128 // Get hostname only (without domain name)
129 bool wxGetHostName(wxChar
*WXUNUSED_IN_WINCE(buf
),
130 int WXUNUSED_IN_WINCE(maxSize
))
132 #if defined(__WXWINCE__)
135 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
136 DWORD nSize
= maxSize
;
137 if ( !::GetComputerName(buf
, &nSize
) )
139 wxLogLastError(wxT("GetComputerName"));
147 const wxChar
*default_host
= wxT("noname");
149 if ((sysname
= wxGetenv(wxT("SYSTEM_NAME"))) == NULL
) {
150 GetProfileString(WX_SECTION
, eHOSTNAME
, default_host
, buf
, maxSize
- 1);
152 wxStrncpy(buf
, sysname
, maxSize
- 1);
153 buf
[maxSize
] = wxT('\0');
154 return *buf
? true : false;
158 // get full hostname (with domain name if possible)
159 bool wxGetFullHostName(wxChar
*buf
, int maxSize
)
161 #if !defined( __WXMICROWIN__) && wxUSE_DYNLIB_CLASS && wxUSE_SOCKETS
162 // TODO should use GetComputerNameEx() when available
164 // we don't want to always link with Winsock DLL as we might not use it at
165 // all, so load it dynamically here if needed (and don't complain if it is
166 // missing, we handle this)
169 wxDynamicLibrary
dllWinsock(_T("ws2_32.dll"), wxDL_VERBATIM
);
170 if ( dllWinsock
.IsLoaded() )
172 typedef int (PASCAL
*WSAStartup_t
)(WORD
, WSADATA
*);
173 typedef int (PASCAL
*gethostname_t
)(char *, int);
174 typedef hostent
* (PASCAL
*gethostbyname_t
)(const char *);
175 typedef hostent
* (PASCAL
*gethostbyaddr_t
)(const char *, int , int);
176 typedef int (PASCAL
*WSACleanup_t
)(void);
178 #define LOAD_WINSOCK_FUNC(func) \
180 pfn ## func = (func ## _t)dllWinsock.GetSymbol(_T(#func))
182 LOAD_WINSOCK_FUNC(WSAStartup
);
185 if ( pfnWSAStartup
&& pfnWSAStartup(MAKEWORD(1, 1), &wsa
) == 0 )
187 LOAD_WINSOCK_FUNC(gethostname
);
190 if ( pfngethostname
)
193 if ( pfngethostname(bufA
, WXSIZEOF(bufA
)) == 0 )
195 // gethostname() won't usually include the DNS domain name,
196 // for this we need to work a bit more
197 if ( !strchr(bufA
, '.') )
199 LOAD_WINSOCK_FUNC(gethostbyname
);
201 struct hostent
*pHostEnt
= pfngethostbyname
202 ? pfngethostbyname(bufA
)
207 // Windows will use DNS internally now
208 LOAD_WINSOCK_FUNC(gethostbyaddr
);
210 pHostEnt
= pfngethostbyaddr
211 ? pfngethostbyaddr(pHostEnt
->h_addr
,
218 host
= wxString::FromAscii(pHostEnt
->h_name
);
224 LOAD_WINSOCK_FUNC(WSACleanup
);
231 wxStrncpy(buf
, host
, maxSize
);
237 #endif // !__WXMICROWIN__
239 return wxGetHostName(buf
, maxSize
);
242 // Get user ID e.g. jacs
243 bool wxGetUserId(wxChar
*WXUNUSED_IN_WINCE(buf
),
244 int WXUNUSED_IN_WINCE(maxSize
))
246 #if defined(__WXWINCE__)
249 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
250 DWORD nSize
= maxSize
;
251 if ( ::GetUserName(buf
, &nSize
) == 0 )
253 // actually, it does happen on Win9x if the user didn't log on
254 DWORD res
= ::GetEnvironmentVariable(wxT("username"), buf
, maxSize
);
263 #else // __WXMICROWIN__
265 const wxChar
*default_id
= wxT("anonymous");
267 // Can't assume we have NIS (PC-NFS) or some other ID daemon
269 if ( (user
= wxGetenv(wxT("USER"))) == NULL
&&
270 (user
= wxGetenv(wxT("LOGNAME"))) == NULL
)
272 // Use wxWidgets configuration data (comming soon)
273 GetProfileString(WX_SECTION
, eUSERID
, default_id
, buf
, maxSize
- 1);
277 wxStrncpy(buf
, user
, maxSize
- 1);
280 return *buf
? true : false;
284 // Get user name e.g. Julian Smart
285 bool wxGetUserName(wxChar
*buf
, int maxSize
)
287 wxCHECK_MSG( buf
&& ( maxSize
> 0 ), false,
288 _T("empty buffer in wxGetUserName") );
289 #if defined(__WXWINCE__) && wxUSE_REGKEY
291 wxRegKey
key(wxRegKey::HKCU
, wxT("ControlPanel\\Owner"));
292 if(!key
.Open(wxRegKey::Read
))
295 if(!key
.QueryValue(wxT("Owner"),name
))
297 wxStrncpy(buf
, name
.c_str(), maxSize
-1);
298 buf
[maxSize
-1] = _T('\0');
300 #elif defined(USE_NET_API)
301 CHAR szUserName
[256];
302 if ( !wxGetUserId(szUserName
, WXSIZEOF(szUserName
)) )
305 // TODO how to get the domain name?
308 // the code is based on the MSDN example (also see KB article Q119670)
309 WCHAR wszUserName
[256]; // Unicode user name
310 WCHAR wszDomain
[256];
313 USER_INFO_2
*ui2
; // User structure
315 // Convert ANSI user name and domain to Unicode
316 MultiByteToWideChar( CP_ACP
, 0, szUserName
, strlen(szUserName
)+1,
317 wszUserName
, WXSIZEOF(wszUserName
) );
318 MultiByteToWideChar( CP_ACP
, 0, szDomain
, strlen(szDomain
)+1,
319 wszDomain
, WXSIZEOF(wszDomain
) );
321 // Get the computer name of a DC for the domain.
322 if ( NetGetDCName( NULL
, wszDomain
, &ComputerName
) != NERR_Success
)
324 wxLogError(wxT("Can not find domain controller"));
329 // Look up the user on the DC
330 NET_API_STATUS status
= NetUserGetInfo( (LPWSTR
)ComputerName
,
331 (LPWSTR
)&wszUserName
,
332 2, // level - we want USER_INFO_2
340 case NERR_InvalidComputer
:
341 wxLogError(wxT("Invalid domain controller name."));
345 case NERR_UserNotFound
:
346 wxLogError(wxT("Invalid user name '%s'."), szUserName
);
351 wxLogSysError(wxT("Can't get information about user"));
356 // Convert the Unicode full name to ANSI
357 WideCharToMultiByte( CP_ACP
, 0, ui2
->usri2_full_name
, -1,
358 buf
, maxSize
, NULL
, NULL
);
363 wxLogError(wxT("Couldn't look up full user name."));
366 #else // !USE_NET_API
367 // Could use NIS, MS-Mail or other site specific programs
368 // Use wxWidgets configuration data
369 bool ok
= GetProfileString(WX_SECTION
, eUSERNAME
, wxEmptyString
, buf
, maxSize
- 1) != 0;
372 ok
= wxGetUserId(buf
, maxSize
);
377 wxStrncpy(buf
, wxT("Unknown User"), maxSize
);
384 const wxChar
* wxGetHomeDir(wxString
*pstr
)
386 wxString
& strDir
= *pstr
;
388 // first branch is for Cygwin
389 #if defined(__UNIX__) && !defined(__WINE__)
390 const wxChar
*szHome
= wxGetenv("HOME");
391 if ( szHome
== NULL
) {
393 wxLogWarning(_("can't find user's HOME, using current directory."));
399 // add a trailing slash if needed
400 if ( strDir
.Last() != wxT('/') )
404 // Cygwin returns unix type path but that does not work well
405 static wxChar windowsPath
[MAX_PATH
];
406 cygwin_conv_to_full_win32_path(strDir
, windowsPath
);
407 strDir
= windowsPath
;
409 #elif defined(__WXWINCE__)
414 // If we have a valid HOME directory, as is used on many machines that
415 // have unix utilities on them, we should use that.
416 const wxChar
*szHome
= wxGetenv(wxT("HOME"));
418 if ( szHome
!= NULL
)
422 else // no HOME, try HOMEDRIVE/PATH
424 szHome
= wxGetenv(wxT("HOMEDRIVE"));
425 if ( szHome
!= NULL
)
427 szHome
= wxGetenv(wxT("HOMEPATH"));
429 if ( szHome
!= NULL
)
433 // the idea is that under NT these variables have default values
434 // of "%systemdrive%:" and "\\". As we don't want to create our
435 // config files in the root directory of the system drive, we will
436 // create it in our program's dir. However, if the user took care
437 // to set HOMEPATH to something other than "\\", we suppose that he
438 // knows what he is doing and use the supplied value.
439 if ( wxStrcmp(szHome
, wxT("\\")) == 0 )
444 if ( strDir
.empty() )
446 // If we have a valid USERPROFILE directory, as is the case in
447 // Windows NT, 2000 and XP, we should use that as our home directory.
448 szHome
= wxGetenv(wxT("USERPROFILE"));
450 if ( szHome
!= NULL
)
454 if ( !strDir
.empty() )
456 // sometimes the value of HOME may be "%USERPROFILE%", so reexpand the
457 // value once again, it shouldn't hurt anyhow
458 strDir
= wxExpandEnvVars(strDir
);
460 else // fall back to the program directory
462 // extract the directory component of the program file name
463 wxSplitPath(wxGetFullModuleName(), &strDir
, NULL
, NULL
);
467 return strDir
.c_str();
470 wxString
wxGetUserHome(const wxString
& user
)
474 if ( user
.empty() || user
== wxGetUserId() )
480 bool wxGetDiskSpace(const wxString
& WXUNUSED_IN_WINCE(path
),
481 wxDiskspaceSize_t
*WXUNUSED_IN_WINCE(pTotal
),
482 wxDiskspaceSize_t
*WXUNUSED_IN_WINCE(pFree
))
491 // old w32api don't have ULARGE_INTEGER
492 #if defined(__WIN32__) && \
493 (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION( 0, 3 ))
494 // GetDiskFreeSpaceEx() is not available under original Win95, check for
496 typedef BOOL (WINAPI
*GetDiskFreeSpaceEx_t
)(LPCTSTR
,
502 pGetDiskFreeSpaceEx
= (GetDiskFreeSpaceEx_t
)::GetProcAddress
504 ::GetModuleHandle(_T("kernel32.dll")),
506 "GetDiskFreeSpaceExW"
508 "GetDiskFreeSpaceExA"
512 if ( pGetDiskFreeSpaceEx
)
514 ULARGE_INTEGER bytesFree
, bytesTotal
;
516 // may pass the path as is, GetDiskFreeSpaceEx() is smart enough
517 if ( !pGetDiskFreeSpaceEx(path
.fn_str(),
522 wxLogLastError(_T("GetDiskFreeSpaceEx"));
527 // ULARGE_INTEGER is a union of a 64 bit value and a struct containing
528 // two 32 bit fields which may be or may be not named - try to make it
529 // compile in all cases
530 #if defined(__BORLANDC__) && !defined(_ANONYMOUS_STRUCT)
538 *pTotal
= wxDiskspaceSize_t(UL(bytesTotal
).HighPart
, UL(bytesTotal
).LowPart
);
540 *pTotal
= wxDiskspaceSize_t(UL(bytesTotal
).LowPart
);
547 *pFree
= wxLongLong(UL(bytesFree
).HighPart
, UL(bytesFree
).LowPart
);
549 *pFree
= wxDiskspaceSize_t(UL(bytesFree
).LowPart
);
556 // there's a problem with drives larger than 2GB, GetDiskFreeSpaceEx()
557 // should be used instead - but if it's not available, fall back on
558 // GetDiskFreeSpace() nevertheless...
560 DWORD lSectorsPerCluster
,
562 lNumberOfFreeClusters
,
563 lTotalNumberOfClusters
;
565 // FIXME: this is wrong, we should extract the root drive from path
566 // instead, but this is the job for wxFileName...
567 if ( !::GetDiskFreeSpace(path
.fn_str(),
570 &lNumberOfFreeClusters
,
571 &lTotalNumberOfClusters
) )
573 wxLogLastError(_T("GetDiskFreeSpace"));
578 wxDiskspaceSize_t lBytesPerCluster
= (wxDiskspaceSize_t
) lSectorsPerCluster
;
579 lBytesPerCluster
*= lBytesPerSector
;
583 *pTotal
= lBytesPerCluster
;
584 *pTotal
*= lTotalNumberOfClusters
;
589 *pFree
= lBytesPerCluster
;
590 *pFree
*= lNumberOfFreeClusters
;
599 // ----------------------------------------------------------------------------
601 // ----------------------------------------------------------------------------
603 bool wxGetEnv(const wxString
& WXUNUSED_IN_WINCE(var
),
604 wxString
*WXUNUSED_IN_WINCE(value
))
607 // no environment variables under CE
610 // first get the size of the buffer
611 DWORD dwRet
= ::GetEnvironmentVariable(var
.t_str(), NULL
, 0);
614 // this means that there is no such variable
620 (void)::GetEnvironmentVariable(var
.t_str(),
621 wxStringBuffer(*value
, dwRet
),
629 bool wxDoSetEnv(const wxString
& WXUNUSED_IN_WINCE(var
),
630 const wxChar
*WXUNUSED_IN_WINCE(value
))
632 // some compilers have putenv() or _putenv() or _wputenv() but it's better
633 // to always use Win32 function directly instead of dealing with them
635 // no environment variables under CE
638 if ( !::SetEnvironmentVariable(var
.t_str(), value
) )
640 wxLogLastError(_T("SetEnvironmentVariable"));
649 bool wxSetEnv(const wxString
& variable
, const wxString
& value
)
651 return wxDoSetEnv(variable
, value
.t_str());
654 bool wxUnsetEnv(const wxString
& variable
)
656 return wxDoSetEnv(variable
, NULL
);
659 // ----------------------------------------------------------------------------
660 // process management
661 // ----------------------------------------------------------------------------
663 // structure used to pass parameters from wxKill() to wxEnumFindByPidProc()
664 struct wxFindByPidParams
666 wxFindByPidParams() { hwnd
= 0; pid
= 0; }
668 // the HWND used to return the result
671 // the PID we're looking from
674 DECLARE_NO_COPY_CLASS(wxFindByPidParams
)
677 // wxKill helper: EnumWindows() callback which is used to find the first (top
678 // level) window belonging to the given process
679 BOOL CALLBACK
wxEnumFindByPidProc(HWND hwnd
, LPARAM lParam
)
682 (void)::GetWindowThreadProcessId(hwnd
, &pid
);
684 wxFindByPidParams
*params
= (wxFindByPidParams
*)lParam
;
685 if ( pid
== params
->pid
)
687 // remember the window we found
690 // return FALSE to stop the enumeration
694 // continue enumeration
698 int wxKillAllChildren(long pid
, wxSignal sig
, wxKillError
*krc
);
700 int wxKill(long pid
, wxSignal sig
, wxKillError
*krc
, int flags
)
702 if (flags
& wxKILL_CHILDREN
)
703 wxKillAllChildren(pid
, sig
, krc
);
705 // get the process handle to operate on
706 HANDLE hProcess
= ::OpenProcess(SYNCHRONIZE
|
708 PROCESS_QUERY_INFORMATION
,
709 FALSE
, // not inheritable
711 if ( hProcess
== NULL
)
715 // recognize wxKILL_ACCESS_DENIED as special because this doesn't
716 // mean that the process doesn't exist and this is important for
717 // wxProcess::Exists()
718 *krc
= ::GetLastError() == ERROR_ACCESS_DENIED
719 ? wxKILL_ACCESS_DENIED
726 wxON_BLOCK_EXIT1(::CloseHandle
, hProcess
);
732 // kill the process forcefully returning -1 as error code
733 if ( !::TerminateProcess(hProcess
, (UINT
)-1) )
735 wxLogSysError(_("Failed to kill process %d"), pid
);
739 // this is not supposed to happen if we could open the
749 // do nothing, we just want to test for process existence
755 // any other signal means "terminate"
757 wxFindByPidParams params
;
758 params
.pid
= (DWORD
)pid
;
760 // EnumWindows() has nice semantics: it returns 0 if it found
761 // something or if an error occurred and non zero if it
762 // enumerated all the window
763 if ( !::EnumWindows(wxEnumFindByPidProc
, (LPARAM
)¶ms
) )
765 // did we find any window?
768 // tell the app to close
770 // NB: this is the harshest way, the app won't have an
771 // opportunity to save any files, for example, but
772 // this is probably what we want here. If not we
773 // can also use SendMesageTimeout(WM_CLOSE)
774 if ( !::PostMessage(params
.hwnd
, WM_QUIT
, 0, 0) )
776 wxLogLastError(_T("PostMessage(WM_QUIT)"));
779 else // it was an error then
781 wxLogLastError(_T("EnumWindows"));
786 else // no windows for this PID
797 DWORD rc
wxDUMMY_INITIALIZE(0);
800 // as we wait for a short time, we can use just WaitForSingleObject()
801 // and not MsgWaitForMultipleObjects()
802 switch ( ::WaitForSingleObject(hProcess
, 500 /* msec */) )
805 // process terminated
806 if ( !::GetExitCodeProcess(hProcess
, &rc
) )
808 wxLogLastError(_T("GetExitCodeProcess"));
813 wxFAIL_MSG( _T("unexpected WaitForSingleObject() return") );
817 wxLogLastError(_T("WaitForSingleObject"));
830 // the return code is the same as from Unix kill(): 0 if killed
831 // successfully or -1 on error
832 if ( !ok
|| rc
== STILL_ACTIVE
)
841 typedef HANDLE (WINAPI
*CreateToolhelp32Snapshot_t
)(DWORD
,DWORD
);
842 typedef BOOL (WINAPI
*Process32_t
)(HANDLE
,LPPROCESSENTRY32
);
844 CreateToolhelp32Snapshot_t lpfCreateToolhelp32Snapshot
;
845 Process32_t lpfProcess32First
, lpfProcess32Next
;
847 static void InitToolHelp32()
849 static bool s_initToolHelpDone
= false;
851 if (s_initToolHelpDone
)
854 s_initToolHelpDone
= true;
856 lpfCreateToolhelp32Snapshot
= NULL
;
857 lpfProcess32First
= NULL
;
858 lpfProcess32Next
= NULL
;
860 #if wxUSE_DYNLIB_CLASS
862 wxDynamicLibrary
dllKernel(_T("kernel32.dll"), wxDL_VERBATIM
);
864 // Get procedure addresses.
865 // We are linking to these functions of Kernel32
866 // explicitly, because otherwise a module using
867 // this code would fail to load under Windows NT,
868 // which does not have the Toolhelp32
869 // functions in the Kernel 32.
870 lpfCreateToolhelp32Snapshot
=
871 (CreateToolhelp32Snapshot_t
)dllKernel
.RawGetSymbol(_T("CreateToolhelp32Snapshot"));
874 (Process32_t
)dllKernel
.RawGetSymbol(_T("Process32First"));
877 (Process32_t
)dllKernel
.RawGetSymbol(_T("Process32Next"));
879 #endif // wxUSE_DYNLIB_CLASS
883 int wxKillAllChildren(long pid
, wxSignal sig
, wxKillError
*krc
)
890 // If not implemented for this platform (e.g. NT 4.0), silently ignore
891 if (!lpfCreateToolhelp32Snapshot
|| !lpfProcess32First
|| !lpfProcess32Next
)
894 // Take a snapshot of all processes in the system.
895 HANDLE hProcessSnap
= lpfCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS
, 0);
896 if (hProcessSnap
== INVALID_HANDLE_VALUE
) {
902 //Fill in the size of the structure before using it.
905 pe
.dwSize
= sizeof(PROCESSENTRY32
);
907 // Walk the snapshot of the processes, and for each process,
908 // kill it if its parent is pid.
909 if (!lpfProcess32First(hProcessSnap
, &pe
)) {
910 // Can't get first process.
913 CloseHandle (hProcessSnap
);
918 if (pe
.th32ParentProcessID
== (DWORD
) pid
) {
919 if (wxKill(pe
.th32ProcessID
, sig
, krc
))
922 } while (lpfProcess32Next (hProcessSnap
, &pe
));
928 // Execute a program in an Interactive Shell
929 bool wxShell(const wxString
& command
)
936 wxChar
*shell
= wxGetenv(wxT("COMSPEC"));
938 shell
= (wxChar
*) wxT("\\COMMAND.COM");
947 // pass the command to execute to the command processor
948 cmd
.Printf(wxT("%s /c %s"), shell
, command
.c_str());
952 return wxExecute(cmd
, wxEXEC_SYNC
) == 0;
955 // Shutdown or reboot the PC
956 bool wxShutdown(wxShutdownFlags
WXUNUSED_IN_WINCE(wFlags
))
961 #elif defined(__WIN32__)
964 if ( wxGetOsVersion(NULL
, NULL
) == wxOS_WINDOWS_NT
) // if is NT or 2K
966 // Get a token for this process.
968 bOK
= ::OpenProcessToken(GetCurrentProcess(),
969 TOKEN_ADJUST_PRIVILEGES
| TOKEN_QUERY
,
973 TOKEN_PRIVILEGES tkp
;
975 // Get the LUID for the shutdown privilege.
976 ::LookupPrivilegeValue(NULL
, SE_SHUTDOWN_NAME
,
977 &tkp
.Privileges
[0].Luid
);
979 tkp
.PrivilegeCount
= 1; // one privilege to set
980 tkp
.Privileges
[0].Attributes
= SE_PRIVILEGE_ENABLED
;
982 // Get the shutdown privilege for this process.
983 ::AdjustTokenPrivileges(hToken
, FALSE
, &tkp
, 0,
984 (PTOKEN_PRIVILEGES
)NULL
, 0);
986 // Cannot test the return value of AdjustTokenPrivileges.
987 bOK
= ::GetLastError() == ERROR_SUCCESS
;
993 UINT flags
= EWX_SHUTDOWN
| EWX_FORCE
;
996 case wxSHUTDOWN_POWEROFF
:
997 flags
|= EWX_POWEROFF
;
1000 case wxSHUTDOWN_REBOOT
:
1001 flags
|= EWX_REBOOT
;
1005 wxFAIL_MSG( _T("unknown wxShutdown() flag") );
1009 bOK
= ::ExitWindowsEx(flags
, 0) != 0;
1016 // ----------------------------------------------------------------------------
1018 // ----------------------------------------------------------------------------
1020 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
1021 wxMemorySize
wxGetFreeMemory()
1023 #if defined(__WIN64__)
1024 MEMORYSTATUSEX memStatex
;
1025 memStatex
.dwLength
= sizeof (memStatex
);
1026 ::GlobalMemoryStatusEx (&memStatex
);
1027 return (wxMemorySize
)memStatex
.ullAvailPhys
;
1028 #else /* if defined(__WIN32__) */
1029 MEMORYSTATUS memStatus
;
1030 memStatus
.dwLength
= sizeof(MEMORYSTATUS
);
1031 ::GlobalMemoryStatus(&memStatus
);
1032 return (wxMemorySize
)memStatus
.dwAvailPhys
;
1036 unsigned long wxGetProcessId()
1038 return ::GetCurrentProcessId();
1044 ::MessageBeep((UINT
)-1); // default sound
1047 bool wxIsDebuggerRunning()
1049 #if wxUSE_DYNLIB_CLASS
1050 // IsDebuggerPresent() is not available under Win95, so load it dynamically
1051 wxDynamicLibrary
dll(_T("kernel32.dll"), wxDL_VERBATIM
);
1053 typedef BOOL (WINAPI
*IsDebuggerPresent_t
)();
1054 if ( !dll
.HasSymbol(_T("IsDebuggerPresent")) )
1056 // no way to know, assume no
1060 return (*(IsDebuggerPresent_t
)dll
.GetSymbol(_T("IsDebuggerPresent")))() != 0;
1066 // ----------------------------------------------------------------------------
1068 // ----------------------------------------------------------------------------
1070 // check if we're running under a server or workstation Windows system: it
1071 // returns true or false with obvious meaning as well as -1 if the system type
1072 // couldn't be determined
1074 // this function is currently private but we may want to expose it later if
1075 // it's really useful
1079 int wxIsWindowsServer()
1081 #ifdef VER_NT_WORKSTATION
1082 OSVERSIONINFOEX info
;
1085 info
.dwOSVersionInfoSize
= sizeof(info
);
1086 if ( ::GetVersionEx(wx_reinterpret_cast(OSVERSIONINFO
*, &info
)) )
1088 switch ( info
.wProductType
)
1090 case VER_NT_WORKSTATION
:
1094 case VER_NT_DOMAIN_CONTROLLER
:
1098 #endif // VER_NT_WORKSTATION
1103 } // anonymous namespace
1105 wxString
wxGetOsDescription()
1112 info
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFO
);
1113 if ( ::GetVersionEx(&info
) )
1115 switch ( info
.dwPlatformId
)
1117 #ifdef VER_PLATFORM_WIN32_CE
1118 case VER_PLATFORM_WIN32_CE
:
1119 str
.Printf(_("Windows CE (%d.%d)"),
1120 info
.dwMajorVersion
,
1121 info
.dwMinorVersion
);
1124 case VER_PLATFORM_WIN32s
:
1125 str
= _("Win32s on Windows 3.1");
1128 case VER_PLATFORM_WIN32_WINDOWS
:
1129 switch (info
.dwMinorVersion
)
1132 if ( info
.szCSDVersion
[1] == 'B' ||
1133 info
.szCSDVersion
[1] == 'C' )
1135 str
= _("Windows 95 OSR2");
1139 str
= _("Windows 95");
1143 if ( info
.szCSDVersion
[1] == 'B' ||
1144 info
.szCSDVersion
[1] == 'C' )
1146 str
= _("Windows 98 SE");
1150 str
= _("Windows 98");
1154 str
= _("Windows ME");
1157 str
.Printf(_("Windows 9x (%d.%d)"),
1158 info
.dwMajorVersion
,
1159 info
.dwMinorVersion
);
1162 if ( !wxIsEmpty(info
.szCSDVersion
) )
1164 str
<< _T(" (") << info
.szCSDVersion
<< _T(')');
1168 case VER_PLATFORM_WIN32_NT
:
1169 switch ( info
.dwMajorVersion
)
1172 switch ( info
.dwMinorVersion
)
1175 str
.Printf(_("Windows 2000 (build %lu"),
1176 info
.dwBuildNumber
);
1180 // we can't distinguish between XP 64 and 2003
1181 // as they both are 5.2, so examine the product
1182 // type to resolve this ambiguity
1183 if ( wxIsWindowsServer() == 1 )
1185 str
.Printf(_("Windows Server 2003 (build %lu"),
1186 info
.dwBuildNumber
);
1189 //else: must be XP, fall through
1192 str
.Printf(_("Windows XP (build %lu"),
1193 info
.dwBuildNumber
);
1199 if ( info
.dwMinorVersion
== 0 )
1201 str
.Printf(_("Windows Vista (build %lu"),
1202 info
.dwBuildNumber
);
1209 str
.Printf(_("Windows NT %lu.%lu (build %lu"),
1210 info
.dwMajorVersion
,
1211 info
.dwMinorVersion
,
1212 info
.dwBuildNumber
);
1215 if ( !wxIsEmpty(info
.szCSDVersion
) )
1217 str
<< _T(", ") << info
.szCSDVersion
;
1221 if ( wxIsPlatform64Bit() )
1222 str
<< _(", 64-bit edition");
1228 wxFAIL_MSG( _T("GetVersionEx() failed") ); // should never happen
1234 bool wxIsPlatform64Bit()
1237 return true; // 64-bit programs run only on Win64
1238 #elif wxUSE_DYNLIB_CLASS // Win32
1239 // 32-bit programs run on both 32-bit and 64-bit Windows so check
1240 typedef BOOL (WINAPI
*IsWow64Process_t
)(HANDLE
, BOOL
*);
1242 wxDynamicLibrary
dllKernel32(_T("kernel32.dll"));
1243 IsWow64Process_t pfnIsWow64Process
=
1244 (IsWow64Process_t
)dllKernel32
.RawGetSymbol(_T("IsWow64Process"));
1247 if ( pfnIsWow64Process
)
1249 pfnIsWow64Process(::GetCurrentProcess(), &wow64
);
1251 //else: running under a system without Win64 support
1253 return wow64
!= FALSE
;
1256 #endif // Win64/Win32
1259 wxOperatingSystemId
wxGetOsVersion(int *verMaj
, int *verMin
)
1263 // this may be false, true or -1 if we tried to initialize but failed
1266 wxOperatingSystemId os
;
1272 // query the OS info only once as it's not supposed to change
1273 if ( !s_version
.initialized
)
1277 info
.dwOSVersionInfoSize
= sizeof(info
);
1278 if ( ::GetVersionEx(&info
) )
1280 s_version
.initialized
= true;
1282 #if defined(__WXWINCE__)
1283 s_version
.os
= wxOS_WINDOWS_CE
;
1284 #elif defined(__WXMICROWIN__)
1285 s_version
.os
= wxOS_WINDOWS_MICRO
;
1286 #else // "normal" desktop Windows system, use run-time detection
1287 switch ( info
.dwPlatformId
)
1289 case VER_PLATFORM_WIN32_NT
:
1290 s_version
.os
= wxOS_WINDOWS_NT
;
1293 case VER_PLATFORM_WIN32_WINDOWS
:
1294 s_version
.os
= wxOS_WINDOWS_9X
;
1297 #endif // Windows versions
1299 s_version
.verMaj
= info
.dwMajorVersion
;
1300 s_version
.verMin
= info
.dwMinorVersion
;
1302 else // GetVersionEx() failed
1304 s_version
.initialized
= -1;
1308 if ( s_version
.initialized
== 1 )
1311 *verMaj
= s_version
.verMaj
;
1313 *verMin
= s_version
.verMin
;
1316 // this works even if we were not initialized successfully as the initial
1317 // values of this field is 0 which is wxOS_UNKNOWN and exactly what we need
1318 return s_version
.os
;
1321 wxWinVersion
wxGetWinVersion()
1325 switch ( wxGetOsVersion(&verMaj
, &verMin
) )
1327 case wxOS_WINDOWS_9X
:
1333 return wxWinVersion_95
;
1336 return wxWinVersion_98
;
1339 return wxWinVersion_ME
;
1344 case wxOS_WINDOWS_NT
:
1348 return wxWinVersion_NT3
;
1351 return wxWinVersion_NT4
;
1357 return wxWinVersion_2000
;
1360 return wxWinVersion_XP
;
1363 return wxWinVersion_2003
;
1368 return wxWinVersion_NT6
;
1373 // Do nothing just to silence GCC warning
1377 return wxWinVersion_Unknown
;
1380 // ----------------------------------------------------------------------------
1382 // ----------------------------------------------------------------------------
1384 void wxMilliSleep(unsigned long milliseconds
)
1386 ::Sleep(milliseconds
);
1389 void wxMicroSleep(unsigned long microseconds
)
1391 wxMilliSleep(microseconds
/1000);
1394 void wxSleep(int nSecs
)
1396 wxMilliSleep(1000*nSecs
);
1399 // ----------------------------------------------------------------------------
1400 // font encoding <-> Win32 codepage conversion functions
1401 // ----------------------------------------------------------------------------
1403 extern WXDLLIMPEXP_BASE
long wxEncodingToCharset(wxFontEncoding encoding
)
1407 // although this function is supposed to return an exact match, do do
1408 // some mappings here for the most common case of "standard" encoding
1409 case wxFONTENCODING_SYSTEM
:
1410 return DEFAULT_CHARSET
;
1412 case wxFONTENCODING_ISO8859_1
:
1413 case wxFONTENCODING_ISO8859_15
:
1414 case wxFONTENCODING_CP1252
:
1415 return ANSI_CHARSET
;
1417 #if !defined(__WXMICROWIN__)
1418 // The following four fonts are multi-byte charsets
1419 case wxFONTENCODING_CP932
:
1420 return SHIFTJIS_CHARSET
;
1422 case wxFONTENCODING_CP936
:
1423 return GB2312_CHARSET
;
1426 case wxFONTENCODING_CP949
:
1427 return HANGUL_CHARSET
;
1430 case wxFONTENCODING_CP950
:
1431 return CHINESEBIG5_CHARSET
;
1433 // The rest are single byte encodings
1434 case wxFONTENCODING_CP1250
:
1435 return EASTEUROPE_CHARSET
;
1437 case wxFONTENCODING_CP1251
:
1438 return RUSSIAN_CHARSET
;
1440 case wxFONTENCODING_CP1253
:
1441 return GREEK_CHARSET
;
1443 case wxFONTENCODING_CP1254
:
1444 return TURKISH_CHARSET
;
1446 case wxFONTENCODING_CP1255
:
1447 return HEBREW_CHARSET
;
1449 case wxFONTENCODING_CP1256
:
1450 return ARABIC_CHARSET
;
1452 case wxFONTENCODING_CP1257
:
1453 return BALTIC_CHARSET
;
1455 case wxFONTENCODING_CP874
:
1456 return THAI_CHARSET
;
1457 #endif // !__WXMICROWIN__
1459 case wxFONTENCODING_CP437
:
1463 // no way to translate this encoding into a Windows charset
1468 // we have 2 versions of wxCharsetToCodepage(): the old one which directly
1469 // looks up the vlaues in the registry and the new one which is more
1470 // politically correct and has more chances to work on other Windows versions
1471 // as well but the old version is still needed for !wxUSE_FONTMAP case
1474 #include "wx/fontmap.h"
1476 extern WXDLLIMPEXP_BASE
long wxEncodingToCodepage(wxFontEncoding encoding
)
1478 // There don't seem to be symbolic names for
1479 // these under Windows so I just copied the
1480 // values from MSDN.
1486 case wxFONTENCODING_ISO8859_1
: ret
= 28591; break;
1487 case wxFONTENCODING_ISO8859_2
: ret
= 28592; break;
1488 case wxFONTENCODING_ISO8859_3
: ret
= 28593; break;
1489 case wxFONTENCODING_ISO8859_4
: ret
= 28594; break;
1490 case wxFONTENCODING_ISO8859_5
: ret
= 28595; break;
1491 case wxFONTENCODING_ISO8859_6
: ret
= 28596; break;
1492 case wxFONTENCODING_ISO8859_7
: ret
= 28597; break;
1493 case wxFONTENCODING_ISO8859_8
: ret
= 28598; break;
1494 case wxFONTENCODING_ISO8859_9
: ret
= 28599; break;
1495 case wxFONTENCODING_ISO8859_10
: ret
= 28600; break;
1496 case wxFONTENCODING_ISO8859_11
: ret
= 874; break;
1497 // case wxFONTENCODING_ISO8859_12, // doesn't exist currently, but put it
1498 case wxFONTENCODING_ISO8859_13
: ret
= 28603; break;
1499 // case wxFONTENCODING_ISO8859_14: ret = 28604; break; // no correspondence on Windows
1500 case wxFONTENCODING_ISO8859_15
: ret
= 28605; break;
1502 case wxFONTENCODING_KOI8
: ret
= 20866; break;
1503 case wxFONTENCODING_KOI8_U
: ret
= 21866; break;
1505 case wxFONTENCODING_CP437
: ret
= 437; break;
1506 case wxFONTENCODING_CP850
: ret
= 850; break;
1507 case wxFONTENCODING_CP852
: ret
= 852; break;
1508 case wxFONTENCODING_CP855
: ret
= 855; break;
1509 case wxFONTENCODING_CP866
: ret
= 866; break;
1510 case wxFONTENCODING_CP874
: ret
= 874; break;
1511 case wxFONTENCODING_CP932
: ret
= 932; break;
1512 case wxFONTENCODING_CP936
: ret
= 936; break;
1513 case wxFONTENCODING_CP949
: ret
= 949; break;
1514 case wxFONTENCODING_CP950
: ret
= 950; break;
1515 case wxFONTENCODING_CP1250
: ret
= 1250; break;
1516 case wxFONTENCODING_CP1251
: ret
= 1251; break;
1517 case wxFONTENCODING_CP1252
: ret
= 1252; break;
1518 case wxFONTENCODING_CP1253
: ret
= 1253; break;
1519 case wxFONTENCODING_CP1254
: ret
= 1254; break;
1520 case wxFONTENCODING_CP1255
: ret
= 1255; break;
1521 case wxFONTENCODING_CP1256
: ret
= 1256; break;
1522 case wxFONTENCODING_CP1257
: ret
= 1257; break;
1524 case wxFONTENCODING_EUC_JP
: ret
= 20932; break;
1526 case wxFONTENCODING_MACROMAN
: ret
= 10000; break;
1527 case wxFONTENCODING_MACJAPANESE
: ret
= 10001; break;
1528 case wxFONTENCODING_MACCHINESETRAD
: ret
= 10002; break;
1529 case wxFONTENCODING_MACKOREAN
: ret
= 10003; break;
1530 case wxFONTENCODING_MACARABIC
: ret
= 10004; break;
1531 case wxFONTENCODING_MACHEBREW
: ret
= 10005; break;
1532 case wxFONTENCODING_MACGREEK
: ret
= 10006; break;
1533 case wxFONTENCODING_MACCYRILLIC
: ret
= 10007; break;
1534 case wxFONTENCODING_MACTHAI
: ret
= 10021; break;
1535 case wxFONTENCODING_MACCHINESESIMP
: ret
= 10008; break;
1536 case wxFONTENCODING_MACCENTRALEUR
: ret
= 10029; break;
1537 case wxFONTENCODING_MACCROATIAN
: ret
= 10082; break;
1538 case wxFONTENCODING_MACICELANDIC
: ret
= 10079; break;
1539 case wxFONTENCODING_MACROMANIAN
: ret
= 10009; break;
1541 case wxFONTENCODING_ISO2022_JP
: ret
= 50222; break;
1543 case wxFONTENCODING_UTF7
: ret
= 65000; break;
1544 case wxFONTENCODING_UTF8
: ret
= 65001; break;
1549 if (::IsValidCodePage(ret
) == 0)
1553 if (::GetCPInfo(ret
, &info
) == 0)
1559 extern long wxCharsetToCodepage(const char *name
)
1561 // first get the font encoding for this charset
1565 wxFontEncoding enc
= wxFontMapperBase::Get()->CharsetToEncoding(name
, false);
1566 if ( enc
== wxFONTENCODING_SYSTEM
)
1569 // the use the helper function
1570 return wxEncodingToCodepage(enc
);
1573 #else // !wxUSE_FONTMAP
1575 #include "wx/msw/registry.h"
1577 // this should work if Internet Exploiter is installed
1578 extern long wxCharsetToCodepage(const char *name
)
1586 wxString
path(wxT("MIME\\Database\\Charset\\"));
1589 // follow the alias loop
1592 wxRegKey
key(wxRegKey::HKCR
, path
+ cn
);
1597 // two cases: either there's an AliasForCharset string,
1598 // or there are Codepage and InternetEncoding dwords.
1599 // The InternetEncoding gives us the actual encoding,
1600 // the Codepage just says which Windows character set to
1601 // use when displaying the data.
1602 if (key
.HasValue(wxT("InternetEncoding")) &&
1603 key
.QueryValue(wxT("InternetEncoding"), &CP
))
1606 // no encoding, see if it's an alias
1607 if (!key
.HasValue(wxT("AliasForCharset")) ||
1608 !key
.QueryValue(wxT("AliasForCharset"), cn
))
1611 #endif // wxUSE_REGKEY
1616 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
1619 Creates a hidden window with supplied window proc registering the class for
1620 it if necesssary (i.e. the first time only). Caller is responsible for
1621 destroying the window and unregistering the class (note that this must be
1622 done because wxWidgets may be used as a DLL and so may be loaded/unloaded
1623 multiple times into/from the same process so we cna't rely on automatic
1624 Windows class unregistration).
1626 pclassname is a pointer to a caller stored classname, which must initially be
1627 NULL. classname is the desired wndclass classname. If function successfully
1628 registers the class, pclassname will be set to classname.
1630 extern "C" WXDLLIMPEXP_BASE HWND
1631 wxCreateHiddenWindow(LPCTSTR
*pclassname
, LPCTSTR classname
, WNDPROC wndproc
)
1633 wxCHECK_MSG( classname
&& pclassname
&& wndproc
, NULL
,
1634 _T("NULL parameter in wxCreateHiddenWindow") );
1636 // register the class fi we need to first
1637 if ( *pclassname
== NULL
)
1640 wxZeroMemory(wndclass
);
1642 wndclass
.lpfnWndProc
= wndproc
;
1643 wndclass
.hInstance
= wxGetInstance();
1644 wndclass
.lpszClassName
= classname
;
1646 if ( !::RegisterClass(&wndclass
) )
1648 wxLogLastError(wxT("RegisterClass() in wxCreateHiddenWindow"));
1653 *pclassname
= classname
;
1656 // next create the window
1657 HWND hwnd
= ::CreateWindow
1671 wxLogLastError(wxT("CreateWindow() in wxCreateHiddenWindow"));