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