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


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