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