VRUT::FlexiLog Class Reference

Logging class with file and window output. More...

#include <flexilog.h>

List of all members.

Public Member Functions

 FlexiLog (wxTextCtrl *_textCtrl)
 Class constructor.
virtual ~FlexiLog ()
 Class destructor.
void SyncEveryMsg (bool enable=true)
wxTextCtrl * GetTextCtrl () const
 Get text control.
virtual void DoLog (wxLogLevel level, const wxChar *msg, time_t timestamp)
void SetStatusText (const wxString &status)
 Set status text in log window.
void LogMessage (const wxString &msg, wxLogLevel loglevel)
 Log message thread safe - adds log event to be processed later if not main thread.

Static Public Member Functions

static FlexiLog * GetInstance ()
 Get active log instance only if it is FlexiLog, NULL otherwise.
static void LogMessageFlexi (const wxString &msg, wxLogLevel loglevel)
 Log message to active log target only if it is FlexiLog (using FlexiLog::LogMessage).
static void SetTextCtrlLogging (bool enable)
 Enable or disable logging to text control window.

Protected Attributes

wxTextCtrl * textCtrl
 Text control window.
wxFileOutputStream * dbgout
 Output file stream.
wxTextOutputStream * dout
 Output text stream.
bool logToTextCtrl
 Log to text control window?
bool syncEveryMsg
 Sync log file after every log message?
Kernel * kernel
 Auxiliary kernel instance pointer - eg. enables kernel access when logging from modules.

Friends

class Kernel

Detailed Description

Logging class with file and window output.

Definition at line 35 of file flexilog.h.

Constructor & Destructor Documentation

FlexiLog::FlexiLog ( wxTextCtrl *  _textCtrl  ) 

Class constructor.

Definition at line 22 of file flexilog.cpp.

00023               : wxLogTextCtrl(_textCtrl),
00024               textCtrl(_textCtrl),
00025               dbgout((wxFileOutputStream *)NULL), dout((wxTextOutputStream *)NULL)
00026 {
00027        syncEveryMsg = false;
00028        kernel = (Kernel *)NULL;
00029        SetLogLevel(wxLOG_Max);
00030        SetVerbose(true);
00031        logToTextCtrl = true;
00032        dbgout = new wxFileOutputStream(LOGFILE);
00033        if (dbgout && dbgout->IsOk())
00034               dout = new wxTextOutputStream(*dbgout);
00035        else
00036               LogMessage(wxT("<FlexiLog>Logging to file disabled"), wxLOG_Warning);
00037 }

FlexiLog::~FlexiLog (  )  [virtual]

Class destructor.

Definition at line 40 of file flexilog.cpp.

00041 {
00042        SAFE_DELETE(dout);
00043        if (dbgout)
00044               dbgout->Close();
00045        SAFE_DELETE(dbgout);
00046 }

Member Function Documentation

FlexiLog * FlexiLog::GetInstance (  )  [static]

Get active log instance only if it is FlexiLog, NULL otherwise.

Definition at line 49 of file flexilog.cpp.

00050 {
00051        wxLog * logInst = wxLog::GetActiveTarget();
00052        if (logInst)
00053               return dynamic_cast<FlexiLog *>(logInst);
00054 
00055        return (FlexiLog *)NULL;
00056 }

void FlexiLog::LogMessageFlexi ( const wxString &  msg,
wxLogLevel  loglevel 
) [static]

Log message to active log target only if it is FlexiLog (using FlexiLog::LogMessage).

Definition at line 59 of file flexilog.cpp.

00060 {
00061        FlexiLog * logInst = GetInstance();
00062        if (logInst)
00063               logInst->LogMessage(msg, loglevel);
00064 }

static void VRUT::FlexiLog::SetTextCtrlLogging ( bool  enable  )  [inline, static]

Enable or disable logging to text control window.

Definition at line 62 of file flexilog.h.

00063               {
00064                      FlexiLog * logInst = GetInstance();
00065                      if (logInst)
00066                             logInst->logToTextCtrl = enable;
00067               }

void VRUT::FlexiLog::SyncEveryMsg ( bool  enable = true  )  [inline]

Definition at line 68 of file flexilog.h.

00069               {
00070                      syncEveryMsg = enable;
00071               }

wxTextCtrl* VRUT::FlexiLog::GetTextCtrl (  )  const [inline]

Get text control.

Definition at line 73 of file flexilog.h.

00074               {
00075                      return textCtrl;
00076               }

void FlexiLog::DoLog ( wxLogLevel  level,
const wxChar *  msg,
time_t  timestamp 
) [virtual]

Log message - wxLogTextCtrl overload

Parameters:
[in] level Message importance
[in] msg Message to log
[in] timestamp Time information

Definition at line 67 of file flexilog.cpp.

