qpidmainwindow.cpp

Go to the documentation of this file.

#include "qpidmainwindow.h"
#include "ui_qpidmainwindow.h"
#include "qextserialenumerator.h"
#include <stdio.h>
#include "qwt_legend.h"
#include "qwt_symbol.h"
#include "qpidcontroller.h"
#include "qpiddevice.h"
#include "qpiddevicethread.h"
#include <QMessageBox>
#include <QCloseEvent>
#include <QFileDialog>
#include "qpiddebug.h"
#include <QTableWidgetItem>
#include "qpidlogger.h"

QPidMainWindow::QPidMainWindow(QPidControllerWPtr ctl, QWidget *parent) :
  QMainWindow(parent),
  ui(new Ui::QPidMainWindow),
  m_Controller(ctl),
  m_DeviceDefaultMapper(new QSignalMapper(this))
{
  ui->setupUi(this);

  ui->m_TemperatureGraph->init(m_Controller);

  QwtLegend *x = new QwtLegend(ui->m_TemperatureGraph);

  ui->m_TemperatureGraph->enableAxis(QwtPlot::yRight, true);
  ui->m_TemperatureGraph->insertLegend(x, QwtPlot::BottomLegend);

//  QList<QextPortInfo> ports = QextSerialEnumerator::getPorts();

//  foreach(QextPortInfo port, ports) {
//    printf("Port %s : %s : %s : %s : %x : %x\n",
//           qPrintable(port.portName), qPrintable(port.friendName),
//           qPrintable(port.physName), qPrintable(port.enumName),
//           port.vendorID, port.productID);
//  }

  connect(ui->m_ActionQuit, SIGNAL(triggered()), this, SLOT(quitApplication()));
  connect(ui->m_ActionSettings, SIGNAL(triggered()), this, SLOT(editSettings()));
  connect(ui->m_ActionChangeSetpoint, SIGNAL(triggered()), this, SLOT(changeSetpoint()));
  connect(ui->m_ActionAutoTune, SIGNAL(triggered()), this, SLOT(autoTune()));
  connect(ui->m_ActionRampTemperature, SIGNAL(triggered()), this, SLOT(rampTemperature()));
  connect(ui->m_ActionConfigureGraph, SIGNAL(triggered()), this, SLOT(configureGraph()));
  connect(ui->m_ActionDeviceConfiguration, SIGNAL(triggered()), this, SLOT(deviceConfiguration()));
  connect(ui->m_ActionLoadSettings, SIGNAL(triggered()), this, SLOT(loadSettings()));
  connect(ui->m_ActionSaveSettings, SIGNAL(triggered()), this, SLOT(saveSettings()));

  connect(ui->m_ActionAutoScaleGraph, SIGNAL(triggered()), ui->m_TemperatureGraph, SLOT(autoScale()));

  connect(ui->m_CommandInput, SIGNAL(returnPressed()), this, SLOT(commandEntered()));

  connect(ui->m_LoggingButton, SIGNAL(clicked()), this, SLOT(chooseLoggingFile()));

  QPidControllerPtr ctrl(m_Controller);

  if (ctrl) {
    ctrl->prop_RampPoint()->linkTo(ui->m_SetPointDisplay);
    ctrl->prop_Temperature()->linkTo(ui->m_TemperatureDisplay);
    ctrl->prop_OutputLevel()->linkTo(ui->m_OutputLevelDisplay);
    ctrl->prop_Enabled()->linkTo(ui->m_Enabled);
    ctrl->prop_LoopEnabled()->linkTo(ui->m_LoopEnabled);

    ctrl->prop_SetPoint()->linkTo(ui->m_TargetSetPoint);
    ctrl->prop_RampRate()->linkTo(ui->m_RampRate);

    connect(ctrl->prop_ControllerStatus(), SIGNAL(valueChanged(int,int)),
            this, SLOT(onControllerStatusChanged(int)));
  }

  ui->m_StartControllerButton->setDefaultAction(ui->m_ActionStartController);
  ui->m_StopControllerButton->setDefaultAction(ui->m_ActionStopController);
  ui->m_RestartControllerButton->setDefaultAction(ui->m_ActionRestartController);

  connect(ui->m_ActionStartController, SIGNAL(triggered()), this, SLOT(onStartController()));
  connect(ui->m_ActionStopController, SIGNAL(triggered()), this, SLOT(onStopController()));
  connect(ui->m_ActionRestartController, SIGNAL(triggered()), this, SLOT(onRestartController()));

  ui->m_CreateDeviceButton->setDefaultAction(ui->m_ActionCreateNewDevice);
  ui->m_DeleteDeviceButton->setDefaultAction(ui->m_ActionDeleteDevice);

  connect(ui->m_ActionCreateNewDevice, SIGNAL(triggered()), ui->m_DevicesList, SLOT(doCreateNewDevice()));
  connect(ui->m_ActionDeleteDevice, SIGNAL(triggered()), ui->m_DevicesList, SLOT(doDeleteDevice()));

  if (ctrl) {
    onControllerStatusChanged(ctrl->get_ControllerStatus());
  }

  ui->m_DevicesList->setController(m_Controller);

  connect(m_Controller.data(), SIGNAL(deviceListChanged()), this, SLOT(updateDevicesMenu())/*, Qt::QueuedConnection*/);

  ui->m_TemperatureGraph->autoScale();

  ui->m_DevicesList->updateDevicesList();

  connect(m_DeviceDefaultMapper, SIGNAL(mapped(int)), ui->m_DevicesList, SLOT(doSetDefaultDevice(int)));
}

