comparison view/View.cpp @ 1495:6bb0afa607f5

Toward trying to figure out a progress-bar problem

     m_haveSelectedLayer(false),
     m_useAligningProxy(false),
     m_manager(nullptr),
     m_propertyContainer(new ViewPropertyContainer(this))
 {
-//    cerr << "View::View(" << this << ")" << endl;
+//    cerr << "View::View(" << getId() << ")" << endl;
 }
 
 View::~View()
 {
-//    cerr << "View::~View(" << this << ")" << endl;
+//    cerr << "View::~View(" << getId() << ")" << endl;
 
     m_deleting = true;
     delete m_propertyContainer;
     delete m_cache;
     delete m_buffer;

         m_centreFrame = f;
         
         if (m_zoomLevel.zone == ZoomLevel::PixelsPerFrame) {
 
 #ifdef DEBUG_VIEW
-            SVCERR << "View(" << this << ")::setCentreFrame: in PixelsPerFrame zone, so change must be visible" << endl;
+            SVCERR << "View(" << getId() << ")::setCentreFrame: in PixelsPerFrame zone, so change must be visible" << endl;
 #endif
             update();
             changeVisible = true;
 
         } else {

             int newPixel = int(m_centreFrame / m_zoomLevel.level);
         
             if (newPixel != formerPixel) {
 
 #ifdef DEBUG_VIEW
-                SVCERR << "View(" << this << ")::setCentreFrame: newPixel " << newPixel << ", formerPixel " << formerPixel << endl;
+                SVCERR << "View(" << getId() << ")::setCentreFrame: newPixel " << newPixel << ", formerPixel " << formerPixel << endl;
 #endif
                 // ensure the centre frame is a multiple of the zoom level
                 m_centreFrame = sv_frame_t(newPixel) * m_zoomLevel.level;
 
 #ifdef DEBUG_VIEW

         }
 
         if (e) {
             sv_frame_t rf = alignToReference(m_centreFrame);
 #ifdef DEBUG_VIEW
-            cerr << "View[" << this << "]::setCentreFrame(" << f
+            cerr << "View[" << getId() << "]::setCentreFrame(" << f
                  << "): m_centreFrame = " << m_centreFrame
                  << ", emitting centreFrameChanged with aligned frame "
                  << rf << endl;
 #endif
             emit centreFrameChanged(rf, m_followPan, m_followPlay);

 }
 
 void
 View::modelChanged(ModelId modelId)
 {
-#ifdef DEBUG_VIEW_WIDGET_PAINT
-    cerr << "View(" << this << ")::modelChanged()" << endl;
+#if defined(DEBUG_VIEW_WIDGET_PAINT) || defined(DEBUG_PROGRESS_STUFF)
+    cerr << "View[" << getId() << "]::modelChanged(" << modelId << ")" << endl;
 #endif
 
     // If the model that has changed is not used by any of the cached
     // layers, we won't need to recreate the cache
     

 {
     sv_frame_t myStartFrame = getStartFrame();
     sv_frame_t myEndFrame = getEndFrame();
 
 #ifdef DEBUG_VIEW_WIDGET_PAINT
-    cerr << "View(" << this << ")::modelChangedWithin(" << startFrame << "," << endFrame << ") [me " << myStartFrame << "," << myEndFrame << "]" << endl;
+    cerr << "View(" << getId() << ")::modelChangedWithin(" << startFrame << "," << endFrame << ") [me " << myStartFrame << "," << myEndFrame << "]" << endl;
 #endif
 
     if (myStartFrame > 0 && endFrame < myStartFrame) {
         checkProgress(modelId);
         return;

 }    
 
 void
 View::modelCompletionChanged(ModelId modelId)
 {
+#ifdef DEBUG_PROGRESS_STUFF
+    cerr << "View[" << getId() << "]::modelCompletionChanged(" << modelId << ")" << endl;
+#endif
     checkProgress(modelId);
 }
 
 void
 View::modelAlignmentCompletionChanged(ModelId modelId)
 {
+#ifdef DEBUG_PROGRESS_STUFF
+    cerr << "View[" << getId() << "]::modelAlignmentCompletionChanged(" << modelId << ")" << endl;
+#endif
     checkProgress(modelId);
 }
 
 void
 View::modelReplaced()
 {
 #ifdef DEBUG_VIEW_WIDGET_PAINT
-    cerr << "View(" << this << ")::modelReplaced()" << endl;
+    cerr << "View(" << getId() << ")::modelReplaced()" << endl;
 #endif
     m_cacheValid = false;
     update();
 }
 

 View::globalCentreFrameChanged(sv_frame_t rf)
 {
     if (m_followPan) {
         sv_frame_t f = alignFromReference(rf);
 #ifdef DEBUG_VIEW
-        cerr << "View[" << this << "]::globalCentreFrameChanged(" << rf
+        cerr << "View[" << getId() << "]::globalCentreFrameChanged(" << rf
                   << "): setting centre frame to " << f << endl;
 #endif
         setCentreFrame(f, false);
     }
 }

 
 void
 View::movePlayPointer(sv_frame_t newFrame)
 {
 #ifdef DEBUG_VIEW
-    cerr << "View(" << this << ")::movePlayPointer(" << newFrame << ")" << endl;
+    cerr << "View(" << getId() << ")::movePlayPointer(" << newFrame << ")" << endl;
 #endif
 
     if (m_playPointerFrame == newFrame) return;
     bool visibleChange =
         (getXForFrame(m_playPointerFrame) != getXForFrame(newFrame));

 
 void
 View::viewZoomLevelChanged(View *p, ZoomLevel z, bool locked)
 {
 #ifdef DEBUG_VIEW_WIDGET_PAINT
-    cerr  << "View[" << this << "]: viewZoomLevelChanged(" << p << ", " << z << ", " << locked << ")" << endl;
+    cerr  << "View[" << getId() << "]: viewZoomLevelChanged(" << p << ", " << z << ", " << locked << ")" << endl;
 #endif
     if (m_followZoom && p != this && locked) {
         setZoomLevel(z);
     }
 }

 
     for (LayerList::const_iterator i = m_layerStack.begin(); i != m_layerStack.end(); ++i) {
 //        SVDEBUG << "View::getScrollableBackLayers: calling isLayerDormant on layer " << *i << endl;
 //        cerr << "(name is " << (*i)->objectName() << ")"
 //                  << endl;
-//        SVDEBUG << "View::getScrollableBackLayers: I am " << this << endl;
+//        SVDEBUG << "View::getScrollableBackLayers: I am " << getId() << endl;
         if ((*i)->isLayerDormant(this)) continue;
         if ((*i)->isLayerOpaque()) {
             // You can't see anything behind an opaque layer!
             scrollables.clear();
             if (metUnscrollable) break;

 void
 View::checkProgress(ModelId modelId)
 {
     if (!m_showProgress) {
 #ifdef DEBUG_PROGRESS_STUFF
-        SVCERR << "View[" << this << "]::checkProgress(" << modelId << "): "
+        SVCERR << "View[" << getId() << "]::checkProgress(" << modelId << "): "
                << "m_showProgress is off" << endl;
 #endif
         return;
     }
 

         QPushButton *cancel = i->second.cancel;
 
         if (i->first && i->first->getModel() == modelId) {
 
             found = true;
-
-            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
-                cancel->hide();
-                pb->hide();
-                continue;
-            }
+            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;

             int completion = i->first->getCompletion(this);
             QString text = i->first->getPropertyContainerName();
             QString error = i->first->getError(this);
 
 #ifdef DEBUG_PROGRESS_STUFF
-            SVCERR << "View[" << this << "]::checkProgress(" << modelId << "): "
+            SVCERR << "View[" << getId() << "]::checkProgress(" << modelId << "): "
                    << "found progress bar " << pb << " for layer at height " << ph
                    << ": completion = " << completion << endl;
 #endif
 
             if (error != "" && error != m_lastError) {

                 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[" << this << "]::checkProgress(" << modelId << "): "
+                    SVCERR << "View[" << getId() << "]::checkProgress(" << modelId << "): "
                            << "alignment completion = " << completion << endl;
 #endif
                 
                     if (completion < 100) {
                         text = tr("Alignment");

 
                 pb->hide();
                 cancel->hide();
                 timer->stop();
 
+            } else if (i->first->isLayerDormant(this) && !isAlignmentProgress) {
+
+                // 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
+#ifdef DEBUG_PROGRESS_STUFF
+                SVCERR << "View[" << getId() << "]::checkProgress("
+                       << modelId << "): layer is dormant" << endl;
+#endif
+                pb->hide();
+                cancel->hide();
+                timer->stop();
+                
             } else {
 
                 if (!pb->isVisible()) {
                     i->second.lastCheck = 0;
                     timer->setInterval(2000);

                 }
 
                 pb->show();
                 pb->update();
 
-                ph -= pb->height();
+                if (pb->isVisible()) {
+                    ph -= pb->height();
+                }
             }
         } else {
             if (pb->isVisible()) {
                 ph -= pb->height();
             }
         }
     }
 
     if (!found) {
 #ifdef DEBUG_PROGRESS_STUFF
-        SVCERR << "View[" << this << "]::checkProgress(" << modelId << "): "
+        SVCERR << "View[" << getId() << "]::checkProgress(" << modelId << "): "
                << "failed to find layer for model in progress map"
                << endl;
 #endif
     }
 }

     for (ProgressMap::iterator i =  m_progressBars.begin();
          i != m_progressBars.end(); ++i) {
 
         if (i->second.checkTimer == t) {
 
+            int value = i->second.bar->value();
+
 #ifdef DEBUG_PROGRESS_STUFF
-            SVCERR << "View[" << this << "]::progressCheckStalledTimerElapsed for layer " << i->first << endl;
-#endif
-    
-            int value = i->second.bar->value();
+            SVCERR << "View[" << getId() << "]::progressCheckStalledTimerElapsed for layer " << i->first << ": value is " << value << endl;
+#endif
+    
             if (value > 0 && value == i->second.lastCheck) {
                 i->second.bar->setMaximum(0); // indeterminate
             }
             i->second.lastCheck = value;
             return;

     bool layersChanged = false;
     LayerList scrollables = getScrollableBackLayers(true, layersChanged);
     LayerList nonScrollables = getNonScrollableFrontLayers(true, layersChanged);
 
 #ifdef DEBUG_VIEW_WIDGET_PAINT
-    cerr << "View(" << this << ")::paintEvent: have " << scrollables.size()
+    cerr << "View(" << getId() << ")::paintEvent: have " << scrollables.size()
               << " scrollable back layers and " << nonScrollables.size()
               << " non-scrollable front layers" << endl;
 #endif
 
     if (layersChanged || scrollables.empty()) {

         shouldUseCache = true;
         shouldRepaintCache = true;
         cacheAreaToRepaint = wholeArea;
 
 #ifdef DEBUG_VIEW_WIDGET_PAINT
-        cerr << "View(" << this << "): cache " << m_cache << ", cache zoom "
+        cerr << "View(" << getId() << "): cache " << m_cache << ", cache zoom "
                   << m_cacheZoomLevel << ", zoom " << m_zoomLevel << endl;
 #endif
 
         using namespace std::rel_ops;
     

                 m_cacheValid = false;
                 shouldUseCache = false;
                 shouldRepaintCache = false;
 
 #ifdef DEBUG_VIEW_WIDGET_PAINT
-                cerr << "View(" << this << ")::paintEvent: cache is invalid but only small area requested, will repaint directly instead" << endl;
+                cerr << "View(" << getId() << ")::paintEvent: cache is invalid but only small area requested, will repaint directly instead" << endl;
 #endif
             } else {
 
                 if (!m_cache ||
                     m_cache->size() != wholeSize) {
                     delete m_cache;
                     m_cache = new QPixmap(wholeSize);
                 }
 
 #ifdef DEBUG_VIEW_WIDGET_PAINT
-                cerr << "View(" << this << ")::paintEvent: cache is invalid, will repaint whole" << endl;
+                cerr << "View(" << getId() << ")::paintEvent: cache is invalid, will repaint whole" << endl;
 #endif
             }
 
             count.miss();
             

                 }
 
                 count.partial();
 
 #ifdef DEBUG_VIEW_WIDGET_PAINT
-                cerr << "View(" << this << ")::paintEvent: scrolled cache by " << dx << endl;
+                cerr << "View(" << getId() << ")::paintEvent: scrolled cache by " << dx << endl;
 #endif
             } else {
                 count.miss();
 #ifdef DEBUG_VIEW_WIDGET_PAINT
-                cerr << "View(" << this << ")::paintEvent: scrolling too far" << endl;
+                cerr << "View(" << getId() << ")::paintEvent: scrolling too far" << endl;
 #endif
             }
 
         } else {
 #ifdef DEBUG_VIEW_WIDGET_PAINT
-            cerr << "View(" << this << ")::paintEvent: cache is good" << endl;
+            cerr << "View(" << getId() << ")::paintEvent: cache is good" << endl;
 #endif
             count.hit();
             shouldRepaintCache = false;
         }
     }
 
 #ifdef DEBUG_VIEW_WIDGET_PAINT
-    cerr << "View(" << this << ")::paintEvent: m_cacheValid = " << m_cacheValid << ", shouldUseCache = " << shouldUseCache << ", shouldRepaintCache = " << shouldRepaintCache << ", cacheAreaToRepaint = " << cacheAreaToRepaint.x() << "," << cacheAreaToRepaint.y() << " " << cacheAreaToRepaint.width() << "x" << cacheAreaToRepaint.height() << endl;
+    cerr << "View(" << getId() << ")::paintEvent: m_cacheValid = " << m_cacheValid << ", shouldUseCache = " << shouldUseCache << ", shouldRepaintCache = " << shouldRepaintCache << ", cacheAreaToRepaint = " << cacheAreaToRepaint.x() << "," << cacheAreaToRepaint.y() << " " << cacheAreaToRepaint.width() << "x" << cacheAreaToRepaint.height() << endl;
 #endif
 
     if (shouldRepaintCache && !shouldUseCache) {
         // If we are repainting the cache, then we paint the
         // scrollables only to the cache, not to the buffer. So if

 }
 
 ViewPropertyContainer::ViewPropertyContainer(View *v) :
     m_v(v)
 {
-//    cerr << "ViewPropertyContainer: " << this << " is owned by View " << v << endl;
+//    cerr << "ViewPropertyContainer: " << getId() << " is owned by View " << v << endl;
     connect(m_v, SIGNAL(propertyChanged(PropertyContainer::PropertyName)),
             this, SIGNAL(propertyChanged(PropertyContainer::PropertyName)));
 }
 
 ViewPropertyContainer::~ViewPropertyContainer()