#include "CANbusSettingsPage.h"
#include "ui_CANbusSettingsPage.h"

#include "CANDevice.h"
#include <QFileDialog>
#include <QFileInfo>
#include "SystemConfig.h"
#include "OtarcikCan.h"


CCANbusSettingsPage::CCANbusSettingsPage(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::CCANbusSettingsPage)
{
    ui->setupUi(this);

    mProgramPtr = 0;
    mDevicesList = 0;
    mCurModifiedDevConfig = 0;
    mDeviceChangeModeEnabled = false;

    ui->mDBSignalDetailsTable->setColumnCount(11);
    ui->mDBSignalDetailsTable->setHorizontalHeaderLabels(QStringList() << "Signal" << "Bit No" << "Length" << "Type" << "Max Val" << "Min Val" << "Offset" << "Scale factor" << "Unit" << "Byte order" << "Comment");

    ui->mDevicePollPeriodSpinBx->setRange(200,60000);


    ui->mCANBaudrateComboBx->clear();
    ui->mCANBaudrateComboBx->addItem("PCAN_BAUD_1M",QVariant(PCAN_BAUD_1M));
    ui->mCANBaudrateComboBx->addItem("PCAN_BAUD_800K",QVariant(PCAN_BAUD_800K));
    ui->mCANBaudrateComboBx->addItem("PCAN_BAUD_500K",QVariant(PCAN_BAUD_500K));
    ui->mCANBaudrateComboBx->addItem("PCAN_BAUD_250K",QVariant(PCAN_BAUD_250K));
    ui->mCANBaudrateComboBx->addItem("PCAN_BAUD_125K",QVariant(PCAN_BAUD_125K));
    ui->mCANBaudrateComboBx->addItem("PCAN_BAUD_100K",QVariant(PCAN_BAUD_100K));
    ui->mCANBaudrateComboBx->addItem("PCAN_BAUD_95K",QVariant(PCAN_BAUD_95K));
    ui->mCANBaudrateComboBx->addItem("PCAN_BAUD_83K",QVariant(PCAN_BAUD_83K));
    ui->mCANBaudrateComboBx->addItem("PCAN_BAUD_50K",QVariant(PCAN_BAUD_50K));
    ui->mCANBaudrateComboBx->addItem("PCAN_BAUD_47K",QVariant(PCAN_BAUD_47K));
    ui->mCANBaudrateComboBx->addItem("PCAN_BAUD_33K",QVariant(PCAN_BAUD_33K));
    ui->mCANBaudrateComboBx->addItem("PCAN_BAUD_20K",QVariant(PCAN_BAUD_20K));
    ui->mCANBaudrateComboBx->addItem("PCAN_BAUD_10K",QVariant(PCAN_BAUD_10K));
    ui->mCANBaudrateComboBx->addItem("PCAN_BAUD_5K",QVariant(PCAN_BAUD_5K));


   /* ui->mCANIDComboBx->addItem("PCAN_USBBUS1",QVariant(PCAN_USBBUS1));
    ui->mCANIDComboBx->addItem("PCAN_USBBUS2",QVariant(PCAN_USBBUS2));
    ui->mCANIDComboBx->addItem("PCAN_USBBUS3",QVariant(PCAN_USBBUS3));
    ui->mCANIDComboBx->addItem("PCAN_USBBUS4",QVariant(PCAN_USBBUS4));
    ui->mCANIDComboBx->addItem("PCAN_USBBUS5",QVariant(PCAN_USBBUS5));
    ui->mCANIDComboBx->addItem("PCAN_USBBUS6",QVariant(PCAN_USBBUS6));
    ui->mCANIDComboBx->addItem("PCAN_USBBUS7",QVariant(PCAN_USBBUS7));
    ui->mCANIDComboBx->addItem("PCAN_USBBUS8",QVariant(PCAN_USBBUS8));
    ui->mCANIDComboBx->addItem("PCAN_USBBUS9",QVariant(PCAN_USBBUS9));
    ui->mCANIDComboBx->addItem("PCAN_USBBUS10",QVariant(PCAN_USBBUS10));
    ui->mCANIDComboBx->addItem("PCAN_USBBUS11",QVariant(PCAN_USBBUS11));
    ui->mCANIDComboBx->addItem("PCAN_USBBUS12",QVariant(PCAN_USBBUS12));
    ui->mCANIDComboBx->addItem("PCAN_USBBUS13",QVariant(PCAN_USBBUS13));
    ui->mCANIDComboBx->addItem("PCAN_USBBUS14",QVariant(PCAN_USBBUS14));
    ui->mCANIDComboBx->addItem("PCAN_USBBUS15",QVariant(PCAN_USBBUS15));
    ui->mCANIDComboBx->addItem("PCAN_USBBUS16",QVariant(PCAN_USBBUS16));*/


    ui->mDeviceDescriptionTxtEdit->setEnabled(false);
    ui->mDatabaseFileSelectBtn->hide();
    ui->mCANBaudrateComboBx->setEnabled(false);
    //ui->mCANIDComboBx->setEnabled(false);
    ui->mCANDeviceIDSpinBx->setValue(1);
    ui->mCANDeviceIDSpinBx->setEnabled(false);  //JFM 2023-06-02
    ui->mDevicePollPeriodSpinBx->setEnabled(false);
    ui->mCancelModifyParamsBtn->hide();
    ui->mDeviceNameEditBx->setEnabled(false);
    ui->mWatchdogPollPeriodSpinBx->setEnabled(false);
    ui->mWatchdogMsgIDSpinBx->setEnabled(false);
    ui->mCANDeviceWatchdogActivateChkBx->setEnabled(false);


    connect(ui->mDevicesList,&QListWidget::itemSelectionChanged,this,&CCANbusSettingsPage::DeviceSelectionChanged);
    connect(ui->mDBMessagesListWidget,&QListWidget::itemSelectionChanged,this,&CCANbusSettingsPage::MessageSelectionChanged);
    connect(ui->mModifyDevParamsBtn,&QPushButton::clicked,this,&CCANbusSettingsPage::ModifyDeviceBtnPressed);
    connect(ui->mCancelModifyParamsBtn,&QPushButton::clicked,this,&CCANbusSettingsPage::CancelModifyDevBtnPressed);
    connect(ui->mDatabaseFileSelectBtn,&QPushButton::clicked,this,&CCANbusSettingsPage::SelectDBFileBtnPressed);
    connect(ui->mAddDeviceBtn,&QPushButton::clicked,this,&CCANbusSettingsPage::AddDeviceBtnPressed);
    connect(ui->mDeleteDeviceBtn,&QPushButton::clicked,this,&CCANbusSettingsPage::DeleteDeviceBtnPressed);
    connect(ui->mCANDeviceWatchdogActivateChkBx,&QCheckBox::stateChanged,this,&CCANbusSettingsPage::WatchdogActivationBoxChanged);


}

