comparison layer/LayerFactory.cpp @ 718:e5f4385615ac tony_integration

Merge from tonioni branch

 #include "SpectrogramLayer.h"
 #include "TimeRulerLayer.h"
 #include "TimeInstantLayer.h"
 #include "TimeValueLayer.h"
 #include "NoteLayer.h"
+#include "FlexiNoteLayer.h"
 #include "RegionLayer.h"
 #include "TextLayer.h"
 #include "ImageLayer.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"
 #include "data/model/NoteModel.h"
+#include "data/model/FlexiNoteModel.h"
 #include "data/model/RegionModel.h"
 #include "data/model/TextModel.h"
 #include "data/model/ImageModel.h"
 #include "data/model/DenseThreeDimensionalModel.h"
 #include "data/model/WaveFileModel.h"

     case Spectrogram:  return Layer::tr("Spectrogram");
     case TimeRuler:    return Layer::tr("Ruler");
     case TimeInstants: return Layer::tr("Time Instants");
     case TimeValues:   return Layer::tr("Time Values");
     case Notes:        return Layer::tr("Notes");
+    case FlexiNotes:   return Layer::tr("Flexible Notes");
     case Regions:      return Layer::tr("Regions");
     case Text:         return Layer::tr("Text");
     case Image:        return Layer::tr("Images");
     case Colour3DPlot: return Layer::tr("Colour 3D Plot");
     case Spectrum:     return Layer::tr("Spectrum");

 
     if (dynamic_cast<NoteModel *>(model)) {
 	types.insert(Notes);
     }
 
+	// NOTE: GF: types is a set, so order of insertion does not matter
+    if (dynamic_cast<FlexiNoteModel *>(model)) {
+	types.insert(FlexiNotes);
+    }
+
     if (dynamic_cast<RegionModel *>(model)) {
 	types.insert(Regions);
     }
 
     if (dynamic_cast<TextModel *>(model)) {

 LayerFactory::getValidEmptyLayerTypes()
 {
     LayerTypeSet types;
     types.insert(TimeInstants);
     types.insert(TimeValues);
+	types.insert(FlexiNotes);
     types.insert(Notes);
     types.insert(Regions);
     types.insert(Text);
     types.insert(Image);
     //!!! and in principle Colour3DPlot -- now that's a challenge

     if (dynamic_cast<const WaveformLayer *>(layer)) return Waveform;
     if (dynamic_cast<const SpectrogramLayer *>(layer)) return Spectrogram;
     if (dynamic_cast<const TimeRulerLayer *>(layer)) return TimeRuler;
     if (dynamic_cast<const TimeInstantLayer *>(layer)) return TimeInstants;
     if (dynamic_cast<const TimeValueLayer *>(layer)) return TimeValues;
+	if (dynamic_cast<const FlexiNoteLayer *>(layer)) return FlexiNotes;
     if (dynamic_cast<const NoteLayer *>(layer)) return Notes;
     if (dynamic_cast<const RegionLayer *>(layer)) return Regions;
     if (dynamic_cast<const TextLayer *>(layer)) return Text;
     if (dynamic_cast<const ImageLayer *>(layer)) return Image;
     if (dynamic_cast<const Colour3DPlotLayer *>(layer)) return Colour3DPlot;

     case Spectrogram: return "spectrogram";
     case TimeRuler: return "timeruler";
     case TimeInstants: return "instants";
     case TimeValues: return "values";
     case Notes: return "notes";
+    case FlexiNotes: return "flexible notes";
     case Regions: return "regions";
     case Text: return "text";
     case Image: return "image";
     case Colour3DPlot: return "colour3d";
     case Spectrum: return "spectrum";

     case Spectrogram: return "spectrogram";
     case TimeRuler: return "timeruler";
     case TimeInstants: return "timeinstants";
     case TimeValues: return "timevalues";
     case Notes: return "notes";
+    case FlexiNotes: return "flexinotes";
     case Regions: return "regions";
     case Text: return "text";
     case Image: return "image";
     case Colour3DPlot: return "colour3dplot";
     case Spectrum: return "spectrum";

     if (name == "waveform") return Waveform;
     if (name == "spectrogram") return Spectrogram;
     if (name == "timeruler") return TimeRuler;
     if (name == "timeinstants") return TimeInstants;
     if (name == "timevalues") return TimeValues;
-    if (name == "notes") return Notes;
+    if (name == "flexinotes") return FlexiNotes;
     if (name == "regions") return Regions;
     if (name == "text") return Text;
     if (name == "image") return Image;
     if (name == "colour3dplot") return Colour3DPlot;
     if (name == "spectrum") return Spectrum;

 void
 LayerFactory::setModel(Layer *layer, Model *model)
 {
 //    if (trySetModel<WaveformLayer, RangeSummarisableTimeValueModel>(layer, model))
 //	return;
-
+	
     if (trySetModel<WaveformLayer, WaveFileModel>(layer, model))
 	return;
 
     if (trySetModel<WaveformLayer, WritableWaveFileModel>(layer, model))
 	return;

 	return;
 
     if (trySetModel<TimeValueLayer, SparseTimeValueModel>(layer, model))
 	return;
 
-    if (trySetModel<NoteLayer, NoteModel>(layer, model))
-	return;
-
+    if (trySetModel<NoteLayer, NoteModel>(layer, model)) 
+	return; 
+
+	// GF: added FlexiNoteLayer
+    if (trySetModel<FlexiNoteLayer, FlexiNoteModel>(layer, model)) 
+	return; 
+	
     if (trySetModel<RegionLayer, RegionModel>(layer, model))
 	return;
 
     if (trySetModel<TextLayer, TextModel>(layer, model))
 	return;

 {
     if (layerType == TimeInstants) {
 	return new SparseOneDimensionalModel(baseModel->getSampleRate(), 1);
     } else if (layerType == TimeValues) {
 	return new SparseTimeValueModel(baseModel->getSampleRate(), 1, true);
+	} else if (layerType == FlexiNotes) {
+	return new FlexiNoteModel(baseModel->getSampleRate(), 1, true);
     } else if (layerType == Notes) {
 	return new NoteModel(baseModel->getSampleRate(), 1, true);
     } else if (layerType == Regions) {
 	return new RegionModel(baseModel->getSampleRate(), 1, true);
     } else if (layerType == Text) {

 	layer = new TimeInstantLayer;
 	break;
 
     case TimeValues:
 	layer = new TimeValueLayer;
+	break;
+
+    case FlexiNotes:
+	layer = new FlexiNoteLayer;
 	break;
 
     case Notes:
 	layer = new NoteLayer;
 	break;