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