comparison layer/SpectrogramLayer.cpp @ 34:c43f2c4f66f2

* As previous commit

 }
 
 void
 SpectrogramLayer::setModel(const DenseTimeValueModel *model)
 {
+    std::cerr << "SpectrogramLayer(" << this << "): setModel(" << model << ")" << std::endl;
+
     m_mutex.lock();
     m_model = model;
-    delete m_cache;
+    delete m_cache; //!!! hang on, this isn't safe to do here is it? 
+		    // we need some sort of guard against the fill
+		    // thread trying to read the defunct model too.
+		    // should we use a scavenger?
     m_cache = 0;
     m_mutex.unlock();
 
     if (!m_model || !m_model->isOK()) return;
 

     if (dormant) {
 
 	m_mutex.lock();
 	m_dormant = true;
 
-	delete m_cache;
-	m_cache = 0;
+//	delete m_cache;
+//	m_cache = 0;
 	
+	m_cacheInvalid = true;
 	m_pixmapCacheInvalid = true;
+	m_cachedInitialVisibleArea = false;
 	delete m_pixmapCache;
 	m_pixmapCache = 0;
 	
 	m_mutex.unlock();
 

 
     windower.cut(input);
 
     fftw_execute(plan);
 
-    if (lock) m_mutex.lock();
+//    if (lock) m_mutex.lock();
     bool interrupted = false;
 
     for (size_t i = 0; i < windowSize / 2; ++i) {
 
 	int value = 0;

 	}
 
 	m_cache->setValueAt(column, i, value + 1);
     }
 
-    if (lock) m_mutex.unlock();
+//    if (lock) m_mutex.unlock();
     return !interrupted;
 }
 
 SpectrogramLayer::Cache::Cache(size_t width, size_t height) :
     m_width(width),

 
 	bool interrupted = false;
 
 //	std::cerr << "SpectrogramLayer::CacheFillThread::run in loop" << std::endl;
 
-	if (m_layer.m_model && m_layer.m_cacheInvalid && !m_layer.m_dormant) {
+	if (m_layer.m_dormant) {
+
+	    if (m_layer.m_cacheInvalid) {
+		delete m_layer.m_cache;
+		m_layer.m_cache = 0;
+	    }
+
+	} else if (m_layer.m_model && m_layer.m_cacheInvalid) {
 
 //	    std::cerr << "SpectrogramLayer::CacheFillThread::run: something to do" << std::endl;
 
 	    while (!m_layer.m_model->isReady()) {
 		m_layer.m_condition.wait(&m_layer.m_mutex, 100);