[wxWidgets.git] / wxPython / src / _log.i

/////////////////////////////////////////////////////////////////////////////
// Name:        _log.i
// Purpose:     SWIG interface stuff for wxLog
//
// Author:      Robin Dunn
//
// Created:     18-June-1999
// RCS-ID:      $Id$
// Copyright:   (c) 2003 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

// Not a %module


//---------------------------------------------------------------------------
%newgroup


typedef unsigned long wxTraceMask;
typedef unsigned long wxLogLevel;


enum
{
    wxLOG_FatalError, // program can't continue, abort immediately
    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_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_Max = 10000
};

#define wxTRACE_MemAlloc "memalloc" // trace memory allocation (new/delete)
#define wxTRACE_Messages "messages" // trace window messages/X callbacks
#define wxTRACE_ResAlloc "resalloc" // trace GDI resource allocation
#define wxTRACE_RefCount "refcount" // trace various ref counting operations
#define wxTRACE_OleCalls "ole"      // OLE interface calls

#define wxTraceMemAlloc 0x0001  // trace memory allocation (new/delete)
#define wxTraceMessages 0x0002  // trace window messages/X callbacks
#define wxTraceResAlloc 0x0004  // trace GDI resource allocation
#define wxTraceRefCount 0x0008  // trace various ref counting operations
#define wxTraceOleCalls 0x0100  // OLE interface calls

//---------------------------------------------------------------------------

class wxLog
{
public:
    wxLog();
    ~wxLog();

    // these functions allow to completely disable all log messages
    // is logging disabled now?
    static bool IsEnabled();

    // change the flag state, return the previous one
    static bool EnableLogging(bool doIt = true);

    // static sink function
    static void OnLog(wxLogLevel level, const wxChar *szString, time_t t);    

    // message buffering
    // flush shows all messages if they're not logged immediately (FILE
    // and iostream logs don't need it, but wxGuiLog does to avoid showing
    // 17 modal dialogs one after another)
    virtual void Flush();

    // flush the active target if any
    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
    static wxLog *GetActiveTarget();

    %disownarg( wxLog* pLogger );
    %newobject SetActiveTarget;
    // change log target, pLogger may be NULL
    static wxLog *SetActiveTarget(wxLog *pLogger);
    %cleardisown( wxLog* pLogger );
    
    // suspend the message flushing of the main target until the next call
    // to Resume() - this is mainly for internal use (to prevent wxYield()
    // from flashing the messages)
    static void Suspend();

    // must be called for each Suspend()!
    static void Resume();


    // verbose mode is activated by standard command-line '-verbose'
    // option
    static void SetVerbose(bool bVerbose = true);

    // Set log level.  Log messages with level > logLevel will not be logged.
    static void SetLogLevel(wxLogLevel logLevel);

    // should GetActiveTarget() try to create a new log object if the
    // current is NULL?
    static void DontCreateOnDemand();

    // log the count of repeating messages instead of logging the messages
    // multiple times
    static void SetRepetitionCounting(bool bRepetCounting = true);

    // gets duplicate counting status
    static bool GetRepetitionCounting();

    // trace mask (see wxTraceXXX constants for details)
    static void SetTraceMask(wxTraceMask ulMask);

    // add string trace mask
    static void AddTraceMask(const wxString& str);
    
    // remove string trace mask
    static void RemoveTraceMask(const wxString& str);

    // remove all string trace masks
    static void ClearTraceMasks();

    // get string trace masks
    static const wxArrayString &GetTraceMasks();

    // 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);


    // gets the verbose status
    static bool GetVerbose();
    
    // get trace mask
    static wxTraceMask GetTraceMask();

    // is this trace mask in the list?
    static bool IsAllowedTraceMask(const wxChar *mask);

    // return the current loglevel limit
    static wxLogLevel GetLogLevel();


    // get the current timestamp format string (may be NULL)
    static const wxChar *GetTimestamp();


    %extend {
        static wxString TimeStamp() {
            wxString msg;
            wxLog::TimeStamp(&msg);
            return msg;
        }
    }

    %pythonAppend Destroy "args[0].thisown = 0";
    %extend { void Destroy() { delete self; } }
};


//---------------------------------------------------------------------------


class wxLogStderr : public wxLog
{
public:
    wxLogStderr(/* TODO: FILE *fp = (FILE *) NULL*/);
};


class wxLogTextCtrl : public wxLog
{
public:
    wxLogTextCtrl(wxTextCtrl *pTextCtrl);
};


