1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/utilscmn.cpp
3 // Purpose: Miscellaneous utility functions and classes
4 // Author: Julian Smart
8 // Copyright: (c) 1998 Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
29 #include "wx/string.h"
35 #include "wx/window.h"
38 #include "wx/msgdlg.h"
39 #include "wx/textdlg.h"
40 #include "wx/textctrl.h" // for wxTE_PASSWORD
42 #include "wx/menuitem.h"
48 #include "wx/apptrait.h"
50 #include "wx/process.h"
51 #include "wx/txtstrm.h"
53 #include "wx/mimetype.h"
54 #include "wx/config.h"
56 #if defined(__WXWINCE__) && wxUSE_DATETIME
57 #include "wx/datetime.h"
65 #if !wxONLY_WATCOM_EARLIER_THAN(1,4)
66 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
72 #include "wx/colordlg.h"
73 #include "wx/fontdlg.h"
74 #include "wx/notebook.h"
75 #include "wx/statusbr.h"
82 #include "wx/msw/wince/time.h"
84 #endif // ! __WXPALMOS5__
87 #include "wx/osx/private.h"
91 #if !defined(__MWERKS__) && !defined(__WXWINCE__)
92 #include <sys/types.h>
95 #endif // ! __WXPALMOS5__
97 #if defined(__WXMSW__)
98 #include "wx/msw/private.h"
99 #include "wx/filesys.h"
102 #if wxUSE_GUI && defined(__WXGTK__)
103 #include <gtk/gtk.h> // for GTK_XXX_VERSION constants
108 // ============================================================================
110 // ============================================================================
112 // Array used in DecToHex conversion routine.
113 static wxChar hexArray
[] = wxT("0123456789ABCDEF");
115 // Convert 2-digit hex number to decimal
116 int wxHexToDec(const wxString
& buf
)
118 int firstDigit
, secondDigit
;
120 if (buf
.GetChar(0) >= wxT('A'))
121 firstDigit
= buf
.GetChar(0) - wxT('A') + 10;
123 firstDigit
= buf
.GetChar(0) - wxT('0');
125 if (buf
.GetChar(1) >= wxT('A'))
126 secondDigit
= buf
.GetChar(1) - wxT('A') + 10;
128 secondDigit
= buf
.GetChar(1) - wxT('0');
130 return (firstDigit
& 0xF) * 16 + (secondDigit
& 0xF );
133 // Convert decimal integer to 2-character hex string
134 void wxDecToHex(int dec
, wxChar
*buf
)
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
];
143 // Convert decimal integer to 2 characters
144 void wxDecToHex(int dec
, char* ch1
, char* ch2
)
146 int firstDigit
= (int)(dec
/16.0);
147 int secondDigit
= (int)(dec
- (firstDigit
*16.0));
148 (*ch1
) = (char) hexArray
[firstDigit
];
149 (*ch2
) = (char) hexArray
[secondDigit
];
152 // Convert decimal integer to 2-character hex string
153 wxString
wxDecToHex(int dec
)
156 wxDecToHex(dec
, buf
);
157 return wxString(buf
);
160 // ----------------------------------------------------------------------------
162 // ----------------------------------------------------------------------------
164 // Don't synthesize KeyUp events holding down a key and producing KeyDown
165 // events with autorepeat. On by default and always on in wxMSW. wxGTK version
168 bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag
) )
170 return true; // detectable auto-repeat is the only mode MSW supports
174 // Return the current date/time
179 wxDateTime now
= wxDateTime::Now();
182 return wxEmptyString
;
185 time_t now
= time((time_t *) NULL
);
186 char *date
= ctime(&now
);
188 return wxString::FromAscii(date
);
192 #if WXWIN_COMPATIBILITY_2_8
193 void wxUsleep(unsigned long milliseconds
)
195 wxMilliSleep(milliseconds
);
199 const wxChar
*wxGetInstallPrefix()
203 if ( wxGetEnv(wxT("WXPREFIX"), &prefix
) )
204 return prefix
.c_str();
206 #ifdef wxINSTALL_PREFIX
207 return wxT(wxINSTALL_PREFIX
);
209 return wxEmptyString
;
213 wxString
wxGetDataDir()
215 wxString dir
= wxGetInstallPrefix();
216 dir
<< wxFILE_SEP_PATH
<< wxT("share") << wxFILE_SEP_PATH
<< wxT("wx");
220 bool wxIsPlatformLittleEndian()
222 // Are we little or big endian? This method is from Harbison & Steele.
226 char c
[sizeof(long)];
234 // ----------------------------------------------------------------------------
236 // ----------------------------------------------------------------------------
239 * Class to make it easier to specify platform-dependent values
242 wxArrayInt
* wxPlatform::sm_customPlatforms
= NULL
;
244 void wxPlatform::Copy(const wxPlatform
& platform
)
246 m_longValue
= platform
.m_longValue
;
247 m_doubleValue
= platform
.m_doubleValue
;
248 m_stringValue
= platform
.m_stringValue
;
251 wxPlatform
wxPlatform::If(int platform
, long value
)
254 return wxPlatform(value
);
259 wxPlatform
wxPlatform::IfNot(int platform
, long value
)
262 return wxPlatform(value
);
267 wxPlatform
& wxPlatform::ElseIf(int platform
, long value
)
274 wxPlatform
& wxPlatform::ElseIfNot(int platform
, long value
)
281 wxPlatform
wxPlatform::If(int platform
, double value
)
284 return wxPlatform(value
);
289 wxPlatform
wxPlatform::IfNot(int platform
, double value
)
292 return wxPlatform(value
);
297 wxPlatform
& wxPlatform::ElseIf(int platform
, double value
)
300 m_doubleValue
= value
;
304 wxPlatform
& wxPlatform::ElseIfNot(int platform
, double value
)
307 m_doubleValue
= value
;
311 wxPlatform
wxPlatform::If(int platform
, const wxString
& value
)
314 return wxPlatform(value
);
319 wxPlatform
wxPlatform::IfNot(int platform
, const wxString
& value
)
322 return wxPlatform(value
);
327 wxPlatform
& wxPlatform::ElseIf(int platform
, const wxString
& value
)
330 m_stringValue
= value
;
334 wxPlatform
& wxPlatform::ElseIfNot(int platform
, const wxString
& value
)
337 m_stringValue
= value
;
341 wxPlatform
& wxPlatform::Else(long value
)
347 wxPlatform
& wxPlatform::Else(double value
)
349 m_doubleValue
= value
;
353 wxPlatform
& wxPlatform::Else(const wxString
& value
)
355 m_stringValue
= value
;
359 void wxPlatform::AddPlatform(int platform
)
361 if (!sm_customPlatforms
)
362 sm_customPlatforms
= new wxArrayInt
;
363 sm_customPlatforms
->Add(platform
);
366 void wxPlatform::ClearPlatforms()
368 delete sm_customPlatforms
;
369 sm_customPlatforms
= NULL
;
372 /// Function for testing current platform
374 bool wxPlatform::Is(int platform
)
377 if (platform
== wxOS_WINDOWS
)
381 if (platform
== wxOS_WINDOWS_CE
)
387 // FIXME: wxWinPocketPC and wxWinSmartPhone are unknown symbols
389 #if defined(__WXWINCE__) && defined(__POCKETPC__)
390 if (platform
== wxWinPocketPC
)
393 #if defined(__WXWINCE__) && defined(__SMARTPHONE__)
394 if (platform
== wxWinSmartPhone
)
401 if (platform
== wxPORT_GTK
)
405 if (platform
== wxPORT_MAC
)
409 if (platform
== wxPORT_X11
)
413 if (platform
== wxOS_UNIX
)
417 if (platform
== wxPORT_MGL
)
421 if (platform
== wxOS_OS2
)
425 if (platform
== wxPORT_PM
)
429 if (platform
== wxPORT_MAC
)
433 if (sm_customPlatforms
&& sm_customPlatforms
->Index(platform
) != wxNOT_FOUND
)
439 // ----------------------------------------------------------------------------
440 // network and user id functions
441 // ----------------------------------------------------------------------------
443 // Get Full RFC822 style email address
444 bool wxGetEmailAddress(wxChar
*address
, int maxSize
)
446 wxString email
= wxGetEmailAddress();
450 wxStrlcpy(address
, email
.t_str(), maxSize
);
455 wxString
wxGetEmailAddress()
459 wxString host
= wxGetFullHostName();
462 wxString user
= wxGetUserId();
465 email
<< user
<< wxT('@') << host
;
472 wxString
wxGetUserId()
474 static const int maxLoginLen
= 256; // FIXME arbitrary number
477 bool ok
= wxGetUserId(wxStringBuffer(buf
, maxLoginLen
), maxLoginLen
);
485 wxString
wxGetUserName()
487 static const int maxUserNameLen
= 1024; // FIXME arbitrary number
490 bool ok
= wxGetUserName(wxStringBuffer(buf
, maxUserNameLen
), maxUserNameLen
);
498 wxString
wxGetHostName()
500 static const size_t hostnameSize
= 257;
503 bool ok
= wxGetHostName(wxStringBuffer(buf
, hostnameSize
), hostnameSize
);
511 wxString
wxGetFullHostName()
513 static const size_t hostnameSize
= 257;
516 bool ok
= wxGetFullHostName(wxStringBuffer(buf
, hostnameSize
), hostnameSize
);
524 wxString
wxGetHomeDir()
534 wxString
wxGetCurrentDir()
541 ok
= getcwd(dir
.GetWriteBuf(len
+ 1), len
) != NULL
;
546 if ( errno
!= ERANGE
)
548 wxLogSysError(_T("Failed to get current directory"));
550 return wxEmptyString
;
554 // buffer was too small, retry with a larger one
566 // ----------------------------------------------------------------------------
568 // ----------------------------------------------------------------------------
570 // wxDoExecuteWithCapture() helper: reads an entire stream into one array
572 // returns true if ok, false if error
574 static bool ReadAll(wxInputStream
*is
, wxArrayString
& output
)
576 wxCHECK_MSG( is
, false, _T("NULL stream in wxExecute()?") );
578 // the stream could be already at EOF or in wxSTREAM_BROKEN_PIPE state
581 wxTextInputStream
tis(*is
);
585 wxString line
= tis
.ReadLine();
587 // check for EOF before other errors as it's not really an error
590 // add the last, possibly incomplete, line
596 // any other error is fatal
605 #endif // wxUSE_STREAMS
607 // this is a private function because it hasn't a clean interface: the first
608 // array is passed by reference, the second by pointer - instead we have 2
609 // public versions of wxExecute() below
610 static long wxDoExecuteWithCapture(const wxString
& command
,
611 wxArrayString
& output
,
612 wxArrayString
* error
,
615 // create a wxProcess which will capture the output
616 wxProcess
*process
= new wxProcess
;
619 long rc
= wxExecute(command
, wxEXEC_SYNC
| flags
, process
);
624 if ( !ReadAll(process
->GetInputStream(), output
) )
629 if ( !ReadAll(process
->GetErrorStream(), *error
) )
637 #endif // wxUSE_STREAMS/!wxUSE_STREAMS
644 long wxExecute(const wxString
& command
, wxArrayString
& output
, int flags
)
646 return wxDoExecuteWithCapture(command
, output
, NULL
, flags
);
649 long wxExecute(const wxString
& command
,
650 wxArrayString
& output
,
651 wxArrayString
& error
,
654 return wxDoExecuteWithCapture(command
, output
, &error
, flags
);
657 // ----------------------------------------------------------------------------
659 // ----------------------------------------------------------------------------
662 static long wxCurrentId
= 100;
666 // skip the part of IDs space that contains hard-coded values:
667 if (wxCurrentId
== wxID_LOWEST
)
668 wxCurrentId
= wxID_HIGHEST
+ 1;
670 return wxCurrentId
++;
674 wxGetCurrentId(void) { return wxCurrentId
; }
677 wxRegisterId (long id
)
679 if (id
>= wxCurrentId
)
680 wxCurrentId
= id
+ 1;
683 // ----------------------------------------------------------------------------
684 // wxQsort, adapted by RR to allow user_data
685 // ----------------------------------------------------------------------------
687 /* This file is part of the GNU C Library.
688 Written by Douglas C. Schmidt (schmidt@ics.uci.edu).
690 Douglas Schmidt kindly gave permission to relicence the
691 code under the wxWindows licence:
693 From: "Douglas C. Schmidt" <schmidt@dre.vanderbilt.edu>
694 To: Robert Roebling <robert.roebling@uni-ulm.de>
695 Subject: Re: qsort licence
696 Date: Mon, 23 Jul 2007 03:44:25 -0500
697 Sender: schmidt@dre.vanderbilt.edu
698 Message-Id: <20070723084426.64F511000A8@tango.dre.vanderbilt.edu>
702 > [...] I'm asking if you'd be willing to relicence your code
703 > under the wxWindows licence. [...]
705 That's fine with me [...]
712 /* Byte-wise swap two items of size SIZE. */
713 #define SWAP(a, b, size) \
716 register size_t __size = (size); \
717 register char *__a = (a), *__b = (b); \
723 } while (--__size > 0); \
726 /* Discontinue quicksort algorithm when partition gets below this size.
727 This particular magic number was chosen to work best on a Sun 4/260. */
730 /* Stack node declarations used to store unfulfilled partition obligations. */
737 /* The next 4 #defines implement a very fast in-line stack abstraction. */
738 #define STACK_SIZE (8 * sizeof(unsigned long int))
739 #define PUSH(low, high) ((void) ((top->lo = (low)), (top->hi = (high)), ++top))
740 #define POP(low, high) ((void) (--top, (low = top->lo), (high = top->hi)))
741 #define STACK_NOT_EMPTY (stack < top)
744 /* Order size using quicksort. This implementation incorporates
745 four optimizations discussed in Sedgewick:
747 1. Non-recursive, using an explicit stack of pointer that store the
748 next array partition to sort. To save time, this maximum amount
749 of space required to store an array of MAX_INT is allocated on the
750 stack. Assuming a 32-bit integer, this needs only 32 *
751 sizeof(stack_node) == 136 bits. Pretty cheap, actually.
753 2. Chose the pivot element using a median-of-three decision tree.
754 This reduces the probability of selecting a bad pivot value and
755 eliminates certain extraneous comparisons.
757 3. Only quicksorts TOTAL_ELEMS / MAX_THRESH partitions, leaving
758 insertion sort to order the MAX_THRESH items within each partition.
759 This is a big win, since insertion sort is faster for small, mostly
760 sorted array segments.
762 4. The larger of the two sub-partitions is always pushed onto the
763 stack first, with the algorithm then concentrating on the
764 smaller partition. This *guarantees* no more than log (n)
765 stack size is needed (actually O(1) in this case)! */
767 void wxQsort(void *const pbase
, size_t total_elems
,
768 size_t size
, CMPFUNCDATA cmp
, const void* user_data
)
770 register char *base_ptr
= (char *) pbase
;
771 const size_t max_thresh
= MAX_THRESH
* size
;
773 if (total_elems
== 0)
774 /* Avoid lossage with unsigned arithmetic below. */
777 if (total_elems
> MAX_THRESH
)
780 char *hi
= &lo
[size
* (total_elems
- 1)];
781 stack_node stack
[STACK_SIZE
];
782 stack_node
*top
= stack
;
786 while (STACK_NOT_EMPTY
)
791 /* Select median value from among LO, MID, and HI. Rearrange
792 LO and HI so the three values are sorted. This lowers the
793 probability of picking a pathological pivot value and
794 skips a comparison for both the LEFT_PTR and RIGHT_PTR. */
796 char *mid
= lo
+ size
* ((hi
- lo
) / size
>> 1);
798 if ((*cmp
) ((void *) mid
, (void *) lo
, user_data
) < 0)
799 SWAP (mid
, lo
, size
);
800 if ((*cmp
) ((void *) hi
, (void *) mid
, user_data
) < 0)
801 SWAP (mid
, hi
, size
);
804 if ((*cmp
) ((void *) mid
, (void *) lo
, user_data
) < 0)
805 SWAP (mid
, lo
, size
);
807 left_ptr
= lo
+ size
;
808 right_ptr
= hi
- size
;
810 /* Here's the famous ``collapse the walls'' section of quicksort.
811 Gotta like those tight inner loops! They are the main reason
812 that this algorithm runs much faster than others. */
815 while ((*cmp
) ((void *) left_ptr
, (void *) mid
, user_data
) < 0)
818 while ((*cmp
) ((void *) mid
, (void *) right_ptr
, user_data
) < 0)
821 if (left_ptr
< right_ptr
)
823 SWAP (left_ptr
, right_ptr
, size
);
826 else if (mid
== right_ptr
)
831 else if (left_ptr
== right_ptr
)
838 while (left_ptr
<= right_ptr
);
840 /* Set up pointers for next iteration. First determine whether
841 left and right partitions are below the threshold size. If so,
842 ignore one or both. Otherwise, push the larger partition's
843 bounds on the stack and continue sorting the smaller one. */
845 if ((size_t) (right_ptr
- lo
) <= max_thresh
)
847 if ((size_t) (hi
- left_ptr
) <= max_thresh
)
848 /* Ignore both small partitions. */
851 /* Ignore small left partition. */
854 else if ((size_t) (hi
- left_ptr
) <= max_thresh
)
855 /* Ignore small right partition. */
857 else if ((right_ptr
- lo
) > (hi
- left_ptr
))
859 /* Push larger left partition indices. */
860 PUSH (lo
, right_ptr
);
865 /* Push larger right partition indices. */
872 /* Once the BASE_PTR array is partially sorted by quicksort the rest
873 is completely sorted using insertion sort, since this is efficient
874 for partitions below MAX_THRESH size. BASE_PTR points to the beginning
875 of the array to sort, and END_PTR points at the very last element in
876 the array (*not* one beyond it!). */
879 char *const end_ptr
= &base_ptr
[size
* (total_elems
- 1)];
880 char *tmp_ptr
= base_ptr
;
881 char *thresh
= base_ptr
+ max_thresh
;
882 if ( thresh
> end_ptr
)
884 register char *run_ptr
;
886 /* Find smallest element in first threshold and place it at the
887 array's beginning. This is the smallest array element,
888 and the operation speeds up insertion sort's inner loop. */
890 for (run_ptr
= tmp_ptr
+ size
; run_ptr
<= thresh
; run_ptr
+= size
)
891 if ((*cmp
) ((void *) run_ptr
, (void *) tmp_ptr
, user_data
) < 0)
894 if (tmp_ptr
!= base_ptr
)
895 SWAP (tmp_ptr
, base_ptr
, size
);
897 /* Insertion sort, running from left-hand-side up to right-hand-side. */
899 run_ptr
= base_ptr
+ size
;
900 while ((run_ptr
+= size
) <= end_ptr
)
902 tmp_ptr
= run_ptr
- size
;
903 while ((*cmp
) ((void *) run_ptr
, (void *) tmp_ptr
, user_data
) < 0)
907 if (tmp_ptr
!= run_ptr
)
911 trav
= run_ptr
+ size
;
912 while (--trav
>= run_ptr
)
917 for (hi
= lo
= trav
; (lo
-= size
) >= tmp_ptr
; hi
= lo
)
930 // ============================================================================
931 // GUI-only functions from now on
932 // ============================================================================
936 // ----------------------------------------------------------------------------
937 // Launch default browser
938 // ----------------------------------------------------------------------------
940 #if defined(__WXMSW__)
942 // implemented in a port-specific utils source file:
943 bool wxDoLaunchDefaultBrowser(const wxString
& url
, const wxString
& scheme
, int flags
);
945 #elif defined(__WXX11__) || defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXCOCOA__) || \
946 (defined(__WXMAC__) && !defined(__WXOSX_IPHONE__))
948 // implemented in a port-specific utils source file:
949 bool wxDoLaunchDefaultBrowser(const wxString
& url
, int flags
);
953 // a "generic" implementation:
954 bool wxDoLaunchDefaultBrowser(const wxString
& url
, int flags
)
956 // on other platforms try to use mime types or wxExecute...
962 wxFileType
*ft
= wxTheMimeTypesManager
->GetFileTypeFromExtension(_T("html"));
966 ft
->GetMimeType(&mt
);
968 ok
= ft
->GetOpenCommand(&cmd
, wxFileType::MessageParameters(url
));
971 #endif // wxUSE_MIMETYPE
973 if ( !ok
|| cmd
.empty() )
975 // fallback to checking for the BROWSER environment variable
976 if ( !wxGetEnv(wxT("BROWSER"), &cmd
) || cmd
.empty() )
977 cmd
<< _T(' ') << url
;
980 ok
= ( !cmd
.empty() && wxExecute(cmd
) );
984 // no file type for HTML extension
985 wxLogError(_("No default application configured for HTML files."));
991 static bool DoLaunchDefaultBrowserHelper(const wxString
& urlOrig
, int flags
)
993 // NOTE: we don't have to care about the wxBROWSER_NOBUSYCURSOR flag
994 // as it was already handled by wxLaunchDefaultBrowser
998 wxString
url(urlOrig
), scheme
;
1001 // this check is useful to avoid that wxURI recognizes as scheme parts of
1002 // the filename, in case urlOrig is a local filename
1003 // (e.g. "C:\\test.txt" when parsed by wxURI reports a scheme == "C")
1004 bool hasValidScheme
= uri
.HasScheme() &&
1005 (uri
.GetScheme() == "http" || uri
.GetScheme() == "file");
1007 #if defined(__WXMSW__)
1009 // NOTE: when testing wxMSW's wxLaunchDefaultBrowser all possible forms
1010 // of the URL/flags should be tested; e.g.:
1012 // for (int i=0; i<2; i++)
1014 // wxLaunchDefaultBrowser("C:\\test.txt", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1015 // wxLaunchDefaultBrowser("wxwidgets.org", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1016 // wxLaunchDefaultBrowser("file:/C%3A/test.txt", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1017 // wxLaunchDefaultBrowser("http://wxwidgets.org", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1019 // (assuming you have a C:\test.txt file)
1021 if ( !hasValidScheme
)
1023 if (wxFileExists(urlOrig
) || wxDirExists(urlOrig
))
1026 // do not prepend the file scheme to the URL as ShellExecuteEx() doesn't like it
1030 url
.Prepend(wxS("http://"));
1034 else if ( hasValidScheme
)
1036 scheme
= uri
.GetScheme();
1038 if ( uri
.GetScheme() == "file" )
1040 // ShellExecuteEx() doesn't like the "file" scheme when opening local files;
1042 url
= wxFileSystem::URLToFileName(url
).GetFullPath();
1046 if (wxDoLaunchDefaultBrowser(url
, scheme
, flags
))
1048 //else: call wxLogSysError
1050 if ( !hasValidScheme
)
1052 // set the scheme of url to "http" or "file" if it does not have one
1053 if (wxFileExists(urlOrig
) || wxDirExists(urlOrig
))
1054 url
.Prepend(wxS("file://"));
1056 url
.Prepend(wxS("http://"));
1059 if (wxDoLaunchDefaultBrowser(url
, flags
))
1061 //else: call wxLogSysError
1064 wxLogSysError(_("Failed to open URL \"%s\" in default browser."),
1070 bool wxLaunchDefaultBrowser(const wxString
& url
, int flags
)
1072 // NOTE: as documented, "url" may be both a real well-formed URL
1073 // and a local file name
1075 if ( flags
& wxBROWSER_NOBUSYCURSOR
)
1076 return DoLaunchDefaultBrowserHelper(url
, flags
);
1079 return DoLaunchDefaultBrowserHelper(url
, flags
);
1082 // ----------------------------------------------------------------------------
1083 // Menu accelerators related functions
1084 // ----------------------------------------------------------------------------
1086 #if WXWIN_COMPATIBILITY_2_6
1087 wxChar
*wxStripMenuCodes(const wxChar
*in
, wxChar
*out
)
1090 wxString s
= wxMenuItem::GetLabelText(in
);
1093 wxString s
= wxStripMenuCodes(str
);
1094 #endif // wxUSE_MENUS
1097 // go smash their buffer if it's not big enough - I love char * params
1098 memcpy(out
, s
.c_str(), s
.length() * sizeof(wxChar
));
1102 out
= new wxChar
[s
.length() + 1];
1103 wxStrcpy(out
, s
.c_str());
1110 wxString
wxStripMenuCodes(const wxString
& in
, int flags
)
1112 wxASSERT_MSG( flags
, _T("this is useless to call without any flags") );
1116 size_t len
= in
.length();
1119 for ( size_t n
= 0; n
< len
; n
++ )
1122 if ( (flags
& wxStrip_Mnemonics
) && ch
== _T('&') )
1124 // skip it, it is used to introduce the accel char (or to quote
1125 // itself in which case it should still be skipped): note that it
1126 // can't be the last character of the string
1129 wxLogDebug(_T("Invalid menu string '%s'"), in
.c_str());
1133 // use the next char instead
1137 else if ( (flags
& wxStrip_Accel
) && ch
== _T('\t') )
1139 // everything after TAB is accel string, exit the loop
1149 // ----------------------------------------------------------------------------
1150 // Window search functions
1151 // ----------------------------------------------------------------------------
1154 * If parent is non-NULL, look through children for a label or title
1155 * matching the specified string. If NULL, look through all top-level windows.
1160 wxFindWindowByLabel (const wxString
& title
, wxWindow
* parent
)
1162 return wxWindow::FindWindowByLabel( title
, parent
);
1167 * If parent is non-NULL, look through children for a name
1168 * matching the specified string. If NULL, look through all top-level windows.
1173 wxFindWindowByName (const wxString
& name
, wxWindow
* parent
)
1175 return wxWindow::FindWindowByName( name
, parent
);
1178 // Returns menu item id or wxNOT_FOUND if none.
1180 wxFindMenuItemId(wxFrame
*frame
,
1181 const wxString
& menuString
,
1182 const wxString
& itemString
)
1185 wxMenuBar
*menuBar
= frame
->GetMenuBar ();
1187 return menuBar
->FindMenuItem (menuString
, itemString
);
1188 #else // !wxUSE_MENUS
1190 wxUnusedVar(menuString
);
1191 wxUnusedVar(itemString
);
1192 #endif // wxUSE_MENUS/!wxUSE_MENUS
1197 // Try to find the deepest child that contains 'pt'.
1198 // We go backwards, to try to allow for controls that are spacially
1199 // within other controls, but are still siblings (e.g. buttons within
1200 // static boxes). Static boxes are likely to be created _before_ controls
1201 // that sit inside them.
1202 wxWindow
* wxFindWindowAtPoint(wxWindow
* win
, const wxPoint
& pt
)
1204 if (!win
->IsShown())
1207 // Hack for wxNotebook case: at least in wxGTK, all pages
1208 // claim to be shown, so we must only deal with the selected one.
1210 if (win
->IsKindOf(CLASSINFO(wxNotebook
)))
1212 wxNotebook
* nb
= (wxNotebook
*) win
;
1213 int sel
= nb
->GetSelection();
1216 wxWindow
* child
= nb
->GetPage(sel
);
1217 wxWindow
* foundWin
= wxFindWindowAtPoint(child
, pt
);
1224 wxWindowList::compatibility_iterator node
= win
->GetChildren().GetLast();
1227 wxWindow
* child
= node
->GetData();
1228 wxWindow
* foundWin
= wxFindWindowAtPoint(child
, pt
);
1231 node
= node
->GetPrevious();
1234 wxPoint pos
= win
->GetPosition();
1235 wxSize sz
= win
->GetSize();
1236 if ( !win
->IsTopLevel() && win
->GetParent() )
1238 pos
= win
->GetParent()->ClientToScreen(pos
);
1241 wxRect
rect(pos
, sz
);
1242 if (rect
.Contains(pt
))
1248 wxWindow
* wxGenericFindWindowAtPoint(const wxPoint
& pt
)
1250 // Go backwards through the list since windows
1251 // on top are likely to have been appended most
1253 wxWindowList::compatibility_iterator node
= wxTopLevelWindows
.GetLast();
1256 wxWindow
* win
= node
->GetData();
1257 wxWindow
* found
= wxFindWindowAtPoint(win
, pt
);
1260 node
= node
->GetPrevious();
1265 // ----------------------------------------------------------------------------
1267 // ----------------------------------------------------------------------------
1270 * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
1271 * since otherwise the generic code may be pulled in unnecessarily.
1276 int wxMessageBox(const wxString
& message
, const wxString
& caption
, long style
,
1277 wxWindow
*parent
, int WXUNUSED(x
), int WXUNUSED(y
) )
1279 long decorated_style
= style
;
1281 if ( ( style
& ( wxICON_EXCLAMATION
| wxICON_HAND
| wxICON_INFORMATION
| wxICON_QUESTION
) ) == 0 )
1283 decorated_style
|= ( style
& wxYES
) ? wxICON_QUESTION
: wxICON_INFORMATION
;
1286 wxMessageDialog
dialog(parent
, message
, caption
, decorated_style
);
1288 int ans
= dialog
.ShowModal();
1301 wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") );
1306 void wxInfoMessageBox(wxWindow
* parent
)
1308 // don't translate these strings, they're for diagnostics purposes only
1310 msg
.Printf(_T("wxWidgets Library (%s port)\n")
1311 _T("Version %d.%d.%d%s%s, compiled at %s %s\n")
1312 _T("Runtime version of toolkit used is %d.%d.%s\n")
1313 _T("Copyright (c) 1995-2009 wxWidgets team"),
1314 wxPlatformInfo::Get().GetPortIdName().c_str(),
1330 wxPlatformInfo::Get().GetToolkitMajorVersion(),
1331 wxPlatformInfo::Get().GetToolkitMinorVersion(),
1333 wxString::Format("\nThe compile-time GTK+ version is %d.%d.%d.",
1336 GTK_MICRO_VERSION
).c_str()
1341 wxMessageBox(msg
, _T("wxWidgets information"),
1342 wxICON_INFORMATION
| wxOK
,
1346 #endif // wxUSE_MSGDLG
1350 wxString
wxGetTextFromUser(const wxString
& message
, const wxString
& caption
,
1351 const wxString
& defaultValue
, wxWindow
*parent
,
1352 wxCoord x
, wxCoord y
, bool centre
)
1355 long style
= wxTextEntryDialogStyle
;
1362 wxTextEntryDialog
dialog(parent
, message
, caption
, defaultValue
, style
, wxPoint(x
, y
));
1364 if (dialog
.ShowModal() == wxID_OK
)
1366 str
= dialog
.GetValue();
1372 wxString
wxGetPasswordFromUser(const wxString
& message
,
1373 const wxString
& caption
,
1374 const wxString
& defaultValue
,
1376 wxCoord x
, wxCoord y
, bool centre
)
1379 long style
= wxTextEntryDialogStyle
;
1386 wxPasswordEntryDialog
dialog(parent
, message
, caption
, defaultValue
,
1387 style
, wxPoint(x
, y
));
1388 if ( dialog
.ShowModal() == wxID_OK
)
1390 str
= dialog
.GetValue();
1396 #endif // wxUSE_TEXTDLG
1400 wxColour
wxGetColourFromUser(wxWindow
*parent
,
1401 const wxColour
& colInit
,
1402 const wxString
& caption
,
1403 wxColourData
*ptrData
)
1405 // contains serialized representation of wxColourData used the last time
1406 // the dialog was shown: we want to reuse it the next time in order to show
1407 // the same custom colours to the user (and we can't just have static
1408 // wxColourData itself because it's a GUI object and so should be destroyed
1409 // before GUI shutdown and doing it during static cleanup is too late)
1410 static wxString s_strColourData
;
1416 if ( !s_strColourData
.empty() )
1418 if ( !data
.FromString(s_strColourData
) )
1420 wxFAIL_MSG( "bug in wxColourData::FromString()?" );
1424 // we don't get back the "choose full" flag value from the native
1425 // dialog and so we can't preserve it between runs, so we decide to
1426 // always use it as it seems better than not using it (user can
1427 // just ignore the extra controls in the dialog but having to click
1428 // a button each time to show them would be very annoying
1429 data
.SetChooseFull(true);
1434 if ( colInit
.IsOk() )
1436 ptrData
->SetColour(colInit
);
1440 wxColourDialog
dialog(parent
, ptrData
);
1441 if (!caption
.empty())
1442 dialog
.SetTitle(caption
);
1443 if ( dialog
.ShowModal() == wxID_OK
)
1445 *ptrData
= dialog
.GetColourData();
1446 colRet
= ptrData
->GetColour();
1447 s_strColourData
= ptrData
->ToString();
1449 //else: leave colRet invalid
1454 #endif // wxUSE_COLOURDLG
1458 wxFont
wxGetFontFromUser(wxWindow
*parent
, const wxFont
& fontInit
, const wxString
& caption
)
1461 if ( fontInit
.Ok() )
1463 data
.SetInitialFont(fontInit
);
1467 wxFontDialog
dialog(parent
, data
);
1468 if (!caption
.empty())
1469 dialog
.SetTitle(caption
);
1470 if ( dialog
.ShowModal() == wxID_OK
)
1472 fontRet
= dialog
.GetFontData().GetChosenFont();
1474 //else: leave it invalid
1479 #endif // wxUSE_FONTDLG
1481 // ----------------------------------------------------------------------------
1482 // wxSafeYield and supporting functions
1483 // ----------------------------------------------------------------------------
1485 void wxEnableTopLevelWindows(bool enable
)
1487 wxWindowList::compatibility_iterator node
;
1488 for ( node
= wxTopLevelWindows
.GetFirst(); node
; node
= node
->GetNext() )
1489 node
->GetData()->Enable(enable
);
1492 wxWindowDisabler::wxWindowDisabler(bool disable
)
1494 m_disabled
= disable
;
1499 wxWindowDisabler::wxWindowDisabler(wxWindow
*winToSkip
)
1502 DoDisable(winToSkip
);
1505 void wxWindowDisabler::DoDisable(wxWindow
*winToSkip
)
1507 // remember the top level windows which were already disabled, so that we
1508 // don't reenable them later
1509 m_winDisabled
= NULL
;
1511 wxWindowList::compatibility_iterator node
;
1512 for ( node
= wxTopLevelWindows
.GetFirst(); node
; node
= node
->GetNext() )
1514 wxWindow
*winTop
= node
->GetData();
1515 if ( winTop
== winToSkip
)
1518 // we don't need to disable the hidden or already disabled windows
1519 if ( winTop
->IsEnabled() && winTop
->IsShown() )
1525 if ( !m_winDisabled
)
1527 m_winDisabled
= new wxWindowList
;
1530 m_winDisabled
->Append(winTop
);
1535 wxWindowDisabler::~wxWindowDisabler()
1540 wxWindowList::compatibility_iterator node
;
1541 for ( node
= wxTopLevelWindows
.GetFirst(); node
; node
= node
->GetNext() )
1543 wxWindow
*winTop
= node
->GetData();
1544 if ( !m_winDisabled
|| !m_winDisabled
->Find(winTop
) )
1548 //else: had been already disabled, don't reenable
1551 delete m_winDisabled
;
1554 // Yield to other apps/messages and disable user input to all windows except
1556 bool wxSafeYield(wxWindow
*win
, bool onlyIfNeeded
)
1558 wxWindowDisabler
wd(win
);
1562 rc
= wxYieldIfNeeded();
1569 // ----------------------------------------------------------------------------
1570 // wxApp::Yield() wrappers for backwards compatibility
1571 // ----------------------------------------------------------------------------
1575 return wxTheApp
&& wxTheApp
->Yield();
1578 bool wxYieldIfNeeded()
1580 return wxTheApp
&& wxTheApp
->Yield(true);