comparison framework/MainWindowBase.cpp @ 236:dd14baa45847

Merge from branch "templating"

 #include "base/XmlExportable.h"
 #include "base/Profiler.h"
 #include "base/Preferences.h"
 #include "base/TempWriteFile.h"
 #include "base/Exceptions.h"
+#include "base/ResourceFinder.h"
 
 #include "data/osc/OSCQueue.h"
 #include "data/midi/MIDIInput.h"
 
 #include <QApplication>

             this,
             SLOT(preferenceChanged(PropertyContainer::PropertyName)));
 
     Labeller::ValueType labellerType = Labeller::ValueFromTwoLevelCounter;
     settings.beginGroup("MainWindow");
+
     labellerType = (Labeller::ValueType)
         settings.value("labellertype", (int)labellerType).toInt();
     int cycle = settings.value("labellercycle", 4).toInt();
+
     settings.endGroup();
 
     m_labeller = new Labeller(labellerType);
     m_labeller->setCounterCycleSize(cycle);
 

 void
 MainWindowBase::registerLastOpenedFilePath(FileFinder::FileType type, QString path)
 {
     FileFinder *ff = FileFinder::getInstance();
     ff->registerLastOpenedFilePath(type, path);
+}
+
+QString
+MainWindowBase::getDefaultSessionTemplate() const
+{
+    QSettings settings;
+    settings.beginGroup("MainWindow");
+    QString templateName = settings.value("sessiontemplate", "").toString();
+    if (templateName == "") templateName = "default";
+    return templateName;
 }
 
 void
 MainWindowBase::updateMenuStates()
 {

     Clipboard &clipboard = m_viewManager->getClipboard();
     if (!clipboard.empty()) {
         long firstEventFrame = clipboard.getPoints()[0].getFrame();
         long offset = 0;
         if (firstEventFrame < 0) {
-            offset = long(pos) - firstEventFrame;
+            offset = (long)pos - firstEventFrame;
         } else if (firstEventFrame < pos) {
-            offset = pos - firstEventFrame;
+            offset = pos - (unsigned long)firstEventFrame;
         } else {
-            offset = -(firstEventFrame - pos);
+            offset = -((unsigned long)firstEventFrame - pos);
         }
         pasteRelative(offset);
     }
 }
 

 	return FileOpenFailed;
     }
 }
 
 MainWindowBase::FileOpenStatus
