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             if ( GetVerbose() )
 336         case wxLOG_Message:
 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             break;
 350
 351         default:
 352             wxFAIL_MSG(_("unknown log level in wxLog::DoLog"));
 353     }
 354 }
 355
 356 void wxLog::DoLogString(const wxChar *WXUNUSED(szString), time_t t)
 357 {
 358     wxFAIL_MSG(_T("DoLogString must be overriden if it's called."));
 359 }
 360
 361 void wxLog::Flush()
 362 {
 363     // do nothing
 364 }
 365
 366 // ----------------------------------------------------------------------------
 367 // wxLogStderr class implementation
 368 // ----------------------------------------------------------------------------
 369
 370 wxLogStderr::wxLogStderr(FILE *fp)
 371 {
 372     if ( fp == NULL )
 373         m_fp = stderr;
 374     else
 375         m_fp = fp;
 376 }
 377
 378 void wxLogStderr::DoLogString(const wxChar *szString, time_t t)
 379 {
 380     wxString str(szString);
 381     str << _T('\n');
 382
 383     fputs(str.mb_str(), m_fp);
 384     fflush(m_fp);
 385
 386     // under Windows, programs usually don't have stderr at all, so make show the
 387     // messages also under debugger
 388 #ifdef __WXMSW__
 389     OutputDebugString(str + _T('\r'));
 390 #endif // MSW
 391 }
 392
 393 // ----------------------------------------------------------------------------
 394 // wxLogStream implementation
 395 // ----------------------------------------------------------------------------
 396
 397 #if wxUSE_STD_IOSTREAM
 398 wxLogStream::wxLogStream(ostream *ostr)
 399 {
 400     if ( ostr == NULL )
 401         m_ostr = &cerr;
 402     else
 403         m_ostr = ostr;
 404 }
 405
 406 void wxLogStream::DoLogString(const wxChar *szString, time_t t)
 407 {
 408     (*m_ostr) << szString << endl << flush;
 409 }
 410 #endif // wxUSE_STD_IOSTREAM
 411
 412 #ifndef wxUSE_NOGUI
 413
 414 // ----------------------------------------------------------------------------
 415 // wxLogTextCtrl implementation
 416 // ----------------------------------------------------------------------------
 417
 418 #if wxUSE_STD_IOSTREAM
 419 wxLogTextCtrl::wxLogTextCtrl(wxTextCtrl *pTextCtrl)
 420 #if !defined(NO_TEXT_WINDOW_STREAM)
 421 : wxLogStream(new ostream(pTextCtrl))
 422 #endif
 423 {
 424 }
 425
 426 wxLogTextCtrl::~wxLogTextCtrl()
 427 {
 428     delete m_ostr;
 429 }
 430 #endif // wxUSE_STD_IOSTREAM
 431
 432 // ----------------------------------------------------------------------------
 433 // wxLogGui implementation (FIXME MT-unsafe)
 434 // ----------------------------------------------------------------------------
 435
 436 wxLogGui::wxLogGui()
 437 {
 438     Clear();
 439 }
 440
 441 void wxLogGui::Clear()
 442 {
 443     m_bErrors = m_bWarnings = FALSE;
 444     m_aMessages.Empty();
 445     m_aTimes.Empty();
 446 }
 447
 448 void wxLogGui::Flush()
 449 {
 450     if ( !m_bHasMessages )
 451         return;
 452
 453     // do it right now to block any new calls to Flush() while we're here
 454     m_bHasMessages = FALSE;
 455
 456     // concatenate all strings (but not too many to not overfill the msg box)
 457     wxString str;
 458     size_t nLines = 0,
 459     nMsgCount = m_aMessages.Count();
 460
 461     // start from the most recent message
 462     for ( size_t n = nMsgCount; n > 0; n-- ) {
 463         // for Windows strings longer than this value are wrapped (NT 4.0)
 464         const size_t nMsgLineWidth = 156;
 465
 466         nLines += (m_aMessages[n - 1].Len() + nMsgLineWidth - 1) / nMsgLineWidth;
 467
 468         if ( nLines > 25 )  // don't put too many lines in message box
 469             break;
 470
 471         str << m_aMessages[n - 1] << _T("\n");
 472     }
 473
 474     const wxChar *title;
 475     long style;
 476
 477     if ( m_bErrors ) {
 478         title = _("Error");
 479         style = wxICON_STOP;
 480     }
 481     else if ( m_bWarnings ) {
 482         title = _("Warning");
 483         style = wxICON_EXCLAMATION;
 484     }
 485     else {
 486         title = _("Information");
 487         style = wxICON_INFORMATION;
 488     }
 489
 490     wxMessageBox(str, title, wxOK | style);
 491
 492     // no undisplayed messages whatsoever
 493     Clear();
 494 }
 495
 496 // the default behaviour is to discard all informational messages if there
 497 // are any errors/warnings.
 498 void wxLogGui::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
 499 {
 500     switch ( level ) {
 501         case wxLOG_Info:
 502             if ( GetVerbose() )
 503         case wxLOG_Message:
 504                 if ( !m_bErrors ) {
 505                     m_aMessages.Add(szString);
 506                     m_aTimes.Add((long)t);
 507                     m_bHasMessages = TRUE;
 508                 }
 509                 break;
 510
 511         case wxLOG_Status:
 512                 {
 513                     // find the top window and set it's status text if it has any
 514                     wxFrame *pFrame = gs_pFrame;
 515                     if ( pFrame == NULL ) {
 516                         wxWindow *pWin = wxTheApp->GetTopWindow();
 517                         if ( pWin != NULL && pWin->IsKindOf(CLASSINFO(wxFrame)) ) {
 518                             pFrame = (wxFrame *)pWin;
 519                         }
 520                     }
 521
 522                     if ( pFrame != NULL )
 523                         pFrame->SetStatusText(szString);
 524                 }
 525                 break;
 526
 527         case wxLOG_Trace:
 528         case wxLOG_Debug:
 529                 #ifdef __WXDEBUG__
 530                 {
 531                     #ifdef __WXMSW__
 532                         // don't prepend debug/trace here: it goes to the
 533                         // debug window anyhow, but do put a timestamp
 534                         OutputDebugString(wxString(szString) + _T("\n\r"));
 535                     #else
 536                         // send them to stderr
 537                         wxFprintf(stderr, _T("%s: %s\n"),
 538                                 level == wxLOG_Trace ? _T("Trace") : _T("Debug"),
 539                                 szString);
 540                         fflush(stderr);
 541                     #endif
 542                 }
 543                 #endif // __WXDEBUG__
 544
 545                 break;
 546
 547         case wxLOG_FatalError:
 548                 // show this one immediately
 549                 wxMessageBox(szString, _("Fatal error"), wxICON_HAND);
 550                 break;
 551
 552         case wxLOG_Error:
 553                 // discard earlier informational messages if this is the 1st
 554                 // error because they might not make sense any more
 555                 if ( !m_bErrors ) {
 556                     m_aMessages.Empty();
 557                     m_aTimes.Empty();
 558                     m_bHasMessages = TRUE;
 559                     m_bErrors = TRUE;
 560                 }
 561                 // fall through
 562
 563         case wxLOG_Warning:
 564                 if ( !m_bErrors ) {
 565                     // for the warning we don't discard the info messages
 566                     m_bWarnings = TRUE;
 567                 }
 568
 569                 m_aMessages.Add(szString);
 570                 m_aTimes.Add((long)t);
 571                 break;
 572
 573         default:
 574                 wxFAIL_MSG(_("unknown log level in wxLogGui::DoLog"));
 575     }
 576 }
 577
 578 // ----------------------------------------------------------------------------
 579 // wxLogWindow and wxLogFrame implementation
 580 // ----------------------------------------------------------------------------
 581
 582 // log frame class
 583 // ---------------
 584 class wxLogFrame : public wxFrame
 585 {
 586 public:
 587     // ctor & dtor
 588     wxLogFrame(wxFrame *pParent, wxLogWindow *log, const wxChar *szTitle);
 589     virtual ~wxLogFrame();
 590
 591     // menu callbacks
 592     void OnClose(wxCommandEvent& event);
 593     void OnCloseWindow(wxCloseEvent& event);
 594     void OnSave (wxCommandEvent& event);
 595     void OnClear(wxCommandEvent& event);
 596
 597     void OnIdle(wxIdleEvent&);
 598
 599     // accessors
 600     wxTextCtrl *TextCtrl() const { return m_pTextCtrl; }
 601
 602 private:
 603     enum
 604     {
 605         Menu_Close = 100,
 606         Menu_Save,
 607         Menu_Clear
 608     };
 609
 610     // instead of closing just hide the window to be able to Show() it later
 611     void DoClose() { Show(FALSE); }
 612
 613     wxTextCtrl  *m_pTextCtrl;
 614     wxLogWindow *m_log;
 615
 616     DECLARE_EVENT_TABLE()
 617 };
 618
 619 BEGIN_EVENT_TABLE(wxLogFrame, wxFrame)
 620     // wxLogWindow menu events
 621     EVT_MENU(Menu_Close, wxLogFrame::OnClose)
 622     EVT_MENU(Menu_Save,  wxLogFrame::OnSave)
 623     EVT_MENU(Menu_Clear, wxLogFrame::OnClear)
 624
 625     EVT_CLOSE(wxLogFrame::OnCloseWindow)
 626 END_EVENT_TABLE()
 627
 628 wxLogFrame::wxLogFrame(wxFrame *pParent, wxLogWindow *log, const wxChar *szTitle)
 629           : wxFrame(pParent, -1, szTitle)
 630 {
 631     m_log = log;
 632
 633     m_pTextCtrl = new wxTextCtrl(this, -1, wxEmptyString, wxDefaultPosition,
 634             wxDefaultSize,
 635             wxTE_MULTILINE  |
 636             wxHSCROLL       |
 637             wxTE_READONLY);
 638
 639     // create menu
 640     wxMenuBar *pMenuBar = new wxMenuBar;
 641     wxMenu *pMenu = new wxMenu;
 642     pMenu->Append(Menu_Save,  _("&Save..."), _("Save log contents to file"));
 643     pMenu->Append(Menu_Clear, _("C&lear"), _("Clear the log contents"));
 644     pMenu->AppendSeparator();
 645     pMenu->Append(Menu_Close, _("&Close"), _("Close this window"));
 646     pMenuBar->Append(pMenu, _("&Log"));
 647     SetMenuBar(pMenuBar);
 648
 649     // status bar for menu prompts
 650     CreateStatusBar();
 651
 652     m_log->OnFrameCreate(this);
 653 }
 654
 655 void wxLogFrame::OnClose(wxCommandEvent& WXUNUSED(event))
 656 {
 657     DoClose();
 658 }
 659
 660 void wxLogFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
 661 {
 662     DoClose();
 663 }
 664
 665 void wxLogFrame::OnSave(wxCommandEvent& WXUNUSED(event))
 666 {
 667     // get the file name
 668     // -----------------
 669     const wxChar *szFileName = wxSaveFileSelector(_T("log"), _T("txt"), _T("log.txt"));
 670     if ( szFileName == NULL ) {
 671         // cancelled
 672         return;
 673     }
 674
 675     // open file
 676     // ---------
 677     wxFile file;
 678     bool bOk = FALSE;
 679     if ( wxFile::Exists(szFileName) ) {
 680         bool bAppend = FALSE;
 681         wxString strMsg;
 682         strMsg.Printf(_("Append log to file '%s' "
 683                     "(choosing [No] will overwrite it)?"), szFileName);
 684         switch ( wxMessageBox(strMsg, _("Question"), wxYES_NO | wxCANCEL) ) {
 685             case wxYES:
 686                 bAppend = TRUE;
 687                 break;
 688
 689             case wxNO:
 690                 bAppend = FALSE;
 691                 break;
 692
 693             case wxCANCEL:
 694                 return;
 695
 696             default:
 697                 wxFAIL_MSG(_("invalid message box return value"));
 698         }
 699
 700         if ( bAppend ) {
 701             bOk = file.Open(szFileName, wxFile::write_append);
 702         }
 703         else {
 704             bOk = file.Create(szFileName, TRUE /* overwrite */);
 705         }
 706     }
 707     else {
 708         bOk = file.Create(szFileName);
 709     }
 710
 711     // retrieve text and save it
 712     // -------------------------
 713     int nLines = m_pTextCtrl->GetNumberOfLines();
 714     for ( int nLine = 0; bOk && nLine < nLines; nLine++ ) {
 715         bOk = file.Write(m_pTextCtrl->GetLineText(nLine) +
 716                 // we're not going to pull in the whole wxTextFile if all we need is this...
 717 #if wxUSE_TEXTFILE
 718                 wxTextFile::GetEOL()
 719 #else // !wxUSE_TEXTFILE
 720                 '\n'
 721 #endif // wxUSE_TEXTFILE
 722                         );
 723     }
 724
 725     if ( bOk )
 726         bOk = file.Close();
 727
 728     if ( !bOk ) {
 729         wxLogError(_("Can't save log contents to file."));
 730     }
 731     else {
 732         wxLogStatus(this, _("Log saved to the file '%s'."), szFileName);
 733     }
 734 }
 735
 736 void wxLogFrame::OnClear(wxCommandEvent& WXUNUSED(event))
 737 {
 738     m_pTextCtrl->Clear();
 739 }
 740
 741 wxLogFrame::~wxLogFrame()
 742 {
 743     m_log->OnFrameDelete(this);
 744 }
 745
 746 // wxLogWindow
 747 // -----------
 748 wxLogWindow::wxLogWindow(wxFrame *pParent,
 749         const wxChar *szTitle,
 750         bool bShow,
 751         bool bDoPass)
 752 {
 753     m_bPassMessages = bDoPass;
 754
 755     m_pLogFrame = new wxLogFrame(pParent, this, szTitle);
 756     m_pOldLog = wxLog::SetActiveTarget(this);
 757
 758     if ( bShow )
 759         m_pLogFrame->Show(TRUE);
 760 }
 761
 762 void wxLogWindow::Show(bool bShow)
 763 {
 764     m_pLogFrame->Show(bShow);
 765 }
 766
 767 void wxLogWindow::Flush()
 768 {
 769     if ( m_pOldLog != NULL )
 770         m_pOldLog->Flush();
 771
 772     m_bHasMessages = FALSE;
 773 }
 774
 775 void wxLogWindow::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
 776 {
 777     // first let the previous logger show it
 778     if ( m_pOldLog != NULL && m_bPassMessages ) {
 779         // FIXME why can't we access protected wxLog method from here (we derive
 780         //       from wxLog)? gcc gives "DoLog is protected in this context", what
 781         //       does this mean? Anyhow, the cast is harmless and let's us do what
 782         //       we want.
 783         ((wxLogWindow *)m_pOldLog)->DoLog(level, szString, t);
 784     }
 785
 786     if ( m_pLogFrame ) {
 787         switch ( level ) {
 788             case wxLOG_Status:
 789                 // by default, these messages are ignored by wxLog, so process
 790                 // them ourselves
 791                 if ( !wxIsEmpty(szString) )
 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