CCANbusSettingsPage::~CCANbusSettingsPage()
{
    while(!mDeviceConfigList.isEmpty())
    {
        delete mDeviceConfigList.takeFirst();
    }

    delete ui;
}

int CCANbusSettingsPage::SetDevicesList(QList<CCANDevice *> *DevicesList)
{
    if(DevicesList == 0)
    {
        return RET_GENERAL_ERROR;
    }

    mDevicesList = DevicesList;

    if(mDevicesList == 0)
    {
        return RET_GENERAL_ERROR;
    }

    ui->mDevicesList->clear();
    for(int i = 0; i < mDevicesList->size(); i++)
    {
        QString name = mDevicesList->at(i)->mDeviceConfigInfo.mDeviceName;
        if(name.isEmpty())
        {
            name = QString("Device %1").arg(i+1);
        }
        ui->mDevicesList->addItem(name);
    }
    ui->mDevicesList->setCurrentRow(0);



    return RET_OK;
}

int CCANbusSettingsPage::ClearDatabaseData()
{
    ui->mDBMessagesListWidget->clear();
    return RET_OK;
}

int CCANbusSettingsPage::UpdatePage()
{
    int index = ui->mDevicesList->currentRow();

    if(index < 0 || index >= mDevicesList->size())
    {
        return RET_GENERAL_ERROR;
    }

    CCANDevice *Device = mDevicesList->at(index);


    if(Device != 0)
    {
        CCANDeviceConfig *DevConfigInfo = &Device->mDeviceConfigInfo;
        //Update device name in the list (it might have just changed)
        ui->mDevicesList->item(ui->mDevicesList->currentRow())->setText(DevConfigInfo->mDeviceName);
        //update device information
        ui->mDeviceNameEditBx->setPlainText(DevConfigInfo->mDeviceName);
        ui->mCANBaudrateComboBx->setCurrentIndex(ui->mCANBaudrateComboBx->findData(DevConfigInfo->mCANDeviceBaudrate));

        //ui->mCANIDComboBx->setCurrentIndex(ui->mCANIDComboBx->findData(DevConfigInfo->mCANDeviceID)); //JFM 2023-06-02
        ui->mCANDeviceIDSpinBx->setValue(DevConfigInfo->mCANDeviceID);

        ui->mDeviceDescriptionTxtEdit->setPlainText(DevConfigInfo->mDeviceDescription);

        QFileInfo FileInfo(DevConfigInfo->mCANDeviceDatabaseFilename);
        ui->mDatabaseFileNameLbl->setText(FileInfo.fileName());
        ui->mDatabaseFileNameLbl->setToolTip(DevConfigInfo->mCANDeviceDatabaseFilename);
//        ui->mDatabaseFileNameLbl->setText(QString("%1").arg(Device->mCANDeviceDatabaseFilename));

        ui->mDevicePollPeriodSpinBx->setValue(DevConfigInfo->mDevicePollPeriod);

        if(DevConfigInfo->mDeviceWatchdogActivated == true)
        {
            disconnect(ui->mCANDeviceWatchdogActivateChkBx,&QCheckBox::stateChanged,this,&CCANbusSettingsPage::WatchdogActivationBoxChanged);
            ui->mCANDeviceWatchdogActivateChkBx->setCheckState(Qt::Checked);
            connect(ui->mCANDeviceWatchdogActivateChkBx,&QCheckBox::stateChanged,this,&CCANbusSettingsPage::WatchdogActivationBoxChanged);
            ui->mWatchdogMsgIDSpinBx->setValue(DevConfigInfo->mWatchdogCANMsgID);
            ui->mWatchdogPollPeriodSpinBx->setValue(DevConfigInfo->mWatchdogPeriod);
        }
        else
        {
            disconnect(ui->mCANDeviceWatchdogActivateChkBx,&QCheckBox::stateChanged,this,&CCANbusSettingsPage::WatchdogActivationBoxChanged);
            ui->mCANDeviceWatchdogActivateChkBx->setCheckState(Qt::Unchecked);
            connect(ui->mCANDeviceWatchdogActivateChkBx,&QCheckBox::stateChanged,this,&CCANbusSettingsPage::WatchdogActivationBoxChanged);
            ui->mWatchdogMsgIDSpinBx->setValue(1);
            ui->mWatchdogPollPeriodSpinBx->setValue(100);
        }

        //update device database information
         ui->mDBMessagesListWidget->clear();
         ui->mDBSignalDetailsTable->clearContents();
         ui->mDBSignalDetailsTable->setRowCount(0);
        if(Device->mMessageList.isEmpty())
        {
            ui->mDBMessagesListWidget->insertItem(0,"Aucun message");
            ui->mDBMessageIDLbl->setText("Message ID: ");
            ui->mDBMessageLengthLbl->setText("Message Length: ");
            ui->mDBMessageNameLbl->setText("Message Name: ");
            ui->mDBMessageNbSignalsLbl->setText("Number of signals: ");
            ui->mDBMessageCommentLbl->setText("Comment: ");
        }
        else
        {
            ui->mDBMessagesListWidget->clear();
            for(int msg = 0; msg < Device->mMessageList.size(); msg++)
            {
                ui->mDBMessagesListWidget->insertItem(msg,Device->mMessageList.at(msg)->mCANMsgName);
            }

            ui->mDBMessagesListWidget->setCurrentRow(0);
        }


    }



    return RET_OK;
}