00068 {
00069        if (dout)
00070        {
00071               wxString prep;
00072               TimeStamp(&prep);
00073               switch (level)
00074               {
00075               case wxLOG_FatalError:
00076               case wxLOG_Error:
00077                      prep.Append(wxT("Error: "));
00078                      break;
00079               case wxLOG_Warning:
00080                      prep.Append(wxT("Warning: "));
00081                      break;
00082               case wxLOG_Debug:
00083                      prep.Append(wxT("Debug: "));
00084                      break;
00085               case wxLOG_Info:
00086               case wxLOG_Message:
00087               case wxLOG_Status:
00088               case wxLOG_Trace:
00089               case wxLOG_Progress:
00090               default:
00091                      break;
00092               }
00093               *dout << prep << msg << wxT('\n');
00094               if (syncEveryMsg)
00095                      dbgout->Sync();
00096        }
00097 
00098        if (logToTextCtrl)
00099        {
00100               switch (level)
00101               {
00102               case wxLOG_FatalError:
00103               case wxLOG_Error:
00104                      textCtrl->SetDefaultStyle(wxTextAttr(*wxRED));
00105                      break;
00106               case wxLOG_Warning:
00107                      textCtrl->SetDefaultStyle(wxTextAttr(wxColour(128, 0, 0)));
00108                      break;
00109               case wxLOG_Info:
00110               case wxLOG_Debug:
00111               case wxLOG_Trace:
00112               case wxLOG_Progress:
00113                      textCtrl->SetDefaultStyle(wxTextAttr(wxColour(0, 128, 0)));
00114                      break;
00115               case wxLOG_Message:
00116               case wxLOG_Status:
00117               default:
00118                      textCtrl->SetDefaultStyle(wxTextAttr(*wxBLACK));
00119                      break;
00120               }
00121               wxLogTextCtrl::DoLog(level, msg, timestamp);
00122        }
00123 }

void FlexiLog::SetStatusText ( const wxString &  status  ) 

Set status text in log window.

Definition at line 126 of file flexilog.cpp.

00127 {
00128        if (textCtrl &&      textCtrl->GetParent())
00129               if (textCtrl->GetParent()->IsKindOf(CLASSINFO(wxFrame)))
00130                      ((wxFrame *)textCtrl->GetParent())->SetStatusText(status);
00131 }

void FlexiLog::LogMessage ( const wxString &  msg,
wxLogLevel  loglevel 
)

Log message thread safe - adds log event to be processed later if not main thread.

Definition at line 134 of file flexilog.cpp.

00135 {
00136        if (!kernel || kernel->GetMainThreadID() == wxThread::GetCurrentId())
00137        {
00138               switch (loglevel)
00139               {
00140               case wxLOG_FatalError:
00141                      wxLogFatalError(msg);
00142                      break;
00143               case wxLOG_Error:
00144                      wxLogError(msg);
00145                      break;
00146               case wxLOG_Warning:
00147                      wxLogWarning(msg);
00148                      break;
00149               case wxLOG_Info:
00150                      wxLogVerbose(msg);
00151                      break;
00152               case wxLOG_Debug:
00153                      wxLogDebug(msg);
00154                      break;
00155               case wxLOG_Trace:
00156               case wxLOG_Progress:
00157               case wxLOG_Message:
00158                      wxLogMessage(msg);
00159                      break;
00160               case wxLOG_Status:
00161                      wxLogStatus(msg);
00162                      break;
00163               }
00164        }
00165        else
00166        {
00167               wxCommandEvent ev = Event::GET_EVT_LOG(msg + wxT(" [async]"), loglevel);
00168               kernel->GetMessageSink()->PostEvent(ev);
00169        }
00170 }

Friends And Related Function Documentation

friend class Kernel [friend]

Definition at line 87 of file flexilog.h.

Member Data Documentation

wxTextCtrl* VRUT::FlexiLog::textCtrl [protected]

Text control window.

Definition at line 39 of file flexilog.h.

wxFileOutputStream* VRUT::FlexiLog::dbgout [protected]

Output file stream.

Definition at line 41 of file flexilog.h.

wxTextOutputStream* VRUT::FlexiLog::dout [protected]

Output text stream.

Definition at line 43 of file flexilog.h.

bool VRUT::FlexiLog::logToTextCtrl [protected]

Log to text control window?

Definition at line 45 of file flexilog.h.

bool VRUT::FlexiLog::syncEveryMsg [protected]

Sync log file after every log message?

Definition at line 47 of file flexilog.h.

Kernel* VRUT::FlexiLog::kernel [protected]

Auxiliary kernel instance pointer - eg. enables kernel access when logging from modules.

Definition at line 49 of file flexilog.h.

The documentation for this class was generated from the following files:
Generated on Tue Mar 10 14:41:42 2009 for VRUT by  doxygen 1.5.5