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