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