comparison view/View.cpp @ 1496:d09345e578a7

Separate out handling of alignment progress bar from the layer progress bars and fix tendency to have them hanging around even when alignment has completed

     m_cacheZoomLevel(ZoomLevel::FramesPerPixel, 1024),
     m_selectionCached(false),
     m_deleting(false),
     m_haveSelectedLayer(false),
     m_useAligningProxy(false),
+    m_alignmentProgressBar({ {}, nullptr }),
     m_manager(nullptr),
     m_propertyContainer(new ViewPropertyContainer(this))
 {
 //    cerr << "View::View(" << getId() << ")" << endl;
 }

     connect(cancel, SIGNAL(clicked()), this, SLOT(cancelClicked()));
     
     ProgressBarRec pbr;
     pbr.cancel = cancel;
     pbr.bar = pb;
-    pbr.lastCheck = 0;
-    pbr.checkTimer = new QTimer();
-    connect(pbr.checkTimer, SIGNAL(timeout()), this,
+    pbr.lastStallCheckValue = 0;
+    pbr.stallCheckTimer = new QTimer();
+    connect(pbr.stallCheckTimer, SIGNAL(timeout()), this,
             SLOT(progressCheckStalledTimerElapsed()));
 
     m_progressBars[layer] = pbr;
 
     QFont f(pb->font());

         if (*i == layer) {
             m_layerStack.erase(i);
             if (m_progressBars.find(layer) != m_progressBars.end()) {
                 delete m_progressBars[layer].bar;
                 delete m_progressBars[layer].cancel;
-                delete m_progressBars[layer].checkTimer;
+                delete m_progressBars[layer].stallCheckTimer;
                 m_progressBars.erase(layer);
             }
             break;
         }
     }

 View::modelAlignmentCompletionChanged(ModelId modelId)
 {
 #ifdef DEBUG_PROGRESS_STUFF
     cerr << "View[" << getId() << "]::modelAlignmentCompletionChanged(" << modelId << ")" << endl;
 #endif
-    checkProgress(modelId);
+    checkAlignmentProgress(modelId);
 }
 
 void
 View::modelReplaced()
 {

                << "m_showProgress is off" << endl;
 #endif
         return;
     }
 
+#ifdef DEBUG_PROGRESS_STUFF
+    SVCERR << "View[" << getId() << "]::checkProgress(" << modelId << ")" << endl;
+#endif
+
     QSettings settings;
     settings.beginGroup("View");
     bool showCancelButton = settings.value("showcancelbuttons", true).toBool();
     settings.endGroup();
     
     int ph = height();
     bool found = false;
 
