comparison framework/MainWindowBase.cpp @ 684:5e9b1956b609 by-id

ModelId updates

 #include <QDateTime>
 #include <QProcess>
 #include <QCheckBox>
 #include <QRegExp>
 #include <QScrollArea>
-#include <QDesktopWidget>
+#include <QScreen>
 #include <QSignalMapper>
 
 #include <iostream>
 #include <cstdio>
 #include <errno.h>

 }
 
 void
 MainWindowBase::resizeConstrained(QSize size)
 {
-    QDesktopWidget *desktop = QApplication::desktop();
-    QRect available = desktop->availableGeometry();
+    QScreen *screen = QApplication::primaryScreen();
+    QRect available = screen->availableGeometry();
     QSize actual(std::min(size.width(), available.width()),
                  std::min(size.height(), available.height()));
     resize(actual);
 }
 

 MainWindowBase::getOpenFileName(FileFinder::FileType type)
 {
     FileFinder *ff = FileFinder::getInstance();
 
     if (type == FileFinder::AnyFile) {
-        if (getMainModel() != nullptr &&
+        if (!getMainModelId().isNone() &&
             m_paneStack != nullptr &&
             m_paneStack->getCurrentPane() != nullptr) { // can import a layer
             return ff->getOpenFileName(FileFinder::AnyFile, m_sessionFile);
         } else {
             return ff->getOpenFileName(FileFinder::SessionOrAudioFile,

         (currentPane != nullptr);
     bool haveCurrentLayer =
         (haveCurrentPane &&
          (currentLayer != nullptr));
     bool haveMainModel =
-        (getMainModel() != nullptr);
+        (!getMainModelId().isNone());
     bool havePlayTarget =
         (m_playTarget != nullptr || m_audioIO != nullptr);
     bool haveSelection = 
         (m_viewManager &&
          !m_viewManager->getSelections().empty());

     bool haveClipboardContents =
         (m_viewManager &&
          !m_viewManager->getClipboard().empty());
     bool haveTabularLayer =
         (haveCurrentLayer &&
-         dynamic_cast<TabularModel *>(currentLayer->getModel()));
+         ModelById::isa<TabularModel>(currentLayer->getModel()));
 
     emit canAddPane(haveMainModel);
     emit canDeleteCurrentPane(haveCurrentPane);
     emit canZoom(haveMainModel && haveCurrentPane);
     emit canScroll(haveMainModel && haveCurrentPane);

     }
 
     if (m_viewManager->getPlaySoloMode()) {
         currentPaneChanged(m_paneStack->getCurrentPane());
     } else {
-        m_viewManager->setPlaybackModel(nullptr);
+        m_viewManager->setPlaybackModel({});
         if (m_playSource) {
             m_playSource->clearSoloModelSet();
         }
     }
 }

     if (!p) return;
 
     if (!(m_viewManager &&
           m_playSource &&
           m_viewManager->getPlaySoloMode())) {
-        if (m_viewManager) m_viewManager->setPlaybackModel(nullptr);
+        if (m_viewManager) {
+            m_viewManager->setPlaybackModel(ModelId());
+        }
         return;
     }
 
-    Model *prevPlaybackModel = m_viewManager->getPlaybackModel();
+    ModelId prevPlaybackModel = m_viewManager->getPlaybackModel();
 
     // What we want here is not the currently playing frame (unless we
     // are about to clear out the audio playback buffers -- which may
     // or may not be possible, depending on the audio driver).  What
     // we want is the frame that was last committed to the soundcard

     cerr << "currentPaneChanged: current frame (in ref model) = " << frame << endl;
 
     View::ModelSet soloModels = p->getModels();
     
     View::ModelSet sources;
-    for (View::ModelSet::iterator mi = soloModels.begin();
-         mi != soloModels.end(); ++mi) {
+    for (ModelId modelId: sources) {
         // If a model in this pane is derived from something else,
         // then we want to play that model as well -- if the model
         // that's derived from it is not something that is itself
         // individually playable (e.g. a waveform)
-        if (*mi &&
-            !dynamic_cast<RangeSummarisableTimeValueModel *>(*mi) &&
-            (*mi)->getSourceModel()) {
-            sources.insert((*mi)->getSourceModel());
-        }
-    }
-    for (View::ModelSet::iterator mi = sources.begin();
-         mi != sources.end(); ++mi) {
-        soloModels.insert(*mi);
+        if (auto model = ModelById::get(modelId)) {
+            if (!ModelById::isa<RangeSummarisableTimeValueModel>(modelId) &&
+                !model->getSourceModel().isNone()) {
+                sources.insert(model->getSourceModel());
+            }
+        }
+    }
+    for (ModelId modelId: sources) {
+        soloModels.insert(modelId);
     }
 
     //!!! Need an "atomic" way of telling the play source that the
     //playback model has changed, and changing it on ViewManager --
     //the play source should be making the setPlaybackModel call to
     //ViewManager
 
-    for (View::ModelSet::iterator mi = soloModels.begin();
-         mi != soloModels.end(); ++mi) {
-        if (dynamic_cast<RangeSummarisableTimeValueModel *>(*mi)) {
-            m_viewManager->setPlaybackModel(*mi);
-        }
-    }
-    
-    RangeSummarisableTimeValueModel *a = 
-        dynamic_cast<RangeSummarisableTimeValueModel *>(prevPlaybackModel);
-    RangeSummarisableTimeValueModel *b = 
-        dynamic_cast<RangeSummarisableTimeValueModel *>(m_viewManager->
-                                                        getPlaybackModel());
+    ModelId newPlaybackModel;
+    
+    for (ModelId modelId: soloModels) {
+        if (ModelById::isa<RangeSummarisableTimeValueModel>(modelId)) {
+            m_viewManager->setPlaybackModel(modelId);
+            newPlaybackModel = modelId;
+        }
+    }
 
     m_playSource->setSoloModelSet(soloModels);
 
-    if (a && b && (a != b)) {
-        if (m_playSource->isPlaying()) m_playSource->play(frame);
+    if (!prevPlaybackModel.isNone() && !newPlaybackModel.isNone() &&
+        prevPlaybackModel != newPlaybackModel) {
+        if (m_playSource->isPlaying()) {
+            m_playSource->play(frame);
+        }
     }
 }
 
 void
 MainWindowBase::currentLayerChanged(Pane *p, Layer *)

 }
 
 void
 MainWindowBase::selectAll()
 {
-    if (!getMainModel()) return;
     m_viewManager->setSelection(Selection(getModelsStartFrame(),
                                           getModelsEndFrame()));
 }
 
 void
 MainWindowBase::selectToStart()
 {
-    if (!getMainModel()) return;
-    m_viewManager->setSelection(Selection(getMainModel()->getStartFrame(),
+    m_viewManager->setSelection(Selection(getModelsStartFrame(),
                                           m_viewManager->getGlobalCentreFrame()));
 }
 
 void
 MainWindowBase::selectToEnd()
 {
-    if (!getMainModel()) return;
     m_viewManager->setSelection(Selection(m_viewManager->getGlobalCentreFrame(),
-                                          getMainModel()->getEndFrame()));
+                                          getModelsEndFrame()));
 }
 
 void
 MainWindowBase::selectVisible()
 {
-    Model *model = getMainModel();
+    auto model = getMainModel();
     if (!model) return;
 
     Pane *currentPane = m_paneStack->getCurrentPane();
     if (!currentPane) return;
 
     sv_frame_t startFrame, endFrame;
 
-    if (currentPane->getStartFrame() < 0) startFrame = 0;
-    else startFrame = currentPane->getStartFrame();
-
-    if (currentPane->getEndFrame() > model->getEndFrame()) endFrame = model->getEndFrame();
-    else endFrame = currentPane->getEndFrame();
+    if (currentPane->getStartFrame() < 0) {
+        startFrame = 0;
+    } else {
+        startFrame = currentPane->getStartFrame();
+    }
+
+    if (currentPane->getEndFrame() > model->getEndFrame()) {
+        endFrame = model->getEndFrame();
+    } else {
+        endFrame = currentPane->getEndFrame();
+    }
 
     m_viewManager->setSelection(Selection(startFrame, endFrame));
 }
 
 void

         }
     }
 
     if (layer) {
     
-        Model *model = layer->getModel();
-        SparseOneDimensionalModel *sodm =
-            dynamic_cast<SparseOneDimensionalModel *>(model);
+        ModelId model = layer->getModel();
+        auto sodm = ModelById::getAs<SparseOneDimensionalModel>(model);
 
         if (sodm) {
             Event point(frame, "");
             Event prevPoint(0);
             bool havePrevPoint = false;
 
             ChangeEventsCommand *command =
-                new ChangeEventsCommand(sodm, tr("Add Point"));
+                new ChangeEventsCommand(model.untyped, tr("Add Point"));
 
             if (m_labeller) {
 
                 if (m_labeller->requiresPrevPoint()) {
                     

                                   (frame,
                                    sodm->getSampleRate())
                                   .toText(false).c_str()));
 
             Command *c = command->finish();
-            if (c) CommandHistory::getInstance()->addCommand(c, false);
+            if (c) {
+                CommandHistory::getInstance()->addCommand(c, false);
+            }
         }
     }
 }
 
 void

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

     Layer *layer = dynamic_cast<TimeInstantLayer *>(pane->getSelectedLayer());
     if (!layer) return;
 
     MultiSelection ms(m_viewManager->getSelection());
     
