sip/gen/log.sip

//---------------------------------------------------------------------------
// This file is generated by wxPython's SIP generator.  Do not edit by hand.
//
// Copyright: (c) 2018 by Total Control Software
// License:   wxWindows License
//
// This file will be included by _core.sip
//
//---------------------------------------------------------------------------

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

enum wxLogLevelValues
{
    wxLOG_FatalError,
    wxLOG_Error,
    wxLOG_Warning,
    wxLOG_Message,
    wxLOG_Status,
    wxLOG_Info,
    wxLOG_Debug,
    wxLOG_Trace,
    wxLOG_Progress,
    wxLOG_User,
    wxLOG_Max
};

typedef unsigned long wxLogLevel;

class wxLog
{
    %Docstring
        wxLog class defines the interface for the log targets used by
        wxWidgets logging functions as explained in the Logging Overview.
    %End
    %TypeHeaderCode
        #include <wx/log.h>
    %End

public:
    static
    void AddTraceMask(
        const wxString & mask
    );
    %Docstring
        AddTraceMask(mask)

        Add the mask to the list of allowed masks for wxLogTrace().
    %End

    static
    void ClearTraceMasks();
    %Docstring
        ClearTraceMasks()

        Removes all trace masks previously set with AddTraceMask().
    %End

    static
    const wxArrayString & GetTraceMasks();
    %Docstring
        GetTraceMasks() -> ArrayString

        Returns the currently allowed list of string trace masks.
    %End

    static
    bool IsAllowedTraceMask(
        const wxString & mask
    );
    %Docstring
        IsAllowedTraceMask(mask) -> bool

        Returns true if the mask is one of allowed masks for wxLogTrace().
    %End

    static
    void RemoveTraceMask(
        const wxString & mask
    );
    %Docstring
        RemoveTraceMask(mask)

        Remove the mask from the list of allowed masks for wxLogTrace().
    %End

    static
    void DontCreateOnDemand();
    %Docstring
        DontCreateOnDemand()

        Instructs wxLog to not create new log targets on the fly if there is
        none currently (see GetActiveTarget()).
    %End

    static
    wxLog * GetActiveTarget();
    %Docstring
        GetActiveTarget() -> Log

        Returns the pointer to the active log target (may be NULL).
    %End

    static
    wxLog * SetActiveTarget(
        wxLog * logtarget   /Transfer/
    )   /TransferBack/;
    %Docstring
        SetActiveTarget(logtarget) -> Log

        Sets the specified log target as the active one.
    %End

    static
    wxLog * SetThreadActiveTarget(
        wxLog * logger   /Transfer/
    )   /TransferBack/;
    %Docstring
        SetThreadActiveTarget(logger) -> Log

        Sets a thread-specific log target.
    %End

    static
    void FlushActive();
    %Docstring
        FlushActive()

        Flushes the current log target if any, does nothing if there is none.
    %End

    static
    void Resume();
    %Docstring
        Resume()

        Resumes logging previously suspended by a call to Suspend().
    %End

    static
    void Suspend();
    %Docstring
        Suspend()

        Suspends the logging until Resume() is called.
    %End

    static
    wxLogLevel GetLogLevel();
    %Docstring
        GetLogLevel() -> LogLevel

        Returns the current log level limit.
    %End

    static
    bool IsLevelEnabled(
        wxLogLevel level,
        wxString component
    );
    %Docstring
        IsLevelEnabled(level, component) -> bool

        Returns true if logging at this level is enabled for the current
        thread.
    %End

    static
    void SetComponentLevel(
        const wxString & component,
        wxLogLevel level
    );
    %Docstring
        SetComponentLevel(component, level)

        Sets the log level for the given component.
    %End

    static
    void SetLogLevel(
        wxLogLevel logLevel
    );
    %Docstring
        SetLogLevel(logLevel)

        Specifies that log messages with level greater (numerically) than
        logLevel should be ignored and not sent to the active log target.
    %End

    static
    bool EnableLogging(
        bool enable = true
    );
    %Docstring
        EnableLogging(enable=True) -> bool

