    //=============================================================================
    //  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 "fastlog.h"
    #include "aslider.h"

    namespace Awl {

    //---------------------------------------------------------
    //   AbstractSlider
    //---------------------------------------------------------

    AbstractSlider::AbstractSlider(QWidget* parent)
       : QWidget(parent), _scaleColor(Qt::darkGray), _scaleValueColor(QColor("#2456aa"))
          {
          _id         = 0;
          _value      = 0.5;
          _minValue   = 0.0;
          _maxValue   = 1.0;
          _lineStep   = 0.1;
          _pageStep   = 0.2;
          _center     = false;
          _invert     = false;
          _scaleWidth = 4;
          _log        = false;
          _useActualValue = false;
          setFocusPolicy(Qt::StrongFocus);
          }

    //---------------------------------------------------------
    //   setEnabled
    //---------------------------------------------------------

    void AbstractSlider::setEnabled(bool val)
          {
          QWidget::setEnabled(val);
          update();
          }

    //---------------------------------------------------------
    //   setCenter
    //!   If the center flag is set, a notch is drawn to
    //!   show the center position.
    //---------------------------------------------------------

    void AbstractSlider::setCenter(bool val)
          {
          if (val != _center) {
                _center = val;
                update();
                }
          }

    //!--------------------------------------------------------
    //   setScaleWidth
    //---------------------------------------------------------

    void AbstractSlider::setScaleWidth(int val)
          {
          if (val != _scaleWidth) {
                _scaleWidth = val;
                update();
                }
          }

    //---------------------------------------------------------
    //   setScaleColor
    //---------------------------------------------------------

    void AbstractSlider::setScaleColor(const QColor& c)
          {
          if (c != _scaleColor) {
                _scaleColor = c;
                update();
                }
          }

    //---------------------------------------------------------
    //   setScaleValueColor
    //---------------------------------------------------------

    void AbstractSlider::setScaleValueColor(const QColor& c)
          {
          if (c != _scaleValueColor) {
                _scaleValueColor = c;
                update();
                }
          }

    //---------------------------------------------------------
    //   wheelEvent
    //---------------------------------------------------------

    void AbstractSlider::wheelEvent(QWheelEvent* ev)
          {
          int div = 50;
          if (ev->modifiers() & Qt::ShiftModifier)
                div = 15;
          _value += (ev->delta() * lineStep()) / div;
          if (_value < _minValue)
                _value = _minValue;
          else if (_value > _maxValue)
                _value = _maxValue;
          valueChange();
          }

    //---------------------------------------------------------
    //   keyPressEvent
    //---------------------------------------------------------

    void AbstractSlider::keyPressEvent(QKeyEvent* ev)
          {
          double oval = _value;

          switch (ev->key()) {
                case Qt::Key_Home:      _value = _minValue; break;
                case Qt::Key_End:       _value = _maxValue; break;
                case Qt::Key_Up:
                case Qt::Key_Left:      _value += lineStep(); break;
                case Qt::Key_Down:
                case Qt::Key_Right:     _value -= lineStep(); break;
                case Qt::Key_PageDown:  _value -= pageStep(); break;
                case Qt::Key_PageUp:    _value += pageStep(); break;
                case Qt::Key_Delete:
                case Qt::Key_Backspace: _value = ev->modifiers() & Qt::ShiftModifier ? dclickValue2() : dclickValue1(); break;
                default:
                      break;
                }
          if (_value < _minValue)
                _value = _minValue;
          else if (_value > _maxValue)
                _value = _maxValue;
          if (oval != _value)
                valueChange();
          }

    //---------------------------------------------------------
    //   mouseDoubleClickEvent
    //---------------------------------------------------------

    void AbstractSlider::mouseDoubleClickEvent(QMouseEvent* ev)
          {
          if (ev->button() == Qt::RightButton)
                _value = _dclickValue2;
          else
                _value = _dclickValue1;
          valueChange();
          }

    //---------------------------------------------------------
    //   setValue
    //---------------------------------------------------------

    void AbstractSlider::setValue(double val)
          {
          if (_log) {
                if (val == 0.0f)
                      _value = _minValue;
                else {
                      _value = fast_log10(val) * 20.0f;
                      if (_value < _minValue)
                            _value = _minValue;
                      }
                }
          else
                _value = val;
          update();
          }

    //---------------------------------------------------------
    //   valueChange
    //---------------------------------------------------------

    void AbstractSlider::valueChange()
          {
          emit valueChanged(value(), _id);
          update();
          }

    //---------------------------------------------------------
    //   value
    //---------------------------------------------------------

    double AbstractSlider::value() const
          {
          return _log ? pow(10.0, _value*0.05f) : _value;
          }

    //---------------------------------------------------------
    //   userValue (between 0 and 100)
    //---------------------------------------------------------

    QString AbstractSlider::userValue() const
          {
          double result;
          if (_useActualValue)
                result = value();
          else
                result = (_value - minValue())/ ((maxValue() - minValue())/100);

          return QString::number(result, 'f', 2);
          }

    //---------------------------------------------------------
    //   minLogValue
    //---------------------------------------------------------

    //double AbstractSlider::minValue() const {
    //  return _log ? pow(10.0, _minValue*0.05f) : _minValue;
    //}

    //---------------------------------------------------------
    //   setMinLogValue
    //---------------------------------------------------------

    void AbstractSlider::setMinLogValue(double val)
          {
          if (_log) {
                if (val == 0.0f)
                      _minValue = -100;
                else
                      _minValue = fast_log10(val) * 20.0f;
                }
          else
                _minValue = val;
          }

    //---------------------------------------------------------
    //   maxLogValue
    //---------------------------------------------------------

    //double AbstractSlider::maxValue() const {
    //  return _log ? pow(10.0, _maxValue*0.05f) : _maxValue;
    //}

    //---------------------------------------------------------
    //   setMaxLogValue
    //---------------------------------------------------------

    void AbstractSlider::setMaxLogValue(double val)
          {
          if (_log) {
                _maxValue = fast_log10(val) * 20.0f;
                }
          else
                _maxValue = val;
          }

    #if 0
    //---------------------------------------------------------
    //   init
    //---------------------------------------------------------

    void AbstractSlider::init(const SyntiParameter& f)
          {
          _minValue = f.min();
          _maxValue = f.max();
          _value    = f.fval();
          _lineStep   = (_maxValue - _minValue) * 0.1;
          _pageStep   = _lineStep * 2.0;
          }
    #endif

    AccessibleAbstractSlider::AccessibleAbstractSlider(AbstractSlider* s) : QAccessibleWidget(s)
          {
          slider = s;
          }

    QAccessible::Role AccessibleAbstractSlider::role() const
          {
          return QAccessible::Slider;
          }

    QString AccessibleAbstractSlider::text(QAccessible::Text t) const
          {
          switch (t) {
                case QAccessible::Name:
                      return slider->accessibleName();
                case QAccessible::Value:
                      return slider->userValue();
                case QAccessible::Description:
                      return slider->accessibleDescription();
                default:
                      return QString();
                }
          return QString();
          }

    void AccessibleAbstractSlider::valueChanged(double, int)
          {
          QAccessibleValueChangeEvent ev(slider, slider->userValue());
          QAccessible::updateAccessibility(&ev);
          }

    QAccessibleInterface* AccessibleAbstractSlider::AbstractSliderFactory(const QString& /*classname*/, QObject *object)
          {
          QAccessibleInterface *iface = 0;
          if (object && object->isWidgetType() && object->inherits("Awl::AbstractSlider")){
                AbstractSlider* slider = static_cast<AbstractSlider*>(object);
                AccessibleAbstractSlider* acc = new AccessibleAbstractSlider(slider);
                QObject::connect(slider, SIGNAL(valueChanged(double,int)), acc, SLOT(valueChanged(double,int)));
                iface = static_cast<QAccessibleInterface*>(acc);
                }

          return iface;
          }
    }

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