comparison data/model/ModelDataTableModel.cpp @ 454:ba7aaacb7211

* Support transforms that output regions with more than one bin (by
  creating more than one region)
* When model displayed in the spreadsheet dialog is deleted, close
  the dialog in preference to crashing

     Model *baseModel = dynamic_cast<Model *>(m);
 
     connect(baseModel, SIGNAL(modelChanged()), this, SLOT(modelChanged()));
     connect(baseModel, SIGNAL(modelChanged(size_t, size_t)),
             this, SLOT(modelChanged(size_t, size_t)));
+    connect(baseModel, SIGNAL(aboutToBeDeleted()),
+            this, SLOT(modelAboutToBeDeleted()));
 }
 
 ModelDataTableModel::~ModelDataTableModel()
 {
 }
 
 QVariant
 ModelDataTableModel::data(const QModelIndex &index, int role) const
 {
+    if (!m_model) return QVariant();
     if (role != Qt::EditRole && role != Qt::DisplayRole) return QVariant();
     if (!index.isValid()) return QVariant();
     return m_model->getData(getUnsorted(index.row()), index.column(), role);
 }
 
 bool
 ModelDataTableModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
+    if (!m_model) return false;
     if (!index.isValid()) return false;
     Command *command = m_model->getSetDataCommand(getUnsorted(index.row()),
                                                   index.column(),
                                                   value, role);
     if (command) {

 }
 
 bool
 ModelDataTableModel::insertRow(int row, const QModelIndex &parent)
 {
+    if (!m_model) return false;
     if (parent.isValid()) return false;
 
     emit beginInsertRows(parent, row, row);
 
     Command *command = m_model->getInsertRowCommand(getUnsorted(row));

 }
 
 bool
 ModelDataTableModel::removeRow(int row, const QModelIndex &parent)
 {
+    if (!m_model) return false;
     if (parent.isValid()) return false;
 
     emit beginRemoveRows(parent, row, row);
 
     Command *command = m_model->getRemoveRowCommand(getUnsorted(row));

 }
 
 QVariant
 ModelDataTableModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
+    if (!m_model) return QVariant();
+
     if (orientation == Qt::Vertical && role == Qt::DisplayRole) {
         return section + 1;
     }
     if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
         return m_model->getHeading(section);

 }
 
 int
 ModelDataTableModel::rowCount(const QModelIndex &parent) const
 {
+    if (!m_model) return 0;
     if (parent.isValid()) return 0;
     return m_model->getRowCount();
 }
 
 int
 ModelDataTableModel::columnCount(const QModelIndex &parent) const
 {
+    if (!m_model) return 0;
     if (parent.isValid()) return 0;
     return m_model->getColumnCount();
 }
 
 QModelIndex 
 ModelDataTableModel::getModelIndexForFrame(size_t frame) const
 {
+    if (!m_model) return createIndex(0, 0);
     int row = m_model->getRowForFrame(frame);
     return createIndex(getSorted(row), 0, 0);
 }
 
 size_t 
 ModelDataTableModel::getFrameForModelIndex(const QModelIndex &index) const
 {
+    if (!m_model) return 0;
     return m_model->getFrameForRow(getUnsorted(index.row()));
 }
 
 void
 ModelDataTableModel::sort(int column, Qt::SortOrder sortOrder)

     //!!! inefficient
     clearSort();
     emit layoutChanged();
 }
 
+void
+ModelDataTableModel::modelAboutToBeDeleted()
+{
+    m_model = 0;
+    emit modelRemoved();
+}
+
 int
 ModelDataTableModel::getSorted(int row) const
 {
+    if (!m_model) return row;
+
     if (m_model->isColumnTimeValue(m_sortColumn)) {
         if (m_sortOrdering == Qt::AscendingOrder) {
             return row;
         } else {
             return rowCount() - row - 1;

 }
 
 int
 ModelDataTableModel::getUnsorted(int row) const
 {
+    if (!m_model) return row;
+
     if (m_model->isColumnTimeValue(m_sortColumn)) {
         if (m_sortOrdering == Qt::AscendingOrder) {
             return row;
         } else {
             return rowCount() - row - 1;

 }
 
 void
 ModelDataTableModel::resort() const
 {
+    if (!m_model) return;
+
     bool numeric = (m_model->getSortType(m_sortColumn) ==
                     TabularModel::SortNumeric);
 
     m_sort.clear();
     m_rsort.clear();

 }
 
 void
 ModelDataTableModel::resortNumeric() const
 {
+    if (!m_model) return;
+
     typedef std::multimap<double, int> MapType;
 
     MapType rowMap;
     int rows = m_model->getRowCount();
 

 }
 
 void
 ModelDataTableModel::resortAlphabetical() const
 {
+    if (!m_model) return;
+
     typedef std::multimap<QString, int> MapType;
 
     MapType rowMap;
     int rows = m_model->getRowCount();