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