        Globally enable or disable logging.
    %End

    static
    bool IsEnabled();
    %Docstring
        IsEnabled() -> bool

        Returns true if logging is enabled at all now.
    %End

    static
    bool GetRepetitionCounting();
    %Docstring
        GetRepetitionCounting() -> bool

        Returns whether the repetition counting mode is enabled.
    %End

    static
    void SetRepetitionCounting(
        bool repetCounting = true
    );
    %Docstring
        SetRepetitionCounting(repetCounting=True)

        Enables logging mode in which a log message is logged once, and in
        case exactly the same message successively repeats one or more times,
        only the number of repetitions is logged.
    %End

    static
    const wxString & GetTimestamp();
    %Docstring
        GetTimestamp() -> String

        Returns the current timestamp format string.
    %End

    static
    void SetTimestamp(
        const wxString & format
    );
    %Docstring
        SetTimestamp(format)

        Sets the timestamp format prepended by the default log targets to all
        messages.
    %End

    static
    void DisableTimestamp();
    %Docstring
        DisableTimestamp()

        Disables time stamping of the log messages.
    %End

    static
    bool GetVerbose();
    %Docstring
        GetVerbose() -> bool

        Returns whether the verbose mode is currently active.
    %End

    static
    void SetVerbose(
        bool verbose = true
    );
    %Docstring
        SetVerbose(verbose=True)

        Activates or deactivates verbose mode in which the verbose messages
        are logged as the normal ones instead of being silently dropped.
    %End

    wxLogFormatter * SetFormatter(
        wxLogFormatter * formatter
    );
    %Docstring
        SetFormatter(formatter) -> LogFormatter

        Sets the specified formatter as the active one.
    %End

    virtual
    void Flush();
    %Docstring
        Flush()

        Some of wxLog implementations, most notably the standard wxLogGui
        class, buffer the messages (for example, to avoid showing the user a
        zillion of modal message boxes one after another  which would be
        really annoying).
    %End

    void LogRecord(
        wxLogLevel level,
        const wxString & msg,
        const wxLogRecordInfo & info
    );
    %Docstring
        LogRecord(level, msg, info)

        Log the given record.
    %End

    public:


protected:
    virtual
    void DoLogRecord(
        wxLogLevel level,
        const wxString & msg,
        const wxLogRecordInfo & info
    );
    %Docstring
        DoLogRecord(level, msg, info)

        Called to log a new record.
    %End

    virtual
    void DoLogTextAtLevel(
        wxLogLevel level,
        const wxString & msg
    );
    %Docstring
        DoLogTextAtLevel(level, msg)

        Called to log the specified string at given level.
    %End

    virtual
    void DoLogText(
        const wxString & msg
    );
    %Docstring
        DoLogText(msg)

        Called to log the specified string.
    %End

};  // end of class wxLog


class wxLogGui : wxLog
{
    %Docstring
        LogGui()

        This is the default log target for the GUI wxWidgets applications.
    %End
    %TypeHeaderCode
        #include <wx/log.h>
    %End

public:
    wxLogGui();

    virtual
    void Flush();
    %Docstring
        Flush()

        Presents the accumulated log messages, if any, to the user.
    %End

    private:
        wxLogGui(const wxLogGui&);


    private:
        wxLogGui& operator=(const wxLogGui&);


};  // end of class wxLogGui


class wxLogNull
{
    %Docstring
        LogNull()

        This class allows you to temporarily suspend logging.
    %End
    %TypeHeaderCode
        #include <wx/log.h>
    %End

public:
    wxLogNull();

    ~wxLogNull();

};  // end of class wxLogNull


class wxLogRecordInfo
{
    %Docstring
        Information about a log record (unit of the log output).
    %End
    %TypeHeaderCode
        #include <wx/log.h>
    %End

public:
    const char * filename;

    int line;

    const char * func;

    time_t timestamp;

};  // end of class wxLogRecordInfo


class wxLogChain : wxLog
{
    %Docstring
        LogChain(logger)

