]> git.saurik.com Git - wxWidgets.git/blob - src/common/log.cpp
projects / wxWidgets.git / blob
? search:


5b3a6f1ffc6f971ff06468e22c5975cf1d15a32c
[wxWidgets.git] / 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
wxWidgets (Impactor)