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/scopedptr.h"
  46 #include "wx/tokenzr.h"
  47 #include "wx/thread.h"
  48
  49 #if wxUSE_EXCEPTIONS && wxUSE_STL
  50     #include <exception>
  51     #include <typeinfo>
  52 #endif
  53
  54 #ifndef __WXPALMOS5__
  55 #if !defined(__WXMSW__) || defined(__WXMICROWIN__)
  56   #include  <signal.h>      // for SIGTRAP used by wxTrap()
  57 #endif  //Win/Unix
  58
  59 #include <locale.h>
  60 #endif // ! __WXPALMOS5__
  61
  62 #if wxUSE_FONTMAP
  63     #include "wx/fontmap.h"
  64 #endif // wxUSE_FONTMAP
  65
  66 #if wxDEBUG_LEVEL
  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_LEVEL
  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 #if wxDEBUG_LEVEL
  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 wxString& file,
  96                           int line,
  97                           const wxString& func,
  98                           const wxString& cond,
  99                           const wxString& msg,
 100                           wxAppTraits *traits = NULL);
 101 #endif // wxDEBUG_LEVEL
 102
 103 #ifdef __WXDEBUG__
 104     // turn on the trace masks specified in the env variable WXTRACE
 105     static void LINKAGEMODE SetTraceMasks();
 106 #endif // __WXDEBUG__
 107
 108 // ----------------------------------------------------------------------------
 109 // global vars
 110 // ----------------------------------------------------------------------------
 111
 112 wxAppConsole *wxAppConsoleBase::ms_appInstance = NULL;
 113
 114 wxAppInitializerFunction wxAppConsoleBase::ms_appInitFn = NULL;
 115
 116 wxSocketManager *wxAppTraitsBase::ms_manager = NULL;
 117
 118 WXDLLIMPEXP_DATA_BASE(wxList) wxPendingDelete;
 119
 120 // ----------------------------------------------------------------------------
 121 // wxEventLoopPtr
 122 // ----------------------------------------------------------------------------
 123
 124 // this defines wxEventLoopPtr
 125 wxDEFINE_TIED_SCOPED_PTR_TYPE(wxEventLoopBase)
 126
 127 // ============================================================================
 128 // wxAppConsoleBase implementation
 129 // ============================================================================
 130
 131 // ----------------------------------------------------------------------------
 132 // ctor/dtor
 133 // ----------------------------------------------------------------------------
 134
 135 wxAppConsoleBase::wxAppConsoleBase()
 136 {
 137     m_traits = NULL;
 138     m_mainLoop = NULL;
 139     m_bDoPendingEventProcessing = true;
 140
 141     ms_appInstance = static_cast<wxAppConsole *>(this);
 142
 143 #ifdef __WXDEBUG__
 144     SetTraceMasks();
 145 #if wxUSE_UNICODE
 146     // In unicode mode the SetTraceMasks call can cause an apptraits to be
 147     // created, but since we are still in the constructor the wrong kind will
 148     // be created for GUI apps.  Destroy it so it can be created again later.
 149     delete m_traits;
 150     m_traits = NULL;
 151 #endif
 152 #endif
 153 }
 154
 155 wxAppConsoleBase::~wxAppConsoleBase()
 156 {
 157     delete m_traits;
 158 }
 159
 160 // ----------------------------------------------------------------------------
 161 // initialization/cleanup
 162 // ----------------------------------------------------------------------------
 163
 164 bool wxAppConsoleBase::Initialize(int& WXUNUSED(argc), wxChar **WXUNUSED(argv))
 165 {
 166 #if wxUSE_INTL
 167     GetTraits()->SetLocale();
 168 #endif // wxUSE_INTL
 169
 170     return true;
 171 }
 172
 173 wxString wxAppConsoleBase::GetAppName() const
 174 {
 175     wxString name = m_appName;
 176 #ifndef __WXPALMOS__
 177     if ( name.empty() )
 178     {
 179         if ( argv )
 180         {
 181             // the application name is, by default, the name of its executable file
 182             wxFileName::SplitPath(argv[0], NULL, &name, NULL);
 183         }
 184     }
 185 #endif // !__WXPALMOS__
 186     return name;
 187 }
 188
 189 wxString wxAppConsoleBase::GetAppDisplayName() const
 190 {
 191     // use the explicitly provided display name, if any
 192     if ( !m_appDisplayName.empty() )
 193         return m_appDisplayName;
 194
 195     // if the application name was explicitly set, use it as is as capitalizing
 196     // it won't always produce good results
 197     if ( !m_appName.empty() )
 198         return m_appName;
 199
 200     // if neither is set, use the capitalized version of the program file as
 201     // it's the most reasonable default
 202     return GetAppName().Capitalize();
 203 }
 204
 205 wxEventLoopBase *wxAppConsoleBase::CreateMainLoop()
 206 {
 207     return GetTraits()->CreateEventLoop();
 208 }
 209
 210 void wxAppConsoleBase::CleanUp()
 211 {
 212     if ( m_mainLoop )
 213     {
 214         delete m_mainLoop;
 215         m_mainLoop = NULL;
 216     }
 217 }
 218
 219 // ----------------------------------------------------------------------------
 220 // OnXXX() callbacks
 221 // ----------------------------------------------------------------------------
 222
 223 bool wxAppConsoleBase::OnInit()
 224 {
 225 #if wxUSE_CMDLINE_PARSER
 226     wxCmdLineParser parser(argc, argv);
 227
 228     OnInitCmdLine(parser);
 229
 230     bool cont;
 231     switch ( parser.Parse(false /* don't show usage */) )
 232     {
 233         case -1:
 234             cont = OnCmdLineHelp(parser);
 235             break;
 236
 237         case 0:
 238             cont = OnCmdLineParsed(parser);
 239             break;
 240
 241         default:
 242             cont = OnCmdLineError(parser);
 243             break;
 244     }
 245
 246     if ( !cont )
 247         return false;
 248 #endif // wxUSE_CMDLINE_PARSER
 249
 250     return true;
 251 }
 252
 253 int wxAppConsoleBase::OnRun()
 254 {
 255     return MainLoop();
 256 }
 257
 258 int wxAppConsoleBase::OnExit()
 259 {
 260 #if wxUSE_CONFIG
 261     // delete the config object if any (don't use Get() here, but Set()
 262     // because Get() could create a new config object)
 263     delete wxConfigBase::Set(NULL);
 264 #endif // wxUSE_CONFIG
 265
 266     return 0;
 267 }
 268
 269 void wxAppConsoleBase::Exit()
 270 {
 271     if (m_mainLoop != NULL)
 272         ExitMainLoop();
 273     else
 274         exit(-1);
 275 }
 276
 277 // ----------------------------------------------------------------------------
 278 // traits stuff
 279 // ----------------------------------------------------------------------------
 280
 281 wxAppTraits *wxAppConsoleBase::CreateTraits()
 282 {
 283     return new wxConsoleAppTraits;
 284 }
 285
 286 wxAppTraits *wxAppConsoleBase::GetTraits()
 287 {
 288     // FIXME-MT: protect this with a CS?
 289     if ( !m_traits )
 290     {
 291         m_traits = CreateTraits();
 292
 293         wxASSERT_MSG( m_traits, wxT("wxApp::CreateTraits() failed?") );
 294     }
 295
 296     return m_traits;
 297 }
 298
 299 /* static */
 300 wxAppTraits *wxAppConsoleBase::GetTraitsIfExists()
 301 {
 302     wxAppConsole * const app = GetInstance();
 303     return app ? app->GetTraits() : NULL;
 304 }
 305
 306 // ----------------------------------------------------------------------------
 307 // wxEventLoop redirection
 308 // ----------------------------------------------------------------------------
 309
 310 int wxAppConsoleBase::MainLoop()
 311 {
 312     wxEventLoopBaseTiedPtr mainLoop(&m_mainLoop, CreateMainLoop());
 313
 314     return m_mainLoop ? m_mainLoop->Run() : -1;
 315 }
 316
 317 void wxAppConsoleBase::ExitMainLoop()
 318 {
 319     // we should exit from the main event loop, not just any currently active
 320     // (e.g. modal dialog) event loop
 321     if ( m_mainLoop && m_mainLoop->IsRunning() )
 322     {
 323         m_mainLoop->Exit(0);
 324     }
 325 }
 326
 327 bool wxAppConsoleBase::Pending()
 328 {
 329     // use the currently active message loop here, not m_mainLoop, because if
 330     // we're showing a modal dialog (with its own event loop) currently the
 331     // main event loop is not running anyhow
 332     wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
 333
 334     return loop && loop->Pending();
 335 }
 336
 337 bool wxAppConsoleBase::Dispatch()
 338 {
 339     // see comment in Pending()
 340     wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
 341
 342     return loop && loop->Dispatch();
 343 }
 344
 345 bool wxAppConsoleBase::Yield(bool onlyIfNeeded)
 346 {
 347     wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
 348
 349     return loop && loop->Yield(onlyIfNeeded);
 350 }
 351
 352 void wxAppConsoleBase::WakeUpIdle()
 353 {
 354     wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
 355
 356     if ( loop )
 357         loop->WakeUp();
 358 }
 359
 360 bool wxAppConsoleBase::ProcessIdle()
 361 {
 362     // synthesize an idle event and check if more of them are needed
 363     wxIdleEvent event;
 364     event.SetEventObject(this);
 365     ProcessEvent(event);
 366
 367 #if wxUSE_LOG
 368     // flush the logged messages if any (do this after processing the events
 369     // which could have logged new messages)
 370     wxLog::FlushActive();
 371 #endif
 372
 373     return event.MoreRequested();
 374 }
 375
 376 bool wxAppConsoleBase::UsesEventLoop() const
 377 {
 378     // in console applications we don't know whether we're going to have an
 379     // event loop so assume we won't -- unless we already have one running
 380     return wxEventLoopBase::GetActive() != NULL;
 381 }
 382
 383 // ----------------------------------------------------------------------------
 384 // events
 385 // ----------------------------------------------------------------------------
 386
 387 /* static */
 388 bool wxAppConsoleBase::IsMainLoopRunning()
 389 {
 390     const wxAppConsole * const app = GetInstance();
 391
 392     return app && app->m_mainLoop != NULL;
 393 }
 394
 395 int wxAppConsoleBase::FilterEvent(wxEvent& WXUNUSED(event))
 396 {
 397     // process the events normally by default
 398     return -1;
 399 }
 400
 401 void wxAppConsoleBase::DelayPendingEventHandler(wxEvtHandler* toDelay)
 402 {
 403     wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
 404
 405     // move the handler from the list of handlers with processable pending events
 406     // to the list of handlers with pending events which needs to be processed later
 407     m_handlersWithPendingEvents.Remove(toDelay);
 408
 409     if (m_handlersWithPendingDelayedEvents.Index(toDelay) == wxNOT_FOUND)
 410         m_handlersWithPendingDelayedEvents.Add(toDelay);
 411
 412     wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
 413 }
 414
 415 void wxAppConsoleBase::RemovePendingEventHandler(wxEvtHandler* toRemove)
 416 {
 417     wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
 418
 419     if (m_handlersWithPendingEvents.Index(toRemove) != wxNOT_FOUND)
 420     {
 421         m_handlersWithPendingEvents.Remove(toRemove);
 422
 423         // check that the handler was present only once in the list
 424         wxASSERT_MSG( m_handlersWithPendingEvents.Index(toRemove) == wxNOT_FOUND,
 425                         "Handler occurs twice in the m_handlersWithPendingEvents list!" );
 426     }
 427     //else: it wasn't in this list at all, it's ok
 428
 429     if (m_handlersWithPendingDelayedEvents.Index(toRemove) != wxNOT_FOUND)
 430     {
 431         m_handlersWithPendingDelayedEvents.Remove(toRemove);
 432
 433         // check that the handler was present only once in the list
 434         wxASSERT_MSG( m_handlersWithPendingDelayedEvents.Index(toRemove) == wxNOT_FOUND,
 435                         "Handler occurs twice in m_handlersWithPendingDelayedEvents list!" );
 436     }
 437     //else: it wasn't in this list at all, it's ok
 438
 439     wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
 440 }
 441
 442 void wxAppConsoleBase::AppendPendingEventHandler(wxEvtHandler* toAppend)
 443 {
 444     wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
 445
 446     if ( m_handlersWithPendingEvents.Index(toAppend) == wxNOT_FOUND )
 447         m_handlersWithPendingEvents.Add(toAppend);
 448
 449     wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
 450 }
 451
 452 bool wxAppConsoleBase::HasPendingEvents() const
 453 {
 454     wxENTER_CRIT_SECT(const_cast<wxAppConsoleBase*>(this)->m_handlersWithPendingEventsLocker);
 455
 456     bool has = !m_handlersWithPendingEvents.IsEmpty();
 457
 458     wxLEAVE_CRIT_SECT(const_cast<wxAppConsoleBase*>(this)->m_handlersWithPendingEventsLocker);
 459
 460     return has;
 461 }
 462
 463 void wxAppConsoleBase::SuspendProcessingOfPendingEvents()
 464 {
 465     m_bDoPendingEventProcessing = false;
 466 }
 467
 468 void wxAppConsoleBase::ResumeProcessingOfPendingEvents()
 469 {
 470     m_bDoPendingEventProcessing = true;
 471 }
 472
 473 void wxAppConsoleBase::ProcessPendingEvents()
 474 {
 475     if ( m_bDoPendingEventProcessing )
 476     {
 477         wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
 478
 479         wxCHECK_RET( m_handlersWithPendingDelayedEvents.IsEmpty(),
 480                      "this helper list should be empty" );
 481
 482         // iterate until the list becomes empty: the handlers remove themselves
 483         // from it when they don't have any more pending events
 484         while (!m_handlersWithPendingEvents.IsEmpty())
 485         {
 486             // In ProcessPendingEvents(), new handlers might be added
 487             // and we can safely leave the critical section here.
 488             wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
 489
 490             // NOTE: we always call ProcessPendingEvents() on the first event handler
 491             //       with pending events because handlers auto-remove themselves
 492             //       from this list (see RemovePendingEventHandler) if they have no
 493             //       more pending events.
 494             m_handlersWithPendingEvents[0]->ProcessPendingEvents();
 495
 496             wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
 497         }
 498
 499         // now the wxHandlersWithPendingEvents is surely empty; however some event
 500         // handlers may have moved themselves into wxHandlersWithPendingDelayedEvents
 501         // because of a selective wxYield call in progress.
 502         // Now we need to move them back to wxHandlersWithPendingEvents so the next
 503         // call to this function has the chance of processing them:
 504         if (!m_handlersWithPendingDelayedEvents.IsEmpty())
 505         {
 506             WX_APPEND_ARRAY(m_handlersWithPendingEvents, m_handlersWithPendingDelayedEvents);
 507             m_handlersWithPendingDelayedEvents.Clear();
 508         }
 509
 510         wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
 511     }
 512
 513     // Garbage collect all objects previously scheduled for destruction.
 514     DeletePendingObjects();
 515 }
 516
 517 void wxAppConsoleBase::DeletePendingEvents()
 518 {
 519     wxENTER_CRIT_SECT(m_handlersWithPendingEventsLocker);
 520
 521     wxCHECK_RET( m_handlersWithPendingDelayedEvents.IsEmpty(),
 522                  "this helper list should be empty" );
 523
 524     for (unsigned int i=0; i<m_handlersWithPendingEvents.GetCount(); i++)
 525         m_handlersWithPendingEvents[i]->DeletePendingEvents();
 526
 527     m_handlersWithPendingEvents.Clear();
 528
 529     wxLEAVE_CRIT_SECT(m_handlersWithPendingEventsLocker);
 530 }
 531
 532 // ----------------------------------------------------------------------------
 533 // delayed objects destruction
 534 // ----------------------------------------------------------------------------
 535
 536 bool wxAppConsoleBase::IsScheduledForDestruction(wxObject *object) const
 537 {
 538     return wxPendingDelete.Member(object) != NULL;
 539 }
 540
 541 void wxAppConsoleBase::ScheduleForDestruction(wxObject *object)
 542 {
 543     if ( !UsesEventLoop() )
 544     {
 545         // we won't be able to delete it later so do it right now
 546         delete object;
 547         return;
 548     }
 549     //else: we either already have or will soon start an event loop
 550
 551     if ( !wxPendingDelete.Member(object) )
 552         wxPendingDelete.Append(object);
 553 }
 554
 555 void wxAppConsoleBase::DeletePendingObjects()
 556 {
 557     wxList::compatibility_iterator node = wxPendingDelete.GetFirst();
 558     while (node)
 559     {
 560         wxObject *obj = node->GetData();
 561
 562         // remove it from the list first so that if we get back here somehow
 563         // during the object deletion (e.g. wxYield called from its dtor) we
 564         // wouldn't try to delete it the second time
 565         if ( wxPendingDelete.Member(obj) )
 566             wxPendingDelete.Erase(node);
 567
 568         delete obj;
 569
 570         // Deleting one object may have deleted other pending
 571         // objects, so start from beginning of list again.
 572         node = wxPendingDelete.GetFirst();
 573     }
 574 }
 575
 576 // ----------------------------------------------------------------------------
 577 // exception handling
 578 // ----------------------------------------------------------------------------
 579
 580 #if wxUSE_EXCEPTIONS
 581
 582 void
 583 wxAppConsoleBase::HandleEvent(wxEvtHandler *handler,
 584                               wxEventFunction func,
 585                               wxEvent& event) const
 586 {
 587     // by default, simply call the handler
 588     (handler->*func)(event);
 589 }
 590
 591 void wxAppConsoleBase::CallEventHandler(wxEvtHandler *handler,
 592                                         wxEventFunctor& functor,
 593                                         wxEvent& event) const
 594 {
 595     // If the functor holds a method then, for backward compatibility, call
 596     // HandleEvent():
 597     wxEventFunction eventFunction = functor.GetEvtMethod();
 598
 599     if ( eventFunction )
 600         HandleEvent(handler, eventFunction, event);
 601     else
 602         functor(handler, event);
 603 }
 604
 605 void wxAppConsoleBase::OnUnhandledException()
 606 {
 607 #ifdef __WXDEBUG__
 608     // we're called from an exception handler so we can re-throw the exception
 609     // to recover its type
 610     wxString what;
 611     try
 612     {
 613         throw;
 614     }
 615 #if wxUSE_STL
 616     catch ( std::exception& e )
 617     {
 618         what.Printf("std::exception of type \"%s\", what() = \"%s\"",
 619                     typeid(e).name(), e.what());
 620     }
 621 #endif // wxUSE_STL
 622     catch ( ... )
 623     {
 624         what = "unknown exception";
 625     }
 626
 627     wxMessageOutputBest().Printf(
 628         "*** Caught unhandled %s; terminating\n", what
 629     );
 630 #endif // __WXDEBUG__
 631 }
 632
 633 // ----------------------------------------------------------------------------
 634 // exceptions support
 635 // ----------------------------------------------------------------------------
 636
 637 bool wxAppConsoleBase::OnExceptionInMainLoop()
 638 {
 639     throw;
 640
 641     // some compilers are too stupid to know that we never return after throw
 642 #if defined(__DMC__) || (defined(_MSC_VER) && _MSC_VER < 1200)
 643     return false;
 644 #endif
 645 }
 646
 647 #endif // wxUSE_EXCEPTIONS
 648
 649 // ----------------------------------------------------------------------------
 650 // cmd line parsing
 651 // ----------------------------------------------------------------------------
 652
 653 #if wxUSE_CMDLINE_PARSER
 654
 655 #define OPTION_VERBOSE "verbose"
 656
 657 void wxAppConsoleBase::OnInitCmdLine(wxCmdLineParser& parser)
 658 {
 659     // the standard command line options
 660     static const wxCmdLineEntryDesc cmdLineDesc[] =
 661     {
 662         {
 663             wxCMD_LINE_SWITCH,
 664             "h",
 665             "help",
 666             gettext_noop("show this help message"),
 667             wxCMD_LINE_VAL_NONE,
 668             wxCMD_LINE_OPTION_HELP
 669         },
 670
 671 #if wxUSE_LOG
 672         {
 673             wxCMD_LINE_SWITCH,
 674             NULL,
 675             OPTION_VERBOSE,
 676             gettext_noop("generate verbose log messages"),
 677             wxCMD_LINE_VAL_NONE,
 678             0x0
 679         },
 680 #endif // wxUSE_LOG
 681
 682         // terminator
 683         wxCMD_LINE_DESC_END
 684     };
 685
 686     parser.SetDesc(cmdLineDesc);
 687 }
 688
 689 bool wxAppConsoleBase::OnCmdLineParsed(wxCmdLineParser& parser)
 690 {
 691 #if wxUSE_LOG
 692     if ( parser.Found(OPTION_VERBOSE) )
 693     {
 694         wxLog::SetVerbose(true);
 695     }
 696 #else
 697     wxUnusedVar(parser);
 698 #endif // wxUSE_LOG
 699
 700     return true;
 701 }
 702
 703 bool wxAppConsoleBase::OnCmdLineHelp(wxCmdLineParser& parser)
 704 {
 705     parser.Usage();
 706
 707     return false;
 708 }
 709
 710 bool wxAppConsoleBase::OnCmdLineError(wxCmdLineParser& parser)
 711 {
 712     parser.Usage();
 713
 714     return false;
 715 }
 716
 717 #endif // wxUSE_CMDLINE_PARSER
 718
 719 // ----------------------------------------------------------------------------
 720 // debugging support
 721 // ----------------------------------------------------------------------------
 722
 723 /* static */
 724 bool wxAppConsoleBase::CheckBuildOptions(const char *optionsSignature,
 725                                          const char *componentName)
 726 {
 727 #if 0 // can't use wxLogTrace, not up and running yet
 728     printf("checking build options object '%s' (ptr %p) in '%s'\n",
 729              optionsSignature, optionsSignature, componentName);
 730 #endif
 731
 732     if ( strcmp(optionsSignature, WX_BUILD_OPTIONS_SIGNATURE) != 0 )
 733     {
 734         wxString lib = wxString::FromAscii(WX_BUILD_OPTIONS_SIGNATURE);
 735         wxString prog = wxString::FromAscii(optionsSignature);
 736         wxString progName = wxString::FromAscii(componentName);
 737         wxString msg;
 738
 739         msg.Printf(wxT("Mismatch between the program and library build versions detected.\nThe library used %s,\nand %s used %s."),
 740                    lib.c_str(), progName.c_str(), prog.c_str());
 741
 742         wxLogFatalError(msg.c_str());
 743
 744         // normally wxLogFatalError doesn't return
 745         return false;
 746     }
 747
 748     return true;
 749 }
 750
 751 void wxAppConsoleBase::OnAssertFailure(const wxChar *file,
 752                                        int line,
 753                                        const wxChar *func,
 754                                        const wxChar *cond,
 755                                        const wxChar *msg)
 756 {
 757 #if wxDEBUG_LEVEL
 758     ShowAssertDialog(file, line, func, cond, msg, GetTraits());
 759 #else
 760     // this function is still present even in debug level 0 build for ABI
 761     // compatibility reasons but is never called there and so can simply do
 762     // nothing in it
 763     wxUnusedVar(file);
 764     wxUnusedVar(line);
 765     wxUnusedVar(func);
 766     wxUnusedVar(cond);
 767     wxUnusedVar(msg);
 768 #endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
 769 }
 770
 771 void wxAppConsoleBase::OnAssert(const wxChar *file,
 772                                 int line,
 773                                 const wxChar *cond,
 774                                 const wxChar *msg)
 775 {
 776     OnAssertFailure(file, line, NULL, cond, msg);
 777 }
 778
 779 // ============================================================================
 780 // other classes implementations
 781 // ============================================================================
 782
 783 // ----------------------------------------------------------------------------
 784 // wxConsoleAppTraitsBase
 785 // ----------------------------------------------------------------------------
 786
 787 #if wxUSE_LOG
 788
 789 wxLog *wxConsoleAppTraitsBase::CreateLogTarget()
 790 {
 791     return new wxLogStderr;
 792 }
 793
 794 #endif // wxUSE_LOG
 795
 796 wxMessageOutput *wxConsoleAppTraitsBase::CreateMessageOutput()
 797 {
 798     return new wxMessageOutputStderr;
 799 }
 800
 801 #if wxUSE_FONTMAP
 802
 803 wxFontMapper *wxConsoleAppTraitsBase::CreateFontMapper()
 804 {
 805     return (wxFontMapper *)new wxFontMapperBase;
 806 }
 807
 808 #endif // wxUSE_FONTMAP
 809
 810 wxRendererNative *wxConsoleAppTraitsBase::CreateRenderer()
 811 {
 812     // console applications don't use renderers
 813     return NULL;
 814 }
 815
 816 bool wxConsoleAppTraitsBase::ShowAssertDialog(const wxString& msg)
 817 {
 818     return wxAppTraitsBase::ShowAssertDialog(msg);
 819 }
 820
 821 bool wxConsoleAppTraitsBase::HasStderr()
 822 {
 823     // console applications always have stderr, even under Mac/Windows
 824     return true;
 825 }
 826
 827 // ----------------------------------------------------------------------------
 828 // wxAppTraits
 829 // ----------------------------------------------------------------------------
 830
 831 #if wxUSE_INTL
 832 void wxAppTraitsBase::SetLocale()
 833 {
 834     wxSetlocale(LC_ALL, "");
 835     wxUpdateLocaleIsUtf8();
 836 }
 837 #endif
 838
 839 #if wxUSE_THREADS
 840 void wxMutexGuiEnterImpl();
 841 void wxMutexGuiLeaveImpl();
 842
 843 void wxAppTraitsBase::MutexGuiEnter()
 844 {
 845     wxMutexGuiEnterImpl();
 846 }
 847
 848 void wxAppTraitsBase::MutexGuiLeave()
 849 {
 850     wxMutexGuiLeaveImpl();
 851 }
 852
 853 void WXDLLIMPEXP_BASE wxMutexGuiEnter()
 854 {
 855     wxAppTraits * const traits = wxAppConsoleBase::GetTraitsIfExists();
 856     if ( traits )
 857         traits->MutexGuiEnter();
 858 }
 859
 860 void WXDLLIMPEXP_BASE wxMutexGuiLeave()
 861 {
 862     wxAppTraits * const traits = wxAppConsoleBase::GetTraitsIfExists();
 863     if ( traits )
 864         traits->MutexGuiLeave();
 865 }
 866 #endif // wxUSE_THREADS
 867
 868 bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal)
 869 {
 870 #if wxDEBUG_LEVEL
 871     wxString msg = msgOriginal;
 872
 873 #if wxUSE_STACKWALKER
 874 #if !defined(__WXMSW__)
 875     // on Unix stack frame generation may take some time, depending on the
 876     // size of the executable mainly... warn the user that we are working
 877     wxFprintf(stderr, wxT("[Debug] Generating a stack trace... please wait"));
 878     fflush(stderr);
 879 #endif
 880
 881     const wxString stackTrace = GetAssertStackTrace();
 882     if ( !stackTrace.empty() )
 883         msg << wxT("\n\nCall stack:\n") << stackTrace;
 884 #endif // wxUSE_STACKWALKER
 885
 886     return DoShowAssertDialog(msg);
 887 #else // !wxDEBUG_LEVEL
 888     wxUnusedVar(msgOriginal);
 889
 890     return false;
 891 #endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
 892 }
 893
 894 #if wxUSE_STACKWALKER
 895 wxString wxAppTraitsBase::GetAssertStackTrace()
 896 {
 897 #if wxDEBUG_LEVEL
 898     wxString stackTrace;
 899
 900     class StackDump : public wxStackWalker
 901     {
 902     public:
 903         StackDump() { }
 904
 905         const wxString& GetStackTrace() const { return m_stackTrace; }
 906
 907     protected:
 908         virtual void OnStackFrame(const wxStackFrame& frame)
 909         {
 910             m_stackTrace << wxString::Format
 911                             (
 912                               wxT("[%02d] "),
 913                               wx_truncate_cast(int, frame.GetLevel())
 914                             );
 915
 916             wxString name = frame.GetName();
 917             if ( !name.empty() )
 918             {
 919                 m_stackTrace << wxString::Format(wxT("%-40s"), name.c_str());
 920             }
 921             else
 922             {
 923                 m_stackTrace << wxString::Format(wxT("%p"), frame.GetAddress());
 924             }
 925
 926             if ( frame.HasSourceLocation() )
 927             {
 928                 m_stackTrace << wxT('\t')
 929                              << frame.GetFileName()
 930                              << wxT(':')
 931                              << frame.GetLine();
 932             }
 933
 934             m_stackTrace << wxT('\n');
 935         }
 936
 937     private:
 938         wxString m_stackTrace;
 939     };
 940
 941     // don't show more than maxLines or we could get a dialog too tall to be
 942     // shown on screen: 20 should be ok everywhere as even with 15 pixel high
 943     // characters it is still only 300 pixels...
 944     static const int maxLines = 20;
 945
 946     StackDump dump;
 947     dump.Walk(2, maxLines); // don't show OnAssert() call itself
 948     stackTrace = dump.GetStackTrace();
 949
 950     const int count = stackTrace.Freq(wxT('\n'));
 951     for ( int i = 0; i < count - maxLines; i++ )
 952         stackTrace = stackTrace.BeforeLast(wxT('\n'));
 953
 954     return stackTrace;
 955 #else // !wxDEBUG_LEVEL
 956     // this function is still present for ABI-compatibility even in debug level
 957     // 0 build but is not used there and so can simply do nothing
 958     return wxString();
 959 #endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
 960 }
 961 #endif // wxUSE_STACKWALKER
 962
 963
 964 // ============================================================================
 965 // global functions implementation
 966 // ============================================================================
 967
 968 void wxExit()
 969 {
 970     if ( wxTheApp )
 971     {
 972         wxTheApp->Exit();
 973     }
 974     else
 975     {
 976         // what else can we do?
 977         exit(-1);
 978     }
 979 }
 980
 981 void wxWakeUpIdle()
 982 {
 983     if ( wxTheApp )
 984     {
 985         wxTheApp->WakeUpIdle();
 986     }
 987     //else: do nothing, what can we do?
 988 }
 989
 990 // wxASSERT() helper
 991 bool wxAssertIsEqual(int x, int y)
 992 {
 993     return x == y;
 994 }
 995
 996 #if wxDEBUG_LEVEL
 997
 998 // break into the debugger
 999 void wxTrap()
