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