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