qsecontroller.cpp

Go to the documentation of this file.

#include "qsecontroller.h"

#include <QTableWidget>
#include <QTableWidgetItem>

#include <QPushButton>
#include <QStatusBar>
#include <QProgressBar>
#include <QSlider>
#include <QLabel>
#include <QLineEdit>
#include <QCheckBox>
#include <QMenu>
#include <QCursor>
#include <QFileDialog>
#include <QSettings>
#include <QDesktopServices>

#include <qwt_plot.h>
#include <qwt_plot_item.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_zoomer.h>

#include "qsescan.h"
#include "qsefilereader.h"
#include "qsedataset.h"
#include "qsedatasetmodel.h"
#include "qseinputfile.h"
#include "qseprocessormain.h"
#include "qsegraphcontroller.h"
#include "qsedataflow.h"
#include "qsedatadeglitcherui.h"
#include "qsenormalizer.h"
#include "qsenormalizerui.h"
#include "qseedgealignerui.h"
#include "qsescanaveragerui.h"

#include <stdio.h>

QseController::QseController
(QseProcessorMain *w, QObject *parent)
  : QObject(parent),
    m_DataFlow(0),
    m_MainWindow(w),
    m_CurrentScan(0),
    m_InputDataUI(NULL),
    m_DeglitcherUI(NULL),
    m_NormalizerUI(NULL),
    m_EdgeAlignerUI(NULL),
    m_ScanAveragerUI(NULL),
    m_NormalizedController(NULL),
    m_AveragedController(NULL),
    m_Progress(NULL)
{
  m_DataFlow = new QseDataFlow();
  int tab = 0;

  m_InputDataUI = new QseGraphController(m_DataFlow->m_InputData, NULL);
  m_MainWindow -> m_TabWidget -> insertTab(tab++, m_InputDataUI, "Input Data");

//   m_DeglitcherUI = new QseDataDeglitcherUI(m_DataFlow->m_Deglitcher, NULL);
//   m_MainWindow -> m_TabWidget -> insertTab(tab++, m_DeglitcherUI, "Deglitched Data");

  m_NormalizerUI = new QseNormalizerUI(m_DataFlow->m_Normalizer, NULL);
  m_MainWindow -> m_TabWidget -> insertTab(tab++, m_NormalizerUI, "Normalization");

  m_NormalizedController   = 
    new QseGraphController(m_DataFlow->m_NormalizedData, NULL);
  m_MainWindow -> m_TabWidget -> 
    insertTab(tab++, m_NormalizedController, "Normalized Data");

//   m_EdgeAlignerUI = new QseEdgeAlignerUI(m_DataFlow->m_EdgeAligner, NULL);
//   m_MainWindow -> m_TabWidget -> insertTab(tab++, m_EdgeAlignerUI, "Aligned Data");

  m_ScanAveragerUI = new QseScanAveragerUI(m_DataFlow->m_ScanAverager, NULL);
  m_MainWindow -> m_TabWidget -> insertTab(tab++, m_ScanAveragerUI, "Averaging");
  
  m_AveragedController     = 
    new QseGraphController(m_DataFlow->m_AveragedData, NULL);
  m_MainWindow -> m_TabWidget -> 
    insertTab(tab++, m_AveragedController, "Averaged Data");

  m_MainWindow -> m_TabWidget -> setCurrentIndex(0);

  m_NormalizedController -> addContextMenuAction(m_MainWindow->actionAverageSelectedScans);

  setupActions();

  connect(m_MainWindow -> actionRunNormalizer, SIGNAL(triggered()), 
          this, SLOT(runNormalizer(void)));

  connect(m_DataFlow->m_InputData, SIGNAL(message(const QString&)),
          this,           SLOT(message(const QString&)));

  connect(m_DataFlow->m_Normalizer, SIGNAL(message(const QString&)),
          this,           SLOT(message(const QString&)));

  connect(m_DataFlow->m_InputData, SIGNAL(madeProgress(int)), this, SLOT(setProgress(int)));

  m_NormalizedController->setTitle("Normalized Scans");

  m_AveragedController->setTitle("Averaged Data");

  m_Progress = new QProgressBar(NULL);
  m_Progress -> setMinimumWidth(150);
  m_Progress -> setSizePolicy(QSizePolicy::Fixed,QSizePolicy::Fixed);

  m_MainWindow -> statusBar() -> addPermanentWidget(m_Progress);

  QStringList args = QApplication::arguments();
  int nargs = args.size();

  for (int i=1; i<nargs; i++) {
    appendDataFile(args.at(i));
  }
}