-    Model *model = layer->getModel();
-    SparseOneDimensionalModel *sodm = dynamic_cast<SparseOneDimensionalModel *>
-        (model);
+    auto sodm = ModelById::getAs<SparseOneDimensionalModel>(layer->getModel());
     if (!sodm) return;
 
     if (!m_labeller) return;
 
     Labeller labeller(*m_labeller);
     labeller.setSampleRate(sodm->getSampleRate());
-/*!!! to be updated after SODM API update
-    Command *c = labeller.labelAll<SparseOneDimensionalModel::Point>(*sodm, &ms);
+
+    /*!!!
+    Command *c = labeller.labelAll(sodm->getId().untyped, &ms);
     if (c) CommandHistory::getInstance()->addCommand(c, false);
 */
 }
 
 void

     Layer *layer = dynamic_cast<TimeInstantLayer *>(pane->getSelectedLayer());
     if (!layer) return;
 
     MultiSelection ms(m_viewManager->getSelection());
     
-    Model *model = layer->getModel();
-    SparseOneDimensionalModel *sodm =
-        dynamic_cast<SparseOneDimensionalModel *>(model);
+    auto sodm = ModelById::getAs<SparseOneDimensionalModel>(layer->getModel());
     if (!sodm) return;
 
     if (!m_labeller) return;
 
     Labeller labeller(*m_labeller);
     labeller.setSampleRate(sodm->getSampleRate());
 
     (void)n;