class wxLogGui : public wxLog
{
public:
    wxLogGui();
};

class wxLogWindow : public wxLog
{
public:
    wxLogWindow(wxFrame *pParent,         // the parent frame (can be NULL)
            const wxString& szTitle,      // the title of the frame
            bool bShow = true,            // show window immediately?
            bool bPassToOld = true);      // pass log messages to the old target?

    void Show(bool bShow = true);
    wxFrame *GetFrame() const;
    wxLog *GetOldLog() const;
    bool IsPassingMessages() const;
    void PassMessages(bool bDoPass);
    
    %property(Frame, GetFrame, doc="See `GetFrame`");
    %property(OldLog, GetOldLog, doc="See `GetOldLog`");
};


class wxLogChain : public wxLog
{
public:
    wxLogChain(wxLog *logger);
    void SetLog(wxLog *logger);
    void PassMessages(bool bDoPass);
    bool IsPassingMessages();
    wxLog *GetOldLog();

    %property(OldLog, GetOldLog, doc="See `GetOldLog`");    
};

// log everything to a buffer
class wxLogBuffer : public wxLog
{
public:
    wxLogBuffer();

    // get the string contents with all messages logged
    const wxString& GetBuffer() const;

    // show the buffer contents to the user in the best possible way (this uses
    // wxMessageOutputMessageBox) and clear it
    virtual void Flush();

    %property(Buffer, GetBuffer, doc="See `GetBuffer`");    
};


//---------------------------------------------------------------------------

unsigned long wxSysErrorCode();
const wxString wxSysErrorMsg(unsigned long nErrCode = 0);

%{// Make some wrappers that double any % signs so they are 'escaped'
    void wxPyLogFatalError(const wxString& msg)
    {
        wxString m(msg);
        m.Replace(wxT("%"), wxT("%%"));
        wxLogFatalError(m);
    }
    
    void wxPyLogError(const wxString& msg)
    {
        wxString m(msg);
        m.Replace(wxT("%"), wxT("%%"));
        wxLogError(m);
    }

    void wxPyLogWarning(const wxString& msg)
    {
        wxString m(msg);
        m.Replace(wxT("%"), wxT("%%"));
        wxLogWarning(m);
    }

    void wxPyLogMessage(const wxString& msg)
    {
        wxString m(msg);
        m.Replace(wxT("%"), wxT("%%"));
        wxLogMessage(m);
    }

    void wxPyLogInfo(const wxString& msg)
    {
        wxString m(msg);
        m.Replace(wxT("%"), wxT("%%"));
        wxLogInfo(m);
    }

    void wxPyLogDebug(const wxString& msg)
    {
        wxString m(msg);
        m.Replace(wxT("%"), wxT("%%"));
        wxLogDebug(m);
    }

    void wxPyLogVerbose(const wxString& msg)
    {
        wxString m(msg);
        m.Replace(wxT("%"), wxT("%%"));
        wxLogVerbose(m);
    }

    void wxPyLogStatus(const wxString& msg)
    {
        wxString m(msg);
        m.Replace(wxT("%"), wxT("%%"));
        wxLogStatus(m);
    }

    void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
    {
        wxString m(msg);
        m.Replace(wxT("%"), wxT("%%"));
        wxLogStatus(pFrame, m);
    }

    void wxPyLogSysError(const wxString& msg)
    {
        wxString m(msg);
        m.Replace(wxT("%"), wxT("%%"));
        wxLogSysError(m);
    }

    void wxPyLogGeneric(unsigned long level, const wxString& msg)
    {
        wxString m(msg);
        m.Replace(wxT("%"), wxT("%%"));
        wxLogGeneric(level, m);
    }

    void wxPyLogTrace(unsigned long mask, const wxString& msg)
    {
        wxString m(msg);
        m.Replace(wxT("%"), wxT("%%"));
        wxLogTrace(mask, m);
    }
        
    void wxPyLogTrace(const wxString& mask, const wxString& msg)
    {
        wxString m(msg);
        m.Replace(wxT("%"), wxT("%%"));
        wxLogTrace(mask, m);
    }
    
%}

