src/mgl/app.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        app.cpp
   3 // Author:      Vaclav Slavik
   4 //              based on GTK and MSW implementations
   5 // Id:          $Id$
   6 // Copyright:   (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #ifdef __GNUG__
  11     #pragma implementation "app.h"
  12 #endif
  13
  14 // For compilers that support precompilation, includes "wx.h".
  15 #include "wx/wxprec.h"
  16
  17 #ifdef __BORLANDC__
  18     #pragma hdrstop
  19 #endif
  20
  21
  22 #ifndef WX_PRECOMP
  23     #include "wx/settings.h"
  24     #include "wx/module.h"
  25     #include "wx/evtloop.h"
  26     #include "wx/frame.h"
  27     #include "wx/dialog.h"
  28     #include "wx/log.h"
  29     #include "wx/intl.h"
  30 #endif
  31
  32 #include "wx/app.h"
  33 #include "wx/fontutil.h"
  34 #include "wx/univ/theme.h"
  35 #include "wx/univ/renderer.h"
  36 #include "wx/univ/colschem.h"
  37 #include "wx/sysopt.h"
  38 #include "wx/mgl/private.h"
  39
  40 //-----------------------------------------------------------------------------
  41 // Global data
  42 //-----------------------------------------------------------------------------
  43
  44 wxApp *wxTheApp = NULL;
  45 wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
  46
  47
  48 void wxApp::Exit()
  49 {
  50     MGL_exit();
  51     exit(0);
  52 }
  53
  54 //-----------------------------------------------------------------------------
  55 // wxYield
  56 //-----------------------------------------------------------------------------
  57
  58 static bool gs_inYield = FALSE;
  59
  60 bool wxApp::Yield(bool onlyIfNeeded)
  61 {
  62     if ( gs_inYield )
  63     {
  64         if ( !onlyIfNeeded )
  65         {
  66             wxFAIL_MSG( wxT("wxYield called recursively" ) );
  67         }
  68
  69         return FALSE;
  70     }
  71
  72 #if wxUSE_THREADS
  73     if ( !wxThread::IsMain() )
  74     {
  75         // can't process events from other threads, MGL is thread-unsafe
  76         return TRUE;
  77     }
  78 #endif // wxUSE_THREADS
  79
  80     gs_inYield = TRUE;
  81
  82     wxLog::Suspend();
  83
  84     if ( wxEventLoop::GetActive() )
  85     {
  86         while (wxEventLoop::GetActive()->Pending())
  87             wxEventLoop::GetActive()->Dispatch();
  88     }
  89
  90     /* it's necessary to call ProcessIdle() to update the frames sizes which
  91        might have been changed (it also will update other things set from
  92        OnUpdateUI() which is a nice (and desired) side effect) */
  93     while (wxTheApp->ProcessIdle()) { }
  94
  95     wxLog::Resume();
  96
  97     gs_inYield = FALSE;
  98
  99     return TRUE;
 100 }
 101
 102
 103 //-----------------------------------------------------------------------------
 104 // wxWakeUpIdle
 105 //-----------------------------------------------------------------------------
 106
 107 void wxApp::WakeUpIdle()
 108 {
 109 #if wxUSE_THREADS
 110     if (!wxThread::IsMain())
 111         wxMutexGuiEnter();
 112 #endif
 113
 114     while (wxTheApp->ProcessIdle())
 115         ;
 116
 117 #if wxUSE_THREADS
 118     if (!wxThread::IsMain())
 119         wxMutexGuiLeave();
 120 #endif
 121 }
 122
 123 //-----------------------------------------------------------------------------
 124 // Root window
 125 //-----------------------------------------------------------------------------
 126
 127 class wxRootWindow : public wxWindow
 128 {
 129     public:
 130         wxRootWindow() : wxWindow(NULL, -1)
 131         {
 132             SetMGLwindow_t(MGL_wmGetRootWindow(g_winMng));
 133             SetBackgroundColour(wxTHEME_COLOUR(DESKTOP));
 134         }
 135         ~wxRootWindow()
 136         {
 137             // we don't want to delete MGL_WM's rootWnd
 138             m_wnd = NULL;
 139         }
 140
 141         virtual bool AcceptsFocus() const { return FALSE; }
 142
 143         DECLARE_DYNAMIC_CLASS(wxRootWindow)
 144 };
 145
 146 IMPLEMENT_DYNAMIC_CLASS(wxRootWindow, wxWindow)
 147
 148 static wxRootWindow *gs_rootWindow = NULL;
 149
 150 //-----------------------------------------------------------------------------
 151 // MGL initialization
 152 //-----------------------------------------------------------------------------
 153
 154 static bool wxCreateMGL_WM(const wxDisplayModeInfo& displayMode)
 155 {
 156     int mode;
 157     int refresh = MGL_DEFAULT_REFRESH;
 158
 159 #if wxUSE_SYSTEM_OPTIONS
 160     if ( wxSystemOptions::HasOption(wxT("mgl.screen-refresh")) )
 161         refresh = wxSystemOptions::GetOptionInt(wxT("mgl.screen-refresh"));
 162 #endif
 163
 164     mode = MGL_findMode(displayMode.GetWidth(),
 165                         displayMode.GetHeight(),
 166                         displayMode.GetDepth());
 167     if ( mode == -1 )
 168     {
 169         wxLogError(_("Mode %ix%i-%i not available."),
 170                      displayMode.GetWidth(),
 171                      displayMode.GetHeight(),
 172                      displayMode.GetDepth());
 173         return FALSE;
 174     }
 175     g_displayDC = new MGLDisplayDC(mode, 1, refresh);
 176     if ( !g_displayDC->isValid() )
 177     {
 178         delete g_displayDC;
 179         g_displayDC = NULL;
 180         return FALSE;
 181     }
 182
 183     g_winMng = MGL_wmCreate(g_displayDC->getDC());
 184     if (!g_winMng)
 185         return FALSE;
 186
 187     return TRUE;
 188 }
 189
 190 static void wxDestroyMGL_WM()
 191 {
 192     if ( g_winMng )
 193     {
 194         MGL_wmDestroy(g_winMng);
 195         g_winMng = NULL;
 196     }
 197     if ( g_displayDC )
 198     {
 199         delete g_displayDC;
 200         g_displayDC = NULL;
 201     }
 202 }
 203
 204 //-----------------------------------------------------------------------------
 205 // wxApp
 206 //-----------------------------------------------------------------------------
 207
 208 IMPLEMENT_DYNAMIC_CLASS(wxApp,wxEvtHandler)
 209
 210 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 211     EVT_IDLE(wxApp::OnIdle)
 212 END_EVENT_TABLE()
 213
 214
 215 wxApp::wxApp() : m_mainLoop(NULL)
 216 {
 217 }
 218
 219 wxApp::~wxApp()
 220 {
 221 }
 222
 223 wxDisplayModeInfo wxGetDefaultDisplayMode()
 224 {
 225     wxString mode;
 226     unsigned w, h, bpp;
 227
 228     if ( !wxGetEnv(wxT("WXMODE"), &mode) ||
 229          (wxSscanf(mode.c_str(), _T("%ux%u-%u"), &w, &h, &bpp) != 3) )
 230     {
 231         w = 640, h = 480, bpp = 16;
 232     }
 233
 234     return wxDisplayModeInfo(w, h, bpp);
 235 }
 236
 237 bool wxApp::SetDisplayMode(const wxDisplayModeInfo& mode)
 238 {
 239     if ( !mode.IsOk() )
 240     {
 241         return FALSE;
 242     }
 243     if ( g_displayDC != NULL )
 244     {
 245         // FIXME_MGL -- we currently don't allow to switch video mode
 246         // more than once. This can hopefully be changed...
 247         wxFAIL_MSG(wxT("Can't change display mode after intialization!"));
 248         return FALSE;
 249     }
 250
 251     if ( !wxCreateMGL_WM(mode) )
 252         return FALSE;
 253     gs_rootWindow = new wxRootWindow;
 254
 255     m_displayMode = mode;
 256
 257     return TRUE;
 258 }
 259
 260 bool wxApp::OnInitGui()
 261 {
 262     if ( !wxAppBase::OnInitGui() )
 263         return FALSE;
 264
 265 #ifdef __WXDEBUG__
 266     // MGL redirects stdout and stderr to physical console, so lets redirect
 267     // it to file. Do it only when WXDEBUG environment variable is set
 268     wxString redirect;
 269     if ( wxGetEnv(wxT("WXSTDERR"), &redirect) )
 270         freopen(redirect.mb_str(), "wt", stderr);
 271 #endif
 272
 273     wxLog *oldLog = wxLog::SetActiveTarget(new wxLogGui);
 274     if ( oldLog ) delete oldLog;
 275
 276     return TRUE;
 277 }
 278
 279 bool wxApp::ProcessIdle()
 280 {
 281     wxIdleEvent event;
 282     event.SetEventObject(this);
 283     ProcessEvent(event);
 284
 285     return event.MoreRequested();
 286 }
 287
 288 void wxApp::OnIdle(wxIdleEvent &event)
 289 {
 290     static bool s_inOnIdle = FALSE;
 291
 292     /* Avoid recursion (via ProcessEvent default case) */
 293     if (s_inOnIdle)
 294         return;
 295
 296     s_inOnIdle = TRUE;
 297
 298     /* Resend in the main thread events which have been prepared in other
 299        threads */
 300     ProcessPendingEvents();
 301
 302     // 'Garbage' collection of windows deleted with Close().
 303     DeletePendingObjects();
 304
 305 #if wxUSE_LOG
 306     // flush the logged messages if any
 307     wxLog::FlushActive();
 308 #endif // wxUSE_LOG
 309
 310     // Send OnIdle events to all windows
 311     if ( SendIdleEvents() )
 312         event.RequestMore(TRUE);
 313
 314     s_inOnIdle = FALSE;
 315 }
 316
 317 bool wxApp::SendIdleEvents()
 318 {
 319     bool needMore = FALSE;
 320
 321     wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
 322     while (node)
 323     {
 324         wxWindow* win = node->GetData();
 325         if ( SendIdleEvents(win) )
 326             needMore = TRUE;
 327         node = node->GetNext();
 328     }
 329
 330     return needMore;
 331 }
 332
 333 bool wxApp::SendIdleEvents(wxWindow* win)
 334 {
 335     bool needMore = FALSE;
 336
 337     wxIdleEvent event;
 338     event.SetEventObject(win);
 339
 340     win->GetEventHandler()->ProcessEvent(event);
 341
 342     if ( event.MoreRequested() )
 343         needMore = TRUE;
 344
 345     wxNode* node = win->GetChildren().First();
 346     while (node)
 347     {
 348         wxWindow* win = (wxWindow*) node->Data();
 349         if ( SendIdleEvents(win) )
 350             needMore = TRUE;
 351
 352         node = node->Next();
 353     }
 354     return needMore;
 355 }
 356
 357 int wxApp::MainLoop()
 358 {
 359     int rt;
 360     m_mainLoop = new wxEventLoop;
 361
 362     rt = m_mainLoop->Run();
 363
 364     delete m_mainLoop;
 365     m_mainLoop = NULL;
 366     return rt;
 367 }
 368
 369 void wxApp::ExitMainLoop()
 370 {
 371     if ( m_mainLoop )
 372         m_mainLoop->Exit(0);
 373 }
 374
 375 bool wxApp::Initialized()
 376 {
 377     return (wxTopLevelWindows.GetCount() != 0);
 378 }
 379
 380 bool wxApp::Pending()
 381 {
 382     return wxEventLoop::GetActive()->Pending();
 383 }
 384
 385 void wxApp::Dispatch()
 386 {
 387     wxEventLoop::GetActive()->Dispatch();
 388 }
 389
 390 void wxApp::DeletePendingObjects()
 391 {
 392     wxNode *node = wxPendingDelete.First();
 393     while (node)
 394     {
 395         wxObject *obj = (wxObject *)node->Data();
 396
 397         delete obj;
 398
 399         if ( wxPendingDelete.Find(obj) )
 400             delete node;
 401
 402         node = wxPendingDelete.First();
 403     }
 404 }
 405
 406 bool wxApp::Initialize()
 407 {
 408     if ( MGL_init(".", NULL) == 0 )
 409     {
 410         wxLogError(_("Cannot initialize SciTech MGL!"));
 411         return FALSE;
 412     }
 413
 414     wxClassInfo::InitializeClasses();
 415
 416 #if wxUSE_INTL
 417     wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
 418 #endif
 419
 420     // GL: I'm annoyed ... I don't know where to put this and I don't want to
 421     // create a module for that as it's part of the core.
 422 #if wxUSE_THREADS
 423     wxPendingEvents = new wxList;
 424     wxPendingEventsLocker = new wxCriticalSection;
 425 #endif
 426
 427     wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
 428     wxTheColourDatabase->Initialize();
 429
 430     // Can't do this in wxModule, because fonts are needed by stock lists
 431     wxTheFontsManager = new wxFontsManager;
 432
 433     wxInitializeStockLists();
 434     wxInitializeStockObjects();
 435
 436     wxModule::RegisterModules();
 437     if (!wxModule::InitializeModules()) return FALSE;
 438
 439     return TRUE;
 440 }
 441
 442 void wxApp::CleanUp()
 443 {
 444 #if wxUSE_LOG
 445     // continuing to use user defined log target is unsafe from now on because
 446     // some resources may be already unavailable, so replace it by something
 447     // more safe
 448     wxLog *oldlog = wxLog::SetActiveTarget(new wxLogStderr);
 449     if ( oldlog )
 450         delete oldlog;
 451 #endif // wxUSE_LOG
 452
 453     delete gs_rootWindow;
 454
 455     wxModule::CleanUpModules();
 456
 457     if (wxTheColourDatabase)
 458         delete wxTheColourDatabase;
 459
 460     wxTheColourDatabase = (wxColourDatabase*) NULL;
 461
 462     wxDeleteStockObjects();
 463     wxDeleteStockLists();
 464
 465     delete wxTheApp;
 466     wxTheApp = (wxApp*) NULL;
 467
 468
 469     // GL: I'm annoyed ... I don't know where to put this and I don't want to
 470     // create a module for that as it's part of the core.
 471 #if wxUSE_THREADS
 472     delete wxPendingEvents;
 473     delete wxPendingEventsLocker;
 474 #endif
 475
 476     wxClassInfo::CleanUpClasses();
 477
 478     // Can't do this in wxModule, because fonts are needed by stock lists
 479     // (do it after deleting wxTheApp and cleaning modules up, since somebody
 480     // may be deleting fonts that lately)
 481     delete wxTheFontsManager;
 482     wxTheFontsManager = (wxFontsManager*) NULL;
 483
 484     // check for memory leaks
 485 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 486     if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
 487     {
 488         wxLogDebug(wxT("There were memory leaks.\n"));
 489         wxDebugContext::Dump();
 490         wxDebugContext::PrintStatistics();
 491     }
 492 #endif // Debug
 493
 494 #if wxUSE_LOG
 495     // do this as the very last thing because everything else can log messages
 496     wxLog::DontCreateOnDemand();
 497
 498     wxLog *oldLog = wxLog::SetActiveTarget( (wxLog*) NULL );
 499     if (oldLog)
 500         delete oldLog;
 501 #endif // wxUSE_LOG
 502
 503     wxDestroyMGL_WM();
 504     MGL_exit();
 505 }
 506
 507
 508 int wxEntryStart(int argc, char *argv[])
 509 {
 510     return wxApp::Initialize() ? 0 : -1;
 511 }
 512
 513
 514 int wxEntryInitGui()
 515 {
 516     return wxTheApp->OnInitGui() ? 0 : -1;
 517 }
 518
 519
 520 void wxEntryCleanup()
 521 {
 522     wxApp::CleanUp();
 523 }
 524
 525
 526
 527 int wxEntry(int argc, char *argv[])
 528 {
 529 #ifdef __DJGPP__
 530     // VS: disable long filenames under DJGPP as the very first thing,
 531     //     since SciTech MGL doesn't like them much...
 532     wxSetEnv(wxT("LFN"), wxT("N"));
 533 #endif
 534
 535 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 536     // This seems to be necessary since there are 'rogue'
 537     // objects present at this point (perhaps global objects?)
 538     // Setting a checkpoint will ignore them as far as the
 539     // memory checking facility is concerned.
 540     // Of course you may argue that memory allocated in globals should be
 541     // checked, but this is a reasonable compromise.
 542     wxDebugContext::SetCheckpoint();
 543 #endif
 544     int err = wxEntryStart(argc, argv);
 545     if ( err )
 546         return err;
 547
 548     if ( !wxTheApp )
 549     {
 550         wxCHECK_MSG( wxApp::GetInitializerFunction(), -1,
 551                      wxT("wxWindows error: No initializer - use IMPLEMENT_APP macro.\n") );
 552
 553         wxAppInitializerFunction app_ini = wxApp::GetInitializerFunction();
 554
 555         wxObject *test_app = app_ini();
 556
 557         wxTheApp = (wxApp*) test_app;
 558     }
 559
 560     wxCHECK_MSG( wxTheApp, -1, wxT("wxWindows error: no application object") );
 561
 562     wxTheApp->argc = argc;
 563 #if wxUSE_UNICODE
 564     wxTheApp->argv = new wxChar*[argc+1];
 565     int mb_argc = 0;
 566     while (mb_argc < argc)
 567     {
 568         wxTheApp->argv[mb_argc] = wxStrdup(wxConvLibc.cMB2WX(argv[mb_argc]));
 569         mb_argc++;
 570     }
 571     wxTheApp->argv[mb_argc] = (wxChar *)NULL;
 572 #else
 573     wxTheApp->argv = argv;
 574 #endif
 575
 576     wxString name(wxFileNameFromPath(argv[0]));
 577     wxStripExtension(name);
 578     wxTheApp->SetAppName(name);
 579
 580     int retValue;
 581     retValue = wxEntryInitGui();
 582
 583     // Here frames insert themselves automatically into wxTopLevelWindows by
 584     // getting created in OnInit().
 585     if ( retValue == 0 )
 586     {
 587         if ( !wxTheApp->OnInit() )
 588             retValue = -1;
 589     }
 590
 591     if ( retValue == 0 )
 592     {
 593         /* delete pending toplevel windows (typically a single
 594            dialog) so that, if there isn't any left, we don't
 595            call OnRun() */
 596         wxTheApp->DeletePendingObjects();
 597
 598         if ( wxTheApp->Initialized() )
 599         {
 600             wxTheApp->OnRun();
 601
 602             wxWindow *topWindow = wxTheApp->GetTopWindow();
 603             if ( topWindow )
 604             {
 605                 /* Forcibly delete the window. */
 606                 if (topWindow->IsKindOf(CLASSINFO(wxFrame)) ||
 607                     topWindow->IsKindOf(CLASSINFO(wxDialog)) )
 608                 {
 609                     topWindow->Close(TRUE);
 610                     wxTheApp->DeletePendingObjects();
 611                 }
 612                 else
 613                 {
 614                     delete topWindow;
 615                     wxTheApp->SetTopWindow((wxWindow*) NULL);
 616                 }
 617             }
 618
 619 #if wxUSE_LOG
 620             // flush the logged messages if any
 621             wxLog *log = wxLog::GetActiveTarget();
 622             if (log != NULL && log->HasPendingMessages())
 623                 log->Flush();
 624 #endif // wxUSE_LOG
 625             retValue = wxTheApp->OnExit();
 626         }
 627     }
 628
 629     wxEntryCleanup();
 630
 631     return retValue;
 632 }