src/common/init.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/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/filefn.h"
  29     #include "wx/log.h"
  30     #include "wx/intl.h"
  31     #include "wx/module.h"
  32 #endif
  33
  34 #include "wx/init.h"
  35 #include "wx/thread.h"
  36
  37 #include "wx/scopedptr.h"
  38 #include "wx/except.h"
  39
  40 #if defined(__WXMSW__)
  41     #include "wx/msw/msvcrt.h"
  42
  43     #ifdef wxCrtSetDbgFlag
  44         static struct EnableMemLeakChecking
  45         {
  46             EnableMemLeakChecking()
  47             {
  48                 // check for memory leaks on program exit (another useful flag
  49                 // is _CRTDBG_DELAY_FREE_MEM_DF which doesn't free deallocated
  50                 // memory which may be used to simulate low-memory condition)
  51                 wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF);
  52             }
  53         } gs_enableLeakChecks;
  54     #endif // wxCrtSetDbgFlag
  55 #endif // __WXMSW__
  56
  57 // ----------------------------------------------------------------------------
  58 // private classes
  59 // ----------------------------------------------------------------------------
  60
  61 // we need a dummy app object if the user doesn't want to create a real one
  62 class wxDummyConsoleApp : public wxAppConsole
  63 {
  64 public:
  65     wxDummyConsoleApp() { }
  66
  67     virtual int OnRun() { wxFAIL_MSG( wxT("unreachable code") ); return 0; }
  68     virtual bool DoYield(bool, long) { return true; }
  69
  70     wxDECLARE_NO_COPY_CLASS(wxDummyConsoleApp);
  71 };
  72
  73 // we need a special kind of auto pointer to wxApp which not only deletes the
  74 // pointer it holds in its dtor but also resets the global application pointer
  75 wxDECLARE_SCOPED_PTR(wxAppConsole, wxAppPtrBase)
  76 wxDEFINE_SCOPED_PTR(wxAppConsole, wxAppPtrBase)
  77
  78 class wxAppPtr : public wxAppPtrBase
  79 {
  80 public:
  81     wxEXPLICIT wxAppPtr(wxAppConsole *ptr = NULL) : wxAppPtrBase(ptr) { }
  82     ~wxAppPtr()
  83     {
  84         if ( get() )
  85         {
  86             // the pointer is going to be deleted in the base class dtor, don't
  87             // leave the dangling pointer!
  88             wxApp::SetInstance(NULL);
  89         }
  90     }
  91
  92     void Set(wxAppConsole *ptr)
  93     {
  94         reset(ptr);
  95
  96         wxApp::SetInstance(ptr);
  97     }
  98
  99     wxDECLARE_NO_COPY_CLASS(wxAppPtr);
 100 };
 101
 102 // class to ensure that wxAppBase::CleanUp() is called if our Initialize()
 103 // fails
 104 class wxCallAppCleanup
 105 {
 106 public:
 107     wxCallAppCleanup(wxAppConsole *app) : m_app(app) { }
 108     ~wxCallAppCleanup() { if ( m_app ) m_app->CleanUp(); }
 109
 110     void Dismiss() { m_app = NULL; }
 111
 112 private:
 113     wxAppConsole *m_app;
 114 };
 115
 116 // ----------------------------------------------------------------------------
 117 // private functions
 118 // ----------------------------------------------------------------------------
 119
 120 // suppress warnings about unused variables
 121 static inline void Use(void *) { }
 122
 123 #define WX_SUPPRESS_UNUSED_WARN(x) Use(&x)
 124
 125 // ----------------------------------------------------------------------------
 126 // initialization data
 127 // ----------------------------------------------------------------------------
 128
 129 static struct InitData
 130 {
 131     InitData()
 132     {
 133         nInitCount = 0;
 134
 135 #if wxUSE_UNICODE
 136         argc = 0;
 137         // argv = NULL; -- not even really needed
 138 #endif // wxUSE_UNICODE
 139     }
 140
 141     // critical section protecting this struct
 142     wxCRIT_SECT_DECLARE_MEMBER(csInit);
 143
 144     // number of times wxInitialize() was called minus the number of times
 145     // wxUninitialize() was
 146     size_t nInitCount;
 147
 148 #if wxUSE_UNICODE
 149     int argc;
 150
 151     // if we receive the command line arguments as ASCII and have to convert
 152     // them to Unicode ourselves (this is the case under Unix but not Windows,
 153     // for example), we remember the converted argv here because we'll have to
 154     // free it when doing cleanup to avoid memory leaks
 155     wchar_t **argv;
 156 #endif // wxUSE_UNICODE
 157
 158     wxDECLARE_NO_COPY_CLASS(InitData);
 159 } gs_initData;
 160
 161 // ============================================================================
 162 // implementation
 163 // ============================================================================
 164
 165 // ----------------------------------------------------------------------------
 166 // command line arguments ANSI -> Unicode conversion
 167 // ----------------------------------------------------------------------------
 168
 169 #if wxUSE_UNICODE
 170
 171 static void ConvertArgsToUnicode(int argc, char **argv)
 172 {
 173     gs_initData.argv = new wchar_t *[argc + 1];
 174     int wargc = 0;
 175     for ( int i = 0; i < argc; i++ )
 176     {
 177 #ifdef __DARWIN__
 178         wxWCharBuffer buf(wxConvFileName->cMB2WX(argv[i]));
 179 #else
 180         wxWCharBuffer buf(wxConvLocal.cMB2WX(argv[i]));
 181 #endif
 182         if ( !buf )
 183         {
 184             wxLogWarning(_("Command line argument %d couldn't be converted to Unicode and will be ignored."),
 185                          i);
 186         }
 187         else // converted ok
 188         {
 189             gs_initData.argv[wargc++] = wxStrdup(buf);
 190         }
 191     }
 192
 193     gs_initData.argc = wargc;
 194     gs_initData.argv[wargc] = NULL;
 195 }
 196
 197 static void FreeConvertedArgs()
 198 {
 199     if ( gs_initData.argv )
 200     {
 201         for ( int i = 0; i < gs_initData.argc; i++ )
 202         {
 203             free(gs_initData.argv[i]);
 204         }
 205
 206         delete [] gs_initData.argv;
 207         gs_initData.argv = NULL;
 208         gs_initData.argc = 0;
 209     }
 210 }
 211
 212 #endif // wxUSE_UNICODE
 213
 214 // ----------------------------------------------------------------------------
 215 // start up
 216 // ----------------------------------------------------------------------------
 217
 218 // initialization which is always done (not customizable) before wxApp creation
 219 static bool DoCommonPreInit()
 220 {
 221 #if wxUSE_LOG
 222     // Reset logging in case we were cleaned up and are being reinitialized.
 223     wxLog::DoCreateOnDemand();
 224 #endif // wxUSE_LOG
 225
 226     return true;
 227 }
 228
 229 // non customizable initialization done after wxApp creation and initialization
 230 static bool DoCommonPostInit()
 231 {
 232     wxModule::RegisterModules();
 233
 234     if ( !wxModule::InitializeModules() )
 235     {
 236         wxLogError(_("Initialization failed in post init, aborting."));
 237         return false;
 238     }
 239
 240     return true;
 241 }
 242
 243 bool wxEntryStart(int& argc, wxChar **argv)
 244 {
 245     // do minimal, always necessary, initialization
 246     // --------------------------------------------
 247
 248     // initialize wxRTTI
 249     if ( !DoCommonPreInit() )
 250         return false;
 251
 252
 253     // first of all, we need an application object
 254     // -------------------------------------------
 255
 256     // the user might have already created it himself somehow
 257     wxAppPtr app(wxTheApp);
 258     if ( !app.get() )
 259     {
 260         // if not, he might have used IMPLEMENT_APP() to give us a function to
 261         // create it
 262         wxAppInitializerFunction fnCreate = wxApp::GetInitializerFunction();
 263
 264         if ( fnCreate )
 265         {
 266             // he did, try to create the custom wxApp object
 267             app.Set((*fnCreate)());
 268         }
 269     }
 270
 271     if ( !app.get() )
 272     {
 273         // either IMPLEMENT_APP() was not used at all or it failed -- in any
 274         // case we still need something
 275         app.Set(new wxDummyConsoleApp);
 276     }
 277
 278
 279     // wxApp initialization: this can be customized
 280     // --------------------------------------------
 281
 282     if ( !app->Initialize(argc, argv) )
 283         return false;
 284
 285     // remember, possibly modified (e.g. due to removal of toolkit-specific
 286     // parameters), command line arguments in member variables
 287     app->argc = argc;
 288     app->argv = argv;
 289
 290     wxCallAppCleanup callAppCleanup(app.get());
 291
 292
 293     // common initialization after wxTheApp creation
 294     // ---------------------------------------------
 295
 296     if ( !DoCommonPostInit() )
 297         return false;
 298
 299
 300     // prevent the smart pointer from destroying its contents
 301     app.release();
 302
 303     // and the cleanup object from doing cleanup
 304     callAppCleanup.Dismiss();
 305
 306 #if wxUSE_LOG
 307     // now that we have a valid wxApp (wxLogGui would have crashed if we used
 308     // it before now), we can delete the temporary sink we had created for the
 309     // initialization messages -- the next time logging function is called, the
 310     // sink will be recreated but this time wxAppTraits will be used
 311     delete wxLog::SetActiveTarget(NULL);
 312 #endif // wxUSE_LOG
 313
 314     return true;
 315 }
 316
 317 #if wxUSE_UNICODE
 318
 319 // we provide a wxEntryStart() wrapper taking "char *" pointer too
 320 bool wxEntryStart(int& argc, char **argv)
 321 {
 322     ConvertArgsToUnicode(argc, argv);
 323
 324     if ( !wxEntryStart(gs_initData.argc, gs_initData.argv) )
 325     {
 326         FreeConvertedArgs();
 327
 328         return false;
 329     }
 330
 331     return true;
 332 }
 333
 334 #endif // wxUSE_UNICODE
 335
 336 // ----------------------------------------------------------------------------
 337 // clean up
 338 // ----------------------------------------------------------------------------
 339
 340 // cleanup done before destroying wxTheApp
 341 static void DoCommonPreCleanup()
 342 {
 343 #if wxUSE_LOG
 344     // flush the logged messages if any and don't use the current probably
 345     // unsafe log target any more: the default one (wxLogGui) can't be used
 346     // after the resources are freed which happens when we return and the user
 347     // supplied one might be even more unsafe (using any wxWidgets GUI function
 348     // is unsafe starting from now)
 349     //
 350     // notice that wxLog will still recreate a default log target if any
 351     // messages are logged but that one will be safe to use until the very end
 352     delete wxLog::SetActiveTarget(NULL);
 353 #endif // wxUSE_LOG
 354 }
 355
 356 // cleanup done after destroying wxTheApp
 357 static void DoCommonPostCleanup()
 358 {
 359     wxModule::CleanUpModules();
 360
 361     // we can't do this in wxApp itself because it doesn't know if argv had
 362     // been allocated
 363 #if wxUSE_UNICODE
 364     FreeConvertedArgs();
 365 #endif // wxUSE_UNICODE
 366
 367     // use Set(NULL) and not Get() to avoid creating a message output object on
 368     // demand when we just want to delete it
 369     delete wxMessageOutput::Set(NULL);
 370
 371 #if wxUSE_LOG
 372     // and now delete the last logger as well
 373     //
 374     // we still don't disable log target auto-vivification even if any log
 375     // objects created now will result in memory leaks because it seems better
 376     // to leak memory which doesn't matter much considering the application is
 377     // exiting anyhow than to not show messages which could still be logged
 378     // from the user code (e.g. static dtors and such)
 379     delete wxLog::SetActiveTarget(NULL);
 380 #endif // wxUSE_LOG
 381 }
 382
 383 void wxEntryCleanup()
 384 {
 385     DoCommonPreCleanup();
 386
 387
 388     // delete the application object
 389     if ( wxTheApp )
 390     {
 391         wxTheApp->CleanUp();
 392
 393         // reset the global pointer to it to NULL before destroying it as in
 394         // some circumstances this can result in executing the code using
 395         // wxTheApp and using half-destroyed object is no good
 396         wxAppConsole * const app = wxApp::GetInstance();
 397         wxApp::SetInstance(NULL);
 398         delete app;
 399     }
 400
 401
 402     DoCommonPostCleanup();
 403 }
 404
 405 // ----------------------------------------------------------------------------
 406 // wxEntry
 407 // ----------------------------------------------------------------------------
 408
 409 // for MSW the real wxEntry is defined in msw/main.cpp
 410 #ifndef __WXMSW__
 411     #define wxEntryReal wxEntry
 412 #endif // !__WXMSW__
 413
 414 int wxEntryReal(int& argc, wxChar **argv)
 415 {
 416     // library initialization
 417     wxInitializer initializer(argc, argv);
 418
 419     if ( !initializer.IsOk() )
 420     {
 421 #if wxUSE_LOG
 422         // flush any log messages explaining why we failed
 423         delete wxLog::SetActiveTarget(NULL);
 424 #endif
 425         return -1;
 426     }
 427
 428     wxTRY
 429     {
 430         // app initialization
 431         if ( !wxTheApp->CallOnInit() )
 432         {
 433             // don't call OnExit() if OnInit() failed
 434             return -1;
 435         }
 436
 437         // ensure that OnExit() is called if OnInit() had succeeded
 438         class CallOnExit
 439         {
 440         public:
 441             ~CallOnExit() { wxTheApp->OnExit(); }
 442         } callOnExit;
 443
 444         WX_SUPPRESS_UNUSED_WARN(callOnExit);
 445
 446         // app execution
 447         return wxTheApp->OnRun();
 448     }
 449     wxCATCH_ALL( wxTheApp->OnUnhandledException(); return -1; )
 450 }
 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(gs_initData.argc, gs_initData.argv);
 460 }
 461
 462 #endif // wxUSE_UNICODE
 463
 464 // ----------------------------------------------------------------------------
 465 // wxInitialize/wxUninitialize
 466 // ----------------------------------------------------------------------------
 467
 468 bool wxInitialize()
 469 {
 470     return wxInitialize(0, (wxChar**)NULL);
 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 #if wxUSE_UNICODE
 487 bool wxInitialize(int argc, char **argv)
 488 {
 489     wxCRIT_SECT_LOCKER(lockInit, gs_initData.csInit);
 490
 491     if ( gs_initData.nInitCount++ )
 492     {
 493         // already initialized
 494         return true;
 495     }
 496
 497     return wxEntryStart(argc, argv);
 498 }
 499 #endif // wxUSE_UNICODE
 500
 501 void wxUninitialize()
 502 {
 503     wxCRIT_SECT_LOCKER(lockInit, gs_initData.csInit);
 504
 505     if ( --gs_initData.nInitCount == 0 )
 506     {
 507         wxEntryCleanup();
 508     }
 509 }