comparison layer/Colour3DPlotRenderer.cpp @ 1113:261a00010918 spectrogram-minor-refactor

Consts and willRenderOpaque

 //#define DEBUG_SPECTROGRAM_REPAINT 1
 
 using namespace std;
 
 Colour3DPlotRenderer::RenderResult
-Colour3DPlotRenderer::render(LayerGeometryProvider *v, QPainter &paint, QRect rect)
+Colour3DPlotRenderer::render(const LayerGeometryProvider *v, QPainter &paint, QRect rect)
 {
     return render(v, paint, rect, false);
 }
 
 Colour3DPlotRenderer::RenderResult
-Colour3DPlotRenderer::renderTimeConstrained(LayerGeometryProvider *v,
+Colour3DPlotRenderer::renderTimeConstrained(const LayerGeometryProvider *v,
                                             QPainter &paint, QRect rect)
 {
     return render(v, paint, rect, true);
 }
 

         return areaLeft;
     }
 }
 
 Colour3DPlotRenderer::RenderResult
-Colour3DPlotRenderer::render(LayerGeometryProvider *v,
+Colour3DPlotRenderer::render(const LayerGeometryProvider *v,
                              QPainter &paint, QRect rect, bool timeConstrained)
 {
     RenderType renderType = decideRenderType(v);
 
     if (renderType != DrawBufferPixelResolution) {

     
     //!!! should we own the Dense3DModelPeakCache here? or should it persist
 }
 
 Colour3DPlotRenderer::RenderType
-Colour3DPlotRenderer::decideRenderType(LayerGeometryProvider *v) const
+Colour3DPlotRenderer::decideRenderType(const LayerGeometryProvider *v) const
 {
     const DenseThreeDimensionalModel *model = m_sources.source;
     if (!model || !v || !(v->getViewManager())) {
         return DrawBufferPixelResolution; // or anything
     }

         return DrawBufferPixelResolution;
     }
 }
 
 void
-Colour3DPlotRenderer::renderDirectTranslucent(LayerGeometryProvider *v,
+Colour3DPlotRenderer::renderDirectTranslucent(const LayerGeometryProvider *v,
                                               QPainter &paint,
                                               QRect rect)
 {
 //!!!    QPoint illuminatePos;
 //    bool illuminate = v->shouldIlluminateLocalFeatures

     }
    
 }
 
 void
-Colour3DPlotRenderer::renderToCachePixelResolution(LayerGeometryProvider *v,
+Colour3DPlotRenderer::renderToCachePixelResolution(const LayerGeometryProvider *v,
                                                    int x0, int repaintWidth,
                                                    bool rightToLeft,
                                                    bool timeConstrained)
 {
     cerr << "renderToCachePixelResolution" << endl;

                       m_drawBuffer,
                       paintedLeft - x0, attainedWidth);
 }
 
 void
-Colour3DPlotRenderer::renderToCacheBinResolution(LayerGeometryProvider *v,
+Colour3DPlotRenderer::renderToCacheBinResolution(const LayerGeometryProvider *v,
                                                  int x0, int repaintWidth)
 {
     cerr << "renderToCacheBinResolution" << endl;
     
     // Draw to the draw buffer, and then scale-copy from there. Draw

 
     return columnCount;
 }
 
 int
-Colour3DPlotRenderer::renderDrawBufferPeakFrequencies(LayerGeometryProvider *v,
+Colour3DPlotRenderer::renderDrawBufferPeakFrequencies(const LayerGeometryProvider *v,
                                                       int w, int h,
                                                       const vector<int> &binforx,
                                                       const vector<double> &binfory,
                                                       bool rightToLeft,
                                                       bool timeConstrained)