]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/init.cpp
Rework the wxCusor ctor taking wx stock number to provide as many cursors as
[wxWidgets.git] / src / common / init.cpp
... / ...
CommitLineData
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/thread.h"
31 #include "wx/intl.h"
32 #include "wx/module.h"
33#endif
34
35#include "wx/init.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
60class wxDummyConsoleApp : public wxAppConsole
61{
62public:
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
72wxDECLARE_SCOPED_PTR(wxAppConsole, wxAppPtrBase)
73wxDEFINE_SCOPED_PTR(wxAppConsole, wxAppPtrBase)
74
75class wxAppPtr : public wxAppPtrBase
76{
77public:
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
101class wxCallAppCleanup
102{
103public:
104 wxCallAppCleanup(wxAppConsole *app) : m_app(app) { }
105 ~wxCallAppCleanup() { if ( m_app ) m_app->CleanUp(); }
106
107 void Dismiss() { m_app = NULL; }
108
109private:
110 wxAppConsole *m_app;
111};
112
113// another tiny class which simply exists to ensure that wxEntryCleanup is
114// always called
115class wxCleanupOnExit
116{
117public:
118 ~wxCleanupOnExit() { wxEntryCleanup(); }
119};
120
121// ----------------------------------------------------------------------------
122// private functions
123// ----------------------------------------------------------------------------
124
125// suppress warnings about unused variables
126static inline void Use(void *) { }
127
128#define WX_SUPPRESS_UNUSED_WARN(x) Use(&x)
129
130// ----------------------------------------------------------------------------
131// initialization data
132// ----------------------------------------------------------------------------
133
134static 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
176static 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 wxWCharBuffer buf(wxConvLocal.cMB2WX(argv[i]));
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
198static 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 delete [] gs_initData.argv;
208 gs_initData.argv = NULL;
209 gs_initData.argc = 0;
210 }
211}
212
213#endif // wxUSE_UNICODE
214
215// ----------------------------------------------------------------------------
216// start up
217// ----------------------------------------------------------------------------
218
219// initialization which is always done (not customizable) before wxApp creation
220static bool DoCommonPreInit()
221{
222#if wxUSE_LOG
223 // Reset logging in case we were cleaned up and are being reinitialized.
224 wxLog::DoCreateOnDemand();
225
226 // install temporary log sink: we can't use wxLogGui before wxApp is
227 // constructed and if we use wxLogStderr, all messages during
228 // initialization simply disappear under Windows
229 //
230 // note that we will delete this log target below
231 delete wxLog::SetActiveTarget(new wxLogBuffer);
232#endif // wxUSE_LOG
233
234 return true;
235}
236
237// non customizable initialization done after wxApp creation and initialization
238static bool DoCommonPostInit()
239{
240 wxModule::RegisterModules();
241
242 if ( !wxModule::InitializeModules() )
243 {
244 wxLogError(_("Initialization failed in post init, aborting."));
245 return false;
246 }
247
248 return true;
249}
250
251bool wxEntryStart(int& argc, wxChar **argv)
252{
253 // do minimal, always necessary, initialization
254 // --------------------------------------------
255
256 // initialize wxRTTI
257 if ( !DoCommonPreInit() )
258 {
259 return false;
260 }
261
262
263 // first of all, we need an application object
264 // -------------------------------------------
265
266 // the user might have already created it himself somehow
267 wxAppPtr app(wxTheApp);
268 if ( !app.get() )
269 {
270 // if not, he might have used IMPLEMENT_APP() to give us a function to
271 // create it
272 wxAppInitializerFunction fnCreate = wxApp::GetInitializerFunction();
273
274 if ( fnCreate )
275 {
276 // he did, try to create the custom wxApp object
277 app.Set((*fnCreate)());
278 }
279 }
280
281 if ( !app.get() )
282 {
283 // either IMPLEMENT_APP() was not used at all or it failed -- in any
284 // case we still need something
285 app.Set(new wxDummyConsoleApp);
286 }
287
288
289 // wxApp initialization: this can be customized
290 // --------------------------------------------
291
292 if ( !app->Initialize(argc, argv) )
293 {
294 return false;
295 }
296
297 wxCallAppCleanup callAppCleanup(app.get());
298
299 // for compatibility call the old initialization function too
300 if ( !app->OnInitGui() )
301 return false;
302
303
304 // common initialization after wxTheApp creation
305 // ---------------------------------------------
306
307 if ( !DoCommonPostInit() )
308 return false;
309
310
311 // prevent the smart pointer from destroying its contents
312 app.release();
313
314 // and the cleanup object from doing cleanup
315 callAppCleanup.Dismiss();
316
317#if wxUSE_LOG
318 // now that we have a valid wxApp (wxLogGui would have crashed if we used
319 // it before now), we can delete the temporary sink we had created for the
320 // initialization messages -- the next time logging function is called, the
321 // sink will be recreated but this time wxAppTraits will be used
322 delete wxLog::SetActiveTarget(NULL);
323#endif // wxUSE_LOG
324
325 return true;
326}
327
328#if wxUSE_UNICODE
329
330// we provide a wxEntryStart() wrapper taking "char *" pointer too
331bool wxEntryStart(int& argc, char **argv)
332{
333 ConvertArgsToUnicode(argc, argv);
334
335 if ( !wxEntryStart(gs_initData.argc, gs_initData.argv) )
336 {
337 FreeConvertedArgs();
338
339 return false;
340 }
341
342 return true;
343}
344
345#endif // wxUSE_UNICODE
346
347// ----------------------------------------------------------------------------
348// clean up
349// ----------------------------------------------------------------------------
350
351// cleanup done before destroying wxTheApp
352static void DoCommonPreCleanup()
353{
354#if wxUSE_LOG
355 // flush the logged messages if any and install a 'safer' log target: the
356 // default one (wxLogGui) can't be used after the resources are freed just
357 // below and the user supplied one might be even more unsafe (using any
358 // wxWidgets GUI function is unsafe starting from now)
359 wxLog::DontCreateOnDemand();
360
361 // this will flush the old messages if any
362 delete wxLog::SetActiveTarget(new wxLogStderr);
363#endif // wxUSE_LOG
364}
365
366// cleanup done after destroying wxTheApp
367static void DoCommonPostCleanup()
368{
369 wxModule::CleanUpModules();
370
371 // we can't do this in wxApp itself because it doesn't know if argv had
372 // been allocated
373#if wxUSE_UNICODE
374 FreeConvertedArgs();
375#endif // wxUSE_UNICODE
376
377 // use Set(NULL) and not Get() to avoid creating a message output object on
378 // demand when we just want to delete it
379 delete wxMessageOutput::Set(NULL);
380
381#if wxUSE_LOG
382 // and now delete the last logger as well
383 delete wxLog::SetActiveTarget(NULL);
384#endif // wxUSE_LOG
385}
386
387void wxEntryCleanup()
388{
389 DoCommonPreCleanup();
390
391
392 // delete the application object
393 if ( wxTheApp )
394 {
395 wxTheApp->CleanUp();
396
397 delete wxTheApp;
398 wxApp::SetInstance(NULL);
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
414int wxEntryReal(int& argc, wxChar **argv)
415{
416 // library initialization
417 if ( !wxEntryStart(argc, argv) )
418 {
419#if wxUSE_LOG
420 // flush any log messages explaining why we failed
421 delete wxLog::SetActiveTarget(NULL);
422#endif
423 return -1;
424 }
425
426 // if wxEntryStart succeeded, we must call wxEntryCleanup even if the code
427 // below returns or throws
428 wxCleanupOnExit cleanupOnExit;
429
430 WX_SUPPRESS_UNUSED_WARN(cleanupOnExit);
431
432 wxTRY
433 {
434
435 // app initialization
436 if ( !wxTheApp->CallOnInit() )
437 {
438 // don't call OnExit() if OnInit() failed
439 return -1;
440 }
441
442 // ensure that OnExit() is called if OnInit() had succeeded
443 class CallOnExit
444 {
445 public:
446 ~CallOnExit() { wxTheApp->OnExit(); }
447 } callOnExit;
448
449 WX_SUPPRESS_UNUSED_WARN(callOnExit);
450
451 // app execution
452 return wxTheApp->OnRun();
453 }
454 wxCATCH_ALL( wxTheApp->OnUnhandledException(); return -1; )
455}
456
457#if wxUSE_UNICODE
458
459// as with wxEntryStart, we provide an ANSI wrapper
460int wxEntry(int& argc, char **argv)
461{
462 ConvertArgsToUnicode(argc, argv);
463
464 return wxEntry(gs_initData.argc, gs_initData.argv);
465}
466
467#endif // wxUSE_UNICODE
468
469// ----------------------------------------------------------------------------
470// wxInitialize/wxUninitialize
471// ----------------------------------------------------------------------------
472
473bool 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
486void wxUninitialize()
487{
488 wxCRIT_SECT_LOCKER(lockInit, gs_initData.csInit);
489
490 if ( --gs_initData.nInitCount == 0 )
491 {
492 wxEntryCleanup();
493 }
494}