projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
hook the docview-specific customization of event handling logic at TryValidator(...
[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 __WXMAC__
945 static const char * const OPEN_CMD = "/usr/bin/open";
946 if ( wxFileExists(OPEN_CMD) &&
947 wxExecute(wxString(OPEN_CMD) + " " + document) )
948 return true;
949 #elif defined(__UNIX__)
950 // Our best best is to use xdg-open from freedesktop.org cross-desktop
951 // compatibility suite xdg-utils
952 // (see http://portland.freedesktop.org/wiki/) -- this is installed on
953 // most modern distributions and may be tweaked by them to handle
954 // distribution specifics.
955 wxString path, xdg_open;
956 if ( wxGetEnv("PATH", &path) &&
957 wxFindFileInPath(&xdg_open, path, "xdg-open") )
958 {
959 if ( wxExecute(xdg_open + " " + document) )
960 return true;
961 }
962 #elif defined(__WXMSW__)
963 const INT_PTR result = (INT_PTR)::ShellExecute
964 (
965 NULL, // parent window
966 _T("open"),
967 document.wx_str(),
968 NULL, // parameters
969 NULL, // working directory
970 SW_SHOWDEFAULT
971 );
972 if ( result > 32 )
973 return true;
974 #endif
975
976 return false;
977 }
978
979 // ----------------------------------------------------------------------------
980 // Launch default browser
981 // ----------------------------------------------------------------------------
982
983 #ifdef __WXCOCOA__
984 // Private method in Objective-C++ source file.
985 bool wxCocoaLaunchDefaultBrowser(const wxString& url, int flags);
986 #endif
987
988 static bool DoLaunchDefaultBrowser(const wxString& urlOrig, int flags)
989 {
990 wxUnusedVar(flags);
991
992 // set the scheme of url to http if it does not have one
993 // RR: This doesn't work if the url is just a local path
994 wxString url(urlOrig);
995 wxURI uri(url);
996 if ( !uri.HasScheme() )
997 {
998 if (wxFileExists(urlOrig))
999 url.Prepend( wxT("file://") );
1000 else
1001 url.Prepend(wxT("http://"));
1002 }
1003
1004
1005 #if defined(__WXMSW__)
1006
1007 #if wxUSE_IPC
1008 if ( flags & wxBROWSER_NEW_WINDOW )
1009 {
1010 // ShellExecuteEx() opens the URL in an existing window by default so
1011 // we can't use it if we need a new window
1012 wxRegKey key(wxRegKey::HKCR, uri.GetScheme() + _T("\\shell\\open"));
1013 if ( !key.Exists() )
1014 {
1015 // try default browser, it must be registered at least for http URLs
1016 key.SetName(wxRegKey::HKCR, _T("http\\shell\\open"));
1017 }
1018
1019 if ( key.Exists() )
1020 {
1021 wxRegKey keyDDE(key, wxT("DDEExec"));
1022 if ( keyDDE.Exists() )
1023 {
1024 // we only know the syntax of WWW_OpenURL DDE request for IE,
1025 // optimistically assume that all other browsers are compatible
1026 // with it
1027 static const wxChar *TOPIC_OPEN_URL = wxT("WWW_OpenURL");
1028 wxString ddeCmd;
1029 wxRegKey keyTopic(keyDDE, wxT("topic"));
1030 bool ok = keyTopic.Exists() && keyTopic == TOPIC_OPEN_URL;
1031 if ( ok )
1032 {
1033 ddeCmd = keyDDE.QueryDefaultValue();
1034 ok = !ddeCmd.empty();
1035 }
1036
1037 if ( ok )
1038 {
1039 // for WWW_OpenURL, the index of the window to open the URL
1040 // in is -1 (meaning "current") by default, replace it with
1041 // 0 which means "new" (see KB article 160957)
1042 ok = ddeCmd.Replace(wxT("-1"), wxT("0"),
1043 false /* only first occurence */) == 1;
1044 }
1045
1046 if ( ok )
1047 {
1048 // and also replace the parameters: the topic should
1049 // contain a placeholder for the URL
1050 ok = ddeCmd.Replace(wxT("%1"), url, false) == 1;
1051 }
1052
1053 if ( ok )
1054 {
1055 // try to send it the DDE request now but ignore the errors
1056 wxLogNull noLog;
1057
1058 const wxString ddeServer = wxRegKey(keyDDE, wxT("application"));
1059 if ( wxExecuteDDE(ddeServer, TOPIC_OPEN_URL, ddeCmd) )
1060 return true;
1061
1062 // this is not necessarily an error: maybe browser is
1063 // simply not running, but no matter, in any case we're
1064 // going to launch it using ShellExecuteEx() below now and
1065 // we shouldn't try to open a new window if we open a new
1066 // browser anyhow
1067 }
1068 }
1069 }
1070 }
1071 #endif // wxUSE_IPC
1072
1073 WinStruct<SHELLEXECUTEINFO> sei;
1074 sei.lpFile = url.c_str();
1075 sei.lpVerb = _T("open");
1076 sei.nShow = SW_SHOWNORMAL;
1077 sei.fMask = SEE_MASK_FLAG_NO_UI; // we give error message ourselves
1078
1079 ::ShellExecuteEx(&sei);
1080
1081 const INT_PTR nResult = (INT_PTR)sei.hInstApp;
1082
1083 // Firefox returns file not found for some reason, so make an exception
1084 // for it
1085 if ( nResult > 32 || nResult == SE_ERR_FNF )
1086 {
1087 #ifdef __WXDEBUG__
1088 // Log something if SE_ERR_FNF happens
1089 if ( nResult == SE_ERR_FNF )
1090 wxLogDebug(wxT("SE_ERR_FNF from ShellExecute -- maybe FireFox?"));
1091 #endif // __WXDEBUG__
1092 return true;
1093 }
1094 #elif defined(__WXCOCOA__)
1095 // NOTE: We need to call the real implementation from src/cocoa/utils.mm
1096 // because the code must use Objective-C features.
1097 return wxCocoaLaunchDefaultBrowser(url, flags);
1098 #elif defined(__WXMAC__) && !defined(__WXOSX_IPHONE__)
1099 wxCFRef< CFURLRef > curl( CFURLCreateWithString( kCFAllocatorDefault,
1100 wxCFStringRef( url ), NULL ) );
1101 OSStatus err = LSOpenCFURLRef( curl , NULL );
1102
1103 if (err == noErr)
1104 {
1105 return true;
1106 }
1107 else
1108 {
1109 wxLogDebug(wxT("Browser Launch error %d"), (int) err);
1110 return false;
1111 }
1112 #else
1113 // (non-Mac, non-MSW)
1114
1115 #ifdef __UNIX__
1116
1117 // Our best best is to use xdg-open from freedesktop.org cross-desktop
1118 // compatibility suite xdg-utils
1119 // (see http://portland.freedesktop.org/wiki/) -- this is installed on
1120 // most modern distributions and may be tweaked by them to handle
1121 // distribution specifics. Only if that fails, try to find the right
1122 // browser ourselves.
1123 wxString path, xdg_open;
1124 if ( wxGetEnv("PATH", &path) &&
1125 wxFindFileInPath(&xdg_open, path, "xdg-open") )
1126 {
1127 if ( wxExecute(xdg_open + " " + url) )
1128 return true;
1129 }
1130
1131 wxString desktop = wxTheApp->GetTraits()->GetDesktopEnvironment();
1132
1133 // GNOME and KDE desktops have some applications which should be always installed
1134 // together with their main parts, which give us the
1135 if (desktop == wxT("GNOME"))
1136 {
1137 wxArrayString errors;
1138 wxArrayString output;
1139
1140 // gconf will tell us the path of the application to use as browser
1141 long res = wxExecute( wxT("gconftool-2 --get /desktop/gnome/applications/browser/exec"),
1142 output, errors, wxEXEC_NODISABLE );
1143 if (res >= 0 && errors.GetCount() == 0)
1144 {
1145 wxString cmd = output[0];
1146 cmd << _T(' ') << url;
1147 if (wxExecute(cmd))
1148 return true;
1149 }
1150 }
1151 else if (desktop == wxT("KDE"))
1152 {
1153 // kfmclient directly opens the given URL
1154 if (wxExecute(wxT("kfmclient openURL ") + url))
1155 return true;
1156 }
1157 #endif
1158
1159 bool ok = false;
1160 wxString cmd;
1161
1162 #if wxUSE_MIMETYPE
1163 wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(_T("html"));
1164 if ( ft )
1165 {
1166 wxString mt;
1167 ft->GetMimeType(&mt);
1168
1169 ok = ft->GetOpenCommand(&cmd, wxFileType::MessageParameters(url));
1170 delete ft;
1171 }
1172 #endif // wxUSE_MIMETYPE
1173
1174 if ( !ok || cmd.empty() )
1175 {
1176 // fallback to checking for the BROWSER environment variable
1177 cmd = wxGetenv(wxT("BROWSER"));
1178 if ( !cmd.empty() )
1179 cmd << _T(' ') << url;
1180 }
1181
1182 ok = ( !cmd.empty() && wxExecute(cmd) );
1183 if (ok)
1184 return ok;
1185
1186 // no file type for HTML extension
1187 wxLogError(_("No default application configured for HTML files."));
1188
1189 #endif // !wxUSE_MIMETYPE && !__WXMSW__
1190
1191 wxLogSysError(_("Failed to open URL \"%s\" in default browser."),
1192 url.c_str());
1193
1194 return false;
1195 }
1196
1197 bool wxLaunchDefaultBrowser(const wxString& url, int flags)
1198 {
1199 if ( flags & wxBROWSER_NOBUSYCURSOR )
1200 return DoLaunchDefaultBrowser(url, flags);
1201
1202 wxBusyCursor bc;
1203 return DoLaunchDefaultBrowser(url, flags);
1204 }
1205
1206 // ----------------------------------------------------------------------------
1207 // Menu accelerators related functions
1208 // ----------------------------------------------------------------------------
1209
1210 wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
1211 {
1212 #if wxUSE_MENUS
1213 wxString s = wxMenuItem::GetLabelText(in);
1214 #else
1215 wxString str(in);
1216 wxString s = wxStripMenuCodes(str);
1217 #endif // wxUSE_MENUS
1218 if ( out )
1219 {
1220 // go smash their buffer if it's not big enough - I love char * params
1221 memcpy(out, s.c_str(), s.length() * sizeof(wxChar));
1222 }
1223 else
1224 {
1225 out = new wxChar[s.length() + 1];
1226 wxStrcpy(out, s.c_str());
1227 }
1228
1229 return out;
1230 }
1231
1232 wxString wxStripMenuCodes(const wxString& in, int flags)
1233 {
1234 wxASSERT_MSG( flags, _T("this is useless to call without any flags") );
1235
1236 wxString out;
1237
1238 size_t len = in.length();
1239 out.reserve(len);
1240
1241 for ( size_t n = 0; n < len; n++ )
1242 {
1243 wxChar ch = in[n];
1244 if ( (flags & wxStrip_Mnemonics) && ch == _T('&') )
1245 {
1246 // skip it, it is used to introduce the accel char (or to quote
1247 // itself in which case it should still be skipped): note that it
1248 // can't be the last character of the string
1249 if ( ++n == len )
1250 {
1251 wxLogDebug(_T("Invalid menu string '%s'"), in.c_str());
1252 }
1253 else
1254 {
1255 // use the next char instead
1256 ch = in[n];
1257 }
1258 }
1259 else if ( (flags & wxStrip_Accel) && ch == _T('\t') )
1260 {
1261 // everything after TAB is accel string, exit the loop
1262 break;
1263 }
1264
1265 out += ch;
1266 }
1267
1268 return out;
1269 }
1270
1271 // ----------------------------------------------------------------------------
1272 // Window search functions
1273 // ----------------------------------------------------------------------------
1274
1275 /*
1276 * If parent is non-NULL, look through children for a label or title
1277 * matching the specified string. If NULL, look through all top-level windows.
1278 *
1279 */
1280
1281 wxWindow *
1282 wxFindWindowByLabel (const wxString& title, wxWindow * parent)
1283 {
1284 return wxWindow::FindWindowByLabel( title, parent );
1285 }
1286
1287
1288 /*
1289 * If parent is non-NULL, look through children for a name
1290 * matching the specified string. If NULL, look through all top-level windows.
1291 *
1292 */
1293
1294 wxWindow *
1295 wxFindWindowByName (const wxString& name, wxWindow * parent)
1296 {
1297 return wxWindow::FindWindowByName( name, parent );
1298 }
1299
1300 // Returns menu item id or wxNOT_FOUND if none.
1301 int
1302 wxFindMenuItemId(wxFrame *frame,
1303 const wxString& menuString,
1304 const wxString& itemString)
1305 {
1306 #if wxUSE_MENUS
1307 wxMenuBar *menuBar = frame->GetMenuBar ();
1308 if ( menuBar )
1309 return menuBar->FindMenuItem (menuString, itemString);
1310 #else // !wxUSE_MENUS
1311 wxUnusedVar(frame);
1312 wxUnusedVar(menuString);
1313 wxUnusedVar(itemString);
1314 #endif // wxUSE_MENUS/!wxUSE_MENUS
1315
1316 return wxNOT_FOUND;
1317 }
1318
1319 // Try to find the deepest child that contains 'pt'.
1320 // We go backwards, to try to allow for controls that are spacially
1321 // within other controls, but are still siblings (e.g. buttons within
1322 // static boxes). Static boxes are likely to be created _before_ controls
1323 // that sit inside them.
1324 wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt)
1325 {
1326 if (!win->IsShown())
1327 return NULL;
1328
1329 // Hack for wxNotebook case: at least in wxGTK, all pages
1330 // claim to be shown, so we must only deal with the selected one.
1331 #if wxUSE_NOTEBOOK
1332 if (win->IsKindOf(CLASSINFO(wxNotebook)))
1333 {
1334 wxNotebook* nb = (wxNotebook*) win;
1335 int sel = nb->GetSelection();
1336 if (sel >= 0)
1337 {
1338 wxWindow* child = nb->GetPage(sel);
1339 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1340 if (foundWin)
1341 return foundWin;
1342 }
1343 }
1344 #endif
1345
1346 wxWindowList::compatibility_iterator node = win->GetChildren().GetLast();
1347 while (node)
1348 {
1349 wxWindow* child = node->GetData();
1350 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1351 if (foundWin)
1352 return foundWin;
1353 node = node->GetPrevious();
1354 }
1355
1356 wxPoint pos = win->GetPosition();
1357 wxSize sz = win->GetSize();
1358 if ( !win->IsTopLevel() && win->GetParent() )
1359 {
1360 pos = win->GetParent()->ClientToScreen(pos);
1361 }
1362
1363 wxRect rect(pos, sz);
1364 if (rect.Contains(pt))
1365 return win;
1366
1367 return NULL;
1368 }
1369
1370 wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt)
1371 {
1372 // Go backwards through the list since windows
1373 // on top are likely to have been appended most
1374 // recently.
1375 wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast();
1376 while (node)
1377 {
1378 wxWindow* win = node->GetData();
1379 wxWindow* found = wxFindWindowAtPoint(win, pt);
1380 if (found)
1381 return found;
1382 node = node->GetPrevious();
1383 }
1384 return NULL;
1385 }
1386
1387 // ----------------------------------------------------------------------------
1388 // GUI helpers
1389 // ----------------------------------------------------------------------------
1390
1391 /*
1392 * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
1393 * since otherwise the generic code may be pulled in unnecessarily.
1394 */
1395
1396 #if wxUSE_MSGDLG
1397
1398 int wxMessageBox(const wxString& message, const wxString& caption, long style,
1399 wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
1400 {
1401 long decorated_style = style;
1402
1403 if ( ( style & ( wxICON_EXCLAMATION | wxICON_HAND | wxICON_INFORMATION | wxICON_QUESTION ) ) == 0 )
1404 {
1405 decorated_style |= ( style & wxYES ) ? wxICON_QUESTION : wxICON_INFORMATION ;
1406 }
1407
1408 wxMessageDialog dialog(parent, message, caption, decorated_style);
1409
1410 int ans = dialog.ShowModal();
1411 switch ( ans )
1412 {
1413 case wxID_OK:
1414 return wxOK;
1415 case wxID_YES:
1416 return wxYES;
1417 case wxID_NO:
1418 return wxNO;
1419 case wxID_CANCEL:
1420 return wxCANCEL;
1421 }
1422
1423 wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") );
1424
1425 return wxCANCEL;
1426 }
1427
1428 void wxInfoMessageBox(wxWindow* parent)
1429 {
1430 // don't translate these strings, they're for diagnostics purposes only
1431 wxString msg;
1432 msg.Printf(_T("wxWidgets Library (%s port)\n")
1433 _T("Version %d.%d.%d%s%s, compiled at %s %s\n")
1434 _T("Runtime version of toolkit used is %d.%d.%s\n")
1435 _T("Copyright (c) 1995-2008 wxWidgets team"),
1436 wxPlatformInfo::Get().GetPortIdName().c_str(),
1437 wxMAJOR_VERSION,
1438 wxMINOR_VERSION,
1439 wxRELEASE_NUMBER,
1440 #if wxUSE_UNICODE
1441 L" (Unicode)",
1442 #else
1443 wxEmptyString,
1444 #endif
1445 #ifdef __WXDEBUG__
1446 _T(" Debug build"),
1447 #else
1448 wxEmptyString,
1449 #endif
1450 __TDATE__,
1451 __TTIME__,
1452 wxPlatformInfo::Get().GetToolkitMajorVersion(),
1453 wxPlatformInfo::Get().GetToolkitMinorVersion(),
1454 #ifdef __WXGTK__
1455 wxString::Format("\nThe compile-time GTK+ version is %d.%d.%d.",
1456 GTK_MAJOR_VERSION,
1457 GTK_MINOR_VERSION,
1458 GTK_MICRO_VERSION).c_str()
1459 #else
1460 wxEmptyString
1461 #endif
1462 );
1463 wxMessageBox(msg, _T("wxWidgets information"),
1464 wxICON_INFORMATION | wxOK,
1465 parent);
1466 }
1467
1468 #endif // wxUSE_MSGDLG
1469
1470 #if wxUSE_TEXTDLG
1471
1472 wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
1473 const wxString& defaultValue, wxWindow *parent,
1474 wxCoord x, wxCoord y, bool centre )
1475 {
1476 wxString str;
1477 long style = wxTextEntryDialogStyle;
1478
1479 if (centre)
1480 style |= wxCENTRE;
1481 else
1482 style &= ~wxCENTRE;
1483
1484 wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y));
1485
1486 if (dialog.ShowModal() == wxID_OK)
1487 {
1488 str = dialog.GetValue();
1489 }
1490
1491 return str;
1492 }
1493
1494 wxString wxGetPasswordFromUser(const wxString& message,
1495 const wxString& caption,
1496 const wxString& defaultValue,
1497 wxWindow *parent,
1498 wxCoord x, wxCoord y, bool centre )
1499 {
1500 wxString str;
1501 long style = wxTextEntryDialogStyle;
1502
1503 if (centre)
1504 style |= wxCENTRE;
1505 else
1506 style &= ~wxCENTRE;
1507
1508 wxPasswordEntryDialog dialog(parent, message, caption, defaultValue,
1509 style, wxPoint(x, y));
1510 if ( dialog.ShowModal() == wxID_OK )
1511 {
1512 str = dialog.GetValue();
1513 }
1514
1515 return str;
1516 }
1517
1518 #endif // wxUSE_TEXTDLG
1519
1520 #if wxUSE_COLOURDLG
1521
1522 wxColour wxGetColourFromUser(wxWindow *parent,
1523 const wxColour& colInit,
1524 const wxString& caption,
1525 wxColourData *ptrData)
1526 {
1527 // contains serialized representation of wxColourData used the last time
1528 // the dialog was shown: we want to reuse it the next time in order to show
1529 // the same custom colours to the user (and we can't just have static
1530 // wxColourData itself because it's a GUI object and so should be destroyed
1531 // before GUI shutdown and doing it during static cleanup is too late)
1532 static wxString s_strColourData;
1533
1534 wxColourData data;
1535 if ( !ptrData )
1536 {
1537 ptrData = &data;
1538 if ( !s_strColourData.empty() )
1539 {
1540 if ( !data.FromString(s_strColourData) )
1541 {
1542 wxFAIL_MSG( "bug in wxColourData::FromString()?" );
1543 }
1544
1545 #ifdef __WXMSW__
1546 // we don't get back the "choose full" flag value from the native
1547 // dialog and so we can't preserve it between runs, so we decide to
1548 // always use it as it seems better than not using it (user can
1549 // just ignore the extra controls in the dialog but having to click
1550 // a button each time to show them would be very annoying
1551 data.SetChooseFull(true);
1552 #endif // __WXMSW__
1553 }
1554 }
1555
1556 if ( colInit.IsOk() )
1557 {
1558 ptrData->SetColour(colInit);
1559 }
1560
1561 wxColour colRet;
1562 wxColourDialog dialog(parent, ptrData);
1563 if (!caption.empty())
1564 dialog.SetTitle(caption);
1565 if ( dialog.ShowModal() == wxID_OK )
1566 {
1567 *ptrData = dialog.GetColourData();
1568 colRet = ptrData->GetColour();
1569 s_strColourData = ptrData->ToString();
1570 }
1571 //else: leave colRet invalid
1572
1573 return colRet;
1574 }
1575
1576 #endif // wxUSE_COLOURDLG
1577
1578 #if wxUSE_FONTDLG
1579
1580 wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit, const wxString& caption)
1581 {
1582 wxFontData data;
1583 if ( fontInit.Ok() )
1584 {
1585 data.SetInitialFont(fontInit);
1586 }
1587
1588 wxFont fontRet;
1589 wxFontDialog dialog(parent, data);
1590 if (!caption.empty())
1591 dialog.SetTitle(caption);
1592 if ( dialog.ShowModal() == wxID_OK )
1593 {
1594 fontRet = dialog.GetFontData().GetChosenFont();
1595 }
1596 //else: leave it invalid
1597
1598 return fontRet;
1599 }
1600
1601 #endif // wxUSE_FONTDLG
1602
1603 // ----------------------------------------------------------------------------
1604 // wxSafeYield and supporting functions
1605 // ----------------------------------------------------------------------------
1606
1607 void wxEnableTopLevelWindows(bool enable)
1608 {
1609 wxWindowList::compatibility_iterator node;
1610 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1611 node->GetData()->Enable(enable);
1612 }
1613
1614 wxWindowDisabler::wxWindowDisabler(bool disable)
1615 {
1616 m_disabled = disable;
1617 if ( disable )
1618 DoDisable();
1619 }
1620
1621 wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
1622 {
1623 m_disabled = true;
1624 DoDisable(winToSkip);
1625 }
1626
1627 void wxWindowDisabler::DoDisable(wxWindow *winToSkip)
1628 {
1629 // remember the top level windows which were already disabled, so that we
1630 // don't reenable them later
1631 m_winDisabled = NULL;
1632
1633 wxWindowList::compatibility_iterator node;
1634 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1635 {
1636 wxWindow *winTop = node->GetData();
1637 if ( winTop == winToSkip )
1638 continue;
1639
1640 // we don't need to disable the hidden or already disabled windows
1641 if ( winTop->IsEnabled() && winTop->IsShown() )
1642 {
1643 winTop->Disable();
1644 }
1645 else
1646 {
1647 if ( !m_winDisabled )
1648 {
1649 m_winDisabled = new wxWindowList;
1650 }
1651
1652 m_winDisabled->Append(winTop);
1653 }
1654 }
1655 }
1656
1657 wxWindowDisabler::~wxWindowDisabler()
1658 {
1659 if ( !m_disabled )
1660 return;
1661
1662 wxWindowList::compatibility_iterator node;
1663 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1664 {
1665 wxWindow *winTop = node->GetData();
1666 if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
1667 {
1668 winTop->Enable();
1669 }
1670 //else: had been already disabled, don't reenable
1671 }
1672
1673 delete m_winDisabled;
1674 }
1675
1676 // Yield to other apps/messages and disable user input to all windows except
1677 // the given one
1678 bool wxSafeYield(wxWindow *win, bool onlyIfNeeded)
1679 {
1680 wxWindowDisabler wd(win);
1681
1682 bool rc;
1683 if (onlyIfNeeded)
1684 rc = wxYieldIfNeeded();
1685 else
1686 rc = wxYield();
1687
1688 return rc;
1689 }
1690
1691 // Don't synthesize KeyUp events holding down a key and producing KeyDown
1692 // events with autorepeat. On by default and always on in wxMSW. wxGTK version
1693 // in utilsgtk.cpp.
1694 #ifndef __WXGTK__
1695 bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
1696 {
1697 return true; // detectable auto-repeat is the only mode MSW supports
1698 }
1699 #endif // !wxGTK
1700
1701 #endif // wxUSE_GUI
wxWidgets (Impactor)