comparison main/MainWindow.cpp @ 95:2678a1f132d2

* Add slice layers (so you can display a slice of a colour 3d plot as if it were
  a spectrum)
* Make spectrum layer a subclass of slice layer

 #include "layer/WaveformLayer.h"
 #include "layer/TimeRulerLayer.h"
 #include "layer/TimeInstantLayer.h"
 #include "layer/TimeValueLayer.h"
 #include "layer/Colour3DPlotLayer.h"
+#include "layer/SliceLayer.h"
+#include "layer/SliceableLayer.h"
 #include "widgets/Fader.h"
 #include "view/Overview.h"
 #include "widgets/PropertyBox.h"
 #include "widgets/PropertyStack.h"
 #include "widgets/AudioDial.h"

     m_mainMenusCreated(false),
     m_paneMenu(0),
     m_layerMenu(0),
     m_transformsMenu(0),
     m_existingLayersMenu(0),
+    m_sliceMenu(0),
     m_recentFilesMenu(0),
     m_recentTransformsMenu(0),
     m_rightButtonMenu(0),
     m_rightButtonLayerMenu(0),
     m_rightButtonTransformsMenu(0),

 
     menu->addSeparator();
 
     m_existingLayersMenu = menu->addMenu(tr("Add &Existing Layer"));
     m_rightButtonLayerMenu->addMenu(m_existingLayersMenu);
-    setupExistingLayersMenu();
+
+    m_sliceMenu = menu->addMenu(tr("Add S&lice of Layer"));
+    m_rightButtonLayerMenu->addMenu(m_sliceMenu);
+
+    setupExistingLayersMenus();
 
     m_rightButtonLayerMenu->addSeparator();
     menu->addSeparator();
 
     action = new QAction(tr("&Rename Layer..."), this);

 	m_recentTransformsMenu->addAction(ti->second);
     }
 }
 
 void
-MainWindow::setupExistingLayersMenu()
+MainWindow::setupExistingLayersMenus()
 {
     if (!m_existingLayersMenu) return; // should have been created by setupMenus
 
 //    std::cerr << "MainWindow::setupExistingLayersMenu" << std::endl;
 
     m_existingLayersMenu->clear();
     m_existingLayerActions.clear();
 
+    m_sliceMenu->clear();
+    m_sliceActions.clear();
+
     vector<Layer *> orderedLayers;
     set<Layer *> observedLayers;
+    set<Layer *> sliceableLayers;
+
+    LayerFactory *factory = LayerFactory::getInstance();
 
     for (int i = 0; i < m_paneStack->getPaneCount(); ++i) {
 
 	Pane *pane = m_paneStack->getPane(i);
 	if (!pane) continue;

 //	    std::cerr << "found new layer " << layer << " (name = " 
 //		      << layer->getLayerPresentationName().toStdString() << ")" << std::endl;
 
 	    orderedLayers.push_back(layer);
 	    observedLayers.insert(layer);
+
+            if (factory->isLayerSliceable(layer)) {
+                sliceableLayers.insert(layer);
+            }
 	}
     }
 
     map<QString, int> observedNames;
 
     for (int i = 0; i < orderedLayers.size(); ++i) {
 	
-	QString name = orderedLayers[i]->getLayerPresentationName();
+        Layer *layer = orderedLayers[i];
+
+	QString name = layer->getLayerPresentationName();
 	int n = ++observedNames[name];
 	if (n > 1) name = QString("%1 <%2>").arg(name).arg(n);
 
-	QAction *action = new QAction(name, this);
+	QIcon icon = QIcon(QString(":/icons/%1.png")
+                           .arg(factory->getLayerIconName
+                                (factory->getLayerType(layer))));
+
+	QAction *action = new QAction(icon, name, this);
 	connect(action, SIGNAL(triggered()), this, SLOT(addLayer()));
 	connect(this, SIGNAL(canAddLayer(bool)), action, SLOT(setEnabled(bool)));
-	m_existingLayerActions[action] = orderedLayers[i];
+	m_existingLayerActions[action] = layer;
 
 	m_existingLayersMenu->addAction(action);
-    }
+
+        if (sliceableLayers.find(layer) != sliceableLayers.end()) {
+            action = new QAction(icon, name, this);
+            connect(action, SIGNAL(triggered()), this, SLOT(addLayer()));
+            connect(this, SIGNAL(canAddLayer(bool)), action, SLOT(setEnabled(bool)));
+            m_sliceActions[action] = layer;
+            m_sliceMenu->addAction(action);
+        }
+    }
+
+    m_sliceMenu->setEnabled(!m_sliceActions.empty());
 }
 
 void
 MainWindow::setupToolbars()
 {

 	m_document->addLayerToView(pane, newLayer);
 	m_paneStack->setCurrentLayer(pane, newLayer);
 	return;
     }
 
+    ei = m_sliceActions.find(action);
+
+    if (ei != m_sliceActions.end()) {
+        Layer *newLayer = m_document->createLayer(LayerFactory::Slice);
+//        document->setModel(newLayer, ei->second->getModel());
+        SliceableLayer *source = dynamic_cast<SliceableLayer *>(ei->second);
+        SliceLayer *dest = dynamic_cast<SliceLayer *>(newLayer);
+        if (source && dest) {
+            dest->setSliceableModel(source->getSliceableModel());
+            connect(source, SIGNAL(sliceableModelReplaced(const Model *, const Model *)),
+                    dest, SLOT(sliceableModelReplaced(const Model *, const Model *)));
+            connect(m_document, SIGNAL(modelAboutToBeDeleted(Model *)),
+                    dest, SLOT(modelAboutToBeDeleted(Model *)));
+        }
+	m_document->addLayerToView(pane, newLayer);
+	m_paneStack->setCurrentLayer(pane, newLayer);
+	return;
+    }
+
     TransformActionMap::iterator i = m_transformActions.find(action);
 
     if (i == m_transformActions.end()) {
 
 	LayerActionMap::iterator i = m_layerActions.find(action);

 		(this, tr("Rename Layer"),
 		 tr("New name for this layer:"),
 		 QLineEdit::Normal, layer->objectName(), &ok);
 	    if (ok) {
 		layer->setObjectName(newName);
-		setupExistingLayersMenu();
+		setupExistingLayersMenus();
 	    }
 	}
     }
 }
 

 
 void
 MainWindow::layerRemoved(Layer *layer)
 {
 //    std::cerr << "MainWindow::layerRemoved(" << layer << ")" << std::endl;
-    setupExistingLayersMenu();
+    setupExistingLayersMenus();
     updateMenuStates();
 }
 
 void
 MainWindow::layerAboutToBeDeleted(Layer *layer)

             }
             if (!found) m_playSource->removeModel(model);
         }
     }
 
-    setupExistingLayersMenu();
+    setupExistingLayersMenus();
     updateMenuStates();
 }
 
 void
 MainWindow::modelAdded(Model *model)