1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/init.cpp
3 // Purpose: initialisation for the library
4 // Author: Vadim Zeitlin
8 // Copyright: (c) Vadim Zeitlin
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 #include "wx/wxprec.h"
28 #include "wx/filefn.h"
31 #include "wx/module.h"
35 #include "wx/thread.h"
37 #include "wx/ptr_scpd.h"
38 #include "wx/except.h"
40 #if defined(__WXMSW__) && defined(__WXDEBUG__)
41 #include "wx/msw/msvcrt.h"
43 static struct EnableMemLeakChecking
45 EnableMemLeakChecking()
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
);
52 } gs_enableLeakChecks
;
53 #endif // __WXMSW__ && __WXDEBUG__
55 // ----------------------------------------------------------------------------
57 // ----------------------------------------------------------------------------
59 // we need a dummy app object if the user doesn't want to create a real one
60 class wxDummyConsoleApp
: public wxAppConsole
63 wxDummyConsoleApp() { }
65 virtual int OnRun() { wxFAIL_MSG( _T("unreachable code") ); return 0; }
67 DECLARE_NO_COPY_CLASS(wxDummyConsoleApp
)
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
)
75 class wxAppPtr
: public wxAppPtrBase
78 wxEXPLICIT
wxAppPtr(wxAppConsole
*ptr
= NULL
) : wxAppPtrBase(ptr
) { }
83 // the pointer is going to be deleted in the base class dtor, don't
84 // leave the dangling pointer!
85 wxApp::SetInstance(NULL
);
89 void Set(wxAppConsole
*ptr
)
93 wxApp::SetInstance(ptr
);
96 DECLARE_NO_COPY_CLASS(wxAppPtr
)
99 // class to ensure that wxAppBase::CleanUp() is called if our Initialize()
101 class wxCallAppCleanup
104 wxCallAppCleanup(wxAppConsole
*app
) : m_app(app
) { }
105 ~wxCallAppCleanup() { if ( m_app
) m_app
->CleanUp(); }
107 void Dismiss() { m_app
= NULL
; }
113 // another tiny class which simply exists to ensure that wxEntryCleanup is
115 class wxCleanupOnExit
118 ~wxCleanupOnExit() { wxEntryCleanup(); }
121 // ----------------------------------------------------------------------------
123 // ----------------------------------------------------------------------------
125 // suppress warnings about unused variables
126 static inline void Use(void *) { }
128 #define WX_SUPPRESS_UNUSED_WARN(x) Use(&x)
130 // ----------------------------------------------------------------------------
131 // initialization data
132 // ----------------------------------------------------------------------------
134 static struct InitData
142 // argv = NULL; -- not even really needed
143 #endif // wxUSE_UNICODE
146 // critical section protecting this struct
147 wxCRIT_SECT_DECLARE_MEMBER(csInit
);
149 // number of times wxInitialize() was called minus the number of times
150 // wxUninitialize() was
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
161 #endif // wxUSE_UNICODE
163 DECLARE_NO_COPY_CLASS(InitData
)
166 // ============================================================================
168 // ============================================================================
170 // ----------------------------------------------------------------------------
171 // command line arguments ANSI -> Unicode conversion
172 // ----------------------------------------------------------------------------
176 static void ConvertArgsToUnicode(int argc
, char **argv
)
178 gs_initData
.argv
= new wchar_t *[argc
+ 1];
180 for ( int i
= 0; i
< argc
; i
++ )
183 wxWCharBuffer
buf(wxConvFileName
->cMB2WX(argv
[i
]));
185 wxWCharBuffer
buf(wxConvLocal
.cMB2WX(argv
[i
]));
189 wxLogWarning(_("Command line argument %d couldn't be converted to Unicode and will be ignored."),
194 gs_initData
.argv
[wargc
++] = wxStrdup(buf
);
198 gs_initData
.argc
= wargc
;
199 gs_initData
.argv
[wargc
] = NULL
;
202 static void FreeConvertedArgs()
204 if ( gs_initData
.argv
)
206 for ( int i
= 0; i
< gs_initData
.argc
; i
++ )
208 free(gs_initData
.argv
[i
]);
211 delete [] gs_initData
.argv
;
212 gs_initData
.argv
= NULL
;
213 gs_initData
.argc
= 0;
217 #endif // wxUSE_UNICODE
219 // ----------------------------------------------------------------------------
221 // ----------------------------------------------------------------------------
223 // initialization which is always done (not customizable) before wxApp creation
224 static bool DoCommonPreInit()
227 // Reset logging in case we were cleaned up and are being reinitialized.
228 wxLog::DoCreateOnDemand();
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
234 // note that we will delete this log target below
235 delete wxLog::SetActiveTarget(new wxLogBuffer
);
241 // non customizable initialization done after wxApp creation and initialization
242 static bool DoCommonPostInit()
244 wxModule::RegisterModules();
246 if ( !wxModule::InitializeModules() )
248 wxLogError(_("Initialization failed in post init, aborting."));
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())
260 // is this class derived from wxEvent?
261 if (!ci
->IsKindOf(CLASSINFO(wxEvent
)) || wxString(ci
->GetClassName()) == "wxEvent")
264 if (!ci
->IsDynamic())
266 wxLogWarning("The event class '%s' should have a DECLARE_DYNAMIC_CLASS macro!",
271 // yes; test if it implements Clone() correctly
272 wxEvent
* test
= dynamic_cast<wxEvent
*>(ci
->CreateObject());
275 wxLogWarning("The event class '%s' should have a DECLARE_DYNAMIC_CLASS macro!",
280 wxEvent
* cloned
= test
->Clone();
281 if (!cloned
|| cloned
->GetClassInfo() != ci
)
282 wxLogWarning("The event class '%s' does not correctly implement Clone()!",
293 bool wxEntryStart(int& argc
, wxChar
**argv
)
295 // do minimal, always necessary, initialization
296 // --------------------------------------------
299 if ( !DoCommonPreInit() )
305 // first of all, we need an application object
306 // -------------------------------------------
308 // the user might have already created it himself somehow
309 wxAppPtr
app(wxTheApp
);
312 // if not, he might have used IMPLEMENT_APP() to give us a function to
314 wxAppInitializerFunction fnCreate
= wxApp::GetInitializerFunction();
318 // he did, try to create the custom wxApp object
319 app
.Set((*fnCreate
)());
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
);
331 // wxApp initialization: this can be customized
332 // --------------------------------------------
334 if ( !app
->Initialize(argc
, argv
) )
339 // remember, possibly modified (e.g. due to removal of toolkit-specific
340 // parameters), command line arguments in member variables
345 wxCallAppCleanup
callAppCleanup(app
.get());
347 // for compatibility call the old initialization function too
348 if ( !app
->OnInitGui() )
352 // common initialization after wxTheApp creation
353 // ---------------------------------------------
355 if ( !DoCommonPostInit() )
359 // prevent the smart pointer from destroying its contents
362 // and the cleanup object from doing cleanup
363 callAppCleanup
.Dismiss();
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
);
378 // we provide a wxEntryStart() wrapper taking "char *" pointer too
379 bool wxEntryStart(int& argc
, char **argv
)
381 ConvertArgsToUnicode(argc
, argv
);
383 if ( !wxEntryStart(gs_initData
.argc
, gs_initData
.argv
) )
393 #endif // wxUSE_UNICODE
395 // ----------------------------------------------------------------------------
397 // ----------------------------------------------------------------------------
399 // cleanup done before destroying wxTheApp
400 static void DoCommonPreCleanup()
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();
409 // this will flush the old messages if any
410 delete wxLog::SetActiveTarget(new wxLogStderr
);
414 // cleanup done after destroying wxTheApp
415 static void DoCommonPostCleanup()
417 wxModule::CleanUpModules();
419 // we can't do this in wxApp itself because it doesn't know if argv had
423 #endif // wxUSE_UNICODE
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
);
430 // and now delete the last logger as well
431 delete wxLog::SetActiveTarget(NULL
);
435 void wxEntryCleanup()
437 DoCommonPreCleanup();
440 // delete the application object
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
);
454 DoCommonPostCleanup();
457 // ----------------------------------------------------------------------------
459 // ----------------------------------------------------------------------------
461 // for MSW the real wxEntry is defined in msw/main.cpp
463 #define wxEntryReal wxEntry
466 int wxEntryReal(int& argc
, wxChar
**argv
)
468 // library initialization
469 if ( !wxEntryStart(argc
, argv
) )
472 // flush any log messages explaining why we failed
473 delete wxLog::SetActiveTarget(NULL
);
478 // if wxEntryStart succeeded, we must call wxEntryCleanup even if the code
479 // below returns or throws
480 wxCleanupOnExit cleanupOnExit
;
482 WX_SUPPRESS_UNUSED_WARN(cleanupOnExit
);
487 // app initialization
488 if ( !wxTheApp
->CallOnInit() )
490 // don't call OnExit() if OnInit() failed
494 // ensure that OnExit() is called if OnInit() had succeeded
498 ~CallOnExit() { wxTheApp
->OnExit(); }
501 WX_SUPPRESS_UNUSED_WARN(callOnExit
);
504 return wxTheApp
->OnRun();
506 wxCATCH_ALL( wxTheApp
->OnUnhandledException(); return -1; )
511 // as with wxEntryStart, we provide an ANSI wrapper
512 int wxEntry(int& argc
, char **argv
)
514 ConvertArgsToUnicode(argc
, argv
);
516 return wxEntry(gs_initData
.argc
, gs_initData
.argv
);
519 #endif // wxUSE_UNICODE
521 // ----------------------------------------------------------------------------
522 // wxInitialize/wxUninitialize
523 // ----------------------------------------------------------------------------
525 bool wxInitialize(int argc
, wxChar
**argv
)
527 wxCRIT_SECT_LOCKER(lockInit
, gs_initData
.csInit
);
529 if ( gs_initData
.nInitCount
++ )
531 // already initialized
535 return wxEntryStart(argc
, argv
);
538 void wxUninitialize()
540 wxCRIT_SECT_LOCKER(lockInit
, gs_initData
.csInit
);
542 if ( --gs_initData
.nInitCount
== 0 )