        This simple class allows you to chain log sinks, that is to install a
        new sink but keep passing log messages to the old one instead of
        replacing it completely as wxLog::SetActiveTarget does.
    %End
    %TypeHeaderCode
        #include <wx/log.h>
    %End

public:
    wxLogChain(
        wxLog * logger
    );

    virtual
    ~wxLogChain();

    void DetachOldLog();
    %Docstring
        DetachOldLog()

        Detaches the old log target so it won't be destroyed when the
        wxLogChain object is destroyed.
    %End

    wxLog * GetOldLog() const;
    %Docstring
        GetOldLog() -> Log

        Returns the pointer to the previously active log target (which may be
        NULL).
    %End

    bool IsPassingMessages() const;
    %Docstring
        IsPassingMessages() -> bool

        Returns true if the messages are passed to the previously active log
        target (default) or false if PassMessages() had been called.
    %End

    void PassMessages(
        bool passMessages
    );
    %Docstring
        PassMessages(passMessages)

        By default, the log messages are passed to the previously active log
        target.
    %End

    void SetLog(
        wxLog * logger
    );
    %Docstring
        SetLog(logger)

        Sets another log target to use (may be NULL).
    %End

    private:
        wxLogChain(const wxLogChain&);


    private:
        wxLogChain& operator=(const wxLogChain&);


    public:


    %Property(name=OldLog, get=GetOldLog)
};  // end of class wxLogChain


class wxLogInterposer : wxLogChain
{
    %Docstring
        LogInterposer()

        A special version of wxLogChain which uses itself as the new log
        target.
    %End
    %TypeHeaderCode
        #include <wx/log.h>
    %End

public:
    wxLogInterposer();

};  // end of class wxLogInterposer


class wxLogInterposerTemp : wxLogChain
{
    %Docstring
        LogInterposerTemp()

        A special version of wxLogChain which uses itself as the new log
        target.
    %End
    %TypeHeaderCode
        #include <wx/log.h>
    %End

public:
    wxLogInterposerTemp();

};  // end of class wxLogInterposerTemp


class wxLogWindow : wxLogInterposer
{
    %Docstring
        LogWindow(pParent, szTitle, show=True, passToOld=True)

        This class represents a background log window: to be precise, it
        collects all log messages in the log frame which it manages but also
        passes them on to the log target which was active at the moment of its
        creation.
    %End
    %TypeHeaderCode
        #include <wx/log.h>
    %End

public:
    wxLogWindow(
        wxWindow * pParent,
        const wxString & szTitle,
        bool show = true,
        bool passToOld = true
    );

    wxFrame * GetFrame() const;
    %Docstring
        GetFrame() -> Frame

        Returns the associated log frame window.
    %End

    virtual
    bool OnFrameClose(
        wxFrame * frame
    );
    %Docstring
        OnFrameClose(frame) -> bool

        Called if the user closes the window interactively, will not be called
        if it is destroyed for another reason (such as when program exits).
    %End

    virtual
    void OnFrameDelete(
        wxFrame * frame
    );
    %Docstring
        OnFrameDelete(frame)

        Called right before the log frame is going to be deleted: will always
        be called unlike OnFrameClose().
    %End

    void Show(
        bool show = true
    );
    %Docstring
        Show(show=True)

        Shows or hides the frame.
    %End

    public:


    %Property(name=Frame, get=GetFrame)
};  // end of class wxLogWindow


class wxLogStderr : wxLog
{
    %Docstring
        LogStderr()

        This class can be used to redirect the log messages to a C file stream
        (not to be confused with C++ streams).
    %End
    %TypeHeaderCode
        #include <wx/log.h>
    %End

public:
    wxLogStderr(
    );

    private:
        wxLogStderr(const wxLogStderr&);


    private:
        wxLogStderr& operator=(const wxLogStderr&);


};  // end of class wxLogStderr


class wxLogBuffer : wxLog
{
    %Docstring
        LogBuffer()

        wxLogBuffer is a very simple implementation of log sink which simply
        collects all the logged messages in a string (except the debug
        messages which are output in the usual way immediately as we're
        presumably not interested in collecting them for later).
    %End
    %TypeHeaderCode
        #include <wx/log.h>
    %End

public:
    wxLogBuffer();

