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