/////////////////////////////////////////////////////////////////////////////
-// Name: log.h
+// Name: wx/log.h
// Purpose: Assorted wxLogXXX functions, and wxLog (sink for logs)
// Author: Vadim Zeitlin
// Modified by:
// functions controlling the default wxLog behaviour
// verbose mode is activated by standard command-line '-verbose'
// option
- void SetVerbose(bool bVerbose = TRUE) { m_bVerbose = bVerbose; }
+ static void SetVerbose(bool bVerbose = TRUE) { ms_bVerbose = bVerbose; }
// should GetActiveTarget() try to create a new log object if the
// current is NULL?
static void DontCreateOnDemand();
// accessors
// gets the verbose status
- bool GetVerbose() const { return m_bVerbose; }
+ static bool GetVerbose() { return ms_bVerbose; }
// get trace mask
static wxTraceMask GetTraceMask() { return ms_ulTraceMask; }
// is this trace mask in the list?
protected:
bool m_bHasMessages; // any messages in the queue?
- bool m_bVerbose; // FALSE => ignore LogInfo messages
// the logging functions that can be overriden
// default DoLog() prepends the time stamp and a prefix corresponding
static wxLog *ms_pLogger; // currently active log sink
static bool ms_doLog; // FALSE => all logging disabled
static bool ms_bAutoCreate; // create new log targets on demand?
+ static bool ms_bVerbose; // FALSE => ignore LogInfo messages
static size_t ms_suspendCount; // if positive, logs are not flushed
// redirect log output to a FILE
wxLogStderr(FILE *fp = (FILE *) NULL);
-private:
+protected:
// implement sink function
virtual void DoLogString(const wxChar *szString, time_t t);
};
#if wxUSE_STD_IOSTREAM
+
// log everything to an "ostream", cerr by default
class WXDLLEXPORT wxLogStream : public wxLog
{
// using ptr here to avoid including <iostream.h> from this file
wxSTD ostream *m_ostr;
};
-#endif
+#endif // wxUSE_STD_IOSTREAM
+
+// ----------------------------------------------------------------------------
+// /dev/null log target: suppress logging until this object goes out of scope
+// ----------------------------------------------------------------------------
+
+// example of usage:
+/*
+ void Foo()
+ {
+ wxFile file;
+
+ // wxFile.Open() normally complains if file can't be opened, we don't
+ // want it
+ wxLogNull logNo;
+
+ if ( !file.Open("bar") )
+ ... process error ourselves ...
+
+ // ~wxLogNull called, old log sink restored
+ }
+ */
+class WXDLLEXPORT wxLogNull
+{
+public:
+ wxLogNull() { m_flagOld = wxLog::EnableLogging(FALSE); }
+ ~wxLogNull() { (void)wxLog::EnableLogging(m_flagOld); }
+
+private:
+ bool m_flagOld; // the previous value of the wxLog::ms_doLog
+};
+
+// ----------------------------------------------------------------------------
+// chaining log target: installs itself as a log target and passes all
+// messages to the real log target given to it in the ctor but also forwards
+// them to the previously active one
+//
+// note that you don't have to call SetActiveTarget() with this class, it
+// does it itself in its ctor
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxLogChain : public wxLog
+{
+public:
+ wxLogChain(wxLog *logger);
+ virtual ~wxLogChain() { delete m_logOld; }
+
+ // change the new log target
+ void SetLog(wxLog *logger);
+
+ // this can be used to temporarily disable (and then reenable) passing
+ // messages to the old logger (by default we do pass them)
+ void PassMessages(bool bDoPass) { m_bPassMessages = bDoPass; }
+
+ // are we passing the messages to the previous log target?
+ bool IsPassingMessages() const { return m_bPassMessages; }
+
+ // return the previous log target (may be NULL)
+ wxLog *GetOldLog() const { return m_logOld; }
+
+ // override base class version to flush the old logger as well
+ virtual void Flush();
+
+protected:
+ // pass the chain to the old logger if needed
+ virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t);
+
+private:
+ // the current log target
+ wxLog *m_logNew;
+
+ // the previous log target
+ wxLog *m_logOld;
+
+ // do we pass the messages to the old logger?
+ bool m_bPassMessages;
+};
+
+// a chain log target which uses itself as the new logger
+class WXDLLEXPORT wxLogPassThrough : public wxLogChain
+{
+public:
+ wxLogPassThrough();
+};
+
+// ----------------------------------------------------------------------------
// the following log targets are only compiled in if the we're compiling the
// GUI part (andnot just the base one) of the library, they're implemented in
// src/generic/logg.cpp *and not src/common/log.cpp unlike all the rest)
+// ----------------------------------------------------------------------------
#if wxUSE_GUI
#if wxUSE_LOGWINDOW
-class WXDLLEXPORT wxLogWindow : public wxLog
+class WXDLLEXPORT wxLogWindow : public wxLogPassThrough
{
public:
wxLogWindow(wxFrame *pParent, // the parent frame (can be NULL)
- const wxChar *szTitle, // the title of the frame
- bool bShow = TRUE, // show window immediately?
- bool bPassToOld = TRUE); // pass log messages to the old target?
+ const wxChar *szTitle, // the title of the frame
+ bool bShow = TRUE, // show window immediately?
+ bool bPassToOld = TRUE); // pass messages to the old target?
+
~wxLogWindow();
// window operations
// retrieve the pointer to the frame
wxFrame *GetFrame() const;
- // accessors
- // the previous log target (may be NULL)
- wxLog *GetOldLog() const { return m_pOldLog; }
- // are we passing the messages to the previous log target?
- bool IsPassingMessages() const { return m_bPassMessages; }
-
- // we can pass the messages to the previous log target (we're in this mode by
- // default: we collect all messages in the window, but also let the default
- // processing take place)
- void PassMessages(bool bDoPass) { m_bPassMessages = bDoPass; }
-
- // base class virtuals
- // we don't need it ourselves, but we pass it to the previous logger
- virtual void Flush();
-
// overridables
// called immediately after the log frame creation allowing for
// any extra initializations
virtual void DoLogString(const wxChar *szString, time_t t);
private:
- bool m_bPassMessages; // pass messages to m_pOldLog?
- wxLog *m_pOldLog; // previous log target
wxLogFrame *m_pLogFrame; // the log frame
};
#endif // wxUSE_GUI
-// ----------------------------------------------------------------------------
-// /dev/null log target: suppress logging until this object goes out of scope
-// ----------------------------------------------------------------------------
-
-// example of usage:
-/*
- void Foo() {
- wxFile file;
-
-// wxFile.Open() normally complains if file can't be opened, we don't want it
-wxLogNull logNo;
-if ( !file.Open("bar") )
-... process error ourselves ...
-
-// ~wxLogNull called, old log sink restored
-}
- */
-class WXDLLEXPORT wxLogNull
-{
-public:
- wxLogNull() { m_flagOld = wxLog::EnableLogging(FALSE); }
- ~wxLogNull() { (void)wxLog::EnableLogging(m_flagOld); }
-
-private:
- bool m_flagOld; // the previous value of the wxLog::ms_doLog
-};
-
// ============================================================================
// global functions
// ============================================================================
// for log messages for easy redirection
// ----------------------------------------------------------------------------
-// are we in 'verbose' mode?
-// (note that it's often handy to change this var manually from the
-// debugger, thus enabling/disabling verbose reporting for some
-// parts of the program only)
-WXDLLEXPORT_DATA(extern bool) g_bVerbose;
-
// ----------------------------------------------------------------------------
// get error code/error message from system in a portable way
// ----------------------------------------------------------------------------
// -------------------
#define DECLARE_LOG_FUNCTION(level) \
+extern void WXDLLEXPORT wxVLog##level(const wxChar *szFormat, \
+ va_list argptr); \
extern void WXDLLEXPORT wxLog##level(const wxChar *szFormat, ...)
#define DECLARE_LOG_FUNCTION2(level, arg1) \
+extern void WXDLLEXPORT wxVLog##level(arg1, const wxChar *szFormat, \
+ va_list argptr); \
extern void WXDLLEXPORT wxLog##level(arg1, const wxChar *szFormat, ...)
#else // !wxUSE_LOG
// log functions do nothing at all
#define DECLARE_LOG_FUNCTION(level) \
+inline void WXDLLEXPORT wxVLog##level(const wxChar *szFormat, \
+ va_list argptr) {} \
inline void WXDLLEXPORT wxLog##level(const wxChar *szFormat, ...) {}
#define DECLARE_LOG_FUNCTION2(level, arg1) \
+inline void WXDLLEXPORT wxVLog##level(arg1, const wxChar *szFormat, \
+ va_list argptr) {} \
inline void WXDLLEXPORT wxLog##level(arg1, const wxChar *szFormat, ...) {}
#endif // wxUSE_LOG/!wxUSE_LOG
#ifdef __WXDEBUG__
DECLARE_LOG_FUNCTION(Debug);
- // first king of LogTrace is uncoditional: it doesn't check the level,
+ // first kind of LogTrace is unconditional: it doesn't check the level,
DECLARE_LOG_FUNCTION(Trace);
// this second version will only log the message if the mask had been
DECLARE_LOG_FUNCTION2(Trace, wxTraceMask mask);
#else //!debug
// these functions do nothing in release builds
+ inline void wxVLogDebug(const wxChar *, va_list) { }
inline void wxLogDebug(const wxChar *, ...) { }
+ inline void wxVLogTrace(const wxChar *, va_list) { }
inline void wxLogTrace(const wxChar *, ...) { }
+ inline void wxVLogTrace(wxTraceMask, const wxChar *, va_list) { }
inline void wxLogTrace(wxTraceMask, const wxChar *, ...) { }
+ inline void wxVLogTrace(const wxChar *, const wxChar *, va_list) { }
inline void wxLogTrace(const wxChar *, const wxChar *, ...) { }
#endif // debug/!debug
// debug only logging functions: use them with API name and error code
// ----------------------------------------------------------------------------
-#ifndef __TFILE__
- #define __XFILE__(x) Tx)
- #define __TFILE__ __XFILE__(__FILE__)
-#endif
-
#ifdef __WXDEBUG__
// make life easier for people using VC++ IDE: clicking on the message
// will take us immediately to the place of the failed API
projects / wxWidgets.git / blobdiff