src/gtk/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 #if wxUSE_THREADS
  32 #include "wx/thread.h"
  33 #endif
  34
  35 #include "unistd.h"
  36
  37 #include "glib.h"
  38 #include "gdk/gdk.h"
  39 #include "gtk/gtk.h"
  40
  41 #include "wx/gtk/win_gtk.h"
  42
  43 //-----------------------------------------------------------------------------
  44 // global data
  45 //-----------------------------------------------------------------------------
  46
  47 wxApp *wxTheApp = (wxApp *)  NULL;
  48 wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL;
  49
  50 #if wxUSE_THREADS
  51 extern wxList *wxPendingEvents;
  52 extern wxCriticalSection *wxPendingEventsLocker;
  53 #endif
  54 extern wxResourceCache *wxTheResourceCache;
  55 extern bool g_isIdle;
  56
  57 unsigned char g_palette[64*3] =
  58 {
  59   0x0,  0x0,  0x0,
  60   0xff, 0xff, 0xff,
  61   0xff, 0x0,  0x0,
  62   0xff, 0xff, 0x0,
  63   0x0,  0xff, 0x0,
  64   0x0,  0x0,  0xff,
  65   0x0,  0xff, 0xff,
  66   0x99, 0x99, 0x99,
  67   0xff, 0x88, 0x0,
  68   0x88, 0x0,  0x0,
  69   0x0,  0x88, 0x88,
  70   0x88, 0x88, 0x0,
  71   0xff, 0xcc, 0x97,
  72   0xbb, 0xbb, 0xbb,
  73   0x9f, 0x6b, 0x42,
  74   0x55, 0x55, 0x55,
  75   0xdd, 0xdd, 0xdd,
  76   0x77, 0x77, 0x77,
  77   0x33, 0x33, 0x33,
  78   0xcc, 0x0,  0x0,
  79   0xff, 0x44, 0x0,
  80   0xff, 0xcc, 0x0,
  81   0xcc, 0xcc, 0x0,
  82   0x60, 0x60, 0x0,
  83   0x0,  0x43, 0x0,
  84   0x0,  0x7f, 0x0,
  85   0x0,  0xcc, 0x0,
  86   0x0,  0x44, 0x44,
  87   0x0,  0x0,  0x44,
  88   0x0,  0x0,  0x88,
  89   0xef, 0xb1, 0x7b,
  90   0xdf, 0x98, 0x5f,
  91   0xbf, 0x87, 0x56,
  92   0x7f, 0x57, 0x26,
  93   0x5f, 0x39, 0xc,
  94   0x3f, 0x1c, 0x0,
  95   0x21, 0x0,  0x0,
  96   0x0,  0x43, 0x87,
  97   0x2d, 0x70, 0xaf,
  98   0x5a, 0x9e, 0xd7,
  99   0x87, 0xcc, 0xff,
 100   0xff, 0xe0, 0xba,
 101   0x21, 0x43, 0xf,
 102   0x3d, 0x5d, 0x25,
 103   0x59, 0x78, 0x3a,
 104   0x75, 0x93, 0x4f,
 105   0x91, 0xae, 0x64,
 106   0xad, 0xc8, 0x7a,
 107   0xf0, 0xa8, 0xef,
 108   0xd0, 0x88, 0xd0,
 109   0xaf, 0x66, 0xaf,
 110   0x8e, 0x44, 0x8e,
 111   0x6d, 0x22, 0x6d,
 112   0x4b, 0x0,  0x4b,
 113   0xff, 0xc0, 0xbc,
 114   0xff, 0x93, 0x91,
 115   0xff, 0x66, 0x67,
 116   0xd8, 0xf2, 0xbf,
 117   0xff, 0xc9, 0x68,
 118   0xff, 0x96, 0x67,
 119   0xa5, 0x60, 0xff,
 120   0x51, 0xff, 0x99,
 121   0x3f, 0xa5, 0x63,
 122   0x98, 0x90, 0x67
 123 };
 124
 125 //-----------------------------------------------------------------------------
 126 // local functions
 127 //-----------------------------------------------------------------------------
 128
 129 extern void wxFlushResources(void);
 130
 131 //-----------------------------------------------------------------------------
 132 // global functions
 133 //-----------------------------------------------------------------------------
 134
 135 void wxExit()
 136 {
 137     gtk_main_quit();
 138 }
 139
 140 /* forward declaration */
 141 gint wxapp_idle_callback( gpointer WXUNUSED(data) );
 142
 143 bool wxYield()
 144 {
 145     /* it's necessary to call ProcessIdle() to update the frames sizes which
 146        might have been changed (it also will update other things set from
 147        OnUpdateUI() which is a nice (and desired) side effect) */
 148     while (wxTheApp->ProcessIdle()) { }
 149
 150 #if 0
 151     for ( wxWindowList::Node *node = wxTopLevelWindows.GetFirst();
 152           node;
 153           node = node->GetNext() )
 154     {
 155         wxWindow *win = node->GetData();
 156         win->OnInternalIdle();
 157     }
 158 #endif
 159
 160     if (wxTheApp->m_idleTag)
 161     {
 162         /* We need to temporarily remove idle callbacks or the loop will
 163            never finish. */
 164         gtk_idle_remove( wxTheApp->m_idleTag );
 165         wxTheApp->m_idleTag = 0;
 166
 167         while (gtk_events_pending())
 168             gtk_main_iteration();
 169
 170         /* re-add idle handler */
 171         wxTheApp->m_idleTag = gtk_idle_add( wxapp_idle_callback, (gpointer) NULL );
 172     }
 173     else
 174     {
 175         while (gtk_events_pending())
 176             gtk_main_iteration();
 177     }
 178
 179     return TRUE;
 180 }
 181
 182 gint wxapp_idle_callback( gpointer WXUNUSED(data) )
 183 {
 184     if (!wxTheApp) return TRUE;
 185
 186 #if (GTK_MINOR_VERSION > 0)
 187     /* when getting called from GDK's idle handler we
 188        are no longer within GDK's grab on the GUI
 189        thread so we must lock it here ourselves */
 190     GDK_THREADS_ENTER ();
 191 #endif
 192
 193     /* sent idle event to all who request them */
 194     while (wxTheApp->ProcessIdle()) { }
 195
 196     /* we don't want any more idle events until the next event is
 197        sent to wxGTK */
 198     gtk_idle_remove( wxTheApp->m_idleTag );
 199     wxTheApp->m_idleTag = 0;
 200
 201     /* indicate that we are now in idle mode - even so deeply
 202        in idle mode that we don't get any idle events anymore.
 203        this is like wxMSW where an idle event is sent only
 204        once each time after the event queue has been completely
 205        emptied */
 206     g_isIdle = TRUE;
 207
 208 #if (GTK_MINOR_VERSION > 0)
 209     /* release lock again */
 210     GDK_THREADS_LEAVE ();
 211 #endif
 212
 213     return TRUE;
 214 }
 215
 216 void wxapp_install_idle_handler()
 217 {
 218     wxASSERT_MSG( wxTheApp->m_idleTag == 0, _T("attempt to install idle handler twice") );
 219
 220     /* this routine gets called by all event handlers
 221        indicating that the idle is over. */
 222
 223     wxTheApp->m_idleTag = gtk_idle_add( wxapp_idle_callback, (gpointer) NULL );
 224
 225     g_isIdle = FALSE;
 226 }
 227
 228 /*
 229 #if wxUSE_THREADS
 230 static gint wxapp_wakeup_timerout_callback( gpointer WXUNUSED(data) )
 231 {
 232     gtk_timeout_remove( wxTheApp->m_wakeUpTimerTag );
 233     wxTheApp->m_wakeUpTimerTag = 0;
 234
 235 #if (GTK_MINOR_VERSION > 0)
 236     // when getting called from GDK's time-out handler
 237     // we are no longer within GDK's grab on the GUI
 238     // thread so we must lock it here ourselves
 239     GDK_THREADS_ENTER ();
 240 #endif
 241
 242     // unblock other threads wishing to do some GUI things
 243     wxMutexGuiLeave();
 244
 245     // wake up other threads
 246     wxUsleep( 1 );
 247
 248     // block other thread again
 249     wxMutexGuiEnter();
 250
 251 #if (GTK_MINOR_VERSION > 0)
 252     // release lock again
 253     GDK_THREADS_LEAVE ();
 254 #endif
 255
 256     wxTheApp->m_wakeUpTimerTag = gtk_timeout_add( 20, wxapp_wakeup_timerout_callback, (gpointer) NULL );
 257
 258     return TRUE;
 259 }
 260 #endif
 261 */
 262
 263 //-----------------------------------------------------------------------------
 264 // wxApp
 265 //-----------------------------------------------------------------------------
 266
 267 IMPLEMENT_DYNAMIC_CLASS(wxApp,wxEvtHandler)
 268
 269 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 270     EVT_IDLE(wxApp::OnIdle)
 271 END_EVENT_TABLE()
 272
 273 wxApp::wxApp()
 274 {
 275     wxTheApp = this;
 276
 277     m_topWindow = (wxWindow *) NULL;
 278     m_exitOnFrameDelete = TRUE;
 279
 280     m_idleTag = gtk_idle_add( wxapp_idle_callback, (gpointer) NULL );
 281
 282 /*
 283 #if wxUSE_THREADS
 284     m_wakeUpTimerTag = gtk_timeout_add( 20, wxapp_wakeup_timerout_callback, (gpointer) NULL );
 285 #endif
 286 */
 287
 288     m_colorCube = (unsigned char*) NULL;
 289 }
 290
 291 wxApp::~wxApp()
 292 {
 293     if (m_idleTag) gtk_idle_remove( m_idleTag );
 294
 295 /*
 296 #if wxUSE_THREADS
 297     if (m_wakeUpTimerTag) gtk_timeout_remove( m_wakeUpTimerTag );
 298 #endif
 299 */
 300
 301     if (m_colorCube) free(m_colorCube);
 302 }
 303
 304 bool wxApp::OnInitGui()
 305 {
 306     GdkVisual *visual = gdk_visual_get_system();
 307
 308     /* on some machines, the default visual is just 256 colours, so
 309        we make sure we get the best. this can sometimes be wasteful,
 310        of course, but what do these guys pay $30.000 for? */
 311 /*
 312     if (gdk_visual_get_best() != gdk_visual_get_system())
 313     {
 314         GdkVisual* vis = gdk_visual_get_best();
 315         gtk_widget_set_default_visual( vis );
 316
 317         GdkColormap *colormap = gdk_colormap_new( vis, FALSE );
 318         gtk_widget_set_default_colormap( colormap );
 319
 320         visual = vis;
 321     }
 322 */
 323
 324     /* Nothing to do for 15, 16, 24, 32 bit displays */
 325     if (visual->depth > 8) return TRUE;
 326
 327         /* this initiates the standard palette as defined by GdkImlib
 328            in the GNOME libraries. it ensures that all GNOME applications
 329            use the same 64 colormap entries on 8-bit displays so you
 330            can use several rather graphics-heavy applications at the
 331            same time.
 332            NOTE: this doesn't really seem to work this way... */
 333
 334         /*
 335         GdkColormap *cmap = gdk_colormap_new( gdk_visual_get_system(), TRUE );
 336
 337         for (int i = 0; i < 64; i++)
 338         {
 339             GdkColor col;
 340             col.red    = g_palette[i*3 + 0] << 8;
 341             col.green  = g_palette[i*3 + 1] << 8;
 342             col.blue   = g_palette[i*3 + 2] << 8;
 343             col.pixel  = 0;
 344
 345             gdk_color_alloc( cmap, &col );
 346         }
 347
 348         gtk_widget_set_default_colormap( cmap );
 349         */
 350
 351     /* initialize color cube for 8-bit color reduction dithering */
 352
 353     GdkColormap *cmap = gtk_widget_get_default_colormap();
 354
 355     m_colorCube = (unsigned char*)malloc(32 * 32 * 32);
 356
 357     for (int r = 0; r < 32; r++)
 358     {
 359         for (int g = 0; g < 32; g++)
 360         {
 361             for (int b = 0; b < 32; b++)
 362             {
 363                 int rr = (r << 3) | (r >> 2);
 364                 int gg = (g << 3) | (g >> 2);
 365                 int bb = (b << 3) | (b >> 2);
 366
 367                 int index = -1;
 368
 369                 GdkColor *colors = cmap->colors;
 370                 if (colors)
 371                 {
 372                     int max = 3 * 65536;
 373
 374                     for (int i = 0; i < cmap->size; i++)
 375                     {
 376                         int rdiff = ((rr << 8) - colors[i].red);
 377                         int gdiff = ((gg << 8) - colors[i].green);
 378                         int bdiff = ((bb << 8) - colors[i].blue);
 379                         int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
 380                         if (sum < max)
 381                         {
 382                             index = i; max = sum;
 383                         }
 384                     }
 385                 }
 386                 else
 387                 {
 388 #if (GTK_MINOR_VERSION > 0)
 389                     /* assume 8-bit true or static colors. this really
 390                        exists. */
 391                     GdkVisual* vis = gdk_colormap_get_visual( cmap );
 392                     index = (r >> (5 - vis->red_prec)) << vis->red_shift;
 393                     index |= (g >> (5 - vis->green_prec)) << vis->green_shift;
 394                     index |= (b >> (5 - vis->blue_prec)) << vis->blue_shift;
 395 #else
 396                     wxFAIL_MSG( _T("Unsupported graphics hardware") );
 397 #endif
 398                 }
 399                 m_colorCube[ (r*1024) + (g*32) + b ] = index;
 400             }
 401         }
 402     }
 403
 404     return TRUE;
 405 }
 406
 407 bool wxApp::ProcessIdle()
 408 {
 409     wxIdleEvent event;
 410     event.SetEventObject( this );
 411     ProcessEvent( event );
 412
 413     return event.MoreRequested();
 414 }
 415
 416 void wxApp::OnIdle( wxIdleEvent &event )
 417 {
 418     static bool inOnIdle = FALSE;
 419
 420     /* Avoid recursion (via ProcessEvent default case) */
 421     if (inOnIdle)
 422         return;
 423
 424     inOnIdle = TRUE;
 425
 426 #if wxUSE_THREADS
 427     /* Resend in the main thread events which have been prepared in other
 428        threads */
 429     ProcessPendingEvents();
 430 #endif
 431
 432     /* 'Garbage' collection of windows deleted with Close(). */
 433     DeletePendingObjects();
 434
 435     /* flush the logged messages if any */
 436 #if wxUSE_LOG
 437     wxLog *log = wxLog::GetActiveTarget();
 438     if (log != NULL && log->HasPendingMessages())
 439         log->Flush();
 440 #endif // wxUSE_LOG
 441
 442     /* Send OnIdle events to all windows */
 443     bool needMore = SendIdleEvents();
 444
 445     if (needMore)
 446         event.RequestMore(TRUE);
 447
 448     inOnIdle = FALSE;
 449 }
 450
 451 bool wxApp::SendIdleEvents()
 452 {
 453     bool needMore = FALSE;
 454
 455     wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
 456     while (node)
 457     {
 458         wxWindow* win = node->GetData();
 459         if (SendIdleEvents(win))
 460             needMore = TRUE;
 461         node = node->GetNext();
 462     }
 463
 464     return needMore;
 465 }
 466
 467 bool wxApp::SendIdleEvents( wxWindow* win )
 468 {
 469     bool needMore = FALSE;
 470
 471     wxIdleEvent event;
 472     event.SetEventObject(win);
 473
 474     win->OnInternalIdle();
 475
 476     win->ProcessEvent(event);
 477
 478     if (event.MoreRequested())
 479         needMore = TRUE;
 480
 481     wxNode* node = win->GetChildren().First();
 482     while (node)
 483     {
 484         wxWindow* win = (wxWindow*) node->Data();
 485         if (SendIdleEvents(win))
 486             needMore = TRUE;
 487
 488         node = node->Next();
 489     }
 490     return needMore ;
 491 }
 492
 493 int wxApp::MainLoop()
 494 {
 495     gtk_main();
 496     return 0;
 497 }
 498
 499 void wxApp::ExitMainLoop()
 500 {
 501     gtk_main_quit();
 502 }
 503
 504 bool wxApp::Initialized()
 505 {
 506     return m_initialized;
 507 }
 508
 509 bool wxApp::Pending()
 510 {
 511     return (gtk_events_pending() > 0);
 512 }
 513
 514 void wxApp::Dispatch()
 515 {
 516     gtk_main_iteration();
 517 }
 518
 519 #if wxUSE_THREADS
 520 void wxApp::ProcessPendingEvents()
 521 {
 522     wxNode *node = wxPendingEvents->First();
 523     wxCriticalSectionLocker locker(*wxPendingEventsLocker);
 524
 525     while (node)
 526     {
 527         wxEvtHandler *handler = (wxEvtHandler *)node->Data();
 528
 529         handler->ProcessPendingEvents();
 530
 531         delete node;
 532
 533         node = wxPendingEvents->First();
 534     }
 535 }
 536 #endif // wxUSE_THREADS
 537
 538 void wxApp::DeletePendingObjects()
 539 {
 540     wxNode *node = wxPendingDelete.First();
 541     while (node)
 542     {
 543         wxObject *obj = (wxObject *)node->Data();
 544
 545         delete obj;
 546
 547         if (wxPendingDelete.Find(obj))
 548             delete node;
 549
 550         node = wxPendingDelete.First();
 551     }
 552 }
 553
 554 wxWindow *wxApp::GetTopWindow()
 555 {
 556     if (m_topWindow)
 557         return m_topWindow;
 558     else if (wxTopLevelWindows.GetCount() > 0)
 559         return wxTopLevelWindows.GetFirst()->GetData();
 560     else
 561         return NULL;
 562 }
 563
 564 void wxApp::SetTopWindow( wxWindow *win )
 565 {
 566     m_topWindow = win;
 567 }
 568
 569 bool wxApp::Initialize()
 570 {
 571     wxBuffer = new wxChar[BUFSIZ + 512];
 572
 573     wxClassInfo::InitializeClasses();
 574
 575     wxSystemSettings::Init();
 576
 577     // GL: I'm annoyed ... I don't know where to put this and I don't want to
 578     // create a module for that as it's part of the core.
 579 #if wxUSE_THREADS
 580     wxPendingEvents = new wxList();
 581     wxPendingEventsLocker = new wxCriticalSection();
 582 #endif
 583
 584 /*
 585     wxTheFontNameDirectory =  new wxFontNameDirectory;
 586     wxTheFontNameDirectory->Initialize();
 587 */
 588
 589     wxTheColourDatabase = new wxColourDatabase( wxKEY_STRING );
 590     wxTheColourDatabase->Initialize();
 591
 592     wxInitializeStockLists();
 593     wxInitializeStockObjects();
 594
 595 #if wxUSE_WX_RESOURCES
 596     wxTheResourceCache = new wxResourceCache( wxKEY_STRING );
 597
 598     wxInitializeResourceSystem();
 599 #endif
 600
 601     wxImage::InitStandardHandlers();
 602
 603     wxModule::RegisterModules();
 604     if (!wxModule::InitializeModules()) return FALSE;
 605
 606     return TRUE;
 607 }
 608
 609 void wxApp::CleanUp()
 610 {
 611     wxModule::CleanUpModules();
 612
 613 #if wxUSE_WX_RESOURCES
 614     wxFlushResources();
 615
 616     if (wxTheResourceCache)
 617         delete wxTheResourceCache;
 618     wxTheResourceCache = (wxResourceCache*) NULL;
 619
 620     wxCleanUpResourceSystem();
 621 #endif
 622
 623     if (wxTheColourDatabase)
 624         delete wxTheColourDatabase;
 625     wxTheColourDatabase = (wxColourDatabase*) NULL;
 626
 627 /*
 628     if (wxTheFontNameDirectory) delete wxTheFontNameDirectory;
 629     wxTheFontNameDirectory = (wxFontNameDirectory*) NULL;
 630 */
 631
 632     wxDeleteStockObjects();
 633
 634     wxDeleteStockLists();
 635
 636     wxImage::CleanUpHandlers();
 637
 638     delete wxTheApp;
 639     wxTheApp = (wxApp*) NULL;
 640
 641     // GL: I'm annoyed ... I don't know where to put this and I don't want to
 642     // create a module for that as it's part of the core.
 643 #if wxUSE_THREADS
 644     delete wxPendingEvents;
 645     delete wxPendingEventsLocker;
 646 #endif
 647
 648     wxSystemSettings::Done();
 649
 650     delete[] wxBuffer;
 651
 652     wxClassInfo::CleanUpClasses();
 653
 654     // check for memory leaks
 655 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 656     if (wxDebugContext::CountObjectsLeft() > 0)
 657     {
 658         wxLogDebug(_T("There were memory leaks.\n"));
 659         wxDebugContext::Dump();
 660         wxDebugContext::PrintStatistics();
 661     }
 662 #endif // Debug
 663
 664 #if wxUSE_LOG
 665     // do this as the very last thing because everything else can log messages
 666     wxLog::DontCreateOnDemand();
 667
 668     wxLog *oldLog = wxLog::SetActiveTarget( (wxLog*) NULL );
 669     if (oldLog)
 670         delete oldLog;
 671 }
 672
 673 wxLog *wxApp::CreateLogTarget()
 674 {
 675     return new wxLogGui;
 676 }
 677 #endif // wxUSE_LOG
 678
 679 //-----------------------------------------------------------------------------
 680 // wxEntry
 681 //-----------------------------------------------------------------------------
 682
 683 int wxEntry( int argc, char *argv[] )
 684 {
 685     gtk_set_locale();
 686
 687     if (!wxOKlibc()) wxConvCurrent = &wxConvLocal;
 688
 689     gtk_init( &argc, &argv );
 690
 691     wxSetDetectableAutoRepeat( TRUE );
 692
 693     if (!wxApp::Initialize())
 694         return -1;
 695
 696     if (!wxTheApp)
 697     {
 698         wxCHECK_MSG( wxApp::GetInitializerFunction(), -1,
 699                      _T("wxWindows error: No initializer - use IMPLEMENT_APP macro.\n") );
 700
 701         wxAppInitializerFunction app_ini = wxApp::GetInitializerFunction();
 702
 703         wxObject *test_app = app_ini();
 704
 705         wxTheApp = (wxApp*) test_app;
 706     }
 707
 708     wxCHECK_MSG( wxTheApp, -1, _T("wxWindows error: no application object") );
 709
 710     wxTheApp->argc = argc;
 711     wxTheApp->argv = argv;
 712
 713     wxString name(wxFileNameFromPath(argv[0]));
 714     wxStripExtension( name );
 715     wxTheApp->SetAppName( name );
 716
 717     int retValue = 0;
 718
 719     if ( !wxTheApp->OnInitGui() )
 720         retValue = -1;
 721
 722     // Here frames insert themselves automatically into wxTopLevelWindows by
 723     // getting created in OnInit().
 724     if ( retValue == 0 )
 725     {
 726         if ( !wxTheApp->OnInit() )
 727             retValue = -1;
 728     }
 729
 730     if ( retValue == 0 )
 731     {
 732         /* delete pending toplevel windows (typically a single
 733            dialog) so that, if there isn't any left, we don't
 734            call OnRun() */
 735         wxTheApp->DeletePendingObjects();
 736
 737         wxTheApp->m_initialized = wxTopLevelWindows.GetCount() != 0;
 738
 739         if (wxTheApp->Initialized())
 740         {
 741             retValue = wxTheApp->OnRun();
 742
 743             wxWindow *topWindow = wxTheApp->GetTopWindow();
 744             if (topWindow)
 745             {
 746                 /* Forcibly delete the window. */
 747                 if (topWindow->IsKindOf(CLASSINFO(wxFrame)) ||
 748                     topWindow->IsKindOf(CLASSINFO(wxDialog)) )
 749                 {
 750                     topWindow->Close( TRUE );
 751                     wxTheApp->DeletePendingObjects();
 752                 }
 753                 else
 754                 {
 755                     delete topWindow;
 756                     wxTheApp->SetTopWindow( (wxWindow*) NULL );
 757                 }
 758             }
 759             wxTheApp->OnExit();
 760         }
 761     }
 762
 763 #if wxUSE_LOG
 764     // flush the logged messages if any
 765     wxLog *log = wxLog::GetActiveTarget();
 766     if (log != NULL && log->HasPendingMessages())
 767         log->Flush();
 768
 769     // continuing to use user defined log target is unsafe from now on because
 770     // some resources may be already unavailable, so replace it by something
 771     // more safe
 772     wxLog *oldlog = wxLog::SetActiveTarget(new wxLogStderr);
 773     if ( oldlog )
 774         delete oldlog;
 775 #endif // wxUSE_LOG
 776
 777     wxApp::CleanUp();
 778
 779     return retValue;
 780 }
 781