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


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