/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/src/common/appbase.cpp
ViewVC logotype

Contents of /trunk/3rdparty/wxWidgets/src/common/appbase.cpp

Parent Directory Parent Directory | Revision Log Revision Log


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

  ViewVC Help
Powered by ViewVC 1.1.22