]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/msw/utils.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
include wx/wxchar.h after ctype.h to fix compilation problem with _T redefinition...
[wxWidgets.git] / src / msw / utils.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: msw/utils.cpp
3// Purpose: Various utilities
4// Author: Julian Smart
5// Modified by:
6// Created: 04/01/98
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
20// For compilers that support precompilation, includes "wx.h".
21#include "wx/wxprec.h"
22
23#ifdef __BORLANDC__
24 #pragma hdrstop
25#endif
26
27#ifndef WX_PRECOMP
28 #include "wx/utils.h"
29 #include "wx/app.h"
30 #include "wx/intl.h"
31 #include "wx/log.h"
32#endif //WX_PRECOMP
33
34#include "wx/apptrait.h"
35#include "wx/dynload.h"
36
37#include "wx/confbase.h" // for wxExpandEnvVars()
38
39#include "wx/msw/private.h" // includes <windows.h>
40#include "wx/msw/missing.h" // CHARSET_HANGUL
41
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
46 #include <winsock.h>
47#endif
48
49#include "wx/timer.h"
50
51#if !defined(__GNUWIN32__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
52 #include <direct.h>
53
54 #ifndef __MWERKS__
55 #include <dos.h>
56 #endif
57#endif //GNUWIN32
58
59#if defined(__CYGWIN__)
60 #include <sys/unistd.h>
61 #include <sys/stat.h>
62 #include <sys/cygwin.h> // for cygwin_conv_to_full_win32_path()
63#endif //GNUWIN32
64
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.
68 #include <dir.h>
69#endif
70
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
75#undef USE_NET_API
76
77#ifdef USE_NET_API
78 #include <lm.h>
79#endif // USE_NET_API
80
81#if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
82 #ifndef __UNIX__
83 #include <io.h>
84 #endif
85
86 #ifndef __GNUWIN32__
87 #include <shellapi.h>
88 #endif
89#endif
90
91#ifndef __WATCOMC__
92 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
93 #include <errno.h>
94 #endif
95#endif
96
97// 260 was taken from windef.h
98#ifndef MAX_PATH
99 #define MAX_PATH 260
100#endif
101
102// ----------------------------------------------------------------------------
103// constants
104// ----------------------------------------------------------------------------
105
106// In the WIN.INI file
107static const wxChar WX_SECTION[] = wxT("wxWindows");
108static const wxChar eUSERNAME[] = wxT("UserName");
109
110// ============================================================================
111// implementation
112// ============================================================================
113
114// ----------------------------------------------------------------------------
115// get host name and related
116// ----------------------------------------------------------------------------
117
118// Get hostname only (without domain name)
119bool wxGetHostName(wxChar *buf, int maxSize)
120{
121#if defined(__WXWINCE__)
122 return false;
123#elif defined(__WIN32__) && !defined(__WXMICROWIN__)
124 DWORD nSize = maxSize;
125 if ( !::GetComputerName(buf, &nSize) )
126 {
127 wxLogLastError(wxT("GetComputerName"));
128
129 return false;
130 }
131
132 return true;
133#else
134 wxChar *sysname;
135 const wxChar *default_host = wxT("noname");
136
137 if ((sysname = wxGetenv(wxT("SYSTEM_NAME"))) == NULL) {
138 GetProfileString(WX_SECTION, eHOSTNAME, default_host, buf, maxSize - 1);
139 } else
140 wxStrncpy(buf, sysname, maxSize - 1);
141 buf[maxSize] = wxT('\0');
142 return *buf ? true : false;
143#endif
144}
145
146// get full hostname (with domain name if possible)
147bool wxGetFullHostName(wxChar *buf, int maxSize)
148{
149#if !defined( __WXMICROWIN__) && wxUSE_DYNAMIC_LOADER
150 // TODO should use GetComputerNameEx() when available
151
152 // we don't want to always link with Winsock DLL as we might not use it at
153 // all, so load it dynamically here if needed (and don't complain if it is
154 // missing, we handle this)
155 wxLogNull noLog;
156
157 wxDynamicLibrary dllWinsock(_T("ws2_32.dll"), wxDL_VERBATIM);
158 if ( dllWinsock.IsLoaded() )
159 {
160 typedef int (PASCAL *WSAStartup_t)(WORD, WSADATA *);
161 typedef int (PASCAL *gethostname_t)(char *, int);
162 typedef hostent* (PASCAL *gethostbyname_t)(const char *);
163 typedef hostent* (PASCAL *gethostbyaddr_t)(const char *, int , int);
164 typedef int (PASCAL *WSACleanup_t)(void);
165
166 #define LOAD_WINSOCK_FUNC(func) \
167 func ## _t \
168 pfn ## func = (func ## _t)dllWinsock.GetSymbol(_T(#func))
169
170 LOAD_WINSOCK_FUNC(WSAStartup);
171
172 WSADATA wsa;
173 if ( pfnWSAStartup && pfnWSAStartup(MAKEWORD(1, 1), &wsa) == 0 )
174 {
175 LOAD_WINSOCK_FUNC(gethostname);
176
177 wxString host;
178 if ( pfngethostname )
179 {
180 char bufA[256];
181 if ( pfngethostname(bufA, WXSIZEOF(bufA)) == 0 )
182 {
183 // gethostname() won't usually include the DNS domain name,
184 // for this we need to work a bit more
185 if ( !strchr(bufA, '.') )
186 {
187 LOAD_WINSOCK_FUNC(gethostbyname);
188
189 struct hostent *pHostEnt = pfngethostbyname
190 ? pfngethostbyname(bufA)
191 : NULL;
192
193 if ( pHostEnt )
194 {
195 // Windows will use DNS internally now
196 LOAD_WINSOCK_FUNC(gethostbyaddr);
197
198 pHostEnt = pfngethostbyaddr
199 ? pfngethostbyaddr(pHostEnt->h_addr,
200 4, AF_INET)
201 : NULL;
202 }
203
204 if ( pHostEnt )
205 {
206 host = wxString::FromAscii(pHostEnt->h_name);
207 }
208 }
209 }
210 }
211
212 LOAD_WINSOCK_FUNC(WSACleanup);
213 if ( pfnWSACleanup )
214 pfnWSACleanup();
215
216
217 if ( !host.empty() )
218 {
219 wxStrncpy(buf, host, maxSize);
220
221 return true;
222 }
223 }
224 }
225#endif // !__WXMICROWIN__
226
227 return wxGetHostName(buf, maxSize);
228}
229
230// Get user ID e.g. jacs
231bool wxGetUserId(wxChar *buf, int maxSize)
232{
233#if defined(__WXWINCE__)
234 return false;
235#elif defined(__WIN32__) && !defined(__WXMICROWIN__)
236 DWORD nSize = maxSize;
237 if ( ::GetUserName(buf, &nSize) == 0 )
238 {
239 // actually, it does happen on Win9x if the user didn't log on
240 DWORD res = ::GetEnvironmentVariable(wxT("username"), buf, maxSize);
241 if ( res == 0 )
242 {
243 // not found
244 return false;
245 }
246 }
247
248 return true;
249#else // __WXMICROWIN__
250 wxChar *user;
251 const wxChar *default_id = wxT("anonymous");
252
253 // Can't assume we have NIS (PC-NFS) or some other ID daemon
254 // So we ...
255 if ( (user = wxGetenv(wxT("USER"))) == NULL &&
256 (user = wxGetenv(wxT("LOGNAME"))) == NULL )
257 {
258 // Use wxWidgets configuration data (comming soon)
259 GetProfileString(WX_SECTION, eUSERID, default_id, buf, maxSize - 1);
260 }
261 else
262 {
263 wxStrncpy(buf, user, maxSize - 1);
264 }
265
266 return *buf ? true : false;
267#endif
268}
269
270// Get user name e.g. Julian Smart
271bool wxGetUserName(wxChar *buf, int maxSize)
272{
273#if defined(__WXWINCE__)
274 return false;
275#elif defined(USE_NET_API)
276 CHAR szUserName[256];
277 if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )
278 return false;
279
280 // TODO how to get the domain name?
281 CHAR *szDomain = "";
282
283 // the code is based on the MSDN example (also see KB article Q119670)
284 WCHAR wszUserName[256]; // Unicode user name
285 WCHAR wszDomain[256];
286 LPBYTE ComputerName;
287
288 USER_INFO_2 *ui2; // User structure
289
290 // Convert ANSI user name and domain to Unicode
291 MultiByteToWideChar( CP_ACP, 0, szUserName, strlen(szUserName)+1,
292 wszUserName, WXSIZEOF(wszUserName) );
293 MultiByteToWideChar( CP_ACP, 0, szDomain, strlen(szDomain)+1,
294 wszDomain, WXSIZEOF(wszDomain) );
295
296 // Get the computer name of a DC for the domain.
297 if ( NetGetDCName( NULL, wszDomain, &ComputerName ) != NERR_Success )
298 {
299 wxLogError(wxT("Can not find domain controller"));
300
301 goto error;
302 }
303
304 // Look up the user on the DC
305 NET_API_STATUS status = NetUserGetInfo( (LPWSTR)ComputerName,
306 (LPWSTR)&wszUserName,
307 2, // level - we want USER_INFO_2
308 (LPBYTE *) &ui2 );
309 switch ( status )
310 {
311 case NERR_Success:
312 // ok
313 break;
314
315 case NERR_InvalidComputer:
316 wxLogError(wxT("Invalid domain controller name."));
317
318 goto error;
319
320 case NERR_UserNotFound:
321 wxLogError(wxT("Invalid user name '%s'."), szUserName);
322
323 goto error;
324
325 default:
326 wxLogSysError(wxT("Can't get information about user"));
327
328 goto error;
329 }
330
331 // Convert the Unicode full name to ANSI
332 WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1,
333 buf, maxSize, NULL, NULL );
334
335 return true;
336
337error:
338 wxLogError(wxT("Couldn't look up full user name."));
339
340 return false;
341#else // !USE_NET_API
342 // Could use NIS, MS-Mail or other site specific programs
343 // Use wxWidgets configuration data
344 bool ok = GetProfileString(WX_SECTION, eUSERNAME, wxEmptyString, buf, maxSize - 1) != 0;
345 if ( !ok )
346 {
347 ok = wxGetUserId(buf, maxSize);
348 }
349
350 if ( !ok )
351 {
352 wxStrncpy(buf, wxT("Unknown User"), maxSize);
353 }
354#endif // Win32/16
355
356 return true;
357}
358
359const wxChar* wxGetHomeDir(wxString *pstr)
360{
361 wxString& strDir = *pstr;
362
363 // first branch is for Cygwin
364#if defined(__UNIX__)
365 const wxChar *szHome = wxGetenv("HOME");
366 if ( szHome == NULL ) {
367 // we're homeless...
368 wxLogWarning(_("can't find user's HOME, using current directory."));
369 strDir = wxT(".");
370 }
371 else
372 strDir = szHome;
373
374 // add a trailing slash if needed
375 if ( strDir.Last() != wxT('/') )
376 strDir << wxT('/');
377
378 #ifdef __CYGWIN__
379 // Cygwin returns unix type path but that does not work well
380 static wxChar windowsPath[MAX_PATH];
381 cygwin_conv_to_full_win32_path(strDir, windowsPath);
382 strDir = windowsPath;
383 #endif
384#elif defined(__WXWINCE__)
385 // Nothing
386#else
387 strDir.clear();
388
389 // If we have a valid HOME directory, as is used on many machines that
390 // have unix utilities on them, we should use that.
391 const wxChar *szHome = wxGetenv(wxT("HOME"));
392
393 if ( szHome != NULL )
394 {
395 strDir = szHome;
396 }
397 else // no HOME, try HOMEDRIVE/PATH
398 {
399 szHome = wxGetenv(wxT("HOMEDRIVE"));
400 if ( szHome != NULL )
401 strDir << szHome;
402 szHome = wxGetenv(wxT("HOMEPATH"));
403
404 if ( szHome != NULL )
405 {
406 strDir << szHome;
407
408 // the idea is that under NT these variables have default values
409 // of "%systemdrive%:" and "\\". As we don't want to create our
410 // config files in the root directory of the system drive, we will
411 // create it in our program's dir. However, if the user took care
412 // to set HOMEPATH to something other than "\\", we suppose that he
413 // knows what he is doing and use the supplied value.
414 if ( wxStrcmp(szHome, wxT("\\")) == 0 )
415 strDir.clear();
416 }
417 }
418
419 if ( strDir.empty() )
420 {
421 // If we have a valid USERPROFILE directory, as is the case in
422 // Windows NT, 2000 and XP, we should use that as our home directory.
423 szHome = wxGetenv(wxT("USERPROFILE"));
424
425 if ( szHome != NULL )
426 strDir = szHome;
427 }
428
429 if ( !strDir.empty() )
430 {
431 // sometimes the value of HOME may be "%USERPROFILE%", so reexpand the
432 // value once again, it shouldn't hurt anyhow
433 strDir = wxExpandEnvVars(strDir);
434 }
435 else // fall back to the program directory
436 {
437 wxString strPath;
438 ::GetModuleFileName(::GetModuleHandle(NULL),
439 wxStringBuffer(strPath, MAX_PATH), MAX_PATH);
440
441 // extract the dir name
442 wxSplitPath(strPath, &strDir, NULL, NULL);
443 }
444#endif // UNIX/Win
445
446 return strDir.c_str();
447}
448
449wxChar *wxGetUserHome(const wxString& WXUNUSED(user))
450{
451 // VZ: the old code here never worked for user != "" anyhow! Moreover, it
452 // returned sometimes a malloc()'d pointer, sometimes a pointer to a
453 // static buffer and sometimes I don't even know what.
454 static wxString s_home;
455
456 return (wxChar *)wxGetHomeDir(&s_home);
457}
458
459bool wxDirExists(const wxString& dir)
460{
461#ifdef __WXMICROWIN__
462 return wxPathExist(dir);
463#elif defined(__WIN32__)
464 DWORD attribs = GetFileAttributes(dir);
465 return ((attribs != (DWORD)-1) && (attribs & FILE_ATTRIBUTE_DIRECTORY));
466#endif // Win32/__WXMICROWIN__
467}
468
469bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
470{
471#ifdef __WXWINCE__
472 return false;
473#else
474 if ( path.empty() )
475 return false;
476
477// old w32api don't have ULARGE_INTEGER
478#if defined(__WIN32__) && \
479 (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION( 0, 3 ))
480 // GetDiskFreeSpaceEx() is not available under original Win95, check for
481 // it
482 typedef BOOL (WINAPI *GetDiskFreeSpaceEx_t)(LPCTSTR,
483 PULARGE_INTEGER,
484 PULARGE_INTEGER,
485 PULARGE_INTEGER);
486
487 GetDiskFreeSpaceEx_t
488 pGetDiskFreeSpaceEx = (GetDiskFreeSpaceEx_t)::GetProcAddress
489 (
490 ::GetModuleHandle(_T("kernel32.dll")),
491#if wxUSE_UNICODE
492 "GetDiskFreeSpaceExW"
493#else
494 "GetDiskFreeSpaceExA"
495#endif
496 );
497
498 if ( pGetDiskFreeSpaceEx )
499 {
500 ULARGE_INTEGER bytesFree, bytesTotal;
501
502 // may pass the path as is, GetDiskFreeSpaceEx() is smart enough
503 if ( !pGetDiskFreeSpaceEx(path,
504 &bytesFree,
505 &bytesTotal,
506 NULL) )
507 {
508 wxLogLastError(_T("GetDiskFreeSpaceEx"));
509
510 return false;
511 }
512
513 // ULARGE_INTEGER is a union of a 64 bit value and a struct containing
514 // two 32 bit fields which may be or may be not named - try to make it
515 // compile in all cases
516#if defined(__BORLANDC__) && !defined(_ANONYMOUS_STRUCT)
517 #define UL(ul) ul.u
518#else // anon union
519 #define UL(ul) ul
520#endif
521 if ( pTotal )
522 {
523 *pTotal = wxLongLong(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart);
524 }
525
526 if ( pFree )
527 {
528 *pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);
529 }
530 }
531 else
532#endif // Win32
533 {
534 // there's a problem with drives larger than 2GB, GetDiskFreeSpaceEx()
535 // should be used instead - but if it's not available, fall back on
536 // GetDiskFreeSpace() nevertheless...
537
538 DWORD lSectorsPerCluster,
539 lBytesPerSector,
540 lNumberOfFreeClusters,
541 lTotalNumberOfClusters;
542
543 // FIXME: this is wrong, we should extract the root drive from path
544 // instead, but this is the job for wxFileName...
545 if ( !::GetDiskFreeSpace(path,
546 &lSectorsPerCluster,
547 &lBytesPerSector,
548 &lNumberOfFreeClusters,
549 &lTotalNumberOfClusters) )
550 {
551 wxLogLastError(_T("GetDiskFreeSpace"));
552
553 return false;
554 }
555
556 wxLongLong lBytesPerCluster = lSectorsPerCluster;
557 lBytesPerCluster *= lBytesPerSector;
558
559 if ( pTotal )
560 {
561 *pTotal = lBytesPerCluster;
562 *pTotal *= lTotalNumberOfClusters;
563 }
564
565 if ( pFree )
566 {
567 *pFree = lBytesPerCluster;
568 *pFree *= lNumberOfFreeClusters;
569 }
570 }
571
572 return true;
573#endif
574 // __WXWINCE__
575}
576
577// ----------------------------------------------------------------------------
578// env vars
579// ----------------------------------------------------------------------------
580
581bool wxGetEnv(const wxString& var, wxString *value)
582{
583#ifdef __WXWINCE__
584 return false;
585#else // Win32
586 // first get the size of the buffer
587 DWORD dwRet = ::GetEnvironmentVariable(var, NULL, 0);
588 if ( !dwRet )
589 {
590 // this means that there is no such variable
591 return false;
592 }
593
594 if ( value )
595 {
596 (void)::GetEnvironmentVariable(var, wxStringBuffer(*value, dwRet),
597 dwRet);
598 }
599
600 return true;
601#endif // WinCE/32
602}
603
604bool wxSetEnv(const wxString& var, const wxChar *value)
605{
606 // some compilers have putenv() or _putenv() or _wputenv() but it's better
607 // to always use Win32 function directly instead of dealing with them
608#if defined(__WIN32__) && !defined(__WXWINCE__)
609 if ( !::SetEnvironmentVariable(var, value) )
610 {
611 wxLogLastError(_T("SetEnvironmentVariable"));
612
613 return false;
614 }
615
616 return true;
617#else // no way to set env vars
618 return false;
619#endif
620}
621
622// ----------------------------------------------------------------------------
623// process management
624// ----------------------------------------------------------------------------
625
626// structure used to pass parameters from wxKill() to wxEnumFindByPidProc()
627struct wxFindByPidParams
628{
629 wxFindByPidParams() { hwnd = 0; pid = 0; }
630
631 // the HWND used to return the result
632 HWND hwnd;
633
634 // the PID we're looking from
635 DWORD pid;
636
637 DECLARE_NO_COPY_CLASS(wxFindByPidParams)
638};
639
640// wxKill helper: EnumWindows() callback which is used to find the first (top
641// level) window belonging to the given process
642BOOL CALLBACK wxEnumFindByPidProc(HWND hwnd, LPARAM lParam)
643{
644 DWORD pid;
645 (void)::GetWindowThreadProcessId(hwnd, &pid);
646
647 wxFindByPidParams *params = (wxFindByPidParams *)lParam;
648 if ( pid == params->pid )
649 {
650 // remember the window we found
651 params->hwnd = hwnd;
652
653 // return FALSE to stop the enumeration
654 return FALSE;
655 }
656
657 // continue enumeration
658 return TRUE;
659}
660
661int wxKill(long pid, wxSignal sig, wxKillError *krc)
662{
663 // get the process handle to operate on
664 HANDLE hProcess = ::OpenProcess(SYNCHRONIZE |
665 PROCESS_TERMINATE |
666 PROCESS_QUERY_INFORMATION,
667 FALSE, // not inheritable
668 (DWORD)pid);
669 if ( hProcess == NULL )
670 {
671 if ( krc )
672 {
673 if ( ::GetLastError() == ERROR_ACCESS_DENIED )
674 {
675 *krc = wxKILL_ACCESS_DENIED;
676 }
677 else
678 {
679 *krc = wxKILL_NO_PROCESS;
680 }
681 }
682
683 return -1;
684 }
685
686 bool ok = true;
687 switch ( sig )
688 {
689 case wxSIGKILL:
690 // kill the process forcefully returning -1 as error code
691 if ( !::TerminateProcess(hProcess, (UINT)-1) )
692 {
693 wxLogSysError(_("Failed to kill process %d"), pid);
694
695 if ( krc )
696 {
697 // this is not supposed to happen if we could open the
698 // process
699 *krc = wxKILL_ERROR;
700 }
701
702 ok = false;
703 }
704 break;
705
706 case wxSIGNONE:
707 // do nothing, we just want to test for process existence
708 break;
709
710 default:
711 // any other signal means "terminate"
712 {
713 wxFindByPidParams params;
714 params.pid = (DWORD)pid;
715
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)&params) )
720 {
721 // did we find any window?
722 if ( params.hwnd )
723 {
724 // tell the app to close
725 //
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) )
731 {
732 wxLogLastError(_T("PostMessage(WM_QUIT)"));
733 }
734 }
735 else // it was an error then
736 {
737 wxLogLastError(_T("EnumWindows"));
738
739 ok = false;
740 }
741 }
742 else // no windows for this PID
743 {
744 if ( krc )
745 {
746 *krc = wxKILL_ERROR;
747 }
748
749 ok = false;
750 }
751 }
752 }
753
754 // the return code
755 DWORD rc;
756
757 if ( ok )
758 {
759 // as we wait for a short time, we can use just WaitForSingleObject()
760 // and not MsgWaitForMultipleObjects()
761 switch ( ::WaitForSingleObject(hProcess, 500 /* msec */) )
762 {
763 case WAIT_OBJECT_0:
764 // process terminated
765 if ( !::GetExitCodeProcess(hProcess, &rc) )
766 {
767 wxLogLastError(_T("GetExitCodeProcess"));
768 }
769 break;
770
771 default:
772 wxFAIL_MSG( _T("unexpected WaitForSingleObject() return") );
773 // fall through
774
775 case WAIT_FAILED:
776 wxLogLastError(_T("WaitForSingleObject"));
777 // fall through
778
779 case WAIT_TIMEOUT:
780 if ( krc )
781 {
782 *krc = wxKILL_ERROR;
783 }
784
785 rc = STILL_ACTIVE;
786 break;
787 }
788 }
789 else // !ok
790 {
791 // just to suppress the warnings about uninitialized variable
792 rc = 0;
793 }
794
795 ::CloseHandle(hProcess);
796
797 // the return code is the same as from Unix kill(): 0 if killed
798 // successfully or -1 on error
799 //
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
802 if ( ok &&
803 ((sig == wxSIGNONE) == (rc == STILL_ACTIVE)) )
804 {
805 if ( krc )
806 {
807 *krc = wxKILL_OK;
808 }
809
810 return 0;
811 }
812
813 // error
814 return -1;
815}
816
817// Execute a program in an Interactive Shell
818bool wxShell(const wxString& command)
819{
820 wxString cmd;
821
822#ifdef __WXWINCE__
823 cmd = command;
824#else
825 wxChar *shell = wxGetenv(wxT("COMSPEC"));
826 if ( !shell )
827 shell = (wxChar*) wxT("\\COMMAND.COM");
828
829 if ( !command )
830 {
831 // just the shell
832 cmd = shell;
833 }
834 else
835 {
836 // pass the command to execute to the command processor
837 cmd.Printf(wxT("%s /c %s"), shell, command.c_str());
838 }
839#endif
840
841 return wxExecute(cmd, wxEXEC_SYNC) == 0;
842}
843
844// Shutdown or reboot the PC
845bool wxShutdown(wxShutdownFlags wFlags)
846{
847#ifdef __WXWINCE__
848 return false;
849#elif defined(__WIN32__)
850 bool bOK = true;
851
852 if ( wxGetOsVersion(NULL, NULL) == wxWINDOWS_NT ) // if is NT or 2K
853 {
854 // Get a token for this process.
855 HANDLE hToken;
856 bOK = ::OpenProcessToken(GetCurrentProcess(),
857 TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
858 &hToken) != 0;
859 if ( bOK )
860 {
861 TOKEN_PRIVILEGES tkp;
862
863 // Get the LUID for the shutdown privilege.
864 ::LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME,
865 &tkp.Privileges[0].Luid);
866
867 tkp.PrivilegeCount = 1; // one privilege to set
868 tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
869
870 // Get the shutdown privilege for this process.
871 ::AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,
872 (PTOKEN_PRIVILEGES)NULL, 0);
873
874 // Cannot test the return value of AdjustTokenPrivileges.
875 bOK = ::GetLastError() == ERROR_SUCCESS;
876 }
877 }
878
879 if ( bOK )
880 {
881 UINT flags = EWX_SHUTDOWN | EWX_FORCE;
882 switch ( wFlags )
883 {
884 case wxSHUTDOWN_POWEROFF:
885 flags |= EWX_POWEROFF;
886 break;
887
888 case wxSHUTDOWN_REBOOT:
889 flags |= EWX_REBOOT;
890 break;
891
892 default:
893 wxFAIL_MSG( _T("unknown wxShutdown() flag") );
894 return false;
895 }
896
897 bOK = ::ExitWindowsEx(flags, 0) != 0;
898 }
899
900 return bOK;
901#endif // Win32/16
902}
903
904// ----------------------------------------------------------------------------
905// misc
906// ----------------------------------------------------------------------------
907
908// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
909long wxGetFreeMemory()
910{
911#if defined(__WIN32__) && !defined(__BORLANDC__)
912 MEMORYSTATUS memStatus;
913 memStatus.dwLength = sizeof(MEMORYSTATUS);
914 GlobalMemoryStatus(&memStatus);
915 return memStatus.dwAvailPhys;
916#else
917 return (long)GetFreeSpace(0);
918#endif
919}
920
921unsigned long wxGetProcessId()
922{
923 return ::GetCurrentProcessId();
924}
925
926// Emit a beeeeeep
927void wxBell()
928{
929 ::MessageBeep((UINT)-1); // default sound
930}
931
932wxString wxGetOsDescription()
933{
934 wxString str;
935
936 OSVERSIONINFO info;
937 wxZeroMemory(info);
938
939 info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
940 if ( ::GetVersionEx(&info) )
941 {
942 switch ( info.dwPlatformId )
943 {
944 case VER_PLATFORM_WIN32s:
945 str = _("Win32s on Windows 3.1");
946 break;
947
948 case VER_PLATFORM_WIN32_WINDOWS:
949 str.Printf(_("Windows 9%c"),
950 info.dwMinorVersion == 0 ? _T('5') : _T('8'));
951 if ( !wxIsEmpty(info.szCSDVersion) )
952 {
953 str << _T(" (") << info.szCSDVersion << _T(')');
954 }
955 break;
956
957 case VER_PLATFORM_WIN32_NT:
958 str.Printf(_T("Windows NT %lu.%lu (build %lu"),
959 info.dwMajorVersion,
960 info.dwMinorVersion,
961 info.dwBuildNumber);
962 if ( !wxIsEmpty(info.szCSDVersion) )
963 {
964 str << _T(", ") << info.szCSDVersion;
965 }
966 str << _T(')');
967 break;
968 }
969 }
970 else
971 {
972 wxFAIL_MSG( _T("GetVersionEx() failed") ); // should never happen
973 }
974
975 return str;
976}
977
978wxToolkitInfo& wxAppTraits::GetToolkitInfo()
979{
980 // cache the version info, it's not going to change
981 //
982 // NB: this is MT-safe, we may use these static vars from different threads
983 // but as they always have the same value it doesn't matter
984 static int s_ver = -1,
985 s_major = -1,
986 s_minor = -1;
987
988 if ( s_ver == -1 )
989 {
990 OSVERSIONINFO info;
991 wxZeroMemory(info);
992
993 s_ver = wxWINDOWS;
994 info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
995 if ( ::GetVersionEx(&info) )
996 {
997 s_major = info.dwMajorVersion;
998 s_minor = info.dwMinorVersion;
999
1000 switch ( info.dwPlatformId )
1001 {
1002 case VER_PLATFORM_WIN32s:
1003 s_ver = wxWIN32S;
1004 break;
1005
1006 case VER_PLATFORM_WIN32_WINDOWS:
1007 s_ver = wxWIN95;
1008 break;
1009
1010 case VER_PLATFORM_WIN32_NT:
1011 s_ver = wxWINDOWS_NT;
1012 break;
1013#ifdef __WXWINCE__
1014 case VER_PLATFORM_WIN32_CE:
1015 s_ver = wxWINDOWS_CE;
1016 break;
1017#endif
1018 }
1019 }
1020 }
1021
1022 static wxToolkitInfo info;
1023 info.versionMajor = s_major;
1024 info.versionMinor = s_minor;
1025 info.os = s_ver;
1026 info.name = _T("wxBase");
1027 return info;
1028}
1029
1030// ----------------------------------------------------------------------------
1031// sleep functions
1032// ----------------------------------------------------------------------------
1033
1034void wxMilliSleep(unsigned long milliseconds)
1035{
1036 ::Sleep(milliseconds);
1037}
1038
1039void wxMicroSleep(unsigned long microseconds)
1040{
1041 wxMilliSleep(microseconds/1000);
1042}
1043
1044void wxSleep(int nSecs)
1045{
1046 wxMilliSleep(1000*nSecs);
1047}
1048
1049// ----------------------------------------------------------------------------
1050// font encoding <-> Win32 codepage conversion functions
1051// ----------------------------------------------------------------------------
1052
1053extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)
1054{
1055 switch ( encoding )
1056 {
1057 // although this function is supposed to return an exact match, do do
1058 // some mappings here for the most common case of "standard" encoding
1059 case wxFONTENCODING_SYSTEM:
1060 return DEFAULT_CHARSET;
1061
1062 case wxFONTENCODING_ISO8859_1:
1063 case wxFONTENCODING_ISO8859_15:
1064 case wxFONTENCODING_CP1252:
1065 return ANSI_CHARSET;
1066
1067#if !defined(__WXMICROWIN__)
1068 // The following four fonts are multi-byte charsets
1069 case wxFONTENCODING_CP932:
1070 return SHIFTJIS_CHARSET;
1071
1072 case wxFONTENCODING_CP936:
1073 return GB2312_CHARSET;
1074
1075 case wxFONTENCODING_CP949:
1076 return HANGUL_CHARSET;
1077
1078 case wxFONTENCODING_CP950:
1079 return CHINESEBIG5_CHARSET;
1080
1081 // The rest are single byte encodings
1082 case wxFONTENCODING_CP1250:
1083 return EASTEUROPE_CHARSET;
1084
1085 case wxFONTENCODING_CP1251:
1086 return RUSSIAN_CHARSET;
1087
1088 case wxFONTENCODING_CP1253:
1089 return GREEK_CHARSET;
1090
1091 case wxFONTENCODING_CP1254:
1092 return TURKISH_CHARSET;
1093
1094 case wxFONTENCODING_CP1255:
1095 return HEBREW_CHARSET;
1096
1097 case wxFONTENCODING_CP1256:
1098 return ARABIC_CHARSET;
1099
1100 case wxFONTENCODING_CP1257:
1101 return BALTIC_CHARSET;
1102
1103 case wxFONTENCODING_CP874:
1104 return THAI_CHARSET;
1105#endif // !__WXMICROWIN__
1106
1107 case wxFONTENCODING_CP437:
1108 return OEM_CHARSET;
1109
1110 default:
1111 // no way to translate this encoding into a Windows charset
1112 return -1;
1113 }
1114}
1115
1116// we have 2 versions of wxCharsetToCodepage(): the old one which directly
1117// looks up the vlaues in the registry and the new one which is more
1118// politically correct and has more chances to work on other Windows versions
1119// as well but the old version is still needed for !wxUSE_FONTMAP case
1120#if wxUSE_FONTMAP
1121
1122#include "wx/fontmap.h"
1123
1124extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
1125{
1126 // translate encoding into the Windows CHARSET
1127 long charset = wxEncodingToCharset(encoding);
1128 if ( charset == -1 )
1129 return -1;
1130
1131 // translate CHARSET to code page
1132 CHARSETINFO csetInfo;
1133 if ( !::TranslateCharsetInfo((DWORD *)(DWORD)charset,
1134 &csetInfo,
1135 TCI_SRCCHARSET) )
1136 {
1137 wxLogLastError(_T("TranslateCharsetInfo(TCI_SRCCHARSET)"));
1138
1139 return -1;
1140 }
1141
1142 return csetInfo.ciACP;
1143}
1144
1145extern long wxCharsetToCodepage(const wxChar *name)
1146{
1147 // first get the font encoding for this charset
1148 if ( !name )
1149 return -1;
1150
1151 wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(name, false);
1152 if ( enc == wxFONTENCODING_SYSTEM )
1153 return -1;
1154
1155 // the use the helper function
1156 return wxEncodingToCodepage(enc);
1157}
1158
1159#else // !wxUSE_FONTMAP
1160
1161#include "wx/msw/registry.h"
1162
1163// this should work if Internet Exploiter is installed
1164extern long wxCharsetToCodepage(const wxChar *name)
1165{
1166 if (!name)
1167 return GetACP();
1168
1169 long CP = -1;
1170
1171 wxString path(wxT("MIME\\Database\\Charset\\"));
1172 wxString cn(name);
1173
1174 // follow the alias loop
1175 for ( ;; )
1176 {
1177 wxRegKey key(wxRegKey::HKCR, path + cn);
1178
1179 if (!key.Exists())
1180 break;
1181
1182 // two cases: either there's an AliasForCharset string,
1183 // or there are Codepage and InternetEncoding dwords.
1184 // The InternetEncoding gives us the actual encoding,
1185 // the Codepage just says which Windows character set to
1186 // use when displaying the data.
1187 if (key.HasValue(wxT("InternetEncoding")) &&
1188 key.QueryValue(wxT("InternetEncoding"), &CP))
1189 break;
1190
1191 // no encoding, see if it's an alias
1192 if (!key.HasValue(wxT("AliasForCharset")) ||
1193 !key.QueryValue(wxT("AliasForCharset"), cn))
1194 break;
1195 }
1196
1197 return CP;
1198}
1199
1200#endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
1201
1202/*
1203 Creates a hidden window with supplied window proc registering the class for
1204 it if necesssary (i.e. the first time only). Caller is responsible for
1205 destroying the window and unregistering the class (note that this must be
1206 done because wxWidgets may be used as a DLL and so may be loaded/unloaded
1207 multiple times into/from the same process so we cna't rely on automatic
1208 Windows class unregistration).
1209
1210 pclassname is a pointer to a caller stored classname, which must initially be
1211 NULL. classname is the desired wndclass classname. If function succesfully
1212 registers the class, pclassname will be set to classname.
1213 */
1214extern "C" WXDLLIMPEXP_BASE HWND
1215wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc)
1216{
1217 wxCHECK_MSG( classname && pclassname && wndproc, NULL,
1218 _T("NULL parameter in wxCreateHiddenWindow") );
1219
1220 // register the class fi we need to first
1221 if ( *pclassname == NULL )
1222 {
1223 WNDCLASS wndclass;
1224 wxZeroMemory(wndclass);
1225
1226 wndclass.lpfnWndProc = wndproc;
1227 wndclass.hInstance = wxGetInstance();
1228 wndclass.lpszClassName = classname;
1229
1230 if ( !::RegisterClass(&wndclass) )
1231 {
1232 wxLogLastError(wxT("RegisterClass() in wxCreateHiddenWindow"));
1233
1234 return NULL;
1235 }
1236
1237 *pclassname = classname;
1238 }
1239
1240 // next create the window
1241 HWND hwnd = ::CreateWindow
1242 (
1243 *pclassname,
1244 NULL,
1245 0, 0, 0, 0,
1246 0,
1247 (HWND) NULL,
1248 (HMENU)NULL,
1249 wxGetInstance(),
1250 (LPVOID) NULL
1251 );
1252
1253 if ( !hwnd )
1254 {
1255 wxLogLastError(wxT("CreateWindow() in wxCreateHiddenWindow"));
1256 }
1257
1258 return hwnd;
1259}
1260
wxWidgets (Impactor)