logger.cpp

Go to the documentation of this file.

#include "logger.h"
 
Logger::Logger(Ui::MainWindow* UI_Window)
{
    // Keep a Pointer to the Main Window
    ui = UI_Window;
 
    // Register Custom Meta Types for the "QObject::connect" Definitions
    qRegisterMetaType<REMOTE_LOG_ENTRY>("REMOTE_LOG_ENTRY");
 
    // Setup Severity Names
    severity_name_list << "EMERGENCY" << "ALERT"  << "CRITICAL" << "ERROR"
                       << "WARNING"   << "NOTICE" << "INFO"     << "DEBUG";
 
    // Setup Severity Icon List
    icon_name_list << ":/Resources/Emergency.png" << ":/Resources/Alert.png"  << ":/Resources/Critical.png" << ":/Resources/Error.png"
                   << ":/Resources/Warning.png"   << ":/Resources/Notice.png" << ":/Resources/Info.png"     << ":/Resources/Debug.png";
 
    // Setup Mode Names
    mode_name_list << "SIG_PROC" << "QT"    << "GENERAL" << "THREAD"  << "CONFIG"   << "TIMING"   << "SECURITY"  << "GRAPHICS"
                   << "MEMORY"   << "MATHS" << "FILE"    << "NETWORK" << "OPERATOR" << "DATABASE" << "EXCEPTION" << "SENSOR";
 
    current_severity_mask = ( 1 << (LOG_DEBUG   + 1 ) ) - 1;
    current_mode_mask     = ( 1 << (MODE_SENSOR + 1 ) ) - 1;
    maximum_log_lines     = DEFAULT_MAXIMUM_LOG_LINES;
 
    LoadLogSettings();
}
 
Logger::~Logger()
{
    if (ui->LogSavOnExit->isChecked()) SaveLogSettings();
    severity_name_list.clear();
    icon_name_list.clear();
    mode_name_list.clear();
}
 
void Logger::SaveSeverityMask( int SeverityMask )
{
    current_severity_mask = SeverityMask;
}
 
void Logger::SaveModeMask( int ModeMask )
{
    current_mode_mask = ModeMask;
}
 
void Logger::SetMaxLines( int MaxLogLines )
{
    maximum_log_lines = MaxLogLines;
}
 
void Logger::ClearLog( void )
{
    ui->LogView->clear();
    emit CountChanged( ui->LogView->count() );
}
 
void Logger::SaveLog( void )
{
    // Ask the User for the Name of the File to hold the Log Entries
    QString filename = QFileDialog::getSaveFileName( nullptr, "Save Filename", "LogFile.txt", "Files (*.txt )" );
 
    // If A Filename was provided, write out the log lines, then clear the display.
    if ( filename != "" )
    {
        // Write to the File
        QFile file( filename );
        if (file.open(QIODevice::WriteOnly | QIODevice::Text))
        {
            int row_counter = 0;
            QTextStream out(&file);
            while( row_counter < ui->LogView->count() )
            {
                out << ui->LogView->item( row_counter++ )->text() << "\n";
            }
        }
        file.close();
        ui->LogView->clear();
    }
    emit CountChanged( ui->LogView->count() );
}
 
void Logger::PresetLogSeverity( bool OnOff )
{
    ui->EmergencySelect->setChecked( OnOff );
    ui->AlertSelect->setChecked(     OnOff );
    ui->DebugSelect->setChecked(     OnOff );
    ui->ErrorSelect->setChecked(     OnOff );
    ui->NoticeSelect->setChecked(    OnOff );
    ui->WarningSelect->setChecked(   OnOff );
    ui->CriticalSelect->setChecked(  OnOff );
    ui->InfoSelect->setChecked(      OnOff );
    SaveSeverityMask( true );
 
    if ( OnOff )
    {
        Add( LOG_DEBUG, MODE_OPERATOR, "All Severity Check Boxes Enabled" );
    }
    else
    {
        Add( LOG_DEBUG, MODE_OPERATOR, "All Severity Check Boxes Disabled" );
    }
}
 
