comparison layer/LayerFactory.cpp @ 193:57c2350a8c40

* 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 "TimeValueLayer.h"
 #include "NoteLayer.h"
 #include "TextLayer.h"
 #include "Colour3DPlotLayer.h"
 #include "SpectrumLayer.h"
+#include "SliceLayer.h"
+#include "SliceableLayer.h"
 
 #include "data/model/RangeSummarisableTimeValueModel.h"
 #include "data/model/DenseTimeValueModel.h"
 #include "data/model/SparseOneDimensionalModel.h"
 #include "data/model/SparseTimeValueModel.h"

     case TimeValues:   return Layer::tr("Time Values");
     case Notes:        return Layer::tr("Notes");
     case Text:         return Layer::tr("Text");
     case Colour3DPlot: return Layer::tr("Colour 3D Plot");
     case Spectrum:     return Layer::tr("Spectrum");
+    case Slice:        return Layer::tr("Time Slice");
 
     case MelodicRangeSpectrogram:
 	// The user can change all the parameters of this after the
 	// fact -- there's nothing permanently melodic-range about it
 	// that should be encoded in its name

     }
 
     return Layer::tr("Layer");
 }
 
+bool
+LayerFactory::isLayerSliceable(const Layer *layer)
+{
+    if (dynamic_cast<const SliceableLayer *>(layer)) {
+        if (dynamic_cast<const SpectrogramLayer *>(layer)) {
+
+            //!!! We can create slices of spectrograms, but there's a
+            // problem managing the models.  The source model for the
+            // slice layer has to be one of the spectrogram's FFT
+            // models -- that's fine, except that we can't store &
+            // recall the slice layer with a reference to that model
+            // because the model is internal to the spectrogram layer
+            // and the document has no record of it.  We would need
+            // some other way of managing models that are used in this
+            // way.  For the moment we just don't allow slices of
+            // spectrograms -- and provide a spectrum layer for this
+            // instead.
+            //
+            // This business needs a bit more thought -- either come
+            // up with a sensible way to deal with that stuff, or
+            // simplify the existing slice layer logic so that it
+            // doesn't have to deal with models disappearing on it at
+            // all (and use the normal Document setModel mechanism to
+            // set its sliceable model instead of the fancy pants
+            // nonsense it's doing at the moment).
+
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+
 LayerFactory::LayerTypeSet
 LayerFactory::getValidLayerTypes(Model *model)
 {
     LayerTypeSet types;
 
     if (dynamic_cast<DenseThreeDimensionalModel *>(model)) {
 	types.insert(Colour3DPlot);
+        types.insert(Slice);
+    }
+
+    if (dynamic_cast<RangeSummarisableTimeValueModel *>(model)) {
+	types.insert(Waveform);
     }
 
     if (dynamic_cast<DenseTimeValueModel *>(model)) {
 	types.insert(Spectrogram);
 	types.insert(MelodicRangeSpectrogram);
 	types.insert(PeakFrequencySpectrogram);
-    }
-
-    if (dynamic_cast<RangeSummarisableTimeValueModel *>(model)) {
-	types.insert(Waveform);
     }
 
     if (dynamic_cast<SparseOneDimensionalModel *>(model)) {
 	types.insert(TimeInstants);
     }

     if (dynamic_cast<const TimeValueLayer *>(layer)) return TimeValues;
     if (dynamic_cast<const NoteLayer *>(layer)) return Notes;
     if (dynamic_cast<const TextLayer *>(layer)) return Text;
     if (dynamic_cast<const Colour3DPlotLayer *>(layer)) return Colour3DPlot;
     if (dynamic_cast<const SpectrumLayer *>(layer)) return Spectrum;
+    if (dynamic_cast<const SliceLayer *>(layer)) return Slice;
     return UnknownLayer;
 }
 
 QString
 LayerFactory::getLayerIconName(LayerType type)

     case TimeValues: return "values";
     case Notes: return "notes";
     case Text: return "text";
     case Colour3DPlot: return "colour3d";
     case Spectrum: return "spectrum";
+    case Slice: return "spectrum";
     default: return "unknown";
     }
 }
 
 QString

     case TimeValues: return "timevalues";
     case Notes: return "notes";
     case Text: return "text";
     case Colour3DPlot: return "colour3dplot";
     case Spectrum: return "spectrum";
+    case Slice: return "slice";
     default: return "unknown";
     }
 }
 
 LayerFactory::LayerType

     if (name == "timevalues") return TimeValues;
     if (name == "notes") return Notes;
     if (name == "text") return Text;
     if (name == "colour3dplot") return Colour3DPlot;
     if (name == "spectrum") return Spectrum;
+    if (name == "slice") return Slice;
     return UnknownLayer;
 }
 
 void
 LayerFactory::setModel(Layer *layer, Model *model)

     if (trySetModel<SpectrogramLayer, DenseTimeValueModel>(layer, model))
 	return;
 
     if (trySetModel<SpectrumLayer, DenseTimeValueModel>(layer, model)) 
         return;
+
+//    if (trySetModel<SliceLayer, DenseThreeDimensionalModel>(layer, model)) 
+//        return;
 }
 
 Model *
 LayerFactory::createEmptyModel(LayerType layerType, Model *baseModel)
 {

 
     case Spectrum:
         layer = new SpectrumLayer;
         break;
 
+    case Slice:
+        layer = new SliceLayer;
+        break;
+
     case MelodicRangeSpectrogram: 
 	layer = new SpectrogramLayer(SpectrogramLayer::MelodicRange);
 	break;
 
     case PeakFrequencySpectrogram: