]> git.saurik.com Git - wxWidgets.git/blob - src/common/utilscmn.cpp
Temporary ugly trick to make release for OpenWatcom possible.
[wxWidgets.git] / src / common / utilscmn.cpp
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
451 #if 0
452
453 // FIXME: wxWinPocketPC and wxWinSmartPhone are unknown symbols
454
455 #if defined(__WXWINCE__) && defined(__POCKETPC__)
456 if (platform == wxWinPocketPC)
457 return true;
458 #endif
459 #if defined(__WXWINCE__) && defined(__SMARTPHONE__)
460 if (platform == wxWinSmartPhone)
461 return true;
462 #endif
463
464 #endif
465
466 #ifdef __WXGTK__
467 if (platform == wxPORT_GTK)
468 return true;
469 #endif
470 #ifdef __WXMAC__
471 if (platform == wxPORT_MAC)
472 return true;
473 #endif
474 #ifdef __WXX11__
475 if (platform == wxPORT_X11)
476 return true;
477 #endif
478 #ifdef __UNIX__
479 if (platform == wxOS_UNIX)
480 return true;
481 #endif
482 #ifdef __WXMGL__
483 if (platform == wxPORT_MGL)
484 return true;
485 #endif
486 #ifdef __OS2__
487 if (platform == wxOS_OS2)
488 return true;
489 #endif
490 #ifdef __WXPM__
491 if (platform == wxPORT_PM)
492 return true;
493 #endif
494 #ifdef __WXCOCOA__
495 if (platform == wxPORT_MAC)
496 return true;
497 #endif
498
499 if (sm_customPlatforms && sm_customPlatforms->Index(platform) != wxNOT_FOUND)
500 return true;
501
502 return false;
503 }
504
505 // ----------------------------------------------------------------------------
506 // network and user id functions
507 // ----------------------------------------------------------------------------
508
509 // Get Full RFC822 style email address
510 bool wxGetEmailAddress(wxChar *address, int maxSize)
511 {
512 wxString email = wxGetEmailAddress();
513 if ( !email )
514 return false;
515
516 wxStrncpy(address, email, maxSize - 1);
517 address[maxSize - 1] = wxT('\0');
518
519 return true;
520 }
521
522 wxString wxGetEmailAddress()
523 {
524 wxString email;
525
526 wxString host = wxGetFullHostName();
527 if ( !host.empty() )
528 {
529 wxString user = wxGetUserId();
530 if ( !user.empty() )
531 {
532 email << user << wxT('@') << host;
533 }
534 }
535
536 return email;
537 }
538
539 wxString wxGetUserId()
540 {
541 static const int maxLoginLen = 256; // FIXME arbitrary number
542
543 wxString buf;
544 bool ok = wxGetUserId(wxStringBuffer(buf, maxLoginLen), maxLoginLen);
545
546 if ( !ok )
547 buf.Empty();
548
549 return buf;
550 }
551
552 wxString wxGetUserName()
553 {
554 static const int maxUserNameLen = 1024; // FIXME arbitrary number
555
556 wxString buf;
557 bool ok = wxGetUserName(wxStringBuffer(buf, maxUserNameLen), maxUserNameLen);
558
559 if ( !ok )
560 buf.Empty();
561
562 return buf;
563 }
564
565 wxString wxGetHostName()
566 {
567 static const size_t hostnameSize = 257;
568
569 wxString buf;
570 bool ok = wxGetHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
571
572 if ( !ok )
573 buf.Empty();
574
575 return buf;
576 }
577
578 wxString wxGetFullHostName()
579 {
580 static const size_t hostnameSize = 257;
581
582 wxString buf;
583 bool ok = wxGetFullHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
584
585 if ( !ok )
586 buf.Empty();
587
588 return buf;
589 }
590
591 wxString wxGetHomeDir()
592 {
593 wxString home;
594 wxGetHomeDir(&home);
595
596 return home;
597 }
598
599 #if 0
600
601 wxString wxGetCurrentDir()
602 {
603 wxString dir;
604 size_t len = 1024;
605 bool ok;
606 do
607 {
608 ok = getcwd(dir.GetWriteBuf(len + 1), len) != NULL;
609 dir.UngetWriteBuf();
610
611 if ( !ok )
612 {
613 if ( errno != ERANGE )
614 {
615 wxLogSysError(_T("Failed to get current directory"));
616
617 return wxEmptyString;
618 }
619 else
620 {
621 // buffer was too small, retry with a larger one
622 len *= 2;
623 }
624 }
625 //else: ok
626 } while ( !ok );
627
628 return dir;
629 }
630
631 #endif // 0
632
633 // ----------------------------------------------------------------------------
634 // wxExecute
635 // ----------------------------------------------------------------------------
636
637 // wxDoExecuteWithCapture() helper: reads an entire stream into one array
638 //
639 // returns true if ok, false if error
640 #if wxUSE_STREAMS
641 static bool ReadAll(wxInputStream *is, wxArrayString& output)
642 {
643 wxCHECK_MSG( is, false, _T("NULL stream in wxExecute()?") );
644
645 // the stream could be already at EOF or in wxSTREAM_BROKEN_PIPE state
646 is->Reset();
647
648 wxTextInputStream tis(*is);
649
650 bool cont = true;
651 while ( cont )
652 {
653 wxString line = tis.ReadLine();
654 if ( is->Eof() )
655 break;
656
657 if ( !*is )
658 {
659 cont = false;
660 }
661 else
662 {
663 output.Add(line);
664 }
665 }
666
667 return cont;
668 }
669 #endif // wxUSE_STREAMS
670
671 // this is a private function because it hasn't a clean interface: the first
672 // array is passed by reference, the second by pointer - instead we have 2
673 // public versions of wxExecute() below
674 static long wxDoExecuteWithCapture(const wxString& command,
675 wxArrayString& output,
676 wxArrayString* error,
677 int flags)
678 {
679 // create a wxProcess which will capture the output
680 wxProcess *process = new wxProcess;
681 process->Redirect();
682
683 long rc = wxExecute(command, wxEXEC_SYNC | flags, process);
684
685 #if wxUSE_STREAMS
686 if ( rc != -1 )
687 {
688 if ( !ReadAll(process->GetInputStream(), output) )
689 rc = -1;
690
691 if ( error )
692 {
693 if ( !ReadAll(process->GetErrorStream(), *error) )
694 rc = -1;
695 }
696
697 }
698 #else
699 wxUnusedVar(output);
700 wxUnusedVar(error);
701 #endif // wxUSE_STREAMS/!wxUSE_STREAMS
702
703 delete process;
704
705 return rc;
706 }
707
708 long wxExecute(const wxString& command, wxArrayString& output, int flags)
709 {
710 return wxDoExecuteWithCapture(command, output, NULL, flags);
711 }
712
713 long wxExecute(const wxString& command,
714 wxArrayString& output,
715 wxArrayString& error,
716 int flags)
717 {
718 return wxDoExecuteWithCapture(command, output, &error, flags);
719 }
720
721 // ----------------------------------------------------------------------------
722 // Launch default browser
723 // ----------------------------------------------------------------------------
724
725 bool wxLaunchDefaultBrowser(const wxString& urlOrig, int flags)
726 {
727 wxUnusedVar(flags);
728
729 // set the scheme of url to http if it does not have one
730 // RR: This doesn't work if the url is just a local path
731 wxString url(urlOrig);
732 wxURI uri(url);
733 if ( !uri.HasScheme() )
734 url.Prepend(wxT("http://"));
735
736
737 #if defined(__WXMSW__)
738
739 #if wxUSE_IPC
740 if ( flags & wxBROWSER_NEW_WINDOW )
741 {
742 // ShellExecuteEx() opens the URL in an existing window by default so
743 // we can't use it if we need a new window
744 wxRegKey key(wxRegKey::HKCR, uri.GetScheme() + _T("\\shell\\open"));
745 if ( !key.Exists() )
746 {
747 // try default browser, it must be registered at least for http URLs
748 key.SetName(wxRegKey::HKCR, _T("http\\shell\\open"));
749 }
750
751 if ( key.Exists() )
752 {
753 wxRegKey keyDDE(key, wxT("DDEExec"));
754 if ( keyDDE.Exists() )
755 {
756 const wxString ddeTopic = wxRegKey(keyDDE, wxT("topic"));
757
758 // we only know the syntax of WWW_OpenURL DDE request for IE,
759 // optimistically assume that all other browsers are compatible
760 // with it
761 wxString ddeCmd;
762 bool ok = ddeTopic == wxT("WWW_OpenURL");
763 if ( ok )
764 {
765 ddeCmd = keyDDE.QueryDefaultValue();
766 ok = !ddeCmd.empty();
767 }
768
769 if ( ok )
770 {
771 // for WWW_OpenURL, the index of the window to open the URL
772 // in is -1 (meaning "current") by default, replace it with
773 // 0 which means "new" (see KB article 160957)
774 ok = ddeCmd.Replace(wxT("-1"), wxT("0"),
775 false /* only first occurence */) == 1;
776 }
777
778 if ( ok )
779 {
780 // and also replace the parameters: the topic should
781 // contain a placeholder for the URL
782 ok = ddeCmd.Replace(wxT("%1"), url, false) == 1;
783 }
784
785 if ( ok )
786 {
787 // try to send it the DDE request now but ignore the errors
788 wxLogNull noLog;
789
790 const wxString ddeServer = wxRegKey(keyDDE, wxT("application"));
791 if ( wxExecuteDDE(ddeServer, ddeTopic, ddeCmd) )
792 return true;
793
794 // this is not necessarily an error: maybe browser is
795 // simply not running, but no matter, in any case we're
796 // going to launch it using ShellExecuteEx() below now and
797 // we shouldn't try to open a new window if we open a new
798 // browser anyhow
799 }
800 }
801 }
802 }
803 #endif // wxUSE_IPC
804
805 WinStruct<SHELLEXECUTEINFO> sei;
806 sei.lpFile = url.c_str();
807 sei.lpVerb = _T("open");
808 sei.nShow = SW_SHOWNORMAL;
809
810 ::ShellExecuteEx(&sei);
811
812 const int nResult = (int) sei.hInstApp;
813
814 // Firefox returns file not found for some reason, so make an exception
815 // for it
816 if ( nResult > 32 || nResult == SE_ERR_FNF )
817 {
818 #ifdef __WXDEBUG__
819 // Log something if SE_ERR_FNF happens
820 if ( nResult == SE_ERR_FNF )
821 wxLogDebug(wxT("SE_ERR_FNF from ShellExecute -- maybe FireFox?"));
822 #endif // __WXDEBUG__
823 return true;
824 }
825 #elif defined(__WXMAC__)
826 OSStatus err;
827 ICInstance inst;
828 long int startSel;
829 long int endSel;
830
831 err = ICStart(&inst, 'STKA'); // put your app creator code here
832 if (err == noErr)
833 {
834 #if !TARGET_CARBON
835 err = ICFindConfigFile(inst, 0, NULL);
836 #endif
837 if (err == noErr)
838 {
839 ConstStr255Param hint = 0;
840 startSel = 0;
841 endSel = url.length();
842 err = ICLaunchURL(inst, hint, url.fn_str(), endSel, &startSel, &endSel);
843 if (err != noErr)
844 wxLogDebug(wxT("ICLaunchURL error %d"), (int) err);
845 }
846 ICStop(inst);
847 return true;
848 }
849 else
850 {
851 wxLogDebug(wxT("ICStart error %d"), (int) err);
852 return false;
853 }
854 #else
855 // (non-Mac, non-MSW)
856
857 #ifdef __UNIX__
858 if (wxTheApp->GetTraits()->GetDesktopEnvironment() == wxT("GNOME"))
859 {
860 wxArrayString errors;
861 wxArrayString output;
862 long res = wxExecute( wxT("gconftool-2 --get /desktop/gnome/applications/browser/exec"), output, errors, wxEXEC_NODISABLE );
863 if (res >= 0 && errors.GetCount() == 0)
864 {
865 wxString cmd = output[0];
866 cmd << _T(' ') << url;
867 if (wxExecute(cmd))
868 return true;
869 }
870 }
871 #endif
872
873 bool ok = false;
874 wxString cmd;
875
876 wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(_T("html"));
877 if ( ft )
878 {
879 wxString mt;
880 ft->GetMimeType(&mt);
881
882 ok = ft->GetOpenCommand(&cmd, wxFileType::MessageParameters(url));
883 delete ft;
884 }
885
886 if ( !ok || cmd.empty() )
887 {
888 // fallback to checking for the BROWSER environment variable
889 cmd = wxGetenv(wxT("BROWSER"));
890 if ( !cmd.empty() )
891 cmd << _T(' ') << url;
892 }
893
894 ok = ( !cmd.empty() && wxExecute(cmd) );
895 if (ok)
896 return ok;
897
898 // no file type for HTML extension
899 wxLogError(_T("No default application configured for HTML files."));
900
901 #endif // !wxUSE_MIMETYPE && !__WXMSW__
902
903 wxLogSysError(_T("Failed to open URL \"%s\" in default browser."),
904 url.c_str());
905
906 return false;
907 }
908
909 // ----------------------------------------------------------------------------
910 // wxApp::Yield() wrappers for backwards compatibility
911 // ----------------------------------------------------------------------------
912
913 bool wxYield()
914 {
915 return wxTheApp && wxTheApp->Yield();
916 }
917
918 bool wxYieldIfNeeded()
919 {
920 return wxTheApp && wxTheApp->Yield(true);
921 }
922
923 #endif // wxUSE_BASE
924
925 // ============================================================================
926 // GUI-only functions from now on
927 // ============================================================================
928
929 #if wxUSE_GUI
930
931 // Id generation
932 static long wxCurrentId = 100;
933
934 long wxNewId()
935 {
936 // skip the part of IDs space that contains hard-coded values:
937 if (wxCurrentId == wxID_LOWEST)
938 wxCurrentId = wxID_HIGHEST + 1;
939
940 return wxCurrentId++;
941 }
942
943 long
944 wxGetCurrentId(void) { return wxCurrentId; }
945
946 void
947 wxRegisterId (long id)
948 {
949 if (id >= wxCurrentId)
950 wxCurrentId = id + 1;
951 }
952
953 // ----------------------------------------------------------------------------
954 // Menu accelerators related functions
955 // ----------------------------------------------------------------------------
956
957 wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
958 {
959 #if wxUSE_MENUS
960 wxString s = wxMenuItem::GetLabelFromText(in);
961 #else
962 wxString str(in);
963 wxString s = wxStripMenuCodes(str);
964 #endif // wxUSE_MENUS
965 if ( out )
966 {
967 // go smash their buffer if it's not big enough - I love char * params
968 memcpy(out, s.c_str(), s.length() * sizeof(wxChar));
969 }
970 else
971 {
972 // MYcopystring - for easier search...
973 out = new wxChar[s.length() + 1];
974 wxStrcpy(out, s.c_str());
975 }
976
977 return out;
978 }
979
980 wxString wxStripMenuCodes(const wxString& in, int flags)
981 {
982 wxASSERT_MSG( flags, _T("this is useless to call without any flags") );
983
984 wxString out;
985
986 size_t len = in.length();
987 out.reserve(len);
988
989 for ( size_t n = 0; n < len; n++ )
990 {
991 wxChar ch = in[n];
992 if ( (flags & wxStrip_Mnemonics) && ch == _T('&') )
993 {
994 // skip it, it is used to introduce the accel char (or to quote
995 // itself in which case it should still be skipped): note that it
996 // can't be the last character of the string
997 if ( ++n == len )
998 {
999 wxLogDebug(_T("Invalid menu string '%s'"), in.c_str());
1000 }
1001 else
1002 {
1003 // use the next char instead
1004 ch = in[n];
1005 }
1006 }
1007 else if ( (flags & wxStrip_Accel) && ch == _T('\t') )
1008 {
1009 // everything after TAB is accel string, exit the loop
1010 break;
1011 }
1012
1013 out += ch;
1014 }
1015
1016 return out;
1017 }
1018
1019 // ----------------------------------------------------------------------------
1020 // Window search functions
1021 // ----------------------------------------------------------------------------
1022
1023 /*
1024 * If parent is non-NULL, look through children for a label or title
1025 * matching the specified string. If NULL, look through all top-level windows.
1026 *
1027 */
1028
1029 wxWindow *
1030 wxFindWindowByLabel (const wxString& title, wxWindow * parent)
1031 {
1032 return wxWindow::FindWindowByLabel( title, parent );
1033 }
1034
1035
1036 /*
1037 * If parent is non-NULL, look through children for a name
1038 * matching the specified string. If NULL, look through all top-level windows.
1039 *
1040 */
1041
1042 wxWindow *
1043 wxFindWindowByName (const wxString& name, wxWindow * parent)
1044 {
1045 return wxWindow::FindWindowByName( name, parent );
1046 }
1047
1048 // Returns menu item id or wxNOT_FOUND if none.
1049 int
1050 wxFindMenuItemId (wxFrame * frame, const wxString& menuString, const wxString& itemString)
1051 {
1052 #if wxUSE_MENUS
1053 wxMenuBar *menuBar = frame->GetMenuBar ();
1054 if ( menuBar )
1055 return menuBar->FindMenuItem (menuString, itemString);
1056 #endif // wxUSE_MENUS
1057
1058 return wxNOT_FOUND;
1059 }
1060
1061 // Try to find the deepest child that contains 'pt'.
1062 // We go backwards, to try to allow for controls that are spacially
1063 // within other controls, but are still siblings (e.g. buttons within
1064 // static boxes). Static boxes are likely to be created _before_ controls
1065 // that sit inside them.
1066 wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt)
1067 {
1068 if (!win->IsShown())
1069 return NULL;
1070
1071 // Hack for wxNotebook case: at least in wxGTK, all pages
1072 // claim to be shown, so we must only deal with the selected one.
1073 #if wxUSE_NOTEBOOK
1074 if (win->IsKindOf(CLASSINFO(wxNotebook)))
1075 {
1076 wxNotebook* nb = (wxNotebook*) win;
1077 int sel = nb->GetSelection();
1078 if (sel >= 0)
1079 {
1080 wxWindow* child = nb->GetPage(sel);
1081 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1082 if (foundWin)
1083 return foundWin;
1084 }
1085 }
1086 #endif
1087
1088 wxWindowList::compatibility_iterator node = win->GetChildren().GetLast();
1089 while (node)
1090 {
1091 wxWindow* child = node->GetData();
1092 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1093 if (foundWin)
1094 return foundWin;
1095 node = node->GetPrevious();
1096 }
1097
1098 wxPoint pos = win->GetPosition();
1099 wxSize sz = win->GetSize();
1100 if ( !win->IsTopLevel() && win->GetParent() )
1101 {
1102 pos = win->GetParent()->ClientToScreen(pos);
1103 }
1104
1105 wxRect rect(pos, sz);
1106 if (rect.Contains(pt))
1107 return win;
1108
1109 return NULL;
1110 }
1111
1112 wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt)
1113 {
1114 // Go backwards through the list since windows
1115 // on top are likely to have been appended most
1116 // recently.
1117 wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast();
1118 while (node)
1119 {
1120 wxWindow* win = node->GetData();
1121 wxWindow* found = wxFindWindowAtPoint(win, pt);
1122 if (found)
1123 return found;
1124 node = node->GetPrevious();
1125 }
1126 return NULL;
1127 }
1128
1129 // ----------------------------------------------------------------------------
1130 // GUI helpers
1131 // ----------------------------------------------------------------------------
1132
1133 /*
1134 * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
1135 * since otherwise the generic code may be pulled in unnecessarily.
1136 */
1137
1138 #if wxUSE_MSGDLG
1139
1140 int wxMessageBox(const wxString& message, const wxString& caption, long style,
1141 wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
1142 {
1143 long decorated_style = style;
1144
1145 if ( ( style & ( wxICON_EXCLAMATION | wxICON_HAND | wxICON_INFORMATION | wxICON_QUESTION ) ) == 0 )
1146 {
1147 decorated_style |= ( style & wxYES ) ? wxICON_QUESTION : wxICON_INFORMATION ;
1148 }
1149
1150 wxMessageDialog dialog(parent, message, caption, decorated_style);
1151
1152 int ans = dialog.ShowModal();
1153 switch ( ans )
1154 {
1155 case wxID_OK:
1156 return wxOK;
1157 case wxID_YES:
1158 return wxYES;
1159 case wxID_NO:
1160 return wxNO;
1161 case wxID_CANCEL:
1162 return wxCANCEL;
1163 }
1164
1165 wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") );
1166
1167 return wxCANCEL;
1168 }
1169
1170 #endif // wxUSE_MSGDLG
1171
1172 #if wxUSE_TEXTDLG
1173
1174 wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
1175 const wxString& defaultValue, wxWindow *parent,
1176 wxCoord x, wxCoord y, bool centre )
1177 {
1178 wxString str;
1179 long style = wxTextEntryDialogStyle;
1180
1181 if (centre)
1182 style |= wxCENTRE;
1183 else
1184 style &= ~wxCENTRE;
1185
1186 wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y));
1187
1188 if (dialog.ShowModal() == wxID_OK)
1189 {
1190 str = dialog.GetValue();
1191 }
1192
1193 return str;
1194 }
1195
1196 wxString wxGetPasswordFromUser(const wxString& message,
1197 const wxString& caption,
1198 const wxString& defaultValue,
1199 wxWindow *parent,
1200 wxCoord x, wxCoord y, bool centre )
1201 {
1202 wxString str;
1203 long style = wxTextEntryDialogStyle;
1204
1205 if (centre)
1206 style |= wxCENTRE;
1207 else
1208 style &= ~wxCENTRE;
1209
1210 wxPasswordEntryDialog dialog(parent, message, caption, defaultValue,
1211 style, wxPoint(x, y));
1212 if ( dialog.ShowModal() == wxID_OK )
1213 {
1214 str = dialog.GetValue();
1215 }
1216
1217 return str;
1218 }
1219
1220 #endif // wxUSE_TEXTDLG
1221
1222 #if wxUSE_COLOURDLG
1223
1224 wxColour wxGetColourFromUser(wxWindow *parent, const wxColour& colInit, const wxString& caption)
1225 {
1226 wxColourData data;
1227 data.SetChooseFull(true);
1228 if ( colInit.Ok() )
1229 {
1230 data.SetColour((wxColour &)colInit); // const_cast
1231 }
1232
1233 wxColour colRet;
1234 wxColourDialog dialog(parent, &data);
1235 if (!caption.empty())
1236 dialog.SetTitle(caption);
1237 if ( dialog.ShowModal() == wxID_OK )
1238 {
1239 colRet = dialog.GetColourData().GetColour();
1240 }
1241 //else: leave it invalid
1242
1243 return colRet;
1244 }
1245
1246 #endif // wxUSE_COLOURDLG
1247
1248 #if wxUSE_FONTDLG
1249
1250 wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit, const wxString& caption)
1251 {
1252 wxFontData data;
1253 if ( fontInit.Ok() )
1254 {
1255 data.SetInitialFont(fontInit);
1256 }
1257
1258 wxFont fontRet;
1259 wxFontDialog dialog(parent, data);
1260 if (!caption.empty())
1261 dialog.SetTitle(caption);
1262 if ( dialog.ShowModal() == wxID_OK )
1263 {
1264 fontRet = dialog.GetFontData().GetChosenFont();
1265 }
1266 //else: leave it invalid
1267
1268 return fontRet;
1269 }
1270
1271 #endif // wxUSE_FONTDLG
1272
1273 // ----------------------------------------------------------------------------
1274 // wxSafeYield and supporting functions
1275 // ----------------------------------------------------------------------------
1276
1277 void wxEnableTopLevelWindows(bool enable)
1278 {
1279 wxWindowList::compatibility_iterator node;
1280 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1281 node->GetData()->Enable(enable);
1282 }
1283
1284 wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
1285 {
1286 // remember the top level windows which were already disabled, so that we
1287 // don't reenable them later
1288 m_winDisabled = NULL;
1289
1290 wxWindowList::compatibility_iterator node;
1291 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1292 {
1293 wxWindow *winTop = node->GetData();
1294 if ( winTop == winToSkip )
1295 continue;
1296
1297 // we don't need to disable the hidden or already disabled windows
1298 if ( winTop->IsEnabled() && winTop->IsShown() )
1299 {
1300 winTop->Disable();
1301 }
1302 else
1303 {
1304 if ( !m_winDisabled )
1305 {
1306 m_winDisabled = new wxWindowList;
1307 }
1308
1309 m_winDisabled->Append(winTop);
1310 }
1311 }
1312 }
1313
1314 wxWindowDisabler::~wxWindowDisabler()
1315 {
1316 wxWindowList::compatibility_iterator node;
1317 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1318 {
1319 wxWindow *winTop = node->GetData();
1320 if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
1321 {
1322 winTop->Enable();
1323 }
1324 //else: had been already disabled, don't reenable
1325 }
1326
1327 delete m_winDisabled;
1328 }
1329
1330 // Yield to other apps/messages and disable user input to all windows except
1331 // the given one
1332 bool wxSafeYield(wxWindow *win, bool onlyIfNeeded)
1333 {
1334 wxWindowDisabler wd(win);
1335
1336 bool rc;
1337 if (onlyIfNeeded)
1338 rc = wxYieldIfNeeded();
1339 else
1340 rc = wxYield();
1341
1342 return rc;
1343 }
1344
1345 // Don't synthesize KeyUp events holding down a key and producing KeyDown
1346 // events with autorepeat. On by default and always on in wxMSW. wxGTK version
1347 // in utilsgtk.cpp.
1348 #ifndef __WXGTK__
1349 bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
1350 {
1351 return true; // detectable auto-repeat is the only mode MSW supports
1352 }
1353 #endif // !wxGTK
1354
1355 #endif // wxUSE_GUI