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