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