comparison main/MainWindow.cpp @ 82:d82e332cb178

* Fix #1491849 strange behaviour on Cancel during query on new file load

 MainWindow::importAudio()
 {
     QString path = getOpenFileName(AudioFile);
 
     if (path != "") {
-	if (!openAudioFile(path, ReplaceMainModel)) {
+	if (openAudioFile(path, ReplaceMainModel) == FileOpenFailed) {
 	    QMessageBox::critical(this, tr("Failed to open file"),
 				  tr("Audio file \"%1\" could not be opened").arg(path));
 	}
     }
 }

 MainWindow::importMoreAudio()
 {
     QString path = getOpenFileName(AudioFile);
 
     if (path != "") {
-	if (!openAudioFile(path, CreateAdditionalModel)) {
+	if (openAudioFile(path, CreateAdditionalModel) == FileOpenFailed) {
 	    QMessageBox::critical(this, tr("Failed to open file"),
 				  tr("Audio file \"%1\" could not be opened").arg(path));
 	}
     }
 }

 
     QString path = getOpenFileName(LayerFile);
 
     if (path != "") {
 
-        if (!openLayerFile(path)) {
+        if (openLayerFile(path) == FileOpenFailed) {
             QMessageBox::critical(this, tr("Failed to open file"),
                                   tr("File %1 could not be opened.").arg(path));
             return;
         }
     }
 }
 
-bool
+MainWindow::FileOpenStatus
 MainWindow::openLayerFile(QString path)
 {
     Pane *pane = m_paneStack->getCurrentPane();
     
     if (!pane) {
 	// shouldn't happen, as the menu action should have been disabled
 	std::cerr << "WARNING: MainWindow::openLayerFile: no current pane" << std::endl;
-	return false;
+	return FileOpenFailed;
     }
 
     if (!getMainModel()) {
 	// shouldn't happen, as the menu action should have been disabled
 	std::cerr << "WARNING: MainWindow::openLayerFile: No main model -- hence no default sample rate available" << std::endl;
-	return false;
+	return FileOpenFailed;
     }
 
     if (path.endsWith(".svl") || path.endsWith(".xml")) {
 
         PaneCallback callback(this);

         
         if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
             std::cerr << "ERROR: MainWindow::openLayerFile("
                       << path.toStdString()
                       << "): Failed to open file for reading" << std::endl;
-            return false;
+            return FileOpenFailed;
         }
         
         SVFileReader reader(m_document, callback);
         reader.setCurrentPane(pane);
         

         if (!reader.isOK()) {
             std::cerr << "ERROR: MainWindow::openLayerFile("
                       << path.toStdString()
                       << "): Failed to read XML file: "
                       << reader.getErrorString().toStdString() << std::endl;
-            return false;
+            return FileOpenFailed;
         }
 
         m_recentFiles.addFile(path);
         registerLastOpenedFilePath(LayerFile, path); // for file dialog
-        return true;
+        return FileOpenSucceeded;
         
     } else {
         
         Model *model = DataFileReaderFactory::load(path, getMainModel()->getSampleRate());
         
         if (model) {
             Layer *newLayer = m_document->createImportedLayer(model);
             if (newLayer) {
                 m_document->addLayerToView(pane, newLayer);
                 m_recentFiles.addFile(path);
-                return true;
+                return FileOpenSucceeded;
             }
         }
     }
 
-    return false;
+    return FileOpenFailed;
 }
 
 void
 MainWindow::exportLayer()
 {

     } else {
         m_recentFiles.addFile(path);
     }
 }
 
-bool
+MainWindow::FileOpenStatus
 MainWindow::openAudioFile(QString path, AudioFileOpenMode mode)
 {
     if (!(QFileInfo(path).exists() &&
 	  QFileInfo(path).isFile() &&
 	  QFileInfo(path).isReadable())) {
-	return false;
+	return FileOpenFailed;
     }
 
     m_openingAudioFile = true;
 
     WaveFileModel *newModel = new WaveFileModel(path);
 
     if (!newModel->isOK()) {
 	delete newModel;
         m_openingAudioFile = false;
-	return false;
+	return FileOpenFailed;
     }
 
     bool setAsMain = true;
     static bool prevSetAsMain = true;
 

                  items, prevSetAsMain ? 0 : 1, &ok);
             
             if (!ok || item.isEmpty()) {
                 delete newModel;
                 m_openingAudioFile = false;
-                return false;
+                return FileOpenCancelled;
             }
             
             setAsMain = (item == items[0]);
             prevSetAsMain = setAsMain;
         }

     updateMenuStates();
     m_recentFiles.addFile(path);
     registerLastOpenedFilePath(AudioFile, path); // for file dialog
     m_openingAudioFile = false;
 
