Changeset 26712 in vbox for trunk/src/VBox/Frontends

Timestamp:

Feb 23, 2010 2:39:23 PM (15 years ago)

Author:

vboxsync

Message:

FE/Qt4: coding style

Location:

trunk/src/VBox/Frontends/VirtualBox/src/extensions

Files:

• QIAdvancedSlider.cpp (modified) (3 diffs)
• QIAdvancedSlider.h (modified) (2 diffs)

trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIAdvancedSlider.cpp

@@ +1 @@
+/* $Id$ */
 /** @file
  *
@@ -6 +7 @@
 
 /*
- * Copyright (C) 2009 Sun Microsystems, Inc.
+ * Copyright (C) 2009-2010 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -36 +37 @@
 {
 public:
-    CPrivateSlider (Qt::Orientation aOrientation, QWidget *aParent = 0)
-      : QSlider (aOrientation, aParent)
-      , mOptColor (0x0, 0xff, 0x0, 0x3c)
-      , mWrnColor (0xff, 0x54, 0x0, 0x3c)
-      , mErrColor (0xff, 0x0, 0x0, 0x3c)
-      , mMinOpt (-1)
-      , mMaxOpt (-1)
-      , mMinWrn (-1)
-      , mMaxWrn (-1)
-      , mMinErr (-1)
-      , mMaxErr (-1)
+    CPrivateSlider(Qt::Orientation fOrientation, QWidget *pParent = 0)
+      : QSlider(fOrientation, pParent)
+      , m_optColor(0x0, 0xff, 0x0, 0x3c)
+      , m_wrnColor(0xff, 0x54, 0x0, 0x3c)
+      , m_errColor(0xff, 0x0, 0x0, 0x3c)
+      , m_minOpt(-1)
+      , m_maxOpt(-1)
+      , m_minWrn(-1)
+      , m_maxWrn(-1)
+      , m_minErr(-1)
+      , m_maxErr(-1)
     {}
 
-    int positionForValue (int aVal) const
+    int positionForValue(int val) const
     {
         QStyleOptionSlider opt;
-        initStyleOption (&opt);
+        initStyleOption(&opt);
         opt.subControls = QStyle::SC_All;
-        int available = opt.rect.width() - style()->pixelMetric (QStyle::PM_SliderLength, &opt, this);
-        return QStyle::sliderPositionFromValue (opt.minimum, opt.maximum, aVal, available);
+        int available = opt.rect.width() - style()->pixelMetric(QStyle::PM_SliderLength, &opt, this);
+        return QStyle::sliderPositionFromValue(opt.minimum, opt.maximum, val, available);
     }
 
-    virtual void paintEvent (QPaintEvent *aEvent)
+    virtual void paintEvent(QPaintEvent *pEvent)
     {
         QPainter p(this);
 
         QStyleOptionSlider opt;
-        initStyleOption (&opt);
+        initStyleOption(&opt);
         opt.subControls = QStyle::SC_All;
 
-        int available = opt.rect.width() - style()->pixelMetric (QStyle::PM_SliderLength, &opt, this);
+        int available = opt.rect.width() - style()->pixelMetric(QStyle::PM_SliderLength, &opt, this);
         QSize s = size();
 
-        QRect ticks = style()->subControlRect (QStyle::CC_Slider, &opt, QStyle::SC_SliderTickmarks, this);
+        QRect ticks = style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderTickmarks, this);
 #ifdef Q_WS_MAC
-        ticks.setRect ((s.width() - available) / 2, s.height() - ticks.y(), available, ticks.height());
+        ticks.setRect((s.width() - available) / 2, s.height() - ticks.y(), available, ticks.height());
 #else /* Q_WS_MAC */
         if (ticks.isNull() || ticks.isEmpty())
         {
-            ticks = style()->subControlRect (QStyle::CC_Slider, &opt, QStyle::SC_SliderHandle, this) | style()->subControlRect (QStyle::CC_Slider, &opt, QStyle::SC_SliderGroove, this);
-            ticks.setRect ((s.width() - available) / 2, ticks.bottom() + 1, available, s.height() - ticks.bottom() - 1);
+            ticks = style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderHandle, this) | style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderGroove, this);
+            ticks.setRect((s.width() - available) / 2, ticks.bottom() + 1, available, s.height() - ticks.bottom() - 1);
         }
 #endif /* Q_WS_MAC */
