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