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

Consts and willRenderOpaque

      * std::logic_error exception. The model must be ready and the
      * layer requesting the render must not be dormant in its view, so
      * that the LayerGeometryProvider returns valid results; it is the
      * caller's responsibility to ensure these.
      */
-    RenderResult render(LayerGeometryProvider *v, QPainter &paint, QRect rect);
+    RenderResult render(const LayerGeometryProvider *v, QPainter &paint, QRect rect);
     
     /**
      * Render the requested area using the given painter, obtaining
      * geometry (e.g. start frame) from the stored
      * LayerGeometryProvider.

      * std::logic_error exception. The model must be ready and the
      * layer requesting the render must not be dormant in its view, so
      * that the LayerGeometryProvider returns valid results; it is the
      * caller's responsibility to ensure these.
      */
-    RenderResult renderTimeConstrained(LayerGeometryProvider *v,
+    RenderResult renderTimeConstrained(const LayerGeometryProvider *v,
                                        QPainter &paint, QRect rect);
 
     /**
      * Return the area of the largest rectangle within the entire area
      * of the cache that is unavailable in the cache. This is only

      * cleared).
      *
      * Returns an empty QRect if the cache is entirely valid.
      */
     QRect getLargestUncachedRect();
+
+    /**
+     * Return true if the rendering will be opaque. This may be used
+     * by the calling layer to determine whether it can scroll
+     * directly without regard to any other layers beneath.
+     */
+    bool willRenderOpaque(const LayerGeometryProvider *v) {
+        return decideRenderType(v) != DirectTranslucent;
+    }
     
 private:
     Sources m_sources;
     Parameters m_params;
 

     // carried out by repainting to cache (via the draw buffer) any
     // area that is being requested but is not valid in the cache, and
     // then repainting from cache to the requested painter.
     ScrollableImageCache m_cache;
 
-    RenderResult render(LayerGeometryProvider *v,
+    RenderResult render(const LayerGeometryProvider *v,
                         QPainter &paint, QRect rect, bool timeConstrained);
 
-    void renderDirectTranslucent(LayerGeometryProvider *v,
+    void renderDirectTranslucent(const LayerGeometryProvider *v,
                                  QPainter &paint, QRect rect);
     
-    void renderToCachePixelResolution(LayerGeometryProvider *v, int x0,
+    void renderToCachePixelResolution(const LayerGeometryProvider *v, int x0,
                                       int repaintWidth, bool rightToLeft,
                                       bool timeConstrained);
 
-    void renderToCacheBinResolution(LayerGeometryProvider *v, int x0,
+    void renderToCacheBinResolution(const LayerGeometryProvider *v, int x0,
                                     int repaintWidth);
 
     int renderDrawBuffer(int w, int h,
                          const std::vector<int> &binforx,
                          const std::vector<double> &binfory,
                          bool usePeaksCache,
                          bool rightToLeft,
                          bool timeConstrained);
 
-    int renderDrawBufferPeakFrequencies(LayerGeometryProvider *v,
+    int renderDrawBufferPeakFrequencies(const LayerGeometryProvider *v,
                                         int w, int h,
                                         const std::vector<int> &binforx,
                                         const std::vector<double> &binfory,
                                         bool rightToLeft,
                                         bool timeConstrained);

         DrawBufferPixelResolution,
         DrawBufferBinResolution,
         DirectTranslucent
     };
 
-    RenderType decideRenderType(LayerGeometryProvider *) const;
+    RenderType decideRenderType(const LayerGeometryProvider *) const;
 };
 
 #endif