void Logger::PresetLogMode( bool OnOff )
{
    ui->SigProcessSelect->setChecked(   OnOff );
    ui->QtSelect->setChecked(           OnOff );
    ui->GeneralSelect->setChecked(      OnOff );
    ui->ThreadSelect->setChecked(       OnOff );
    ui->ConfigSelect->setChecked(       OnOff );
    ui->TimingSelect->setChecked(       OnOff );
    ui->SecuritySelect->setChecked(     OnOff );
    ui->GraphicsSelect->setChecked(     OnOff );
    ui->MemorySelect->setChecked(       OnOff );
    ui->MathsSelect->setChecked(        OnOff );
    ui->FileOpsSelect ->setChecked(     OnOff );
    ui->NetworkCommsSelect->setChecked( OnOff );
    ui->OperatorSelect->setChecked(     OnOff );
    ui->DatabaseSelect->setChecked(     OnOff );
    ui->ExceptionsSelect->setChecked(   OnOff );
    ui->SensorsSelect->setChecked(      OnOff );
    SaveModeMask( true );
 
    if ( OnOff )
    {
        Add( LOG_DEBUG, MODE_OPERATOR, "All Mode Check Boxes Enabled" );
    }
    else
    {
        Add( LOG_DEBUG, MODE_OPERATOR, "All Mode Check Boxes Disabled" );
    }
}
 
void Logger::Add( LOGGING_SEVERITY Severity, LOGGING_MODE Mode, const QString LogMessage )
{
    // Check if the Log message will be added to the Log record based onthe Severity and Mode
    if ( ( ( current_severity_mask & (1 << Severity ) ) != 0 ) && ( ( current_mode_mask & (1 << Mode ) ) != 0 ) )
    {
        // Get the name of the severity icon, the name of the severity level, the name of the mode and the datetime of the entry
        // and place it into a ListWidget Item for inclusion in the Log
        QString icon_name     = icon_name_list.at( Severity );
        QString severity_name = severity_name_list.at( Severity );
        QString mode_name     = mode_name_list.at( Mode );
        QString entry_date    = QDateTime::currentDateTime().toString();
        QString log_entry     = "<" + entry_date + ">[" + severity_name + " : " + mode_name + " ] " +LogMessage;
        QListWidgetItem *item = new QListWidgetItem;
 
        // Put the Icon and Text into the Log Item and add to the Log
        item->setIcon( QIcon( icon_name ) );
        item->setText( log_entry );
        ui->LogView->addItem( item );
 
        // Remove Oldest Item While the Line Count Is Being Exceeded
        while ( ui->LogView->count() > maximum_log_lines )
        {
            ui->LogView->takeItem( 0 );
        }
    }
 
    // Flag the number of Entries in the Log to the Number of Log Lines Display
    emit CountChanged( ui->LogView->count() );
}
 
