comparison align/ExternalProgramAligner.cpp @ 761:6429a164b7e1 pitch-align

Schedule alignments with a small delay to avoid too much UI unresponsiveness. Also overhaul error reporting to use signals throughout.

 {
     QFileInfo file(program);
     return file.exists() && file.isExecutable();
 }
 
-bool
-ExternalProgramAligner::begin(QString &error)
+void
+ExternalProgramAligner::begin()
 {
     // Run an external program, passing to it paths to the main
     // model's audio file and the new model's audio file. It returns
     // the path in CSV form through stdout.
 
     auto reference = ModelById::getAs<ReadOnlyWaveFileModel>(m_reference);
     auto other = ModelById::getAs<ReadOnlyWaveFileModel>(m_toAlign);
     if (!reference || !other) {
         SVCERR << "ERROR: ExternalProgramAligner: Can't align non-read-only models via program (no local filename available)" << endl;
-        return false;
+        return;
     }
 
     while (!reference->isReady(nullptr) || !other->isReady(nullptr)) {
         qApp->processEvents();
     }

     if (otherPath == "") {
         otherPath = FileSource(other->getLocation()).getLocalFilename();
     }
 
     if (refPath == "" || otherPath == "") {
-        error = "Failed to find local filepath for wave-file model";
-        return false;
+        emit failed(m_toAlign,
+                    tr("Failed to find local filepath for wave-file model"));
+        return;
     }
 
     auto alignmentModel =
         std::make_shared<AlignmentModel>(m_reference, m_toAlign, ModelId());
 

     bool success = m_process->waitForStarted();
 
     if (!success) {
         
         SVCERR << "ERROR: ExternalProgramAligner: Program did not start" << endl;
-        error = "Alignment program \"" + m_program + "\" did not start";
+        emit failed(m_toAlign,
+                    tr("Alignment program \"%1\" did not start")
+                    .arg(m_program));
         
         other->setAlignment({});
         ModelById::release(m_alignmentModel);
         delete m_process;
         m_process = nullptr;
         
     } else {
         m_document->addNonDerivedModel(m_alignmentModel);
     }
-
-    return success;
 }
 
 void
 ExternalProgramAligner::programFinished(int  exitCode, QProcess::ExitStatus status)
 {

 
         CSVFileReader reader(process, format, alignmentModel->getSampleRate());
         if (!reader.isOK()) {
             SVCERR << "ERROR: ExternalProgramAligner: Failed to parse output"
                    << endl;
-            alignmentModel->setError
-                (QString("Failed to parse output of program: %1")
-                 .arg(reader.getError()));
+            QString error = tr("Failed to parse output of program: %1")
+                .arg(reader.getError());
+            alignmentModel->setError(error);
+            emit failed(m_toAlign, error);
             goto done;
         }
 
         //!!! to use ById?
         

         SparseTimeValueModel *path =
             qobject_cast<SparseTimeValueModel *>(csvOutput);
         if (!path) {
             SVCERR << "ERROR: ExternalProgramAligner: Output did not convert to sparse time-value model"
                    << endl;
-            alignmentModel->setError
-                ("Output of program did not produce sparse time-value model");
+            QString error =
+                tr("Output of alignment program was not in the proper format");
+            alignmentModel->setError(error);
             delete csvOutput;
+            emit failed(m_toAlign, error);
             goto done;
         }
                        
         if (path->isEmpty()) {
             SVCERR << "ERROR: ExternalProgramAligner: Output contained no mappings"
                    << endl;
-            alignmentModel->setError
-                ("Output of alignment program contained no mappings");
+            QString error = 
+                tr("Output of alignment program contained no mappings");
+            alignmentModel->setError(error);
             delete path;
+            emit failed(m_toAlign, error);
             goto done;
         }
 
         SVCERR << "ExternalProgramAligner: Setting alignment path ("
              << path->getEventCount() << " point(s))" << endl;

         
     } else {
         SVCERR << "ERROR: ExternalProgramAligner: Aligner program "
                << "failed: exit code " << exitCode << ", status " << status
                << endl;
-        alignmentModel->setError
-            ("Aligner process returned non-zero exit status");
+        QString error = tr("Aligner process returned non-zero exit status");
+        alignmentModel->setError(error);
+        emit failed(m_toAlign, error);
     }
 
 done:
     delete m_process;
     m_process = nullptr;