int CCANbusSettingsPage::UpdateMessageInformation()
{
    int index = ui->mDevicesList->currentRow();

    if(index < 0 || index >= mDevicesList->size())
    {
        return RET_GENERAL_ERROR;
    }

    CCANDevice *Device = mDevicesList->at(index);


    if(Device != 0)
    {
        int MsgIndex = ui->mDBMessagesListWidget->currentRow();

        if(MsgIndex < 0 || MsgIndex >= Device->mMessageList.size())
        {
            return RET_GENERAL_ERROR;
        }

        CCANMessage *Message = Device->mMessageList.at(MsgIndex);

        ui->mDBMessageIDLbl->setText(QString("Message ID: 0x%1").arg(Message->mCANMsgID,0,16));
        ui->mDBMessageLengthLbl->setText(QString("Message Length: %1").arg(Message->mCANMsgLength));
        ui->mDBMessageNameLbl->setText(QString("Message Name: %1").arg(Message->mCANMsgName));
        ui->mDBMessageNbSignalsLbl->setText(QString("Number of signals: %1").arg(Message->mSignalsList.size()));
        ui->mDBMessageCommentLbl->setText(QString("Comment: %1").arg(Message->mCANMsgComment));

        ui->mDBSignalDetailsTable->clearContents();
        ui->mDBSignalDetailsTable->setRowCount(0);

         ui->mDBSignalDetailsTable->setRowCount(Message->mSignalsList.size());
        for(int Sig = 0; Sig < Message->mSignalsList.size(); Sig++)
        {
           CCANSignal Signal = Message->mSignalsList.at(Sig);
           QTableWidgetItem *NewItem;

           //Signal name
           NewItem = new QTableWidgetItem(Signal.mSignalName);
           ui->mDBSignalDetailsTable->setItem(Sig,0,NewItem);

           //Bit No
           NewItem = new QTableWidgetItem(QString("%1").arg(Signal.mStartBit));
           ui->mDBSignalDetailsTable->setItem(Sig,1,NewItem);

           //Length
           NewItem = new QTableWidgetItem(QString("%1").arg(Signal.mSignalSize));
           ui->mDBSignalDetailsTable->setItem(Sig,2,NewItem);

           //Type
           switch(Signal.mValueType)
           {
               case CCANSignal::CAN_SIGNAL_TYPE_INVALID:
               {
                   NewItem = new QTableWidgetItem(QString("INVALIDE"));
                   break;
               }
               case CCANSignal::CAN_SIGNAL_TYPE_SIGNED_INT:
               {
                   NewItem = new QTableWidgetItem(QString("int"));
                   break;
               }
               case CCANSignal::CAN_SIGNAL_TYPE_UNSIGNED_INT:
               {
                   NewItem = new QTableWidgetItem(QString("uint"));
                   break;
               }
               case CCANSignal::CAN_SIGNAL_TYPE_32_BIT_FLOAT:
               {
                   NewItem = new QTableWidgetItem(QString("Float_32"));
                   break;
               }
               case CCANSignal::CAN_SIGNAL_TYPE_64_BIT_DOUBLE:
               {
                   NewItem = new QTableWidgetItem(QString("Double"));
                   break;
               }
           }
           ui->mDBSignalDetailsTable->setItem(Sig,3,NewItem);

           //Max Val
          NewItem = new QTableWidgetItem(QString("%1").arg(Signal.mMaxValue));
           ui->mDBSignalDetailsTable->setItem(Sig,4,NewItem);

           //Min Val
           NewItem = new QTableWidgetItem(QString("%1").arg(Signal.mMinValue));
           ui->mDBSignalDetailsTable->setItem(Sig,5,NewItem);

           //Offset
           NewItem = new QTableWidgetItem(QString("%1").arg(Signal.mValueOffset));
           ui->mDBSignalDetailsTable->setItem(Sig,6,NewItem);

           //Scale Factor
           NewItem = new QTableWidgetItem(QString("%1").arg(Signal.mValueFactor,0,'f',1));
           ui->mDBSignalDetailsTable->setItem(Sig,7,NewItem);

           //Unit
           NewItem = new QTableWidgetItem(Signal.mSignalUnit);
           ui->mDBSignalDetailsTable->setItem(Sig,8,NewItem);

           //Endian
           switch(Signal.mEncoding)
           {
               case CCANSignal::CAN_SIGNAL_ENCODING_INTEL:
               {
                    NewItem = new QTableWidgetItem(QString("Intel"));
                   break;
               }
               case CCANSignal::CAN_SIGNAL_ENCODING_MOTOROLA:
               {
                   NewItem = new QTableWidgetItem(QString("Motorola"));
                   break;
               }
               case CCANSignal::CAN_SIGNAL_ENCODING_INVALID:
               {
                   NewItem = new QTableWidgetItem(QString("INVALID"));
                   break;
               }
           }

           ui->mDBSignalDetailsTable->setItem(Sig,9,NewItem);

           //Comment
           NewItem = new QTableWidgetItem(Signal.mSignalComment);
           ui->mDBSignalDetailsTable->setItem(Sig,10,NewItem);

        }
        ui->mDBSignalDetailsTable->resizeColumnsToContents();
    }

    return RET_OK;
}

