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


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