void Logger::LoadLogSettings( void )
{
    QSettings settings;
 
    ui->MaxLogLines->setValue(          settings.value( "Log_Setup/Allowed_lines", 500   ).toInt()  );
    ui->MaxLogLines->setMinimum(        settings.value( "Log_Setup/Minimum_lines", 20    ).toInt()  );
    ui->MaxLogLines->setMaximum(        settings.value( "Log_Setup/Maximum_lines", 20000 ).toInt()  );
 
    // Set the Connections
    QObject::connect( ui->ModeSelectAll,      SIGNAL( pressed( void ) ), this, SLOT( LogModeAll(      void ) ) );
    QObject::connect( ui->ModeClearAll,       SIGNAL( pressed( void ) ), this, SLOT( LogModeNone(     void ) ) );
    QObject::connect( ui->SeveritySelectAll,  SIGNAL( pressed( void ) ), this, SLOT( LogSeverityAll(  void ) ) );
    QObject::connect( ui->SeverityClearAll,   SIGNAL( pressed( void ) ), this, SLOT( LogSeverityNone( void ) ) );
    QObject::connect( ui->SaveLog,            SIGNAL( pressed( void ) ), this,  SLOT( SaveLog(         void ) ) );
    QObject::connect( ui->ClearLog,           SIGNAL( pressed( void ) ), this,  SLOT( ClearLog(        void ) ) );
    QObject::connect( ui->EmergencySelect,    SIGNAL( clicked( bool ) ), this, SLOT( ReadSeverityMask(  bool ) ) );
    QObject::connect( ui->AlertSelect,        SIGNAL( clicked( bool ) ), this, SLOT( ReadSeverityMask(  bool ) ) );
    QObject::connect( ui->CriticalSelect,     SIGNAL( clicked( bool ) ), this, SLOT( ReadSeverityMask(  bool ) ) );
    QObject::connect( ui->ErrorSelect,        SIGNAL( clicked( bool ) ), this, SLOT( ReadSeverityMask(  bool ) ) );
    QObject::connect( ui->WarningSelect,      SIGNAL( clicked( bool ) ), this, SLOT( ReadSeverityMask(  bool ) ) );
    QObject::connect( ui->NoticeSelect,       SIGNAL( clicked( bool ) ), this, SLOT( ReadSeverityMask(  bool ) ) );
    QObject::connect( ui->InfoSelect,         SIGNAL( clicked( bool ) ), this, SLOT( ReadSeverityMask(  bool ) ) );
    QObject::connect( ui->DebugSelect,        SIGNAL( clicked( bool ) ), this, SLOT( ReadSeverityMask(  bool ) ) );
    QObject::connect( ui->SigProcessSelect,   SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( ui->QtSelect,           SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( ui->GeneralSelect,      SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( ui->ThreadSelect,       SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( ui->ConfigSelect,       SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( ui->TimingSelect,       SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( ui->SecuritySelect,     SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( ui->GraphicsSelect,     SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( ui->MemorySelect,       SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( ui->MathsSelect,        SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( ui->FileOpsSelect,      SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( ui->NetworkCommsSelect, SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( ui->OperatorSelect,     SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( ui->DatabaseSelect,     SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( ui->ExceptionsSelect,   SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( ui->SensorsSelect,      SIGNAL( clicked( bool ) ), this, SLOT( ReadModeMask(      bool ) ) );
    QObject::connect( this,                   SIGNAL( CountChanged( int ) ), ui->LogLineCounter, SLOT( display( int ) ) );
    QObject::connect( ui->LogView,            SIGNAL( itemClicked( QListWidgetItem * ) ), this, SLOT( LogSelectItem( QListWidgetItem * ) ) );
    QObject::connect( ui->AllUnhideLog,       SIGNAL( pressed( void) ), this, SLOT( LogItemsUnhide( void ) ) );
    QObject::connect( ui->MaxLogLines,        SIGNAL( valueChanged( int) ), this, SLOT( UpdateMaxLogLines( int ) ) );
 
    ui->EmergencySelect->setChecked( settings.value( "Log_Severity/Emergency",     true  ).toBool() );
    ui->AlertSelect->setChecked(     settings.value( "Log_Severity/Alert",         true  ).toBool() );
    ui->CriticalSelect->setChecked(  settings.value( "Log_Severity/Critical",      true  ).toBool() );
    ui->ErrorSelect->setChecked(     settings.value( "Log_Severity/Error",         true  ).toBool() );
    ui->WarningSelect->setChecked(   settings.value( "Log_Severity/Warning",       true ).toBool() );
    ui->NoticeSelect->setChecked(    settings.value( "Log_Severity/Notice",        true ).toBool() );
    ui->InfoSelect->setChecked(      settings.value( "Log_Severity/Info",          true ).toBool() );
    ui->DebugSelect->setChecked(     settings.value( "Log_Severity/Debug",         true ).toBool() );
    ReadSeverityMask( true );
 
    // Load the Mode Settings
    ui->SigProcessSelect->setChecked(   settings.value( "Log_Mode/SigProc",        true  ).toBool() );
    ui->QtSelect->setChecked(           settings.value( "Log_Mode/Qt",             true  ).toBool() );
    ui->GeneralSelect->setChecked(      settings.value( "Log_Mode/General",        true  ).toBool() );
    ui->ThreadSelect->setChecked(       settings.value( "Log_Mode/Thread",         true  ).toBool() );
    ui->ConfigSelect->setChecked(       settings.value( "Log_Mode/Configuration",  true  ).toBool() );
    ui->TimingSelect->setChecked(       settings.value( "Log_Mode/Timing",         true  ).toBool() );
    ui->SecuritySelect->setChecked(     settings.value( "Log_Mode/Security",       true  ).toBool() );
    ui->GraphicsSelect->setChecked(     settings.value( "Log_Mode/Graphics",       true  ).toBool() );
    ui->MemorySelect->setChecked(       settings.value( "Log_Mode/Memory",         true  ).toBool() );
    ui->MathsSelect->setChecked(        settings.value( "Log_Mode/Maths",          true  ).toBool() );
    ui->FileOpsSelect->setChecked(      settings.value( "Log_Mode/File",           true  ).toBool() );
    ui->NetworkCommsSelect->setChecked( settings.value( "Log_Mode/Network",        true  ).toBool() );
    ui->OperatorSelect->setChecked(     settings.value( "Log_Mode/Operator",       true  ).toBool() );
    ui->DatabaseSelect->setChecked(     settings.value( "Log_Mode/Database",       true  ).toBool() );
    ui->ExceptionsSelect->setChecked(   settings.value( "Log_Mode/Exception",      true  ).toBool() );
    ui->SensorsSelect->setChecked(      settings.value( "Log_Mode/Sensors",        true  ).toBool() );
    ReadModeMask( true );
}
 
// Read Severity Mask
void Logger::ReadSeverityMask( bool Unused )
{
    int severity_mask = 0;
 
    if ( ui->EmergencySelect->isChecked() )
    {
        severity_mask |= 1 << LOG_EMERGENCY;
    }
    else
    {
        severity_mask &= ~(1 << LOG_EMERGENCY);
    }
 
    if ( ui->AlertSelect->isChecked() )
    {
        severity_mask |= 1 << LOG_ALERT;
    }
    else
    {
        severity_mask &= ~(1 << LOG_ALERT);
    }
 
    if ( ui->CriticalSelect->isChecked() )
    {
        severity_mask |= 1 << LOG_CRITICAL;
    }
    else
    {
        severity_mask &= ~(1 << LOG_CRITICAL);
    }
 
    if ( ui->ErrorSelect->isChecked() )
    {
        severity_mask |= 1 << LOG_ERROR;
    }
    else
    {
        severity_mask &= ~(1 << LOG_ERROR);
    }
 
    if ( ui->WarningSelect->isChecked() )
    {
        severity_mask |= 1 << LOG_WARNING;
    }
    else
    {
        severity_mask &= ~(1 << LOG_WARNING);
    }
 
    if ( ui->NoticeSelect->isChecked() )
    {
        severity_mask |= 1 << LOG_NOTICE;
    }
    else
    {
        severity_mask &= ~(1 << LOG_NOTICE);
    }
 
    if ( ui->InfoSelect->isChecked() )
    {
        severity_mask |= 1 << LOG_INFO;
    }
    else
    {
        severity_mask &= ~(1 << LOG_INFO);
    }
 
    if ( ui->DebugSelect->isChecked() )
    {
        severity_mask |= 1 << LOG_DEBUG;
    }
    else
    {
        severity_mask &= ~(1 << LOG_DEBUG);
    }
    SaveSeverityMask( severity_mask );
}
 
void Logger::ReadModeMask( bool Unused )
{
    int mode_mask = 0;
 
    if ( ui->SigProcessSelect->isChecked() )
    {
        mode_mask |= 1 << MODE_SIG_PROC;
    }
    else
    {
        mode_mask &= ~(1 << MODE_SIG_PROC);
    }
    if ( ui->QtSelect->isChecked() )
    {
        mode_mask |= 1 << MODE_QT;
    }
    else
    {
        mode_mask &= ~(1 << MODE_QT);
    }
 
    if ( ui->GeneralSelect->isChecked() )
    {
        mode_mask |= 1 << MODE_GENERAL;
    }
    else
    {
        mode_mask &= ~(1 << MODE_GENERAL);
    }
 
    if ( ui->ThreadSelect->isChecked() )
    {
        mode_mask |= 1 << MODE_THREAD;
    }
    else
    {
        mode_mask &= ~(1 << MODE_THREAD);
    }
 
    if ( ui->ConfigSelect->isChecked() )
    {
        mode_mask |= 1 << MODE_CONFIG;
    }
    else
    {
        mode_mask &= ~(1 << MODE_CONFIG);
    }
 
    if ( ui->TimingSelect->isChecked() )
    {
        mode_mask |= 1 << MODE_TIMING;
    }
    else
    {
        mode_mask &= ~(1 << MODE_TIMING);
    }
 
    if ( ui->SecuritySelect->isChecked() )
    {
        mode_mask |= 1 << MODE_SECURITY;
    }
    else
    {
        mode_mask &= ~(1 << MODE_SECURITY);
    }
 
    if ( ui->GraphicsSelect->isChecked() )
    {
        mode_mask |= 1 << MODE_GRAPHICS;
    }
    else
    {
        mode_mask &= ~(1 << MODE_GRAPHICS);
    }
 
    if ( ui->MemorySelect->isChecked() )
    {
        mode_mask |= 1 << MODE_MEMORY;
    }
    else
    {
        mode_mask &= ~(1 << MODE_MEMORY);
    }
 
    if ( ui->MathsSelect->isChecked() )
    {
        mode_mask |= 1 << MODE_MATHS;
    }
    else
    {
        mode_mask &= ~(1 << MODE_MATHS);
    }
 
    if ( ui->FileOpsSelect->isChecked() )
    {
        mode_mask |= 1 << MODE_FILE;
    }
    else
    {
        mode_mask &= ~(1 << MODE_FILE);
    }
 
    if ( ui->NetworkCommsSelect->isChecked() )
    {
        mode_mask |= 1 << MODE_NETWORK;
    }
    else
    {
        mode_mask &= ~(1 << MODE_NETWORK);
    }
 
    if ( ui->OperatorSelect->isChecked() )
    {
        mode_mask |= 1 << MODE_OPERATOR;
    }
    else
    {
        mode_mask &= ~(1 << MODE_OPERATOR);
    }
 
    if ( ui->DatabaseSelect->isChecked() )
    {
        mode_mask |= 1 << MODE_DATABASE;
    }
    else
    {
        mode_mask &= ~(1 << MODE_DATABASE);
    }
 
    if ( ui->ExceptionsSelect->isChecked() )
    {
        mode_mask |= 1 << MODE_EXCEPTION;
    }
    else
    {
        mode_mask &= ~(1 << MODE_EXCEPTION);
    }
 
    if ( ui->SensorsSelect->isChecked() )
    {
        mode_mask |= 1 << MODE_SENSOR;
    }
    else
    {
        mode_mask &= ~(1 << MODE_SENSOR);
    }
    SaveModeMask( mode_mask );
}
 
void Logger::LogSelectItem( QListWidgetItem * Item )
{
    // If Hidden Selected, Hide the Log Line
    if ( ui->HideSelectedLog->isChecked() )
    {
        Item->setHidden( true );
    }
}
 
void Logger::LogModeAll( void )
{
    PresetLogMode( true );
}
 
void Logger::LogModeNone( void )
{
    PresetLogMode( false );
}
 
void Logger::LogSeverityAll( void )
{
    PresetLogSeverity( true );
}
 
void Logger::LogSeverityNone( void )
{
    PresetLogSeverity( false );
}
 
void Logger::LogItemsUnhide( void )
{
    for ( int row = 0; row < ui->LogView->count(); ++row )
    {
        QListWidgetItem *item = ui->LogView->item( row );
        if ( item != nullptr )
        {
            item->setHidden( false );
        }
    }
}
 
void Logger::UpdateMaxLogLines( int Value )
{
    SetMaxLines( Value );
}
 
void Logger::SaveLogSettings( void )
{
    QSettings settings;
 
    // Save the Log Severity Settings
    settings.setValue( "Log_Severity/Emergency", ui->EmergencySelect->isChecked()    );
    settings.setValue( "Log_Severity/Alert",     ui->AlertSelect->isChecked()        );
    settings.setValue( "Log_Severity/Critical",  ui->CriticalSelect->isChecked()     );
    settings.setValue( "Log_Severity/Error",     ui->ErrorSelect->isChecked()        );
    settings.setValue( "Log_Severity/Warning",   ui->WarningSelect->isChecked()      );
    settings.setValue( "Log_Severity/Notice",    ui->NoticeSelect->isChecked()       );
    settings.setValue( "Log_Severity/Info",      ui->InfoSelect->isChecked()         );
    settings.setValue( "Log_Severity/Debug",     ui->DebugSelect->isChecked()        );
 
 
    // Save the Mode Settings
    settings.setValue( "Log_Mode/SigProc",       ui->SigProcessSelect->isChecked()   );
    settings.setValue( "Log_Mode/Qt",            ui->QtSelect->isChecked()           );
    settings.setValue( "Log_Mode/General",       ui->GeneralSelect->isChecked()      );
    settings.setValue( "Log_Mode/Thread",        ui->ThreadSelect->isChecked()       );
    settings.setValue( "Log_Mode/Configuration", ui->ConfigSelect->isChecked()       );
    settings.setValue( "Log_Mode/Timing",        ui->TimingSelect->isChecked()       );
    settings.setValue( "Log_Mode/Security",      ui->SecuritySelect->isChecked()     );
    settings.setValue( "Log_Mode/Graphics",      ui->GraphicsSelect->isChecked()     );
    settings.setValue( "Log_Mode/Memory",        ui->MemorySelect->isChecked()       );
    settings.setValue( "Log_Mode/Maths",         ui->MathsSelect->isChecked()        );
    settings.setValue( "Log_Mode/File",          ui->FileOpsSelect->isChecked()      );
    settings.setValue( "Log_Mode/Network",       ui->NetworkCommsSelect->isChecked() );
    settings.setValue( "Log_Mode/Operator",      ui->OperatorSelect->isChecked()     );
    settings.setValue( "Log_Mode/Database",      ui->DatabaseSelect->isChecked()     );
    settings.setValue( "Log_Mode/Exception",     ui->ExceptionsSelect->isChecked()   );
    settings.setValue( "Log_Mode/Sensors",       ui->SensorsSelect->isChecked()      );
 
    // Save Log Parameters
    settings.setValue( "Log_Setup/Allowed_lines", ui->MaxLogLines->value()           );
    settings.setValue( "Log_Setup/Minimum_lines", ui->MaxLogLines->minimum()         );
    settings.setValue( "Log_Setup/Maximum_lines", ui->MaxLogLines->maximum()         );
}
 
void Logger::RemoteLog( REMOTE_LOG_ENTRY LogEntry )
{
    Add( LogEntry.Severity, LogEntry.Mode, LogEntry.Message );
}