-/*!!! to be updated after SODM API update
-    Command *c = labeller.subdivide<SparseOneDimensionalModel::Point>
-        (*sodm, &ms, n);
+    /*!!!
+    Command *c = labeller.subdivide(sodm->getId().untyped, &ms, n);
     if (c) CommandHistory::getInstance()->addCommand(c, false);
-*/
+    */
 }
 
 void
 MainWindowBase::winnowInstantsBy(int n)
 {

     Layer *layer = dynamic_cast<TimeInstantLayer *>(pane->getSelectedLayer());
     if (!layer) return;
 
     MultiSelection ms(m_viewManager->getSelection());
     
-    Model *model = layer->getModel();
-    SparseOneDimensionalModel *sodm =
-        dynamic_cast<SparseOneDimensionalModel *>(model);
+    auto sodm = ModelById::getAs<SparseOneDimensionalModel>(layer->getModel());
     if (!sodm) return;
 
     if (!m_labeller) return;
 
     Labeller labeller(*m_labeller);
     labeller.setSampleRate(sodm->getSampleRate());
 
     (void)n;
-/*!!! to be updated after SODM API update
-    Command *c = labeller.winnow<SparseOneDimensionalModel::Point>
-        (*sodm, &ms, n);
+    //!!! to update: (and the above two functions)
+    /*
+    Command *c = labeller.winnow(sodm->getId.untyped, &ms, n);
     if (c) CommandHistory::getInstance()->addCommand(c, false);
-*/
+    */
 }
 
 MainWindowBase::FileOpenStatus
 MainWindowBase::openPath(QString fileOrUrl, AudioFileOpenMode mode)
 {

 
     if (rate == 0) {
         SVDEBUG << "Yes, preserving incoming file rate" << endl;
     }
     
-    ReadOnlyWaveFileModel *newModel = new ReadOnlyWaveFileModel(source, rate);
-
+    auto newModel = std::make_shared<ReadOnlyWaveFileModel>(source, rate);
     if (!newModel->isOK()) {
-        delete newModel;
         m_openingAudioFile = false;
         if (source.wasCancelled()) {
             return FileOpenCancelled;
         } else { 
             return FileOpenFailed;
         }
     }
 
-    return addOpenedAudioModel(source, newModel, mode, templateName, true);
+    ModelById::add(newModel);
+
+    return addOpenedAudioModel(source, newModel->getId(),
+                               mode, templateName, true);
 }
 
 MainWindowBase::FileOpenStatus
 MainWindowBase::addOpenedAudioModel(FileSource source,
-                                    WaveFileModel *newModel,
+                                    ModelId newModel,
                                     AudioFileOpenMode mode,
                                     QString templateName,
                                     bool registerSource)
 {
     if (mode == AskUser) {

                 (this, tr("Select target for import"),
                  tr("<b>Select a target for import</b><p>You already have an audio file loaded.<br>What would you like to do with the new audio file?"),
                  items, lastMode, &ok);
             
             if (!ok || item.isEmpty()) {
-                delete newModel;
+                ModelById::release(newModel);
                 m_openingAudioFile = false;
                 return FileOpenCancelled;
             }
             
             for (int i = 0; i < items.size(); ++i) {

 
         Pane *pane = m_paneStack->getCurrentPane();
         if (pane) {
             if (getMainModel()) {
                 View::ModelSet models(pane->getModels());
-                if (models.find(getMainModel()) != models.end()) {
+                if (models.find(getMainModelId()) != models.end()) {
                     // Current pane contains main model: replace that
                     mode = ReplaceMainModel;
                 }
                 // Otherwise the current pane has a non-default model,
                 // which we will deal with later

             // We seem to have no current pane!  Oh well
             mode = CreateAdditionalModel;
         }
     }
 
-    if (mode == CreateAdditionalModel && !getMainModel()) {
+    if (mode == CreateAdditionalModel && getMainModelId().isNone()) {
         SVDEBUG << "Mode is CreateAdditionalModel but we have no main model, switching to ReplaceSession mode" << endl;
         mode = ReplaceSession;
     }
 
     bool loadedTemplate = false;

 
     emit activity(tr("Import audio file \"%1\"").arg(source.getLocation()));
     
     if (mode == ReplaceMainModel) {
 
-        Model *prevMain = getMainModel();
-        if (prevMain) {
+        ModelId prevMain = getMainModelId();
+        if (!prevMain.isNone()) {
             m_playSource->removeModel(prevMain);
-            PlayParameterRepository::getInstance()->removePlayable(prevMain);
-        }
-        PlayParameterRepository::getInstance()->addPlayable(newModel);
+            //!!! shouldn't this stuff be handled by Document?
+            PlayParameterRepository::getInstance()->removePlayable
+                (prevMain.untyped);
+        }
+        PlayParameterRepository::getInstance()->addPlayable(newModel.untyped);
 
         SVDEBUG << "SV about to call setMainModel(" << newModel << "): prevMain is " << prevMain << endl;
 
         m_document->setMainModel(newModel);
 

         
         try {
 
             MIDIFileImportDialog midiDlg(this);
 
-            Model *model = DataFileReaderFactory::loadNonCSV
+            Model *newModelPtr = DataFileReaderFactory::loadNonCSV
                 (path, &midiDlg, getMainModel()->getSampleRate());
         
-            if (!model) {
+            if (!newModelPtr) {
                 CSVFormatDialog *dialog =
                     new CSVFormatDialog(this,
                                         path,
                                         getMainModel()->getSampleRate(),
                                         5);
                 if (dialog->exec() == QDialog::Accepted) {
-                    model = DataFileReaderFactory::loadCSV
+                    newModelPtr = DataFileReaderFactory::loadCSV
                         (path, dialog->getFormat(),
                          getMainModel()->getSampleRate());
                 }
                 delete dialog;
             }
 
-            if (model) {
+            if (newModelPtr) {
 
                 SVDEBUG << "MainWindowBase::openLayer: Have model" << endl;
 
                 emit activity(tr("Import MIDI file \"%1\"").arg(source.getLocation()));
 
-                Layer *newLayer = m_document->createImportedLayer(model);
+                ModelId modelId = newModelPtr->getId();
+                ModelById::add(std::shared_ptr<Model>(newModelPtr));
+                
+                Layer *newLayer = m_document->createImportedLayer(modelId);
 
                 if (newLayer) {
 
                     m_document->addLayerToView(pane, newLayer);
                     m_paneStack->setCurrentLayer(pane, newLayer);

         // shouldn't happen, as the menu action should have been disabled
         cerr << "WARNING: MainWindowBase::openImage: no current pane" << endl;
         return FileOpenWrongMode;
     }
 
-    if (!m_document->getMainModel()) {
+    if (!getMainModel()) {
         return FileOpenWrongMode;
     }
 
     bool newLayer = false;
 

                  .arg(source.getLocation()).arg(importer.getErrorString()));
         }
         return FileOpenFailed;
     }
 
-    std::vector<Model *> models = importer.getDataModels(&dialog);
+    std::vector<Model *> modelPtrs = importer.getDataModels(&dialog);
 
     dialog.setMessage(tr("Importing from RDF..."));
 
-    if (models.empty()) {
+    if (modelPtrs.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<Model *> added;
-
-    for (int i = 0; i < (int)models.size(); ++i) {
-
-        Model *m = models[i];
-        WaveFileModel *w = dynamic_cast<WaveFileModel *>(m);
-
-        if (w) {
+    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) {
+        
+        if (ModelById::isa<WaveFileModel>(modelId)) {
 
             Pane *pane = addPaneToStack();
             Layer *layer = nullptr;
 
             if (m_timeRulerLayer) {
                 m_document->addLayerToView(pane, m_timeRulerLayer);
             }
 
             if (!getMainModel()) {
-                m_document->setMainModel(w);
+                m_document->setMainModel(modelId);
                 layer = m_document->createMainModelLayer(LayerFactory::Waveform);
             } else {
-                layer = m_document->createImportedLayer(w);
+                layer = m_document->createImportedLayer(modelId);
             }
 
             m_document->addLayerToView(pane, layer);
 
-            added.insert(w);
-            
-            for (int j = 0; j < (int)models.size(); ++j) {
-
-                Model *dm = models[j];
-
-                if (dm == m) continue;
-                if (dm->getSourceModel() != m) continue;
-
-                layer = m_document->createImportedLayer(dm);
+            added.insert(modelId);
+
+            for (auto otherId: modelIds) {
+
+                if (otherId == modelId) continue;
+
+                bool isDependent = false;
+                if (auto dm = ModelById::get(otherId)) {
+                    if (dm->getSourceModel() == modelId) {
+                        isDependent = true;
+                    }
+                }
+                if (!isDependent) continue;
+
+                layer = m_document->createImportedLayer(otherId);
 
                 if (layer->isLayerOpaque() ||
                     dynamic_cast<Colour3DPlotLayer *>(layer)) {
 
                     // these always go in a new pane, with nothing

                     }
 
                     m_document->addLayerToView(pane, layer);
                 }
 
-                added.insert(dm);
+                added.insert(otherId);
             }
         }
     }
 
-    for (int i = 0; i < (int)models.size(); ++i) {
-
-        Model *m = models[i];
-
-        if (added.find(m) == added.end()) {
+    for (auto modelId : modelIds) {
+        
+        if (added.find(modelId) == added.end()) {
             
-            Layer *layer = m_document->createImportedLayer(m);
+            Layer *layer = m_document->createImportedLayer(modelId);
             if (!layer) return FileOpenFailed;
 
             Pane *singleLayerPane = addPaneToStack();
             if (m_timeRulerLayer) {
                 m_document->addLayerToView(singleLayerPane, m_timeRulerLayer);

         SVCERR << "MainWindowBase::audioChannelCountIncreased: we were recording already, so resuming IO now" << endl;
         m_audioIO->resume();
     }
 }
 
-WaveFileModel *
+ModelId
+MainWindowBase::getMainModelId()
+{
+    if (!m_document) return {};
+    return m_document->getMainModel();
+}
+
+std::shared_ptr<WaveFileModel>
 MainWindowBase::getMainModel()
 {
-    if (!m_document) return nullptr;
-    return m_document->getMainModel();
-}
-
-const WaveFileModel *
-MainWindowBase::getMainModel() const
-{
-    if (!m_document) return nullptr;
-    return m_document->getMainModel();
+    return ModelById::getAs<WaveFileModel>(getMainModelId());
 }
 
 void
 MainWindowBase::createDocument()
 {

     connect(m_document, SIGNAL(layerAboutToBeDeleted(Layer *)),
             this, SLOT(layerAboutToBeDeleted(Layer *)));
     connect(m_document, SIGNAL(layerInAView(Layer *, bool)),
             this, SLOT(layerInAView(Layer *, bool)));
 
-    connect(m_document, SIGNAL(modelAdded(Model *)),
-            this, SLOT(modelAdded(Model *)));
+    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(Model *)),
-            this, SLOT(modelAboutToBeDeleted(Model *)));
+    connect(m_document, SIGNAL(modelAboutToBeDeleted(ModelId )),
+            this, SLOT(modelAboutToBeDeleted(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)));

 {
     if (QFileInfo(path).suffix() == "") path += ".svl";
 
     QString suffix = QFileInfo(path).suffix().toLower();
 
-    Model *model = layer->getModel();
+    auto model = ModelById::get(layer->getModel());
+    if (!model) {
+        error = tr("Internal error: unknown model");
+        return false;
+    }
 
     if (suffix == "xml" || suffix == "svl") {
 
         QFile file(path);
         if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {

                 << "</sv>\n";
         }
 
     } else if (suffix == "mid" || suffix == "midi") {
 
-        NoteModel *nm = dynamic_cast<NoteModel *>(model);
+        auto nm = ModelById::getAs<NoteModel>(layer->getModel());
 
         if (!nm) {
             error = tr("Can't export non-note layers to MIDI");
         } else {
-            MIDIFileWriter writer(path, nm, nm->getSampleRate());
+            MIDIFileWriter writer(path, nm.get(), nm->getSampleRate());
             writer.write();
             if (!writer.isOK()) {
                 error = writer.getError();
             }
         }
 
     } else if (suffix == "ttl" || suffix == "n3") {
 
-        if (!RDFExporter::canExportModel(model)) {
+        if (!RDFExporter::canExportModel(model.get())) {
             error = tr("Sorry, cannot export this layer type to RDF (supported types are: region, note, text, time instants, time values)");
         } else {
-            RDFExporter exporter(path, model);
+            RDFExporter exporter(path, model.get());
             exporter.write();
             if (!exporter.isOK()) {
                 error = exporter.getError();
             }
         }
 
     } else {
 
-        CSVFileWriter writer(path, model,
+        CSVFileWriter writer(path, model.get(),
                              ((suffix == "csv") ? "," : "\t"));
         writer.write();
 
         if (!writer.isOK()) {
             error = writer.getError();

 MainWindowBase::zoomToFit()
 {
     Pane *currentPane = m_paneStack->getCurrentPane();
     if (!currentPane) return;
 
-    Model *model = getMainModel();
+    auto model = getMainModel();
     if (!model) return;
     
     sv_frame_t start = model->getStartFrame();
     sv_frame_t end = model->getEndFrame();
     if (m_playSource) end = std::max(end, m_playSource->getPlayEndFrame());

     if (m_viewManager) m_viewManager->setGlobalCentreFrame(0);
     
     SVCERR << "MainWindowBase::record: about to resume" << endl;
     m_audioIO->resume();
 
-    WritableWaveFileModel *model = m_recordTarget->startRecording();
-    if (!model) {
+    WritableWaveFileModel *modelPtr = m_recordTarget->startRecording();
+    if (!modelPtr) {
         SVCERR << "ERROR: MainWindowBase::record: Recording failed" << endl;
         QMessageBox::critical
             (this, tr("Recording failed"),
              tr("<b>Recording failed</b><p>Failed to switch to record mode (some internal problem?)</p>"));
         if (action) action->setChecked(false);
         return;
     }
 
-    if (!model->isOK()) {
+    if (!modelPtr->isOK()) {
         SVCERR << "MainWindowBase::record: Model not OK, stopping and suspending" << endl;
         m_recordTarget->stopRecording();
         m_audioIO->suspend();
         if (action) action->setChecked(false);
-        delete model;
+        delete modelPtr;
         return;
     }
 
     SVCERR << "MainWindowBase::record: Model is OK, continuing..." << endl;
-    
-    PlayParameterRepository::getInstance()->addPlayable(model);
+
+    QString location = modelPtr->getLocation();
+    
+    auto modelId = modelPtr->getId();
+    ModelById::add(std::shared_ptr<Model>(modelPtr));
+    PlayParameterRepository::getInstance()->addPlayable(modelId.untyped);
 
     if (m_audioRecordMode == RecordReplaceSession || !getMainModel()) {
 
         //!!! duplication with openAudio here
         

             FileOpenStatus tplStatus = openSessionTemplate(templateName);
             if (tplStatus == FileOpenCancelled) {
                 SVCERR << "MainWindowBase::record: Session template open cancelled, stopping and suspending" << endl;
                 m_recordTarget->stopRecording();
                 m_audioIO->suspend();
-                PlayParameterRepository::getInstance()->removePlayable(model);
+                PlayParameterRepository::getInstance()->removePlayable
+                    (modelId.untyped);
+                ModelById::release(modelId);
                 return;
             }
             if (tplStatus != FileOpenFailed) {
                 loadedTemplate = true;
             }

         if (!loadedTemplate) {
             closeSession();
             createDocument();
         }
         
-        Model *prevMain = getMainModel();
-        if (prevMain) {
+        ModelId prevMain = getMainModelId();
+        if (!prevMain.isNone()) {
             m_playSource->removeModel(prevMain);
-            PlayParameterRepository::getInstance()->removePlayable(prevMain);
+            PlayParameterRepository::getInstance()->removePlayable
+                (prevMain.untyped);
         }
         
-        m_document->setMainModel(model);
+        m_document->setMainModel(modelId);
         setupMenus();
         findTimeRulerLayer();
 
-        m_originalLocation = model->getLocation();
+        m_originalLocation = location;
         
         if (loadedTemplate || (m_sessionFile == "")) {
             CommandHistory::getInstance()->clear();
             CommandHistory::getInstance()->documentSaved();
         }

     } else {
 
         CommandHistory::getInstance()->startCompoundOperation
             (tr("Import Recorded Audio"), true);
 
-        m_document->addImportedModel(model);
+        m_document->addImportedModel(modelId);
 
         AddPaneCommand *command = new AddPaneCommand(this);
         CommandHistory::getInstance()->addCommand(command);
 
         Pane *pane = command->getPane();
 
         if (m_timeRulerLayer) {
             m_document->addLayerToView(pane, m_timeRulerLayer);
         }
 
-        Layer *newLayer = m_document->createImportedLayer(model);
+        Layer *newLayer = m_document->createImportedLayer(modelId);
 
         if (newLayer) {
             m_document->addLayerToView(pane, newLayer);
         }
         
         CommandHistory::getInstance()->endCompoundOperation();
     }
 
     updateMenuStates();
-    m_recentFiles.addFile(model->getLocation());
+    m_recentFiles.addFile(location);
     currentPaneChanged(m_paneStack->getCurrentPane());
     
     emit audioFileLoaded();
 }
 

     Layer *layer = nullptr;
     Pane *pane = m_paneStack->getCurrentPane();
     if (pane) layer = pane->getSelectedLayer();
     if (!layer) return;
 
-    Model *model = layer->getModel();
-    if (!model) return;
-
-    TabularModel *tabular = dynamic_cast<TabularModel *>(model);
+    auto tabular = ModelById::getAs<TabularModel>(layer->getModel());
     if (!tabular) {
         //!!! how to prevent this function from being active if not
         //appropriate model type?  or will we ultimately support
         //tabular display for all editable models?
         SVDEBUG << "NOTE: Not a tabular model" << endl;

         }
     }
 
     QString title = layer->getLayerPresentationName();
 
-    ModelDataTableDialog *dialog = new ModelDataTableDialog(tabular, title, this);
+    ModelDataTableDialog *dialog = new ModelDataTableDialog
+        (layer->getModel(), title, this);
     dialog->setAttribute(Qt::WA_DeleteOnClose);
     
     connectLayerEditDialog(dialog);
 
     m_layerDataDialogMap[layer] = dialog;

 //    SVDEBUG << "MainWindowBase::layerInAView(" << layer << "," << inAView << ")" << endl;
 
     if (!inAView) removeLayerEditDialog(layer);
 
     // Check whether we need to add or remove model from play source
-    Model *model = layer->getModel();
-    if (model) {
+    ModelId modelId = layer->getModel();
+    if (!modelId.isNone()) {
         if (inAView) {
-            m_playSource->addModel(model);
+            m_playSource->addModel(modelId);
         } else {
             bool found = false;
             for (int i = 0; i < m_paneStack->getPaneCount(); ++i) {
                 Pane *pane = m_paneStack->getPane(i);
                 if (!pane) continue;
                 for (int j = 0; j < pane->getLayerCount(); ++j) {
                     Layer *pl = pane->getLayer(j);
                     if (pl &&
                         !dynamic_cast<TimeRulerLayer *>(pl) &&
-                        (pl->getModel() == model)) {
+                        (pl->getModel() == modelId)) {
                         found = true;
                         break;
                     }
                 }
                 if (found) break;
             }
             if (!found) {
-                m_playSource->removeModel(model);
+                m_playSource->removeModel(modelId);
             }
         }
     }
 
     updateMenuStates();

         delete dialog;
     }
 }
 
 void
-MainWindowBase::modelAdded(Model *model)
+MainWindowBase::modelAdded(ModelId model)
 {
 //    SVDEBUG << "MainWindowBase::modelAdded(" << model << ")" << endl;
-        std::cerr << "\nAdding model " << model->getTypeName() << " to playsource " << std::endl;
+    std::cerr << "\nAdding model " << model << " to playsource " << std::endl;
     m_playSource->addModel(model);
 }
 
 void
-MainWindowBase::mainModelChanged(WaveFileModel *model)
+MainWindowBase::mainModelChanged(ModelId modelId)
 {
 //    SVDEBUG << "MainWindowBase::mainModelChanged(" << model << ")" << endl;
     updateDescriptionLabel();
+    auto model = ModelById::getAs<WaveFileModel>(modelId);
     if (model) m_viewManager->setMainModelSampleRate(model->getSampleRate());
     if (model && !(m_playTarget || m_audioIO) &&
         (m_soundOptions & WithAudioOutput)) {
         createAudioIO();
     }
 }
 
 void
-MainWindowBase::modelAboutToBeDeleted(Model *model)
-{
-//    SVDEBUG << "MainWindowBase::modelAboutToBeDeleted(" << model << ")" << endl;
+MainWindowBase::modelAboutToBeDeleted(ModelId model)
+{
     if (model == m_viewManager->getPlaybackModel()) {
-        m_viewManager->setPlaybackModel(nullptr);
+        m_viewManager->setPlaybackModel({});
     }
     m_playSource->removeModel(model);
 }
 
 void

 
     updateMenuStates();
 }
 
 void
-MainWindowBase::alignmentComplete(AlignmentModel *model)
-{
-    cerr << "MainWindowBase::alignmentComplete(" << model << ")" << endl;
+MainWindowBase::alignmentComplete(ModelId alignmentModelId)
+{
+    cerr << "MainWindowBase::alignmentComplete(" << alignmentModelId << ")" << endl;
 }
 
 void
 MainWindowBase::pollOSC()
 {