comparison view/View.h @ 1406:a18e78b9c78b fix-static-analysis

Use override throughout

 
     /**
      * Retrieve the id of this object. Views have their own unique
      * ids, but ViewProxy objects share the id of their View.
      */
-    int getId() const { return m_id; }
+    int getId() const override { return m_id; }
     
     /**
      * Retrieve the first visible sample frame on the widget.
      * This is a calculated value based on the centre-frame, widget
      * width and zoom level.  The result may be negative.
      */
-    sv_frame_t getStartFrame() const;
+    sv_frame_t getStartFrame() const override;
 
     /**
      * Set the widget pan based on the given first visible frame.  The
      * frame value may be negative.
      */

      * Return the centre frame of the visible widget.  This is an
      * exact value that does not depend on the zoom block size.  Other
      * frame values (start, end) are calculated from this based on the
      * zoom and other factors.
      */
-    sv_frame_t getCentreFrame() const { return m_centreFrame; }
+    sv_frame_t getCentreFrame() const override { return m_centreFrame; }
 
     /**
      * Set the centre frame of the visible widget.
      */
     void setCentreFrame(sv_frame_t f) { setCentreFrame(f, true); }

     /**
      * Retrieve the last visible sample frame on the widget.
      * This is a calculated value based on the centre-frame, widget
      * width and zoom level.
      */
-    sv_frame_t getEndFrame() const;
+    sv_frame_t getEndFrame() const override;
 
     /**
      * Return the pixel x-coordinate corresponding to a given sample
      * frame. The frame is permitted to be negative, and the result
      * may be outside the currently visible area. But this should not
      * be called with frame values very far away from the currently
      * visible area, as that could lead to overflow. In that situation
      * an error will be logged and 0 returned.
      */
-    int getXForFrame(sv_frame_t frame) const;
+    int getXForFrame(sv_frame_t frame) const override;
 
     /**
      * Return the closest frame to the given pixel x-coordinate.
      */
-    sv_frame_t getFrameForX(int x) const;
+    sv_frame_t getFrameForX(int x) const override;
 
     /**
      * Return the closest pixel x-coordinate corresponding to a given
      * view x-coordinate. Default is no scaling, ViewProxy handles
      * scaling case.
      */
-    int getXForViewX(int viewx) const { return viewx; }
+    int getXForViewX(int viewx) const override { return viewx; }
 
     /**
      * Return the closest view x-coordinate corresponding to a given
      * pixel x-coordinate. Default is no scaling, ViewProxy handles
      * scaling case.
      */
-    int getViewXForX(int x) const { return x; }
+    int getViewXForX(int x) const override { return x; }
 
     /**
      * Return the pixel y-coordinate corresponding to a given
      * frequency, if the frequency range is as specified.  This does
      * not imply any policy about layer frequency ranges, but it might
      * be useful for layers to match theirs up if desired.
      *
      * Not thread-safe in logarithmic mode.  Call only from GUI thread.
      */
     double getYForFrequency(double frequency, double minFreq, double maxFreq, 
-                           bool logarithmic) const;
+                           bool logarithmic) const override;
 
     /**
      * Return the closest frequency to the given pixel y-coordinate,
      * if the frequency range is as specified.
      *
      * Not thread-safe in logarithmic mode.  Call only from GUI thread.
      */
     double getFrequencyForY(double y, double minFreq, double maxFreq,
-                            bool logarithmic) const;
+                            bool logarithmic) const override;
 
     /**
      * Return the zoom level, i.e. the number of frames per pixel or
      * pixels per frame
      */
-    ZoomLevel getZoomLevel() const;
+    ZoomLevel getZoomLevel() const override;
 
     /**
      * Set the zoom level, i.e. the number of frames per pixel or
      * pixels per frame.  The centre frame will be unchanged; the
      * start and end frames will change.

         return m_layerStack.empty() ? 0 : m_layerStack[m_layerStack.size()-1];
     }
 
     virtual void setViewManager(ViewManager *m);
     virtual void setViewManager(ViewManager *m, sv_frame_t initialFrame);
-    virtual ViewManager *getViewManager() const { return m_manager; }
+    ViewManager *getViewManager() const override { return m_manager; }
 
     virtual void setFollowGlobalPan(bool f);
     virtual bool getFollowGlobalPan() const { return m_followPan; }
 
     virtual void setFollowGlobalZoom(bool f);
     virtual bool getFollowGlobalZoom() const { return m_followZoom; }
 
-    virtual bool hasLightBackground() const;
-    virtual QColor getForeground() const;
-    virtual QColor getBackground() const;
-
-    virtual void drawMeasurementRect(QPainter &p, const Layer *,
-                                     QRect rect, bool focus) const;
-
-    virtual bool shouldShowFeatureLabels() const {
+    bool hasLightBackground() const override;
+    QColor getForeground() const override;
+    QColor getBackground() const override;
+
+    void drawMeasurementRect(QPainter &p, const Layer *,
+                                     QRect rect, bool focus) const override;
+
+    bool shouldShowFeatureLabels() const override {
         return m_manager && m_manager->shouldShowFeatureLabels();
     }
-    virtual bool shouldIlluminateLocalFeatures(const Layer *, QPoint &) const {
+    bool shouldIlluminateLocalFeatures(const Layer *, QPoint &) const override {
         return false;
     }
     virtual bool shouldIlluminateLocalSelection(QPoint &, bool &, bool &) const {
         return false;
     }

      * new SVG file.
      */
     virtual bool renderPartToSvgFile(QString filename,
                                      sv_frame_t f0, sv_frame_t f1);
     
