VirtualBox

Changeset 90074 in vbox


Ignore:
Timestamp:
Jul 7, 2021 10:06:10 AM (4 years ago)
Author:
vboxsync
Message:

FE/Qt: bugref:9996: Initial fixes on disk creation page

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

Legend:

Unmodified
Added
Removed

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

    r90073 r90074  
    6262
    6363
    64 
    65 
    66 enum SelectedDiskSource
    67 {
    68     SelectedDiskSource_Empty = 0,
    69     SelectedDiskSource_New,
    70     SelectedDiskSource_Existing,
    71     SelectedDiskSource_Max
    72 };
    73 
    74 Q_DECLARE_METATYPE(SelectedDiskSource);
    75 
    7664/** New Virtual Machine wizard: */
    7765class UIWizardNewVM : public UINativeWizard

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

    r90003 r90074  
    1919#include <QButtonGroup>
    2020#include <QCheckBox>
     21#include <QDir>
    2122#include <QGridLayout>
    2223#include <QGroupBox>
    … …  
    4243#include "CSystemProperties.h"
    4344
    44 // UIWizardNewVMDiskPage::UIWizardNewVMDiskPage()
    45 //     : m_fRecommendedNoDisk(false)
    46 //     , m_enmSelectedDiskSource(SelectedDiskSource_New)
    47 // {
    48 // }
    49 
    50 // SelectedDiskSource UIWizardNewVMDiskPage::selectedDiskSource() const
    51 // {
    52 //     return m_enmSelectedDiskSource;
    53 // }
    54 
    55 // void UIWizardNewVMDiskPage::setSelectedDiskSource(SelectedDiskSource enmSelectedDiskSource)
    56 // {
    57 //     m_enmSelectedDiskSource = enmSelectedDiskSource;
    58 // }
    59 
    60 // void UIWizardNewVMDiskPage::getWithFileOpenDialog()
    61 // {
    62 //     QUuid uMediumId;
    63 //     int returnCode = uiCommon().openMediumSelectorDialog(thisImp(), UIMediumDeviceType_HardDisk,
    64 //                                                            uMediumId,
    65 //                                                            fieldImp("machineFolder").toString(),
    66 //                                                            fieldImp("machineBaseName").toString(),
    67 //                                                            fieldImp("type").value<CGuestOSType>().GetId(),
    68 //                                                            false /* don't show/enable the create action: */);
    69 //     if (returnCode == static_cast<int>(UIMediumSelector::ReturnCode_Accepted) && !uMediumId.isNull())
    70 //     {
    71 //         m_pDiskSelector->setCurrentItem(uMediumId);
    72 //         m_pDiskSelector->setFocus();
    73 //     }
    74 // }
    75 
    76 // void UIWizardNewVMDiskPage::setEnableDiskSelectionWidgets(bool fEnabled)
    77 // {
    78 //     if (!m_pDiskSelector || !m_pDiskSelectionButton)
    79 //         return;
    80 
    81 //     m_pDiskSelector->setEnabled(fEnabled);
    82 //     m_pDiskSelectionButton->setEnabled(fEnabled);
    83 // }
     45QString UIWizardNewVMDiskPage::defaultExtension(const CMediumFormat &mediumFormatRef)
     46{
     47    if (!mediumFormatRef.isNull())
     48    {
     49        /* Load extension / device list: */
     50        QVector<QString> fileExtensions;
     51        QVector<KDeviceType> deviceTypes;
     52        CMediumFormat mediumFormat(mediumFormatRef);
     53        mediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
     54        for (int i = 0; i < fileExtensions.size(); ++i)
     55            if (deviceTypes[i] == KDeviceType_HardDisk)
     56                return fileExtensions[i].toLower();
     57    }
     58    AssertMsgFailed(("Extension can't be NULL!\n"));
     59    return QString();
     60}
     61
     62QString UIWizardNewVMDiskPage::toFileName(const QString &strName, const QString &strExtension)
     63{
     64    /* Convert passed name to native separators (it can be full, actually): */
     65    QString strFileName = QDir::toNativeSeparators(strName);
     66
     67    /* Remove all trailing dots to avoid multiple dots before extension: */
     68    int iLen;
     69    while (iLen = strFileName.length(), iLen > 0 && strFileName[iLen - 1] == '.')
     70        strFileName.truncate(iLen - 1);
     71
     72    /* Add passed extension if its not done yet: */
     73    if (QFileInfo(strFileName).suffix().toLower() != strExtension)
     74        strFileName += QString(".%1").arg(strExtension);
     75
     76    /* Return result: */
     77    return strFileName;
     78}
     79
     80QString UIWizardNewVMDiskPage::absoluteFilePath(const QString &strFileName, const QString &strPath)
     81{
     82    /* Wrap file-info around received file name: */
     83    QFileInfo fileInfo(strFileName);
     84    /* If path-info is relative or there is no path-info at all: */
     85    if (fileInfo.fileName() == strFileName || fileInfo.isRelative())
     86    {
     87        /* Resolve path on the basis of  path we have: */
     88        fileInfo = QFileInfo(strPath, strFileName);
     89    }
     90    /* Return full absolute hard disk file path: */
     91    return QDir::toNativeSeparators(fileInfo.absoluteFilePath());
     92}
     93
     94QUuid UIWizardNewVMDiskPage::getWithFileOpenDialog(const QString &strOSTypeID,
     95                                                   const QString &strMachineFolder,
     96                                                   const QString &strMachineBaseName,
     97                                                   QWidget *pCaller)
     98{
     99    QUuid uMediumId;
     100    int returnCode = uiCommon().openMediumSelectorDialog(pCaller, UIMediumDeviceType_HardDisk,
     101                                                         uMediumId,
     102                                                         strMachineFolder,
     103                                                         strMachineBaseName,
     104                                                         strOSTypeID,
     105                                                         false /* don't show/enable the create action: */);
     106    if (returnCode != static_cast<int>(UIMediumSelector::ReturnCode_Accepted))
     107        return QUuid();
     108    return uMediumId;
     109}
     110
    84111
    85112// QWidget *UIWizardNewVMDiskPage::createNewDiskWidgets()
    … …  
    88115// }
    89116
     117    // registerField("mediumFormat", this, "mediumFormat");
     118    // registerField("mediumVariant" /* KMediumVariant */, this, "mediumVariant");
     119    // registerField("mediumPath", this, "mediumPath");
     120    // registerField("mediumSize", this, "mediumSize");
    90121
    91122UIWizardNewVMDiskPageBasic::UIWizardNewVMDiskPageBasic()
    … …  
    105136    , m_pFixedCheckBox(0)
    106137    , m_pSplitBox(0)
    107     , m_fUserSetSize(false)
     138    , m_enmSelectedDiskSource(SelectedDiskSource_New)
     139    , m_fRecommendedNoDisk(false)
    108140{
    109141    prepare();
    … …  
    111143    // qRegisterMetaType<SelectedDiskSource>();
    112144
    113     // /* We do not have any UI elements for HDD format selection since we default to VDI in case of guided wizard mode: */
    114     // bool fFoundVDI = false;
    115     // CSystemProperties properties = uiCommon().virtualBox().GetSystemProperties();
    116     // const QVector<CMediumFormat> &formats = properties.GetMediumFormats();
    117     // foreach (const CMediumFormat &format, formats)
    118     // {
    119     //     if (format.GetName() == "VDI")
    120     //     {
    121     //         m_mediumFormat = format;
    122     //         fFoundVDI = true;
    123     //     }
    124     // }
    125     // if (!fFoundVDI)
    126     //     AssertMsgFailed(("No medium format corresponding to VDI could be found!"));
    127 
    128     // m_strDefaultExtension =  defaultExtension(m_mediumFormat);
    129 
    130     // /* Since the medium format is static we can decide widget visibility here: */
    131     // setWidgetVisibility(m_mediumFormat);
     145    /* We do not have any UI elements for HDD format selection since we default to VDI in case of guided wizard mode: */
     146    bool fFoundVDI = false;
     147    CSystemProperties properties = uiCommon().virtualBox().GetSystemProperties();
     148    const QVector<CMediumFormat> &formats = properties.GetMediumFormats();
     149    foreach (const CMediumFormat &format, formats)
     150    {
     151        if (format.GetName() == "VDI")
     152        {
     153            m_mediumFormat = format;
     154            fFoundVDI = true;
     155        }
     156    }
     157    if (!fFoundVDI)
     158        AssertMsgFailed(("No medium format corresponding to VDI could be found!"));
     159
     160    m_strDefaultExtension =  UIWizardNewVMDiskPage::defaultExtension(m_mediumFormat);
     161
     162    /* Since the medium format is static we can decide widget visibility here: */
     163    setWidgetVisibility(m_mediumFormat);
    132164}
    133165
    … …  
    139171QString UIWizardNewVMDiskPageBasic::mediumPath() const
    140172{
    141     return QString();//absoluteFilePath(toFileName(m_strDefaultName, m_strDefaultExtension), m_strDefaultPath);
     173    return UIWizardNewVMDiskPage::absoluteFilePath(UIWizardNewVMDiskPage::toFileName(m_strDefaultName,
     174                                                                                     m_strDefaultExtension), m_strDefaultPath);
    142175}
    143176
    … …  
    151184
    152185    pMainLayout->addStretch();
    153     // setEnableDiskSelectionWidgets(m_enmSelectedDiskSource == SelectedDiskSource_Existing);
    154     // setEnableNewDiskWidgets(m_enmSelectedDiskSource == SelectedDiskSource_New);
     186    setEnableDiskSelectionWidgets(m_enmSelectedDiskSource == SelectedDiskSource_Existing);
     187    setEnableNewDiskWidgets(m_enmSelectedDiskSource == SelectedDiskSource_New);
    155188
    156189    createConnections();
    … …  
    222255void UIWizardNewVMDiskPageBasic::sltSelectedDiskSourceChanged()
    223256{
    224     // if (!m_pDiskSourceButtonGroup)
    225     //     return;
    226 
    227     // if (m_pDiskSourceButtonGroup->checkedButton() == m_pDiskEmpty)
    228     //     setSelectedDiskSource(SelectedDiskSource_Empty);
    229     // else if (m_pDiskSourceButtonGroup->checkedButton() == m_pDiskExisting)
    230     // {
    231     //     setSelectedDiskSource(SelectedDiskSource_Existing);
    232     //     setVirtualDiskFromDiskCombo();
    233     // }
    234     // else
    235     //     setSelectedDiskSource(SelectedDiskSource_New);
    236 
    237     // setEnableDiskSelectionWidgets(m_enmSelectedDiskSource == SelectedDiskSource_Existing);
    238     // setEnableNewDiskWidgets(m_enmSelectedDiskSource == SelectedDiskSource_New);
    239 
    240     // completeChanged();
     257    if (!m_pDiskSourceButtonGroup)
     258        return;
     259
     260    if (m_pDiskSourceButtonGroup->checkedButton() == m_pDiskEmpty)
     261        m_enmSelectedDiskSource = SelectedDiskSource_Empty;
     262    else if (m_pDiskSourceButtonGroup->checkedButton() == m_pDiskExisting)
     263    {
     264        m_enmSelectedDiskSource = SelectedDiskSource_Existing;
     265        setVirtualDiskFromDiskCombo();
     266    }
     267    else
     268        m_enmSelectedDiskSource = SelectedDiskSource_New;
     269
     270    setEnableDiskSelectionWidgets(m_enmSelectedDiskSource == SelectedDiskSource_Existing);
     271    setEnableNewDiskWidgets(m_enmSelectedDiskSource == SelectedDiskSource_New);
     272
     273    emit completeChanged();
    241274}
    242275
    … …  
    250283void UIWizardNewVMDiskPageBasic::sltGetWithFileOpenDialog()
    251284{
    252     //getWithFileOpenDialog();
     285    UIWizardNewVM *pWizard = qobject_cast<UIWizardNewVM*>(wizard());
     286    AssertReturnVoid(pWizard);
     287    const CGuestOSType &comOSType = pWizard->guestOSType();
     288    AssertReturnVoid(!comOSType.isNull());
     289    QUuid uMediumId = UIWizardNewVMDiskPage::getWithFileOpenDialog(comOSType.GetId(),
     290                                                                   pWizard->machineFolder(),
     291                                                                   pWizard->machineBaseName(),
     292                                                                   this);
     293    if (!uMediumId.isNull())
     294    {
     295        m_pDiskSelector->setCurrentItem(uMediumId);
     296        m_pDiskSelector->setFocus();
     297    }
    253298}
    254299
    … …  
    257302    setTitle(UIWizardNewVM::tr("Virtual Hard disk"));
    258303
    259     // QString strRecommendedHDD = field("type").value<CGuestOSType>().isNull() ? QString() :
    260     //                             UICommon::formatSize(field("type").value<CGuestOSType>().GetRecommendedHDD());
    261304    if (m_pLabel)
    262305        m_pLabel->setText(UIWizardNewVM::tr("<p>If you wish you can add a virtual hard disk to the new machine. "
    … …  
    308351void UIWizardNewVMDiskPageBasic::initializePage()
    309352{
    310 //     retranslateUi();
    311 
    312 //     if (!field("type").canConvert<CGuestOSType>())
    313 //         return;
    314 
    315 //     CGuestOSType type = field("type").value<CGuestOSType>();
    316 
    317 //     if (type.GetRecommendedHDD() != 0)
    318 //     {
    319 //         if (m_pDiskNew)
    320 //         {
    321 //             m_pDiskNew->setFocus();
    322 //             m_pDiskNew->setChecked(true);
    323 //         }
    324 //         setSelectedDiskSource(SelectedDiskSource_New);
    325 //         m_fRecommendedNoDisk = false;
    326 //     }
    327 //     else
    328 //     {
    329 //         if (m_pDiskEmpty)
    330 //         {
    331 //             m_pDiskEmpty->setFocus();
    332 //             m_pDiskEmpty->setChecked(true);
    333 //         }
    334 //         setSelectedDiskSource(SelectedDiskSource_Empty);
    335 //         m_fRecommendedNoDisk = true;
    336 //     }
    337 //     if (m_pDiskSelector)
    338 //         m_pDiskSelector->setCurrentIndex(0);
    339 //     setEnableDiskSelectionWidgets(m_enmSelectedDiskSource == SelectedDiskSource_Existing);
    340 //     setEnableNewDiskWidgets(m_enmSelectedDiskSource == SelectedDiskSource_New);
    341 
    342 //     /* We set the medium name and path according to machine name/path and do let user change these in the guided mode: */
    343 //     QString strDefaultName = fieldImp("machineBaseName").toString();
    344 //     m_strDefaultName = strDefaultName.isEmpty() ? QString("NewVirtualDisk1") : strDefaultName;
    345 //     m_strDefaultPath = fieldImp("machineFolder").toString();
    346 //     /* Set the recommended disk size if user has already not done so: */
    347 //     if (m_pMediumSizeEditor && !m_fUserSetSize)
    348 //     {
    349 //         m_pMediumSizeEditor->blockSignals(true);
    350 //         setMediumSize(fieldImp("type").value<CGuestOSType>().GetRecommendedHDD());
    351 //         m_pMediumSizeEditor->blockSignals(false);
    352 //     }
     353     retranslateUi();
     354
     355     UIWizardNewVM *pWizard = qobject_cast<UIWizardNewVM*>(wizard());
     356     AssertReturnVoid(pWizard);
     357
     358     LONG64 iRecommendedSize = 0;
     359     CGuestOSType type = pWizard->guestOSType();
     360     if (!type.isNull())
     361     {
     362         iRecommendedSize = type.GetRecommendedHDD();
     363         if (iRecommendedSize != 0)
     364         {
     365             if (m_pDiskNew)
     366             {
     367                 m_pDiskNew->setFocus();
     368                 m_pDiskNew->setChecked(true);
     369             }
     370             m_enmSelectedDiskSource = SelectedDiskSource_New;
     371             m_fRecommendedNoDisk = false;
     372         }
     373         else
     374         {
     375             if (m_pDiskEmpty)
     376             {
     377                 m_pDiskEmpty->setFocus();
     378                 m_pDiskEmpty->setChecked(true);
     379             }
     380             m_enmSelectedDiskSource = SelectedDiskSource_Empty;
     381             m_fRecommendedNoDisk = true;
     382         }
     383     }
     384
     385    if (m_pDiskSelector)
     386        m_pDiskSelector->setCurrentIndex(0);
     387    setEnableDiskSelectionWidgets(m_enmSelectedDiskSource == SelectedDiskSource_Existing);
     388    setEnableNewDiskWidgets(m_enmSelectedDiskSource == SelectedDiskSource_New);
     389
     390    /* We set the medium name and path according to machine name/path and do not allow user change these in the guided mode: */
     391    const QString &strDefaultName = pWizard->machineBaseName();
     392    m_strDefaultName = strDefaultName.isEmpty() ? QString("NewVirtualDisk1") : strDefaultName;
     393    m_strDefaultPath = pWizard->machineFolder();
     394    /* Set the recommended disk size if user has already not done so: */
     395    if (m_pMediumSizeEditor && !m_userModifiedParameters.contains("MediumSize"))
     396    {
     397        m_pMediumSizeEditor->blockSignals(true);
     398        m_pMediumSizeEditor->setMediumSize(iRecommendedSize);
     399        m_pMediumSizeEditor->blockSignals(false);
     400    }
    353401}
    354402
    … …  
    437485void UIWizardNewVMDiskPageBasic::sltHandleSizeEditorChange()
    438486{
    439     m_fUserSetSize = true;
     487    m_userModifiedParameters << "MediumSize";
    440488}
    441489
    442490void UIWizardNewVMDiskPageBasic::setEnableNewDiskWidgets(bool fEnable)
    443491{
    444     Q_UNUSED(fEnable);
    445     // if (m_pMediumSizeEditor)
    446     //     m_pMediumSizeEditor->setEnabled(fEnable);
    447     // if (m_pMediumSizeEditorLabel)
    448     //     m_pMediumSizeEditorLabel->setEnabled(fEnable);
    449     // if (m_pFixedCheckBox)
    450     //     m_pFixedCheckBox->setEnabled(fEnable);
     492    if (m_pMediumSizeEditor)
     493        m_pMediumSizeEditor->setEnabled(fEnable);
     494    if (m_pMediumSizeEditorLabel)
     495        m_pMediumSizeEditorLabel->setEnabled(fEnable);
     496    if (m_pFixedCheckBox)
     497        m_pFixedCheckBox->setEnabled(fEnable);
    451498}
    452499
    453500void UIWizardNewVMDiskPageBasic::setVirtualDiskFromDiskCombo()
    454501{
    455     // AssertReturnVoid(m_pDiskSelector);
    456     // UIWizardNewVM *pWizard = wizardImp();
    457     // AssertReturnVoid(pWizard);
    458     // pWizard->setVirtualDisk(m_pDiskSelector->id());
     502    AssertReturnVoid(m_pDiskSelector);
     503    UIWizardNewVM *pWizard = qobject_cast<UIWizardNewVM*>(wizard());
     504    AssertReturnVoid(pWizard);
     505    pWizard->setVirtualDisk(m_pDiskSelector->id());
    459506}
    460507
    … …  
    528575    return pContainerWidget;
    529576}
     577
     578void UIWizardNewVMDiskPageBasic::setEnableDiskSelectionWidgets(bool fEnabled)
     579{
     580    if (!m_pDiskSelector || !m_pDiskSelectionButton)
     581        return;
     582
     583    m_pDiskSelector->setEnabled(fEnabled);
     584    m_pDiskSelectionButton->setEnabled(fEnabled);
     585}
     586
     587void UIWizardNewVMDiskPageBasic::setWidgetVisibility(CMediumFormat &mediumFormat)
     588{
     589    ULONG uCapabilities = 0;
     590    QVector<KMediumFormatCapabilities> capabilities;
     591    capabilities = mediumFormat.GetCapabilities();
     592    for (int i = 0; i < capabilities.size(); i++)
     593        uCapabilities |= capabilities[i];
     594
     595    bool fIsCreateDynamicPossible = uCapabilities & KMediumFormatCapabilities_CreateDynamic;
     596    bool fIsCreateFixedPossible = uCapabilities & KMediumFormatCapabilities_CreateFixed;
     597    bool fIsCreateSplitPossible = uCapabilities & KMediumFormatCapabilities_CreateSplit2G;
     598    if (m_pFixedCheckBox)
     599    {
     600        if (!fIsCreateDynamicPossible)
     601        {
     602            m_pFixedCheckBox->setChecked(true);
     603            m_pFixedCheckBox->setEnabled(false);
     604        }
     605        if (!fIsCreateFixedPossible)
     606        {
     607            m_pFixedCheckBox->setChecked(false);
     608            m_pFixedCheckBox->setEnabled(false);
     609        }
     610    }
     611    if (m_pDynamicLabel)
     612        m_pDynamicLabel->setHidden(!fIsCreateDynamicPossible);
     613    if (m_pFixedLabel)
     614        m_pFixedLabel->setHidden(!fIsCreateFixedPossible);
     615    if (m_pFixedCheckBox)
     616        m_pFixedCheckBox->setHidden(!fIsCreateFixedPossible);
     617    if (m_pSplitLabel)
     618        m_pSplitLabel->setHidden(!fIsCreateSplitPossible);
     619    if (m_pSplitBox)
     620        m_pSplitBox->setHidden(!fIsCreateSplitPossible);
     621}

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

    r90003 r90074  
    2424/* Qt includes: */
    2525#include <QVariant>
     26#include <QSet>
    2627
    2728/* GUI includes: */
    … …  
    4344class UIMediaComboBox;
    4445
     46enum SelectedDiskSource
     47{
     48    SelectedDiskSource_Empty = 0,
     49    SelectedDiskSource_New,
     50    SelectedDiskSource_Existing,
     51    SelectedDiskSource_Max
     52};
    4553
    46 // class UIWizardNewVMDiskPage : public UIWizardPageBase
    47 // {
    48 
    49 // public:
    50 
    51 
    52 // protected:
    53 
    54 //     UIWizardNewVMDiskPage();
     54namespace UIWizardNewVMDiskPage
     55{
     56    QString defaultExtension(const CMediumFormat &mediumFormatRef);
     57    QString toFileName(const QString &strName, const QString &strExtension);
     58    QUuid getWithFileOpenDialog(const QString &strOSTypeID,
     59                                const QString &strMachineFolder,
     60                                const QString &strMachineBaseName,
     61                                QWidget *pCaller);
     62    QString absoluteFilePath(const QString &strFileName, const QString &strPath);
     63}
    5564
    5665//     SelectedDiskSource selectedDiskSource() const;
    5766//     void setSelectedDiskSource(SelectedDiskSource enmSelectedDiskSource);
    5867//     bool getWithNewVirtualDiskWizard();
    59 
    6068//     virtual QWidget *createDiskWidgets();
    6169//     virtual QWidget *createNewDiskWidgets();
    6270//     void getWithFileOpenDialog();
    6371//     void retranslateWidgets();
    64 
    6572//     void setEnableDiskSelectionWidgets(bool fEnable);
    66 //     bool m_fRecommendedNoDisk;
    67 
    68 //     SelectedDiskSource m_enmSelectedDiskSource;
    69 // };
    7073
    7174class UIWizardNewVMDiskPageBasic : public UINativeWizardPage
    … …  
    9699    void createConnections();
    97100    QWidget *createNewDiskWidgets();
    98     void retranslateUi();
    99     void initializePage();
    100101    void cleanupPage();
    101102    void setEnableNewDiskWidgets(bool fEnable);
    … …  
    103104    QWidget *createDiskWidgets();
    104105    QWidget *createMediumVariantWidgets(bool fWithLabels);
    105     bool isComplete() const;
    106     virtual bool validatePage() /* override */;
     106
     107    virtual void retranslateUi() /* override final */;
     108    virtual void initializePage() /* override final */;
     109    virtual bool isComplete() const /* override final */;
     110    virtual bool validatePage() /* override final */;
     111
     112    void setEnableDiskSelectionWidgets(bool fEnabled);
     113    void setWidgetVisibility(CMediumFormat &mediumFormat);
    107114
    108115    /** @name Widgets
    … …  
    125132    /** @} */
    126133
    127     /** This is set to true when user manually set the size. */
    128     bool m_fUserSetSize;
    129134    /** For guided new vm wizard VDI is the only format. Thus we have no UI item for it. */
    130135    CMediumFormat m_mediumFormat;
     136    SelectedDiskSource m_enmSelectedDiskSource;
     137    bool m_fRecommendedNoDisk;
     138    QString m_strDefaultName;
     139    QString m_strDefaultPath;
     140    QString m_strDefaultExtension;
     141    QSet<QString> m_userModifiedParameters;
    131142};
    132143

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

    r90003 r90074  
    7272    /* Register classes: */
    7373    qRegisterMetaType<CMedium>();
    74     qRegisterMetaType<SelectedDiskSource>();
     74    //qRegisterMetaType<SelectedDiskSource>();
    7575
    7676    /* Register fields: */
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