%Rename(LogFatalError,  void, wxPyLogFatalError(const wxString& msg));
%Rename(LogError,  void, wxPyLogError(const wxString& msg));
%Rename(LogWarning,  void, wxPyLogWarning(const wxString& msg));
%Rename(LogMessage,  void, wxPyLogMessage(const wxString& msg));
%Rename(LogInfo,  void, wxPyLogInfo(const wxString& msg));
%Rename(LogDebug,  void, wxPyLogDebug(const wxString& msg));
%Rename(LogVerbose,  void, wxPyLogVerbose(const wxString& msg));
%Rename(LogStatus,  void, wxPyLogStatus(const wxString& msg));
%Rename(LogStatusFrame,  void, wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg));
%Rename(LogSysError,  void, wxPyLogSysError(const wxString& msg));

%Rename(LogGeneric,  void, wxPyLogGeneric(unsigned long level, const wxString& msg));

%nokwargs wxPyLogTrace;
%Rename(LogTrace,  void, wxPyLogTrace(unsigned long mask, const wxString& msg));
%Rename(LogTrace,  void, wxPyLogTrace(const wxString& mask, const wxString& msg));


// 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 wxSafeShowMessage(const wxString& title, const wxString& text);


// Suspress logging while an instance of this class exists
class wxLogNull
{
public:
    wxLogNull();
    ~wxLogNull();
};


//---------------------------------------------------------------------------

%{
// A wxLog class that can be derived from in wxPython
class wxPyLog : public wxLog {
public:
    wxPyLog() : wxLog() {}

    virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
        bool found;
        wxPyBlock_t blocked = wxPyBeginBlockThreads();
        if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
            PyObject* s = wx2PyString(szString);
            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
            Py_DECREF(s);
        }
        wxPyEndBlockThreads(blocked);
        if (! found)
            wxLog::DoLog(level, szString, t);
    }

    virtual void DoLogString(const wxChar *szString, time_t t) {
        bool found;
        wxPyBlock_t blocked = wxPyBeginBlockThreads();
        if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
            PyObject* s = wx2PyString(szString);
            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
            Py_DECREF(s);
        }
        wxPyEndBlockThreads(blocked);
        if (! found)
            wxLog::DoLogString(szString, t);
    }

    DEC_PYCALLBACK_VOID_(Flush);
    PYPRIVATE;
};
IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
%}

// Now tell SWIG about it
class wxPyLog : public wxLog {
public:
    %pythonAppend wxPyLog   "self._setCallbackInfo(self, PyLog)"

    wxPyLog();
    
    void _setCallbackInfo(PyObject* self, PyObject* _class);
};

