1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Various utilities
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
21 // #pragma implementation "utils.h" // Note: this is done in utilscmn.cpp now.
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
34 #include "wx/cursor.h"
39 // In some mingws there is a missing extern "C" int the winsock header,
40 // so we put it here just to be safe. Note that this must appear _before_
41 // #include "wx/msw/private.h" which itself includes <windows.h>, as this
42 // one in turn includes <winsock.h> unless we define WIN32_LEAN_AND_MEAN.
44 #if defined(__WIN32__) && !defined(__TWIN32__) && ! (defined(__GNUWIN32__) && !defined(__MINGW32__))
46 #include <winsock.h> // we use socket functions in wxGetFullHostName()
50 #include "wx/msw/private.h" // includes <windows.h>
56 #if !defined(__GNUWIN32__) && !defined(__WXWINE__) && !defined(__SALFORDC__)
64 #if defined(__GNUWIN32__) && !defined(__TWIN32__)
65 #include <sys/unistd.h>
69 #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs
70 // this (3.1 I believe) and how to test for it.
71 // If this works for Borland 4.0 as well, then no worries.
75 // VZ: there is some code using NetXXX() functions to get the full user name:
76 // I don't think it's a good idea because they don't work under Win95 and
77 // seem to return the same as wxGetUserId() under NT. If you really want
78 // to use them, just #define USE_NET_API
85 #if defined(__WIN32__) && !defined(__WXWINE__)
97 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
103 //// BEGIN for console support: VC++ only
106 #include "wx/msw/msvcrt.h"
110 #include "wx/ioswrap.h"
113 // N.B. BC++ doesn't have istream.h, ostream.h
115 # include <fstream.h>
120 /* Need to undef new if including crtdbg.h */
129 # if defined(__WXDEBUG__) && wxUSE_GLOBAL_MEMORY_OPERATORS && wxUSE_DEBUG_NEW_ALWAYS
130 # define new new(__TFILE__,__LINE__)
135 /// END for console support
137 // ----------------------------------------------------------------------------
139 // ----------------------------------------------------------------------------
141 // In the WIN.INI file
142 static const wxChar WX_SECTION
[] = wxT("wxWindows");
143 static const wxChar eUSERNAME
[] = wxT("UserName");
145 // these are only used under Win16
147 static const wxChar eHOSTNAME
[] = wxT("HostName");
148 static const wxChar eUSERID
[] = wxT("UserId");
151 // ============================================================================
153 // ============================================================================
155 // ----------------------------------------------------------------------------
156 // get host name and related
157 // ----------------------------------------------------------------------------
159 // Get hostname only (without domain name)
160 bool wxGetHostName(wxChar
*buf
, int maxSize
)
162 #if defined(__WIN32__) && !defined(__TWIN32__)
163 DWORD nSize
= maxSize
;
164 if ( !::GetComputerName(buf
, &nSize
) )
166 wxLogLastError(wxT("GetComputerName"));
174 const wxChar
*default_host
= wxT("noname");
176 if ((sysname
= wxGetenv(wxT("SYSTEM_NAME"))) == NULL
) {
177 GetProfileString(WX_SECTION
, eHOSTNAME
, default_host
, buf
, maxSize
- 1);
179 wxStrncpy(buf
, sysname
, maxSize
- 1);
180 buf
[maxSize
] = wxT('\0');
181 return *buf
? TRUE
: FALSE
;
185 // get full hostname (with domain name if possible)
186 bool wxGetFullHostName(wxChar
*buf
, int maxSize
)
188 #if defined(__WIN32__) && !defined(__TWIN32__) && ! (defined(__GNUWIN32__) && !defined(__MINGW32__))
189 // TODO should use GetComputerNameEx() when available
191 if ( WSAStartup(MAKEWORD(1, 1), &wsa
) == 0 )
195 if ( gethostname(bufA
, WXSIZEOF(bufA
)) == 0 )
197 // gethostname() won't usually include the DNS domain name, for
198 // this we need to work a bit more
199 if ( !strchr(bufA
, '.') )
201 struct hostent
*pHostEnt
= gethostbyname(bufA
);
205 // Windows will use DNS internally now
206 pHostEnt
= gethostbyaddr(pHostEnt
->h_addr
, 4, PF_INET
);
211 host
= pHostEnt
->h_name
;
220 wxStrncpy(buf
, host
, maxSize
);
227 return wxGetHostName(buf
, maxSize
);
230 // Get user ID e.g. jacs
231 bool wxGetUserId(wxChar
*buf
, int maxSize
)
233 #if defined(__WIN32__) && !defined(__win32s__) && !defined(__TWIN32__)
234 DWORD nSize
= maxSize
;
235 if ( ::GetUserName(buf
, &nSize
) == 0 )
237 // actually, it does happen on Win9x if the user didn't log on
238 DWORD res
= ::GetEnvironmentVariable(wxT("username"), buf
, maxSize
);
247 #else // Win16 or Win32s
249 const wxChar
*default_id
= wxT("anonymous");
251 // Can't assume we have NIS (PC-NFS) or some other ID daemon
253 if ( (user
= wxGetenv(wxT("USER"))) == NULL
&&
254 (user
= wxGetenv(wxT("LOGNAME"))) == NULL
)
256 // Use wxWindows configuration data (comming soon)
257 GetProfileString(WX_SECTION
, eUSERID
, default_id
, buf
, maxSize
- 1);
261 wxStrncpy(buf
, user
, maxSize
- 1);
264 return *buf
? TRUE
: FALSE
;
268 // Get user name e.g. Julian Smart
269 bool wxGetUserName(wxChar
*buf
, int maxSize
)
271 #if wxUSE_PENWINDOWS && !defined(__WATCOMC__) && !defined(__GNUWIN32__)
272 extern HANDLE g_hPenWin
; // PenWindows Running?
275 // PenWindows Does have a user concept!
276 // Get the current owner of the recognizer
277 GetPrivateProfileString("Current", "User", default_name
, wxBuffer
, maxSize
- 1, "PENWIN.INI");
278 strncpy(buf
, wxBuffer
, maxSize
- 1);
284 CHAR szUserName
[256];
285 if ( !wxGetUserId(szUserName
, WXSIZEOF(szUserName
)) )
288 // TODO how to get the domain name?
291 // the code is based on the MSDN example (also see KB article Q119670)
292 WCHAR wszUserName
[256]; // Unicode user name
293 WCHAR wszDomain
[256];
296 USER_INFO_2
*ui2
; // User structure
298 // Convert ANSI user name and domain to Unicode
299 MultiByteToWideChar( CP_ACP
, 0, szUserName
, strlen(szUserName
)+1,
300 wszUserName
, WXSIZEOF(wszUserName
) );
301 MultiByteToWideChar( CP_ACP
, 0, szDomain
, strlen(szDomain
)+1,
302 wszDomain
, WXSIZEOF(wszDomain
) );
304 // Get the computer name of a DC for the domain.
305 if ( NetGetDCName( NULL
, wszDomain
, &ComputerName
) != NERR_Success
)
307 wxLogError(wxT("Can not find domain controller"));
312 // Look up the user on the DC
313 NET_API_STATUS status
= NetUserGetInfo( (LPWSTR
)ComputerName
,
314 (LPWSTR
)&wszUserName
,
315 2, // level - we want USER_INFO_2
323 case NERR_InvalidComputer
:
324 wxLogError(wxT("Invalid domain controller name."));
328 case NERR_UserNotFound
:
329 wxLogError(wxT("Invalid user name '%s'."), szUserName
);
334 wxLogSysError(wxT("Can't get information about user"));
339 // Convert the Unicode full name to ANSI
340 WideCharToMultiByte( CP_ACP
, 0, ui2
->usri2_full_name
, -1,
341 buf
, maxSize
, NULL
, NULL
);
346 wxLogError(wxT("Couldn't look up full user name."));
349 #else // !USE_NET_API
350 // Could use NIS, MS-Mail or other site specific programs
351 // Use wxWindows configuration data
352 bool ok
= GetProfileString(WX_SECTION
, eUSERNAME
, wxT(""), buf
, maxSize
- 1) != 0;
355 ok
= wxGetUserId(buf
, maxSize
);
360 wxStrncpy(buf
, wxT("Unknown User"), maxSize
);
368 const wxChar
* wxGetHomeDir(wxString
*pstr
)
370 wxString
& strDir
= *pstr
;
372 #if defined(__UNIX__) && !defined(__TWIN32__)
373 const wxChar
*szHome
= wxGetenv("HOME");
374 if ( szHome
== NULL
) {
376 wxLogWarning(_("can't find user's HOME, using current directory."));
382 // add a trailing slash if needed
383 if ( strDir
.Last() != wxT('/') )
387 const wxChar
*szHome
= wxGetenv(wxT("HOMEDRIVE"));
388 if ( szHome
!= NULL
)
390 szHome
= wxGetenv(wxT("HOMEPATH"));
391 if ( szHome
!= NULL
) {
394 // the idea is that under NT these variables have default values
395 // of "%systemdrive%:" and "\\". As we don't want to create our
396 // config files in the root directory of the system drive, we will
397 // create it in our program's dir. However, if the user took care
398 // to set HOMEPATH to something other than "\\", we suppose that he
399 // knows what he is doing and use the supplied value.
400 if ( wxStrcmp(szHome
, wxT("\\")) != 0 )
401 return strDir
.c_str();
405 // Win16 has no idea about home, so use the working directory instead
408 // 260 was taken from windef.h
414 ::GetModuleFileName(::GetModuleHandle(NULL
),
415 strPath
.GetWriteBuf(MAX_PATH
), MAX_PATH
);
416 strPath
.UngetWriteBuf();
418 // extract the dir name
419 wxSplitPath(strPath
, &strDir
, NULL
, NULL
);
423 return strDir
.c_str();
426 wxChar
*wxGetUserHome(const wxString
& WXUNUSED(user
))
428 // VZ: the old code here never worked for user != "" anyhow! Moreover, it
429 // returned sometimes a malloc()'d pointer, sometimes a pointer to a
430 // static buffer and sometimes I don't even know what.
431 static wxString s_home
;
433 return (wxChar
*)wxGetHomeDir(&s_home
);
436 bool wxDirExists(const wxString
& dir
)
438 #if defined(__WIN32__)
439 DWORD attribs
= GetFileAttributes(dir
);
440 return ((attribs
!= (DWORD
)-1) && (attribs
& FILE_ATTRIBUTE_DIRECTORY
));
443 struct ffblk fileInfo
;
445 struct find_t fileInfo
;
447 // In Borland findfirst has a different argument
448 // ordering from _dos_findfirst. But _dos_findfirst
449 // _should_ be ok in both MS and Borland... why not?
451 return (findfirst(dir
, &fileInfo
, _A_SUBDIR
) == 0 &&
452 (fileInfo
.ff_attrib
& _A_SUBDIR
) != 0);
454 return (_dos_findfirst(dir
, _A_SUBDIR
, &fileInfo
) == 0) &&
455 ((fileInfo
.attrib
& _A_SUBDIR
) != 0);
460 // ----------------------------------------------------------------------------
462 // ----------------------------------------------------------------------------
464 bool wxGetEnv(const wxString
& var
, wxString
*value
)
467 const wxChar
* ret
= wxGetenv(var
);
476 // first get the size of the buffer
477 DWORD dwRet
= ::GetEnvironmentVariable(var
, NULL
, 0);
480 // this means that there is no such variable
486 (void)::GetEnvironmentVariable(var
, value
->GetWriteBuf(dwRet
), dwRet
);
487 value
->UngetWriteBuf();
494 bool wxSetEnv(const wxString
& var
, const wxChar
*value
)
496 // some compilers have putenv() or _putenv() or _wputenv() but it's better
497 // to always use Win32 function directly instead of dealing with them
498 #if defined(__WIN32__)
499 if ( !::SetEnvironmentVariable(var
, value
) )
501 wxLogLastError(_T("SetEnvironmentVariable"));
507 #else // no way to set env vars
512 // ----------------------------------------------------------------------------
513 // process management
514 // ----------------------------------------------------------------------------
516 int wxKill(long pid
, wxSignal sig
)
521 // This in a work in progress. We need to eliminate the call to wxSleep,
522 // deal with child processes, and also test it :-)
526 bool terminateSuccess
= TRUE
;
528 hProcess
= OpenProcess(PROCESS_TERMINATE
| PROCESS_QUERY_INFORMATION
,
529 FALSE
, (unsigned long)pid
);
530 if (hProcess
== NULL
)
533 if (sig
== wxSIGKILL
)
534 terminateSuccess
= (TerminateProcess(hProcess
, 0) != 0);
535 else if (sig
!= wxSIGNONE
)
537 hHwnd
= ::FindWindow(NULL
, NULL
);
540 if (::GetParent(hHwnd
) == 0)
542 unsigned long testpid
= 0;
543 GetWindowThreadProcessId(hHwnd
, &testpid
);
544 if ((unsigned long)pid
== testpid
)
546 PostMessage(hHwnd
, WM_QUIT
, 0, 0);
547 // How to make this better?
548 // If we don't wait, the return value is wrong.
553 hHwnd
= GetWindow(hHwnd
, GW_HWNDNEXT
);
557 GetExitCodeProcess(hProcess
, &code
);
558 CloseHandle(hProcess
);
560 if (sig
== wxSIGNONE
)
562 if (code
== STILL_ACTIVE
)
569 if (!terminateSuccess
|| code
== STILL_ACTIVE
)
577 // Execute a program in an Interactive Shell
578 bool wxShell(const wxString
& command
)
580 wxChar
*shell
= wxGetenv(wxT("COMSPEC"));
582 shell
= wxT("\\COMMAND.COM");
592 // pass the command to execute to the command processor
593 cmd
.Printf(wxT("%s /c %s"), shell
, command
.c_str());
596 return wxExecute(cmd
, TRUE
/* sync */) != 0;
599 // ----------------------------------------------------------------------------
601 // ----------------------------------------------------------------------------
603 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
604 long wxGetFreeMemory()
606 #if defined(__WIN32__) && !defined(__BORLANDC__) && !defined(__TWIN32__)
607 MEMORYSTATUS memStatus
;
608 memStatus
.dwLength
= sizeof(MEMORYSTATUS
);
609 GlobalMemoryStatus(&memStatus
);
610 return memStatus
.dwAvailPhys
;
612 return (long)GetFreeSpace(0);
619 ::MessageBeep((UINT
)-1); // default sound
622 wxString
wxGetOsDescription()
630 info
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFO
);
631 if ( ::GetVersionEx(&info
) )
633 switch ( info
.dwPlatformId
)
635 case VER_PLATFORM_WIN32s
:
636 str
= _("Win32s on Windows 3.1");
639 case VER_PLATFORM_WIN32_WINDOWS
:
640 str
.Printf(_("Windows 9%c"),
641 info
.dwMinorVersion
== 0 ? _T('5') : _T('8'));
642 if ( !wxIsEmpty(info
.szCSDVersion
) )
644 str
<< _T(" (") << info
.szCSDVersion
<< _T(')');
648 case VER_PLATFORM_WIN32_NT
:
649 str
.Printf(_T("Windows NT %lu.%lu (build %lu"),
653 if ( !wxIsEmpty(info
.szCSDVersion
) )
655 str
<< _T(", ") << info
.szCSDVersion
;
663 wxFAIL_MSG( _T("GetVersionEx() failed") ); // should never happen
668 return _("Windows 3.1");
672 int wxGetOsVersion(int *majorVsn
, int *minorVsn
)
674 #if defined(__WIN32__) && !defined(__SC__)
678 info
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFO
);
679 if ( ::GetVersionEx(&info
) )
682 *majorVsn
= info
.dwMajorVersion
;
684 *minorVsn
= info
.dwMinorVersion
;
686 switch ( info
.dwPlatformId
)
688 case VER_PLATFORM_WIN32s
:
691 case VER_PLATFORM_WIN32_WINDOWS
:
694 case VER_PLATFORM_WIN32_NT
:
699 return wxWINDOWS
; // error if we get here, return generic value
701 int retValue
= wxWINDOWS
;
702 #ifdef __WINDOWS_386__
705 #if !defined(__WATCOMC__) && !defined(GNUWIN32) && wxUSE_PENWINDOWS
706 extern HANDLE g_hPenWin
;
707 retValue
= g_hPenWin
? wxPENWINDOWS
: wxWINDOWS
;
720 // ----------------------------------------------------------------------------
722 // ----------------------------------------------------------------------------
726 // Sleep for nSecs seconds. Attempt a Windows implementation using timers.
727 static bool gs_inTimer
= FALSE
;
729 class wxSleepTimer
: public wxTimer
732 virtual void Notify()
739 static wxTimer
*wxTheSleepTimer
= NULL
;
741 void wxUsleep(unsigned long milliseconds
)
744 ::Sleep(milliseconds
);
749 wxTheSleepTimer
= new wxSleepTimer
;
751 wxTheSleepTimer
->Start(milliseconds
);
754 if (wxTheApp
->Pending())
755 wxTheApp
->Dispatch();
757 delete wxTheSleepTimer
;
758 wxTheSleepTimer
= NULL
;
762 void wxSleep(int nSecs
)
767 wxTheSleepTimer
= new wxSleepTimer
;
769 wxTheSleepTimer
->Start(nSecs
*1000);
772 if (wxTheApp
->Pending())
773 wxTheApp
->Dispatch();
775 delete wxTheSleepTimer
;
776 wxTheSleepTimer
= NULL
;
779 // Consume all events until no more left
785 #elif defined(__WIN32__) // wxUSE_GUI
787 void wxUsleep(unsigned long milliseconds
)
789 ::Sleep(milliseconds
);
792 void wxSleep(int nSecs
)
794 wxUsleep(1000*nSecs
);
797 #endif // wxUSE_GUI/!wxUSE_GUI
799 // ----------------------------------------------------------------------------
800 // deprecated (in favour of wxLog) log functions
801 // ----------------------------------------------------------------------------
805 // Output a debug mess., in a system dependent fashion.
806 void wxDebugMsg(const wxChar
*fmt
...)
809 static wxChar buffer
[512];
811 if (!wxTheApp
->GetWantDebugOutput())
816 wvsprintf(buffer
,fmt
,ap
) ;
817 OutputDebugString((LPCTSTR
)buffer
) ;
822 // Non-fatal error: pop up message box and (possibly) continue
823 void wxError(const wxString
& msg
, const wxString
& title
)
825 wxSprintf(wxBuffer
, wxT("%s\nContinue?"), WXSTRINGCAST msg
);
826 if (MessageBox(NULL
, (LPCTSTR
)wxBuffer
, (LPCTSTR
)WXSTRINGCAST title
,
827 MB_ICONSTOP
| MB_YESNO
) == IDNO
)
831 // Fatal error: pop up message box and abort
832 void wxFatalError(const wxString
& msg
, const wxString
& title
)
834 wxSprintf(wxBuffer
, wxT("%s: %s"), WXSTRINGCAST title
, WXSTRINGCAST msg
);
835 FatalAppExit(0, (LPCTSTR
)wxBuffer
);
838 // ----------------------------------------------------------------------------
839 // functions to work with .INI files
840 // ----------------------------------------------------------------------------
842 // Reading and writing resources (eg WIN.INI, .Xdefaults)
844 bool wxWriteResource(const wxString
& section
, const wxString
& entry
, const wxString
& value
, const wxString
& file
)
847 // Don't know what the correct cast should be, but it doesn't
848 // compile in BC++/16-bit without this cast.
849 #if !defined(__WIN32__)
850 return (WritePrivateProfileString((const char*) section
, (const char*) entry
, (const char*) value
, (const char*) file
) != 0);
852 return (WritePrivateProfileString((LPCTSTR
)WXSTRINGCAST section
, (LPCTSTR
)WXSTRINGCAST entry
, (LPCTSTR
)value
, (LPCTSTR
)WXSTRINGCAST file
) != 0);
855 return (WriteProfileString((LPCTSTR
)WXSTRINGCAST section
, (LPCTSTR
)WXSTRINGCAST entry
, (LPCTSTR
)WXSTRINGCAST value
) != 0);
858 bool wxWriteResource(const wxString
& section
, const wxString
& entry
, float value
, const wxString
& file
)
861 buf
.Printf(wxT("%.4f"), value
);
863 return wxWriteResource(section
, entry
, buf
, file
);
866 bool wxWriteResource(const wxString
& section
, const wxString
& entry
, long value
, const wxString
& file
)
869 buf
.Printf(wxT("%ld"), value
);
871 return wxWriteResource(section
, entry
, buf
, file
);
874 bool wxWriteResource(const wxString
& section
, const wxString
& entry
, int value
, const wxString
& file
)
877 buf
.Printf(wxT("%d"), value
);
879 return wxWriteResource(section
, entry
, buf
, file
);
882 bool wxGetResource(const wxString
& section
, const wxString
& entry
, wxChar
**value
, const wxString
& file
)
884 static const wxChar defunkt
[] = wxT("$$default");
887 int n
= GetPrivateProfileString((LPCTSTR
)WXSTRINGCAST section
, (LPCTSTR
)WXSTRINGCAST entry
, (LPCTSTR
)defunkt
,
888 (LPTSTR
)wxBuffer
, 1000, (LPCTSTR
)WXSTRINGCAST file
);
889 if (n
== 0 || wxStrcmp(wxBuffer
, defunkt
) == 0)
894 int n
= GetProfileString((LPCTSTR
)WXSTRINGCAST section
, (LPCTSTR
)WXSTRINGCAST entry
, (LPCTSTR
)defunkt
,
895 (LPTSTR
)wxBuffer
, 1000);
896 if (n
== 0 || wxStrcmp(wxBuffer
, defunkt
) == 0)
899 if (*value
) delete[] (*value
);
900 *value
= copystring(wxBuffer
);
904 bool wxGetResource(const wxString
& section
, const wxString
& entry
, float *value
, const wxString
& file
)
907 bool succ
= wxGetResource(section
, entry
, (wxChar
**)&s
, file
);
910 *value
= (float)wxStrtod(s
, NULL
);
917 bool wxGetResource(const wxString
& section
, const wxString
& entry
, long *value
, const wxString
& file
)
920 bool succ
= wxGetResource(section
, entry
, (wxChar
**)&s
, file
);
923 *value
= wxStrtol(s
, NULL
, 10);
930 bool wxGetResource(const wxString
& section
, const wxString
& entry
, int *value
, const wxString
& file
)
933 bool succ
= wxGetResource(section
, entry
, (wxChar
**)&s
, file
);
936 *value
= (int)wxStrtol(s
, NULL
, 10);
942 #endif // wxUSE_RESOURCES
944 // ---------------------------------------------------------------------------
945 // helper functions for showing a "busy" cursor
946 // ---------------------------------------------------------------------------
948 static HCURSOR gs_wxBusyCursor
= 0; // new, busy cursor
949 static HCURSOR gs_wxBusyCursorOld
= 0; // old cursor
950 static int gs_wxBusyCursorCount
= 0;
952 extern HCURSOR
wxGetCurrentBusyCursor()
954 return gs_wxBusyCursor
;
957 // Set the cursor to the busy cursor for all windows
958 void wxBeginBusyCursor(wxCursor
*cursor
)
960 if ( gs_wxBusyCursorCount
++ == 0 )
962 gs_wxBusyCursor
= (HCURSOR
)cursor
->GetHCURSOR();
963 gs_wxBusyCursorOld
= ::SetCursor(gs_wxBusyCursor
);
965 //else: nothing to do, already set
968 // Restore cursor to normal
969 void wxEndBusyCursor()
971 wxCHECK_RET( gs_wxBusyCursorCount
> 0,
972 wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") );
974 if ( --gs_wxBusyCursorCount
== 0 )
976 ::SetCursor(gs_wxBusyCursorOld
);
978 gs_wxBusyCursorOld
= 0;
982 // TRUE if we're between the above two calls
985 return (gs_wxBusyCursorCount
> 0);
988 // Check whether this window wants to process messages, e.g. Stop button
989 // in long calculations.
990 bool wxCheckForInterrupt(wxWindow
*wnd
)
992 wxCHECK( wnd
, FALSE
);
995 while ( ::PeekMessage(&msg
, GetHwndOf(wnd
), 0, 0, PM_REMOVE
) )
997 ::TranslateMessage(&msg
);
998 ::DispatchMessage(&msg
);
1004 // MSW only: get user-defined resource from the .res file.
1005 // Returns NULL or newly-allocated memory, so use delete[] to clean up.
1007 wxChar
*wxLoadUserResource(const wxString
& resourceName
, const wxString
& resourceType
)
1009 HRSRC hResource
= ::FindResource(wxGetInstance(), resourceName
, resourceType
);
1010 if ( hResource
== 0 )
1013 HGLOBAL hData
= ::LoadResource(wxGetInstance(), hResource
);
1017 wxChar
*theText
= (wxChar
*)::LockResource(hData
);
1021 // Not all compilers put a zero at the end of the resource (e.g. BC++ doesn't).
1022 // so we need to find the length of the resource.
1023 int len
= ::SizeofResource(wxGetInstance(), hResource
);
1024 wxChar
*s
= new wxChar
[len
+1];
1025 wxStrncpy(s
,theText
,len
);
1028 // wxChar *s = copystring(theText);
1030 // Obsolete in WIN32
1032 UnlockResource(hData
);
1036 // GlobalFree(hData);
1041 // ----------------------------------------------------------------------------
1043 // ----------------------------------------------------------------------------
1045 // See also the wxGetMousePosition in window.cpp
1046 // Deprecated: use wxPoint wxGetMousePosition() instead
1047 void wxGetMousePosition( int* x
, int* y
)
1050 GetCursorPos( & pt
);
1055 // Return TRUE if we have a colour display
1056 bool wxColourDisplay()
1058 // this function is called from wxDC ctor so it is called a *lot* of times
1059 // hence we optimize it a bit but doign the check only once
1061 // this should be MT safe as only the GUI thread (holding the GUI mutex)
1063 static int s_isColour
= -1;
1065 if ( s_isColour
== -1 )
1068 int noCols
= ::GetDeviceCaps(dc
, NUMCOLORS
);
1070 s_isColour
= (noCols
== -1) || (noCols
> 2);
1073 return s_isColour
!= 0;
1076 // Returns depth of screen
1077 int wxDisplayDepth()
1080 return GetDeviceCaps(dc
, PLANES
) * GetDeviceCaps(dc
, BITSPIXEL
);
1083 // Get size of display
1084 void wxDisplaySize(int *width
, int *height
)
1088 if ( width
) *width
= GetDeviceCaps(dc
, HORZRES
);
1089 if ( height
) *height
= GetDeviceCaps(dc
, VERTRES
);
1092 void wxDisplaySizeMM(int *width
, int *height
)
1096 if ( width
) *width
= GetDeviceCaps(dc
, HORZSIZE
);
1097 if ( height
) *height
= GetDeviceCaps(dc
, VERTSIZE
);
1100 void wxClientDisplayRect(int *x
, int *y
, int *width
, int *height
)
1104 wxDisplaySize(width
, height
);
1106 // Determine the desktop dimensions minus the taskbar and any other
1107 // special decorations...
1110 SystemParametersInfo(SPI_GETWORKAREA
, 0, &r
, 0);
1113 if (width
) *width
= r
.right
- r
.left
;
1114 if (height
) *height
= r
.bottom
- r
.top
;
1119 // ---------------------------------------------------------------------------
1120 // window information functions
1121 // ---------------------------------------------------------------------------
1123 wxString WXDLLEXPORT
wxGetWindowText(WXHWND hWnd
)
1126 int len
= GetWindowTextLength((HWND
)hWnd
) + 1;
1127 GetWindowText((HWND
)hWnd
, str
.GetWriteBuf(len
), len
);
1128 str
.UngetWriteBuf();
1133 wxString WXDLLEXPORT
wxGetWindowClass(WXHWND hWnd
)
1137 int len
= 256; // some starting value
1141 // as we've #undefined GetClassName we must now manually choose the
1142 // right function to call
1155 #endif // Twin32/!Twin32
1156 #endif // Unicode/ANSI
1158 ((HWND
)hWnd
, str
.GetWriteBuf(len
), len
);
1160 str
.UngetWriteBuf();
1163 // the class name might have been truncated, retry with larger
1176 WXWORD WXDLLEXPORT
wxGetWindowId(WXHWND hWnd
)
1179 return (WXWORD
)GetWindowWord((HWND
)hWnd
, GWW_ID
);
1181 return (WXWORD
)GetWindowLong((HWND
)hWnd
, GWL_ID
);
1188 //------------------------------------------------------------------------
1189 // wild character routines
1190 //------------------------------------------------------------------------
1192 bool wxIsWild( const wxString
& pattern
)
1194 wxString tmp
= pattern
;
1195 char *pat
= WXSTRINGCAST(tmp
);
1198 case '?': case '*': case '[': case '{':
1209 bool wxMatchWild( const wxString
& pat
, const wxString
& text
, bool dot_special
)
1211 wxString tmp1
= pat
;
1212 char *pattern
= WXSTRINGCAST(tmp1
);
1213 wxString tmp2
= text
;
1214 char *str
= WXSTRINGCAST(tmp2
);
1217 bool done
= FALSE
, ret_code
, ok
;
1218 // Below is for vi fans
1219 const char OB
= '{', CB
= '}';
1221 // dot_special means '.' only matches '.'
1222 if (dot_special
&& *str
== '.' && *pattern
!= *str
)
1225 while ((*pattern
!= '\0') && (!done
)
1226 && (((*str
=='\0')&&((*pattern
==OB
)||(*pattern
=='*')))||(*str
!='\0'))) {
1230 if (*pattern
!= '\0')
1237 && (!(ret_code
=wxMatchWild(pattern
, str
++, FALSE
))))
1240 while (*str
!= '\0')
1242 while (*pattern
!= '\0')
1249 if ((*pattern
== '\0') || (*pattern
== ']')) {
1253 if (*pattern
== '\\') {
1255 if (*pattern
== '\0') {
1260 if (*(pattern
+ 1) == '-') {
1263 if (*pattern
== ']') {
1267 if (*pattern
== '\\') {
1269 if (*pattern
== '\0') {
1274 if ((*str
< c
) || (*str
> *pattern
)) {
1278 } else if (*pattern
!= *str
) {
1283 while ((*pattern
!= ']') && (*pattern
!= '\0')) {
1284 if ((*pattern
== '\\') && (*(pattern
+ 1) != '\0'))
1288 if (*pattern
!= '\0') {
1298 while ((*pattern
!= CB
) && (*pattern
!= '\0')) {
1301 while (ok
&& (*cp
!= '\0') && (*pattern
!= '\0')
1302 && (*pattern
!= ',') && (*pattern
!= CB
)) {
1303 if (*pattern
== '\\')
1305 ok
= (*pattern
++ == *cp
++);
1307 if (*pattern
== '\0') {
1313 while ((*pattern
!= CB
) && (*pattern
!= '\0')) {
1314 if (*++pattern
== '\\') {
1315 if (*++pattern
== CB
)
1320 while (*pattern
!=CB
&& *pattern
!=',' && *pattern
!='\0') {
1321 if (*++pattern
== '\\') {
1322 if (*++pattern
== CB
|| *pattern
== ',')
1327 if (*pattern
!= '\0')
1332 if (*str
== *pattern
) {
1339 while (*pattern
== '*')
1341 return ((*str
== '\0') && (*pattern
== '\0'));
1348 // maximum mumber of lines the output console should have
1349 static const WORD MAX_CONSOLE_LINES
= 500;
1351 BOOL WINAPI
MyConsoleHandler( DWORD dwCtrlType
) { // control signal type
1356 void wxRedirectIOToConsole()
1360 CONSOLE_SCREEN_BUFFER_INFO coninfo
;
1363 // allocate a console for this app
1366 // set the screen buffer to be big enough to let us scroll text
1367 GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE
),
1369 coninfo
.dwSize
.Y
= MAX_CONSOLE_LINES
;
1370 SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE
),
1373 // redirect unbuffered STDOUT to the console
1374 lStdHandle
= (long)GetStdHandle(STD_OUTPUT_HANDLE
);
1375 hConHandle
= _open_osfhandle(lStdHandle
, _O_TEXT
);
1376 if(hConHandle
<= 0) return;
1377 fp
= _fdopen( hConHandle
, "w" );
1379 setvbuf( stdout
, NULL
, _IONBF
, 0 );
1381 // redirect unbuffered STDIN to the console
1382 lStdHandle
= (long)GetStdHandle(STD_INPUT_HANDLE
);
1383 hConHandle
= _open_osfhandle(lStdHandle
, _O_TEXT
);
1384 if(hConHandle
<= 0) return;
1385 fp
= _fdopen( hConHandle
, "r" );
1387 setvbuf( stdin
, NULL
, _IONBF
, 0 );
1389 // redirect unbuffered STDERR to the console
1390 lStdHandle
= (long)GetStdHandle(STD_ERROR_HANDLE
);
1391 hConHandle
= _open_osfhandle(lStdHandle
, _O_TEXT
);
1392 if(hConHandle
<= 0) return;
1393 fp
= _fdopen( hConHandle
, "w" );
1395 setvbuf( stderr
, NULL
, _IONBF
, 0 );
1397 // make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog
1398 // point to console as well
1399 ios::sync_with_stdio();
1401 SetConsoleCtrlHandler(MyConsoleHandler
, TRUE
);
1405 void wxRedirectIOToConsole()