QPidMainWindow::~QPidMainWindow()
{
  delete ui;
}

void QPidMainWindow::start()
{
  QPidControllerPtr ctrl(m_Controller);

  if (ctrl) {
    QPidLoggerPtr log = ctrl->logger();

    if (log) {
      log->prop_Enabled()->linkTo(ui->m_LoggingIndicator);
      log->prop_FileName()->linkTo(ui->m_LoggingPath);
    }
  }
}

void QPidMainWindow::printMessage(QString msg, QDateTime ts)
{
  if (QThread::currentThread() != thread()) {
    QMetaObject::invokeMethod(this, "printMessage", Q_ARG(QString, msg), Q_ARG(QDateTime, ts));
  } else {
    ui->m_OutputMessages->append(ts.toString("yyyy MMM dd hh:mm:ss.zzz: ")+msg);
  }
}

void QPidMainWindow::criticalMessage(QString msg)
{
  if (QThread::currentThread() != thread()) {
    QMetaObject::invokeMethod(this, "criticalMessage", Q_ARG(QString, msg));
  } else {
    ui->m_OutputMessages->append("Error: " + msg);
  }
}

void QPidMainWindow::quitApplication()
{
  close();
}

void QPidMainWindow::closeEvent ( QCloseEvent * event )
{
  if (wantToClose()) {
    QPidControllerPtr ctrl(m_Controller);

    if (ctrl) {
      ctrl->writeSettings();
    }

    event -> accept();
  } else {
    event -> ignore();
  }
}