QseController::~QseController()
{
  delete m_NormalizedController;
  delete m_AveragedController;
}

void QseController::setupActions()
{
  connect(m_MainWindow->actionOpenDataFile, SIGNAL(triggered()), 
          this, SLOT(openDataFile()));
  connect(m_MainWindow->actionAppendDataFile, SIGNAL(triggered()), 
          this, SLOT(appendDataFile()));
  connect(m_MainWindow->actionOpenControlFile, SIGNAL(triggered()), 
          this, SLOT(openControlFile()));
  connect(m_MainWindow->actionSaveSplitDataFiles, SIGNAL(triggered()), 
          this, SLOT(saveSplitDataFile()));
  connect(m_MainWindow->actionSaveNormalizedFiles, SIGNAL(triggered()), 
          this, SLOT(saveNormalizedFile()));
  connect(m_MainWindow->actionSaveAveragedFiles, SIGNAL(triggered()), 
          this, SLOT(saveAveragedFile()));
  connect(m_MainWindow->actionSaveControlFile, SIGNAL(triggered()), 
          this, SLOT(saveControlFile()));
  connect(m_MainWindow->actionExit, SIGNAL(triggered()), 
          this, SLOT(exitApplication()));

  connect(m_MainWindow->actionPrintNormalizedGraph, SIGNAL(triggered()), 
          m_NormalizedController, SLOT(printGraph()));
  connect(m_MainWindow->actionPrintAveragedGraph, SIGNAL(triggered()), 
          m_AveragedController, SLOT(printGraph()));

  connect(m_MainWindow->actionQSEHomePage, SIGNAL(triggered()), 
          this, SLOT(openQSEHomePage()));

  connect(m_MainWindow->actionExit, SIGNAL(triggered()), 
          qApp, SLOT(quit()));

  connect(m_MainWindow->actionAverageSelectedScans, SIGNAL(triggered()), 
          this, SLOT(averageSelectedScans()));
}

void QseController::message(const QString& message)
{
  m_MainWindow->statusBar()->showMessage(message, 5000);
  m_MainWindow->outputMessageView->append(message);
}

void QseController::setProgress(int level)
{
  if (level > 100) {
    m_Progress -> reset();
  } else {
    m_Progress -> setValue(level);
  }
}

void QseController::openCompleted()
{
  m_MainWindow -> loadedFile -> setText(m_DataFlow->m_InputData -> filePath());

  QString fname = m_DataFlow->m_InputData -> fileName();
  QStringList hdr = m_DataFlow->m_InputData -> header();

  m_DataFlow->m_NormalizedData -> setFileName(fname+"_norm");
  m_DataFlow->m_NormalizedData -> setHeader(hdr);

  m_DataFlow->m_AveragedData -> setFileName(fname+"_avg");
  m_DataFlow->m_AveragedData -> setHeader(hdr);
}


QseScan* QseController::scan(int n)
{
  return m_DataFlow->m_InputData->scan(n);
}

QseScan* QseController::currentScan()
{
  return m_DataFlow->m_InputData->scan(m_CurrentScan);
}

void QseController::runNormalizer()
{
  m_DataFlow->m_Normalizer->exec();

  emit normalizedScansChanged();
}

void QseController::openDataFile()
{
  QString filename = QFileDialog::getOpenFileName(m_MainWindow, tr("Open Data File"), ".", "");

  if (filename != "") {
    readDataFile(filename);
  }
}

void QseController::readDataFile(const QString &name)
{
//   setCurrentScan(0);

  m_DataFlow -> m_InputReader -> openFile(name);

  openCompleted();

  message(tr("New Data File loaded %1").arg(name));
}

void QseController::appendDataFile()
{
  QString filename = QFileDialog::getOpenFileName(m_MainWindow, tr("Append Data File"), ".", "");

  if (filename != "") {
    appendDataFile(filename);
  }
}

void QseController::appendDataFile(const QString &name)
{
  m_DataFlow -> m_InputReader -> appendFile(name);

  openCompleted();

  message(tr("New Data File appended %1").arg(name));
}

void QseController::openControlFile()
{
  QString filename = QFileDialog::getOpenFileName(m_MainWindow, tr("Open Control File"), ".", "");

  if (filename != "") {
    readControlFile(filename);
  }
}