-MainWindowBase::openAudio(FileSource source, AudioFileOpenMode mode, QString templateName)
+MainWindowBase::openAudio(FileSource source, AudioFileOpenMode mode,
+                          QString templateName)
 {
 //    SVDEBUG << "MainWindowBase::openAudio(" << source.getLocation() << ")" << endl;
+
+    if (templateName == "") {
+        templateName = getDefaultSessionTemplate();
+    }
+
+    std::cerr << "template is: \"" << templateName.toStdString() << "\"" << std::endl;
 
     if (!source.isAvailable()) return FileOpenFailed;
     source.waitForData();
 
     m_openingAudioFile = true;

     if (mode == AskUser) {
         if (getMainModel()) {
 
             QSettings settings;
             settings.beginGroup("MainWindow");
-            bool prevSetAsMain = settings.value("newsessionforaudio", true).toBool();
+            int lastMode = settings.value("lastaudioopenmode", 0).toBool();
             settings.endGroup();
-            bool setAsMain = true;
+            int imode = 0;
             
             QStringList items;
-            items << tr("Replace the existing main waveform")
-                  << tr("Load this file into a new waveform pane");
+            items << tr("Close the current session and start a new one")
+                  << tr("Replace the main audio file in this session")
+                  << tr("Add the audio file to this session");
 
             bool ok = false;
             QString item = ListInputDialog::getItem
                 (this, tr("Select target for import"),
-                 tr("<b>Select a target for import</b><p>You already have an audio waveform loaded.<br>What would you like to do with the new audio file?"),
-                 items, prevSetAsMain ? 0 : 1, &ok);
+                 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;
                 m_openingAudioFile = false;
                 return FileOpenCancelled;
             }
             
-            setAsMain = (item == items[0]);
+            for (int i = 0; i < items.size(); ++i) {
+                if (item == items[i]) imode = i;
+            }
+
             settings.beginGroup("MainWindow");
-            settings.setValue("newsessionforaudio", setAsMain);
+            settings.setValue("lastaudioopenmode", imode);
             settings.endGroup();
 
-            if (setAsMain) mode = ReplaceMainModel;
-            else mode = CreateAdditionalModel;
+            mode = (AudioFileOpenMode)imode;
 
         } else {
-            mode = ReplaceMainModel;
+            // no main model: make a new session
+            mode = ReplaceSession;
         }
     }
 
     if (mode == ReplaceCurrentPane) {
 
         Pane *pane = m_paneStack->getCurrentPane();
         if (pane) {
             if (getMainModel()) {
                 View::ModelSet models(pane->getModels());
                 if (models.find(getMainModel()) != 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
             } else {
-                mode = ReplaceMainModel;
+                // We have no main model, so start a new session with
+                // optional template
+                mode = ReplaceSession;
             }
         } else {
+            // We seem to have no current pane!  Oh well
             mode = CreateAdditionalModel;
         }
     }
 
     if (mode == CreateAdditionalModel && !getMainModel()) {
+        mode = ReplaceSession;
+    }
+
+    bool loadedTemplate = false;
+
+    if (mode == ReplaceSession) {
+        std::cerr << "SV looking for template " << tplPath << std::endl;
+        if (templateName != "") {
+            FileOpenStatus tplStatus = openSessionTemplate(templateName);
+            if (tplStatus != FileOpenFailed) {
+                std::cerr << "Template load succeeded" << std::endl;
+                loadedTemplate = true;
+            }
+        }
+
+        if (!loadedTemplate) {
+            closeSession();
+            createDocument();
+        }
+
         mode = ReplaceMainModel;
-    }
-
-    bool loadedTemplate = false;
-    if ((mode == ReplaceMainModel) && (templateName.length() != 0)) {
-        QString tplPath = "file::templates/" + templateName + ".xml";
-        std::cerr << "SV looking for template " << tplPath << std::endl;
-        FileOpenStatus tplStatus = openSessionFile(tplPath);
-        if(tplStatus != FileOpenFailed) {
-            loadedTemplate = true;
-            mode = ReplaceMainModel;
-        }
     }
 
     emit activity(tr("Import audio file \"%1\"").arg(source.getLocation()));
 
     if (mode == ReplaceMainModel) {

         m_recentFiles.addFile(source.getLocation());
 
         if (!source.isRemote()) {
             // for file dialog
             registerLastOpenedFilePath(FileFinder::SessionFile,
-                                        source.getLocalFilename());
+                                       source.getLocalFilename());
         }
 
     } else {
 	setWindowTitle(QApplication::applicationName());
+    }
+
+    return ok ? FileOpenSucceeded : FileOpenFailed;
+}
+
+MainWindowBase::FileOpenStatus
+MainWindowBase::openSessionTemplate(QString templateName)
+{
+    // Template in the user's template directory takes
+    // priority over a bundled one; we don't unbundle, but
+    // open directly from the bundled file (where applicable)
+    ResourceFinder rf;
+    QString tfile = rf.getResourcePath("templates", templateName + ".svt");
+    if (tfile != "") {
+        std::cerr << "SV loading template file " << tfile.toStdString() << std::endl;
+        return openSessionTemplate(FileSource("file:" + tfile));
+    } else {
+        return FileOpenFailed;
+    }
+}
+
+MainWindowBase::FileOpenStatus
+MainWindowBase::openSessionTemplate(FileSource source)
+{
+    std::cerr << "MainWindowBase::openSessionTemplate(" << source.getLocation().toStdString() << ")" << std::endl;
+
+    if (!source.isAvailable()) return FileOpenFailed;
+    source.waitForData();
+
+    QXmlInputSource *inputSource = 0;
+    QFile *file = 0;
+    bool isTemplate = false;
+
+    file = new QFile(source.getLocalFilename());
+    inputSource = new QXmlInputSource(file);
+
+    if (!checkSaveModified()) {
+        delete inputSource;
+        delete file;
+        return FileOpenCancelled;
+    }
+
+    QString error;
+    closeSession();
+    createDocument();
+
+    PaneCallback callback(this);
+    m_viewManager->clearSelections();
+
+    SVFileReader reader(m_document, callback, source.getLocation());
+    connect
+        (&reader, SIGNAL(modelRegenerationFailed(QString, QString, QString)),
+         this, SLOT(modelRegenerationFailed(QString, QString, QString)));
+    connect
+        (&reader, SIGNAL(modelRegenerationWarning(QString, QString, QString)),
+         this, SLOT(modelRegenerationWarning(QString, QString, QString)));
+
+    reader.parse(*inputSource);
+    
+    if (!reader.isOK()) {
+        error = tr("SV XML file read error:\n%1").arg(reader.getErrorString());
+    }
+    
+    delete inputSource;
+    delete file;
+
+    bool ok = (error == "");
+
+    setWindowTitle(QApplication::applicationName());
+
+    if (ok) {
+
+        emit activity(tr("Open session template \"%1\"").arg(source.getLocation()));
+
+	setupMenus();
+
+	CommandHistory::getInstance()->clear();
+	CommandHistory::getInstance()->documentSaved();
+	m_documentModified = false;
+	updateMenuStates();
     }
 
     return ok ? FileOpenSucceeded : FileOpenFailed;
 }
 

 
     emit activity(tr("Import RDF document \"%1\"").arg(source.getLocation()));
 
     std::set<Model *> added;
 
