1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Assorted wxLogXXX functions, and wxLog (sink for logs)
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
17 // ----------------------------------------------------------------------------
19 // ----------------------------------------------------------------------------
21 // NB: this is needed even if wxUSE_LOG == 0
22 typedef unsigned long wxLogLevel
;
24 // the trace masks have been superseded by symbolic trace constants, they're
25 // for compatibility only and will be removed soon - do NOT use them
26 #if WXWIN_COMPATIBILITY_2_8
27 #define wxTraceMemAlloc 0x0001 // trace memory allocation (new/delete)
28 #define wxTraceMessages 0x0002 // trace window messages/X callbacks
29 #define wxTraceResAlloc 0x0004 // trace GDI resource allocation
30 #define wxTraceRefCount 0x0008 // trace various ref counting operations
33 #define wxTraceOleCalls 0x0100 // OLE interface calls
36 typedef unsigned long wxTraceMask
;
37 #endif // WXWIN_COMPATIBILITY_2_8
39 // ----------------------------------------------------------------------------
41 // ----------------------------------------------------------------------------
43 #include "wx/string.h"
44 #include "wx/strvararg.h"
48 #include "wx/arrstr.h"
52 #include <time.h> // for time_t
54 #endif // ! __WXPALMOS5__
56 #include "wx/dynarray.h"
57 #include "wx/hashmap.h"
60 #include "wx/thread.h"
61 #endif // wxUSE_THREADS
63 // wxUSE_LOG_DEBUG enables the debug log messages
64 #ifndef wxUSE_LOG_DEBUG
66 #define wxUSE_LOG_DEBUG 1
67 #else // !wxDEBUG_LEVEL
68 #define wxUSE_LOG_DEBUG 0
72 // wxUSE_LOG_TRACE enables the trace messages, they are disabled by default
73 #ifndef wxUSE_LOG_TRACE
75 #define wxUSE_LOG_TRACE 1
76 #else // !wxDEBUG_LEVEL
77 #define wxUSE_LOG_TRACE 0
79 #endif // wxUSE_LOG_TRACE
81 // wxLOG_COMPONENT identifies the component which generated the log record and
82 // can be #define'd to a user-defined value when compiling the user code to use
83 // component-based filtering (see wxLog::SetComponentLevel())
84 #ifndef wxLOG_COMPONENT
85 // this is a variable and not a macro in order to allow the user code to
86 // just #define wxLOG_COMPONENT without #undef'ining it first
87 extern WXDLLIMPEXP_DATA_BASE(const char *) wxLOG_COMPONENT
;
90 #define wxLOG_COMPONENT "wx"
94 // ----------------------------------------------------------------------------
95 // forward declarations
96 // ----------------------------------------------------------------------------
98 class WXDLLIMPEXP_FWD_BASE wxObject
;
101 class WXDLLIMPEXP_FWD_CORE wxFrame
;
104 // ----------------------------------------------------------------------------
106 // ----------------------------------------------------------------------------
108 // different standard log levels (you may also define your own)
109 enum wxLogLevelValues
111 wxLOG_FatalError
, // program can't continue, abort immediately
112 wxLOG_Error
, // a serious error, user must be informed about it
113 wxLOG_Warning
, // user is normally informed about it but may be ignored
114 wxLOG_Message
, // normal message (i.e. normal output of a non GUI app)
115 wxLOG_Status
, // informational: might go to the status line of GUI app
116 wxLOG_Info
, // informational message (a.k.a. 'Verbose')
117 wxLOG_Debug
, // never shown to the user, disabled in release mode
118 wxLOG_Trace
, // trace messages are also only enabled in debug mode
119 wxLOG_Progress
, // used for progress indicator (not yet)
120 wxLOG_User
= 100, // user defined levels start here
124 // symbolic trace masks - wxLogTrace("foo", "some trace message...") will be
125 // discarded unless the string "foo" has been added to the list of allowed
126 // ones with AddTraceMask()
128 #define wxTRACE_MemAlloc wxT("memalloc") // trace memory allocation (new/delete)
129 #define wxTRACE_Messages wxT("messages") // trace window messages/X callbacks
130 #define wxTRACE_ResAlloc wxT("resalloc") // trace GDI resource allocation
131 #define wxTRACE_RefCount wxT("refcount") // trace various ref counting operations
134 #define wxTRACE_OleCalls wxT("ole") // OLE interface calls
137 #include "wx/iosfwrap.h"
139 // ----------------------------------------------------------------------------
140 // information about a log record, i.e. unit of log output
141 // ----------------------------------------------------------------------------
143 class wxLogRecordInfo
146 // default ctor creates an uninitialized object
149 memset(this, 0, sizeof(*this));
152 // normal ctor, used by wxLogger specifies the location of the log
153 // statement; its time stamp and thread id are set up here
154 wxLogRecordInfo(const char *filename_
,
157 const char *component_
)
159 filename
= filename_
;
162 component
= component_
;
164 timestamp
= time(NULL
);
167 threadId
= wxThread::GetCurrentId();
168 #endif // wxUSE_THREADS
173 // we need to define copy ctor and assignment operator because of m_data
174 wxLogRecordInfo(const wxLogRecordInfo
& other
)
179 wxLogRecordInfo
& operator=(const wxLogRecordInfo
& other
)
181 if ( &other
!= this )
190 // dtor is non-virtual, this class is not meant to be derived from
197 // the file name and line number of the file where the log record was
198 // generated, if available or NULL and 0 otherwise
199 const char *filename
;
202 // the name of the function where the log record was generated (may be NULL
203 // if the compiler doesn't support __FUNCTION__)
206 // the name of the component which generated this message, may be NULL if
207 // not set (i.e. wxLOG_COMPONENT not defined)
208 const char *component
;
210 // time of record generation
214 // id of the thread which logged this record
215 wxThreadIdType threadId
;
216 #endif // wxUSE_THREADS
219 // store an arbitrary value in this record context
221 // wxWidgets always uses keys starting with "wx.", e.g. "wx.sys_error"
222 void StoreValue(const wxString
& key
, wxUIntPtr val
)
225 m_data
= new ExtraData
;
227 m_data
->numValues
[key
] = val
;
230 void StoreValue(const wxString
& key
, const wxString
& val
)
233 m_data
= new ExtraData
;
235 m_data
->strValues
[key
] = val
;
239 // these functions retrieve the value of either numeric or string key,
240 // return false if not found
241 bool GetNumValue(const wxString
& key
, wxUIntPtr
*val
) const
246 wxStringToNumHashMap::const_iterator it
= m_data
->numValues
.find(key
);
247 if ( it
== m_data
->numValues
.end() )
255 bool GetStrValue(const wxString
& key
, wxString
*val
) const
260 wxStringToStringHashMap::const_iterator it
= m_data
->strValues
.find(key
);
261 if ( it
== m_data
->strValues
.end() )
270 void Copy(const wxLogRecordInfo
& other
)
272 memcpy(this, &other
, sizeof(*this));
274 m_data
= new ExtraData(*other
.m_data
);
277 // extra data associated with the log record: this is completely optional
278 // and can be used to pass information from the log function to the log
279 // sink (e.g. wxLogSysError() uses this to pass the error code)
282 wxStringToNumHashMap numValues
;
283 wxStringToStringHashMap strValues
;
290 #define wxLOG_KEY_TRACE_MASK "wx.trace_mask"
292 // ----------------------------------------------------------------------------
293 // log record: a unit of log output
294 // ----------------------------------------------------------------------------
298 wxLogRecord(wxLogLevel level_
,
299 const wxString
& msg_
,
300 const wxLogRecordInfo
& info_
)
309 wxLogRecordInfo info
;
312 // ----------------------------------------------------------------------------
313 // derive from this class to redirect (or suppress, or ...) log messages
314 // normally, only a single instance of this class exists but it's not enforced
315 // ----------------------------------------------------------------------------
317 class WXDLLIMPEXP_BASE wxLog
323 // make dtor virtual for all derived classes
327 // log messages selection
328 // ----------------------
330 // these functions allow to completely disable all log messages or disable
331 // log messages at level less important than specified
333 // is logging enabled at all now?
334 static bool IsEnabled() { return ms_doLog
; }
336 // change the flag state, return the previous one
337 static bool EnableLogging(bool doIt
= true)
338 { bool doLogOld
= ms_doLog
; ms_doLog
= doIt
; return doLogOld
; }
341 // return the current global log level
342 static wxLogLevel
GetLogLevel() { return ms_logLevel
; }
344 // set global log level: messages with level > logLevel will not be logged
345 static void SetLogLevel(wxLogLevel logLevel
) { ms_logLevel
= logLevel
; }
347 // set the log level for the given component
348 static void SetComponentLevel(const wxString
& component
, wxLogLevel level
);
350 // return the effective log level for this component, falling back to
351 // parent component and to the default global log level if necessary
353 // NB: component argument is passed by value and not const reference in an
354 // attempt to encourage compiler to avoid an extra copy: as we modify
355 // the component internally, we'd create one anyhow and like this it
356 // can be avoided if the string is a temporary anyhow
357 static wxLogLevel
GetComponentLevel(wxString component
);
360 // is logging of messages from this component enabled at this level?
362 // usually always called with wxLOG_COMPONENT as second argument
363 static bool IsLevelEnabled(wxLogLevel level
, wxString component
)
365 return IsEnabled() && level
<= GetComponentLevel(component
);
369 // enable/disable messages at wxLOG_Verbose level (only relevant if the
370 // current log level is greater or equal to it)
372 // notice that verbose mode can be activated by the standard command-line
373 // '--verbose' option
374 static void SetVerbose(bool bVerbose
= true) { ms_bVerbose
= bVerbose
; }
376 // check if verbose messages are enabled
377 static bool GetVerbose() { return ms_bVerbose
; }
383 // flush shows all messages if they're not logged immediately (FILE
384 // and iostream logs don't need it, but wxGuiLog does to avoid showing
385 // 17 modal dialogs one after another)
386 virtual void Flush();
388 // flush the active target if any
389 static void FlushActive()
391 if ( !ms_suspendCount
)
393 wxLog
*log
= GetActiveTarget();
399 // only one sink is active at each moment
400 // get current log target, will call wxApp::CreateLogTarget() to
401 // create one if none exists
402 static wxLog
*GetActiveTarget();
404 // change log target, pLogger may be NULL
405 static wxLog
*SetActiveTarget(wxLog
*pLogger
);
407 // suspend the message flushing of the main target until the next call
408 // to Resume() - this is mainly for internal use (to prevent wxYield()
409 // from flashing the messages)
410 static void Suspend() { ms_suspendCount
++; }
412 // must be called for each Suspend()!
413 static void Resume() { ms_suspendCount
--; }
415 // should GetActiveTarget() try to create a new log object if the
417 static void DontCreateOnDemand();
419 // Make GetActiveTarget() create a new log object again.
420 static void DoCreateOnDemand();
422 // log the count of repeating messages instead of logging the messages
424 static void SetRepetitionCounting(bool bRepetCounting
= true)
425 { ms_bRepetCounting
= bRepetCounting
; }
427 // gets duplicate counting status
428 static bool GetRepetitionCounting() { return ms_bRepetCounting
; }
430 // add string trace mask
431 static void AddTraceMask(const wxString
& str
);
433 // add string trace mask
434 static void RemoveTraceMask(const wxString
& str
);
436 // remove all string trace masks
437 static void ClearTraceMasks();
439 // get string trace masks: note that this is MT-unsafe if other threads can
440 // call AddTraceMask() concurrently
441 static const wxArrayString
& GetTraceMasks() { return ms_aTraceMasks
; }
443 // sets the time stamp string format: this is used as strftime() format
444 // string for the log targets which add time stamps to the messages; set
445 // it to empty string to disable time stamping completely.
446 static void SetTimestamp(const wxString
& ts
) { ms_timestamp
= ts
; }
448 // disable time stamping of log messages
449 static void DisableTimestamp() { SetTimestamp(wxEmptyString
); }
452 // is this trace mask in the list?
453 static bool IsAllowedTraceMask(const wxString
& mask
);
455 // get the current timestamp format string (maybe empty)
456 static const wxString
& GetTimestamp() { return ms_timestamp
; }
460 // helpers: all functions in this section are mostly for internal use only,
461 // don't call them from your code even if they are not formally deprecated
463 // put the time stamp into the string if ms_timestamp != NULL (don't
464 // change it otherwise)
465 static void TimeStamp(wxString
*str
);
467 // these methods should only be called from derived classes DoLogRecord(),
468 // DoLogTextAtLevel() and DoLogText() implementations respectively and
469 // shouldn't be called directly, use logging functions instead
470 void LogRecord(wxLogLevel level
,
472 const wxLogRecordInfo
& info
)
474 DoLogRecord(level
, msg
, info
);
477 void LogTextAtLevel(wxLogLevel level
, const wxString
& msg
)
479 DoLogTextAtLevel(level
, msg
);
482 void LogText(const wxString
& msg
)
487 // this is a helper used by wxLogXXX() functions, don't call it directly
488 // and see DoLog() for function to overload in the derived classes
489 static void OnLog(wxLogLevel level
,
491 const wxLogRecordInfo
& info
);
493 // version called when no information about the location of the log record
494 // generation is available (but the time stamp is), it mainly exists for
495 // backwards compatibility, don't use it in new code
496 static void OnLog(wxLogLevel level
, const wxString
& msg
, time_t t
);
498 // a helper calling the above overload with current time
499 static void OnLog(wxLogLevel level
, const wxString
& msg
)
501 OnLog(level
, msg
, time(NULL
));
505 // this method exists for backwards compatibility only, don't use
506 bool HasPendingMessages() const { return true; }
508 #if WXWIN_COMPATIBILITY_2_6
509 // this function doesn't do anything any more, don't call it
511 static wxChar
*SetLogBuffer(wxChar
*, size_t = 0), return NULL
;
513 #endif // WXWIN_COMPATIBILITY_2_6
515 // don't use integer masks any more, use string trace masks instead
516 #if WXWIN_COMPATIBILITY_2_8
517 wxDEPRECATED_INLINE( static void SetTraceMask(wxTraceMask ulMask
),
518 ms_ulTraceMask
= ulMask
; )
520 // this one can't be marked deprecated as it's used in our own wxLogger
521 // below but it still is deprecated and shouldn't be used
522 static wxTraceMask
GetTraceMask() { return ms_ulTraceMask
; }
523 #endif // WXWIN_COMPATIBILITY_2_8
526 // the logging functions that can be overridden: DoLogRecord() is called
527 // for every "record", i.e. a unit of log output, to be logged and by
528 // default formats the message and passes it to DoLogTextAtLevel() which in
529 // turn passes it to DoLogText() by default
531 // override this method if you want to change message formatting or do
533 virtual void DoLogRecord(wxLogLevel level
,
535 const wxLogRecordInfo
& info
);
537 // override this method to redirect output to different channels depending
538 // on its level only; if even the level doesn't matter, override
539 // DoLogText() instead
540 virtual void DoLogTextAtLevel(wxLogLevel level
, const wxString
& msg
);
542 // this function is not pure virtual as it might not be needed if you do
543 // the logging in overridden DoLogRecord() or DoLogTextAtLevel() directly
544 // but if you do not override them in your derived class you must override
545 // this one as the default implementation of it simply asserts
546 virtual void DoLogText(const wxString
& msg
);
549 // the rest of the functions are for backwards compatibility only, don't
550 // use them in new code; if you're updating your existing code you need to
551 // switch to overriding DoLogRecord/Text() above (although as long as these
552 // functions exist, log classes using them will continue to work)
553 #if WXWIN_COMPATIBILITY_2_8
554 wxDEPRECATED_BUT_USED_INTERNALLY(
555 virtual void DoLog(wxLogLevel level
, const char *szString
, time_t t
)
558 wxDEPRECATED_BUT_USED_INTERNALLY(
559 virtual void DoLog(wxLogLevel level
, const wchar_t *wzString
, time_t t
)
562 // these shouldn't be used by new code
563 wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(
564 virtual void DoLogString(const char *WXUNUSED(szString
),
566 wxEMPTY_PARAMETER_VALUE
569 wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(
570 virtual void DoLogString(const wchar_t *WXUNUSED(wzString
),
572 wxEMPTY_PARAMETER_VALUE
574 #endif // WXWIN_COMPATIBILITY_2_8
577 // log a message indicating the number of times the previous message was
578 // repeated if previous repetition counter is strictly positive, does
579 // nothing otherwise; return the old value of repetition counter
580 unsigned LogLastRepeatIfNeeded();
583 // implement of LogLastRepeatIfNeeded(): it assumes that the
584 // caller had already locked GetPreviousLogCS()
585 unsigned LogLastRepeatIfNeededUnlocked();
587 // called from OnLog() if it's called from the main thread and from Flush()
588 // when it plays back the buffered messages logged from the other threads
589 void OnLogInMainThread(wxLogLevel level
,
591 const wxLogRecordInfo
& info
);
597 // if true, don't log the same message multiple times, only log it once
598 // with the number of times it was repeated
599 static bool ms_bRepetCounting
;
601 static wxLog
*ms_pLogger
; // currently active log sink
602 static bool ms_doLog
; // false => all logging disabled
603 static bool ms_bAutoCreate
; // create new log targets on demand?
604 static bool ms_bVerbose
; // false => ignore LogInfo messages
606 static wxLogLevel ms_logLevel
; // limit logging to levels <= ms_logLevel
608 static size_t ms_suspendCount
; // if positive, logs are not flushed
610 // format string for strftime(), if empty, time stamping log messages is
612 static wxString ms_timestamp
;
614 #if WXWIN_COMPATIBILITY_2_8
615 static wxTraceMask ms_ulTraceMask
; // controls wxLogTrace behaviour
616 #endif // WXWIN_COMPATIBILITY_2_8
618 // currently enabled trace masks
619 static wxArrayString ms_aTraceMasks
;
622 // ----------------------------------------------------------------------------
623 // "trivial" derivations of wxLog
624 // ----------------------------------------------------------------------------
626 // log everything except for the debug/trace messages (which are passed to
627 // wxMessageOutputDebug) to a buffer
628 class WXDLLIMPEXP_BASE wxLogBuffer
: public wxLog
633 // get the string contents with all messages logged
634 const wxString
& GetBuffer() const { return m_str
; }
636 // show the buffer contents to the user in the best possible way (this uses
637 // wxMessageOutputMessageBox) and clear it
638 virtual void Flush();
641 virtual void DoLogTextAtLevel(wxLogLevel level
, const wxString
& msg
);
646 wxDECLARE_NO_COPY_CLASS(wxLogBuffer
);
650 // log everything to a "FILE *", stderr by default
651 class WXDLLIMPEXP_BASE wxLogStderr
: public wxLog
654 // redirect log output to a FILE
655 wxLogStderr(FILE *fp
= NULL
);
658 // implement sink function
659 virtual void DoLogText(const wxString
& msg
);
663 wxDECLARE_NO_COPY_CLASS(wxLogStderr
);
666 #if wxUSE_STD_IOSTREAM
668 // log everything to an "ostream", cerr by default
669 class WXDLLIMPEXP_BASE wxLogStream
: public wxLog
672 // redirect log output to an ostream
673 wxLogStream(wxSTD ostream
*ostr
= (wxSTD ostream
*) NULL
);
676 // implement sink function
677 virtual void DoLogText(const wxString
& msg
);
679 // using ptr here to avoid including <iostream.h> from this file
680 wxSTD ostream
*m_ostr
;
683 #endif // wxUSE_STD_IOSTREAM
685 // ----------------------------------------------------------------------------
686 // /dev/null log target: suppress logging until this object goes out of scope
687 // ----------------------------------------------------------------------------
695 // wxFile.Open() normally complains if file can't be opened, we don't
699 if ( !file.Open("bar") )
700 ... process error ourselves ...
702 // ~wxLogNull called, old log sink restored
705 class WXDLLIMPEXP_BASE wxLogNull
708 wxLogNull() : m_flagOld(wxLog::EnableLogging(false)) { }
709 ~wxLogNull() { (void)wxLog::EnableLogging(m_flagOld
); }
712 bool m_flagOld
; // the previous value of the wxLog::ms_doLog
715 // ----------------------------------------------------------------------------
716 // chaining log target: installs itself as a log target and passes all
717 // messages to the real log target given to it in the ctor but also forwards
718 // them to the previously active one
720 // note that you don't have to call SetActiveTarget() with this class, it
721 // does it itself in its ctor
722 // ----------------------------------------------------------------------------
724 class WXDLLIMPEXP_BASE wxLogChain
: public wxLog
727 wxLogChain(wxLog
*logger
);
728 virtual ~wxLogChain();
730 // change the new log target
731 void SetLog(wxLog
*logger
);
733 // this can be used to temporarily disable (and then reenable) passing
734 // messages to the old logger (by default we do pass them)
735 void PassMessages(bool bDoPass
) { m_bPassMessages
= bDoPass
; }
737 // are we passing the messages to the previous log target?
738 bool IsPassingMessages() const { return m_bPassMessages
; }
740 // return the previous log target (may be NULL)
741 wxLog
*GetOldLog() const { return m_logOld
; }
743 // override base class version to flush the old logger as well
744 virtual void Flush();
746 // call to avoid destroying the old log target
747 void DetachOldLog() { m_logOld
= NULL
; }
750 // pass the record to the old logger if needed
751 virtual void DoLogRecord(wxLogLevel level
,
753 const wxLogRecordInfo
& info
);
756 // the current log target
759 // the previous log target
762 // do we pass the messages to the old logger?
763 bool m_bPassMessages
;
765 wxDECLARE_NO_COPY_CLASS(wxLogChain
);
768 // a chain log target which uses itself as the new logger
770 #define wxLogPassThrough wxLogInterposer
772 class WXDLLIMPEXP_BASE wxLogInterposer
: public wxLogChain
778 wxDECLARE_NO_COPY_CLASS(wxLogInterposer
);
781 // a temporary interposer which doesn't destroy the old log target
782 // (calls DetachOldLog)
784 class WXDLLIMPEXP_BASE wxLogInterposerTemp
: public wxLogChain
787 wxLogInterposerTemp();
790 wxDECLARE_NO_COPY_CLASS(wxLogInterposerTemp
);
794 // include GUI log targets:
795 #include "wx/generic/logg.h"
798 // ----------------------------------------------------------------------------
800 // ----------------------------------------------------------------------------
802 // wxLogger is a helper class used by wxLogXXX() functions implementation,
803 // don't use it directly as it's experimental and subject to change (OTOH it
804 // might become public in the future if it's deemed to be useful enough)
806 // contains information about the context from which a log message originates
807 // and provides Log() vararg method which forwards to wxLog::OnLog() and passes
808 // this context to it
812 // ctor takes the basic information about the log record
813 wxLogger(wxLogLevel level
,
814 const char *filename
,
817 const char *component
)
819 m_info(filename
, line
, func
, component
)
823 // store extra data in our log record and return this object itself (so
824 // that further calls to its functions could be chained)
825 template <typename T
>
826 wxLogger
& Store(const wxString
& key
, T val
)
828 m_info
.StoreValue(key
, val
);
832 // hack for "overloaded" wxLogXXX() functions: calling this method
833 // indicates that we may have an extra first argument preceding the format
834 // string and that if we do have it, we should store it in m_info using the
835 // given key (while by default 0 value will be used)
836 wxLogger
& MaybeStore(const wxString
& key
)
838 wxASSERT_MSG( m_optKey
.empty(), "can only have one optional value" );
841 m_info
.StoreValue(key
, 0);
846 // non-vararg function used by wxVLogXXX():
848 // log the message at the level specified in the ctor if this log message
850 void LogV(const wxString
& format
, va_list argptr
)
852 // remember that fatal errors can't be disabled
853 if ( m_level
== wxLOG_FatalError
||
854 wxLog::IsLevelEnabled(m_level
, m_info
.component
) )
855 DoCallOnLog(format
, argptr
);
858 // overloads used by functions with optional leading arguments (whose
859 // values are stored in the key passed to MaybeStore())
860 void LogV(long num
, const wxString
& format
, va_list argptr
)
862 Store(m_optKey
, num
);
864 LogV(format
, argptr
);
867 void LogV(void *ptr
, const wxString
& format
, va_list argptr
)
869 Store(m_optKey
, wxPtrToUInt(ptr
));
871 LogV(format
, argptr
);
875 // vararg functions used by wxLogXXX():
877 // will log the message at the level specified in the ctor
879 // notice that this function supposes that the caller already checked that
880 // the level was enabled and does no checks itself
881 WX_DEFINE_VARARG_FUNC_VOID
884 1, (const wxFormatString
&),
888 // same as Log() but with an extra numeric or pointer parameters: this is
889 // used to pass an optional value by storing it in m_info under the name
890 // passed to MaybeStore() and is required to support "overloaded" versions
891 // of wxLogStatus() and wxLogSysError()
892 WX_DEFINE_VARARG_FUNC_VOID
895 2, (long, const wxFormatString
&),
896 DoLogWithNum
, DoLogWithNumUtf8
899 // unfortunately we can't use "void *" here as we get overload ambiguities
900 // with Log(wxFormatString, ...) when the first argument is a "char *" or
901 // "wchar_t *" then -- so we only allow passing wxObject here, which is
902 // ugly but fine in practice as this overload is only used by wxLogStatus()
903 // whose first argument is a wxFrame
904 WX_DEFINE_VARARG_FUNC_VOID
907 2, (wxObject
*, const wxFormatString
&),
908 DoLogWithPtr
, DoLogWithPtrUtf8
911 // log the message at the level specified as its first argument
913 // as the macros don't have access to the level argument in this case, this
914 // function does check that the level is enabled itself
915 WX_DEFINE_VARARG_FUNC_VOID
918 2, (wxLogLevel
, const wxFormatString
&),
919 DoLogAtLevel
, DoLogAtLevelUtf8
922 // special versions for wxLogTrace() which is passed either string or
923 // integer mask as first argument determining whether the message should be
925 WX_DEFINE_VARARG_FUNC_VOID
928 2, (const wxString
&, const wxFormatString
&),
929 DoLogTrace
, DoLogTraceUtf8
932 #if WXWIN_COMPATIBILITY_2_8
933 WX_DEFINE_VARARG_FUNC_VOID
936 2, (wxTraceMask
, const wxFormatString
&),
937 DoLogTraceMask
, DoLogTraceMaskUtf8
939 #endif // WXWIN_COMPATIBILITY_2_8
942 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
943 WX_VARARG_WATCOM_WORKAROUND(void, Log
,
944 1, (const wxString
&),
945 (wxFormatString(f1
)))
946 WX_VARARG_WATCOM_WORKAROUND(void, Log
,
947 1, (const wxCStrData
&),
948 (wxFormatString(f1
)))
949 WX_VARARG_WATCOM_WORKAROUND(void, Log
,
951 (wxFormatString(f1
)))
952 WX_VARARG_WATCOM_WORKAROUND(void, Log
,
954 (wxFormatString(f1
)))
956 WX_VARARG_WATCOM_WORKAROUND(void, Log
,
957 2, (long, const wxString
&),
958 (f1
, wxFormatString(f2
)))
959 WX_VARARG_WATCOM_WORKAROUND(void, Log
,
960 2, (long, const wxCStrData
&),
961 (f1
, wxFormatString(f2
)))
962 WX_VARARG_WATCOM_WORKAROUND(void, Log
,
963 2, (long, const char *),
964 (f1
, wxFormatString(f2
)))
965 WX_VARARG_WATCOM_WORKAROUND(void, Log
,
966 2, (long, const wchar_t *),
967 (f1
, wxFormatString(f2
)))
969 WX_VARARG_WATCOM_WORKAROUND(void, Log
,
970 2, (wxObject
*, const wxString
&),
971 (f1
, wxFormatString(f2
)))
972 WX_VARARG_WATCOM_WORKAROUND(void, Log
,
973 2, (wxObject
*, const wxCStrData
&),
974 (f1
, wxFormatString(f2
)))
975 WX_VARARG_WATCOM_WORKAROUND(void, Log
,
976 2, (wxObject
*, const char *),
977 (f1
, wxFormatString(f2
)))
978 WX_VARARG_WATCOM_WORKAROUND(void, Log
,
979 2, (wxObject
*, const wchar_t *),
980 (f1
, wxFormatString(f2
)))
982 WX_VARARG_WATCOM_WORKAROUND(void, LogAtLevel
,
983 2, (wxLogLevel
, const wxString
&),
984 (f1
, wxFormatString(f2
)))
985 WX_VARARG_WATCOM_WORKAROUND(void, LogAtLevel
,
986 2, (wxLogLevel
, const wxCStrData
&),
987 (f1
, wxFormatString(f2
)))
988 WX_VARARG_WATCOM_WORKAROUND(void, LogAtLevel
,
989 2, (wxLogLevel
, const char *),
990 (f1
, wxFormatString(f2
)))
991 WX_VARARG_WATCOM_WORKAROUND(void, LogAtLevel
,
992 2, (wxLogLevel
, const wchar_t *),
993 (f1
, wxFormatString(f2
)))
995 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace
,
996 2, (const wxString
&, const wxString
&),
997 (f1
, wxFormatString(f2
)))
998 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace
,
999 2, (const wxString
&, const wxCStrData
&),
1000 (f1
, wxFormatString(f2
)))
1001 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace
,
1002 2, (const wxString
&, const char *),
1003 (f1
, wxFormatString(f2
)))
1004 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace
,
1005 2, (const wxString
&, const wchar_t *),
1006 (f1
, wxFormatString(f2
)))
1008 #if WXWIN_COMPATIBILITY_2_8
1009 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace
,
1010 2, (wxTraceMask
, wxTraceMask
),
1011 (f1
, wxFormatString(f2
)))
1012 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace
,
1013 2, (wxTraceMask
, const wxCStrData
&),
1014 (f1
, wxFormatString(f2
)))
1015 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace
,
1016 2, (wxTraceMask
, const char *),
1017 (f1
, wxFormatString(f2
)))
1018 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace
,
1019 2, (wxTraceMask
, const wchar_t *),
1020 (f1
, wxFormatString(f2
)))
1021 #endif // WXWIN_COMPATIBILITY_2_8
1022 #endif // __WATCOMC__
1025 #if !wxUSE_UTF8_LOCALE_ONLY
1026 void DoLog(const wxChar
*format
, ...)
1029 va_start(argptr
, format
);
1030 DoCallOnLog(format
, argptr
);
1034 void DoLogWithNum(long num
, const wxChar
*format
, ...)
1036 Store(m_optKey
, num
);
1039 va_start(argptr
, format
);
1040 DoCallOnLog(format
, argptr
);
1044 void DoLogWithPtr(void *ptr
, const wxChar
*format
, ...)
1046 Store(m_optKey
, wxPtrToUInt(ptr
));
1049 va_start(argptr
, format
);
1050 DoCallOnLog(format
, argptr
);
1054 void DoLogAtLevel(wxLogLevel level
, const wxChar
*format
, ...)
1056 if ( !wxLog::IsLevelEnabled(level
, m_info
.component
) )
1060 va_start(argptr
, format
);
1061 DoCallOnLog(level
, format
, argptr
);
1065 void DoLogTrace(const wxString
& mask
, const wxChar
*format
, ...)
1067 if ( !wxLog::IsAllowedTraceMask(mask
) )
1070 Store(wxLOG_KEY_TRACE_MASK
, mask
);
1073 va_start(argptr
, format
);
1074 DoCallOnLog(format
, argptr
);
1078 #if WXWIN_COMPATIBILITY_2_8
1079 void DoLogTraceMask(wxTraceMask mask
, const wxChar
*format
, ...)
1081 if ( (wxLog::GetTraceMask() & mask
) != mask
)
1084 Store(wxLOG_KEY_TRACE_MASK
, mask
);
1087 va_start(argptr
, format
);
1088 DoCallOnLog(format
, argptr
);
1091 #endif // WXWIN_COMPATIBILITY_2_8
1092 #endif // !wxUSE_UTF8_LOCALE_ONLY
1094 #if wxUSE_UNICODE_UTF8
1095 void DoLogUtf8(const char *format
, ...)
1098 va_start(argptr
, format
);
1099 DoCallOnLog(format
, argptr
);
1103 void DoLogWithNumUtf8(long num
, const char *format
, ...)
1105 Store(m_optKey
, num
);
1108 va_start(argptr
, format
);
1109 DoCallOnLog(format
, argptr
);
1113 void DoLogWithPtrUtf8(void *ptr
, const char *format
, ...)
1115 Store(m_optKey
, wxPtrToUInt(ptr
));
1118 va_start(argptr
, format
);
1119 DoCallOnLog(format
, argptr
);
1123 void DoLogAtLevelUtf8(wxLogLevel level
, const char *format
, ...)
1125 if ( !wxLog::IsLevelEnabled(level
, m_info
.component
) )
1129 va_start(argptr
, format
);
1130 DoCallOnLog(level
, format
, argptr
);
1134 void DoLogTraceUtf8(const wxString
& mask
, const char *format
, ...)
1136 if ( !wxLog::IsAllowedTraceMask(mask
) )
1139 Store(wxLOG_KEY_TRACE_MASK
, mask
);
1142 va_start(argptr
, format
);
1143 DoCallOnLog(format
, argptr
);
1147 #if WXWIN_COMPATIBILITY_2_8
1148 void DoLogTraceMaskUtf8(wxTraceMask mask
, const char *format
, ...)
1150 if ( (wxLog::GetTraceMask() & mask
) != mask
)
1153 Store(wxLOG_KEY_TRACE_MASK
, mask
);
1156 va_start(argptr
, format
);
1157 DoCallOnLog(format
, argptr
);
1160 #endif // WXWIN_COMPATIBILITY_2_8
1161 #endif // wxUSE_UNICODE_UTF8
1163 void DoCallOnLog(wxLogLevel level
, const wxString
& format
, va_list argptr
)
1165 wxLog::OnLog(level
, wxString::FormatV(format
, argptr
), m_info
);
1168 void DoCallOnLog(const wxString
& format
, va_list argptr
)
1170 wxLog::OnLog(m_level
, wxString::FormatV(format
, argptr
), m_info
);
1174 const wxLogLevel m_level
;
1175 wxLogRecordInfo m_info
;
1179 wxDECLARE_NO_COPY_CLASS(wxLogger
);
1182 // ============================================================================
1184 // ============================================================================
1186 // ----------------------------------------------------------------------------
1187 // get error code/error message from system in a portable way
1188 // ----------------------------------------------------------------------------
1190 // return the last system error code
1191 WXDLLIMPEXP_BASE
unsigned long wxSysErrorCode();
1193 // return the error message for given (or last if 0) error code
1194 WXDLLIMPEXP_BASE
const wxChar
* wxSysErrorMsg(unsigned long nErrCode
= 0);
1196 // ----------------------------------------------------------------------------
1197 // define wxLog<level>() functions which can be used by application instead of
1198 // stdio, iostream &c for log messages for easy redirection
1199 // ----------------------------------------------------------------------------
1202 The code below is unreadable because it (unfortunately unavoidably)
1203 contains a lot of macro magic but all it does is to define wxLogXXX() such
1204 that you can call them as vararg functions to log a message at the
1205 corresponding level.
1207 More precisely, it defines:
1209 - wxLog{FatalError,Error,Warning,Message,Verbose,Debug}() functions
1210 taking the format string and additional vararg arguments if needed.
1211 - wxLogGeneric(wxLogLevel level, const wxString& format, ...) which
1212 takes the log level explicitly.
1213 - wxLogSysError(const wxString& format, ...) and wxLogSysError(long
1214 err, const wxString& format, ...) which log a wxLOG_Error severity
1215 message with the error message corresponding to the system error code
1216 err or the last error.
1217 - wxLogStatus(const wxString& format, ...) which logs the message into
1218 the status bar of the main application window and its overload
1219 wxLogStatus(wxFrame *frame, const wxString& format, ...) which logs it
1220 into the status bar of the specified frame.
1221 - wxLogTrace(Mask mask, const wxString& format, ...) which only logs
1222 the message is the specified mask is enabled. This comes in two kinds:
1223 Mask can be a wxString or a long. Both are deprecated.
1225 In addition, wxVLogXXX() versions of all the functions above are also
1226 defined. They take a va_list argument instead of "...".
1229 // creates wxLogger object for the current location
1230 #define wxMAKE_LOGGER(level) \
1231 wxLogger(wxLOG_##level, __FILE__, __LINE__, __WXFUNCTION__, wxLOG_COMPONENT)
1233 // this macro generates the expression which logs whatever follows it in
1234 // parentheses at the level specified as argument
1235 #define wxDO_LOG(level) wxMAKE_LOGGER(level).Log
1237 // this is the non-vararg equivalent
1238 #define wxDO_LOGV(level, format, argptr) \
1239 wxMAKE_LOGGER(level).LogV(format, argptr)
1241 // this macro declares wxLog<level>() macro which logs whatever follows it if
1242 // logging at specified level is enabled (notice that if it is false, the
1243 // following arguments are not even evaluated which is good as it avoids
1244 // unnecessary overhead)
1246 // Note: the strange if/else construct is needed to make the following code
1249 // wxLogError("!!!");
1253 // work as expected, without it the second "else" would match the "if"
1254 // inside wxLogError(). Unfortunately code like
1257 // wxLogError("!!!");
1259 // now provokes "suggest explicit braces to avoid ambiguous 'else'"
1260 // warnings from g++ 4.3 and later with -Wparentheses on but they can be
1261 // easily fixed by adding curly braces around wxLogError() and at least
1262 // the code still does do the right thing.
1263 #define wxDO_LOG_IF_ENABLED(level) \
1264 if ( !wxLog::IsLevelEnabled(wxLOG_##level, wxLOG_COMPONENT) ) \
1269 // wxLogFatalError() is special as it can't be disabled
1270 #define wxLogFatalError wxDO_LOG(FatalError)
1271 #define wxVLogFatalError(format, argptr) wxDO_LOGV(FatalError, format, argptr)
1273 #define wxLogError wxDO_LOG_IF_ENABLED(Error)
1274 #define wxVLogError(format, argptr) wxDO_LOGV(Error, format, argptr)
1276 #define wxLogWarning wxDO_LOG_IF_ENABLED(Warning)
1277 #define wxVLogWarning(format, argptr) wxDO_LOGV(Warning, format, argptr)
1279 #define wxLogMessage wxDO_LOG_IF_ENABLED(Message)
1280 #define wxVLogMessage(format, argptr) wxDO_LOGV(Message, format, argptr)
1282 // this one is special as it only logs if we're in verbose mode
1283 #define wxLogVerbose \
1284 if ( !(wxLog::IsLevelEnabled(wxLOG_Info, wxLOG_COMPONENT) && \
1285 wxLog::GetVerbose()) ) \
1289 #define wxVLogVerbose(format, argptr) \
1290 if ( !(wxLog::IsLevelEnabled(wxLOG_Info, wxLOG_COMPONENT) && \
1291 wxLog::GetVerbose()) ) \
1294 wxDO_LOGV(Info, format, argptr)
1296 // deprecated synonyms for wxLogVerbose() and wxVLogVerbose()
1297 #define wxLogInfo wxLogVerbose
1298 #define wxVLogInfo wxVLogVerbose
1301 // another special case: the level is passed as first argument of the function
1302 // and so is not available to the macro
1304 // notice that because of this, arguments of wxLogGeneric() are currently
1305 // always evaluated, unlike for the other log functions
1306 #define wxLogGeneric wxMAKE_LOGGER(Max).LogAtLevel
1307 #define wxVLogGeneric(level, format, argptr) \
1308 if ( !wxLog::IsLevelEnabled(wxLOG_##level, wxLOG_COMPONENT) ) \
1311 wxDO_LOGV(level, format, argptr)
1314 // wxLogSysError() needs to stash the error code value in the log record info
1315 // so it needs special handling too; additional complications arise because the
1316 // error code may or not be present as the first argument
1317 #define wxLOG_KEY_SYS_ERROR_CODE "wx.sys_error"
1319 #define wxLogSysError \
1320 if ( !wxLog::IsLevelEnabled(wxLOG_Error, wxLOG_COMPONENT) ) \
1323 wxMAKE_LOGGER(Error).MaybeStore(wxLOG_KEY_SYS_ERROR_CODE).Log
1325 // unfortunately we can't have overloaded macros so we can't define versions
1326 // both with and without error code argument and have to rely on LogV()
1327 // overloads in wxLogger to select between them
1328 #define wxVLogSysError \
1329 wxMAKE_LOGGER(Error).MaybeStore(wxLOG_KEY_SYS_ERROR_CODE).LogV
1332 // wxLogStatus() is similar to wxLogSysError() as it allows to optionally
1333 // specify the frame to which the message should go
1334 #define wxLOG_KEY_FRAME "wx.frame"
1336 #define wxLogStatus \
1337 if ( !wxLog::IsLevelEnabled(wxLOG_Status, wxLOG_COMPONENT) ) \
1340 wxMAKE_LOGGER(Status).MaybeStore(wxLOG_KEY_FRAME).Log
1342 #define wxVLogStatus(format, argptr) \
1343 wxMAKE_LOGGER(Status).MaybeStore(wxLOG_KEY_FRAME).LogV
1349 #undef wxUSE_LOG_DEBUG
1350 #define wxUSE_LOG_DEBUG 0
1352 #undef wxUSE_LOG_TRACE
1353 #define wxUSE_LOG_TRACE 0
1355 #if defined(__WATCOMC__) || defined(__MINGW32__)
1356 // Mingw has similar problem with wxLogSysError:
1357 #define WX_WATCOM_OR_MINGW_ONLY_CODE( x ) x
1359 #define WX_WATCOM_OR_MINGW_ONLY_CODE( x )
1362 // define macros for defining log functions which do nothing at all
1364 // WX_WATCOM_ONLY_CODE is needed to work around
1365 // http://bugzilla.openwatcom.org/show_bug.cgi?id=351
1366 #define wxDEFINE_EMPTY_LOG_FUNCTION(level) \
1367 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wxString&)) \
1368 WX_WATCOM_ONLY_CODE( \
1369 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const char*)) \
1370 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wchar_t*)) \
1371 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wxCStrData&)) \
1373 inline void wxVLog##level(const wxString& WXUNUSED(format), \
1374 va_list WXUNUSED(argptr)) { } \
1376 #define wxDEFINE_EMPTY_LOG_FUNCTION2(level, argclass) \
1377 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wxString&)) \
1378 WX_WATCOM_OR_MINGW_ONLY_CODE( \
1379 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const char*)) \
1380 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wchar_t*)) \
1381 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wxCStrData&)) \
1383 inline void wxVLog##level(argclass WXUNUSED(arg), \
1384 const wxString& WXUNUSED(format), \
1385 va_list WXUNUSED(argptr)) {}
1387 wxDEFINE_EMPTY_LOG_FUNCTION(FatalError
);
1388 wxDEFINE_EMPTY_LOG_FUNCTION(Error
);
1389 wxDEFINE_EMPTY_LOG_FUNCTION(SysError
);
1390 wxDEFINE_EMPTY_LOG_FUNCTION2(SysError
, long);
1391 wxDEFINE_EMPTY_LOG_FUNCTION(Warning
);
1392 wxDEFINE_EMPTY_LOG_FUNCTION(Message
);
1393 wxDEFINE_EMPTY_LOG_FUNCTION(Info
);
1394 wxDEFINE_EMPTY_LOG_FUNCTION(Verbose
);
1396 wxDEFINE_EMPTY_LOG_FUNCTION2(Generic
, wxLogLevel
);
1399 wxDEFINE_EMPTY_LOG_FUNCTION(Status
);
1400 wxDEFINE_EMPTY_LOG_FUNCTION2(Status
, wxFrame
*);
1403 // Empty Class to fake wxLogNull
1404 class WXDLLIMPEXP_BASE wxLogNull
1410 // Dummy macros to replace some functions.
1411 #define wxSysErrorCode() (unsigned long)0
1412 #define wxSysErrorMsg( X ) (const wxChar*)NULL
1414 // Fake symbolic trace masks... for those that are used frequently
1415 #define wxTRACE_OleCalls wxEmptyString // OLE interface calls
1417 #endif // wxUSE_LOG/!wxUSE_LOG
1420 // debug functions can be completely disabled in optimized builds
1422 // if these log functions are disabled, we prefer to define them as (empty)
1423 // variadic macros as this completely removes them and their argument
1424 // evaluation from the object code but if this is not supported by compiler we
1425 // use empty inline functions instead (defining them as nothing would result in
1426 // compiler warnings)
1428 // note that making wxVLogDebug/Trace() themselves (empty inline) functions is
1429 // a bad idea as some compilers are stupid enough to not inline even empty
1430 // functions if their parameters are complicated enough, but by defining them
1431 // as an empty inline function we ensure that even dumbest compilers optimise
1434 // but Borland gives "W8019: Code has no effect" for wxLogNop() so we need
1435 // to define it differently for it to avoid these warnings (same problem as
1436 // with wxUnusedVar())
1437 #define wxLogNop() { }
1439 inline void wxLogNop() { }
1443 #define wxLogDebug wxDO_LOG_IF_ENABLED(Debug)
1444 #define wxVLogDebug(format, argptr) wxDO_LOGV(Debug, format, argptr)
1445 #else // !wxUSE_LOG_DEBUG
1446 #define wxVLogDebug(fmt, valist) wxLogNop()
1448 #ifdef HAVE_VARIADIC_MACROS
1449 #define wxLogDebug(fmt, ...) wxLogNop()
1450 #else // !HAVE_VARIADIC_MACROS
1451 WX_DEFINE_VARARG_FUNC_NOP(wxLogDebug
, 1, (const wxString
&))
1453 #endif // wxUSE_LOG_DEBUG/!wxUSE_LOG_DEBUG
1456 #define wxLogTrace \
1457 if ( !wxLog::IsLevelEnabled(wxLOG_Trace, wxLOG_COMPONENT) ) \
1460 wxMAKE_LOGGER(Trace).LogTrace
1461 #else // !wxUSE_LOG_TRACE
1462 #define wxVLogTrace(mask, fmt, valist) wxLogNop()
1464 #ifdef HAVE_VARIADIC_MACROS
1465 #define wxLogTrace(mask, fmt, ...) wxLogNop()
1466 #else // !HAVE_VARIADIC_MACROS
1467 #if WXWIN_COMPATIBILITY_2_8
1468 WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace
, 2, (wxTraceMask
, const wxString
&))
1470 WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace
, 2, (const wxString
&, const wxString
&))
1472 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
1473 WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace
, 2, (const char*, const char*))
1474 WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace
, 2, (const wchar_t*, const wchar_t*))
1476 #endif // HAVE_VARIADIC_MACROS/!HAVE_VARIADIC_MACROS
1477 #endif // wxUSE_LOG_TRACE/!wxUSE_LOG_TRACE
1479 // wxLogFatalError helper: show the (fatal) error to the user in a safe way,
1480 // i.e. without using wxMessageBox() for example because it could crash
1481 void WXDLLIMPEXP_BASE
1482 wxSafeShowMessage(const wxString
& title
, const wxString
& text
);
1484 // ----------------------------------------------------------------------------
1485 // debug only logging functions: use them with API name and error code
1486 // ----------------------------------------------------------------------------
1489 // make life easier for people using VC++ IDE: clicking on the message
1490 // will take us immediately to the place of the failed API
1492 #define wxLogApiError(api, rc) \
1493 wxLogDebug(wxT("%s(%d): '%s' failed with error 0x%08lx (%s)."), \
1494 __FILE__, __LINE__, api, \
1495 (long)rc, wxSysErrorMsg(rc))
1497 #define wxLogApiError(api, rc) \
1498 wxLogDebug(wxT("In file %s at line %d: '%s' failed with ") \
1499 wxT("error 0x%08lx (%s)."), \
1500 __FILE__, __LINE__, api, \
1501 (long)rc, wxSysErrorMsg(rc))
1502 #endif // VC++/!VC++
1504 #define wxLogLastError(api) wxLogApiError(api, wxSysErrorCode())
1506 #else // !wxUSE_LOG_DEBUG
1507 #define wxLogApiError(api, err) wxLogNop()
1508 #define wxLogLastError(api) wxLogNop()
1509 #endif // wxUSE_LOG_DEBUG/!wxUSE_LOG_DEBUG
1511 // wxCocoa has additiional trace masks
1512 #if defined(__WXCOCOA__)
1513 #include "wx/cocoa/log.h"
1516 #ifdef WX_WATCOM_ONLY_CODE
1517 #undef WX_WATCOM_ONLY_CODE
1520 #endif // _WX_LOG_H_