]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/common/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 | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
20 | // For compilers that support precompilation, includes "wx.h". | |
21 | #include "wx/wxprec.h" | |
22 | ||
23 | #ifdef __BORLANDC__ | |
24 | #pragma hdrstop | |
25 | #endif | |
26 | ||
27 | #ifndef WX_PRECOMP | |
28 | #include "wx/app.h" | |
29 | #include "wx/string.h" | |
30 | #include "wx/utils.h" | |
31 | #include "wx/intl.h" | |
32 | #include "wx/log.h" | |
33 | ||
34 | #if wxUSE_GUI | |
35 | #include "wx/window.h" | |
36 | #include "wx/frame.h" | |
37 | #include "wx/menu.h" | |
38 | #include "wx/msgdlg.h" | |
39 | #include "wx/textdlg.h" | |
40 | #include "wx/textctrl.h" // for wxTE_PASSWORD | |
41 | #if wxUSE_ACCEL | |
42 | #include "wx/menuitem.h" | |
43 | #include "wx/accel.h" | |
44 | #endif // wxUSE_ACCEL | |
45 | #endif // wxUSE_GUI | |
46 | #endif // WX_PRECOMP | |
47 | ||
48 | #include "wx/apptrait.h" | |
49 | ||
50 | #include "wx/process.h" | |
51 | #include "wx/txtstrm.h" | |
52 | #include "wx/uri.h" | |
53 | #include "wx/mimetype.h" | |
54 | #include "wx/config.h" | |
55 | ||
56 | #if defined(__WXWINCE__) && wxUSE_DATETIME | |
57 | #include "wx/datetime.h" | |
58 | #endif | |
59 | ||
60 | #include <ctype.h> | |
61 | #include <stdio.h> | |
62 | #include <stdlib.h> | |
63 | #include <string.h> | |
64 | ||
65 | #if !wxONLY_WATCOM_EARLIER_THAN(1,4) | |
66 | #if !(defined(_MSC_VER) && (_MSC_VER > 800)) | |
67 | #include <errno.h> | |
68 | #endif | |
69 | #endif | |
70 | ||
71 | #if wxUSE_GUI | |
72 | #include "wx/colordlg.h" | |
73 | #include "wx/fontdlg.h" | |
74 | #include "wx/notebook.h" | |
75 | #include "wx/statusbr.h" | |
76 | #endif // wxUSE_GUI | |
77 | ||
78 | #ifndef __WXWINCE__ | |
79 | #include <time.h> | |
80 | #else | |
81 | #include "wx/msw/wince/time.h" | |
82 | #endif | |
83 | ||
84 | #ifdef __WXMAC__ | |
85 | #include "wx/mac/private.h" | |
86 | #ifndef __DARWIN__ | |
87 | #include "InternetConfig.h" | |
88 | #endif | |
89 | #endif | |
90 | ||
91 | #if !defined(__MWERKS__) && !defined(__WXWINCE__) | |
92 | #include <sys/types.h> | |
93 | #include <sys/stat.h> | |
94 | #endif | |
95 | ||
96 | #if defined(__WXMSW__) | |
97 | #include "wx/msw/private.h" | |
98 | #include "wx/msw/registry.h" | |
99 | #include <shellapi.h> // needed for SHELLEXECUTEINFO | |
100 | #endif | |
101 | ||
102 | #if wxUSE_BASE | |
103 | ||
104 | // ---------------------------------------------------------------------------- | |
105 | // common data | |
106 | // ---------------------------------------------------------------------------- | |
107 | ||
108 | // ============================================================================ | |
109 | // implementation | |
110 | // ============================================================================ | |
111 | ||
112 | #if WXWIN_COMPATIBILITY_2_4 | |
113 | ||
114 | wxChar * | |
115 | copystring (const wxChar *s) | |
116 | { | |
117 | if (s == NULL) s = wxEmptyString; | |
118 | size_t len = wxStrlen (s) + 1; | |
119 | ||
120 | wxChar *news = new wxChar[len]; | |
121 | memcpy (news, s, len * sizeof(wxChar)); // Should be the fastest | |
122 | ||
123 | return news; | |
124 | } | |
125 | ||
126 | #endif // WXWIN_COMPATIBILITY_2_4 | |
127 | ||
128 | // ---------------------------------------------------------------------------- | |
129 | // String <-> Number conversions (deprecated) | |
130 | // ---------------------------------------------------------------------------- | |
131 | ||
132 | #if WXWIN_COMPATIBILITY_2_4 | |
133 | ||
134 | WXDLLIMPEXP_DATA_BASE(const wxChar *) wxFloatToStringStr = wxT("%.2f"); | |
135 | WXDLLIMPEXP_DATA_BASE(const wxChar *) wxDoubleToStringStr = wxT("%.2f"); | |
136 | ||
137 | void | |
138 | StringToFloat (const wxChar *s, float *number) | |
139 | { | |
140 | if (s && *s && number) | |
141 | *number = (float) wxStrtod (s, (wxChar **) NULL); | |
142 | } | |
143 | ||
144 | void | |
145 | StringToDouble (const wxChar *s, double *number) | |
146 | { | |
147 | if (s && *s && number) | |
148 | *number = wxStrtod (s, (wxChar **) NULL); | |
149 | } | |
150 | ||
151 | wxChar * | |
152 | FloatToString (float number, const wxChar *fmt) | |
153 | { | |
154 | static wxChar buf[256]; | |
155 | ||
156 | wxSprintf (buf, fmt, number); | |
157 | return buf; | |
158 | } | |
159 | ||
160 | wxChar * | |
161 | DoubleToString (double number, const wxChar *fmt) | |
162 | { | |
163 | static wxChar buf[256]; | |
164 | ||
165 | wxSprintf (buf, fmt, number); | |
166 | return buf; | |
167 | } | |
168 | ||
169 | void | |
170 | StringToInt (const wxChar *s, int *number) | |
171 | { | |
172 | if (s && *s && number) | |
173 | *number = (int) wxStrtol (s, (wxChar **) NULL, 10); | |
174 | } | |
175 | ||
176 | void | |
177 | StringToLong (const wxChar *s, long *number) | |
178 | { | |
179 | if (s && *s && number) | |
180 | *number = wxStrtol (s, (wxChar **) NULL, 10); | |
181 | } | |
182 | ||
183 | wxChar * | |
184 | IntToString (int number) | |
185 | { | |
186 | static wxChar buf[20]; | |
187 | ||
188 | wxSprintf (buf, wxT("%d"), number); | |
189 | return buf; | |
190 | } | |
191 | ||
192 | wxChar * | |
193 | LongToString (long number) | |
194 | { | |
195 | static wxChar buf[20]; | |
196 | ||
197 | wxSprintf (buf, wxT("%ld"), number); | |
198 | return buf; | |
199 | } | |
200 | ||
201 | #endif // WXWIN_COMPATIBILITY_2_4 | |
202 | ||
203 | // Array used in DecToHex conversion routine. | |
204 | static wxChar hexArray[] = wxT("0123456789ABCDEF"); | |
205 | ||
206 | // Convert 2-digit hex number to decimal | |
207 | int wxHexToDec(const wxString& buf) | |
208 | { | |
209 | int firstDigit, secondDigit; | |
210 | ||
211 | if (buf.GetChar(0) >= wxT('A')) | |
212 | firstDigit = buf.GetChar(0) - wxT('A') + 10; | |
213 | else | |
214 | firstDigit = buf.GetChar(0) - wxT('0'); | |
215 | ||
216 | if (buf.GetChar(1) >= wxT('A')) | |
217 | secondDigit = buf.GetChar(1) - wxT('A') + 10; | |
218 | else | |
219 | secondDigit = buf.GetChar(1) - wxT('0'); | |
220 | ||
221 | return (firstDigit & 0xF) * 16 + (secondDigit & 0xF ); | |
222 | } | |
223 | ||
224 | // Convert decimal integer to 2-character hex string | |
225 | void wxDecToHex(int dec, wxChar *buf) | |
226 | { | |
227 | int firstDigit = (int)(dec/16.0); | |
228 | int secondDigit = (int)(dec - (firstDigit*16.0)); | |
229 | buf[0] = hexArray[firstDigit]; | |
230 | buf[1] = hexArray[secondDigit]; | |
231 | buf[2] = 0; | |
232 | } | |
233 | ||
234 | // Convert decimal integer to 2-character hex string | |
235 | wxString wxDecToHex(int dec) | |
236 | { | |
237 | wxChar buf[3]; | |
238 | wxDecToHex(dec, buf); | |
239 | return wxString(buf); | |
240 | } | |
241 | ||
242 | // ---------------------------------------------------------------------------- | |
243 | // misc functions | |
244 | // ---------------------------------------------------------------------------- | |
245 | ||
246 | // Return the current date/time | |
247 | wxString wxNow() | |
248 | { | |
249 | #ifdef __WXWINCE__ | |
250 | #if wxUSE_DATETIME | |
251 | wxDateTime now = wxDateTime::Now(); | |
252 | return now.Format(); | |
253 | #else | |
254 | return wxEmptyString; | |
255 | #endif | |
256 | #else | |
257 | time_t now = time((time_t *) NULL); | |
258 | char *date = ctime(&now); | |
259 | date[24] = '\0'; | |
260 | return wxString::FromAscii(date); | |
261 | #endif | |
262 | } | |
263 | ||
264 | void wxUsleep(unsigned long milliseconds) | |
265 | { | |
266 | wxMilliSleep(milliseconds); | |
267 | } | |
268 | ||
269 | const wxChar *wxGetInstallPrefix() | |
270 | { | |
271 | wxString prefix; | |
272 | ||
273 | if ( wxGetEnv(wxT("WXPREFIX"), &prefix) ) | |
274 | return prefix.c_str(); | |
275 | ||
276 | #ifdef wxINSTALL_PREFIX | |
277 | return wxT(wxINSTALL_PREFIX); | |
278 | #else | |
279 | return wxEmptyString; | |
280 | #endif | |
281 | } | |
282 | ||
283 | wxString wxGetDataDir() | |
284 | { | |
285 | wxString dir = wxGetInstallPrefix(); | |
286 | dir << wxFILE_SEP_PATH << wxT("share") << wxFILE_SEP_PATH << wxT("wx"); | |
287 | return dir; | |
288 | } | |
289 | ||
290 | bool wxIsPlatformLittleEndian() | |
291 | { | |
292 | // Are we little or big endian? This method is from Harbison & Steele. | |
293 | union | |
294 | { | |
295 | long l; | |
296 | char c[sizeof(long)]; | |
297 | } u; | |
298 | u.l = 1; | |
299 | ||
300 | return u.c[0] == 1; | |
301 | } | |
302 | ||
303 | ||
304 | /* | |
305 | * Class to make it easier to specify platform-dependent values | |
306 | */ | |
307 | ||
308 | wxArrayInt* wxPlatform::sm_customPlatforms = NULL; | |
309 | ||
310 | void wxPlatform::Copy(const wxPlatform& platform) | |
311 | { | |
312 | m_longValue = platform.m_longValue; | |
313 | m_doubleValue = platform.m_doubleValue; | |
314 | m_stringValue = platform.m_stringValue; | |
315 | } | |
316 | ||
317 | wxPlatform wxPlatform::If(int platform, long value) | |
318 | { | |
319 | if (Is(platform)) | |
320 | return wxPlatform(value); | |
321 | else | |
322 | return wxPlatform(); | |
323 | } | |
324 | ||
325 | wxPlatform wxPlatform::IfNot(int platform, long value) | |
326 | { | |
327 | if (!Is(platform)) | |
328 | return wxPlatform(value); | |
329 | else | |
330 | return wxPlatform(); | |
331 | } | |
332 | ||
333 | wxPlatform& wxPlatform::ElseIf(int platform, long value) | |
334 | { | |
335 | if (Is(platform)) | |
336 | m_longValue = value; | |
337 | return *this; | |
338 | } | |
339 | ||
340 | wxPlatform& wxPlatform::ElseIfNot(int platform, long value) | |
341 | { | |
342 | if (!Is(platform)) | |
343 | m_longValue = value; | |
344 | return *this; | |
345 | } | |
346 | ||
347 | wxPlatform wxPlatform::If(int platform, double value) | |
348 | { | |
349 | if (Is(platform)) | |
350 | return wxPlatform(value); | |
351 | else | |
352 | return wxPlatform(); | |
353 | } | |
354 | ||
355 | wxPlatform wxPlatform::IfNot(int platform, double value) | |
356 | { | |
357 | if (!Is(platform)) | |
358 | return wxPlatform(value); | |
359 | else | |
360 | return wxPlatform(); | |
361 | } | |
362 | ||
363 | wxPlatform& wxPlatform::ElseIf(int platform, double value) | |
364 | { | |
365 | if (Is(platform)) | |
366 | m_doubleValue = value; | |
367 | return *this; | |
368 | } | |
369 | ||
370 | wxPlatform& wxPlatform::ElseIfNot(int platform, double value) | |
371 | { | |
372 | if (!Is(platform)) | |
373 | m_doubleValue = value; | |
374 | return *this; | |
375 | } | |
376 | ||
377 | wxPlatform wxPlatform::If(int platform, const wxString& value) | |
378 | { | |
379 | if (Is(platform)) | |
380 | return wxPlatform(value); | |
381 | else | |
382 | return wxPlatform(); | |
383 | } | |
384 | ||
385 | wxPlatform wxPlatform::IfNot(int platform, const wxString& value) | |
386 | { | |
387 | if (!Is(platform)) | |
388 | return wxPlatform(value); | |
389 | else | |
390 | return wxPlatform(); | |
391 | } | |
392 | ||
393 | wxPlatform& wxPlatform::ElseIf(int platform, const wxString& value) | |
394 | { | |
395 | if (Is(platform)) | |
396 | m_stringValue = value; | |
397 | return *this; | |
398 | } | |
399 | ||
400 | wxPlatform& wxPlatform::ElseIfNot(int platform, const wxString& value) | |
401 | { | |
402 | if (!Is(platform)) | |
403 | m_stringValue = value; | |
404 | return *this; | |
405 | } | |
406 | ||
407 | wxPlatform& wxPlatform::Else(long value) | |
408 | { | |
409 | m_longValue = value; | |
410 | return *this; | |
411 | } | |
412 | ||
413 | wxPlatform& wxPlatform::Else(double value) | |
414 | { | |
415 | m_doubleValue = value; | |
416 | return *this; | |
417 | } | |
418 | ||
419 | wxPlatform& wxPlatform::Else(const wxString& value) | |
420 | { | |
421 | m_stringValue = value; | |
422 | return *this; | |
423 | } | |
424 | ||
425 | void wxPlatform::AddPlatform(int platform) | |
426 | { | |
427 | if (!sm_customPlatforms) | |
428 | sm_customPlatforms = new wxArrayInt; | |
429 | sm_customPlatforms->Add(platform); | |
430 | } | |
431 | ||
432 | void wxPlatform::ClearPlatforms() | |
433 | { | |
434 | delete sm_customPlatforms; | |
435 | sm_customPlatforms = NULL; | |
436 | } | |
437 | ||
438 | /// Function for testing current platform | |
439 | ||
440 | bool wxPlatform::Is(int platform) | |
441 | { | |
442 | #ifdef __WXMSW__ | |
443 | if (platform == wxOS_WINDOWS) | |
444 | return true; | |
445 | #endif | |
446 | #ifdef __WXWINCE__ | |
447 | if (platform == wxOS_WINDOWS_CE) | |
448 | return true; | |
449 | #endif | |
450 | #if defined(__WXWINCE__) && defined(__POCKETPC__) | |
451 | if (platform == wxWinPocketPC) | |
452 | return true; | |
453 | #endif | |
454 | #if defined(__WXWINCE__) && defined(__SMARTPHONE__) | |
455 | if (platform == wxWinSmartPhone) | |
456 | return true; | |
457 | #endif | |
458 | #ifdef __WXGTK__ | |
459 | if (platform == wxPORT_GTK) | |
460 | return true; | |
461 | #endif | |
462 | #ifdef __WXMAC__ | |
463 | if (platform == wxPORT_MAC) | |
464 | return true; | |
465 | #endif | |
466 | #ifdef __WXX11__ | |
467 | if (platform == wxPORT_X11) | |
468 | return true; | |
469 | #endif | |
470 | #ifdef __UNIX__ | |
471 | if (platform == wxOS_UNIX) | |
472 | return true; | |
473 | #endif | |
474 | #ifdef __WXMGL__ | |
475 | if (platform == wxPORT_MGL) | |
476 | return true; | |
477 | #endif | |
478 | #ifdef __WXOS2__ | |
479 | if (platform == wxPORT_OS2) | |
480 | return true; | |
481 | #endif | |
482 | #ifdef __WXCOCOA__ | |
483 | if (platform == wxPORT_MAC) | |
484 | return true; | |
485 | #endif | |
486 | ||
487 | if (sm_customPlatforms && sm_customPlatforms->Index(platform) != wxNOT_FOUND) | |
488 | return true; | |
489 | ||
490 | return false; | |
491 | } | |
492 | ||
493 | // ---------------------------------------------------------------------------- | |
494 | // network and user id functions | |
495 | // ---------------------------------------------------------------------------- | |
496 | ||
497 | // Get Full RFC822 style email address | |
498 | bool wxGetEmailAddress(wxChar *address, int maxSize) | |
499 | { | |
500 | wxString email = wxGetEmailAddress(); | |
501 | if ( !email ) | |
502 | return false; | |
503 | ||
504 | wxStrncpy(address, email, maxSize - 1); | |
505 | address[maxSize - 1] = wxT('\0'); | |
506 | ||
507 | return true; | |
508 | } | |
509 | ||
510 | wxString wxGetEmailAddress() | |
511 | { | |
512 | wxString email; | |
513 | ||
514 | wxString host = wxGetFullHostName(); | |
515 | if ( !host.empty() ) | |
516 | { | |
517 | wxString user = wxGetUserId(); | |
518 | if ( !user.empty() ) | |
519 | { | |
520 | email << user << wxT('@') << host; | |
521 | } | |
522 | } | |
523 | ||
524 | return email; | |
525 | } | |
526 | ||
527 | wxString wxGetUserId() | |
528 | { | |
529 | static const int maxLoginLen = 256; // FIXME arbitrary number | |
530 | ||
531 | wxString buf; | |
532 | bool ok = wxGetUserId(wxStringBuffer(buf, maxLoginLen), maxLoginLen); | |
533 | ||
534 | if ( !ok ) | |
535 | buf.Empty(); | |
536 | ||
537 | return buf; | |
538 | } | |
539 | ||
540 | wxString wxGetUserName() | |
541 | { | |
542 | static const int maxUserNameLen = 1024; // FIXME arbitrary number | |
543 | ||
544 | wxString buf; | |
545 | bool ok = wxGetUserName(wxStringBuffer(buf, maxUserNameLen), maxUserNameLen); | |
546 | ||
547 | if ( !ok ) | |
548 | buf.Empty(); | |
549 | ||
550 | return buf; | |
551 | } | |
552 | ||
553 | wxString wxGetHostName() | |
554 | { | |
555 | static const size_t hostnameSize = 257; | |
556 | ||
557 | wxString buf; | |
558 | bool ok = wxGetHostName(wxStringBuffer(buf, hostnameSize), hostnameSize); | |
559 | ||
560 | if ( !ok ) | |
561 | buf.Empty(); | |
562 | ||
563 | return buf; | |
564 | } | |
565 | ||
566 | wxString wxGetFullHostName() | |
567 | { | |
568 | static const size_t hostnameSize = 257; | |
569 | ||
570 | wxString buf; | |
571 | bool ok = wxGetFullHostName(wxStringBuffer(buf, hostnameSize), hostnameSize); | |
572 | ||
573 | if ( !ok ) | |
574 | buf.Empty(); | |
575 | ||
576 | return buf; | |
577 | } | |
578 | ||
579 | wxString wxGetHomeDir() | |
580 | { | |
581 | wxString home; | |
582 | wxGetHomeDir(&home); | |
583 | ||
584 | return home; | |
585 | } | |
586 | ||
587 | #if 0 | |
588 | ||
589 | wxString wxGetCurrentDir() | |
590 | { | |
591 | wxString dir; | |
592 | size_t len = 1024; | |
593 | bool ok; | |
594 | do | |
595 | { | |
596 | ok = getcwd(dir.GetWriteBuf(len + 1), len) != NULL; | |
597 | dir.UngetWriteBuf(); | |
598 | ||
599 | if ( !ok ) | |
600 | { | |
601 | if ( errno != ERANGE ) | |
602 | { | |
603 | wxLogSysError(_T("Failed to get current directory")); | |
604 | ||
605 | return wxEmptyString; | |
606 | } | |
607 | else | |
608 | { | |
609 | // buffer was too small, retry with a larger one | |
610 | len *= 2; | |
611 | } | |
612 | } | |
613 | //else: ok | |
614 | } while ( !ok ); | |
615 | ||
616 | return dir; | |
617 | } | |
618 | ||
619 | #endif // 0 | |
620 | ||
621 | // ---------------------------------------------------------------------------- | |
622 | // wxExecute | |
623 | // ---------------------------------------------------------------------------- | |
624 | ||
625 | // wxDoExecuteWithCapture() helper: reads an entire stream into one array | |
626 | // | |
627 | // returns true if ok, false if error | |
628 | #if wxUSE_STREAMS | |
629 | static bool ReadAll(wxInputStream *is, wxArrayString& output) | |
630 | { | |
631 | wxCHECK_MSG( is, false, _T("NULL stream in wxExecute()?") ); | |
632 | ||
633 | // the stream could be already at EOF or in wxSTREAM_BROKEN_PIPE state | |
634 | is->Reset(); | |
635 | ||
636 | wxTextInputStream tis(*is); | |
637 | ||
638 | bool cont = true; | |
639 | while ( cont ) | |
640 | { | |
641 | wxString line = tis.ReadLine(); | |
642 | if ( is->Eof() ) | |
643 | break; | |
644 | ||
645 | if ( !*is ) | |
646 | { | |
647 | cont = false; | |
648 | } | |
649 | else | |
650 | { | |
651 | output.Add(line); | |
652 | } | |
653 | } | |
654 | ||
655 | return cont; | |
656 | } | |
657 | #endif // wxUSE_STREAMS | |
658 | ||
659 | // this is a private function because it hasn't a clean interface: the first | |
660 | // array is passed by reference, the second by pointer - instead we have 2 | |
661 | // public versions of wxExecute() below | |
662 | static long wxDoExecuteWithCapture(const wxString& command, | |
663 | wxArrayString& output, | |
664 | wxArrayString* error, | |
665 | int flags) | |
666 | { | |
667 | // create a wxProcess which will capture the output | |
668 | wxProcess *process = new wxProcess; | |
669 | process->Redirect(); | |
670 | ||
671 | long rc = wxExecute(command, wxEXEC_SYNC | flags, process); | |
672 | ||
673 | #if wxUSE_STREAMS | |
674 | if ( rc != -1 ) | |
675 | { | |
676 | if ( !ReadAll(process->GetInputStream(), output) ) | |
677 | rc = -1; | |
678 | ||
679 | if ( error ) | |
680 | { | |
681 | if ( !ReadAll(process->GetErrorStream(), *error) ) | |
682 | rc = -1; | |
683 | } | |
684 | ||
685 | } | |
686 | #else | |
687 | wxUnusedVar(output); | |
688 | wxUnusedVar(error); | |
689 | #endif // wxUSE_STREAMS/!wxUSE_STREAMS | |
690 | ||
691 | delete process; | |
692 | ||
693 | return rc; | |
694 | } | |
695 | ||
696 | long wxExecute(const wxString& command, wxArrayString& output, int flags) | |
697 | { | |
698 | return wxDoExecuteWithCapture(command, output, NULL, flags); | |
699 | } | |
700 | ||
701 | long wxExecute(const wxString& command, | |
702 | wxArrayString& output, | |
703 | wxArrayString& error, | |
704 | int flags) | |
705 | { | |
706 | return wxDoExecuteWithCapture(command, output, &error, flags); | |
707 | } | |
708 | ||
709 | // ---------------------------------------------------------------------------- | |
710 | // Launch default browser | |
711 | // ---------------------------------------------------------------------------- | |
712 | ||
713 | bool wxLaunchDefaultBrowser(const wxString& urlOrig, int flags) | |
714 | { | |
715 | wxUnusedVar(flags); | |
716 | ||
717 | // set the scheme of url to http if it does not have one | |
718 | wxString url(urlOrig); | |
719 | if ( !wxURI(url).HasScheme() ) | |
720 | url.Prepend(wxT("http://")); | |
721 | ||
722 | #if defined(__WXMSW__) | |
723 | ||
724 | #if wxUSE_IPC | |
725 | if ( flags & wxBROWSER_NEW_WINDOW ) | |
726 | { | |
727 | // ShellExecuteEx() opens the URL in an existing window by default so | |
728 | // we can't use it if we need a new window | |
729 | wxRegKey key(wxRegKey::HKCR, url.BeforeFirst(':') + _T("\\shell\\open")); | |
730 | if ( key.Exists() ) | |
731 | { | |
732 | wxRegKey keyDDE(key, wxT("DDEExec")); | |
733 | if ( keyDDE.Exists() ) | |
734 | { | |
735 | const wxString ddeTopic = wxRegKey(keyDDE, wxT("topic")); | |
736 | ||
737 | // we only know the syntax of WWW_OpenURL DDE request for IE, | |
738 | // optimistically assume that all other browsers are compatible | |
739 | // with it | |
740 | wxString ddeCmd; | |
741 | bool ok = ddeTopic == wxT("WWW_OpenURL"); | |
742 | if ( ok ) | |
743 | { | |
744 | ddeCmd = keyDDE.QueryDefaultValue(); | |
745 | ok = !ddeCmd.empty(); | |
746 | } | |
747 | ||
748 | if ( ok ) | |
749 | { | |
750 | // for WWW_OpenURL, the index of the window to open the URL | |
751 | // in is -1 (meaning "current") by default, replace it with | |
752 | // 0 which means "new" (see KB article 160957) | |
753 | ok = ddeCmd.Replace(wxT("-1"), wxT("0"), | |
754 | false /* only first occurence */) == 1; | |
755 | } | |
756 | ||
757 | if ( ok ) | |
758 | { | |
759 | // and also replace the parameters: the topic should | |
760 | // contain a placeholder for the URL | |
761 | ok = ddeCmd.Replace(wxT("%1"), url, false) == 1; | |
762 | } | |
763 | ||
764 | if ( ok ) | |
765 | { | |
766 | // try to send it the DDE request now but ignore the errors | |
767 | wxLogNull noLog; | |
768 | ||
769 | const wxString ddeServer = wxRegKey(keyDDE, wxT("application")); | |
770 | if ( wxExecuteDDE(ddeServer, ddeTopic, ddeCmd) ) | |
771 | return true; | |
772 | ||
773 | // this is not necessarily an error: maybe browser is | |
774 | // simply not running, but no matter, in any case we're | |
775 | // going to launch it using ShellExecuteEx() below now and | |
776 | // we shouldn't try to open a new window if we open a new | |
777 | // browser anyhow | |
778 | } | |
779 | } | |
780 | } | |
781 | } | |
782 | #endif // wxUSE_IPC | |
783 | ||
784 | WinStruct<SHELLEXECUTEINFO> sei; | |
785 | sei.lpFile = url.c_str(); | |
786 | sei.lpVerb = _T("open"); | |
787 | sei.nShow = SW_SHOWNORMAL; | |
788 | ||
789 | ::ShellExecuteEx(&sei); | |
790 | ||
791 | const int nResult = (int) sei.hInstApp; | |
792 | ||
793 | // Firefox returns file not found for some reason, so make an exception | |
794 | // for it | |
795 | if ( nResult > 32 || nResult == SE_ERR_FNF ) | |
796 | { | |
797 | #ifdef __WXDEBUG__ | |
798 | // Log something if SE_ERR_FNF happens | |
799 | if ( nResult == SE_ERR_FNF ) | |
800 | wxLogDebug(wxT("SE_ERR_FNF from ShellExecute -- maybe FireFox?")); | |
801 | #endif // __WXDEBUG__ | |
802 | return true; | |
803 | } | |
804 | #elif defined(__WXMAC__) | |
805 | OSStatus err; | |
806 | ICInstance inst; | |
807 | SInt32 startSel; | |
808 | SInt32 endSel; | |
809 | ||
810 | err = ICStart(&inst, 'STKA'); // put your app creator code here | |
811 | if (err == noErr) | |
812 | { | |
813 | #if !TARGET_CARBON | |
814 | err = ICFindConfigFile(inst, 0, NULL); | |
815 | #endif | |
816 | if (err == noErr) | |
817 | { | |
818 | ConstStr255Param hint = 0; | |
819 | startSel = 0; | |
820 | endSel = url.length(); | |
821 | err = ICLaunchURL(inst, hint, url.fn_str(), endSel, &startSel, &endSel); | |
822 | if (err != noErr) | |
823 | wxLogDebug(wxT("ICLaunchURL error %d"), (int) err); | |
824 | } | |
825 | ICStop(inst); | |
826 | return true; | |
827 | } | |
828 | else | |
829 | { | |
830 | wxLogDebug(wxT("ICStart error %d"), (int) err); | |
831 | return false; | |
832 | } | |
833 | #elif wxUSE_MIMETYPE | |
834 | // Non-windows way | |
835 | bool ok = false; | |
836 | wxString cmd; | |
837 | ||
838 | wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(_T("html")); | |
839 | if ( ft ) | |
840 | { | |
841 | wxString mt; | |
842 | ft->GetMimeType(&mt); | |
843 | ||
844 | ok = ft->GetOpenCommand(&cmd, wxFileType::MessageParameters(url)); | |
845 | delete ft; | |
846 | } | |
847 | ||
848 | if ( !ok || cmd.empty() ) | |
849 | { | |
850 | // fallback to checking for the BROWSER environment variable | |
851 | cmd = wxGetenv(wxT("BROWSER")); | |
852 | if ( !cmd.empty() ) | |
853 | cmd << _T(' ') << url; | |
854 | } | |
855 | ||
856 | ok = ( !cmd.empty() && wxExecute(cmd) ); | |
857 | if (ok) | |
858 | return ok; | |
859 | ||
860 | // no file type for HTML extension | |
861 | wxLogError(_T("No default application configured for HTML files.")); | |
862 | ||
863 | #endif // !wxUSE_MIMETYPE && !__WXMSW__ | |
864 | ||
865 | wxLogSysError(_T("Failed to open URL \"%s\" in default browser."), | |
866 | url.c_str()); | |
867 | ||
868 | return false; | |
869 | } | |
870 | ||
871 | // ---------------------------------------------------------------------------- | |
872 | // wxApp::Yield() wrappers for backwards compatibility | |
873 | // ---------------------------------------------------------------------------- | |
874 | ||
875 | bool wxYield() | |
876 | { | |
877 | return wxTheApp && wxTheApp->Yield(); | |
878 | } | |
879 | ||
880 | bool wxYieldIfNeeded() | |
881 | { | |
882 | return wxTheApp && wxTheApp->Yield(true); | |
883 | } | |
884 | ||
885 | #endif // wxUSE_BASE | |
886 | ||
887 | // ============================================================================ | |
888 | // GUI-only functions from now on | |
889 | // ============================================================================ | |
890 | ||
891 | #if wxUSE_GUI | |
892 | ||
893 | // Id generation | |
894 | static long wxCurrentId = 100; | |
895 | ||
896 | long wxNewId() | |
897 | { | |
898 | // skip the part of IDs space that contains hard-coded values: | |
899 | if (wxCurrentId == wxID_LOWEST) | |
900 | wxCurrentId = wxID_HIGHEST + 1; | |
901 | ||
902 | return wxCurrentId++; | |
903 | } | |
904 | ||
905 | long | |
906 | wxGetCurrentId(void) { return wxCurrentId; } | |
907 | ||
908 | void | |
909 | wxRegisterId (long id) | |
910 | { | |
911 | if (id >= wxCurrentId) | |
912 | wxCurrentId = id + 1; | |
913 | } | |
914 | ||
915 | // ---------------------------------------------------------------------------- | |
916 | // Menu accelerators related functions | |
917 | // ---------------------------------------------------------------------------- | |
918 | ||
919 | wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out) | |
920 | { | |
921 | #if wxUSE_MENUS | |
922 | wxString s = wxMenuItem::GetLabelFromText(in); | |
923 | #else | |
924 | wxString str(in); | |
925 | wxString s = wxStripMenuCodes(str); | |
926 | #endif // wxUSE_MENUS | |
927 | if ( out ) | |
928 | { | |
929 | // go smash their buffer if it's not big enough - I love char * params | |
930 | memcpy(out, s.c_str(), s.length() * sizeof(wxChar)); | |
931 | } | |
932 | else | |
933 | { | |
934 | // MYcopystring - for easier search... | |
935 | out = new wxChar[s.length() + 1]; | |
936 | wxStrcpy(out, s.c_str()); | |
937 | } | |
938 | ||
939 | return out; | |
940 | } | |
941 | ||
942 | wxString wxStripMenuCodes(const wxString& in, int flags) | |
943 | { | |
944 | wxASSERT_MSG( flags, _T("this is useless to call without any flags") ); | |
945 | ||
946 | wxString out; | |
947 | ||
948 | size_t len = in.length(); | |
949 | out.reserve(len); | |
950 | ||
951 | for ( size_t n = 0; n < len; n++ ) | |
952 | { | |
953 | wxChar ch = in[n]; | |
954 | if ( (flags & wxStrip_Mnemonics) && ch == _T('&') ) | |
955 | { | |
956 | // skip it, it is used to introduce the accel char (or to quote | |
957 | // itself in which case it should still be skipped): note that it | |
958 | // can't be the last character of the string | |
959 | if ( ++n == len ) | |
960 | { | |
961 | wxLogDebug(_T("Invalid menu string '%s'"), in.c_str()); | |
962 | } | |
963 | else | |
964 | { | |
965 | // use the next char instead | |
966 | ch = in[n]; | |
967 | } | |
968 | } | |
969 | else if ( (flags & wxStrip_Accel) && ch == _T('\t') ) | |
970 | { | |
971 | // everything after TAB is accel string, exit the loop | |
972 | break; | |
973 | } | |
974 | ||
975 | out += ch; | |
976 | } | |
977 | ||
978 | return out; | |
979 | } | |
980 | ||
981 | // ---------------------------------------------------------------------------- | |
982 | // Window search functions | |
983 | // ---------------------------------------------------------------------------- | |
984 | ||
985 | /* | |
986 | * If parent is non-NULL, look through children for a label or title | |
987 | * matching the specified string. If NULL, look through all top-level windows. | |
988 | * | |
989 | */ | |
990 | ||
991 | wxWindow * | |
992 | wxFindWindowByLabel (const wxString& title, wxWindow * parent) | |
993 | { | |
994 | return wxWindow::FindWindowByLabel( title, parent ); | |
995 | } | |
996 | ||
997 | ||
998 | /* | |
999 | * If parent is non-NULL, look through children for a name | |
1000 | * matching the specified string. If NULL, look through all top-level windows. | |
1001 | * | |
1002 | */ | |
1003 | ||
1004 | wxWindow * | |
1005 | wxFindWindowByName (const wxString& name, wxWindow * parent) | |
1006 | { | |
1007 | return wxWindow::FindWindowByName( name, parent ); | |
1008 | } | |
1009 | ||
1010 | // Returns menu item id or wxNOT_FOUND if none. | |
1011 | int | |
1012 | wxFindMenuItemId (wxFrame * frame, const wxString& menuString, const wxString& itemString) | |
1013 | { | |
1014 | #if wxUSE_MENUS | |
1015 | wxMenuBar *menuBar = frame->GetMenuBar (); | |
1016 | if ( menuBar ) | |
1017 | return menuBar->FindMenuItem (menuString, itemString); | |
1018 | #endif // wxUSE_MENUS | |
1019 | ||
1020 | return wxNOT_FOUND; | |
1021 | } | |
1022 | ||
1023 | // Try to find the deepest child that contains 'pt'. | |
1024 | // We go backwards, to try to allow for controls that are spacially | |
1025 | // within other controls, but are still siblings (e.g. buttons within | |
1026 | // static boxes). Static boxes are likely to be created _before_ controls | |
1027 | // that sit inside them. | |
1028 | wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt) | |
1029 | { | |
1030 | if (!win->IsShown()) | |
1031 | return NULL; | |
1032 | ||
1033 | // Hack for wxNotebook case: at least in wxGTK, all pages | |
1034 | // claim to be shown, so we must only deal with the selected one. | |
1035 | #if wxUSE_NOTEBOOK | |
1036 | if (win->IsKindOf(CLASSINFO(wxNotebook))) | |
1037 | { | |
1038 | wxNotebook* nb = (wxNotebook*) win; | |
1039 | int sel = nb->GetSelection(); | |
1040 | if (sel >= 0) | |
1041 | { | |
1042 | wxWindow* child = nb->GetPage(sel); | |
1043 | wxWindow* foundWin = wxFindWindowAtPoint(child, pt); | |
1044 | if (foundWin) | |
1045 | return foundWin; | |
1046 | } | |
1047 | } | |
1048 | #endif | |
1049 | ||
1050 | wxWindowList::compatibility_iterator node = win->GetChildren().GetLast(); | |
1051 | while (node) | |
1052 | { | |
1053 | wxWindow* child = node->GetData(); | |
1054 | wxWindow* foundWin = wxFindWindowAtPoint(child, pt); | |
1055 | if (foundWin) | |
1056 | return foundWin; | |
1057 | node = node->GetPrevious(); | |
1058 | } | |
1059 | ||
1060 | wxPoint pos = win->GetPosition(); | |
1061 | wxSize sz = win->GetSize(); | |
1062 | if ( !win->IsTopLevel() && win->GetParent() ) | |
1063 | { | |
1064 | pos = win->GetParent()->ClientToScreen(pos); | |
1065 | } | |
1066 | ||
1067 | wxRect rect(pos, sz); | |
1068 | if (rect.Inside(pt)) | |
1069 | return win; | |
1070 | ||
1071 | return NULL; | |
1072 | } | |
1073 | ||
1074 | wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt) | |
1075 | { | |
1076 | // Go backwards through the list since windows | |
1077 | // on top are likely to have been appended most | |
1078 | // recently. | |
1079 | wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast(); | |
1080 | while (node) | |
1081 | { | |
1082 | wxWindow* win = node->GetData(); | |
1083 | wxWindow* found = wxFindWindowAtPoint(win, pt); | |
1084 | if (found) | |
1085 | return found; | |
1086 | node = node->GetPrevious(); | |
1087 | } | |
1088 | return NULL; | |
1089 | } | |
1090 | ||
1091 | // ---------------------------------------------------------------------------- | |
1092 | // GUI helpers | |
1093 | // ---------------------------------------------------------------------------- | |
1094 | ||
1095 | /* | |
1096 | * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp | |
1097 | * since otherwise the generic code may be pulled in unnecessarily. | |
1098 | */ | |
1099 | ||
1100 | #if wxUSE_MSGDLG | |
1101 | ||
1102 | int wxMessageBox(const wxString& message, const wxString& caption, long style, | |
1103 | wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) ) | |
1104 | { | |
1105 | long decorated_style = style; | |
1106 | ||
1107 | if ( ( style & ( wxICON_EXCLAMATION | wxICON_HAND | wxICON_INFORMATION | wxICON_QUESTION ) ) == 0 ) | |
1108 | { | |
1109 | decorated_style |= ( style & wxYES ) ? wxICON_QUESTION : wxICON_INFORMATION ; | |
1110 | } | |
1111 | ||
1112 | wxMessageDialog dialog(parent, message, caption, decorated_style); | |
1113 | ||
1114 | int ans = dialog.ShowModal(); | |
1115 | switch ( ans ) | |
1116 | { | |
1117 | case wxID_OK: | |
1118 | return wxOK; | |
1119 | case wxID_YES: | |
1120 | return wxYES; | |
1121 | case wxID_NO: | |
1122 | return wxNO; | |
1123 | case wxID_CANCEL: | |
1124 | return wxCANCEL; | |
1125 | } | |
1126 | ||
1127 | wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") ); | |
1128 | ||
1129 | return wxCANCEL; | |
1130 | } | |
1131 | ||
1132 | #endif // wxUSE_MSGDLG | |
1133 | ||
1134 | #if wxUSE_TEXTDLG | |
1135 | ||
1136 | wxString wxGetTextFromUser(const wxString& message, const wxString& caption, | |
1137 | const wxString& defaultValue, wxWindow *parent, | |
1138 | wxCoord x, wxCoord y, bool centre ) | |
1139 | { | |
1140 | wxString str; | |
1141 | long style = wxTextEntryDialogStyle; | |
1142 | ||
1143 | if (centre) | |
1144 | style |= wxCENTRE; | |
1145 | else | |
1146 | style &= ~wxCENTRE; | |
1147 | ||
1148 | wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y)); | |
1149 | ||
1150 | if (dialog.ShowModal() == wxID_OK) | |
1151 | { | |
1152 | str = dialog.GetValue(); | |
1153 | } | |
1154 | ||
1155 | return str; | |
1156 | } | |
1157 | ||
1158 | wxString wxGetPasswordFromUser(const wxString& message, | |
1159 | const wxString& caption, | |
1160 | const wxString& defaultValue, | |
1161 | wxWindow *parent, | |
1162 | wxCoord x, wxCoord y, bool centre ) | |
1163 | { | |
1164 | wxString str; | |
1165 | long style = wxTextEntryDialogStyle; | |
1166 | ||
1167 | if (centre) | |
1168 | style |= wxCENTRE; | |
1169 | else | |
1170 | style &= ~wxCENTRE; | |
1171 | ||
1172 | wxPasswordEntryDialog dialog(parent, message, caption, defaultValue, | |
1173 | style, wxPoint(x, y)); | |
1174 | if ( dialog.ShowModal() == wxID_OK ) | |
1175 | { | |
1176 | str = dialog.GetValue(); | |
1177 | } | |
1178 | ||
1179 | return str; | |
1180 | } | |
1181 | ||
1182 | #endif // wxUSE_TEXTDLG | |
1183 | ||
1184 | #if wxUSE_COLOURDLG | |
1185 | ||
1186 | wxColour wxGetColourFromUser(wxWindow *parent, const wxColour& colInit, const wxString& caption) | |
1187 | { | |
1188 | wxColourData data; | |
1189 | data.SetChooseFull(true); | |
1190 | if ( colInit.Ok() ) | |
1191 | { | |
1192 | data.SetColour((wxColour &)colInit); // const_cast | |
1193 | } | |
1194 | ||
1195 | wxColour colRet; | |
1196 | wxColourDialog dialog(parent, &data); | |
1197 | if (!caption.empty()) | |
1198 | dialog.SetTitle(caption); | |
1199 | if ( dialog.ShowModal() == wxID_OK ) | |
1200 | { | |
1201 | colRet = dialog.GetColourData().GetColour(); | |
1202 | } | |
1203 | //else: leave it invalid | |
1204 | ||
1205 | return colRet; | |
1206 | } | |
1207 | ||
1208 | #endif // wxUSE_COLOURDLG | |
1209 | ||
1210 | #if wxUSE_FONTDLG | |
1211 | ||
1212 | wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit, const wxString& caption) | |
1213 | { | |
1214 | wxFontData data; | |
1215 | if ( fontInit.Ok() ) | |
1216 | { | |
1217 | data.SetInitialFont(fontInit); | |
1218 | } | |
1219 | ||
1220 | wxFont fontRet; | |
1221 | wxFontDialog dialog(parent, data); | |
1222 | if (!caption.empty()) | |
1223 | dialog.SetTitle(caption); | |
1224 | if ( dialog.ShowModal() == wxID_OK ) | |
1225 | { | |
1226 | fontRet = dialog.GetFontData().GetChosenFont(); | |
1227 | } | |
1228 | //else: leave it invalid | |
1229 | ||
1230 | return fontRet; | |
1231 | } | |
1232 | ||
1233 | #endif // wxUSE_FONTDLG | |
1234 | ||
1235 | // ---------------------------------------------------------------------------- | |
1236 | // wxSafeYield and supporting functions | |
1237 | // ---------------------------------------------------------------------------- | |
1238 | ||
1239 | void wxEnableTopLevelWindows(bool enable) | |
1240 | { | |
1241 | wxWindowList::compatibility_iterator node; | |
1242 | for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() ) | |
1243 | node->GetData()->Enable(enable); | |
1244 | } | |
1245 | ||
1246 | wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip) | |
1247 | { | |
1248 | // remember the top level windows which were already disabled, so that we | |
1249 | // don't reenable them later | |
1250 | m_winDisabled = NULL; | |
1251 | ||
1252 | wxWindowList::compatibility_iterator node; | |
1253 | for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() ) | |
1254 | { | |
1255 | wxWindow *winTop = node->GetData(); | |
1256 | if ( winTop == winToSkip ) | |
1257 | continue; | |
1258 | ||
1259 | // we don't need to disable the hidden or already disabled windows | |
1260 | if ( winTop->IsEnabled() && winTop->IsShown() ) | |
1261 | { | |
1262 | winTop->Disable(); | |
1263 | } | |
1264 | else | |
1265 | { | |
1266 | if ( !m_winDisabled ) | |
1267 | { | |
1268 | m_winDisabled = new wxWindowList; | |
1269 | } | |
1270 | ||
1271 | m_winDisabled->Append(winTop); | |
1272 | } | |
1273 | } | |
1274 | } | |
1275 | ||
1276 | wxWindowDisabler::~wxWindowDisabler() | |
1277 | { | |
1278 | wxWindowList::compatibility_iterator node; | |
1279 | for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() ) | |
1280 | { | |
1281 | wxWindow *winTop = node->GetData(); | |
1282 | if ( !m_winDisabled || !m_winDisabled->Find(winTop) ) | |
1283 | { | |
1284 | winTop->Enable(); | |
1285 | } | |
1286 | //else: had been already disabled, don't reenable | |
1287 | } | |
1288 | ||
1289 | delete m_winDisabled; | |
1290 | } | |
1291 | ||
1292 | // Yield to other apps/messages and disable user input to all windows except | |
1293 | // the given one | |
1294 | bool wxSafeYield(wxWindow *win, bool onlyIfNeeded) | |
1295 | { | |
1296 | wxWindowDisabler wd(win); | |
1297 | ||
1298 | bool rc; | |
1299 | if (onlyIfNeeded) | |
1300 | rc = wxYieldIfNeeded(); | |
1301 | else | |
1302 | rc = wxYield(); | |
1303 | ||
1304 | return rc; | |
1305 | } | |
1306 | ||
1307 | // Don't synthesize KeyUp events holding down a key and producing KeyDown | |
1308 | // events with autorepeat. On by default and always on in wxMSW. wxGTK version | |
1309 | // in utilsgtk.cpp. | |
1310 | #ifndef __WXGTK__ | |
1311 | bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) ) | |
1312 | { | |
1313 | return true; // detectable auto-repeat is the only mode MSW supports | |
1314 | } | |
1315 | #endif // !wxGTK | |
1316 | ||
1317 | #endif // wxUSE_GUI |