-        if ((mMinOpt != -1 &&
-             mMaxOpt != -1) &&
-            mMinOpt != mMaxOpt)
-        {
-            int posMinOpt = QStyle::sliderPositionFromValue (opt.minimum, opt.maximum, mMinOpt, available);
-            int posMaxOpt = QStyle::sliderPositionFromValue (opt.minimum, opt.maximum, mMaxOpt, available);
-            p.fillRect (ticks.x() + posMinOpt, ticks.y(), posMaxOpt - posMinOpt + 1, ticks.height(), mOptColor);
-        }
-        if ((mMinWrn != -1 &&
-             mMaxWrn != -1) &&
-            mMinWrn != mMaxWrn)
-        {
-            int posMinWrn = QStyle::sliderPositionFromValue (opt.minimum, opt.maximum, mMinWrn, available);
-            int posMaxWrn = QStyle::sliderPositionFromValue (opt.minimum, opt.maximum, mMaxWrn, available);
-            p.fillRect (ticks.x() + posMinWrn, ticks.y(), posMaxWrn - posMinWrn + 1, ticks.height(), mWrnColor);
-        }
-        if ((mMinErr != -1 &&
-             mMaxErr != -1) &&
-            mMinErr != mMaxErr)
-        {
-            int posMinErr = QStyle::sliderPositionFromValue (opt.minimum, opt.maximum, mMinErr, available);
-            int posMaxErr = QStyle::sliderPositionFromValue (opt.minimum, opt.maximum, mMaxErr, available);
-            p.fillRect (ticks.x() + posMinErr, ticks.y(), posMaxErr - posMinErr + 1, ticks.height(), mErrColor);
+        if ((m_minOpt != -1 &&
+             m_maxOpt != -1) &&
+            m_minOpt != m_maxOpt)
+        {
+            int posMinOpt = QStyle::sliderPositionFromValue(opt.minimum, opt.maximum, m_minOpt, available);
+            int posMaxOpt = QStyle::sliderPositionFromValue(opt.minimum, opt.maximum, m_maxOpt, available);
+            p.fillRect(ticks.x() + posMinOpt, ticks.y(), posMaxOpt - posMinOpt + 1, ticks.height(), m_optColor);
+        }
+        if ((m_minWrn != -1 &&
+             m_maxWrn != -1) &&
+            m_minWrn != m_maxWrn)
+        {
+            int posMinWrn = QStyle::sliderPositionFromValue(opt.minimum, opt.maximum, m_minWrn, available);
+            int posMaxWrn = QStyle::sliderPositionFromValue(opt.minimum, opt.maximum, m_maxWrn, available);
+            p.fillRect(ticks.x() + posMinWrn, ticks.y(), posMaxWrn - posMinWrn + 1, ticks.height(), m_wrnColor);
+        }
+        if ((m_minErr != -1 &&
+             m_maxErr != -1) &&
+            m_minErr != m_maxErr)
+        {
+            int posMinErr = QStyle::sliderPositionFromValue(opt.minimum, opt.maximum, m_minErr, available);
+            int posMaxErr = QStyle::sliderPositionFromValue(opt.minimum, opt.maximum, m_maxErr, available);
+            p.fillRect(ticks.x() + posMinErr, ticks.y(), posMaxErr - posMinErr + 1, ticks.height(), m_errColor);
         }
         p.end();
 
-        QSlider::paintEvent (aEvent);
+        QSlider::paintEvent(pEvent);
     }
 
-    QColor mOptColor;
-    QColor mWrnColor;
-    QColor mErrColor;
-
-    int mMinOpt;
-    int mMaxOpt;
-    int mMinWrn;
-    int mMaxWrn;
-    int mMinErr;
-    int mMaxErr;
+    QColor m_optColor;
+    QColor m_wrnColor;
+    QColor m_errColor;
+
+    int m_minOpt;
+    int m_maxOpt;
+    int m_minWrn;
+    int m_maxWrn;
+    int m_minErr;
+    int m_maxErr;
 };
 
