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