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