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 // wxApp::Exit()
  42 //-----------------------------------------------------------------------------
  43
  44 void wxApp::Exit()
  45 {
  46     MGL_exit();
  47     exit(0);
  48 }
  49
  50 //-----------------------------------------------------------------------------
  51 // wxYield
  52 //-----------------------------------------------------------------------------
  53
  54 static bool gs_inYield = FALSE;
  55
  56 bool wxApp::Yield(bool onlyIfNeeded)
  57 {
  58     if ( gs_inYield )
  59     {
  60         if ( !onlyIfNeeded )
  61         {
  62             wxFAIL_MSG( wxT("wxYield called recursively" ) );
  63         }
  64
  65         return FALSE;
  66     }
  67
  68 #if wxUSE_THREADS
  69     if ( !wxThread::IsMain() )
  70     {
  71         // can't process events from other threads, MGL is thread-unsafe
  72         return TRUE;
  73     }
  74 #endif // wxUSE_THREADS
  75
  76     gs_inYield = TRUE;
  77
  78     wxLog::Suspend();
  79
  80     if ( wxEventLoop::GetActive() )
  81     {
  82         while (wxEventLoop::GetActive()->Pending())
  83             wxEventLoop::GetActive()->Dispatch();
  84     }
  85
  86     /* it's necessary to call ProcessIdle() to update the frames sizes which
  87        might have been changed (it also will update other things set from
  88        OnUpdateUI() which is a nice (and desired) side effect) */
  89     while (wxTheApp->ProcessIdle()) { }
  90
  91     wxLog::Resume();
  92
  93     gs_inYield = FALSE;
  94
  95     return TRUE;
  96 }
  97
  98
  99 //-----------------------------------------------------------------------------
 100 // wxWakeUpIdle
 101 //-----------------------------------------------------------------------------
 102
 103 void wxApp::WakeUpIdle()
 104 {
 105 #if wxUSE_THREADS
 106     if (!wxThread::IsMain())
 107         wxMutexGuiEnter();
 108 #endif
 109
 110     while (wxTheApp->ProcessIdle())
 111         ;
 112
 113 #if wxUSE_THREADS
 114     if (!wxThread::IsMain())
 115         wxMutexGuiLeave();
 116 #endif
 117 }
 118
 119 //-----------------------------------------------------------------------------
 120 // Root window
 121 //-----------------------------------------------------------------------------
 122
 123 class wxRootWindow : public wxWindow
 124 {
 125     public:
 126         wxRootWindow() : wxWindow(NULL, -1)
 127         {
 128             SetMGLwindow_t(MGL_wmGetRootWindow(g_winMng));
 129             SetBackgroundColour(wxTHEME_COLOUR(DESKTOP));
 130         }
 131         ~wxRootWindow()
 132         {
 133             // we don't want to delete MGL_WM's rootWnd
 134             m_wnd = NULL;
 135         }
 136
 137         virtual bool AcceptsFocus() const { return FALSE; }
 138
 139         DECLARE_DYNAMIC_CLASS(wxRootWindow)
 140 };
 141
 142 IMPLEMENT_DYNAMIC_CLASS(wxRootWindow, wxWindow)
 143
 144 static wxRootWindow *gs_rootWindow = NULL;
 145
 146 //-----------------------------------------------------------------------------
 147 // MGL initialization
 148 //-----------------------------------------------------------------------------
 149
 150 static bool wxCreateMGL_WM(const wxDisplayModeInfo& displayMode)
 151 {
 152     int mode;
 153     int refresh = MGL_DEFAULT_REFRESH;
 154
 155 #if wxUSE_SYSTEM_OPTIONS
 156     if ( wxSystemOptions::HasOption(wxT("mgl.screen-refresh")) )
 157         refresh = wxSystemOptions::GetOptionInt(wxT("mgl.screen-refresh"));
 158 #endif
 159
 160     mode = MGL_findMode(displayMode.GetWidth(),
 161                         displayMode.GetHeight(),
 162                         displayMode.GetDepth());
 163     if ( mode == -1 )
 164     {
 165         wxLogError(_("Mode %ix%i-%i not available."),
 166                      displayMode.GetWidth(),
 167                      displayMode.GetHeight(),
 168                      displayMode.GetDepth());
 169         return FALSE;
 170     }
 171     g_displayDC = new MGLDisplayDC(mode, 1, refresh);
 172     if ( !g_displayDC->isValid() )
 173     {
 174         delete g_displayDC;
 175         g_displayDC = NULL;
 176         return FALSE;
 177     }
 178
 179     g_winMng = MGL_wmCreate(g_displayDC->getDC());
 180     if (!g_winMng)
 181         return FALSE;
 182
 183     return TRUE;
 184 }
 185
 186 static void wxDestroyMGL_WM()
 187 {
 188     if ( g_winMng )
 189     {
 190         MGL_wmDestroy(g_winMng);
 191         g_winMng = NULL;
 192     }
 193     if ( g_displayDC )
 194     {
 195         delete g_displayDC;
 196         g_displayDC = NULL;
 197     }
 198 }
 199
 200 //-----------------------------------------------------------------------------
 201 // wxApp
 202 //-----------------------------------------------------------------------------
 203
 204 IMPLEMENT_DYNAMIC_CLASS(wxApp,wxEvtHandler)
 205
 206 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 207     EVT_IDLE(wxApp::OnIdle)
 208 END_EVENT_TABLE()
 209
 210
 211 wxApp::wxApp() : m_mainLoop(NULL)
 212 {
 213 }
 214
 215 wxApp::~wxApp()
 216 {
 217 }
 218
 219 wxDisplayModeInfo wxGetDefaultDisplayMode()
 220 {
 221     wxString mode;
 222     unsigned w, h, bpp;
 223
 224     if ( !wxGetEnv(wxT("WXMODE"), &mode) ||
 225          (wxSscanf(mode.c_str(), _T("%ux%u-%u"), &w, &h, &bpp) != 3) )
 226     {
 227         w = 640, h = 480, bpp = 16;
 228     }
 229
 230     return wxDisplayModeInfo(w, h, bpp);
 231 }
 232
 233 bool wxApp::SetDisplayMode(const wxDisplayModeInfo& mode)
 234 {
 235     if ( !mode.IsOk() )
 236     {
 237         return FALSE;
 238     }
 239     if ( g_displayDC != NULL )
 240     {
 241         // FIXME_MGL -- we currently don't allow to switch video mode
 242         // more than once. This can hopefully be changed...
 243         wxFAIL_MSG(wxT("Can't change display mode after intialization!"));
 244         return FALSE;
 245     }
 246
 247     if ( !wxCreateMGL_WM(mode) )
 248         return FALSE;
 249     gs_rootWindow = new wxRootWindow;
 250
 251     m_displayMode = mode;
 252
 253     return TRUE;
 254 }
 255
 256 bool wxApp::OnInitGui()
 257 {
 258     if ( !wxAppBase::OnInitGui() )
 259         return FALSE;
 260
 261 #ifdef __WXDEBUG__
 262     // MGL redirects stdout and stderr to physical console, so lets redirect
 263     // it to file. Do it only when WXDEBUG environment variable is set
 264     wxString redirect;
 265     if ( wxGetEnv(wxT("WXSTDERR"), &redirect) )
 266         freopen(redirect.mb_str(), "wt", stderr);
 267 #endif
 268
 269     wxLog *oldLog = wxLog::SetActiveTarget(new wxLogGui);
 270     if ( oldLog ) delete oldLog;
 271
 272     return TRUE;
 273 }
 274
 275 bool wxApp::ProcessIdle()
 276 {
 277     wxIdleEvent event;
 278     event.SetEventObject(this);
 279     ProcessEvent(event);
 280
 281     wxUpdateUIEvent::ResetUpdateTime();
 282
 283     return event.MoreRequested();
 284 }
 285
 286 void wxApp::OnIdle(wxIdleEvent &event)
 287 {
 288     static bool s_inOnIdle = FALSE;
 289
 290     /* Avoid recursion (via ProcessEvent default case) */
 291     if (s_inOnIdle)
 292         return;
 293
 294     s_inOnIdle = TRUE;
 295
 296     /* Resend in the main thread events which have been prepared in other
 297        threads */
 298     ProcessPendingEvents();
 299
 300     // 'Garbage' collection of windows deleted with Close().
 301     DeletePendingObjects();
 302
 303 #if wxUSE_LOG
 304     // flush the logged messages if any
 305     wxLog::FlushActive();
 306 #endif // wxUSE_LOG
 307
 308     // Send OnIdle events to all windows
 309     if ( SendIdleEvents() )
 310         event.RequestMore(TRUE);
 311
 312     s_inOnIdle = FALSE;
 313 }
 314
 315 bool wxApp::SendIdleEvents()
 316 {
 317     bool needMore = FALSE;
 318
 319     wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
 320     while (node)
 321     {
 322         wxWindow* win = node->GetData();
 323         if ( SendIdleEvents(win) )
 324             needMore = TRUE;
 325         node = node->GetNext();
 326     }
 327
 328     return needMore;
 329 }
 330
 331 bool wxApp::SendIdleEvents(wxWindow* win)
 332 {
 333     bool needMore = FALSE;
 334
 335     wxIdleEvent event;
 336     event.SetEventObject(win);
 337
 338     win->GetEventHandler()->ProcessEvent(event);
 339
 340     if ( event.MoreRequested() )
 341         needMore = TRUE;
 342
 343     wxNode* node = win->GetChildren().First();
 344     while (node)
 345     {
 346         wxWindow* win = (wxWindow*) node->Data();
 347         if ( SendIdleEvents(win) )
 348             needMore = TRUE;
 349
 350         node = node->Next();
 351     }
 352     return needMore;
 353 }
 354
 355 int wxApp::MainLoop()
 356 {
 357     int rt;
 358     m_mainLoop = new wxEventLoop;
 359
 360     rt = m_mainLoop->Run();
 361
 362     delete m_mainLoop;
 363     m_mainLoop = NULL;
 364     return rt;
 365 }
 366
 367 void wxApp::ExitMainLoop()
 368 {
 369     if ( m_mainLoop )
 370         m_mainLoop->Exit(0);
 371 }
 372
 373 bool wxApp::Initialized()
 374 {
 375     return (wxTopLevelWindows.GetCount() != 0);
 376 }
 377
 378 bool wxApp::Pending()
 379 {
 380     return wxEventLoop::GetActive()->Pending();
 381 }
 382
 383 void wxApp::Dispatch()
 384 {
 385     wxEventLoop::GetActive()->Dispatch();
 386 }
 387
 388 bool wxApp::Initialize(int& argc, wxChar **argv)
 389 {
 390 #ifdef __DJGPP__
 391     // VS: disable long filenames under DJGPP as the very first thing,
 392     //     since SciTech MGL doesn't like them much...
 393     wxSetEnv(wxT("LFN"), wxT("N"));
 394 #endif
 395
 396     // must do it before calling wxAppBase::Initialize(), because fonts are
 397     // needed by stock lists which are created there
 398     wxTheFontsManager = new wxFontsManager;
 399
 400     if ( !wxAppBase::Initialize(argc, argv) )
 401         return false;
 402
 403     if ( MGL_init(".", NULL) == 0 )
 404     {
 405         wxLogError(_("Cannot initialize SciTech MGL!"));
 406
 407         wxAppBase::CleanUp();
 408
 409         return false;
 410     }
 411
 412 #if wxUSE_INTL
 413     wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
 414 #endif
 415
 416     return true;
 417 }
 418
 419 void wxApp::CleanUp()
 420 {
 421     delete gs_rootWindow;
 422
 423     wxAppBase::CleanUp();
 424
 425     // must do this after calling base class CleanUp()
 426     delete wxTheFontsManager;
 427     wxTheFontsManager = (wxFontsManager*) NULL;
 428
 429     wxDestroyMGL_WM();
 430     MGL_exit();
 431 }
 432