support SDK < 10.6, fixes #14902

[wxWidgets.git] / include / wx / log.h

diff --git a/include/wx/log.h b/include/wx/log.h
index e3626ad6342eef42d5e3b8adbe406729909be330..e3e1f54adf4c588df38a7c45800dfe5142cd626c 100644 (file)
--- a/include/wx/log.h
+++ b/include/wx/log.h
@@ -29,7 +29,7 @@ typedef unsigned long wxLogLevel;
     #define wxTraceResAlloc 0x0004  // trace GDI resource allocation
     #define wxTraceRefCount 0x0008  // trace various ref counting operations
 
     #define wxTraceResAlloc 0x0004  // trace GDI resource allocation
     #define wxTraceRefCount 0x0008  // trace various ref counting operations
 

-    #ifdef  __WXMSW__
+    #ifdef  __WINDOWS__

         #define wxTraceOleCalls 0x0100  // OLE interface calls
     #endif
 
         #define wxTraceOleCalls 0x0100  // OLE interface calls
     #endif
 


@@ -43,15 +43,23 @@ typedef unsigned long wxLogLevel;
 #include "wx/string.h"
 #include "wx/strvararg.h"
 
 #include "wx/string.h"
 #include "wx/strvararg.h"
 

+// ----------------------------------------------------------------------------
+// forward declarations
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_FWD_BASE wxObject;
+
+#if wxUSE_GUI
+    class WXDLLIMPEXP_FWD_CORE wxFrame;
+#endif // wxUSE_GUI
+

 #if wxUSE_LOG
 
 #include "wx/arrstr.h"
 
 #if wxUSE_LOG
 
 #include "wx/arrstr.h"
 

-#ifndef __WXPALMOS5__

 #ifndef __WXWINCE__
     #include <time.h>   // for time_t
 #endif
 #ifndef __WXWINCE__
     #include <time.h>   // for time_t
 #endif

-#endif // ! __WXPALMOS5__

 
 #include "wx/dynarray.h"
 #include "wx/hashmap.h"
 
 #include "wx/dynarray.h"
 #include "wx/hashmap.h"


@@ -91,16 +99,6 @@ typedef unsigned long wxLogLevel;
     #endif
 #endif
 
     #endif
 #endif
 

-// ----------------------------------------------------------------------------
-// forward declarations
-// ----------------------------------------------------------------------------
-
-class WXDLLIMPEXP_FWD_BASE wxObject;
-
-#if wxUSE_GUI
-    class WXDLLIMPEXP_FWD_CORE wxFrame;
-#endif // wxUSE_GUI
-

 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------


@@ -130,7 +128,7 @@ enum wxLogLevelValues
 #define wxTRACE_ResAlloc wxT("resalloc") // trace GDI resource allocation
 #define wxTRACE_RefCount wxT("refcount") // trace various ref counting operations
 
 #define wxTRACE_ResAlloc wxT("resalloc") // trace GDI resource allocation
 #define wxTRACE_RefCount wxT("refcount") // trace various ref counting operations
 

-#ifdef  __WXMSW__
+#ifdef  __WINDOWS__

     #define wxTRACE_OleCalls wxT("ole")  // OLE interface calls
 #endif
 
     #define wxTRACE_OleCalls wxT("ole")  // OLE interface calls
 #endif
 


@@ -309,6 +307,34 @@ struct wxLogRecord
     wxLogRecordInfo info;
 };
 
     wxLogRecordInfo info;
 };
 

+// ----------------------------------------------------------------------------
+// Derive from this class to customize format of log messages.
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_BASE wxLogFormatter
+{
+public:
+    // Default constructor.
+    wxLogFormatter() { }
+
+    // Trivial but virtual destructor for the base class.
+    virtual ~wxLogFormatter() { }
+
+
+    // Override this method to implement custom formatting of the given log
+    // record. The default implementation simply prepends a level-dependent
+    // prefix to the message and optionally adds a time stamp.
+    virtual wxString Format(wxLogLevel level,
+                            const wxString& msg,
+                            const wxLogRecordInfo& info) const;
+
+protected:
+    // Override this method to change just the time stamp formatting. It is
+    // called by default Format() implementation.
+    virtual wxString FormatTime(time_t t) const;
+};
+
+

 // ----------------------------------------------------------------------------
 // derive from this class to redirect (or suppress, or ...) log messages
 // normally, only a single instance of this class exists but it's not enforced
 // ----------------------------------------------------------------------------
 // derive from this class to redirect (or suppress, or ...) log messages
 // normally, only a single instance of this class exists but it's not enforced


