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