-QIAdvancedSlider::QIAdvancedSlider (QWidget *aParent /* = 0 */)
-  : QWidget (aParent)
+QIAdvancedSlider::QIAdvancedSlider(QWidget *pParent /* = 0 */)
+  : QWidget(pParent)
 {
     init();
 }
 
-QIAdvancedSlider::QIAdvancedSlider (Qt::Orientation aOrientation, QWidget *aParent /* = 0 */)
-  : QWidget (aParent)
-{
-    init (aOrientation);
+QIAdvancedSlider::QIAdvancedSlider(Qt::Orientation fOrientation, QWidget *pParent /* = 0 */)
+  : QWidget(pParent)
+{
+    init(fOrientation);
 }
 
 int QIAdvancedSlider::value() const
 {
-    return mSlider->value();
-}
-
-void QIAdvancedSlider::setRange (int aMinV, int aMaxV)
-{
-    mSlider->setRange (aMinV, aMaxV);
-}
-
-void QIAdvancedSlider::setMaximum (int aVal)
-{
-    mSlider->setMaximum (aVal);
+    return m_pSlider->value();
+}
+
+void QIAdvancedSlider::setRange(int minV, int maxV)
+{
+    m_pSlider->setRange(minV, maxV);
+}
+
+void QIAdvancedSlider::setMaximum(int val)
+{
+    m_pSlider->setMaximum(val);
 }
 
 int QIAdvancedSlider::maximum() const
 {
-    return mSlider->maximum();
-}
-
-void QIAdvancedSlider::setMinimum (int aVal)
-{
-    mSlider->setMinimum (aVal);
+    return m_pSlider->maximum();
+}
+
+void QIAdvancedSlider::setMinimum(int val)
+{
+    m_pSlider->setMinimum(val);
 }
 
 int QIAdvancedSlider::minimum() const
 {
-    return mSlider->minimum();
-}
-
-void QIAdvancedSlider::setPageStep (int aVal)
-{
-    mSlider->setPageStep (aVal);
+    return m_pSlider->minimum();
+}
+
+void QIAdvancedSlider::setPageStep(int val)
+{
+    m_pSlider->setPageStep(val);
 }
 
 int QIAdvancedSlider::pageStep() const
 {
-    return mSlider->pageStep();
-}
-
-void QIAdvancedSlider::setSingleStep (int aVal)
-{
-    mSlider->setSingleStep (aVal);
+    return m_pSlider->pageStep();
+}
+
+void QIAdvancedSlider::setSingleStep(int val)
+{
+    m_pSlider->setSingleStep(val);
 }
 
 int QIAdvancedSlider::singelStep() const
 {
-    return mSlider->singleStep();
-}
-
-void QIAdvancedSlider::setTickInterval (int aVal)
-{
-    mSlider->setTickInterval (aVal);
+    return m_pSlider->singleStep();
+}
+
+void QIAdvancedSlider::setTickInterval(int val)
+{
+    m_pSlider->setTickInterval(val);
 }
 
 int QIAdvancedSlider::tickInterval() const
 {
-    return mSlider->tickInterval();
-}
-
-void QIAdvancedSlider::setTickPosition (QSlider::TickPosition aPos)
-{
-    mSlider->setTickPosition (aPos);
+    return m_pSlider->tickInterval();
+}
+
+void QIAdvancedSlider::setTickPosition(QSlider::TickPosition fPos)
+{
+    m_pSlider->setTickPosition(fPos);
 }
 
 QSlider::TickPosition QIAdvancedSlider::tickPosition() const
 {
-    return mSlider->tickPosition();
+    return m_pSlider->tickPosition();
 }
 
 Qt::Orientation QIAdvancedSlider::orientation() const
 {
-    return mSlider->orientation();
-}
-
-void QIAdvancedSlider::setSnappingEnabled (bool aOn)
-{
-    mSnappingEnabled = aOn;
+    return m_pSlider->orientation();
+}
+
+void QIAdvancedSlider::setSnappingEnabled(bool fOn)
+{
+    m_fSnappingEnabled = fOn;
 }
 
 bool QIAdvancedSlider::isSnappingEnabled() const
 {
-    return mSnappingEnabled;
-}
-
-void QIAdvancedSlider::setOptimalHint (int aMin, int aMax)
-{
-    mSlider->mMinOpt = aMin;
-    mSlider->mMaxOpt = aMax;
-}
-
-void QIAdvancedSlider::setWarningHint (int aMin, int aMax)
-{
-    mSlider->mMinWrn = aMin;
-    mSlider->mMaxWrn = aMax;
-}
-
-void QIAdvancedSlider::setErrorHint (int aMin, int aMax)
-{
-    mSlider->mMinErr = aMin;
-    mSlider->mMaxErr = aMax;
-}
-
-void QIAdvancedSlider::setOrientation (Qt::Orientation aOrientation)
-{
-    mSlider->setOrientation (aOrientation);
-}
-
-void QIAdvancedSlider::setValue (int aVal)
-{
-    mSlider->setValue (aVal);
-}
-
-void QIAdvancedSlider::prvSliderMoved(int val)
+    return m_fSnappingEnabled;
+}
+
+void QIAdvancedSlider::setOptimalHint(int min, int max)
+{
+    m_pSlider->m_minOpt = min;
+    m_pSlider->m_maxOpt = max;
+}
+
+void QIAdvancedSlider::setWarningHint(int min, int max)
+{
+    m_pSlider->m_minWrn = min;
+    m_pSlider->m_maxWrn = max;
+}
+
+void QIAdvancedSlider::setErrorHint(int min, int max)
+{
+    m_pSlider->m_minErr = min;
+    m_pSlider->m_maxErr = max;
+}
+
+void QIAdvancedSlider::setOrientation(Qt::Orientation fOrientation)
+{
+    m_pSlider->setOrientation(fOrientation);
+}
+
+void QIAdvancedSlider::setValue (int val)
+{
+    m_pSlider->setValue(val);
+}
+
+void QIAdvancedSlider::sltSliderMoved(int val)
 {
     val = snapValue(val);
-    mSlider->setValue(val);
+    m_pSlider->setValue(val);
     emit sliderMoved(val);
 }
 