@@ -318,7 +344,7 @@ class WXDLLIMPEXP_BASE wxLog
 {
 public:
     // ctor
 {
 public:
     // ctor

-    wxLog() { }
+    wxLog() : m_formatter(new wxLogFormatter) { }

 
     // make dtor virtual for all derived classes
     virtual ~wxLog();
 
     // make dtor virtual for all derived classes
     virtual ~wxLog();


@@ -328,15 +354,32 @@ public:
     // ----------------------
 
     // these functions allow to completely disable all log messages or disable
     // ----------------------
 
     // these functions allow to completely disable all log messages or disable

-    // log messages at level less important than specified
+    // log messages at level less important than specified for the current
+    // thread

 
     // is logging enabled at all now?
 
     // is logging enabled at all now?

-    static bool IsEnabled() { return ms_doLog; }
+    static bool IsEnabled()
+    {
+#if wxUSE_THREADS
+        if ( !wxThread::IsMain() )
+            return IsThreadLoggingEnabled();
+#endif // wxUSE_THREADS
+
+        return ms_doLog;
+    }

 
     // change the flag state, return the previous one
 
     // change the flag state, return the previous one

-    static bool EnableLogging(bool doIt = true)
-        { bool doLogOld = ms_doLog; ms_doLog = doIt; return doLogOld; }
+    static bool EnableLogging(bool enable = true)
+    {
+#if wxUSE_THREADS
+        if ( !wxThread::IsMain() )
+            return EnableThreadLogging(enable);
+#endif // wxUSE_THREADS

 
 

+        bool doLogOld = ms_doLog;
+        ms_doLog = enable;
+        return doLogOld;
+    }

 
     // return the current global log level
     static wxLogLevel GetLogLevel() { return ms_logLevel; }
 
     // return the current global log level
     static wxLogLevel GetLogLevel() { return ms_logLevel; }


@@ -381,28 +424,26 @@ public:
     // -----------------
 
     // flush shows all messages if they're not logged immediately (FILE
     // -----------------
 
     // flush shows all messages if they're not logged immediately (FILE

-    // and iostream logs don't need it, but wxGuiLog does to avoid showing
+    // and iostream logs don't need it, but wxLogGui does to avoid showing

     // 17 modal dialogs one after another)
     virtual void Flush();
 
     // 17 modal dialogs one after another)
     virtual void Flush();
 

-    // flush the active target if any
-    static void FlushActive()
-    {
-        if ( !ms_suspendCount )
-        {
-            wxLog *log = GetActiveTarget();
-            if ( log )
-                log->Flush();
-        }
-    }
+    // flush the active target if any and also output any pending messages from
+    // background threads
+    static void FlushActive();

 
 

-    // only one sink is active at each moment
-    // get current log target, will call wxApp::CreateLogTarget() to
-    // create one if none exists
+    // only one sink is active at each moment get current log target, will call
+    // wxAppTraits::CreateLogTarget() to create one if none exists

     static wxLog *GetActiveTarget();
 
     static wxLog *GetActiveTarget();
 

-    // change log target, pLogger may be NULL
-    static wxLog *SetActiveTarget(wxLog *pLogger);
+    // change log target, logger may be NULL
+    static wxLog *SetActiveTarget(wxLog *logger);
+
+#if wxUSE_THREADS
+    // change log target for the current thread only, shouldn't be called from
+    // the main thread as it doesn't use thread-specific log target
+    static wxLog *SetThreadActiveTarget(wxLog *logger);
+#endif // wxUSE_THREADS

 
     // suspend the message flushing of the main target until the next call
     // to Resume() - this is mainly for internal use (to prevent wxYield()
 
     // suspend the message flushing of the main target until the next call
     // to Resume() - this is mainly for internal use (to prevent wxYield()


@@ -438,7 +479,27 @@ public:
 
     // get string trace masks: note that this is MT-unsafe if other threads can
     // call AddTraceMask() concurrently
 
     // get string trace masks: note that this is MT-unsafe if other threads can
     // call AddTraceMask() concurrently

-    static const wxArrayString& GetTraceMasks() { return ms_aTraceMasks; }
+    static const wxArrayString& GetTraceMasks();
+
+    // is this trace mask in the list?
+    static bool IsAllowedTraceMask(const wxString& mask);
+
+
+    // log formatting
+    // -----------------
+
+    // Change wxLogFormatter object used by wxLog to format the log messages.
+    //
+    // wxLog takes ownership of the pointer passed in but the caller is
+    // responsible for deleting the returned pointer.
+    wxLogFormatter* SetFormatter(wxLogFormatter* formatter);
+
+
+    // All the time stamp related functions below only work when the default
+    // wxLogFormatter is being used. Defining a custom formatter overrides them
+    // as it could use its own time stamp format or format messages without
+    // using time stamp at all.
+

 
     // sets the time stamp string format: this is used as strftime() format
     // string for the log targets which add time stamps to the messages; set
 
     // sets the time stamp string format: this is used as strftime() format
     // string for the log targets which add time stamps to the messages; set


@@ -449,9 +510,6 @@ public:
     static void DisableTimestamp() { SetTimestamp(wxEmptyString); }
 
 
     static void DisableTimestamp() { SetTimestamp(wxEmptyString); }
 
 

-    // is this trace mask in the list?
-    static bool IsAllowedTraceMask(const wxString& mask);
-

     // get the current timestamp format string (maybe empty)
     static const wxString& GetTimestamp() { return ms_timestamp; }
 
     // get the current timestamp format string (maybe empty)
     static const wxString& GetTimestamp() { return ms_timestamp; }
 


@@ -460,9 +518,10 @@ public:
     // helpers: all functions in this section are mostly for internal use only,
     // don't call them from your code even if they are not formally deprecated
 
     // helpers: all functions in this section are mostly for internal use only,
     // don't call them from your code even if they are not formally deprecated
 

-    // put the time stamp into the string if ms_timestamp != NULL (don't
-    // change it otherwise)
+    // put the time stamp into the string if ms_timestamp is not empty (don't
+    // change it otherwise); the first overload uses the current time.

     static void TimeStamp(wxString *str);
     static void TimeStamp(wxString *str);

+    static void TimeStamp(wxString *str, time_t t);

 
     // these methods should only be called from derived classes DoLogRecord(),
     // DoLogTextAtLevel() and DoLogText() implementations respectively and
 
     // these methods should only be called from derived classes DoLogRecord(),
     // DoLogTextAtLevel() and DoLogText() implementations respectively and


@@ -507,14 +566,14 @@ public:
 
 #if WXWIN_COMPATIBILITY_2_6
     // this function doesn't do anything any more, don't call it
 
 #if WXWIN_COMPATIBILITY_2_6
     // this function doesn't do anything any more, don't call it

-    wxDEPRECATED_INLINE(
-        static wxChar *SetLogBuffer(wxChar *, size_t = 0), return NULL;
+    static wxDEPRECATED_INLINE(
+        wxChar *SetLogBuffer(wxChar *, size_t = 0), return NULL;

     );
 #endif // WXWIN_COMPATIBILITY_2_6
 
     // don't use integer masks any more, use string trace masks instead
 #if WXWIN_COMPATIBILITY_2_8
     );
 #endif // WXWIN_COMPATIBILITY_2_6
 
     // don't use integer masks any more, use string trace masks instead
 #if WXWIN_COMPATIBILITY_2_8

-    wxDEPRECATED_INLINE( static void SetTraceMask(wxTraceMask ulMask),
+    static wxDEPRECATED_INLINE( void SetTraceMask(wxTraceMask ulMask),

         ms_ulTraceMask = ulMask; )
 
     // this one can't be marked deprecated as it's used in our own wxLogger
         ms_ulTraceMask = ulMask; )
 
     // this one can't be marked deprecated as it's used in our own wxLogger


@@ -580,15 +639,36 @@ protected:
     unsigned LogLastRepeatIfNeeded();
 
 private:
     unsigned LogLastRepeatIfNeeded();
 
 private:

-    // implement of LogLastRepeatIfNeeded(): it assumes that the
-    // caller had already locked GetPreviousLogCS()
-    unsigned LogLastRepeatIfNeededUnlocked();
+#if wxUSE_THREADS
+    // called from FlushActive() to really log any buffered messages logged
+    // from the other threads
+    void FlushThreadMessages();
+
+    // these functions are called for non-main thread only by IsEnabled() and
+    // EnableLogging() respectively
+    static bool IsThreadLoggingEnabled();
+    static bool EnableThreadLogging(bool enable = true);
+#endif // wxUSE_THREADS
+
+    // get the active log target for the main thread, auto-creating it if
+    // necessary
+    //
+    // this is called from GetActiveTarget() and OnLog() when they're called
+    // from the main thread
+    static wxLog *GetMainThreadActiveTarget();

 
 

-    // called from OnLog() if it's called from the main thread and from Flush()
+    // called from OnLog() if it's called from the main thread or if we have a
+    // (presumably MT-safe) thread-specific logger and by FlushThreadMessages()

     // when it plays back the buffered messages logged from the other threads
     // when it plays back the buffered messages logged from the other threads

-    void OnLogInMainThread(wxLogLevel level,
-                           const wxString& msg,
-                           const wxLogRecordInfo& info);
+    void CallDoLogNow(wxLogLevel level,
+                      const wxString& msg,
+                      const wxLogRecordInfo& info);
+
+
+    // variables
+    // ----------------
+
+    wxLogFormatter    *m_formatter; // We own this pointer.

 
 
     // static variables
 
 
     // static variables


@@ -614,9 +694,6 @@ private:
 #if WXWIN_COMPATIBILITY_2_8
     static wxTraceMask ms_ulTraceMask;   // controls wxLogTrace behaviour
 #endif // WXWIN_COMPATIBILITY_2_8
 #if WXWIN_COMPATIBILITY_2_8
     static wxTraceMask ms_ulTraceMask;   // controls wxLogTrace behaviour
 #endif // WXWIN_COMPATIBILITY_2_8

-
-    // currently enabled trace masks
-    static wxArrayString ms_aTraceMasks;

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -833,12 +910,12 @@ public:
     // indicates that we may have an extra first argument preceding the format
     // string and that if we do have it, we should store it in m_info using the
     // given key (while by default 0 value will be used)
     // indicates that we may have an extra first argument preceding the format
     // string and that if we do have it, we should store it in m_info using the
     // given key (while by default 0 value will be used)

-    wxLogger& MaybeStore(const wxString& key)
+    wxLogger& MaybeStore(const wxString& key, wxUIntPtr value = 0)

     {
         wxASSERT_MSG( m_optKey.empty(), "can only have one optional value" );
         m_optKey = key;
 
     {
         wxASSERT_MSG( m_optKey.empty(), "can only have one optional value" );
         m_optKey = key;
 

-        m_info.StoreValue(key, 0);
+        m_info.StoreValue(key, value);

         return *this;
     }
 
         return *this;
     }
 


@@ -871,6 +948,16 @@ public:
         LogV(format, argptr);
     }
 
         LogV(format, argptr);
     }
 

