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


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