void QseController::readControlFile(const QString &name)
{
  QSettings settings(name, QSettings::IniFormat);

  readSettings(&settings);
}

void QseController::saveSplitDataFile()
{
//   m_MainController -> saveSelectedScans();
}

void QseController::saveNormalizedFile()
{
  m_NormalizedController -> saveSelectedScans();
}

void QseController::saveAveragedFile()
{
  m_AveragedController -> saveSelectedScans();
}

void QseController::saveControlFile()
{
  QString filename = QFileDialog::getSaveFileName(m_MainWindow, tr("Save Control File"), ".", "");

  if (filename != "") {
    writeControlFile(filename);
  }
}

void QseController::writeControlFile(const QString &name)
{
  QSettings settings(name, QSettings::IniFormat);

  writeSettings(&settings);
}

void QseController::exitApplication()
{
}

void QseController::readSettings(QSettings *settings)
{
//   QString scanPattern = settings->value("scanPattern").toString();
//   QString energyPattern = settings->value("energyPattern").toString();
//   QString detectorPattern = settings->value("detectorPattern").toString();
//   QString normalizationPattern = settings->value("normalizationPattern").toString();
//   QString secondsPattern = settings->value("secondsPattern").toString();
//   QString minScanRowCount = settings->value("minScanRowCount").toString();
//   QString maxScanRowCount = settings->value("maxScanRowCount").toString();

//   int  inputEnergyUnits = settings->value("inputEnergyUnits").toInt();
//   int  outputEnergyUnits = settings->value("outputEnergyUnits").toInt();

//   bool scanRegexp = settings->value("scanRegexp").toBool();
//   bool energyRegexp = settings->value("energyRegexp").toBool();
//   bool detectorRegexp = settings->value("detectorRegexp").toBool();
//   bool normalizationRegexp = settings->value("normalizationRegexp").toBool();
//   bool secondsRegexp = settings->value("secondsRegexp").toBool();

//   m_DataFlow->m_AveragerRole->setScanPattern(scanPattern);
//   m_DataFlow->m_AveragerRole->setEnergyPattern(energyPattern);
//   m_DataFlow->m_AveragerRole->setDetectorPattern(detectorPattern);
//   m_DataFlow->m_AveragerRole->setNormalizationPattern(normalizationPattern);
//   m_DataFlow->m_AveragerRole->setSecondsPattern(secondsPattern);
//   m_DataFlow->m_AveragerRole->setMinScanRowCount(minScanRowCount);
//   m_DataFlow->m_AveragerRole->setMaxScanRowCount(maxScanRowCount);
  
//   m_DataFlow->m_AveragerRole->setInputEnergyUnits(inputEnergyUnits);
//   m_DataFlow->m_AveragerRole->setOutputEnergyUnits(outputEnergyUnits);

//   m_DataFlow->m_AveragerRole->setScanRegexp(scanRegexp);
//   m_DataFlow->m_AveragerRole->setEnergyRegexp(energyRegexp);
//   m_DataFlow->m_AveragerRole->setDetectorRegexp(detectorRegexp);
//   m_DataFlow->m_AveragerRole->setNormalizationRegexp(normalizationRegexp);
//   m_DataFlow->m_AveragerRole->setSecondsRegexp(secondsRegexp);

//   if (m_DataFlow->m_InputData) {
//     if (m_DataFlow->m_InputData->filePath() == settings->value("inputfile").toString()) {
//       settings->beginReadArray("overrides");
//       int ns = m_DataFlow->m_InputData -> scanCount();

//       m_DataFlow->m_InputData -> setDefaultRoles();

//       for (int i=0; i<ns; i++) {
//      QseScan *s = m_DataFlow->m_InputData->scan(i);
        
//      if (s) {
//        settings->setArrayIndex(i);

//        if (settings->contains("scanrole")) {
//          QseScan::QseScanRole r = (QseScan::QseScanRole) settings->value("scanrole").toInt();
//          int nc = s -> columnCount();

//          s -> setScanRole(r);

//          settings->beginReadArray("roles");

//          for (int j=0; j<nc; j++) {
//            QseColumn *c = s->column(j);

//            settings->setArrayIndex(j);

//            if (settings->contains("role")) {
//              QseColumn::QseColumnRole r = (QseColumn::QseColumnRole) settings->value("role").toInt();

//              c -> setColumnRole(r);
//            }
//          }

//          settings -> endArray();
//        }
//      }
//       }

//       settings -> endArray();
//     } else {
//       printf("overridden file name does not match\n");
//     }
//   }

// //   revertPatternDisplay();

//   emit defaultRolesChanged();
}

