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