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