]> git.saurik.com Git - wxWidgets.git/blob - src/common/log.cpp
Use wxAcceleratorEntry::ToString() for undo/redo accelerator labels.
[wxWidgets.git] / src / common / log.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/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 licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #if wxUSE_LOG
28
29 // wxWidgets
30 #ifndef WX_PRECOMP
31 #include "wx/log.h"
32 #include "wx/app.h"
33 #include "wx/arrstr.h"
34 #include "wx/intl.h"
35 #include "wx/string.h"
36 #include "wx/utils.h"
37 #endif //WX_PRECOMP
38
39 #include "wx/apptrait.h"
40 #include "wx/datetime.h"
41 #include "wx/file.h"
42 #include "wx/msgout.h"
43 #include "wx/textfile.h"
44 #include "wx/thread.h"
45 #include "wx/private/threadinfo.h"
46 #include "wx/crt.h"
47 #include "wx/vector.h"
48
49 // other standard headers
50 #ifndef __WXWINCE__
51 #include <errno.h>
52 #endif
53
54 #include <stdlib.h>
55
56 #ifndef __WXPALMOS5__
57 #ifndef __WXWINCE__
58 #include <time.h>
59 #else
60 #include "wx/msw/wince/time.h"
61 #endif
62 #endif /* ! __WXPALMOS5__ */
63
64 #if defined(__WINDOWS__)
65 #include "wx/msw/private.h" // includes windows.h
66 #endif
67
68 #undef wxLOG_COMPONENT
69 const char *wxLOG_COMPONENT = "";
70
71 // this macro allows to define an object which will be initialized before any
72 // other function in this file is called: this is necessary to allow log
73 // functions to be used during static initialization (this is not advisable
74 // anyhow but we should at least try to not crash) and to also ensure that they
75 // are initialized by the time static initialization is done, i.e. before any
76 // threads are created hopefully
77 //
78 // the net effect of all this is that you can use Get##name() function to
79 // access the object without worrying about it being not initialized
80 //
81 // see also WX_DEFINE_GLOBAL_CONV2() in src/common/strconv.cpp
82 #define WX_DEFINE_GLOBAL_VAR(type, name) \
83 inline type& Get##name() \
84 { \
85 static type s_##name; \
86 return s_##name; \
87 } \
88 \
89 type *gs_##name##Ptr = &Get##name()
90
91 #if wxUSE_THREADS
92
93 wxTLS_TYPE(wxThreadSpecificInfo) wxThreadInfoVar;
94
95 namespace
96 {
97
98 // contains messages logged by the other threads and waiting to be shown until
99 // Flush() is called in the main one
100 typedef wxVector<wxLogRecord> wxLogRecords;
101 wxLogRecords gs_bufferedLogRecords;
102
103 #define WX_DEFINE_LOG_CS(name) WX_DEFINE_GLOBAL_VAR(wxCriticalSection, name##CS)
104
105 // this critical section is used for buffering the messages from threads other
106 // than main, i.e. it protects all accesses to gs_bufferedLogRecords above
107 WX_DEFINE_LOG_CS(BackgroundLog);
108
109 // this one is used for protecting ms_aTraceMasks from concurrent access
110 WX_DEFINE_LOG_CS(TraceMask);
111
112 // and this one is used for GetComponentLevels()
113 WX_DEFINE_LOG_CS(Levels);
114
115 } // anonymous namespace
116
117 #endif // wxUSE_THREADS
118
119 // ----------------------------------------------------------------------------
120 // non member functions
121 // ----------------------------------------------------------------------------
122
123 // define this to enable wrapping of log messages
124 //#define LOG_PRETTY_WRAP
125
126 #ifdef LOG_PRETTY_WRAP
127 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz);
128 #endif
129
130 // ----------------------------------------------------------------------------
131 // module globals
132 // ----------------------------------------------------------------------------
133
134 namespace
135 {
136
137 // this struct is used to store information about the previous log message used
138 // by OnLog() to (optionally) avoid logging multiple copies of the same message
139 struct PreviousLogInfo
140 {
141 PreviousLogInfo()
142 {
143 numRepeated = 0;
144 }
145
146
147 // previous message itself
148 wxString msg;
149
150 // its level
151 wxLogLevel level;
152
153 // other information about it
154 wxLogRecordInfo info;
155
156 // the number of times it was already repeated
157 unsigned numRepeated;
158 };
159
160 PreviousLogInfo gs_prevLog;
161
162
163 // map containing all components for which log level was explicitly set
164 //
165 // NB: all accesses to it must be protected by GetLevelsCS() critical section
166 WX_DEFINE_GLOBAL_VAR(wxStringToNumHashMap, ComponentLevels);
167
168 // ----------------------------------------------------------------------------
169 // wxLogOutputBest: wxLog wrapper around wxMessageOutputBest
170 // ----------------------------------------------------------------------------
171
172 class wxLogOutputBest : public wxLog
173 {
174 public:
175 wxLogOutputBest() { }
176
177 protected:
178 virtual void DoLogText(const wxString& msg)
179 {
180 wxMessageOutputBest().Output(msg);
181 }
182
183 private:
184 wxDECLARE_NO_COPY_CLASS(wxLogOutputBest);
185 };
186
187 } // anonymous namespace
188
189 // ============================================================================
190 // implementation
191 // ============================================================================
192
193 // ----------------------------------------------------------------------------
194 // helper global functions
195 // ----------------------------------------------------------------------------
196
197 void wxSafeShowMessage(const wxString& title, const wxString& text)
198 {
199 #ifdef __WINDOWS__
200 ::MessageBox(NULL, text.t_str(), title.t_str(), MB_OK | MB_ICONSTOP);
201 #else
202 wxFprintf(stderr, wxS("%s: %s\n"), title.c_str(), text.c_str());
203 fflush(stderr);
204 #endif
205 }
206
207 // ----------------------------------------------------------------------------
208 // wxLog class implementation
209 // ----------------------------------------------------------------------------
210
211 unsigned wxLog::LogLastRepeatIfNeeded()
212 {
213 const unsigned count = gs_prevLog.numRepeated;
214
215 if ( gs_prevLog.numRepeated )
216 {
217 wxString msg;
218 #if wxUSE_INTL
219 msg.Printf(wxPLURAL("The previous message repeated once.",
220 "The previous message repeated %lu times.",
221 gs_prevLog.numRepeated),
222 gs_prevLog.numRepeated);
223 #else
224 msg.Printf(wxS("The previous message was repeated %lu times."),
225 gs_prevLog.numRepeated);
226 #endif
227 gs_prevLog.numRepeated = 0;
228 gs_prevLog.msg.clear();
229 DoLogRecord(gs_prevLog.level, msg, gs_prevLog.info);
230 }
231
232 return count;
233 }
234
235 wxLog::~wxLog()
236 {
237 // Flush() must be called before destroying the object as otherwise some
238 // messages could be lost
239 if ( gs_prevLog.numRepeated )
240 {
241 wxMessageOutputDebug().Printf
242 (
243 wxS("Last repeated message (\"%s\", %lu times) wasn't output"),
244 gs_prevLog.msg,
245 gs_prevLog.numRepeated
246 );
247 }
248 }
249
250 // ----------------------------------------------------------------------------
251 // wxLog logging functions
252 // ----------------------------------------------------------------------------
253
254 /* static */
255 void
256 wxLog::OnLog(wxLogLevel level, const wxString& msg, time_t t)
257 {
258 wxLogRecordInfo info;
259 info.timestamp = t;
260 #if wxUSE_THREADS
261 info.threadId = wxThread::GetCurrentId();
262 #endif // wxUSE_THREADS
263
264 OnLog(level, msg, info);
265 }
266
267 /* static */
268 void
269 wxLog::OnLog(wxLogLevel level,
270 const wxString& msg,
271 const wxLogRecordInfo& info)
272 {
273 // fatal errors can't be suppressed nor handled by the custom log target
274 // and always terminate the program
275 if ( level == wxLOG_FatalError )
276 {
277 wxSafeShowMessage(wxS("Fatal Error"), msg);
278
279 #ifdef __WXWINCE__
280 ExitThread(3);
281 #else
282 abort();
283 #endif
284 }
285
286 wxLog *logger;
287
288 #if wxUSE_THREADS
289 if ( !wxThread::IsMain() )
290 {
291 logger = wxThreadInfo.logger;
292 if ( !logger )
293 {
294 if ( ms_pLogger )
295 {
296 // buffer the messages until they can be shown from the main
297 // thread
298 wxCriticalSectionLocker lock(GetBackgroundLogCS());
299
300 gs_bufferedLogRecords.push_back(wxLogRecord(level, msg, info));
301
302 // ensure that our Flush() will be called soon
303 wxWakeUpIdle();
304 }
305 //else: we don't have any logger at all, there is no need to log
306 // anything
307
308 return;
309 }
310 //else: we have a thread-specific logger, we can send messages to it
311 // directly
312 }
313 else
314 #endif // wxUSE_THREADS
315 {
316 logger = GetMainThreadActiveTarget();
317 if ( !logger )
318 return;
319 }
320
321 logger->CallDoLogNow(level, msg, info);
322 }
323
324 void
325 wxLog::CallDoLogNow(wxLogLevel level,
326 const wxString& msg,
327 const wxLogRecordInfo& info)
328 {
329 if ( GetRepetitionCounting() )
330 {
331 if ( msg == gs_prevLog.msg )
332 {
333 gs_prevLog.numRepeated++;
334
335 // nothing else to do, in particular, don't log the
336 // repeated message
337 return;
338 }
339
340 LogLastRepeatIfNeeded();
341
342 // reset repetition counter for a new message
343 gs_prevLog.msg = msg;
344 gs_prevLog.level = level;
345 gs_prevLog.info = info;
346 }
347
348 // handle extra data which may be passed to us by wxLogXXX()
349 wxString prefix, suffix;
350 wxUIntPtr num = 0;
351 if ( info.GetNumValue(wxLOG_KEY_SYS_ERROR_CODE, &num) )
352 {
353 const long err = static_cast<long>(num);
354
355 suffix.Printf(_(" (error %ld: %s)"), err, wxSysErrorMsg(err));
356 }
357
358 #if wxUSE_LOG_TRACE
359 wxString str;
360 if ( level == wxLOG_Trace && info.GetStrValue(wxLOG_KEY_TRACE_MASK, &str) )
361 {
362 prefix = "(" + str + ") ";
363 }
364 #endif // wxUSE_LOG_TRACE
365
366 DoLogRecord(level, prefix + msg + suffix, info);
367 }
368
369 void wxLog::DoLogRecord(wxLogLevel level,
370 const wxString& msg,
371 const wxLogRecordInfo& info)
372 {
373 #if WXWIN_COMPATIBILITY_2_8
374 // call the old DoLog() to ensure that existing custom log classes still
375 // work
376 //
377 // as the user code could have defined it as either taking "const char *"
378 // (in ANSI build) or "const wxChar *" (in ANSI/Unicode), we have no choice
379 // but to call both of them
380 DoLog(level, (const char*)msg.mb_str(), info.timestamp);
381 DoLog(level, (const wchar_t*)msg.wc_str(), info.timestamp);
382 #else // !WXWIN_COMPATIBILITY_2_8
383 wxUnusedVar(info);
384 #endif // WXWIN_COMPATIBILITY_2_8/!WXWIN_COMPATIBILITY_2_8
385
386
387 // TODO: it would be better to extract message formatting in a separate
388 // wxLogFormatter class but for now we hard code formatting here
389
390 wxString prefix;
391
392 // don't time stamp debug messages under MSW as debug viewers usually
393 // already have an option to do it
394 #ifdef __WXMSW__
395 if ( level != wxLOG_Debug && level != wxLOG_Trace )
396 #endif // __WXMSW__
397 TimeStamp(&prefix);
398
399 // TODO: use the other wxLogRecordInfo fields
400
401 switch ( level )
402 {
403 case wxLOG_Error:
404 prefix += _("Error: ");
405 break;
406
407 case wxLOG_Warning:
408 prefix += _("Warning: ");
409 break;
410
411 // don't prepend "debug/trace" prefix under MSW as it goes to the debug
412 // window anyhow and so can't be confused with something else
413 #ifndef __WXMSW__
414 case wxLOG_Debug:
415 // this prefix (as well as the one below) is intentionally not
416 // translated as nobody translates debug messages anyhow
417 prefix += "Debug: ";
418 break;
419
420 case wxLOG_Trace:
421 prefix += "Trace: ";
422 break;
423 #endif // !__WXMSW__
424 }
425
426 DoLogTextAtLevel(level, prefix + msg);
427 }
428
429 void wxLog::DoLogTextAtLevel(wxLogLevel level, const wxString& msg)
430 {
431 // we know about debug messages (because using wxMessageOutputDebug is the
432 // right thing to do in 99% of all cases and also for compatibility) but
433 // anything else needs to be handled in the derived class
434 if ( level == wxLOG_Debug || level == wxLOG_Trace )
435 {
436 wxMessageOutputDebug().Output(msg + wxS('\n'));
437 }
438 else
439 {
440 DoLogText(msg);
441 }
442 }
443
444 void wxLog::DoLogText(const wxString& WXUNUSED(msg))
445 {
446 // in 2.8-compatible build the derived class might override DoLog() or
447 // DoLogString() instead so we can't have this assert there
448 #if !WXWIN_COMPATIBILITY_2_8
449 wxFAIL_MSG( "must be overridden if it is called" );
450 #endif // WXWIN_COMPATIBILITY_2_8
451 }
452
453 #if WXWIN_COMPATIBILITY_2_8
454
455 void wxLog::DoLog(wxLogLevel WXUNUSED(level), const char *szString, time_t t)
456 {
457 DoLogString(szString, t);
458 }
459
460 void wxLog::DoLog(wxLogLevel WXUNUSED(level), const wchar_t *wzString, time_t t)
461 {
462 DoLogString(wzString, t);
463 }
464
465 #endif // WXWIN_COMPATIBILITY_2_8
466
467 // ----------------------------------------------------------------------------
468 // wxLog active target management
469 // ----------------------------------------------------------------------------
470
471 wxLog *wxLog::GetActiveTarget()
472 {
473 #if wxUSE_THREADS
474 if ( !wxThread::IsMain() )
475 {
476 // check if we have a thread-specific log target
477 wxLog * const logger = wxThreadInfo.logger;
478
479 // the code below should be only executed for the main thread as
480 // CreateLogTarget() is not meant for auto-creating log targets for
481 // worker threads so skip it in any case
482 return logger ? logger : ms_pLogger;
483 }
484 #endif // wxUSE_THREADS
485
486 return GetMainThreadActiveTarget();
487 }
488
489 /* static */
490 wxLog *wxLog::GetMainThreadActiveTarget()
491 {
492 if ( ms_bAutoCreate && ms_pLogger == NULL ) {
493 // prevent infinite recursion if someone calls wxLogXXX() from
494 // wxApp::CreateLogTarget()
495 static bool s_bInGetActiveTarget = false;
496 if ( !s_bInGetActiveTarget ) {
497 s_bInGetActiveTarget = true;
498
499 // ask the application to create a log target for us
500 if ( wxTheApp != NULL )
501 ms_pLogger = wxTheApp->GetTraits()->CreateLogTarget();
502 else
503 ms_pLogger = new wxLogOutputBest;
504
505 s_bInGetActiveTarget = false;
506
507 // do nothing if it fails - what can we do?
508 }
509 }
510
511 return ms_pLogger;
512 }
513
514 wxLog *wxLog::SetActiveTarget(wxLog *pLogger)
515 {
516 if ( ms_pLogger != NULL ) {
517 // flush the old messages before changing because otherwise they might
518 // get lost later if this target is not restored
519 ms_pLogger->Flush();
520 }
521
522 wxLog *pOldLogger = ms_pLogger;
523 ms_pLogger = pLogger;
524
525 return pOldLogger;
526 }
527
528 #if wxUSE_THREADS
529 /* static */
530 wxLog *wxLog::SetThreadActiveTarget(wxLog *logger)
531 {
532 wxASSERT_MSG( !wxThread::IsMain(), "use SetActiveTarget() for main thread" );
533
534 wxLog * const oldLogger = wxThreadInfo.logger;
535 if ( oldLogger )
536 oldLogger->Flush();
537
538 wxThreadInfo.logger = logger;
539
540 return oldLogger;
541 }
542 #endif // wxUSE_THREADS
543
544 void wxLog::DontCreateOnDemand()
545 {
546 ms_bAutoCreate = false;
547
548 // this is usually called at the end of the program and we assume that it
549 // is *always* called at the end - so we free memory here to avoid false
550 // memory leak reports from wxWin memory tracking code
551 ClearTraceMasks();
552 }
553
554 void wxLog::DoCreateOnDemand()
555 {
556 ms_bAutoCreate = true;
557 }
558
559 // ----------------------------------------------------------------------------
560 // wxLog components levels
561 // ----------------------------------------------------------------------------
562
563 /* static */
564 void wxLog::SetComponentLevel(const wxString& component, wxLogLevel level)
565 {
566 if ( component.empty() )
567 {
568 SetLogLevel(level);
569 }
570 else
571 {
572 wxCRIT_SECT_LOCKER(lock, GetLevelsCS());
573
574 GetComponentLevels()[component] = level;
575 }
576 }
577
578 /* static */
579 wxLogLevel wxLog::GetComponentLevel(wxString component)
580 {
581 wxCRIT_SECT_LOCKER(lock, GetLevelsCS());
582
583 const wxStringToNumHashMap& componentLevels = GetComponentLevels();
584 while ( !component.empty() )
585 {
586 wxStringToNumHashMap::const_iterator
587 it = componentLevels.find(component);
588 if ( it != componentLevels.end() )
589 return static_cast<wxLogLevel>(it->second);
590
591 component = component.BeforeLast('/');
592 }
593
594 return GetLogLevel();
595 }
596
597 // ----------------------------------------------------------------------------
598 // wxLog trace masks
599 // ----------------------------------------------------------------------------
600
601 void wxLog::AddTraceMask(const wxString& str)
602 {
603 wxCRIT_SECT_LOCKER(lock, GetTraceMaskCS());
604
605 ms_aTraceMasks.push_back(str);
606 }
607
608 void wxLog::RemoveTraceMask(const wxString& str)
609 {
610 wxCRIT_SECT_LOCKER(lock, GetTraceMaskCS());
611
612 int index = ms_aTraceMasks.Index(str);
613 if ( index != wxNOT_FOUND )
614 ms_aTraceMasks.RemoveAt((size_t)index);
615 }
616
617 void wxLog::ClearTraceMasks()
618 {
619 wxCRIT_SECT_LOCKER(lock, GetTraceMaskCS());
620
621 ms_aTraceMasks.Clear();
622 }
623
624 /*static*/ bool wxLog::IsAllowedTraceMask(const wxString& mask)
625 {
626 wxCRIT_SECT_LOCKER(lock, GetTraceMaskCS());
627
628 for ( wxArrayString::iterator it = ms_aTraceMasks.begin(),
629 en = ms_aTraceMasks.end();
630 it != en; ++it )
631 {
632 if ( *it == mask)
633 return true;
634 }
635
636 return false;
637 }
638
639 // ----------------------------------------------------------------------------
640 // wxLog miscellaneous other methods
641 // ----------------------------------------------------------------------------
642
643 void wxLog::TimeStamp(wxString *str)
644 {
645 #if wxUSE_DATETIME
646 if ( !ms_timestamp.empty() )
647 {
648 wxChar buf[256];
649 time_t timeNow;
650 (void)time(&timeNow);
651
652 struct tm tm;
653 wxStrftime(buf, WXSIZEOF(buf),
654 ms_timestamp, wxLocaltime_r(&timeNow, &tm));
655
656 str->Empty();
657 *str << buf << wxS(": ");
658 }
659 #endif // wxUSE_DATETIME
660 }
661
662 #if wxUSE_THREADS
663
664 void wxLog::FlushThreadMessages()
665 {
666 // check if we have queued messages from other threads
667 wxLogRecords bufferedLogRecords;
668
669 {
670 wxCriticalSectionLocker lock(GetBackgroundLogCS());
671 bufferedLogRecords.swap(gs_bufferedLogRecords);
672
673 // release the lock now to not keep it while we are logging the
674 // messages below, allowing background threads to run
675 }
676
677 if ( !bufferedLogRecords.empty() )
678 {
679 for ( wxLogRecords::const_iterator it = bufferedLogRecords.begin();
680 it != bufferedLogRecords.end();
681 ++it )
682 {
683 CallDoLogNow(it->level, it->msg, it->info);
684 }
685 }
686 }
687
688 /* static */
689 bool wxLog::IsThreadLoggingEnabled()
690 {
691 return !wxThreadInfo.loggingDisabled;
692 }
693
694 /* static */
695 bool wxLog::EnableThreadLogging(bool enable)
696 {
697 const bool wasEnabled = !wxThreadInfo.loggingDisabled;
698 wxThreadInfo.loggingDisabled = !enable;
699 return wasEnabled;
700 }
701
702 #endif // wxUSE_THREADS
703
704 void wxLog::Flush()
705 {
706 LogLastRepeatIfNeeded();
707 }
708
709 /* static */
710 void wxLog::FlushActive()
711 {
712 if ( ms_suspendCount )
713 return;
714
715 wxLog * const log = GetActiveTarget();
716 if ( log )
717 {
718 #if wxUSE_THREADS
719 if ( wxThread::IsMain() )
720 log->FlushThreadMessages();
721 #endif // wxUSE_THREADS
722
723 log->Flush();
724 }
725 }
726
727 // ----------------------------------------------------------------------------
728 // wxLogBuffer implementation
729 // ----------------------------------------------------------------------------
730
731 void wxLogBuffer::Flush()
732 {
733 wxLog::Flush();
734
735 if ( !m_str.empty() )
736 {
737 wxMessageOutputBest out;
738 out.Printf(wxS("%s"), m_str.c_str());
739 m_str.clear();
740 }
741 }
742
743 void wxLogBuffer::DoLogTextAtLevel(wxLogLevel level, const wxString& msg)
744 {
745 // don't put debug messages in the buffer, we don't want to show
746 // them to the user in a msg box, log them immediately
747 switch ( level )
748 {
749 case wxLOG_Debug:
750 case wxLOG_Trace:
751 wxLog::DoLogTextAtLevel(level, msg);
752 break;
753
754 default:
755 m_str << msg << wxS("\n");
756 }
757 }
758
759 // ----------------------------------------------------------------------------
760 // wxLogStderr class implementation
761 // ----------------------------------------------------------------------------
762
763 wxLogStderr::wxLogStderr(FILE *fp)
764 {
765 if ( fp == NULL )
766 m_fp = stderr;
767 else
768 m_fp = fp;
769 }
770
771 void wxLogStderr::DoLogText(const wxString& msg)
772 {
773 wxFputs(msg + '\n', m_fp);
774 fflush(m_fp);
775
776 // under GUI systems such as Windows or Mac, programs usually don't have
777 // stderr at all, so show the messages also somewhere else, typically in
778 // the debugger window so that they go at least somewhere instead of being
779 // simply lost
780 if ( m_fp == stderr )
781 {
782 wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
783 if ( traits && !traits->HasStderr() )
784 {
785 wxMessageOutputDebug().Output(msg + wxS('\n'));
786 }
787 }
788 }
789
790 // ----------------------------------------------------------------------------
791 // wxLogStream implementation
792 // ----------------------------------------------------------------------------
793
794 #if wxUSE_STD_IOSTREAM
795 #include "wx/ioswrap.h"
796 wxLogStream::wxLogStream(wxSTD ostream *ostr)
797 {
798 if ( ostr == NULL )
799 m_ostr = &wxSTD cerr;
800 else
801 m_ostr = ostr;
802 }
803
804 void wxLogStream::DoLogText(const wxString& msg)
805 {
806 (*m_ostr) << msg << wxSTD endl;
807 }
808 #endif // wxUSE_STD_IOSTREAM
809
810 // ----------------------------------------------------------------------------
811 // wxLogChain
812 // ----------------------------------------------------------------------------
813
814 wxLogChain::wxLogChain(wxLog *logger)
815 {
816 m_bPassMessages = true;
817
818 m_logNew = logger;
819 m_logOld = wxLog::SetActiveTarget(this);
820 }
821
822 wxLogChain::~wxLogChain()
823 {
824 delete m_logOld;
825
826 if ( m_logNew != this )
827 delete m_logNew;
828 }
829
830 void wxLogChain::SetLog(wxLog *logger)
831 {
832 if ( m_logNew != this )
833 delete m_logNew;
834
835 m_logNew = logger;
836 }
837
838 void wxLogChain::Flush()
839 {
840 if ( m_logOld )
841 m_logOld->Flush();
842
843 // be careful to avoid infinite recursion
844 if ( m_logNew && m_logNew != this )
845 m_logNew->Flush();
846 }
847
848 void wxLogChain::DoLogRecord(wxLogLevel level,
849 const wxString& msg,
850 const wxLogRecordInfo& info)
851 {
852 // let the previous logger show it
853 if ( m_logOld && IsPassingMessages() )
854 m_logOld->LogRecord(level, msg, info);
855
856 // and also send it to the new one
857 if ( m_logNew )
858 {
859 // don't call m_logNew->LogRecord() to avoid infinite recursion when
860 // m_logNew is this object itself
861 if ( m_logNew != this )
862 m_logNew->LogRecord(level, msg, info);
863 else
864 wxLog::DoLogRecord(level, msg, info);
865 }
866 }
867
868 #ifdef __VISUALC__
869 // "'this' : used in base member initializer list" - so what?
870 #pragma warning(disable:4355)
871 #endif // VC++
872
873 // ----------------------------------------------------------------------------
874 // wxLogInterposer
875 // ----------------------------------------------------------------------------
876
877 wxLogInterposer::wxLogInterposer()
878 : wxLogChain(this)
879 {
880 }
881
882 // ----------------------------------------------------------------------------
883 // wxLogInterposerTemp
884 // ----------------------------------------------------------------------------
885
886 wxLogInterposerTemp::wxLogInterposerTemp()
887 : wxLogChain(this)
888 {
889 DetachOldLog();
890 }
891
892 #ifdef __VISUALC__
893 #pragma warning(default:4355)
894 #endif // VC++
895
896 // ============================================================================
897 // Global functions/variables
898 // ============================================================================
899
900 // ----------------------------------------------------------------------------
901 // static variables
902 // ----------------------------------------------------------------------------
903
904 bool wxLog::ms_bRepetCounting = false;
905
906 wxLog *wxLog::ms_pLogger = NULL;
907 bool wxLog::ms_doLog = true;
908 bool wxLog::ms_bAutoCreate = true;
909 bool wxLog::ms_bVerbose = false;
910
911 wxLogLevel wxLog::ms_logLevel = wxLOG_Max; // log everything by default
912
913 size_t wxLog::ms_suspendCount = 0;
914
915 wxString wxLog::ms_timestamp(wxS("%X")); // time only, no date
916
917 #if WXWIN_COMPATIBILITY_2_8
918 wxTraceMask wxLog::ms_ulTraceMask = (wxTraceMask)0;
919 #endif // wxDEBUG_LEVEL
920
921 wxArrayString wxLog::ms_aTraceMasks;
922
923 // ----------------------------------------------------------------------------
924 // stdout error logging helper
925 // ----------------------------------------------------------------------------
926
927 // helper function: wraps the message and justifies it under given position
928 // (looks more pretty on the terminal). Also adds newline at the end.
929 //
930 // TODO this is now disabled until I find a portable way of determining the
931 // terminal window size (ok, I found it but does anybody really cares?)
932 #ifdef LOG_PRETTY_WRAP
933 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz)
934 {
935 size_t nMax = 80; // FIXME
936 size_t nStart = strlen(pszPrefix);
937 fputs(pszPrefix, f);
938
939 size_t n;
940 while ( *psz != '\0' ) {
941 for ( n = nStart; (n < nMax) && (*psz != '\0'); n++ )
942 putc(*psz++, f);
943
944 // wrapped?
945 if ( *psz != '\0' ) {
946 /*putc('\n', f);*/
947 for ( n = 0; n < nStart; n++ )
948 putc(' ', f);
949
950 // as we wrapped, squeeze all white space
951 while ( isspace(*psz) )
952 psz++;
953 }
954 }
955
956 putc('\n', f);
957 }
958 #endif //LOG_PRETTY_WRAP
959
960 // ----------------------------------------------------------------------------
961 // error code/error message retrieval functions
962 // ----------------------------------------------------------------------------
963
964 // get error code from syste
965 unsigned long wxSysErrorCode()
966 {
967 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
968 return ::GetLastError();
969 #else //Unix
970 return errno;
971 #endif //Win/Unix
972 }
973
974 // get error message from system
975 const wxChar *wxSysErrorMsg(unsigned long nErrCode)
976 {
977 if ( nErrCode == 0 )
978 nErrCode = wxSysErrorCode();
979
980 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
981 static wxChar s_szBuf[1024];
982
983 // get error message from system
984 LPVOID lpMsgBuf;
985 if ( ::FormatMessage
986 (
987 FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
988 NULL,
989 nErrCode,
990 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
991 (LPTSTR)&lpMsgBuf,
992 0,
993 NULL
994 ) == 0 )
995 {
996 // if this happens, something is seriously wrong, so don't use _() here
997 // for safety
998 wxSprintf(s_szBuf, wxS("unknown error %lx"), nErrCode);
999 return s_szBuf;
1000 }
1001
1002
1003 // copy it to our buffer and free memory
1004 // Crashes on SmartPhone (FIXME)
1005 #if !defined(__SMARTPHONE__) /* of WinCE */
1006 if( lpMsgBuf != 0 )
1007 {
1008 wxStrlcpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf));
1009
1010 LocalFree(lpMsgBuf);
1011
1012 // returned string is capitalized and ended with '\r\n' - bad
1013 s_szBuf[0] = (wxChar)wxTolower(s_szBuf[0]);
1014 size_t len = wxStrlen(s_szBuf);
1015 if ( len > 0 ) {
1016 // truncate string
1017 if ( s_szBuf[len - 2] == wxS('\r') )
1018 s_szBuf[len - 2] = wxS('\0');
1019 }
1020 }
1021 else
1022 #endif // !__SMARTPHONE__
1023 {
1024 s_szBuf[0] = wxS('\0');
1025 }
1026
1027 return s_szBuf;
1028 #else // !__WXMSW__
1029 #if wxUSE_UNICODE
1030 static wchar_t s_wzBuf[1024];
1031 wxConvCurrent->MB2WC(s_wzBuf, strerror((int)nErrCode),
1032 WXSIZEOF(s_wzBuf) - 1);
1033 return s_wzBuf;
1034 #else
1035 return strerror((int)nErrCode);
1036 #endif
1037 #endif // __WXMSW__/!__WXMSW__
1038 }
1039
1040 #endif // wxUSE_LOG