void CCANbusSettingsPage::DeviceSelectionChanged()
{
    UpdatePage();
}

void CCANbusSettingsPage::SignalSelectionChanged()
{

}

void CCANbusSettingsPage::MessageSelectionChanged()
{
    UpdateMessageInformation();
}
void CCANbusSettingsPage::ModifyDeviceBtnPressed()
{
    if(mDeviceChangeModeEnabled == false)
    {
        //Populate the devices config list with present devices
        PopulateDevicesConfigList();

        //Find the selected device index
        int index = ui->mDevicesList->currentRow();
        if(index >=0 && index < mDeviceConfigList.size())
        {
            mCurModifiedDevConfig = mDeviceConfigList.at(index);

        }
    }


    ModifyDeviceConfig();
}

int CCANbusSettingsPage::ModifyDeviceConfig()
{
    if(mDeviceChangeModeEnabled)
    {
        //Save Data
        if(mCurModifiedDevConfig != 0)
        {
            CCANDeviceConfig *ModifiedDevice = mCurModifiedDevConfig; //mDeviceConfigList.at(index);

            ModifiedDevice->mCANDeviceBaudrate = ui->mCANBaudrateComboBx->currentData().toInt();

            ModifiedDevice->mCANDeviceID = ui->mCANIDComboBx->currentData().toInt();
            ModifiedDevice->mCANDeviceID = ui->mCANDeviceIDSpinBx->value(); //JFM 2023-06-02

            ModifiedDevice->mCANDeviceDatabaseFilename = ui->mDatabaseFileNameLbl->toolTip();   //The full path is stored in the tooltip!
            ModifiedDevice->mDeviceDescription = ui->mDeviceDescriptionTxtEdit->toPlainText();
            ModifiedDevice->mDeviceName = ui->mDeviceNameEditBx->toPlainText();
            ModifiedDevice->mDevicePollPeriod = ui->mDevicePollPeriodSpinBx->value();
            ModifiedDevice->mDeviceWatchdogActivated = ui->mCANDeviceWatchdogActivateChkBx->isChecked();
            ModifiedDevice->mWatchdogCANMsgID = ui->mWatchdogMsgIDSpinBx->value();
            ModifiedDevice->mWatchdogPeriod = ui->mWatchdogPollPeriodSpinBx->value();

            mProgramPtr->SaveCANDevicesConfigRequest(&mDeviceConfigList);
        }



        ui->mDeviceDescriptionTxtEdit->setEnabled(false);
        ui->mDatabaseFileSelectBtn->hide();
        ui->mCANBaudrateComboBx->setEnabled(false);
   //     ui->mCANIDComboBx->setEnabled(false);     //JFM 2023-06-02
        ui->mCANDeviceIDSpinBx->setEnabled(false);
        ui->mDevicesList->setEnabled(true);
        ui->mDevicePollPeriodSpinBx->setEnabled(false);
        ui->mModifyDevParamsBtn->setText("Modifier");
        ui->mCancelModifyParamsBtn->hide();
        ui->mDeviceNameEditBx->setEnabled(false);
        mDeviceChangeModeEnabled = false;
        ui->mWatchdogPollPeriodSpinBx->setEnabled(false);
        ui->mWatchdogMsgIDSpinBx->setEnabled(false);
        ui->mCANDeviceWatchdogActivateChkBx->setEnabled(false);
        ui->mAddDeviceBtn->setEnabled(true);



    }
    else
    {

        //Modify data
        ui->mDeviceDescriptionTxtEdit->setEnabled(true);
        ui->mDatabaseFileSelectBtn->show();
        ui->mCANBaudrateComboBx->setEnabled(true);
       // ui->mCANIDComboBx->setEnabled(true);  //JFM 2023-06-02
        ui->mCANDeviceIDSpinBx->setEnabled(true);

        ui->mDevicesList->setEnabled(false);
        ui->mDevicePollPeriodSpinBx->setEnabled(true);
        ui->mModifyDevParamsBtn->setText("Sauvegarder");
        ui->mCancelModifyParamsBtn->show();
        ui->mDeviceNameEditBx->setEnabled(true);
        ui->mAddDeviceBtn->setEnabled(true);
        ui->mCANDeviceWatchdogActivateChkBx->setEnabled(true);
        if(ui->mCANDeviceWatchdogActivateChkBx->isChecked())
        {
            ui->mWatchdogPollPeriodSpinBx->setEnabled(true);
            ui->mWatchdogMsgIDSpinBx->setEnabled(true);
        }


        mDeviceChangeModeEnabled = true;
    }

    return RET_OK;
}