+    void LogVTrace(const wxString& mask, const wxString& format, va_list argptr)
+    {
+        if ( !wxLog::IsAllowedTraceMask(mask) )
+            return;
+
+        Store(wxLOG_KEY_TRACE_MASK, mask);
+
+        LogV(format, argptr);
+    }
+

 
     // vararg functions used by wxLogXXX():
 
 
     // vararg functions used by wxLogXXX():
 


@@ -1167,7 +1254,7 @@ private:
 
     void DoCallOnLog(const wxString& format, va_list argptr)
     {
 
     void DoCallOnLog(const wxString& format, va_list argptr)
     {

-        wxLog::OnLog(m_level, wxString::FormatV(format, argptr), m_info);
+        DoCallOnLog(m_level, format, argptr);

     }
 
 
     }
 
 


@@ -1267,7 +1354,7 @@ WXDLLIMPEXP_BASE const wxChar* wxSysErrorMsg(unsigned long nErrCode = 0);
         wxDO_LOG(level)
 
 // wxLogFatalError() is special as it can't be disabled
         wxDO_LOG(level)
 
 // wxLogFatalError() is special as it can't be disabled

-#define wxLogFatalError wxDO_LOG(FatalError) 
+#define wxLogFatalError wxDO_LOG(FatalError)

 #define wxVLogFatalError(format, argptr) wxDO_LOGV(FatalError, format, argptr)
 
 #define wxLogError wxDO_LOG_IF_ENABLED(Error)
 #define wxVLogFatalError(format, argptr) wxDO_LOGV(FatalError, format, argptr)
 
 #define wxLogError wxDO_LOG_IF_ENABLED(Error)


