comparison data/model/ModelDataTableModel.cpp @ 929:59e7fe1b1003 warnfix_no_size_t

Unsigned removals and warning fixes in data/

     m_currentRow(0)
 {
     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(modelChanged(int, int)),
+            this, SLOT(modelChanged(int, int)));
     connect(baseModel, SIGNAL(aboutToBeDeleted()),
             this, SLOT(modelAboutToBeDeleted()));
 }
 
 ModelDataTableModel::~ModelDataTableModel()

 
     return (command ? true : false);
 }
 
 Qt::ItemFlags
-ModelDataTableModel::flags(const QModelIndex &index) const
+ModelDataTableModel::flags(const QModelIndex &) const
 {
     Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsEditable |
         Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | Qt::ItemIsSelectable;
     return flags;
 }

     } 
     return QVariant();
 }
 
 QModelIndex
-ModelDataTableModel::index(int row, int column, const QModelIndex &parent) const
+ModelDataTableModel::index(int row, int column, const QModelIndex &) const
 {
     return createIndex(row, column, (void *)0);
 }
 
 QModelIndex
-ModelDataTableModel::parent(const QModelIndex &index) const
+ModelDataTableModel::parent(const QModelIndex &) const
 {
     return QModelIndex();
 }
 
 int

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

     clearSort();
     emit layoutChanged();
 }
 
 void 
-ModelDataTableModel::modelChanged(size_t f0, size_t f1)
+ModelDataTableModel::modelChanged(int, int)
 {
     //!!! inefficient
     clearSort();
     emit layoutChanged();
 }

 
     if (m_sort.empty()) {
         resort();
     }
     int result = 0;
-    if (row >= 0 && row < m_sort.size()) {
+    if (row >= 0 && row < (int)m_sort.size()) {
         result = m_sort[row];
     }
     if (m_sortOrdering == Qt::DescendingOrder) {
         result = rowCount() - result - 1;
     }

     if (m_sort.empty()) {
         resort();
     }
 
     int result = 0;
-    if (row >= 0 && row < m_sort.size()) {
+    if (row >= 0 && row < (int)m_sort.size()) {
         if (m_sortOrdering == Qt::AscendingOrder) {
             result = m_rsort[row];
         } else {
             result = m_rsort[rowCount() - row - 1];
         }

 
     std::map<int, int> tmp;
 
     // rsort maps from sorted row number to original row number
 
-    for (int i = 0; i < m_rsort.size(); ++i) {
+    for (int i = 0; i < (int)m_rsort.size(); ++i) {
         tmp[m_rsort[i]] = i;
     }
 
     // tmp now maps from original row number to sorted row number