]> git.saurik.com Git - wxWidgets.git/blob - src/common/utilscmn.cpp
projects / wxWidgets.git / blob
? search:


82b05eece5ee21334b0b15b380e5e0772210ea18
[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 __WXPALMOS5__
79 #ifndef __WXWINCE__
80 #include <time.h>
81 #else
82 #include "wx/msw/wince/time.h"
83 #endif
84 #endif // ! __WXPALMOS5__
85
86 #ifdef __WXMAC__
87 #include "wx/osx/private.h"
88 #endif
89
90 #ifndef __WXPALMOS5__
91 #if !defined(__MWERKS__) && !defined(__WXWINCE__)
92 #include <sys/types.h>
93 #include <sys/stat.h>
94 #endif
95 #endif // ! __WXPALMOS5__
96
97 #if defined(__WXMSW__)
98 #include "wx/msw/private.h"
99 #include "wx/msw/registry.h"
100 #include <shellapi.h> // needed for SHELLEXECUTEINFO
101 #endif
102
103 #if wxUSE_GUI && defined(__WXGTK__)
104 #include <gtk/gtk.h> // for GTK_XXX_VERSION constants
105 #endif
106
107 #if wxUSE_BASE
108
109 // ============================================================================
110 // implementation
111 // ============================================================================
112
113 // Array used in DecToHex conversion routine.
114 static wxChar hexArray[] = wxT("0123456789ABCDEF");
115
116 // Convert 2-digit hex number to decimal
117 int wxHexToDec(const wxString& buf)
118 {
119 int firstDigit, secondDigit;
120
121 if (buf.GetChar(0) >= wxT('A'))
122 firstDigit = buf.GetChar(0) - wxT('A') + 10;
123 else
124 firstDigit = buf.GetChar(0) - wxT('0');
125
126 if (buf.GetChar(1) >= wxT('A'))
127 secondDigit = buf.GetChar(1) - wxT('A') + 10;
128 else
129 secondDigit = buf.GetChar(1) - wxT('0');
130
131 return (firstDigit & 0xF) * 16 + (secondDigit & 0xF );
132 }
133
134 // Convert decimal integer to 2-character hex string
135 void wxDecToHex(int dec, wxChar *buf)
136 {
137 int firstDigit = (int)(dec/16.0);
138 int secondDigit = (int)(dec - (firstDigit*16.0));
139 buf[0] = hexArray[firstDigit];
140 buf[1] = hexArray[secondDigit];
141 buf[2] = 0;
142 }
143
144 // Convert decimal integer to 2 characters
145 void wxDecToHex(int dec, char* ch1, char* ch2)
146 {
147 int firstDigit = (int)(dec/16.0);
148 int secondDigit = (int)(dec - (firstDigit*16.0));
149 (*ch1) = (char) hexArray[firstDigit];
150 (*ch2) = (char) hexArray[secondDigit];
151 }
152
153 // Convert decimal integer to 2-character hex string
154 wxString wxDecToHex(int dec)
155 {
156 wxChar buf[3];
157 wxDecToHex(dec, buf);
158 return wxString(buf);
159 }
160
161 // ----------------------------------------------------------------------------
162 // misc functions
163 // ----------------------------------------------------------------------------
164
165 // Don't synthesize KeyUp events holding down a key and producing KeyDown
166 // events with autorepeat. On by default and always on in wxMSW. wxGTK version
167 // in utilsgtk.cpp.
168 #ifndef __WXGTK__
169 bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
170 {
171 return true; // detectable auto-repeat is the only mode MSW supports
172 }
173 #endif // !wxGTK
174
175 // Return the current date/time
176 wxString wxNow()
177 {
178 #ifdef __WXWINCE__
179 #if wxUSE_DATETIME
180 wxDateTime now = wxDateTime::Now();
181 return now.Format();
182 #else
183 return wxEmptyString;
184 #endif
185 #else
186 time_t now = time((time_t *) NULL);
187 char *date = ctime(&now);
188 date[24] = '\0';
189 return wxString::FromAscii(date);
190 #endif
191 }
192
193 #if WXWIN_COMPATIBILITY_2_6
194 void wxUsleep(unsigned long milliseconds)
195 {
196 wxMilliSleep(milliseconds);
197 }
198 #endif
199
200 const wxChar *wxGetInstallPrefix()
201 {
202 wxString prefix;
203
204 if ( wxGetEnv(wxT("WXPREFIX"), &prefix) )
205 return prefix.c_str();
206
207 #ifdef wxINSTALL_PREFIX
208 return wxT(wxINSTALL_PREFIX);
209 #else
210 return wxEmptyString;
211 #endif
212 }
213
214 wxString wxGetDataDir()
215 {
216 wxString dir = wxGetInstallPrefix();
217 dir << wxFILE_SEP_PATH << wxT("share") << wxFILE_SEP_PATH << wxT("wx");
218 return dir;
219 }
220
221 bool wxIsPlatformLittleEndian()
222 {
223 // Are we little or big endian? This method is from Harbison & Steele.
224 union
225 {
226 long l;
227 char c[sizeof(long)];
228 } u;
229 u.l = 1;
230
231 return u.c[0] == 1;
232 }
233
234
235 // ----------------------------------------------------------------------------
236 // wxPlatform
237 // ----------------------------------------------------------------------------
238
239 /*
240 * Class to make it easier to specify platform-dependent values
241 */
242
243 wxArrayInt* wxPlatform::sm_customPlatforms = NULL;
244
245 void wxPlatform::Copy(const wxPlatform& platform)
246 {
247 m_longValue = platform.m_longValue;
248 m_doubleValue = platform.m_doubleValue;
249 m_stringValue = platform.m_stringValue;
250 }
251
252 wxPlatform wxPlatform::If(int platform, long value)
253 {
254 if (Is(platform))
255 return wxPlatform(value);
256 else
257 return wxPlatform();
258 }
259
260 wxPlatform wxPlatform::IfNot(int platform, long value)
261 {
262 if (!Is(platform))
263 return wxPlatform(value);
264 else
265 return wxPlatform();
266 }
267
268 wxPlatform& wxPlatform::ElseIf(int platform, long value)
269 {
270 if (Is(platform))
271 m_longValue = value;
272 return *this;
273 }
274
275 wxPlatform& wxPlatform::ElseIfNot(int platform, long value)
276 {
277 if (!Is(platform))
278 m_longValue = value;
279 return *this;
280 }
281
282 wxPlatform wxPlatform::If(int platform, double value)
283 {
284 if (Is(platform))
285 return wxPlatform(value);
286 else
287 return wxPlatform();
288 }
289
290 wxPlatform wxPlatform::IfNot(int platform, double value)
291 {
292 if (!Is(platform))
293 return wxPlatform(value);
294 else
295 return wxPlatform();
296 }
297
298 wxPlatform& wxPlatform::ElseIf(int platform, double value)
299 {
300 if (Is(platform))
301 m_doubleValue = value;
302 return *this;
303 }
304
305 wxPlatform& wxPlatform::ElseIfNot(int platform, double value)
306 {
307 if (!Is(platform))
308 m_doubleValue = value;
309 return *this;
310 }
311
312 wxPlatform wxPlatform::If(int platform, const wxString& value)
313 {
314 if (Is(platform))
315 return wxPlatform(value);
316 else
317 return wxPlatform();
318 }
319
320 wxPlatform wxPlatform::IfNot(int platform, const wxString& value)
321 {
322 if (!Is(platform))
323 return wxPlatform(value);
324 else
325 return wxPlatform();
326 }
327
328 wxPlatform& wxPlatform::ElseIf(int platform, const wxString& value)
329 {
330 if (Is(platform))
331 m_stringValue = value;
332 return *this;
333 }
334
335 wxPlatform& wxPlatform::ElseIfNot(int platform, const wxString& value)
336 {
337 if (!Is(platform))
338 m_stringValue = value;
339 return *this;
340 }
341
342 wxPlatform& wxPlatform::Else(long value)
343 {
344 m_longValue = value;
345 return *this;
346 }
347
348 wxPlatform& wxPlatform::Else(double value)
349 {
350 m_doubleValue = value;
351 return *this;
352 }
353
354 wxPlatform& wxPlatform::Else(const wxString& value)
355 {
356 m_stringValue = value;
357 return *this;
358 }
359
360 void wxPlatform::AddPlatform(int platform)
361 {
362 if (!sm_customPlatforms)
363 sm_customPlatforms = new wxArrayInt;
364 sm_customPlatforms->Add(platform);
365 }
366
367 void wxPlatform::ClearPlatforms()
368 {
369 delete sm_customPlatforms;
370 sm_customPlatforms = NULL;
371 }
372
373 /// Function for testing current platform
374
375 bool wxPlatform::Is(int platform)
376 {
377 #ifdef __WXMSW__
378 if (platform == wxOS_WINDOWS)
379 return true;
380 #endif
381 #ifdef __WXWINCE__
382 if (platform == wxOS_WINDOWS_CE)
383 return true;
384 #endif
385
386 #if 0
387
388 // FIXME: wxWinPocketPC and wxWinSmartPhone are unknown symbols
389
390 #if defined(__WXWINCE__) && defined(__POCKETPC__)
391 if (platform == wxWinPocketPC)
392 return true;
393 #endif
394 #if defined(__WXWINCE__) && defined(__SMARTPHONE__)
395 if (platform == wxWinSmartPhone)
396 return true;
397 #endif
398
399 #endif
400
401 #ifdef __WXGTK__
402 if (platform == wxPORT_GTK)
403 return true;
404 #endif
405 #ifdef __WXMAC__
406 if (platform == wxPORT_MAC)
407 return true;
408 #endif
409 #ifdef __WXX11__
410 if (platform == wxPORT_X11)
411 return true;
412 #endif
413 #ifdef __UNIX__
414 if (platform == wxOS_UNIX)
415 return true;
416 #endif
417 #ifdef __WXMGL__
418 if (platform == wxPORT_MGL)
419 return true;
420 #endif
421 #ifdef __OS2__
422 if (platform == wxOS_OS2)
423 return true;
424 #endif
425 #ifdef __WXPM__
426 if (platform == wxPORT_PM)
427 return true;
428 #endif
429 #ifdef __WXCOCOA__
430 if (platform == wxPORT_MAC)
431 return true;
432 #endif
433
434 if (sm_customPlatforms && sm_customPlatforms->Index(platform) != wxNOT_FOUND)
435 return true;
436
437 return false;
438 }
439
440 // ----------------------------------------------------------------------------
441 // network and user id functions
442 // ----------------------------------------------------------------------------
443
444 // Get Full RFC822 style email address
445 bool wxGetEmailAddress(wxChar *address, int maxSize)
446 {
447 wxString email = wxGetEmailAddress();
448 if ( !email )
449 return false;
450
451 wxStrlcpy(address, email.t_str(), maxSize);
452
453 return true;
454 }
455
456 wxString wxGetEmailAddress()
457 {
458 wxString email;
459
460 wxString host = wxGetFullHostName();
461 if ( !host.empty() )
462 {
463 wxString user = wxGetUserId();
464 if ( !user.empty() )
465 {
466 email << user << wxT('@') << host;
467 }
468 }
469
470 return email;
471 }
472
473 wxString wxGetUserId()
474 {
475 static const int maxLoginLen = 256; // FIXME arbitrary number
476
477 wxString buf;
478 bool ok = wxGetUserId(wxStringBuffer(buf, maxLoginLen), maxLoginLen);
479
480 if ( !ok )
481 buf.Empty();
482
483 return buf;
484 }
485
486 wxString wxGetUserName()
487 {
488 static const int maxUserNameLen = 1024; // FIXME arbitrary number
489
490 wxString buf;
491 bool ok = wxGetUserName(wxStringBuffer(buf, maxUserNameLen), maxUserNameLen);
492
493 if ( !ok )
494 buf.Empty();
495
496 return buf;
497 }
498
499 wxString wxGetHostName()
500 {
501 static const size_t hostnameSize = 257;
502
503 wxString buf;
504 bool ok = wxGetHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
505
506 if ( !ok )
507 buf.Empty();
508
509 return buf;
510 }
511
512 wxString wxGetFullHostName()
513 {
514 static const size_t hostnameSize = 257;
515
516 wxString buf;
517 bool ok = wxGetFullHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
518
519 if ( !ok )
520 buf.Empty();
521
522 return buf;
523 }
524
525 wxString wxGetHomeDir()
526 {
527 wxString home;
528 wxGetHomeDir(&home);
529
530 return home;
531 }
532
533 #if 0
534
535 wxString wxGetCurrentDir()
536 {
537 wxString dir;
538 size_t len = 1024;
539 bool ok;
540 do
541 {
542 ok = getcwd(dir.GetWriteBuf(len + 1), len) != NULL;
543 dir.UngetWriteBuf();
544
545 if ( !ok )
546 {
547 if ( errno != ERANGE )
548 {
549 wxLogSysError(_T("Failed to get current directory"));
550
551 return wxEmptyString;
552 }
553 else
554 {
555 // buffer was too small, retry with a larger one
556 len *= 2;
557 }
558 }
559 //else: ok
560 } while ( !ok );
561
562 return dir;
563 }
564
565 #endif // 0
566
567 // ----------------------------------------------------------------------------
568 // wxExecute
569 // ----------------------------------------------------------------------------
570
571 // wxDoExecuteWithCapture() helper: reads an entire stream into one array
572 //
573 // returns true if ok, false if error
574 #if wxUSE_STREAMS
575 static bool ReadAll(wxInputStream *is, wxArrayString& output)
576 {
577 wxCHECK_MSG( is, false, _T("NULL stream in wxExecute()?") );
578
579 // the stream could be already at EOF or in wxSTREAM_BROKEN_PIPE state
580 is->Reset();
581
582 wxTextInputStream tis(*is);
583
584 for ( ;; )
585 {
586 wxString line = tis.ReadLine();
587
588 // check for EOF before other errors as it's not really an error
589 if ( is->Eof() )
590 {
591 // add the last, possibly incomplete, line
592 if ( !line.empty() )
593 output.Add(line);
594 break;
595 }
596
597 // any other error is fatal
598 if ( !*is )
599 return false;
600
601 output.Add(line);
602 }
603
604 return true;
605 }
606 #endif // wxUSE_STREAMS
607
608 // this is a private function because it hasn't a clean interface: the first
609 // array is passed by reference, the second by pointer - instead we have 2
610 // public versions of wxExecute() below
611 static long wxDoExecuteWithCapture(const wxString& command,
612 wxArrayString& output,
613 wxArrayString* error,
614 int flags)
615 {
616 // create a wxProcess which will capture the output
617 wxProcess *process = new wxProcess;
618 process->Redirect();
619
620 long rc = wxExecute(command, wxEXEC_SYNC | flags, process);
621
622 #if wxUSE_STREAMS
623 if ( rc != -1 )
624 {
625 if ( !ReadAll(process->GetInputStream(), output) )
626 rc = -1;
627
628 if ( error )
629 {
630 if ( !ReadAll(process->GetErrorStream(), *error) )
631 rc = -1;
632 }
633
634 }
635 #else
636 wxUnusedVar(output);
637 wxUnusedVar(error);
638 #endif // wxUSE_STREAMS/!wxUSE_STREAMS
639
640 delete process;
641
642 return rc;
643 }
644
645 long wxExecute(const wxString& command, wxArrayString& output, int flags)
646 {
647 return wxDoExecuteWithCapture(command, output, NULL, flags);
648 }
649
650 long wxExecute(const wxString& command,
651 wxArrayString& output,
652 wxArrayString& error,
653 int flags)
654 {
655 return wxDoExecuteWithCapture(command, output, &error, flags);
656 }
657
658 // ----------------------------------------------------------------------------
659 // Id functions
660 // ----------------------------------------------------------------------------
661
662 // Id generation
663 static long wxCurrentId = 100;
664
665 long wxNewId()
666 {
667 // skip the part of IDs space that contains hard-coded values:
668 if (wxCurrentId == wxID_LOWEST)
669 wxCurrentId = wxID_HIGHEST + 1;
670
671 return wxCurrentId++;
672 }
673
674 long
675 wxGetCurrentId(void) { return wxCurrentId; }
676
677 void
678 wxRegisterId (long id)
679 {
680 if (id >= wxCurrentId)
681 wxCurrentId = id + 1;
682 }
683
684 // ----------------------------------------------------------------------------
685 // wxQsort, adapted by RR to allow user_data
686 // ----------------------------------------------------------------------------
687
688 /* This file is part of the GNU C Library.
689 Written by Douglas C. Schmidt (schmidt@ics.uci.edu).
690
691 Douglas Schmidt kindly gave permission to relicence the
692 code under the wxWindows licence:
693
694 From: "Douglas C. Schmidt" <schmidt@dre.vanderbilt.edu>
695 To: Robert Roebling <robert.roebling@uni-ulm.de>
696 Subject: Re: qsort licence
697 Date: Mon, 23 Jul 2007 03:44:25 -0500
698 Sender: schmidt@dre.vanderbilt.edu
699 Message-Id: <20070723084426.64F511000A8@tango.dre.vanderbilt.edu>
700
701 Hi Robert,
702
703 > [...] I'm asking if you'd be willing to relicence your code
704 > under the wxWindows licence. [...]
705
706 That's fine with me [...]
707
708 Thanks,
709
710 Doug */
711
712
713 /* Byte-wise swap two items of size SIZE. */
714 #define SWAP(a, b, size) \
715 do \
716 { \
717 register size_t __size = (size); \
718 register char *__a = (a), *__b = (b); \
719 do \
720 { \
721 char __tmp = *__a; \
722 *__a++ = *__b; \
723 *__b++ = __tmp; \
724 } while (--__size > 0); \
725 } while (0)
726
727 /* Discontinue quicksort algorithm when partition gets below this size.
728 This particular magic number was chosen to work best on a Sun 4/260. */
729 #define MAX_THRESH 4
730
731 /* Stack node declarations used to store unfulfilled partition obligations. */
732 typedef struct
733 {
734 char *lo;
735 char *hi;
736 } stack_node;
737
738 /* The next 4 #defines implement a very fast in-line stack abstraction. */
739 #define STACK_SIZE (8 * sizeof(unsigned long int))
740 #define PUSH(low, high) ((void) ((top->lo = (low)), (top->hi = (high)), ++top))
741 #define POP(low, high) ((void) (--top, (low = top->lo), (high = top->hi)))
742 #define STACK_NOT_EMPTY (stack < top)
743
744
745 /* Order size using quicksort. This implementation incorporates
746 four optimizations discussed in Sedgewick:
747
748 1. Non-recursive, using an explicit stack of pointer that store the
749 next array partition to sort. To save time, this maximum amount
750 of space required to store an array of MAX_INT is allocated on the
751 stack. Assuming a 32-bit integer, this needs only 32 *
752 sizeof(stack_node) == 136 bits. Pretty cheap, actually.
753
754 2. Chose the pivot element using a median-of-three decision tree.
755 This reduces the probability of selecting a bad pivot value and
756 eliminates certain extraneous comparisons.
757
758 3. Only quicksorts TOTAL_ELEMS / MAX_THRESH partitions, leaving
759 insertion sort to order the MAX_THRESH items within each partition.
760 This is a big win, since insertion sort is faster for small, mostly
761 sorted array segments.
762
763 4. The larger of the two sub-partitions is always pushed onto the
764 stack first, with the algorithm then concentrating on the
765 smaller partition. This *guarantees* no more than log (n)
766 stack size is needed (actually O(1) in this case)! */
767
768 void wxQsort(void *const pbase, size_t total_elems,
769 size_t size, CMPFUNCDATA cmp, const void* user_data)
770 {
771 register char *base_ptr = (char *) pbase;
772 const size_t max_thresh = MAX_THRESH * size;
773
774 if (total_elems == 0)
775 /* Avoid lossage with unsigned arithmetic below. */
776 return;
777
778 if (total_elems > MAX_THRESH)
779 {
780 char *lo = base_ptr;
781 char *hi = &lo[size * (total_elems - 1)];
782 stack_node stack[STACK_SIZE];
783 stack_node *top = stack;
784
785 PUSH (NULL, NULL);
786
787 while (STACK_NOT_EMPTY)
788 {
789 char *left_ptr;
790 char *right_ptr;
791
792 /* Select median value from among LO, MID, and HI. Rearrange
793 LO and HI so the three values are sorted. This lowers the
794 probability of picking a pathological pivot value and
795 skips a comparison for both the LEFT_PTR and RIGHT_PTR. */
796
797 char *mid = lo + size * ((hi - lo) / size >> 1);
798
799 if ((*cmp) ((void *) mid, (void *) lo, user_data) < 0)
800 SWAP (mid, lo, size);
801 if ((*cmp) ((void *) hi, (void *) mid, user_data) < 0)
802 SWAP (mid, hi, size);
803 else
804 goto jump_over;
805 if ((*cmp) ((void *) mid, (void *) lo, user_data) < 0)
806 SWAP (mid, lo, size);
807 jump_over:;
808 left_ptr = lo + size;
809 right_ptr = hi - size;
810
811 /* Here's the famous ``collapse the walls'' section of quicksort.
812 Gotta like those tight inner loops! They are the main reason
813 that this algorithm runs much faster than others. */
814 do
815 {
816 while ((*cmp) ((void *) left_ptr, (void *) mid, user_data) < 0)
817 left_ptr += size;
818
819 while ((*cmp) ((void *) mid, (void *) right_ptr, user_data) < 0)
820 right_ptr -= size;
821
822 if (left_ptr < right_ptr)
823 {
824 SWAP (left_ptr, right_ptr, size);
825 if (mid == left_ptr)
826 mid = right_ptr;
827 else if (mid == right_ptr)
828 mid = left_ptr;
829 left_ptr += size;
830 right_ptr -= size;
831 }
832 else if (left_ptr == right_ptr)
833 {
834 left_ptr += size;
835 right_ptr -= size;
836 break;
837 }
838 }
839 while (left_ptr <= right_ptr);
840
841 /* Set up pointers for next iteration. First determine whether
842 left and right partitions are below the threshold size. If so,
843 ignore one or both. Otherwise, push the larger partition's
844 bounds on the stack and continue sorting the smaller one. */
845
846 if ((size_t) (right_ptr - lo) <= max_thresh)
847 {
848 if ((size_t) (hi - left_ptr) <= max_thresh)
849 /* Ignore both small partitions. */
850 POP (lo, hi);
851 else
852 /* Ignore small left partition. */
853 lo = left_ptr;
854 }
855 else if ((size_t) (hi - left_ptr) <= max_thresh)
856 /* Ignore small right partition. */
857 hi = right_ptr;
858 else if ((right_ptr - lo) > (hi - left_ptr))
859 {
860 /* Push larger left partition indices. */
861 PUSH (lo, right_ptr);
862 lo = left_ptr;
863 }
864 else
865 {
866 /* Push larger right partition indices. */
867 PUSH (left_ptr, hi);
868 hi = right_ptr;
869 }
870 }
871 }
872
873 /* Once the BASE_PTR array is partially sorted by quicksort the rest
874 is completely sorted using insertion sort, since this is efficient
875 for partitions below MAX_THRESH size. BASE_PTR points to the beginning
876 of the array to sort, and END_PTR points at the very last element in
877 the array (*not* one beyond it!). */
878
879 {
880 char *const end_ptr = &base_ptr[size * (total_elems - 1)];
881 char *tmp_ptr = base_ptr;
882 char *thresh = base_ptr + max_thresh;
883 if ( thresh > end_ptr )
884 thresh = end_ptr;
885 register char *run_ptr;
886
887 /* Find smallest element in first threshold and place it at the
888 array's beginning. This is the smallest array element,
889 and the operation speeds up insertion sort's inner loop. */
890
891 for (run_ptr = tmp_ptr + size; run_ptr <= thresh; run_ptr += size)
892 if ((*cmp) ((void *) run_ptr, (void *) tmp_ptr, user_data) < 0)
893 tmp_ptr = run_ptr;
894
895 if (tmp_ptr != base_ptr)
896 SWAP (tmp_ptr, base_ptr, size);
897
898 /* Insertion sort, running from left-hand-side up to right-hand-side. */
899
900 run_ptr = base_ptr + size;
901 while ((run_ptr += size) <= end_ptr)
902 {
903 tmp_ptr = run_ptr - size;
904 while ((*cmp) ((void *) run_ptr, (void *) tmp_ptr, user_data) < 0)
905 tmp_ptr -= size;
906
907 tmp_ptr += size;
908 if (tmp_ptr != run_ptr)
909 {
910 char *trav;
911
912 trav = run_ptr + size;
913 while (--trav >= run_ptr)
914 {
915 char c = *trav;
916 char *hi, *lo;
917
918 for (hi = lo = trav; (lo -= size) >= tmp_ptr; hi = lo)
919 *hi = *lo;
920 *hi = c;
921 }
922 }
923 }
924 }
925 }
926
927 #endif // wxUSE_BASE
928
929
930
931 // ============================================================================
932 // GUI-only functions from now on
933 // ============================================================================
934
935 #if wxUSE_GUI
936
937 // ----------------------------------------------------------------------------
938 // Launch document with default app
939 // ----------------------------------------------------------------------------
940
941 bool wxLaunchDefaultApplication(const wxString& document, int flags)
942 {
943 wxUnusedVar(flags);
944
945 #ifdef __WXMAC__
946 static const char * const OPEN_CMD = "/usr/bin/open";
947 if ( wxFileExists(OPEN_CMD) &&
948 wxExecute(wxString(OPEN_CMD) + " " + document) )
949 return true;
950 #elif defined(__UNIX__)
951 // Our best best is to use xdg-open from freedesktop.org cross-desktop
952 // compatibility suite xdg-utils
953 // (see http://portland.freedesktop.org/wiki/) -- this is installed on
954 // most modern distributions and may be tweaked by them to handle
955 // distribution specifics.
956 wxString path, xdg_open;
957 if ( wxGetEnv("PATH", &path) &&
958 wxFindFileInPath(&xdg_open, path, "xdg-open") )
959 {
960 if ( wxExecute(xdg_open + " " + document) )
961 return true;
962 }
963 #elif defined(__WXMSW__)
964 WinStruct<SHELLEXECUTEINFO> sei;
965 sei.lpFile = document.wx_str();
966 sei.lpVerb = _T("open");
967 #ifdef __WXWINCE__
968 sei.nShow = SW_SHOWNORMAL; // SW_SHOWDEFAULT not defined under CE (#10216)
969 #else
970 sei.nShow = SW_SHOWDEFAULT;
971 #endif
972
973 // avoid Windows message box in case of error for consistency with
974 // wxLaunchDefaultBrowser() even if don't show the error ourselves in this
975 // function
976 sei.fMask = SEE_MASK_FLAG_NO_UI;
977
978 if ( ::ShellExecuteEx(&sei) )
979 return true;
980 #endif
981
982 return false;
983 }
984
985 // ----------------------------------------------------------------------------
986 // Launch default browser
987 // ----------------------------------------------------------------------------
988
989 #ifdef __WXCOCOA__
990 // Private method in Objective-C++ source file.
991 bool wxCocoaLaunchDefaultBrowser(const wxString& url, int flags);
992 #endif
993
994 static bool DoLaunchDefaultBrowser(const wxString& urlOrig, int flags)
995 {
996 wxUnusedVar(flags);
997
998 // set the scheme of url to http if it does not have one
999 // RR: This doesn't work if the url is just a local path
1000 wxString url(urlOrig);
1001 wxURI uri(url);
1002 if ( !uri.HasScheme() )
1003 {
1004 if (wxFileExists(urlOrig))
1005 url.Prepend( wxT("file://") );
1006 else
1007 url.Prepend(wxT("http://"));
1008 }
1009
1010
1011 #if defined(__WXMSW__)
1012
1013 #if wxUSE_IPC
1014 if ( flags & wxBROWSER_NEW_WINDOW )
1015 {
1016 // ShellExecuteEx() opens the URL in an existing window by default so
1017 // we can't use it if we need a new window
1018 wxRegKey key(wxRegKey::HKCR, uri.GetScheme() + _T("\\shell\\open"));
1019 if ( !key.Exists() )
1020 {
1021 // try default browser, it must be registered at least for http URLs
1022 key.SetName(wxRegKey::HKCR, _T("http\\shell\\open"));
1023 }
1024
1025 if ( key.Exists() )
1026 {
1027 wxRegKey keyDDE(key, wxT("DDEExec"));
1028 if ( keyDDE.Exists() )
1029 {
1030 // we only know the syntax of WWW_OpenURL DDE request for IE,
1031 // optimistically assume that all other browsers are compatible
1032 // with it
1033 static const wxChar *TOPIC_OPEN_URL = wxT("WWW_OpenURL");
1034 wxString ddeCmd;
1035 wxRegKey keyTopic(keyDDE, wxT("topic"));
1036 bool ok = keyTopic.Exists() &&
1037 keyTopic.QueryDefaultValue() == TOPIC_OPEN_URL;
1038 if ( ok )
1039 {
1040 ddeCmd = keyDDE.QueryDefaultValue();
1041 ok = !ddeCmd.empty();
1042 }
1043
1044 if ( ok )
1045 {
1046 // for WWW_OpenURL, the index of the window to open the URL
1047 // in is -1 (meaning "current") by default, replace it with
1048 // 0 which means "new" (see KB article 160957)
1049 ok = ddeCmd.Replace(wxT("-1"), wxT("0"),
1050 false /* only first occurrence */) == 1;
1051 }
1052
1053 if ( ok )
1054 {
1055 // and also replace the parameters: the topic should
1056 // contain a placeholder for the URL
1057 ok = ddeCmd.Replace(wxT("%1"), url, false) == 1;
1058 }
1059
1060 if ( ok )
1061 {
1062 // try to send it the DDE request now but ignore the errors
1063 wxLogNull noLog;
1064
1065 const wxString ddeServer = wxRegKey(keyDDE, wxT("application"));
1066 if ( wxExecuteDDE(ddeServer, TOPIC_OPEN_URL, ddeCmd) )
1067 return true;
1068
1069 // this is not necessarily an error: maybe browser is
1070 // simply not running, but no matter, in any case we're
1071 // going to launch it using ShellExecuteEx() below now and
1072 // we shouldn't try to open a new window if we open a new
1073 // browser anyhow
1074 }
1075 }
1076 }
1077 }
1078 #endif // wxUSE_IPC
1079
1080 WinStruct<SHELLEXECUTEINFO> sei;
1081 sei.lpFile = url.c_str();
1082 sei.lpVerb = _T("open");
1083 sei.nShow = SW_SHOWNORMAL;
1084 sei.fMask = SEE_MASK_FLAG_NO_UI; // we give error message ourselves
1085
1086 if ( ::ShellExecuteEx(&sei) )
1087 return true;
1088 #elif defined(__WXCOCOA__)
1089 // NOTE: We need to call the real implementation from src/cocoa/utils.mm
1090 // because the code must use Objective-C features.
1091 return wxCocoaLaunchDefaultBrowser(url, flags);
1092 #elif defined(__WXMAC__) && !defined(__WXOSX_IPHONE__)
1093 wxCFRef< CFURLRef > curl( CFURLCreateWithString( kCFAllocatorDefault,
1094 wxCFStringRef( url ), NULL ) );
1095 OSStatus err = LSOpenCFURLRef( curl , NULL );
1096
1097 if (err == noErr)
1098 {
1099 return true;
1100 }
1101 else
1102 {
1103 wxLogDebug(wxT("Browser Launch error %d"), (int) err);
1104 return false;
1105 }
1106 #else
1107 // (non-Mac, non-MSW)
1108
1109 #ifdef __UNIX__
1110
1111 // Our best best is to use xdg-open from freedesktop.org cross-desktop
1112 // compatibility suite xdg-utils
1113 // (see http://portland.freedesktop.org/wiki/) -- this is installed on
1114 // most modern distributions and may be tweaked by them to handle
1115 // distribution specifics. Only if that fails, try to find the right
1116 // browser ourselves.
1117 wxString path, xdg_open;
1118 if ( wxGetEnv("PATH", &path) &&
1119 wxFindFileInPath(&xdg_open, path, "xdg-open") )
1120 {
1121 if ( wxExecute(xdg_open + " " + url) )
1122 return true;
1123 }
1124
1125 wxString desktop = wxTheApp->GetTraits()->GetDesktopEnvironment();
1126
1127 // GNOME and KDE desktops have some applications which should be always installed
1128 // together with their main parts, which give us the
1129 if (desktop == wxT("GNOME"))
1130 {
1131 wxArrayString errors;
1132 wxArrayString output;
1133
1134 // gconf will tell us the path of the application to use as browser
1135 long res = wxExecute( wxT("gconftool-2 --get /desktop/gnome/applications/browser/exec"),
1136 output, errors, wxEXEC_NODISABLE );
1137 if (res >= 0 && errors.GetCount() == 0)
1138 {
1139 wxString cmd = output[0];
1140 cmd << _T(' ') << url;
1141 if (wxExecute(cmd))
1142 return true;
1143 }
1144 }
1145 else if (desktop == wxT("KDE"))
1146 {
1147 // kfmclient directly opens the given URL
1148 if (wxExecute(wxT("kfmclient openURL ") + url))
1149 return true;
1150 }
1151 #endif
1152
1153 bool ok = false;
1154 wxString cmd;
1155
1156 #if wxUSE_MIMETYPE
1157 wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(_T("html"));
1158 if ( ft )
1159 {
1160 wxString mt;
1161 ft->GetMimeType(&mt);
1162
1163 ok = ft->GetOpenCommand(&cmd, wxFileType::MessageParameters(url));
1164 delete ft;
1165 }
1166 #endif // wxUSE_MIMETYPE
1167
1168 if ( !ok || cmd.empty() )
1169 {
1170 // fallback to checking for the BROWSER environment variable
1171 cmd = wxGetenv(wxT("BROWSER"));
1172 if ( !cmd.empty() )
1173 cmd << _T(' ') << url;
1174 }
1175
1176 ok = ( !cmd.empty() && wxExecute(cmd) );
1177 if (ok)
1178 return ok;
1179
1180 // no file type for HTML extension
1181 wxLogError(_("No default application configured for HTML files."));
1182
1183 #endif // !wxUSE_MIMETYPE && !__WXMSW__
1184
1185 wxLogSysError(_("Failed to open URL \"%s\" in default browser."),
1186 url.c_str());
1187
1188 return false;
1189 }
1190
1191 bool wxLaunchDefaultBrowser(const wxString& url, int flags)
1192 {
1193 if ( flags & wxBROWSER_NOBUSYCURSOR )
1194 return DoLaunchDefaultBrowser(url, flags);
1195
1196 wxBusyCursor bc;
1197 return DoLaunchDefaultBrowser(url, flags);
1198 }
1199
1200 // ----------------------------------------------------------------------------
1201 // Menu accelerators related functions
1202 // ----------------------------------------------------------------------------
1203
1204 wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
1205 {
1206 #if wxUSE_MENUS
1207 wxString s = wxMenuItem::GetLabelText(in);
1208 #else
1209 wxString str(in);
1210 wxString s = wxStripMenuCodes(str);
1211 #endif // wxUSE_MENUS
1212 if ( out )
1213 {
1214 // go smash their buffer if it's not big enough - I love char * params
1215 memcpy(out, s.c_str(), s.length() * sizeof(wxChar));
1216 }
1217 else
1218 {
1219 out = new wxChar[s.length() + 1];
1220 wxStrcpy(out, s.c_str());
1221 }
1222
1223 return out;
1224 }
1225
1226 wxString wxStripMenuCodes(const wxString& in, int flags)
1227 {
1228 wxASSERT_MSG( flags, _T("this is useless to call without any flags") );
1229
1230 wxString out;
1231
1232 size_t len = in.length();
1233 out.reserve(len);
1234
1235 for ( size_t n = 0; n < len; n++ )
1236 {
1237 wxChar ch = in[n];
1238 if ( (flags & wxStrip_Mnemonics) && ch == _T('&') )
1239 {
1240 // skip it, it is used to introduce the accel char (or to quote
1241 // itself in which case it should still be skipped): note that it
1242 // can't be the last character of the string
1243 if ( ++n == len )
1244 {
1245 wxLogDebug(_T("Invalid menu string '%s'"), in.c_str());
1246 }
1247 else
1248 {
1249 // use the next char instead
1250 ch = in[n];
1251 }
1252 }
1253 else if ( (flags & wxStrip_Accel) && ch == _T('\t') )
1254 {
1255 // everything after TAB is accel string, exit the loop
1256 break;
1257 }
1258
1259 out += ch;
1260 }
1261
1262 return out;
1263 }
1264
1265 // ----------------------------------------------------------------------------
1266 // Window search functions
1267 // ----------------------------------------------------------------------------
1268
1269 /*
1270 * If parent is non-NULL, look through children for a label or title
1271 * matching the specified string. If NULL, look through all top-level windows.
1272 *
1273 */
1274
1275 wxWindow *
1276 wxFindWindowByLabel (const wxString& title, wxWindow * parent)
1277 {
1278 return wxWindow::FindWindowByLabel( title, parent );
1279 }
1280
1281
1282 /*
1283 * If parent is non-NULL, look through children for a name
1284 * matching the specified string. If NULL, look through all top-level windows.
1285 *
1286 */
1287
1288 wxWindow *
1289 wxFindWindowByName (const wxString& name, wxWindow * parent)
1290 {
1291 return wxWindow::FindWindowByName( name, parent );
1292 }
1293
1294 // Returns menu item id or wxNOT_FOUND if none.
1295 int
1296 wxFindMenuItemId(wxFrame *frame,
1297 const wxString& menuString,
1298 const wxString& itemString)
1299 {
1300 #if wxUSE_MENUS
1301 wxMenuBar *menuBar = frame->GetMenuBar ();
1302 if ( menuBar )
1303 return menuBar->FindMenuItem (menuString, itemString);
1304 #else // !wxUSE_MENUS
1305 wxUnusedVar(frame);
1306 wxUnusedVar(menuString);
1307 wxUnusedVar(itemString);
1308 #endif // wxUSE_MENUS/!wxUSE_MENUS
1309
1310 return wxNOT_FOUND;
1311 }
1312
1313 // Try to find the deepest child that contains 'pt'.
1314 // We go backwards, to try to allow for controls that are spacially
1315 // within other controls, but are still siblings (e.g. buttons within
1316 // static boxes). Static boxes are likely to be created _before_ controls
1317 // that sit inside them.
1318 wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt)
1319 {
1320 if (!win->IsShown())
1321 return NULL;
1322
1323 // Hack for wxNotebook case: at least in wxGTK, all pages
1324 // claim to be shown, so we must only deal with the selected one.
1325 #if wxUSE_NOTEBOOK
1326 if (win->IsKindOf(CLASSINFO(wxNotebook)))
1327 {
1328 wxNotebook* nb = (wxNotebook*) win;
1329 int sel = nb->GetSelection();
1330 if (sel >= 0)
1331 {
1332 wxWindow* child = nb->GetPage(sel);
1333 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1334 if (foundWin)
1335 return foundWin;
1336 }
1337 }
1338 #endif
1339
1340 wxWindowList::compatibility_iterator node = win->GetChildren().GetLast();
1341 while (node)
1342 {
1343 wxWindow* child = node->GetData();
1344 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1345 if (foundWin)
1346 return foundWin;
1347 node = node->GetPrevious();
1348 }
1349
1350 wxPoint pos = win->GetPosition();
1351 wxSize sz = win->GetSize();
1352 if ( !win->IsTopLevel() && win->GetParent() )
1353 {
1354 pos = win->GetParent()->ClientToScreen(pos);
1355 }
1356
1357 wxRect rect(pos, sz);
1358 if (rect.Contains(pt))
1359 return win;
1360
1361 return NULL;
1362 }
1363
1364 wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt)
1365 {
1366 // Go backwards through the list since windows
1367 // on top are likely to have been appended most
1368 // recently.
1369 wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast();
1370 while (node)
1371 {
1372 wxWindow* win = node->GetData();
1373 wxWindow* found = wxFindWindowAtPoint(win, pt);
1374 if (found)
1375 return found;
1376 node = node->GetPrevious();
1377 }
1378 return NULL;
1379 }
1380
1381 // ----------------------------------------------------------------------------
1382 // GUI helpers
1383 // ----------------------------------------------------------------------------
1384
1385 /*
1386 * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
1387 * since otherwise the generic code may be pulled in unnecessarily.
1388 */
1389
1390 #if wxUSE_MSGDLG
1391
1392 int wxMessageBox(const wxString& message, const wxString& caption, long style,
1393 wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
1394 {
1395 long decorated_style = style;
1396
1397 if ( ( style & ( wxICON_EXCLAMATION | wxICON_HAND | wxICON_INFORMATION | wxICON_QUESTION ) ) == 0 )
1398 {
1399 decorated_style |= ( style & wxYES ) ? wxICON_QUESTION : wxICON_INFORMATION ;
1400 }
1401
1402 wxMessageDialog dialog(parent, message, caption, decorated_style);
1403
1404 int ans = dialog.ShowModal();
1405 switch ( ans )
1406 {
1407 case wxID_OK:
1408 return wxOK;
1409 case wxID_YES:
1410 return wxYES;
1411 case wxID_NO:
1412 return wxNO;
1413 case wxID_CANCEL:
1414 return wxCANCEL;
1415 }
1416
1417 wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") );
1418
1419 return wxCANCEL;
1420 }
1421
1422 void wxInfoMessageBox(wxWindow* parent)
1423 {
1424 // don't translate these strings, they're for diagnostics purposes only
1425 wxString msg;
1426 msg.Printf(_T("wxWidgets Library (%s port)\n")
1427 _T("Version %d.%d.%d%s%s, compiled at %s %s\n")
1428 _T("Runtime version of toolkit used is %d.%d.%s\n")
1429 _T("Copyright (c) 1995-2009 wxWidgets team"),
1430 wxPlatformInfo::Get().GetPortIdName().c_str(),
1431 wxMAJOR_VERSION,
1432 wxMINOR_VERSION,
1433 wxRELEASE_NUMBER,
1434 #if wxUSE_UNICODE
1435 L" (Unicode)",
1436 #else
1437 wxEmptyString,
1438 #endif
1439 #ifdef __WXDEBUG__
1440 _T(" Debug build"),
1441 #else
1442 wxEmptyString,
1443 #endif
1444 __TDATE__,
1445 __TTIME__,
1446 wxPlatformInfo::Get().GetToolkitMajorVersion(),
1447 wxPlatformInfo::Get().GetToolkitMinorVersion(),
1448 #ifdef __WXGTK__
1449 wxString::Format("\nThe compile-time GTK+ version is %d.%d.%d.",
1450 GTK_MAJOR_VERSION,
1451 GTK_MINOR_VERSION,
1452 GTK_MICRO_VERSION).c_str()
1453 #else
1454 wxEmptyString
1455 #endif
1456 );
1457 wxMessageBox(msg, _T("wxWidgets information"),
1458 wxICON_INFORMATION | wxOK,
1459 parent);
1460 }
1461
1462 #endif // wxUSE_MSGDLG
1463
1464 #if wxUSE_TEXTDLG
1465
1466 wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
1467 const wxString& defaultValue, wxWindow *parent,
1468 wxCoord x, wxCoord y, bool centre )
1469 {
1470 wxString str;
1471 long style = wxTextEntryDialogStyle;
1472
1473 if (centre)
1474 style |= wxCENTRE;
1475 else
1476 style &= ~wxCENTRE;
1477
1478 wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y));
1479
1480 if (dialog.ShowModal() == wxID_OK)
1481 {
1482 str = dialog.GetValue();
1483 }
1484
1485 return str;
1486 }
1487
1488 wxString wxGetPasswordFromUser(const wxString& message,
1489 const wxString& caption,
1490 const wxString& defaultValue,
1491 wxWindow *parent,
1492 wxCoord x, wxCoord y, bool centre )
1493 {
1494 wxString str;
1495 long style = wxTextEntryDialogStyle;
1496
1497 if (centre)
1498 style |= wxCENTRE;
1499 else
1500 style &= ~wxCENTRE;
1501
1502 wxPasswordEntryDialog dialog(parent, message, caption, defaultValue,
1503 style, wxPoint(x, y));
1504 if ( dialog.ShowModal() == wxID_OK )
1505 {
1506 str = dialog.GetValue();
1507 }
1508
1509 return str;
1510 }
1511
1512 #endif // wxUSE_TEXTDLG
1513
1514 #if wxUSE_COLOURDLG
1515
1516 wxColour wxGetColourFromUser(wxWindow *parent,
1517 const wxColour& colInit,
1518 const wxString& caption,
1519 wxColourData *ptrData)
1520 {
1521 // contains serialized representation of wxColourData used the last time
1522 // the dialog was shown: we want to reuse it the next time in order to show
1523 // the same custom colours to the user (and we can't just have static
1524 // wxColourData itself because it's a GUI object and so should be destroyed
1525 // before GUI shutdown and doing it during static cleanup is too late)
1526 static wxString s_strColourData;
1527
1528 wxColourData data;
1529 if ( !ptrData )
1530 {
1531 ptrData = &data;
1532 if ( !s_strColourData.empty() )
1533 {
1534 if ( !data.FromString(s_strColourData) )
1535 {
1536 wxFAIL_MSG( "bug in wxColourData::FromString()?" );
1537 }
1538
1539 #ifdef __WXMSW__
1540 // we don't get back the "choose full" flag value from the native
1541 // dialog and so we can't preserve it between runs, so we decide to
1542 // always use it as it seems better than not using it (user can
1543 // just ignore the extra controls in the dialog but having to click
1544 // a button each time to show them would be very annoying
1545 data.SetChooseFull(true);
1546 #endif // __WXMSW__
1547 }
1548 }
1549
1550 if ( colInit.IsOk() )
1551 {
1552 ptrData->SetColour(colInit);
1553 }
1554
1555 wxColour colRet;
1556 wxColourDialog dialog(parent, ptrData);
1557 if (!caption.empty())
1558 dialog.SetTitle(caption);
1559 if ( dialog.ShowModal() == wxID_OK )
1560 {
1561 *ptrData = dialog.GetColourData();
1562 colRet = ptrData->GetColour();
1563 s_strColourData = ptrData->ToString();
1564 }
1565 //else: leave colRet invalid
1566
1567 return colRet;
1568 }
1569
1570 #endif // wxUSE_COLOURDLG
1571
1572 #if wxUSE_FONTDLG
1573
1574 wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit, const wxString& caption)
1575 {
1576 wxFontData data;
1577 if ( fontInit.Ok() )
1578 {
1579 data.SetInitialFont(fontInit);
1580 }
1581
1582 wxFont fontRet;
1583 wxFontDialog dialog(parent, data);
1584 if (!caption.empty())
1585 dialog.SetTitle(caption);
1586 if ( dialog.ShowModal() == wxID_OK )
1587 {
1588 fontRet = dialog.GetFontData().GetChosenFont();
1589 }
1590 //else: leave it invalid
1591
1592 return fontRet;
1593 }
1594
1595 #endif // wxUSE_FONTDLG
1596
1597 // ----------------------------------------------------------------------------
1598 // wxSafeYield and supporting functions
1599 // ----------------------------------------------------------------------------
1600
1601 void wxEnableTopLevelWindows(bool enable)
1602 {
1603 wxWindowList::compatibility_iterator node;
1604 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1605 node->GetData()->Enable(enable);
1606 }
1607
1608 wxWindowDisabler::wxWindowDisabler(bool disable)
1609 {
1610 m_disabled = disable;
1611 if ( disable )
1612 DoDisable();
1613 }
1614
1615 wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
1616 {
1617 m_disabled = true;
1618 DoDisable(winToSkip);
1619 }
1620
1621 void wxWindowDisabler::DoDisable(wxWindow *winToSkip)
1622 {
1623 // remember the top level windows which were already disabled, so that we
1624 // don't reenable them later
1625 m_winDisabled = NULL;
1626
1627 wxWindowList::compatibility_iterator node;
1628 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1629 {
1630 wxWindow *winTop = node->GetData();
1631 if ( winTop == winToSkip )
1632 continue;
1633
1634 // we don't need to disable the hidden or already disabled windows
1635 if ( winTop->IsEnabled() && winTop->IsShown() )
1636 {
1637 winTop->Disable();
1638 }
1639 else
1640 {
1641 if ( !m_winDisabled )
1642 {
1643 m_winDisabled = new wxWindowList;
1644 }
1645
1646 m_winDisabled->Append(winTop);
1647 }
1648 }
1649 }
1650
1651 wxWindowDisabler::~wxWindowDisabler()
1652 {
1653 if ( !m_disabled )
1654 return;
1655
1656 wxWindowList::compatibility_iterator node;
1657 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1658 {
1659 wxWindow *winTop = node->GetData();
1660 if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
1661 {
1662 winTop->Enable();
1663 }
1664 //else: had been already disabled, don't reenable
1665 }
1666
1667 delete m_winDisabled;
1668 }
1669
1670 // Yield to other apps/messages and disable user input to all windows except
1671 // the given one
1672 bool wxSafeYield(wxWindow *win, bool onlyIfNeeded)
1673 {
1674 wxWindowDisabler wd(win);
1675
1676 bool rc;
1677 if (onlyIfNeeded)
1678 rc = wxYieldIfNeeded();
1679 else
1680 rc = wxYield();
1681
1682 return rc;
1683 }
1684
1685 // ----------------------------------------------------------------------------
1686 // wxApp::Yield() wrappers for backwards compatibility
1687 // ----------------------------------------------------------------------------
1688
1689 bool wxYield()
1690 {
1691 return wxTheApp && wxTheApp->Yield();
1692 }
1693
1694 bool wxYieldIfNeeded()
1695 {
1696 return wxTheApp && wxTheApp->Yield(true);
1697 }
1698
1699 #endif // wxUSE_GUI
wxWidgets (Impactor)