void QseController::writeSettings(QSettings *settings)
{
//   settings->setValue("scanPattern", m_DataFlow->m_AveragerRole->scanPattern());
//   settings->setValue("energyPattern", m_DataFlow->m_AveragerRole->energyPattern());
//   settings->setValue("detectorPattern", m_DataFlow->m_AveragerRole->detectorPattern());
//   settings->setValue("normalizationPattern", m_DataFlow->m_AveragerRole->normalizationPattern());
//   settings->setValue("secondsPattern", m_DataFlow->m_AveragerRole->secondsPattern());
//   settings->setValue("minScanRowCount", m_DataFlow->m_AveragerRole->minScanRowCount());
//   settings->setValue("maxScanRowCount", m_DataFlow->m_AveragerRole->maxScanRowCount());
//   settings->setValue("inputEnergyUnits", m_DataFlow->m_AveragerRole->inputEnergyUnits());
//   settings->setValue("outputEnergyUnits", m_DataFlow->m_AveragerRole->outputEnergyUnits());

//   settings->setValue("scanRegexp", m_DataFlow->m_AveragerRole->scanRegexp());
//   settings->setValue("energyRegexp", m_DataFlow->m_AveragerRole->energyRegexp());
//   settings->setValue("detectorRegexp", m_DataFlow->m_AveragerRole->detectorRegexp());
//   settings->setValue("normalizationRegexp", m_DataFlow->m_AveragerRole->normalizationRegexp());
//   settings->setValue("secondsRegexp", m_DataFlow->m_AveragerRole->secondsRegexp());

//   if (m_DataFlow->m_InputData) {
//     settings->setValue("inputfile", m_DataFlow->m_InputData->filePath());
//     int ns = m_DataFlow->m_InputData -> scanCount();
//     settings->setValue("inputscancount", ns);

//     if (ns > 0) {
//       settings->beginWriteArray("overrides");

//       for (int i=0; i<ns; i++) {
//      settings -> setArrayIndex(i);

//      QseScan *s = m_DataFlow->m_InputData -> scan(i);

//      if (s) {
//        int nc = s->columnCount();
//        int ovr = false;

//        for (int j=0; j<nc; j++) {
//          QseColumn *c = s->column(j);
//          if (c) {
//            QseColumn::QseColumnRole r = c->columnRole();
              
//            if (r != QseColumn::UnspecifiedRole) {
//              ovr = true;
//              break;
//            }
//          }
//        }
          
//        if (ovr) {
//          QseScan::QseScanRole r = s->scanRole();
//          settings->setValue("scanrole", r);
            
//          settings->beginWriteArray("roles");

//          for (int j=0; j<nc; j++) {
//            QseColumn *c = s->column(j);
//            if (c) {
//              QseColumn::QseColumnRole r = c->columnRole();

//              if (r != QseColumn::UnspecifiedRole) {
//                settings->setArrayIndex(j);
//                settings->setValue("name", c->name());
//                settings->setValue("role", r);
//              }
//            }
//          }

//          settings->endArray();
//        }
//      }
//       }

//       settings->endArray();
//     }
//   }
}

void QseController::averageSelectedScans()
{
//   QTableWidget *t = m_MainWindow->normalizedScanTable;

//   QList<QTableWidgetSelectionRange> selections = t -> selectedRanges();
//   QTableWidgetSelectionRange selection;

//   int nscans = 0;
//   QseScan *result = m_DataFlow->m_AveragedDataSet -> appendScan();

//   foreach (selection, selections) {
//     int r0 = selection.topRow();
//     int r1 = selection.bottomRow();

//     for (int i = r0; i<=r1; i++) {
//       QseScan *s = m_DataFlow->m_NormalizedDataSet->scan(i);

//       if (s) {
//      if (m_DataFlow->m_Averager->addScans(result, s)) {
//        nscans++;
//      }
//       }
//     }
//   }

//   if (nscans > 0) {
//     m_DataFlow->m_Averager->divideScan(result, nscans);

//     emit averagedScansChanged();
//   } else {
//     delete result;
//   }
}

void QseController::openQSEHomePage()
{
  QDesktopServices::openUrl(QUrl("http://qse.sourceforge.net"));
}