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


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