comparison data/model/NoteModel.h @ 1651:7a56bb85030f single-point

Introduce deferred notifier, + start converting sparse time-value model (perhaps we should rename it too)

 
 /*
     Sonic Visualiser
     An audio file viewer and annotation editor.
     Centre for Digital Music, Queen Mary, University of London.
-    This file copyright 2006 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.  See the file

 #define SV_NOTE_MODEL_H
 
 #include "Model.h"
 #include "TabularModel.h"
 #include "EventCommands.h"
+#include "DeferredNotifier.h"
 #include "base/UnitDatabase.h"
 #include "base/EventSeries.h"
 #include "base/NoteData.h"
 #include "base/NoteExportable.h"
 #include "base/RealTime.h"

         m_valueMaximum(0.f),
         m_haveExtents(false),
         m_valueQuantization(0),
         m_units(""),
         m_extendTo(0),
-        m_notifyOnAdd(notifyOnAdd),
-        m_sinceLastNotifyMin(-1),
-        m_sinceLastNotifyMax(-1),
+        m_notifier(this,
+                   notifyOnAdd ?
+                   DeferredNotifier::NOTIFY_ALWAYS :
+                   DeferredNotifier::NOTIFY_DEFERRED),
         m_completion(0) {
         if (subtype == FLEXI_NOTE) {
             m_valueMinimum = 33.f;
             m_valueMaximum = 88.f;
         }

         m_valueMaximum(valueMaximum),
         m_haveExtents(true),
         m_valueQuantization(0),
         m_units(""),
         m_extendTo(0),
-        m_notifyOnAdd(notifyOnAdd),
-        m_sinceLastNotifyMin(-1),
-        m_sinceLastNotifyMax(-1),
+        m_notifier(this,
+                   notifyOnAdd ?
+                   DeferredNotifier::NOTIFY_ALWAYS :
+                   DeferredNotifier::NOTIFY_DEFERRED),
         m_completion(0) {
         PlayParameterRepository::getInstance()->addPlayable(this);
     }
 
     virtual ~NoteModel() {

     
     int getCompletion() const { return m_completion; }
 
     void setCompletion(int completion, bool update = true) {
 
-        bool emitCompletionChanged = true;
-        bool emitGeneralModelChanged = false;
-        bool emitRegionChanged = false;
-
-        {
-            QMutexLocker locker(&m_mutex);
-
-            if (m_completion != completion) {
-                m_completion = completion;
-
-                if (completion == 100) {
-
-                    if (m_notifyOnAdd) {
-                        emitCompletionChanged = false;
-                    }
-
-                    m_notifyOnAdd = true; // henceforth
-                    emitGeneralModelChanged = true;
-
-                } else if (!m_notifyOnAdd) {
-
-                    if (update &&
-                        m_sinceLastNotifyMin >= 0 &&
-                        m_sinceLastNotifyMax >= 0) {
-                        emitRegionChanged = true;
-                    }
-                }
-            }
-        }
-
-        if (emitCompletionChanged) {
-            emit completionChanged();
-        }
-        if (emitGeneralModelChanged) {
+        {   QMutexLocker locker(&m_mutex);
+            if (m_completion == completion) return;
+            m_completion = completion;
+        }
+
+        if (update) {
+            m_notifier.makeDeferredNotifications();
+        }
+        
+        emit completionChanged();
+
+        if (completion == 100) {
+            // henceforth:
+            m_notifier.switchMode(DeferredNotifier::NOTIFY_ALWAYS);
             emit modelChanged();
         }
-        if (emitRegionChanged) {
-            emit modelChangedWithin(m_sinceLastNotifyMin, m_sinceLastNotifyMax);
-            m_sinceLastNotifyMin = m_sinceLastNotifyMax = -1;
-        }        
     }
 
     /**
      * Query methods.
      */

         bool allChange = false;
            
         {
             QMutexLocker locker(&m_mutex);
             m_events.add(e);
-//!!!???        if (point.getLabel() != "") m_hasTextLabels = true;
 
             float v = e.getValue();
             if (!ISNAN(v) && !ISINF(v)) {
                 if (!m_haveExtents || v < m_valueMinimum) {
                     m_valueMinimum = v; allChange = true;

                 if (!m_haveExtents || v > m_valueMaximum) {
                     m_valueMaximum = v; allChange = true;
                 }
                 m_haveExtents = true;
             }
-            
-            sv_frame_t f = e.getFrame();
-
-            if (!m_notifyOnAdd) {
-                if (m_sinceLastNotifyMin == -1 || f < m_sinceLastNotifyMin) {
-                    m_sinceLastNotifyMin = f;
-                }
-                if (m_sinceLastNotifyMax == -1 || f > m_sinceLastNotifyMax) {
-                    m_sinceLastNotifyMax = f;
-                }
-            }
-        }
-        
-        if (m_notifyOnAdd) {
-            emit modelChangedWithin(e.getFrame(),
-                                    e.getFrame() + e.getDuration() + m_resolution);
-        }
+        }
+        
+        m_notifier.update(e.getFrame(), e.getDuration() + m_resolution);
+
         if (allChange) {
             emit modelChanged();
         }
     }
     

              QString("type=\"sparse\" dimensions=\"3\" resolution=\"%1\" "
                      "notifyOnAdd=\"%2\" dataset=\"%3\" subtype=\"%4\" "
                      "valueQuantization=\"%5\" minimum=\"%6\" maximum=\"%7\" "
                      "units=\"%8\" %9")
              .arg(m_resolution)
-             .arg(m_notifyOnAdd ? "true" : "false")
+             .arg("true") // always true after model reaches 100% -
+                          // subsequent events are always notified
              .arg(getObjectExportId(&m_events))
              .arg(m_subtype == FLEXI_NOTE ? "flexinote" : "note")
              .arg(m_valueQuantization)
              .arg(m_valueMinimum)
              .arg(m_valueMaximum)
-             .arg(m_units)
+             .arg(encodeEntities(m_units))
              .arg(extraAttributes));
         
         m_events.toXml(out, indent, QString("dimensions=\"3\""));
     }
 

     float m_valueMinimum;
     float m_valueMaximum;
     bool m_haveExtents;
     float m_valueQuantization;
     QString m_units;
-    
     sv_frame_t m_extendTo;
-
-    bool m_notifyOnAdd;
-    sv_frame_t m_sinceLastNotifyMin;
-    sv_frame_t m_sinceLastNotifyMax;
+    DeferredNotifier m_notifier;
+    int m_completion;
 
     EventSeries m_events;
-
-    int m_completion;
 
     mutable QMutex m_mutex;
 
     //!!! do we have general docs for ownership and synchronisation of models?
     // this might be a good opportunity to stop using bare pointers to them