]> git.saurik.com Git - wxWidgets.git/blob - src/gtk1/app.cpp
PyCrust updates
[wxWidgets.git] / src / gtk1 / app.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: app.cpp
3 // Purpose:
4 // Author: Robert Roebling
5 // Id: $Id$
6 // Copyright: (c) 1998 Robert Roebling, Julian Smart
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 #ifdef __GNUG__
11 #pragma implementation "app.h"
12 #endif
13
14 #include "wx/app.h"
15 #include "wx/gdicmn.h"
16 #include "wx/utils.h"
17 #include "wx/intl.h"
18 #include "wx/log.h"
19 #include "wx/memory.h"
20 #include "wx/font.h"
21 #include "wx/settings.h"
22 #include "wx/dialog.h"
23
24 #if wxUSE_WX_RESOURCES
25 #include "wx/resource.h"
26 #endif
27
28 #include "wx/module.h"
29 #include "wx/image.h"
30
31 #ifdef __WXUNIVERSAL__
32 #include "wx/univ/theme.h"
33 #include "wx/univ/renderer.h"
34 #endif
35
36 #if wxUSE_THREADS
37 #include "wx/thread.h"
38 #endif
39
40 #include <unistd.h>
41 #include "wx/gtk/win_gtk.h"
42
43 #include <gtk/gtk.h>
44
45
46 //-----------------------------------------------------------------------------
47 // global data
48 //-----------------------------------------------------------------------------
49
50 wxApp *wxTheApp = (wxApp *) NULL;
51 wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
52
53 extern bool g_isIdle;
54
55 bool g_mainThreadLocked = FALSE;
56 gint g_pendingTag = 0;
57
58 static GtkWidget *gs_RootWindow = (GtkWidget*) NULL;
59
60 //-----------------------------------------------------------------------------
61 // local functions
62 //-----------------------------------------------------------------------------
63
64 /* forward declaration */
65 gint wxapp_idle_callback( gpointer WXUNUSED(data) );
66 gint wxapp_pending_callback( gpointer WXUNUSED(data) );
67 void wxapp_install_idle_handler();
68
69 #if wxUSE_THREADS
70 gint wxapp_wakeup_timerout_callback( gpointer WXUNUSED(data) );
71 #endif
72
73 //-----------------------------------------------------------------------------
74 // wxExit
75 //-----------------------------------------------------------------------------
76
77 void wxExit()
78 {
79 gtk_main_quit();
80 }
81
82 //-----------------------------------------------------------------------------
83 // wxYield
84 //-----------------------------------------------------------------------------
85
86 bool wxApp::Yield(bool onlyIfNeeded)
87 {
88 // MT-FIXME
89 static bool s_inYield = FALSE;
90
91 if ( s_inYield )
92 {
93 if ( !onlyIfNeeded )
94 {
95 wxFAIL_MSG( wxT("wxYield called recursively" ) );
96 }
97
98 return FALSE;
99 }
100
101 #if wxUSE_THREADS
102 if ( !wxThread::IsMain() )
103 {
104 // can't call gtk_main_iteration() from other threads like this
105 return TRUE;
106 }
107 #endif // wxUSE_THREADS
108
109 s_inYield = TRUE;
110
111 if (!g_isIdle)
112 {
113 // We need to remove idle callbacks or the loop will
114 // never finish.
115 gtk_idle_remove( m_idleTag );
116 m_idleTag = 0;
117 g_isIdle = TRUE;
118 }
119
120 // disable log flushing from here because a call to wxYield() shouldn't
121 // normally result in message boxes popping up &c
122 wxLog::Suspend();
123
124 while (gtk_events_pending())
125 gtk_main_iteration();
126
127 /* it's necessary to call ProcessIdle() to update the frames sizes which
128 might have been changed (it also will update other things set from
129 OnUpdateUI() which is a nice (and desired) side effect) */
130 while ( ProcessIdle() )
131 {
132 }
133
134 // let the logs be flashed again
135 wxLog::Resume();
136
137 s_inYield = FALSE;
138
139 return TRUE;
140 }
141
142 //-----------------------------------------------------------------------------
143 // wxWakeUpIdle
144 //-----------------------------------------------------------------------------
145
146 void wxWakeUpIdle()
147 {
148 #if wxUSE_THREADS
149 if (!wxThread::IsMain())
150 wxMutexGuiEnter();
151 #endif
152
153 if (g_isIdle)
154 wxapp_install_idle_handler();
155
156 #if wxUSE_THREADS
157 if (!wxThread::IsMain())
158 wxMutexGuiLeave();
159 #endif
160 }
161
162 //-----------------------------------------------------------------------------
163 // local functions
164 //-----------------------------------------------------------------------------
165
166 gint wxapp_pending_callback( gpointer WXUNUSED(data) )
167 {
168 if (!wxTheApp) return TRUE;
169
170 // when getting called from GDK's time-out handler
171 // we are no longer within GDK's grab on the GUI
172 // thread so we must lock it here ourselves
173 gdk_threads_enter();
174
175 // Sent idle event to all who request them
176 wxTheApp->ProcessPendingEvents();
177
178 g_pendingTag = 0;
179
180 /* flush the logged messages if any */
181 #if wxUSE_LOG
182 wxLog::FlushActive();
183 #endif // wxUSE_LOG
184
185 // Release lock again
186 gdk_threads_leave();
187
188 // Return FALSE to indicate that no more idle events are
189 // to be sent (single shot instead of continuous stream)
190 return FALSE;
191 }
192
193 gint wxapp_idle_callback( gpointer WXUNUSED(data) )
194 {
195 if (!wxTheApp)
196 return TRUE;
197
198 #ifdef __WXDEBUG__
199 // don't generate the idle events while the assert modal dialog is shown,
200 // this completely confuses the apps which don't expect to be reentered
201 // from some safely-looking functions
202 if ( wxTheApp->IsInAssert() )
203 {
204 return TRUE;
205 }
206 #endif // __WXDEBUG__
207
208 // when getting called from GDK's time-out handler
209 // we are no longer within GDK's grab on the GUI
210 // thread so we must lock it here ourselves
211 gdk_threads_enter();
212
213 /* Indicate that we are now in idle mode - even so deeply
214 in idle mode that we don't get any idle events anymore.
215 this is like wxMSW where an idle event is sent only
216 once each time after the event queue has been completely
217 emptied */
218 g_isIdle = TRUE;
219 wxTheApp->m_idleTag = 0;
220
221 // Sent idle event to all who request them as long as they do
222 while (wxTheApp->ProcessIdle())
223 ;
224
225 // Release lock again
226 gdk_threads_leave();
227
228 // Return FALSE to indicate that no more idle events are
229 // to be sent (single shot instead of continuous stream)
230 return FALSE;
231 }
232
233 void wxapp_install_idle_handler()
234 {
235 wxASSERT_MSG( wxTheApp->m_idleTag == 0, wxT("attempt to install idle handler twice") );
236
237 g_isIdle = FALSE;
238
239 if (g_pendingTag == 0)
240 g_pendingTag = gtk_idle_add_priority( 900, wxapp_pending_callback, (gpointer) NULL );
241
242 /* This routine gets called by all event handlers
243 indicating that the idle is over. It may also
244 get called from other thread for sending events
245 to the main thread (and processing these in
246 idle time). Very low priority. */
247
248 wxTheApp->m_idleTag = gtk_idle_add_priority( 1000, wxapp_idle_callback, (gpointer) NULL );
249 }
250
251 #if wxUSE_THREADS
252
253 static int g_threadUninstallLevel = 0;
254
255 void wxapp_install_thread_wakeup()
256 {
257 g_threadUninstallLevel++;
258
259 if (g_threadUninstallLevel != 1) return;
260
261 if (wxTheApp->m_wakeUpTimerTag) return;
262
263 wxTheApp->m_wakeUpTimerTag = gtk_timeout_add( 50, wxapp_wakeup_timerout_callback, (gpointer) NULL );
264 }
265
266 void wxapp_uninstall_thread_wakeup()
267 {
268 g_threadUninstallLevel--;
269
270 if (g_threadUninstallLevel != 0) return;
271
272 if (!wxTheApp->m_wakeUpTimerTag) return;
273
274 gtk_timeout_remove( wxTheApp->m_wakeUpTimerTag );
275 wxTheApp->m_wakeUpTimerTag = 0;
276 }
277
278 gint wxapp_wakeup_timerout_callback( gpointer WXUNUSED(data) )
279 {
280 // when getting called from GDK's time-out handler
281 // we are no longer within GDK's grab on the GUI
282 // thread so we must lock it here ourselves
283 gdk_threads_enter();
284
285 wxapp_uninstall_thread_wakeup();
286
287 // unblock other threads wishing to do some GUI things
288 wxMutexGuiLeave();
289
290 g_mainThreadLocked = TRUE;
291
292 // wake up other threads
293 wxUsleep( 1 );
294
295 // block other thread again
296 wxMutexGuiEnter();
297
298 g_mainThreadLocked = FALSE;
299
300 wxapp_install_thread_wakeup();
301
302 // release lock again
303 gdk_threads_leave();
304
305 return TRUE;
306 }
307
308 #endif // wxUSE_THREADS
309
310 //-----------------------------------------------------------------------------
311 // wxApp
312 //-----------------------------------------------------------------------------
313
314 IMPLEMENT_DYNAMIC_CLASS(wxApp,wxEvtHandler)
315
316 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
317 EVT_IDLE(wxApp::OnIdle)
318 END_EVENT_TABLE()
319
320 wxApp::wxApp()
321 {
322 m_initialized = FALSE;
323 #ifdef __WXDEBUG__
324 m_isInAssert = FALSE;
325 #endif // __WXDEBUG__
326
327 m_idleTag = 0;
328 wxapp_install_idle_handler();
329
330 #if wxUSE_THREADS
331 m_wakeUpTimerTag = 0;
332 wxapp_install_thread_wakeup();
333 #endif
334
335 m_colorCube = (unsigned char*) NULL;
336
337 // this is NULL for a "regular" wxApp, but is set (and freed) by a wxGLApp
338 m_glVisualInfo = (void *) NULL;
339 }
340
341 wxApp::~wxApp()
342 {
343 if (m_idleTag) gtk_idle_remove( m_idleTag );
344
345 #if wxUSE_THREADS
346 wxapp_uninstall_thread_wakeup();
347 #endif
348
349 if (m_colorCube) free(m_colorCube);
350 }
351
352 bool wxApp::OnInitGui()
353 {
354 if ( !wxAppBase::OnInitGui() )
355 return FALSE;
356
357 GdkVisual *visual = gdk_visual_get_system();
358
359 // if this is a wxGLApp (derived from wxApp), and we've already
360 // chosen a specific visual, then derive the GdkVisual from that
361 if (m_glVisualInfo != NULL) {
362 #ifdef __WXGTK20__
363 /* seems gtk_widget_set_default_visual no longer exists? */
364 GdkVisual* vis = gtk_widget_get_default_visual();
365 #else
366 GdkVisual* vis = gdkx_visual_get(
367 ((XVisualInfo *) m_glVisualInfo) ->visualid );
368 gtk_widget_set_default_visual( vis );
369 #endif
370
371 GdkColormap *colormap = gdk_colormap_new( vis, FALSE );
372 gtk_widget_set_default_colormap( colormap );
373
374 visual = vis;
375 }
376
377 /* on some machines, the default visual is just 256 colours, so
378 we make sure we get the best. this can sometimes be wasteful,
379 of course, but what do these guys pay $30.000 for? */
380
381 else if ((gdk_visual_get_best() != gdk_visual_get_system()) &&
382 (m_useBestVisual))
383 {
384 #ifdef __WXGTK20__
385 /* seems gtk_widget_set_default_visual no longer exists? */
386 GdkVisual* vis = gtk_widget_get_default_visual();
387 #else
388 GdkVisual* vis = gdk_visual_get_best();
389 gtk_widget_set_default_visual( vis );
390 #endif
391
392 GdkColormap *colormap = gdk_colormap_new( vis, FALSE );
393 gtk_widget_set_default_colormap( colormap );
394
395 visual = vis;
396 }
397
398 /* Nothing to do for 15, 16, 24, 32 bit displays */
399 if (visual->depth > 8) return TRUE;
400
401 /* initialize color cube for 8-bit color reduction dithering */
402
403 GdkColormap *cmap = gtk_widget_get_default_colormap();
404
405 m_colorCube = (unsigned char*)malloc(32 * 32 * 32);
406
407 for (int r = 0; r < 32; r++)
408 {
409 for (int g = 0; g < 32; g++)
410 {
411 for (int b = 0; b < 32; b++)
412 {
413 int rr = (r << 3) | (r >> 2);
414 int gg = (g << 3) | (g >> 2);
415 int bb = (b << 3) | (b >> 2);
416
417 int index = -1;
418
419 GdkColor *colors = cmap->colors;
420 if (colors)
421 {
422 int max = 3 * 65536;
423
424 for (int i = 0; i < cmap->size; i++)
425 {
426 int rdiff = ((rr << 8) - colors[i].red);
427 int gdiff = ((gg << 8) - colors[i].green);
428 int bdiff = ((bb << 8) - colors[i].blue);
429 int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
430 if (sum < max)
431 {
432 index = i; max = sum;
433 }
434 }
435 }
436 else
437 {
438 #if (GTK_MINOR_VERSION > 0)
439 /* assume 8-bit true or static colors. this really
440 exists. */
441 GdkVisual* vis = gdk_colormap_get_visual( cmap );
442 index = (r >> (5 - vis->red_prec)) << vis->red_shift;
443 index |= (g >> (5 - vis->green_prec)) << vis->green_shift;
444 index |= (b >> (5 - vis->blue_prec)) << vis->blue_shift;
445 #else
446 wxFAIL_MSG( wxT("Unsupported graphics hardware") );
447 #endif
448 }
449 m_colorCube[ (r*1024) + (g*32) + b ] = index;
450 }
451 }
452 }
453
454 return TRUE;
455 }
456
457 bool wxApp::ProcessIdle()
458 {
459 wxIdleEvent event;
460 event.SetEventObject( this );
461 ProcessEvent( event );
462
463 return event.MoreRequested();
464 }
465
466 void wxApp::OnIdle( wxIdleEvent &event )
467 {
468 static bool s_inOnIdle = FALSE;
469
470 /* Avoid recursion (via ProcessEvent default case) */
471 if (s_inOnIdle)
472 return;
473
474 s_inOnIdle = TRUE;
475
476 /* Resend in the main thread events which have been prepared in other
477 threads */
478 ProcessPendingEvents();
479
480 /* 'Garbage' collection of windows deleted with Close(). */
481 DeletePendingObjects();
482
483 /* Send OnIdle events to all windows */
484 bool needMore = SendIdleEvents();
485
486 if (needMore)
487 event.RequestMore(TRUE);
488
489 s_inOnIdle = FALSE;
490 }
491
492 bool wxApp::SendIdleEvents()
493 {
494 bool needMore = FALSE;
495
496 wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
497 while (node)
498 {
499 wxWindow* win = node->GetData();
500 if (SendIdleEvents(win))
501 needMore = TRUE;
502 node = node->GetNext();
503 }
504
505 return needMore;
506 }
507
508 bool wxApp::SendIdleEvents( wxWindow* win )
509 {
510 bool needMore = FALSE;
511
512 wxIdleEvent event;
513 event.SetEventObject(win);
514
515 win->GetEventHandler()->ProcessEvent(event);
516
517 win->OnInternalIdle();
518
519 if (event.MoreRequested())
520 needMore = TRUE;
521
522 wxNode* node = win->GetChildren().First();
523 while (node)
524 {
525 wxWindow* win = (wxWindow*) node->Data();
526 if (SendIdleEvents(win))
527 needMore = TRUE;
528
529 node = node->Next();
530 }
531 return needMore ;
532 }
533
534 int wxApp::MainLoop()
535 {
536 gtk_main();
537 return 0;
538 }
539
540 void wxApp::ExitMainLoop()
541 {
542 if (gtk_main_level() > 0)
543 gtk_main_quit();
544 }
545
546 bool wxApp::Initialized()
547 {
548 return m_initialized;
549 }
550
551 bool wxApp::Pending()
552 {
553 return (gtk_events_pending() > 0);
554 }
555
556 void wxApp::Dispatch()
557 {
558 gtk_main_iteration();
559 }
560
561 void wxApp::DeletePendingObjects()
562 {
563 wxNode *node = wxPendingDelete.First();
564 while (node)
565 {
566 wxObject *obj = (wxObject *)node->Data();
567
568 delete obj;
569
570 if (wxPendingDelete.Find(obj))
571 delete node;
572
573 node = wxPendingDelete.First();
574 }
575 }
576
577 bool wxApp::Initialize()
578 {
579 wxBuffer = new wxChar[BUFSIZ + 512];
580
581 wxClassInfo::InitializeClasses();
582
583 #if wxUSE_INTL
584 wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
585 #endif
586
587 // GL: I'm annoyed ... I don't know where to put this and I don't want to
588 // create a module for that as it's part of the core.
589 #if wxUSE_THREADS
590 wxPendingEvents = new wxList();
591 wxPendingEventsLocker = new wxCriticalSection();
592 #endif
593
594 wxTheColourDatabase = new wxColourDatabase( wxKEY_STRING );
595 wxTheColourDatabase->Initialize();
596
597 wxInitializeStockLists();
598 wxInitializeStockObjects();
599
600 #if wxUSE_WX_RESOURCES
601 wxInitializeResourceSystem();
602 #endif
603
604 wxModule::RegisterModules();
605 if (!wxModule::InitializeModules()) return FALSE;
606
607 return TRUE;
608 }
609
610 void wxApp::CleanUp()
611 {
612 wxModule::CleanUpModules();
613
614 #if wxUSE_WX_RESOURCES
615 wxCleanUpResourceSystem();
616 #endif
617
618 if (wxTheColourDatabase)
619 delete wxTheColourDatabase;
620
621 wxTheColourDatabase = (wxColourDatabase*) NULL;
622
623 wxDeleteStockObjects();
624
625 wxDeleteStockLists();
626
627 delete wxTheApp;
628 wxTheApp = (wxApp*) NULL;
629
630 // GL: I'm annoyed ... I don't know where to put this and I don't want to
631 // create a module for that as it's part of the core.
632 #if wxUSE_THREADS
633 delete wxPendingEvents;
634 delete wxPendingEventsLocker;
635 #endif
636
637 delete[] wxBuffer;
638
639 wxClassInfo::CleanUpClasses();
640
641 // check for memory leaks
642 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
643 if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
644 {
645 wxLogDebug(wxT("There were memory leaks.\n"));
646 wxDebugContext::Dump();
647 wxDebugContext::PrintStatistics();
648 }
649 #endif // Debug
650
651 #if wxUSE_LOG
652 // do this as the very last thing because everything else can log messages
653 wxLog::DontCreateOnDemand();
654
655 wxLog *oldLog = wxLog::SetActiveTarget( (wxLog*) NULL );
656 if (oldLog)
657 delete oldLog;
658 #endif // wxUSE_LOG
659 }
660
661 //-----------------------------------------------------------------------------
662 // Access to the root window global
663 //-----------------------------------------------------------------------------
664
665 GtkWidget* wxGetRootWindow()
666 {
667 if (gs_RootWindow == NULL) {
668 gs_RootWindow = gtk_window_new( GTK_WINDOW_TOPLEVEL );
669 gtk_widget_realize( gs_RootWindow );
670 }
671 return gs_RootWindow;
672 }
673
674 //-----------------------------------------------------------------------------
675 // wxEntry
676 //-----------------------------------------------------------------------------
677
678 // NB: argc and argv may be changed here, pass by reference!
679 int wxEntryStart( int& argc, char *argv[] )
680 {
681 #if wxUSE_THREADS
682 /* GTK 1.2 up to version 1.2.3 has broken threads */
683 if ((gtk_major_version == 1) &&
684 (gtk_minor_version == 2) &&
685 (gtk_micro_version < 4))
686 {
687 printf( "wxWindows warning: GUI threading disabled due to outdated GTK version\n" );
688 }
689 else
690 {
691 g_thread_init(NULL);
692 }
693 #endif
694
695 gtk_set_locale();
696
697 // We should have the wxUSE_WCHAR_T test on the _outside_
698 #if wxUSE_WCHAR_T
699 #if defined(__WXGTK20__)
700 // gtk+ 2.0 supports Unicode through UTF-8 strings
701 wxConvCurrent = &wxConvUTF8;
702 #else
703 if (!wxOKlibc()) wxConvCurrent = &wxConvLocal;
704 #endif
705 #else
706 if (!wxOKlibc()) wxConvCurrent = (wxMBConv*) NULL;
707 #endif
708
709 gdk_threads_enter();
710
711 gtk_init( &argc, &argv );
712
713 wxSetDetectableAutoRepeat( TRUE );
714
715 if (!wxApp::Initialize())
716 {
717 gdk_threads_leave();
718 return -1;
719 }
720
721 return 0;
722 }
723
724
725 int wxEntryInitGui()
726 {
727 int retValue = 0;
728
729 if ( !wxTheApp->OnInitGui() )
730 retValue = -1;
731
732 wxGetRootWindow();
733
734 return retValue;
735 }
736
737
738 void wxEntryCleanup()
739 {
740 #if wxUSE_LOG
741 // flush the logged messages if any
742 wxLog *log = wxLog::GetActiveTarget();
743 if (log != NULL && log->HasPendingMessages())
744 log->Flush();
745
746 // continuing to use user defined log target is unsafe from now on because
747 // some resources may be already unavailable, so replace it by something
748 // more safe
749 wxLog *oldlog = wxLog::SetActiveTarget(new wxLogStderr);
750 if ( oldlog )
751 delete oldlog;
752 #endif // wxUSE_LOG
753
754 wxApp::CleanUp();
755
756 gdk_threads_leave();
757 }
758
759
760
761 int wxEntry( int argc, char *argv[] )
762 {
763 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
764 // This seems to be necessary since there are 'rogue'
765 // objects present at this point (perhaps global objects?)
766 // Setting a checkpoint will ignore them as far as the
767 // memory checking facility is concerned.
768 // Of course you may argue that memory allocated in globals should be
769 // checked, but this is a reasonable compromise.
770 wxDebugContext::SetCheckpoint();
771 #endif
772 int err = wxEntryStart(argc, argv);
773 if (err)
774 return err;
775
776 if (!wxTheApp)
777 {
778 wxCHECK_MSG( wxApp::GetInitializerFunction(), -1,
779 wxT("wxWindows error: No initializer - use IMPLEMENT_APP macro.\n") );
780
781 wxAppInitializerFunction app_ini = wxApp::GetInitializerFunction();
782
783 wxObject *test_app = app_ini();
784
785 wxTheApp = (wxApp*) test_app;
786 }
787
788 wxCHECK_MSG( wxTheApp, -1, wxT("wxWindows error: no application object") );
789
790 wxTheApp->argc = argc;
791 #if wxUSE_UNICODE
792 wxTheApp->argv = new wxChar*[argc+1];
793 int mb_argc = 0;
794 while (mb_argc < argc)
795 {
796 wxTheApp->argv[mb_argc] = wxStrdup(wxConvLibc.cMB2WX(argv[mb_argc]));
797 mb_argc++;
798 }
799 wxTheApp->argv[mb_argc] = (wxChar *)NULL;
800 #else
801 wxTheApp->argv = argv;
802 #endif
803
804 wxString name(wxFileNameFromPath(argv[0]));
805 wxStripExtension( name );
806 wxTheApp->SetAppName( name );
807
808 int retValue;
809 retValue = wxEntryInitGui();
810
811 // Here frames insert themselves automatically into wxTopLevelWindows by
812 // getting created in OnInit().
813 if ( retValue == 0 )
814 {
815 if ( !wxTheApp->OnInit() )
816 retValue = -1;
817 }
818
819 if ( retValue == 0 )
820 {
821 /* delete pending toplevel windows (typically a single
822 dialog) so that, if there isn't any left, we don't
823 call OnRun() */
824 wxTheApp->DeletePendingObjects();
825
826 wxTheApp->m_initialized = wxTopLevelWindows.GetCount() != 0;
827
828 if (wxTheApp->Initialized())
829 {
830 wxTheApp->OnRun();
831
832 wxWindow *topWindow = wxTheApp->GetTopWindow();
833 if (topWindow)
834 {
835 /* Forcibly delete the window. */
836 if (topWindow->IsKindOf(CLASSINFO(wxFrame)) ||
837 topWindow->IsKindOf(CLASSINFO(wxDialog)) )
838 {
839 topWindow->Close( TRUE );
840 wxTheApp->DeletePendingObjects();
841 }
842 else
843 {
844 delete topWindow;
845 wxTheApp->SetTopWindow( (wxWindow*) NULL );
846 }
847 }
848
849 retValue = wxTheApp->OnExit();
850 }
851 }
852
853 wxEntryCleanup();
854
855 return retValue;
856 }
857
858 #ifndef __WXUNIVERSAL__
859
860 #include "wx/gtk/info.xpm"
861 #include "wx/gtk/error.xpm"
862 #include "wx/gtk/question.xpm"
863 #include "wx/gtk/warning.xpm"
864
865 wxIcon wxApp::GetStdIcon(int which) const
866 {
867 switch(which)
868 {
869 case wxICON_INFORMATION:
870 return wxIcon(info_xpm);
871
872 case wxICON_QUESTION:
873 return wxIcon(question_xpm);
874
875 case wxICON_EXCLAMATION:
876 return wxIcon(warning_xpm);
877
878 default:
879 wxFAIL_MSG(wxT("requested non existent standard icon"));
880 // still fall through
881
882 case wxICON_HAND:
883 return wxIcon(error_xpm);
884 }
885 }
886 #else
887 wxIcon wxApp::GetStdIcon(int which) const
888 {
889 return wxTheme::Get()->GetRenderer()->GetStdIcon(which);
890 }
891 #endif // !__WXUNIVERSAL__
892
893
894 #ifdef __WXDEBUG__
895
896 void wxApp::OnAssert(const wxChar *file, int line, const wxChar *msg)
897 {
898 m_isInAssert = TRUE;
899
900 wxAppBase::OnAssert(file, line, msg);
901
902 m_isInAssert = FALSE;
903 }
904
905 #endif // __WXDEBUG__
906