src/common/log.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        log.cpp
   3 // Purpose:     Assorted wxLogXXX functions, and wxLog (sink for logs)
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     29/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19 #ifdef __GNUG__
  20   #pragma implementation "log.h"
  21 #endif
  22
  23 // For compilers that support precompilation, includes "wx.h".
  24 #include "wx/wxprec.h"
  25
  26 #ifdef __BORLANDC__
  27   #pragma hdrstop
  28 #endif
  29
  30 // wxWindows
  31 #ifndef WX_PRECOMP
  32   #include  <wx/event.h>
  33   #include  <wx/app.h>
  34   #include  <wx/string.h>
  35   #include  <wx/intl.h>
  36   #include  <wx/menu.h>
  37   #include  <wx/frame.h>
  38   #include  <wx/msgdlg.h>
  39   #include  <wx/filedlg.h>
  40   #include  <wx/textctrl.h>
  41 #endif //WX_PRECOMP
  42
  43 #include  <wx/file.h>
  44 #include  <wx/textfile.h>
  45 #include  <wx/utils.h>
  46 #include  <wx/log.h>
  47
  48 // other standard headers
  49 #include  <errno.h>
  50 #include  <stdlib.h>
  51 #include  <time.h>
  52
  53 #ifdef  __WXMSW__
  54   #include  <windows.h>
  55   // Redefines OutputDebugString if necessary
  56   #include  "wx/msw/private.h"
  57 #else   //Unix
  58   #include  <signal.h>
  59 #endif  //Win/Unix
  60
  61 // ----------------------------------------------------------------------------
  62 // non member functions
  63 // ----------------------------------------------------------------------------
  64
  65 // define this to enable wrapping of log messages
  66 //#define LOG_PRETTY_WRAP
  67
  68 #ifdef  LOG_PRETTY_WRAP
  69   static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz);
  70 #endif
  71
  72 // ----------------------------------------------------------------------------
  73 // global variables
  74 // ----------------------------------------------------------------------------
  75
  76 // we use a global variable to store the frame pointer for wxLogStatus - bad,
  77 // but it's he easiest way
  78 static wxFrame *gs_pFrame; // FIXME MT-unsafe
  79
  80 // ============================================================================
  81 // implementation
  82 // ============================================================================
  83
  84 // ----------------------------------------------------------------------------
  85 // implementation of Log functions
  86 //
  87 // NB: unfortunately we need all these distinct functions, we can't make them
  88 //     macros and not all compilers inline vararg functions.
  89 // ----------------------------------------------------------------------------
  90
  91 // log functions can't allocate memory (LogError("out of memory...") should
  92 // work!), so we use a static buffer for all log messages
  93 #define LOG_BUFFER_SIZE   (4096)
  94
  95 // static buffer for error messages (FIXME MT-unsafe)
  96 static wxChar s_szBuf[LOG_BUFFER_SIZE];
  97
  98 // generic log function
  99 void wxLogGeneric(wxLogLevel level, const wxChar *szFormat, ...)
 100 {
 101   if ( wxLog::GetActiveTarget() != NULL ) {
 102     va_list argptr;
 103     va_start(argptr, szFormat);
 104     wxVsprintf(s_szBuf, szFormat, argptr);
 105     va_end(argptr);
 106
 107     wxLog::OnLog(level, s_szBuf, time(NULL));
 108   }
 109 }
 110
 111 #define IMPLEMENT_LOG_FUNCTION(level)                             \
 112   void wxLog##level(const wxChar *szFormat, ...)                  \
 113   {                                                               \
 114     if ( wxLog::GetActiveTarget() != NULL ) {                     \
 115       va_list argptr;                                             \
 116       va_start(argptr, szFormat);                                 \
 117       wxVsprintf(s_szBuf, szFormat, argptr);                      \
 118       va_end(argptr);                                             \
 119                                                                   \
 120       wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL));           \
 121     }                                                             \
 122   }
 123
 124 IMPLEMENT_LOG_FUNCTION(FatalError)
 125 IMPLEMENT_LOG_FUNCTION(Error)
 126 IMPLEMENT_LOG_FUNCTION(Warning)
 127 IMPLEMENT_LOG_FUNCTION(Message)
 128 IMPLEMENT_LOG_FUNCTION(Info)
 129 IMPLEMENT_LOG_FUNCTION(Status)
 130
 131 // accepts an additional argument which tells to which frame the output should
 132 // be directed
 133 void wxLogStatus(wxFrame *pFrame, const wxChar *szFormat, ...)
 134 {
 135   wxLog *pLog = wxLog::GetActiveTarget();
 136   if ( pLog != NULL ) {
 137     va_list argptr;
 138     va_start(argptr, szFormat);
 139     wxVsprintf(s_szBuf, szFormat, argptr);
 140     va_end(argptr);
 141
 142     wxASSERT( gs_pFrame == NULL ); // should be reset!
 143     gs_pFrame = pFrame;
 144     wxLog::OnLog(wxLOG_Status, s_szBuf, time(NULL));
 145     gs_pFrame = (wxFrame *) NULL;
 146   }
 147 }
 148
 149 // same as info, but only if 'verbose' mode is on
 150 void wxLogVerbose(const wxChar *szFormat, ...)
 151 {
 152   wxLog *pLog = wxLog::GetActiveTarget();
 153   if ( pLog != NULL && pLog->GetVerbose() ) {
 154     va_list argptr;
 155     va_start(argptr, szFormat);
 156     wxVsprintf(s_szBuf, szFormat, argptr);
 157     va_end(argptr);
 158
 159     wxLog::OnLog(wxLOG_Info, s_szBuf, time(NULL));
 160   }
 161 }
 162
 163 // debug functions
 164 #ifdef __WXDEBUG__
 165 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)                       \
 166   void wxLog##level(const wxChar *szFormat, ...)                  \
 167   {                                                               \
 168     if ( wxLog::GetActiveTarget() != NULL ) {                     \
 169       va_list argptr;                                             \
 170       va_start(argptr, szFormat);                                 \
 171       wxVsprintf(s_szBuf, szFormat, argptr);                      \
 172       va_end(argptr);                                             \
 173                                                                   \
 174       wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL));           \
 175     }                                                             \
 176   }
 177
 178   void wxLogTrace(const wxChar *mask, const wxChar *szFormat, ...)
 179   {
 180     wxLog *pLog = wxLog::GetActiveTarget();
 181
 182     if ( pLog != NULL && wxLog::IsAllowedTraceMask(mask) ) {
 183       va_list argptr;
 184       va_start(argptr, szFormat);
 185       wxVsprintf(s_szBuf, szFormat, argptr);
 186       va_end(argptr);
 187
 188       wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
 189     }
 190   }
 191
 192   void wxLogTrace(wxTraceMask mask, const wxChar *szFormat, ...)
 193   {
 194     wxLog *pLog = wxLog::GetActiveTarget();
 195
 196     // we check that all of mask bits are set in the current mask, so
 197     // that wxLogTrace(wxTraceRefCount | wxTraceOle) will only do something
 198     // if both bits are set.
 199     if ( pLog != NULL && ((pLog->GetTraceMask() & mask) == mask) ) {
 200       va_list argptr;
 201       va_start(argptr, szFormat);
 202       wxVsprintf(s_szBuf, szFormat, argptr);
 203       va_end(argptr);
 204
 205       wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
 206     }
 207   }
 208
 209 #else // release
 210   #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)
 211 #endif
 212
 213 IMPLEMENT_LOG_DEBUG_FUNCTION(Debug)
 214 IMPLEMENT_LOG_DEBUG_FUNCTION(Trace)
 215
 216 // wxLogSysError: one uses the last error code, for other  you must give it
 217 // explicitly
 218
 219 // common part of both wxLogSysError
 220 void wxLogSysErrorHelper(long lErrCode)
 221 {
 222     wxChar szErrMsg[LOG_BUFFER_SIZE / 2];
 223     wxSprintf(szErrMsg, _(" (error %ld: %s)"), lErrCode, wxSysErrorMsg(lErrCode));
 224     wxStrncat(s_szBuf, szErrMsg, WXSIZEOF(s_szBuf) - wxStrlen(s_szBuf));
 225
 226     wxLog::OnLog(wxLOG_Error, s_szBuf, time(NULL));
 227 }
 228
 229 void WXDLLEXPORT wxLogSysError(const wxChar *szFormat, ...)
 230 {
 231     va_list argptr;
 232     va_start(argptr, szFormat);
 233     wxVsprintf(s_szBuf, szFormat, argptr);
 234     va_end(argptr);
 235
 236     wxLogSysErrorHelper(wxSysErrorCode());
 237 }
 238
 239 void WXDLLEXPORT wxLogSysError(long lErrCode, const wxChar *szFormat, ...)
 240 {
 241     va_list argptr;
 242     va_start(argptr, szFormat);
 243     wxVsprintf(s_szBuf, szFormat, argptr);
 244     va_end(argptr);
 245
 246     wxLogSysErrorHelper(lErrCode);
 247 }
 248
 249 // ----------------------------------------------------------------------------
 250 // wxLog class implementation
 251 // ----------------------------------------------------------------------------
 252
 253 wxLog::wxLog()
 254 {
 255     m_bHasMessages = FALSE;
 256
 257     // enable verbose messages by default in the debug builds
 258 #ifdef __WXDEBUG__
 259     m_bVerbose = TRUE;
 260 #else // release
 261     m_bVerbose = FALSE;
 262 #endif // debug/release
 263 }
 264
 265 wxLog *wxLog::GetActiveTarget()
 266 {
 267     if ( ms_bAutoCreate && ms_pLogger == NULL ) {
 268         // prevent infinite recursion if someone calls wxLogXXX() from
 269         // wxApp::CreateLogTarget()
 270         static bool s_bInGetActiveTarget = FALSE;
 271         if ( !s_bInGetActiveTarget ) {
 272             s_bInGetActiveTarget = TRUE;
 273
 274 #ifdef  wxUSE_NOGUI
 275             ms_pLogger = new wxLogStderr;
 276 #else
 277             // ask the application to create a log target for us
 278             if ( wxTheApp != NULL )
 279                 ms_pLogger = wxTheApp->CreateLogTarget();
 280             else
 281                 ms_pLogger = new wxLogStderr;
 282 #endif
 283
 284             s_bInGetActiveTarget = FALSE;
 285
 286             // do nothing if it fails - what can we do?
 287         }
 288     }
 289
 290     return ms_pLogger;
 291 }
 292
 293 wxLog *wxLog::SetActiveTarget(wxLog *pLogger)
 294 {
 295     if ( ms_pLogger != NULL ) {
 296         // flush the old messages before changing because otherwise they might
 297         // get lost later if this target is not restored
 298         ms_pLogger->Flush();
 299     }
 300
 301     wxLog *pOldLogger = ms_pLogger;
 302     ms_pLogger = pLogger;
 303
 304     return pOldLogger;
 305 }
 306
 307 void wxLog::RemoveTraceMask(const wxString& str)
 308 {
 309     int index = ms_aTraceMasks.Index(str);
 310     if ( index != wxNOT_FOUND )
 311         ms_aTraceMasks.Remove((size_t)index);
 312 }
 313
 314 void wxLog::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
 315 {
 316     wxString str;
 317
 318     switch ( level ) {
 319         case wxLOG_FatalError:
 320             DoLogString(str << _("Fatal error: ") << szString, t);
 321             DoLogString(_("Program aborted."), t);
 322             Flush();
 323             abort();
 324             break;
 325
 326         case wxLOG_Error:
 327             DoLogString(str << _("Error: ") << szString, t);
 328             break;
 329
 330         case wxLOG_Warning:
 331             DoLogString(str << _("Warning: ") << szString, t);
 332             break;
 333
 334         case wxLOG_Info:
 335         case wxLOG_Message:
 336             if ( GetVerbose() )
 337                 DoLogString(str + szString, t);
 338             // fall through
 339
 340         case wxLOG_Status:
 341             // nothing to do
 342             break;
 343
 344         case wxLOG_Trace:
 345         case wxLOG_Debug:
 346 #ifdef __WXDEBUG__
 347             DoLogString(szString, t);
 348 #endif
 349
 350             break;
 351
 352         default:
 353             wxFAIL_MSG(_("unknown log level in wxLog::DoLog"));
 354     }
 355 }
 356
 357 void wxLog::DoLogString(const wxChar *WXUNUSED(szString), time_t t)
 358 {
 359     wxFAIL_MSG(_T("DoLogString must be overriden if it's called."));
 360 }
 361
 362 void wxLog::Flush()
 363 {
 364     // do nothing
 365 }
 366
 367 // ----------------------------------------------------------------------------
 368 // wxLogStderr class implementation
 369 // ----------------------------------------------------------------------------
 370
 371 wxLogStderr::wxLogStderr(FILE *fp)
 372 {
 373     if ( fp == NULL )
 374         m_fp = stderr;
 375     else
 376         m_fp = fp;
 377 }
 378
 379 void wxLogStderr::DoLogString(const wxChar *szString, time_t t)
 380 {
 381     wxString str(szString);
 382     str << _T('\n');
 383
 384     fputs(str.mb_str(), m_fp);
 385     fflush(m_fp);
 386
 387     // under Windows, programs usually don't have stderr at all, so make show the
 388     // messages also under debugger
 389 #ifdef __WXMSW__
 390     OutputDebugString(str + _T('\r'));
 391 #endif // MSW
 392 }
 393
 394 // ----------------------------------------------------------------------------
 395 // wxLogStream implementation
 396 // ----------------------------------------------------------------------------
 397
 398 #if wxUSE_STD_IOSTREAM
 399 wxLogStream::wxLogStream(ostream *ostr)
 400 {
 401     if ( ostr == NULL )
 402         m_ostr = &cerr;
 403     else
 404         m_ostr = ostr;
 405 }
 406
 407 void wxLogStream::DoLogString(const wxChar *szString, time_t t)
 408 {
 409     (*m_ostr) << szString << endl << flush;
 410 }
 411 #endif // wxUSE_STD_IOSTREAM
 412
 413 #ifndef wxUSE_NOGUI
 414
 415 // ----------------------------------------------------------------------------
 416 // wxLogTextCtrl implementation
 417 // ----------------------------------------------------------------------------
 418
 419 #if wxUSE_STD_IOSTREAM
 420 wxLogTextCtrl::wxLogTextCtrl(wxTextCtrl *pTextCtrl)
 421 #if !defined(NO_TEXT_WINDOW_STREAM)
 422 : wxLogStream(new ostream(pTextCtrl))
 423 #endif
 424 {
 425 }
 426
 427 wxLogTextCtrl::~wxLogTextCtrl()
 428 {
 429     delete m_ostr;
 430 }
 431 #endif // wxUSE_STD_IOSTREAM
 432
 433 // ----------------------------------------------------------------------------
 434 // wxLogGui implementation (FIXME MT-unsafe)
 435 // ----------------------------------------------------------------------------
 436
 437 wxLogGui::wxLogGui()
 438 {
 439     Clear();
 440 }
 441
 442 void wxLogGui::Clear()
 443 {
 444     m_bErrors = m_bWarnings = FALSE;
 445     m_aMessages.Empty();
 446     m_aTimes.Empty();
 447 }
 448
 449 void wxLogGui::Flush()
 450 {
 451     if ( !m_bHasMessages )
 452         return;
 453
 454     // do it right now to block any new calls to Flush() while we're here
 455     m_bHasMessages = FALSE;
 456
 457     // concatenate all strings (but not too many to not overfill the msg box)
 458     wxString str;
 459     size_t nLines = 0,
 460     nMsgCount = m_aMessages.Count();
 461
 462     // start from the most recent message
 463     for ( size_t n = nMsgCount; n > 0; n-- ) {
 464         // for Windows strings longer than this value are wrapped (NT 4.0)
 465         const size_t nMsgLineWidth = 156;
 466
 467         nLines += (m_aMessages[n - 1].Len() + nMsgLineWidth - 1) / nMsgLineWidth;
 468
 469         if ( nLines > 25 )  // don't put too many lines in message box
 470             break;
 471
 472         str << m_aMessages[n - 1] << _T("\n");
 473     }
 474
 475     const wxChar *title;
 476     long style;
 477
 478     if ( m_bErrors ) {
 479         title = _("Error");
 480         style = wxICON_STOP;
 481     }
 482     else if ( m_bWarnings ) {
 483         title = _("Warning");
 484         style = wxICON_EXCLAMATION;
 485     }
 486     else {
 487         title = _("Information");
 488         style = wxICON_INFORMATION;
 489     }
 490
 491     wxMessageBox(str, title, wxOK | style);
 492
 493     // no undisplayed messages whatsoever
 494     Clear();
 495 }
 496
 497 // the default behaviour is to discard all informational messages if there
 498 // are any errors/warnings.
 499 void wxLogGui::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
 500 {
 501     switch ( level ) {
 502         case wxLOG_Info:
 503             if ( GetVerbose() )
 504         case wxLOG_Message:
 505                 if ( !m_bErrors ) {
 506                     m_aMessages.Add(szString);
 507                     m_aTimes.Add((long)t);
 508                     m_bHasMessages = TRUE;
 509                 }
 510                 break;
 511
 512         case wxLOG_Status:
 513                 {
 514                     // find the top window and set it's status text if it has any
 515                     wxFrame *pFrame = gs_pFrame;
 516                     if ( pFrame == NULL ) {
 517                         wxWindow *pWin = wxTheApp->GetTopWindow();
 518                         if ( pWin != NULL && pWin->IsKindOf(CLASSINFO(wxFrame)) ) {
 519                             pFrame = (wxFrame *)pWin;
 520                         }
 521                     }
 522
 523                     if ( pFrame != NULL )
 524                         pFrame->SetStatusText(szString);
 525                 }
 526                 break;
 527
 528         case wxLOG_Trace:
 529         case wxLOG_Debug:
 530                 #ifdef __WXDEBUG__
 531                 {
 532                     #ifdef __WXMSW__
 533                         // don't prepend debug/trace here: it goes to the
 534                         // debug window anyhow, but do put a timestamp
 535                         OutputDebugString(wxString(szString) + _T("\n\r"));
 536                     #else
 537                         // send them to stderr
 538                         wxFprintf(stderr, _T("%s: %s\n"),
 539                                 level == wxLOG_Trace ? _T("Trace") : _T("Debug"),
 540                                 szString);
 541                         fflush(stderr);
 542                     #endif
 543                 }
 544                 #endif // __WXDEBUG__
 545
 546                 break;
 547
 548         case wxLOG_FatalError:
 549                 // show this one immediately
 550                 wxMessageBox(szString, _("Fatal error"), wxICON_HAND);
 551                 break;
 552
 553         case wxLOG_Error:
 554                 // discard earlier informational messages if this is the 1st
 555                 // error because they might not make sense any more
 556                 if ( !m_bErrors ) {
 557                     m_aMessages.Empty();
 558                     m_aTimes.Empty();
 559                     m_bHasMessages = TRUE;
 560                     m_bErrors = TRUE;
 561                 }
 562                 // fall through
 563
 564         case wxLOG_Warning:
 565                 if ( !m_bErrors ) {
 566                     // for the warning we don't discard the info messages
 567                     m_bWarnings = TRUE;
 568                 }
 569
 570                 m_aMessages.Add(szString);
 571                 m_aTimes.Add((long)t);
 572                 break;
 573
 574         default:
 575                 wxFAIL_MSG(_("unknown log level in wxLogGui::DoLog"));
 576     }
 577 }
 578
 579 // ----------------------------------------------------------------------------
 580 // wxLogWindow and wxLogFrame implementation
 581 // ----------------------------------------------------------------------------
 582
 583 // log frame class
 584 // ---------------
 585 class wxLogFrame : public wxFrame
 586 {
 587 public:
 588     // ctor & dtor
 589     wxLogFrame(wxFrame *pParent, wxLogWindow *log, const wxChar *szTitle);
 590     virtual ~wxLogFrame();
 591
 592     // menu callbacks
 593     void OnClose(wxCommandEvent& event);
 594     void OnCloseWindow(wxCloseEvent& event);
 595     void OnSave (wxCommandEvent& event);
 596     void OnClear(wxCommandEvent& event);
 597
 598     void OnIdle(wxIdleEvent&);
 599
 600     // accessors
 601     wxTextCtrl *TextCtrl() const { return m_pTextCtrl; }
 602
 603 private:
 604     enum
 605     {
 606         Menu_Close = 100,
 607         Menu_Save,
 608         Menu_Clear
 609     };
 610
 611     // instead of closing just hide the window to be able to Show() it later
 612     void DoClose() { Show(FALSE); }
 613
 614     wxTextCtrl  *m_pTextCtrl;
 615     wxLogWindow *m_log;
 616
 617     DECLARE_EVENT_TABLE()
 618 };
 619
 620 BEGIN_EVENT_TABLE(wxLogFrame, wxFrame)
 621     // wxLogWindow menu events
 622     EVT_MENU(Menu_Close, wxLogFrame::OnClose)
 623     EVT_MENU(Menu_Save,  wxLogFrame::OnSave)
 624     EVT_MENU(Menu_Clear, wxLogFrame::OnClear)
 625
 626     EVT_CLOSE(wxLogFrame::OnCloseWindow)
 627 END_EVENT_TABLE()
 628
 629 wxLogFrame::wxLogFrame(wxFrame *pParent, wxLogWindow *log, const wxChar *szTitle)
 630           : wxFrame(pParent, -1, szTitle)
 631 {
 632     m_log = log;
 633
 634     m_pTextCtrl = new wxTextCtrl(this, -1, wxEmptyString, wxDefaultPosition,
 635             wxDefaultSize,
 636             wxTE_MULTILINE  |
 637             wxHSCROLL       |
 638             wxTE_READONLY);
 639
 640     // create menu
 641     wxMenuBar *pMenuBar = new wxMenuBar;
 642     wxMenu *pMenu = new wxMenu;
 643     pMenu->Append(Menu_Save,  _("&Save..."), _("Save log contents to file"));
 644     pMenu->Append(Menu_Clear, _("C&lear"), _("Clear the log contents"));
 645     pMenu->AppendSeparator();
 646     pMenu->Append(Menu_Close, _("&Close"), _("Close this window"));
 647     pMenuBar->Append(pMenu, _("&Log"));
 648     SetMenuBar(pMenuBar);
 649
 650     // status bar for menu prompts
 651     CreateStatusBar();
 652
 653     m_log->OnFrameCreate(this);
 654 }
 655
 656 void wxLogFrame::OnClose(wxCommandEvent& WXUNUSED(event))
 657 {
 658     DoClose();
 659 }
 660
 661 void wxLogFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
 662 {
 663     DoClose();
 664 }
 665
 666 void wxLogFrame::OnSave(wxCommandEvent& WXUNUSED(event))
 667 {
 668     // get the file name
 669     // -----------------
 670     const wxChar *szFileName = wxSaveFileSelector(_T("log"), _T("txt"), _T("log.txt"));
 671     if ( szFileName == NULL ) {
 672         // cancelled
 673         return;
 674     }
 675
 676     // open file
 677     // ---------
 678     wxFile file;
 679     bool bOk = FALSE;
 680     if ( wxFile::Exists(szFileName) ) {
 681         bool bAppend = FALSE;
 682         wxString strMsg;
 683         strMsg.Printf(_("Append log to file '%s' "
 684                     "(choosing [No] will overwrite it)?"), szFileName);
 685         switch ( wxMessageBox(strMsg, _("Question"), wxYES_NO | wxCANCEL) ) {
 686             case wxYES:
 687                 bAppend = TRUE;
 688                 break;
 689
 690             case wxNO:
 691                 bAppend = FALSE;
 692                 break;
 693
 694             case wxCANCEL:
 695                 return;
 696
 697             default:
 698                 wxFAIL_MSG(_("invalid message box return value"));
 699         }
 700
 701         if ( bAppend ) {
 702             bOk = file.Open(szFileName, wxFile::write_append);
 703         }
 704         else {
 705             bOk = file.Create(szFileName, TRUE /* overwrite */);
 706         }
 707     }
 708     else {
 709         bOk = file.Create(szFileName);
 710     }
 711
 712     // retrieve text and save it
 713     // -------------------------
 714     int nLines = m_pTextCtrl->GetNumberOfLines();
 715     for ( int nLine = 0; bOk && nLine < nLines; nLine++ ) {
 716         bOk = file.Write(m_pTextCtrl->GetLineText(nLine) +
 717                 // we're not going to pull in the whole wxTextFile if all we need is this...
 718 #if wxUSE_TEXTFILE
 719                 wxTextFile::GetEOL()
 720 #else // !wxUSE_TEXTFILE
 721                 '\n'
 722 #endif // wxUSE_TEXTFILE
 723                         );
 724     }
 725
 726     if ( bOk )
 727         bOk = file.Close();
 728
 729     if ( !bOk ) {
 730         wxLogError(_("Can't save log contents to file."));
 731     }
 732     else {
 733         wxLogStatus(this, _("Log saved to the file '%s'."), szFileName);
 734     }
 735 }
 736
 737 void wxLogFrame::OnClear(wxCommandEvent& WXUNUSED(event))
 738 {
 739     m_pTextCtrl->Clear();
 740 }
 741
 742 wxLogFrame::~wxLogFrame()
 743 {
 744     m_log->OnFrameDelete(this);
 745 }
 746
 747 // wxLogWindow
 748 // -----------
 749 wxLogWindow::wxLogWindow(wxFrame *pParent,
 750         const wxChar *szTitle,
 751         bool bShow,
 752         bool bDoPass)
 753 {
 754     m_bPassMessages = bDoPass;
 755
 756     m_pLogFrame = new wxLogFrame(pParent, this, szTitle);
 757     m_pOldLog = wxLog::SetActiveTarget(this);
 758
 759     if ( bShow )
 760         m_pLogFrame->Show(TRUE);
 761 }
 762
 763 void wxLogWindow::Show(bool bShow)
 764 {
 765     m_pLogFrame->Show(bShow);
 766 }
 767
 768 void wxLogWindow::Flush()
 769 {
 770     if ( m_pOldLog != NULL )
 771         m_pOldLog->Flush();
 772
 773     m_bHasMessages = FALSE;
 774 }
 775
 776 void wxLogWindow::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
 777 {
 778     // first let the previous logger show it
 779     if ( m_pOldLog != NULL && m_bPassMessages ) {
 780         // FIXME why can't we access protected wxLog method from here (we derive
 781         //       from wxLog)? gcc gives "DoLog is protected in this context", what
 782         //       does this mean? Anyhow, the cast is harmless and let's us do what
 783         //       we want.
 784         ((wxLogWindow *)m_pOldLog)->DoLog(level, szString, t);
 785     }
 786
 787     if ( m_pLogFrame ) {
 788         switch ( level ) {
 789             case wxLOG_Status:
 790                 // by default, these messages are ignored by wxLog, so process
 791                 // them ourselves
 792                 {
 793                     wxString str;
 794                     str << _("Status: ") << szString;
 795                     DoLogString(str, t);
 796                 }
 797                 break;
 798
 799                 // don't put trace messages in the text window for 2 reasons:
 800                 // 1) there are too many of them
 801                 // 2) they may provoke other trace messages thus sending a program
 802                 //    into an infinite loop
 803             case wxLOG_Trace:
 804                 break;
 805
 806             default:
 807                 // and this will format it nicely and call our DoLogString()
 808                 wxLog::DoLog(level, szString, t);
 809         }
 810     }
 811
 812     m_bHasMessages = TRUE;
 813 }
 814
 815 void wxLogWindow::DoLogString(const wxChar *szString, time_t t)
 816 {
 817     // put the text into our window
 818     wxTextCtrl *pText = m_pLogFrame->TextCtrl();
 819
 820     // remove selection (WriteText is in fact ReplaceSelection)
 821 #ifdef __WXMSW__
 822     long nLen = pText->GetLastPosition();
 823     pText->SetSelection(nLen, nLen);
 824 #endif // Windows
 825
 826     pText->WriteText(szString);
 827     pText->WriteText(_T("\n")); // "\n" ok here (_not_ "\r\n")
 828
 829     // TODO ensure that the line can be seen
 830 }
 831
 832 wxFrame *wxLogWindow::GetFrame() const
 833 {
 834     return m_pLogFrame;
 835 }
 836
 837 void wxLogWindow::OnFrameCreate(wxFrame * WXUNUSED(frame))
 838 {
 839 }
 840
 841 void wxLogWindow::OnFrameDelete(wxFrame * WXUNUSED(frame))
 842 {
 843     m_pLogFrame = (wxLogFrame *)NULL;
 844 }
 845
 846 wxLogWindow::~wxLogWindow()
 847 {
 848     delete m_pOldLog;
 849
 850     // may be NULL if log frame already auto destroyed itself
 851     delete m_pLogFrame;
 852 }
 853
 854 #endif  //wxUSE_NOGUI
 855
 856 // ============================================================================
 857 // Global functions/variables
 858 // ============================================================================
 859
 860 // ----------------------------------------------------------------------------
 861 // static variables
 862 // ----------------------------------------------------------------------------
 863
 864 wxLog          *wxLog::ms_pLogger      = (wxLog *)NULL;
 865 bool            wxLog::ms_doLog        = TRUE;
 866 bool            wxLog::ms_bAutoCreate  = TRUE;
 867 wxTraceMask     wxLog::ms_ulTraceMask  = (wxTraceMask)0;
 868 wxArrayString   wxLog::ms_aTraceMasks;
 869
 870 // ----------------------------------------------------------------------------
 871 // stdout error logging helper
 872 // ----------------------------------------------------------------------------
 873
 874 // helper function: wraps the message and justifies it under given position
 875 // (looks more pretty on the terminal). Also adds newline at the end.
 876 //
 877 // TODO this is now disabled until I find a portable way of determining the
 878 //      terminal window size (ok, I found it but does anybody really cares?)
 879 #ifdef LOG_PRETTY_WRAP
 880 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz)
 881 {
 882     size_t nMax = 80; // FIXME
 883     size_t nStart = strlen(pszPrefix);
 884     fputs(pszPrefix, f);
 885
 886     size_t n;
 887     while ( *psz != '\0' ) {
 888         for ( n = nStart; (n < nMax) && (*psz != '\0'); n++ )
 889             putc(*psz++, f);
 890
 891         // wrapped?
 892         if ( *psz != '\0' ) {
 893             /*putc('\n', f);*/
 894             for ( n = 0; n < nStart; n++ )
 895                 putc(' ', f);
 896
 897             // as we wrapped, squeeze all white space
 898             while ( isspace(*psz) )
 899                 psz++;
 900         }
 901     }
 902
 903     putc('\n', f);
 904 }
 905 #endif  //LOG_PRETTY_WRAP
 906
 907 // ----------------------------------------------------------------------------
 908 // error code/error message retrieval functions
 909 // ----------------------------------------------------------------------------
 910
 911 // get error code from syste
 912 unsigned long wxSysErrorCode()
 913 {
 914 #ifdef  __WXMSW__
 915 #ifdef  __WIN32__
 916     return ::GetLastError();
 917 #else   //WIN16
 918     // TODO what to do on Windows 3.1?
 919     return 0;
 920 #endif  //WIN16/32
 921 #else   //Unix
 922     return errno;
 923 #endif  //Win/Unix
 924 }
 925
 926 // get error message from system
 927 const wxChar *wxSysErrorMsg(unsigned long nErrCode)
 928 {
 929     if ( nErrCode == 0 )
 930         nErrCode = wxSysErrorCode();
 931
 932 #ifdef  __WXMSW__
 933 #ifdef  __WIN32__
 934     static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
 935
 936     // get error message from system
 937     LPVOID lpMsgBuf;
 938     FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 939             NULL, nErrCode,
 940             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 941             (LPTSTR)&lpMsgBuf,
 942             0, NULL);
 943
 944     // copy it to our buffer and free memory
 945     wxStrncpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
 946     s_szBuf[WXSIZEOF(s_szBuf) - 1] = _T('\0');
 947     LocalFree(lpMsgBuf);
 948
 949     // returned string is capitalized and ended with '\r\n' - bad
 950     s_szBuf[0] = (wxChar)wxTolower(s_szBuf[0]);
 951     size_t len = wxStrlen(s_szBuf);
 952     if ( len > 0 ) {
 953         // truncate string
 954         if ( s_szBuf[len - 2] == _T('\r') )
 955             s_szBuf[len - 2] = _T('\0');
 956     }
 957
 958     return s_szBuf;
 959 #else   //Win16
 960     // TODO
 961     return NULL;
 962 #endif // Win16/32
 963 #else   // Unix
 964 #if wxUSE_UNICODE
 965     static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
 966     wxConv_libc.MB2WC(s_szBuf, strerror(nErrCode), WXSIZEOF(s_szBuf) -1);
 967     return s_szBuf;
 968 #else
 969     return strerror(nErrCode);
 970 #endif
 971 #endif  // Win/Unix
 972 }
 973
 974 // ----------------------------------------------------------------------------
 975 // debug helper
 976 // ----------------------------------------------------------------------------
 977
 978 #ifdef  __WXDEBUG__
 979
 980 // break into the debugger
 981 void Trap()
 982 {
 983 #ifdef __WXMSW__
 984     DebugBreak();
 985 #elif defined(__WXMAC__)
 986 #if __powerc
 987     Debugger();
 988 #else
 989     SysBreak();
 990 #endif
 991 #elif defined(__UNIX__)
 992     raise(SIGTRAP);
 993 #else
 994     // TODO
 995 #endif // Win/Unix
 996 }
 997
 998 // this function is called when an assert fails
 999 void wxOnAssert(const char *szFile, int nLine, const wxChar *szMsg)
