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