]>
Commit | Line | Data |
---|---|---|
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 | |
78 | static 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) | |
96 | static char s_szBuf[LOG_BUFFER_SIZE]; | |
97 | ||
98 | // generic log function | |
7502ba29 | 99 | void 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 | ||
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 | ||
470b7da3 VZ |
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); | |
c67daf87 | 145 | gs_pFrame = (wxFrame *) NULL; |
470b7da3 VZ |
146 | } |
147 | } | |
148 | ||
9ef3052c | 149 | // same as info, but only if 'verbose' mode is on |
7502ba29 | 150 | void 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 | ||
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) | |
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 | 215 | void 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 | 225 | void 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 | ||
239 | wxLog::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 |
246 | wxLog *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 | 274 | wxLog *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 | 288 | wxString 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 | ||
311 | void 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 | 359 | void wxLog::DoLogString(const char *WXUNUSED(szString)) |
c801d85f | 360 | { |
1a5a8367 | 361 | wxFAIL_MSG(_("DoLogString must be overrided if it's called.")); |
c801d85f KB |
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 | wxLogStream::wxLogStream(ostream *ostr) | |
393 | { | |
394 | if ( ostr == NULL ) | |
395 | m_ostr = &cerr; | |
396 | else | |
397 | m_ostr = ostr; | |
398 | } | |
399 | ||
400 | void 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 | 409 | wxLogTextCtrl::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 | ||
420 | wxLogTextCtrl::~wxLogTextCtrl() | |
421 | { | |
c5c16a30 | 422 | delete m_ostr; |
c801d85f | 423 | } |
c801d85f KB |
424 | |
425 | // ---------------------------------------------------------------------------- | |
426 | // wxLogGui implementation | |
427 | // ---------------------------------------------------------------------------- | |
428 | ||
c801d85f KB |
429 | wxLogGui::wxLogGui() |
430 | { | |
431 | m_bErrors = FALSE; | |
432 | } | |
433 | ||
434 | void 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 | 476 | void 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 |
558 | class wxLogFrame : public wxFrame |
559 | { | |
560 | public: | |
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 | ||
576 | private: | |
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 | ||
593 | BEGIN_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 | 600 | END_EVENT_TABLE() |
9ef3052c | 601 | |
470b7da3 VZ |
602 | wxLogFrame::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 | 632 | void wxLogFrame::OnClose(wxCommandEvent& WXUNUSED(event)) |
9ef3052c | 633 | { |
fe7b1156 | 634 | DoClose(); |
9ef3052c VZ |
635 | } |
636 | ||
46dc76ba | 637 | void wxLogFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event)) |
5260b1c5 | 638 | { |
fe7b1156 VZ |
639 | DoClose(); |
640 | } | |
641 | ||
46dc76ba | 642 | void 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 | 709 | void wxLogFrame::OnClear(wxCommandEvent& WXUNUSED(event)) |
9ef3052c VZ |
710 | { |
711 | m_pTextCtrl->Clear(); | |
712 | } | |
713 | ||
fe7b1156 VZ |
714 | wxLogFrame::~wxLogFrame() |
715 | { | |
716 | m_log->OnFrameDelete(this); | |
717 | } | |
718 | ||
719 | // wxLogWindow | |
720 | // ----------- | |
470b7da3 VZ |
721 | wxLogWindow::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 | 735 | void wxLogWindow::Show(bool bShow) |
9ef3052c VZ |
736 | { |
737 | m_pLogFrame->Show(bShow); | |
738 | } | |
739 | ||
fe7b1156 | 740 | void 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 |
748 | void 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 | ||
787 | void 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 |
804 | wxFrame *wxLogWindow::GetFrame() const |
805 | { | |
806 | return m_pLogFrame; | |
807 | } | |
808 | ||
8fdca65c | 809 | void wxLogWindow::OnFrameCreate(wxFrame *WXUNUSED(frame)) |
fe7b1156 VZ |
810 | { |
811 | } | |
812 | ||
8fdca65c | 813 | void wxLogWindow::OnFrameDelete(wxFrame *WXUNUSED(frame)) |
fe7b1156 | 814 | { |
c085e333 | 815 | m_pLogFrame = (wxLogFrame *)NULL; |
fe7b1156 VZ |
816 | } |
817 | ||
9ef3052c VZ |
818 | wxLogWindow::~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 | 835 | wxLog *wxLog::ms_pLogger = (wxLog *) NULL; |
c085e333 | 836 | bool wxLog::ms_doLog = TRUE; |
275bf4c1 | 837 | bool wxLog::ms_bAutoCreate = TRUE; |
88f2aa37 | 838 | wxTraceMask 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 |
850 | static 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 | |
882 | unsigned 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 | |
897 | const 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 |
944 | void 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 |
956 | void 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 |