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