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