-    virtual int getTextLabelHeight(const Layer *layer, QPainter &) const;
-
-    virtual bool getValueExtents(QString unit, double &min, double &max,
-                                 bool &log) const;
-
-    virtual void toXml(QTextStream &stream, QString indent = "",
-                       QString extraAttributes = "") const;
+    int getTextLabelHeight(const Layer *layer, QPainter &) const override;
+
+    bool getValueExtents(QString unit, double &min, double &max,
+                                 bool &log) const override;
+
+    void toXml(QTextStream &stream, QString indent = "",
+                       QString extraAttributes = "") const override;
 
     // First frame actually in model, to right of scale, if present
     virtual sv_frame_t getFirstVisibleFrame() const;
     virtual sv_frame_t getLastVisibleFrame() const;
 
-    sv_frame_t getModelsStartFrame() const;
-    sv_frame_t getModelsEndFrame() const;
+    sv_frame_t getModelsStartFrame() const override;
+    sv_frame_t getModelsEndFrame() const override;
 
     /**
      * To be called from a layer, to obtain the extent of the surface
      * that the layer is currently painting to. This may be the extent
      * of the view (if 1x display scaling is in effect) or of a larger
      * cached pixmap (if greater display scaling is in effect).
      */
-    QRect getPaintRect() const;
-
-    QSize getPaintSize() const { return getPaintRect().size(); }
-    int getPaintWidth() const { return getPaintRect().width(); }
-    int getPaintHeight() const { return getPaintRect().height(); }
-
-    double scaleSize(double size) const;
-    int scalePixelSize(int size) const;
-    double scalePenWidth(double width) const;
-    QPen scalePen(QPen pen) const;
+    QRect getPaintRect() const override;
+
+    QSize getPaintSize() const override { return getPaintRect().size(); }
+    int getPaintWidth() const override { return getPaintRect().width(); }
+    int getPaintHeight() const override { return getPaintRect().height(); }
+
+    double scaleSize(double size) const override;
+    int scalePixelSize(int size) const override;
+    double scalePenWidth(double width) const override;
+    QPen scalePen(QPen pen) const override;
 
     typedef std::set<Model *> ModelSet;
     ModelSet getModels();
 
     //!!!
     Model *getAligningModel() const;
     sv_frame_t alignFromReference(sv_frame_t) const;
     sv_frame_t alignToReference(sv_frame_t) const;
     sv_frame_t getAlignedPlaybackFrame() const;
 
-    void updatePaintRect(QRect r) { update(r); }
-    
-    View *getView() { return this; } 
-    const View *getView() const { return this; } 
+    void updatePaintRect(QRect r) override { update(r); }
+    
+    View *getView() override { return this; } 
+    const View *getView() const override { return this; } 
     
 signals:
     void propertyContainerAdded(PropertyContainer *pc);
     void propertyContainerRemoved(PropertyContainer *pc);
     void propertyContainerPropertyChanged(PropertyContainer *pc);

 protected:
     View(QWidget *, bool showProgress);
 
     int m_id;
     
-    virtual void paintEvent(QPaintEvent *e);
+    void paintEvent(QPaintEvent *e) override;
     virtual void drawSelections(QPainter &);
     virtual bool shouldLabelSelections() const { return true; }
     virtual void drawPlayPointer(QPainter &);
     virtual bool render(QPainter &paint, int x0, sv_frame_t f0, sv_frame_t f1);
     virtual void setPaintFont(QPainter &paint);

 
 public:
     ViewPropertyContainer(View *v);
     virtual ~ViewPropertyContainer();
 
-    PropertyList getProperties() const { return m_v->getProperties(); }
-    QString getPropertyLabel(const PropertyName &n) const {
+    PropertyList getProperties() const override { return m_v->getProperties(); }
+    QString getPropertyLabel(const PropertyName &n) const override {
         return m_v->getPropertyLabel(n);
     }
-    PropertyType getPropertyType(const PropertyName &n) const {
+    PropertyType getPropertyType(const PropertyName &n) const override {
         return m_v->getPropertyType(n);
     }
     int getPropertyRangeAndValue(const PropertyName &n, int *min, int *max,
-                                 int *deflt) const {
+                                 int *deflt) const override {
         return m_v->getPropertyRangeAndValue(n, min, max, deflt);
     }
-    QString getPropertyValueLabel(const PropertyName &n, int value) const {
+    QString getPropertyValueLabel(const PropertyName &n, int value) const override {
         return m_v->getPropertyValueLabel(n, value);
     }
-    QString getPropertyContainerName() const {
+    QString getPropertyContainerName() const override {
         return m_v->getPropertyContainerName();
     }
-    QString getPropertyContainerIconName() const {
+    QString getPropertyContainerIconName() const override {
         return m_v->getPropertyContainerIconName();
     }
 
 public slots:
-    virtual void setProperty(const PropertyName &n, int value) {
+    void setProperty(const PropertyName &n, int value) override {
         m_v->setProperty(n, value);
     }
 
 protected:
     View *m_v;