comparison widgets/LayerTree.cpp @ 392:1d85aa5a49be

* Start adding a spreadsheet-style editor window for model data

 
 #include <QIcon>
 #include <iostream>
 
 
-ModelDataModel::ModelDataModel(PaneStack *stack, bool waveModelsOnly,
+ModelMetadataModel::ModelMetadataModel(PaneStack *stack, bool waveModelsOnly,
                                QObject *parent) :
     QAbstractItemModel(parent),
     m_stack(stack),
     m_waveModelsOnly(waveModelsOnly)
 {

     }
 
     rebuildModelSet();
 }
 
-ModelDataModel::~ModelDataModel()
-{
-}
-
-void
-ModelDataModel::rebuildModelSet()
+ModelMetadataModel::~ModelMetadataModel()
+{
+}
+
+void
+ModelMetadataModel::rebuildModelSet()
 {
     std::set<Model *> unfound = m_models;
 
     for (int i = 0; i < m_stack->getPaneCount(); ++i) {
 

     for (std::set<Model *>::iterator i = unfound.begin();
          i != unfound.end(); ++i) {
         m_models.erase(*i);
     }
 
-    std::cerr << "ModelDataModel::rebuildModelSet: " << m_models.size() << " models" << std::endl;
-}
-
-void
-ModelDataModel::paneAdded()
+    std::cerr << "ModelMetadataModel::rebuildModelSet: " << m_models.size() << " models" << std::endl;
+}
+
+void
+ModelMetadataModel::paneAdded()
 {
     rebuildModelSet();
     emit layoutChanged();
 }
 
 void
-ModelDataModel::paneDeleted()
+ModelMetadataModel::paneDeleted()
 {
     rebuildModelSet();
     emit layoutChanged();
 }
 
 void
-ModelDataModel::paneLayerModelChanged()
+ModelMetadataModel::paneLayerModelChanged()
 {
     rebuildModelSet();
     emit layoutChanged();
 }
 
 void
-ModelDataModel::propertyContainerAdded(PropertyContainer *)
+ModelMetadataModel::propertyContainerAdded(PropertyContainer *)
 {
     rebuildModelSet();
     emit layoutChanged();
 }
 
 void
-ModelDataModel::propertyContainerRemoved(PropertyContainer *)
+ModelMetadataModel::propertyContainerRemoved(PropertyContainer *)
 {
     rebuildModelSet();
     emit layoutChanged();
 }
 
 void
-ModelDataModel::propertyContainerSelected(PropertyContainer *)
-{
-}
-
-void
-ModelDataModel::propertyContainerPropertyChanged(PropertyContainer *pc)
-{
-}
-
-void
-ModelDataModel::playParametersAudibilityChanged(bool a)
+ModelMetadataModel::propertyContainerSelected(PropertyContainer *)
+{
+}
+
+void
+ModelMetadataModel::propertyContainerPropertyChanged(PropertyContainer *pc)
+{
+}
+
+void
+ModelMetadataModel::playParametersAudibilityChanged(bool a)
 {
 }
 
 QVariant
-ModelDataModel::data(const QModelIndex &index, int role) const
+ModelMetadataModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) return QVariant();
 
     QObject *obj = static_cast<QObject *>(index.internalPointer());
     int row = index.row(), col = index.column();

     
     return QVariant();
 }
 
 bool
-ModelDataModel::setData(const QModelIndex &index, const QVariant &value, int role)
+ModelMetadataModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     return false;
 }
 
 Qt::ItemFlags
-ModelDataModel::flags(const QModelIndex &index) const
+ModelMetadataModel::flags(const QModelIndex &index) const
 {
     Qt::ItemFlags flags = Qt::ItemIsEnabled;
     return flags;
 }
 
 QVariant
-ModelDataModel::headerData(int section,
+ModelMetadataModel::headerData(int section,
 			   Qt::Orientation orientation,
 			   int role) const
 {
     if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
 	if (section == m_modelTypeColumn) return QVariant(tr("Type"));

 
     return QVariant();
 }
 
 QModelIndex
-ModelDataModel::index(int row, int column, const QModelIndex &parent) const
+ModelMetadataModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         if (row >= m_models.size()) return QModelIndex();
 	return createIndex(row, column, 0);
     }
 
     return QModelIndex();
 }
 
 QModelIndex
-ModelDataModel::parent(const QModelIndex &index) const
+ModelMetadataModel::parent(const QModelIndex &index) const
 {
     return QModelIndex();
 }
 
 int
-ModelDataModel::rowCount(const QModelIndex &parent) const
+ModelMetadataModel::rowCount(const QModelIndex &parent) const
 {
     if (!parent.isValid()) return m_models.size();
     return 0;
 }
 
 int
-ModelDataModel::columnCount(const QModelIndex &parent) const
+ModelMetadataModel::columnCount(const QModelIndex &parent) const
 {
     return m_columnCount;
 }