Changeset 21194 in vbox for trunk/src

Timestamp:

Jul 3, 2009 12:24:28 PM (16 years ago)

Author:

vboxsync

Message:

FE/Qt4: Colored slider for memory/CPU. Better snapping handling.

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• include/QIAdvancedSlider.h (modified) (3 diffs)
• include/VBoxVMSettingsSystem.h (modified) (1 diff)
• src/QIAdvancedSlider.cpp (modified) (5 diffs)
• src/VBoxVMSettingsDisplay.cpp (modified) (1 diff)
• src/VBoxVMSettingsSystem.cpp (modified) (6 diffs)
• ui/VBoxVMSettingsSystem.ui (modified) (1 diff)

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

@@ -26 +26 @@
 /* Qt includes */
 #include <QSlider>
+
+class CPrivateSlider;
 
 class QIAdvancedSlider: public QWidget
@@ -62 +64 @@
     bool isSnappingEnabled() const;
 
+    void setOptimalHint (int aMin, int aMax);
+    void setWarningHint (int aMin, int aMax);
+    void setErrorHint (int aMin, int aMax);
+
 public slots:
 
@@ -83 +89 @@
 
     /* Private member vars */
-    QSlider *mSlider;
+    CPrivateSlider *mSlider;
     bool mSnappingEnabled;
 };

trunk/src/VBox/Frontends/VirtualBox/include/VBoxVMSettingsSystem.h

@@ -82 +82 @@
     uint mMinGuestCPU;
     uint mMaxGuestCPU;
+
+    int mMaxRAMAllowed;
+    int mMaxRAMOptimum;
 };
 

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

@@ -22 +22 @@
 
 #include "QIAdvancedSlider.h"
+#include "VBoxGlobal.h"
 
 /* Qt includes */
 #include <QVBoxLayout>
+#include <QPainter>
+#include <QStyle>
+#include <QStyleOptionSlider>
 
 /* System includes */
 #include <math.h>
 
+class CPrivateSlider: public QSlider
+{
+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)
+    {}
+
+    int positionForValue (int aVal) const
+    {
+        QStyleOptionSlider opt;
+        initStyleOption (&opt);
+        opt.subControls = QStyle::SC_All;
+        int available = style()->pixelMetric (QStyle::PM_SliderSpaceAvailable, &opt, this);
+        return QStyle::sliderPositionFromValue (opt.minimum, opt.maximum, aVal, available);
+    }
+
+    virtual void paintEvent ( QPaintEvent * event )
+    {
+        QPainter p(this);
+
+        QStyleOptionSlider opt;
+        initStyleOption (&opt);
+        opt.subControls = QStyle::SC_All;
+
+        int available = style()->pixelMetric (QStyle::PM_SliderSpaceAvailable, &opt, this);
+        QSize s = size();
+
+        QRect ticks = style()->subControlRect (QStyle::CC_Slider, &opt, QStyle::SC_SliderTickmarks, this);
+        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);
+        }
+        if (mMinOpt != -1 &&
+            mMaxOpt != -1)
+        {
+            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)
+        {
+            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)
+        {
+            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);
+        }
+
+        QSlider::paintEvent (event);
+    }
+
+    QColor mOptColor;
+    QColor mWrnColor;
+    QColor mErrColor;
+
+    int mMinOpt;
+    int mMaxOpt;
+    int mMinWrn;
+    int mMaxWrn;
+    int mMinErr;
+    int mMaxErr;
+};
 
 QIAdvancedSlider::QIAdvancedSlider (QWidget *aParent /* = 0 */)
@@ -125 +207 @@
 {
     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;
 }
 
