void PortControl::onTbPortListActivated(int index)

{

    ui->cbPortList->setCurrentIndex(index);

}

void PortControl::onPortError(QSerialPort::SerialPortError error)

{

#ifdef Q_OS_UNIX

    // For suppressing "Invalid argument" errors that happens with pseudo terminals

    auto isPtsInvalidArgErr = [this] () -> bool {

        return serialPort->portName().contains("pts/") && serialPort->errorString().contains("Invalid argument");

    };

#endif

    switch(error)

    {

        case QSerialPort::NoError :

            break;

        case QSerialPort::ResourceError :

            qWarning() << "Port error: resource unavaliable; most likely device removed.";

            if (serialPort->isOpen())

            {

                qWarning() << "Closing port on resource error: " << serialPort->portName();

                togglePort();

            }

            loadPortList();

            break;

        case QSerialPort::DeviceNotFoundError:

            qCritical() << "Device doesn't exists: " << serialPort->portName();

            break;

        case QSerialPort::PermissionError:

            qCritical() << "Permission denied. Either you don't have \

required privileges or device is already opened by another process.";

            break;

        case QSerialPort::OpenError:

            qWarning() << "Device is already opened!";

            break;

        case QSerialPort::NotOpenError:

            qCritical() << "Device is not open!";

            break;

        case QSerialPort::ParityError:

            qCritical() << "Parity error detected.";

            break;

        case QSerialPort::FramingError:

            qCritical() << "Framing error detected.";

            break;

        case QSerialPort::BreakConditionError:

            qCritical() << "Break condition is detected.";

            break;

        case QSerialPort::WriteError:

            qCritical() << "An error occurred while writing data.";

            break;

        case QSerialPort::ReadError:

            qCritical() << "An error occurred while reading data.";

            break;

        case QSerialPort::UnsupportedOperationError:

#ifdef Q_OS_UNIX

            // Qt 5.5 gives "Invalid argument" with 'UnsupportedOperationError'

            if (isPtsInvalidArgErr())

                break;

#endif

            qCritical() << "Operation is not supported.";

            break;

        case QSerialPort::TimeoutError:

            qCritical() << "A timeout error occurred.";

            break;

        case QSerialPort::UnknownError:

#ifdef Q_OS_UNIX

            // Qt 5.2 gives "Invalid argument" with 'UnknownError'

            if (isPtsInvalidArgErr())

                break;

#endif

            qCritical() << "Unknown error! Error: " << serialPort->errorString();

            break;

        default:

            qCritical() << "Unhandled port error: " << error;

            break;

    }

}

void PortControl::updatePinLeds(void)

{

    auto pins = serialPort->pinoutSignals();

    ui->ledDCD->setOn(pins & QSerialPort::DataCarrierDetectSignal);

    ui->ledDSR->setOn(pins & QSerialPort::DataSetReadySignal);

    ui->ledRI->setOn(pins & QSerialPort::RingIndicatorSignal);

    ui->ledCTS->setOn(pins & QSerialPort::ClearToSendSignal);

}

QString PortControl::currentParityText()

{

    return paritySettingMap.value(

        (QSerialPort::Parity) parityButtons.checkedId());

}

QString PortControl::currentFlowControlText()

{

    if (flowControlButtons.checkedId() == QSerialPort::HardwareControl)

    {

        return "hardware";

    }

    else if (flowControlButtons.checkedId() == QSerialPort::SoftwareControl)

    {

        return "software";

    }

    else // no parity

    {

        return "none";

    }

}

void PortControl::selectPort(QString portName)

{

    int portIndex = portList.indexOfName(portName);

    if (portIndex < 0) // not in list, add to model and update the selections

    {

        portList.appendRow(new PortListItem(portName));

        ui->cbPortList->setCurrentIndex(portList.rowCount()-1);

        tbPortList.setCurrentIndex(portList.rowCount()-1);

    }

    else

    {

        ui->cbPortList->setCurrentIndex(portIndex);

        tbPortList.setCurrentIndex(portIndex);

    }

    _selectPort(portName);

}

void PortControl::selectBaudrate(QString baudRate)

{

    int baudRateIndex = ui->cbBaudRate->findText(baudRate);

    if (baudRateIndex < 0)

    {

        ui->cbBaudRate->setCurrentText(baudRate);

    }

    else

    {

        ui->cbBaudRate->setCurrentIndex(baudRateIndex);

    }

    _selectBaudRate(baudRate);

}

void PortControl::openPort()

{

    if (!serialPort->isOpen())

    {

        openAction.trigger();

    }

}

void PortControl::saveSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_Port);

    settings->setValue(SG_Port_SelectedPort, selectedPortName());

    settings->setValue(SG_Port_BaudRate, ui->cbBaudRate->currentText());

    settings->setValue(SG_Port_Parity, currentParityText());

    settings->setValue(SG_Port_DataBits, dataBitsButtons.checkedId());

    settings->setValue(SG_Port_StopBits, stopBitsButtons.checkedId());

    settings->setValue(SG_Port_FlowControl, currentFlowControlText());

    settings->endGroup();

}

void PortControl::loadSettings(QSettings* settings)

{

    // make sure the port is closed

    if (serialPort->isOpen()) togglePort();

    settings->beginGroup(SettingGroup_Port);

    // set port name if it exists in the current list otherwise ignore

    QString portName = settings->value(SG_Port_SelectedPort, QString()).toString();

    if (!portName.isEmpty())

    {

        int index = portList.indexOfName(portName);

        if (index > -1) ui->cbPortList->setCurrentIndex(index);

    }

    // load baud rate setting if it exists in baud rate list

    QString baudSetting = settings->value(

        SG_Port_BaudRate, ui->cbBaudRate->currentText()).toString();

    int baudIndex = ui->cbBaudRate->findText(baudSetting);

    if (baudIndex > -1) ui->cbBaudRate->setCurrentIndex(baudIndex);

    // load parity setting

    QString parityText =

        settings->value(SG_Port_Parity, currentParityText()).toString();

    QSerialPort::Parity paritySetting = paritySettingMap.key(

        parityText, (QSerialPort::Parity) parityButtons.checkedId());

    parityButtons.button(paritySetting)->setChecked(true);

    // load number of bits

    if (dataBits >=5 && dataBits <= 8)

    {

        dataBitsButtons.button((QSerialPort::DataBits) dataBits)->setChecked(true);

    }

    // load stop bits

    int stopBits = settings->value(SG_Port_StopBits, stopBitsButtons.checkedId()).toInt();

    if (stopBits == QSerialPort::OneStop)

    {

        ui->rb1StopBit->setChecked(true);

    }

    else if (stopBits == QSerialPort::TwoStop)

    {

        ui->rb2StopBit->setChecked(true);

    }

    // load flow control

    QString flowControlSetting =

        settings->value(SG_Port_FlowControl, currentFlowControlText()).toString();

    if (flowControlSetting == "hardware")

    {

        ui->rbHardwareControl->setChecked(true);

    }

    else if (flowControlSetting == "software")

    {

        ui->rbSoftwareControl->setChecked(true);

    }

    else

    {

        ui->rbNoFlowControl->setChecked(true);

    }

    settings->endGroup();

}