1000 {
1001 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
1002     DebugBreak();
1003 #elif defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
1004     Debugger();
1005 #elif defined(__UNIX__)
1006     raise(SIGTRAP);
1007 #else
1008     // TODO
1009 #endif // Win/Unix
1010 }
1011
1012 // default assert handler
1013 static void
1014 wxDefaultAssertHandler(const wxString& file,
1015                        int line,
1016                        const wxString& func,
1017                        const wxString& cond,
1018                        const wxString& msg)
1019 {
1020     // FIXME MT-unsafe
1021     static int s_bInAssert = 0;
1022
1023     wxRecursionGuard guard(s_bInAssert);
1024     if ( guard.IsInside() )
1025     {
1026         // can't use assert here to avoid infinite loops, so just trap
1027         wxTrap();
1028
1029         return;
1030     }
1031
1032     if ( !wxTheApp )
1033     {
1034         // by default, show the assert dialog box -- we can't customize this
1035         // behaviour
1036         ShowAssertDialog(file, line, func, cond, msg);
1037     }
1038     else
1039     {
1040         // let the app process it as it wants
1041         // FIXME-UTF8: use wc_str(), not c_str(), when ANSI build is removed
1042         wxTheApp->OnAssertFailure(file.c_str(), line, func.c_str(),
1043                                   cond.c_str(), msg.c_str());
1044     }
1045 }
1046
1047 wxAssertHandler_t wxTheAssertHandler = wxDefaultAssertHandler;
1048
1049 void wxSetDefaultAssertHandler()
1050 {
1051     wxTheAssertHandler = wxDefaultAssertHandler;
1052 }
1053
1054 void wxOnAssert(const wxString& file,
1055                 int line,
1056                 const wxString& func,
1057                 const wxString& cond,
1058                 const wxString& msg)
1059 {
1060     wxTheAssertHandler(file, line, func, cond, msg);
1061 }
1062
1063 void wxOnAssert(const wxString& file,
1064                 int line,
1065                 const wxString& func,
1066                 const wxString& cond)
1067 {
1068     wxTheAssertHandler(file, line, func, cond, wxString());
1069 }
1070
1071 void wxOnAssert(const wxChar *file,
1072                 int line,
1073                 const char *func,
1074                 const wxChar *cond,
1075                 const wxChar *msg)
1076 {
1077     // this is the backwards-compatible version (unless we don't use Unicode)
1078     // so it could be called directly from the user code and this might happen
1079     // even when wxTheAssertHandler is NULL
1080 #if wxUSE_UNICODE
1081     if ( wxTheAssertHandler )
1082 #endif // wxUSE_UNICODE
1083         wxTheAssertHandler(file, line, func, cond, msg);
1084 }
1085
1086 void wxOnAssert(const char *file,
1087                 int line,
1088                 const char *func,
1089                 const char *cond,
1090                 const wxString& msg)
1091 {
1092     wxTheAssertHandler(file, line, func, cond, msg);
1093 }
1094
1095 void wxOnAssert(const char *file,
1096                 int line,
1097                 const char *func,
1098                 const char *cond,
1099                 const wxCStrData& msg)
1100 {
1101     wxTheAssertHandler(file, line, func, cond, msg);
1102 }
1103
1104 #if wxUSE_UNICODE
1105 void wxOnAssert(const char *file,
1106                 int line,
1107                 const char *func,
1108                 const char *cond)
1109 {
1110     wxTheAssertHandler(file, line, func, cond, wxString());
1111 }
1112
1113 void wxOnAssert(const char *file,
1114                 int line,
1115                 const char *func,
1116                 const char *cond,
1117                 const char *msg)
1118 {
1119     wxTheAssertHandler(file, line, func, cond, msg);
1120 }
1121
1122 void wxOnAssert(const char *file,
1123                 int line,
1124                 const char *func,
1125                 const char *cond,
1126                 const wxChar *msg)
1127 {
1128     wxTheAssertHandler(file, line, func, cond, msg);
1129 }
1130 #endif // wxUSE_UNICODE
1131
1132 #endif // wxDEBUG_LEVEL
1133
1134 // ============================================================================
1135 // private functions implementation
1136 // ============================================================================
1137
1138 #ifdef __WXDEBUG__
1139
1140 static void LINKAGEMODE SetTraceMasks()
1141 {
1142 #if wxUSE_LOG
1143     wxString mask;
1144     if ( wxGetEnv(wxT("WXTRACE"), &mask) )
1145     {
1146         wxStringTokenizer tkn(mask, wxT(",;:"));
1147         while ( tkn.HasMoreTokens() )
1148             wxLog::AddTraceMask(tkn.GetNextToken());
1149     }
1150 #endif // wxUSE_LOG
1151 }
1152
1153 #endif // __WXDEBUG__
1154
1155 #if wxDEBUG_LEVEL
1156
1157 static
1158 bool DoShowAssertDialog(const wxString& msg)
1159 {
1160     // under MSW we can show the dialog even in the console mode
1161 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
1162     wxString msgDlg(msg);
1163
1164     // this message is intentionally not translated -- it is for developers
1165     // only -- and the less code we use here, less is the danger of recursively
1166     // asserting and dying
1167     msgDlg += wxT("\nDo you want to stop the program?\n")
1168               wxT("You can also choose [Cancel] to suppress ")
1169               wxT("further warnings.");
1170
1171     switch ( ::MessageBox(NULL, msgDlg.wx_str(), wxT("wxWidgets Debug Alert"),
1172                           MB_YESNOCANCEL | MB_ICONSTOP ) )
1173     {
1174         case IDYES:
1175             wxTrap();
1176             break;
1177
1178         case IDCANCEL:
1179             // stop the asserts
1180             return true;
1181
1182         //case IDNO: nothing to do
1183     }
1184 #else // !__WXMSW__
1185     wxFprintf(stderr, wxT("%s\n"), msg.c_str());
1186     fflush(stderr);
1187
1188     // TODO: ask the user to enter "Y" or "N" on the console?
1189     wxTrap();
1190 #endif // __WXMSW__/!__WXMSW__
1191
1192     // continue with the asserts
1193     return false;
1194 }
1195
1196 // show the standard assert dialog
1197 static
1198 void ShowAssertDialog(const wxString& file,
1199                       int line,
1200                       const wxString& func,
1201                       const wxString& cond,
1202                       const wxString& msgUser,
1203                       wxAppTraits *traits)
1204 {
1205     // this variable can be set to true to suppress "assert failure" messages
1206     static bool s_bNoAsserts = false;
1207
1208     wxString msg;
1209     msg.reserve(2048);
1210
1211     // make life easier for people using VC++ IDE by using this format: like
1212     // this, clicking on the message will take us immediately to the place of
1213     // the failed assert
1214     msg.Printf(wxT("%s(%d): assert \"%s\" failed"), file, line, cond);
1215
1216     // add the function name, if any
1217     if ( !func.empty() )
1218         msg << wxT(" in ") << func << wxT("()");
1219
1220     // and the message itself
1221     if ( !msgUser.empty() )
1222     {
1223         msg << wxT(": ") << msgUser;
1224     }
1225     else // no message given
1226     {
1227         msg << wxT('.');
1228     }
1229
1230 #if wxUSE_THREADS
1231     // if we are not in the main thread, output the assert directly and trap
1232     // since dialogs cannot be displayed
1233     if ( !wxThread::IsMain() )
1234     {
1235         msg += wxT(" [in child thread]");
1236
1237 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
1238         msg << wxT("\r\n");
1239         OutputDebugString(msg.wx_str());
1240 #else
1241         // send to stderr
1242         wxFprintf(stderr, wxT("%s\n"), msg.c_str());
1243         fflush(stderr);
1244 #endif
1245         // He-e-e-e-elp!! we're asserting in a child thread
1246         wxTrap();
1247     }
1248     else
1249 #endif // wxUSE_THREADS
1250
1251     if ( !s_bNoAsserts )
1252     {
1253         // send it to the normal log destination
1254         wxLogDebug(wxT("%s"), msg.c_str());
1255
1256         if ( traits )
1257         {
1258             // delegate showing assert dialog (if possible) to that class
1259             s_bNoAsserts = traits->ShowAssertDialog(msg);
1260         }
1261         else // no traits object
1262         {
1263             // fall back to the function of last resort
1264             s_bNoAsserts = DoShowAssertDialog(msg);
1265         }
1266     }
1267 }
1268
1269 #endif // wxDEBUG_LEVEL