1000 {
1001     // this variable can be set to true to suppress "assert failure" messages
1002     static bool s_bNoAsserts = FALSE;
1003     static bool s_bInAssert = FALSE;        // FIXME MT-unsafe
1004
1005     if ( s_bInAssert ) {
1006         // He-e-e-e-elp!! we're trapped in endless loop
1007         Trap();
1008
1009         s_bInAssert = FALSE;
1010
1011         return;
1012     }
1013
1014     s_bInAssert = TRUE;
1015
1016     wxChar szBuf[LOG_BUFFER_SIZE];
1017
1018     // make life easier for people using VC++ IDE: clicking on the message
1019     // will take us immediately to the place of the failed assert
1020 #ifdef __VISUALC__
1021     wxSprintf(szBuf, _T("%s(%d): assert failed"), szFile, nLine);
1022 #else  // !VC++
1023     // make the error message more clear for all the others
1024 #ifdef wxSprintf
1025     wxSprintf(szBuf, _T("Assert failed in file %s at line %d"), szFile, nLine);
1026 #else
1027     wxSprintf(szBuf, _T("Assert failed in file %hs at line %d"), szFile, nLine);
1028 #endif
1029 #endif // VC/!VC
1030
1031     if ( szMsg != NULL ) {
1032         wxStrcat(szBuf, _T(": "));
1033         wxStrcat(szBuf, szMsg);
1034     }
1035     else {
1036         wxStrcat(szBuf, _T("."));
1037     }
1038
1039     if ( !s_bNoAsserts ) {
1040         // send it to the normal log destination
1041         wxLogDebug(szBuf);
1042
1043 #if wxUSE_NOGUI
1044         Trap();
1045 #else
1046         // this message is intentionally not translated - it is for
1047         // developpers only
1048         wxStrcat(szBuf, _T("\nDo you want to stop the program?"
1049                 "\nYou can also choose [Cancel] to suppress "
1050                 "further warnings."));
1051
1052         switch ( wxMessageBox(szBuf, _("Debug"),
1053                     wxYES_NO | wxCANCEL | wxICON_STOP ) ) {
1054             case wxYES:
1055                 Trap();
1056                 break;
1057
1058             case wxCANCEL:
1059                 s_bNoAsserts = TRUE;
1060                 break;
1061
1062                 //case wxNO: nothing to do
1063         }
1064 #endif // USE_NOGUI
1065     }
1066
1067     s_bInAssert = FALSE;
1068 }
1069
1070 #endif  //WXDEBUG
1071