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