void CCANbusSettingsPage::CancelModifyDevBtnPressed()
{
    ui->mDeviceDescriptionTxtEdit->setEnabled(false);
    ui->mDatabaseFileSelectBtn->hide();
    ui->mCANBaudrateComboBx->setEnabled(false);
    //ui->mCANIDComboBx->setEnabled(false);
    ui->mCANDeviceIDSpinBx->setEnabled(false);

    ui->mDevicesList->setEnabled(true);
    ui->mDevicePollPeriodSpinBx->setEnabled(false);
    ui->mModifyDevParamsBtn->setText("Modifier");
    ui->mCancelModifyParamsBtn->hide();
    ui->mDeviceNameEditBx->setEnabled(false);
    ui->mAddDeviceBtn->setEnabled(true);
    ui->mWatchdogPollPeriodSpinBx->setEnabled(false);
    ui->mWatchdogMsgIDSpinBx->setEnabled(false);
    ui->mCANDeviceWatchdogActivateChkBx->setEnabled(false);
    mDeviceChangeModeEnabled = false;

    UpdatePage();

}

void CCANbusSettingsPage::SelectDBFileBtnPressed()
{
    QString FileName;
    FileName = QFileDialog::getOpenFileName(this,tr("Fichier database"), "./", tr("Fichiers dbc (*.dbc)"));

    if(!FileName.isEmpty())
    {
        QFileInfo FileInfo(FileName);

        ui->mDatabaseFileNameLbl->setText(FileInfo.fileName());
        ui->mDatabaseFileNameLbl->setToolTip(FileName);
    }

}

