]>
Commit | Line | Data |
---|---|---|
c801d85f KB |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: utilscmn.cpp | |
3 | // Purpose: Miscellaneous utility functions and classes | |
4 | // Author: Julian Smart | |
5 | // Modified by: | |
6 | // Created: 29/01/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 1998 Julian Smart | |
3f4a0c5b | 9 | // Licence: wxWindows license |
c801d85f KB |
10 | ///////////////////////////////////////////////////////////////////////////// |
11 | ||
e90c1d2a VZ |
12 | // ============================================================================ |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
c801d85f | 20 | #ifdef __GNUG__ |
e90c1d2a | 21 | #pragma implementation "utils.h" |
c801d85f KB |
22 | #endif |
23 | ||
24 | // For compilers that support precompilation, includes "wx.h". | |
25 | #include "wx/wxprec.h" | |
26 | ||
27 | #ifdef __BORLANDC__ | |
e90c1d2a | 28 | #pragma hdrstop |
c801d85f KB |
29 | #endif |
30 | ||
31 | #ifndef WX_PRECOMP | |
e90c1d2a VZ |
32 | #include "wx/defs.h" |
33 | #include "wx/string.h" | |
34 | #include "wx/utils.h" | |
974e8d94 VZ |
35 | #include "wx/intl.h" |
36 | #include "wx/log.h" | |
e90c1d2a VZ |
37 | |
38 | #if wxUSE_GUI | |
39 | #include "wx/window.h" | |
40 | #include "wx/menu.h" | |
41 | #include "wx/frame.h" | |
42 | #include "wx/msgdlg.h" | |
43 | #include "wx/textdlg.h" | |
974e8d94 VZ |
44 | #if wxUSE_ACCEL |
45 | #include "wx/menuitem.h" | |
46 | #include "wx/accel.h" | |
47 | #endif // wxUSE_ACCEL | |
e90c1d2a VZ |
48 | #endif // wxUSE_GUI |
49 | #endif // WX_PRECOMP | |
c801d85f | 50 | |
cd6ce4a9 VZ |
51 | #include "wx/process.h" |
52 | #include "wx/txtstrm.h" | |
53 | ||
c801d85f KB |
54 | #include <ctype.h> |
55 | #include <stdio.h> | |
56 | #include <stdlib.h> | |
57 | #include <string.h> | |
e90c1d2a | 58 | |
c801d85f | 59 | #if !defined(__WATCOMC__) |
3f4a0c5b VZ |
60 | #if !(defined(_MSC_VER) && (_MSC_VER > 800)) |
61 | #include <errno.h> | |
62 | #endif | |
c801d85f | 63 | #endif |
e90c1d2a | 64 | |
91b4c08d VZ |
65 | #if wxUSE_GUI |
66 | #include "wx/colordlg.h" | |
67 | #endif // wxUSE_GUI | |
68 | ||
c801d85f | 69 | #include <time.h> |
e90c1d2a | 70 | |
469e1e5c | 71 | #ifndef __MWERKS__ |
e90c1d2a VZ |
72 | #include <sys/types.h> |
73 | #include <sys/stat.h> | |
469e1e5c | 74 | #endif |
c801d85f | 75 | |
ce3ed50d | 76 | #ifdef __SALFORDC__ |
e90c1d2a | 77 | #include <clib.h> |
ce3ed50d JS |
78 | #endif |
79 | ||
2049ba38 | 80 | #ifdef __WXMSW__ |
5e1febfa | 81 | #include "wx/msw/private.h" |
c801d85f KB |
82 | #endif |
83 | ||
e90c1d2a VZ |
84 | // ---------------------------------------------------------------------------- |
85 | // function protoypes | |
86 | // ---------------------------------------------------------------------------- | |
87 | ||
88 | #if wxUSE_GUI | |
89 | static wxWindow *wxFindWindowByLabel1(const wxString& title, wxWindow *parent); | |
90 | static wxWindow *wxFindWindowByName1 (const wxString& title, wxWindow *parent); | |
91 | #endif // wxUSE_GUI | |
c801d85f | 92 | |
e90c1d2a VZ |
93 | // ============================================================================ |
94 | // implementation | |
95 | // ============================================================================ | |
c801d85f | 96 | |
e146b8c8 | 97 | // ---------------------------------------------------------------------------- |
e90c1d2a | 98 | // string functions |
e146b8c8 VZ |
99 | // ---------------------------------------------------------------------------- |
100 | ||
17dff81c SC |
101 | #ifdef __WXMAC__ |
102 | int strcasecmp(const char *str_1, const char *str_2) | |
103 | { | |
104 | register char c1, c2; | |
105 | do { | |
106 | c1 = tolower(*str_1++); | |
107 | c2 = tolower(*str_2++); | |
108 | } while ( c1 && (c1 == c2) ); | |
109 | ||
110 | return c1 - c2; | |
111 | } | |
112 | ||
113 | int strncasecmp(const char *str_1, const char *str_2, size_t maxchar) | |
114 | { | |
115 | ||
116 | register char c1, c2; | |
3f4a0c5b | 117 | while( maxchar--) |
17dff81c SC |
118 | { |
119 | c1 = tolower(*str_1++); | |
120 | c2 = tolower(*str_2++); | |
3f4a0c5b | 121 | |
17dff81c | 122 | if ( !c1 || c1!=c2 ) |
3f4a0c5b VZ |
123 | return c1 - c2; |
124 | ||
17dff81c SC |
125 | } ; |
126 | ||
127 | return 0 ; | |
128 | ||
129 | } | |
e90c1d2a VZ |
130 | #endif // wxMAC |
131 | ||
7e72d7aa | 132 | #if defined( __VMS__ ) && ( __VMS_VER < 70000000 ) |
c801d85f KB |
133 | // we have no strI functions under VMS, therefore I have implemented |
134 | // an inefficient but portable version: convert copies of strings to lowercase | |
135 | // and then use the normal comparison | |
136 | static void myLowerString(char *s) | |
137 | { | |
138 | while(*s){ | |
139 | if(isalpha(*s)) *s = (char)tolower(*s); | |
140 | s++; | |
141 | } | |
142 | } | |
143 | ||
144 | int strcasecmp(const char *str_1, const char *str_2) | |
145 | { | |
146 | char *temp1 = new char[strlen(str_1)+1]; | |
147 | char *temp2 = new char[strlen(str_2)+1]; | |
148 | strcpy(temp1,str_1); | |
149 | strcpy(temp2,str_2); | |
150 | myLowerString(temp1); | |
151 | myLowerString(temp2); | |
152 | ||
81c67e27 | 153 | int result = wxStrcmp(temp1,temp2); |
c801d85f KB |
154 | delete[] temp1; |
155 | delete[] temp2; | |
156 | ||
157 | return(result); | |
158 | } | |
159 | ||
160 | int strncasecmp(const char *str_1, const char *str_2, size_t maxchar) | |
161 | { | |
162 | char *temp1 = new char[strlen(str_1)+1]; | |
163 | char *temp2 = new char[strlen(str_2)+1]; | |
164 | strcpy(temp1,str_1); | |
165 | strcpy(temp2,str_2); | |
166 | myLowerString(temp1); | |
167 | myLowerString(temp2); | |
168 | ||
169 | int result = strncmp(temp1,temp2,maxchar); | |
170 | delete[] temp1; | |
171 | delete[] temp2; | |
172 | ||
173 | return(result); | |
174 | } | |
e90c1d2a | 175 | #endif // __VMS__ |
c801d85f | 176 | |
34138703 | 177 | #ifdef __WINDOWS__ |
c801d85f KB |
178 | |
179 | #ifndef __GNUWIN32__ | |
469e1e5c | 180 | #ifndef __MWERKS__ |
c801d85f KB |
181 | #define strcasecmp stricmp |
182 | #define strncasecmp strnicmp | |
469e1e5c SC |
183 | #else |
184 | #define strcasecmp _stricmp | |
185 | #define strncasecmp _strnicmp | |
186 | #endif | |
c801d85f KB |
187 | #endif |
188 | ||
c801d85f | 189 | #else |
91b8de8d RR |
190 | |
191 | #ifdef __EMX__ | |
192 | #define strcasecmp stricmp | |
193 | #define strncasecmp strnicmp | |
194 | #endif | |
195 | ||
c801d85f KB |
196 | // This declaration is missing in SunOS! |
197 | // (Yes, I know it is NOT ANSI-C but its in BSD libc) | |
198 | #if defined(__xlC) || defined(__AIX__) || defined(__GNUG__) | |
199 | extern "C" | |
200 | { | |
201 | int strcasecmp (const char *, const char *); | |
202 | int strncasecmp (const char *, const char *, size_t); | |
203 | } | |
204 | #endif | |
3f4a0c5b | 205 | #endif /* __WXMSW__ */ |
c801d85f | 206 | |
717b9bf2 DW |
207 | #ifdef __WXPM__ |
208 | #define strcasecmp stricmp | |
209 | #define strncasecmp strnicmp | |
210 | #endif | |
c801d85f | 211 | |
0080691b OK |
212 | wxChar * |
213 | copystring (const wxChar *s) | |
c801d85f | 214 | { |
223d09f6 | 215 | if (s == NULL) s = wxT(""); |
0080691b | 216 | size_t len = wxStrlen (s) + 1; |
c801d85f | 217 | |
0080691b OK |
218 | wxChar *news = new wxChar[len]; |
219 | memcpy (news, s, len * sizeof(wxChar)); // Should be the fastest | |
c801d85f KB |
220 | |
221 | return news; | |
222 | } | |
223 | ||
224 | // Id generation | |
225 | static long wxCurrentId = 100; | |
226 | ||
3f4a0c5b | 227 | long |
c801d85f KB |
228 | wxNewId (void) |
229 | { | |
230 | return wxCurrentId++; | |
231 | } | |
232 | ||
233 | long | |
234 | wxGetCurrentId(void) { return wxCurrentId; } | |
235 | ||
3f4a0c5b | 236 | void |
c801d85f KB |
237 | wxRegisterId (long id) |
238 | { | |
239 | if (id >= wxCurrentId) | |
240 | wxCurrentId = id + 1; | |
241 | } | |
242 | ||
3f4a0c5b | 243 | void |
0080691b | 244 | StringToFloat (wxChar *s, float *number) |
c801d85f KB |
245 | { |
246 | if (s && *s && number) | |
0080691b | 247 | *number = (float) wxStrtod (s, (wxChar **) NULL); |
c801d85f KB |
248 | } |
249 | ||
3f4a0c5b | 250 | void |
0080691b | 251 | StringToDouble (wxChar *s, double *number) |
c801d85f KB |
252 | { |
253 | if (s && *s && number) | |
0080691b | 254 | *number = wxStrtod (s, (wxChar **) NULL); |
c801d85f KB |
255 | } |
256 | ||
0080691b OK |
257 | wxChar * |
258 | FloatToString (float number, const wxChar *fmt) | |
c801d85f | 259 | { |
0080691b | 260 | static wxChar buf[256]; |
c801d85f KB |
261 | |
262 | // sprintf (buf, "%.2f", number); | |
0080691b | 263 | wxSprintf (buf, fmt, number); |
c801d85f KB |
264 | return buf; |
265 | } | |
266 | ||
0080691b OK |
267 | wxChar * |
268 | DoubleToString (double number, const wxChar *fmt) | |
c801d85f | 269 | { |
0080691b | 270 | static wxChar buf[256]; |
c801d85f | 271 | |
0080691b | 272 | wxSprintf (buf, fmt, number); |
c801d85f KB |
273 | return buf; |
274 | } | |
275 | ||
3f4a0c5b | 276 | void |
0080691b | 277 | StringToInt (wxChar *s, int *number) |
c801d85f KB |
278 | { |
279 | if (s && *s && number) | |
0080691b | 280 | *number = (int) wxStrtol (s, (wxChar **) NULL, 10); |
c801d85f KB |
281 | } |
282 | ||
3f4a0c5b | 283 | void |
0080691b | 284 | StringToLong (wxChar *s, long *number) |
c801d85f KB |
285 | { |
286 | if (s && *s && number) | |
0080691b | 287 | *number = wxStrtol (s, (wxChar **) NULL, 10); |
c801d85f KB |
288 | } |
289 | ||
84fff0b3 | 290 | wxChar * |
c801d85f KB |
291 | IntToString (int number) |
292 | { | |
84fff0b3 | 293 | static wxChar buf[20]; |
c801d85f | 294 | |
223d09f6 | 295 | wxSprintf (buf, wxT("%d"), number); |
c801d85f KB |
296 | return buf; |
297 | } | |
298 | ||
84fff0b3 | 299 | wxChar * |
c801d85f KB |
300 | LongToString (long number) |
301 | { | |
84fff0b3 | 302 | static wxChar buf[20]; |
c801d85f | 303 | |
223d09f6 | 304 | wxSprintf (buf, wxT("%ld"), number); |
c801d85f KB |
305 | return buf; |
306 | } | |
307 | ||
308 | // Array used in DecToHex conversion routine. | |
223d09f6 | 309 | static wxChar hexArray[] = wxT("0123456789ABCDEF"); |
c801d85f KB |
310 | |
311 | // Convert 2-digit hex number to decimal | |
fd71308f | 312 | int wxHexToDec(const wxString& buf) |
c801d85f KB |
313 | { |
314 | int firstDigit, secondDigit; | |
3f4a0c5b | 315 | |
223d09f6 KB |
316 | if (buf.GetChar(0) >= wxT('A')) |
317 | firstDigit = buf.GetChar(0) - wxT('A') + 10; | |
c801d85f | 318 | else |
223d09f6 | 319 | firstDigit = buf.GetChar(0) - wxT('0'); |
c801d85f | 320 | |
223d09f6 KB |
321 | if (buf.GetChar(1) >= wxT('A')) |
322 | secondDigit = buf.GetChar(1) - wxT('A') + 10; | |
c801d85f | 323 | else |
223d09f6 | 324 | secondDigit = buf.GetChar(1) - wxT('0'); |
3f4a0c5b | 325 | |
c801d85f KB |
326 | return firstDigit * 16 + secondDigit; |
327 | } | |
328 | ||
329 | // Convert decimal integer to 2-character hex string | |
84fff0b3 | 330 | void wxDecToHex(int dec, wxChar *buf) |
c801d85f KB |
331 | { |
332 | int firstDigit = (int)(dec/16.0); | |
333 | int secondDigit = (int)(dec - (firstDigit*16.0)); | |
334 | buf[0] = hexArray[firstDigit]; | |
335 | buf[1] = hexArray[secondDigit]; | |
336 | buf[2] = 0; | |
337 | } | |
338 | ||
fd71308f JS |
339 | // Convert decimal integer to 2-character hex string |
340 | wxString wxDecToHex(int dec) | |
341 | { | |
84fff0b3 | 342 | wxChar buf[3]; |
fd71308f JS |
343 | wxDecToHex(dec, buf); |
344 | return wxString(buf); | |
345 | } | |
346 | ||
c801d85f | 347 | // Match a string INDEPENDENT OF CASE |
3f4a0c5b | 348 | bool |
c801d85f KB |
349 | StringMatch (char *str1, char *str2, bool subString, bool exact) |
350 | { | |
351 | if (str1 == NULL || str2 == NULL) | |
352 | return FALSE; | |
353 | if (str1 == str2) | |
354 | return TRUE; | |
355 | ||
356 | if (subString) | |
357 | { | |
358 | int len1 = strlen (str1); | |
359 | int len2 = strlen (str2); | |
360 | int i; | |
361 | ||
362 | // Search for str1 in str2 | |
363 | // Slow .... but acceptable for short strings | |
364 | for (i = 0; i <= len2 - len1; i++) | |
3f4a0c5b VZ |
365 | { |
366 | if (strncasecmp (str1, str2 + i, len1) == 0) | |
367 | return TRUE; | |
368 | } | |
c801d85f KB |
369 | } |
370 | else if (exact) | |
371 | { | |
372 | if (strcasecmp (str1, str2) == 0) | |
3f4a0c5b | 373 | return TRUE; |
c801d85f KB |
374 | } |
375 | else | |
376 | { | |
377 | int len1 = strlen (str1); | |
378 | int len2 = strlen (str2); | |
379 | ||
380 | if (strncasecmp (str1, str2, wxMin (len1, len2)) == 0) | |
3f4a0c5b | 381 | return TRUE; |
c801d85f KB |
382 | } |
383 | ||
384 | return FALSE; | |
385 | } | |
386 | ||
387 | // Return the current date/time | |
388 | // [volatile] | |
e90c1d2a | 389 | wxString wxNow() |
c801d85f | 390 | { |
c67daf87 | 391 | time_t now = time((time_t *) NULL); |
3f4a0c5b | 392 | char *date = ctime(&now); |
c801d85f KB |
393 | date[24] = '\0'; |
394 | return wxString(date); | |
395 | } | |
396 | ||
e90c1d2a VZ |
397 | #if wxUSE_GUI |
398 | ||
399 | // ---------------------------------------------------------------------------- | |
974e8d94 | 400 | // Menu accelerators related functions |
e90c1d2a | 401 | // ---------------------------------------------------------------------------- |
c801d85f | 402 | |
0080691b | 403 | wxChar *wxStripMenuCodes (wxChar *in, wxChar *out) |
c801d85f KB |
404 | { |
405 | if (!in) | |
0080691b | 406 | return (wxChar *) NULL; |
3f4a0c5b | 407 | |
c801d85f KB |
408 | if (!out) |
409 | out = copystring(in); | |
410 | ||
0080691b | 411 | wxChar *tmpOut = out; |
3f4a0c5b | 412 | |
c801d85f KB |
413 | while (*in) |
414 | { | |
223d09f6 | 415 | if (*in == wxT('&')) |
3f4a0c5b VZ |
416 | { |
417 | // Check && -> &, &x -> x | |
223d09f6 | 418 | if (*++in == wxT('&')) |
3f4a0c5b VZ |
419 | *out++ = *in++; |
420 | } | |
223d09f6 | 421 | else if (*in == wxT('\t')) |
3f4a0c5b | 422 | { |
c801d85f KB |
423 | // Remove all stuff after \t in X mode, and let the stuff as is |
424 | // in Windows mode. | |
425 | // Accelerators are handled in wx_item.cc for Motif, and are not | |
426 | // YET supported in XView | |
3f4a0c5b VZ |
427 | break; |
428 | } | |
c801d85f | 429 | else |
3f4a0c5b VZ |
430 | *out++ = *in++; |
431 | } // while | |
c801d85f | 432 | |
223d09f6 | 433 | *out = wxT('\0'); |
c801d85f KB |
434 | |
435 | return tmpOut; | |
436 | } | |
437 | ||
47bc1060 JS |
438 | wxString wxStripMenuCodes(const wxString& str) |
439 | { | |
84fff0b3 OK |
440 | wxChar *buf = new wxChar[str.Length() + 1]; |
441 | wxStripMenuCodes(WXSTRINGCAST str, buf); | |
47bc1060 JS |
442 | wxString str1(buf); |
443 | delete[] buf; | |
444 | return str1; | |
445 | } | |
c801d85f | 446 | |
974e8d94 VZ |
447 | #if wxUSE_ACCEL |
448 | ||
449 | // return wxAcceleratorEntry for the given menu string or NULL if none | |
450 | // specified | |
451 | wxAcceleratorEntry *wxGetAccelFromString(const wxString& label) | |
452 | { | |
453 | // check for accelerators: they are given after '\t' | |
454 | int posTab = label.Find(wxT('\t')); | |
455 | if ( posTab != wxNOT_FOUND ) { | |
456 | // parse the accelerator string | |
457 | int keyCode = 0; | |
458 | int accelFlags = wxACCEL_NORMAL; | |
459 | wxString current; | |
460 | for ( size_t n = (size_t)posTab + 1; n < label.Len(); n++ ) { | |
461 | if ( (label[n] == '+') || (label[n] == '-') ) { | |
462 | if ( current == _("ctrl") ) | |
463 | accelFlags |= wxACCEL_CTRL; | |
464 | else if ( current == _("alt") ) | |
465 | accelFlags |= wxACCEL_ALT; | |
466 | else if ( current == _("shift") ) | |
467 | accelFlags |= wxACCEL_SHIFT; | |
468 | else { | |
469 | wxLogDebug(wxT("Unknown accel modifier: '%s'"), | |
470 | current.c_str()); | |
471 | } | |
472 | ||
473 | current.Empty(); | |
474 | } | |
475 | else { | |
476 | current += wxTolower(label[n]); | |
477 | } | |
478 | } | |
479 | ||
480 | if ( current.IsEmpty() ) { | |
481 | wxLogDebug(wxT("No accel key found, accel string ignored.")); | |
482 | } | |
483 | else { | |
484 | if ( current.Len() == 1 ) { | |
485 | // it's a letter | |
486 | keyCode = wxToupper(current[0U]); | |
487 | } | |
488 | else { | |
489 | // is it a function key? | |
490 | if ( current[0U] == 'f' && isdigit(current[1U]) && | |
491 | (current.Len() == 2 || | |
492 | (current.Len() == 3 && isdigit(current[2U]))) ) { | |
493 | int n; | |
494 | wxSscanf(current.c_str() + 1, wxT("%d"), &n); | |
495 | ||
496 | keyCode = WXK_F1 + n - 1; | |
497 | } | |
498 | else { | |
499 | #if 0 // this is not supported by GTK+, apparently | |
500 | // several special cases | |
501 | current.MakeUpper(); | |
502 | if ( current == wxT("DEL") ) { | |
503 | keyCode = VK_DELETE; | |
504 | } | |
505 | else if ( current == wxT("PGUP") ) { | |
506 | keyCode = VK_PRIOR; | |
507 | } | |
508 | else if ( current == wxT("PGDN") ) { | |
509 | keyCode = VK_NEXT; | |
510 | } | |
511 | else | |
512 | #endif // 0 | |
513 | { | |
514 | wxLogDebug(wxT("Unrecognized accel key '%s', accel " | |
515 | "string ignored."), current.c_str()); | |
516 | } | |
517 | } | |
518 | } | |
519 | } | |
520 | ||
521 | if ( keyCode ) { | |
522 | // we do have something | |
523 | return new wxAcceleratorEntry(accelFlags, keyCode); | |
524 | } | |
525 | } | |
526 | ||
bbeb6c2b | 527 | return (wxAcceleratorEntry *)NULL; |
974e8d94 VZ |
528 | } |
529 | ||
530 | #endif // wxUSE_ACCEL | |
531 | ||
e90c1d2a VZ |
532 | // ---------------------------------------------------------------------------- |
533 | // Window search functions | |
534 | // ---------------------------------------------------------------------------- | |
c801d85f KB |
535 | |
536 | /* | |
537 | * If parent is non-NULL, look through children for a label or title | |
538 | * matching the specified string. If NULL, look through all top-level windows. | |
539 | * | |
540 | */ | |
541 | ||
c801d85f KB |
542 | wxWindow * |
543 | wxFindWindowByLabel (const wxString& title, wxWindow * parent) | |
544 | { | |
e146b8c8 | 545 | if (parent) |
c801d85f | 546 | { |
e146b8c8 | 547 | return wxFindWindowByLabel1(title, parent); |
c801d85f | 548 | } |
e146b8c8 | 549 | else |
c801d85f | 550 | { |
e146b8c8 VZ |
551 | for ( wxWindowList::Node * node = wxTopLevelWindows.GetFirst(); |
552 | node; | |
553 | node = node->GetNext() ) | |
3f4a0c5b | 554 | { |
e146b8c8 VZ |
555 | wxWindow *win = node->GetData(); |
556 | wxWindow *retwin = wxFindWindowByLabel1 (title, win); | |
557 | if (retwin) | |
558 | return retwin; | |
3f4a0c5b | 559 | } // for() |
c801d85f KB |
560 | |
561 | } | |
e146b8c8 | 562 | return (wxWindow *) NULL; |
c801d85f KB |
563 | } |
564 | ||
565 | // Recursive | |
566 | static wxWindow * | |
567 | wxFindWindowByLabel1 (const wxString& title, wxWindow * parent) | |
568 | { | |
e146b8c8 | 569 | if (parent) |
c801d85f | 570 | { |
e146b8c8 VZ |
571 | if (parent->GetLabel() == title) |
572 | return parent; | |
c801d85f KB |
573 | } |
574 | ||
e146b8c8 | 575 | if (parent) |
c801d85f | 576 | { |
f03fc89f | 577 | for ( wxWindowList::Node * node = parent->GetChildren().GetFirst(); |
e146b8c8 VZ |
578 | node; |
579 | node = node->GetNext() ) | |
3f4a0c5b | 580 | { |
e146b8c8 VZ |
581 | wxWindow *win = (wxWindow *)node->GetData(); |
582 | wxWindow *retwin = wxFindWindowByLabel1 (title, win); | |
583 | if (retwin) | |
584 | return retwin; | |
585 | } | |
c801d85f KB |
586 | |
587 | } | |
588 | ||
e146b8c8 | 589 | return (wxWindow *) NULL; // Not found |
c801d85f KB |
590 | } |
591 | ||
592 | /* | |
593 | * If parent is non-NULL, look through children for a name | |
594 | * matching the specified string. If NULL, look through all top-level windows. | |
595 | * | |
596 | */ | |
597 | ||
c801d85f KB |
598 | wxWindow * |
599 | wxFindWindowByName (const wxString& title, wxWindow * parent) | |
600 | { | |
e146b8c8 | 601 | if (parent) |
c801d85f | 602 | { |
e146b8c8 | 603 | return wxFindWindowByName1 (title, parent); |
c801d85f | 604 | } |
e146b8c8 | 605 | else |
c801d85f | 606 | { |
e146b8c8 VZ |
607 | for ( wxWindowList::Node * node = wxTopLevelWindows.GetFirst(); |
608 | node; | |
609 | node = node->GetNext() ) | |
3f4a0c5b | 610 | { |
e146b8c8 VZ |
611 | wxWindow *win = node->GetData(); |
612 | wxWindow *retwin = wxFindWindowByName1 (title, win); | |
613 | if (retwin) | |
614 | return retwin; | |
615 | } | |
c801d85f KB |
616 | |
617 | } | |
e146b8c8 VZ |
618 | |
619 | // Failed? Try by label instead. | |
620 | return wxFindWindowByLabel(title, parent); | |
c801d85f KB |
621 | } |
622 | ||
623 | // Recursive | |
624 | static wxWindow * | |
625 | wxFindWindowByName1 (const wxString& title, wxWindow * parent) | |
626 | { | |
627 | if (parent) | |
628 | { | |
3f4a0c5b VZ |
629 | if ( parent->GetName() == title ) |
630 | return parent; | |
c801d85f KB |
631 | } |
632 | ||
633 | if (parent) | |
634 | { | |
c0ed460c | 635 | for (wxNode * node = parent->GetChildren().First (); node; node = node->Next ()) |
3f4a0c5b VZ |
636 | { |
637 | wxWindow *win = (wxWindow *) node->Data (); | |
638 | wxWindow *retwin = wxFindWindowByName1 (title, win); | |
639 | if (retwin) | |
640 | return retwin; | |
641 | } // for() | |
c801d85f KB |
642 | |
643 | } | |
644 | ||
3f4a0c5b | 645 | return (wxWindow *) NULL; // Not found |
c801d85f KB |
646 | |
647 | } | |
648 | ||
649 | // Returns menu item id or -1 if none. | |
3f4a0c5b | 650 | int |
c801d85f KB |
651 | wxFindMenuItemId (wxFrame * frame, const wxString& menuString, const wxString& itemString) |
652 | { | |
653 | wxMenuBar *menuBar = frame->GetMenuBar (); | |
654 | if (!menuBar) | |
655 | return -1; | |
656 | return menuBar->FindMenuItem (menuString, itemString); | |
657 | } | |
658 | ||
e90c1d2a VZ |
659 | #endif // wxUSE_GUI |
660 | ||
c801d85f KB |
661 | /* |
662 | On Fri, 21 Jul 1995, Paul Craven wrote: | |
663 | ||
664 | > Is there a way to find the path of running program's executable? I can get | |
665 | > my home directory, and the current directory, but I don't know how to get the | |
666 | > executable directory. | |
3f4a0c5b | 667 | > |
c801d85f KB |
668 | |
669 | The code below (warty as it is), does what you want on most Unix, | |
670 | DOS, and Mac platforms (it's from the ALS Prolog main). | |
671 | ||
3f4a0c5b | 672 | || Ken Bowen Applied Logic Systems, Inc. PO Box 180, |
c801d85f KB |
673 | ||==== Voice: +1 (617)965-9191 Newton Centre, |
674 | || FAX: +1 (617)965-1636 MA 02159 USA | |
675 | Email: ken@als.com WWW: http://www.als.com | |
676 | ------------------------------------------------------------------------ | |
677 | */ | |
678 | ||
679 | // This code is commented out but it may be integrated with wxWin at | |
680 | // a later date, after testing. Thanks Ken! | |
681 | #if 0 | |
682 | ||
683 | /*--------------------------------------------------------------------* | |
684 | | whereami is given a filename f in the form: whereami(argv[0]) | |
3f4a0c5b VZ |
685 | | It returns the directory in which the executable file (containing |
686 | | this code [main.c] ) may be found. A dot will be returned to indicate | |
c801d85f KB |
687 | | the current directory. |
688 | *--------------------------------------------------------------------*/ | |
689 | ||
690 | static void | |
691 | whereami(name) | |
692 | char *name; | |
693 | { | |
3f4a0c5b | 694 | register char *cutoff = NULL; /* stifle -Wall */ |
c801d85f KB |
695 | register char *s; |
696 | register char *t; | |
697 | int cc; | |
698 | char ebuf[4096]; | |
699 | ||
700 | /* | |
701 | * See if the file is accessible either through the current directory | |
702 | * or through an absolute path. | |
703 | */ | |
704 | ||
705 | if (access(name, R_OK) == 0) { | |
706 | ||
3f4a0c5b VZ |
707 | /*-------------------------------------------------------------* |
708 | * The file was accessible without any other work. But the current | |
709 | * working directory might change on us, so if it was accessible | |
710 | * through the cwd, then we should get it for later accesses. | |
711 | *-------------------------------------------------------------*/ | |
c801d85f | 712 | |
3f4a0c5b VZ |
713 | t = imagedir; |
714 | if (!absolute_pathname(name)) { | |
c801d85f | 715 | #if defined(DOS) || defined(__WIN32__) |
3f4a0c5b VZ |
716 | int drive; |
717 | char *newrbuf; | |
c801d85f | 718 | |
3f4a0c5b | 719 | newrbuf = imagedir; |
c801d85f | 720 | #ifndef __DJGPP__ |
3f4a0c5b VZ |
721 | if (*(name + 1) == ':') { |
722 | if (*name >= 'a' && *name <= 'z') | |
723 | drive = (int) (*name - 'a' + 1); | |
724 | else | |
725 | drive = (int) (*name - 'A' + 1); | |
726 | *newrbuf++ = *name; | |
727 | *newrbuf++ = *(name + 1); | |
728 | *newrbuf++ = DIR_SEPARATOR; | |
729 | } | |
730 | else { | |
731 | drive = 0; | |
732 | *newrbuf++ = DIR_SEPARATOR; | |
733 | } | |
734 | if (getcwd(newrbuf, drive) == 0) { /* } */ | |
c801d85f | 735 | #else |
3f4a0c5b | 736 | if (getcwd(newrbuf, 1024) == 0) { /* } */ |
c801d85f KB |
737 | #endif |
738 | #else /* DOS */ | |
739 | #ifdef HAVE_GETWD | |
3f4a0c5b | 740 | if (getwd(imagedir) == 0) { /* } */ |
c801d85f | 741 | #else /* !HAVE_GETWD */ |
3f4a0c5b | 742 | if (getcwd(imagedir, 1024) == 0) { |
c801d85f KB |
743 | #endif /* !HAVE_GETWD */ |
744 | #endif /* DOS */ | |
3f4a0c5b VZ |
745 | fatal_error(FE_GETCWD, 0); |
746 | } | |
747 | for (; *t; t++) /* Set t to end of buffer */ | |
748 | ; | |
749 | if (*(t - 1) == DIR_SEPARATOR) /* leave slash if already | |
750 | * last char | |
751 | */ | |
752 | cutoff = t - 1; | |
753 | else { | |
754 | cutoff = t; /* otherwise put one in */ | |
755 | *t++ = DIR_SEPARATOR; | |
756 | } | |
757 | } | |
c801d85f | 758 | #if (!defined(__MAC__) && !defined(__DJGPP__) && !defined(__GO32__) && !defined(__WIN32__)) |
3f4a0c5b VZ |
759 | else |
760 | (*t++ = DIR_SEPARATOR); | |
c801d85f KB |
761 | #endif |
762 | ||
3f4a0c5b VZ |
763 | /*-------------------------------------------------------------* |
764 | * Copy the rest of the string and set the cutoff if it was not | |
765 | * already set. If the first character of name is a slash, cutoff | |
766 | * is not presently set but will be on the first iteration of the | |
767 | * loop below. | |
768 | *-------------------------------------------------------------*/ | |
c801d85f | 769 | |
3f4a0c5b VZ |
770 | for ((*name == DIR_SEPARATOR ? (s = name+1) : (s = name));;) { |
771 | if (*s == DIR_SEPARATOR) | |
772 | cutoff = t; | |
773 | if (!(*t++ = *s++)) | |
774 | break; | |
775 | } | |
c801d85f KB |
776 | |
777 | } | |
778 | else { | |
779 | ||
3f4a0c5b VZ |
780 | /*-------------------------------------------------------------* |
781 | * Get the path list from the environment. If the path list is | |
782 | * inaccessible for any reason, leave with fatal error. | |
783 | *-------------------------------------------------------------*/ | |
c801d85f KB |
784 | |
785 | #ifdef __MAC__ | |
3f4a0c5b | 786 | if ((s = getenv("Commands")) == (char *) 0) |
c801d85f | 787 | #else |
3f4a0c5b | 788 | if ((s = getenv("PATH")) == (char *) 0) |
c801d85f | 789 | #endif |
3f4a0c5b VZ |
790 | fatal_error(FE_PATH, 0); |
791 | ||
792 | /* | |
793 | * Copy path list into ebuf and set the source pointer to the | |
794 | * beginning of this buffer. | |
795 | */ | |
796 | ||
797 | strcpy(ebuf, s); | |
798 | s = ebuf; | |
799 | ||
800 | for (;;) { | |
801 | t = imagedir; | |
802 | while (*s && *s != PATH_SEPARATOR) | |
803 | *t++ = *s++; | |
804 | if (t > imagedir && *(t - 1) == DIR_SEPARATOR) | |
805 | ; /* do nothing -- slash already is in place */ | |
806 | else | |
807 | *t++ = DIR_SEPARATOR; /* put in the slash */ | |
808 | cutoff = t - 1; /* set cutoff */ | |
809 | strcpy(t, name); | |
810 | if (access(imagedir, R_OK) == 0) | |
811 | break; | |
812 | ||
813 | if (*s) | |
814 | s++; /* advance source pointer */ | |
815 | else | |
816 | fatal_error(FE_INFND, 0); | |
817 | } | |
c801d85f KB |
818 | |
819 | } | |
820 | ||
821 | /*-------------------------------------------------------------* | |
822 | | At this point the full pathname should exist in imagedir and | |
823 | | cutoff should be set to the final slash. We must now determine | |
824 | | whether the file name is a symbolic link or not and chase it down | |
825 | | if it is. Note that we reuse ebuf for getting the link. | |
826 | *-------------------------------------------------------------*/ | |
827 | ||
828 | #ifdef HAVE_SYMLINK | |
829 | while ((cc = readlink(imagedir, ebuf, 512)) != -1) { | |
3f4a0c5b VZ |
830 | ebuf[cc] = 0; |
831 | s = ebuf; | |
832 | if (*s == DIR_SEPARATOR) { | |
833 | t = imagedir; | |
834 | } | |
835 | else { | |
836 | t = cutoff + 1; | |
837 | } | |
838 | for (;;) { | |
839 | if (*s == DIR_SEPARATOR) | |
840 | cutoff = t; /* mark the last slash seen */ | |
841 | if (!(*t++ = *s++)) /* copy the character */ | |
842 | break; | |
843 | } | |
c801d85f KB |
844 | } |
845 | ||
846 | #endif /* HAVE_SYMLINK */ | |
847 | ||
3f4a0c5b VZ |
848 | strcpy(imagename, cutoff + 1); /* keep the image name */ |
849 | *(cutoff + 1) = 0; /* chop off the filename part */ | |
c801d85f KB |
850 | } |
851 | ||
852 | #endif | |
ead7ce10 | 853 | |
e90c1d2a VZ |
854 | #if wxUSE_GUI |
855 | ||
856 | // ---------------------------------------------------------------------------- | |
857 | // GUI helpers | |
858 | // ---------------------------------------------------------------------------- | |
ead7ce10 | 859 | |
dfad0599 JS |
860 | /* |
861 | * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp | |
862 | * since otherwise the generic code may be pulled in unnecessarily. | |
863 | */ | |
864 | ||
865 | int wxMessageBox(const wxString& message, const wxString& caption, long style, | |
866 | wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) ) | |
867 | { | |
868 | wxMessageDialog dialog(parent, message, caption, style); | |
869 | ||
870 | int ans = dialog.ShowModal(); | |
871 | switch ( ans ) | |
872 | { | |
873 | case wxID_OK: | |
874 | return wxOK; | |
dfad0599 JS |
875 | case wxID_YES: |
876 | return wxYES; | |
dfad0599 JS |
877 | case wxID_NO: |
878 | return wxNO; | |
dfad0599 JS |
879 | default: |
880 | case wxID_CANCEL: | |
881 | return wxCANCEL; | |
dfad0599 | 882 | } |
dfad0599 JS |
883 | } |
884 | ||
88ac883a | 885 | #if wxUSE_TEXTDLG |
dfad0599 JS |
886 | wxString wxGetTextFromUser(const wxString& message, const wxString& caption, |
887 | const wxString& defaultValue, wxWindow *parent, | |
888 | int x, int y, bool WXUNUSED(centre) ) | |
889 | { | |
d2f50933 | 890 | wxString str; |
dfad0599 JS |
891 | wxTextEntryDialog dialog(parent, message, caption, defaultValue, wxOK|wxCANCEL, wxPoint(x, y)); |
892 | if (dialog.ShowModal() == wxID_OK) | |
d2f50933 VZ |
893 | { |
894 | str = dialog.GetValue(); | |
895 | } | |
896 | ||
897 | return str; | |
dfad0599 | 898 | } |
d2f50933 VZ |
899 | |
900 | wxString wxGetPasswordFromUser(const wxString& message, | |
901 | const wxString& caption, | |
902 | const wxString& defaultValue, | |
903 | wxWindow *parent) | |
904 | { | |
905 | wxString str; | |
906 | wxTextEntryDialog dialog(parent, message, caption, defaultValue, | |
907 | wxOK | wxCANCEL | wxTE_PASSWORD); | |
908 | if ( dialog.ShowModal() == wxID_OK ) | |
909 | { | |
910 | str = dialog.GetValue(); | |
911 | } | |
912 | ||
913 | return str; | |
914 | } | |
915 | ||
88ac883a | 916 | #endif // wxUSE_TEXTDLG |
dfad0599 | 917 | |
91b4c08d VZ |
918 | wxColour wxGetColourFromUser(wxWindow *parent, const wxColour& colInit) |
919 | { | |
920 | wxColourData data; | |
921 | data.SetChooseFull(TRUE); | |
922 | if ( colInit.Ok() ) | |
923 | { | |
924 | data.SetColour((wxColour &)colInit); // const_cast | |
925 | } | |
926 | ||
927 | wxColour colRet; | |
928 | wxColourDialog dialog(parent, &data); | |
929 | if ( dialog.ShowModal() == wxID_OK ) | |
930 | { | |
931 | colRet = dialog.GetColourData().GetColour(); | |
932 | } | |
933 | //else: leave it invalid | |
934 | ||
935 | return colRet; | |
936 | } | |
937 | ||
938 | // ---------------------------------------------------------------------------- | |
939 | // missing C RTL functions (FIXME shouldn't be here at all) | |
940 | // ---------------------------------------------------------------------------- | |
941 | ||
469e1e5c | 942 | #ifdef __MWERKS__ |
3f4a0c5b | 943 | char *strdup(const char *s) |
469e1e5c | 944 | { |
3f4a0c5b | 945 | return strcpy( (char*) malloc( strlen( s ) + 1 ) , s ) ; |
469e1e5c SC |
946 | } |
947 | ||
3f4a0c5b | 948 | int isascii( int c ) |
469e1e5c | 949 | { |
3f4a0c5b | 950 | return ( c >= 0 && c < 128 ) ; |
469e1e5c | 951 | } |
e90c1d2a VZ |
952 | #endif // __MWERKS__ |
953 | ||
954 | // ---------------------------------------------------------------------------- | |
955 | // misc functions | |
956 | // ---------------------------------------------------------------------------- | |
957 | ||
958 | void wxEnableTopLevelWindows(bool enable) | |
959 | { | |
225fe9d6 VZ |
960 | wxWindowList::Node *node; |
961 | for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() ) | |
962 | node->GetData()->Enable(enable); | |
e90c1d2a VZ |
963 | } |
964 | ||
225fe9d6 VZ |
965 | static void wxFindDisabledWindows(wxWindowList& winDisabled, wxWindow *win) |
966 | { | |
967 | wxWindowList::Node *node; | |
968 | for ( node = win->GetChildren().GetFirst(); node; node = node->GetNext() ) | |
969 | { | |
970 | wxWindow *child = node->GetData(); | |
cd6ce4a9 VZ |
971 | wxFindDisabledWindows(winDisabled, child); |
972 | ||
225fe9d6 VZ |
973 | if ( child->IsEnabled() ) |
974 | { | |
975 | winDisabled.Append(child); | |
cd6ce4a9 | 976 | child->Disable(); |
225fe9d6 | 977 | } |
225fe9d6 VZ |
978 | } |
979 | } | |
980 | ||
cd6ce4a9 | 981 | wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip) |
e90c1d2a | 982 | { |
225fe9d6 | 983 | // remember all windows we're going to (temporarily) disable |
cd6ce4a9 | 984 | m_winDisabled = new wxWindowList; |
225fe9d6 | 985 | |
5e1febfa | 986 | #ifdef __WXMSW__ |
62ea79f3 | 987 | #ifdef __WIN32__ |
5e1febfa VZ |
988 | // and the top level window too |
989 | HWND hwndFG = ::GetForegroundWindow(); | |
990 | m_winTop = hwndFG ? wxFindWinFromHandle((WXHWND)hwndFG) : (wxWindow *)NULL; | |
62ea79f3 JS |
991 | #else |
992 | HWND hwndFG = ::GetTopWindow(); | |
993 | m_winTop = hwndFG ? wxFindWinFromHandle((WXHWND)hwndFG) : (wxWindow *)NULL; | |
994 | #endif | |
5e1febfa VZ |
995 | #endif // MSW |
996 | ||
225fe9d6 VZ |
997 | wxWindowList::Node *node; |
998 | for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() ) | |
999 | { | |
1000 | wxWindow *winTop = node->GetData(); | |
cd6ce4a9 VZ |
1001 | if ( winTop->IsEnabled() ) |
1002 | { | |
1003 | wxFindDisabledWindows(*m_winDisabled, winTop); | |
225fe9d6 | 1004 | |
cd6ce4a9 VZ |
1005 | m_winDisabled->Append(winTop); |
1006 | winTop->Disable(); | |
1007 | } | |
225fe9d6 VZ |
1008 | } |
1009 | ||
cd6ce4a9 | 1010 | if ( winToSkip && m_winDisabled->Find(winToSkip) ) |
225fe9d6 VZ |
1011 | { |
1012 | // always enable ourselves | |
cd6ce4a9 VZ |
1013 | m_winDisabled->DeleteObject(winToSkip); |
1014 | winToSkip->Enable(); | |
225fe9d6 | 1015 | } |
cd6ce4a9 | 1016 | } |
225fe9d6 | 1017 | |
cd6ce4a9 VZ |
1018 | wxWindowDisabler::~wxWindowDisabler() |
1019 | { | |
1020 | wxWindowList::Node *node; | |
1021 | for ( node = m_winDisabled->GetFirst(); node; node = node->GetNext() ) | |
225fe9d6 VZ |
1022 | { |
1023 | node->GetData()->Enable(); | |
1024 | } | |
1025 | ||
cd6ce4a9 | 1026 | delete m_winDisabled; |
5e1febfa VZ |
1027 | |
1028 | #ifdef __WXMSW__ | |
62ea79f3 | 1029 | #ifdef __WIN32__ |
5e1febfa VZ |
1030 | if ( m_winTop ) |
1031 | { | |
1032 | if ( !::SetForegroundWindow(GetHwndOf(m_winTop)) ) | |
1033 | { | |
1034 | wxLogLastError("SetForegroundWindow"); | |
1035 | } | |
1036 | } | |
62ea79f3 JS |
1037 | #else |
1038 | if ( m_winTop ) | |
1039 | { | |
1040 | // 16-bit SetForegroundWindow() replacement | |
1041 | RECT reWin; | |
1042 | GetWindowRect(m_winTop, &reWin); | |
1043 | SetWindowPos (m_winTop, HWND_TOP, | |
1044 | reWin.left, reWin.top, | |
1045 | reWin.right - reWin.left, reWin.bottom, | |
1046 | SWP_SHOWWINDOW); | |
1047 | } | |
1048 | #endif | |
5e1febfa | 1049 | #endif // MSW |
cd6ce4a9 VZ |
1050 | } |
1051 | ||
1052 | // Yield to other apps/messages and disable user input to all windows except | |
1053 | // the given one | |
1054 | bool wxSafeYield(wxWindow *win) | |
1055 | { | |
1056 | wxWindowDisabler wd; | |
1057 | ||
1058 | bool rc = wxYield(); | |
1059 | ||
225fe9d6 | 1060 | return rc; |
e90c1d2a VZ |
1061 | } |
1062 | ||
1063 | // Don't synthesize KeyUp events holding down a key and producing KeyDown | |
1064 | // events with autorepeat. On by default and always on in wxMSW. wxGTK version | |
1065 | // in utilsgtk.cpp. | |
1066 | #ifndef __WXGTK__ | |
1067 | bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) ) | |
1068 | { | |
225fe9d6 | 1069 | return TRUE; // detectable auto-repeat is the only mode MSW supports |
e90c1d2a VZ |
1070 | } |
1071 | #endif // !wxGTK | |
1072 | ||
1073 | #endif // wxUSE_GUI | |
e2a6f233 | 1074 | |
0fb67cd1 VZ |
1075 | // ---------------------------------------------------------------------------- |
1076 | // network and user id functions | |
1077 | // ---------------------------------------------------------------------------- | |
1078 | ||
1079 | // Get Full RFC822 style email address | |
84fff0b3 | 1080 | bool wxGetEmailAddress(wxChar *address, int maxSize) |
e2a6f233 | 1081 | { |
0fb67cd1 VZ |
1082 | wxString email = wxGetEmailAddress(); |
1083 | if ( !email ) | |
e2a6f233 | 1084 | return FALSE; |
0fb67cd1 | 1085 | |
84fff0b3 | 1086 | wxStrncpy(address, email, maxSize - 1); |
223d09f6 | 1087 | address[maxSize - 1] = wxT('\0'); |
0fb67cd1 VZ |
1088 | |
1089 | return TRUE; | |
e2a6f233 JS |
1090 | } |
1091 | ||
0fb67cd1 | 1092 | wxString wxGetEmailAddress() |
e2a6f233 | 1093 | { |
0fb67cd1 VZ |
1094 | wxString email; |
1095 | ||
1096 | wxString host = wxGetHostName(); | |
1097 | if ( !!host ) | |
e2a6f233 | 1098 | { |
0fb67cd1 VZ |
1099 | wxString user = wxGetUserId(); |
1100 | if ( !!user ) | |
1101 | { | |
1102 | wxString email(user); | |
223d09f6 | 1103 | email << wxT('@') << host; |
0fb67cd1 | 1104 | } |
e2a6f233 | 1105 | } |
0fb67cd1 VZ |
1106 | |
1107 | return email; | |
1108 | } | |
1109 | ||
1110 | wxString wxGetUserId() | |
1111 | { | |
1112 | static const int maxLoginLen = 256; // FIXME arbitrary number | |
1113 | ||
1114 | wxString buf; | |
1115 | bool ok = wxGetUserId(buf.GetWriteBuf(maxLoginLen), maxLoginLen); | |
1116 | buf.UngetWriteBuf(); | |
1117 | ||
1118 | if ( !ok ) | |
1119 | buf.Empty(); | |
1120 | ||
1121 | return buf; | |
1122 | } | |
1123 | ||
1124 | wxString wxGetUserName() | |
1125 | { | |
1126 | static const int maxUserNameLen = 1024; // FIXME arbitrary number | |
1127 | ||
1128 | wxString buf; | |
1129 | bool ok = wxGetUserName(buf.GetWriteBuf(maxUserNameLen), maxUserNameLen); | |
1130 | buf.UngetWriteBuf(); | |
1131 | ||
1132 | if ( !ok ) | |
1133 | buf.Empty(); | |
1134 | ||
1135 | return buf; | |
e2a6f233 JS |
1136 | } |
1137 | ||
0fb67cd1 | 1138 | wxString wxGetHostName() |
518b5d2f VZ |
1139 | { |
1140 | static const size_t hostnameSize = 257; | |
0fb67cd1 VZ |
1141 | |
1142 | wxString buf; | |
518b5d2f VZ |
1143 | bool ok = wxGetHostName(buf.GetWriteBuf(hostnameSize), hostnameSize); |
1144 | ||
1145 | buf.UngetWriteBuf(); | |
1146 | ||
0fb67cd1 VZ |
1147 | if ( !ok ) |
1148 | buf.Empty(); | |
1149 | ||
1150 | return buf; | |
518b5d2f VZ |
1151 | } |
1152 | ||
96c5bd7f KB |
1153 | wxString wxGetFullHostName() |
1154 | { | |
1155 | static const size_t hostnameSize = 257; | |
1156 | ||
1157 | wxString buf; | |
1158 | bool ok = wxGetFullHostName(buf.GetWriteBuf(hostnameSize), hostnameSize); | |
1159 | ||
1160 | buf.UngetWriteBuf(); | |
1161 | ||
1162 | if ( !ok ) | |
1163 | buf.Empty(); | |
1164 | ||
1165 | return buf; | |
1166 | } | |
1167 | ||
c51deffc VZ |
1168 | wxString wxGetHomeDir() |
1169 | { | |
1170 | wxString home; | |
1171 | wxGetHomeDir(&home); | |
1172 | ||
1173 | return home; | |
1174 | } | |
bc385ba9 VZ |
1175 | |
1176 | #if 0 | |
1177 | ||
1178 | wxString wxGetCurrentDir() | |
1179 | { | |
1180 | wxString dir; | |
1181 | size_t len = 1024; | |
1182 | bool ok; | |
1183 | do | |
1184 | { | |
1185 | ok = getcwd(dir.GetWriteBuf(len + 1), len) != NULL; | |
1186 | dir.UngetWriteBuf(); | |
1187 | ||
1188 | if ( !ok ) | |
1189 | { | |
1190 | if ( errno != ERANGE ) | |
1191 | { | |
1192 | wxLogSysError(_T("Failed to get current directory")); | |
1193 | ||
1194 | return wxEmptyString; | |
1195 | } | |
1196 | else | |
1197 | { | |
1198 | // buffer was too small, retry with a larger one | |
1199 | len *= 2; | |
1200 | } | |
1201 | } | |
1202 | //else: ok | |
1203 | } while ( !ok ); | |
1204 | ||
1205 | return dir; | |
1206 | } | |
1207 | ||
1208 | #endif // 0 | |
cd6ce4a9 VZ |
1209 | |
1210 | // ---------------------------------------------------------------------------- | |
1211 | // wxExecute | |
1212 | // ---------------------------------------------------------------------------- | |
1213 | ||
1214 | long wxExecute(const wxString& command, wxArrayString& output) | |
1215 | { | |
1216 | // create a wxProcess which will capture the output | |
1217 | wxProcess *process = new wxProcess; | |
1218 | process->Redirect(); | |
1219 | ||
1220 | long rc = wxExecute(command, TRUE /* sync */, process); | |
1221 | if ( rc != -1 ) | |
1222 | { | |
1223 | wxInputStream& is = *process->GetInputStream(); | |
1224 | wxTextInputStream tis(is); | |
5e1febfa | 1225 | while ( !is.Eof() && is.IsOk() ) |
cd6ce4a9 VZ |
1226 | { |
1227 | wxString line = tis.ReadLine(); | |
1228 | if ( is.LastError() ) | |
1229 | break; | |
1230 | ||
1231 | output.Add(line); | |
1232 | } | |
1233 | } | |
1234 | ||
1235 | return rc; | |
1236 | } |