qsegraphscansmodel.cpp

Go to the documentation of this file.

#include "qsegraphscansmodel.h"
#include "qsedataset.h"
#include <QBrush>
#include <QTableView>

#include <stdio.h>

QseGraphScansModel::QseGraphScansModel
(QseDataSet *dataSet, QTableView *table, QObject *parent)
  : QAbstractTableModel(parent),
    m_DataSet(dataSet),
    m_TableView(table),
    m_PrevRowCount(0),
    m_PrevColumnCount(3)
{
//   connect(dataSet, SIGNAL(dataChanged()),
//        this,    SLOT(dataChanged()));
  connect(dataSet, SIGNAL(operationCompleted()),
          this,    SLOT(operationCompleted()));
}

bool
QseGraphScansModel::scanSelected(int s)
{
  QItemSelectionModel *m = m_TableView -> selectionModel();

  return (m->isRowSelected(s, QModelIndex()));
}

void
QseGraphScansModel::operationCompleted()
{
  int nrows = m_DataSet -> scanCount();
  int ncols = 3;

  if (ncols > m_PrevColumnCount) {
    beginInsertColumns(QModelIndex(), m_PrevColumnCount, ncols-1);
    m_PrevColumnCount = ncols;
    endInsertColumns();
  } else if (ncols < m_PrevColumnCount) {
    beginRemoveColumns(QModelIndex(), ncols, m_PrevColumnCount-1);
    m_PrevColumnCount = ncols;
    endRemoveColumns();
  }

  if (nrows > m_PrevRowCount) {
    beginInsertRows(QModelIndex(), m_PrevRowCount, nrows-1);

    if (scanSelected(m_PrevRowCount-1)) {
      QItemSelectionModel *m = m_TableView -> selectionModel();

      if (scanSelected(m_PrevRowCount-2)) {
        m -> select(index(nrows-1,0),
                    QItemSelectionModel::Current | QItemSelectionModel::Rows |
                    QItemSelectionModel::Select);                 
      } else {
        QItemSelection ss(index(m_PrevRowCount-1,0),index(m_PrevRowCount-1,0));
        ss.select(index(nrows-1,0),index(nrows-1,0));
        m -> select(ss,
                    QItemSelectionModel::Current | QItemSelectionModel::Rows |
                    QItemSelectionModel::Toggle);
      }
    }

    m_PrevRowCount = nrows;
    endInsertRows();
  } else if (nrows < m_PrevRowCount) {
    beginRemoveRows(QModelIndex(), nrows, m_PrevRowCount-1);
    m_PrevRowCount = nrows;
    endRemoveRows();
  }

  QModelIndex topLeft = createIndex(0,0);
  QModelIndex botRight = createIndex(m_PrevRowCount,m_PrevColumnCount);

  emit dataChanged(topLeft, botRight);

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

QModelIndex
QseGraphScansModel::indexOfScan(int n)
{
  return index(n,0,QModelIndex());
}

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

  int res = m_DataSet -> scanCount();

//   if (res > m_PrevRowCount) {
//     printf("QseGraphScansModel::rowCount(%d>%d)\n", res, m_PrevRowCount);
//   } else if (res < m_PrevRowCount) {
//     printf("QseGraphScansModel::rowCount(%d<%d)\n", res, m_PrevRowCount);    
//   }

//   m_PrevRowCount = res;

  return res;
}

int
QseGraphScansModel::columnCount(const QModelIndex &parent) const
{
  int res = 3;

//   if (res > m_PrevColumnCount) {
//     printf("QseGraphScansModel::columnCount(%d>%d)\n", res, m_PrevColumnCount);
//   } else if (res < m_PrevColumnCount) {
//     printf("QseGraphScansModel::columnCount(%d<%d)\n", res, m_PrevColumnCount);    
//   }

//   m_PrevColumnCount = res;

  return res;
}

static int min(int a, int b)
{
  if (a<b) {
    return a;
  } else {
    return b;
  }
}

