qsenormalizermodel.cpp

Go to the documentation of this file.

#include "qsenormalizermodel.h"
#include "qsenormalizer.h"
#include "qsedataset.h"

#include <QColor>
#include <QTableView>

#include <stdio.h>

QseNormalizerModel::QseNormalizerModel
(QseNormalizer *normalizer, QTableView *table, QObject *parent)
  : inherited(parent),
    m_Normalizer(normalizer),
    m_TableView(table)
{
  connect(m_Normalizer -> inputData(), SIGNAL(operationCompleted()),
          this,                        SLOT(operationCompleted()));

  //   connect(m_Normalizer -> inputData(), SIGNAL(dataChanged()),
  //      this,                        SLOT(dataChanged()));

  //   connect(m_Normalizer -> inputData(), SIGNAL(dataCleared()),
  //      this,                        SLOT(dataCleared()));

  //   connect(m_Normalizer -> inputData(), SIGNAL(dataChanged()),
  //      this,                        SIGNAL(modelReset()));
}

int
QseNormalizerModel::rowCount(const QModelIndex &parent) const
{
  if (parent.column() > 0) {
    return 0;
  }

  int res = m_Normalizer -> inputData() -> scanCount();

  return res;
}

int
QseNormalizerModel::columnCount(const QModelIndex &parent) const
{
  int res = 3 + m_Normalizer -> inputData() -> maxColumnCount();

  //   printf("QseNormalizerModel::columnCount = %d\n", res);

  return res;
}

QVariant
QseNormalizerModel::data(const QModelIndex &index, int role) const
{
  //   printf("QseNormalizerModel::data(%d,%d,%d)\n", index.row(), index.column(), role);

  if (!index.isValid()) {
    return QVariant();
  }

  if (role == Qt::DisplayRole) {

    int row = index.row();
    int col = index.column();

    QseScan *scan = m_Normalizer -> inputData() -> scan(row);

    switch (col) {
    case 0:
      return scan -> name();
      break;
    case 1:
      return scan -> maxRowCount();
      break;
    case 2:
      return scan -> columnCount();
      break;
    default:
      QseColumn *c = scan->column(col-3);
      
      if (c) {
        return c -> name();
      } else {
        return QVariant();
      }
    }
    
  } else if (role == Qt::BackgroundRole) {
    int row = index.row();
    int col = index.column();

    QseScan *scan = m_Normalizer -> inputData() -> scan(row);

    switch (col) {
    case 0:
    case 1:
    case 2:
      if (m_Normalizer -> matchesScanException(row)) {
        return QColor(230,255,230);
      } else {
        return QColor(Qt::white);
      }
      break;
    default:
      QseColumn *c = scan->column(col-3);
      
      if (c) {
        QseNormalizer::QseColumnRole role = m_Normalizer->exceptionalColumnRole(row, col-3);

        return QseNormalizer::backgroundColorForRole(role);
      } else {
        return QVariant();
      }
    }
  } else if (role == Qt::ForegroundRole) {
    //     printf("Foreground role\n");

    int row = index.row();
    int col = index.column();

    QseScan *scan = m_Normalizer -> inputData() -> scan(row);

    switch (col) {
    case 0:
    case 1:
    case 2:
      if (m_Normalizer -> matchesScan(row)) {
        return QColor(Qt::black);
      } else {
        return QColor(Qt::gray);
      }
      break;
    default:
      QseColumn *c = scan->column(col-3);
      
      if (c) {
        QseNormalizer::QseColumnRole role = m_Normalizer->patternColumnRole(row, col-3);

        return QseNormalizer::colorForRole(role);
      } else {
        return QVariant();
      }
    }
  } else {
    return QVariant();
  }
}

QVariant
QseNormalizerModel::headerData
(int section, Qt::Orientation orientation, int role) const
{
  if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
    switch (section) {
    case 0:
      return "Scan Name";
      break;
    case 1:
      return "Rows";
      break;
    case 2:
      return "Columns";
      break;
    default:
      return tr("Col %1").arg(section-3);
    }
  }

  if (orientation == Qt::Vertical && role == Qt::DisplayRole) {
    return section;
  }

  return QVariant();
}

void
QseNormalizerModel::operationCompleted()
{
  //   printf("QseNormalizerModel::operationCompleted()\n");

//  reset();
  beginResetModel();
  endResetModel();

  m_TableView -> resizeRowsToContents();
  m_TableView -> resizeColumnsToContents();
}

void
QseNormalizerModel::dataChanged()
{
  //   m_TableView -> resizeRowsToContents();
  //   m_TableView -> resizeColumnsToContents();

  //   reset();
}

void
QseNormalizerModel::dataCleared()
{
  //   reset();
}

void
QseNormalizerModel::scanAdded(int n)
{
}

void 
QseNormalizerModel::setScanExceptions
(QItemSelectionModel *s, QseNormalizer::QseScanRole r)
{
  QItemSelection sel = s->selection();
  QItemSelectionRange range;

  foreach(range, sel) {
    for (int i=range.top(); i<=range.bottom(); i++) {
      m_Normalizer -> setScanException(i, r);
    }
  }
}

void 
QseNormalizerModel::setColumnExceptions
(QItemSelectionModel *s, QseNormalizer::QseColumnRole r)
{
  QItemSelection sel = s->selection();
  QItemSelectionRange range;

  foreach(range, sel) {
    for (int i=range.top(); i<=range.bottom(); i++) {
      for (int c=range.left(); c<=range.right(); c++) {
        if (c >= 3) {
          m_Normalizer -> setColumnException(i, c-3, r);
        }
      }
    }
  }
}