comparison layer/LayerFactory.cpp @ 30:ea6fe8cfcdd5

* Add the Note layer for pianoroll-type display of note-type data
* Complete the MIDI file importer (well, nearly -- it would be nice to
  be able to import the non-note data as other sorts of models, and that's
  not done yet).
* Minor refactoring in RealTime etc

 #include "WaveformLayer.h"
 #include "SpectrogramLayer.h"
 #include "TimeRulerLayer.h"
 #include "TimeInstantLayer.h"
 #include "TimeValueLayer.h"
+#include "NoteLayer.h"
 #include "Colour3DPlotLayer.h"
 
 #include "model/RangeSummarisableTimeValueModel.h"
 #include "model/DenseTimeValueModel.h"
 #include "model/SparseOneDimensionalModel.h"
 #include "model/SparseTimeValueModel.h"
+#include "model/NoteModel.h"
 #include "model/DenseThreeDimensionalModel.h"
 
 LayerFactory *
 LayerFactory::m_instance = new LayerFactory;
 

     case Waveform:     return Layer::tr("Waveform");
     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 Colour3DPlot: return Layer::tr("Colour 3D Plot");
 
     case MelodicRangeSpectrogram:
 	// The user can change all the parameters of this after the
 	// fact -- there's nothing permanently melodic-range about it

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

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

     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 NoteLayer *>(layer)) return Notes;
     if (dynamic_cast<const Colour3DPlotLayer *>(layer)) return Colour3DPlot;
     return UnknownLayer;
 }
 
 QString

     case Waveform: return "waveform";
     case Spectrogram: return "spectrogram";
     case TimeRuler: return "timeruler";
     case TimeInstants: return "instants";
     case TimeValues: return "values";
+    case Notes: return "notes";
     case Colour3DPlot: return "colour3d";
     default: return "unknown";
     }
 }
 

     case Waveform: return "waveform";
     case Spectrogram: return "spectrogram";
     case TimeRuler: return "timeruler";
     case TimeInstants: return "timeinstants";
     case TimeValues: return "timevalues";
+    case Notes: return "notes";
     case Colour3DPlot: return "colour3dplot";
     default: return "unknown";
     }
 }
 

     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 == "colour3dplot") return Colour3DPlot;
     return UnknownLayer;
 }
 
 void

 
     if (trySetModel<TimeInstantLayer, SparseOneDimensionalModel>(layer, model))
 	return;
 
     if (trySetModel<TimeValueLayer, SparseTimeValueModel>(layer, model))
+	return;
+
+    if (trySetModel<NoteLayer, NoteModel>(layer, model))
 	return;
 
     if (trySetModel<Colour3DPlotLayer, DenseThreeDimensionalModel>(layer, model))
 	return;
 

     if (layerType == TimeInstants) {
 	return new SparseOneDimensionalModel(baseModel->getSampleRate(), 1);
     } else if (layerType == TimeValues) {
 	return new SparseTimeValueModel(baseModel->getSampleRate(), 1,
 					0.0, 0.0, true);
+    } else if (layerType == Notes) {
+	return new NoteModel(baseModel->getSampleRate(), 1,
+			     0.0, 0.0, true);
     } else {
 	return 0;
     }
 }
 

 	layer = new TimeInstantLayer(view);
 	break;
 
     case TimeValues:
 	layer = new TimeValueLayer(view);
+	break;
+
+    case Notes:
+	layer = new NoteLayer(view);
 	break;
 
     case Colour3DPlot:
 	layer = new Colour3DPlotLayer(view);
 	break;