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