//---------------------------------------------------------------------------
Commit	Line	Data
d14a1e28 RD	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: _log.i
	3	// Purpose: SWIG interface stuff for wxLog
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 18-June-1999
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 2003 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13	// Not a %module
	14
	15
	16	//---------------------------------------------------------------------------
	17	%newgroup
	18
	19
	20	typedef unsigned long wxTraceMask;
	21	typedef unsigned long wxLogLevel;
	22
	23
	24	enum
	25	{
	26	wxLOG_FatalError, // program can't continue, abort immediately
	27	wxLOG_Error, // a serious error, user must be informed about it
	28	wxLOG_Warning, // user is normally informed about it but may be ignored
	29	wxLOG_Message, // normal message (i.e. normal output of a non GUI app)
	30	wxLOG_Status, // informational: might go to the status line of GUI app
	31	wxLOG_Info, // informational message (a.k.a. 'Verbose')
	32	wxLOG_Debug, // never shown to the user, disabled in release mode
	33	wxLOG_Trace, // trace messages are also only enabled in debug mode
	34	wxLOG_Progress, // used for progress indicator (not yet)
	35	wxLOG_User = 100, // user defined levels start here
	36	wxLOG_Max = 10000
	37	};
	38
	39	#define wxTRACE_MemAlloc "memalloc" // trace memory allocation (new/delete)
	40	#define wxTRACE_Messages "messages" // trace window messages/X callbacks
	41	#define wxTRACE_ResAlloc "resalloc" // trace GDI resource allocation
	42	#define wxTRACE_RefCount "refcount" // trace various ref counting operations
	43	#define wxTRACE_OleCalls "ole" // OLE interface calls
	44
	45	#define wxTraceMemAlloc 0x0001 // trace memory allocation (new/delete)
	46	#define wxTraceMessages 0x0002 // trace window messages/X callbacks
	47	#define wxTraceResAlloc 0x0004 // trace GDI resource allocation
	48	#define wxTraceRefCount 0x0008 // trace various ref counting operations
	49	#define wxTraceOleCalls 0x0100 // OLE interface calls
	50
	51	//---------------------------------------------------------------------------
	52
	53	class wxLog
	54	{
	55	public:
	56	wxLog();
214c4fbe	57	~wxLog();
d14a1e28 RD	58
	59	// these functions allow to completely disable all log messages
	60	// is logging disabled now?
	61	static bool IsEnabled();
	62
	63	// change the flag state, return the previous one
a72f4631	64	static bool EnableLogging(bool doIt = true);
d14a1e28 RD	65
	66	// static sink function
	67	static void OnLog(wxLogLevel level, const wxChar *szString, time_t t);
	68
	69	// message buffering
	70	// flush shows all messages if they're not logged immediately (FILE
	71	// and iostream logs don't need it, but wxGuiLog does to avoid showing
	72	// 17 modal dialogs one after another)
	73	virtual void Flush();
	74
	75	// flush the active target if any
	76	static void FlushActive();
	77
	78	// only one sink is active at each moment
	79	// get current log target, will call wxApp::CreateLogTarget() to
	80	// create one if none exists
	81	static wxLog *GetActiveTarget();
	82
214c4fbe RD	83	%disownarg( wxLog* pLogger );
214c4fbe RD	84	%newobject SetActiveTarget;
d14a1e28 RD	85	// change log target, pLogger may be NULL
d14a1e28 RD	86	static wxLog SetActiveTarget(wxLog pLogger);
214c4fbe RD	87	%cleardisown( wxLog* pLogger );
214c4fbe RD	88
d14a1e28 RD	89	// suspend the message flushing of the main target until the next call
	90	// to Resume() - this is mainly for internal use (to prevent wxYield()
	91	// from flashing the messages)
	92	static void Suspend();
	93
	94	// must be called for each Suspend()!
	95	static void Resume();
	96
	97
	98	// verbose mode is activated by standard command-line '-verbose'
	99	// option
a72f4631	100	static void SetVerbose(bool bVerbose = true);
d14a1e28 RD	101
	102	// Set log level. Log messages with level > logLevel will not be logged.
	103	static void SetLogLevel(wxLogLevel logLevel);
	104
	105	// should GetActiveTarget() try to create a new log object if the
	106	// current is NULL?
	107	static void DontCreateOnDemand();
	108
6aaca5ba RD	109	// log the count of repeating messages instead of logging the messages
	110	// multiple times
	111	static void SetRepetitionCounting(bool bRepetCounting = true);
	112
	113	// gets duplicate counting status
	114	static bool GetRepetitionCounting();
	115
d14a1e28 RD	116	// trace mask (see wxTraceXXX constants for details)
	117	static void SetTraceMask(wxTraceMask ulMask);
	118
	119	// add string trace mask
	120	static void AddTraceMask(const wxString& str);
	121
	122	// remove string trace mask
	123	static void RemoveTraceMask(const wxString& str);
	124
	125	// remove all string trace masks
	126	static void ClearTraceMasks();
	127
	128	// get string trace masks
	129	static const wxArrayString &GetTraceMasks();
	130
	131	// sets the timestamp string: this is used as strftime() format string
	132	// for the log targets which add time stamps to the messages - set it
	133	// to NULL to disable time stamping completely.
	134	static void SetTimestamp(const wxChar *ts);
	135
	136
	137	// gets the verbose status
	138	static bool GetVerbose();
	139
	140	// get trace mask
	141	static wxTraceMask GetTraceMask();
	142
	143	// is this trace mask in the list?
	144	static bool IsAllowedTraceMask(const wxChar *mask);
	145
	146	// return the current loglevel limit
	147	static wxLogLevel GetLogLevel();
	148
	149
	150	// get the current timestamp format string (may be NULL)
	151	static const wxChar *GetTimestamp();
	152
	153
	154	%extend {
	155	static wxString TimeStamp() {
	156	wxString msg;
	157	wxLog::TimeStamp(&msg);
	158	return msg;
	159	}
	160	}
	161
214c4fbe	162	%pythonAppend Destroy "args[0].thisown = 0";
d14a1e28 RD	163	%extend { void Destroy() { delete self; } }
	164	};
	165
	166
	167	//---------------------------------------------------------------------------
	168
	169
	170	class wxLogStderr : public wxLog
	171	{
	172	public:
	173	wxLogStderr(/* TODO: FILE fp = (FILE ) NULL*/);
	174	};
	175
	176
	177	class wxLogTextCtrl : public wxLog
	178	{
	179	public:
	180	wxLogTextCtrl(wxTextCtrl *pTextCtrl);
	181	};
	182
	183
	184	class wxLogGui : public wxLog
	185	{
	186	public:
	187	wxLogGui();
	188	};
	189
	190	class wxLogWindow : public wxLog
	191	{
	192	public:
	193	wxLogWindow(wxFrame *pParent, // the parent frame (can be NULL)
	194	const wxString& szTitle, // the title of the frame
a72f4631 RD	195	bool bShow = true, // show window immediately?
a72f4631 RD	196	bool bPassToOld = true); // pass log messages to the old target?
d14a1e28	197
a72f4631	198	void Show(bool bShow = true);
d14a1e28 RD	199	wxFrame *GetFrame() const;
	200	wxLog *GetOldLog() const;
	201	bool IsPassingMessages() const;
	202	void PassMessages(bool bDoPass);
76b8fa1d RD	203
	204	%property(Frame, GetFrame, doc="See `GetFrame`");
	205	%property(OldLog, GetOldLog, doc="See `GetOldLog`");
d14a1e28 RD	206	};
	207
	208
	209	class wxLogChain : public wxLog
	210	{
	211	public:
	212	wxLogChain(wxLog *logger);
	213	void SetLog(wxLog *logger);
	214	void PassMessages(bool bDoPass);
	215	bool IsPassingMessages();
	216	wxLog *GetOldLog();
76b8fa1d RD	217
76b8fa1d RD	218	%property(OldLog, GetOldLog, doc="See `GetOldLog`");
d14a1e28 RD	219	};
d14a1e28 RD	220
93649c2c RD	221	// log everything to a buffer
	222	class wxLogBuffer : public wxLog
	223	{
	224	public:
	225	wxLogBuffer();
	226
	227	// get the string contents with all messages logged
76b8fa1d	228	const wxString& GetBuffer() const;
93649c2c RD	229
	230	// show the buffer contents to the user in the best possible way (this uses
	231	// wxMessageOutputMessageBox) and clear it
	232	virtual void Flush();
76b8fa1d RD	233
76b8fa1d RD	234	%property(Buffer, GetBuffer, doc="See `GetBuffer`");
93649c2c RD	235	};
93649c2c RD	236
d14a1e28 RD	237
	238	//---------------------------------------------------------------------------
	239
	240	unsigned long wxSysErrorCode();
	241	const wxString wxSysErrorMsg(unsigned long nErrCode = 0);