@@ -1314,19 +1401,30 @@ WXDLLIMPEXP_BASE const wxChar* wxSysErrorMsg(unsigned long nErrCode = 0);
 // wxLogSysError() needs to stash the error code value in the log record info
 // so it needs special handling too; additional complications arise because the
 // error code may or not be present as the first argument
 // wxLogSysError() needs to stash the error code value in the log record info
 // so it needs special handling too; additional complications arise because the
 // error code may or not be present as the first argument

+//
+// notice that we unfortunately can't avoid the call to wxSysErrorCode() even
+// though it may be unneeded if an explicit error code is passed to us because
+// the message might not be logged immediately (e.g. it could be queued for
+// logging from the main thread later) and so we can't to wait until it is
+// logged to determine whether we have last error or not as it will be too late
+// and it will have changed already by then (in fact it even changes when
+// wxString::Format() is called because of vsnprintf() inside it so it can
+// change even much sooner)

 #define wxLOG_KEY_SYS_ERROR_CODE "wx.sys_error"
 
 #define wxLogSysError                                                         \
     if ( !wxLog::IsLevelEnabled(wxLOG_Error, wxLOG_COMPONENT) )               \
     {}                                                                        \
     else                                                                      \
 #define wxLOG_KEY_SYS_ERROR_CODE "wx.sys_error"
 
 #define wxLogSysError                                                         \
     if ( !wxLog::IsLevelEnabled(wxLOG_Error, wxLOG_COMPONENT) )               \
     {}                                                                        \
     else                                                                      \

