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
 225     // force wxLog to create a log target now: we do it because wxTheApp
 226     // doesn't exist yet so wxLog will create a special log target which is
 227     // safe to use even when the GUI is not available while without this call
 228     // we could create wxApp in wxEntryStart() below, then log an error about
 229     // e.g. failure to establish connection to the X server and wxLog would
 230     // send it to wxLogGui (because wxTheApp does exist already) which, of
 231     // course, can't be used in this case
 232     //
 233     // notice also that this does nothing if the user had set up a custom log
 234     // target before -- which is fine as we want to give him this possibility
 235     // (as it's impossible to override logging by overriding wxAppTraits::
 236     // CreateLogTarget() before wxApp is created) and we just assume he knows
 237     // what he is doing
 238     wxLog::GetActiveTarget();
 239 #endif // wxUSE_LOG
 240
 241     return true;
 242 }
 243
 244 // non customizable initialization done after wxApp creation and initialization
 245 static bool DoCommonPostInit()
 246 {
 247     wxModule::RegisterModules();
 248
 249     if ( !wxModule::InitializeModules() )
 250     {
 251         wxLogError(_("Initialization failed in post init, aborting."));
 252         return false;
 253     }
 254
 255     return true;
 256 }
 257
 258 bool wxEntryStart(int& argc, wxChar **argv)
 259 {
 260     // do minimal, always necessary, initialization
 261     // --------------------------------------------
 262
 263     // initialize wxRTTI
 264     if ( !DoCommonPreInit() )
 265         return false;
 266
 267
 268     // first of all, we need an application object
 269     // -------------------------------------------
 270
 271     // the user might have already created it himself somehow
 272     wxAppPtr app(wxTheApp);
 273     if ( !app.get() )
 274     {
 275         // if not, he might have used IMPLEMENT_APP() to give us a function to
 276         // create it
 277         wxAppInitializerFunction fnCreate = wxApp::GetInitializerFunction();
 278
 279         if ( fnCreate )
 280         {
 281             // he did, try to create the custom wxApp object
 282             app.Set((*fnCreate)());
 283         }
 284     }
 285
 286     if ( !app.get() )
 287     {
 288         // either IMPLEMENT_APP() was not used at all or it failed -- in any
 289         // case we still need something
 290         app.Set(new wxDummyConsoleApp);
 291     }
 292
 293
 294     // wxApp initialization: this can be customized
 295     // --------------------------------------------
 296
 297     if ( !app->Initialize(argc, argv) )
 298         return false;
 299
 300     // remember, possibly modified (e.g. due to removal of toolkit-specific
 301     // parameters), command line arguments in member variables
 302     app->argc = argc;
 303     app->argv = argv;
 304
 305     wxCallAppCleanup callAppCleanup(app.get());
 306
 307
 308     // common initialization after wxTheApp creation
 309     // ---------------------------------------------
 310
 311     if ( !DoCommonPostInit() )
 312         return false;
 313
 314
 315     // prevent the smart pointer from destroying its contents
 316     app.release();
 317
 318     // and the cleanup object from doing cleanup
 319     callAppCleanup.Dismiss();
 320
 321 #if wxUSE_LOG
 322     // now that we have a valid wxApp (wxLogGui would have crashed if we used
 323     // it before now), we can delete the temporary sink we had created for the
 324     // initialization messages -- the next time logging function is called, the
 325     // sink will be recreated but this time wxAppTraits will be used
 326     delete wxLog::SetActiveTarget(NULL);
 327 #endif // wxUSE_LOG
 328
 329     return true;
 330 }
 331
 332 #if wxUSE_UNICODE
 333
 334 // we provide a wxEntryStart() wrapper taking "char *" pointer too
 335 bool wxEntryStart(int& argc, char **argv)
 336 {
 337     ConvertArgsToUnicode(argc, argv);
 338
 339     if ( !wxEntryStart(gs_initData.argc, gs_initData.argv) )
 340     {
 341         FreeConvertedArgs();
 342
 343         return false;
 344     }
 345
 346     return true;
 347 }
 348
 349 #endif // wxUSE_UNICODE
 350
 351 // ----------------------------------------------------------------------------
 352 // clean up
 353 // ----------------------------------------------------------------------------
 354
 355 // cleanup done before destroying wxTheApp
 356 static void DoCommonPreCleanup()
 357 {
 358 #if wxUSE_LOG
 359     // flush the logged messages if any and don't use the current probably
 360     // unsafe log target any more: the default one (wxLogGui) can't be used
 361     // after the resources are freed which happens when we return and the user
 362     // supplied one might be even more unsafe (using any wxWidgets GUI function
 363     // is unsafe starting from now)
 364     //
 365     // notice that wxLog will still recreate a default log target if any
 366     // messages are logged but that one will be safe to use until the very end
 367     delete wxLog::SetActiveTarget(NULL);
 368 #endif // wxUSE_LOG
 369 }
 370
 371 // cleanup done after destroying wxTheApp
 372 static void DoCommonPostCleanup()
 373 {
 374     wxModule::CleanUpModules();
 375
 376     // we can't do this in wxApp itself because it doesn't know if argv had
 377     // been allocated
 378 #if wxUSE_UNICODE
 379     FreeConvertedArgs();
 380 #endif // wxUSE_UNICODE
 381
 382     // use Set(NULL) and not Get() to avoid creating a message output object on
 383     // demand when we just want to delete it
 384     delete wxMessageOutput::Set(NULL);
 385
 386 #if wxUSE_LOG
 387     // and now delete the last logger as well
 388     //
 389     // we still don't disable log target auto-vivification even if any log
 390     // objects created now will result in memory leaks because it seems better
 391     // to leak memory which doesn't matter much considering the application is
 392     // exiting anyhow than to not show messages which could still be logged
 393     // from the user code (e.g. static dtors and such)
 394     delete wxLog::SetActiveTarget(NULL);
 395 #endif // wxUSE_LOG
 396 }
 397
 398 void wxEntryCleanup()
 399 {
 400     DoCommonPreCleanup();
 401
 402
 403     // delete the application object
 404     if ( wxTheApp )
 405     {
 406         wxTheApp->CleanUp();
 407
 408         // reset the global pointer to it to NULL before destroying it as in
 409         // some circumstances this can result in executing the code using
 410         // wxTheApp and using half-destroyed object is no good
 411         wxAppConsole * const app = wxApp::GetInstance();
 412         wxApp::SetInstance(NULL);
 413         delete app;
 414     }
 415
 416
 417     DoCommonPostCleanup();
 418 }
 419
 420 // ----------------------------------------------------------------------------
 421 // wxEntry
 422 // ----------------------------------------------------------------------------
 423
 424 // for MSW the real wxEntry is defined in msw/main.cpp
 425 #ifndef __WXMSW__
 426     #define wxEntryReal wxEntry
 427 #endif // !__WXMSW__
 428
 429 int wxEntryReal(int& argc, wxChar **argv)
 430 {
 431     // library initialization
 432     wxInitializer initializer(argc, argv);
 433
 434     if ( !initializer.IsOk() )
 435     {
 436 #if wxUSE_LOG
 437         // flush any log messages explaining why we failed
 438         delete wxLog::SetActiveTarget(NULL);
 439 #endif
 440         return -1;
 441     }
 442
 443     wxTRY
 444     {
 445         // app initialization
 446         if ( !wxTheApp->CallOnInit() )
 447         {
 448             // don't call OnExit() if OnInit() failed
 449             return -1;
 450         }
 451
 452         // ensure that OnExit() is called if OnInit() had succeeded
 453         class CallOnExit
 454         {
 455         public:
 456             ~CallOnExit() { wxTheApp->OnExit(); }
 457         } callOnExit;
 458
 459         WX_SUPPRESS_UNUSED_WARN(callOnExit);
 460
 461         // app execution
 462         return wxTheApp->OnRun();
 463     }
 464     wxCATCH_ALL( wxTheApp->OnUnhandledException(); return -1; )
 465 }
 466
 467 #if wxUSE_UNICODE
 468
 469 // as with wxEntryStart, we provide an ANSI wrapper
 470 int wxEntry(int& argc, char **argv)
 471 {
 472     ConvertArgsToUnicode(argc, argv);
 473
 474     return wxEntry(gs_initData.argc, gs_initData.argv);
 475 }
 476
 477 #endif // wxUSE_UNICODE
 478
 479 // ----------------------------------------------------------------------------
 480 // wxInitialize/wxUninitialize
 481 // ----------------------------------------------------------------------------
 482
 483 bool wxInitialize()
 484 {
 485     return wxInitialize(0, (wxChar**)NULL);
 486 }
 487
 488 bool wxInitialize(int argc, wxChar **argv)
 489 {
 490     wxCRIT_SECT_LOCKER(lockInit, gs_initData.csInit);
 491
 492     if ( gs_initData.nInitCount++ )
 493     {
 494         // already initialized
 495         return true;
 496     }
 497
 498     return wxEntryStart(argc, argv);
 499 }
 500
 501 #if wxUSE_UNICODE
 502 bool wxInitialize(int argc, char **argv)
 503 {
 504     wxCRIT_SECT_LOCKER(lockInit, gs_initData.csInit);
 505
 506     if ( gs_initData.nInitCount++ )
 507     {
 508         // already initialized
 509         return true;
 510     }
 511
 512     return wxEntryStart(argc, argv);
 513 }
 514 #endif // wxUSE_UNICODE
 515
 516 void wxUninitialize()
 517 {
 518     wxCRIT_SECT_LOCKER(lockInit, gs_initData.csInit);
 519
 520     if ( --gs_initData.nInitCount == 0 )
 521     {
 522         wxEntryCleanup();
 523     }
 524 }