]>
Commit | Line | Data |
---|---|---|
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 and Markus Holzem | |
9 | // Licence: wxWindows license | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
20 | #ifdef __GNUG__ | |
21 | // #pragma implementation "utils.h" // Note: this is done in utilscmn.cpp now. | |
22 | #endif | |
23 | ||
24 | // For compilers that support precompilation, includes "wx.h". | |
25 | #include "wx/wxprec.h" | |
26 | ||
27 | #ifdef __BORLANDC__ | |
28 | #pragma hdrstop | |
29 | #endif | |
30 | ||
31 | #ifndef WX_PRECOMP | |
32 | #include "wx/utils.h" | |
33 | #include "wx/app.h" | |
34 | #include "wx/cursor.h" | |
35 | #endif //WX_PRECOMP | |
36 | ||
37 | #include "wx/msw/private.h" // includes <windows.h> | |
38 | ||
39 | #include "wx/timer.h" | |
40 | #include "wx/intl.h" | |
41 | ||
42 | #include <ctype.h> | |
43 | ||
44 | #if !defined(__GNUWIN32__) && !defined(__WXWINE__) && !defined(__SALFORDC__) | |
45 | #include <direct.h> | |
46 | ||
47 | #ifndef __MWERKS__ | |
48 | #include <dos.h> | |
49 | #endif | |
50 | #endif //GNUWIN32 | |
51 | ||
52 | #if defined(__GNUWIN32__) && !defined(__TWIN32__) | |
53 | #include <sys/unistd.h> | |
54 | #include <sys/stat.h> | |
55 | #endif //GNUWIN32 | |
56 | ||
57 | #include "wx/log.h" | |
58 | ||
59 | #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs | |
60 | // this (3.1 I believe) and how to test for it. | |
61 | // If this works for Borland 4.0 as well, then no worries. | |
62 | #include <dir.h> | |
63 | #endif | |
64 | ||
65 | // VZ: there is some code using NetXXX() functions to get the full user name: | |
66 | // I don't think it's a good idea because they don't work under Win95 and | |
67 | // seem to return the same as wxGetUserId() under NT. If you really want | |
68 | // to use them, just #define USE_NET_API | |
69 | #undef USE_NET_API | |
70 | ||
71 | #ifdef USE_NET_API | |
72 | #include <lm.h> | |
73 | #endif // USE_NET_API | |
74 | ||
75 | #if defined(__WIN32__) && !defined(__WXWINE__) | |
76 | #include <io.h> | |
77 | ||
78 | #ifndef __GNUWIN32__ | |
79 | #include <shellapi.h> | |
80 | #endif | |
81 | #endif | |
82 | ||
83 | #include <stdio.h> | |
84 | #include <stdlib.h> | |
85 | #include <string.h> | |
86 | #ifndef __WATCOMC__ | |
87 | #if !(defined(_MSC_VER) && (_MSC_VER > 800)) | |
88 | #include <errno.h> | |
89 | #endif | |
90 | #endif | |
91 | #include <stdarg.h> | |
92 | ||
93 | //// BEGIN for console support: VC++ only | |
94 | #ifdef __VISUALC__ | |
95 | ||
96 | #include "wx/msw/msvcrt.h" | |
97 | ||
98 | #include <fcntl.h> | |
99 | ||
100 | #include "wx/ioswrap.h" | |
101 | ||
102 | #if wxUSE_IOSTREAMH | |
103 | // N.B. BC++ doesn't have istream.h, ostream.h | |
104 | # include <io.h> | |
105 | # include <fstream.h> | |
106 | #else | |
107 | # include <fstream> | |
108 | #endif | |
109 | ||
110 | /* Need to undef new if including crtdbg.h */ | |
111 | # ifdef new | |
112 | # undef new | |
113 | # endif | |
114 | ||
115 | #ifndef __WIN16__ | |
116 | # include <crtdbg.h> | |
117 | #endif | |
118 | ||
119 | # if defined(__WXDEBUG__) && wxUSE_GLOBAL_MEMORY_OPERATORS && wxUSE_DEBUG_NEW_ALWAYS | |
120 | # define new new(__FILE__,__LINE__) | |
121 | # endif | |
122 | ||
123 | #endif | |
124 | // __VISUALC__ | |
125 | /// END for console support | |
126 | ||
127 | // ---------------------------------------------------------------------------- | |
128 | // constants | |
129 | // ---------------------------------------------------------------------------- | |
130 | ||
131 | // In the WIN.INI file | |
132 | static const wxChar WX_SECTION[] = wxT("wxWindows"); | |
133 | static const wxChar eUSERNAME[] = wxT("UserName"); | |
134 | ||
135 | // these are only used under Win16 | |
136 | #ifndef __WIN32__ | |
137 | static const wxChar eHOSTNAME[] = wxT("HostName"); | |
138 | static const wxChar eUSERID[] = wxT("UserId"); | |
139 | #endif // !Win32 | |
140 | ||
141 | // ============================================================================ | |
142 | // implementation | |
143 | // ============================================================================ | |
144 | ||
145 | // ---------------------------------------------------------------------------- | |
146 | // get host name and related | |
147 | // ---------------------------------------------------------------------------- | |
148 | ||
149 | // Get full hostname (eg. DoDo.BSn-Germany.crg.de) | |
150 | bool wxGetHostName(wxChar *buf, int maxSize) | |
151 | { | |
152 | #if defined(__WIN32__) && !defined(__TWIN32__) | |
153 | // TODO should use GetComputerNameEx() when available | |
154 | ||
155 | DWORD nSize = maxSize; | |
156 | if ( !::GetComputerName(buf, &nSize) ) | |
157 | { | |
158 | wxLogLastError("GetComputerName"); | |
159 | ||
160 | return FALSE; | |
161 | } | |
162 | ||
163 | return TRUE; | |
164 | #else | |
165 | wxChar *sysname; | |
166 | const wxChar *default_host = wxT("noname"); | |
167 | ||
168 | if ((sysname = wxGetenv(wxT("SYSTEM_NAME"))) == NULL) { | |
169 | GetProfileString(WX_SECTION, eHOSTNAME, default_host, buf, maxSize - 1); | |
170 | } else | |
171 | wxStrncpy(buf, sysname, maxSize - 1); | |
172 | buf[maxSize] = wxT('\0'); | |
173 | return *buf ? TRUE : FALSE; | |
174 | #endif | |
175 | } | |
176 | ||
177 | bool wxGetFullHostName(wxChar *buf, int maxSize) | |
178 | { | |
179 | return wxGetHostName(buf, maxSize); | |
180 | } | |
181 | ||
182 | // Get user ID e.g. jacs | |
183 | bool wxGetUserId(wxChar *buf, int maxSize) | |
184 | { | |
185 | #if defined(__WIN32__) && !defined(__win32s__) && !defined(__TWIN32__) | |
186 | DWORD nSize = maxSize; | |
187 | if ( ::GetUserName(buf, &nSize) == 0 ) | |
188 | { | |
189 | // actually, it does happen on Win9x if the user didn't log on | |
190 | DWORD res = ::GetEnvironmentVariable(wxT("username"), buf, maxSize); | |
191 | if ( res == 0 ) | |
192 | { | |
193 | // not found | |
194 | return FALSE; | |
195 | } | |
196 | } | |
197 | ||
198 | return TRUE; | |
199 | #else // Win16 or Win32s | |
200 | wxChar *user; | |
201 | const wxChar *default_id = wxT("anonymous"); | |
202 | ||
203 | // Can't assume we have NIS (PC-NFS) or some other ID daemon | |
204 | // So we ... | |
205 | if ( (user = wxGetenv(wxT("USER"))) == NULL && | |
206 | (user = wxGetenv(wxT("LOGNAME"))) == NULL ) | |
207 | { | |
208 | // Use wxWindows configuration data (comming soon) | |
209 | GetProfileString(WX_SECTION, eUSERID, default_id, buf, maxSize - 1); | |
210 | } | |
211 | else | |
212 | { | |
213 | wxStrncpy(buf, user, maxSize - 1); | |
214 | } | |
215 | ||
216 | return *buf ? TRUE : FALSE; | |
217 | #endif | |
218 | } | |
219 | ||
220 | // Get user name e.g. Julian Smart | |
221 | bool wxGetUserName(wxChar *buf, int maxSize) | |
222 | { | |
223 | #if wxUSE_PENWINDOWS && !defined(__WATCOMC__) && !defined(__GNUWIN32__) | |
224 | extern HANDLE g_hPenWin; // PenWindows Running? | |
225 | if (g_hPenWin) | |
226 | { | |
227 | // PenWindows Does have a user concept! | |
228 | // Get the current owner of the recognizer | |
229 | GetPrivateProfileString("Current", "User", default_name, wxBuffer, maxSize - 1, "PENWIN.INI"); | |
230 | strncpy(buf, wxBuffer, maxSize - 1); | |
231 | } | |
232 | else | |
233 | #endif | |
234 | { | |
235 | #ifdef USE_NET_API | |
236 | CHAR szUserName[256]; | |
237 | if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) ) | |
238 | return FALSE; | |
239 | ||
240 | // TODO how to get the domain name? | |
241 | CHAR *szDomain = ""; | |
242 | ||
243 | // the code is based on the MSDN example (also see KB article Q119670) | |
244 | WCHAR wszUserName[256]; // Unicode user name | |
245 | WCHAR wszDomain[256]; | |
246 | LPBYTE ComputerName; | |
247 | ||
248 | USER_INFO_2 *ui2; // User structure | |
249 | ||
250 | // Convert ANSI user name and domain to Unicode | |
251 | MultiByteToWideChar( CP_ACP, 0, szUserName, strlen(szUserName)+1, | |
252 | wszUserName, WXSIZEOF(wszUserName) ); | |
253 | MultiByteToWideChar( CP_ACP, 0, szDomain, strlen(szDomain)+1, | |
254 | wszDomain, WXSIZEOF(wszDomain) ); | |
255 | ||
256 | // Get the computer name of a DC for the domain. | |
257 | if ( NetGetDCName( NULL, wszDomain, &ComputerName ) != NERR_Success ) | |
258 | { | |
259 | wxLogError(wxT("Can not find domain controller")); | |
260 | ||
261 | goto error; | |
262 | } | |
263 | ||
264 | // Look up the user on the DC | |
265 | NET_API_STATUS status = NetUserGetInfo( (LPWSTR)ComputerName, | |
266 | (LPWSTR)&wszUserName, | |
267 | 2, // level - we want USER_INFO_2 | |
268 | (LPBYTE *) &ui2 ); | |
269 | switch ( status ) | |
270 | { | |
271 | case NERR_Success: | |
272 | // ok | |
273 | break; | |
274 | ||
275 | case NERR_InvalidComputer: | |
276 | wxLogError(wxT("Invalid domain controller name.")); | |
277 | ||
278 | goto error; | |
279 | ||
280 | case NERR_UserNotFound: | |
281 | wxLogError(wxT("Invalid user name '%s'."), szUserName); | |
282 | ||
283 | goto error; | |
284 | ||
285 | default: | |
286 | wxLogSysError(wxT("Can't get information about user")); | |
287 | ||
288 | goto error; | |
289 | } | |
290 | ||
291 | // Convert the Unicode full name to ANSI | |
292 | WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1, | |
293 | buf, maxSize, NULL, NULL ); | |
294 | ||
295 | return TRUE; | |
296 | ||
297 | error: | |
298 | wxLogError(wxT("Couldn't look up full user name.")); | |
299 | ||
300 | return FALSE; | |
301 | #else // !USE_NET_API | |
302 | // Could use NIS, MS-Mail or other site specific programs | |
303 | // Use wxWindows configuration data | |
304 | bool ok = GetProfileString(WX_SECTION, eUSERNAME, wxT(""), buf, maxSize - 1) != 0; | |
305 | if ( !ok ) | |
306 | { | |
307 | ok = wxGetUserId(buf, maxSize); | |
308 | } | |
309 | ||
310 | if ( !ok ) | |
311 | { | |
312 | wxStrncpy(buf, wxT("Unknown User"), maxSize); | |
313 | } | |
314 | #endif // Win32/16 | |
315 | } | |
316 | ||
317 | return TRUE; | |
318 | } | |
319 | ||
320 | const wxChar* wxGetHomeDir(wxString *pstr) | |
321 | { | |
322 | wxString& strDir = *pstr; | |
323 | ||
324 | #if defined(__UNIX__) && !defined(__TWIN32__) | |
325 | const wxChar *szHome = wxGetenv("HOME"); | |
326 | if ( szHome == NULL ) { | |
327 | // we're homeless... | |
328 | wxLogWarning(_("can't find user's HOME, using current directory.")); | |
329 | strDir = wxT("."); | |
330 | } | |
331 | else | |
332 | strDir = szHome; | |
333 | ||
334 | // add a trailing slash if needed | |
335 | if ( strDir.Last() != wxT('/') ) | |
336 | strDir << wxT('/'); | |
337 | #else // Windows | |
338 | #ifdef __WIN32__ | |
339 | const wxChar *szHome = wxGetenv(wxT("HOMEDRIVE")); | |
340 | if ( szHome != NULL ) | |
341 | strDir << szHome; | |
342 | szHome = wxGetenv(wxT("HOMEPATH")); | |
343 | if ( szHome != NULL ) { | |
344 | strDir << szHome; | |
345 | ||
346 | // the idea is that under NT these variables have default values | |
347 | // of "%systemdrive%:" and "\\". As we don't want to create our | |
348 | // config files in the root directory of the system drive, we will | |
349 | // create it in our program's dir. However, if the user took care | |
350 | // to set HOMEPATH to something other than "\\", we suppose that he | |
351 | // knows what he is doing and use the supplied value. | |
352 | if ( wxStrcmp(szHome, wxT("\\")) != 0 ) | |
353 | return strDir.c_str(); | |
354 | } | |
355 | ||
356 | #else // Win16 | |
357 | // Win16 has no idea about home, so use the working directory instead | |
358 | #endif // WIN16/32 | |
359 | ||
360 | // 260 was taken from windef.h | |
361 | #ifndef MAX_PATH | |
362 | #define MAX_PATH 260 | |
363 | #endif | |
364 | ||
365 | wxString strPath; | |
366 | ::GetModuleFileName(::GetModuleHandle(NULL), | |
367 | strPath.GetWriteBuf(MAX_PATH), MAX_PATH); | |
368 | strPath.UngetWriteBuf(); | |
369 | ||
370 | // extract the dir name | |
371 | wxSplitPath(strPath, &strDir, NULL, NULL); | |
372 | ||
373 | #endif // UNIX/Win | |
374 | ||
375 | return strDir.c_str(); | |
376 | } | |
377 | ||
378 | wxChar *wxGetUserHome(const wxString& user) | |
379 | { | |
380 | // VZ: the old code here never worked for user != "" anyhow! Moreover, it | |
381 | // returned sometimes a malloc()'d pointer, sometimes a pointer to a | |
382 | // static buffer and sometimes I don't even know what. | |
383 | static wxString s_home; | |
384 | ||
385 | return (wxChar *)wxGetHomeDir(&s_home); | |
386 | } | |
387 | ||
388 | bool wxDirExists(const wxString& dir) | |
389 | { | |
390 | #if defined(__WIN32__) | |
391 | WIN32_FIND_DATA fileInfo; | |
392 | #else // Win16 | |
393 | #ifdef __BORLANDC__ | |
394 | struct ffblk fileInfo; | |
395 | #else | |
396 | struct find_t fileInfo; | |
397 | #endif | |
398 | #endif // Win32/16 | |
399 | ||
400 | #if defined(__WIN32__) | |
401 | HANDLE h = ::FindFirstFile(dir, &fileInfo); | |
402 | ||
403 | if ( h == INVALID_HANDLE_VALUE ) | |
404 | { | |
405 | wxLogLastError("FindFirstFile"); | |
406 | ||
407 | return FALSE; | |
408 | } | |
409 | ||
410 | ::FindClose(h); | |
411 | ||
412 | return (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0; | |
413 | #else // Win16 | |
414 | // In Borland findfirst has a different argument | |
415 | // ordering from _dos_findfirst. But _dos_findfirst | |
416 | // _should_ be ok in both MS and Borland... why not? | |
417 | #ifdef __BORLANDC__ | |
418 | return (findfirst(dir, &fileInfo, _A_SUBDIR) == 0 && | |
419 | (fileInfo.ff_attrib & _A_SUBDIR) != 0); | |
420 | #else | |
421 | return (_dos_findfirst(dir, _A_SUBDIR, &fileInfo) == 0) && | |
422 | ((fileInfo.attrib & _A_SUBDIR) != 0); | |
423 | #endif | |
424 | #endif // Win32/16 | |
425 | } | |
426 | ||
427 | // ---------------------------------------------------------------------------- | |
428 | // process management | |
429 | // ---------------------------------------------------------------------------- | |
430 | ||
431 | int wxKill(long pid, int sig) | |
432 | { | |
433 | // TODO use SendMessage(WM_QUIT) and TerminateProcess() if needed | |
434 | ||
435 | return 0; | |
436 | } | |
437 | ||
438 | // Execute a program in an Interactive Shell | |
439 | bool wxShell(const wxString& command) | |
440 | { | |
441 | wxChar *shell = wxGetenv(wxT("COMSPEC")); | |
442 | if ( !shell ) | |
443 | shell = wxT("\\COMMAND.COM"); | |
444 | ||
445 | wxString cmd; | |
446 | if ( !command ) | |
447 | { | |
448 | // just the shell | |
449 | cmd = shell; | |
450 | } | |
451 | else | |
452 | { | |
453 | // pass the command to execute to the command processor | |
454 | cmd.Printf(wxT("%s /c %s"), shell, command.c_str()); | |
455 | } | |
456 | ||
457 | return wxExecute(cmd, TRUE /* sync */) != 0; | |
458 | } | |
459 | ||
460 | // ---------------------------------------------------------------------------- | |
461 | // misc | |
462 | // ---------------------------------------------------------------------------- | |
463 | ||
464 | // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX) | |
465 | long wxGetFreeMemory() | |
466 | { | |
467 | #if defined(__WIN32__) && !defined(__BORLANDC__) && !defined(__TWIN32__) | |
468 | MEMORYSTATUS memStatus; | |
469 | memStatus.dwLength = sizeof(MEMORYSTATUS); | |
470 | GlobalMemoryStatus(&memStatus); | |
471 | return memStatus.dwAvailPhys; | |
472 | #else | |
473 | return (long)GetFreeSpace(0); | |
474 | #endif | |
475 | } | |
476 | ||
477 | // Emit a beeeeeep | |
478 | void wxBell() | |
479 | { | |
480 | ::MessageBeep((UINT)-1); // default sound | |
481 | } | |
482 | ||
483 | wxString wxGetOsDescription() | |
484 | { | |
485 | #ifdef __WIN32__ | |
486 | wxString str; | |
487 | ||
488 | OSVERSIONINFO info; | |
489 | wxZeroMemory(info); | |
490 | ||
491 | info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); | |
492 | if ( ::GetVersionEx(&info) ) | |
493 | { | |
494 | switch ( info.dwPlatformId ) | |
495 | { | |
496 | case VER_PLATFORM_WIN32s: | |
497 | str = _("Win32s on Windows 3.1"); | |
498 | break; | |
499 | ||
500 | case VER_PLATFORM_WIN32_WINDOWS: | |
501 | str.Printf(_("Windows 9%c"), | |
502 | info.dwMinorVersion == 0 ? _T('5') : _T('9')); | |
503 | if ( !wxIsEmpty(info.szCSDVersion) ) | |
504 | { | |
505 | str << _T(" (") << info.szCSDVersion << _T(')'); | |
506 | } | |
507 | break; | |
508 | ||
509 | case VER_PLATFORM_WIN32_NT: | |
510 | str.Printf(_T("Windows NT %lu.%lu (build %lu"), | |
511 | info.dwMajorVersion, | |
512 | info.dwMinorVersion, | |
513 | info.dwBuildNumber); | |
514 | if ( !wxIsEmpty(info.szCSDVersion) ) | |
515 | { | |
516 | str << _T(", ") << info.szCSDVersion; | |
517 | } | |
518 | str << _T(')'); | |
519 | break; | |
520 | } | |
521 | } | |
522 | else | |
523 | { | |
524 | wxFAIL_MSG( _T("GetVersionEx() failed") ); // should never happen | |
525 | } | |
526 | ||
527 | return str; | |
528 | #else // Win16 | |
529 | return _("Windows 3.1"); | |
530 | #endif // Win32/16 | |
531 | } | |
532 | ||
533 | int wxGetOsVersion(int *majorVsn, int *minorVsn) | |
534 | { | |
535 | #if defined(__WIN32__) && !defined(__SC__) | |
536 | OSVERSIONINFO info; | |
537 | wxZeroMemory(info); | |
538 | ||
539 | info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); | |
540 | if ( ::GetVersionEx(&info) ) | |
541 | { | |
542 | if (majorVsn) | |
543 | *majorVsn = info.dwMajorVersion; | |
544 | if (minorVsn) | |
545 | *minorVsn = info.dwMinorVersion; | |
546 | ||
547 | switch ( info.dwPlatformId ) | |
548 | { | |
549 | case VER_PLATFORM_WIN32s: | |
550 | return wxWIN32S; | |
551 | ||
552 | case VER_PLATFORM_WIN32_WINDOWS: | |
553 | return wxWIN95; | |
554 | ||
555 | case VER_PLATFORM_WIN32_NT: | |
556 | return wxWINDOWS_NT; | |
557 | } | |
558 | } | |
559 | ||
560 | return wxWINDOWS; // error if we get here, return generic value | |
561 | #else // Win16 | |
562 | int retValue = wxWINDOWS; | |
563 | #ifdef __WINDOWS_386__ | |
564 | retValue = wxWIN386; | |
565 | #else | |
566 | #if !defined(__WATCOMC__) && !defined(GNUWIN32) && wxUSE_PENWINDOWS | |
567 | extern HANDLE g_hPenWin; | |
568 | retValue = g_hPenWin ? wxPENWINDOWS : wxWINDOWS; | |
569 | #endif | |
570 | #endif | |
571 | ||
572 | if (majorVsn) | |
573 | *majorVsn = 3; | |
574 | if (minorVsn) | |
575 | *minorVsn = 1; | |
576 | ||
577 | return retValue; | |
578 | #endif | |
579 | } | |
580 | ||
581 | // ---------------------------------------------------------------------------- | |
582 | // sleep functions | |
583 | // ---------------------------------------------------------------------------- | |
584 | ||
585 | #if wxUSE_GUI | |
586 | ||
587 | // Sleep for nSecs seconds. Attempt a Windows implementation using timers. | |
588 | static bool gs_inTimer = FALSE; | |
589 | ||
590 | class wxSleepTimer: public wxTimer | |
591 | { | |
592 | public: | |
593 | virtual void Notify() | |
594 | { | |
595 | gs_inTimer = FALSE; | |
596 | Stop(); | |
597 | } | |
598 | }; | |
599 | ||
600 | static wxTimer *wxTheSleepTimer = NULL; | |
601 | ||
602 | void wxUsleep(unsigned long milliseconds) | |
603 | { | |
604 | #ifdef __WIN32__ | |
605 | ::Sleep(milliseconds); | |
606 | #else | |
607 | if (gs_inTimer) | |
608 | return; | |
609 | ||
610 | wxTheSleepTimer = new wxSleepTimer; | |
611 | gs_inTimer = TRUE; | |
612 | wxTheSleepTimer->Start(milliseconds); | |
613 | while (gs_inTimer) | |
614 | { | |
615 | if (wxTheApp->Pending()) | |
616 | wxTheApp->Dispatch(); | |
617 | } | |
618 | delete wxTheSleepTimer; | |
619 | wxTheSleepTimer = NULL; | |
620 | #endif | |
621 | } | |
622 | ||
623 | void wxSleep(int nSecs) | |
624 | { | |
625 | if (gs_inTimer) | |
626 | return; | |
627 | ||
628 | wxTheSleepTimer = new wxSleepTimer; | |
629 | gs_inTimer = TRUE; | |
630 | wxTheSleepTimer->Start(nSecs*1000); | |
631 | while (gs_inTimer) | |
632 | { | |
633 | if (wxTheApp->Pending()) | |
634 | wxTheApp->Dispatch(); | |
635 | } | |
636 | delete wxTheSleepTimer; | |
637 | wxTheSleepTimer = NULL; | |
638 | } | |
639 | ||
640 | // Consume all events until no more left | |
641 | void wxFlushEvents() | |
642 | { | |
643 | // wxYield(); | |
644 | } | |
645 | ||
646 | #elif defined(__WIN32__) // wxUSE_GUI | |
647 | ||
648 | void wxUsleep(unsigned long milliseconds) | |
649 | { | |
650 | ::Sleep(milliseconds); | |
651 | } | |
652 | ||
653 | void wxSleep(int nSecs) | |
654 | { | |
655 | wxUsleep(1000*nSecs); | |
656 | } | |
657 | ||
658 | #endif // wxUSE_GUI/!wxUSE_GUI | |
659 | ||
660 | // ---------------------------------------------------------------------------- | |
661 | // deprecated (in favour of wxLog) log functions | |
662 | // ---------------------------------------------------------------------------- | |
663 | ||
664 | #if wxUSE_GUI | |
665 | ||
666 | // Output a debug mess., in a system dependent fashion. | |
667 | void wxDebugMsg(const wxChar *fmt ...) | |
668 | { | |
669 | va_list ap; | |
670 | static wxChar buffer[512]; | |
671 | ||
672 | if (!wxTheApp->GetWantDebugOutput()) | |
673 | return ; | |
674 | ||
675 | va_start(ap, fmt); | |
676 | ||
677 | wvsprintf(buffer,fmt,ap) ; | |
678 | OutputDebugString((LPCTSTR)buffer) ; | |
679 | ||
680 | va_end(ap); | |
681 | } | |
682 | ||
683 | // Non-fatal error: pop up message box and (possibly) continue | |
684 | void wxError(const wxString& msg, const wxString& title) | |
685 | { | |
686 | wxSprintf(wxBuffer, wxT("%s\nContinue?"), WXSTRINGCAST msg); | |
687 | if (MessageBox(NULL, (LPCTSTR)wxBuffer, (LPCTSTR)WXSTRINGCAST title, | |
688 | MB_ICONSTOP | MB_YESNO) == IDNO) | |
689 | wxExit(); | |
690 | } | |
691 | ||
692 | // Fatal error: pop up message box and abort | |
693 | void wxFatalError(const wxString& msg, const wxString& title) | |
694 | { | |
695 | wxSprintf(wxBuffer, wxT("%s: %s"), WXSTRINGCAST title, WXSTRINGCAST msg); | |
696 | FatalAppExit(0, (LPCTSTR)wxBuffer); | |
697 | } | |
698 | ||
699 | // ---------------------------------------------------------------------------- | |
700 | // functions to work with .INI files | |
701 | // ---------------------------------------------------------------------------- | |
702 | ||
703 | // Reading and writing resources (eg WIN.INI, .Xdefaults) | |
704 | #if wxUSE_RESOURCES | |
705 | bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file) | |
706 | { | |
707 | if (file != wxT("")) | |
708 | // Don't know what the correct cast should be, but it doesn't | |
709 | // compile in BC++/16-bit without this cast. | |
710 | #if !defined(__WIN32__) | |
711 | return (WritePrivateProfileString((const char*) section, (const char*) entry, (const char*) value, (const char*) file) != 0); | |
712 | #else | |
713 | return (WritePrivateProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)value, (LPCTSTR)WXSTRINGCAST file) != 0); | |
714 | #endif | |
715 | else | |
716 | return (WriteProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)WXSTRINGCAST value) != 0); | |
717 | } | |
718 | ||
719 | bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file) | |
720 | { | |
721 | wxString buf; | |
722 | buf.Printf(wxT("%.4f"), value); | |
723 | ||
724 | return wxWriteResource(section, entry, buf, file); | |
725 | } | |
726 | ||
727 | bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file) | |
728 | { | |
729 | wxString buf; | |
730 | buf.Printf(wxT("%ld"), value); | |
731 | ||
732 | return wxWriteResource(section, entry, buf, file); | |
733 | } | |
734 | ||
735 | bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file) | |
736 | { | |
737 | wxString buf; | |
738 | buf.Printf(wxT("%d"), value); | |
739 | ||
740 | return wxWriteResource(section, entry, buf, file); | |
741 | } | |
742 | ||
743 | bool wxGetResource(const wxString& section, const wxString& entry, wxChar **value, const wxString& file) | |
744 | { | |
745 | static const wxChar defunkt[] = wxT("$$default"); | |
746 | if (file != wxT("")) | |
747 | { | |
748 | int n = GetPrivateProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)defunkt, | |
749 | (LPTSTR)wxBuffer, 1000, (LPCTSTR)WXSTRINGCAST file); | |
750 | if (n == 0 || wxStrcmp(wxBuffer, defunkt) == 0) | |
751 | return FALSE; | |
752 | } | |
753 | else | |
754 | { | |
755 | int n = GetProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)defunkt, | |
756 | (LPTSTR)wxBuffer, 1000); | |
757 | if (n == 0 || wxStrcmp(wxBuffer, defunkt) == 0) | |
758 | return FALSE; | |
759 | } | |
760 | if (*value) delete[] (*value); | |
761 | *value = copystring(wxBuffer); | |
762 | return TRUE; | |
763 | } | |
764 | ||
765 | bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file) | |
766 | { | |
767 | wxChar *s = NULL; | |
768 | bool succ = wxGetResource(section, entry, (wxChar **)&s, file); | |
769 | if (succ) | |
770 | { | |
771 | *value = (float)wxStrtod(s, NULL); | |
772 | delete[] s; | |
773 | return TRUE; | |
774 | } | |
775 | else return FALSE; | |
776 | } | |
777 | ||
778 | bool wxGetResource(const wxString& section, const wxString& entry, long *value, const wxString& file) | |
779 | { | |
780 | wxChar *s = NULL; | |
781 | bool succ = wxGetResource(section, entry, (wxChar **)&s, file); | |
782 | if (succ) | |
783 | { | |
784 | *value = wxStrtol(s, NULL, 10); | |
785 | delete[] s; | |
786 | return TRUE; | |
787 | } | |
788 | else return FALSE; | |
789 | } | |
790 | ||
791 | bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file) | |
792 | { | |
793 | wxChar *s = NULL; | |
794 | bool succ = wxGetResource(section, entry, (wxChar **)&s, file); | |
795 | if (succ) | |
796 | { | |
797 | *value = (int)wxStrtol(s, NULL, 10); | |
798 | delete[] s; | |
799 | return TRUE; | |
800 | } | |
801 | else return FALSE; | |
802 | } | |
803 | #endif // wxUSE_RESOURCES | |
804 | ||
805 | // --------------------------------------------------------------------------- | |
806 | // helper functions for showing a "busy" cursor | |
807 | // --------------------------------------------------------------------------- | |
808 | ||
809 | HCURSOR gs_wxBusyCursor = 0; // new, busy cursor | |
810 | HCURSOR gs_wxBusyCursorOld = 0; // old cursor | |
811 | static int gs_wxBusyCursorCount = 0; | |
812 | ||
813 | // Set the cursor to the busy cursor for all windows | |
814 | void wxBeginBusyCursor(wxCursor *cursor) | |
815 | { | |
816 | if ( gs_wxBusyCursorCount++ == 0 ) | |
817 | { | |
818 | gs_wxBusyCursor = (HCURSOR)cursor->GetHCURSOR(); | |
819 | gs_wxBusyCursorOld = ::SetCursor(gs_wxBusyCursor); | |
820 | } | |
821 | //else: nothing to do, already set | |
822 | } | |
823 | ||
824 | // Restore cursor to normal | |
825 | void wxEndBusyCursor() | |
826 | { | |
827 | wxCHECK_RET( gs_wxBusyCursorCount > 0, | |
828 | wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") ); | |
829 | ||
830 | if ( --gs_wxBusyCursorCount == 0 ) | |
831 | { | |
832 | ::SetCursor(gs_wxBusyCursorOld); | |
833 | ||
834 | gs_wxBusyCursorOld = 0; | |
835 | } | |
836 | } | |
837 | ||
838 | // TRUE if we're between the above two calls | |
839 | bool wxIsBusy() | |
840 | { | |
841 | return (gs_wxBusyCursorCount > 0); | |
842 | } | |
843 | ||
844 | // Check whether this window wants to process messages, e.g. Stop button | |
845 | // in long calculations. | |
846 | bool wxCheckForInterrupt(wxWindow *wnd) | |
847 | { | |
848 | wxCHECK( wnd, FALSE ); | |
849 | ||
850 | MSG msg; | |
851 | while ( ::PeekMessage(&msg, GetHwndOf(wnd), 0, 0, PM_REMOVE) ) | |
852 | { | |
853 | ::TranslateMessage(&msg); | |
854 | ::DispatchMessage(&msg); | |
855 | } | |
856 | ||
857 | return TRUE; | |
858 | } | |
859 | ||
860 | #endif // wxUSE_GUI | |
861 | ||
862 | // MSW only: get user-defined resource from the .res file. | |
863 | // Returns NULL or newly-allocated memory, so use delete[] to clean up. | |
864 | ||
865 | wxChar *wxLoadUserResource(const wxString& resourceName, const wxString& resourceType) | |
866 | { | |
867 | HRSRC hResource = ::FindResource(wxGetInstance(), resourceName, resourceType); | |
868 | if ( hResource == 0 ) | |
869 | return NULL; | |
870 | ||
871 | HGLOBAL hData = ::LoadResource(wxGetInstance(), hResource); | |
872 | if ( hData == 0 ) | |
873 | return NULL; | |
874 | ||
875 | wxChar *theText = (wxChar *)::LockResource(hData); | |
876 | if ( !theText ) | |
877 | return NULL; | |
878 | ||
879 | // Not all compilers put a zero at the end of the resource (e.g. BC++ doesn't). | |
880 | // so we need to find the length of the resource. | |
881 | int len = ::SizeofResource(wxGetInstance(), hResource); | |
882 | wxChar *s = new wxChar[len+1]; | |
883 | wxStrncpy(s,theText,len); | |
884 | s[len]=0; | |
885 | ||
886 | // wxChar *s = copystring(theText); | |
887 | ||
888 | // Obsolete in WIN32 | |
889 | #ifndef __WIN32__ | |
890 | UnlockResource(hData); | |
891 | #endif | |
892 | ||
893 | // No need?? | |
894 | // GlobalFree(hData); | |
895 | ||
896 | return s; | |
897 | } | |
898 | ||
899 | // ---------------------------------------------------------------------------- | |
900 | // get display info | |
901 | // ---------------------------------------------------------------------------- | |
902 | ||
903 | void wxGetMousePosition( int* x, int* y ) | |
904 | { | |
905 | POINT pt; | |
906 | GetCursorPos( & pt ); | |
907 | if ( x ) *x = pt.x; | |
908 | if ( y ) *y = pt.y; | |
909 | }; | |
910 | ||
911 | // Return TRUE if we have a colour display | |
912 | bool wxColourDisplay() | |
913 | { | |
914 | ScreenHDC dc; | |
915 | int noCols = GetDeviceCaps(dc, NUMCOLORS); | |
916 | ||
917 | return (noCols == -1) || (noCols > 2); | |
918 | } | |
919 | ||
920 | // Returns depth of screen | |
921 | int wxDisplayDepth() | |
922 | { | |
923 | ScreenHDC dc; | |
924 | return GetDeviceCaps(dc, PLANES) * GetDeviceCaps(dc, BITSPIXEL); | |
925 | } | |
926 | ||
927 | // Get size of display | |
928 | void wxDisplaySize(int *width, int *height) | |
929 | { | |
930 | ScreenHDC dc; | |
931 | ||
932 | if ( width ) *width = GetDeviceCaps(dc, HORZRES); | |
933 | if ( height ) *height = GetDeviceCaps(dc, VERTRES); | |
934 | } | |
935 | ||
936 | // --------------------------------------------------------------------------- | |
937 | // window information functions | |
938 | // --------------------------------------------------------------------------- | |
939 | ||
940 | wxString WXDLLEXPORT wxGetWindowText(WXHWND hWnd) | |
941 | { | |
942 | wxString str; | |
943 | int len = GetWindowTextLength((HWND)hWnd) + 1; | |
944 | GetWindowText((HWND)hWnd, str.GetWriteBuf(len), len); | |
945 | str.UngetWriteBuf(); | |
946 | ||
947 | return str; | |
948 | } | |
949 | ||
950 | wxString WXDLLEXPORT wxGetWindowClass(WXHWND hWnd) | |
951 | { | |
952 | wxString str; | |
953 | ||
954 | int len = 256; // some starting value | |
955 | ||
956 | for ( ;; ) | |
957 | { | |
958 | // as we've #undefined GetClassName we must now manually choose the | |
959 | // right function to call | |
960 | int count = | |
961 | ||
962 | #ifndef __WIN32__ | |
963 | GetClassName | |
964 | #else // Win32 | |
965 | #ifdef UNICODE | |
966 | GetClassNameW | |
967 | #else // !Unicode | |
968 | #ifdef __TWIN32__ | |
969 | GetClassName | |
970 | #else // !Twin32 | |
971 | GetClassNameA | |
972 | #endif // Twin32/!Twin32 | |
973 | #endif // Unicode/ANSI | |
974 | #endif // Win16/32 | |
975 | ((HWND)hWnd, str.GetWriteBuf(len), len); | |
976 | ||
977 | str.UngetWriteBuf(); | |
978 | if ( count == len ) | |
979 | { | |
980 | // the class name might have been truncated, retry with larger | |
981 | // buffer | |
982 | len *= 2; | |
983 | } | |
984 | else | |
985 | { | |
986 | break; | |
987 | } | |
988 | } | |
989 | ||
990 | return str; | |
991 | } | |
992 | ||
993 | WXWORD WXDLLEXPORT wxGetWindowId(WXHWND hWnd) | |
994 | { | |
995 | #ifndef __WIN32__ | |
996 | return GetWindowWord((HWND)hWnd, GWW_ID); | |
997 | #else // Win32 | |
998 | return GetWindowLong((HWND)hWnd, GWL_ID); | |
999 | #endif // Win16/32 | |
1000 | } | |
1001 | ||
1002 | #if 0 | |
1003 | //------------------------------------------------------------------------ | |
1004 | // wild character routines | |
1005 | //------------------------------------------------------------------------ | |
1006 | ||
1007 | bool wxIsWild( const wxString& pattern ) | |
1008 | { | |
1009 | wxString tmp = pattern; | |
1010 | char *pat = WXSTRINGCAST(tmp); | |
1011 | while (*pat) { | |
1012 | switch (*pat++) { | |
1013 | case '?': case '*': case '[': case '{': | |
1014 | return TRUE; | |
1015 | case '\\': | |
1016 | if (!*pat++) | |
1017 | return FALSE; | |
1018 | } | |
1019 | } | |
1020 | return FALSE; | |
1021 | }; | |
1022 | ||
1023 | ||
1024 | bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special ) | |
1025 | { | |
1026 | wxString tmp1 = pat; | |
1027 | char *pattern = WXSTRINGCAST(tmp1); | |
1028 | wxString tmp2 = text; | |
1029 | char *str = WXSTRINGCAST(tmp2); | |
1030 | char c; | |
1031 | char *cp; | |
1032 | bool done = FALSE, ret_code, ok; | |
1033 | // Below is for vi fans | |
1034 | const char OB = '{', CB = '}'; | |
1035 | ||
1036 | // dot_special means '.' only matches '.' | |
1037 | if (dot_special && *str == '.' && *pattern != *str) | |
1038 | return FALSE; | |
1039 | ||
1040 | while ((*pattern != '\0') && (!done) | |
1041 | && (((*str=='\0')&&((*pattern==OB)||(*pattern=='*')))||(*str!='\0'))) { | |
1042 | switch (*pattern) { | |
1043 | case '\\': | |
1044 | pattern++; | |
1045 | if (*pattern != '\0') | |
1046 | pattern++; | |
1047 | break; | |
1048 | case '*': | |
1049 | pattern++; | |
1050 | ret_code = FALSE; | |
1051 | while ((*str!='\0') | |
1052 | && (!(ret_code=wxMatchWild(pattern, str++, FALSE)))) | |
1053 | /*loop*/; | |
1054 | if (ret_code) { | |
1055 | while (*str != '\0') | |
1056 | str++; | |
1057 | while (*pattern != '\0') | |
1058 | pattern++; | |
1059 | } | |
1060 | break; | |
1061 | case '[': | |
1062 | pattern++; | |
1063 | repeat: | |
1064 | if ((*pattern == '\0') || (*pattern == ']')) { | |
1065 | done = TRUE; | |
1066 | break; | |
1067 | } | |
1068 | if (*pattern == '\\') { | |
1069 | pattern++; | |
1070 | if (*pattern == '\0') { | |
1071 | done = TRUE; | |
1072 | break; | |
1073 | } | |
1074 | } | |
1075 | if (*(pattern + 1) == '-') { | |
1076 | c = *pattern; | |
1077 | pattern += 2; | |
1078 | if (*pattern == ']') { | |
1079 | done = TRUE; | |
1080 | break; | |
1081 | } | |
1082 | if (*pattern == '\\') { | |
1083 | pattern++; | |
1084 | if (*pattern == '\0') { | |
1085 | done = TRUE; | |
1086 | break; | |
1087 | } | |
1088 | } | |
1089 | if ((*str < c) || (*str > *pattern)) { | |
1090 | pattern++; | |
1091 | goto repeat; | |
1092 | } | |
1093 | } else if (*pattern != *str) { | |
1094 | pattern++; | |
1095 | goto repeat; | |
1096 | } | |
1097 | pattern++; | |
1098 | while ((*pattern != ']') && (*pattern != '\0')) { | |
1099 | if ((*pattern == '\\') && (*(pattern + 1) != '\0')) | |
1100 | pattern++; | |
1101 | pattern++; | |
1102 | } | |
1103 | if (*pattern != '\0') { | |
1104 | pattern++, str++; | |
1105 | } | |
1106 | break; | |
1107 | case '?': | |
1108 | pattern++; | |
1109 | str++; | |
1110 | break; | |
1111 | case OB: | |
1112 | pattern++; | |
1113 | while ((*pattern != CB) && (*pattern != '\0')) { | |
1114 | cp = str; | |
1115 | ok = TRUE; | |
1116 | while (ok && (*cp != '\0') && (*pattern != '\0') | |
1117 | && (*pattern != ',') && (*pattern != CB)) { | |
1118 | if (*pattern == '\\') | |
1119 | pattern++; | |
1120 | ok = (*pattern++ == *cp++); | |
1121 | } | |
1122 | if (*pattern == '\0') { | |
1123 | ok = FALSE; | |
1124 | done = TRUE; | |
1125 | break; | |
1126 | } else if (ok) { | |
1127 | str = cp; | |
1128 | while ((*pattern != CB) && (*pattern != '\0')) { | |
1129 | if (*++pattern == '\\') { | |
1130 | if (*++pattern == CB) | |
1131 | pattern++; | |
1132 | } | |
1133 | } | |
1134 | } else { | |
1135 | while (*pattern!=CB && *pattern!=',' && *pattern!='\0') { | |
1136 | if (*++pattern == '\\') { | |
1137 | if (*++pattern == CB || *pattern == ',') | |
1138 | pattern++; | |
1139 | } | |
1140 | } | |
1141 | } | |
1142 | if (*pattern != '\0') | |
1143 | pattern++; | |
1144 | } | |
1145 | break; | |
1146 | default: | |
1147 | if (*str == *pattern) { | |
1148 | str++, pattern++; | |
1149 | } else { | |
1150 | done = TRUE; | |
1151 | } | |
1152 | } | |
1153 | } | |
1154 | while (*pattern == '*') | |
1155 | pattern++; | |
1156 | return ((*str == '\0') && (*pattern == '\0')); | |
1157 | }; | |
1158 | ||
1159 | #endif | |
1160 | ||
1161 | #if 0 | |
1162 | ||
1163 | // maximum mumber of lines the output console should have | |
1164 | static const WORD MAX_CONSOLE_LINES = 500; | |
1165 | ||
1166 | BOOL WINAPI MyConsoleHandler( DWORD dwCtrlType ) { // control signal type | |
1167 | FreeConsole(); | |
1168 | return TRUE; | |
1169 | } | |
1170 | ||
1171 | void wxRedirectIOToConsole() | |
1172 | { | |
1173 | int hConHandle; | |
1174 | long lStdHandle; | |
1175 | CONSOLE_SCREEN_BUFFER_INFO coninfo; | |
1176 | FILE *fp; | |
1177 | ||
1178 | // allocate a console for this app | |
1179 | AllocConsole(); | |
1180 | ||
1181 | // set the screen buffer to be big enough to let us scroll text | |
1182 | GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), | |
1183 | &coninfo); | |
1184 | coninfo.dwSize.Y = MAX_CONSOLE_LINES; | |
1185 | SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), | |
1186 | coninfo.dwSize); | |
1187 | ||
1188 | // redirect unbuffered STDOUT to the console | |
1189 | lStdHandle = (long)GetStdHandle(STD_OUTPUT_HANDLE); | |
1190 | hConHandle = _open_osfhandle(lStdHandle, _O_TEXT); | |
1191 | if(hConHandle <= 0) return; | |
1192 | fp = _fdopen( hConHandle, "w" ); | |
1193 | *stdout = *fp; | |
1194 | setvbuf( stdout, NULL, _IONBF, 0 ); | |
1195 | ||
1196 | // redirect unbuffered STDIN to the console | |
1197 | lStdHandle = (long)GetStdHandle(STD_INPUT_HANDLE); | |
1198 | hConHandle = _open_osfhandle(lStdHandle, _O_TEXT); | |
1199 | if(hConHandle <= 0) return; | |
1200 | fp = _fdopen( hConHandle, "r" ); | |
1201 | *stdin = *fp; | |
1202 | setvbuf( stdin, NULL, _IONBF, 0 ); | |
1203 | ||
1204 | // redirect unbuffered STDERR to the console | |
1205 | lStdHandle = (long)GetStdHandle(STD_ERROR_HANDLE); | |
1206 | hConHandle = _open_osfhandle(lStdHandle, _O_TEXT); | |
1207 | if(hConHandle <= 0) return; | |
1208 | fp = _fdopen( hConHandle, "w" ); | |
1209 | *stderr = *fp; | |
1210 | setvbuf( stderr, NULL, _IONBF, 0 ); | |
1211 | ||
1212 | // make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog | |
1213 | // point to console as well | |
1214 | ios::sync_with_stdio(); | |
1215 | ||
1216 | SetConsoleCtrlHandler(MyConsoleHandler, TRUE); | |
1217 | } | |
1218 | #else | |
1219 | // Not supported | |
1220 | void wxRedirectIOToConsole() | |
1221 | { | |
1222 | } | |
1223 | #endif | |
1224 | ||
1225 |