void CCANbusSettingsPage::AddDeviceBtnPressed()
{
    //Populate the devices config list with present devices
    PopulateDevicesConfigList();
    //add an empty config and enable modification
    CCANDeviceConfig *NewDevConfig = new CCANDeviceConfig;
    mDeviceConfigList.append(NewDevConfig);
    //update device information
    ui->mDeviceNameEditBx->setPlainText(NewDevConfig->mDeviceName);
    ui->mCANBaudrateComboBx->setCurrentIndex(ui->mCANBaudrateComboBx->findData(NewDevConfig->mCANDeviceBaudrate));

    ui->mCANIDComboBx->setCurrentIndex(ui->mCANIDComboBx->findData(NewDevConfig->mCANDeviceID));    //JFM 2023-06-02
    ui->mCANDeviceIDSpinBx->setValue(NewDevConfig->mCANDeviceID);

    ui->mDeviceDescriptionTxtEdit->setPlainText(NewDevConfig->mDeviceDescription);
    ui->mDatabaseFileNameLbl->setText(NewDevConfig->mCANDeviceDatabaseFilename);
     ui->mDatabaseFileNameLbl->setToolTip(NewDevConfig->mCANDeviceDatabaseFilename);

    ui->mDevicePollPeriodSpinBx->setValue(NewDevConfig->mDevicePollPeriod);
    //update device database information
    ui->mDBMessagesListWidget->clear();
    ui->mDBSignalDetailsTable->clearContents();
    ui->mDBSignalDetailsTable->setRowCount(0);

    mCurModifiedDevConfig = NewDevConfig;
    ModifyDeviceConfig();

    ui->mAddDeviceBtn->setEnabled(false);
}

