1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Assorted wxLogXXX functions, and wxLog (sink for logs)
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 #pragma implementation "log.h"
23 // For compilers that support precompilation, includes "wx.h".
24 #include "wx/wxprec.h"
33 #include <wx/string.h>
37 #include <wx/generic/msgdlgg.h>
38 #include <wx/filedlg.h>
39 #include <wx/textctrl.h>
43 #include <wx/textfile.h>
47 // other standard headers
58 // ----------------------------------------------------------------------------
59 // non member functions
60 // ----------------------------------------------------------------------------
62 // define this to enable wrapping of log messages
63 //#define LOG_PRETTY_WRAP
65 #ifdef LOG_PRETTY_WRAP
66 static void wxLogWrap(FILE *f
, const char *pszPrefix
, const char *psz
);
69 // ============================================================================
71 // ============================================================================
73 // ----------------------------------------------------------------------------
74 // implementation of Log functions
76 // NB: unfortunately we need all these distinct functions, we can't make them
77 // macros and not all compilers inline vararg functions.
78 // ----------------------------------------------------------------------------
80 // log functions can't allocate memory (LogError("out of memory...") should
81 // work!), so we use a static buffer for all log messages
82 #define LOG_BUFFER_SIZE (4096)
84 // static buffer for error messages (@@@ MT-unsafe)
85 static char s_szBuf
[LOG_BUFFER_SIZE
];
87 // generic log function
88 void wxLogGeneric(wxLogLevel level
, const char *szFormat
, ...)
90 if ( wxLog::GetActiveTarget() != NULL
) {
92 va_start(argptr
, szFormat
);
93 vsprintf(s_szBuf
, szFormat
, argptr
);
96 wxLog::OnLog(level
, s_szBuf
);
100 #define IMPLEMENT_LOG_FUNCTION(level) \
101 void wxLog##level(const char *szFormat, ...) \
103 if ( wxLog::GetActiveTarget() != NULL ) { \
105 va_start(argptr, szFormat); \
106 vsprintf(s_szBuf, szFormat, argptr); \
109 wxLog::OnLog(wxLOG_##level, s_szBuf); \
113 IMPLEMENT_LOG_FUNCTION(FatalError
)
114 IMPLEMENT_LOG_FUNCTION(Error
)
115 IMPLEMENT_LOG_FUNCTION(Warning
)
116 IMPLEMENT_LOG_FUNCTION(Message
)
117 IMPLEMENT_LOG_FUNCTION(Info
)
118 IMPLEMENT_LOG_FUNCTION(Status
)
120 // same as info, but only if 'verbose' mode is on
121 void wxLogVerbose(const char *szFormat
, ...)
123 wxLog
*pLog
= wxLog::GetActiveTarget();
124 if ( pLog
!= NULL
&& pLog
->GetVerbose() ) {
126 va_start(argptr
, szFormat
);
127 vsprintf(s_szBuf
, szFormat
, argptr
);
130 wxLog::OnLog(wxLOG_Info
, s_szBuf
);
136 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level) \
137 void wxLog##level(const char *szFormat, ...) \
139 if ( wxLog::GetActiveTarget() != NULL ) { \
141 va_start(argptr, szFormat); \
142 vsprintf(s_szBuf, szFormat, argptr); \
145 wxLog::OnLog(wxLOG_##level, s_szBuf); \
149 void wxLogTrace(wxTraceMask mask
, const char *szFormat
, ...)
151 wxLog
*pLog
= wxLog::GetActiveTarget();
153 // we check that all of mask bits are set in the current mask, so
154 // that wxLogTrace(wxTraceRefCount | wxTraceOle) will only do something
155 // if both bits are set.
156 if ( pLog
!= NULL
&& (pLog
->GetTraceMask() & mask
== mask
) ) {
158 va_start(argptr
, szFormat
);
159 vsprintf(s_szBuf
, szFormat
, argptr
);
162 wxLog::OnLog(wxLOG_Trace
, s_szBuf
);
167 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)
170 IMPLEMENT_LOG_DEBUG_FUNCTION(Debug
)
171 IMPLEMENT_LOG_DEBUG_FUNCTION(Trace
)
173 // wxLogSysError: one uses the last error code, for other you must give it
176 // common part of both wxLogSysError
177 void wxLogSysErrorHelper(long lErrCode
)
179 char szErrMsg
[LOG_BUFFER_SIZE
/ 2];
180 sprintf(szErrMsg
, _(" (error %ld: %s)"), lErrCode
, wxSysErrorMsg(lErrCode
));
181 strncat(s_szBuf
, szErrMsg
, WXSIZEOF(s_szBuf
) - strlen(s_szBuf
));
183 wxLog::OnLog(wxLOG_Error
, s_szBuf
);
186 void WXDLLEXPORT
wxLogSysError(const char *szFormat
, ...)
189 va_start(argptr
, szFormat
);
190 vsprintf(s_szBuf
, szFormat
, argptr
);
193 wxLogSysErrorHelper(wxSysErrorCode());
196 void WXDLLEXPORT
wxLogSysError(long lErrCode
, const char *szFormat
, ...)
199 va_start(argptr
, szFormat
);
200 vsprintf(s_szBuf
, szFormat
, argptr
);
203 wxLogSysErrorHelper(lErrCode
);
206 // ----------------------------------------------------------------------------
207 // wxLog class implementation
208 // ----------------------------------------------------------------------------
212 m_bHasMessages
= FALSE
;
214 m_szTimeFormat
= "[%d/%b/%y %H:%M:%S] ";
217 wxLog
*wxLog::GetActiveTarget()
219 if ( !ms_bInitialized
) {
220 // prevent infinite recursion if someone calls wxLogXXX() from
221 // wxApp::CreateLogTarget()
222 ms_bInitialized
= TRUE
;
224 #ifdef WX_TEST_MINIMAL
225 ms_pLogger
= new wxLogStderr
;
227 // ask the application to create a log target for us
228 ms_pLogger
= wxTheApp
->CreateLogTarget();
231 // do nothing if it fails - what can we do?
237 wxLog
*wxLog::SetActiveTarget(wxLog
*pLogger
)
239 // flush the old messages before changing
240 if ( ms_pLogger
!= NULL
)
243 ms_bInitialized
= TRUE
;
245 wxLog
*pOldLogger
= ms_pLogger
;
246 ms_pLogger
= pLogger
;
250 void wxLog::DoLog(wxLogLevel level
, const char *szString
)
254 // prepend a timestamp if not disabled
255 if ( !IsEmpty(m_szTimeFormat
) ) {
261 ptmNow
= localtime(&timeNow
);
263 strftime(szBuf
, WXSIZEOF(szBuf
), m_szTimeFormat
, ptmNow
);
268 case wxLOG_FatalError
:
269 DoLogString(str
<< _("Fatal error: ") << szString
);
270 DoLogString(_("Program aborted."));
276 DoLogString(str
<< _("Error: ") << szString
);
280 DoLogString(str
<< _("Warning: ") << szString
);
286 DoLogString(str
+ szString
);
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");
301 DoLogString(str
<< (level
== wxLOG_Trace
? _("Trace") : _("Debug"))
302 << ": " << szString
);
308 wxFAIL_MSG("unknown log level in wxLog::DoLog");
312 void wxLog::DoLogString(const char *WXUNUSED(szString
))
314 wxFAIL_MSG("DoLogString must be overrided if it's called.");
322 // ----------------------------------------------------------------------------
323 // wxLogStderr class implementation
324 // ----------------------------------------------------------------------------
326 wxLogStderr::wxLogStderr(FILE *fp
)
334 void wxLogStderr::DoLogString(const char *szString
)
336 fputs(szString
, m_fp
);
341 // ----------------------------------------------------------------------------
342 // wxLogStream implementation
343 // ----------------------------------------------------------------------------
345 wxLogStream::wxLogStream(ostream
*ostr
)
353 void wxLogStream::DoLogString(const char *szString
)
355 (*m_ostr
) << szString
<< endl
<< flush
;
358 // ----------------------------------------------------------------------------
359 // wxLogTextCtrl implementation
360 // ----------------------------------------------------------------------------
361 wxLogTextCtrl::wxLogTextCtrl(wxTextCtrl
*pTextCtrl
)
362 // @@@ TODO: in wxGTK wxTextCtrl doesn't derive from streambuf
364 : wxLogStream(new ostream(pTextCtrl
))
369 wxLogTextCtrl::~wxLogTextCtrl()
376 // ----------------------------------------------------------------------------
377 // wxLogGui implementation
378 // ----------------------------------------------------------------------------
380 #ifndef WX_TEST_MINIMAL
387 void wxLogGui::Flush()
389 if ( !m_bHasMessages
)
394 // concatenate all strings (but not too many to not overfill the msg box)
397 nMsgCount
= m_aMessages
.Count();
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;
404 nLines
+= (m_aMessages
[n
- 1].Len() + nMsgLineWidth
- 1) / nMsgLineWidth
;
406 if ( nLines
> 25 ) // don't put too many lines in message box
409 str
<< m_aMessages
[n
- 1] << "\n";
413 wxMessageBox(str
, _("Error"), wxOK
| wxICON_EXCLAMATION
);
416 wxMessageBox(str
, _("Information"), wxOK
| wxICON_INFORMATION
);
419 // no undisplayed messages whatsoever
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
)
434 m_aMessages
.Add(szString
);
435 m_bHasMessages
= TRUE
;
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
);
454 OutputDebugString(szString
);
455 OutputDebugString("\n\r");
457 // send them to stderr
458 fprintf(stderr
, "%s: %s\n",
459 level
== wxLOG_Trace
? _("Trace") : _("Debug"), szString
);
465 case wxLOG_FatalError
:
466 // show this one immediately
467 wxMessageBox(szString
, _("Fatal error"), wxICON_HAND
);
472 // discard earlier informational messages if this is the 1st error
475 m_bHasMessages
= TRUE
;
479 m_aMessages
.Add(szString
);
483 wxFAIL_MSG("unknown log level in wxLogGui::DoLog");
487 // ----------------------------------------------------------------------------
488 // wxLogWindow implementation
489 // ----------------------------------------------------------------------------
492 class wxLogFrame
: public wxFrame
496 wxLogFrame(const char *szTitle
);
499 void OnClose(wxCommandEvent
& event
);
500 void OnCloseWindow(wxCloseEvent
& event
);
501 void OnSave (wxCommandEvent
& event
);
502 void OnClear(wxCommandEvent
& event
);
505 wxTextCtrl
*TextCtrl() const { return m_pTextCtrl
; }
515 wxTextCtrl
*m_pTextCtrl
;
517 DECLARE_EVENT_TABLE()
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
)
526 EVT_CLOSE(wxLogFrame::OnCloseWindow
)
529 wxLogFrame::wxLogFrame(const char *szTitle
)
530 : wxFrame(NULL
, -1, szTitle
)
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);
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
,
545 m_pTextCtrl->SetEditable(FALSE);
546 m_pTextCtrl->SetRichEdit(FALSE);
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
);
559 // @@ what about status bar? needed (for menu prompts)?
562 void wxLogFrame::OnClose(wxCommandEvent
& WXUNUSED(event
))
564 // just hide the window
568 void wxLogFrame::OnCloseWindow(wxCloseEvent
& WXUNUSED(event
))
570 // just hide the window
574 void wxLogFrame::OnSave(wxCommandEvent
& WXUNUSED(event
))
578 const char *szFileName
= wxSaveFileSelector("log", "txt", "log.txt");
579 if ( szFileName
== NULL
) {
588 if ( wxFile::Exists(szFileName
) ) {
589 bool bAppend
= FALSE
;
591 strMsg
.Printf(_("Append log to file '%s' "
592 "(choosing [No] will overwrite it)?"), szFileName
);
593 switch ( wxMessageBox(strMsg
, "Question", wxYES_NO
| wxCANCEL
) ) {
606 wxFAIL_MSG("invalid message box return value");
610 bOk
= file
.Open(szFileName
, wxFile::write_append
);
613 bOk
= file
.Create(szFileName
, TRUE
/* overwrite */);
617 bOk
= file
.Create(szFileName
);
620 // retrieve text and save it
621 // -------------------------
623 // @@@@ TODO: no GetNumberOfLines and GetLineText in wxGTK yet
624 wxLogError("Sorry, this function is not implemented under GTK");
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());
636 wxLogError(_("Can't save log contents to file."));
641 void wxLogFrame::OnClear(wxCommandEvent
& WXUNUSED(event
))
643 m_pTextCtrl
->Clear();
646 wxLogWindow::wxLogWindow(const char *szTitle
, bool bShow
)
648 m_pOldLog
= wxLog::GetActiveTarget();
649 m_pLogFrame
= new wxLogFrame(szTitle
);
652 m_pLogFrame
->Show(TRUE
);
655 void wxLogWindow::Show(bool bShow
)
657 m_pLogFrame
->Show(bShow
);
660 void wxLogWindow::DoLog(wxLogLevel level
, const char *szString
)
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
668 ((wxLogWindow
*)m_pOldLog
)->DoLog(level
, szString
);
671 // and this will format it nicely and call our DoLogString()
672 wxLog::DoLog(level
, szString
);
675 void wxLogWindow::DoLogString(const char *szString
)
677 // put the text into our window
678 wxTextCtrl
*pText
= m_pLogFrame
->TextCtrl();
680 // remove selection (WriteText is in fact ReplaceSelection)
682 long nLen
= pText
->GetLastPosition();
683 pText
->SetSelection(nLen
, nLen
);
686 pText
->WriteText(szString
);
687 pText
->WriteText("\n"); // "\n" ok here (_not_ "\r\n")
689 // ensure that the line can be seen
693 wxLogWindow::~wxLogWindow()
695 m_pLogFrame
->Close(TRUE
);
698 #endif //WX_TEST_MINIMAL
700 // ============================================================================
701 // Global functions/variables
702 // ============================================================================
704 // ----------------------------------------------------------------------------
706 // ----------------------------------------------------------------------------
707 wxLog
*wxLog::ms_pLogger
= NULL
;
708 bool wxLog::ms_bInitialized
= FALSE
;
709 wxTraceMask
wxLog::ms_ulTraceMask
= (wxTraceMask
)0;
711 // ----------------------------------------------------------------------------
712 // stdout error logging helper
713 // ----------------------------------------------------------------------------
715 // helper function: wraps the message and justifies it under given position
716 // (looks more pretty on the terminal). Also adds newline at the end.
718 // @@ this is now disabled until I find a portable way of determining the
719 // terminal window size (ok, I found it but does anybody really cares?)
720 #ifdef LOG_PRETTY_WRAP
721 static void wxLogWrap(FILE *f
, const char *pszPrefix
, const char *psz
)
723 size_t nMax
= 80; // @@@@
724 size_t nStart
= strlen(pszPrefix
);
728 while ( *psz
!= '\0' ) {
729 for ( n
= nStart
; (n
< nMax
) && (*psz
!= '\0'); n
++ )
733 if ( *psz
!= '\0' ) {
735 for ( n
= 0; n
< nStart
; n
++ )
738 // as we wrapped, squeeze all white space
739 while ( isspace(*psz
) )
746 #endif //LOG_PRETTY_WRAP
748 // ----------------------------------------------------------------------------
749 // error code/error message retrieval functions
750 // ----------------------------------------------------------------------------
752 // get error code from syste
753 unsigned long wxSysErrorCode()
757 return ::GetLastError();
759 // @@@@ what to do on Windows 3.1?
767 // get error message from system
768 const char *wxSysErrorMsg(unsigned long nErrCode
)
771 nErrCode
= wxSysErrorCode();
775 static char s_szBuf
[LOG_BUFFER_SIZE
/ 2];
777 // get error message from system
779 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_SYSTEM
,
781 MAKELANGID(LANG_NEUTRAL
, SUBLANG_DEFAULT
),
785 // copy it to our buffer and free memory
786 strncpy(s_szBuf
, (const char *)lpMsgBuf
, WXSIZEOF(s_szBuf
) - 1);
787 s_szBuf
[WXSIZEOF(s_szBuf
) - 1] = '\0';
790 // returned string is capitalized and ended with '\r\n' - bad
791 s_szBuf
[0] = (char)wxToLower(s_szBuf
[0]);
792 size_t len
= strlen(s_szBuf
);
795 if ( s_szBuf
[len
- 2] == '\r' )
796 s_szBuf
[len
- 2] = '\0';
805 return strerror(nErrCode
);
809 // ----------------------------------------------------------------------------
811 // ----------------------------------------------------------------------------
824 // this function is called when an assert fails
825 void wxOnAssert(const char *szFile
, int nLine
, const char *szMsg
)
827 // this variable can be set to true to suppress "assert failure" messages
828 static bool s_bNoAsserts
= FALSE
;
829 static bool s_bInAssert
= FALSE
;
832 // He-e-e-e-elp!! we're trapped in endless loop
838 char szBuf
[LOG_BUFFER_SIZE
];
839 sprintf(szBuf
, _("Assert failed in file %s at line %d"), szFile
, nLine
);
840 if ( szMsg
!= NULL
) {
842 strcat(szBuf
, szMsg
);
848 if ( !s_bNoAsserts
) {
849 // send it to the normal log destination
852 strcat(szBuf
, _("\nDo you want to stop the program?"
853 "\nYou can also choose [Cancel] to suppress "
854 "further warnings."));
856 switch ( wxMessageBox(szBuf
, _("Debug"),
857 wxYES_NO
| wxCANCEL
| wxICON_STOP
) ) {
866 //case wxNO: nothing to do