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


df8a474ea7d503a784c5ecca785095dc76aa77f7
[wxWidgets.git] / src / msw / utils.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/utils.cpp
3 // Purpose: Various utilities
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #ifndef WX_PRECOMP
28 #include "wx/utils.h"
29 #include "wx/app.h"
30 #include "wx/intl.h"
31 #include "wx/log.h"
32 #endif //WX_PRECOMP
33
34 #include "wx/msw/registry.h"
35 #include "wx/apptrait.h"
36 #include "wx/dynlib.h"
37 #include "wx/dynload.h"
38 #include "wx/scopeguard.h"
39
40 #include "wx/confbase.h" // for wxExpandEnvVars()
41
42 #include "wx/msw/private.h" // includes <windows.h>
43 #include "wx/msw/missing.h" // for CHARSET_HANGUL
44
45 #if defined(__CYGWIN__)
46 //CYGWIN gives annoying warning about runtime stuff if we don't do this
47 # define USE_SYS_TYPES_FD_SET
48 # include <sys/types.h>
49 #endif
50
51 // Doesn't work with Cygwin at present
52 #if wxUSE_SOCKETS && (defined(__GNUWIN32_OLD__) || defined(__WXWINCE__) || defined(__CYGWIN32__))
53 // apparently we need to include winsock.h to get WSADATA and other stuff
54 // used in wxGetFullHostName() with the old mingw32 versions
55 #include <winsock.h>
56 #endif
57
58 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
59 #include <direct.h>
60
61 #ifndef __MWERKS__
62 #include <dos.h>
63 #endif
64 #endif //GNUWIN32
65
66 #if defined(__CYGWIN__)
67 #include <sys/unistd.h>
68 #include <sys/stat.h>
69 #include <sys/cygwin.h> // for cygwin_conv_to_full_win32_path()
70 #endif //GNUWIN32
71
72 #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs
73 // this (3.1 I believe) and how to test for it.
74 // If this works for Borland 4.0 as well, then no worries.
75 #include <dir.h>
76 #endif
77
78 // VZ: there is some code using NetXXX() functions to get the full user name:
79 // I don't think it's a good idea because they don't work under Win95 and
80 // seem to return the same as wxGetUserId() under NT. If you really want
81 // to use them, just #define USE_NET_API
82 #undef USE_NET_API
83
84 #ifdef USE_NET_API
85 #include <lm.h>
86 #endif // USE_NET_API
87
88 #if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
89 #ifndef __UNIX__
90 #include <io.h>
91 #endif
92
93 #ifndef __GNUWIN32__
94 #include <shellapi.h>
95 #endif
96 #endif
97
98 #ifndef __WATCOMC__
99 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
100 #include <errno.h>
101 #endif
102 #endif
103
104 // For wxKillAllChildren
105 #include <tlhelp32.h>
106
107 // ----------------------------------------------------------------------------
108 // constants
109 // ----------------------------------------------------------------------------
110
111 // In the WIN.INI file
112 #if (!defined(USE_NET_API) && !defined(__WXWINCE__)) || defined(__WXMICROWIN__)
113 static const wxChar WX_SECTION[] = wxT("wxWindows");
114 #endif
115
116 #if (!defined(USE_NET_API) && !defined(__WXWINCE__))
117 static const wxChar eUSERNAME[] = wxT("UserName");
118 #endif
119
120 // ============================================================================
121 // implementation
122 // ============================================================================
123
124 // ----------------------------------------------------------------------------
125 // get host name and related
126 // ----------------------------------------------------------------------------
127
128 // Get hostname only (without domain name)
129 bool wxGetHostName(wxChar *WXUNUSED_IN_WINCE(buf),
130 int WXUNUSED_IN_WINCE(maxSize))
131 {
132 #if defined(__WXWINCE__)
133 // TODO-CE
134 return false;
135 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
136 DWORD nSize = maxSize;
137 if ( !::GetComputerName(buf, &nSize) )
138 {
139 wxLogLastError(wxT("GetComputerName"));
140
141 return false;
142 }
143
144 return true;
145 #else
146 wxChar *sysname;
147 const wxChar *default_host = wxT("noname");
148
149 if ((sysname = wxGetenv(wxT("SYSTEM_NAME"))) == NULL) {
150 GetProfileString(WX_SECTION, eHOSTNAME, default_host, buf, maxSize - 1);
151 } else
152 wxStrncpy(buf, sysname, maxSize - 1);
153 buf[maxSize] = wxT('\0');
154 return *buf ? true : false;
155 #endif
156 }
157
158 // get full hostname (with domain name if possible)
159 bool wxGetFullHostName(wxChar *buf, int maxSize)
160 {
161 #if !defined( __WXMICROWIN__) && wxUSE_DYNAMIC_LOADER && wxUSE_SOCKETS
162 // TODO should use GetComputerNameEx() when available
163
164 // we don't want to always link with Winsock DLL as we might not use it at
165 // all, so load it dynamically here if needed (and don't complain if it is
166 // missing, we handle this)
167 wxLogNull noLog;
168
169 wxDynamicLibrary dllWinsock(_T("ws2_32.dll"), wxDL_VERBATIM);
170 if ( dllWinsock.IsLoaded() )
171 {
172 typedef int (PASCAL *WSAStartup_t)(WORD, WSADATA *);
173 typedef int (PASCAL *gethostname_t)(char *, int);
174 typedef hostent* (PASCAL *gethostbyname_t)(const char *);
175 typedef hostent* (PASCAL *gethostbyaddr_t)(const char *, int , int);
176 typedef int (PASCAL *WSACleanup_t)(void);
177
178 #define LOAD_WINSOCK_FUNC(func) \
179 func ## _t \
180 pfn ## func = (func ## _t)dllWinsock.GetSymbol(_T(#func))
181
182 LOAD_WINSOCK_FUNC(WSAStartup);
183
184 WSADATA wsa;
185 if ( pfnWSAStartup && pfnWSAStartup(MAKEWORD(1, 1), &wsa) == 0 )
186 {
187 LOAD_WINSOCK_FUNC(gethostname);
188
189 wxString host;
190 if ( pfngethostname )
191 {
192 char bufA[256];
193 if ( pfngethostname(bufA, WXSIZEOF(bufA)) == 0 )
194 {
195 // gethostname() won't usually include the DNS domain name,
196 // for this we need to work a bit more
197 if ( !strchr(bufA, '.') )
198 {
199 LOAD_WINSOCK_FUNC(gethostbyname);
200
201 struct hostent *pHostEnt = pfngethostbyname
202 ? pfngethostbyname(bufA)
203 : NULL;
204
205 if ( pHostEnt )
206 {
207 // Windows will use DNS internally now
208 LOAD_WINSOCK_FUNC(gethostbyaddr);
209
210 pHostEnt = pfngethostbyaddr
211 ? pfngethostbyaddr(pHostEnt->h_addr,
212 4, AF_INET)
213 : NULL;
214 }
215
216 if ( pHostEnt )
217 {
218 host = wxString::FromAscii(pHostEnt->h_name);
219 }
220 }
221 }
222 }
223
224 LOAD_WINSOCK_FUNC(WSACleanup);
225 if ( pfnWSACleanup )
226 pfnWSACleanup();
227
228
229 if ( !host.empty() )
230 {
231 wxStrncpy(buf, host, maxSize);
232
233 return true;
234 }
235 }
236 }
237 #endif // !__WXMICROWIN__
238
239 return wxGetHostName(buf, maxSize);
240 }
241
242 // Get user ID e.g. jacs
243 bool wxGetUserId(wxChar *WXUNUSED_IN_WINCE(buf),
244 int WXUNUSED_IN_WINCE(maxSize))
245 {
246 #if defined(__WXWINCE__)
247 // TODO-CE
248 return false;
249 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
250 DWORD nSize = maxSize;
251 if ( ::GetUserName(buf, &nSize) == 0 )
252 {
253 // actually, it does happen on Win9x if the user didn't log on
254 DWORD res = ::GetEnvironmentVariable(wxT("username"), buf, maxSize);
255 if ( res == 0 )
256 {
257 // not found
258 return false;
259 }
260 }
261
262 return true;
263 #else // __WXMICROWIN__
264 wxChar *user;
265 const wxChar *default_id = wxT("anonymous");
266
267 // Can't assume we have NIS (PC-NFS) or some other ID daemon
268 // So we ...
269 if ( (user = wxGetenv(wxT("USER"))) == NULL &&
270 (user = wxGetenv(wxT("LOGNAME"))) == NULL )
271 {
272 // Use wxWidgets configuration data (comming soon)
273 GetProfileString(WX_SECTION, eUSERID, default_id, buf, maxSize - 1);
274 }
275 else
276 {
277 wxStrncpy(buf, user, maxSize - 1);
278 }
279
280 return *buf ? true : false;
281 #endif
282 }
283
284 // Get user name e.g. Julian Smart
285 bool wxGetUserName(wxChar *buf, int maxSize)
286 {
287 wxCHECK_MSG( buf && ( maxSize > 0 ), false,
288 _T("empty buffer in wxGetUserName") );
289 #if defined(__WXWINCE__)
290 wxLogNull noLog;
291 wxRegKey key(wxRegKey::HKCU, wxT("ControlPanel\\Owner"));
292 if(!key.Open(wxRegKey::Read))
293 return false;
294 wxString name;
295 if(!key.QueryValue(wxT("Owner"),name))
296 return false;
297 wxStrncpy(buf, name.c_str(), maxSize-1);
298 buf[maxSize-1] = _T('\0');
299 return true;
300 #elif defined(USE_NET_API)
301 CHAR szUserName[256];
302 if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )
303 return false;
304
305 // TODO how to get the domain name?
306 CHAR *szDomain = "";
307
308 // the code is based on the MSDN example (also see KB article Q119670)
309 WCHAR wszUserName[256]; // Unicode user name
310 WCHAR wszDomain[256];
311 LPBYTE ComputerName;
312
313 USER_INFO_2 *ui2; // User structure
314
315 // Convert ANSI user name and domain to Unicode
316 MultiByteToWideChar( CP_ACP, 0, szUserName, strlen(szUserName)+1,
317 wszUserName, WXSIZEOF(wszUserName) );
318 MultiByteToWideChar( CP_ACP, 0, szDomain, strlen(szDomain)+1,
319 wszDomain, WXSIZEOF(wszDomain) );
320
321 // Get the computer name of a DC for the domain.
322 if ( NetGetDCName( NULL, wszDomain, &ComputerName ) != NERR_Success )
323 {
324 wxLogError(wxT("Can not find domain controller"));
325
326 goto error;
327 }
328
329 // Look up the user on the DC
330 NET_API_STATUS status = NetUserGetInfo( (LPWSTR)ComputerName,
331 (LPWSTR)&wszUserName,
332 2, // level - we want USER_INFO_2
333 (LPBYTE *) &ui2 );
334 switch ( status )
335 {
336 case NERR_Success:
337 // ok
338 break;
339
340 case NERR_InvalidComputer:
341 wxLogError(wxT("Invalid domain controller name."));
342
343 goto error;
344
345 case NERR_UserNotFound:
346 wxLogError(wxT("Invalid user name '%s'."), szUserName);
347
348 goto error;
349
350 default:
351 wxLogSysError(wxT("Can't get information about user"));
352
353 goto error;
354 }
355
356 // Convert the Unicode full name to ANSI
357 WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1,
358 buf, maxSize, NULL, NULL );
359
360 return true;
361
362 error:
363 wxLogError(wxT("Couldn't look up full user name."));
364
365 return false;
366 #else // !USE_NET_API
367 // Could use NIS, MS-Mail or other site specific programs
368 // Use wxWidgets configuration data
369 bool ok = GetProfileString(WX_SECTION, eUSERNAME, wxEmptyString, buf, maxSize - 1) != 0;
370 if ( !ok )
371 {
372 ok = wxGetUserId(buf, maxSize);
373 }
374
375 if ( !ok )
376 {
377 wxStrncpy(buf, wxT("Unknown User"), maxSize);
378 }
379
380 return true;
381 #endif // Win32/16
382 }
383
384 const wxChar* wxGetHomeDir(wxString *pstr)
385 {
386 wxString& strDir = *pstr;
387
388 // first branch is for Cygwin
389 #if defined(__UNIX__) && !defined(__WINE__)
390 const wxChar *szHome = wxGetenv("HOME");
391 if ( szHome == NULL ) {
392 // we're homeless...
393 wxLogWarning(_("can't find user's HOME, using current directory."));
394 strDir = wxT(".");
395 }
396 else
397 strDir = szHome;
398
399 // add a trailing slash if needed
400 if ( strDir.Last() != wxT('/') )
401 strDir << wxT('/');
402
403 #ifdef __CYGWIN__
404 // Cygwin returns unix type path but that does not work well
405 static wxChar windowsPath[MAX_PATH];
406 cygwin_conv_to_full_win32_path(strDir, windowsPath);
407 strDir = windowsPath;
408 #endif
409 #elif defined(__WXWINCE__)
410 strDir = wxT("\\");
411 #else
412 strDir.clear();
413
414 // If we have a valid HOME directory, as is used on many machines that
415 // have unix utilities on them, we should use that.
416 const wxChar *szHome = wxGetenv(wxT("HOME"));
417
418 if ( szHome != NULL )
419 {
420 strDir = szHome;
421 }
422 else // no HOME, try HOMEDRIVE/PATH
423 {
424 szHome = wxGetenv(wxT("HOMEDRIVE"));
425 if ( szHome != NULL )
426 strDir << szHome;
427 szHome = wxGetenv(wxT("HOMEPATH"));
428
429 if ( szHome != NULL )
430 {
431 strDir << szHome;
432
433 // the idea is that under NT these variables have default values
434 // of "%systemdrive%:" and "\\". As we don't want to create our
435 // config files in the root directory of the system drive, we will
436 // create it in our program's dir. However, if the user took care
437 // to set HOMEPATH to something other than "\\", we suppose that he
438 // knows what he is doing and use the supplied value.
439 if ( wxStrcmp(szHome, wxT("\\")) == 0 )
440 strDir.clear();
441 }
442 }
443
444 if ( strDir.empty() )
445 {
446 // If we have a valid USERPROFILE directory, as is the case in
447 // Windows NT, 2000 and XP, we should use that as our home directory.
448 szHome = wxGetenv(wxT("USERPROFILE"));
449
450 if ( szHome != NULL )
451 strDir = szHome;
452 }
453
454 if ( !strDir.empty() )
455 {
456 // sometimes the value of HOME may be "%USERPROFILE%", so reexpand the
457 // value once again, it shouldn't hurt anyhow
458 strDir = wxExpandEnvVars(strDir);
459 }
460 else // fall back to the program directory
461 {
462 // extract the directory component of the program file name
463 wxSplitPath(wxGetFullModuleName(), &strDir, NULL, NULL);
464 }
465 #endif // UNIX/Win
466
467 return strDir.c_str();
468 }
469
470 wxChar *wxGetUserHome(const wxString& WXUNUSED(user))
471 {
472 // VZ: the old code here never worked for user != "" anyhow! Moreover, it
473 // returned sometimes a malloc()'d pointer, sometimes a pointer to a
474 // static buffer and sometimes I don't even know what.
475 static wxString s_home;
476
477 return (wxChar *)wxGetHomeDir(&s_home);
478 }
479
480 bool wxGetDiskSpace(const wxString& WXUNUSED_IN_WINCE(path),
481 wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pTotal),
482 wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pFree))
483 {
484 #ifdef __WXWINCE__
485 // TODO-CE
486 return false;
487 #else
488 if ( path.empty() )
489 return false;
490
491 // old w32api don't have ULARGE_INTEGER
492 #if defined(__WIN32__) && \
493 (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION( 0, 3 ))
494 // GetDiskFreeSpaceEx() is not available under original Win95, check for
495 // it
496 typedef BOOL (WINAPI *GetDiskFreeSpaceEx_t)(LPCTSTR,
497 PULARGE_INTEGER,
498 PULARGE_INTEGER,
499 PULARGE_INTEGER);
500
501 GetDiskFreeSpaceEx_t
502 pGetDiskFreeSpaceEx = (GetDiskFreeSpaceEx_t)::GetProcAddress
503 (
504 ::GetModuleHandle(_T("kernel32.dll")),
505 #if wxUSE_UNICODE
506 "GetDiskFreeSpaceExW"
507 #else
508 "GetDiskFreeSpaceExA"
509 #endif
510 );
511
512 if ( pGetDiskFreeSpaceEx )
513 {
514 ULARGE_INTEGER bytesFree, bytesTotal;
515
516 // may pass the path as is, GetDiskFreeSpaceEx() is smart enough
517 if ( !pGetDiskFreeSpaceEx(path,
518 &bytesFree,
519 &bytesTotal,
520 NULL) )
521 {
522 wxLogLastError(_T("GetDiskFreeSpaceEx"));
523
524 return false;
525 }
526
527 // ULARGE_INTEGER is a union of a 64 bit value and a struct containing
528 // two 32 bit fields which may be or may be not named - try to make it
529 // compile in all cases
530 #if defined(__BORLANDC__) && !defined(_ANONYMOUS_STRUCT)
531 #define UL(ul) ul.u
532 #else // anon union
533 #define UL(ul) ul
534 #endif
535 if ( pTotal )
536 {
537 #if wxUSE_LONGLONG
538 *pTotal = wxDiskspaceSize_t(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart);
539 #else
540 *pTotal = wxDiskspaceSize_t(UL(bytesTotal).LowPart);
541 #endif
542 }
543
544 if ( pFree )
545 {
546 #if wxUSE_LONGLONG
547 *pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);
548 #else
549 *pFree = wxDiskspaceSize_t(UL(bytesFree).LowPart);
550 #endif
551 }
552 }
553 else
554 #endif // Win32
555 {
556 // there's a problem with drives larger than 2GB, GetDiskFreeSpaceEx()
557 // should be used instead - but if it's not available, fall back on
558 // GetDiskFreeSpace() nevertheless...
559
560 DWORD lSectorsPerCluster,
561 lBytesPerSector,
562 lNumberOfFreeClusters,
563 lTotalNumberOfClusters;
564
565 // FIXME: this is wrong, we should extract the root drive from path
566 // instead, but this is the job for wxFileName...
567 if ( !::GetDiskFreeSpace(path,
568 &lSectorsPerCluster,
569 &lBytesPerSector,
570 &lNumberOfFreeClusters,
571 &lTotalNumberOfClusters) )
572 {
573 wxLogLastError(_T("GetDiskFreeSpace"));
574
575 return false;
576 }
577
578 wxDiskspaceSize_t lBytesPerCluster = (wxDiskspaceSize_t) lSectorsPerCluster;
579 lBytesPerCluster *= lBytesPerSector;
580
581 if ( pTotal )
582 {
583 *pTotal = lBytesPerCluster;
584 *pTotal *= lTotalNumberOfClusters;
585 }
586
587 if ( pFree )
588 {
589 *pFree = lBytesPerCluster;
590 *pFree *= lNumberOfFreeClusters;
591 }
592 }
593
594 return true;
595 #endif
596 // __WXWINCE__
597 }
598
599 // ----------------------------------------------------------------------------
600 // env vars
601 // ----------------------------------------------------------------------------
602
603 bool wxGetEnv(const wxString& WXUNUSED_IN_WINCE(var),
604 wxString *WXUNUSED_IN_WINCE(value))
605 {
606 #ifdef __WXWINCE__
607 // no environment variables under CE
608 return false;
609 #else // Win32
610 // first get the size of the buffer
611 DWORD dwRet = ::GetEnvironmentVariable(var, NULL, 0);
612 if ( !dwRet )
613 {
614 // this means that there is no such variable
615 return false;
616 }
617
618 if ( value )
619 {
620 (void)::GetEnvironmentVariable(var, wxStringBuffer(*value, dwRet),
621 dwRet);
622 }
623
624 return true;
625 #endif // WinCE/32
626 }
627
628 bool wxDoSetEnv(const wxString& WXUNUSED_IN_WINCE(var),
629 const wxChar *WXUNUSED_IN_WINCE(value))
630 {
631 // some compilers have putenv() or _putenv() or _wputenv() but it's better
632 // to always use Win32 function directly instead of dealing with them
633 #ifdef __WXWINCE__
634 // no environment variables under CE
635 return false;
636 #else
637 if ( !::SetEnvironmentVariable(var.wx_str(), value) )
638 {
639 wxLogLastError(_T("SetEnvironmentVariable"));
640
641 return false;
642 }
643
644 return true;
645 #endif
646 }
647
648 bool wxSetEnv(const wxString& variable, const wxString& value)
649 {
650 return wxDoSetEnv(variable, value.wx_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 DECLARE_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(_T("PostMessage(WM_QUIT)"));
776 }
777 }
778 else // it was an error then
779 {
780 wxLogLastError(_T("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(_T("GetExitCodeProcess"));
808 }
809 break;
810
811 default:
812 wxFAIL_MSG( _T("unexpected WaitForSingleObject() return") );
813 // fall through
814
815 case WAIT_FAILED:
816 wxLogLastError(_T("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(_T("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(_T("CreateToolhelp32Snapshot"));
871
872 lpfProcess32First =
873 (Process32_t)dllKernel.RawGetSymbol(_T("Process32First"));
874
875 lpfProcess32Next =
876 (Process32_t)dllKernel.RawGetSymbol(_T("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(wxShutdownFlags WXUNUSED_IN_WINCE(wFlags))
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 ::LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME,
976 &tkp.Privileges[0].Luid);
977
978 tkp.PrivilegeCount = 1; // one privilege to set
979 tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
980
981 // Get the shutdown privilege for this process.
982 ::AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,
983 (PTOKEN_PRIVILEGES)NULL, 0);
984
985 // Cannot test the return value of AdjustTokenPrivileges.
986 bOK = ::GetLastError() == ERROR_SUCCESS;
987 }
988 }
989
990 if ( bOK )
991 {
992 UINT flags = EWX_SHUTDOWN | EWX_FORCE;
993 switch ( wFlags )
994 {
995 case wxSHUTDOWN_POWEROFF:
996 flags |= EWX_POWEROFF;
997 break;
998
999 case wxSHUTDOWN_REBOOT:
1000 flags |= EWX_REBOOT;
1001 break;
1002
1003 default:
1004 wxFAIL_MSG( _T("unknown wxShutdown() flag") );
1005 return false;
1006 }
1007
1008 bOK = ::ExitWindowsEx(flags, 0) != 0;
1009 }
1010
1011 return bOK;
1012 #endif // Win32/16
1013 }
1014
1015 // ----------------------------------------------------------------------------
1016 // misc
1017 // ----------------------------------------------------------------------------
1018
1019 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
1020 wxMemorySize wxGetFreeMemory()
1021 {
1022 #if defined(__WIN64__)
1023 MEMORYSTATUSEX memStatex;
1024 memStatex.dwLength = sizeof (memStatex);
1025 ::GlobalMemoryStatusEx (&memStatex);
1026 return (wxMemorySize)memStatex.ullAvailPhys;
1027 #else /* if defined(__WIN32__) */
1028 MEMORYSTATUS memStatus;
1029 memStatus.dwLength = sizeof(MEMORYSTATUS);
1030 ::GlobalMemoryStatus(&memStatus);
1031 return (wxMemorySize)memStatus.dwAvailPhys;
1032 #endif
1033 }
1034
1035 unsigned long wxGetProcessId()
1036 {
1037 return ::GetCurrentProcessId();
1038 }
1039
1040 // Emit a beeeeeep
1041 void wxBell()
1042 {
1043 ::MessageBeep((UINT)-1); // default sound
1044 }
1045
1046 bool wxIsDebuggerRunning()
1047 {
1048 #if wxUSE_DYNLIB_CLASS
1049 // IsDebuggerPresent() is not available under Win95, so load it dynamically
1050 wxDynamicLibrary dll(_T("kernel32.dll"), wxDL_VERBATIM);
1051
1052 typedef BOOL (WINAPI *IsDebuggerPresent_t)();
1053 if ( !dll.HasSymbol(_T("IsDebuggerPresent")) )
1054 {
1055 // no way to know, assume no
1056 return false;
1057 }
1058
1059 return (*(IsDebuggerPresent_t)dll.GetSymbol(_T("IsDebuggerPresent")))() != 0;
1060 #else
1061 return false;
1062 #endif
1063 }
1064
1065 // ----------------------------------------------------------------------------
1066 // OS version
1067 // ----------------------------------------------------------------------------
1068
1069 wxString wxGetOsDescription()
1070 {
1071 wxString str;
1072
1073 OSVERSIONINFO info;
1074 wxZeroMemory(info);
1075
1076 info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1077 if ( ::GetVersionEx(&info) )
1078 {
1079 switch ( info.dwPlatformId )
1080 {
1081 #ifdef VER_PLATFORM_WIN32_CE
1082 case VER_PLATFORM_WIN32_CE:
1083 str.Printf(_("Windows CE (%d.%d)"),
1084 info.dwMajorVersion,
1085 info.dwMinorVersion);
1086 break;
1087 #endif
1088 case VER_PLATFORM_WIN32s:
1089 str = _("Win32s on Windows 3.1");
1090 break;
1091
1092 case VER_PLATFORM_WIN32_WINDOWS:
1093 switch (info.dwMinorVersion)
1094 {
1095 case 0:
1096 if ( info.szCSDVersion[1] == 'B' ||
1097 info.szCSDVersion[1] == 'C' )
1098 {
1099 str = _("Windows 95 OSR2");
1100 }
1101 else
1102 {
1103 str = _("Windows 95");
1104 }
1105 break;
1106 case 10:
1107 if ( info.szCSDVersion[1] == 'B' ||
1108 info.szCSDVersion[1] == 'C' )
1109 {
1110 str = _("Windows 98 SE");
1111 }
1112 else
1113 {
1114 str = _("Windows 98");
1115 }
1116 break;
1117 case 90:
1118 str = _("Windows ME");
1119 break;
1120 default:
1121 str.Printf(_("Windows 9x (%d.%d)"),
1122 info.dwMajorVersion,
1123 info.dwMinorVersion);
1124 break;
1125 }
1126 if ( !wxIsEmpty(info.szCSDVersion) )
1127 {
1128 str << _T(" (") << info.szCSDVersion << _T(')');
1129 }
1130 break;
1131
1132 case VER_PLATFORM_WIN32_NT:
1133 if ( info.dwMajorVersion == 5 )
1134 {
1135 switch ( info.dwMinorVersion )
1136 {
1137 case 0:
1138 str.Printf(_("Windows 2000 (build %lu"),
1139 info.dwBuildNumber);
1140 break;
1141 case 1:
1142 str.Printf(_("Windows XP (build %lu"),
1143 info.dwBuildNumber);
1144 break;
1145 case 2:
1146 str.Printf(_("Windows Server 2003 (build %lu"),
1147 info.dwBuildNumber);
1148 break;
1149 }
1150 }
1151 if ( str.empty() )
1152 {
1153 str.Printf(_("Windows NT %lu.%lu (build %lu"),
1154 info.dwMajorVersion,
1155 info.dwMinorVersion,
1156 info.dwBuildNumber);
1157 }
1158 if ( !wxIsEmpty(info.szCSDVersion) )
1159 {
1160 str << _T(", ") << info.szCSDVersion;
1161 }
1162 str << _T(')');
1163 break;
1164 }
1165 }
1166 else
1167 {
1168 wxFAIL_MSG( _T("GetVersionEx() failed") ); // should never happen
1169 }
1170
1171 return str;
1172 }
1173
1174 bool wxIsPlatform64Bit()
1175 {
1176 #if defined(_WIN64)
1177 return true; // 64-bit programs run only on Win64
1178 #else // Win32
1179 // 32-bit programs run on both 32-bit and 64-bit Windows so check
1180 typedef BOOL (WINAPI *IsWow64Process_t)(HANDLE, BOOL *);
1181
1182 wxDynamicLibrary dllKernel32(_T("kernel32.dll"));
1183 IsWow64Process_t pfnIsWow64Process =
1184 (IsWow64Process_t)dllKernel32.RawGetSymbol(_T("IsWow64Process"));
1185
1186 BOOL wow64 = FALSE;
1187 if ( pfnIsWow64Process )
1188 {
1189 pfnIsWow64Process(::GetCurrentProcess(), &wow64);
1190 }
1191 //else: running under a system without Win64 support
1192
1193 return wow64 != FALSE;
1194 #endif // Win64/Win32
1195 }
1196
1197 wxOperatingSystemId wxGetOsVersion(int *verMaj, int *verMin)
1198 {
1199 OSVERSIONINFO info;
1200 wxZeroMemory(info);
1201
1202 info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1203 if ( ::GetVersionEx(&info) )
1204 {
1205 if (verMaj) *verMaj = info.dwMajorVersion;
1206 if (verMin) *verMin = info.dwMinorVersion;
1207 }
1208
1209 #if defined( __WXWINCE__ )
1210 return wxOS_WINDOWS_CE;
1211 #elif defined( __WXMICROWIN__ )
1212 return wxOS_WINDOWS_MICRO;
1213 #else
1214 switch ( info.dwPlatformId )
1215 {
1216 case VER_PLATFORM_WIN32_NT:
1217 return wxOS_WINDOWS_NT;
1218
1219 case VER_PLATFORM_WIN32_WINDOWS:
1220 return wxOS_WINDOWS_9X;
1221 }
1222
1223 return wxOS_UNKNOWN;
1224 #endif
1225 }
1226
1227 wxWinVersion wxGetWinVersion()
1228 {
1229 int verMaj,
1230 verMin;
1231 switch ( wxGetOsVersion(&verMaj, &verMin) )
1232 {
1233 case wxOS_WINDOWS_9X:
1234 if ( verMaj == 4 )
1235 {
1236 switch ( verMin )
1237 {
1238 case 0:
1239 return wxWinVersion_95;
1240
1241 case 10:
1242 return wxWinVersion_98;
1243
1244 case 90:
1245 return wxWinVersion_ME;
1246 }
1247 }
1248 break;
1249
1250 case wxOS_WINDOWS_NT:
1251 switch ( verMaj )
1252 {
1253 case 3:
1254 return wxWinVersion_NT3;
1255
1256 case 4:
1257 return wxWinVersion_NT4;
1258
1259 case 5:
1260 switch ( verMin )
1261 {
1262 case 0:
1263 return wxWinVersion_2000;
1264
1265 case 1:
1266 return wxWinVersion_XP;
1267
1268 case 2:
1269 return wxWinVersion_2003;
1270 }
1271 break;
1272
1273 case 6:
1274 return wxWinVersion_NT6;
1275 }
1276 break;
1277
1278 default:
1279 // Do nothing just to silence GCC warning
1280 break;
1281 }
1282
1283 return wxWinVersion_Unknown;
1284 }
1285
1286 // ----------------------------------------------------------------------------
1287 // sleep functions
1288 // ----------------------------------------------------------------------------
1289
1290 void wxMilliSleep(unsigned long milliseconds)
1291 {
1292 ::Sleep(milliseconds);
1293 }
1294
1295 void wxMicroSleep(unsigned long microseconds)
1296 {
1297 wxMilliSleep(microseconds/1000);
1298 }
1299
1300 void wxSleep(int nSecs)
1301 {
1302 wxMilliSleep(1000*nSecs);
1303 }
1304
1305 // ----------------------------------------------------------------------------
1306 // font encoding <-> Win32 codepage conversion functions
1307 // ----------------------------------------------------------------------------
1308
1309 extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)
1310 {
1311 switch ( encoding )
1312 {
1313 // although this function is supposed to return an exact match, do do
1314 // some mappings here for the most common case of "standard" encoding
1315 case wxFONTENCODING_SYSTEM:
1316 return DEFAULT_CHARSET;
1317
1318 case wxFONTENCODING_ISO8859_1:
1319 case wxFONTENCODING_ISO8859_15:
1320 case wxFONTENCODING_CP1252:
1321 return ANSI_CHARSET;
1322
1323 #if !defined(__WXMICROWIN__)
1324 // The following four fonts are multi-byte charsets
1325 case wxFONTENCODING_CP932:
1326 return SHIFTJIS_CHARSET;
1327
1328 case wxFONTENCODING_CP936:
1329 return GB2312_CHARSET;
1330
1331 #ifndef __WXWINCE__
1332 case wxFONTENCODING_CP949:
1333 return HANGUL_CHARSET;
1334 #endif
1335
1336 case wxFONTENCODING_CP950:
1337 return CHINESEBIG5_CHARSET;
1338
1339 // The rest are single byte encodings
1340 case wxFONTENCODING_CP1250:
1341 return EASTEUROPE_CHARSET;
1342
1343 case wxFONTENCODING_CP1251:
1344 return RUSSIAN_CHARSET;
1345
1346 case wxFONTENCODING_CP1253:
1347 return GREEK_CHARSET;
1348
1349 case wxFONTENCODING_CP1254:
1350 return TURKISH_CHARSET;
1351
1352 case wxFONTENCODING_CP1255:
1353 return HEBREW_CHARSET;
1354
1355 case wxFONTENCODING_CP1256:
1356 return ARABIC_CHARSET;
1357
1358 case wxFONTENCODING_CP1257:
1359 return BALTIC_CHARSET;
1360
1361 case wxFONTENCODING_CP874:
1362 return THAI_CHARSET;
1363 #endif // !__WXMICROWIN__
1364
1365 case wxFONTENCODING_CP437:
1366 return OEM_CHARSET;
1367
1368 default:
1369 // no way to translate this encoding into a Windows charset
1370 return -1;
1371 }
1372 }
1373
1374 // we have 2 versions of wxCharsetToCodepage(): the old one which directly
1375 // looks up the vlaues in the registry and the new one which is more
1376 // politically correct and has more chances to work on other Windows versions
1377 // as well but the old version is still needed for !wxUSE_FONTMAP case
1378 #if wxUSE_FONTMAP
1379
1380 #include "wx/fontmap.h"
1381
1382 extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
1383 {
1384 // There don't seem to be symbolic names for
1385 // these under Windows so I just copied the
1386 // values from MSDN.
1387
1388 unsigned int ret;
1389
1390 switch (encoding)
1391 {
1392 case wxFONTENCODING_ISO8859_1: ret = 28591; break;
1393 case wxFONTENCODING_ISO8859_2: ret = 28592; break;
1394 case wxFONTENCODING_ISO8859_3: ret = 28593; break;
1395 case wxFONTENCODING_ISO8859_4: ret = 28594; break;
1396 case wxFONTENCODING_ISO8859_5: ret = 28595; break;
1397 case wxFONTENCODING_ISO8859_6: ret = 28596; break;
1398 case wxFONTENCODING_ISO8859_7: ret = 28597; break;
1399 case wxFONTENCODING_ISO8859_8: ret = 28598; break;
1400 case wxFONTENCODING_ISO8859_9: ret = 28599; break;
1401 case wxFONTENCODING_ISO8859_10: ret = 28600; break;
1402 case wxFONTENCODING_ISO8859_11: ret = 874; break;
1403 // case wxFONTENCODING_ISO8859_12, // doesn't exist currently, but put it
1404 case wxFONTENCODING_ISO8859_13: ret = 28603; break;
1405 // case wxFONTENCODING_ISO8859_14: ret = 28604; break; // no correspondence on Windows
1406 case wxFONTENCODING_ISO8859_15: ret = 28605; break;
1407 case wxFONTENCODING_KOI8: ret = 20866; break;
1408 case wxFONTENCODING_KOI8_U: ret = 21866; break;
1409 case wxFONTENCODING_CP437: ret = 437; break;
1410 case wxFONTENCODING_CP850: ret = 850; break;
1411 case wxFONTENCODING_CP852: ret = 852; break;
1412 case wxFONTENCODING_CP855: ret = 855; break;
1413 case wxFONTENCODING_CP866: ret = 866; break;
1414 case wxFONTENCODING_CP874: ret = 874; break;
1415 case wxFONTENCODING_CP932: ret = 932; break;
1416 case wxFONTENCODING_CP936: ret = 936; break;
1417 case wxFONTENCODING_CP949: ret = 949; break;
1418 case wxFONTENCODING_CP950: ret = 950; break;
1419 case wxFONTENCODING_CP1250: ret = 1250; break;
1420 case wxFONTENCODING_CP1251: ret = 1251; break;
1421 case wxFONTENCODING_CP1252: ret = 1252; break;
1422 case wxFONTENCODING_CP1253: ret = 1253; break;
1423 case wxFONTENCODING_CP1254: ret = 1254; break;
1424 case wxFONTENCODING_CP1255: ret = 1255; break;
1425 case wxFONTENCODING_CP1256: ret = 1256; break;
1426 case wxFONTENCODING_CP1257: ret = 1257; break;
1427 case wxFONTENCODING_EUC_JP: ret = 20932; break;
1428 case wxFONTENCODING_MACROMAN: ret = 10000; break;
1429 case wxFONTENCODING_MACJAPANESE: ret = 10001; break;
1430 case wxFONTENCODING_MACCHINESETRAD: ret = 10002; break;
1431 case wxFONTENCODING_MACKOREAN: ret = 10003; break;
1432 case wxFONTENCODING_MACARABIC: ret = 10004; break;
1433 case wxFONTENCODING_MACHEBREW: ret = 10005; break;
1434 case wxFONTENCODING_MACGREEK: ret = 10006; break;
1435 case wxFONTENCODING_MACCYRILLIC: ret = 10007; break;
1436 case wxFONTENCODING_MACTHAI: ret = 10021; break;
1437 case wxFONTENCODING_MACCHINESESIMP: ret = 10008; break;
1438 case wxFONTENCODING_MACCENTRALEUR: ret = 10029; break;
1439 case wxFONTENCODING_MACCROATIAN: ret = 10082; break;
1440 case wxFONTENCODING_MACICELANDIC: ret = 10079; break;
1441 case wxFONTENCODING_MACROMANIAN: ret = 10009; break;
1442 case wxFONTENCODING_UTF7: ret = 65000; break;
1443 case wxFONTENCODING_UTF8: ret = 65001; break;
1444 default: return -1;
1445 }
1446
1447 if (::IsValidCodePage(ret) == 0)
1448 return -1;
1449
1450 CPINFO info;
1451 if (::GetCPInfo(ret, &info) == 0)
1452 return -1;
1453
1454 return (long) ret;
1455 }
1456
1457 extern long wxCharsetToCodepage(const char *name)
1458 {
1459 // first get the font encoding for this charset
1460 if ( !name )
1461 return -1;
1462
1463 wxFontEncoding enc = wxFontMapperBase::Get()->CharsetToEncoding(name, false);
1464 if ( enc == wxFONTENCODING_SYSTEM )
1465 return -1;
1466
1467 // the use the helper function
1468 return wxEncodingToCodepage(enc);
1469 }
1470
1471 #else // !wxUSE_FONTMAP
1472
1473 #include "wx/msw/registry.h"
1474
1475 // this should work if Internet Exploiter is installed
1476 extern long wxCharsetToCodepage(const char *name)
1477 {
1478 if (!name)
1479 return GetACP();
1480
1481 long CP = -1;
1482
1483 wxString path(wxT("MIME\\Database\\Charset\\"));
1484 wxString cn(name);
1485
1486 // follow the alias loop
1487 for ( ;; )
1488 {
1489 wxRegKey key(wxRegKey::HKCR, path + cn);
1490
1491 if (!key.Exists())
1492 break;
1493
1494 // two cases: either there's an AliasForCharset string,
1495 // or there are Codepage and InternetEncoding dwords.
1496 // The InternetEncoding gives us the actual encoding,
1497 // the Codepage just says which Windows character set to
1498 // use when displaying the data.
1499 if (key.HasValue(wxT("InternetEncoding")) &&
1500 key.QueryValue(wxT("InternetEncoding"), &CP))
1501 break;
1502
1503 // no encoding, see if it's an alias
1504 if (!key.HasValue(wxT("AliasForCharset")) ||
1505 !key.QueryValue(wxT("AliasForCharset"), cn))
1506 break;
1507 }
1508
1509 return CP;
1510 }
1511
1512 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
1513
1514 /*
1515 Creates a hidden window with supplied window proc registering the class for
1516 it if necesssary (i.e. the first time only). Caller is responsible for
1517 destroying the window and unregistering the class (note that this must be
1518 done because wxWidgets may be used as a DLL and so may be loaded/unloaded
1519 multiple times into/from the same process so we cna't rely on automatic
1520 Windows class unregistration).
1521
1522 pclassname is a pointer to a caller stored classname, which must initially be
1523 NULL. classname is the desired wndclass classname. If function successfully
1524 registers the class, pclassname will be set to classname.
1525 */
1526 extern "C" WXDLLIMPEXP_BASE HWND
1527 wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc)
1528 {
1529 wxCHECK_MSG( classname && pclassname && wndproc, NULL,
1530 _T("NULL parameter in wxCreateHiddenWindow") );
1531
1532 // register the class fi we need to first
1533 if ( *pclassname == NULL )
1534 {
1535 WNDCLASS wndclass;
1536 wxZeroMemory(wndclass);
1537
1538 wndclass.lpfnWndProc = wndproc;
1539 wndclass.hInstance = wxGetInstance();
1540 wndclass.lpszClassName = classname;
1541
1542 if ( !::RegisterClass(&wndclass) )
1543 {
1544 wxLogLastError(wxT("RegisterClass() in wxCreateHiddenWindow"));
1545
1546 return NULL;
1547 }
1548
1549 *pclassname = classname;
1550 }
1551
1552 // next create the window
1553 HWND hwnd = ::CreateWindow
1554 (
1555 *pclassname,
1556 NULL,
1557 0, 0, 0, 0,
1558 0,
1559 (HWND) NULL,
1560 (HMENU)NULL,
1561 wxGetInstance(),
1562 (LPVOID) NULL
1563 );
1564
1565 if ( !hwnd )
1566 {
1567 wxLogLastError(wxT("CreateWindow() in wxCreateHiddenWindow"));
1568 }
1569
1570 return hwnd;
1571 }
wxWidgets (Impactor)