src/common/init.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        common/init.cpp
   3 // Purpose:     initialisation for the library
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     04.10.99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Vadim Zeitlin
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #include "wx/wxprec.h"
  21
  22 #ifdef    __BORLANDC__
  23   #pragma hdrstop
  24 #endif  //__BORLANDC__
  25
  26 #ifndef WX_PRECOMP
  27     #include "wx/app.h"
  28     #include "wx/debug.h"
  29     #include "wx/filefn.h"
  30     #include "wx/log.h"
  31     #include "wx/thread.h"
  32 #endif
  33
  34 #include "wx/init.h"
  35
  36 #include "wx/ptr_scpd.h"
  37 #include "wx/module.h"
  38 #include "wx/except.h"
  39
  40 #if defined(__WXMSW__) && defined(__WXDEBUG__)
  41     #include "wx/msw/msvcrt.h"
  42
  43     static struct EnableMemLeakChecking
  44     {
  45         EnableMemLeakChecking()
  46         {
  47             // do check for memory leaks on program exit (another useful flag
  48             // is _CRTDBG_DELAY_FREE_MEM_DF which doesn't free deallocated
  49             // memory which may be used to simulate low-memory condition)
  50             wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF);
  51         }
  52     } gs_enableLeakChecks;
  53 #endif // __WXMSW__ && __WXDEBUG__
  54
  55 // ----------------------------------------------------------------------------
  56 // private classes
  57 // ----------------------------------------------------------------------------
  58
  59 // we need a dummy app object if the user doesn't want to create a real one
  60 class wxDummyConsoleApp : public wxAppConsole
  61 {
  62 public:
  63     wxDummyConsoleApp() { }
  64
  65     virtual int OnRun() { wxFAIL_MSG( _T("unreachable code") ); return 0; }
  66
  67     DECLARE_NO_COPY_CLASS(wxDummyConsoleApp)
  68 };
  69
  70 // we need a special kind of auto pointer to wxApp which not only deletes the
  71 // pointer it holds in its dtor but also resets the global application pointer
  72 wxDECLARE_SCOPED_PTR(wxAppConsole, wxAppPtrBase);
  73 wxDEFINE_SCOPED_PTR(wxAppConsole, wxAppPtrBase);
  74
  75 class wxAppPtr : public wxAppPtrBase
  76 {
  77 public:
  78     wxEXPLICIT wxAppPtr(wxAppConsole *ptr = NULL) : wxAppPtrBase(ptr) { }
  79     ~wxAppPtr()
  80     {
  81         if ( get() )
  82         {
  83             // the pointer is going to be deleted in the base class dtor, don't
  84             // leave the dangling pointer!
  85             wxApp::SetInstance(NULL);
  86         }
  87     }
  88
  89     void Set(wxAppConsole *ptr)
  90     {
  91         reset(ptr);
  92
  93         wxApp::SetInstance(ptr);
  94     }
  95
  96     DECLARE_NO_COPY_CLASS(wxAppPtr)
  97 };
  98
  99 // class to ensure that wxAppBase::CleanUp() is called if our Initialize()
 100 // fails
 101 class wxCallAppCleanup
 102 {
 103 public:
 104     wxCallAppCleanup(wxAppConsole *app) : m_app(app) { }
 105     ~wxCallAppCleanup() { if ( m_app ) m_app->CleanUp(); }
 106
 107     void Dismiss() { m_app = NULL; }
 108
 109 private:
 110     wxAppConsole *m_app;
 111 };
 112
 113 // another tiny class which simply exists to ensure that wxEntryCleanup is
 114 // always called
 115 class wxCleanupOnExit
 116 {
 117 public:
 118     ~wxCleanupOnExit() { wxEntryCleanup(); }
 119 };
 120
 121 // ----------------------------------------------------------------------------
 122 // private functions
 123 // ----------------------------------------------------------------------------
 124
 125 // suppress warnings about unused variables
 126 static inline void Use(void *) { }
 127
 128 #define WX_SUPPRESS_UNUSED_WARN(x) Use(&x)
 129
 130 // ----------------------------------------------------------------------------
 131 // initialization data
 132 // ----------------------------------------------------------------------------
 133
 134 static struct InitData
 135 {
 136     InitData()
 137     {
 138         nInitCount = 0;
 139
 140 #if wxUSE_UNICODE
 141         argc = 0;
 142         // argv = NULL; -- not even really needed
 143 #endif // wxUSE_UNICODE
 144     }
 145
 146     // critical section protecting this struct
 147     wxCRIT_SECT_DECLARE_MEMBER(csInit);
 148
 149     // number of times wxInitialize() was called minus the number of times
 150     // wxUninitialize() was
 151     size_t nInitCount;
 152
 153 #if wxUSE_UNICODE
 154     int argc;
 155
 156     // if we receive the command line arguments as ASCII and have to convert
 157     // them to Unicode ourselves (this is the case under Unix but not Windows,
 158     // for example), we remember the converted argv here because we'll have to
 159     // free it when doing cleanup to avoid memory leaks
 160     wchar_t **argv;
 161 #endif // wxUSE_UNICODE
 162
 163     DECLARE_NO_COPY_CLASS(InitData)
 164 } gs_initData;
 165
 166 // ============================================================================
 167 // implementation
 168 // ============================================================================
 169
 170 // ----------------------------------------------------------------------------
 171 // command line arguments ANSI -> Unicode conversion
 172 // ----------------------------------------------------------------------------
 173
 174 #if wxUSE_UNICODE
 175
 176 static void ConvertArgsToUnicode(int argc, char **argv)
 177 {
 178     gs_initData.argv = new wchar_t *[argc + 1];
 179     for ( int i = 0; i < argc; i++ )
 180     {
 181         gs_initData.argv[i] = wxStrdup(wxConvLocal.cMB2WX(argv[i]));
 182     }
 183
 184     gs_initData.argv[argc] = NULL;
 185 }
 186
 187 static void FreeConvertedArgs()
 188 {
 189     if ( gs_initData.argv )
 190     {
 191         for ( int i = 0; i < gs_initData.argc; i++ )
 192         {
 193             free(gs_initData.argv[i]);
 194         }
 195
 196         delete [] gs_initData.argv;
 197         gs_initData.argv = NULL;
 198     }
 199 }
 200
 201 #endif // wxUSE_UNICODE
 202
 203 // ----------------------------------------------------------------------------
 204 // start up
 205 // ----------------------------------------------------------------------------
 206
 207 // initialization which is always done (not customizable) before wxApp creation
 208 static bool DoCommonPreInit()
 209 {
 210     return true;
 211 }
 212
 213 // non customizable initialization done after wxApp creation and initialization
 214 static bool DoCommonPostInit()
 215 {
 216     wxModule::RegisterModules();
 217
 218     return wxModule::InitializeModules();
 219 }
 220
 221 bool wxEntryStart(int& argc, wxChar **argv)
 222 {
 223     // do minimal, always necessary, initialization
 224     // --------------------------------------------
 225
 226     // initialize wxRTTI
 227     if ( !DoCommonPreInit() )
 228     {
 229         return false;
 230     }
 231
 232
 233     // first of all, we need an application object
 234     // -------------------------------------------
 235
 236     // the user might have already created it himself somehow
 237     wxAppPtr app(wxTheApp);
 238     if ( !app.get() )
 239     {
 240         // if not, he might have used IMPLEMENT_APP() to give us a function to
 241         // create it
 242         wxAppInitializerFunction fnCreate = wxApp::GetInitializerFunction();
 243
 244         if ( fnCreate )
 245         {
 246             // he did, try to create the custom wxApp object
 247             app.Set((*fnCreate)());
 248         }
 249     }
 250
 251     if ( !app.get() )
 252     {
 253         // either IMPLEMENT_APP() was not used at all or it failed -- in any
 254         // case we still need something
 255         app.Set(new wxDummyConsoleApp);
 256     }
 257
 258
 259     // wxApp initialization: this can be customized
 260     // --------------------------------------------
 261
 262     if ( !app->Initialize(argc, argv) )
 263     {
 264         return false;
 265     }
 266
 267     wxCallAppCleanup callAppCleanup(app.get());
 268
 269     // for compatibility call the old initialization function too
 270     if ( !app->OnInitGui() )
 271         return false;
 272
 273
 274     // common initialization after wxTheApp creation
 275     // ---------------------------------------------
 276
 277     if ( !DoCommonPostInit() )
 278         return false;
 279
 280
 281     // prevent the smart pointer from destroying its contents
 282     app.release();
 283
 284     // and the cleanup object from doing cleanup
 285     callAppCleanup.Dismiss();
 286
 287     return true;
 288 }
 289
 290 #if wxUSE_UNICODE
 291
 292 // we provide a wxEntryStart() wrapper taking "char *" pointer too
 293 bool wxEntryStart(int& argc, char **argv)
 294 {
 295     ConvertArgsToUnicode(argc, argv);
 296
 297     if ( !wxEntryStart(argc, gs_initData.argv) )
 298     {
 299         FreeConvertedArgs();
 300
 301         return false;
 302     }
 303
 304     return true;
 305 }
 306
 307 #endif // wxUSE_UNICODE
 308
 309 // ----------------------------------------------------------------------------
 310 // clean up
 311 // ----------------------------------------------------------------------------
 312
 313 // cleanup done before destroying wxTheApp
 314 static void DoCommonPreCleanup()
 315 {
 316 #if wxUSE_LOG
 317     // flush the logged messages if any and install a 'safer' log target: the
 318     // default one (wxLogGui) can't be used after the resources are freed just
 319     // below and the user supplied one might be even more unsafe (using any
 320     // wxWindows GUI function is unsafe starting from now)
 321     wxLog::DontCreateOnDemand();
 322
 323     // this will flush the old messages if any
 324     delete wxLog::SetActiveTarget(new wxLogStderr);
 325 #endif // wxUSE_LOG
 326
 327     wxModule::CleanUpModules();
 328 }
 329
 330 // cleanup done after destroying wxTheApp
 331 static void DoCommonPostCleanup()
 332 {
 333     wxClassInfo::CleanUp();
 334
 335     // we can't do this in wxApp itself because it doesn't know if argv had
 336     // been allocated
 337 #if wxUSE_UNICODE
 338     FreeConvertedArgs();
 339 #endif // wxUSE_UNICODE
 340
 341     // check for memory leaks
 342 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 343     if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
 344     {
 345         wxLogDebug(wxT("There were memory leaks.\n"));
 346         wxDebugContext::Dump();
 347         wxDebugContext::PrintStatistics();
 348     }
 349 #endif // Debug
 350
 351 #if wxUSE_LOG
 352     // and now delete the last logger as well
 353     delete wxLog::SetActiveTarget(NULL);
 354 #endif // wxUSE_LOG
 355 }
 356
 357 void wxEntryCleanup()
 358 {
 359     DoCommonPreCleanup();
 360
 361
 362     // delete the application object
 363     if ( wxTheApp )
 364     {
 365         wxTheApp->CleanUp();
 366
 367         delete wxTheApp;
 368         wxApp::SetInstance(NULL);
 369     }
 370
 371
 372     DoCommonPostCleanup();
 373 }
 374
 375 // ----------------------------------------------------------------------------
 376 // wxEntry
 377 // ----------------------------------------------------------------------------
 378
 379 #if !defined(__WXMSW__) || !wxUSE_ON_FATAL_EXCEPTION
 380     #define wxEntryReal wxEntry
 381 #endif // !(__WXMSW__ && wxUSE_ON_FATAL_EXCEPTION)
 382
 383 int wxEntryReal(int& argc, wxChar **argv)
 384 {
 385     // library initialization
 386     if ( !wxEntryStart(argc, argv) )
 387     {
 388         return -1;
 389     }
 390
 391     // if wxEntryStart succeeded, we must call wxEntryCleanup even if the code
 392     // below returns or throws
 393     wxCleanupOnExit cleanupOnExit;
 394
 395     WX_SUPPRESS_UNUSED_WARN(cleanupOnExit);
 396
 397     wxTRY
 398     {
 399         // app initialization
 400         if ( !wxTheApp->CallOnInit() )
 401         {
 402             // don't call OnExit() if OnInit() failed
 403             return -1;
 404         }
 405
 406         // app execution
 407         int retValue = wxTheApp->OnRun();
 408
 409         // app clean up
 410         wxTheApp->OnExit();
 411
 412         return retValue;
 413     }
 414     wxCATCH_ALL( wxTheApp->OnUnhandledException(); return -1; )
 415 }
 416
 417 // wrap real wxEntry in a try-except block to be able to call
 418 // OnFatalException() if necessary
 419 #if defined(__WXMSW__) && wxUSE_ON_FATAL_EXCEPTION
 420
 421 #ifdef __WXWINCE__
 422 // For ExitThread
 423 #include "wx/msw/private.h"
 424 #endif
 425
 426 extern unsigned long wxGlobalSEHandler(EXCEPTION_POINTERS *pExcPtrs);
 427
 428 int wxEntry(int& argc, wxChar **argv)
 429 {
 430     __try
 431     {
 432         return wxEntryReal(argc, argv);
 433     }
 434     __except ( wxGlobalSEHandler(GetExceptionInformation()) )
 435     {
 436 #ifdef __WXWINCE__
 437         ::ExitThread(3); // the same exit code as abort()
 438 #else
 439         ::ExitProcess(3); // the same exit code as abort()
 440 #endif
 441
 442 #if !defined(_MSC_VER) || _MSC_VER < 1300
 443         // this code is unreachable but put it here to suppress warnings
 444         // from some compilers
 445         return -1;
 446 #endif
 447     }
 448 }
 449
 450 #endif // __WXMSW__ && wxUSE_ON_FATAL_EXCEPTION
 451
 452 #if wxUSE_UNICODE
 453
 454 // as with wxEntryStart, we provide an ANSI wrapper
 455 int wxEntry(int& argc, char **argv)
 456 {
 457     ConvertArgsToUnicode(argc, argv);
 458
 459     return wxEntry(argc, gs_initData.argv);
 460 }
 461
 462 #endif // wxUSE_UNICODE
 463
 464 // ----------------------------------------------------------------------------
 465 // wxInitialize/wxUninitialize
 466 // ----------------------------------------------------------------------------
 467
 468 bool wxInitialize(int argc, wxChar **argv)
 469 {
 470     wxCRIT_SECT_LOCKER(lockInit, gs_initData.csInit);
 471
 472     if ( gs_initData.nInitCount++ )
 473     {
 474         // already initialized
 475         return true;
 476     }
 477
 478     return wxEntryStart(argc, argv);
 479 }
 480
 481 void wxUninitialize()
 482 {
 483     wxCRIT_SECT_LOCKER(lockInit, gs_initData.csInit);
 484
 485     if ( !--gs_initData.nInitCount )
 486     {
 487         wxEntryCleanup();
 488     }
 489 }
 490