static
const char* role_string(int role)
{
  switch (role) {
  case Qt::DisplayRole:
    return "Qt::DisplayRole";
    break;
  case Qt::DecorationRole:
    return "Qt::DecorationRole";
    break;
  case Qt::EditRole:
    return "Qt::EditRole";
    break;
  case Qt::ToolTipRole:
    return "Qt::ToolTipRole";
    break;
  case Qt::StatusTipRole:
    return "Qt::StatusTipRole";
    break;
  case Qt::WhatsThisRole:
    return "Qt::WhatsThisRole";
    break;
  case Qt::SizeHintRole:
    return "Qt::SizeHintRole";
    break;
  case Qt::FontRole:
    return "Qt::FontRole";
    break;
  case Qt::TextAlignmentRole:
    return "Qt::TextAlignmentRole";
    break;
  case Qt::BackgroundRole:
    return "Qt::BackgroundRole";
    break;
//   case Qt::BackgroundColorRole:
//     return "Qt::BackgroundColorRole";
//     break;
  case Qt::ForegroundRole:
    return "Qt::ForegroundRole";
    break;
//   case Qt::TextColorRole:
//     return "Qt::TextColorRole";
//     break;
  case Qt::CheckStateRole:
    return "Qt::CheckStateRole";
    break;
  case Qt::AccessibleTextRole:
    return "Qt::AccessibleTextRole";
    break;
  case Qt::AccessibleDescriptionRole:
    return "Qt::AccessibleDescriptionRole";
    break;
  case Qt::UserRole:
    return "Qt::UserRole";
    break;
  default:
    return "Other role";
  }
}

QVariant
QseGraphScansModel::data(const QModelIndex &index, int role) const
{
  if (!index.isValid()) {
    return QVariant();
  }

  int row = index.row();
  int col = index.column();
  
  QseScan *scan = m_DataSet->scan(row);

  switch (role) {
  case Qt::DisplayRole:
    switch (col) {
    case 0:
      return scan -> name();
      break;
    case 1:
      return scan -> maxRowCount();
      break;
    case 2:
      return scan -> columnCount();
      break;
    default:
      return QVariant();
    }
    break;

//   case Qt::BackgroundRole:
//     return QColor(255,255,192);
//     break;

//   case Qt::ForegroundRole:
//     return QBrush(Qt::red);
//     break;

  case Qt::ToolTipRole:
    {
      const int maxlines = 15;
      const int maxlength = 80;

      QString res;

      res = scan->scanCommand()+"\n";
      res += scan->scanDateLine()+"\n";
      
      QStringList hdr = scan -> header();
      int nlines = min(hdr.size(),maxlines);
      for (int i=0; i<nlines; i++) {
        QString l = hdr[i];
        if (l.size()>maxlength) {
          res += l.mid(0,maxlength) + " ...\n";
        } else {
          res += l + "\n";
        }
      }
      if (hdr.size()>maxlines) {
        res += "...";
      } else {
        int ncols = scan->columnCount();
        res += scan->scanColumnCountLine()+"\n";
        QString l = scan->scanColumnNamesLine();
        if (l.size()>maxlength) {
          res += l.mid(0,maxlength) + " ...\n";
        } else {
          res += l + "\n";
        }
      }
      return res;
    }
    break;

  case Qt::SizeHintRole:
    switch (col) {
    case 0:
      return QSize(200,15);
      break;

    case 1:
      return QSize(20,15);
      break;

    case 2:
      return QSize(20,15);
      break;

    default:
      return QVariant();
    }
    break;

  default:
//     printf("QseGraphScansModel::data(%d,%d,%s)\n", row,col, role_string(role));
    return QVariant();
  }
}

QVariant
QseGraphScansModel::headerData
(int section, Qt::Orientation orientation, int role) const
{
  if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
    switch (section) {
    case 0:
      return "Scan";
      break;
    case 1:
      return "rows";
      break;
    case 2:
      return "cols";
      break;
    default:
      return QVariant();
    }
  }

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

  return QVariant();
}