VirtualBox

Changeset 95169 in vbox


Ignore:
Timestamp:
Jun 2, 2022 11:10:20 AM (3 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
151667
Message:

FE/Qt/Ds: bugref:6899: Machine settings: System page accessibility improvements (part 5); Replacing VCPU stuff with existing UIVirtualCPUEditor editor, a bit of cleanup for corresponding editor as well.

Location:
trunk/src/VBox/Frontends/VirtualBox/src
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIVideoMemoryEditor.cpp

    r94395 r95169  
    163163        m_pLabelMemory->setText(tr("Video &Memory:"));
    164164
     165    const QString strToolTip(tr("Holds the amount of video memory provided to the virtual machine."));
    165166    if (m_pSlider)
    166         m_pSlider->setToolTip(tr("Holds the amount of video memory provided to the virtual machine."));
     167        m_pSlider->setToolTip(strToolTip);
    167168    if (m_pSpinBox)
    168         m_pSpinBox->setToolTip(tr("Holds the amount of video memory provided to the virtual machine."));
     169        m_pSpinBox->setToolTip(strToolTip);
    169170
    170171    if (m_pLabelMemoryMin)

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIVirtualCPUEditor.cpp

    r93115 r95169  
    2424
    2525/* GUI includes: */
     26#include "QIAdvancedSlider.h"
    2627#include "UICommon.h"
    2728#include "UIVirtualCPUEditor.h"
    28 #include "QIAdvancedSlider.h"
    2929
    3030/* COM includes */
    … …  
    3232#include "CSystemProperties.h"
    3333
    34 UIVirtualCPUEditor::UIVirtualCPUEditor(QWidget *pParent /* = 0 */, bool fWithLabel /* = false */)
     34UIVirtualCPUEditor::UIVirtualCPUEditor(QWidget *pParent /* = 0 */)
    3535    : QIWithRetranslateUI<QWidget>(pParent)
     36    , m_uMinVCPUCount(1)
     37    , m_uMaxVCPUCount(1)
    3638    , m_pLabelVCPU(0)
    3739    , m_pSlider(0)
     40    , m_pSpinBox(0)
    3841    , m_pLabelVCPUMin(0)
    3942    , m_pLabelVCPUMax(0)
    40     , m_pSpinBox(0)
    41     , m_uMaxVCPUCount(1)
    42     , m_uMinVCPUCount(1)
    43     , m_fWithLabel(fWithLabel)
    4443{
    4544    prepare();
    … …  
    5756}
    5857
     58int UIVirtualCPUEditor::minimumLabelHorizontalHint() const
     59{
     60    return m_pLabelVCPU->minimumSizeHint().width();
     61}
     62
     63void UIVirtualCPUEditor::setMinimumLayoutIndent(int iIndent)
     64{
     65    if (m_pLayout)
     66        m_pLayout->setColumnMinimumWidth(0, iIndent);
     67}
     68
    5969void UIVirtualCPUEditor::retranslateUi()
    6070{
    6171    if (m_pLabelVCPU)
    62         m_pLabelVCPU->setText(tr("&Processor(s):"));
    63     if (m_pLabelVCPUMin)
    64         m_pLabelVCPUMin->setText(tr("%1 CPU", "%1 is 1 for now").arg(m_uMinVCPUCount));
    65     if (m_pLabelVCPUMax)
    66         m_pLabelVCPUMax->setText(tr("%1 CPUs", "%1 is host cpu count * 2 for now").arg(m_uMaxVCPUCount));
    67 
    68     QString strToolTip(tr("Specifies the number of virtual CPUs the virtual machine will have"));
     72        m_pLabelVCPU->setText(tr("&Processors:"));
     73
     74    QString strToolTip(tr("Holds the number of virtual CPUs in the virtual machine. You need hardware "
     75                          "virtualization support on your host system to use more than one virtual CPU."));
    6976    if (m_pSlider)
    7077        m_pSlider->setToolTip(strToolTip);
    7178    if (m_pSpinBox)
    7279        m_pSpinBox->setToolTip(strToolTip);
     80
     81    if (m_pLabelVCPUMin)
     82    {
     83        m_pLabelVCPUMin->setText(tr("%1 CPU", "%1 is 1 for now").arg(m_uMinVCPUCount));
     84        m_pLabelVCPUMin->setToolTip(tr("Minimum possible virtual CPU count."));
     85    }
     86    if (m_pLabelVCPUMax)
     87    {
     88        m_pLabelVCPUMax->setText(tr("%1 CPUs", "%1 is host cpu count * 2 for now").arg(m_uMaxVCPUCount));
     89        m_pLabelVCPUMax->setToolTip(tr("Maximum possible virtual CPU count."));
     90    }
    7391}
    7492
    7593void UIVirtualCPUEditor::sltHandleSliderChange()
    7694{
     95    /* Apply spin-box value keeping it's signals disabled: */
    7796    if (m_pSpinBox && m_pSlider)
    7897    {
    … …  
    81100        m_pSpinBox->blockSignals(false);
    82101    }
     102
     103    /* Send signal to listener: */
    83104    emit sigValueChanged(m_pSlider->value());
    84105}
    … …  
    86107void UIVirtualCPUEditor::sltHandleSpinBoxChange()
    87108{
     109    /* Apply slider value keeping it's signals disabled: */
    88110    if (m_pSpinBox && m_pSlider)
    89111    {
    … …  
    92114        m_pSlider->blockSignals(false);
    93115    }
     116
     117    /* Send signal to listener: */
    94118    emit sigValueChanged(m_pSpinBox->value());
    95119}
    … …  
    97121void UIVirtualCPUEditor::prepare()
    98122{
    99     const CSystemProperties properties = uiCommon().virtualBox().GetSystemProperties();
     123    /* Prepare common variables: */
     124    const CSystemProperties comProperties = uiCommon().virtualBox().GetSystemProperties();
    100125    const uint uHostCPUs = uiCommon().host().GetProcessorOnlineCoreCount();
    101     m_uMinVCPUCount = properties.GetMinGuestCPUCount();
    102     m_uMaxVCPUCount = qMin(2 * uHostCPUs, (uint)properties.GetMaxGuestCPUCount());
    103 
    104     QGridLayout *pMainLayout = new QGridLayout(this);
    105     if (pMainLayout)
    106     {
    107         pMainLayout->setContentsMargins(0, 0, 0, 0);
    108         int iRow = 0;
    109 
    110         if (m_fWithLabel)
    111             m_pLabelVCPU = new QLabel(this);
     126    m_uMinVCPUCount = comProperties.GetMinGuestCPUCount();
     127    m_uMaxVCPUCount = qMin(2 * uHostCPUs, (uint)comProperties.GetMaxGuestCPUCount());
     128
     129    /* Create main layout: */
     130    m_pLayout = new QGridLayout(this);
     131    if (m_pLayout)
     132    {
     133        m_pLayout->setContentsMargins(0, 0, 0, 0);
     134
     135        /* Create VCPU label: */
     136        m_pLabelVCPU = new QLabel(this);
    112137        if (m_pLabelVCPU)
    113             pMainLayout->addWidget(m_pLabelVCPU, 0, iRow++, 1, 1);
    114 
     138        {
     139            m_pLabelVCPU->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     140            m_pLayout->addWidget(m_pLabelVCPU, 0, 0);
     141        }
     142
     143        /* Create slider layout: */
    115144        QVBoxLayout *pSliderLayout = new QVBoxLayout;
    116145        if (pSliderLayout)
    117146        {
    118147            pSliderLayout->setContentsMargins(0, 0, 0, 0);
     148
     149            /* Create VCPU slider: */
    119150            m_pSlider = new QIAdvancedSlider(this);
    120151            if (m_pSlider)
    … …  
    128159                m_pSlider->setOptimalHint(1, uHostCPUs);
    129160                m_pSlider->setWarningHint(uHostCPUs, m_uMaxVCPUCount);
    130 
    131161                connect(m_pSlider, &QIAdvancedSlider::valueChanged,
    132162                        this, &UIVirtualCPUEditor::sltHandleSliderChange);
    133163                pSliderLayout->addWidget(m_pSlider);
    134164            }
     165
     166            /* Create legend layout: */
    135167            QHBoxLayout *pLegendLayout = new QHBoxLayout;
    136168            if (pLegendLayout)
    137169            {
    138170                pLegendLayout->setContentsMargins(0, 0, 0, 0);
     171
     172                /* Create min label: */
    139173                m_pLabelVCPUMin = new QLabel(this);
    140174                if (m_pLabelVCPUMin)
    141175                    pLegendLayout->addWidget(m_pLabelVCPUMin);
     176
     177                /* Push labels from each other: */
    142178                pLegendLayout->addStretch();
     179
     180                /* Create max label: */
    143181                m_pLabelVCPUMax = new QLabel(this);
    144182                if (m_pLabelVCPUMax)
    145183                    pLegendLayout->addWidget(m_pLabelVCPUMax);
     184
     185                /* Add legend layout to slider layout: */
    146186                pSliderLayout->addLayout(pLegendLayout);
    147187            }
    148             pMainLayout->addLayout(pSliderLayout, 0, iRow++, 2, 1);
     188
     189            /* Add slider layout to main layout: */
     190            m_pLayout->addLayout(pSliderLayout, 0, 1, 2, 1);
    149191        }
     192
     193        /* Create VCPU spin-box: */
    150194        m_pSpinBox = new QSpinBox(this);
    151195        if (m_pSpinBox)
    … …  
    158202            connect(m_pSpinBox, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged),
    159203                    this, &UIVirtualCPUEditor::sltHandleSpinBoxChange);
    160             pMainLayout->addWidget(m_pSpinBox, 0, iRow++, 1, 1);
     204            m_pLayout->addWidget(m_pSpinBox, 0, 2, 1, 1);
    161205        }
    162206    }
    163207
     208    /* Apply language settings: */
    164209    retranslateUi();
    165210}

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIVirtualCPUEditor.h

    r94395 r95169  
    2828#include "QIWithRetranslateUI.h"
    2929
    30 
    3130/* Forward declarations: */
     31class QGridLayout;
    3232class QLabel;
    3333class QSpinBox;
    3434class QIAdvancedSlider;
    3535
    36 /** QWidget subclass used as a virtual cpu count editor. Includes a spinbox, a slider,
    37   * optional label, and max-min value labels. */
     36/** QWidget subclass used as a virtual CPU editor. */
    3837class SHARED_LIBRARY_STUFF UIVirtualCPUEditor : public QIWithRetranslateUI<QWidget>
    3938{
    4039    Q_OBJECT;
    4140
    42  signals:
     41signals:
    4342
     43    /** Notifies listeners about @a iValue changed. */
    4444    void sigValueChanged(int iValue);
    4545
    4646public:
    4747
    48     /** Constructs editor passing @a pParent to the base-class.
    49       * @param  fWithLabel  Determines whether we should add label ourselves. */
    50     UIVirtualCPUEditor(QWidget *pParent = 0, bool fWithLabel = false);
     48    /** Constructs editor passing @a pParent to the base-class. */
     49    UIVirtualCPUEditor(QWidget *pParent = 0);
    5150
    5251    /** Defines editor @a iValue. */
    … …  
    5453    /** Returns editor value. */
    5554    int value() const;
     55
     56    /** Returns minimum layout hint. */
     57    int minimumLabelHorizontalHint() const;
     58    /** Defines minimum layout @a iIndent. */
     59    void setMinimumLayoutIndent(int iIndent);
    5660
    5761protected:
    … …  
    7276    void prepare();
    7377
    74 
    75     /* @{ */
    76     /** Widgets */
    77        QLabel           *m_pLabelVCPU;
    78        QIAdvancedSlider *m_pSlider;
    79        QLabel           *m_pLabelVCPUMin;
    80        QLabel           *m_pLabelVCPUMax;
    81        QSpinBox         *m_pSpinBox;
     78    /** @name Options
     79     * @{ */
     80        /** Holds the maximum virtual CPU count. */
     81        uint  m_uMinVCPUCount;
     82        /** Holds the minimum virtual CPU count. */
     83        uint  m_uMaxVCPUCount;
    8284    /** @} */
    8385
    84     unsigned m_uMaxVCPUCount;
    85     unsigned m_uMinVCPUCount;
    86     bool  m_fWithLabel;
    87 
     86    /** @name Widgets
     87     * @{ */
     88        /** Holds the main layout instance. */
     89        QGridLayout      *m_pLayout;
     90        /** Holds the main label instance. */
     91        QLabel           *m_pLabelVCPU;
     92        /** Holds the slider instance. */
     93        QIAdvancedSlider *m_pSlider;
     94        /** Holds the spinbox instance. */
     95        QSpinBox         *m_pSpinBox;
     96        /** Holds the minimum label instance. */
     97        QLabel           *m_pLabelVCPUMin;
     98        /** Holds the maximum label instance. */
     99        QLabel           *m_pLabelVCPUMax;
     100    /** @} */
    88101};
    89102

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsSystem.cpp

    r95163 r95169  
    3939#include "UIPointingHIDEditor.h"
    4040#include "UITranslator.h"
     41#include "UIVirtualCPUEditor.h"
    4142
    4243/* COM includes: */
    … …  
    165166    , m_pEditorMotherboardFeatures(0)
    166167    , m_pTabProcessor(0)
    167     , m_pLabelProcessorCount(0)
    168     , m_pSliderProcessorCount(0)
    169     , m_pSpinboxProcessorCount(0)
    170     , m_pLabelProcessorCountMin(0)
    171     , m_pLabelProcessorCountMax(0)
     168    , m_pEditorVCPU(0)
    172169    , m_pLabelProcessorExecCap(0)
    173170    , m_pSliderProcessorExecCap(0)
    … …  
    334331
    335332    /* Load old 'Processor' data from cache: */
    336     if (m_pSliderProcessorCount)
    337         m_pSliderProcessorCount->setValue(oldSystemData.m_cCPUCount);
     333    if (m_pEditorVCPU)
     334        m_pEditorVCPU->setValue(oldSystemData.m_cCPUCount);
    338335    if (m_pSliderProcessorExecCap)
    339336        m_pSliderProcessorExecCap->setValue(oldSystemData.m_iCPUExecCap);
    … …  
    386383        newSystemData.m_pointingHIDType = m_pEditorPointingHID->value();
    387384    if (   m_pEditorMotherboardFeatures
    388         && m_pSliderProcessorCount
     385        && m_pEditorVCPU
    389386        && m_pEditorChipset)
    390387        newSystemData.m_fEnabledIoApic =    m_pEditorMotherboardFeatures->isEnabledIoApic()
    391                                          || m_pSliderProcessorCount->value() > 1
     388                                         || m_pEditorVCPU->value() > 1
    392389                                         || m_pEditorChipset->value() == KChipsetType_ICH9;
    393390    if (m_pEditorMotherboardFeatures)
    … …  
    397394
    398395    /* Gather 'Processor' data: */
    399     if (m_pSliderProcessorCount)
    400         newSystemData.m_cCPUCount = m_pSliderProcessorCount->value();
     396    if (m_pEditorVCPU)
     397        newSystemData.m_cCPUCount = m_pEditorVCPU->value();
    401398    if (m_pSliderProcessorExecCap)
    402399        newSystemData.m_iCPUExecCap = m_pSliderProcessorExecCap->value();
    … …  
    410407    /* Enable HW Virt Ex automatically if it's supported and
    411408     * 1. multiple CPUs, 2. Nested Paging or 3. Nested HW Virt Ex is requested. */
    412     if (m_pSliderProcessorCount)
     409    if (m_pEditorVCPU)
    413410        newSystemData.m_fEnabledHwVirtEx =    isHWVirtExEnabled()
    414411                                           || (   isHWVirtExSupported()
    415                                                && (   m_pSliderProcessorCount->value() > 1
     412                                               && (   m_pEditorVCPU->value() > 1
    416413                                                   || isNestedPagingEnabled()
    417414                                                   || isNestedHWVirtExEnabled()));
    … …  
    500497        /* VCPU amount test: */
    501498        const int cTotalCPUs = uiCommon().host().GetProcessorOnlineCoreCount();
    502         if (m_pSliderProcessorCount->value() > 2 * cTotalCPUs)
     499        if (m_pEditorVCPU->value() > 2 * cTotalCPUs)
    503500        {
    504501            message.second << tr(
    … …  
    508505            fPass = false;
    509506        }
    510         else if (m_pSliderProcessorCount->value() > cTotalCPUs)
     507        else if (m_pEditorVCPU->value() > cTotalCPUs)
    511508        {
    512509            message.second << tr(
    … …  
    517514
    518515        /* VCPU vs IO-APIC test: */
    519         if (m_pSliderProcessorCount->value() > 1 && !m_pEditorMotherboardFeatures->isEnabledIoApic())
     516        if (m_pEditorVCPU->value() > 1 && !m_pEditorMotherboardFeatures->isEnabledIoApic())
    520517        {
    521518            message.second << tr(
    … …  
    526523
    527524        /* VCPU: */
    528         if (m_pSliderProcessorCount->value() > 1)
     525        if (m_pEditorVCPU->value() > 1)
    529526        {
    530527            /* HW Virt Ex test: */
    … …  
    547544        if (m_pSliderProcessorExecCap->value() < 100)
    548545        {
    549             if (m_uMaxGuestCPU > 1 && m_pSliderProcessorCount->value() > 1)
     546            if (m_uMaxGuestCPU > 1 && m_pEditorVCPU->value() > 1)
    550547            {
    551548                message.second << tr("Please consider lowering the number of CPUs assigned to the virtual machine rather "
    … …  
    623620    setTabOrder(m_pEditorChipset, m_pEditorPointingHID);
    624621    setTabOrder(m_pEditorPointingHID, m_pEditorMotherboardFeatures);
    625     setTabOrder(m_pEditorMotherboardFeatures, m_pSliderProcessorCount);
     622    setTabOrder(m_pEditorMotherboardFeatures, m_pEditorVCPU);
    626623
    627624    /* Configure navigation for 'processor' tab: */
    628     setTabOrder(m_pSliderProcessorCount, m_pSpinboxProcessorCount);
    629     setTabOrder(m_pSpinboxProcessorCount, m_pSliderProcessorExecCap);
     625    setTabOrder(m_pEditorVCPU, m_pSliderProcessorExecCap);
    630626    setTabOrder(m_pSliderProcessorExecCap, m_pSpinboxProcessorExecCap);
    631627    setTabOrder(m_pSpinboxProcessorExecCap, m_pComboParavirtProvider);
    … …  
    646642                                        "Move items up and down to change the device order."));
    647643    m_pTabWidget->setTabText(m_pTabWidget->indexOf(m_pTabMotherboard), tr("&Motherboard"));
    648     m_pLabelProcessorCount->setText(tr("&Processor(s):"));
    649     m_pSliderProcessorCount->setToolTip(tr("Controls the number of virtual CPUs in the virtual machine. You need hardware "
    650                                            "virtualization support on your host system to use more than one virtual CPU."));
    651     m_pSpinboxProcessorCount->setToolTip(tr("Controls the number of virtual CPUs in the virtual machine. You need hardware "
    652                                             "virtualization support on your host system to use more than one virtual CPU."));
    653644    m_pLabelProcessorExecCap->setText(tr("&Execution Cap:"));
    654645    m_pSliderProcessorExecCap->setToolTip(tr("Limits the amount of time that each virtual CPU is allowed to run for. "
    … …  
    681672    m_pTabWidget->setTabText(m_pTabWidget->indexOf(m_pTabAcceleration), tr("Acce&leration"));
    682673
    683     /* Retranslate the cpu slider legend: */
    684     m_pLabelProcessorCountMin->setText(tr("%1 CPU", "%1 is 1 for now").arg(m_uMinGuestCPU));
    685     m_pLabelProcessorCountMax->setText(tr("%1 CPUs", "%1 is host cpu count * 2 for now").arg(m_uMaxGuestCPU));
    686 
    687674    /* Retranslate the cpu cap slider legend: */
    688675    m_pLabelProcessorExecCapMin->setText(tr("%1%").arg(m_uMinGuestCPUExecCap));
    … …  
    704691    m_pEditorPointingHID->setMinimumLayoutIndent(iMinimumLayoutHint);
    705692    m_pEditorMotherboardFeatures->setMinimumLayoutIndent(iMinimumLayoutHint);
     693    iMinimumLayoutHint = 0;
     694    iMinimumLayoutHint = qMax(iMinimumLayoutHint, m_pEditorVCPU->minimumLabelHorizontalHint());
     695    iMinimumLayoutHint = qMax(iMinimumLayoutHint, m_pLabelProcessorExecCap->minimumSizeHint().width());
     696    iMinimumLayoutHint = qMax(iMinimumLayoutHint, m_pLabelExtendedProcessor->minimumSizeHint().width());
     697    m_pEditorVCPU->setMinimumLayoutIndent(iMinimumLayoutHint);
    706698}
    707699
    … …  
    719711
    720712    /* Polish 'Processor' availability: */
    721     m_pLabelProcessorCount->setEnabled(isMachineOffline());
    722     m_pLabelProcessorCountMin->setEnabled(isMachineOffline());
    723     m_pLabelProcessorCountMax->setEnabled(isMachineOffline());
    724     m_pSliderProcessorCount->setEnabled(isMachineOffline() && systemData.m_fSupportedHwVirtEx);
    725     m_pSpinboxProcessorCount->setEnabled(isMachineOffline() && systemData.m_fSupportedHwVirtEx);
     713    m_pEditorVCPU->setEnabled(isMachineOffline() && systemData.m_fSupportedHwVirtEx);
    726714    m_pLabelProcessorExecCap->setEnabled(isMachineInValidMode());
    727715    m_pLabelProcessorExecCapMin->setEnabled(isMachineInValidMode());
    … …  
    745733}
    746734
    747 void UIMachineSettingsSystem::sltHandleCPUCountSliderChange()
    748 {
    749     /* Apply new memory-size value: */
    750     m_pSpinboxProcessorCount->blockSignals(true);
    751     m_pSpinboxProcessorCount->setValue(m_pSliderProcessorCount->value());
    752     m_pSpinboxProcessorCount->blockSignals(false);
    753 
    754     /* Revalidate: */
    755     revalidate();
    756 }
    757 
    758 void UIMachineSettingsSystem::sltHandleCPUCountEditorChange()
    759 {
    760     /* Apply new memory-size value: */
    761     m_pSliderProcessorCount->blockSignals(true);
    762     m_pSliderProcessorCount->setValue(m_pSpinboxProcessorCount->value());
    763     m_pSliderProcessorCount->blockSignals(false);
    764 
    765     /* Revalidate: */
    766     revalidate();
    767 }
    768 
    769735void UIMachineSettingsSystem::sltHandleCPUExecCapSliderChange()
    770736{
    … …  
    898864        {
    899865            pLayoutProcessor->setColumnStretch(1, 1);
    900             pLayoutProcessor->setRowStretch(6, 1);
    901 
    902             /* Prepare processor count label: */
    903             m_pLabelProcessorCount = new QLabel(m_pTabProcessor);
    904             if (m_pLabelProcessorCount)
    905             {
    906                 m_pLabelProcessorCount->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
    907                 pLayoutProcessor->addWidget(m_pLabelProcessorCount, 0, 0);
    908             }
    909             /* Prepare processor count layout: */
    910             QVBoxLayout *pLayoutProcessorCount = new QVBoxLayout;
    911             if (pLayoutProcessorCount)
    912             {
    913                 pLayoutProcessorCount->setContentsMargins(0, 0, 0, 0);
    914 
    915                 /* Prepare processor count slider: */
    916                 m_pSliderProcessorCount = new QIAdvancedSlider(m_pTabProcessor);
    917                 if (m_pSliderProcessorCount)
    918                 {
    919                     m_pSliderProcessorCount->setOrientation(Qt::Horizontal);
    920                     m_pSliderProcessorCount->setPageStep(1);
    921                     m_pSliderProcessorCount->setSingleStep(1);
    922                     m_pSliderProcessorCount->setTickInterval(1);
    923                     m_pSliderProcessorCount->setMinimum(m_uMinGuestCPU);
    924                     m_pSliderProcessorCount->setMaximum(m_uMaxGuestCPU);
    925                     m_pSliderProcessorCount->setOptimalHint(1, uHostCPUs);
    926                     m_pSliderProcessorCount->setWarningHint(uHostCPUs, m_uMaxGuestCPU);
    927 
    928                     pLayoutProcessorCount->addWidget(m_pSliderProcessorCount);
    929                 }
    930                 /* Prepare processor count scale layout: */
    931                 QHBoxLayout *m_pLayoutProcessorCountScale = new QHBoxLayout;
    932                 if (m_pLayoutProcessorCountScale)
    933                 {
    934                     /* Prepare processor count min label: */
    935                     m_pLabelProcessorCountMin = new QLabel(m_pTabProcessor);
    936                     if (m_pLabelProcessorCountMin)
    937                         m_pLayoutProcessorCountScale->addWidget(m_pLabelProcessorCountMin);
    938                     m_pLayoutProcessorCountScale->addStretch();
    939                     /* Prepare processor count max label: */
    940                     m_pLabelProcessorCountMax = new QLabel(m_pTabProcessor);
    941                     if (m_pLabelProcessorCountMax)
    942                         m_pLayoutProcessorCountScale->addWidget(m_pLabelProcessorCountMax);
    943 
    944                     pLayoutProcessorCount->addLayout(m_pLayoutProcessorCountScale);
    945                 }
    946 
    947                 pLayoutProcessor->addLayout(pLayoutProcessorCount, 0, 1, 2, 2);
    948             }
    949             /* Prepare processor count spinbox: */
    950             m_pSpinboxProcessorCount = new QSpinBox(m_pTabProcessor);
    951             if (m_pSpinboxProcessorCount)
    952             {
    953                 if (m_pLabelProcessorCount)
    954                     m_pLabelProcessorCount->setBuddy(m_pSpinboxProcessorCount);
    955                 m_pSpinboxProcessorCount->setMinimum(m_uMinGuestCPU);
    956                 m_pSpinboxProcessorCount->setMaximum(m_uMaxGuestCPU);
    957                 uiCommon().setMinimumWidthAccordingSymbolCount(m_pSpinboxProcessorCount, 4);
    958 
    959                 pLayoutProcessor->addWidget(m_pSpinboxProcessorCount, 0, 3);
    960             }
     866            pLayoutProcessor->setRowStretch(5, 1);
     867
     868            /* Prepare VCPU editor : */
     869            m_pEditorVCPU = new UIVirtualCPUEditor(m_pTabProcessor);
     870            if (m_pEditorVCPU)
     871                pLayoutProcessor->addWidget(m_pEditorVCPU, 0, 0, 1, 4);
    961872
    962873            /* Prepare processor exec cap label: */
    … …  
    965876            {
    966877                m_pLabelProcessorExecCap->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
    967                 pLayoutProcessor->addWidget(m_pLabelProcessorExecCap, 2, 0);
     878                pLayoutProcessor->addWidget(m_pLabelProcessorExecCap, 1, 0);
    968879            }
    969880            /* Prepare processor exec cap layout: */
    … …  
    1005916                }
    1006917
    1007                 pLayoutProcessor->addLayout(pLayoutProcessorExecCap, 2, 1, 2, 2);
     918                pLayoutProcessor->addLayout(pLayoutProcessorExecCap, 1, 1, 2, 2);
    1008919            }
    1009920            /* Prepare processor exec cap spinbox: */
    … …  
    1017928                uiCommon().setMinimumWidthAccordingSymbolCount(m_pSpinboxProcessorExecCap, 4);
    1018929
    1019                 pLayoutProcessor->addWidget(m_pSpinboxProcessorExecCap, 2, 3);
     930                pLayoutProcessor->addWidget(m_pSpinboxProcessorExecCap, 1, 3);
    1020931            }
    1021932
    … …  
    1025936            {
    1026937                m_pLabelExtendedProcessor->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
    1027                 pLayoutProcessor->addWidget(m_pLabelExtendedProcessor, 4, 0);
     938                pLayoutProcessor->addWidget(m_pLabelExtendedProcessor, 3, 0);
    1028939            }
    1029940            /* Prepare PAE check-box: */
    1030941            m_pCheckBoxPAE = new QCheckBox(m_pTabProcessor);
    1031942            if (m_pCheckBoxPAE)
    1032                 pLayoutProcessor->addWidget(m_pCheckBoxPAE, 4, 1);
     943                pLayoutProcessor->addWidget(m_pCheckBoxPAE, 3, 1);
    1033944            /* Prepare nested virtualization check-box: */
    1034945            m_pCheckBoxNestedVirtualization = new QCheckBox(m_pTabProcessor);
    1035946            if (m_pCheckBoxNestedVirtualization)
    1036                 pLayoutProcessor->addWidget(m_pCheckBoxNestedVirtualization, 5, 1);
     947                pLayoutProcessor->addWidget(m_pCheckBoxNestedVirtualization, 4, 1);
    1037948        }
    1038949
    … …  
    11391050
    11401051    /* Configure 'Processor' connections: */
    1141     connect(m_pSliderProcessorCount, &QIAdvancedSlider::valueChanged, this, &UIMachineSettingsSystem::sltHandleCPUCountSliderChange);
    1142     connect(m_pSpinboxProcessorCount, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged),
    1143             this, &UIMachineSettingsSystem::sltHandleCPUCountEditorChange);
    1144     connect(m_pSliderProcessorExecCap, &QIAdvancedSlider::valueChanged, this, &UIMachineSettingsSystem::sltHandleCPUExecCapSliderChange);
     1052    connect(m_pEditorVCPU, &UIVirtualCPUEditor::sigValueChanged,
     1053            this, &UIMachineSettingsSystem::revalidate);
     1054    connect(m_pSliderProcessorExecCap, &QIAdvancedSlider::valueChanged,
     1055            this, &UIMachineSettingsSystem::sltHandleCPUExecCapSliderChange);
    11451056    connect(m_pSpinboxProcessorExecCap, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged),
    11461057            this, &UIMachineSettingsSystem::sltHandleCPUExecCapEditorChange);
    1147     connect(m_pCheckBoxNestedVirtualization, &QCheckBox::stateChanged, this, &UIMachineSettingsSystem::revalidate);
     1058    connect(m_pCheckBoxNestedVirtualization, &QCheckBox::stateChanged,
     1059            this, &UIMachineSettingsSystem::revalidate);
    11481060
    11491061    /* Configure 'Acceleration' connections: */

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsSystem.h

    r95163 r95169  
    3939class UIMotherboardFeaturesEditor;
    4040class UIPointingHIDEditor;
     41class UIVirtualCPUEditor;
    4142
    4243/** Machine settings: System page. */
    … …  
    109110private slots:
    110111
    111     /** Handles CPU count slider change. */
    112     void sltHandleCPUCountSliderChange();
    113     /** Handles CPU count editor change. */
    114     void sltHandleCPUCountEditorChange();
    115112    /** Handles CPU execution cap slider change. */
    116113    void sltHandleCPUExecCapSliderChange();
    … …  
    189186
    190187        /** Holds the 'Processor' tab instance. */
    191         QWidget          *m_pTabProcessor;
    192         /** Holds the processor count label instance. */
    193         QLabel           *m_pLabelProcessorCount;
    194         /** Holds the processor count slider instance. */
    195         QIAdvancedSlider *m_pSliderProcessorCount;
    196         /** Holds the processor count spinbox instance. */
    197         QSpinBox         *m_pSpinboxProcessorCount;
    198         /** Holds the processor count min label instance. */
    199         QLabel           *m_pLabelProcessorCountMin;
    200         /** Holds the processor count max label instance. */
    201         QLabel           *m_pLabelProcessorCountMax;
     188        QWidget            *m_pTabProcessor;
     189        /** Holds the VCPU editor instance. */
     190        UIVirtualCPUEditor *m_pEditorVCPU;
    202191        /** Holds the processor exec cap label instance. */
    203192        QLabel           *m_pLabelProcessorExecCap;

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/editors/UIWizardNewVMEditors.cpp

    r95163 r95169  
    385385
    386386    m_pBaseMemoryEditor = new UIBaseMemoryEditor;
    387     m_pVirtualCPUEditor = new UIVirtualCPUEditor(0, true);
     387    m_pVirtualCPUEditor = new UIVirtualCPUEditor;
    388388    m_pEFICheckBox      = new QCheckBox;
    389389    pHardwareLayout->addWidget(m_pBaseMemoryEditor, 0, 0, 1, 4);
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette