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