qavrgapplication.cpp

Go to the documentation of this file.

#include "qavrgapplication.h"
#include "qavrgwindow.h"
#include "qavrgserver.h"
#include "qavrgserverthread.h"
#include "qavrgspecserver.h"
#include "qavrgspecserverthread.h"
#include "qavrgepicsinterface.h"
#include "qavrgfillpattern.h"
#include "qavrgacquisitionthread.h"
#include "qavrgacquisition.h"
#include "qavrgfitter.h"
#include "qavrgresultsmodel.h"
#include "qavrgscriptingthread.h"
#include "qavrgscriptingengine.h"
#include "qavrgsettings.h"

#include <QMessageBox>
#include <QFileDialog>

#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <stdio.h>

int gCEPDebug = 0;

static QavrgApplication* g_Application = NULL;

QavrgApplication::QavrgApplication(int &argc, char **argv)
  : QApplication(argc, argv),
    m_SettingsSaver(new QcepSettingsSaver(this)),
    m_Window(NULL),
    m_ServerThread(NULL),
    m_Server(NULL),
    m_SpecServerThread(NULL),
    m_SpecServer(NULL),
    m_ScriptingThread(NULL),
    m_ScriptingEngine(NULL),
    m_AcquisitionThread(NULL),
    m_Acquisition(NULL),
    m_EpicsInterface(NULL)
{
  QcepProperty::registerMetaTypes();

  setObjectName("qavrgapplication");

  g_Application = this;

  setOrganizationName("bessrc");
  setOrganizationDomain("xor.aps.anl.gov");
  setApplicationName("qavrg");

  m_Window = new QavrgWindow(this);

  m_AcquisitionThread = new QavrgAcquisitionThread(this);
  m_Acquisition = m_AcquisitionThread -> acquisition();

  m_Window -> setAcquisition(m_Acquisition);

  connect(m_Acquisition, SIGNAL(noDeviceAvailable()),
          m_Window,      SLOT(showDeviceError()), Qt::QueuedConnection);

  m_AcquisitionThread -> start();

  m_ScriptingThread = new QavrgScriptingThread(this, m_Window, m_Acquisition);
  m_ScriptingEngine = m_ScriptingThread -> scriptingEngine();

  m_Window -> setScriptingEngine(m_ScriptingEngine);

  m_ScriptingThread -> start();

  connect(this, SIGNAL(aboutToQuit()), this, SLOT(writeSettings()));
  connect(this, SIGNAL(aboutToQuit()), this, SLOT(shutdownThreads()));

  connect(m_Acquisition, SIGNAL(new_RawData()),
          m_Window,      SLOT(new_RawData()));
  connect(m_Acquisition, SIGNAL(new_ReferenceData()),
          m_Window,      SLOT(new_ReferenceData()));
  connect(m_Acquisition, SIGNAL(new_DarkData()),
          m_Window,      SLOT(new_DarkData()));
  connect(m_Acquisition, SIGNAL(new_FitData()),
          m_Window,      SLOT(new_FitData()));

  connect(m_Window->m_ActionSetReferenceData, SIGNAL(triggered()),
          m_Acquisition, SLOT(setReferenceData()));

  connect(m_Window->m_ActionSetDarkData, SIGNAL(triggered()),
          m_Acquisition, SLOT(setDarkData()));

  m_EpicsInterface = new QavrgEpicsInterface(this);

  connect(m_EpicsInterface -> fillPattern(), SIGNAL(fillPatternChanged()), 
          m_Acquisition, SLOT(fillPatternChanged()));

  QavrgResultsModel     *model    = new QavrgResultsModel(m_Acquisition);

  m_Window->m_FitResultsTable -> setModel(model);

  connect(m_Acquisition, SIGNAL(new_FittingResults()),
          model,         SLOT(new_FittingResults()));

  m_ServerThread = new QavrgServerThread();
  m_Server = m_ServerThread -> server();

  m_SpecServerThread = new QavrgSpecServerThread(m_Acquisition);
  m_SpecServer = m_SpecServerThread -> server();

  connect(m_Window, SIGNAL(executeCommand(QString)), m_ScriptingEngine, SLOT(evaluateAppCommand(QString)));
  connect(m_ScriptingEngine, SIGNAL(appResultAvailable(QScriptValue)), m_Window, SLOT(finishedCommand(QScriptValue)));

  connect(m_Server, SIGNAL(executeCommand(QString)), m_ScriptingEngine, SLOT(evaluateServerCommand(QString)));
  connect(m_ScriptingEngine, SIGNAL(serverResultAvailable(QScriptValue)), m_Server, SLOT(finishedCommand(QScriptValue)));

  connect(m_SpecServer, SIGNAL(executeCommand(QString)), m_ScriptingEngine, SLOT(evaluateSpecCommand(QString)));
  connect(m_ScriptingEngine, SIGNAL(specResultAvailable(QScriptValue)), m_SpecServer, SLOT(finishedCommand(QScriptValue)));

  connect(m_Server, SIGNAL(printMessage(QString)), m_Window, SLOT(printMessage(QString)));
  connect(m_ServerThread, SIGNAL(printMessage(QString)), m_Window, SLOT(printMessage(QString)));
  connect(m_SpecServer, SIGNAL(printMessage(QString)), m_Window, SLOT(printMessage(QString)));
  connect(m_SpecServerThread, SIGNAL(printMessage(QString)), m_Window, SLOT(printMessage(QString)));
  connect(m_Acquisition, SIGNAL(printMessage(QString)), m_Window, SLOT(printMessage(QString)));
  connect(m_Acquisition, SIGNAL(warningMessage(QString)), m_Window, SLOT(warningMessage(QString)));
  connect(m_AcquisitionThread, SIGNAL(printMessage(QString)), m_Window, SLOT(printMessage(QString)));
  connect(m_ScriptingEngine, SIGNAL(printMessage(QString)), m_Window, SLOT(printMessage(QString)));
  connect(m_ScriptingThread, SIGNAL(printMessage(QString)), m_Window, SLOT(printMessage(QString)));

  m_ServerThread -> start();
  m_SpecServerThread -> start();

  readSettings();
  m_Window -> show();

  m_Window -> updateGraph();
}

