Include wx/choicdlg.h, wx/textdlg.h and wx/filedlg.h according to precompiled headers...
[wxWidgets.git] / src / common / appbase.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/appbase.cpp
3 // Purpose: implements wxAppConsole class
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 19.06.2003 (extracted from common/appcmn.cpp)
7 // RCS-ID: $Id$
8 // Copyright: (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
9 // License: wxWindows license
10 ///////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // for compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #ifndef WX_PRECOMP
28 #include "wx/list.h"
29 #include "wx/app.h"
30 #include "wx/intl.h"
31 #include "wx/log.h"
32 #include "wx/utils.h"
33 #endif //WX_PRECOMP
34
35 #include "wx/apptrait.h"
36 #include "wx/cmdline.h"
37 #include "wx/confbase.h"
38 #include "wx/filename.h"
39 #include "wx/msgout.h"
40 #include "wx/tokenzr.h"
41
42 #if !defined(__WXMSW__) || defined(__WXMICROWIN__)
43 #include <signal.h> // for SIGTRAP used by wxTrap()
44 #endif //Win/Unix
45
46 #if defined(__WXMSW__)
47 #include "wx/msw/wrapwin.h" // includes windows.h for MessageBox()
48 #endif
49
50 #if wxUSE_FONTMAP
51 #include "wx/fontmap.h"
52 #endif // wxUSE_FONTMAP
53
54 #if defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
55 // For MacTypes.h for Debugger function
56 #include <CoreFoundation/CFBase.h>
57 #endif
58
59 #if defined(__WXMAC__)
60 #ifdef __DARWIN__
61 #include <CoreServices/CoreServices.h>
62 #else
63 #include "wx/mac/private.h" // includes mac headers
64 #endif
65 #endif // __WXMAC__
66
67 #ifdef __WXDEBUG__
68 #if wxUSE_STACKWALKER
69 #include "wx/stackwalk.h"
70 #ifdef __WXMSW__
71 #include "wx/msw/debughlp.h"
72 #endif
73 #endif // wxUSE_STACKWALKER
74 #endif // __WXDEBUG__
75
76 // wxABI_VERSION can be defined when compiling applications but it should be
77 // left undefined when compiling the library itself, it is then set to its
78 // default value in version.h
79 #if wxABI_VERSION != wxMAJOR_VERSION * 10000 + wxMINOR_VERSION * 100 + 99
80 #error "wxABI_VERSION should not be defined when compiling the library"
81 #endif
82
83 // ----------------------------------------------------------------------------
84 // private functions prototypes
85 // ----------------------------------------------------------------------------
86
87 #ifdef __WXDEBUG__
88 // really just show the assert dialog
89 static bool DoShowAssertDialog(const wxString& msg);
90
91 // prepare for showing the assert dialog, use the given traits or
92 // DoShowAssertDialog() as last fallback to really show it
93 static
94 void ShowAssertDialog(const wxChar *szFile,
95 int nLine,
96 const wxChar *szFunc,
97 const wxChar *szCond,
98 const wxChar *szMsg,
99 wxAppTraits *traits = NULL);
100
101 // turn on the trace masks specified in the env variable WXTRACE
102 static void LINKAGEMODE SetTraceMasks();
103 #endif // __WXDEBUG__
104
105 // ----------------------------------------------------------------------------
106 // global vars
107 // ----------------------------------------------------------------------------
108
109 wxAppConsole *wxAppConsole::ms_appInstance = NULL;
110
111 wxAppInitializerFunction wxAppConsole::ms_appInitFn = NULL;
112
113 // ============================================================================
114 // wxAppConsole implementation
115 // ============================================================================
116
117 // ----------------------------------------------------------------------------
118 // ctor/dtor
119 // ----------------------------------------------------------------------------
120
121 wxAppConsole::wxAppConsole()
122 {
123 m_traits = NULL;
124
125 ms_appInstance = this;
126
127 #ifdef __WXDEBUG__
128 SetTraceMasks();
129 #if wxUSE_UNICODE
130 // In unicode mode the SetTraceMasks call can cause an apptraits to be
131 // created, but since we are still in the constructor the wrong kind will
132 // be created for GUI apps. Destroy it so it can be created again later.
133 delete m_traits;
134 m_traits = NULL;
135 #endif
136 #endif
137 }
138
139 wxAppConsole::~wxAppConsole()
140 {
141 delete m_traits;
142 }
143
144 // ----------------------------------------------------------------------------
145 // initilization/cleanup
146 // ----------------------------------------------------------------------------
147
148 bool wxAppConsole::Initialize(int& argcOrig, wxChar **argvOrig)
149 {
150 // remember the command line arguments
151 argc = argcOrig;
152 argv = argvOrig;
153
154 #ifndef __WXPALMOS__
155 if ( m_appName.empty() && argv )
156 {
157 // the application name is, by default, the name of its executable file
158 wxFileName::SplitPath(argv[0], NULL, &m_appName, NULL);
159 }
160 #endif
161
162 return true;
163 }
164
165 void wxAppConsole::CleanUp()
166 {
167 }
168
169 // ----------------------------------------------------------------------------
170 // OnXXX() callbacks
171 // ----------------------------------------------------------------------------
172
173 bool wxAppConsole::OnInit()
174 {
175 #if wxUSE_CMDLINE_PARSER
176 wxCmdLineParser parser(argc, argv);
177
178 OnInitCmdLine(parser);
179
180 bool cont;
181 switch ( parser.Parse(false /* don't show usage */) )
182 {
183 case -1:
184 cont = OnCmdLineHelp(parser);
185 break;
186
187 case 0:
188 cont = OnCmdLineParsed(parser);
189 break;
190
191 default:
192 cont = OnCmdLineError(parser);
193 break;
194 }
195
196 if ( !cont )
197 return false;
198 #endif // wxUSE_CMDLINE_PARSER
199
200 return true;
201 }
202
203 int wxAppConsole::OnExit()
204 {
205 #if wxUSE_CONFIG
206 // delete the config object if any (don't use Get() here, but Set()
207 // because Get() could create a new config object)
208 delete wxConfigBase::Set((wxConfigBase *) NULL);
209 #endif // wxUSE_CONFIG
210
211 return 0;
212 }
213
214 void wxAppConsole::Exit()
215 {
216 exit(-1);
217 }
218
219 // ----------------------------------------------------------------------------
220 // traits stuff
221 // ----------------------------------------------------------------------------
222
223 wxAppTraits *wxAppConsole::CreateTraits()
224 {
225 return new wxConsoleAppTraits;
226 }
227
228 wxAppTraits *wxAppConsole::GetTraits()
229 {
230 // FIXME-MT: protect this with a CS?
231 if ( !m_traits )
232 {
233 m_traits = CreateTraits();
234
235 wxASSERT_MSG( m_traits, _T("wxApp::CreateTraits() failed?") );
236 }
237
238 return m_traits;
239 }
240
241 // we must implement CreateXXX() in wxApp itself for backwards compatibility
242 #if WXWIN_COMPATIBILITY_2_4
243
244 #if wxUSE_LOG
245
246 wxLog *wxAppConsole::CreateLogTarget()
247 {
248 wxAppTraits *traits = GetTraits();
249 return traits ? traits->CreateLogTarget() : NULL;
250 }
251
252 #endif // wxUSE_LOG
253
254 wxMessageOutput *wxAppConsole::CreateMessageOutput()
255 {
256 wxAppTraits *traits = GetTraits();
257 return traits ? traits->CreateMessageOutput() : NULL;
258 }
259
260 #endif // WXWIN_COMPATIBILITY_2_4
261
262 // ----------------------------------------------------------------------------
263 // event processing
264 // ----------------------------------------------------------------------------
265
266 void wxAppConsole::ProcessPendingEvents()
267 {
268 #if wxUSE_THREADS
269 if ( !wxPendingEventsLocker )
270 return;
271 #endif
272
273 // ensure that we're the only thread to modify the pending events list
274 wxENTER_CRIT_SECT( *wxPendingEventsLocker );
275
276 if ( !wxPendingEvents )
277 {
278 wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
279 return;
280 }
281
282 // iterate until the list becomes empty
283 wxList::compatibility_iterator node = wxPendingEvents->GetFirst();
284 while (node)
285 {
286 wxEvtHandler *handler = (wxEvtHandler *)node->GetData();
287 wxPendingEvents->Erase(node);
288
289 // In ProcessPendingEvents(), new handlers might be add
290 // and we can safely leave the critical section here.
291 wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
292
293 handler->ProcessPendingEvents();
294
295 wxENTER_CRIT_SECT( *wxPendingEventsLocker );
296
297 node = wxPendingEvents->GetFirst();
298 }
299
300 wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
301 }
302
303 int wxAppConsole::FilterEvent(wxEvent& WXUNUSED(event))
304 {
305 // process the events normally by default
306 return -1;
307 }
308
309 // ----------------------------------------------------------------------------
310 // exception handling
311 // ----------------------------------------------------------------------------
312
313 #if wxUSE_EXCEPTIONS
314
315 void
316 wxAppConsole::HandleEvent(wxEvtHandler *handler,
317 wxEventFunction func,
318 wxEvent& event) const
319 {
320 // by default, simply call the handler
321 (handler->*func)(event);
322 }
323
324 #endif // wxUSE_EXCEPTIONS
325
326 // ----------------------------------------------------------------------------
327 // cmd line parsing
328 // ----------------------------------------------------------------------------
329
330 #if wxUSE_CMDLINE_PARSER
331
332 #define OPTION_VERBOSE _T("verbose")
333
334 void wxAppConsole::OnInitCmdLine(wxCmdLineParser& parser)
335 {
336 // the standard command line options
337 static const wxCmdLineEntryDesc cmdLineDesc[] =
338 {
339 {
340 wxCMD_LINE_SWITCH,
341 _T("h"),
342 _T("help"),
343 gettext_noop("show this help message"),
344 wxCMD_LINE_VAL_NONE,
345 wxCMD_LINE_OPTION_HELP
346 },
347
348 #if wxUSE_LOG
349 {
350 wxCMD_LINE_SWITCH,
351 wxEmptyString,
352 OPTION_VERBOSE,
353 gettext_noop("generate verbose log messages"),
354 wxCMD_LINE_VAL_NONE,
355 0x0
356 },
357 #endif // wxUSE_LOG
358
359 // terminator
360 {
361 wxCMD_LINE_NONE,
362 wxEmptyString,
363 wxEmptyString,
364 wxEmptyString,
365 wxCMD_LINE_VAL_NONE,
366 0x0
367 }
368 };
369
370 parser.SetDesc(cmdLineDesc);
371 }
372
373 bool wxAppConsole::OnCmdLineParsed(wxCmdLineParser& parser)
374 {
375 #if wxUSE_LOG
376 if ( parser.Found(OPTION_VERBOSE) )
377 {
378 wxLog::SetVerbose(true);
379 }
380 #else
381 wxUnusedVar(parser);
382 #endif // wxUSE_LOG
383
384 return true;
385 }
386
387 bool wxAppConsole::OnCmdLineHelp(wxCmdLineParser& parser)
388 {
389 parser.Usage();
390
391 return false;
392 }
393
394 bool wxAppConsole::OnCmdLineError(wxCmdLineParser& parser)
395 {
396 parser.Usage();
397
398 return false;
399 }
400
401 #endif // wxUSE_CMDLINE_PARSER
402
403 // ----------------------------------------------------------------------------
404 // debugging support
405 // ----------------------------------------------------------------------------
406
407 /* static */
408 bool wxAppConsole::CheckBuildOptions(const char *optionsSignature,
409 const char *componentName)
410 {
411 #if 0 // can't use wxLogTrace, not up and running yet
412 printf("checking build options object '%s' (ptr %p) in '%s'\n",
413 optionsSignature, optionsSignature, componentName);
414 #endif
415
416 if ( strcmp(optionsSignature, WX_BUILD_OPTIONS_SIGNATURE) != 0 )
417 {
418 wxString lib = wxString::FromAscii(WX_BUILD_OPTIONS_SIGNATURE);
419 wxString prog = wxString::FromAscii(optionsSignature);
420 wxString progName = wxString::FromAscii(componentName);
421 wxString msg;
422
423 msg.Printf(_T("Mismatch between the program and library build versions detected.\nThe library used %s,\nand %s used %s."),
424 lib.c_str(), progName.c_str(), prog.c_str());
425
426 wxLogFatalError(msg.c_str());
427
428 // normally wxLogFatalError doesn't return
429 return false;
430 }
431 #undef wxCMP
432
433 return true;
434 }
435
436 #ifdef __WXDEBUG__
437
438 void wxAppConsole::OnAssertFailure(const wxChar *file,
439 int line,
440 const wxChar *func,
441 const wxChar *cond,
442 const wxChar *msg)
443 {
444 ShowAssertDialog(file, line, func, cond, msg, GetTraits());
445 }
446
447 void wxAppConsole::OnAssert(const wxChar *file,
448 int line,
449 const wxChar *cond,
450 const wxChar *msg)
451 {
452 OnAssertFailure(file, line, NULL, cond, msg);
453 }
454
455 #endif // __WXDEBUG__
456
457 #if WXWIN_COMPATIBILITY_2_4
458
459 bool wxAppConsole::CheckBuildOptions(const wxBuildOptions& buildOptions)
460 {
461 return CheckBuildOptions(buildOptions.m_signature, "your program");
462 }
463
464 #endif
465
466 // ============================================================================
467 // other classes implementations
468 // ============================================================================
469
470 // ----------------------------------------------------------------------------
471 // wxConsoleAppTraitsBase
472 // ----------------------------------------------------------------------------
473
474 #if wxUSE_LOG
475
476 wxLog *wxConsoleAppTraitsBase::CreateLogTarget()
477 {
478 return new wxLogStderr;
479 }
480
481 #endif // wxUSE_LOG
482
483 wxMessageOutput *wxConsoleAppTraitsBase::CreateMessageOutput()
484 {
485 return new wxMessageOutputStderr;
486 }
487
488 #if wxUSE_FONTMAP
489
490 wxFontMapper *wxConsoleAppTraitsBase::CreateFontMapper()
491 {
492 return (wxFontMapper *)new wxFontMapperBase;
493 }
494
495 #endif // wxUSE_FONTMAP
496
497 wxRendererNative *wxConsoleAppTraitsBase::CreateRenderer()
498 {
499 // console applications don't use renderers
500 return NULL;
501 }
502
503 #ifdef __WXDEBUG__
504 bool wxConsoleAppTraitsBase::ShowAssertDialog(const wxString& msg)
505 {
506 return wxAppTraitsBase::ShowAssertDialog(msg);
507 }
508 #endif
509
510 bool wxConsoleAppTraitsBase::HasStderr()
511 {
512 // console applications always have stderr, even under Mac/Windows
513 return true;
514 }
515
516 void wxConsoleAppTraitsBase::ScheduleForDestroy(wxObject *object)
517 {
518 delete object;
519 }
520
521 void wxConsoleAppTraitsBase::RemoveFromPendingDelete(wxObject * WXUNUSED(object))
522 {
523 // nothing to do
524 }
525
526 #if wxUSE_SOCKETS
527 GSocketGUIFunctionsTable* wxConsoleAppTraitsBase::GetSocketGUIFunctionsTable()
528 {
529 return NULL;
530 }
531 #endif
532
533 // ----------------------------------------------------------------------------
534 // wxAppTraits
535 // ----------------------------------------------------------------------------
536
537 #ifdef __WXDEBUG__
538
539 bool wxAppTraitsBase::ShowAssertDialog(const wxString& msg)
540 {
541 return DoShowAssertDialog(msg);
542 }
543
544 #endif // __WXDEBUG__
545
546 // ============================================================================
547 // global functions implementation
548 // ============================================================================
549
550 void wxExit()
551 {
552 if ( wxTheApp )
553 {
554 wxTheApp->Exit();
555 }
556 else
557 {
558 // what else can we do?
559 exit(-1);
560 }
561 }
562
563 void wxWakeUpIdle()
564 {
565 if ( wxTheApp )
566 {
567 wxTheApp->WakeUpIdle();
568 }
569 //else: do nothing, what can we do?
570 }
571
572 #ifdef __WXDEBUG__
573
574 // wxASSERT() helper
575 bool wxAssertIsEqual(int x, int y)
576 {
577 return x == y;
578 }
579
580 // break into the debugger
581 void wxTrap()
582 {
583 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
584 DebugBreak();
585 #elif defined(__WXMAC__) && !defined(__DARWIN__)
586 #if __powerc
587 Debugger();
588 #else
589 SysBreak();
590 #endif
591 #elif defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
592 Debugger();
593 #elif defined(__UNIX__)
594 raise(SIGTRAP);
595 #else
596 // TODO
597 #endif // Win/Unix
598 }
599
600 // this function is called when an assert fails
601 void wxOnAssert(const wxChar *szFile,
602 int nLine,
603 const char *szFunc,
604 const wxChar *szCond,
605 const wxChar *szMsg)
606 {
607 // FIXME MT-unsafe
608 static bool s_bInAssert = false;
609
610 if ( s_bInAssert )
611 {
612 // He-e-e-e-elp!! we're trapped in endless loop
613 wxTrap();
614
615 s_bInAssert = false;
616
617 return;
618 }
619
620 s_bInAssert = true;
621
622 // __FUNCTION__ is always in ASCII, convert it to wide char if needed
623 const wxString strFunc = wxString::FromAscii(szFunc);
624
625 if ( !wxTheApp )
626 {
627 // by default, show the assert dialog box -- we can't customize this
628 // behaviour
629 ShowAssertDialog(szFile, nLine, strFunc, szCond, szMsg);
630 }
631 else
632 {
633 // let the app process it as it wants
634 wxTheApp->OnAssertFailure(szFile, nLine, strFunc, szCond, szMsg);
635 }
636
637 s_bInAssert = false;
638 }
639
640 #endif // __WXDEBUG__
641
642 // ============================================================================
643 // private functions implementation
644 // ============================================================================
645
646 #ifdef __WXDEBUG__
647
648 static void LINKAGEMODE SetTraceMasks()
649 {
650 #if wxUSE_LOG
651 wxString mask;
652 if ( wxGetEnv(wxT("WXTRACE"), &mask) )
653 {
654 wxStringTokenizer tkn(mask, wxT(",;:"));
655 while ( tkn.HasMoreTokens() )
656 wxLog::AddTraceMask(tkn.GetNextToken());
657 }
658 #endif // wxUSE_LOG
659 }
660
661 bool DoShowAssertDialog(const wxString& msg)
662 {
663 // under MSW we can show the dialog even in the console mode
664 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
665 wxString msgDlg(msg);
666
667 // this message is intentionally not translated -- it is for
668 // developpers only
669 msgDlg += wxT("\nDo you want to stop the program?\n")
670 wxT("You can also choose [Cancel] to suppress ")
671 wxT("further warnings.");
672
673 switch ( ::MessageBox(NULL, msgDlg, _T("wxWidgets Debug Alert"),
674 MB_YESNOCANCEL | MB_ICONSTOP ) )
675 {
676 case IDYES:
677 wxTrap();
678 break;
679
680 case IDCANCEL:
681 // stop the asserts
682 return true;
683
684 //case IDNO: nothing to do
685 }
686 #else // !__WXMSW__
687 wxFprintf(stderr, wxT("%s\n"), msg.c_str());
688 fflush(stderr);
689
690 // TODO: ask the user to enter "Y" or "N" on the console?
691 wxTrap();
692 #endif // __WXMSW__/!__WXMSW__
693
694 // continue with the asserts
695 return false;
696 }
697
698 #if wxUSE_STACKWALKER
699 static wxString GetAssertStackTrace()
700 {
701 wxString stackTrace;
702
703 class StackDump : public wxStackWalker
704 {
705 public:
706 StackDump() { }
707
708 const wxString& GetStackTrace() const { return m_stackTrace; }
709
710 protected:
711 virtual void OnStackFrame(const wxStackFrame& frame)
712 {
713 m_stackTrace << wxString::Format
714 (
715 _T("[%02d] "),
716 wx_truncate_cast(int, frame.GetLevel())
717 );
718
719 wxString name = frame.GetName();
720 if ( !name.empty() )
721 {
722 m_stackTrace << wxString::Format(_T("%-40s"), name.c_str());
723 }
724 else
725 {
726 m_stackTrace << wxString::Format(_T("%p"), frame.GetAddress());
727 }
728
729 if ( frame.HasSourceLocation() )
730 {
731 m_stackTrace << _T('\t')
732 << frame.GetFileName()
733 << _T(':')
734 << frame.GetLine();
735 }
736
737 m_stackTrace << _T('\n');
738 }
739
740 private:
741 wxString m_stackTrace;
742 };
743
744 StackDump dump;
745 dump.Walk(2); // don't show OnAssert() call itself
746 stackTrace = dump.GetStackTrace();
747
748 // don't show more than maxLines or we could get a dialog too tall to be
749 // shown on screen: 20 should be ok everywhere as even with 15 pixel high
750 // characters it is still only 300 pixels...
751 static const int maxLines = 20;
752 const int count = stackTrace.Freq(wxT('\n'));
753 for ( int i = 0; i < count - maxLines; i++ )
754 stackTrace = stackTrace.BeforeLast(wxT('\n'));
755
756 return stackTrace;
757 }
758 #endif // wxUSE_STACKWALKER
759
760 // show the assert modal dialog
761 static
762 void ShowAssertDialog(const wxChar *szFile,
763 int nLine,
764 const wxChar *szFunc,
765 const wxChar *szCond,
766 const wxChar *szMsg,
767 wxAppTraits *traits)
768 {
769 // this variable can be set to true to suppress "assert failure" messages
770 static bool s_bNoAsserts = false;
771
772 wxString msg;
773 msg.reserve(2048);
774
775 // make life easier for people using VC++ IDE by using this format: like
776 // this, clicking on the message will take us immediately to the place of
777 // the failed assert
778 msg.Printf(wxT("%s(%d): assert \"%s\" failed"), szFile, nLine, szCond);
779
780 // add the function name, if any
781 if ( szFunc && *szFunc )
782 msg << _T(" in ") << szFunc << _T("()");
783
784 // and the message itself
785 if ( szMsg )
786 {
787 msg << _T(": ") << szMsg;
788 }
789 else // no message given
790 {
791 msg << _T('.');
792 }
793
794 #if wxUSE_STACKWALKER
795 const wxString stackTrace = GetAssertStackTrace();
796 if ( !stackTrace.empty() )
797 {
798 msg << _T("\n\nCall stack:\n") << stackTrace;
799 }
800 #endif // wxUSE_STACKWALKER
801
802 #if wxUSE_THREADS
803 // if we are not in the main thread, output the assert directly and trap
804 // since dialogs cannot be displayed
805 if ( !wxThread::IsMain() )
806 {
807 msg += wxT(" [in child thread]");
808
809 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
810 msg << wxT("\r\n");
811 OutputDebugString(msg );
812 #else
813 // send to stderr
814 wxFprintf(stderr, wxT("%s\n"), msg.c_str());
815 fflush(stderr);
816 #endif
817 // He-e-e-e-elp!! we're asserting in a child thread
818 wxTrap();
819 }
820 else
821 #endif // wxUSE_THREADS
822
823 if ( !s_bNoAsserts )
824 {
825 // send it to the normal log destination
826 wxLogDebug(_T("%s"), msg.c_str());
827
828 if ( traits )
829 {
830 // delegate showing assert dialog (if possible) to that class
831 s_bNoAsserts = traits->ShowAssertDialog(msg);
832 }
833 else // no traits object
834 {
835 // fall back to the function of last resort
836 s_bNoAsserts = DoShowAssertDialog(msg);
837 }
838 }
839 }
840
841 #endif // __WXDEBUG__