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


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