]>
git.saurik.com Git - wxWidgets.git/blob - src/common/utilscmn.cpp
1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Miscellaneous utility functions and classes
4 // Author: Julian Smart
8 // Copyright: (c) 1998 Julian Smart
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
21 #pragma implementation "utils.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
33 #include "wx/string.h"
39 #include "wx/window.h"
42 #include "wx/msgdlg.h"
43 #include "wx/textdlg.h"
45 #include "wx/menuitem.h"
52 #include "wx/process.h"
53 #include "wx/txtstrm.h"
61 #if !defined(__WATCOMC__)
62 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
68 #include "wx/colordlg.h"
74 #include <sys/types.h>
83 #include "wx/msw/private.h"
86 // ----------------------------------------------------------------------------
88 // ----------------------------------------------------------------------------
91 static wxWindow
*wxFindWindowByLabel1(const wxString
& title
, wxWindow
*parent
);
92 static wxWindow
*wxFindWindowByName1 (const wxString
& title
, wxWindow
*parent
);
95 // ============================================================================
97 // ============================================================================
99 // ----------------------------------------------------------------------------
101 // ----------------------------------------------------------------------------
104 int strcasecmp(const char *str_1
, const char *str_2
)
106 register char c1
, c2
;
108 c1
= tolower(*str_1
++);
109 c2
= tolower(*str_2
++);
110 } while ( c1
&& (c1
== c2
) );
115 int strncasecmp(const char *str_1
, const char *str_2
, size_t maxchar
)
118 register char c1
, c2
;
121 c1
= tolower(*str_1
++);
122 c2
= tolower(*str_2
++);
134 #if defined( __VMS__ ) && ( __VMS_VER < 70000000 )
135 // we have no strI functions under VMS, therefore I have implemented
136 // an inefficient but portable version: convert copies of strings to lowercase
137 // and then use the normal comparison
138 static void myLowerString(char *s
)
141 if(isalpha(*s
)) *s
= (char)tolower(*s
);
146 int strcasecmp(const char *str_1
, const char *str_2
)
148 char *temp1
= new char[strlen(str_1
)+1];
149 char *temp2
= new char[strlen(str_2
)+1];
152 myLowerString(temp1
);
153 myLowerString(temp2
);
155 int result
= wxStrcmp(temp1
,temp2
);
162 int strncasecmp(const char *str_1
, const char *str_2
, size_t maxchar
)
164 char *temp1
= new char[strlen(str_1
)+1];
165 char *temp2
= new char[strlen(str_2
)+1];
168 myLowerString(temp1
);
169 myLowerString(temp2
);
171 int result
= strncmp(temp1
,temp2
,maxchar
);
183 #define strcasecmp stricmp
184 #define strncasecmp strnicmp
186 #define strcasecmp _stricmp
187 #define strncasecmp _strnicmp
194 #define strcasecmp stricmp
195 #define strncasecmp strnicmp
198 // This declaration is missing in SunOS!
199 // (Yes, I know it is NOT ANSI-C but its in BSD libc)
200 #if defined(__xlC) || defined(__AIX__) || defined(__GNUG__)
203 int strcasecmp (const char *, const char *);
204 int strncasecmp (const char *, const char *, size_t);
207 #endif /* __WXMSW__ */
210 #define strcasecmp stricmp
211 #define strncasecmp strnicmp
215 copystring (const wxChar
*s
)
217 if (s
== NULL
) s
= wxT("");
218 size_t len
= wxStrlen (s
) + 1;
220 wxChar
*news
= new wxChar
[len
];
221 memcpy (news
, s
, len
* sizeof(wxChar
)); // Should be the fastest
227 static long wxCurrentId
= 100;
232 return wxCurrentId
++;
236 wxGetCurrentId(void) { return wxCurrentId
; }
239 wxRegisterId (long id
)
241 if (id
>= wxCurrentId
)
242 wxCurrentId
= id
+ 1;
246 StringToFloat (wxChar
*s
, float *number
)
248 if (s
&& *s
&& number
)
249 *number
= (float) wxStrtod (s
, (wxChar
**) NULL
);
253 StringToDouble (wxChar
*s
, double *number
)
255 if (s
&& *s
&& number
)
256 *number
= wxStrtod (s
, (wxChar
**) NULL
);
260 FloatToString (float number
, const wxChar
*fmt
)
262 static wxChar buf
[256];
264 // sprintf (buf, "%.2f", number);
265 wxSprintf (buf
, fmt
, number
);
270 DoubleToString (double number
, const wxChar
*fmt
)
272 static wxChar buf
[256];
274 wxSprintf (buf
, fmt
, number
);
279 StringToInt (wxChar
*s
, int *number
)
281 if (s
&& *s
&& number
)
282 *number
= (int) wxStrtol (s
, (wxChar
**) NULL
, 10);
286 StringToLong (wxChar
*s
, long *number
)
288 if (s
&& *s
&& number
)
289 *number
= wxStrtol (s
, (wxChar
**) NULL
, 10);
293 IntToString (int number
)
295 static wxChar buf
[20];
297 wxSprintf (buf
, wxT("%d"), number
);
302 LongToString (long number
)
304 static wxChar buf
[20];
306 wxSprintf (buf
, wxT("%ld"), number
);
310 // Array used in DecToHex conversion routine.
311 static wxChar hexArray
[] = wxT("0123456789ABCDEF");
313 // Convert 2-digit hex number to decimal
314 int wxHexToDec(const wxString
& buf
)
316 int firstDigit
, secondDigit
;
318 if (buf
.GetChar(0) >= wxT('A'))
319 firstDigit
= buf
.GetChar(0) - wxT('A') + 10;
321 firstDigit
= buf
.GetChar(0) - wxT('0');
323 if (buf
.GetChar(1) >= wxT('A'))
324 secondDigit
= buf
.GetChar(1) - wxT('A') + 10;
326 secondDigit
= buf
.GetChar(1) - wxT('0');
328 return firstDigit
* 16 + secondDigit
;
331 // Convert decimal integer to 2-character hex string
332 void wxDecToHex(int dec
, wxChar
*buf
)
334 int firstDigit
= (int)(dec
/16.0);
335 int secondDigit
= (int)(dec
- (firstDigit
*16.0));
336 buf
[0] = hexArray
[firstDigit
];
337 buf
[1] = hexArray
[secondDigit
];
341 // Convert decimal integer to 2-character hex string
342 wxString
wxDecToHex(int dec
)
345 wxDecToHex(dec
, buf
);
346 return wxString(buf
);
349 // Match a string INDEPENDENT OF CASE
351 StringMatch (char *str1
, char *str2
, bool subString
, bool exact
)
353 if (str1
== NULL
|| str2
== NULL
)
360 int len1
= strlen (str1
);
361 int len2
= strlen (str2
);
364 // Search for str1 in str2
365 // Slow .... but acceptable for short strings
366 for (i
= 0; i
<= len2
- len1
; i
++)
368 if (strncasecmp (str1
, str2
+ i
, len1
) == 0)
374 if (strcasecmp (str1
, str2
) == 0)
379 int len1
= strlen (str1
);
380 int len2
= strlen (str2
);
382 if (strncasecmp (str1
, str2
, wxMin (len1
, len2
)) == 0)
389 // Return the current date/time
393 time_t now
= time((time_t *) NULL
);
394 char *date
= ctime(&now
);
396 return wxString(date
);
401 // ----------------------------------------------------------------------------
402 // Menu accelerators related functions
403 // ----------------------------------------------------------------------------
405 wxChar
*wxStripMenuCodes (wxChar
*in
, wxChar
*out
)
408 return (wxChar
*) NULL
;
411 out
= copystring(in
);
413 wxChar
*tmpOut
= out
;
419 // Check && -> &, &x -> x
420 if (*++in
== wxT('&'))
423 else if (*in
== wxT('\t'))
425 // Remove all stuff after \t in X mode, and let the stuff as is
427 // Accelerators are handled in wx_item.cc for Motif, and are not
428 // YET supported in XView
440 wxString
wxStripMenuCodes(const wxString
& str
)
442 wxChar
*buf
= new wxChar
[str
.Length() + 1];
443 wxStripMenuCodes(WXSTRINGCAST str
, buf
);
451 // return wxAcceleratorEntry for the given menu string or NULL if none
453 wxAcceleratorEntry
*wxGetAccelFromString(const wxString
& label
)
455 // check for accelerators: they are given after '\t'
456 int posTab
= label
.Find(wxT('\t'));
457 if ( posTab
!= wxNOT_FOUND
) {
458 // parse the accelerator string
460 int accelFlags
= wxACCEL_NORMAL
;
462 for ( size_t n
= (size_t)posTab
+ 1; n
< label
.Len(); n
++ ) {
463 if ( (label
[n
] == '+') || (label
[n
] == '-') ) {
464 if ( current
== _("ctrl") )
465 accelFlags
|= wxACCEL_CTRL
;
466 else if ( current
== _("alt") )
467 accelFlags
|= wxACCEL_ALT
;
468 else if ( current
== _("shift") )
469 accelFlags
|= wxACCEL_SHIFT
;
471 wxLogDebug(wxT("Unknown accel modifier: '%s'"),
478 current
+= wxTolower(label
[n
]);
482 if ( current
.IsEmpty() ) {
483 wxLogDebug(wxT("No accel key found, accel string ignored."));
486 if ( current
.Len() == 1 ) {
488 keyCode
= wxToupper(current
[0U]);
491 // is it a function key?
492 if ( current
[0U] == 'f' && isdigit(current
[1U]) &&
493 (current
.Len() == 2 ||
494 (current
.Len() == 3 && isdigit(current
[2U]))) ) {
496 wxSscanf(current
.c_str() + 1, wxT("%d"), &n
);
498 keyCode
= WXK_F1
+ n
- 1;
501 #if 0 // this is not supported by GTK+, apparently
502 // several special cases
504 if ( current
== wxT("DEL") ) {
507 else if ( current
== wxT("PGUP") ) {
510 else if ( current
== wxT("PGDN") ) {
516 wxLogDebug(wxT("Unrecognized accel key '%s', accel "
517 "string ignored."), current
.c_str());
524 // we do have something
525 return new wxAcceleratorEntry(accelFlags
, keyCode
);
529 return (wxAcceleratorEntry
*)NULL
;
532 #endif // wxUSE_ACCEL
534 // ----------------------------------------------------------------------------
535 // Window search functions
536 // ----------------------------------------------------------------------------
539 * If parent is non-NULL, look through children for a label or title
540 * matching the specified string. If NULL, look through all top-level windows.
545 wxFindWindowByLabel (const wxString
& title
, wxWindow
* parent
)
549 return wxFindWindowByLabel1(title
, parent
);
553 for ( wxWindowList::Node
* node
= wxTopLevelWindows
.GetFirst();
555 node
= node
->GetNext() )
557 wxWindow
*win
= node
->GetData();
558 wxWindow
*retwin
= wxFindWindowByLabel1 (title
, win
);
564 return (wxWindow
*) NULL
;
569 wxFindWindowByLabel1 (const wxString
& title
, wxWindow
* parent
)
573 if (parent
->GetLabel() == title
)
579 for ( wxWindowList::Node
* node
= parent
->GetChildren().GetFirst();
581 node
= node
->GetNext() )
583 wxWindow
*win
= (wxWindow
*)node
->GetData();
584 wxWindow
*retwin
= wxFindWindowByLabel1 (title
, win
);
591 return (wxWindow
*) NULL
; // Not found
595 * If parent is non-NULL, look through children for a name
596 * matching the specified string. If NULL, look through all top-level windows.
601 wxFindWindowByName (const wxString
& title
, wxWindow
* parent
)
605 return wxFindWindowByName1 (title
, parent
);
609 for ( wxWindowList::Node
* node
= wxTopLevelWindows
.GetFirst();
611 node
= node
->GetNext() )
613 wxWindow
*win
= node
->GetData();
614 wxWindow
*retwin
= wxFindWindowByName1 (title
, win
);
621 // Failed? Try by label instead.
622 return wxFindWindowByLabel(title
, parent
);
627 wxFindWindowByName1 (const wxString
& title
, wxWindow
* parent
)
631 if ( parent
->GetName() == title
)
637 for (wxNode
* node
= parent
->GetChildren().First (); node
; node
= node
->Next ())
639 wxWindow
*win
= (wxWindow
*) node
->Data ();
640 wxWindow
*retwin
= wxFindWindowByName1 (title
, win
);
647 return (wxWindow
*) NULL
; // Not found
651 // Returns menu item id or -1 if none.
653 wxFindMenuItemId (wxFrame
* frame
, const wxString
& menuString
, const wxString
& itemString
)
655 wxMenuBar
*menuBar
= frame
->GetMenuBar ();
658 return menuBar
->FindMenuItem (menuString
, itemString
);
664 On Fri, 21 Jul 1995, Paul Craven wrote:
666 > Is there a way to find the path of running program's executable? I can get
667 > my home directory, and the current directory, but I don't know how to get the
668 > executable directory.
671 The code below (warty as it is), does what you want on most Unix,
672 DOS, and Mac platforms (it's from the ALS Prolog main).
674 || Ken Bowen Applied Logic Systems, Inc. PO Box 180,
675 ||==== Voice: +1 (617)965-9191 Newton Centre,
676 || FAX: +1 (617)965-1636 MA 02159 USA
677 Email: ken@als.com WWW: http://www.als.com
678 ------------------------------------------------------------------------
681 // This code is commented out but it may be integrated with wxWin at
682 // a later date, after testing. Thanks Ken!
685 /*--------------------------------------------------------------------*
686 | whereami is given a filename f in the form: whereami(argv[0])
687 | It returns the directory in which the executable file (containing
688 | this code [main.c] ) may be found. A dot will be returned to indicate
689 | the current directory.
690 *--------------------------------------------------------------------*/
696 register char *cutoff
= NULL
; /* stifle -Wall */
703 * See if the file is accessible either through the current directory
704 * or through an absolute path.
707 if (access(name
, R_OK
) == 0) {
709 /*-------------------------------------------------------------*
710 * The file was accessible without any other work. But the current
711 * working directory might change on us, so if it was accessible
712 * through the cwd, then we should get it for later accesses.
713 *-------------------------------------------------------------*/
716 if (!absolute_pathname(name
)) {
717 #if defined(DOS) || defined(__WIN32__)
723 if (*(name
+ 1) == ':') {
724 if (*name
>= 'a' && *name
<= 'z')
725 drive
= (int) (*name
- 'a' + 1);
727 drive
= (int) (*name
- 'A' + 1);
729 *newrbuf
++ = *(name
+ 1);
730 *newrbuf
++ = DIR_SEPARATOR
;
734 *newrbuf
++ = DIR_SEPARATOR
;
736 if (getcwd(newrbuf
, drive
) == 0) { /* } */
738 if (getcwd(newrbuf
, 1024) == 0) { /* } */
742 if (getwd(imagedir
) == 0) { /* } */
743 #else /* !HAVE_GETWD */
744 if (getcwd(imagedir
, 1024) == 0) {
745 #endif /* !HAVE_GETWD */
747 fatal_error(FE_GETCWD
, 0);
749 for (; *t
; t
++) /* Set t to end of buffer */
751 if (*(t
- 1) == DIR_SEPARATOR
) /* leave slash if already
756 cutoff
= t
; /* otherwise put one in */
757 *t
++ = DIR_SEPARATOR
;
760 #if (!defined(__MAC__) && !defined(__DJGPP__) && !defined(__GO32__) && !defined(__WIN32__))
762 (*t
++ = DIR_SEPARATOR
);
765 /*-------------------------------------------------------------*
766 * Copy the rest of the string and set the cutoff if it was not
767 * already set. If the first character of name is a slash, cutoff
768 * is not presently set but will be on the first iteration of the
770 *-------------------------------------------------------------*/
772 for ((*name
== DIR_SEPARATOR
? (s
= name
+1) : (s
= name
));;) {
773 if (*s
== DIR_SEPARATOR
)
782 /*-------------------------------------------------------------*
783 * Get the path list from the environment. If the path list is
784 * inaccessible for any reason, leave with fatal error.
785 *-------------------------------------------------------------*/
788 if ((s
= getenv("Commands")) == (char *) 0)
790 if ((s
= getenv("PATH")) == (char *) 0)
792 fatal_error(FE_PATH
, 0);
795 * Copy path list into ebuf and set the source pointer to the
796 * beginning of this buffer.
804 while (*s
&& *s
!= PATH_SEPARATOR
)
806 if (t
> imagedir
&& *(t
- 1) == DIR_SEPARATOR
)
807 ; /* do nothing -- slash already is in place */
809 *t
++ = DIR_SEPARATOR
; /* put in the slash */
810 cutoff
= t
- 1; /* set cutoff */
812 if (access(imagedir
, R_OK
) == 0)
816 s
++; /* advance source pointer */
818 fatal_error(FE_INFND
, 0);
823 /*-------------------------------------------------------------*
824 | At this point the full pathname should exist in imagedir and
825 | cutoff should be set to the final slash. We must now determine
826 | whether the file name is a symbolic link or not and chase it down
827 | if it is. Note that we reuse ebuf for getting the link.
828 *-------------------------------------------------------------*/
831 while ((cc
= readlink(imagedir
, ebuf
, 512)) != -1) {
834 if (*s
== DIR_SEPARATOR
) {
841 if (*s
== DIR_SEPARATOR
)
842 cutoff
= t
; /* mark the last slash seen */
843 if (!(*t
++ = *s
++)) /* copy the character */
848 #endif /* HAVE_SYMLINK */
850 strcpy(imagename
, cutoff
+ 1); /* keep the image name */
851 *(cutoff
+ 1) = 0; /* chop off the filename part */
858 // ----------------------------------------------------------------------------
860 // ----------------------------------------------------------------------------
863 * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
864 * since otherwise the generic code may be pulled in unnecessarily.
867 int wxMessageBox(const wxString
& message
, const wxString
& caption
, long style
,
868 wxWindow
*parent
, int WXUNUSED(x
), int WXUNUSED(y
) )
870 wxMessageDialog
dialog(parent
, message
, caption
, style
);
872 int ans
= dialog
.ShowModal();
888 wxString
wxGetTextFromUser(const wxString
& message
, const wxString
& caption
,
889 const wxString
& defaultValue
, wxWindow
*parent
,
890 int x
, int y
, bool WXUNUSED(centre
) )
893 wxTextEntryDialog
dialog(parent
, message
, caption
, defaultValue
, wxOK
|wxCANCEL
, wxPoint(x
, y
));
894 if (dialog
.ShowModal() == wxID_OK
)
896 str
= dialog
.GetValue();
902 wxString
wxGetPasswordFromUser(const wxString
& message
,
903 const wxString
& caption
,
904 const wxString
& defaultValue
,
908 wxTextEntryDialog
dialog(parent
, message
, caption
, defaultValue
,
909 wxOK
| wxCANCEL
| wxTE_PASSWORD
);
910 if ( dialog
.ShowModal() == wxID_OK
)
912 str
= dialog
.GetValue();
918 #endif // wxUSE_TEXTDLG
920 wxColour
wxGetColourFromUser(wxWindow
*parent
, const wxColour
& colInit
)
923 data
.SetChooseFull(TRUE
);
926 data
.SetColour((wxColour
&)colInit
); // const_cast
930 wxColourDialog
dialog(parent
, &data
);
931 if ( dialog
.ShowModal() == wxID_OK
)
933 colRet
= dialog
.GetColourData().GetColour();
935 //else: leave it invalid
940 // ----------------------------------------------------------------------------
941 // missing C RTL functions (FIXME shouldn't be here at all)
942 // ----------------------------------------------------------------------------
945 char *strdup(const char *s
)
947 return strcpy( (char*) malloc( strlen( s
) + 1 ) , s
) ;
952 return ( c
>= 0 && c
< 128 ) ;
956 // ----------------------------------------------------------------------------
957 // wxSafeYield and supporting functions
958 // ----------------------------------------------------------------------------
960 void wxEnableTopLevelWindows(bool enable
)
962 wxWindowList::Node
*node
;
963 for ( node
= wxTopLevelWindows
.GetFirst(); node
; node
= node
->GetNext() )
964 node
->GetData()->Enable(enable
);
967 wxWindowDisabler::wxWindowDisabler(wxWindow
*winToSkip
)
971 // and the top level window too
972 HWND hwndFG
= ::GetForegroundWindow();
973 m_winTop
= hwndFG
? wxFindWinFromHandle((WXHWND
)hwndFG
) : (wxWindow
*)NULL
;
975 HWND hwndFG
= ::GetTopWindow(0);
976 m_winTop
= hwndFG
? wxFindWinFromHandle((WXHWND
)hwndFG
) : (wxWindow
*)NULL
;
980 // remember the top level windows which were already disabled, so that we
981 // don't reenable them later
982 m_winDisabled
= NULL
;
984 wxWindowList::Node
*node
;
985 for ( node
= wxTopLevelWindows
.GetFirst(); node
; node
= node
->GetNext() )
987 wxWindow
*winTop
= node
->GetData();
988 if ( winTop
== winToSkip
)
991 if ( winTop
->IsEnabled() )
997 if ( !m_winDisabled
)
999 m_winDisabled
= new wxWindowList
;
1002 m_winDisabled
->Append(winTop
);
1007 wxWindowDisabler::~wxWindowDisabler()
1009 wxWindowList::Node
*node
;
1010 for ( node
= wxTopLevelWindows
.GetFirst(); node
; node
= node
->GetNext() )
1012 wxWindow
*winTop
= node
->GetData();
1013 if ( !m_winDisabled
|| !m_winDisabled
->Find(winTop
) )
1017 //else: had been already disabled, don't reenable
1020 delete m_winDisabled
;
1026 if ( !::SetForegroundWindow(GetHwndOf(m_winTop
)) )
1028 wxLogLastError("SetForegroundWindow");
1034 // 16-bit SetForegroundWindow() replacement
1036 GetWindowRect((HWND
) m_winTop
, &reWin
);
1037 SetWindowPos ((HWND
) m_winTop
, HWND_TOP
,
1038 reWin
.left
, reWin
.top
,
1039 reWin
.right
- reWin
.left
, reWin
.bottom
,
1046 // Yield to other apps/messages and disable user input to all windows except
1048 bool wxSafeYield(wxWindow
*win
)
1050 wxWindowDisabler wd
;
1052 bool rc
= wxYield();
1057 // ----------------------------------------------------------------------------
1059 // ----------------------------------------------------------------------------
1061 // Don't synthesize KeyUp events holding down a key and producing KeyDown
1062 // events with autorepeat. On by default and always on in wxMSW. wxGTK version
1065 bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag
) )
1067 return TRUE
; // detectable auto-repeat is the only mode MSW supports
1073 // ----------------------------------------------------------------------------
1074 // network and user id functions
1075 // ----------------------------------------------------------------------------
1077 // Get Full RFC822 style email address
1078 bool wxGetEmailAddress(wxChar
*address
, int maxSize
)
1080 wxString email
= wxGetEmailAddress();
1084 wxStrncpy(address
, email
, maxSize
- 1);
1085 address
[maxSize
- 1] = wxT('\0');
1090 wxString
wxGetEmailAddress()
1094 wxString host
= wxGetHostName();
1097 wxString user
= wxGetUserId();
1100 wxString
email(user
);
1101 email
<< wxT('@') << host
;
1108 wxString
wxGetUserId()
1110 static const int maxLoginLen
= 256; // FIXME arbitrary number
1113 bool ok
= wxGetUserId(buf
.GetWriteBuf(maxLoginLen
), maxLoginLen
);
1114 buf
.UngetWriteBuf();
1122 wxString
wxGetUserName()
1124 static const int maxUserNameLen
= 1024; // FIXME arbitrary number
1127 bool ok
= wxGetUserName(buf
.GetWriteBuf(maxUserNameLen
), maxUserNameLen
);
1128 buf
.UngetWriteBuf();
1136 wxString
wxGetHostName()
1138 static const size_t hostnameSize
= 257;
1141 bool ok
= wxGetHostName(buf
.GetWriteBuf(hostnameSize
), hostnameSize
);
1143 buf
.UngetWriteBuf();
1151 wxString
wxGetFullHostName()
1153 static const size_t hostnameSize
= 257;
1156 bool ok
= wxGetFullHostName(buf
.GetWriteBuf(hostnameSize
), hostnameSize
);
1158 buf
.UngetWriteBuf();
1166 wxString
wxGetHomeDir()
1169 wxGetHomeDir(&home
);
1176 wxString
wxGetCurrentDir()
1183 ok
= getcwd(dir
.GetWriteBuf(len
+ 1), len
) != NULL
;
1184 dir
.UngetWriteBuf();
1188 if ( errno
!= ERANGE
)
1190 wxLogSysError(_T("Failed to get current directory"));
1192 return wxEmptyString
;
1196 // buffer was too small, retry with a larger one
1208 // ----------------------------------------------------------------------------
1210 // ----------------------------------------------------------------------------
1212 long wxExecute(const wxString
& command
, wxArrayString
& output
)
1215 wxFAIL_MSG("Sorry, this version of wxExecute not implemented on WIN16.");
1218 // create a wxProcess which will capture the output
1219 wxProcess
*process
= new wxProcess
;
1220 process
->Redirect();
1222 long rc
= wxExecute(command
, TRUE
/* sync */, process
);
1225 wxInputStream
& is
= *process
->GetInputStream();
1226 wxTextInputStream
tis(is
);
1227 while ( !is
.Eof() && is
.IsOk() )
1229 wxString line
= tis
.ReadLine();
1230 if ( is
.LastError() )