-void QIAdvancedSlider::init (Qt::Orientation aOrientation /* = Qt::Horizontal */)
-{
-    mSnappingEnabled = false;
-
-    QVBoxLayout *pMainLayout = new QVBoxLayout (this);
-    VBoxGlobal::setLayoutMargin (pMainLayout, 0);
-    mSlider = new CPrivateSlider (aOrientation, this);
-    pMainLayout->addWidget (mSlider);
-
-    connect(mSlider, SIGNAL (sliderMoved(int)), this, SLOT (prvSliderMoved(int)));
-    connect(mSlider, SIGNAL (valueChanged(int)), this, SIGNAL (valueChanged(int)));
-    connect(mSlider, SIGNAL (sliderPressed()), this, SIGNAL (sliderPressed()));
-    connect(mSlider, SIGNAL (sliderReleased()), this, SIGNAL (sliderReleased()));
+void QIAdvancedSlider::init(Qt::Orientation fOrientation /* = Qt::Horizontal */)
+{
+    m_fSnappingEnabled = false;
+
+    QVBoxLayout *pMainLayout = new QVBoxLayout(this);
+    VBoxGlobal::setLayoutMargin(pMainLayout, 0);
+    m_pSlider = new CPrivateSlider(fOrientation, this);
+    pMainLayout->addWidget(m_pSlider);
+
+    connect(m_pSlider, SIGNAL(sliderMoved(int)), this, SLOT(sltSliderMoved(int)));
+    connect(m_pSlider, SIGNAL(valueChanged(int)), this, SIGNAL(valueChanged(int)));
+    connect(m_pSlider, SIGNAL(sliderPressed()), this, SIGNAL(sliderPressed()));
+    connect(m_pSlider, SIGNAL(sliderReleased()), this, SIGNAL(sliderReleased()));
 }
 
 int QIAdvancedSlider::snapValue(int val)
 {
-    if (mSnappingEnabled &&
+    if (m_fSnappingEnabled &&
         val > 2)
     {
-        float l2 = log ((float)val)/log (2.0);
-        int newVal = (int) pow ((float)2, (int)qRound (l2)); /* The value to snap on */
-        int pos = mSlider->positionForValue (val); /* Get the relative screen pos for the original value */
-        int newPos = mSlider->positionForValue (newVal); /* Get the relative screen pos for the snap value */
-        if (abs (newPos - pos) < 5) /* 10 pixel snapping range */
+        float l2 = log((float)val)/log(2.0);
+        int newVal = (int)pow((float)2, (int)qRound(l2)); /* The value to snap on */
+        int pos = m_pSlider->positionForValue(val); /* Get the relative screen pos for the original value */
+        int newPos = m_pSlider->positionForValue(newVal); /* Get the relative screen pos for the snap value */
+        if (abs(newPos - pos) < 5) /* 10 pixel snapping range */
         {
             val = newVal;
-            if (val > mSlider->maximum())
-                val = mSlider->maximum();
-            else if (val < mSlider->minimum())
-                val = mSlider->minimum();
+            if (val > m_pSlider->maximum())
+                val = m_pSlider->maximum();
+            else if (val < m_pSlider->minimum())
+                val = m_pSlider->minimum();
         }
     }

trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIAdvancedSlider.h

@@ -35 +35 @@
 
 public:
-    QIAdvancedSlider (QWidget *aParent = 0);
-    QIAdvancedSlider (Qt::Orientation aOrientation, QWidget *aParent = 0);
+    QIAdvancedSlider(QWidget *pParent = 0);
+    QIAdvancedSlider(Qt::Orientation fOrientation, QWidget *pParent = 0);
 
     int value() const;
 
-    void setRange (int aMinV, int aMaxV);
+    void setRange(int minV, int maxV);
 
-    void setMaximum (int aVal);
+    void setMaximum(int val);
     int maximum() const;
 
-    void setMinimum (int aVal);
+    void setMinimum(int val);
     int minimum() const;
 
-    void setPageStep (int aVal);
+    void setPageStep(int val);
     int pageStep() const;
 
-    void setSingleStep (int aVal);
+    void setSingleStep(int val);
     int singelStep() const;
 
-    void setTickInterval (int aVal);
+    void setTickInterval(int val);
     int tickInterval() const;
 
-    void setTickPosition (QSlider::TickPosition aPos);
+    void setTickPosition(QSlider::TickPosition fPos);
     QSlider::TickPosition tickPosition() const;
 
     Qt::Orientation orientation() const;
 
-    void setSnappingEnabled (bool aOn);
+    void setSnappingEnabled(bool fOn);
     bool isSnappingEnabled() const;
 
-    void setOptimalHint (int aMin, int aMax);
-    void setWarningHint (int aMin, int aMax);
-    void setErrorHint (int aMin, int aMax);
+    void setOptimalHint(int min, int max);
+    void setWarningHint(int min, int max);
+    void setErrorHint(int min, int max);
 
 public slots:
 
-    void setOrientation (Qt::Orientation aOrientation);
-    void setValue (int aVal);
+    void setOrientation(Qt::Orientation fOrientation);
+    void setValue(int val);
 
 signals:
-    void valueChanged (int);
-    void sliderMoved (int);
+    void valueChanged(int);
+    void sliderMoved(int);
     void sliderPressed();
     void sliderReleased();
@@ -82 +82 @@
 private slots:
 
-    void prvSliderMoved (int val);
+    void sltSliderMoved(int val);
 
 private:
 
-    void init (Qt::Orientation aOrientation = Qt::Horizontal);
+    void init(Qt::Orientation fOrientation = Qt::Horizontal);
     int snapValue(int val);
 
     /* Private member vars */
-    CPrivateSlider *mSlider;
-    bool mSnappingEnabled;
+    CPrivateSlider *m_pSlider;
+    bool m_fSnappingEnabled;
 };