qsenormalizerui.cpp

Go to the documentation of this file.

#include "qsenormalizerui.h"
#include "qsenormalizer.h"
#include "qsenormalizermodel.h"
#include "qsegraphcontroller.h"
#include "qsedatasetmodel.h"
#include "qsegraphscansmodel.h"

#include <QMenu>

QseNormalizerUI::QseNormalizerUI
(QseNormalizer* normalizer, QWidget* parent)
  : QseEXAFSOperatorUI(normalizer, parent),
    m_Normalizer(normalizer),
//     m_NormalizerTable(NULL),
    m_NormalizerModel(NULL),
    m_ScanPatternEditor(this, &m_Normalizer->m_ScanPattern, NULL),
    m_EnergyPatternEditor(this, &m_Normalizer->m_EnergyPattern, NULL),
    m_DetectorPatternEditor(this, &m_Normalizer->m_DetectorPattern, NULL),
    m_NormalizationPatternEditor(this, &m_Normalizer->m_NormalizationPattern, NULL),
    m_SecondsPatternEditor(this, &m_Normalizer->m_SecondsPattern, NULL),
    m_CopyPatternEditor(this, &m_Normalizer->m_CopyPattern, NULL),
    m_CopyNormalizedPatternEditor(this, &m_Normalizer->m_CopyNormalizedPattern, NULL),
    m_CopyRatePatternEditor(this, &m_Normalizer->m_CopyRatePattern, NULL),
    m_CopyTotalCountsPatternEditor(this, &m_Normalizer->m_CopyTotalCountsPattern, NULL),
    m_MinScanRowCountEditor(this, &m_Normalizer->m_MinScanRowCount, NULL),
    m_MaxScanRowCountEditor(this, &m_Normalizer->m_MaxScanRowCount, NULL),
    m_MinScanColumnCountEditor(this, &m_Normalizer->m_MinScanColumnCount, NULL),
    m_MaxScanColumnCountEditor(this, &m_Normalizer->m_MaxScanColumnCount, NULL),
    m_InputEnergyUnitsEditor(this, &m_Normalizer->m_InputEnergyUnits, NULL),
    m_OutputEnergyUnitsEditor(this, &m_Normalizer->m_OutputEnergyUnits, NULL)
{
  setupUi(this);

  m_ScanPatternEditor.setEditors
      (scanPatternEdit,scanRegexp,patternApply,patternCancel);

  m_EnergyPatternEditor.setEditors
    (energyPatternEdit,energyRegexp,patternApply,patternCancel,
     m_EnergyColumnsButton, m_Normalizer->colorForRole(QseNormalizer::EnergyRole), m_Normalizer->backgroundColorForRole(QseNormalizer::EnergyRole));

  m_DetectorPatternEditor.setEditors
    (detectorPatternEdit,detectorRegexp,patternApply,patternCancel,
     m_DetectorColumnsButton, m_Normalizer->colorForRole(QseNormalizer::DetectorRole), m_Normalizer->backgroundColorForRole(QseNormalizer::DetectorRole));

  m_NormalizationPatternEditor.setEditors
    (normalizationPatternEdit,normalizationRegexp,patternApply,patternCancel,
     m_NormalizationColumnsButton, m_Normalizer->colorForRole(QseNormalizer::NormalizationRole), m_Normalizer->backgroundColorForRole(QseNormalizer::NormalizationRole));

  m_SecondsPatternEditor.setEditors
    (secondsPatternEdit,secondsRegexp,patternApply,patternCancel,
     m_SecondsColumnsButton, m_Normalizer->colorForRole(QseNormalizer::SecondsRole), m_Normalizer->backgroundColorForRole(QseNormalizer::SecondsRole));

  m_CopyPatternEditor.setEditors
    (copyPatternEdit,copyRegexp,patternApply,patternCancel,
     m_CopyColumnsButton, m_Normalizer->colorForRole(QseNormalizer::CopyRole), m_Normalizer->backgroundColorForRole(QseNormalizer::CopyRole));

  m_CopyNormalizedPatternEditor.setEditors
    (copyNormalizedPatternEdit,copyNormalizedRegexp,patternApply,patternCancel,
     m_CopyNormalizedColumnsButton, m_Normalizer->colorForRole(QseNormalizer::CopyNormalizedRole), m_Normalizer->backgroundColorForRole(QseNormalizer::CopyNormalizedRole));

  m_CopyRatePatternEditor.setEditors
    (copyRatePatternEdit,copyRateRegexp,patternApply,patternCancel,
     m_CopyRateColumnsButton, m_Normalizer->colorForRole(QseNormalizer::CopyRateRole), m_Normalizer->backgroundColorForRole(QseNormalizer::CopyRateRole));

  m_CopyTotalCountsPatternEditor.setEditors
    (copyTotalCountsPatternEdit,copyTotalCountsRegexp,patternApply,patternCancel,
     m_CopyTotalCountsColumnsButton, m_Normalizer->colorForRole(QseNormalizer::CopyTotalCountsRole), m_Normalizer->backgroundColorForRole(QseNormalizer::CopyTotalCountsRole));

  m_MinScanRowCountEditor.setEditors
    (minScanRowCount,patternApply,patternCancel);

  m_MaxScanRowCountEditor.setEditors
    (maxScanRowCount,patternApply,patternCancel);

  m_MinScanColumnCountEditor.setEditors
    (minScanColumnCount,patternApply,patternCancel);

  m_MaxScanColumnCountEditor.setEditors
    (maxScanColumnCount,patternApply,patternCancel);

  m_InputEnergyUnitsEditor.setEditors
    (inputUnits,patternApply,patternCancel);

  m_OutputEnergyUnitsEditor.setEditors
    (outputUnits,patternApply,patternCancel);

  connect(patternApply, SIGNAL(clicked()), this, SLOT(dialogApply()));
  connect(patternCancel, SIGNAL(clicked()), this, SLOT(dialogCancel()));
  connect(normalizeButton, SIGNAL(clicked()), this, SLOT(normalize()));

  m_NormalizerModel = new QseNormalizerModel(m_Normalizer, m_NormalizerTable, this);
  m_NormalizerTable -> setModel(m_NormalizerModel);

  m_NormalizerTable -> setContextMenuPolicy(Qt::CustomContextMenu);
  connect(m_NormalizerTable, SIGNAL(customContextMenuRequested(const QPoint&)),
          this, SLOT(normalizerTableContextMenu(const QPoint&)));

  connect(m_UseScansButton, SIGNAL(clicked()),
          this,SLOT(setScansUsed()));
  connect(m_ExcludeScansButton, SIGNAL(clicked()),
          this,SLOT(setScansUnused()));
  connect(m_DefaultScansButton, SIGNAL(clicked()),
          this,SLOT(setScansDefault()));

  connect(m_EnergyColumnsButton, SIGNAL(clicked()),
          this,SLOT(setEnergyColumns()));
  connect(m_DetectorColumnsButton, SIGNAL(clicked()),
          this,SLOT(setDetectorColumns()));
  connect(m_NormalizationColumnsButton, SIGNAL(clicked()),
          this,SLOT(setNormalizationColumns()));
  connect(m_SecondsColumnsButton, SIGNAL(clicked()),
          this,SLOT(setSecondsColumns()));
  connect(m_CopyColumnsButton, SIGNAL(clicked()),
          this,SLOT(setCopyColumns()));
  connect(m_CopyNormalizedColumnsButton, SIGNAL(clicked()),
          this,SLOT(setCopyNormalizedColumns()));
  connect(m_CopyRateColumnsButton, SIGNAL(clicked()),
          this,SLOT(setCopyRateColumns()));
  connect(m_CopyTotalCountsColumnsButton, SIGNAL(clicked()),
          this,SLOT(setCopyTotalCountsColumns()));
  connect(m_ExcludeColumnsButton, SIGNAL(clicked()),
          this,SLOT(setExcludeColumns()));
  connect(m_DefaultColumnsButton, SIGNAL(clicked()),
          this,SLOT(setDefaultsColumns()));
}

