comparison framework/MainWindowBase.cpp @ 687:e0b0f3e163ca by-id

Update for removal of (public) getId from Model

         }
     }
     
     qRegisterMetaType<sv_frame_t>("sv_frame_t");
     qRegisterMetaType<sv_samplerate_t>("sv_samplerate_t");
+    qRegisterMetaType<ModelId>("ModelId");
 
 #ifdef Q_WS_X11
     XSetErrorHandler(handle_x11_error);
 #endif
 

              .toText(false).c_str());
 
     Layer *layer = pane->getSelectedLayer();
     if (!layer) return;
 
-    auto rm = ModelById::getAs<RegionModel>(layer->getModel());
+    ModelId modelId = layer->getModel();
+    
+    auto rm = ModelById::getAs<RegionModel>(modelId);
     if (rm) {
         Event point(alignedStart,
                     rm->getValueMaximum() + 1,
                     alignedDuration,
                     "");
         ChangeEventsCommand *command = new ChangeEventsCommand
-            (rm->getId().untyped, name);
+            (modelId.untyped, name);
         command->add(point);
         c = command->finish();
     }
 
     if (c) {
         CommandHistory::getInstance()->addCommand(c, false);
         return;
     }
 
-    auto nm = ModelById::getAs<NoteModel>(layer->getModel());
+    auto nm = ModelById::getAs<NoteModel>(modelId);
     if (nm) {
         Event point(alignedStart,
                     nm->getValueMinimum(),
                     alignedDuration,
                     1.f,
                     "");
         ChangeEventsCommand *command = new ChangeEventsCommand
-            (nm->getId().untyped, name);
+            (modelId.untyped, name);
         command->add(point);
         c = command->finish();
     }
 
     if (c) {

         } else { 
             return FileOpenFailed;
         }
     }
 
-    ModelById::add(newModel);
-
-    return addOpenedAudioModel(source, newModel->getId(),
-                               mode, templateName, true);
+    auto newModelId = ModelById::add(newModel);
+    return addOpenedAudioModel(source, newModelId, mode, templateName, true);
 }
 
 MainWindowBase::FileOpenStatus
 MainWindowBase::addOpenedAudioModel(FileSource source,
                                     ModelId newModel,

 
                 SVDEBUG << "MainWindowBase::openLayer: Have model" << endl;
 
                 emit activity(tr("Import MIDI file \"%1\"").arg(source.getLocation()));
 
-                ModelId modelId = newModelPtr->getId();
-                ModelById::add(std::shared_ptr<Model>(newModelPtr));
+                ModelId modelId = 
+                    ModelById::add(std::shared_ptr<Model>(newModelPtr));
                 
                 Layer *newLayer = m_document->createImportedLayer(modelId);
 
                 if (newLayer) {
 

                  .arg(source.getLocation()).arg(importer.getErrorString()));
         }
         return FileOpenFailed;
     }
 
-    std::vector<Model *> modelPtrs = importer.getDataModels(&dialog);
+    std::vector<ModelId> modelIds = importer.getDataModels(&dialog);
 
     dialog.setMessage(tr("Importing from RDF..."));
 
-    if (modelPtrs.empty()) {
+    if (modelIds.empty()) {
         QMessageBox::critical
             (this, tr("Failed to import RDF"),
              tr("<b>Failed to import RDF</b><p>No suitable data models found for import from RDF document at \"%1\"</p>").arg(source.getLocation()));
         return FileOpenFailed;
     }
 
     emit activity(tr("Import RDF document \"%1\"").arg(source.getLocation()));
-
-    std::set<ModelId> modelIds;
-
-    for (Model *modelPtr: modelPtrs) {
-        modelIds.insert(modelPtr->getId());
-        ModelById::add(std::shared_ptr<Model>(modelPtr));
-    }
     
     std::set<ModelId> added;
 
     for (auto modelId: modelIds) {
         

     connect(m_document, SIGNAL(layerInAView(Layer *, bool)),
             this, SLOT(layerInAView(Layer *, bool)));
 
     connect(m_document, SIGNAL(modelAdded(ModelId )),
             this, SLOT(modelAdded(ModelId )));
-    connect(m_document, SIGNAL(mainModelChanged(WaveFileModel *)),
-            this, SLOT(mainModelChanged(WaveFileModel *)));
-    connect(m_document, SIGNAL(modelAboutToBeDeleted(ModelId )),
-            this, SLOT(modelAboutToBeDeleted(ModelId )));
+    connect(m_document, SIGNAL(mainModelChanged(ModelId)),
+            this, SLOT(mainModelChanged(ModelId)));
 
     connect(m_document, SIGNAL(modelGenerationFailed(QString, QString)),
             this, SLOT(modelGenerationFailed(QString, QString)));
     connect(m_document, SIGNAL(modelRegenerationWarning(QString, QString, QString)),
             this, SLOT(modelRegenerationWarning(QString, QString, QString)));
-    connect(m_document, SIGNAL(alignmentComplete(AlignmentModel *)),
-            this, SLOT(alignmentComplete(AlignmentModel *)));
+    connect(m_document, SIGNAL(alignmentComplete(ModelId)),
+            this, SLOT(alignmentComplete(ModelId)));
     connect(m_document, SIGNAL(alignmentFailed(QString)),
             this, SLOT(alignmentFailed(QString)));
 
     m_document->setAutoAlignment(m_viewManager->getAlignMode());
 

 
     SVCERR << "MainWindowBase::record: Model is OK, continuing..." << endl;
 
     QString location = modelPtr->getLocation();
     
-    auto modelId = modelPtr->getId();
-    ModelById::add(std::shared_ptr<Model>(modelPtr));
+    auto modelId = ModelById::add(std::shared_ptr<Model>(modelPtr));
 
     if (m_audioRecordMode == RecordReplaceSession || !getMainModel()) {
 
         //!!! duplication with openAudio here