    //=============================================================================
    //  Awl
    //  Audio Widget Library
    //  $Id:$
    //
    //  Copyright (C) 2002-2006 by Werner Schweer and others
    //
    //  This program is free software; you can redistribute it and/or modify
    //  it under the terms of the GNU General Public License version 2.
    //
    //  This program is distributed in the hope that it will be useful,
    //  but WITHOUT ANY WARRANTY; without even the implied warranty of
    //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    //  GNU General Public License for more details.
    //
    //  You should have received a copy of the GNU General Public License
    //  along with this program; if not, write to the Free Software
    //  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    //=============================================================================

    #include "knob.h"

    namespace Awl {

    //---------------------------------------------------------
    //   Knob
    ///   this is the AwlKnob contructor
    //---------------------------------------------------------

    Knob::Knob(QWidget* parent)
       : AbstractSlider(parent)
          {
          _scaleSize = 270;
          _markSize  = 6;
          _border    = 2;
          points     = 0;
          }

    //---------------------------------------------------------
    //   Knob
    //---------------------------------------------------------

    Knob::~Knob()
          {
          if (points)
                delete points;
          }

    //---------------------------------------------------------
    //   setText
    //---------------------------------------------------------

    void Knob::setText(const QString& s)
          {
          if (s != _text) {
                _text = s;
                update();
                }
          }

    //---------------------------------------------------------
    //   setScaleSize
    //!   set the scale size in degrees
    //
    //!   the scale size is the max moving angle measured
    //!   in degrees
    //---------------------------------------------------------

    void Knob::setScaleSize(int val)
          {
          if (val != _scaleSize) {
                _scaleSize = val;
                update();
                }
          }

    //---------------------------------------------------------
    //   setMarkSize
    //!   set size of the center marker
    //---------------------------------------------------------

    void Knob::setMarkSize(int val)
          {
          if (val != _markSize) {
                _markSize = val;
                update();
                }
          }

    //---------------------------------------------------------
    //   setBorder
    //!   set border size
    //---------------------------------------------------------

    void Knob::setBorder(int val)
          {
          if (val != _border) {
                _border = val;
                update();
                }
          }

    //---------------------------------------------------------
    //   mousePressEvent
    //---------------------------------------------------------

    void Knob::mousePressEvent(QMouseEvent* ev)
          {
          startY = ev->y();
          emit sliderPressed(_id);
          if (_center) {
                QRect r(points->boundingRect().toRect());
                if (r.contains(ev->pos())) {
                      setValue(.0f);
                      valueChange();
                      }
                }
          }

    //---------------------------------------------------------
    //   mouseReleaseEvent
    //---------------------------------------------------------

    void Knob::mouseReleaseEvent(QMouseEvent*)
          {
          emit sliderReleased(_id);
          }

    //---------------------------------------------------------
    //   mouseMoveEvent
    //---------------------------------------------------------

    void Knob::mouseMoveEvent(QMouseEvent* ev)
          {
          int y       = ev->y();
          double delta = (maxValue() - minValue()) / 100.0f;
          if (delta == 0)
                delta = 1;
          _value  += (startY - y) * delta;
          if (_value < minValue())
                _value = _minValue;
          else if (_value > maxValue())
                _value = _maxValue;
          startY    = y;
          valueChange();
          }

    //---------------------------------------------------------
    //   paintEvent
    //    r - phys coord system
    //---------------------------------------------------------

    void Knob::paintEvent(QPaintEvent* /*ev*/)
          {
    #if 0 // yet(?) unused
          QRect rr(ev->rect());
    #endif
          QPainter p(this);
          p.setRenderHint(QPainter::Antialiasing, true);

          int markSize2  = _markSize/2;
          int restR      = 360      - _scaleSize;
          int w          = width()  - _scaleWidth - 2 * _border;
          int h          = height() - _scaleWidth/2 - 2 * _border;

          int xoffset, yoffset;
          if (_center)
                h -= _markSize;
          if (w > h) {
                yoffset = 0;
                xoffset = (w - h) / 2;
                w = h;
                }
          else {
                xoffset = 0;
                // yoffset = (h - w) / 2;     // center
                yoffset = h - w;              // top align
                h = w;
                }

          int x = xoffset + _scaleWidth / 2 + _border;
          int y = yoffset + _scaleWidth / 2 + _border + (_center ? _markSize+_scaleWidth/2 : 0);
          QRectF ar(x, y, w, h);

          QColor sc(isEnabled() ? _scaleColor : Qt::gray);
          QColor svc(isEnabled() ? _scaleValueColor : Qt::gray);

          //-----------------------------------------
          // draw arc
          //-----------------------------------------

          double dvalue = maxValue() - minValue();
          if (_center) {
                int size = _scaleSize * 8;
                if (_value >= 0) {
                      int offset = (restR-180) * 8;
                      int r1 = int (size * _value / maxValue());
                      int r2 = size - r1;
                      p.setPen(QPen(sc, _scaleWidth));
                      if (r2 > 1)
                            p.drawArc(ar, offset, r2);
                      if (size > 1)
                            p.drawArc(ar, 90*16, size);
                      if (r1 > 1) {
                            p.setPen(QPen(svc, _scaleWidth));
                            p.drawArc(ar, offset+r2, r1);
                            }
                      }
                else {
                      // int offset = (restR+180) * 8;
                      int r1 = int(size * _value / minValue());
                      int r2 = size - r1;

                      p.setPen(QPen(sc, _scaleWidth));
                      if (size > 1)
                            p.drawArc(ar, (restR-180)*8, size);
                      if (r2 > 1)
                            p.drawArc(ar, 90 * 16 + r1, r2);
                      if (r1 > 1) {
                            p.setPen(QPen(svc, _scaleWidth));
                            p.drawArc(ar, 90*16, r1);
                            }
                      }
                }
          else {
                int offset = (180-restR) * 8;
                int size   = _scaleSize * 16;
                int r1     = int(size * (_value - minValue()) / dvalue);
                int r2     = size - r1;
                if (r2 >= 1) {
                      p.setPen(QPen(sc, _scaleWidth));
                      p.drawArc(ar, -offset, r2);
                      }
                if (r1 >= 1) {
                      p.setPen(QPen(svc, _scaleWidth));
                      p.drawArc(ar, r2-offset, r1);
                      }
                }

          //-----------------------------------------
          // draw pointer
          //-----------------------------------------

          p.setPen(QPen(svc, _scaleWidth));
          double r1 = double(_scaleSize) * (_value-minValue()) / dvalue + 90.0
                + double(restR/2);
          r1     = r1 / 180.0 * M_PI;   // convert to radians
          int rd = w/2;
          int x1 = x + rd;
          int y1 = y + rd;
          int x2 = x1 + lrint(cos(r1) * double(rd));
          int y2 = y1 + lrint(sin(r1) * double(rd));
          p.drawLine(x1, y1, x2, y2);

          //-----------------------------------------
          // draw center mark
          //-----------------------------------------

          p.setPen(QPen(svc, 0));
          p.setBrush(svc);
          if (_center) {
                if (points)
                      delete points;
                qreal x = ar.width() / 2 + ar.x();
                qreal y = ar.y() - _markSize - _scaleWidth/2;
                points = new QPainterPath(QPointF(x - markSize2, y));
                points->lineTo(x + markSize2, y);
                points->lineTo(x, _markSize + y);
                points->closeSubpath();
                p.drawPath(*points);
                }

          //-----------------------------------------
          // draw text
          //-----------------------------------------

          if (!_text.isEmpty()) {
                p.drawText(ar, Qt::AlignBottom | Qt::AlignHCenter, _text);
                }
          }
    }

↑ V636 The '_scaleWidth / 2' expression was implicitly cast from 'int' type to 'double' type. Consider utilizing an explicit type cast to avoid the loss of a fractional part. An example: double A = (double)(X) / Y;.

↑ V730 Not all members of a class are initialized inside the constructor. Consider inspecting: startY.