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 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     #include "wx/resource.h"
  31 #endif
  32
  33 #include "wx/app.h"
  34 #include "wx/fontutil.h"
  35 #include "wx/univ/theme.h"
  36 #include "wx/univ/renderer.h"
  37 #include "wx/univ/colschem.h"
  38 #include "wx/sysopt.h"
  39 #include "wx/mgl/private.h"
  40
  41 //-----------------------------------------------------------------------------
  42 // Global data
  43 //-----------------------------------------------------------------------------
  44
  45 wxApp *wxTheApp = NULL;
  46 wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
  47
  48
  49 //-----------------------------------------------------------------------------
  50 // wxExit
  51 //-----------------------------------------------------------------------------
  52
  53 void wxExit()
  54 {
  55     MGL_exit();
  56     exit(0);
  57 }
  58
  59 //-----------------------------------------------------------------------------
  60 // wxYield
  61 //-----------------------------------------------------------------------------
  62
  63 static bool gs_inYield = FALSE;
  64
  65 bool wxApp::Yield(bool onlyIfNeeded)
  66 {
  67     if ( gs_inYield )
  68     {
  69         if ( !onlyIfNeeded )
  70         {
  71             wxFAIL_MSG( wxT("wxYield called recursively" ) );
  72         }
  73
  74         return FALSE;
  75     }
  76
  77 #if wxUSE_THREADS
  78     if ( !wxThread::IsMain() )
  79     {
  80         // can't process events from other threads, MGL is thread-unsafe
  81         return TRUE;
  82     }
  83 #endif // wxUSE_THREADS
  84
  85     gs_inYield = TRUE;
  86
  87     wxLog::Suspend();
  88
  89     if ( wxEventLoop::GetActive() )
  90     {
  91         while (wxEventLoop::GetActive()->Pending())
  92             wxEventLoop::GetActive()->Dispatch();
  93     }
  94
  95     /* it's necessary to call ProcessIdle() to update the frames sizes which
  96        might have been changed (it also will update other things set from
  97        OnUpdateUI() which is a nice (and desired) side effect) */
  98     while (wxTheApp->ProcessIdle()) { }
  99
 100     wxLog::Resume();
 101
 102     gs_inYield = FALSE;
 103
 104     return TRUE;
 105 }
 106
 107
 108 //-----------------------------------------------------------------------------
 109 // wxWakeUpIdle
 110 //-----------------------------------------------------------------------------
 111
 112 void wxWakeUpIdle()
 113 {
 114 #if wxUSE_THREADS
 115     if (!wxThread::IsMain())
 116         wxMutexGuiEnter();
 117 #endif
 118
 119     while (wxTheApp->ProcessIdle()) {}
 120
 121 #if wxUSE_THREADS
 122     if (!wxThread::IsMain())
 123         wxMutexGuiLeave();
 124 #endif
 125 }
 126
 127 //-----------------------------------------------------------------------------
 128 // Root window
 129 //-----------------------------------------------------------------------------
 130
 131 class wxRootWindow : public wxWindow
 132 {
 133     public:
 134         wxRootWindow() : wxWindow(NULL, -1)
 135         {
 136             SetMGLwindow_t(MGL_wmGetRootWindow(g_winMng));
 137             SetBackgroundColour(wxTHEME_COLOUR(DESKTOP));
 138         }
 139         ~wxRootWindow()
 140         {
 141             // we don't want to delete MGL_WM's rootWnd
 142             m_wnd = NULL;
 143         }
 144
 145         virtual bool AcceptsFocus() { return FALSE; }
 146 };
 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     if ( wxGetEnv(wxT("WXDEBUG"), NULL) )
 269         freopen("output.err", "wt", stderr);
 270 #endif
 271
 272     wxLog *oldLog = wxLog::SetActiveTarget(new wxLogGui);
 273     if ( oldLog ) delete oldLog;
 274
 275     return TRUE;
 276 }
 277
 278 bool wxApp::ProcessIdle()
 279 {
 280     wxIdleEvent event;
 281     event.SetEventObject(this);
 282     ProcessEvent(event);
 283
 284     return event.MoreRequested();
 285 }
 286
 287 void wxApp::OnIdle(wxIdleEvent &event)
 288 {
 289     static bool s_inOnIdle = FALSE;
 290
 291     /* Avoid recursion (via ProcessEvent default case) */
 292     if (s_inOnIdle)
 293         return;
 294
 295     s_inOnIdle = TRUE;
 296
 297     /* Resend in the main thread events which have been prepared in other
 298        threads */
 299     ProcessPendingEvents();
 300
 301     // 'Garbage' collection of windows deleted with Close().
 302     DeletePendingObjects();
 303
 304 #if wxUSE_LOG
 305     // flush the logged messages if any
 306     wxLog::FlushActive();
 307 #endif // wxUSE_LOG
 308
 309     // Send OnIdle events to all windows
 310     if ( SendIdleEvents() )
 311         event.RequestMore(TRUE);
 312
 313     s_inOnIdle = FALSE;
 314 }
 315
 316 bool wxApp::SendIdleEvents()
 317 {
 318     bool needMore = FALSE;
 319
 320     wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
 321     while (node)
 322     {
 323         wxWindow* win = node->GetData();
 324         if ( SendIdleEvents(win) )
 325             needMore = TRUE;
 326         node = node->GetNext();
 327     }
 328
 329     return needMore;
 330 }
 331
 332 bool wxApp::SendIdleEvents(wxWindow* win)
 333 {
 334     bool needMore = FALSE;
 335
 336     wxIdleEvent event;
 337     event.SetEventObject(win);
 338
 339     win->GetEventHandler()->ProcessEvent(event);
 340
 341     if ( event.MoreRequested() )
 342         needMore = TRUE;
 343
 344     wxNode* node = win->GetChildren().First();
 345     while (node)
 346     {
 347         wxWindow* win = (wxWindow*) node->Data();
 348         if ( SendIdleEvents(win) )
 349             needMore = TRUE;
 350
 351         node = node->Next();
 352     }
 353     return needMore;
 354 }
 355
 356 int wxApp::MainLoop()
 357 {
 358     int rt;
 359     m_mainLoop = new wxEventLoop;
 360
 361     rt = m_mainLoop->Run();
 362
 363     delete m_mainLoop;
 364     m_mainLoop = NULL;
 365     return rt;
 366 }
 367
 368 void wxApp::ExitMainLoop()
 369 {
 370     if ( m_mainLoop )
 371         m_mainLoop->Exit(0);
 372 }
 373
 374 bool wxApp::Initialized()
 375 {
 376     return (wxTopLevelWindows.GetCount() != 0);
 377 }
 378
 379 bool wxApp::Pending()
 380 {
 381     return wxEventLoop::GetActive()->Pending();
 382 }
 383
 384 void wxApp::Dispatch()
 385 {
 386     wxEventLoop::GetActive()->Dispatch();
 387 }
 388
 389 void wxApp::DeletePendingObjects()
 390 {
 391     wxNode *node = wxPendingDelete.First();
 392     while (node)
 393     {
 394         wxObject *obj = (wxObject *)node->Data();
 395
 396         delete obj;
 397
 398         if ( wxPendingDelete.Find(obj) )
 399             delete node;
 400
 401         node = wxPendingDelete.First();
 402     }
 403 }
 404
 405 bool wxApp::Initialize()
 406 {
 407     if ( MGL_init(".", NULL) == 0 )
 408         return FALSE;
 409
 410     wxBuffer = new wxChar[BUFSIZ + 512];
 411
 412     wxClassInfo::InitializeClasses();
 413
 414     wxSystemSettings::Init();
 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 #if wxUSE_WX_RESOURCES
 437     wxInitializeResourceSystem();
 438 #endif
 439
 440     wxModule::RegisterModules();
 441     if (!wxModule::InitializeModules()) return FALSE;
 442
 443     return TRUE;
 444 }
 445
 446 wxIcon wxApp::GetStdIcon(int which) const
 447 {
 448     return wxTheme::Get()->GetRenderer()->GetStdIcon(which);
 449 }
 450
 451 void wxApp::CleanUp()
 452 {
 453 #if wxUSE_LOG
 454     // continuing to use user defined log target is unsafe from now on because
 455     // some resources may be already unavailable, so replace it by something
 456     // more safe
 457     wxLog *oldlog = wxLog::SetActiveTarget(new wxLogStderr);
 458     if ( oldlog )
 459         delete oldlog;
 460 #endif // wxUSE_LOG
 461
 462     delete gs_rootWindow;
 463
 464     wxModule::CleanUpModules();
 465
 466 #if wxUSE_WX_RESOURCES
 467     wxCleanUpResourceSystem();
 468 #endif
 469
 470     if (wxTheColourDatabase)
 471         delete wxTheColourDatabase;
 472
 473     wxTheColourDatabase = (wxColourDatabase*) NULL;
 474
 475     wxDeleteStockObjects();
 476     wxDeleteStockLists();
 477
 478     delete wxTheApp;
 479     wxTheApp = (wxApp*) NULL;
 480
 481
 482     // GL: I'm annoyed ... I don't know where to put this and I don't want to
 483     // create a module for that as it's part of the core.
 484 #if wxUSE_THREADS
 485     delete wxPendingEvents;
 486     delete wxPendingEventsLocker;
 487 #endif
 488
 489     wxSystemSettings::Done();
 490
 491     wxClassInfo::CleanUpClasses();
 492
 493     // Can't do this in wxModule, because fonts are needed by stock lists
 494     // (do it after deleting wxTheApp and cleaning modules up, since somebody
 495     // may be deleting fonts that lately)
 496     delete wxTheFontsManager;
 497     wxTheFontsManager = (wxFontsManager*) NULL;
 498
 499     delete[] wxBuffer;
 500
 501     // check for memory leaks
 502 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 503     if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
 504     {
 505         wxLogDebug(wxT("There were memory leaks.\n"));
 506         wxDebugContext::Dump();
 507         wxDebugContext::PrintStatistics();
 508     }
 509 #endif // Debug
 510
 511 #if wxUSE_LOG
 512     // do this as the very last thing because everything else can log messages
 513     wxLog::DontCreateOnDemand();
 514
 515     wxLog *oldLog = wxLog::SetActiveTarget( (wxLog*) NULL );
 516     if (oldLog)
 517         delete oldLog;
 518 #endif // wxUSE_LOG
 519
 520     wxDestroyMGL_WM();
 521     MGL_exit();
 522 }
 523
 524
 525 int wxEntryStart(int argc, char *argv[])
 526 {
 527     return wxApp::Initialize() ? 0 : -1;
 528 }
 529
 530
 531 int wxEntryInitGui()
 532 {
 533     return wxTheApp->OnInitGui() ? 0 : -1;
 534 }
 535
 536
 537 void wxEntryCleanup()
 538 {
 539     wxApp::CleanUp();
 540 }
 541
 542
 543
 544 int wxEntry(int argc, char *argv[])
 545 {
 546 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 547     // This seems to be necessary since there are 'rogue'
 548     // objects present at this point (perhaps global objects?)
 549     // Setting a checkpoint will ignore them as far as the
 550     // memory checking facility is concerned.
 551     // Of course you may argue that memory allocated in globals should be
 552     // checked, but this is a reasonable compromise.
 553     wxDebugContext::SetCheckpoint();
 554 #endif
 555     int err = wxEntryStart(argc, argv);
 556     if ( err )
 557         return err;
 558
 559     if ( !wxTheApp )
 560     {
 561         wxCHECK_MSG( wxApp::GetInitializerFunction(), -1,
 562                      wxT("wxWindows error: No initializer - use IMPLEMENT_APP macro.\n") );
 563
 564         wxAppInitializerFunction app_ini = wxApp::GetInitializerFunction();
 565
 566         wxObject *test_app = app_ini();
 567
 568         wxTheApp = (wxApp*) test_app;
 569     }
 570
 571     wxCHECK_MSG( wxTheApp, -1, wxT("wxWindows error: no application object") );
 572
 573     wxTheApp->argc = argc;
 574 #if wxUSE_UNICODE
 575     wxTheApp->argv = new wxChar*[argc+1];
 576     int mb_argc = 0;
 577     while (mb_argc < argc)
 578     {
 579         wxTheApp->argv[mb_argc] = wxStrdup(wxConvLibc.cMB2WX(argv[mb_argc]));
 580         mb_argc++;
 581     }
 582     wxTheApp->argv[mb_argc] = (wxChar *)NULL;
 583 #else
 584     wxTheApp->argv = argv;
 585 #endif
 586
 587     wxString name(wxFileNameFromPath(argv[0]));
 588     wxStripExtension(name);
 589     wxTheApp->SetAppName(name);
 590
 591     int retValue;
 592     retValue = wxEntryInitGui();
 593
 594     // Here frames insert themselves automatically into wxTopLevelWindows by
 595     // getting created in OnInit().
 596     if ( retValue == 0 )
 597     {
 598         if ( !wxTheApp->OnInit() )
 599             retValue = -1;
 600     }
 601
 602     if ( retValue == 0 )
 603     {
 604         /* delete pending toplevel windows (typically a single
 605            dialog) so that, if there isn't any left, we don't
 606            call OnRun() */
 607         wxTheApp->DeletePendingObjects();
 608
 609         if ( wxTheApp->Initialized() )
 610         {
 611             wxTheApp->OnRun();
 612
 613             wxWindow *topWindow = wxTheApp->GetTopWindow();
 614             if ( topWindow )
 615             {
 616                 /* Forcibly delete the window. */
 617                 if (topWindow->IsKindOf(CLASSINFO(wxFrame)) ||
 618                     topWindow->IsKindOf(CLASSINFO(wxDialog)) )
 619                 {
 620                     topWindow->Close(TRUE);
 621                     wxTheApp->DeletePendingObjects();
 622                 }
 623                 else
 624                 {
 625                     delete topWindow;
 626                     wxTheApp->SetTopWindow((wxWindow*) NULL);
 627                 }
 628             }
 629
 630 #if wxUSE_LOG
 631             // flush the logged messages if any
 632             wxLog *log = wxLog::GetActiveTarget();
 633             if (log != NULL && log->HasPendingMessages())
 634                 log->Flush();
 635 #endif // wxUSE_LOG
 636             retValue = wxTheApp->OnExit();
 637         }
 638     }
 639
 640     wxEntryCleanup();
 641
 642     return retValue;
 643 }