// Created: 29/01/98
// RCS-ID: $Id$
// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
-// Licence: wxWindows license
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifndef _WX_LOG_H_
-#define _WX_LOG_H_
+#ifndef _WX_LOG_H_
+#define _WX_LOG_H_
-#if defined(__GNUG__) && !defined(__APPLE__)
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma interface "log.h"
#endif
-#include "wx/setup.h"
+#include "wx/defs.h"
+
+#if wxUSE_LOG
+
#include "wx/string.h"
+#include "wx/arrstr.h"
// ----------------------------------------------------------------------------
// forward declarations
// ----------------------------------------------------------------------------
-class WXDLLEXPORT wxTextCtrl;
-class WXDLLEXPORT wxLogFrame;
-class WXDLLEXPORT wxFrame;
+#if wxUSE_GUI
+ class WXDLLIMPEXP_CORE wxTextCtrl;
+ class WXDLLIMPEXP_CORE wxLogFrame;
+ class WXDLLIMPEXP_CORE wxFrame;
+#endif // wxUSE_GUI
// ----------------------------------------------------------------------------
// types
// headers
// ----------------------------------------------------------------------------
-#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
// normally, only a single instance of this class exists but it's not enforced
// ----------------------------------------------------------------------------
-class WXDLLEXPORT wxLog
+class WXDLLIMPEXP_BASE wxLog
{
public:
// ctor
// 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();
// trace mask (see wxTraceXXX constants for details)
static void SetTraceMask(wxTraceMask ulMask) { ms_ulTraceMask = ulMask; }
// add string trace mask
- static void AddTraceMask(const wxString& str) { ms_aTraceMasks.Add(str); }
+ static void AddTraceMask(const wxString& str)
+ { ms_aTraceMasks.push_back(str); }
// add string trace mask
static void RemoveTraceMask(const wxString& str);
// remove all string trace masks
// 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; }
// get trace mask
static wxTraceMask GetTraceMask() { return ms_ulTraceMask; }
// is this trace mask in the list?
- static bool IsAllowedTraceMask(const wxChar *mask)
- { return ms_aTraceMasks.Index(mask) != wxNOT_FOUND; }
+ static bool IsAllowedTraceMask(const wxChar *mask);
+ // 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
+class WXDLLIMPEXP_BASE wxLogStderr : public wxLog
{
DECLARE_NO_COPY_CLASS(wxLogStderr)
#if wxUSE_STD_IOSTREAM
// log everything to an "ostream", cerr by default
-class WXDLLEXPORT wxLogStream : public wxLog
+class WXDLLIMPEXP_BASE wxLogStream : public wxLog
{
public:
// redirect log output to an ostream
// ~wxLogNull called, old log sink restored
}
*/
-class WXDLLEXPORT wxLogNull
+class WXDLLIMPEXP_BASE wxLogNull
{
public:
wxLogNull() : m_flagOld(wxLog::EnableLogging(FALSE)) { }
// does it itself in its ctor
// ----------------------------------------------------------------------------
-class WXDLLEXPORT wxLogChain : public wxLog
+class WXDLLIMPEXP_BASE wxLogChain : public wxLog
{
public:
wxLogChain(wxLog *logger);
// 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
+class WXDLLIMPEXP_BASE 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_TEXTCTRL
-
-// log everything to a text window (GUI only of course)
-class WXDLLEXPORT wxLogTextCtrl : public wxLog
-{
-public:
- wxLogTextCtrl(wxTextCtrl *pTextCtrl);
-
-private:
- // implement sink function
- virtual void DoLogString(const wxChar *szString, time_t t);
-
- // the control we use
- wxTextCtrl *m_pTextCtrl;
-};
-
-#endif // wxUSE_TEXTCTRL
-
-// ----------------------------------------------------------------------------
-// GUI log target, the default one for wxWindows programs
-// ----------------------------------------------------------------------------
-
-#if wxUSE_LOGGUI
-
-class WXDLLEXPORT wxLogGui : public wxLog
-{
-public:
- // ctor
- wxLogGui();
-
- // show all messages that were logged since the last Flush()
- virtual void Flush();
-
-protected:
- virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t);
-
- // empty everything
- void Clear();
-
- wxArrayString m_aMessages; // the log message texts
- 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?
-};
-
-#endif // wxUSE_LOGGUI
-
-// ----------------------------------------------------------------------------
-// (background) log window: this class forwards all log messages to the log
-// target which was active when it was instantiated, but also collects them
-// to the log window. This window has it's own menu which allows the user to
-// close it, clear the log contents or save it to the file.
-// ----------------------------------------------------------------------------
-
-#if wxUSE_LOGWINDOW
-
-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 messages to the old target?
-
- ~wxLogWindow();
-
- // window operations
- // show/hide the log window
- void Show(bool bShow = TRUE);
- // retrieve the pointer to the frame
- wxFrame *GetFrame() const;
-
- // overridables
- // called immediately after the log frame creation allowing for
- // any extra initializations
- virtual void OnFrameCreate(wxFrame *frame);
- // called if the user closes the window interactively, will not be
- // called if it is destroyed for another reason (such as when program
- // exits) - return TRUE from here to allow the frame to close, FALSE
- // to prevent this from happening
- virtual bool OnFrameClose(wxFrame *frame);
- // called right before the log frame is going to be deleted: will
- // always be called unlike OnFrameClose()
- virtual void OnFrameDelete(wxFrame *frame);
-
-protected:
- virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t);
- virtual void DoLogString(const wxChar *szString, time_t t);
private:
- wxLogFrame *m_pLogFrame; // the log frame
+ DECLARE_NO_COPY_CLASS(wxLogPassThrough)
};
-#endif // wxUSE_LOGWINDOW
-
+#if wxUSE_GUI
+ // include GUI log targets:
+ #include "wx/generic/logg.h"
#endif // wxUSE_GUI
// ============================================================================
// ----------------------------------------------------------------------------
// return the last system error code
-WXDLLEXPORT unsigned long wxSysErrorCode();
+WXDLLIMPEXP_BASE unsigned long wxSysErrorCode();
// return the error message for given (or last if 0) error code
-WXDLLEXPORT const wxChar* wxSysErrorMsg(unsigned long nErrCode = 0);
+WXDLLIMPEXP_BASE const wxChar* wxSysErrorMsg(unsigned long nErrCode = 0);
// ----------------------------------------------------------------------------
// define wxLog<level>
// ----------------------------------------------------------------------------
-#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_FUNCTION(level) \
+extern void WXDLLIMPEXP_BASE wxVLog##level(const wxChar *szFormat, \
+ va_list argptr); \
+extern void WXDLLIMPEXP_BASE wxLog##level(const wxChar *szFormat, \
...) ATTRIBUTE_PRINTF_1
-#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, \
+#define DECLARE_LOG_FUNCTION2_EXP(level, arg, expdecl) \
+extern void expdecl wxVLog##level(arg, const wxChar *szFormat, \
+ va_list argptr); \
+extern void expdecl wxLog##level(arg, const wxChar *szFormat, \
...) ATTRIBUTE_PRINTF_2
+#define DECLARE_LOG_FUNCTION2(level, arg) \
+ DECLARE_LOG_FUNCTION2_EXP(level, arg, WXDLLIMPEXP_BASE)
#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, ...) {}
+#define DECLARE_LOG_FUNCTION(level) \
+inline void wxVLog##level(const wxChar *szFormat, \
+ va_list argptr) { } \
+inline void wxLog##level(const wxChar *szFormat, ...) { }
+#define DECLARE_LOG_FUNCTION2(level, arg) \
+inline void wxVLog##level(arg, const wxChar *szFormat, \
+ va_list argptr) {} \
+inline void wxLog##level(arg, const wxChar *szFormat, ...) { }
+
+// Empty Class to fake wxLogNull
+class WXDLLIMPEXP_BASE 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 wxEmptyString // OLE interface calls
#endif // wxUSE_LOG/!wxUSE_LOG
// application frame, if any
DECLARE_LOG_FUNCTION(Status);
-// this one is the same as previous except that it allows to explicitly
-// specify the frame to which the output should go
-DECLARE_LOG_FUNCTION2(Status, wxFrame *pFrame);
+#if wxUSE_GUI
+ // this one is the same as previous except that it allows to explicitly
+ // specify the frame to which the output should go
+ DECLARE_LOG_FUNCTION2_EXP(Status, wxFrame *pFrame, WXDLLIMPEXP_CORE);
+#endif // wxUSE_GUI
// additional one: as wxLogError, but also logs last system call error code
// and the corresponding error message if available
DECLARE_LOG_FUNCTION2(SysError, long lErrCode);
// debug functions do nothing in release mode
-#ifdef __WXDEBUG__
+#if wxUSE_LOG_DEBUG
DECLARE_LOG_FUNCTION(Debug);
// first kind of LogTrace is unconditional: it doesn't check the level,
// 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);
+void WXDLLIMPEXP_BASE
+wxSafeShowMessage(const wxString& title, const wxString& text);
// ----------------------------------------------------------------------------
// debug only logging functions: use them with API name and error code
#endif // _WX_LOG_H_
-// vi:sts=4:sw=4:et
projects / wxWidgets.git / blobdiff