bool QPidMainWindow::wantToClose()
{
  THREAD_CHECK;

  return QMessageBox::question(this, tr("Really Close?"),
                               tr("Do you really want to close the window?"),
                               QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Ok;
}

void QPidMainWindow::editSettings()
{
//  if (m_SettingsDialog == NULL) {
    m_SettingsDialog = new QPidSettingsDialog(m_Controller, this);
//  }

  if (m_SettingsDialog) {
    m_SettingsDialog -> show();
    m_SettingsDialog -> raise();
  }
}

void QPidMainWindow::chooseLoggingFile()
{
  QPidControllerPtr ctrl(m_Controller);

  if (ctrl) {
    QPidLoggerPtr log = ctrl->logger();

    if (log) {
      QString filePath = QFileDialog::getSaveFileName(this, "Save Log File as...", log->get_FileName(), "Log File (*.log);; Any file (* *.*)");

      if (filePath != "") {
        log->set_FileName(filePath);
      }
    }
  }
}

void QPidMainWindow::loadSettings()
{
  QPidControllerPtr ctrl(m_Controller);

  if (ctrl) {
    QString filePath = QFileDialog::getOpenFileName(this, "Load Settings from...", ctrl->settingsFilePath(), "QPIDCTRL Settings (*.qpset);; Any file (* *.*)");

    if (filePath != "") {
      ctrl->loadSettings(filePath);
    }
  }
}

void QPidMainWindow::saveSettings()
{
  QPidControllerPtr ctrl(m_Controller);

  if (ctrl) {
    QString filePath = QFileDialog::getSaveFileName(this, "Save Settings as...", ctrl->settingsFilePath(), "QPIDCTRL Settings (*.qpset);; Any file (* *.*)");

    if (filePath != "") {
      ctrl->saveSettings(filePath);
    }
  }
}

void QPidMainWindow::enableControllerActions(int canStart, int canStop, int canRestart)
{
  ui->m_ActionStartController->setEnabled(canStart);
  ui->m_ActionStopController->setEnabled(canStop);
  ui->m_ActionRestartController->setEnabled(canRestart);
}

void QPidMainWindow::onControllerStatusChanged(int newStatus)
{
  QPidControllerPtr ctrl(m_Controller);

  if (ctrl) {
    QString statusString = ctrl->controllerStatusString(newStatus);

    ui->m_ControllerStatusLabel->setText(statusString);

    switch (newStatus) {
    case QPidController::Stopping:
    case QPidController::Stopped:
      enableControllerActions(true, false, true);
      break;

    case QPidController::Starting:
    case QPidController::Running:
      enableControllerActions(false, true, true);
      break;

    case QPidController::Paused:
      enableControllerActions(true, false, true);
      break;

    case QPidController::Restarting:
      enableControllerActions(true, false, true);
      break;

    case QPidController::Error:
      enableControllerActions(true, false, true);
      break;

    }
  }
}

void QPidMainWindow::onStartController()
{
  QPidControllerPtr ctrl(m_Controller);

  if (ctrl) {
    ctrl -> startController();
  }
}

void QPidMainWindow::onStopController()
{
  QPidControllerPtr ctrl(m_Controller);

  if (ctrl) {
    ctrl -> stopController();
  }
}

void QPidMainWindow::onRestartController()
{
  QPidControllerPtr ctrl(m_Controller);

  if (ctrl) {
    ctrl -> restartController();
  }
}

void QPidMainWindow::commandEntered()
{
  QString cmd = ui->m_CommandInput->text();

  QPidControllerPtr ctrl(m_Controller);

  if (ctrl) {
    ctrl->executeCommand(cmd);
  }
}

void QPidMainWindow::changeSetpoint()
{
  if (m_SetPoint == NULL) {
    m_SetPoint = new QPidSetPointDialog(m_Controller, this);
  }

  if (m_SetPoint) {
    m_SetPoint -> show();
    m_SetPoint -> raise();
  }
}

void QPidMainWindow::autoTune()
{
  if (m_AutoTune == NULL) {
    m_AutoTune = new QPidAutoTuneDialog(m_Controller, this);
  }

  if (m_AutoTune) {
    m_AutoTune -> show();
    m_AutoTune -> raise();
  }
}

void QPidMainWindow::rampTemperature()
{
  if (m_Ramp == NULL) {
    m_Ramp = new QPidRampDialog(m_Controller, this);
  }

  if (m_Ramp) {
    m_Ramp -> show();
    m_Ramp -> raise();
  }
}

void QPidMainWindow::configureGraph()
{
  if (m_ConfigureGraph == NULL) {
    m_ConfigureGraph = new QPidConfigureGraphDialog(m_Controller, this);
  }

  if (m_ConfigureGraph) {
    m_ConfigureGraph -> show();
    m_ConfigureGraph -> raise();
  }
}

void QPidMainWindow::deviceConfiguration()
{
  QPidControllerPtr ctrl(m_Controller);

  if (ctrl) {
    QPidDevicePtr dev = ctrl->defaultDevice();

    if (dev) {
      dev->configurationDialog();
    }
  }
}

void QPidMainWindow::onInputChannelChanged(QString name, QString units)
{
  if (name.length()) {
    if (units.length()) {
      ui->m_TemperatureLabel->setText(tr("Input : %1 (%2)").arg(name).arg(units));
    } else {
      ui->m_TemperatureLabel->setText(name);
    }
  }
}

void QPidMainWindow::onOutputChannelChanged(QString name, QString units)
{
  if (name.length()) {
    if (units.length()) {
      ui->m_OutputLevelLabel->setText(tr("Output : %1 (%2)").arg(name).arg(units));
    } else {
      ui->m_OutputLevelLabel->setText(name);
    }
  }
}

static const int NPENS = 3;
static const int NSYMS = 4;

static Qt::GlobalColor PenColors[NPENS] = { Qt::red, Qt::blue, Qt::green };
static QwtSymbol::Style Symbols[NSYMS]   = { QwtSymbol::Ellipse, QwtSymbol::Cross, QwtSymbol::Diamond, QwtSymbol::Rect };

QwtPlotCurve *QPidMainWindow::newPlotCurve(int n, QString title)
{
  QwtPlotCurve *pc = new QwtPlotCurve(title);

  int npen = n % NPENS;
  int nsym = (n / NPENS) % NSYMS;

  Qt::GlobalColor  color = PenColors[npen];
  QwtSymbol::Style symbl = Symbols[nsym];

  pc->setPen(QPen(color));

  QwtSymbol symb;

  symb.setStyle(symbl);
  symb.setSize(5,5);
  symb.setPen(QPen(color));
  symb.setBrush(QBrush(color));

  pc->setSymbol(&symb);

  return pc;
}

void QPidMainWindow::updateGraphCurves()
{
  if (QThread::currentThread() != thread()) {
    INVOKE_CHECK(QMetaObject::invokeMethod(this, "updateGraphCurves"));
  } else {
    if (qcepDebug(DEBUG_GRAPHER)) {
      printMessage(tr("QPidMainWindow::updateGraphCurves()"));
    }

    QPidControllerPtr ctrl(m_Controller);

    if (ctrl) {
      QStringList names = ctrl->get_ColumnNames();

      int n  = names.length();
      int cvidx = 0;

      ui->m_TemperatureGraph->detachItems(QwtPlotItem::Rtti_PlotCurve);
      ui->m_TemperatureGraph->detachItems(QwtPlotItem::Rtti_PlotMarker);

      m_Curves.clear();

      for (int i=0+ctrl->m_SkippedColumns; i<n; i++) {
        QString name = names.value(i);

        if (ctrl->yChecked(i)) {
          QwtPlotCurve *pc = newPlotCurve(cvidx++, name);

          pc->setSamples(ctrl->m_PlottedValues.value(0), ctrl->m_PlottedValues.value(i));
          pc->attach(ui->m_TemperatureGraph);

          m_Curves.append(pc);
        }

        if (ctrl->y2Checked(i)) {
          QwtPlotCurve *pc = newPlotCurve(cvidx++, name);

          pc->setSamples(ctrl->m_PlottedValues.value(0), ctrl->m_PlottedValues.value(i));
          pc->setAxes(QwtPlot::xBottom, QwtPlot::yRight);
          pc->attach(ui->m_TemperatureGraph);

          m_Curves.append(pc);
        }
      }

      ui->m_TemperatureGraph->replot();
    }
  }
}

void QPidMainWindow::graphChannelNames(QStringList names)
{
  if (QThread::currentThread() != thread()) {
    INVOKE_CHECK(QMetaObject::invokeMethod(this, "graphChannelNames", Q_ARG(QStringList, names)));
  } else {
    if (qcepDebug(DEBUG_GRAPHER)) {
      printMessage(tr("QPidMainWindow::graphChannelNames %1 ,...").arg(names.value(0)));
    }

    disconnect(ui->m_ColumnList, SIGNAL(cellChanged(int,int)), this, SLOT(onGraphSelectionChanged(int,int)));

    QPidControllerPtr ctrl(m_Controller);

    if (ctrl) {
      int n  = names.length();
      int ns = ctrl->m_SkippedColumns;

      ui->m_ColumnList->setRowCount(n-ns);
      ui->m_ColumnList->setColumnWidth(0, 120);
      ui->m_ColumnList->setColumnWidth(1, 30);
      ui->m_ColumnList->setColumnWidth(2, 30);

      for (int i=0+ctrl->m_SkippedColumns; i<n; i++) {
        QString name = names.value(i);

        ui->m_ColumnList->setItem(i-ns,0, new QTableWidgetItem(name));
        ui->m_ColumnList->setItem(i-ns,1, new QTableWidgetItem());
        ui->m_ColumnList->setItem(i-ns,2, new QTableWidgetItem());

        ui->m_ColumnList->item(i-ns,0)->setFlags(Qt::ItemIsEnabled|Qt::ItemIsSelectable);
        ui->m_ColumnList->item(i-ns,1)->setFlags(Qt::ItemIsEnabled|Qt::ItemIsUserCheckable);
        ui->m_ColumnList->item(i-ns,2)->setFlags(Qt::ItemIsEnabled|Qt::ItemIsUserCheckable);

        ui->m_ColumnList->item(i-ns,1)->setCheckState(ctrl->yChecked(i));
        ui->m_ColumnList->item(i-ns,2)->setCheckState(ctrl->y2Checked(i));
      }
    }

    updateGraphCurves();

    connect(ui->m_ColumnList, SIGNAL(cellChanged(int,int)), this, SLOT(onGraphSelectionChanged(int,int)));
  }
}

void QPidMainWindow::graphChannelValues(QcepDoubleList values)
{
  if (QThread::currentThread() != thread()) {
    INVOKE_CHECK(QMetaObject::invokeMethod(this, "graphChannelValues", Q_ARG(QcepDoubleList, values)));
  } else {
    if (qcepDebug(DEBUG_GRAPHER)) {
      printMessage(tr("QPidMainWindow::graphChannelValues %1 ,...").arg(values.value(0)));
    }

    int n= values.length();
    int cvidx = 0;

    QPidControllerPtr ctrl(m_Controller);

    if (ctrl) {
      for (int i=0+ctrl->m_SkippedColumns; i<n; i++) {
        if (ctrl->yChecked(i)) {
          QwtPlotCurve *pc = m_Curves.value(cvidx++);

          if (pc) {
            pc->setSamples(ctrl->m_PlottedValues.value(0), ctrl->m_PlottedValues.value(i));
          }
        }

        if (ctrl->y2Checked(i)) {
          QwtPlotCurve *pc = m_Curves.value(cvidx++);

          if (pc) {
            pc->setSamples(ctrl->m_PlottedValues.value(0), ctrl->m_PlottedValues.value(i));
          }
        }
      }
    }

    ui->m_TemperatureGraph->replot();
  }
}

void QPidMainWindow::onGraphSelectionChanged(int row, int col)
{
  if (qcepDebug(DEBUG_GRAPHER)) {
    printMessage(tr("onGraphSelectionChanged(R%1,C%2)").arg(row).arg(col));
  }

  QPidControllerPtr ctrl(m_Controller);

  if (ctrl) {
    if (col == 1) {
      ctrl->setYChecked(row+ctrl->m_SkippedColumns, ui->m_ColumnList->item(row,col)->checkState());
    } else if (col == 2) {
      ctrl->setY2Checked(row+ctrl->m_SkippedColumns, ui->m_ColumnList->item(row,col)->checkState());
    }

    updateGraphCurves();
  }
}

void QPidMainWindow::saveSplitterState(QPidSettings *settings)
{
  settings->beginWriteArray("splitters");

  int counter=0;
  saveObjectSplitterState(this, settings, &counter);

  settings->endArray();
}

void QPidMainWindow::restoreSplitterState(QPidSettings *settings)
{
  int nsplitters = settings->beginReadArray("splitters");

  int counter=0;
  restoreObjectSplitterState(this, settings, &counter, nsplitters);

  settings->endArray();
}

void QPidMainWindow::saveObjectSplitterState(QObject *object, QPidSettings *settings, int *counter)
{
  if (object) {
    QSplitter *splitter = qobject_cast<QSplitter*>(object);

    if (splitter) {
      if (counter) {
        settings->setArrayIndex(*counter);
        QByteArray state = splitter->saveState();

        settings->setValue("state", state);

        (*counter) += 1;
      }
    }

    foreach (QObject *obj, object->children()) {
      if (obj) {
        saveObjectSplitterState(obj, settings, counter);
      }
    }
  }
}

void QPidMainWindow::restoreObjectSplitterState(QObject *object, QPidSettings *settings, int *counter, int nsplitters)
{
  if (object) {
    QSplitter *splitter = qobject_cast<QSplitter*>(object);

    if (splitter) {
      if (counter) {
        settings->setArrayIndex(*counter);
        QByteArray state = settings->value("state").toByteArray();

        Qt::Orientation orient = splitter->orientation();

        splitter->restoreState(state);

        splitter->setOrientation(orient);

        (*counter) += 1;
      }
    }

    foreach (QObject *obj, object->children()) {
      if (obj) {
        restoreObjectSplitterState(obj, settings, counter, nsplitters);
      }
    }
  }
}

#define STRINGIFY(s) _str(s)
#define _str(s) #s

void QPidMainWindow::updateDevicesMenu()
{
  ui->m_MenuDefaultDevice->clear();

  QPidControllerPtr ctrl(m_Controller);

  if (ctrl) {
    for (int i=0; i<ctrl->countDevices(); i++) {
      QPidDevicePtr dev = ctrl->getDevice(i);

      if (dev) {
        QAction *select = new QAction(tr("%1: %2 : %3").arg(i).arg(dev->get_DeviceName()).arg(dev->get_DeviceLongTypeName()), NULL);

        connect(select, SIGNAL(triggered()), m_DeviceDefaultMapper, SLOT(map()));
        m_DeviceDefaultMapper->setMapping(select, i);

        select->setCheckable(true);
        select->setChecked(ctrl->get_DefaultDeviceNumber() == i);

        ui->m_MenuDefaultDevice->addAction(select);
      }
    }

    QPidDevicePtr dev = ctrl->defaultDevice();

    if (dev) {
      QString desc = tr("%1 : %2")
          .arg(dev->get_DeviceName())
          .arg(dev->get_DeviceLongTypeName());

      setWindowTitle(tr("QPidCtrl : Device %1 : %2 : %3")
                     .arg(ctrl->get_DefaultDeviceNumber())
                     .arg(STRINGIFY(QPIDCTRL_VERSION))
                     .arg(desc));

      ui->m_ActionStartController->setToolTip(tr("Start Device %1").arg(desc));
      ui->m_ActionStopController->setToolTip(tr("Halt Device %1").arg(desc));
      ui->m_ActionRestartController->setToolTip(tr("Restart Device %1").arg(desc));
    } else {
      setWindowTitle(tr("QPidCtrl : %1 : No Controller")
                     .arg(STRINGIFY(QPIDCTRL_VERSION)));

      ui->m_ActionStartController->setToolTip(tr("Start Device"));
      ui->m_ActionStopController->setToolTip(tr("Halt Device"));
      ui->m_ActionRestartController->setToolTip(tr("Restart Device"));
    }
  }
}