void QseNormalizerUI::setScansUsed()
{
  setScanExceptions(QseNormalizer::ScanUsedRole);
}

void QseNormalizerUI::setScansUnused()
{
  setScanExceptions(QseNormalizer::ScanNotUsedRole);
}

void QseNormalizerUI::setScansDefault()
{
  setScanExceptions(QseNormalizer::UnspecifiedScanRole);
}

void QseNormalizerUI::setEnergyColumns()
{
  setColumnExceptions(QseNormalizer::EnergyRole);
}

void QseNormalizerUI::setDetectorColumns()
{
  setColumnExceptions(QseNormalizer::DetectorRole);
}

void QseNormalizerUI::setNormalizationColumns()
{
  setColumnExceptions(QseNormalizer::NormalizationRole);
}

void QseNormalizerUI::setSecondsColumns()
{
  setColumnExceptions(QseNormalizer::SecondsRole);
}

void QseNormalizerUI::setCopyColumns()
{
  setColumnExceptions(QseNormalizer::CopyRole);
}

void QseNormalizerUI::setCopyNormalizedColumns()
{
  setColumnExceptions(QseNormalizer::CopyNormalizedRole);
}

void QseNormalizerUI::setCopyRateColumns()
{
  setColumnExceptions(QseNormalizer::CopyRateRole);
}

