comparison base/Layer.h @ 36:935a2419a77c

* Refactor Layer classes so as no longer to store a single View pointer;
  instead they need to be able to draw themselves on any View on demand.
  Layers with caches (e.g. spectrogram) will need to be further refactored
  so as to maintain a per-View cache

* Begin refactoring MainWindow by pulling out the document stuff (set of
  layers, models etc) into a Document class.  Not yet in use.

This revision is fairly unstable.

 	      public XmlExportable
 {
     Q_OBJECT
 
 public:
-    Layer(View *w);
+    Layer();
     virtual ~Layer();
 
     virtual const Model *getModel() const = 0;
-    virtual const View *getView() const { return m_view; }
     virtual const ZoomConstraint *getZoomConstraint() const { return 0; }
-    virtual void paint(QPainter &, QRect) const = 0;   
+    virtual void paint(View *, QPainter &, QRect) const = 0;   
 
     enum VerticalPosition {
 	PositionTop, PositionMiddle, PositionBottom
     };
     virtual VerticalPosition getPreferredTimeRulerPosition() const {

 
     virtual QString getPropertyContainerName() const {
 	return objectName();
     }
 
-    virtual int getVerticalScaleWidth(QPainter &) const { return 0; }
-    virtual void paintVerticalScale(QPainter &, QRect) const { }
-
-    virtual QString getFeatureDescription(QPoint &) const {
+    virtual int getVerticalScaleWidth(View *, QPainter &) const { return 0; }
+    virtual void paintVerticalScale(View *, QPainter &, QRect) const { }
+
+    virtual QString getFeatureDescription(View *, QPoint &) const {
 	return "";
     }
 
     //!!! We also need a method (like the vertical scale method) for
     //drawing additional scales like a colour scale.  That is, unless

      * Return true if a suitable feature was found and frame adjusted
      * accordingly.  Return false if no suitable feature was
      * available.  Also return the resolution of the model in this
      * layer in sample frames.
      */
-    virtual bool snapToFeatureFrame(int &frame,
+    virtual bool snapToFeatureFrame(View *v,
+				    int &frame,
 				    size_t &resolution,
 				    SnapType snap) const {
 	resolution = 1;
 	return false;
     }

     // Draw and edit modes:
     //
     // Layer needs to get actual mouse events, I guess.  Draw mode is
     // probably the easier.
 
-    virtual void drawStart(QMouseEvent *) { }
-    virtual void drawDrag(QMouseEvent *) { }
-    virtual void drawEnd(QMouseEvent *) { }
-
-    virtual void editStart(QMouseEvent *) { }
-    virtual void editDrag(QMouseEvent *) { }
-    virtual void editEnd(QMouseEvent *) { }
-
-    virtual void editOpen(QMouseEvent *) { } // on double-click
+    virtual void drawStart(View *, QMouseEvent *) { }
+    virtual void drawDrag(View *, QMouseEvent *) { }
+    virtual void drawEnd(View *, QMouseEvent *) { }
+
+    virtual void editStart(View *, QMouseEvent *) { }
+    virtual void editDrag(View *, QMouseEvent *) { }
+    virtual void editEnd(View *, QMouseEvent *) { }
+
+    virtual void editOpen(View *, QMouseEvent *) { } // on double-click
 
     virtual void moveSelection(Selection s, size_t newStartFrame) { }
     virtual void resizeSelection(Selection s, Selection newSize) { }
     virtual void deleteSelection(Selection s) { }
 

     // and current label from the layer, and then the pane can pop up
     // a little text entry dialog at the right location.  Or we edit
     // in place?  Probably the dialog is easier.
 
     /**
-     * This should return true if the view can safely be scrolled
-     * automatically by the widget (simply copying the existing data
+     * This should return true if the layer can safely be scrolled
+     * automatically by a given view (simply copying the existing data
      * and then refreshing the exposed area) without altering its
-     * meaning.  For the widget as a whole this is usually not
+     * meaning.  For the view widget as a whole this is usually not
      * possible because of invariant (non-scrolling) material
      * displayed over the top, but the widget may be able to optimise
      * scrolling better if it is known that individual views can be
      * scrolled safely in this way.
      */
-    virtual bool isLayerScrollable() const { return true; }
+    virtual bool isLayerScrollable(const View *) const { return true; }
 
     /**
      * This should return true if the layer completely obscures any
      * underlying layers.  It's used to determine whether the view can
      * safely draw any selection rectangles under the layer instead of

 
     /**
      * Return the pixel x-coordinate corresponding to a given sample
      * frame (which may be negative).
      */
-    int getXForFrame(long frame) const;
+//    int getXForFrame(long frame) const;
 
     /**
      * Return the closest frame to the given pixel x-coordinate.
      */
-    long getFrameForX(int x) const;
+//    long getFrameForX(int x) const;
 
     /**
      * Convert the layer's data (though not those of the model it
      * refers to) into an XML string for file output.  This class
      * implements the basic name/type/model-id output; subclasses will

      * layer may respond by (for example) freeing any cache memory it
      * is using, until next time its paint method is called.  It does
      * not need to remember not to draw itself; the view will handle
      * that.
      */
-    virtual void setLayerDormant(bool dormant) { m_dormant = dormant; }
+    //!!! update for multiview
+    virtual void setLayerDormant(const View *, bool dormant) { m_dormant = dormant; }
 
     /**
      * Return whether the layer is dormant (i.e. hidden).
      */
-    virtual bool isLayerDormant() const { return m_dormant; }
+    //!!! update for multiview
+    virtual bool isLayerDormant(const View *) const { return m_dormant; }
 
     virtual PlayParameters *getPlayParameters();
 
 public slots:
-    void showLayer(bool show);
+    //!!! update for multiview
+    void showLayer(View *, bool show);
 
 signals:
     void modelChanged();
     void modelCompletionChanged();
     void modelChanged(size_t startFrame, size_t endFrame);

 
     void layerParametersChanged();
     void layerNameChanged();
 
 protected:
-    View *m_view;
+//    View *m_view;
     bool m_dormant;
 };
 
 #endif