QavrgApplication::~QavrgApplication()
{
  delete m_ScriptingThread;
  delete m_AcquisitionThread;
  delete m_ServerThread;
  delete m_EpicsInterface;
}

void QavrgApplication::possiblyQuit()
{
  if (wantToQuit()) {
    quit();
  }
}

bool QavrgApplication::wantToQuit()
{
  return QMessageBox::question(m_Window, tr("Really Quit?"),
                               tr("Do you really want to exit the application?"),
                                  QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Ok;
}

void QavrgApplication::shutdownThreads()
{
  m_AcquisitionThread -> shutdown();
  m_ServerThread -> shutdown();
  m_EpicsInterface -> shutdown();
  m_ScriptingThread -> shutdown();
}

void QavrgApplication::printMessage(QString msg, QDateTime ts)
{
  printf("%s\n", qPrintable(msg));
}

QavrgFillPattern *QavrgApplication::fillPattern()
{
  if (m_EpicsInterface) {
    return m_EpicsInterface->fillPattern();
  } else {
    return NULL;
  }
}

void QavrgApplication::loadSettings()
{
  QString loadName = QFileDialog::getOpenFileName(m_Window, tr("Load Settings"));

  if (!loadName.isNull()) {
    readSettings(loadName);
  }
}

void QavrgApplication::saveSettings()
{
  QString saveName = QFileDialog::getSaveFileName(m_Window, tr("Save Settings"));

  if (!saveName.isNull()) {
    writeSettings(saveName);
  }
}

void QavrgApplication::readSettings()
{
  QavrgSettings  settings;

  this          -> readSettings(&settings);
  m_Window      -> readSettings(&settings);
  m_Acquisition -> readSettings(&settings);
}

void QavrgApplication::readSettings(QString filePath)
{
  QavrgSettings  settings(filePath);

  this          -> readSettings(&settings);
  m_Window      -> readSettings(&settings);
  m_Acquisition -> readSettings(&settings);
}

void QavrgApplication::writeSettings()
{
  QavrgSettings  settings;

  this          -> writeSettings(&settings);
  m_Window      -> writeSettings(&settings);
  m_Acquisition -> writeSettings(&settings);
}

void QavrgApplication::writeSettings(QString filePath)
{
  QavrgSettings  settings(filePath);

  this          -> writeSettings(&settings);
  m_Window      -> writeSettings(&settings);
  m_Acquisition -> writeSettings(&settings);
}

QcepSettingsSaverWPtr QavrgApplication::saver() const
{
  return m_SettingsSaver;
}

void QavrgApplication::readSettings(QavrgSettings *settings)
{
  QcepProperty::readSettings(this, &staticMetaObject, "application", settings);
}

void QavrgApplication::writeSettings(QavrgSettings *settings)
{
  QcepProperty::writeSettings(this, &staticMetaObject, "application", settings);
}