4e819f10	242
214c4fbe	243	%{// Make some wrappers that double any % signs so they are 'escaped'
4e819f10 RD	244	void wxPyLogFatalError(const wxString& msg)
	245	{
	246	wxString m(msg);
	247	m.Replace(wxT("%"), wxT("%%"));
	248	wxLogFatalError(m);
	249	}
	250
	251	void wxPyLogError(const wxString& msg)
	252	{
	253	wxString m(msg);
	254	m.Replace(wxT("%"), wxT("%%"));
	255	wxLogError(m);
	256	}
	257
	258	void wxPyLogWarning(const wxString& msg)
	259	{
	260	wxString m(msg);
	261	m.Replace(wxT("%"), wxT("%%"));
	262	wxLogWarning(m);
	263	}
	264
	265	void wxPyLogMessage(const wxString& msg)
	266	{
	267	wxString m(msg);
	268	m.Replace(wxT("%"), wxT("%%"));
	269	wxLogMessage(m);
	270	}
	271
	272	void wxPyLogInfo(const wxString& msg)
	273	{
	274	wxString m(msg);
	275	m.Replace(wxT("%"), wxT("%%"));
	276	wxLogInfo(m);
	277	}
	278
	279	void wxPyLogDebug(const wxString& msg)
	280	{
	281	wxString m(msg);
	282	m.Replace(wxT("%"), wxT("%%"));
	283	wxLogDebug(m);
	284	}
	285
	286	void wxPyLogVerbose(const wxString& msg)
	287	{
	288	wxString m(msg);
	289	m.Replace(wxT("%"), wxT("%%"));
	290	wxLogVerbose(m);
	291	}
	292
	293	void wxPyLogStatus(const wxString& msg)
	294	{
	295	wxString m(msg);
	296	m.Replace(wxT("%"), wxT("%%"));
	297	wxLogStatus(m);
	298	}
	299
	300	void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
	301	{
	302	wxString m(msg);
	303	m.Replace(wxT("%"), wxT("%%"));
	304	wxLogStatus(pFrame, m);
	305	}
	306
	307	void wxPyLogSysError(const wxString& msg)
308	{
309	wxString m(msg);
310	m.Replace(wxT("%"), wxT("%%"));
311	wxLogSysError(m);
312	}
313
314	void wxPyLogGeneric(unsigned long level, const wxString& msg)
315	{
316	wxString m(msg);
317	m.Replace(wxT("%"), wxT("%%"));
318	wxLogGeneric(level, m);
319	}
320
321	void wxPyLogTrace(unsigned long mask, const wxString& msg)
322	{
323	wxString m(msg);
324	m.Replace(wxT("%"), wxT("%%"));
325	wxLogTrace(mask, m);
326	}
327
328	void wxPyLogTrace(const wxString& mask, const wxString& msg)
329	{
330	wxString m(msg);
331	m.Replace(wxT("%"), wxT("%%"));
332	wxLogTrace(mask, m);
333	}
334
335	%}
336
1b8c7ba6 RD	337	%Rename(LogFatalError, void, wxPyLogFatalError(const wxString& msg));
	338	%Rename(LogError, void, wxPyLogError(const wxString& msg));
	339	%Rename(LogWarning, void, wxPyLogWarning(const wxString& msg));
	340	%Rename(LogMessage, void, wxPyLogMessage(const wxString& msg));
	341	%Rename(LogInfo, void, wxPyLogInfo(const wxString& msg));
	342	%Rename(LogDebug, void, wxPyLogDebug(const wxString& msg));
	343	%Rename(LogVerbose, void, wxPyLogVerbose(const wxString& msg));
	344	%Rename(LogStatus, void, wxPyLogStatus(const wxString& msg));
	345	%Rename(LogStatusFrame, void, wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg));
	346	%Rename(LogSysError, void, wxPyLogSysError(const wxString& msg));
	347
	348	%Rename(LogGeneric, void, wxPyLogGeneric(unsigned long level, const wxString& msg));
