]> git.saurik.com Git - wxWidgets.git/blob - src/common/utilscmn.cpp
don't use deprecated wxSTRING_MAXLEN
[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 #if wxUSE_MIMETYPE
877 wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(_T("html"));
878 if ( ft )
879 {
880 wxString mt;
881 ft->GetMimeType(&mt);
882
883 ok = ft->GetOpenCommand(&cmd, wxFileType::MessageParameters(url));
884 delete ft;
885 }
886 #endif // wxUSE_MIMETYPE
887
888 if ( !ok || cmd.empty() )
889 {
890 // fallback to checking for the BROWSER environment variable
891 cmd = wxGetenv(wxT("BROWSER"));
892 if ( !cmd.empty() )
893 cmd << _T(' ') << url;
894 }
895
896 ok = ( !cmd.empty() && wxExecute(cmd) );
897 if (ok)
898 return ok;
899
900 // no file type for HTML extension
901 wxLogError(_T("No default application configured for HTML files."));
902
903 #endif // !wxUSE_MIMETYPE && !__WXMSW__
904
905 wxLogSysError(_T("Failed to open URL \"%s\" in default browser."),
906 url.c_str());
907
908 return false;
909 }
910
911 // ----------------------------------------------------------------------------
912 // wxApp::Yield() wrappers for backwards compatibility
913 // ----------------------------------------------------------------------------
914
915 bool wxYield()
916 {
917 return wxTheApp && wxTheApp->Yield();
918 }
919
920 bool wxYieldIfNeeded()
921 {
922 return wxTheApp && wxTheApp->Yield(true);
923 }
924
925 #endif // wxUSE_BASE
926
927 // ============================================================================
928 // GUI-only functions from now on
929 // ============================================================================
930
931 #if wxUSE_GUI
932
933 // Id generation
934 static long wxCurrentId = 100;
935
936 long wxNewId()
937 {
938 // skip the part of IDs space that contains hard-coded values:
939 if (wxCurrentId == wxID_LOWEST)
940 wxCurrentId = wxID_HIGHEST + 1;
941
942 return wxCurrentId++;
943 }
944
945 long
946 wxGetCurrentId(void) { return wxCurrentId; }
947
948 void
949 wxRegisterId (long id)
950 {
951 if (id >= wxCurrentId)
952 wxCurrentId = id + 1;
953 }
954
955 // ----------------------------------------------------------------------------
956 // Menu accelerators related functions
957 // ----------------------------------------------------------------------------
958
959 wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
960 {
961 #if wxUSE_MENUS
962 wxString s = wxMenuItem::GetLabelFromText(in);
963 #else
964 wxString str(in);
965 wxString s = wxStripMenuCodes(str);
966 #endif // wxUSE_MENUS
967 if ( out )
968 {
969 // go smash their buffer if it's not big enough - I love char * params
970 memcpy(out, s.c_str(), s.length() * sizeof(wxChar));
971 }
972 else
973 {
974 // MYcopystring - for easier search...
975 out = new wxChar[s.length() + 1];
976 wxStrcpy(out, s.c_str());
977 }
978
979 return out;
980 }
981
982 wxString wxStripMenuCodes(const wxString& in, int flags)
983 {
984 wxASSERT_MSG( flags, _T("this is useless to call without any flags") );
985
986 wxString out;
987
988 size_t len = in.length();
989 out.reserve(len);
990
991 for ( size_t n = 0; n < len; n++ )
992 {
993 wxChar ch = in[n];
994 if ( (flags & wxStrip_Mnemonics) && ch == _T('&') )
995 {
996 // skip it, it is used to introduce the accel char (or to quote
997 // itself in which case it should still be skipped): note that it
998 // can't be the last character of the string
999 if ( ++n == len )
1000 {
1001 wxLogDebug(_T("Invalid menu string '%s'"), in.c_str());
1002 }
1003 else
1004 {
1005 // use the next char instead
1006 ch = in[n];
1007 }
1008 }
1009 else if ( (flags & wxStrip_Accel) && ch == _T('\t') )
1010 {
1011 // everything after TAB is accel string, exit the loop
1012 break;
1013 }
1014
1015 out += ch;
1016 }
1017
1018 return out;
1019 }
1020
1021 // ----------------------------------------------------------------------------
1022 // Window search functions
1023 // ----------------------------------------------------------------------------
1024
1025 /*
1026 * If parent is non-NULL, look through children for a label or title
1027 * matching the specified string. If NULL, look through all top-level windows.
1028 *
1029 */
1030
1031 wxWindow *
1032 wxFindWindowByLabel (const wxString& title, wxWindow * parent)
1033 {
1034 return wxWindow::FindWindowByLabel( title, parent );
1035 }
1036
1037
1038 /*
1039 * If parent is non-NULL, look through children for a name
1040 * matching the specified string. If NULL, look through all top-level windows.
1041 *
1042 */
1043
1044 wxWindow *
1045 wxFindWindowByName (const wxString& name, wxWindow * parent)
1046 {
1047 return wxWindow::FindWindowByName( name, parent );
1048 }
1049
1050 // Returns menu item id or wxNOT_FOUND if none.
1051 int
1052 wxFindMenuItemId (wxFrame * frame, const wxString& menuString, const wxString& itemString)
1053 {
1054 #if wxUSE_MENUS
1055 wxMenuBar *menuBar = frame->GetMenuBar ();
1056 if ( menuBar )
1057 return menuBar->FindMenuItem (menuString, itemString);
1058 #endif // wxUSE_MENUS
1059
1060 return wxNOT_FOUND;
1061 }
1062
1063 // Try to find the deepest child that contains 'pt'.
1064 // We go backwards, to try to allow for controls that are spacially
1065 // within other controls, but are still siblings (e.g. buttons within
1066 // static boxes). Static boxes are likely to be created _before_ controls
1067 // that sit inside them.
1068 wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt)
1069 {
1070 if (!win->IsShown())
1071 return NULL;
1072
1073 // Hack for wxNotebook case: at least in wxGTK, all pages
1074 // claim to be shown, so we must only deal with the selected one.
1075 #if wxUSE_NOTEBOOK
1076 if (win->IsKindOf(CLASSINFO(wxNotebook)))
1077 {
1078 wxNotebook* nb = (wxNotebook*) win;
1079 int sel = nb->GetSelection();
1080 if (sel >= 0)
1081 {
1082 wxWindow* child = nb->GetPage(sel);
1083 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1084 if (foundWin)
1085 return foundWin;
1086 }
1087 }
1088 #endif
1089
1090 wxWindowList::compatibility_iterator node = win->GetChildren().GetLast();
1091 while (node)
1092 {
1093 wxWindow* child = node->GetData();
1094 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1095 if (foundWin)
1096 return foundWin;
1097 node = node->GetPrevious();
1098 }
1099
1100 wxPoint pos = win->GetPosition();
1101 wxSize sz = win->GetSize();
1102 if ( !win->IsTopLevel() && win->GetParent() )
1103 {
1104 pos = win->GetParent()->ClientToScreen(pos);
1105 }
1106
1107 wxRect rect(pos, sz);
1108 if (rect.Contains(pt))
1109 return win;
1110
1111 return NULL;
1112 }
1113
1114 wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt)
1115 {
1116 // Go backwards through the list since windows
1117 // on top are likely to have been appended most
1118 // recently.
1119 wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast();
1120 while (node)
1121 {
1122 wxWindow* win = node->GetData();
1123 wxWindow* found = wxFindWindowAtPoint(win, pt);
1124 if (found)
1125 return found;
1126 node = node->GetPrevious();
1127 }
1128 return NULL;
1129 }
1130
1131 // ----------------------------------------------------------------------------
1132 // GUI helpers
1133 // ----------------------------------------------------------------------------
1134
1135 /*
1136 * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
1137 * since otherwise the generic code may be pulled in unnecessarily.
1138 */
1139
1140 #if wxUSE_MSGDLG
1141
1142 int wxMessageBox(const wxString& message, const wxString& caption, long style,
1143 wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
1144 {
1145 long decorated_style = style;
1146
1147 if ( ( style & ( wxICON_EXCLAMATION | wxICON_HAND | wxICON_INFORMATION | wxICON_QUESTION ) ) == 0 )
1148 {
1149 decorated_style |= ( style & wxYES ) ? wxICON_QUESTION : wxICON_INFORMATION ;
1150 }
1151
1152 wxMessageDialog dialog(parent, message, caption, decorated_style);
1153
1154 int ans = dialog.ShowModal();
1155 switch ( ans )
1156 {
1157 case wxID_OK:
1158 return wxOK;
1159 case wxID_YES:
1160 return wxYES;
1161 case wxID_NO:
1162 return wxNO;
1163 case wxID_CANCEL:
1164 return wxCANCEL;
1165 }
1166
1167 wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") );
1168
1169 return wxCANCEL;
1170 }
1171
1172 #endif // wxUSE_MSGDLG
1173
1174 #if wxUSE_TEXTDLG
1175
1176 wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
1177 const wxString& defaultValue, wxWindow *parent,
1178 wxCoord x, wxCoord y, bool centre )
1179 {
1180 wxString str;
1181 long style = wxTextEntryDialogStyle;
1182
1183 if (centre)
1184 style |= wxCENTRE;
1185 else
1186 style &= ~wxCENTRE;
1187
1188 wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y));
1189
1190 if (dialog.ShowModal() == wxID_OK)
1191 {
1192 str = dialog.GetValue();
1193 }
1194
1195 return str;
1196 }
1197
1198 wxString wxGetPasswordFromUser(const wxString& message,
1199 const wxString& caption,
1200 const wxString& defaultValue,
1201 wxWindow *parent,
1202 wxCoord x, wxCoord y, bool centre )
1203 {
1204 wxString str;
1205 long style = wxTextEntryDialogStyle;
1206
1207 if (centre)
1208 style |= wxCENTRE;
1209 else
1210 style &= ~wxCENTRE;
1211
1212 wxPasswordEntryDialog dialog(parent, message, caption, defaultValue,
1213 style, wxPoint(x, y));
1214 if ( dialog.ShowModal() == wxID_OK )
1215 {
1216 str = dialog.GetValue();
1217 }
1218
1219 return str;
1220 }
1221
1222 #endif // wxUSE_TEXTDLG
1223
1224 #if wxUSE_COLOURDLG
1225
1226 wxColour wxGetColourFromUser(wxWindow *parent, const wxColour& colInit, const wxString& caption)
1227 {
1228 wxColourData data;
1229 data.SetChooseFull(true);
1230 if ( colInit.Ok() )
1231 {
1232 data.SetColour((wxColour &)colInit); // const_cast
1233 }
1234
1235 wxColour colRet;
1236 wxColourDialog dialog(parent, &data);
1237 if (!caption.empty())
1238 dialog.SetTitle(caption);
1239 if ( dialog.ShowModal() == wxID_OK )
1240 {
1241 colRet = dialog.GetColourData().GetColour();
1242 }
1243 //else: leave it invalid
1244
1245 return colRet;
1246 }
1247
1248 #endif // wxUSE_COLOURDLG
1249
1250 #if wxUSE_FONTDLG
1251
1252 wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit, const wxString& caption)
1253 {
1254 wxFontData data;
1255 if ( fontInit.Ok() )
1256 {
1257 data.SetInitialFont(fontInit);
1258 }
1259
1260 wxFont fontRet;
1261 wxFontDialog dialog(parent, data);
1262 if (!caption.empty())
1263 dialog.SetTitle(caption);
1264 if ( dialog.ShowModal() == wxID_OK )
1265 {
1266 fontRet = dialog.GetFontData().GetChosenFont();
1267 }
1268 //else: leave it invalid
1269
1270 return fontRet;
1271 }
1272
1273 #endif // wxUSE_FONTDLG
1274
1275 // ----------------------------------------------------------------------------
1276 // wxSafeYield and supporting functions
1277 // ----------------------------------------------------------------------------
1278
1279 void wxEnableTopLevelWindows(bool enable)
1280 {
1281 wxWindowList::compatibility_iterator node;
1282 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1283 node->GetData()->Enable(enable);
1284 }
1285
1286 wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
1287 {
1288 // remember the top level windows which were already disabled, so that we
1289 // don't reenable them later
1290 m_winDisabled = NULL;
1291
1292 wxWindowList::compatibility_iterator node;
1293 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1294 {
1295 wxWindow *winTop = node->GetData();
1296 if ( winTop == winToSkip )
1297 continue;
1298
1299 // we don't need to disable the hidden or already disabled windows
1300 if ( winTop->IsEnabled() && winTop->IsShown() )
1301 {
1302 winTop->Disable();
1303 }
1304 else
1305 {
1306 if ( !m_winDisabled )
1307 {
1308 m_winDisabled = new wxWindowList;
1309 }
1310
1311 m_winDisabled->Append(winTop);
1312 }
1313 }
1314 }
1315
1316 wxWindowDisabler::~wxWindowDisabler()
1317 {
1318 wxWindowList::compatibility_iterator node;
1319 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1320 {
1321 wxWindow *winTop = node->GetData();
1322 if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
1323 {
1324 winTop->Enable();
1325 }
1326 //else: had been already disabled, don't reenable
1327 }
1328
1329 delete m_winDisabled;
1330 }
1331
1332 // Yield to other apps/messages and disable user input to all windows except
1333 // the given one
1334 bool wxSafeYield(wxWindow *win, bool onlyIfNeeded)
1335 {
1336 wxWindowDisabler wd(win);
1337
1338 bool rc;
1339 if (onlyIfNeeded)
1340 rc = wxYieldIfNeeded();
1341 else
1342 rc = wxYield();
1343
1344 return rc;
1345 }
1346
1347 // Don't synthesize KeyUp events holding down a key and producing KeyDown
1348 // events with autorepeat. On by default and always on in wxMSW. wxGTK version
1349 // in utilsgtk.cpp.
1350 #ifndef __WXGTK__
1351 bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
1352 {
1353 return true; // detectable auto-repeat is the only mode MSW supports
1354 }
1355 #endif // !wxGTK
1356
1357 #endif // wxUSE_GUI