-        wxMAKE_LOGGER(Error).MaybeStore(wxLOG_KEY_SYS_ERROR_CODE).Log
+        wxMAKE_LOGGER(Error).MaybeStore(wxLOG_KEY_SYS_ERROR_CODE,             \
+                                        wxSysErrorCode()).Log

 
 // unfortunately we can't have overloaded macros so we can't define versions
 // both with and without error code argument and have to rely on LogV()
 // overloads in wxLogger to select between them
 #define wxVLogSysError \
 
 // unfortunately we can't have overloaded macros so we can't define versions
 // both with and without error code argument and have to rely on LogV()
 // overloads in wxLogger to select between them
 #define wxVLogSysError \

-    wxMAKE_LOGGER(Error).MaybeStore(wxLOG_KEY_SYS_ERROR_CODE).LogV
+    wxMAKE_LOGGER(Error).MaybeStore(wxLOG_KEY_SYS_ERROR_CODE, \
+                                    wxSysErrorCode()).LogV

 
 #if wxUSE_GUI
     // wxLogStatus() is similar to wxLogSysError() as it allows to optionally
 
 #if wxUSE_GUI
     // wxLogStatus() is similar to wxLogSysError() as it allows to optionally


@@ -1339,7 +1437,7 @@ WXDLLIMPEXP_BASE const wxChar* wxSysErrorMsg(unsigned long nErrCode = 0);
         else                                                                  \
             wxMAKE_LOGGER(Status).MaybeStore(wxLOG_KEY_FRAME).Log
 
         else                                                                  \
             wxMAKE_LOGGER(Status).MaybeStore(wxLOG_KEY_FRAME).Log
 

-    #define wxVLogStatus(format, argptr) \
+    #define wxVLogStatus \

         wxMAKE_LOGGER(Status).MaybeStore(wxLOG_KEY_FRAME).LogV
 #endif // wxUSE_GUI
 
         wxMAKE_LOGGER(Status).MaybeStore(wxLOG_KEY_FRAME).LogV
 #endif // wxUSE_GUI
 


@@ -1364,24 +1462,24 @@ WXDLLIMPEXP_BASE const wxChar* wxSysErrorMsg(unsigned long nErrCode = 0);
 // WX_WATCOM_ONLY_CODE is needed to work around
 // http://bugzilla.openwatcom.org/show_bug.cgi?id=351
 #define wxDEFINE_EMPTY_LOG_FUNCTION(level)                                  \
 // WX_WATCOM_ONLY_CODE is needed to work around
 // http://bugzilla.openwatcom.org/show_bug.cgi?id=351
 #define wxDEFINE_EMPTY_LOG_FUNCTION(level)                                  \

-    WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wxString&))           \
+    WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wxFormatString&))     \

     WX_WATCOM_ONLY_CODE(                                                    \
         WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const char*))           \
         WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wchar_t*))        \
         WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wxCStrData&))     \
     )                                                                       \
     WX_WATCOM_ONLY_CODE(                                                    \
         WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const char*))           \
         WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wchar_t*))        \
         WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wxCStrData&))     \
     )                                                                       \

-    inline void wxVLog##level(const wxString& WXUNUSED(format),             \
+    inline void wxVLog##level(const wxFormatString& WXUNUSED(format),       \

                               va_list WXUNUSED(argptr)) { }                 \
 
 #define wxDEFINE_EMPTY_LOG_FUNCTION2(level, argclass)                       \
                               va_list WXUNUSED(argptr)) { }                 \
 
 #define wxDEFINE_EMPTY_LOG_FUNCTION2(level, argclass)                       \

