]> git.saurik.com Git - wxWidgets.git/blob - src/common/appbase.cpp
use iterators instead of c_str()
[wxWidgets.git] / src / common / appbase.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/appbase.cpp
3 // Purpose: implements wxAppConsoleBase 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 #ifdef __WXMSW__
29 #include "wx/msw/wrapwin.h" // includes windows.h for MessageBox()
30 #endif
31 #include "wx/list.h"
32 #include "wx/app.h"
33 #include "wx/intl.h"
34 #include "wx/log.h"
35 #include "wx/utils.h"
36 #include "wx/wxcrtvararg.h"
37 #endif //WX_PRECOMP
38
39 #include "wx/apptrait.h"
40 #include "wx/cmdline.h"
41 #include "wx/confbase.h"
42 #include "wx/evtloop.h"
43 #include "wx/filename.h"
44 #include "wx/msgout.h"
45 #include "wx/ptr_scpd.h"
46 #include "wx/tokenzr.h"
47
48 #if wxUSE_EXCEPTIONS && wxUSE_STL
49 #include <exception>
50 #include <typeinfo>
51 #endif
52
53 #if !defined(__WXMSW__) || defined(__WXMICROWIN__)
54 #include <signal.h> // for SIGTRAP used by wxTrap()
55 #endif //Win/Unix
56
57 #include <locale.h>
58
59 #if wxUSE_FONTMAP
60 #include "wx/fontmap.h"
61 #endif // wxUSE_FONTMAP
62
63 #if defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
64 // For MacTypes.h for Debugger function
65 #include <CoreFoundation/CFBase.h>
66 #endif
67
68 #if defined(__WXMAC__)
69 #ifdef __DARWIN__
70 #include <CoreServices/CoreServices.h>
71 #else
72 #include "wx/mac/private.h" // includes mac headers
73 #endif
74 #endif // __WXMAC__
75
76 #ifdef __WXDEBUG__
77 #if wxUSE_STACKWALKER
78 #include "wx/stackwalk.h"
79 #ifdef __WXMSW__
80 #include "wx/msw/debughlp.h"
81 #endif
82 #endif // wxUSE_STACKWALKER
83 #endif // __WXDEBUG__
84
85 // wxABI_VERSION can be defined when compiling applications but it should be
86 // left undefined when compiling the library itself, it is then set to its
87 // default value in version.h
88 #if wxABI_VERSION != wxMAJOR_VERSION * 10000 + wxMINOR_VERSION * 100 + 99
89 #error "wxABI_VERSION should not be defined when compiling the library"
90 #endif
91
92 // ----------------------------------------------------------------------------
93 // private functions prototypes
94 // ----------------------------------------------------------------------------
95
96 #ifdef __WXDEBUG__
97 // really just show the assert dialog
98 static bool DoShowAssertDialog(const wxString& msg);
99
100 // prepare for showing the assert dialog, use the given traits or
101 // DoShowAssertDialog() as last fallback to really show it
102 static
103 void ShowAssertDialog(const wxString& szFile,
104 int nLine,
105 const wxString& szFunc,
106 const wxString& szCond,
107 const wxString& szMsg,
108 wxAppTraits *traits = NULL);
109
110 // turn on the trace masks specified in the env variable WXTRACE
111 static void LINKAGEMODE SetTraceMasks();
112 #endif // __WXDEBUG__
113
114 // ----------------------------------------------------------------------------
115 // global vars
116 // ----------------------------------------------------------------------------
117
118 wxAppConsole *wxAppConsoleBase::ms_appInstance = NULL;
119
120 wxAppInitializerFunction wxAppConsoleBase::ms_appInitFn = NULL;
121
122 // ----------------------------------------------------------------------------
123 // wxEventLoopPtr
124 // ----------------------------------------------------------------------------
125
126 // this defines wxEventLoopPtr
127 wxDEFINE_TIED_SCOPED_PTR_TYPE(wxEventLoopBase)
128
129 // ============================================================================
130 // wxAppConsoleBase implementation
131 // ============================================================================
132
133 // ----------------------------------------------------------------------------
134 // ctor/dtor
135 // ----------------------------------------------------------------------------
136
137 wxAppConsoleBase::wxAppConsoleBase()
138 {
139 m_traits = NULL;
140 m_mainLoop = NULL;
141
142 ms_appInstance = wx_static_cast(wxAppConsole *, this);
143
144 #ifdef __WXDEBUG__
145 SetTraceMasks();
146 #if wxUSE_UNICODE
147 // In unicode mode the SetTraceMasks call can cause an apptraits to be
148 // created, but since we are still in the constructor the wrong kind will
149 // be created for GUI apps. Destroy it so it can be created again later.
150 delete m_traits;
151 m_traits = NULL;
152 #endif
153 #endif
154 }
155
156 wxAppConsoleBase::~wxAppConsoleBase()
157 {
158 delete m_traits;
159 }
160
161 // ----------------------------------------------------------------------------
162 // initilization/cleanup
163 // ----------------------------------------------------------------------------
164
165 bool wxAppConsoleBase::Initialize(int& argcOrig, wxChar **argvOrig)
166 {
167 #if wxUSE_INTL
168 GetTraits()->SetLocale();
169 #endif // wxUSE_INTL
170
171 // remember the command line arguments
172 argc = argcOrig;
173 argv = argvOrig;
174
175 #if wxUSE_THREADS
176 wxPendingEventsLocker = new wxCriticalSection;
177 #endif
178
179 #ifndef __WXPALMOS__
180 if ( m_appName.empty() && argv )
181 {
182 // the application name is, by default, the name of its executable file
183 wxFileName::SplitPath(argv[0], NULL, &m_appName, NULL);
184 }
185 #endif // !__WXPALMOS__
186
187 return true;
188 }
189
190 wxEventLoopBase *wxAppConsoleBase::CreateMainLoop()
191 {
192 return GetTraits()->CreateEventLoop();
193 }
194
195 void wxAppConsoleBase::CleanUp()
196 {
197 if ( m_mainLoop )
198 {
199 delete m_mainLoop;
200 m_mainLoop = NULL;
201 }
202
203 delete wxPendingEvents;
204 wxPendingEvents = NULL;
205
206 #if wxUSE_THREADS
207 delete wxPendingEventsLocker;
208 wxPendingEventsLocker = NULL;
209 #endif // wxUSE_THREADS
210 }
211
212 // ----------------------------------------------------------------------------
213 // OnXXX() callbacks
214 // ----------------------------------------------------------------------------
215
216 bool wxAppConsoleBase::OnInit()
217 {
218 #if wxUSE_CMDLINE_PARSER
219 wxCmdLineParser parser(argc, argv);
220
221 OnInitCmdLine(parser);
222
223 bool cont;
224 switch ( parser.Parse(false /* don't show usage */) )
225 {
226 case -1:
227 cont = OnCmdLineHelp(parser);
228 break;
229
230 case 0:
231 cont = OnCmdLineParsed(parser);
232 break;
233
234 default:
235 cont = OnCmdLineError(parser);
236 break;
237 }
238
239 if ( !cont )
240 return false;
241 #endif // wxUSE_CMDLINE_PARSER
242
243 return true;
244 }
245
246 int wxAppConsoleBase::OnRun()
247 {
248 return MainLoop();
249 }
250
251 int wxAppConsoleBase::OnExit()
252 {
253 #if wxUSE_CONFIG
254 // delete the config object if any (don't use Get() here, but Set()
255 // because Get() could create a new config object)
256 delete wxConfigBase::Set((wxConfigBase *) NULL);
257 #endif // wxUSE_CONFIG
258
259 return 0;
260 }
261
262 void wxAppConsoleBase::Exit()
263 {
264 if (m_mainLoop != NULL)
265 ExitMainLoop();
266 else
267 exit(-1);
268 }
269
270 // ----------------------------------------------------------------------------
271 // traits stuff
272 // ----------------------------------------------------------------------------
273
274 wxAppTraits *wxAppConsoleBase::CreateTraits()
275 {
276 return new wxConsoleAppTraits;
277 }
278
279 wxAppTraits *wxAppConsoleBase::GetTraits()
280 {
281 // FIXME-MT: protect this with a CS?
282 if ( !m_traits )
283 {
284 m_traits = CreateTraits();
285
286 wxASSERT_MSG( m_traits, _T("wxApp::CreateTraits() failed?") );
287 }
288
289 return m_traits;
290 }
291
292 // ----------------------------------------------------------------------------
293 // event processing
294 // ----------------------------------------------------------------------------
295
296 int wxAppConsoleBase::MainLoop()
297 {
298 wxEventLoopBaseTiedPtr mainLoop(&m_mainLoop, CreateMainLoop());
299
300 return m_mainLoop ? m_mainLoop->Run() : -1;
301 }
302
303 void wxAppConsoleBase::ExitMainLoop()
304 {
305 // we should exit from the main event loop, not just any currently active
306 // (e.g. modal dialog) event loop
307 if ( m_mainLoop && m_mainLoop->IsRunning() )
308 {
309 m_mainLoop->Exit(0);
310 }
311 }
312
313 bool wxAppConsoleBase::Pending()
314 {
315 // use the currently active message loop here, not m_mainLoop, because if
316 // we're showing a modal dialog (with its own event loop) currently the
317 // main event loop is not running anyhow
318 wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
319
320 return loop && loop->Pending();
321 }
322
323 bool wxAppConsoleBase::Dispatch()
324 {
325 // see comment in Pending()
326 wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
327
328 return loop && loop->Dispatch();
329 }
330
331 bool wxAppConsoleBase::HasPendingEvents() const
332 {
333 wxENTER_CRIT_SECT( *wxPendingEventsLocker );
334
335 bool has = wxPendingEvents && !wxPendingEvents->IsEmpty();
336
337 wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
338
339 return has;
340 }
341
342 /* static */
343 bool wxAppConsoleBase::IsMainLoopRunning()
344 {
345 const wxAppConsole * const app = GetInstance();
346
347 return app && app->m_mainLoop != NULL;
348 }
349
350 void wxAppConsoleBase::ProcessPendingEvents()
351 {
352 #if wxUSE_THREADS
353 if ( !wxPendingEventsLocker )
354 return;
355 #endif
356
357 wxENTER_CRIT_SECT( *wxPendingEventsLocker );
358
359 if (wxPendingEvents)
360 {
361 // iterate until the list becomes empty
362 wxList::compatibility_iterator node = wxPendingEvents->GetFirst();
363 while (node)
364 {
365 wxEvtHandler *handler = (wxEvtHandler *)node->GetData();
366 wxPendingEvents->Erase(node);
367
368 // In ProcessPendingEvents(), new handlers might be add
369 // and we can safely leave the critical section here.
370 wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
371
372 handler->ProcessPendingEvents();
373
374 wxENTER_CRIT_SECT( *wxPendingEventsLocker );
375
376 node = wxPendingEvents->GetFirst();
377 }
378 }
379
380 wxLEAVE_CRIT_SECT( *wxPendingEventsLocker );
381 }
382
383 void wxAppConsoleBase::WakeUpIdle()
384 {
385 if ( m_mainLoop )
386 m_mainLoop->WakeUp();
387 }
388
389 bool wxAppConsoleBase::ProcessIdle()
390 {
391 wxIdleEvent event;
392
393 event.SetEventObject(this);
394 ProcessEvent(event);
395 return event.MoreRequested();
396 }
397
398 int wxAppConsoleBase::FilterEvent(wxEvent& WXUNUSED(event))
399 {
400 // process the events normally by default
401 return -1;
402 }
403
404 // ----------------------------------------------------------------------------
405 // exception handling
406 // ----------------------------------------------------------------------------
407
408 #if wxUSE_EXCEPTIONS
409
410 void
411 wxAppConsoleBase::HandleEvent(wxEvtHandler *handler,
412 wxEventFunction func,
413 wxEvent& event) const
414 {
415 // by default, simply call the handler
416 (handler->*func)(event);
417 }
418
419 void wxAppConsoleBase::OnUnhandledException()
420 {
421 #ifdef __WXDEBUG__
422 // we're called from an exception handler so we can re-throw the exception
423 // to recover its type
424 wxString what;
425 try
426 {
427 throw;
428 }
429 #if wxUSE_STL
430 catch ( std::exception& e )
431 {
432 what.Printf("std::exception of type \"%s\", what() = \"%s\"",
433 typeid(e).name(), e.what());
434 }
435 #endif // wxUSE_STL
436 catch ( ... )
437 {
438 what = "unknown exception";
439 }
440
441 wxMessageOutputBest().Printf(
442 "*** Caught unhandled %s; terminating\n", what
443 );
444 #endif // __WXDEBUG__
445 }
446
447 // ----------------------------------------------------------------------------
448 // exceptions support
449 // ----------------------------------------------------------------------------
450
451 bool wxAppConsoleBase::OnExceptionInMainLoop()
452 {
453 throw;
454
455 // some compilers are too stupid to know that we never return after throw
456 #if defined(__DMC__) || (defined(_MSC_VER) && _MSC_VER < 1200)
457 return false;
458 #endif
459 }
460
461 #endif // wxUSE_EXCEPTIONS
462
463 // ----------------------------------------------------------------------------
464 // cmd line parsing
465 // ----------------------------------------------------------------------------
466
467 #if wxUSE_CMDLINE_PARSER
468
469 #define OPTION_VERBOSE _T("verbose")
470
471 void wxAppConsoleBase::OnInitCmdLine(wxCmdLineParser& parser)
472 {
473 // the standard command line options
474 static const wxCmdLineEntryDesc cmdLineDesc[] =
475 {
476 {
477 wxCMD_LINE_SWITCH,
478 _T("h"),
479 _T("help"),
480 gettext_noop("show this help message"),
481 wxCMD_LINE_VAL_NONE,
482 wxCMD_LINE_OPTION_HELP
483 },
484
485 #if wxUSE_LOG
486 {
487 wxCMD_LINE_SWITCH,
488 wxEmptyString,
489 OPTION_VERBOSE,
490 gettext_noop("generate verbose log messages"),
491 wxCMD_LINE_VAL_NONE,
492 0x0
493 },
494 #endif // wxUSE_LOG
495
496 // terminator
497 {
498 wxCMD_LINE_NONE,
499 wxEmptyString,
500 wxEmptyString,
501 wxEmptyString,
502 wxCMD_LINE_VAL_NONE,
503 0x0
504 }
505 };
506
507 parser.SetDesc(cmdLineDesc);
508 }
509
510 bool wxAppConsoleBase::OnCmdLineParsed(wxCmdLineParser& parser)
511 {
512 #if wxUSE_LOG
513 if ( parser.Found(OPTION_VERBOSE) )
514 {
515 wxLog::SetVerbose(true);
516 }
517 #else
518 wxUnusedVar(parser);
519 #endif // wxUSE_LOG
520
521 return true;
522 }
523
524 bool wxAppConsoleBase::OnCmdLineHelp(wxCmdLineParser& parser)
525 {
526 parser.Usage();
527
528 return false;
529 }
530
531 bool wxAppConsoleBase::OnCmdLineError(wxCmdLineParser& parser)
532 {
533 parser.Usage();
534
535 return false;
536 }
537
538 #endif // wxUSE_CMDLINE_PARSER
539
540 // ----------------------------------------------------------------------------
541 // debugging support
542 // ----------------------------------------------------------------------------
543
544 /* static */
545 bool wxAppConsoleBase::CheckBuildOptions(const char *optionsSignature,
546 const char *componentName)
547 {
548 #if 0 // can't use wxLogTrace, not up and running yet
549 printf("checking build options object '%s' (ptr %p) in '%s'\n",
550 optionsSignature, optionsSignature, componentName);
551 #endif
552
553 if ( strcmp(optionsSignature, WX_BUILD_OPTIONS_SIGNATURE) != 0 )
554 {
555 wxString lib = wxString::FromAscii(WX_BUILD_OPTIONS_SIGNATURE);
556 wxString prog = wxString::FromAscii(optionsSignature);
557 wxString progName = wxString::FromAscii(componentName);
558 wxString msg;
559
560 msg.Printf(_T("Mismatch between the program and library build versions detected.\nThe library used %s,\nand %s used %s."),
561 lib.c_str(), progName.c_str(), prog.c_str());
562
563 wxLogFatalError(msg.c_str());
564
565 // normally wxLogFatalError doesn't return
566 return false;
567 }
568 #undef wxCMP
569
570 return true;
571 }
572
573 #ifdef __WXDEBUG__
574
575 void wxAppConsoleBase::OnAssertFailure(const wxChar *file,
576 int line,
577 const wxChar *func,
578 const wxChar *cond,
579 const wxChar *msg)
580 {
581 ShowAssertDialog(file, line, func, cond, msg, GetTraits());
582 }
583
584 void wxAppConsoleBase::OnAssert(const wxChar *file,
585 int line,
586 const wxChar *cond,
587 const wxChar *msg)
588 {
589 OnAssertFailure(file, line, NULL, cond, msg);
590 }
591
592 #endif // __WXDEBUG__
593
594 // ============================================================================
595 // other classes implementations
596 // ============================================================================
597
598 // ----------------------------------------------------------------------------
599 // wxConsoleAppTraitsBase
600 // ----------------------------------------------------------------------------
601
602 #if wxUSE_LOG
603
604 wxLog *wxConsoleAppTraitsBase::CreateLogTarget()
605 {
606 return new wxLogStderr;
607 }
608
609 #endif // wxUSE_LOG
610
611 wxMessageOutput *wxConsoleAppTraitsBase::CreateMessageOutput()
612 {
613 return new wxMessageOutputStderr;
614 }
615
616 #if wxUSE_FONTMAP
617
618 wxFontMapper *wxConsoleAppTraitsBase::CreateFontMapper()
619 {
620 return (wxFontMapper *)new wxFontMapperBase;
621 }
622
623 #endif // wxUSE_FONTMAP
624
625 wxRendererNative *wxConsoleAppTraitsBase::CreateRenderer()
626 {
627 // console applications don't use renderers
628 return NULL;
629 }
630
631 #ifdef __WXDEBUG__
632 bool wxConsoleAppTraitsBase::ShowAssertDialog(const wxString& msg)
633 {
634 return wxAppTraitsBase::ShowAssertDialog(msg);
635 }
636 #endif
637
638 bool wxConsoleAppTraitsBase::HasStderr()
639 {
640 // console applications always have stderr, even under Mac/Windows
641 return true;
642 }
643
644 void wxConsoleAppTraitsBase::ScheduleForDestroy(wxObject *object)
645 {
646 delete object;
647 }
648
649 void wxConsoleAppTraitsBase::RemoveFromPendingDelete(wxObject * WXUNUSED(object))
650 {
651 // nothing to do
652 }
653
654 #if wxUSE_SOCKETS
655 GSocketGUIFunctionsTable* wxConsoleAppTraitsBase::GetSocketGUIFunctionsTable()
656 {
657 return NULL;
658 }
659 #endif
660
661 // ----------------------------------------------------------------------------
662 // wxAppTraits
663 // ----------------------------------------------------------------------------
664
665 #if wxUSE_INTL
666 void wxAppTraitsBase::SetLocale()
667 {
668 setlocale(LC_ALL, "");
669 wxUpdateLocaleIsUtf8();
670 }
671 #endif
672
673 #ifdef __WXDEBUG__
674
675 bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal)
676 {
677 wxString msg = msgOriginal;
678
679 #if wxUSE_STACKWALKER
680 #if !defined(__WXMSW__)
681 // on Unix stack frame generation may take some time, depending on the
682 // size of the executable mainly... warn the user that we are working
683 wxFprintf(stderr, wxT("[Debug] Generating a stack trace... please wait"));
684 fflush(stderr);
685 #endif
686
687 const wxString stackTrace = GetAssertStackTrace();
688 if ( !stackTrace.empty() )
689 msg << _T("\n\nCall stack:\n") << stackTrace;
690 #endif // wxUSE_STACKWALKER
691
692 return DoShowAssertDialog(msg);
693 }
694
695 #if wxUSE_STACKWALKER
696 wxString wxAppTraitsBase::GetAssertStackTrace()
697 {
698 wxString stackTrace;
699
700 class StackDump : public wxStackWalker
701 {
702 public:
703 StackDump() { }
704
705 const wxString& GetStackTrace() const { return m_stackTrace; }
706
707 protected:
708 virtual void OnStackFrame(const wxStackFrame& frame)
709 {
710 m_stackTrace << wxString::Format
711 (
712 _T("[%02d] "),
713 wx_truncate_cast(int, frame.GetLevel())
714 );
715
716 wxString name = frame.GetName();
717 if ( !name.empty() )
718 {
719 m_stackTrace << wxString::Format(_T("%-40s"), name.c_str());
720 }
721 else
722 {
723 m_stackTrace << wxString::Format(_T("%p"), frame.GetAddress());
724 }
725
726 if ( frame.HasSourceLocation() )
727 {
728 m_stackTrace << _T('\t')
729 << frame.GetFileName()
730 << _T(':')
731 << frame.GetLine();
732 }
733
734 m_stackTrace << _T('\n');
735 }
736
737 private:
738 wxString m_stackTrace;
739 };
740
741 // don't show more than maxLines or we could get a dialog too tall to be
742 // shown on screen: 20 should be ok everywhere as even with 15 pixel high
743 // characters it is still only 300 pixels...
744 static const int maxLines = 20;
745
746 StackDump dump;
747 dump.Walk(2, maxLines); // don't show OnAssert() call itself
748 stackTrace = dump.GetStackTrace();
749
750 const int count = stackTrace.Freq(wxT('\n'));
751 for ( int i = 0; i < count - maxLines; i++ )
752 stackTrace = stackTrace.BeforeLast(wxT('\n'));
753
754 return stackTrace;
755 }
756 #endif // wxUSE_STACKWALKER
757
758
759 #endif // __WXDEBUG__
760
761 // ============================================================================
762 // global functions implementation
763 // ============================================================================
764
765 void wxExit()
766 {
767 if ( wxTheApp )
768 {
769 wxTheApp->Exit();
770 }
771 else
772 {
773 // what else can we do?
774 exit(-1);
775 }
776 }
777
778 void wxWakeUpIdle()
779 {
780 if ( wxTheApp )
781 {
782 wxTheApp->WakeUpIdle();
783 }
784 //else: do nothing, what can we do?
785 }
786
787 #ifdef __WXDEBUG__
788
789 // wxASSERT() helper
790 bool wxAssertIsEqual(int x, int y)
791 {
792 return x == y;
793 }
794
795 // break into the debugger
796 void wxTrap()
797 {
798 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
799 DebugBreak();
800 #elif defined(__WXMAC__) && !defined(__DARWIN__)
801 #if __powerc
802 Debugger();
803 #else
804 SysBreak();
805 #endif
806 #elif defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
807 Debugger();
808 #elif defined(__UNIX__)
809 raise(SIGTRAP);
810 #else
811 // TODO
812 #endif // Win/Unix
813 }
814
815 // this function is called when an assert fails
816 static void wxDoOnAssert(const wxString& szFile,
817 int nLine,
818 const wxString& szFunc,
819 const wxString& szCond,
820 const wxString& szMsg = wxEmptyString)
821 {
822 // FIXME MT-unsafe
823 static bool s_bInAssert = false;
824
825 if ( s_bInAssert )
826 {
827 // He-e-e-e-elp!! we're trapped in endless loop
828 wxTrap();
829
830 s_bInAssert = false;
831
832 return;
833 }
834
835 s_bInAssert = true;
836
837 if ( !wxTheApp )
838 {
839 // by default, show the assert dialog box -- we can't customize this
840 // behaviour
841 ShowAssertDialog(szFile, nLine, szFunc, szCond, szMsg);
842 }
843 else
844 {
845 // let the app process it as it wants
846 // FIXME-UTF8: use wc_str(), not c_str(), when ANSI build is removed
847 wxTheApp->OnAssertFailure(szFile.c_str(), nLine, szFunc.c_str(),
848 szCond.c_str(), szMsg.c_str());
849 }
850
851 s_bInAssert = false;
852 }
853
854 void wxOnAssert(const wxString& szFile,
855 int nLine,
856 const wxString& szFunc,
857 const wxString& szCond,
858 const wxString& szMsg)
859 {
860 wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
861 }
862
863 void wxOnAssert(const wxString& szFile,
864 int nLine,
865 const wxString& szFunc,
866 const wxString& szCond)
867 {
868 wxDoOnAssert(szFile, nLine, szFunc, szCond);
869 }
870
871 void wxOnAssert(const wxChar *szFile,
872 int nLine,
873 const char *szFunc,
874 const wxChar *szCond,
875 const wxChar *szMsg)
876 {
877 wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
878 }
879
880 void wxOnAssert(const char *szFile,
881 int nLine,
882 const char *szFunc,
883 const char *szCond,
884 const wxString& szMsg)
885 {
886 wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
887 }
888
889 void wxOnAssert(const char *szFile,
890 int nLine,
891 const char *szFunc,
892 const char *szCond,
893 const wxCStrData& msg)
894 {
895 wxDoOnAssert(szFile, nLine, szFunc, szCond, msg);
896 }
897
898 #if wxUSE_UNICODE
899 void wxOnAssert(const char *szFile,
900 int nLine,
901 const char *szFunc,
902 const char *szCond)
903 {
904 wxDoOnAssert(szFile, nLine, szFunc, szCond);
905 }
906
907 void wxOnAssert(const char *szFile,
908 int nLine,
909 const char *szFunc,
910 const char *szCond,
911 const char *szMsg)
912 {
913 wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
914 }
915
916 void wxOnAssert(const char *szFile,
917 int nLine,
918 const char *szFunc,
919 const char *szCond,
920 const wxChar *szMsg)
921 {
922 wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg);
923 }
924 #endif // wxUSE_UNICODE
925
926 #endif // __WXDEBUG__
927
928 // ============================================================================
929 // private functions implementation
930 // ============================================================================
931
932 #ifdef __WXDEBUG__
933
934 static void LINKAGEMODE SetTraceMasks()
935 {
936 #if wxUSE_LOG
937 wxString mask;
938 if ( wxGetEnv(wxT("WXTRACE"), &mask) )
939 {
940 wxStringTokenizer tkn(mask, wxT(",;:"));
941 while ( tkn.HasMoreTokens() )
942 wxLog::AddTraceMask(tkn.GetNextToken());
943 }
944 #endif // wxUSE_LOG
945 }
946
947 bool DoShowAssertDialog(const wxString& msg)
948 {
949 // under MSW we can show the dialog even in the console mode
950 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
951 wxString msgDlg(msg);
952
953 // this message is intentionally not translated -- it is for
954 // developpers only
955 msgDlg += wxT("\nDo you want to stop the program?\n")
956 wxT("You can also choose [Cancel] to suppress ")
957 wxT("further warnings.");
958
959 switch ( ::MessageBox(NULL, msgDlg.wx_str(), _T("wxWidgets Debug Alert"),
960 MB_YESNOCANCEL | MB_ICONSTOP ) )
961 {
962 case IDYES:
963 wxTrap();
964 break;
965
966 case IDCANCEL:
967 // stop the asserts
968 return true;
969
970 //case IDNO: nothing to do
971 }
972 #else // !__WXMSW__
973 wxFprintf(stderr, wxT("%s\n"), msg.c_str());
974 fflush(stderr);
975
976 // TODO: ask the user to enter "Y" or "N" on the console?
977 wxTrap();
978 #endif // __WXMSW__/!__WXMSW__
979
980 // continue with the asserts
981 return false;
982 }
983
984 // show the assert modal dialog
985 static
986 void ShowAssertDialog(const wxString& szFile,
987 int nLine,
988 const wxString& szFunc,
989 const wxString& szCond,
990 const wxString& szMsg,
991 wxAppTraits *traits)
992 {
993 // this variable can be set to true to suppress "assert failure" messages
994 static bool s_bNoAsserts = false;
995
996 wxString msg;
997 msg.reserve(2048);
998
999 // make life easier for people using VC++ IDE by using this format: like
1000 // this, clicking on the message will take us immediately to the place of
1001 // the failed assert
1002 msg.Printf(wxT("%s(%d): assert \"%s\" failed"), szFile, nLine, szCond);
1003
1004 // add the function name, if any
1005 if ( !szFunc.empty() )
1006 msg << _T(" in ") << szFunc << _T("()");
1007
1008 // and the message itself
1009 if ( !szMsg.empty() )
1010 {
1011 msg << _T(": ") << szMsg;
1012 }
1013 else // no message given
1014 {
1015 msg << _T('.');
1016 }
1017
1018 #if wxUSE_THREADS
1019 // if we are not in the main thread, output the assert directly and trap
1020 // since dialogs cannot be displayed
1021 if ( !wxThread::IsMain() )
1022 {
1023 msg += wxT(" [in child thread]");
1024
1025 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
1026 msg << wxT("\r\n");
1027 OutputDebugString(msg.wx_str());
1028 #else
1029 // send to stderr
1030 wxFprintf(stderr, wxT("%s\n"), msg.c_str());
1031 fflush(stderr);
1032 #endif
1033 // He-e-e-e-elp!! we're asserting in a child thread
1034 wxTrap();
1035 }
1036 else
1037 #endif // wxUSE_THREADS
1038
1039 if ( !s_bNoAsserts )
1040 {
1041 // send it to the normal log destination
1042 wxLogDebug(_T("%s"), msg.c_str());
1043
1044 if ( traits )
1045 {
1046 // delegate showing assert dialog (if possible) to that class
1047 s_bNoAsserts = traits->ShowAssertDialog(msg);
1048 }
1049 else // no traits object
1050 {
1051 // fall back to the function of last resort
1052 s_bNoAsserts = DoShowAssertDialog(msg);
1053 }
1054 }
1055 }
1056
1057 #endif // __WXDEBUG__