@@ -146 +246 @@
 void QIAdvancedSlider::init (Qt::Orientation aOrientation /* = Qt::Horizontal */)
 {
-    mSnappingEnabled = true;
+    mSnappingEnabled = false;
 
     QVBoxLayout *pMainLayout = new QVBoxLayout (this);
-    mSlider = new QSlider (aOrientation, this);
+    VBoxGlobal::setLayoutMargin (pMainLayout, 0);
+    mSlider = new CPrivateSlider (aOrientation, this);
     pMainLayout->addWidget (mSlider);
 
@@ -164 +265 @@
     {
         float l2 = log ((float)val)/log (2.0);
-        float snap = 1.0/l2 * 2; /* How much border around the current snaping value (%) */
         int newVal = pow ((float)2, (int)qRound (l2)); /* The value to snap on */
-        if (abs (newVal - val) < (snap * newVal)) /* Snap only if we are in a defined array */
+        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 */
         {
             val = newVal;
@@ -177 +279 @@
     return val;
 }
+

trunk/src/VBox/Frontends/VirtualBox/src/VBoxVMSettingsDisplay.cpp

@@ -74 +74 @@
     mSlMemory->setMinimum ((MinVRAM / mSlMemory->pageStep()) * mSlMemory->pageStep());
     mSlMemory->setMaximum (MaxVRAM);
+    mSlMemory->setSnappingEnabled (true);
+    quint64 needMBytes = VBoxGlobal::requiredVideoMemory (&mMachine) / _1M;
+    mSlMemory->setErrorHint (0, 1);
+    mSlMemory->setWarningHint (1, needMBytes);
+    mSlMemory->setOptimalHint (needMBytes, MaxVRAM);
     /* Limit min/max. size of QLineEdit */
     mLeMemory->setFixedWidthByText (QString().fill ('8', 4));

trunk/src/VBox/Frontends/VirtualBox/src/VBoxVMSettingsSystem.cpp

@@ -57 +57 @@
     mMinGuestRAM = sys.GetMinGuestRAM();
     mMaxGuestRAM = RT_MIN (RT_ALIGN (vboxGlobal().virtualBox().GetHost().GetMemorySize(), _1G / _1M), sys.GetMaxGuestRAM());
+    uint hostCPUs = vboxGlobal().virtualBox().GetHost().GetProcessorCount();
     mMinGuestCPU = sys.GetMinGuestCPUCount();
-    mMaxGuestCPU = RT_MIN (2 * vboxGlobal().virtualBox().GetHost().GetProcessorCount(), sys.GetMaxGuestCPUCount());
+    mMaxGuestCPU = RT_MIN (2 * hostCPUs, sys.GetMaxGuestCPUCount());
+
+    /* Come up with some nice round percent boundraries relative to
+     * the system memory. A max of 75% on a 256GB config is ridiculous,
+     * even on an 8GB rig reserving 2GB for the OS is way to conservative.
+     * The max numbers can be estimated using the following program:
+     *
+     *      double calcMaxPct(uint64_t cbRam)
+     *      {
+     *          double cbRamOverhead = cbRam * 0.0390625; // 160 bytes per page.
+     *          double cbRamForTheOS = RT_MAX(RT_MIN(_512M, cbRam * 0.25), _64M);
+     *          double OSPct  = (cbRamOverhead + cbRamForTheOS) * 100.0 / cbRam;
+     *          double MaxPct = 100 - OSPct;
+     *          return MaxPct;
+     *      }
+     *
+     *      int main()
+     *      {
+     *          uint64_t cbRam = _1G;
+     *          for (; !(cbRam >> 33); cbRam += _1G)
+     *              printf("%8lluGB %.1f%% %8lluKB\n", cbRam >> 30, calcMaxPct(cbRam),
+     *                     (uint64_t)(cbRam * calcMaxPct(cbRam) / 100.0) >> 20);
+     *          for (; !(cbRam >> 51); cbRam <<= 1)
+     *              printf("%8lluGB %.1f%% %8lluKB\n", cbRam >> 30, calcMaxPct(cbRam),
+     *                     (uint64_t)(cbRam * calcMaxPct(cbRam) / 100.0) >> 20);
+     *          return 0;
+     *      }
+     *
+     * Note. We might wanna put these calculations somewhere global later. */
+
+    /* System RAM amount test */
+    ulong fullSize = vboxGlobal().virtualBox().GetHost().GetMemorySize();
+    mMaxRAMAllowed  = 0.75 * fullSize;
+    mMaxRAMOptimum  = 0.50 * fullSize;
+    if (fullSize < 3072)
+        /* done */;
+    else if (fullSize < 4096)   /* 3GB */
+        mMaxRAMAllowed = 0.80 * fullSize;
+    else if (fullSize < 6144)   /* 4-5GB */
+    {
+        mMaxRAMAllowed = 0.84 * fullSize;
+        mMaxRAMOptimum = 0.60 * fullSize;
+    }
+    else if (fullSize < 8192)   /* 6-7GB */
+    {
+        mMaxRAMAllowed = 0.88 * fullSize;
+        mMaxRAMOptimum = 0.65 * fullSize;
+    }
+    else if (fullSize < 16384)  /* 8-15GB */
+    {
+        mMaxRAMAllowed = 0.90 * fullSize;
+        mMaxRAMOptimum = 0.70 * fullSize;
+    }
+    else if (fullSize < 32768)  /* 16-31GB */
+    {
+        mMaxRAMAllowed = 0.93 * fullSize;
+        mMaxRAMOptimum = 0.75 * fullSize;
+    }
+    else if (fullSize < 65536)  /* 32-63GB */
+    {
+        mMaxRAMAllowed = 0.94 * fullSize;
+        mMaxRAMOptimum = 0.80 * fullSize;
+    }
+    else if (fullSize < 131072) /* 64-127GB */
+    {
+        mMaxRAMAllowed = 0.95 * fullSize;
+        mMaxRAMOptimum = 0.85 * fullSize;
+    }
+    else                        /* 128GB- */
+    {
+        mMaxRAMAllowed = 0.96 * fullSize;
+        mMaxRAMOptimum = 0.90 * fullSize;
+    }
 
     /* Setup validators */
@@ -103 +176 @@
     mSlMemory->setMinimum ((mMinGuestRAM / mSlMemory->pageStep()) * mSlMemory->pageStep());
     mSlMemory->setMaximum (mMaxGuestRAM);
+    mSlMemory->setSnappingEnabled (true);
+    mSlMemory->setOptimalHint (1, mMaxRAMOptimum);
+    mSlMemory->setWarningHint (mMaxRAMOptimum, mMaxRAMAllowed);
+    mSlMemory->setErrorHint (mMaxRAMAllowed, mMaxGuestRAM);
     /* Limit min/max. size of QLineEdit */
     mLeMemory->setFixedWidthByText (QString().fill ('8', 5));
@@ -115 +192 @@
     mSlCPU->setMinimum (mMinGuestCPU);
     mSlCPU->setMaximum (mMaxGuestCPU);
+    mSlCPU->setOptimalHint (1, hostCPUs);
+    mSlCPU->setWarningHint (hostCPUs, mMaxGuestCPU);
     /* Limit min/max. size of QLineEdit */
     mLeCPU->setFixedWidthByText (QString().fill ('8', 3));
@@ -274 +353 @@
 bool VBoxVMSettingsSystem::revalidate (QString &aWarning, QString & /* aTitle */)
 {
-    /* Come up with some nice round percent boundraries relative to
-     * the system memory. A max of 75% on a 256GB config is ridiculous,
-     * even on an 8GB rig reserving 2GB for the OS is way to conservative.
-     * The max numbers can be estimated using the following program:
-     *
-     *      double calcMaxPct(uint64_t cbRam)
-     *      {
-     *          double cbRamOverhead = cbRam * 0.0390625; // 160 bytes per page.
-     *          double cbRamForTheOS = RT_MAX(RT_MIN(_512M, cbRam * 0.25), _64M);
-     *          double OSPct  = (cbRamOverhead + cbRamForTheOS) * 100.0 / cbRam;
-     *          double MaxPct = 100 - OSPct;
-     *          return MaxPct;
-     *      }
-     *
-     *      int main()
-     *      {
-     *          uint64_t cbRam = _1G;
-     *          for (; !(cbRam >> 33); cbRam += _1G)
-     *              printf("%8lluGB %.1f%% %8lluKB\n", cbRam >> 30, calcMaxPct(cbRam),
-     *                     (uint64_t)(cbRam * calcMaxPct(cbRam) / 100.0) >> 20);
-     *          for (; !(cbRam >> 51); cbRam <<= 1)
-     *              printf("%8lluGB %.1f%% %8lluKB\n", cbRam >> 30, calcMaxPct(cbRam),
-     *                     (uint64_t)(cbRam * calcMaxPct(cbRam) / 100.0) >> 20);
-     *          return 0;
-     *      }
-     *
-     * Note. We might wanna put these calculations somewhere global later. */
-
-    /* System RAM amount test */
     ulong fullSize = vboxGlobal().virtualBox().GetHost().GetMemorySize();
-    double maxPct  = 0.75;
-    double warnPct = 0.50;
-    if (fullSize < 3072)
-        /* done */;
-    else if (fullSize < 4096)   /* 3GB */
-        maxPct  = 0.80;
-    else if (fullSize < 6144)   /* 4-5GB */
-    {
-        maxPct  = 0.84;
-        warnPct = 0.60;
-    }
-    else if (fullSize < 8192)   /* 6-7GB */
-    {
-        maxPct  = 0.88;
-        warnPct = 0.65;
-    }
-    else if (fullSize < 16384)  /* 8-15GB */
-    {
-        maxPct  = 0.90;
-        warnPct = 0.70;
-    }
-    else if (fullSize < 32768)  /* 16-31GB */
-    {
-        maxPct  = 0.93;
-        warnPct = 0.75;
-    }
-    else if (fullSize < 65536)  /* 32-63GB */
-    {
-        maxPct  = 0.94;
-        warnPct = 0.80;
-    }
-    else if (fullSize < 131072) /* 64-127GB */
-    {
-        maxPct  = 0.95;
-        warnPct = 0.85;
-    }
-    else                        /* 128GB- */
-    {
-        maxPct  = 0.96;
-        warnPct = 0.90;
-    }
-
-    if (mSlMemory->value() > maxPct * fullSize)
+    if (mSlMemory->value() > mMaxRAMAllowed)
     {
         aWarning = tr (
@@ -352 +360 @@
             "(<b>%2</b>) to the virtual machine. Not enough memory is left "
             "for your host operating system. Please select a smaller amount.")
-            .arg ((unsigned)(maxPct * 100))
+            .arg ((unsigned)qRound ((double)mMaxRAMAllowed / fullSize * 100.0))
             .arg (vboxGlobal().formatSize ((uint64_t)fullSize * _1M));
         return false;
     }
-    if (mSlMemory->value() > warnPct * fullSize)
+    if (mSlMemory->value() > mMaxRAMOptimum)
     {
         aWarning = tr (
@@ -362 +370 @@
             "(<b>%2</b>) to the virtual machine. Not enough memory might be "
             "left for your host operating system. Continue at your own risk.")
-            .arg ((unsigned)(warnPct * 100))
+            .arg ((unsigned)qRound ((double)mMaxRAMOptimum / fullSize * 100.0))
             .arg (vboxGlobal().formatSize ((uint64_t)fullSize * _1M));
         return true;

trunk/src/VBox/Frontends/VirtualBox/ui/VBoxVMSettingsSystem.ui

@@ -397 +397 @@
          </property>
          <item>
-          <widget class="QSlider" name="mSlCPU">
+          <widget class="QIAdvancedSlider" name="mSlCPU">
            <property name="whatsThis">
             <string>Controls the number of virtual CPUs in the virtual machine.</string>