void QseNormalizerUI::setCopyTotalCountsColumns()
{
  setColumnExceptions(QseNormalizer::CopyTotalCountsRole);
}

void QseNormalizerUI::setExcludeColumns()
{
  setColumnExceptions(QseNormalizer::NotUsedRole);
}

void QseNormalizerUI::setDefaultsColumns()
{
  setColumnExceptions(QseNormalizer::UnspecifiedRole);
}

void QseNormalizerUI::normalizerTableContextMenu(const QPoint& pos)
{
  QMenu menu(NULL, NULL);

  QAction* excludeScan = menu.addAction(QString("Exclude Scans"));
  QAction* includeScan = menu.addAction(QString("Include Scans"));
  QAction* defaultScan = menu.addAction(QString("Return Scans to default usage"));

  QAction* separator   = menu.addSeparator();

  QAction* energyColumn = menu.addAction(QString("Use columns as Energy"));
  QAction* detectorColumn = menu.addAction(QString("Use columns as Detector"));
  QAction* normalizeColumn = 
    menu.addAction(QString("Use columns for normalization"));
  QAction* secondsColumn = 
    menu.addAction(QString("Use columns for counting time"));
  QAction* copyColumn =
    menu.addAction(QString("Copy columns to output"));
  QAction* copyNormalizedColumn =
    menu.addAction(QString("Copy columns to output normalized by 'normalization'"));
  QAction* copyRateColumn =
    menu.addAction(QString("Copy columns to output divided by 'seconds'"));
  QAction* copyTotalCountsColumn =
    menu.addAction(QString("Copy columns to output multiplied by 'seconds'"));
  QAction* excludeColumn =
    menu.addAction(QString("Do not use columns"));
  QAction* defaultColumn = 
    menu.addAction(QString("Return columns to default usage"));

  menu.setMouseTracking(true);

  QAction* id = menu.exec(QCursor::pos() + QPoint( -40, -10), separator);

  if (id == excludeScan) {
    setScansUnused();
  } else if (id == includeScan) { 
    setScansUsed();
  } else if (id == defaultScan) {
    setScansDefault();
  } else if (id == energyColumn) {
    setEnergyColumns();
  } else if (id == detectorColumn) {
    setDetectorColumns();
  } else if (id == normalizeColumn) {
    setNormalizationColumns();
  } else if (id == secondsColumn) {
    setSecondsColumns();
  } else if (id == copyColumn) {
    setCopyColumns();
  } else if (id == copyNormalizedColumn) {
    setCopyNormalizedColumns();
  } else if (id == copyRateColumn) {
    setCopyRateColumns();
  } else if (id == copyTotalCountsColumn) {
    setCopyTotalCountsColumns();
  } else if (id == excludeColumn) {
    setExcludeColumns();
  } else if (id == defaultColumn) {
    setDefaultsColumns();
  }
}

void QseNormalizerUI::setScanExceptions(QseNormalizer::QseScanRole r)
{
  QItemSelectionModel *s = m_NormalizerTable -> selectionModel();

  m_NormalizerModel -> setScanExceptions(s,r);
  
  m_NormalizerModel -> operationCompleted();
}

void QseNormalizerUI::setColumnExceptions(QseNormalizer::QseColumnRole r)
{
  QItemSelectionModel *s = m_NormalizerTable -> selectionModel();

  m_NormalizerModel -> setColumnExceptions(s,r);

  m_NormalizerModel -> operationCompleted();
}

void QseNormalizerUI::dialogApply()
{
  if (editorValidate()) {
    editorApply();

    patternApply -> setEnabled(false);
    patternCancel-> setEnabled(false);
    normalizeButton-> setEnabled(true);

    m_NormalizerModel -> operationCompleted();
  }
}

void QseNormalizerUI::dialogCancel()
{
  editorCancel();

  patternApply -> setEnabled(false);
  patternCancel-> setEnabled(false);
  normalizeButton-> setEnabled(true);

  m_NormalizerModel -> operationCompleted();
}

void QseNormalizerUI::normalize()
{
  dialogApply();

  m_Normalizer -> exec();
}