VirtualBox

Changeset 91257 in vbox


Ignore:
Timestamp:
Sep 15, 2021 4:33:40 PM (3 years ago)
Author:
vboxsync
Message:

FE/Qt: bugref:9996. Replacing UIDiskFormatsGroupBox with UIDiskFormatsComboBox on the new vm expert wizard.

Location:
trunk/src/VBox/Frontends/VirtualBox/src/wizards
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r91256 r91257  
    168168
    169169/*********************************************************************************************************************************
     170*   UIDiskVariantGroupBox implementation.                                                                                   *
     171*********************************************************************************************************************************/
     172
     173
     174UIDiskVariantGroupBox::UIDiskVariantGroupBox(bool fExpertMode, QWidget *pParent /* = 0 */)
     175    : UIDiskEditorGroupBox(fExpertMode, pParent)
     176    , m_pFixedCheckBox(0)
     177    , m_pSplitBox(0)
     178{
     179    prepare();
     180}
     181
     182void UIDiskVariantGroupBox::prepare()
     183{
     184    QVBoxLayout *pVariantLayout = new QVBoxLayout(this);
     185    AssertReturnVoid(pVariantLayout);
     186    m_pFixedCheckBox = new QCheckBox;
     187    m_pSplitBox = new QCheckBox;
     188    connect(m_pFixedCheckBox, &QCheckBox::toggled, this, &UIDiskVariantGroupBox::sltVariantChanged);
     189    connect(m_pSplitBox, &QCheckBox::toggled, this, &UIDiskVariantGroupBox::sltVariantChanged);
     190    pVariantLayout->addWidget(m_pFixedCheckBox);
     191    pVariantLayout->addWidget(m_pSplitBox);
     192    pVariantLayout->addStretch();
     193    retranslateUi();
     194}
     195
     196void UIDiskVariantGroupBox::retranslateUi()
     197{
     198    if (m_fExpertMode)
     199        setTitle(tr("Storage on Physical Hard Disk"));
     200    if (m_pFixedCheckBox)
     201    {
     202        m_pFixedCheckBox->setText(tr("Pre-allocate &Full Size"));
     203        m_pFixedCheckBox->setToolTip(tr("<p>Allocates the virtual disk image during VM creation."));
     204    }
     205    if (m_pSplitBox)
     206    {
     207        m_pSplitBox->setText(tr("&Split into 2GB parts"));
     208        m_pSplitBox->setToolTip(tr("<p>Splits hard disk file into 2GB parts in the host storage.</p>"));
     209    }
     210}
     211
     212qulonglong UIDiskVariantGroupBox::mediumVariant() const
     213{
     214    /* Initial value: */
     215    qulonglong uMediumVariant = (qulonglong)KMediumVariant_Max;
     216
     217    /* Exclusive options: */
     218    if (m_pFixedCheckBox && m_pFixedCheckBox->isChecked())
     219        uMediumVariant = (qulonglong)KMediumVariant_Fixed;
     220    else
     221        uMediumVariant = (qulonglong)KMediumVariant_Standard;
     222
     223    /* Additional options: */
     224    if (m_pSplitBox && m_pSplitBox->isChecked())
     225        uMediumVariant |= (qulonglong)KMediumVariant_VmdkSplit2G;
     226
     227    /* Return options: */
     228    return uMediumVariant;
     229}
     230
     231void UIDiskVariantGroupBox::setMediumVariant(qulonglong uMediumVariant)
     232{
     233    /* Exclusive options: */
     234    if (uMediumVariant & (qulonglong)KMediumVariant_Fixed)
     235    {
     236        m_pFixedCheckBox->click();
     237        m_pFixedCheckBox->setFocus();
     238    }
     239
     240    /* Additional options: */
     241    m_pSplitBox->setChecked(uMediumVariant & (qulonglong)KMediumVariant_VmdkSplit2G);
     242}
     243
     244void UIDiskVariantGroupBox::updateMediumVariantWidgetsAfterFormatChange(const CMediumFormat &mediumFormat)
     245{
     246    AssertReturnVoid(m_pFixedCheckBox && m_pSplitBox);
     247    ULONG uCapabilities = 0;
     248    QVector<KMediumFormatCapabilities> capabilities;
     249    capabilities = mediumFormat.GetCapabilities();
     250    for (int i = 0; i < capabilities.size(); i++)
     251        uCapabilities |= capabilities[i];
     252
     253    m_fIsCreateDynamicPossible = uCapabilities & KMediumFormatCapabilities_CreateDynamic;
     254    m_fIsCreateFixedPossible = uCapabilities & KMediumFormatCapabilities_CreateFixed;
     255    m_fIsCreateSplitPossible = uCapabilities & KMediumFormatCapabilities_CreateSplit2G;
     256
     257    m_pFixedCheckBox->setEnabled(true);
     258    if (!m_fIsCreateDynamicPossible)
     259    {
     260        m_pFixedCheckBox->setChecked(true);
     261        m_pFixedCheckBox->setEnabled(false);
     262    }
     263    if (!m_fIsCreateFixedPossible)
     264    {
     265        m_pFixedCheckBox->setChecked(false);
     266        m_pFixedCheckBox->setEnabled(false);
     267    }
     268
     269    m_pSplitBox->setEnabled(m_fIsCreateSplitPossible);
     270    if (!m_fIsCreateSplitPossible)
     271        m_pSplitBox->setChecked(false);
     272    emit sigMediumVariantChanged(mediumVariant());
     273}
     274
     275bool UIDiskVariantGroupBox::isComplete() const
     276{
     277    /* Make sure medium variant is correct: */
     278    return mediumVariant() != (qulonglong)KMediumVariant_Max;
     279}
     280
     281bool UIDiskVariantGroupBox::isCreateDynamicPossible() const
     282{
     283    return m_fIsCreateDynamicPossible;
     284}
     285
     286bool UIDiskVariantGroupBox::isCreateFixedPossible() const
     287{
     288    return m_fIsCreateFixedPossible;
     289}
     290
     291bool UIDiskVariantGroupBox::isCreateSplitPossible() const
     292{
     293    return m_fIsCreateSplitPossible;
     294}
     295
     296void UIDiskVariantGroupBox::sltVariantChanged()
     297{
     298    emit sigMediumVariantChanged(mediumVariant());
     299}
     300
     301
     302/*********************************************************************************************************************************
     303*   UIMediumSizeAndPathGroupBox implementation.                                                                                  *
     304*********************************************************************************************************************************/
     305
     306UIMediumSizeAndPathGroupBox::UIMediumSizeAndPathGroupBox(bool fExpertMode, QWidget *pParent, qulonglong uMinimumMediumSize)
     307    : UIDiskEditorGroupBox(fExpertMode, pParent)
     308    , m_pLocationEditor(0)
     309    , m_pLocationOpenButton(0)
     310    , m_pMediumSizeEditor(0)
     311    , m_pLocationLabel(0)
     312    , m_pSizeLabel(0)
     313{
     314    prepare(uMinimumMediumSize);
     315}
     316
     317bool UIMediumSizeAndPathGroupBox::isComplete() const
     318{
     319    if (QFileInfo(mediumPath()).exists())
     320    {
     321        m_pLocationEditor->mark(true, tr("Disk file name is not unique"));
     322        return false;
     323    }
     324    m_pLocationEditor->mark(false);
     325    return true;
     326}
     327
     328void UIMediumSizeAndPathGroupBox::prepare(qulonglong uMinimumMediumSize)
     329{
     330    QVBoxLayout *pMainLayout = new QVBoxLayout(this);
     331    /* Location widgets: */
     332    if (!m_fExpertMode)
     333        m_pLocationLabel = new QIRichTextLabel;
     334    QHBoxLayout *pLocationLayout = new QHBoxLayout;
     335    m_pLocationEditor = new QILineEdit;
     336    m_pLocationOpenButton = new QIToolButton;
     337    if (m_pLocationOpenButton)
     338    {
     339        m_pLocationOpenButton->setAutoRaise(true);
     340        m_pLocationOpenButton->setIcon(UIIconPool::iconSet(":/select_file_16px.png", "select_file_disabled_16px.png"));
     341    }
     342    if (m_pLocationEditor)
     343        m_pLocationEditor->setToolTip(tr("Holds the location of the virtual disk file."));
     344    if (m_pLocationOpenButton)
     345        m_pLocationEditor->setToolTip(tr("Opens file selection dialog so that a location for the disk file can be selected."));
     346    pLocationLayout->addWidget(m_pLocationEditor);
     347    pLocationLayout->addWidget(m_pLocationOpenButton);
     348
     349    /* Size widgets: */
     350    if (!m_fExpertMode)
     351        m_pSizeLabel = new QIRichTextLabel;
     352    m_pMediumSizeEditor = new UIMediumSizeEditor(0 /* parent */, uMinimumMediumSize);
     353
     354    /* Add widgets to main layout: */
     355    if (m_pLocationLabel)
     356        pMainLayout->addWidget(m_pLocationLabel);
     357    pMainLayout->addLayout(pLocationLayout);
     358
     359    if (m_pSizeLabel)
     360        pMainLayout->addWidget(m_pSizeLabel);
     361    pMainLayout->addWidget(m_pMediumSizeEditor);
     362
     363    connect(m_pMediumSizeEditor, &UIMediumSizeEditor::sigSizeChanged,
     364            this, &UIMediumSizeAndPathGroupBox::sigMediumSizeChanged);
     365
     366    connect(m_pLocationEditor, &QILineEdit::textChanged,
     367            this, &UIMediumSizeAndPathGroupBox::sigMediumPathChanged);
     368
     369    connect(m_pLocationOpenButton, &QIToolButton::clicked,
     370            this, &UIMediumSizeAndPathGroupBox::sigMediumLocationButtonClicked);
     371
     372    retranslateUi();
     373}
     374void UIMediumSizeAndPathGroupBox::retranslateUi()
     375{
     376    if (m_fExpertMode)
     377        setTitle(tr("Hard Disk File Location and Size"));
     378    if (m_pLocationOpenButton)
     379        m_pLocationOpenButton->setToolTip(tr("Specify a location for new virtual hard disk file..."));
     380
     381    if (!m_fExpertMode && m_pLocationLabel)
     382        m_pLocationLabel->setText(tr("Please type the name of the new virtual hard disk file into the box below or "
     383                                                    "click on the folder icon to select a different folder to create the file in."));
     384    if (!m_fExpertMode && m_pSizeLabel)
     385        m_pSizeLabel->setText(tr("Select the size of the virtual hard disk in megabytes. "
     386                                                "This size is the limit on the amount of file data "
     387                                                "that a virtual machine will be able to store on the hard disk."));
     388}
     389
     390QString UIMediumSizeAndPathGroupBox::mediumPath() const
     391{
     392    if (m_pLocationEditor)
     393        return m_pLocationEditor->text();
     394    return QString();
     395}
     396
     397void UIMediumSizeAndPathGroupBox::setMediumPath(const QString &strMediumPath)
     398{
     399    if (!m_pLocationEditor)
     400        return;
     401    m_pLocationEditor->setText(strMediumPath);
     402}
     403
     404void UIMediumSizeAndPathGroupBox::updateMediumPath(const CMediumFormat &mediumFormat, const QStringList &formatExtensions,
     405                                                   KDeviceType enmDeviceType)
     406{
     407    /* Compose virtual-disk extension: */
     408    QString strDefaultExtension = UIDiskEditorGroupBox::defaultExtension(mediumFormat, enmDeviceType);
     409    /* Update m_pLocationEditor's text if necessary: */
     410    if (!m_pLocationEditor->text().isEmpty() && !strDefaultExtension.isEmpty())
     411    {
     412        QFileInfo fileInfo(m_pLocationEditor->text());
     413        if (fileInfo.suffix() != strDefaultExtension)
     414        {
     415            QFileInfo newFileInfo(QDir(fileInfo.absolutePath()),
     416                                  QString("%1.%2").
     417                                  arg(stripFormatExtension(fileInfo.fileName(), formatExtensions)).
     418                                  arg(strDefaultExtension));
     419            setMediumPath(newFileInfo.absoluteFilePath());
     420        }
     421    }
     422}
     423
     424qulonglong UIMediumSizeAndPathGroupBox::mediumSize() const
     425{
     426    if (m_pMediumSizeEditor)
     427        return m_pMediumSizeEditor->mediumSize();
     428    return 0;
     429}
     430
     431void UIMediumSizeAndPathGroupBox::setMediumSize(qulonglong uSize)
     432{
     433    if (m_pMediumSizeEditor)
     434        return m_pMediumSizeEditor->setMediumSize(uSize);
     435}
     436
     437/* static */
     438QString UIMediumSizeAndPathGroupBox::stripFormatExtension(const QString &strFileName, const QStringList &formatExtensions)
     439{
     440    QString result(strFileName);
     441    foreach (const QString &strExtension, formatExtensions)
     442    {
     443        if (strFileName.endsWith(strExtension, Qt::CaseInsensitive))
     444        {
     445            /* Add the dot to extenstion: */
     446            QString strExtensionWithDot(strExtension);
     447            strExtensionWithDot.prepend('.');
     448            int iIndex = strFileName.lastIndexOf(strExtensionWithDot, -1, Qt::CaseInsensitive);
     449            result.remove(iIndex, strExtensionWithDot.length());
     450        }
     451    }
     452    return result;
     453}
     454
     455/*********************************************************************************************************************************
    170456*   UIDiskFormatBase implementation.                                                                                   *
    171457*********************************************************************************************************************************/
    … …  
    219505void UIDiskFormatBase::addFormat(CMediumFormat medFormat, bool fPreferred /* = false */)
    220506{
     507    AssertReturnVoid(!medFormat.isNull());
    221508    /* Check that medium format supports creation: */
    222509    ULONG uFormatCapabilities = 0;
    … …  
    267554CMediumFormat UIDiskFormatsGroupBox::mediumFormat() const
    268555{
    269     return m_pFormatButtonGroup &&
    270            m_pFormatButtonGroup->checkedButton() ? m_formatList[m_pFormatButtonGroup->checkedId()].m_comFormat : CMediumFormat();
     556    if (!m_pFormatButtonGroup)
     557        return CMediumFormat();
     558    int iIndex = m_pFormatButtonGroup->checkedId();
     559    if (iIndex < 0 || iIndex >= m_formatList.size())
     560        return CMediumFormat();
     561    return m_formatList[iIndex].m_comFormat;
    271562}
    272563
    … …  
    336627            this, &UIDiskFormatsGroupBox::sigMediumFormatChanged);
    337628}
     629
    338630/*********************************************************************************************************************************
    339 *   UIDiskVariantGroupBox implementation.                                                                                   *
     631*   UIDiskFormatsGroupBox implementation.                                                                                   *
    340632*********************************************************************************************************************************/
    341633
    342 
    343 UIDiskVariantGroupBox::UIDiskVariantGroupBox(bool fExpertMode, QWidget *pParent /* = 0 */)
    344     : UIDiskEditorGroupBox(fExpertMode, pParent)
    345     , m_pFixedCheckBox(0)
    346     , m_pSplitBox(0)
     634UIDiskFormatsComboBox::UIDiskFormatsComboBox(bool fExpertMode, KDeviceType enmDeviceType, QWidget *pParent /* = 0 */)
     635    : QIWithRetranslateUI<QIComboBox>(pParent)
     636    , UIDiskFormatBase(enmDeviceType, fExpertMode)
    347637{
    348638    prepare();
    349639}
    350640
    351 void UIDiskVariantGroupBox::prepare()
    352 {
    353     QVBoxLayout *pVariantLayout = new QVBoxLayout(this);
    354     AssertReturnVoid(pVariantLayout);
    355     m_pFixedCheckBox = new QCheckBox;
    356     m_pSplitBox = new QCheckBox;
    357     connect(m_pFixedCheckBox, &QCheckBox::toggled, this, &UIDiskVariantGroupBox::sltVariantChanged);
    358     connect(m_pSplitBox, &QCheckBox::toggled, this, &UIDiskVariantGroupBox::sltVariantChanged);
    359     pVariantLayout->addWidget(m_pFixedCheckBox);
    360     pVariantLayout->addWidget(m_pSplitBox);
    361     pVariantLayout->addStretch();
     641void UIDiskFormatsComboBox::prepare()
     642{
     643    populateFormats();
     644    foreach (const Format &format, m_formatList)
     645    {
     646        addItem(format.m_comFormat.GetName());
     647    }
     648
     649    connect(this, static_cast<void(QIComboBox::*)(int)>(&QIComboBox::currentIndexChanged),
     650            this, &UIDiskFormatsComboBox::sigMediumFormatChanged);
     651
    362652    retranslateUi();
    363653}
    364654
    365 void UIDiskVariantGroupBox::retranslateUi()
    366 {
    367     if (m_fExpertMode)
    368         setTitle(tr("Storage on Physical Hard Disk"));
    369     if (m_pFixedCheckBox)
    370     {
    371         m_pFixedCheckBox->setText(tr("Pre-allocate &Full Size"));
    372         m_pFixedCheckBox->setToolTip(tr("<p>Allocates the virtual disk image during VM creation."));
    373     }
    374     if (m_pSplitBox)
    375     {
    376         m_pSplitBox->setText(tr("&Split into 2GB parts"));
    377         m_pSplitBox->setToolTip(tr("<p>Splits hard disk file into 2GB parts in the host storage.</p>"));
    378     }
    379 }
    380 
    381 qulonglong UIDiskVariantGroupBox::mediumVariant() const
    382 {
    383     /* Initial value: */
    384     qulonglong uMediumVariant = (qulonglong)KMediumVariant_Max;
    385 
    386     /* Exclusive options: */
    387     if (m_pFixedCheckBox && m_pFixedCheckBox->isChecked())
    388         uMediumVariant = (qulonglong)KMediumVariant_Fixed;
    389     else
    390         uMediumVariant = (qulonglong)KMediumVariant_Standard;
    391 
    392     /* Additional options: */
    393     if (m_pSplitBox && m_pSplitBox->isChecked())
    394         uMediumVariant |= (qulonglong)KMediumVariant_VmdkSplit2G;
    395 
    396     /* Return options: */
    397     return uMediumVariant;
    398 }
    399 
    400 void UIDiskVariantGroupBox::setMediumVariant(qulonglong uMediumVariant)
    401 {
    402     /* Exclusive options: */
    403     if (uMediumVariant & (qulonglong)KMediumVariant_Fixed)
    404     {
    405         m_pFixedCheckBox->click();
    406         m_pFixedCheckBox->setFocus();
    407     }
    408 
    409     /* Additional options: */
    410     m_pSplitBox->setChecked(uMediumVariant & (qulonglong)KMediumVariant_VmdkSplit2G);
    411 }
    412 
    413 void UIDiskVariantGroupBox::updateMediumVariantWidgetsAfterFormatChange(const CMediumFormat &mediumFormat)
    414 {
    415     AssertReturnVoid(m_pFixedCheckBox && m_pSplitBox);
    416     ULONG uCapabilities = 0;
    417     QVector<KMediumFormatCapabilities> capabilities;
    418     capabilities = mediumFormat.GetCapabilities();
    419     for (int i = 0; i < capabilities.size(); i++)
    420         uCapabilities |= capabilities[i];
    421 
    422     m_fIsCreateDynamicPossible = uCapabilities & KMediumFormatCapabilities_CreateDynamic;
    423     m_fIsCreateFixedPossible = uCapabilities & KMediumFormatCapabilities_CreateFixed;
    424     m_fIsCreateSplitPossible = uCapabilities & KMediumFormatCapabilities_CreateSplit2G;
    425 
    426     m_pFixedCheckBox->setEnabled(true);
    427     if (!m_fIsCreateDynamicPossible)
    428     {
    429         m_pFixedCheckBox->setChecked(true);
    430         m_pFixedCheckBox->setEnabled(false);
    431     }
    432     if (!m_fIsCreateFixedPossible)
    433     {
    434         m_pFixedCheckBox->setChecked(false);
    435         m_pFixedCheckBox->setEnabled(false);
    436     }
    437 
    438     m_pSplitBox->setEnabled(m_fIsCreateSplitPossible);
    439     if (!m_fIsCreateSplitPossible)
    440         m_pSplitBox->setChecked(false);
    441     emit sigMediumVariantChanged(mediumVariant());
    442 }
    443 
    444 bool UIDiskVariantGroupBox::isComplete() const
    445 {
    446     /* Make sure medium variant is correct: */
    447     return mediumVariant() != (qulonglong)KMediumVariant_Max;
    448 }
    449 
    450 bool UIDiskVariantGroupBox::isCreateDynamicPossible() const
    451 {
    452     return m_fIsCreateDynamicPossible;
    453 }
    454 
    455 bool UIDiskVariantGroupBox::isCreateFixedPossible() const
    456 {
    457     return m_fIsCreateFixedPossible;
    458 }
    459 
    460 bool UIDiskVariantGroupBox::isCreateSplitPossible() const
    461 {
    462     return m_fIsCreateSplitPossible;
    463 }
    464 
    465 void UIDiskVariantGroupBox::sltVariantChanged()
    466 {
    467     emit sigMediumVariantChanged(mediumVariant());
    468 }
    469 
    470 
    471 /*********************************************************************************************************************************
    472 *   UIMediumSizeAndPathGroupBox implementation.                                                                                  *
    473 *********************************************************************************************************************************/
    474 
    475 UIMediumSizeAndPathGroupBox::UIMediumSizeAndPathGroupBox(bool fExpertMode, QWidget *pParent, qulonglong uMinimumMediumSize)
    476     : UIDiskEditorGroupBox(fExpertMode, pParent)
    477     , m_pLocationEditor(0)
    478     , m_pLocationOpenButton(0)
    479     , m_pMediumSizeEditor(0)
    480     , m_pLocationLabel(0)
    481     , m_pSizeLabel(0)
    482 {
    483     prepare(uMinimumMediumSize);
    484 }
    485 
    486 bool UIMediumSizeAndPathGroupBox::isComplete() const
    487 {
    488     if (QFileInfo(mediumPath()).exists())
    489     {
    490         m_pLocationEditor->mark(true, tr("Disk file name is not unique"));
    491         return false;
    492     }
    493     m_pLocationEditor->mark(false);
    494     return true;
    495 }
    496 
    497 void UIMediumSizeAndPathGroupBox::prepare(qulonglong uMinimumMediumSize)
    498 {
    499     QVBoxLayout *pMainLayout = new QVBoxLayout(this);
    500     /* Location widgets: */
    501     if (!m_fExpertMode)
    502         m_pLocationLabel = new QIRichTextLabel;
    503     QHBoxLayout *pLocationLayout = new QHBoxLayout;
    504     m_pLocationEditor = new QILineEdit;
    505     m_pLocationOpenButton = new QIToolButton;
    506     if (m_pLocationOpenButton)
    507     {
    508         m_pLocationOpenButton->setAutoRaise(true);
    509         m_pLocationOpenButton->setIcon(UIIconPool::iconSet(":/select_file_16px.png", "select_file_disabled_16px.png"));
    510     }
    511     if (m_pLocationEditor)
    512         m_pLocationEditor->setToolTip(tr("Holds the location of the virtual disk file."));
    513     if (m_pLocationOpenButton)
    514         m_pLocationEditor->setToolTip(tr("Opens file selection dialog so that a location for the disk file can be selected."));
    515     pLocationLayout->addWidget(m_pLocationEditor);
    516     pLocationLayout->addWidget(m_pLocationOpenButton);
    517 
    518     /* Size widgets: */
    519     if (!m_fExpertMode)
    520         m_pSizeLabel = new QIRichTextLabel;
    521     m_pMediumSizeEditor = new UIMediumSizeEditor(0 /* parent */, uMinimumMediumSize);
    522 
    523     /* Add widgets to main layout: */
    524     if (m_pLocationLabel)
    525         pMainLayout->addWidget(m_pLocationLabel);
    526     pMainLayout->addLayout(pLocationLayout);
    527 
    528     if (m_pSizeLabel)
    529         pMainLayout->addWidget(m_pSizeLabel);
    530     pMainLayout->addWidget(m_pMediumSizeEditor);
    531 
    532     connect(m_pMediumSizeEditor, &UIMediumSizeEditor::sigSizeChanged,
    533             this, &UIMediumSizeAndPathGroupBox::sigMediumSizeChanged);
    534 
    535     connect(m_pLocationEditor, &QILineEdit::textChanged,
    536             this, &UIMediumSizeAndPathGroupBox::sigMediumPathChanged);
    537 
    538     connect(m_pLocationOpenButton, &QIToolButton::clicked,
    539             this, &UIMediumSizeAndPathGroupBox::sigMediumLocationButtonClicked);
    540 
    541     retranslateUi();
    542 }
    543 void UIMediumSizeAndPathGroupBox::retranslateUi()
    544 {
    545     if (m_fExpertMode)
    546         setTitle(tr("Hard Disk File Location and Size"));
    547     if (m_pLocationOpenButton)
    548         m_pLocationOpenButton->setToolTip(tr("Specify a location for new virtual hard disk file..."));
    549 
    550     if (!m_fExpertMode && m_pLocationLabel)
    551         m_pLocationLabel->setText(tr("Please type the name of the new virtual hard disk file into the box below or "
    552                                                     "click on the folder icon to select a different folder to create the file in."));
    553     if (!m_fExpertMode && m_pSizeLabel)
    554         m_pSizeLabel->setText(tr("Select the size of the virtual hard disk in megabytes. "
    555                                                 "This size is the limit on the amount of file data "
    556                                                 "that a virtual machine will be able to store on the hard disk."));
    557 }
    558 
    559 QString UIMediumSizeAndPathGroupBox::mediumPath() const
    560 {
    561     if (m_pLocationEditor)
    562         return m_pLocationEditor->text();
    563     return QString();
    564 }
    565 
    566 void UIMediumSizeAndPathGroupBox::setMediumPath(const QString &strMediumPath)
    567 {
    568     if (!m_pLocationEditor)
    569         return;
    570     m_pLocationEditor->setText(strMediumPath);
    571 }
    572 
    573 void UIMediumSizeAndPathGroupBox::updateMediumPath(const CMediumFormat &mediumFormat, const QStringList &formatExtensions,
    574                                                    KDeviceType enmDeviceType)
    575 {
    576     /* Compose virtual-disk extension: */
    577     QString strDefaultExtension = UIDiskEditorGroupBox::defaultExtension(mediumFormat, enmDeviceType);
    578     /* Update m_pLocationEditor's text if necessary: */
    579     if (!m_pLocationEditor->text().isEmpty() && !strDefaultExtension.isEmpty())
    580     {
    581         QFileInfo fileInfo(m_pLocationEditor->text());
    582         if (fileInfo.suffix() != strDefaultExtension)
    583         {
    584             QFileInfo newFileInfo(QDir(fileInfo.absolutePath()),
    585                                   QString("%1.%2").
    586                                   arg(stripFormatExtension(fileInfo.fileName(), formatExtensions)).
    587                                   arg(strDefaultExtension));
    588             setMediumPath(newFileInfo.absoluteFilePath());
    589         }
    590     }
    591 }
    592 
    593 qulonglong UIMediumSizeAndPathGroupBox::mediumSize() const
    594 {
    595     if (m_pMediumSizeEditor)
    596         return m_pMediumSizeEditor->mediumSize();
    597     return 0;
    598 }
    599 
    600 void UIMediumSizeAndPathGroupBox::setMediumSize(qulonglong uSize)
    601 {
    602     if (m_pMediumSizeEditor)
    603         return m_pMediumSizeEditor->setMediumSize(uSize);
    604 }
    605 
    606 /* static */
    607 QString UIMediumSizeAndPathGroupBox::stripFormatExtension(const QString &strFileName, const QStringList &formatExtensions)
    608 {
    609     QString result(strFileName);
    610     foreach (const QString &strExtension, formatExtensions)
    611     {
    612         if (strFileName.endsWith(strExtension, Qt::CaseInsensitive))
    613         {
    614             /* Add the dot to extenstion: */
    615             QString strExtensionWithDot(strExtension);
    616             strExtensionWithDot.prepend('.');
    617             int iIndex = strFileName.lastIndexOf(strExtensionWithDot, -1, Qt::CaseInsensitive);
    618             result.remove(iIndex, strExtensionWithDot.length());
    619         }
    620     }
    621     return result;
    622 }
     655CMediumFormat UIDiskFormatsComboBox::mediumFormat() const
     656{
     657    int iIndex = currentIndex();
     658    if (iIndex < 0 || iIndex >= m_formatList.size())
     659        return CMediumFormat();
     660    return m_formatList[iIndex].m_comFormat;
     661}
     662
     663void UIDiskFormatsComboBox::setMediumFormat(const CMediumFormat &mediumFormat)
     664{
     665    int iPosition = -1;
     666    for (int i = 0; i < m_formatList.size(); ++i)
     667    {
     668        if (mediumFormat == m_formatList[i].m_comFormat)
     669            iPosition = i;
     670    }
     671    if (iPosition >= 0)
     672        setCurrentIndex(iPosition);
     673}
     674
     675void UIDiskFormatsComboBox::retranslateUi()
     676{
     677    for (int i = 0; i < count(); ++i)
     678    {
     679        if (i >= m_formatList.size())
     680            break;
     681        const CMediumFormat &format = m_formatList[i].m_comFormat;
     682        if (format.isNull())
     683            continue;
     684        UIMediumFormat enmFormat = gpConverter->fromInternalString<UIMediumFormat>(format.GetName());
     685        setItemText(i, gpConverter->toString(enmFormat));
     686    }
     687}

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/editors/UIWizardDiskEditors.h

    r91256 r91257  
    2828
    2929/* Local includes: */
     30#include "QIComboBox.h"
    3031#include "QIWithRetranslateUI.h"
    3132
    … …  
    156157
    157158    UIDiskFormatBase(KDeviceType enmDeviceType, bool fExpertMode);
     159
     160    virtual CMediumFormat mediumFormat() const = 0;
     161    virtual void setMediumFormat(const CMediumFormat &mediumFormat) = 0;
     162
    158163    const CMediumFormat &VDIMediumFormat() const;
    159164    QStringList formatExtensions() const;
    … …  
    197202
    198203    UIDiskFormatsGroupBox(bool fExpertMode, KDeviceType enmDeviceType, QWidget *pParent = 0);
    199     CMediumFormat mediumFormat() const;
    200     void setMediumFormat(const CMediumFormat &mediumFormat);
     204    virtual CMediumFormat mediumFormat() const /* override final */;
     205    virtual void setMediumFormat(const CMediumFormat &mediumFormat) /* override final */;
    201206
    202207private:
    … …  
    210215};
    211216
     217class SHARED_LIBRARY_STUFF UIDiskFormatsComboBox : public QIWithRetranslateUI<QIComboBox>, public UIDiskFormatBase
     218{
     219    Q_OBJECT;
     220
     221signals:
     222
     223    void sigMediumFormatChanged();
     224
     225public:
     226
     227    UIDiskFormatsComboBox(bool fExpertMode, KDeviceType enmDeviceType, QWidget *pParent = 0);
     228    virtual CMediumFormat mediumFormat() const /* override final */;
     229    virtual void setMediumFormat(const CMediumFormat &mediumFormat) /* override final */;
     230
     231private:
     232
     233    void prepare();
     234    virtual void retranslateUi() /* override final */;
     235};
     236
    212237#endif /* !FEQT_INCLUDED_SRC_wizards_editors_UIWizardDiskEditors_h */

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvm/UIWizardNewVMExpertPage.cpp

    r91256 r91257  
    4444    : m_pToolBox(0)
    4545    , m_pDiskVariantGroupBox(0)
    46     , m_pFormatButtonGroup(0)
     46    , m_pFormatComboBox(0)
    4747    , m_pSizeAndLocationGroup(0)
    4848    , m_pNameAndSystemEditor(0)
    … …  
    292292                this, &UIWizardNewVMExpertPage::sltMediaComboBoxIndexChanged);
    293293
    294     connect(m_pFormatButtonGroup, &UIDiskFormatsGroupBox::sigMediumFormatChanged,
    295             this, &UIWizardNewVMExpertPage::sltMediumFormatChanged);
    296 
    297     connect(m_pDiskVariantGroupBox, &UIDiskVariantGroupBox::sigMediumVariantChanged,
    298             this, &UIWizardNewVMExpertPage::sltMediumVariantChanged);
     294    if (m_pFormatComboBox)
     295        connect(m_pFormatComboBox, &UIDiskFormatsComboBox::sigMediumFormatChanged,
     296                this, &UIWizardNewVMExpertPage::sltMediumFormatChanged);
     297
     298    if (m_pDiskVariantGroupBox)
     299        connect(m_pDiskVariantGroupBox, &UIDiskVariantGroupBox::sigMediumVariantChanged,
     300                this, &UIWizardNewVMExpertPage::sltMediumVariantChanged);
    299301}
    300302
    … …  
    371373
    372374        /* Medium related properties: */
    373         if (m_pFormatButtonGroup)
    374             pWizard->setMediumFormat(m_pFormatButtonGroup->mediumFormat());
     375        if (m_pFormatComboBox)
     376            pWizard->setMediumFormat(m_pFormatComboBox->mediumFormat());
    375377        updateVirtualMediumPathFromMachinePathName();
    376378    }
    … …  
    446448    m_pSizeAndLocationGroup = new UIMediumSizeAndPathGroupBox(true, 0 /* parent */, _4M /* minimum size */);
    447449    pDiskContainerLayout->addWidget(m_pSizeAndLocationGroup, 0, 0, 2, 2);
    448     m_pFormatButtonGroup = new UIDiskFormatsGroupBox(true, KDeviceType_HardDisk, 0);
    449     pDiskContainerLayout->addWidget(m_pFormatButtonGroup, 2, 0, 4, 1);
     450    m_pFormatComboBox = new UIDiskFormatsComboBox(true, KDeviceType_HardDisk, 0);
     451    pDiskContainerLayout->addWidget(m_pFormatComboBox, 2, 0, 1, 1);
    450452    m_pDiskVariantGroupBox  = new UIDiskVariantGroupBox(true, 0);
    451453    pDiskContainerLayout->addWidget(m_pDiskVariantGroupBox, 2, 1, 2, 1);
    452 
    453454    return pNewDiskContainerWidget;
    454455}
    … …  
    652653{
    653654    AssertReturnVoid(wizardWindow<UIWizardNewVM>());
    654     if (!m_pFormatButtonGroup)
     655    if (!m_pFormatComboBox)
    655656        return;
    656657
    657658    m_userModifiedParameters << "MediumFormat";
    658     wizardWindow<UIWizardNewVM>()->setMediumFormat(m_pFormatButtonGroup->mediumFormat());
     659    wizardWindow<UIWizardNewVM>()->setMediumFormat(m_pFormatComboBox->mediumFormat());
    659660    updateDiskWidgetsAfterMediumFormatChange();
    660661    emit completeChanged();
    … …  
    822823{
    823824    UIWizardNewVM *pWizard = wizardWindow<UIWizardNewVM>();
    824     AssertReturnVoid(pWizard && m_pDiskVariantGroupBox && m_pSizeAndLocationGroup && m_pFormatButtonGroup);
     825    AssertReturnVoid(pWizard && m_pDiskVariantGroupBox && m_pSizeAndLocationGroup && m_pFormatComboBox);
    825826    const CMediumFormat &comMediumFormat = pWizard->mediumFormat();
    826827    AssertReturnVoid(!comMediumFormat.isNull());
    … …  
    832833
    833834    m_pSizeAndLocationGroup->blockSignals(true);
    834     m_pSizeAndLocationGroup->updateMediumPath(comMediumFormat, m_pFormatButtonGroup->formatExtensions(), KDeviceType_HardDisk);
     835    m_pSizeAndLocationGroup->updateMediumPath(comMediumFormat, m_pFormatComboBox->formatExtensions(), KDeviceType_HardDisk);
    835836    m_pSizeAndLocationGroup->blockSignals(false);
    836837    /* Update the wizard parameters explicitly since we blocked th signals: */
    … …  
    843844    if (m_pSizeAndLocationGroup)
    844845        m_pSizeAndLocationGroup->setEnabled(fEnable);
    845     if (m_pFormatButtonGroup)
    846         m_pFormatButtonGroup->setEnabled(fEnable);
     846    if (m_pFormatComboBox)
     847        m_pFormatComboBox->setEnabled(fEnable);
    847848    if (m_pDiskVariantGroupBox)
    848849        m_pDiskVariantGroupBox->setEnabled(fEnable);

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvm/UIWizardNewVMExpertPage.h

    r91106 r91257  
    3535class QIToolButton;
    3636class UIAdditionalUnattendedOptions;
    37 class UIDiskFormatsGroupBox;
     37class UIDiskFormatsComboBox;
    3838class UIDiskVariantGroupBox;
    3939class UIMediumSizeAndPathGroupBox;
    … …  
    127127        UIToolBox  *m_pToolBox;
    128128        UIDiskVariantGroupBox *m_pDiskVariantGroupBox;
    129         UIDiskFormatsGroupBox *m_pFormatButtonGroup;
     129        UIDiskFormatsComboBox *m_pFormatComboBox;
    130130        UIMediumSizeAndPathGroupBox *m_pSizeAndLocationGroup;
    131131        UINameAndSystemEditor *m_pNameAndSystemEditor;
Note: See TracChangeset for help on using the changeset viewer.

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