-    return true;
+    return FileOpenSucceeded;
 }
 
 void
 MainWindow::createPlayTarget()
 {

 
     QString path = getOpenFileName(SessionFile);
 
     if (path.isEmpty()) return;
 
-    if (!openSessionFile(path)) {
+    if (openSessionFile(path) == FileOpenFailed) {
 	QMessageBox::critical(this, tr("Failed to open file"),
 			      tr("Session file \"%1\" could not be opened").arg(path));
     }
 }
 

 
     if (path.endsWith(".sv")) {
 
         if (!checkSaveModified()) return;
 
-        if (!openSessionFile(path)) {
+        if (openSessionFile(path) == FileOpenFailed) {
             QMessageBox::critical(this, tr("Failed to open file"),
                                   tr("Session file \"%1\" could not be opened").arg(path));
         }
 
     } else {
 
-        if (!openAudioFile(path, AskUser)) {
-
-            if (!canImportLayer || !openLayerFile(path)) {
+        if (openAudioFile(path, AskUser) == FileOpenFailed) {
+
+            if (!canImportLayer || (openLayerFile(path) == FileOpenFailed)) {
 
                 QMessageBox::critical(this, tr("Failed to open file"),
                                       tr("File \"%1\" could not be opened").arg(path));
             }
         }

 
     if (path.endsWith("sv")) {
 
         if (!checkSaveModified()) return ;
 
-        if (!openSessionFile(path)) {
+        if (openSessionFile(path) == FileOpenFailed) {
             QMessageBox::critical(this, tr("Failed to open file"),
                                   tr("Session file \"%1\" could not be opened").arg(path));
         }
 
     } else {
 
-        if (!openAudioFile(path, AskUser)) {
+        if (openAudioFile(path, AskUser) == FileOpenFailed) {
 
             bool canImportLayer = (getMainModel() != 0 &&
                                    m_paneStack != 0 &&
                                    m_paneStack->getCurrentPane() != 0);
 
-            if (!canImportLayer || !openLayerFile(path)) {
+            if (!canImportLayer || (openLayerFile(path) == FileOpenFailed)) {
 
                 QMessageBox::critical(this, tr("Failed to open file"),
                                       tr("File \"%1\" could not be opened").arg(path));
             }
         }
     }
 }
 
-bool
+MainWindow::FileOpenStatus
 MainWindow::openSomeFile(QString path, AudioFileOpenMode mode)
 {
-    if (openAudioFile(path, mode)) {
-	return true;
-    } else if (openSessionFile(path)) {
-	return true;
+    FileOpenStatus status;
+
+    if ((status = openAudioFile(path, mode)) != FileOpenFailed) {
+        return status;
+    } else if ((status = openSessionFile(path)) != FileOpenFailed) {
+	return status;
     } else {
-	return false;
-    }
-}
-
-bool
+	return FileOpenFailed;
+    }
+}
+
+MainWindow::FileOpenStatus
 MainWindow::openSessionFile(QString path)
 {
     BZipFileDevice bzFile(path);
     if (!bzFile.open(QIODevice::ReadOnly)) {
         std::cerr << "Failed to open session file \"" << path.toStdString()
                   << "\": " << bzFile.errorString().toStdString() << std::endl;
-        return false;
+        return FileOpenFailed;
     }
 
     QString error;
     closeSession();
     createDocument();

         registerLastOpenedFilePath(SessionFile, path); // for file dialog
     } else {
 	setWindowTitle(tr("Sonic Visualiser"));
     }
 
-    return ok;
+    return ok ? FileOpenSucceeded : FileOpenFailed;
 }
 
 void
 MainWindow::closeEvent(QCloseEvent *e)
 {

     if (message.getMethod() == "open") {
 
         if (message.getArgCount() == 1 &&
             message.getArg(0).canConvert(QVariant::String)) {
             QString path = message.getArg(0).toString();
-            if (!openSomeFile(path, ReplaceMainModel)) {
+            if (openSomeFile(path, ReplaceMainModel) != FileOpenSucceeded) {
                 std::cerr << "MainWindow::handleOSCMessage: File open failed for path \""
                           << path.toStdString() << "\"" << std::endl;
             }
             //!!! we really need to spin here and not return until the
             // file has been completely decoded...

     } else if (message.getMethod() == "openadditional") {
 
         if (message.getArgCount() == 1 &&
             message.getArg(0).canConvert(QVariant::String)) {
             QString path = message.getArg(0).toString();
-            if (!openSomeFile(path, CreateAdditionalModel)) {
+            if (openSomeFile(path, CreateAdditionalModel) != FileOpenSucceeded) {
                 std::cerr << "MainWindow::handleOSCMessage: File open failed for path \""
                           << path.toStdString() << "\"" << std::endl;
             }
         }
 

             message.getArg(0).canConvert(QVariant::Int)) {
             n = message.getArg(0).toInt() - 1;
         }
         std::vector<QString> recent = m_recentFiles.getRecent();
         if (n >= 0 && n < recent.size()) {
-            if (!openSomeFile(recent[n], ReplaceMainModel)) {
+            if (openSomeFile(recent[n], ReplaceMainModel) != FileOpenSucceeded) {
                 std::cerr << "MainWindow::handleOSCMessage: File open failed for path \""
                           << recent[n].toStdString() << "\"" << std::endl;
             }
         }