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/app.h>
  33   #include  <wx/string.h>
  34   #include  <wx/intl.h>
  35
  36   #include  <wx/generic/msgdlgg.h>
  37   #include  <wx/filedlg.h>
  38   #include  <wx/textctrl.h>
  39 #endif //WX_PRECOMP
  40
  41 #include  <wx/file.h>
  42 #include  <wx/textfile.h>
  43 #include  <wx/utils.h>
  44 #include  <wx/log.h>
  45
  46 // other standard headers
  47 #include  <errno.h>
  48 #include  <stdlib.h>
  49 #include  <time.h>
  50
  51 #ifdef  __WXMSW__
  52   #include  <windows.h>
  53 #else   //Unix
  54   #include  <signal.h>
  55 #endif  //Win/Unix
  56
  57 // ----------------------------------------------------------------------------
  58 // non member functions
  59 // ----------------------------------------------------------------------------
  60
  61 // define this to enable wrapping of log messages
  62 //#define LOG_PRETTY_WRAP
  63
  64 #ifdef  LOG_PRETTY_WRAP
  65   static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz);
  66 #endif
  67
  68 // ============================================================================
  69 // implementation
  70 // ============================================================================
  71
  72 // ----------------------------------------------------------------------------
  73 // implementation of Log functions
  74 //
  75 // NB: unfortunately we need all these distinct functions, we can't make them
  76 //     macros and not all compilers inline vararg functions.
  77 // ----------------------------------------------------------------------------
  78
  79 // log functions can't allocate memory (LogError("out of memory...") should
  80 // work!), so we use a static buffer for all log messages
  81 #define LOG_BUFFER_SIZE   (4096)
  82
  83 // static buffer for error messages (@@@ MT-unsafe)
  84 static char s_szBuf[LOG_BUFFER_SIZE];
  85
  86 // generic log function
  87 void wxLogGeneric(wxLogLevel level, const char *szFormat, ...)
  88 {
  89   if ( wxLog::GetActiveTarget() != NULL ) {
  90     va_list argptr;
  91     va_start(argptr, szFormat);
  92     vsprintf(s_szBuf, szFormat, argptr);
  93     va_end(argptr);
  94
  95     wxLog::OnLog(level, s_szBuf);
  96   }
  97 }
  98
  99 #define IMPLEMENT_LOG_FUNCTION(level)                             \
 100   void wxLog##level(const char *szFormat, ...)                    \
 101   {                                                               \
 102     if ( wxLog::GetActiveTarget() != NULL ) {                     \
 103       va_list argptr;                                             \
 104       va_start(argptr, szFormat);                                 \
 105       vsprintf(s_szBuf, szFormat, argptr);                        \
 106       va_end(argptr);                                             \
 107                                                                   \
 108       wxLog::OnLog(wxLOG_##level, s_szBuf);                       \
 109     }                                                             \
 110   }
 111
 112 IMPLEMENT_LOG_FUNCTION(FatalError)
 113 IMPLEMENT_LOG_FUNCTION(Error)
 114 IMPLEMENT_LOG_FUNCTION(Warning)
 115 IMPLEMENT_LOG_FUNCTION(Message)
 116 IMPLEMENT_LOG_FUNCTION(Info)
 117 IMPLEMENT_LOG_FUNCTION(Status)
 118
 119 // same as info, but only if 'verbose' mode is on
 120 void wxLogVerbose(const char *szFormat, ...)
 121 {
 122   wxLog *pLog = wxLog::GetActiveTarget();
 123   if ( pLog != NULL && pLog->GetVerbose() ) {
 124     va_list argptr;
 125     va_start(argptr, szFormat);
 126     vsprintf(s_szBuf, szFormat, argptr);
 127     va_end(argptr);
 128
 129     wxLog::OnLog(wxLOG_Info, s_szBuf);
 130   }
 131 }
 132
 133 // debug functions
 134 #ifdef __WXDEBUG__
 135 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)                       \
 136   void wxLog##level(const char *szFormat, ...)                    \
 137   {                                                               \
 138     if ( wxLog::GetActiveTarget() != NULL ) {                     \
 139       va_list argptr;                                             \
 140       va_start(argptr, szFormat);                                 \
 141       vsprintf(s_szBuf, szFormat, argptr);                        \
 142       va_end(argptr);                                             \
 143                                                                   \
 144       wxLog::OnLog(wxLOG_##level, s_szBuf);                       \
 145     }                                                             \
 146   }
 147
 148   void wxLogTrace(wxTraceMask mask, const char *szFormat, ...)
 149   {
 150     wxLog *pLog = wxLog::GetActiveTarget();
 151
 152     // we check that all of mask bits are set in the current mask, so
 153     // that wxLogTrace(wxTraceRefCount | wxTraceOle) will only do something
 154     // if both bits are set.
 155     if ( pLog != NULL && (pLog->GetTraceMask() & mask == mask) ) {
 156       va_list argptr;
 157       va_start(argptr, szFormat);
 158       vsprintf(s_szBuf, szFormat, argptr);
 159       va_end(argptr);
 160
 161       wxLog::OnLog(wxLOG_Trace, s_szBuf);
 162     }
 163   }
 164
 165 #else // release
 166   #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)
 167 #endif
 168
 169 IMPLEMENT_LOG_DEBUG_FUNCTION(Debug)
 170 IMPLEMENT_LOG_DEBUG_FUNCTION(Trace)
 171
 172 // wxLogSysError: one uses the last error code, for other  you must give it
 173 // explicitly
 174
 175 // common part of both wxLogSysError
 176 void wxLogSysErrorHelper(long lErrCode)
 177 {
 178   char szErrMsg[LOG_BUFFER_SIZE / 2];
 179   sprintf(szErrMsg, _(" (error %ld: %s)"), lErrCode, wxSysErrorMsg(lErrCode));
 180   strncat(s_szBuf, szErrMsg, WXSIZEOF(s_szBuf) - strlen(s_szBuf));
 181
 182   wxLog::OnLog(wxLOG_Error, s_szBuf);
 183 }
 184
 185 void WXDLLEXPORT wxLogSysError(const char *szFormat, ...)
 186 {
 187   va_list argptr;
 188   va_start(argptr, szFormat);
 189   vsprintf(s_szBuf, szFormat, argptr);
 190   va_end(argptr);
 191
 192   wxLogSysErrorHelper(wxSysErrorCode());
 193 }
 194
 195 void WXDLLEXPORT wxLogSysError(long lErrCode, const char *szFormat, ...)
 196 {
 197   va_list argptr;
 198   va_start(argptr, szFormat);
 199   vsprintf(s_szBuf, szFormat, argptr);
 200   va_end(argptr);
 201
 202   wxLogSysErrorHelper(lErrCode);
 203 }
 204
 205 // ----------------------------------------------------------------------------
 206 // wxLog class implementation
 207 // ----------------------------------------------------------------------------
 208
 209 wxLog::wxLog()
 210 {
 211   m_bHasMessages = FALSE;
 212   m_bVerbose     = FALSE;
 213   m_szTimeFormat = "[%d/%b/%y %H:%M:%S] ";
 214   m_ulTraceMask  = (wxTraceMask)0;        // -1 to set all bits
 215 }
 216
 217 wxLog *wxLog::GetActiveTarget()
 218 {
 219   if ( !ms_bInitialized ) {
 220     // prevent infinite recursion if someone calls wxLogXXX() from
 221     // wxApp::CreateLogTarget()
 222     ms_bInitialized = TRUE;
 223
 224     #ifdef  WX_TEST_MINIMAL
 225       ms_pLogger = new wxLogStderr;
 226     #else
 227       // ask the application to create a log target for us
 228       ms_pLogger = wxTheApp->CreateLogTarget();
 229     #endif
 230
 231     // do nothing if it fails - what can we do?
 232   }
 233
 234   return ms_pLogger;
 235 }
 236
 237 wxLog *wxLog::SetActiveTarget(wxLog *pLogger)
 238 {
 239   // flush the old messages before changing
 240   if ( ms_pLogger != NULL )
 241     ms_pLogger->Flush();
 242
 243   ms_bInitialized = TRUE;
 244
 245   wxLog *pOldLogger = ms_pLogger;
 246   ms_pLogger = pLogger;
 247   return pOldLogger;
 248 }
 249
 250 void wxLog::DoLog(wxLogLevel level, const char *szString)
 251 {
 252   wxString str;
 253
 254   // prepend a timestamp if not disabled
 255   if ( !IsEmpty(m_szTimeFormat) ) {
 256     char szBuf[128];
 257     time_t timeNow;
 258     struct tm *ptmNow;
 259
 260     time(&timeNow);
 261     ptmNow = localtime(&timeNow);
 262
 263     strftime(szBuf, WXSIZEOF(szBuf), m_szTimeFormat, ptmNow);
 264     str = szBuf;
 265   }
 266
 267   switch ( level ) {
 268     case wxLOG_FatalError:
 269       DoLogString(str << _("Fatal error: ") << szString);
 270       DoLogString(_("Program aborted."));
 271       Flush();
 272       abort();
 273       break;
 274
 275     case wxLOG_Error:
 276       DoLogString(str << _("Error: ") << szString);
 277       break;
 278
 279     case wxLOG_Warning:
 280       DoLogString(str << _("Warning: ") << szString);
 281       break;
 282
 283     case wxLOG_Info:
 284       if ( GetVerbose() )
 285     case wxLOG_Message:
 286         DoLogString(str + szString);
 287       // fall through
 288
 289     case wxLOG_Status:
 290       // nothing to do
 291       break;
 292
 293     case wxLOG_Trace:
 294     case wxLOG_Debug:
 295       #ifdef __WXDEBUG__
 296         #ifdef  __WIN32__
 297           // in addition to normal logging, also send the string to debugger
 298           // (don't prepend "Debug" here: it will go to debug window anyhow)
 299           ::OutputDebugString(str + szString + "\n\r");
 300         #endif  //Win32
 301         DoLogString(str << (level == wxLOG_Trace ? _("Trace") : _("Debug"))
 302                         << ": " << szString);
 303       #endif
 304
 305       break;
 306
 307     default:
 308       wxFAIL_MSG("unknown log level in wxLog::DoLog");
 309   }
 310 }
 311
 312 void wxLog::DoLogString(const char *WXUNUSED(szString))
 313 {
 314   wxFAIL_MSG("DoLogString must be overrided if it's called.");
 315 }
 316
 317 void wxLog::Flush()
 318 {
 319   // do nothing
 320 }
 321
 322 // ----------------------------------------------------------------------------
 323 // wxLogStderr class implementation
 324 // ----------------------------------------------------------------------------
 325
 326 wxLogStderr::wxLogStderr(FILE *fp)
 327 {
 328   if ( fp == NULL )
 329     m_fp = stderr;
 330   else
 331     m_fp = fp;
 332 }
 333
 334 void wxLogStderr::DoLogString(const char *szString)
 335 {
 336   fputs(szString, m_fp);
 337   fputc('\n', m_fp);
 338   fflush(m_fp);
 339 }
 340
 341 // ----------------------------------------------------------------------------
 342 // wxLogStream implementation
 343 // ----------------------------------------------------------------------------
 344
 345 wxLogStream::wxLogStream(ostream *ostr)
 346 {
 347   if ( ostr == NULL )
 348     m_ostr = &cerr;
 349   else
 350     m_ostr = ostr;
 351 }
 352
 353 void wxLogStream::DoLogString(const char *szString)
 354 {
 355   (*m_ostr) << szString << endl << flush;
 356 }
 357
 358 // ----------------------------------------------------------------------------
 359 // wxLogTextCtrl implementation
 360 // ----------------------------------------------------------------------------
 361 wxLogTextCtrl::wxLogTextCtrl(wxTextCtrl *pTextCtrl)
 362 // @@@ TODO: in wxGTK wxTextCtrl doesn't derive from streambuf
 363 #ifndef __WXGTK__
 364              : wxLogStream(new ostream(pTextCtrl))
 365 #endif //GTK
 366 {
 367 }
 368
 369 wxLogTextCtrl::~wxLogTextCtrl()
 370 {
 371   #ifndef __WXGTK__
 372     delete m_ostr;
 373   #endif //GTK
 374 }
 375
 376 // ----------------------------------------------------------------------------
 377 // wxLogGui implementation
 378 // ----------------------------------------------------------------------------
 379
 380 #ifndef   WX_TEST_MINIMAL
 381
 382 wxLogGui::wxLogGui()
 383 {
 384   m_bErrors = FALSE;
 385 }
 386
 387 void wxLogGui::Flush()
 388 {
 389   if ( !m_bHasMessages )
 390     return;
 391
 392   // @@@ ugly...
 393
 394   // concatenate all strings (but not too many to not overfill the msg box)
 395   wxString str;
 396   uint nLines    = 0,
 397        nMsgCount = m_aMessages.Count();
 398
 399   // start from the most recent message
 400   for ( uint n = nMsgCount; n > 0; n-- ) {
 401     // for Windows strings longer than this value are wrapped (NT 4.0)
 402     const uint nMsgLineWidth = 156;
 403
 404     nLines += (m_aMessages[n - 1].Len() + nMsgLineWidth - 1) / nMsgLineWidth;
 405
 406     if ( nLines > 25 )  // don't put too many lines in message box
 407       break;
 408
 409     str << m_aMessages[n - 1] << "\n";
 410   }
 411
 412   if ( m_bErrors ) {
 413     wxMessageBox(str, _("Error"), wxOK | wxICON_EXCLAMATION);
 414   }
 415   else {
 416     wxMessageBox(str, _("Information"), wxOK | wxICON_INFORMATION);
 417   }
 418
 419   // no undisplayed messages whatsoever
 420   m_bHasMessages =
 421   m_bErrors      = FALSE;
 422   m_aMessages.Empty();
 423 }
 424
 425 // the default behaviour is to discard all informational messages if there
 426 // are any errors/warnings.
 427 void wxLogGui::DoLog(wxLogLevel level, const char *szString)
 428 {
 429   switch ( level ) {
 430     case wxLOG_Info:
 431       if ( GetVerbose() )
 432     case wxLOG_Message:
 433         if ( !m_bErrors ) {
 434           m_aMessages.Add(szString);
 435           m_bHasMessages = TRUE;
 436         }
 437       break;
 438
 439     case wxLOG_Status:
 440       {
 441         // find the top window and set it's status text if it has any
 442         wxWindow *pWin = wxTheApp->GetTopWindow();
 443         if ( pWin != NULL && pWin->IsKindOf(CLASSINFO(wxFrame)) ) {
 444           wxFrame *pFrame = (wxFrame *)pWin;
 445           pFrame->SetStatusText(szString);
 446         }
 447       }
 448       break;
 449
 450     case wxLOG_Trace:
 451     case wxLOG_Debug:
 452       #ifdef __WXDEBUG__
 453         #ifdef  __WIN32__
 454           OutputDebugString(szString);
 455           OutputDebugString("\n\r");
 456         #else   //!WIN32
 457           // send them to stderr
 458           fprintf(stderr, "%s: %s\n",
 459                   level == wxLOG_Trace ? _("Trace") : _("Debug"), szString);
 460           fflush(stderr);
 461         #endif  // WIN32
 462       #endif
 463       break;
 464
 465     case wxLOG_FatalError:
 466       // show this one immediately
 467       wxMessageBox(szString, _("Fatal error"), wxICON_HAND);
 468       break;
 469
 470     case wxLOG_Error:
 471     case wxLOG_Warning:
 472       // discard earlier informational messages if this is the 1st error
 473       if ( !m_bErrors ) {
 474         m_aMessages.Empty();
 475         m_bHasMessages = TRUE;
 476         m_bErrors = TRUE;
 477       }
 478
 479       m_aMessages.Add(szString);
 480       break;
 481
 482     default:
 483       wxFAIL_MSG("unknown log level in wxLogGui::DoLog");
 484   }
 485 }
 486
 487 // ----------------------------------------------------------------------------
 488 // wxLogWindow implementation
 489 // ----------------------------------------------------------------------------
 490
 491 // log frame class
 492 class wxLogFrame : public wxFrame
 493 {
 494 public:
 495   // ctor
 496   wxLogFrame(const char *szTitle);
 497
 498   // menu callbacks
 499   void OnClose(wxCommandEvent& event);
 500   void OnCloseWindow(wxCloseEvent& event);
 501   void OnSave (wxCommandEvent& event);
 502   void OnClear(wxCommandEvent& event);
 503
 504   // accessors
 505   wxTextCtrl *TextCtrl() const { return m_pTextCtrl; }
 506
 507 private:
 508   enum
 509   {
 510     Menu_Close = 100,
 511     Menu_Save,
 512     Menu_Clear
 513   };
 514
 515   wxTextCtrl *m_pTextCtrl;
 516
 517   DECLARE_EVENT_TABLE()
 518 };
 519
 520 BEGIN_EVENT_TABLE(wxLogFrame, wxFrame)
 521   // wxLogWindow menu events
 522   EVT_MENU(Menu_Close, wxLogFrame::OnClose)
 523   EVT_MENU(Menu_Save,  wxLogFrame::OnSave)
 524   EVT_MENU(Menu_Clear, wxLogFrame::OnClear)
 525
 526   EVT_CLOSE(wxLogFrame::OnCloseWindow)
 527 END_EVENT_TABLE()
 528
 529 wxLogFrame::wxLogFrame(const char *szTitle)
 530           : wxFrame(NULL, -1, szTitle)
 531 {
 532   // we don't want to be a top-level frame because it would prevent the
 533   // application termination when all other frames are closed
 534   wxTopLevelWindows.DeleteObject(this);
 535
 536   // @@ kludge: wxSIMPLE_BORDER is simply to prevent wxWindows from creating
 537   //    a rich edit control instead of a normal one we want
 538   m_pTextCtrl = new wxTextCtrl(this, -1, wxEmptyString, wxDefaultPosition,
 539                                wxDefaultSize,
 540                                wxSIMPLE_BORDER |
 541                                wxTE_MULTILINE  |
 542                                wxHSCROLL       |
 543                                wxTE_READONLY);
 544   /*
 545   m_pTextCtrl->SetEditable(FALSE);
 546   m_pTextCtrl->SetRichEdit(FALSE);
 547   */
 548
 549   // create menu
 550   wxMenuBar *pMenuBar = new wxMenuBar;
 551   wxMenu *pMenu = new wxMenu;
 552   pMenu->Append(Menu_Save,  "&Save...");
 553   pMenu->Append(Menu_Clear, "C&lear");
 554   pMenu->AppendSeparator();
 555   pMenu->Append(Menu_Close, "&Close");
 556   pMenuBar->Append(pMenu, "&Log");
 557   SetMenuBar(pMenuBar);
 558
 559   // @@ what about status bar? needed (for menu prompts)?
 560 }
 561
 562 void wxLogFrame::OnClose(wxCommandEvent& WXUNUSED(event))
 563 {
 564   // just hide the window
 565   Show(FALSE);
 566 }
 567
 568 void wxLogFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
 569 {
 570   // just hide the window
 571   Show(FALSE);
 572 }
 573
 574 void wxLogFrame::OnSave(wxCommandEvent& WXUNUSED(event))
 575 {
 576   // get the file name
 577   // -----------------
 578   const char *szFileName = wxSaveFileSelector("log", "txt", "log.txt");
 579   if ( szFileName == NULL ) {
 580     // cancelled
 581     return;
 582   }
 583
 584   // open file
 585   // ---------
 586   wxFile file;
 587   bool bOk = FALSE;
 588   if ( wxFile::Exists(szFileName) ) {
 589     bool bAppend = FALSE;
 590     wxString strMsg;
 591     strMsg.Printf(_("Append log to file '%s' "
 592                     "(choosing [No] will overwrite it)?"), szFileName);
 593     switch ( wxMessageBox(strMsg, "Question", wxYES_NO | wxCANCEL) ) {
 594       case wxYES:
 595         bAppend = TRUE;
 596         break;
 597
 598       case wxNO:
 599         bAppend = FALSE;
 600         break;
 601
 602       case wxCANCEL:
 603         return;
 604
 605       default:
 606         wxFAIL_MSG("invalid message box return value");
 607     }
 608
 609     if ( bAppend ) {
 610       bOk = file.Open(szFileName, wxFile::write_append);
 611     }
 612     else {
 613       bOk = file.Create(szFileName, TRUE /* overwrite */);
 614     }
 615   }
 616   else {
 617     bOk = file.Create(szFileName);
 618   }
 619
 620   // retrieve text and save it
 621   // -------------------------
 622 #ifdef __WXGTK__
 623   // @@@@ TODO: no GetNumberOfLines and GetLineText in wxGTK yet
 624   wxLogError("Sorry, this function is not implemented under GTK");
 625 #else
 626   int nLines = m_pTextCtrl->GetNumberOfLines();
 627   for ( int nLine = 0; bOk && nLine < nLines; nLine++ ) {
 628     bOk = file.Write(m_pTextCtrl->GetLineText(nLine) + wxTextFile::GetEOL());
 629   }
 630 #endif //GTK
 631
 632   if ( bOk )
 633     bOk = file.Close();
 634
 635   if ( !bOk ) {
 636     wxLogError(_("Can't save log contents to file."));
 637     return;
 638   }
 639 }
 640
 641 void wxLogFrame::OnClear(wxCommandEvent& WXUNUSED(event))
 642 {
 643   m_pTextCtrl->Clear();
 644 }
 645
 646 wxLogWindow::wxLogWindow(const char *szTitle, bool bShow)
 647 {
 648   m_pOldLog = wxLog::GetActiveTarget();
 649   m_pLogFrame = new wxLogFrame(szTitle);
 650
 651   if ( bShow )
 652     m_pLogFrame->Show(TRUE);
 653 }
 654
 655 void wxLogWindow::Show(bool bShow)
 656 {
 657   m_pLogFrame->Show(bShow);
 658 }
 659
 660 void wxLogWindow::DoLog(wxLogLevel level, const char *szString)
 661 {
 662   // first let the previous logger show it
 663   if ( m_pOldLog != NULL ) {
 664     // @@@ why can't we access protected wxLog method from here (we derive
 665     // from wxLog)? gcc gives "DoLog is protected in this context", what
 666     // does this mean? Anyhow, the cast is harmless and let's us do what
 667     // we want.
 668     ((wxLogWindow *)m_pOldLog)->DoLog(level, szString);
 669   }
 670
 671   // and this will format it nicely and call our DoLogString()
 672   wxLog::DoLog(level, szString);
 673 }
 674
 675 void wxLogWindow::DoLogString(const char *szString)
 676 {
 677   // put the text into our window
 678   wxTextCtrl *pText = m_pLogFrame->TextCtrl();
 679
 680   // remove selection (WriteText is in fact ReplaceSelection)
 681   #ifdef __WXMSW__
 682     long nLen = pText->GetLastPosition();
 683     pText->SetSelection(nLen, nLen);
 684   #endif // Windows
 685
 686   pText->WriteText(szString);
 687   pText->WriteText("\n"); // "\n" ok here (_not_ "\r\n")
 688
 689   // ensure that the line can be seen
 690   // @@@ TODO
 691 }
 692
 693 wxLogWindow::~wxLogWindow()
 694 {
 695   m_pLogFrame->Close(TRUE);
 696 }
 697
 698 #endif  //WX_TEST_MINIMAL
 699
 700 // ============================================================================
 701 // Global functions/variables
 702 // ============================================================================
 703
 704 // ----------------------------------------------------------------------------
 705 // static variables
 706 // ----------------------------------------------------------------------------
 707 wxLog      *wxLog::ms_pLogger      = NULL;
 708 bool        wxLog::ms_bInitialized = FALSE;
 709
 710 // ----------------------------------------------------------------------------
 711 // stdout error logging helper
 712 // ----------------------------------------------------------------------------
 713
 714 // helper function: wraps the message and justifies it under given position
 715 // (looks more pretty on the terminal). Also adds newline at the end.
 716 //
 717 // @@ this is now disabled until I find a portable way of determining the
 718 //    terminal window size (ok, I found it but does anybody really cares?)
 719 #ifdef    LOG_PRETTY_WRAP
 720 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz)
 721 {
 722   size_t nMax = 80; // @@@@
 723   size_t nStart = strlen(pszPrefix);
 724   fputs(pszPrefix, f);
 725
 726   size_t n;
 727   while ( *psz != '\0' ) {
 728     for ( n = nStart; (n < nMax) && (*psz != '\0'); n++ )
 729       putc(*psz++, f);
 730
 731     // wrapped?
 732     if ( *psz != '\0' ) {
 733       /*putc('\n', f);*/
 734       for ( n = 0; n < nStart; n++ )
 735         putc(' ', f);
 736
 737       // as we wrapped, squeeze all white space
 738       while ( isspace(*psz) )
 739         psz++;
 740     }
 741   }
 742
 743   putc('\n', f);
 744 }
 745 #endif  //LOG_PRETTY_WRAP
 746
 747 // ----------------------------------------------------------------------------
 748 // error code/error message retrieval functions
 749 // ----------------------------------------------------------------------------
 750
 751 // get error code from syste
 752 unsigned long wxSysErrorCode()
 753 {
 754   #ifdef  __WXMSW__
 755     #ifdef  __WIN32__
 756       return ::GetLastError();
 757     #else   //WIN16
 758       // @@@@ what to do on Windows 3.1?
 759       return 0;
 760     #endif  //WIN16/32
 761   #else   //Unix
 762     return errno;
 763   #endif  //Win/Unix
 764 }
 765
 766 // get error message from system
 767 const char *wxSysErrorMsg(unsigned long nErrCode)
 768 {
 769   if ( nErrCode == 0 )
 770     nErrCode = wxSysErrorCode();
 771
 772   #ifdef  __WXMSW__
 773     #ifdef  __WIN32__
 774       static char s_szBuf[LOG_BUFFER_SIZE / 2];
 775
 776       // get error message from system
 777       LPVOID lpMsgBuf;
 778       FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 779                     NULL, nErrCode,
 780                     MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 781                     (LPTSTR)&lpMsgBuf,
 782                     0, NULL);
 783
 784       // copy it to our buffer and free memory
 785       strncpy(s_szBuf, (const char *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
 786       s_szBuf[WXSIZEOF(s_szBuf) - 1] = '\0';
 787       LocalFree(lpMsgBuf);
 788
 789       // returned string is capitalized and ended with '\r\n' - bad
 790       s_szBuf[0] = (char)wxToLower(s_szBuf[0]);
 791       size_t len = strlen(s_szBuf);
 792       if ( len > 0 ) {
 793         // truncate string
 794         if ( s_szBuf[len - 2] == '\r' )
 795           s_szBuf[len - 2] = '\0';
 796       }
 797
 798       return s_szBuf;
 799     #else   //Win16
 800       // TODO @@@@
 801       return NULL;
 802     #endif // Win16/32
 803   #else   // Unix
 804     return strerror(nErrCode);
 805   #endif  // Win/Unix
 806 }
 807
 808 // ----------------------------------------------------------------------------
 809 // debug helper
 810 // ----------------------------------------------------------------------------
 811
 812 #ifdef  __WXDEBUG__
 813
 814 void Trap()
 815 {
 816   #ifdef __WXMSW__
 817     DebugBreak();
 818   #else // Unix
 819     raise(SIGTRAP);
 820   #endif // Win/Unix
 821 }
 822
 823 // this function is called when an assert fails
 824 void wxOnAssert(const char *szFile, int nLine, const char *szMsg)
 825 {
 826   // this variable can be set to true to suppress "assert failure" messages
 827   static bool s_bNoAsserts = FALSE;
 828   static bool s_bInAssert = FALSE;
 829
 830   if ( s_bInAssert ) {
 831     // He-e-e-e-elp!! we're trapped in endless loop
 832     Trap();
 833   }
 834
 835   s_bInAssert = TRUE;
 836
 837   char szBuf[LOG_BUFFER_SIZE];
 838   sprintf(szBuf, _("Assert failed in file %s at line %d"), szFile, nLine);
 839   if ( szMsg != NULL ) {
 840     strcat(szBuf, ": ");
 841     strcat(szBuf, szMsg);
 842   }
 843   else {
 844     strcat(szBuf, ".");
 845   }
 846
 847   if ( !s_bNoAsserts ) {
 848     // send it to the normal log destination
 849     wxLogDebug(szBuf);
 850
 851     strcat(szBuf, _("\nDo you want to stop the program?"
 852                     "\nYou can also choose [Cancel] to suppress "
 853                     "further warnings."));
 854
 855     switch ( wxMessageBox(szBuf, _("Debug"),
 856                           wxYES_NO | wxCANCEL | wxICON_STOP ) ) {
 857       case wxYES:
 858         Trap();
 859         break;
 860
 861       case wxCANCEL:
 862         s_bNoAsserts = TRUE;
 863         break;
 864
 865       //case wxNO: nothing to do
 866     }
 867   }
 868
 869   s_bInAssert = FALSE;
 870 }
 871
 872 #endif  //WXDEBUG
 873