void CCANbusSettingsPage::DeleteDeviceBtnPressed()
{

    //Populate the devices config list with present devices
    PopulateDevicesConfigList();

    //Find the selected device index
    int index = ui->mDevicesList->currentRow();
    if(index >=0 && index < mDeviceConfigList.size())
    {
        delete mDeviceConfigList.takeAt(index);
    }
    mProgramPtr->SaveCANDevicesConfigRequest(&mDeviceConfigList);

}

int CCANbusSettingsPage::PopulateDevicesConfigList()
{
    while(!mDeviceConfigList.isEmpty())
    {
        delete mDeviceConfigList.takeFirst();
    }

    //Gather the actual data in the change buffer.
    for(int device = 0; device < mDevicesList->size(); device++)
    {
        const CCANDevice *CurDevice = mDevicesList->at(device);
        CCANDeviceConfig *DevConfig = new CCANDeviceConfig;
        *DevConfig = CurDevice->mDeviceConfigInfo;
        mDeviceConfigList.append(DevConfig);
    }

    return RET_OK;
}

void CCANbusSettingsPage::WatchdogActivationBoxChanged()
{
    if(ui->mCANDeviceWatchdogActivateChkBx->isChecked())
    {
        ui->mWatchdogMsgIDSpinBx->setEnabled(true);
        ui->mWatchdogPollPeriodSpinBx->setEnabled(true);
    }
    else
    {
        ui->mWatchdogMsgIDSpinBx->setValue(1);
        ui->mWatchdogPollPeriodSpinBx->setValue(100);
        ui->mWatchdogMsgIDSpinBx->setEnabled(false);
        ui->mWatchdogPollPeriodSpinBx->setEnabled(false);
    }
}