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/ptr_scpd.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     int wargc = 0;
 180     for ( int i = 0; i < argc; i++ )
 181     {
 182 #ifdef __DARWIN__
 183         wxWCharBuffer buf(wxConvFileName->cMB2WX(argv[i]));
 184 #else
 185         wxWCharBuffer buf(wxConvLocal.cMB2WX(argv[i]));
 186 #endif
 187         if ( !buf )
 188         {
 189             wxLogWarning(_("Command line argument %d couldn't be converted to Unicode and will be ignored."),
 190                          i);
 191         }
 192         else // converted ok
 193         {
 194             gs_initData.argv[wargc++] = wxStrdup(buf);
 195         }
 196     }
 197
 198     gs_initData.argc = wargc;
 199     gs_initData.argv[wargc] = NULL;
 200 }
 201
 202 static void FreeConvertedArgs()
 203 {
 204     if ( gs_initData.argv )
 205     {
 206         for ( int i = 0; i < gs_initData.argc; i++ )
 207         {
 208             free(gs_initData.argv[i]);
 209         }
 210
 211         delete [] gs_initData.argv;
 212         gs_initData.argv = NULL;
 213         gs_initData.argc = 0;
 214     }
 215 }
 216
 217 #endif // wxUSE_UNICODE
 218
 219 // ----------------------------------------------------------------------------
 220 // start up
 221 // ----------------------------------------------------------------------------
 222
 223 // initialization which is always done (not customizable) before wxApp creation
 224 static bool DoCommonPreInit()
 225 {
 226 #if wxUSE_LOG
 227     // Reset logging in case we were cleaned up and are being reinitialized.
 228     wxLog::DoCreateOnDemand();
 229
 230     // install temporary log sink: we can't use wxLogGui before wxApp is
 231     // constructed and if we use wxLogStderr, all messages during
 232     // initialization simply disappear under Windows
 233     //
 234     // note that we will delete this log target below
 235     delete wxLog::SetActiveTarget(new wxLogBuffer);
 236 #endif // wxUSE_LOG
 237
 238     return true;
 239 }
 240
 241 // non customizable initialization done after wxApp creation and initialization
 242 static bool DoCommonPostInit()
 243 {
 244     wxModule::RegisterModules();
 245
 246     if ( !wxModule::InitializeModules() )
 247     {
 248         wxLogError(_("Initialization failed in post init, aborting."));
 249         return false;
 250     }
 251
 252 #if defined(__WXDEBUG__)
 253     // check if event classes implement Clone() correctly
 254     // NOTE: the check is done against _all_ event classes which are linked to
 255     //       the executable currently running, which are not necessarily all
 256     //       wxWidgets event classes.
 257     const wxClassInfo *ci = wxClassInfo::GetFirst();
 258     for (; ci; ci = ci->GetNext())
 259     {
 260         // is this class derived from wxEvent?
 261         if (!ci->IsKindOf(CLASSINFO(wxEvent)) || wxString(ci->GetClassName()) == "wxEvent")
 262             continue;
 263
 264         if (!ci->IsDynamic())
 265         {
 266             wxLogWarning("The event class '%s' should have a DECLARE_DYNAMIC_CLASS macro!",
 267                          ci->GetClassName());
 268             continue;
 269         }
 270
 271         // yes; test if it implements Clone() correctly
 272         wxEvent* test = dynamic_cast<wxEvent*>(ci->CreateObject());
 273         if (test == NULL)
 274         {
 275             wxLogWarning("The event class '%s' should have a DECLARE_DYNAMIC_CLASS macro!",
 276                          ci->GetClassName());
 277             continue;
 278         }
 279
 280         wxEvent* cloned = test->Clone();
 281         if (!cloned || cloned->GetClassInfo() != ci)
 282             wxLogWarning("The event class '%s' does not correctly implement Clone()!",
 283                          ci->GetClassName());
 284
 285         delete cloned;
 286         delete test;
 287     }
 288 #endif
 289
 290     return true;
 291 }
 292
 293 bool wxEntryStart(int& argc, wxChar **argv)
 294 {
 295     // do minimal, always necessary, initialization
 296     // --------------------------------------------
 297
 298     // initialize wxRTTI
 299     if ( !DoCommonPreInit() )
 300     {
 301         return false;
 302     }
 303
 304
 305     // first of all, we need an application object
 306     // -------------------------------------------
 307
 308     // the user might have already created it himself somehow
 309     wxAppPtr app(wxTheApp);
 310     if ( !app.get() )
 311     {
 312         // if not, he might have used IMPLEMENT_APP() to give us a function to
 313         // create it
 314         wxAppInitializerFunction fnCreate = wxApp::GetInitializerFunction();
 315
 316         if ( fnCreate )
 317         {
 318             // he did, try to create the custom wxApp object
 319             app.Set((*fnCreate)());
 320         }
 321     }
 322
 323     if ( !app.get() )
 324     {
 325         // either IMPLEMENT_APP() was not used at all or it failed -- in any
 326         // case we still need something
 327         app.Set(new wxDummyConsoleApp);
 328     }
 329
 330
 331     // wxApp initialization: this can be customized
 332     // --------------------------------------------
 333
 334     if ( !app->Initialize(argc, argv) )
 335     {
 336         return false;
 337     }
 338
 339     // remember, possibly modified (e.g. due to removal of toolkit-specific
 340     // parameters), command line arguments in member variables
 341     app->argc = argc;
 342     app->argv = argv;
 343
 344
 345     wxCallAppCleanup callAppCleanup(app.get());
 346
 347     // for compatibility call the old initialization function too
 348     if ( !app->OnInitGui() )
 349         return false;
 350
 351
 352     // common initialization after wxTheApp creation
 353     // ---------------------------------------------
 354
 355     if ( !DoCommonPostInit() )
 356         return false;
 357
 358
 359     // prevent the smart pointer from destroying its contents
 360     app.release();
 361
 362     // and the cleanup object from doing cleanup
 363     callAppCleanup.Dismiss();
 364
 365 #if wxUSE_LOG
 366     // now that we have a valid wxApp (wxLogGui would have crashed if we used
 367     // it before now), we can delete the temporary sink we had created for the
 368     // initialization messages -- the next time logging function is called, the
 369     // sink will be recreated but this time wxAppTraits will be used
 370     delete wxLog::SetActiveTarget(NULL);
 371 #endif // wxUSE_LOG
 372
 373     return true;
 374 }
 375
 376 #if wxUSE_UNICODE
 377
 378 // we provide a wxEntryStart() wrapper taking "char *" pointer too
 379 bool wxEntryStart(int& argc, char **argv)
 380 {
 381     ConvertArgsToUnicode(argc, argv);
 382
 383     if ( !wxEntryStart(gs_initData.argc, gs_initData.argv) )
 384     {
 385         FreeConvertedArgs();
 386
 387         return false;
 388     }
 389
 390     return true;
 391 }
 392
 393 #endif // wxUSE_UNICODE
 394
 395 // ----------------------------------------------------------------------------
 396 // clean up
 397 // ----------------------------------------------------------------------------
 398
 399 // cleanup done before destroying wxTheApp
 400 static void DoCommonPreCleanup()
 401 {
 402 #if wxUSE_LOG
 403     // flush the logged messages if any and install a 'safer' log target: the
 404     // default one (wxLogGui) can't be used after the resources are freed just
 405     // below and the user supplied one might be even more unsafe (using any
 406     // wxWidgets GUI function is unsafe starting from now)
 407     wxLog::DontCreateOnDemand();
 408
 409     // this will flush the old messages if any
 410     delete wxLog::SetActiveTarget(new wxLogStderr);
 411 #endif // wxUSE_LOG
 412 }
 413
 414 // cleanup done after destroying wxTheApp
 415 static void DoCommonPostCleanup()
 416 {
 417     wxModule::CleanUpModules();
 418
 419     // we can't do this in wxApp itself because it doesn't know if argv had
 420     // been allocated
 421 #if wxUSE_UNICODE
 422     FreeConvertedArgs();
 423 #endif // wxUSE_UNICODE
 424
 425     // use Set(NULL) and not Get() to avoid creating a message output object on
 426     // demand when we just want to delete it
 427     delete wxMessageOutput::Set(NULL);
 428
 429 #if wxUSE_LOG
 430     // and now delete the last logger as well
 431     delete wxLog::SetActiveTarget(NULL);
 432 #endif // wxUSE_LOG
 433 }
 434
 435 void wxEntryCleanup()
 436 {
 437     DoCommonPreCleanup();
 438
 439
 440     // delete the application object
 441     if ( wxTheApp )
 442     {
 443         wxTheApp->CleanUp();
 444
 445         // reset the global pointer to it to NULL before destroying it as in
 446         // some circumstances this can result in executing the code using
 447         // wxTheApp and using half-destroyed object is no good
 448         wxAppConsole * const app = wxApp::GetInstance();
 449         wxApp::SetInstance(NULL);
 450         delete app;
 451     }
 452
 453
 454     DoCommonPostCleanup();
 455 }
 456
 457 // ----------------------------------------------------------------------------
 458 // wxEntry
 459 // ----------------------------------------------------------------------------
 460
 461 // for MSW the real wxEntry is defined in msw/main.cpp
 462 #ifndef __WXMSW__
 463     #define wxEntryReal wxEntry
 464 #endif // !__WXMSW__
 465
 466 int wxEntryReal(int& argc, wxChar **argv)
 467 {
 468     // library initialization
 469     if ( !wxEntryStart(argc, argv) )
 470     {
 471 #if wxUSE_LOG
 472         // flush any log messages explaining why we failed
 473         delete wxLog::SetActiveTarget(NULL);
 474 #endif
 475         return -1;
 476     }
 477
 478     // if wxEntryStart succeeded, we must call wxEntryCleanup even if the code
 479     // below returns or throws
 480     wxCleanupOnExit cleanupOnExit;
 481
 482     WX_SUPPRESS_UNUSED_WARN(cleanupOnExit);
 483
 484     wxTRY
 485     {
 486
 487         // app initialization
 488         if ( !wxTheApp->CallOnInit() )
 489         {
 490             // don't call OnExit() if OnInit() failed
 491             return -1;
 492         }
 493
 494         // ensure that OnExit() is called if OnInit() had succeeded
 495         class CallOnExit
 496         {
 497         public:
 498             ~CallOnExit() { wxTheApp->OnExit(); }
 499         } callOnExit;
 500
 501         WX_SUPPRESS_UNUSED_WARN(callOnExit);
 502
 503         // app execution
 504         return wxTheApp->OnRun();
 505     }
 506     wxCATCH_ALL( wxTheApp->OnUnhandledException(); return -1; )
 507 }
 508
 509 #if wxUSE_UNICODE
 510
 511 // as with wxEntryStart, we provide an ANSI wrapper
 512 int wxEntry(int& argc, char **argv)
 513 {
 514     ConvertArgsToUnicode(argc, argv);
 515
 516     return wxEntry(gs_initData.argc, gs_initData.argv);
 517 }
 518
 519 #endif // wxUSE_UNICODE
 520
 521 // ----------------------------------------------------------------------------
 522 // wxInitialize/wxUninitialize
 523 // ----------------------------------------------------------------------------
 524
 525 bool wxInitialize(int argc, wxChar **argv)
 526 {
 527     wxCRIT_SECT_LOCKER(lockInit, gs_initData.csInit);
 528
 529     if ( gs_initData.nInitCount++ )
 530     {
 531         // already initialized
 532         return true;
 533     }
 534
 535     return wxEntryStart(argc, argv);
 536 }
 537
 538 void wxUninitialize()
 539 {
 540     wxCRIT_SECT_LOCKER(lockInit, gs_initData.csInit);
 541
 542     if ( --gs_initData.nInitCount == 0 )
 543     {
 544         wxEntryCleanup();
 545     }
 546 }