comparison layer/LayerFactory.cpp @ 133:9e6b3e239b9d

* Add zoom thumbwheels to Pane.  Implement horizontal thumbwheel, and
  vertical depending on layer type (supported for waveform and spectrogram,
  though wrong for log-scale spectrogram at the moment).
* Add bare bones of a spectrum layer.
* Add window icon
* Add shortcut for "insert time instant" on laptops without keypad enter (";")
* Delete FFT processing thread when it exits (at least, next time we're asked
  for something interesting)
* Get audio file extensions from the file readers, and thus from libsndfile for
  the wave file reader -- leads to rather a wide combo box in file dialog though
* Better refresh order for spectrogram (redraw centre section first)

 #include "TimeInstantLayer.h"
 #include "TimeValueLayer.h"
 #include "NoteLayer.h"
 #include "TextLayer.h"
 #include "Colour3DPlotLayer.h"
+#include "SpectrumLayer.h"
 
 #include "data/model/RangeSummarisableTimeValueModel.h"
 #include "data/model/DenseTimeValueModel.h"
 #include "data/model/SparseOneDimensionalModel.h"
 #include "data/model/SparseTimeValueModel.h"

     case TimeInstants: return Layer::tr("Time Instants");
     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 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

 	types.insert(Notes);
     }
 
     if (dynamic_cast<TextModel *>(model)) {
 	types.insert(Text);
+    }
+
+    if (dynamic_cast<DenseTimeValueModel *>(model)) {
+        types.insert(Spectrum);
     }
 
     // We don't count TimeRuler here as it doesn't actually display
     // the data, although it can be backed by any model
 

     if (dynamic_cast<const TimeInstantLayer *>(layer)) return 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;
     return UnknownLayer;
 }
 
 QString
 LayerFactory::getLayerIconName(LayerType type)

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

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

     if (name == "timeinstants") return TimeInstants;
     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;
     return UnknownLayer;
 }
 
 void
 LayerFactory::setModel(Layer *layer, Model *model)

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

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