qseaveragerrole.cpp

Go to the documentation of this file.

#include "qseaveragerrole.h" 

// #include "coloredtableitem.h"
#include "qsescan.h"
#include "qsecolumn.h"

#include <QRegExp>

QseAveragerRole::QseAveragerRole(QObject *parent)
  : QObject(parent),
    m_Averager(NULL),
    m_ScanPattern("*exafsscan*", Qt::CaseInsensitive, QRegExp::Wildcard),
    m_EnergyPattern("energy", Qt::CaseInsensitive, QRegExp::Wildcard),
    m_DetectorPattern("", Qt::CaseInsensitive, QRegExp::Wildcard),
    m_NormalizationPattern("", Qt::CaseInsensitive, QRegExp::Wildcard),
    m_SecondsPattern("", Qt::CaseInsensitive, QRegExp::Wildcard),
    m_MinScanRowCount(""),
    m_MaxScanRowCount(""),
    m_InputEnergyUnits(1),
    m_OutputEnergyUnits(1)
{}

QseAveragerRole::~QseAveragerRole()
{}

int QseAveragerRole::matchesScan(const QseScan *s)
{
    if (s) {
        QseScan::QseScanRole r = s->scanRole();

  bool ok1, ok2;

  double minVal = minScanRowCount().toDouble(&ok1);
  double maxVal = maxScanRowCount().toDouble(&ok2);
  
  if (ok1 || ok2) {
    int nrows = s->maxRowCount();

    if (ok1 && (nrows < minVal)) {
      return FALSE;
    }

    if (ok2 && (nrows > maxVal)) {
      return FALSE;
    }
  }

        if (r == QseScan::UnspecifiedRole) {
            return m_ScanPattern.exactMatch(s->scanCommand() );
        } else {
            return r == QseScan::UsedRole;
        }
    } else {
        return FALSE;
    }
}

int QseAveragerRole::matchesEnergyColumn(const QseColumn *c)
{
    if (c) {
        QseColumn::QseColumnRole r = c->columnRole();

        if (r == QseColumn::UnspecifiedRole) {
            return m_EnergyPattern.exactMatch(c->name());
        } else {
            return r == QseColumn::EnergyRole;
        }
    } else {
        return FALSE;
    }
}

int QseAveragerRole::matchesDetectorColumn(const QseColumn *c)
{
    if (c) {
        QseColumn::QseColumnRole r = c->columnRole();

        if (r == QseColumn::UnspecifiedRole) {
            return m_DetectorPattern.exactMatch(c->name());
        } else {
            return r == QseColumn::DetectorRole;
        }
    } else {
        return FALSE;
    }
}

int QseAveragerRole::matchesNormalizationColumn(const QseColumn *c)
{
    if (c) {
        QseColumn::QseColumnRole r = c->columnRole();

        if (r == QseColumn::UnspecifiedRole) {
            return m_NormalizationPattern.exactMatch(c->name());
        } else {
            return r == QseColumn::NormalizationRole;
        }
    } else {
        return FALSE;
    }
}

int QseAveragerRole::matchesSecondsColumn(const QseColumn *c)
{
    if (c) {
        QseColumn::QseColumnRole r = c->columnRole();

        if (r == QseColumn::UnspecifiedRole) {
            return m_SecondsPattern.exactMatch(c->name());
        } else {
            return r == QseColumn::SecondsRole;
        }
    } else {
        return FALSE;
    }
}

QString QseAveragerRole::scanPattern()
{
    return m_ScanPattern.pattern();
}

void QseAveragerRole::setScanPattern(const QString &pattern)
{
    if (m_ScanPattern.pattern() != pattern) {
        m_ScanPattern.setPattern(pattern);

        emit changed();
    }
}

QString QseAveragerRole::energyPattern()
{
    return m_EnergyPattern.pattern();
}

void QseAveragerRole::setEnergyPattern(const QString &pattern)
{
    if (m_EnergyPattern.pattern() != pattern) {
        m_EnergyPattern.setPattern(pattern);

        emit changed();
    }
}

QString QseAveragerRole::detectorPattern()
{
    return m_DetectorPattern.pattern();
}

void QseAveragerRole::setDetectorPattern(const QString &pattern)
{
    if (m_DetectorPattern.pattern() != pattern) {
        m_DetectorPattern.setPattern(pattern);

        emit changed();
    }
}

QString QseAveragerRole::normalizationPattern()
{
    return m_NormalizationPattern.pattern();
}

void QseAveragerRole::setNormalizationPattern(const QString &pattern)
{
    if (m_NormalizationPattern.pattern() != pattern) {
        m_NormalizationPattern.setPattern(pattern);

        emit changed();
    }
}

QString QseAveragerRole::secondsPattern()
{
    return m_SecondsPattern.pattern();
}

void QseAveragerRole::setSecondsPattern(const QString &pattern)
{
    if (m_SecondsPattern.pattern() != pattern) {
        m_SecondsPattern.setPattern(pattern);

        emit changed();
    }
}

QString QseAveragerRole::minScanRowCount()
{
    return m_MinScanRowCount;
}

void QseAveragerRole::setMinScanRowCount(const QString &ct)
{
    if (m_MinScanRowCount != ct) {
        m_MinScanRowCount = ct;

        emit changed();
    }
}

QString QseAveragerRole::maxScanRowCount()
{
    return m_MaxScanRowCount;
}

void QseAveragerRole::setMaxScanRowCount(const QString &ct)
{
    if (m_MaxScanRowCount != ct) {
        m_MaxScanRowCount = ct;

        emit changed();
    }
}

int QseAveragerRole::inputEnergyUnits()
{
  return m_InputEnergyUnits;
}

void QseAveragerRole::setInputEnergyUnits(int n)
{
  if (m_InputEnergyUnits != n) {
    m_InputEnergyUnits = n;

    emit changed();
  }
}

int QseAveragerRole::outputEnergyUnits()
{
  return m_OutputEnergyUnits;
}

void QseAveragerRole::setOutputEnergyUnits(int n)
{
  if (m_OutputEnergyUnits != n) {
    m_OutputEnergyUnits = n;

    emit changed();
  }
}

double QseAveragerRole::energyScalingRatio()
{
  if (m_InputEnergyUnits == m_OutputEnergyUnits) {
    return 1.0;
  } else if (m_InputEnergyUnits == 0 && m_OutputEnergyUnits == 1) {
    return 0.001;
  } else if (m_InputEnergyUnits == 1 && m_OutputEnergyUnits == 0) {
    return 1000.0;
  } else {
    return 1;
  }
}

bool QseAveragerRole::scanRegexp()
{
  return m_ScanPattern.patternSyntax() == QRegExp::RegExp;
}

bool QseAveragerRole::energyRegexp()
{
    return m_EnergyPattern.patternSyntax() == QRegExp::RegExp;
}

bool QseAveragerRole::detectorRegexp()
{
    return m_DetectorPattern.patternSyntax() == QRegExp::RegExp;
}

bool QseAveragerRole::normalizationRegexp()
{
    return m_NormalizationPattern.patternSyntax() == QRegExp::RegExp;
}

bool QseAveragerRole::secondsRegexp()
{
    return m_SecondsPattern.patternSyntax() == QRegExp::RegExp;
}

void QseAveragerRole::setScanRegexp(bool re)
{
  QRegExp::PatternSyntax n = (re ?  QRegExp::RegExp : QRegExp::Wildcard);
  
    if (m_ScanPattern.patternSyntax() != n) {
        m_ScanPattern.setPatternSyntax(n);
        emit changed();
    }
}

void QseAveragerRole::setEnergyRegexp(bool re)
{
  QRegExp::PatternSyntax n = (re ?  QRegExp::RegExp : QRegExp::Wildcard);
  
    if (m_EnergyPattern.patternSyntax() != n) {
        m_EnergyPattern.setPatternSyntax(n);
        emit changed();
    }
}

void QseAveragerRole::setDetectorRegexp(bool re)
{
  QRegExp::PatternSyntax n = (re ?  QRegExp::RegExp : QRegExp::Wildcard);
  
    if (m_DetectorPattern.patternSyntax() != n) {
        m_DetectorPattern.setPatternSyntax(n);
        emit changed();
    }
}

void QseAveragerRole::setNormalizationRegexp(bool re)
{
  QRegExp::PatternSyntax n = (re ?  QRegExp::RegExp : QRegExp::Wildcard);
  
    if (m_NormalizationPattern.patternSyntax() != n) {
        m_NormalizationPattern.setPatternSyntax(n);
        emit changed();
    }
}

void QseAveragerRole::setSecondsRegexp(bool re)
{
  QRegExp::PatternSyntax n = (re ?  QRegExp::RegExp : QRegExp::Wildcard);
  
    if (m_SecondsPattern.patternSyntax() != n) {
        m_SecondsPattern.setPatternSyntax(n);
        emit changed();
    }
}

ColoredTableItem *QseAveragerRole::styledScanItem(QseScan *scan)
{
  bool override = false;

  if (scan -> scanRole() != QseScan::UnspecifiedRole) {
    override = true;
  }

  return NULL;
//   if (this -> matchesScan(scan)) {
//     return new ColoredTableItem(Qt::darkGreen, override, scan->scanCommand());
//   } else {
//     return new ColoredTableItem(Qt::gray, override, scan->scanCommand());
//   }
}

ColoredTableItem *QseAveragerRole::styledColumnItem(QseColumn *col)
{
  bool override = false;

  if (col -> columnRole() != QseColumn::UnspecifiedRole) {
    override = true;
  }

  return NULL;
//   if (this -> matchesDetectorColumn(col)) {
//     return new ColoredTableItem(Qt::darkGreen, override, col->name());
//   } else if (this -> matchesNormalizationColumn(col)) {
//     return new ColoredTableItem(Qt::darkCyan, override, col->name());
//   } else if (this -> matchesEnergyColumn(col)) {
//     return new ColoredTableItem(Qt::darkRed, override, col->name());
//   } else if (this -> matchesSecondsColumn(col)) {
//     return new ColoredTableItem(Qt::darkMagenta, override, col->name());
//   } else {
//     return new ColoredTableItem(Qt::gray, override, col->name());
//   }
}

---