comparison layer/LayerFactory.cpp @ 18:d8e6709e9075

add
- EasaierSessionManager
- Easaier menus
- Interval model

 #include "TextLayer.h"
 #include "Colour3DPlotLayer.h"
 #include "SpectrumLayer.h"
 #include "SliceLayer.h"
 #include "SliceableLayer.h"
+#include "IntervalLayer.h"
 
 #include "data/model/RangeSummarisableTimeValueModel.h"
 #include "data/model/DenseTimeValueModel.h"
 #include "data/model/SparseOneDimensionalModel.h"
 #include "data/model/SparseTimeValueModel.h"
 #include "data/model/NoteModel.h"
 #include "data/model/TextModel.h"
 #include "data/model/DenseThreeDimensionalModel.h"
 #include "data/model/WaveFileModel.h"
 #include "data/model/WritableWaveFileModel.h"
+#include "data/model/IntervalModel.h"
 
 LayerFactory *
 LayerFactory::m_instance = new LayerFactory;
 
 LayerFactory *

 	return Layer::tr("Spectrogram");
 
     case PeakFrequencySpectrogram:
 	// likewise
 	return Layer::tr("Spectrogram");
+
+	case Interval:		return Layer::tr("Interval");
 
     default: break;
     }
 
     return Layer::tr("Layer");

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

     LayerTypeSet types;
     types.insert(TimeInstants);
     types.insert(TimeValues);
     types.insert(Notes);
     types.insert(Text);
+	types.insert(Interval);
     //!!! and in principle Colour3DPlot -- now that's a challenge
     return types;
 }
 
 LayerFactory::LayerType

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

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

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

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

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

 	return new SparseTimeValueModel(baseModel->getSampleRate(), 1, true);
     } else if (layerType == Notes) {
 	return new NoteModel(baseModel->getSampleRate(), 1, true);
     } else if (layerType == Text) {
 	return new TextModel(baseModel->getSampleRate(), 1, true);
+    } else if (layerType == Interval) {
+	return new IntervalModel(baseModel->getSampleRate(), 1, true);
     } else {
 	return 0;
     }
 }
 

 	layer = new SpectrogramLayer(SpectrogramLayer::MelodicRange);
 	break;
 
     case PeakFrequencySpectrogram: 
 	layer = new SpectrogramLayer(SpectrogramLayer::MelodicPeaks);
+	break;
+
+	case Interval: 
+	layer = new IntervalLayer;
 	break;
 
     default: break;
     }