]> git.saurik.com Git - wxWidgets.git/blob - src/common/utilscmn.cpp
added init.cpp
[wxWidgets.git] / src / common / utilscmn.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: 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 #ifdef __GNUG__
21 #pragma implementation "utils.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #ifndef WX_PRECOMP
32 #include "wx/app.h"
33 #include "wx/string.h"
34 #include "wx/utils.h"
35 #include "wx/intl.h"
36 #include "wx/log.h"
37
38 #if wxUSE_GUI
39 #include "wx/window.h"
40 #include "wx/frame.h"
41 #include "wx/menu.h"
42 #include "wx/msgdlg.h"
43 #include "wx/textdlg.h"
44 #include "wx/textctrl.h" // for wxTE_PASSWORD
45 #if wxUSE_ACCEL
46 #include "wx/menuitem.h"
47 #include "wx/accel.h"
48 #endif // wxUSE_ACCEL
49 #endif // wxUSE_GUI
50 #endif // WX_PRECOMP
51
52 #include "wx/apptrait.h"
53
54 #include "wx/process.h"
55 #include "wx/txtstrm.h"
56
57 #include <ctype.h>
58 #include <stdio.h>
59 #include <stdlib.h>
60 #include <string.h>
61
62 #if !defined(__WATCOMC__)
63 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
64 #include <errno.h>
65 #endif
66 #endif
67
68 #if wxUSE_GUI
69 #include "wx/colordlg.h"
70 #include "wx/fontdlg.h"
71 #include "wx/notebook.h"
72 #include "wx/frame.h"
73 #include "wx/statusbr.h"
74 #endif // wxUSE_GUI
75
76 #include <time.h>
77
78 #ifndef __MWERKS__
79 #include <sys/types.h>
80 #include <sys/stat.h>
81 #endif
82
83 #ifdef __SALFORDC__
84 #include <clib.h>
85 #endif
86
87 #ifdef __WXMSW__
88 #include "wx/msw/private.h"
89 #endif
90
91 #if wxUSE_BASE
92
93 // ----------------------------------------------------------------------------
94 // common data
95 // ----------------------------------------------------------------------------
96
97 #if WXWIN_COMPATIBILITY_2_2
98 const wxChar *wxInternalErrorStr = wxT("wxWindows Internal Error");
99 const wxChar *wxFatalErrorStr = wxT("wxWindows Fatal Error");
100 #endif // WXWIN_COMPATIBILITY_2_2
101
102 // ============================================================================
103 // implementation
104 // ============================================================================
105
106 #if WXWIN_COMPATIBILITY_2_4
107
108 wxChar *
109 copystring (const wxChar *s)
110 {
111 if (s == NULL) s = wxT("");
112 size_t len = wxStrlen (s) + 1;
113
114 wxChar *news = new wxChar[len];
115 memcpy (news, s, len * sizeof(wxChar)); // Should be the fastest
116
117 return news;
118 }
119
120 #endif // WXWIN_COMPATIBILITY_2_4
121
122 // Id generation
123 static long wxCurrentId = 100;
124
125 long
126 wxNewId (void)
127 {
128 return wxCurrentId++;
129 }
130
131 long
132 wxGetCurrentId(void) { return wxCurrentId; }
133
134 void
135 wxRegisterId (long id)
136 {
137 if (id >= wxCurrentId)
138 wxCurrentId = id + 1;
139 }
140
141 // ----------------------------------------------------------------------------
142 // String <-> Number conversions (deprecated)
143 // ----------------------------------------------------------------------------
144
145 #if WXWIN_COMPATIBILITY_2_4
146
147 WXDLLEXPORT_DATA(const wxChar *) wxFloatToStringStr = wxT("%.2f");
148 WXDLLEXPORT_DATA(const wxChar *) wxDoubleToStringStr = wxT("%.2f");
149
150 void
151 StringToFloat (const wxChar *s, float *number)
152 {
153 if (s && *s && number)
154 *number = (float) wxStrtod (s, (wxChar **) NULL);
155 }
156
157 void
158 StringToDouble (const wxChar *s, double *number)
159 {
160 if (s && *s && number)
161 *number = wxStrtod (s, (wxChar **) NULL);
162 }
163
164 wxChar *
165 FloatToString (float number, const wxChar *fmt)
166 {
167 static wxChar buf[256];
168
169 wxSprintf (buf, fmt, number);
170 return buf;
171 }
172
173 wxChar *
174 DoubleToString (double number, const wxChar *fmt)
175 {
176 static wxChar buf[256];
177
178 wxSprintf (buf, fmt, number);
179 return buf;
180 }
181
182 void
183 StringToInt (const wxChar *s, int *number)
184 {
185 if (s && *s && number)
186 *number = (int) wxStrtol (s, (wxChar **) NULL, 10);
187 }
188
189 void
190 StringToLong (const wxChar *s, long *number)
191 {
192 if (s && *s && number)
193 *number = wxStrtol (s, (wxChar **) NULL, 10);
194 }
195
196 wxChar *
197 IntToString (int number)
198 {
199 static wxChar buf[20];
200
201 wxSprintf (buf, wxT("%d"), number);
202 return buf;
203 }
204
205 wxChar *
206 LongToString (long number)
207 {
208 static wxChar buf[20];
209
210 wxSprintf (buf, wxT("%ld"), number);
211 return buf;
212 }
213
214 #endif // WXWIN_COMPATIBILITY_2_4
215
216 // Array used in DecToHex conversion routine.
217 static wxChar hexArray[] = wxT("0123456789ABCDEF");
218
219 // Convert 2-digit hex number to decimal
220 int wxHexToDec(const wxString& buf)
221 {
222 int firstDigit, secondDigit;
223
224 if (buf.GetChar(0) >= wxT('A'))
225 firstDigit = buf.GetChar(0) - wxT('A') + 10;
226 else
227 firstDigit = buf.GetChar(0) - wxT('0');
228
229 if (buf.GetChar(1) >= wxT('A'))
230 secondDigit = buf.GetChar(1) - wxT('A') + 10;
231 else
232 secondDigit = buf.GetChar(1) - wxT('0');
233
234 return (firstDigit & 0xF) * 16 + (secondDigit & 0xF );
235 }
236
237 // Convert decimal integer to 2-character hex string
238 void wxDecToHex(int dec, wxChar *buf)
239 {
240 int firstDigit = (int)(dec/16.0);
241 int secondDigit = (int)(dec - (firstDigit*16.0));
242 buf[0] = hexArray[firstDigit];
243 buf[1] = hexArray[secondDigit];
244 buf[2] = 0;
245 }
246
247 // Convert decimal integer to 2-character hex string
248 wxString wxDecToHex(int dec)
249 {
250 wxChar buf[3];
251 wxDecToHex(dec, buf);
252 return wxString(buf);
253 }
254
255 // ----------------------------------------------------------------------------
256 // misc functions
257 // ----------------------------------------------------------------------------
258
259 // Return the current date/time
260 wxString wxNow()
261 {
262 time_t now = time((time_t *) NULL);
263 char *date = ctime(&now);
264 date[24] = '\0';
265 return wxString::FromAscii(date);
266 }
267
268 const wxChar *wxGetInstallPrefix()
269 {
270 wxString prefix;
271
272 if ( wxGetEnv(wxT("WXPREFIX"), &prefix) )
273 return prefix.c_str();
274
275 #ifdef wxINSTALL_PREFIX
276 return wxT(wxINSTALL_PREFIX);
277 #else
278 return wxT("");
279 #endif
280 }
281
282 wxString wxGetDataDir()
283 {
284 wxString format = wxGetInstallPrefix();
285 format << wxFILE_SEP_PATH
286 << wxT("share") << wxFILE_SEP_PATH
287 << wxT("wx") << wxFILE_SEP_PATH
288 << wxT("%i.%i");
289 wxString dir;
290 dir.Printf(format.c_str(), wxMAJOR_VERSION, wxMINOR_VERSION);
291 return dir;
292 }
293
294 int wxGetOsVersion(int *verMaj, int *verMin)
295 {
296 // we want this function to work even if there is no wxApp
297 wxConsoleAppTraits traitsConsole;
298 wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
299 if ( ! traits )
300 traits = &traitsConsole;
301
302 return traits->GetOSVersion(verMaj, verMin);
303 }
304
305 // ----------------------------------------------------------------------------
306 // network and user id functions
307 // ----------------------------------------------------------------------------
308
309 // Get Full RFC822 style email address
310 bool wxGetEmailAddress(wxChar *address, int maxSize)
311 {
312 wxString email = wxGetEmailAddress();
313 if ( !email )
314 return FALSE;
315
316 wxStrncpy(address, email, maxSize - 1);
317 address[maxSize - 1] = wxT('\0');
318
319 return TRUE;
320 }
321
322 wxString wxGetEmailAddress()
323 {
324 wxString email;
325
326 wxString host = wxGetFullHostName();
327 if ( !!host )
328 {
329 wxString user = wxGetUserId();
330 if ( !!user )
331 {
332 email << user << wxT('@') << host;
333 }
334 }
335
336 return email;
337 }
338
339 wxString wxGetUserId()
340 {
341 static const int maxLoginLen = 256; // FIXME arbitrary number
342
343 wxString buf;
344 bool ok = wxGetUserId(buf.GetWriteBuf(maxLoginLen), maxLoginLen);
345 buf.UngetWriteBuf();
346
347 if ( !ok )
348 buf.Empty();
349
350 return buf;
351 }
352
353 wxString wxGetUserName()
354 {
355 static const int maxUserNameLen = 1024; // FIXME arbitrary number
356
357 wxString buf;
358 bool ok = wxGetUserName(buf.GetWriteBuf(maxUserNameLen), maxUserNameLen);
359 buf.UngetWriteBuf();
360
361 if ( !ok )
362 buf.Empty();
363
364 return buf;
365 }
366
367 wxString wxGetHostName()
368 {
369 static const size_t hostnameSize = 257;
370
371 wxString buf;
372 bool ok = wxGetHostName(buf.GetWriteBuf(hostnameSize), hostnameSize);
373
374 buf.UngetWriteBuf();
375
376 if ( !ok )
377 buf.Empty();
378
379 return buf;
380 }
381
382 wxString wxGetFullHostName()
383 {
384 static const size_t hostnameSize = 257;
385
386 wxString buf;
387 bool ok = wxGetFullHostName(buf.GetWriteBuf(hostnameSize), hostnameSize);
388
389 buf.UngetWriteBuf();
390
391 if ( !ok )
392 buf.Empty();
393
394 return buf;
395 }
396
397 wxString wxGetHomeDir()
398 {
399 wxString home;
400 wxGetHomeDir(&home);
401
402 return home;
403 }
404
405 #if 0
406
407 wxString wxGetCurrentDir()
408 {
409 wxString dir;
410 size_t len = 1024;
411 bool ok;
412 do
413 {
414 ok = getcwd(dir.GetWriteBuf(len + 1), len) != NULL;
415 dir.UngetWriteBuf();
416
417 if ( !ok )
418 {
419 if ( errno != ERANGE )
420 {
421 wxLogSysError(_T("Failed to get current directory"));
422
423 return wxEmptyString;
424 }
425 else
426 {
427 // buffer was too small, retry with a larger one
428 len *= 2;
429 }
430 }
431 //else: ok
432 } while ( !ok );
433
434 return dir;
435 }
436
437 #endif // 0
438
439 // ----------------------------------------------------------------------------
440 // wxExecute
441 // ----------------------------------------------------------------------------
442
443 // wxDoExecuteWithCapture() helper: reads an entire stream into one array
444 //
445 // returns TRUE if ok, FALSE if error
446 #if wxUSE_STREAMS
447 static bool ReadAll(wxInputStream *is, wxArrayString& output)
448 {
449 wxCHECK_MSG( is, FALSE, _T("NULL stream in wxExecute()?") );
450
451 // the stream could be already at EOF or in wxSTREAM_BROKEN_PIPE state
452 is->Reset();
453
454 wxTextInputStream tis(*is);
455
456 bool cont = TRUE;
457 while ( cont )
458 {
459 wxString line = tis.ReadLine();
460 if ( is->Eof() )
461 break;
462
463 if ( !*is )
464 {
465 cont = FALSE;
466 }
467 else
468 {
469 output.Add(line);
470 }
471 }
472
473 return cont;
474 }
475 #endif // wxUSE_STREAMS
476
477 // this is a private function because it hasn't a clean interface: the first
478 // array is passed by reference, the second by pointer - instead we have 2
479 // public versions of wxExecute() below
480 static long wxDoExecuteWithCapture(const wxString& command,
481 wxArrayString& output,
482 wxArrayString* error)
483 {
484 // create a wxProcess which will capture the output
485 wxProcess *process = new wxProcess;
486 process->Redirect();
487
488 long rc = wxExecute(command, wxEXEC_SYNC, process);
489
490 #if wxUSE_STREAMS
491 if ( rc != -1 )
492 {
493 if ( !ReadAll(process->GetInputStream(), output) )
494 rc = -1;
495
496 if ( error )
497 {
498 if ( !ReadAll(process->GetErrorStream(), *error) )
499 rc = -1;
500 }
501
502 }
503 #endif // wxUSE_STREAMS
504
505 delete process;
506
507 return rc;
508 }
509
510 long wxExecute(const wxString& command, wxArrayString& output)
511 {
512 return wxDoExecuteWithCapture(command, output, NULL);
513 }
514
515 long wxExecute(const wxString& command,
516 wxArrayString& output,
517 wxArrayString& error)
518 {
519 return wxDoExecuteWithCapture(command, output, &error);
520 }
521
522 // ----------------------------------------------------------------------------
523 // wxApp::Yield() wrappers for backwards compatibility
524 // ----------------------------------------------------------------------------
525
526 bool wxYield()
527 {
528 return wxTheApp && wxTheApp->Yield();
529 }
530
531 bool wxYieldIfNeeded()
532 {
533 return wxTheApp && wxTheApp->Yield(TRUE);
534 }
535
536 #endif // wxUSE_BASE
537
538 // ============================================================================
539 // GUI-only functions from now on
540 // ============================================================================
541
542 #if wxUSE_GUI
543
544 #if wxUSE_MENUS
545
546 // ----------------------------------------------------------------------------
547 // Menu accelerators related functions
548 // ----------------------------------------------------------------------------
549
550 wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
551 {
552 wxString s = wxMenuItem::GetLabelFromText(in);
553 if ( out )
554 {
555 // go smash their buffer if it's not big enough - I love char * params
556 memcpy(out, s.c_str(), s.length() * sizeof(wxChar));
557 }
558 else
559 {
560 out = copystring(s);
561 }
562
563 return out;
564 }
565
566 wxString wxStripMenuCodes(const wxString& in)
567 {
568 wxString out;
569
570 size_t len = in.length();
571 out.reserve(len);
572
573 for ( size_t n = 0; n < len; n++ )
574 {
575 wxChar ch = in[n];
576 if ( ch == _T('&') )
577 {
578 // skip it, it is used to introduce the accel char (or to quote
579 // itself in which case it should still be skipped): note that it
580 // can't be the last character of the string
581 if ( ++n == len )
582 {
583 wxLogDebug(_T("Invalid menu string '%s'"), in.c_str());
584 }
585 else
586 {
587 // use the next char instead
588 ch = in[n];
589 }
590 }
591 else if ( ch == _T('\t') )
592 {
593 // everything after TAB is accel string, exit the loop
594 break;
595 }
596
597 out += ch;
598 }
599
600 return out;
601 }
602
603 #endif // wxUSE_MENUS
604
605 // ----------------------------------------------------------------------------
606 // Window search functions
607 // ----------------------------------------------------------------------------
608
609 /*
610 * If parent is non-NULL, look through children for a label or title
611 * matching the specified string. If NULL, look through all top-level windows.
612 *
613 */
614
615 wxWindow *
616 wxFindWindowByLabel (const wxString& title, wxWindow * parent)
617 {
618 return wxWindow::FindWindowByLabel( title, parent );
619 }
620
621
622 /*
623 * If parent is non-NULL, look through children for a name
624 * matching the specified string. If NULL, look through all top-level windows.
625 *
626 */
627
628 wxWindow *
629 wxFindWindowByName (const wxString& name, wxWindow * parent)
630 {
631 return wxWindow::FindWindowByName( name, parent );
632 }
633
634 // Returns menu item id or -1 if none.
635 int
636 wxFindMenuItemId (wxFrame * frame, const wxString& menuString, const wxString& itemString)
637 {
638 #if wxUSE_MENUS
639 wxMenuBar *menuBar = frame->GetMenuBar ();
640 if ( menuBar )
641 return menuBar->FindMenuItem (menuString, itemString);
642 #endif // wxUSE_MENUS
643
644 return -1;
645 }
646
647 // Try to find the deepest child that contains 'pt'.
648 // We go backwards, to try to allow for controls that are spacially
649 // within other controls, but are still siblings (e.g. buttons within
650 // static boxes). Static boxes are likely to be created _before_ controls
651 // that sit inside them.
652 wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt)
653 {
654 if (!win->IsShown())
655 return NULL;
656
657 // Hack for wxNotebook case: at least in wxGTK, all pages
658 // claim to be shown, so we must only deal with the selected one.
659 #if wxUSE_NOTEBOOK
660 if (win->IsKindOf(CLASSINFO(wxNotebook)))
661 {
662 wxNotebook* nb = (wxNotebook*) win;
663 int sel = nb->GetSelection();
664 if (sel >= 0)
665 {
666 wxWindow* child = nb->GetPage(sel);
667 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
668 if (foundWin)
669 return foundWin;
670 }
671 }
672 #endif
673
674 wxWindowList::Node *node = win->GetChildren().GetLast();
675 while (node)
676 {
677 wxWindow* child = node->GetData();
678 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
679 if (foundWin)
680 return foundWin;
681 node = node->GetPrevious();
682 }
683
684 wxPoint pos = win->GetPosition();
685 wxSize sz = win->GetSize();
686 if (win->GetParent())
687 {
688 pos = win->GetParent()->ClientToScreen(pos);
689 }
690
691 wxRect rect(pos, sz);
692 if (rect.Inside(pt))
693 return win;
694 else
695 return NULL;
696 }
697
698 wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt)
699 {
700 // Go backwards through the list since windows
701 // on top are likely to have been appended most
702 // recently.
703 wxWindowList::Node *node = wxTopLevelWindows.GetLast();
704 while (node)
705 {
706 wxWindow* win = node->GetData();
707 wxWindow* found = wxFindWindowAtPoint(win, pt);
708 if (found)
709 return found;
710 node = node->GetPrevious();
711 }
712 return NULL;
713 }
714
715 // ----------------------------------------------------------------------------
716 // GUI helpers
717 // ----------------------------------------------------------------------------
718
719 /*
720 * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
721 * since otherwise the generic code may be pulled in unnecessarily.
722 */
723
724 #if wxUSE_MSGDLG
725
726 int wxMessageBox(const wxString& message, const wxString& caption, long style,
727 wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
728 {
729 wxMessageDialog dialog(parent, message, caption, style);
730
731 int ans = dialog.ShowModal();
732 switch ( ans )
733 {
734 case wxID_OK:
735 return wxOK;
736 case wxID_YES:
737 return wxYES;
738 case wxID_NO:
739 return wxNO;
740 case wxID_CANCEL:
741 return wxCANCEL;
742 }
743
744 wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") );
745
746 return wxCANCEL;
747 }
748
749 #endif // wxUSE_MSGDLG
750
751 #if wxUSE_TEXTDLG
752
753 wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
754 const wxString& defaultValue, wxWindow *parent,
755 int x, int y, bool WXUNUSED(centre) )
756 {
757 wxString str;
758 wxTextEntryDialog dialog(parent, message, caption, defaultValue, wxOK|wxCANCEL, wxPoint(x, y));
759 if (dialog.ShowModal() == wxID_OK)
760 {
761 str = dialog.GetValue();
762 }
763
764 return str;
765 }
766
767 wxString wxGetPasswordFromUser(const wxString& message,
768 const wxString& caption,
769 const wxString& defaultValue,
770 wxWindow *parent)
771 {
772 wxString str;
773 wxTextEntryDialog dialog(parent, message, caption, defaultValue,
774 wxOK | wxCANCEL | wxTE_PASSWORD);
775 if ( dialog.ShowModal() == wxID_OK )
776 {
777 str = dialog.GetValue();
778 }
779
780 return str;
781 }
782
783 #endif // wxUSE_TEXTDLG
784
785 #if wxUSE_COLOURDLG
786
787 wxColour wxGetColourFromUser(wxWindow *parent, const wxColour& colInit)
788 {
789 wxColourData data;
790 data.SetChooseFull(TRUE);
791 if ( colInit.Ok() )
792 {
793 data.SetColour((wxColour &)colInit); // const_cast
794 }
795
796 wxColour colRet;
797 wxColourDialog dialog(parent, &data);
798 if ( dialog.ShowModal() == wxID_OK )
799 {
800 colRet = dialog.GetColourData().GetColour();
801 }
802 //else: leave it invalid
803
804 return colRet;
805 }
806
807 #endif // wxUSE_COLOURDLG
808
809 #if wxUSE_FONTDLG
810
811 wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit)
812 {
813 wxFontData data;
814 if ( fontInit.Ok() )
815 {
816 data.SetInitialFont(fontInit);
817 }
818
819 wxFont fontRet;
820 wxFontDialog dialog(parent, data);
821 if ( dialog.ShowModal() == wxID_OK )
822 {
823 fontRet = dialog.GetFontData().GetChosenFont();
824 }
825 //else: leave it invalid
826
827 return fontRet;
828 }
829
830 #endif // wxUSE_FONTDLG
831 // ----------------------------------------------------------------------------
832 // missing C RTL functions (FIXME shouldn't be here at all)
833 // ----------------------------------------------------------------------------
834
835 #if defined( __MWERKS__ ) && !defined(__MACH__)
836 char *strdup(const char *s)
837 {
838 return strcpy( (char*) malloc( strlen( s ) + 1 ) , s ) ;
839 }
840 int isascii( int c )
841 {
842 return ( c >= 0 && c < 128 ) ;
843 }
844 #endif // __MWERKS__
845
846 // ----------------------------------------------------------------------------
847 // wxSafeYield and supporting functions
848 // ----------------------------------------------------------------------------
849
850 void wxEnableTopLevelWindows(bool enable)
851 {
852 wxWindowList::Node *node;
853 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
854 node->GetData()->Enable(enable);
855 }
856
857 wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
858 {
859 // remember the top level windows which were already disabled, so that we
860 // don't reenable them later
861 m_winDisabled = NULL;
862
863 wxWindowList::Node *node;
864 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
865 {
866 wxWindow *winTop = node->GetData();
867 if ( winTop == winToSkip )
868 continue;
869
870 // we don't need to disable the hidden or already disabled windows
871 if ( winTop->IsEnabled() && winTop->IsShown() )
872 {
873 winTop->Disable();
874 }
875 else
876 {
877 if ( !m_winDisabled )
878 {
879 m_winDisabled = new wxWindowList;
880 }
881
882 m_winDisabled->Append(winTop);
883 }
884 }
885 }
886
887 wxWindowDisabler::~wxWindowDisabler()
888 {
889 wxWindowList::Node *node;
890 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
891 {
892 wxWindow *winTop = node->GetData();
893 if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
894 {
895 winTop->Enable();
896 }
897 //else: had been already disabled, don't reenable
898 }
899
900 delete m_winDisabled;
901 }
902
903 // Yield to other apps/messages and disable user input to all windows except
904 // the given one
905 bool wxSafeYield(wxWindow *win, bool onlyIfNeeded)
906 {
907 wxWindowDisabler wd(win);
908
909 bool rc;
910 if (onlyIfNeeded)
911 rc = wxYieldIfNeeded();
912 else
913 rc = wxYield();
914
915 return rc;
916 }
917
918 // Don't synthesize KeyUp events holding down a key and producing KeyDown
919 // events with autorepeat. On by default and always on in wxMSW. wxGTK version
920 // in utilsgtk.cpp.
921 #ifndef __WXGTK__
922 bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
923 {
924 return TRUE; // detectable auto-repeat is the only mode MSW supports
925 }
926 #endif // !wxGTK
927
928 #endif // wxUSE_GUI
929