/////////////////////////////////////////////////////////////////////////////
-// Name: log.h
+// Name: wx/log.h
// Purpose: Assorted wxLogXXX functions, and wxLog (sink for logs)
// Author: Vadim Zeitlin
// Modified by:
#ifndef _WX_LOG_H_
#define _WX_LOG_H_
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "log.h"
#endif
#if wxUSE_LOG
+#ifndef __WXWINCE__
#include <time.h> // for time_t
+#endif
#include "wx/dynarray.h"
+#ifndef wxUSE_LOG_DEBUG
+# ifdef __WXDEBUG__
+# define wxUSE_LOG_DEBUG 1
+# else // !__WXDEBUG__
+# define wxUSE_LOG_DEBUG 0
+# endif
+#endif
+
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
wxLOG_Error, // a serious error, user must be informed about it
wxLOG_Warning, // user is normally informed about it but may be ignored
wxLOG_Message, // normal message (i.e. normal output of a non GUI app)
- wxLOG_Info, // informational message (a.k.a. 'Verbose')
wxLOG_Status, // informational: might go to the status line of GUI app
+ wxLOG_Info, // informational message (a.k.a. 'Verbose')
wxLOG_Debug, // never shown to the user, disabled in release mode
wxLOG_Trace, // trace messages are also only enabled in debug mode
wxLOG_Progress, // used for progress indicator (not yet)
- wxLOG_User = 100 // user defined levels start here
+ wxLOG_User = 100, // user defined levels start here
+ wxLOG_Max = 10000
};
// symbolic trace masks - wxLogTrace("foo", "some trace message...") will be
#define wxTraceOleCalls 0x0100 // OLE interface calls
#endif
-#include "wx/ioswrap.h"
+#include "wx/iosfwrap.h"
// ----------------------------------------------------------------------------
// derive from this class to redirect (or suppress, or ...) log messages
// ctor
wxLog();
+ // Internal buffer.
+ // Allow replacement of the fixed size static buffer with
+ // a user allocated one. Pass in NULL to restore the
+ // built in static buffer.
+ static wxChar *SetLogBuffer( wxChar *buf, size_t size = 0 );
+
// these functions allow to completely disable all log messages
// is logging disabled now?
static bool IsEnabled() { return ms_doLog; }
// derived classes
static void OnLog(wxLogLevel level, const wxChar *szString, time_t t)
{
- if ( IsEnabled() ) {
+ if ( IsEnabled() && ms_logLevel >= level ) {
wxLog *pLogger = GetActiveTarget();
if ( pLogger )
pLogger->DoLog(level, szString, t);
// and iostream logs don't need it, but wxGuiLog does to avoid showing
// 17 modal dialogs one after another)
virtual void Flush();
- // call to Flush() may be optimized: call it only if this function
- // returns true (although Flush() also returns immediately if there is
- // no messages, this functions is more efficient because inline)
- bool HasPendingMessages() const { return m_bHasMessages; }
- // only one sink is active at each moment
// flush the active target if any
static void FlushActive()
{
if ( !ms_suspendCount )
{
wxLog *log = GetActiveTarget();
- if ( log && log->HasPendingMessages() )
+ if ( log )
log->Flush();
}
}
+
+ // only one sink is active at each moment
// get current log target, will call wxApp::CreateLogTarget() to
// create one if none exists
static wxLog *GetActiveTarget();
// verbose mode is activated by standard command-line '-verbose'
// option
static void SetVerbose(bool bVerbose = TRUE) { ms_bVerbose = bVerbose; }
+
+ // Set log level. Log messages with level > logLevel will not be logged.
+ static void SetLogLevel(wxLogLevel logLevel) { ms_logLevel = logLevel; }
+
// should GetActiveTarget() try to create a new log object if the
// current is NULL?
static void DontCreateOnDemand();
static void RemoveTraceMask(const wxString& str);
// remove all string trace masks
static void ClearTraceMasks();
+ // get string trace masks
+ static const wxArrayString &GetTraceMasks() { return ms_aTraceMasks; }
// sets the timestamp string: this is used as strftime() format string
// for the log targets which add time stamps to the messages - set it
// to NULL to disable time stamping completely.
static void SetTimestamp(const wxChar *ts) { ms_timestamp = ts; }
+
// accessors
// gets the verbose status
static bool GetVerbose() { return ms_bVerbose; }
// is this trace mask in the list?
static bool IsAllowedTraceMask(const wxChar *mask)
{ return ms_aTraceMasks.Index(mask) != wxNOT_FOUND; }
+ // return the current loglevel limit
+ static wxLogLevel GetLogLevel() { return ms_logLevel; }
// get the current timestamp format string (may be NULL)
static const wxChar *GetTimestamp() { return ms_timestamp; }
+
// helpers
// put the time stamp into the string if ms_timestamp != NULL (don't
// change it otherwise)
// make dtor virtual for all derived classes
virtual ~wxLog() { }
-protected:
- bool m_bHasMessages; // any messages in the queue?
+ // this method exists for backwards compatibility only, don't use
+ bool HasPendingMessages() const { return TRUE; }
+
+protected:
// the logging functions that can be overriden
// default DoLog() prepends the time stamp and a prefix corresponding
// to the message to szString and then passes it to DoLogString()
static bool ms_bAutoCreate; // create new log targets on demand?
static bool ms_bVerbose; // FALSE => ignore LogInfo messages
+ static wxLogLevel ms_logLevel; // limit logging to levels <= ms_logLevel
+
static size_t ms_suspendCount; // if positive, logs are not flushed
// format string for strftime(), if NULL, time stamping log messages is
// log everything to a "FILE *", stderr by default
class WXDLLEXPORT wxLogStderr : public wxLog
{
+ DECLARE_NO_COPY_CLASS(wxLogStderr)
+
public:
// 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();
+
+ // 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;
+
+ DECLARE_NO_COPY_CLASS(wxLogChain)
+};
+
+// 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
// the control we use
wxTextCtrl *m_pTextCtrl;
+
+ DECLARE_NO_COPY_CLASS(wxLogTextCtrl)
};
#endif // wxUSE_TEXTCTRL
wxArrayInt m_aSeverity; // one of wxLOG_XXX values
wxArrayLong m_aTimes; // the time of each message
bool m_bErrors, // do we have any errors?
- m_bWarnings; // any warnings?
+ m_bWarnings, // any warnings?
+ m_bHasMessages; // any messages at all?
+
};
#endif // wxUSE_LOGGUI
#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
+
+ DECLARE_NO_COPY_CLASS(wxLogWindow)
};
#endif // wxUSE_LOGWINDOW
#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
// ----------------------------------------------------------------------------
// return the last system error code
WXDLLEXPORT unsigned long wxSysErrorCode();
+
// return the error message for given (or last if 0) error code
WXDLLEXPORT const wxChar* wxSysErrorMsg(unsigned long nErrCode = 0);
+// ----------------------------------------------------------------------------
// define wxLog<level>
-// -------------------
+// ----------------------------------------------------------------------------
#define DECLARE_LOG_FUNCTION(level) \
-extern void WXDLLEXPORT wxLog##level(const wxChar *szFormat, ...)
+extern void WXDLLEXPORT wxVLog##level(const wxChar *szFormat, \
+ va_list argptr); \
+extern void WXDLLEXPORT wxLog##level(const wxChar *szFormat, \
+ ...) ATTRIBUTE_PRINTF_1
#define DECLARE_LOG_FUNCTION2(level, arg1) \
-extern void WXDLLEXPORT wxLog##level(arg1, const wxChar *szFormat, ...)
+extern void WXDLLEXPORT wxVLog##level(arg1, const wxChar *szFormat, \
+ va_list argptr); \
+extern void WXDLLEXPORT wxLog##level(arg1, const wxChar *szFormat, \
+ ...) ATTRIBUTE_PRINTF_2
#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, ...) {}
+// Empty Class to fake wxLogNull
+class WXDLLEXPORT wxLogNull
+{
+public:
+ wxLogNull() {}
+};
+
+// Dummy macros to replace some functions.
+#define wxSysErrorCode() (unsigned long)0
+#define wxSysErrorMsg( X ) (const wxChar*)NULL
+
+// Fake symbolic trace masks... for those that are used frequently
+#define wxTRACE_OleCalls wxT("") // OLE interface calls
+
#endif // wxUSE_LOG/!wxUSE_LOG
// a generic function for all levels (level is passes as parameter)
DECLARE_LOG_FUNCTION2(SysError, long lErrCode);
// debug functions do nothing in release mode
-#ifdef __WXDEBUG__
+#if wxUSE_LOG_DEBUG
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
+// wxLogFatalError helper: show the (fatal) error to the user in a safe way,
+// i.e. without using wxMessageBox() for example because it could crash
+void WXDLLEXPORT wxSafeShowMessage(const wxString& title, const wxString& text);
+
// ----------------------------------------------------------------------------
// 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
#ifdef __VISUALC__
#define wxLogApiError(api, rc) \
wxLogDebug(wxT("%s(%d): '%s' failed with error 0x%08lx (%s)."), \
- __TFILE__, __LINE__, api, \
- rc, wxSysErrorMsg(rc))
+ __TFILE__, __LINE__, api, \
+ (long)rc, wxSysErrorMsg(rc))
#else // !VC++
#define wxLogApiError(api, rc) \
wxLogDebug(wxT("In file %s at line %d: '%s' failed with " \
- "error 0x%08lx (%s)."), \
- __TFILE__, __LINE__, api, \
- rc, wxSysErrorMsg(rc))
+ "error 0x%08lx (%s)."), \
+ __TFILE__, __LINE__, api, \
+ (long)rc, wxSysErrorMsg(rc))
#endif // VC++/!VC++
#define wxLogLastError(api) wxLogApiError(api, wxSysErrorCode())
#endif //debug/!debug
#endif // _WX_LOG_H_
+
projects / wxWidgets.git / blobdiff