-    WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wxString&)) \
+    WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wxFormatString&)) \

     WX_WATCOM_OR_MINGW_ONLY_CODE(                                           \
         WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const char*)) \
         WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wchar_t*)) \
         WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wxCStrData&)) \
     )                                                                       \
     inline void wxVLog##level(argclass WXUNUSED(arg),                       \
     WX_WATCOM_OR_MINGW_ONLY_CODE(                                           \
         WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const char*)) \
         WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wchar_t*)) \
         WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wxCStrData&)) \
     )                                                                       \
     inline void wxVLog##level(argclass WXUNUSED(arg),                       \

-                              const wxString& WXUNUSED(format),             \
+                              const wxFormatString& WXUNUSED(format),       \

                               va_list WXUNUSED(argptr)) {}
 
 wxDEFINE_EMPTY_LOG_FUNCTION(FatalError);
                               va_list WXUNUSED(argptr)) {}
 
 wxDEFINE_EMPTY_LOG_FUNCTION(FatalError);


@@ -1448,7 +1546,7 @@ public:
     #ifdef HAVE_VARIADIC_MACROS
         #define wxLogDebug(fmt, ...) wxLogNop()
     #else // !HAVE_VARIADIC_MACROS
     #ifdef HAVE_VARIADIC_MACROS
         #define wxLogDebug(fmt, ...) wxLogNop()
     #else // !HAVE_VARIADIC_MACROS

-        WX_DEFINE_VARARG_FUNC_NOP(wxLogDebug, 1, (const wxString&))
+        WX_DEFINE_VARARG_FUNC_NOP(wxLogDebug, 1, (const wxFormatString&))

     #endif
 #endif // wxUSE_LOG_DEBUG/!wxUSE_LOG_DEBUG
 
     #endif
 #endif // wxUSE_LOG_DEBUG/!wxUSE_LOG_DEBUG
 


@@ -1458,6 +1556,11 @@ public:
         {}                                                                    \
         else                                                                  \
             wxMAKE_LOGGER(Trace).LogTrace
         {}                                                                    \
         else                                                                  \
             wxMAKE_LOGGER(Trace).LogTrace

+    #define wxVLogTrace                                                       \
+        if ( !wxLog::IsLevelEnabled(wxLOG_Trace, wxLOG_COMPONENT) )           \
+        {}                                                                    \
+        else                                                                  \
+            wxMAKE_LOGGER(Trace).LogVTrace

 #else  // !wxUSE_LOG_TRACE
     #define wxVLogTrace(mask, fmt, valist) wxLogNop()
 
 #else  // !wxUSE_LOG_TRACE
     #define wxVLogTrace(mask, fmt, valist) wxLogNop()
 


@@ -1465,9 +1568,9 @@ public:
         #define wxLogTrace(mask, fmt, ...) wxLogNop()
     #else // !HAVE_VARIADIC_MACROS
         #if WXWIN_COMPATIBILITY_2_8
         #define wxLogTrace(mask, fmt, ...) wxLogNop()
     #else // !HAVE_VARIADIC_MACROS
         #if WXWIN_COMPATIBILITY_2_8

-        WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (wxTraceMask, const wxString&))
+        WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (wxTraceMask, const wxFormatString&))

         #endif
         #endif

-        WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (const wxString&, const wxString&))
+        WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (const wxString&, const wxFormatString&))

         #ifdef __WATCOMC__
         // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
         WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (const char*, const char*))
         #ifdef __WATCOMC__
         // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
         WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (const char*, const char*))


@@ -1517,5 +1620,14 @@ wxSafeShowMessage(const wxString& title, const wxString& text);
     #undef WX_WATCOM_ONLY_CODE
 #endif
 
     #undef WX_WATCOM_ONLY_CODE
 #endif
 

+// macro which disables debug logging in release builds: this is done by
+// default by wxIMPLEMENT_APP() so usually it doesn't need to be used explicitly
+#if defined(NDEBUG) && wxUSE_LOG_DEBUG
+    #define wxDISABLE_DEBUG_LOGGING_IN_RELEASE_BUILD() \
+        wxLog::SetLogLevel(wxLOG_Info)
+#else // !NDEBUG
+    #define wxDISABLE_DEBUG_LOGGING_IN_RELEASE_BUILD()
+#endif // NDEBUG/!NDEBUG
+

 #endif  // _WX_LOG_H_
 
 #endif  // _WX_LOG_H_