]> git.saurik.com Git - wxWidgets.git/blob - src/msw/utils.cpp
projects / wxWidgets.git / blob
? search:


612ced86ae80fe880c61817017b9326e1bfed051
[wxWidgets.git] / src / msw / utils.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/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/msw/registry.h"
35 #include "wx/apptrait.h"
36 #include "wx/dynlib.h"
37 #include "wx/dynload.h"
38 #include "wx/scopeguard.h"
39
40 #include "wx/confbase.h" // for wxExpandEnvVars()
41
42 #include "wx/msw/private.h" // includes <windows.h>
43 #include "wx/msw/missing.h" // for CHARSET_HANGUL
44
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>
49 #endif
50
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
55 #include <winsock.h>
56 #endif
57
58 #if !defined(__GNUWIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
59 #include <direct.h>
60
61 #ifndef __MWERKS__
62 #include <dos.h>
63 #endif
64 #endif //GNUWIN32
65
66 #if defined(__CYGWIN__)
67 #include <sys/unistd.h>
68 #include <sys/stat.h>
69 #include <sys/cygwin.h> // for cygwin_conv_to_full_win32_path()
70 #endif //GNUWIN32
71
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.
75 #include <dir.h>
76 #endif
77
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
82 #undef USE_NET_API
83
84 #ifdef USE_NET_API
85 #include <lm.h>
86 #endif // USE_NET_API
87
88 #if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
89 #ifndef __UNIX__
90 #include <io.h>
91 #endif
92
93 #ifndef __GNUWIN32__
94 #include <shellapi.h>
95 #endif
96 #endif
97
98 #ifndef __WATCOMC__
99 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
100 #include <errno.h>
101 #endif
102 #endif
103
104 // For wxKillAllChildren
105 #include <tlhelp32.h>
106
107 // ----------------------------------------------------------------------------
108 // constants
109 // ----------------------------------------------------------------------------
110
111 // In the WIN.INI file
112 #if (!defined(USE_NET_API) && !defined(__WXWINCE__)) || defined(__WXMICROWIN__)
113 static const wxChar WX_SECTION[] = wxT("wxWindows");
114 #endif
115
116 #if (!defined(USE_NET_API) && !defined(__WXWINCE__))
117 static const wxChar eUSERNAME[] = wxT("UserName");
118 #endif
119
120 // ============================================================================
121 // implementation
122 // ============================================================================
123
124 // ----------------------------------------------------------------------------
125 // get host name and related
126 // ----------------------------------------------------------------------------
127
128 // Get hostname only (without domain name)
129 bool wxGetHostName(wxChar *WXUNUSED_IN_WINCE(buf),
130 int WXUNUSED_IN_WINCE(maxSize))
131 {
132 #if defined(__WXWINCE__)
133 // TODO-CE
134 return false;
135 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
136 DWORD nSize = maxSize;
137 if ( !::GetComputerName(buf, &nSize) )
138 {
139 wxLogLastError(wxT("GetComputerName"));
140
141 return false;
142 }
143
144 return true;
145 #else
146 wxChar *sysname;
147 const wxChar *default_host = wxT("noname");
148
149 if ((sysname = wxGetenv(wxT("SYSTEM_NAME"))) == NULL) {
150 GetProfileString(WX_SECTION, eHOSTNAME, default_host, buf, maxSize - 1);
151 } else
152 wxStrncpy(buf, sysname, maxSize - 1);
153 buf[maxSize] = wxT('\0');
154 return *buf ? true : false;
155 #endif
156 }
157
158 // get full hostname (with domain name if possible)
159 bool wxGetFullHostName(wxChar *buf, int maxSize)
160 {
161 #if !defined( __WXMICROWIN__) && wxUSE_DYNLIB_CLASS && wxUSE_SOCKETS
162 // TODO should use GetComputerNameEx() when available
163
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)
167 wxLogNull noLog;
168
169 wxDynamicLibrary dllWinsock(_T("ws2_32.dll"), wxDL_VERBATIM);
170 if ( dllWinsock.IsLoaded() )
171 {
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);
177
178 #define LOAD_WINSOCK_FUNC(func) \
179 func ## _t \
180 pfn ## func = (func ## _t)dllWinsock.GetSymbol(_T(#func))
181
182 LOAD_WINSOCK_FUNC(WSAStartup);
183
184 WSADATA wsa;
185 if ( pfnWSAStartup && pfnWSAStartup(MAKEWORD(1, 1), &wsa) == 0 )
186 {
187 LOAD_WINSOCK_FUNC(gethostname);
188
189 wxString host;
190 if ( pfngethostname )
191 {
192 char bufA[256];
193 if ( pfngethostname(bufA, WXSIZEOF(bufA)) == 0 )
194 {
195 // gethostname() won't usually include the DNS domain name,
196 // for this we need to work a bit more
197 if ( !strchr(bufA, '.') )
198 {
199 LOAD_WINSOCK_FUNC(gethostbyname);
200
201 struct hostent *pHostEnt = pfngethostbyname
202 ? pfngethostbyname(bufA)
203 : NULL;
204
205 if ( pHostEnt )
206 {
207 // Windows will use DNS internally now
208 LOAD_WINSOCK_FUNC(gethostbyaddr);
209
210 pHostEnt = pfngethostbyaddr
211 ? pfngethostbyaddr(pHostEnt->h_addr,
212 4, AF_INET)
213 : NULL;
214 }
215
216 if ( pHostEnt )
217 {
218 host = wxString::FromAscii(pHostEnt->h_name);
219 }
220 }
221 }
222 }
223
224 LOAD_WINSOCK_FUNC(WSACleanup);
225 if ( pfnWSACleanup )
226 pfnWSACleanup();
227
228
229 if ( !host.empty() )
230 {
231 wxStrncpy(buf, host, maxSize);
232
233 return true;
234 }
235 }
236 }
237 #endif // !__WXMICROWIN__
238
239 return wxGetHostName(buf, maxSize);
240 }
241
242 // Get user ID e.g. jacs
243 bool wxGetUserId(wxChar *WXUNUSED_IN_WINCE(buf),
244 int WXUNUSED_IN_WINCE(maxSize))
245 {
246 #if defined(__WXWINCE__)
247 // TODO-CE
248 return false;
249 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
250 DWORD nSize = maxSize;
251 if ( ::GetUserName(buf, &nSize) == 0 )
252 {
253 // actually, it does happen on Win9x if the user didn't log on
254 DWORD res = ::GetEnvironmentVariable(wxT("username"), buf, maxSize);
255 if ( res == 0 )
256 {
257 // not found
258 return false;
259 }
260 }
261
262 return true;
263 #else // __WXMICROWIN__
264 wxChar *user;
265 const wxChar *default_id = wxT("anonymous");
266
267 // Can't assume we have NIS (PC-NFS) or some other ID daemon
268 // So we ...
269 if ( (user = wxGetenv(wxT("USER"))) == NULL &&
270 (user = wxGetenv(wxT("LOGNAME"))) == NULL )
271 {
272 // Use wxWidgets configuration data (comming soon)
273 GetProfileString(WX_SECTION, eUSERID, default_id, buf, maxSize - 1);
274 }
275 else
276 {
277 wxStrncpy(buf, user, maxSize - 1);
278 }
279
280 return *buf ? true : false;
281 #endif
282 }
283
284 // Get user name e.g. Julian Smart
285 bool wxGetUserName(wxChar *buf, int maxSize)
286 {
287 wxCHECK_MSG( buf && ( maxSize > 0 ), false,
288 _T("empty buffer in wxGetUserName") );
289 #if defined(__WXWINCE__) && wxUSE_REGKEY
290 wxLogNull noLog;
291 wxRegKey key(wxRegKey::HKCU, wxT("ControlPanel\\Owner"));
292 if(!key.Open(wxRegKey::Read))
293 return false;
294 wxString name;
295 if(!key.QueryValue(wxT("Owner"),name))
296 return false;
297 wxStrncpy(buf, name.c_str(), maxSize-1);
298 buf[maxSize-1] = _T('\0');
299 return true;
300 #elif defined(USE_NET_API)
301 CHAR szUserName[256];
302 if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )
303 return false;
304
305 // TODO how to get the domain name?
306 CHAR *szDomain = "";
307
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];
311 LPBYTE ComputerName;
312
313 USER_INFO_2 *ui2; // User structure
314
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) );
320
321 // Get the computer name of a DC for the domain.
322 if ( NetGetDCName( NULL, wszDomain, &ComputerName ) != NERR_Success )
323 {
324 wxLogError(wxT("Can not find domain controller"));
325
326 goto error;
327 }
328
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
333 (LPBYTE *) &ui2 );
334 switch ( status )
335 {
336 case NERR_Success:
337 // ok
338 break;
339
340 case NERR_InvalidComputer:
341 wxLogError(wxT("Invalid domain controller name."));
342
343 goto error;
344
345 case NERR_UserNotFound:
346 wxLogError(wxT("Invalid user name '%s'."), szUserName);
347
348 goto error;
349
350 default:
351 wxLogSysError(wxT("Can't get information about user"));
352
353 goto error;
354 }
355
356 // Convert the Unicode full name to ANSI
357 WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1,
358 buf, maxSize, NULL, NULL );
359
360 return true;
361
362 error:
363 wxLogError(wxT("Couldn't look up full user name."));
364
365 return false;
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;
370 if ( !ok )
371 {
372 ok = wxGetUserId(buf, maxSize);
373 }
374
375 if ( !ok )
376 {
377 wxStrncpy(buf, wxT("Unknown User"), maxSize);
378 }
379
380 return true;
381 #endif // Win32/16
382 }
383
384 const wxChar* wxGetHomeDir(wxString *pstr)
385 {
386 wxString& strDir = *pstr;
387
388 // first branch is for Cygwin
389 #if defined(__UNIX__) && !defined(__WINE__)
390 const wxChar *szHome = wxGetenv("HOME");
391 if ( szHome == NULL ) {
392 // we're homeless...
393 wxLogWarning(_("can't find user's HOME, using current directory."));
394 strDir = wxT(".");
395 }
396 else
397 strDir = szHome;
398
399 // add a trailing slash if needed
400 if ( strDir.Last() != wxT('/') )
401 strDir << wxT('/');
402
403 #ifdef __CYGWIN__
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;
408 #endif
409 #elif defined(__WXWINCE__)
410 strDir = wxT("\\");
411 #else
412 strDir.clear();
413
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"));
417
418 if ( szHome != NULL )
419 {
420 strDir = szHome;
421 }
422 else // no HOME, try HOMEDRIVE/PATH
423 {
424 szHome = wxGetenv(wxT("HOMEDRIVE"));
425 if ( szHome != NULL )
426 strDir << szHome;
427 szHome = wxGetenv(wxT("HOMEPATH"));
428
429 if ( szHome != NULL )
430 {
431 strDir << szHome;
432
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 )
440 strDir.clear();
441 }
442 }
443
444 if ( strDir.empty() )
445 {
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"));
449
450 if ( szHome != NULL )
451 strDir = szHome;
452 }
453
454 if ( !strDir.empty() )
455 {
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);
459 }
460 else // fall back to the program directory
461 {
462 // extract the directory component of the program file name
463 wxSplitPath(wxGetFullModuleName(), &strDir, NULL, NULL);
464 }
465 #endif // UNIX/Win
466
467 return strDir.c_str();
468 }
469
470 wxString wxGetUserHome(const wxString& user)
471 {
472 wxString home;
473
474 if ( user.empty() || user == wxGetUserId() )
475 wxGetHomeDir(&home);
476
477 return home;
478 }
479
480 bool wxGetDiskSpace(const wxString& WXUNUSED_IN_WINCE(path),
481 wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pTotal),
482 wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pFree))
483 {
484 #ifdef __WXWINCE__
485 // TODO-CE
486 return false;
487 #else
488 if ( path.empty() )
489 return false;
490
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
495 // it
496 typedef BOOL (WINAPI *GetDiskFreeSpaceEx_t)(LPCTSTR,
497 PULARGE_INTEGER,
498 PULARGE_INTEGER,
499 PULARGE_INTEGER);
500
501 GetDiskFreeSpaceEx_t
502 pGetDiskFreeSpaceEx = (GetDiskFreeSpaceEx_t)::GetProcAddress
503 (
504 ::GetModuleHandle(_T("kernel32.dll")),
505 #if wxUSE_UNICODE
506 "GetDiskFreeSpaceExW"
507 #else
508 "GetDiskFreeSpaceExA"
509 #endif
510 );
511
512 if ( pGetDiskFreeSpaceEx )
513 {
514 ULARGE_INTEGER bytesFree, bytesTotal;
515
516 // may pass the path as is, GetDiskFreeSpaceEx() is smart enough
517 if ( !pGetDiskFreeSpaceEx(path.fn_str(),
518 &bytesFree,
519 &bytesTotal,
520 NULL) )
521 {
522 wxLogLastError(_T("GetDiskFreeSpaceEx"));
523
524 return false;
525 }
526
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)
531 #define UL(ul) ul.u
532 #else // anon union
533 #define UL(ul) ul
534 #endif
535 if ( pTotal )
536 {
537 #if wxUSE_LONGLONG
538 *pTotal = wxDiskspaceSize_t(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart);
539 #else
540 *pTotal = wxDiskspaceSize_t(UL(bytesTotal).LowPart);
541 #endif
542 }
543
544 if ( pFree )
545 {
546 #if wxUSE_LONGLONG
547 *pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);
548 #else
549 *pFree = wxDiskspaceSize_t(UL(bytesFree).LowPart);
550 #endif
551 }
552 }
553 else
554 #endif // Win32
555 {
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...
559
560 DWORD lSectorsPerCluster,
561 lBytesPerSector,
562 lNumberOfFreeClusters,
563 lTotalNumberOfClusters;
564
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(),
568 &lSectorsPerCluster,
569 &lBytesPerSector,
570 &lNumberOfFreeClusters,
571 &lTotalNumberOfClusters) )
572 {
573 wxLogLastError(_T("GetDiskFreeSpace"));
574
575 return false;
576 }
577
578 wxDiskspaceSize_t lBytesPerCluster = (wxDiskspaceSize_t) lSectorsPerCluster;
579 lBytesPerCluster *= lBytesPerSector;
580
581 if ( pTotal )
582 {
583 *pTotal = lBytesPerCluster;
584 *pTotal *= lTotalNumberOfClusters;
585 }
586
587 if ( pFree )
588 {
589 *pFree = lBytesPerCluster;
590 *pFree *= lNumberOfFreeClusters;
591 }
592 }
593
594 return true;
595 #endif
596 // __WXWINCE__
597 }
598
599 // ----------------------------------------------------------------------------
600 // env vars
601 // ----------------------------------------------------------------------------
602
603 bool wxGetEnv(const wxString& WXUNUSED_IN_WINCE(var),
604 wxString *WXUNUSED_IN_WINCE(value))
605 {
606 #ifdef __WXWINCE__
607 // no environment variables under CE
608 return false;
609 #else // Win32
610 // first get the size of the buffer
611 DWORD dwRet = ::GetEnvironmentVariable(var.t_str(), NULL, 0);
612 if ( !dwRet )
613 {
614 // this means that there is no such variable
615 return false;
616 }
617
618 if ( value )
619 {
620 (void)::GetEnvironmentVariable(var.t_str(),
621 wxStringBuffer(*value, dwRet),
622 dwRet);
623 }
624
625 return true;
626 #endif // WinCE/32
627 }
628
629 bool wxDoSetEnv(const wxString& WXUNUSED_IN_WINCE(var),
630 const wxChar *WXUNUSED_IN_WINCE(value))
631 {
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
634 #ifdef __WXWINCE__
635 // no environment variables under CE
636 return false;
637 #else
638 if ( !::SetEnvironmentVariable(var.t_str(), value) )
639 {
640 wxLogLastError(_T("SetEnvironmentVariable"));
641
642 return false;
643 }
644
645 return true;
646 #endif
647 }
648
649 bool wxSetEnv(const wxString& variable, const wxString& value)
650 {
651 return wxDoSetEnv(variable, value.t_str());
652 }
653
654 bool wxUnsetEnv(const wxString& variable)
655 {
656 return wxDoSetEnv(variable, NULL);
657 }
658
659 // ----------------------------------------------------------------------------
660 // process management
661 // ----------------------------------------------------------------------------
662
663 // structure used to pass parameters from wxKill() to wxEnumFindByPidProc()
664 struct wxFindByPidParams
665 {
666 wxFindByPidParams() { hwnd = 0; pid = 0; }
667
668 // the HWND used to return the result
669 HWND hwnd;
670
671 // the PID we're looking from
672 DWORD pid;
673
674 DECLARE_NO_COPY_CLASS(wxFindByPidParams)
675 };
676
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)
680 {
681 DWORD pid;
682 (void)::GetWindowThreadProcessId(hwnd, &pid);
683
684 wxFindByPidParams *params = (wxFindByPidParams *)lParam;
685 if ( pid == params->pid )
686 {
687 // remember the window we found
688 params->hwnd = hwnd;
689
690 // return FALSE to stop the enumeration
691 return FALSE;
692 }
693
694 // continue enumeration
695 return TRUE;
696 }
697
698 int wxKillAllChildren(long pid, wxSignal sig, wxKillError *krc);
699
700 int wxKill(long pid, wxSignal sig, wxKillError *krc, int flags)
701 {
702 if (flags & wxKILL_CHILDREN)
703 wxKillAllChildren(pid, sig, krc);
704
705 // get the process handle to operate on
706 HANDLE hProcess = ::OpenProcess(SYNCHRONIZE |
707 PROCESS_TERMINATE |
708 PROCESS_QUERY_INFORMATION,
709 FALSE, // not inheritable
710 (DWORD)pid);
711 if ( hProcess == NULL )
712 {
713 if ( krc )
714 {
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
720 : wxKILL_NO_PROCESS;
721 }
722
723 return -1;
724 }
725
726 wxON_BLOCK_EXIT1(::CloseHandle, hProcess);
727
728 bool ok = true;
729 switch ( sig )
730 {
731 case wxSIGKILL:
732 // kill the process forcefully returning -1 as error code
733 if ( !::TerminateProcess(hProcess, (UINT)-1) )
734 {
735 wxLogSysError(_("Failed to kill process %d"), pid);
736
737 if ( krc )
738 {
739 // this is not supposed to happen if we could open the
740 // process
741 *krc = wxKILL_ERROR;
742 }
743
744 ok = false;
745 }
746 break;
747
748 case wxSIGNONE:
749 // do nothing, we just want to test for process existence
750 if ( krc )
751 *krc = wxKILL_OK;
752 return 0;
753
754 default:
755 // any other signal means "terminate"
756 {
757 wxFindByPidParams params;
758 params.pid = (DWORD)pid;
759
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)&params) )
764 {
765 // did we find any window?
766 if ( params.hwnd )
767 {
768 // tell the app to close
769 //
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) )
775 {
776 wxLogLastError(_T("PostMessage(WM_QUIT)"));
777 }
778 }
779 else // it was an error then
780 {
781 wxLogLastError(_T("EnumWindows"));
782
783 ok = false;
784 }
785 }
786 else // no windows for this PID
787 {
788 if ( krc )
789 *krc = wxKILL_ERROR;
790
791 ok = false;
792 }
793 }
794 }
795
796 // the return code
797 DWORD rc wxDUMMY_INITIALIZE(0);
798 if ( ok )
799 {
800 // as we wait for a short time, we can use just WaitForSingleObject()
801 // and not MsgWaitForMultipleObjects()
802 switch ( ::WaitForSingleObject(hProcess, 500 /* msec */) )
803 {
804 case WAIT_OBJECT_0:
805 // process terminated
806 if ( !::GetExitCodeProcess(hProcess, &rc) )
807 {
808 wxLogLastError(_T("GetExitCodeProcess"));
809 }
810 break;
811
812 default:
813 wxFAIL_MSG( _T("unexpected WaitForSingleObject() return") );
814 // fall through
815
816 case WAIT_FAILED:
817 wxLogLastError(_T("WaitForSingleObject"));
818 // fall through
819
820 case WAIT_TIMEOUT:
821 if ( krc )
822 *krc = wxKILL_ERROR;
823
824 rc = STILL_ACTIVE;
825 break;
826 }
827 }
828
829
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 )
833 return -1;
834
835 if ( krc )
836 *krc = wxKILL_OK;
837
838 return 0;
839 }
840
841 typedef HANDLE (WINAPI *CreateToolhelp32Snapshot_t)(DWORD,DWORD);
842 typedef BOOL (WINAPI *Process32_t)(HANDLE,LPPROCESSENTRY32);
843
844 CreateToolhelp32Snapshot_t lpfCreateToolhelp32Snapshot;
845 Process32_t lpfProcess32First, lpfProcess32Next;
846
847 static void InitToolHelp32()
848 {
849 static bool s_initToolHelpDone = false;
850
851 if (s_initToolHelpDone)
852 return;
853
854 s_initToolHelpDone = true;
855
856 lpfCreateToolhelp32Snapshot = NULL;
857 lpfProcess32First = NULL;
858 lpfProcess32Next = NULL;
859
860 #if wxUSE_DYNLIB_CLASS
861
862 wxDynamicLibrary dllKernel(_T("kernel32.dll"), wxDL_VERBATIM);
863
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"));
872
873 lpfProcess32First =
874 (Process32_t)dllKernel.RawGetSymbol(_T("Process32First"));
875
876 lpfProcess32Next =
877 (Process32_t)dllKernel.RawGetSymbol(_T("Process32Next"));
878
879 #endif // wxUSE_DYNLIB_CLASS
880 }
881
882 // By John Skiff
883 int wxKillAllChildren(long pid, wxSignal sig, wxKillError *krc)
884 {
885 InitToolHelp32();
886
887 if (krc)
888 *krc = wxKILL_OK;
889
890 // If not implemented for this platform (e.g. NT 4.0), silently ignore
891 if (!lpfCreateToolhelp32Snapshot || !lpfProcess32First || !lpfProcess32Next)
892 return 0;
893
894 // Take a snapshot of all processes in the system.
895 HANDLE hProcessSnap = lpfCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
896 if (hProcessSnap == INVALID_HANDLE_VALUE) {
897 if (krc)
898 *krc = wxKILL_ERROR;
899 return -1;
900 }
901
902 //Fill in the size of the structure before using it.
903 PROCESSENTRY32 pe;
904 wxZeroMemory(pe);
905 pe.dwSize = sizeof(PROCESSENTRY32);
906
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.
911 if (krc)
912 *krc = wxKILL_ERROR;
913 CloseHandle (hProcessSnap);
914 return -1;
915 }
916
917 do {
918 if (pe.th32ParentProcessID == (DWORD) pid) {
919 if (wxKill(pe.th32ProcessID, sig, krc))
920 return -1;
921 }
922 } while (lpfProcess32Next (hProcessSnap, &pe));
923
924
925 return 0;
926 }
927
928 // Execute a program in an Interactive Shell
929 bool wxShell(const wxString& command)
930 {
931 wxString cmd;
932
933 #ifdef __WXWINCE__
934 cmd = command;
935 #else
936 wxChar *shell = wxGetenv(wxT("COMSPEC"));
937 if ( !shell )
938 shell = (wxChar*) wxT("\\COMMAND.COM");
939
940 if ( !command )
941 {
942 // just the shell
943 cmd = shell;
944 }
945 else
946 {
947 // pass the command to execute to the command processor
948 cmd.Printf(wxT("%s /c %s"), shell, command.c_str());
949 }
950 #endif
951
952 return wxExecute(cmd, wxEXEC_SYNC) == 0;
953 }
954
955 // Shutdown or reboot the PC
956 bool wxShutdown(int WXUNUSED_IN_WINCE(flags))
957 {
958 #ifdef __WXWINCE__
959 // TODO-CE
960 return false;
961 #elif defined(__WIN32__)
962 bool bOK = true;
963
964 if ( wxGetOsVersion(NULL, NULL) == wxOS_WINDOWS_NT ) // if is NT or 2K
965 {
966 // Get a token for this process.
967 HANDLE hToken;
968 bOK = ::OpenProcessToken(GetCurrentProcess(),
969 TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
970 &hToken) != 0;
971 if ( bOK )
972 {
973 TOKEN_PRIVILEGES tkp;
974
975 // Get the LUID for the shutdown privilege.
976 ::LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME,
977 &tkp.Privileges[0].Luid);
978
979 tkp.PrivilegeCount = 1; // one privilege to set
980 tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
981
982 // Get the shutdown privilege for this process.
983 ::AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,
984 (PTOKEN_PRIVILEGES)NULL, 0);
985
986 // Cannot test the return value of AdjustTokenPrivileges.
987 bOK = ::GetLastError() == ERROR_SUCCESS;
988 }
989 }
990
991 if ( bOK )
992 {
993 UINT wFlags = 0;
994 if ( flags & wxSHUTDOWN_FORCE )
995 {
996 wFlags = EWX_FORCE;
997 flags &= ~wxSHUTDOWN_FORCE;
998 }
999
1000 switch ( flags )
1001 {
1002 case wxSHUTDOWN_POWEROFF:
1003 wFlags |= EWX_POWEROFF;
1004 break;
1005
1006 case wxSHUTDOWN_REBOOT:
1007 wFlags |= EWX_REBOOT;
1008 break;
1009
1010 case wxSHUTDOWN_LOGOFF:
1011 wFlags |= EWX_LOGOFF;
1012 break;
1013
1014 default:
1015 wxFAIL_MSG( _T("unknown wxShutdown() flag") );
1016 return false;
1017 }
1018
1019 bOK = ::ExitWindowsEx(wFlags, 0) != 0;
1020 }
1021
1022 return bOK;
1023 #endif // WinCE/!WinCE
1024 }
1025
1026 // ----------------------------------------------------------------------------
1027 // misc
1028 // ----------------------------------------------------------------------------
1029
1030 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
1031 wxMemorySize wxGetFreeMemory()
1032 {
1033 #if defined(__WIN64__)
1034 MEMORYSTATUSEX memStatex;
1035 memStatex.dwLength = sizeof (memStatex);
1036 ::GlobalMemoryStatusEx (&memStatex);
1037 return (wxMemorySize)memStatex.ullAvailPhys;
1038 #else /* if defined(__WIN32__) */
1039 MEMORYSTATUS memStatus;
1040 memStatus.dwLength = sizeof(MEMORYSTATUS);
1041 ::GlobalMemoryStatus(&memStatus);
1042 return (wxMemorySize)memStatus.dwAvailPhys;
1043 #endif
1044 }
1045
1046 unsigned long wxGetProcessId()
1047 {
1048 return ::GetCurrentProcessId();
1049 }
1050
1051 // Emit a beeeeeep
1052 void wxBell()
1053 {
1054 ::MessageBeep((UINT)-1); // default sound
1055 }
1056
1057 bool wxIsDebuggerRunning()
1058 {
1059 #if wxUSE_DYNLIB_CLASS
1060 // IsDebuggerPresent() is not available under Win95, so load it dynamically
1061 wxDynamicLibrary dll(_T("kernel32.dll"), wxDL_VERBATIM);
1062
1063 typedef BOOL (WINAPI *IsDebuggerPresent_t)();
1064 if ( !dll.HasSymbol(_T("IsDebuggerPresent")) )
1065 {
1066 // no way to know, assume no
1067 return false;
1068 }
1069
1070 return (*(IsDebuggerPresent_t)dll.GetSymbol(_T("IsDebuggerPresent")))() != 0;
1071 #else
1072 return false;
1073 #endif
1074 }
1075
1076 // ----------------------------------------------------------------------------
1077 // OS version
1078 // ----------------------------------------------------------------------------
1079
1080 // check if we're running under a server or workstation Windows system: it
1081 // returns true or false with obvious meaning as well as -1 if the system type
1082 // couldn't be determined
1083 //
1084 // this function is currently private but we may want to expose it later if
1085 // it's really useful
1086 namespace
1087 {
1088
1089 int wxIsWindowsServer()
1090 {
1091 #ifdef VER_NT_WORKSTATION
1092 OSVERSIONINFOEX info;
1093 wxZeroMemory(info);
1094
1095 info.dwOSVersionInfoSize = sizeof(info);
1096 if ( ::GetVersionEx(wx_reinterpret_cast(OSVERSIONINFO *, &info)) )
1097 {
1098 switch ( info.wProductType )
1099 {
1100 case VER_NT_WORKSTATION:
1101 return false;
1102
1103 case VER_NT_SERVER:
1104 case VER_NT_DOMAIN_CONTROLLER:
1105 return true;
1106 }
1107 }
1108 #endif // VER_NT_WORKSTATION
1109
1110 return -1;
1111 }
1112
1113 } // anonymous namespace
1114
1115 wxString wxGetOsDescription()
1116 {
1117 wxString str;
1118
1119 OSVERSIONINFO info;
1120 wxZeroMemory(info);
1121
1122 info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1123 if ( ::GetVersionEx(&info) )
1124 {
1125 switch ( info.dwPlatformId )
1126 {
1127 #ifdef VER_PLATFORM_WIN32_CE
1128 case VER_PLATFORM_WIN32_CE:
1129 str.Printf(_("Windows CE (%d.%d)"),
1130 info.dwMajorVersion,
1131 info.dwMinorVersion);
1132 break;
1133 #endif
1134 case VER_PLATFORM_WIN32s:
1135 str = _("Win32s on Windows 3.1");
1136 break;
1137
1138 case VER_PLATFORM_WIN32_WINDOWS:
1139 switch (info.dwMinorVersion)
1140 {
1141 case 0:
1142 if ( info.szCSDVersion[1] == 'B' ||
1143 info.szCSDVersion[1] == 'C' )
1144 {
1145 str = _("Windows 95 OSR2");
1146 }
1147 else
1148 {
1149 str = _("Windows 95");
1150 }
1151 break;
1152 case 10:
1153 if ( info.szCSDVersion[1] == 'B' ||
1154 info.szCSDVersion[1] == 'C' )
1155 {
1156 str = _("Windows 98 SE");
1157 }
1158 else
1159 {
1160 str = _("Windows 98");
1161 }
1162 break;
1163 case 90:
1164 str = _("Windows ME");
1165 break;
1166 default:
1167 str.Printf(_("Windows 9x (%d.%d)"),
1168 info.dwMajorVersion,
1169 info.dwMinorVersion);
1170 break;
1171 }
1172 if ( !wxIsEmpty(info.szCSDVersion) )
1173 {
1174 str << _T(" (") << info.szCSDVersion << _T(')');
1175 }
1176 break;
1177
1178 case VER_PLATFORM_WIN32_NT:
1179 switch ( info.dwMajorVersion )
1180 {
1181 case 5:
1182 switch ( info.dwMinorVersion )
1183 {
1184 case 0:
1185 str.Printf(_("Windows 2000 (build %lu"),
1186 info.dwBuildNumber);
1187 break;
1188
1189 case 2:
1190 // we can't distinguish between XP 64 and 2003
1191 // as they both are 5.2, so examine the product
1192 // type to resolve this ambiguity
1193 if ( wxIsWindowsServer() == 1 )
1194 {
1195 str.Printf(_("Windows Server 2003 (build %lu"),
1196 info.dwBuildNumber);
1197 break;
1198 }
1199 //else: must be XP, fall through
1200
1201 case 1:
1202 str.Printf(_("Windows XP (build %lu"),
1203 info.dwBuildNumber);
1204 break;
1205 }
1206 break;
1207
1208 case 6:
1209 if ( info.dwMinorVersion == 0 )
1210 {
1211 str.Printf(_("Windows Vista (build %lu"),
1212 info.dwBuildNumber);
1213 }
1214 break;
1215 }
1216
1217 if ( str.empty() )
1218 {
1219 str.Printf(_("Windows NT %lu.%lu (build %lu"),
1220 info.dwMajorVersion,
1221 info.dwMinorVersion,
1222 info.dwBuildNumber);
1223 }
1224
1225 if ( !wxIsEmpty(info.szCSDVersion) )
1226 {
1227 str << _T(", ") << info.szCSDVersion;
1228 }
1229 str << _T(')');
1230
1231 if ( wxIsPlatform64Bit() )
1232 str << _(", 64-bit edition");
1233 break;
1234 }
1235 }
1236 else
1237 {
1238 wxFAIL_MSG( _T("GetVersionEx() failed") ); // should never happen
1239 }
1240
1241 return str;
1242 }
1243
1244 bool wxIsPlatform64Bit()
1245 {
1246 #if defined(_WIN64)
1247 return true; // 64-bit programs run only on Win64
1248 #elif wxUSE_DYNLIB_CLASS // Win32
1249 // 32-bit programs run on both 32-bit and 64-bit Windows so check
1250 typedef BOOL (WINAPI *IsWow64Process_t)(HANDLE, BOOL *);
1251
1252 wxDynamicLibrary dllKernel32(_T("kernel32.dll"));
1253 IsWow64Process_t pfnIsWow64Process =
1254 (IsWow64Process_t)dllKernel32.RawGetSymbol(_T("IsWow64Process"));
1255
1256 BOOL wow64 = FALSE;
1257 if ( pfnIsWow64Process )
1258 {
1259 pfnIsWow64Process(::GetCurrentProcess(), &wow64);
1260 }
1261 //else: running under a system without Win64 support
1262
1263 return wow64 != FALSE;
1264 #else
1265 return false;
1266 #endif // Win64/Win32
1267 }
1268
1269 wxOperatingSystemId wxGetOsVersion(int *verMaj, int *verMin)
1270 {
1271 static struct
1272 {
1273 // this may be false, true or -1 if we tried to initialize but failed
1274 int initialized;
1275
1276 wxOperatingSystemId os;
1277
1278 int verMaj,
1279 verMin;
1280 } s_version;
1281
1282 // query the OS info only once as it's not supposed to change
1283 if ( !s_version.initialized )
1284 {
1285 OSVERSIONINFO info;
1286 wxZeroMemory(info);
1287 info.dwOSVersionInfoSize = sizeof(info);
1288 if ( ::GetVersionEx(&info) )
1289 {
1290 s_version.initialized = true;
1291
1292 #if defined(__WXWINCE__)
1293 s_version.os = wxOS_WINDOWS_CE;
1294 #elif defined(__WXMICROWIN__)
1295 s_version.os = wxOS_WINDOWS_MICRO;
1296 #else // "normal" desktop Windows system, use run-time detection
1297 switch ( info.dwPlatformId )
1298 {
1299 case VER_PLATFORM_WIN32_NT:
1300 s_version.os = wxOS_WINDOWS_NT;
1301 break;
1302
1303 case VER_PLATFORM_WIN32_WINDOWS:
1304 s_version.os = wxOS_WINDOWS_9X;
1305 break;
1306 }
1307 #endif // Windows versions
1308
1309 s_version.verMaj = info.dwMajorVersion;
1310 s_version.verMin = info.dwMinorVersion;
1311 }
1312 else // GetVersionEx() failed
1313 {
1314 s_version.initialized = -1;
1315 }
1316 }
1317
1318 if ( s_version.initialized == 1 )
1319 {
1320 if ( verMaj )
1321 *verMaj = s_version.verMaj;
1322 if ( verMin )
1323 *verMin = s_version.verMin;
1324 }
1325
1326 // this works even if we were not initialized successfully as the initial
1327 // values of this field is 0 which is wxOS_UNKNOWN and exactly what we need
1328 return s_version.os;
1329 }
1330
1331 wxWinVersion wxGetWinVersion()
1332 {
1333 int verMaj,
1334 verMin;
1335 switch ( wxGetOsVersion(&verMaj, &verMin) )
1336 {
1337 case wxOS_WINDOWS_9X:
1338 if ( verMaj == 4 )
1339 {
1340 switch ( verMin )
1341 {
1342 case 0:
1343 return wxWinVersion_95;
1344
1345 case 10:
1346 return wxWinVersion_98;
1347
1348 case 90:
1349 return wxWinVersion_ME;
1350 }
1351 }
1352 break;
1353
1354 case wxOS_WINDOWS_NT:
1355 switch ( verMaj )
1356 {
1357 case 3:
1358 return wxWinVersion_NT3;
1359
1360 case 4:
1361 return wxWinVersion_NT4;
1362
1363 case 5:
1364 switch ( verMin )
1365 {
1366 case 0:
1367 return wxWinVersion_2000;
1368
1369 case 1:
1370 return wxWinVersion_XP;
1371
1372 case 2:
1373 return wxWinVersion_2003;
1374 }
1375 break;
1376
1377 case 6:
1378 return wxWinVersion_NT6;
1379 }
1380 break;
1381
1382 default:
1383 // Do nothing just to silence GCC warning
1384 break;
1385 }
1386
1387 return wxWinVersion_Unknown;
1388 }
1389
1390 // ----------------------------------------------------------------------------
1391 // sleep functions
1392 // ----------------------------------------------------------------------------
1393
1394 void wxMilliSleep(unsigned long milliseconds)
1395 {
1396 ::Sleep(milliseconds);
1397 }
1398
1399 void wxMicroSleep(unsigned long microseconds)
1400 {
1401 wxMilliSleep(microseconds/1000);
1402 }
1403
1404 void wxSleep(int nSecs)
1405 {
1406 wxMilliSleep(1000*nSecs);
1407 }
1408
1409 // ----------------------------------------------------------------------------
1410 // font encoding <-> Win32 codepage conversion functions
1411 // ----------------------------------------------------------------------------
1412
1413 extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)
1414 {
1415 switch ( encoding )
1416 {
1417 // although this function is supposed to return an exact match, do do
1418 // some mappings here for the most common case of "standard" encoding
1419 case wxFONTENCODING_SYSTEM:
1420 return DEFAULT_CHARSET;
1421
1422 case wxFONTENCODING_ISO8859_1:
1423 case wxFONTENCODING_ISO8859_15:
1424 case wxFONTENCODING_CP1252:
1425 return ANSI_CHARSET;
1426
1427 #if !defined(__WXMICROWIN__)
1428 // The following four fonts are multi-byte charsets
1429 case wxFONTENCODING_CP932:
1430 return SHIFTJIS_CHARSET;
1431
1432 case wxFONTENCODING_CP936:
1433 return GB2312_CHARSET;
1434
1435 #ifndef __WXWINCE__
1436 case wxFONTENCODING_CP949:
1437 return HANGUL_CHARSET;
1438 #endif
1439
1440 case wxFONTENCODING_CP950:
1441 return CHINESEBIG5_CHARSET;
1442
1443 // The rest are single byte encodings
1444 case wxFONTENCODING_CP1250:
1445 return EASTEUROPE_CHARSET;
1446
1447 case wxFONTENCODING_CP1251:
1448 return RUSSIAN_CHARSET;
1449
1450 case wxFONTENCODING_CP1253:
1451 return GREEK_CHARSET;
1452
1453 case wxFONTENCODING_CP1254:
1454 return TURKISH_CHARSET;
1455
1456 case wxFONTENCODING_CP1255:
1457 return HEBREW_CHARSET;
1458
1459 case wxFONTENCODING_CP1256:
1460 return ARABIC_CHARSET;
1461
1462 case wxFONTENCODING_CP1257:
1463 return BALTIC_CHARSET;
1464
1465 case wxFONTENCODING_CP874:
1466 return THAI_CHARSET;
1467 #endif // !__WXMICROWIN__
1468
1469 case wxFONTENCODING_CP437:
1470 return OEM_CHARSET;
1471
1472 default:
1473 // no way to translate this encoding into a Windows charset
1474 return -1;
1475 }
1476 }
1477
1478 // we have 2 versions of wxCharsetToCodepage(): the old one which directly
1479 // looks up the vlaues in the registry and the new one which is more
1480 // politically correct and has more chances to work on other Windows versions
1481 // as well but the old version is still needed for !wxUSE_FONTMAP case
1482 #if wxUSE_FONTMAP
1483
1484 #include "wx/fontmap.h"
1485
1486 extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
1487 {
1488 // There don't seem to be symbolic names for
1489 // these under Windows so I just copied the
1490 // values from MSDN.
1491
1492 unsigned int ret;
1493
1494 switch (encoding)
1495 {
1496 case wxFONTENCODING_ISO8859_1: ret = 28591; break;
1497 case wxFONTENCODING_ISO8859_2: ret = 28592; break;
1498 case wxFONTENCODING_ISO8859_3: ret = 28593; break;
1499 case wxFONTENCODING_ISO8859_4: ret = 28594; break;
1500 case wxFONTENCODING_ISO8859_5: ret = 28595; break;
1501 case wxFONTENCODING_ISO8859_6: ret = 28596; break;
1502 case wxFONTENCODING_ISO8859_7: ret = 28597; break;
1503 case wxFONTENCODING_ISO8859_8: ret = 28598; break;
1504 case wxFONTENCODING_ISO8859_9: ret = 28599; break;
1505 case wxFONTENCODING_ISO8859_10: ret = 28600; break;
1506 case wxFONTENCODING_ISO8859_11: ret = 874; break;
1507 // case wxFONTENCODING_ISO8859_12, // doesn't exist currently, but put it
1508 case wxFONTENCODING_ISO8859_13: ret = 28603; break;
1509 // case wxFONTENCODING_ISO8859_14: ret = 28604; break; // no correspondence on Windows
1510 case wxFONTENCODING_ISO8859_15: ret = 28605; break;
1511
1512 case wxFONTENCODING_KOI8: ret = 20866; break;
1513 case wxFONTENCODING_KOI8_U: ret = 21866; break;
1514
1515 case wxFONTENCODING_CP437: ret = 437; break;
1516 case wxFONTENCODING_CP850: ret = 850; break;
1517 case wxFONTENCODING_CP852: ret = 852; break;
1518 case wxFONTENCODING_CP855: ret = 855; break;
1519 case wxFONTENCODING_CP866: ret = 866; break;
1520 case wxFONTENCODING_CP874: ret = 874; break;
1521 case wxFONTENCODING_CP932: ret = 932; break;
1522 case wxFONTENCODING_CP936: ret = 936; break;
1523 case wxFONTENCODING_CP949: ret = 949; break;
1524 case wxFONTENCODING_CP950: ret = 950; break;
1525 case wxFONTENCODING_CP1250: ret = 1250; break;
1526 case wxFONTENCODING_CP1251: ret = 1251; break;
1527 case wxFONTENCODING_CP1252: ret = 1252; break;
1528 case wxFONTENCODING_CP1253: ret = 1253; break;
1529 case wxFONTENCODING_CP1254: ret = 1254; break;
1530 case wxFONTENCODING_CP1255: ret = 1255; break;
1531 case wxFONTENCODING_CP1256: ret = 1256; break;
1532 case wxFONTENCODING_CP1257: ret = 1257; break;
1533
1534 case wxFONTENCODING_EUC_JP: ret = 20932; break;
1535
1536 case wxFONTENCODING_MACROMAN: ret = 10000; break;
1537 case wxFONTENCODING_MACJAPANESE: ret = 10001; break;
1538 case wxFONTENCODING_MACCHINESETRAD: ret = 10002; break;
1539 case wxFONTENCODING_MACKOREAN: ret = 10003; break;
1540 case wxFONTENCODING_MACARABIC: ret = 10004; break;
1541 case wxFONTENCODING_MACHEBREW: ret = 10005; break;
1542 case wxFONTENCODING_MACGREEK: ret = 10006; break;
1543 case wxFONTENCODING_MACCYRILLIC: ret = 10007; break;
1544 case wxFONTENCODING_MACTHAI: ret = 10021; break;
1545 case wxFONTENCODING_MACCHINESESIMP: ret = 10008; break;
1546 case wxFONTENCODING_MACCENTRALEUR: ret = 10029; break;
1547 case wxFONTENCODING_MACCROATIAN: ret = 10082; break;
1548 case wxFONTENCODING_MACICELANDIC: ret = 10079; break;
1549 case wxFONTENCODING_MACROMANIAN: ret = 10009; break;
1550
1551 case wxFONTENCODING_ISO2022_JP: ret = 50222; break;
1552
1553 case wxFONTENCODING_UTF7: ret = 65000; break;
1554 case wxFONTENCODING_UTF8: ret = 65001; break;
1555
1556 default: return -1;
1557 }
1558
1559 if (::IsValidCodePage(ret) == 0)
1560 return -1;
1561
1562 CPINFO info;
1563 if (::GetCPInfo(ret, &info) == 0)
1564 return -1;
1565
1566 return (long) ret;
1567 }
1568
1569 extern long wxCharsetToCodepage(const char *name)
1570 {
1571 // first get the font encoding for this charset
1572 if ( !name )
1573 return -1;
1574
1575 wxFontEncoding enc = wxFontMapperBase::Get()->CharsetToEncoding(name, false);
1576 if ( enc == wxFONTENCODING_SYSTEM )
1577 return -1;
1578
1579 // the use the helper function
1580 return wxEncodingToCodepage(enc);
1581 }
1582
1583 #else // !wxUSE_FONTMAP
1584
1585 #include "wx/msw/registry.h"
1586
1587 // this should work if Internet Exploiter is installed
1588 extern long wxCharsetToCodepage(const char *name)
1589 {
1590 if (!name)
1591 return GetACP();
1592
1593 long CP = -1;
1594
1595 #if wxUSE_REGKEY
1596 wxString path(wxT("MIME\\Database\\Charset\\"));
1597 wxString cn(name);
1598
1599 // follow the alias loop
1600 for ( ;; )
1601 {
1602 wxRegKey key(wxRegKey::HKCR, path + cn);
1603
1604 if (!key.Exists())
1605 break;
1606
1607 // two cases: either there's an AliasForCharset string,
1608 // or there are Codepage and InternetEncoding dwords.
1609 // The InternetEncoding gives us the actual encoding,
1610 // the Codepage just says which Windows character set to
1611 // use when displaying the data.
1612 if (key.HasValue(wxT("InternetEncoding")) &&
1613 key.QueryValue(wxT("InternetEncoding"), &CP))
1614 break;
1615
1616 // no encoding, see if it's an alias
1617 if (!key.HasValue(wxT("AliasForCharset")) ||
1618 !key.QueryValue(wxT("AliasForCharset"), cn))
1619 break;
1620 }
1621 #endif // wxUSE_REGKEY
1622
1623 return CP;
1624 }
1625
1626 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
1627
1628 /*
1629 Creates a hidden window with supplied window proc registering the class for
1630 it if necesssary (i.e. the first time only). Caller is responsible for
1631 destroying the window and unregistering the class (note that this must be
1632 done because wxWidgets may be used as a DLL and so may be loaded/unloaded
1633 multiple times into/from the same process so we cna't rely on automatic
1634 Windows class unregistration).
1635
1636 pclassname is a pointer to a caller stored classname, which must initially be
1637 NULL. classname is the desired wndclass classname. If function successfully
1638 registers the class, pclassname will be set to classname.
1639 */
1640 extern "C" WXDLLIMPEXP_BASE HWND
1641 wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc)
1642 {
1643 wxCHECK_MSG( classname && pclassname && wndproc, NULL,
1644 _T("NULL parameter in wxCreateHiddenWindow") );
1645
1646 // register the class fi we need to first
1647 if ( *pclassname == NULL )
1648 {
1649 WNDCLASS wndclass;
1650 wxZeroMemory(wndclass);
1651
1652 wndclass.lpfnWndProc = wndproc;
1653 wndclass.hInstance = wxGetInstance();
1654 wndclass.lpszClassName = classname;
1655
1656 if ( !::RegisterClass(&wndclass) )
1657 {
1658 wxLogLastError(wxT("RegisterClass() in wxCreateHiddenWindow"));
1659
1660 return NULL;
1661 }
1662
1663 *pclassname = classname;
1664 }
1665
1666 // next create the window
1667 HWND hwnd = ::CreateWindow
1668 (
1669 *pclassname,
1670 NULL,
1671 0, 0, 0, 0,
1672 0,
1673 (HWND) NULL,
1674 (HMENU)NULL,
1675 wxGetInstance(),
1676 (LPVOID) NULL
1677 );
1678
1679 if ( !hwnd )
1680 {
1681 wxLogLastError(wxT("CreateWindow() in wxCreateHiddenWindow"));
1682 }
1683
1684 return hwnd;
1685 }
wxWidgets (Impactor)