    virtual
    void Flush();
    %Docstring
        Flush()

        Shows all the messages collected so far to the user (using a message
        box in the GUI applications or by printing them out to the console in
        text mode) and clears the internal buffer.
    %End

    const wxString & GetBuffer() const;
    %Docstring
        GetBuffer() -> String

        Returns the current buffer contains.
    %End

    private:
        wxLogBuffer(const wxLogBuffer&);


    private:
        wxLogBuffer& operator=(const wxLogBuffer&);


    public:


    %Property(name=Buffer, get=GetBuffer)
};  // end of class wxLogBuffer


class wxLogTextCtrl : wxLog
{
    %Docstring
        LogTextCtrl(pTextCtrl)

        Using these target all the log messages can be redirected to a text
        control.
    %End
    %TypeHeaderCode
        #include <wx/log.h>
    %End

public:
    wxLogTextCtrl(
        wxTextCtrl * pTextCtrl
    );

    private:
        wxLogTextCtrl(const wxLogTextCtrl&);


    private:
        wxLogTextCtrl& operator=(const wxLogTextCtrl&);


};  // end of class wxLogTextCtrl


class wxLogFormatter
{
    %Docstring
        LogFormatter()

        wxLogFormatter class is used to format the log messages.
    %End
    %TypeHeaderCode
        #include <wx/log.h>
    %End

public:
    wxLogFormatter();

    virtual
    wxString Format(
        wxLogLevel level,
        const wxString & msg,
        const wxLogRecordInfo & info
    ) const;
    %Docstring
        Format(level, msg, info) -> String

        This function creates the full log message string.
    %End


protected:
    virtual
    wxString FormatTime(
        time_t time
    ) const;
    %Docstring
        FormatTime(time) -> String

        This function formats the time stamp part of the log message.
    %End

};  // end of class wxLogFormatter


void wxSafeShowMessage(
    const wxString & title,
    const wxString & text
);
%Docstring
    SafeShowMessage(title, text)

    This function shows a message to the user in a safe way and should be
    safe to call even before the application has been initialized or if it
    is currently in some other strange state (for example, about to
    crash).
%End

unsigned long wxSysErrorCode();
%Docstring
    SysErrorCode() -> unsignedlong

    Returns the error code from the last system call.
%End

wxString wxSysErrorMsg(
    unsigned long errCode = 0
);
%Docstring
    SysErrorMsg(errCode=0) -> String

    Returns the error message corresponding to the given system error
    code.
%End

void wxLogGeneric(
    wxLogLevel level,
    const wxString& message
);
%Docstring
    LogGeneric(level, message)

    Logs a message with the given wxLogLevel.
%End

void wxLogMessage(
    const wxString& message
);
%Docstring
    LogMessage(message)

    For all normal, informational messages.
%End

void wxLogVerbose(
    const wxString& message
);
%Docstring
    LogVerbose(message)

    For verbose output.
%End

void wxLogWarning(
    const wxString& message
);
%Docstring
    LogWarning(message)

    For warnings - they are also normally shown to the user, but don't
    interrupt the program work.
%End

void wxLogFatalError(
    const wxString& message
);
%Docstring
    LogFatalError(message)

    Like wxLogError(), but also terminates the program with the exit code
    3.
%End

void wxLogError(
    const wxString& message
);
%Docstring
    LogError(message)

    The functions to use for error messages, i.e.
%End

void wxLogDebug(
    const wxString& message
);
%Docstring
    LogDebug(message)

    The right functions for debug output.
%End

void wxLogStatus(
    wxFrame * frame,
    const wxString& message
);
%Docstring
    LogStatus(frame, message)
    LogStatus(message)

    Messages logged by this function will appear in the statusbar of the
    frame or of the top level application window by default (i.e.
%End
void wxLogStatus(
    const wxString& message
);


void wxLogSysError(
    const wxString& message
);
%Docstring
    LogSysError(message)

    Mostly used by wxWidgets itself, but might be handy for logging errors
    after system call (API function) failure.
%End


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