+    if (m_alignmentProgressBar.bar) {
+        ph -= m_alignmentProgressBar.bar->height();
+    }
+
     for (ProgressMap::iterator i = m_progressBars.begin();
          i != m_progressBars.end(); ++i) {
 
         QProgressBar *pb = i->second.bar;
         QPushButton *cancel = i->second.cancel;
 
         if (i->first && i->first->getModel() == modelId) {
 
             found = true;
-            bool isAlignmentProgress = false;
             
             // The timer is used to test for stalls.  If the progress
             // bar does not get updated for some length of time, the
             // timer prompts it to go back into "indeterminate" mode
-            QTimer *timer = i->second.checkTimer;
+            QTimer *timer = i->second.stallCheckTimer;
 
             int completion = i->first->getCompletion(this);
-            QString text = i->first->getPropertyContainerName();
             QString error = i->first->getError(this);
 
 #ifdef DEBUG_PROGRESS_STUFF
             SVCERR << "View[" << getId() << "]::checkProgress(" << modelId << "): "
                    << "found progress bar " << pb << " for layer at height " << ph

             if (error != "" && error != m_lastError) {
                 QMessageBox::critical(this, tr("Layer rendering error"), error);
                 m_lastError = error;
             }
 
-            auto model = ModelById::get(modelId);
-            auto wfm = std::dynamic_pointer_cast
-                <RangeSummarisableTimeValueModel>(model);
-
             if (completion > 0) {
                 pb->setMaximum(100); // was 0, for indeterminate start
             }
 
-            if (completion >= 100) {
-                
-                if (wfm ||
-                    (model && 
-                     (wfm = ModelById::getAs<RangeSummarisableTimeValueModel>
-                      (model->getSourceModel())))) {
-
-                    isAlignmentProgress = true;
-
-                    completion = wfm->getAlignmentCompletion();
-
-                    // We don't allow cancelling alignment operations
-                    // - they aren't usually all that expensive, and
-                    // it would leave things in a very uncertain state
-                    showCancelButton = false;
-
-#ifdef DEBUG_PROGRESS_STUFF
-                    SVCERR << "View[" << getId() << "]::checkProgress(" << modelId << "): "
-                           << "alignment completion = " << completion << endl;
-#endif
-                
-                    if (completion < 100) {
-                        text = tr("Alignment");
-                    }
-                }
-
-            } else if (wfm) {
+            if (completion < 100 &&
+                ModelById::isa<RangeSummarisableTimeValueModel>(modelId)) {
                 update(); // ensure duration &c gets updated
             }
 
             if (completion >= 100) {
 
                 pb->hide();
                 cancel->hide();
                 timer->stop();
 
-            } else if (i->first->isLayerDormant(this) && !isAlignmentProgress) {
+            } else if (i->first->isLayerDormant(this)) {
 
                 // A dormant (invisible) layer can still be busy
                 // generating, but we don't usually want to indicate
                 // it because it probably means it's a duplicate of a
                 // visible layer

                 timer->stop();
                 
             } else {
 
                 if (!pb->isVisible()) {
-                    i->second.lastCheck = 0;
+                    i->second.lastStallCheckValue = 0;
                     timer->setInterval(2000);
                     timer->start();
                 }
 
                 if (showCancelButton) {

 #endif
     }
 }
 
 void
+View::checkAlignmentProgress(ModelId modelId)
+{
+    if (!m_showProgress) {
+#ifdef DEBUG_PROGRESS_STUFF
+        SVCERR << "View[" << getId() << "]::checkAlignmentProgress(" << modelId << "): "
+               << "m_showProgress is off" << endl;
+#endif
+        return;
+    }
+
+#ifdef DEBUG_PROGRESS_STUFF
+    SVCERR << "View[" << getId() << "]::checkAlignmentProgress(" << modelId << ")" << endl;
+#endif
+
+    if (!m_alignmentProgressBar.alignedModel.isNone() &&
+        modelId != m_alignmentProgressBar.alignedModel) {
+#ifdef DEBUG_PROGRESS_STUFF
+        SVCERR << "View[" << getId() << "]::checkAlignmentProgress(" << modelId << "): Different model (we're currently showing alignment progress for " << modelId << ", ignoring" << endl;
+#endif
+        return;
+    }
+    
+    auto model = ModelById::get(modelId);
+    if (!model) {
+#ifdef DEBUG_PROGRESS_STUFF
+        SVCERR << "View[" << getId() << "]::checkAlignmentProgress(" << modelId << "): Model gone" << endl;
+#endif
+        m_alignmentProgressBar.alignedModel = {};
+        delete m_alignmentProgressBar.bar;
+        m_alignmentProgressBar.bar = nullptr;
+        return;
+    }
+
+    int completion = model->getAlignmentCompletion();
+
+#ifdef DEBUG_PROGRESS_STUFF
+    SVCERR << "View[" << getId() << "]::checkAlignmentProgress(" << modelId << "): Completion is " << completion << endl;
+#endif
+
+    int ph = height();
+
+    if (completion >= 100) {
+        m_alignmentProgressBar.alignedModel = {};
+        delete m_alignmentProgressBar.bar;
+        m_alignmentProgressBar.bar = nullptr;
+        return;
+    }
+
+    QProgressBar *pb = m_alignmentProgressBar.bar;
+    if (!pb) {
+        pb = new QProgressBar(this);
+        pb->setMinimum(0);
+        pb->setMaximum(100);
+        pb->setFixedWidth(80);
+        pb->setTextVisible(false);
+        m_alignmentProgressBar.alignedModel = modelId;
+        m_alignmentProgressBar.bar = pb;
+    }
+        
+    pb->setValue(completion);
+    pb->move(0, ph - pb->height());
+    pb->show();
+    pb->update();
+}
+
+void
 View::progressCheckStalledTimerElapsed()
 {
     QObject *s = sender();
     QTimer *t = qobject_cast<QTimer *>(s);
     if (!t) return;
 
     for (ProgressMap::iterator i =  m_progressBars.begin();
          i != m_progressBars.end(); ++i) {
 
-        if (i->second.checkTimer == t) {
+        if (i->second.stallCheckTimer == t) {
 
             int value = i->second.bar->value();
 
 #ifdef DEBUG_PROGRESS_STUFF
             SVCERR << "View[" << getId() << "]::progressCheckStalledTimerElapsed for layer " << i->first << ": value is " << value << endl;
 #endif
     
-            if (value > 0 && value == i->second.lastCheck) {
+            if (value > 0 && value == i->second.lastStallCheckValue) {
                 i->second.bar->setMaximum(0); // indeterminate
             }
-            i->second.lastCheck = value;
+            i->second.lastStallCheckValue = value;
             return;
         }
     }
 }
 
 int
 View::getProgressBarWidth() const
 {
+    if (m_alignmentProgressBar.bar) {
+        return m_alignmentProgressBar.bar->width();
+    }
+    
     for (ProgressMap::const_iterator i = m_progressBars.begin();
          i != m_progressBars.end(); ++i) {
         if (i->second.bar && i->second.bar->isVisible()) {
             return i->second.bar->width();
         }