4e819f10 RD	349
4e819f10 RD	350	%nokwargs wxPyLogTrace;
1b8c7ba6 RD	351	%Rename(LogTrace, void, wxPyLogTrace(unsigned long mask, const wxString& msg));
1b8c7ba6 RD	352	%Rename(LogTrace, void, wxPyLogTrace(const wxString& mask, const wxString& msg));
4e819f10	353
d14a1e28 RD	354
	355	// wxLogFatalError helper: show the (fatal) error to the user in a safe way,
	356	// i.e. without using wxMessageBox() for example because it could crash
	357	void wxSafeShowMessage(const wxString& title, const wxString& text);
	358
	359
	360
	361	// Suspress logging while an instance of this class exists
	362	class wxLogNull
	363	{
	364	public:
	365	wxLogNull();
	366	~wxLogNull();
	367	};
	368
	369
	370
	371	//---------------------------------------------------------------------------
	372
	373	%{
	374	// A wxLog class that can be derived from in wxPython
	375	class wxPyLog : public wxLog {
	376	public:
	377	wxPyLog() : wxLog() {}
	378
	379	virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
	380	bool found;
6e6b3557	381	wxPyBlock_t blocked = wxPyBeginBlockThreads();
d14a1e28 RD	382	if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
	383	PyObject* s = wx2PyString(szString);
	384	wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
	385	Py_DECREF(s);
	386	}
da32eb53	387	wxPyEndBlockThreads(blocked);
d14a1e28 RD	388	if (! found)
	389	wxLog::DoLog(level, szString, t);
	390	}
	391
	392	virtual void DoLogString(const wxChar *szString, time_t t) {
	393	bool found;
6e6b3557	394	wxPyBlock_t blocked = wxPyBeginBlockThreads();
d14a1e28 RD	395	if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
	396	PyObject* s = wx2PyString(szString);
	397	wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
	398	Py_DECREF(s);
	399	}
da32eb53	400	wxPyEndBlockThreads(blocked);
d14a1e28 RD	401	if (! found)
	402	wxLog::DoLogString(szString, t);
	403	}
	404
a7a01418	405	DEC_PYCALLBACK_VOID_(Flush);
d14a1e28 RD	406	PYPRIVATE;
d14a1e28 RD	407	};
a7a01418	408	IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
d14a1e28 RD	409	%}
	410
	411	// Now tell SWIG about it
	412	class wxPyLog : public wxLog {
	413	public:
2b9048c5	414	%pythonAppend wxPyLog "self._setCallbackInfo(self, PyLog)"
d14a1e28 RD	415
	416	wxPyLog();
	417
	418	void _setCallbackInfo(PyObject* self, PyObject* _class);
	419	};
	420
	421	//---------------------------------------------------------------------------