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