-    for (int i = 0; i < models.size(); ++i) {
+    for (int i = 0; i < (int)models.size(); ++i) {
 
         Model *m = models[i];
         WaveFileModel *w = dynamic_cast<WaveFileModel *>(m);
 
         if (w) {

 
             m_document->addLayerToView(pane, layer);
 
             added.insert(w);
             
-            for (int j = 0; j < models.size(); ++j) {
+            for (int j = 0; j < (int)models.size(); ++j) {
 
                 Model *dm = models[j];
 
                 if (dm == m) continue;
                 if (dm->getSourceModel() != m) continue;

                 added.insert(dm);
             }
         }
     }
 
-    for (int i = 0; i < models.size(); ++i) {
+    for (int i = 0; i < (int)models.size(); ++i) {
 
         Model *m = models[i];
 
         if (added.find(m) == added.end()) {
             

         }
 
         QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
         QTextStream out(&bzFile);
-        toXml(out);
+        toXml(out, false);
         out.flush();
 
         QApplication::restoreOverrideCursor();
 
         if (!bzFile.isOK()) {

                               .arg(path).arg(f.what()));
         return false;
     }
 }
 
-void
-MainWindowBase::toXml(QTextStream &out)
+bool
+MainWindowBase::saveSessionTemplate(QString path)
+{
+    try {
+
+        TempWriteFile temp(path);
+
+        QFile file(temp.getTemporaryFilename());
+        if (!file.open(QIODevice::WriteOnly)) {
+            std::cerr << "Failed to open session template file \""
+                      << temp.getTemporaryFilename().toStdString()
+                      << "\" for writing: "
+                      << file.errorString().toStdString() << std::endl;
+            return false;
+        }
+        
+        QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+
+        QTextStream out(&file);
+        toXml(out, true);
+        out.flush();
+
+        QApplication::restoreOverrideCursor();
+
+        file.close();
+        temp.moveToTarget();
+        return true;
+
+    } catch (FileOperationFailed &f) {
+        
+        QMessageBox::critical(this, tr("Failed to write file"),
+                              tr("<b>Save failed</b><p>Failed to write to file \"%1\": %2")
+                              .arg(path).arg(f.what()));
+        return false;
+    }
+}
+
+void
+MainWindowBase::toXml(QTextStream &out, bool asTemplate)
 {
     QString indent("  ");
 
     out << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
     out << "<!DOCTYPE sonic-visualiser>\n";
     out << "<sv>\n";
 
-    m_document->toXml(out, "", "");
+    if (asTemplate) {
+        m_document->toXmlAsTemplate(out, "", "");
+    } else {
+        m_document->toXml(out, "", "");
+    }
 
     out << "<display>\n";
 
     out << QString("  <window width=\"%1\" height=\"%2\"/>\n")
 	.arg(width()).arg(height());