VirtualBox

Changeset 91106 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Sep 3, 2021 2:37:45 PM (3 years ago)
Author:
vboxsync
Message:

FE/Qt: bugref:9996. Adding a summary page to the new vm wizard guided mode.

Location:
trunk/src/VBox/Frontends/VirtualBox
Files:
7 edited
2 copied

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk

    r91062 r91106  
    665665        src/wizards/newvm/UIWizardNewVMDiskPage.h \
    666666        src/wizards/newvm/UIWizardNewVMExpertPage.h \
     667        src/wizards/newvm/UIWizardNewVMSummaryPage.h \
    667668        src/wizards/clonevm/UIWizardCloneVM.h \
    668669        src/wizards/clonevm/UIWizardCloneVMNamePathPage.h \
    … …  
    11731174        src/wizards/newvm/UIWizardNewVMDiskPage.cpp \
    11741175        src/wizards/newvm/UIWizardNewVMExpertPage.cpp \
     1176        src/wizards/newvm/UIWizardNewVMSummaryPage.cpp \
    11751177        src/wizards/clonevm/UIWizardCloneVM.cpp \
    11761178        src/wizards/clonevm/UIWizardCloneVMNamePathPage.cpp \

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

    r91059 r91106  
    2929#include "UIWizardNewVMDiskPage.h"
    3030#include "UIWizardNewVMExpertPage.h"
     31#include "UIWizardNewVMSummaryPage.h"
    3132#include "UIMessageCenter.h"
    3233#include "UIMedium.h"
    … …  
    6970    , m_uMediumVariant(0)
    7071    , m_uMediumSize(0)
     72    , m_enmDiskSource(SelectedDiskSource_New)
    7173{
    7274#ifndef VBOX_WS_MAC
    … …  
    9496            addPage(new UIWizardNewVMHardwarePage);
    9597            addPage(new UIWizardNewVMDiskPage);
     98            addPage(new UIWizardNewVMSummaryPage);
    9699            break;
    97100        }
    … …  
    885888}
    886889
     890SelectedDiskSource UIWizardNewVM::diskSource() const
     891{
     892    return m_enmDiskSource;
     893}
     894
     895void UIWizardNewVM::setDiskSource(SelectedDiskSource enmDiskSource)
     896{
     897    m_enmDiskSource = enmDiskSource;
     898}
     899
    887900const UIUnattendedInstallData &UIWizardNewVM::unattendedInstallData() const
    888901{

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

    r91031 r91106  
    3131#include "CMediumFormat.h"
    3232#include "CGuestOSType.h"
     33
     34enum SelectedDiskSource
     35{
     36    SelectedDiskSource_Empty = 0,
     37    SelectedDiskSource_New,
     38    SelectedDiskSource_Existing,
     39    SelectedDiskSource_Max
     40};
    3341
    3442/** Container for unattended install related data. */
    … …  
    8088
    8189    /** @name Setter/getters for vm parameters
    82      * @{ */
    83        const QString &machineFilePath() const;
    84        void setMachineFilePath(const QString &strMachineFilePath);
    85 
    86        const QString &machineFolder() const;
    87        void setMachineFolder(const QString &strMachineFolder);
    88 
    89        const QString &machineBaseName() const;
    90        void setMachineBaseName(const QString &strMachineBaseName);
    91 
    92       const QString &createdMachineFolder() const;
    93       void setCreatedMachineFolder(const QString &strCreatedMachineFolder);
    94 
    95       const QString &detectedOSTypeId() const;
    96       void setDetectedOSTypeId(const QString &strDetectedOSTypeId);
    97 
    98       const QString &guestOSFamilyId() const;
    99       void setGuestOSFamilyId(const QString &strGuestOSFamilyId);
    100 
    101       const CGuestOSType &guestOSType() const;
    102       void setGuestOSType(const CGuestOSType &guestOSType);
    103 
    104       bool installGuestAdditions() const;
    105       void setInstallGuestAdditions(bool fInstallGA);
    106 
    107       bool startHeadless() const;
    108       void setStartHeadless(bool fStartHeadless);
    109 
    110       bool skipUnattendedInstall() const;
    111       void setSkipUnattendedInstall(bool fSkipUnattendedInstall);
    112 
    113       bool EFIEnabled() const;
    114       void setEFIEnabled(bool fEnabled);
    115 
    116       const QString &ISOFilePath() const;
    117       void setISOFilePath(const QString &strISOFilePath);
    118 
    119       const QString &userName() const;
    120       void setUserName(const QString &strUserName);
    121 
    122       const QString &password() const;
    123       void setPassword(const QString &strPassword);
    124 
    125       const QString &guestAdditionsISOPath() const;
    126       void setGuestAdditionsISOPath(const QString &strGAISOPath);
    127 
    128       const QString &hostnameDomainName() const;
    129       void setHostnameDomainName(const QString &strHostnameDomainName);
    130 
    131       const QString &productKey() const;
    132       void setProductKey(const QString &productKey);
    133 
    134       int CPUCount() const;
    135       void setCPUCount(int iCPUCount);
    136 
    137       int memorySize() const;
    138       void setMemorySize(int iMemory);
    139 
    140       qulonglong mediumVariant() const;
    141       void setMediumVariant(qulonglong uMediumVariant);
    142 
    143       const CMediumFormat &mediumFormat();
    144       void setMediumFormat(const CMediumFormat &mediumFormat);
    145 
    146       const QString &mediumPath() const;
    147       void setMediumPath(const QString &strMediumPath);
    148 
    149       qulonglong mediumSize() const;
    150       void setMediumSize(qulonglong mediumSize);
     90      * @{ */
     91        const QString &machineFilePath() const;
     92        void setMachineFilePath(const QString &strMachineFilePath);
     93
     94        const QString &machineFolder() const;
     95        void setMachineFolder(const QString &strMachineFolder);
     96
     97        const QString &machineBaseName() const;
     98        void setMachineBaseName(const QString &strMachineBaseName);
     99
     100        const QString &createdMachineFolder() const;
     101        void setCreatedMachineFolder(const QString &strCreatedMachineFolder);
     102
     103        const QString &detectedOSTypeId() const;
     104        void setDetectedOSTypeId(const QString &strDetectedOSTypeId);
     105
     106        const QString &guestOSFamilyId() const;
     107        void setGuestOSFamilyId(const QString &strGuestOSFamilyId);
     108
     109        const CGuestOSType &guestOSType() const;
     110        void setGuestOSType(const CGuestOSType &guestOSType);
     111
     112        bool installGuestAdditions() const;
     113        void setInstallGuestAdditions(bool fInstallGA);
     114
     115        bool startHeadless() const;
     116        void setStartHeadless(bool fStartHeadless);
     117
     118        bool skipUnattendedInstall() const;
     119        void setSkipUnattendedInstall(bool fSkipUnattendedInstall);
     120
     121        bool EFIEnabled() const;
     122        void setEFIEnabled(bool fEnabled);
     123
     124        const QString &ISOFilePath() const;
     125        void setISOFilePath(const QString &strISOFilePath);
     126
     127        const QString &userName() const;
     128        void setUserName(const QString &strUserName);
     129
     130        const QString &password() const;
     131        void setPassword(const QString &strPassword);
     132
     133        const QString &guestAdditionsISOPath() const;
     134        void setGuestAdditionsISOPath(const QString &strGAISOPath);
     135
     136        const QString &hostnameDomainName() const;
     137        void setHostnameDomainName(const QString &strHostnameDomainName);
     138
     139        const QString &productKey() const;
     140        void setProductKey(const QString &productKey);
     141
     142        int CPUCount() const;
     143        void setCPUCount(int iCPUCount);
     144
     145        int memorySize() const;
     146        void setMemorySize(int iMemory);
     147
     148        qulonglong mediumVariant() const;
     149        void setMediumVariant(qulonglong uMediumVariant);
     150
     151        const CMediumFormat &mediumFormat();
     152        void setMediumFormat(const CMediumFormat &mediumFormat);
     153
     154        const QString &mediumPath() const;
     155        void setMediumPath(const QString &strMediumPath);
     156
     157        qulonglong mediumSize() const;
     158        void setMediumSize(qulonglong mediumSize);
     159
     160        SelectedDiskSource diskSource() const;
     161        void setDiskSource(SelectedDiskSource enmDiskSource);
    151162    /** @} */
    152163
    … …  
    219230       QString m_strMediumPath;
    220231       qulonglong m_uMediumSize;
     232       SelectedDiskSource m_enmDiskSource;
    221233    /** @} */
    222234};

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

    r91059 r91106  
    7272    , m_pFixedLabel(0)
    7373    , m_pFixedCheckBox(0)
    74     , m_enmSelectedDiskSource(SelectedDiskSource_New)
    7574    , m_fRecommendedNoDisk(false)
    7675    , m_fVDIFormatFound(false)
    … …  
    8180}
    8281
    83 
    8482void UIWizardNewVMDiskPage::prepare()
    8583{
    … …  
    9189
    9290    pMainLayout->addStretch();
    93     setEnableDiskSelectionWidgets(m_enmSelectedDiskSource == SelectedDiskSource_Existing);
    94     setEnableNewDiskWidgets(m_enmSelectedDiskSource == SelectedDiskSource_New);
    9591
    9692    createConnections();
    … …  
    162158    m_userModifiedParameters << "SelectedDiskSource";
    163159    if (m_pDiskSourceButtonGroup->checkedButton() == m_pDiskEmpty)
    164         m_enmSelectedDiskSource = SelectedDiskSource_Empty;
     160        pWizard->setDiskSource(SelectedDiskSource_Empty);
    165161    else if (m_pDiskSourceButtonGroup->checkedButton() == m_pDiskExisting)
    166162    {
    167         m_enmSelectedDiskSource = SelectedDiskSource_Existing;
     163        pWizard->setDiskSource(SelectedDiskSource_Existing);
    168164        pWizard->setVirtualDisk(m_pDiskSelector->id());
    169165    }
    170166    else
    171         m_enmSelectedDiskSource = SelectedDiskSource_New;
    172 
    173     setEnableDiskSelectionWidgets(m_enmSelectedDiskSource == SelectedDiskSource_Existing);
    174     setEnableNewDiskWidgets(m_enmSelectedDiskSource == SelectedDiskSource_New);
     167        pWizard->setDiskSource(SelectedDiskSource_New);
     168
     169    setEnableDiskSelectionWidgets(pWizard->diskSource() == SelectedDiskSource_Existing);
     170    setEnableNewDiskWidgets(pWizard->diskSource() == SelectedDiskSource_New);
    175171
    176172    emit completeChanged();
    … …  
    262258                m_pDiskNew->setChecked(true);
    263259            }
    264             m_enmSelectedDiskSource = SelectedDiskSource_New;
     260            pWizard->setDiskSource(SelectedDiskSource_New);
    265261            m_fRecommendedNoDisk = false;
    266262        }
    … …  
    272268                m_pDiskEmpty->setChecked(true);
    273269            }
    274             m_enmSelectedDiskSource = SelectedDiskSource_Empty;
     270            pWizard->setDiskSource(SelectedDiskSource_Empty);
    275271            m_fRecommendedNoDisk = true;
    276272        }
    … …  
    279275    if (m_pDiskSelector && !m_userModifiedParameters.contains("SelectedExistingMediumIndex"))
    280276        m_pDiskSelector->setCurrentIndex(0);
    281     setEnableDiskSelectionWidgets(m_enmSelectedDiskSource == SelectedDiskSource_Existing);
    282     setEnableNewDiskWidgets(m_enmSelectedDiskSource == SelectedDiskSource_New);
     277    setEnableDiskSelectionWidgets(pWizard->diskSource() == SelectedDiskSource_Existing);
     278    setEnableNewDiskWidgets(pWizard->diskSource() == SelectedDiskSource_New);
    283279
    284280    if (!m_fVDIFormatFound)
    … …  
    339335
    340336    const qulonglong uSize = pWizard->mediumSize();
    341     if (m_enmSelectedDiskSource == SelectedDiskSource_New)
     337    if (pWizard->diskSource() == SelectedDiskSource_New)
    342338        return uSize >= m_uMediumSizeMin && uSize <= m_uMediumSizeMax;
    343339
    344     if (m_enmSelectedDiskSource == SelectedDiskSource_Existing)
     340    if (pWizard->diskSource() == SelectedDiskSource_Existing)
    345341        return !pWizard->virtualDisk().isNull();
    346342
    347343    return true;
    348 }
    349 
    350 bool UIWizardNewVMDiskPage::validatePage()
    351 {
    352     bool fResult = true;
    353     UIWizardNewVM *pWizard = wizardWindow<UIWizardNewVM>();
    354     AssertReturn(pWizard, false);
    355 
    356     /* Make sure user really intents to creae a vm with no hard drive: */
    357     if (m_enmSelectedDiskSource == SelectedDiskSource_Empty)
    358     {
    359         /* Ask user about disk-less machine unless that's the recommendation: */
    360         if (!m_fRecommendedNoDisk)
    361         {
    362             if (!msgCenter().confirmHardDisklessMachine(this))
    363                 return false;
    364         }
    365     }
    366     else if (m_enmSelectedDiskSource == SelectedDiskSource_New)
    367     {
    368         /* Check if the path we will be using for hard drive creation exists: */
    369         const QString &strMediumPath = pWizard->mediumPath();
    370         fResult = !QFileInfo(strMediumPath).exists();
    371         if (!fResult)
    372         {
    373             msgCenter().cannotOverwriteHardDiskStorage(strMediumPath, this);
    374             return fResult;
    375         }
    376         /* Check FAT size limitation of the host hard drive: */
    377         fResult = UIDiskEditorGroupBox::checkFATSizeLimitation(pWizard->mediumVariant(),
    378                                                                 strMediumPath,
    379                                                                 pWizard->mediumSize());
    380         if (!fResult)
    381         {
    382             msgCenter().cannotCreateHardDiskStorageInFAT(strMediumPath, this);
    383             return fResult;
    384         }
    385     }
    386     if (pWizard)
    387     {
    388             if (m_enmSelectedDiskSource == SelectedDiskSource_New)
    389             {
    390                 /* Try to create the hard drive:*/
    391                 fResult = pWizard->createVirtualDisk();
    392                 /*Don't show any error message here since UIWizardNewVM::createVirtualDisk already does so: */
    393                 if (!fResult)
    394                     return fResult;
    395             }
    396 
    397             fResult = pWizard->createVM();
    398             /* Try to delete the hard disk: */
    399             if (!fResult)
    400                 pWizard->deleteVirtualDisk();
    401     }
    402     // endProcessing();
    403 
    404     return fResult;
    405344}
    406345

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

    r91059 r91106  
    4343class UIMediumSizeEditor;
    4444
    45 enum SelectedDiskSource
    46 {
    47     SelectedDiskSource_Empty = 0,
    48     SelectedDiskSource_New,
    49     SelectedDiskSource_Existing,
    50     SelectedDiskSource_Max
    51 };
    52 
    5345namespace UIWizardNewVMDiskCommon
    5446{
    … …  
    9183    virtual void initializePage() /* override final */;
    9284    virtual bool isComplete() const /* override final */;
    93     virtual bool validatePage() /* override final */;
    9485
    9586    void setEnableDiskSelectionWidgets(bool fEnabled);
    … …  
    115106    /** @name Variables
    116107     * @{ */
    117       SelectedDiskSource m_enmSelectedDiskSource;
    118108      bool m_fRecommendedNoDisk;
    119109      QSet<QString> m_userModifiedParameters;

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

    r91059 r91106  
    3333#include "UIWizardNewVM.h"
    3434#include "UIWizardDiskEditors.h"
     35#include "UIWizardNewVMDiskPage.h"
    3536#include "UIWizardNewVMEditors.h"
    3637#include "UIWizardNewVMExpertPage.h"
    … …  
    5758    , m_pDiskSelector(0)
    5859    , m_pDiskSelectionButton(0)
    59     , m_enmSelectedDiskSource(SelectedDiskSource_New)
    6060    , m_fRecommendedNoDisk(false)
    6161    , m_uMediumSizeMin(_4M)
    … …  
    331331            if (m_pDiskNew)
    332332                m_pDiskNew->setChecked(true);
    333             m_enmSelectedDiskSource = SelectedDiskSource_New;
     333            pWizard->setDiskSource(SelectedDiskSource_New);
    334334            setEnableDiskSelectionWidgets(false);
    335335            setEnableNewDiskWidgets(true);
    … …  
    340340            if (m_pDiskEmpty)
    341341                m_pDiskEmpty->setChecked(true);
    342             m_enmSelectedDiskSource = SelectedDiskSource_Empty;
     342            pWizard->setDiskSource(SelectedDiskSource_Empty);
    343343            setEnableDiskSelectionWidgets(false);
    344344            setEnableNewDiskWidgets(false);
    … …  
    563563    }
    564564
    565     if (m_enmSelectedDiskSource == SelectedDiskSource_Existing && uiCommon().medium(m_pDiskSelector->id()).isNull())
     565    if (pWizard->diskSource() == SelectedDiskSource_Existing && uiCommon().medium(m_pDiskSelector->id()).isNull())
    566566    {
    567567        m_pToolBox->setPageTitleIcon(ExpertToolboxItems_Disk,
    … …  
    570570    }
    571571
    572     if (m_enmSelectedDiskSource == SelectedDiskSource_New)
     572    if (pWizard->diskSource() == SelectedDiskSource_New)
    573573    {
    574574        qulonglong uSize = pWizard->mediumSize();
    … …  
    589589    bool fResult = true;
    590590
    591     if (m_enmSelectedDiskSource == SelectedDiskSource_New)
     591    if (pWizard->diskSource() == SelectedDiskSource_New)
    592592    {
    593593        /* Check if the path we will be using for hard drive creation exists: */
    … …  
    608608            return fResult;
    609609        }
    610     }
    611 
    612     if (m_enmSelectedDiskSource == SelectedDiskSource_New)
    613     {
    614610        /* Try to create the hard drive:*/
    615611        fResult = pWizard->createVirtualDisk();
    … …  
    718714{
    719715    AssertReturnVoid(m_pDiskSelector && m_pDiskSourceButtonGroup);
    720     AssertReturnVoid(wizardWindow<UIWizardNewVM>());
     716    UIWizardNewVM *pWizard = wizardWindow<UIWizardNewVM>();
     717    AssertReturnVoid(pWizard);
    721718    m_userModifiedParameters << "SelectedDiskSource";
    722719    if (m_pDiskSourceButtonGroup->checkedButton() == m_pDiskEmpty)
    723         m_enmSelectedDiskSource = SelectedDiskSource_Empty;
     720        pWizard->setDiskSource(SelectedDiskSource_Empty);
    724721    else if (m_pDiskSourceButtonGroup->checkedButton() == m_pDiskExisting)
    725722    {
    726         m_enmSelectedDiskSource = SelectedDiskSource_Existing;
    727         wizardWindow<UIWizardNewVM>()->setVirtualDisk(m_pDiskSelector->id());
     723        pWizard->setDiskSource(SelectedDiskSource_Existing);
     724        pWizard->setVirtualDisk(m_pDiskSelector->id());
    728725    }
    729726    else
    730         m_enmSelectedDiskSource = SelectedDiskSource_New;
    731 
    732     setEnableDiskSelectionWidgets(m_enmSelectedDiskSource == SelectedDiskSource_Existing);
    733     setEnableNewDiskWidgets(m_enmSelectedDiskSource == SelectedDiskSource_New);
     727        pWizard->setDiskSource(SelectedDiskSource_New);
     728
     729    setEnableDiskSelectionWidgets(pWizard->diskSource() == SelectedDiskSource_Existing);
     730    setEnableNewDiskWidgets(pWizard->diskSource() == SelectedDiskSource_New);
    734731
    735732    emit completeChanged();

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

    r91059 r91106  
    2727/* GUI includes: */
    2828#include "UINativeWizardPage.h"
    29 #include "UIWizardNewVMDiskPage.h"
    3029
    3130/* Forward declarations: */
    … …  
    144143        QIToolButton *m_pDiskSelectionButton;
    145144        QSet<QString> m_userModifiedParameters;
    146         SelectedDiskSource m_enmSelectedDiskSource;
    147145        bool m_fRecommendedNoDisk;
    148146        qulonglong m_uMediumSizeMin;

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

    r91059 r91106  
    11/* $Id$ */
    22/** @file
    3  * VBox Qt GUI - UIWizardNewVMDiskPage class implementation.
     3 * VBox Qt GUI - UIWizardNewVMSummaryPage class implementation.
    44 */
    55
    … …  
    3232#include "UIMessageCenter.h"
    3333#include "UICommon.h"
    34 #include "UIWizardNewVMDiskPage.h"
     34#include "UIWizardNewVMSummaryPage.h"
    3535#include "UIWizardDiskEditors.h"
    3636#include "UIWizardNewVM.h"
    … …  
    4141#include "CSystemProperties.h"
    4242
    43 QUuid UIWizardNewVMDiskCommon::getWithFileOpenDialog(const QString &strOSTypeID,
    44                                                      const QString &strMachineFolder,
    45                                                      const QString &strMachineBaseName,
    46                                                      QWidget *pCaller)
    47 {
    48     QUuid uMediumId;
    49     int returnCode = uiCommon().openMediumSelectorDialog(pCaller, UIMediumDeviceType_HardDisk,
    50                                                          uMediumId,
    51                                                          strMachineFolder,
    52                                                          strMachineBaseName,
    53                                                          strOSTypeID,
    54                                                          false /* don't show/enable the create action: */);
    55     if (returnCode != static_cast<int>(UIMediumSelector::ReturnCode_Accepted))
    56         return QUuid();
    57     return uMediumId;
    58 }
    5943
    60 UIWizardNewVMDiskPage::UIWizardNewVMDiskPage()
    61     : m_pDiskSourceButtonGroup(0)
    62     , m_pDiskEmpty(0)
    63     , m_pDiskNew(0)
    64     , m_pDiskExisting(0)
    65     , m_pDiskSelector(0)
    66     , m_pDiskSelectionButton(0)
    67     , m_pLabel(0)
    68     , m_pMediumSizeEditorLabel(0)
    69     , m_pMediumSizeEditor(0)
    70     , m_pDescriptionLabel(0)
    71     , m_pDynamicLabel(0)
    72     , m_pFixedLabel(0)
    73     , m_pFixedCheckBox(0)
    74     , m_enmSelectedDiskSource(SelectedDiskSource_New)
    75     , m_fRecommendedNoDisk(false)
    76     , m_fVDIFormatFound(false)
    77     , m_uMediumSizeMin(_4M)
    78     , m_uMediumSizeMax(uiCommon().virtualBox().GetSystemProperties().GetInfoVDSize())
     44UIWizardNewVMSummaryPage::UIWizardNewVMSummaryPage()
     45    : m_pLabel(0)
    7946{
    8047    prepare();
    … …  
    8249
    8350
    84 void UIWizardNewVMDiskPage::prepare()
     51void UIWizardNewVMSummaryPage::prepare()
    8552{
    8653    QVBoxLayout *pMainLayout = new QVBoxLayout(this);
    … …  
    8855    m_pLabel = new QIRichTextLabel(this);
    8956    pMainLayout->addWidget(m_pLabel);
    90     pMainLayout->addWidget(createDiskWidgets());
    9157
    9258    pMainLayout->addStretch();
    93     setEnableDiskSelectionWidgets(m_enmSelectedDiskSource == SelectedDiskSource_Existing);
    94     setEnableNewDiskWidgets(m_enmSelectedDiskSource == SelectedDiskSource_New);
    9559
    9660    createConnections();
    9761}
    9862
    99 QWidget *UIWizardNewVMDiskPage::createNewDiskWidgets()
     63void UIWizardNewVMSummaryPage::createConnections()
    10064{
    101     QWidget *pWidget = new QWidget;
    102     if (pWidget)
    103     {
    104         QVBoxLayout *pLayout = new QVBoxLayout(pWidget);
    105         if (pLayout)
    106         {
    107             pLayout->setContentsMargins(0, 0, 0, 0);
    108 
    109             /* Prepare size layout: */
    110             QGridLayout *pSizeLayout = new QGridLayout;
    111             if (pSizeLayout)
    112             {
    113                 pSizeLayout->setContentsMargins(0, 0, 0, 0);
    114 
    115                 /* Prepare Hard disk size label: */
    116                 m_pMediumSizeEditorLabel = new QLabel(pWidget);
    117                 if (m_pMediumSizeEditorLabel)
    118                 {
    119                     m_pMediumSizeEditorLabel->setAlignment(Qt::AlignRight);
    120                     m_pMediumSizeEditorLabel->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
    121                     pSizeLayout->addWidget(m_pMediumSizeEditorLabel, 0, 0, Qt::AlignBottom);
    122                 }
    123                 /* Prepare Hard disk size editor: */
    124                 m_pMediumSizeEditor = new UIMediumSizeEditor(pWidget);
    125                 if (m_pMediumSizeEditor)
    126                 {
    127                     m_pMediumSizeEditorLabel->setBuddy(m_pMediumSizeEditor);
    128                     pSizeLayout->addWidget(m_pMediumSizeEditor, 0, 1, 2, 1);
    129                 }
    130                 pLayout->addLayout(pSizeLayout);
    131             }
    132             /* Hard disk variant (dynamic vs. fixed) widgets: */
    133             pLayout->addWidget(createMediumVariantWidgets(false /* bool fWithLabels */));
    134         }
    135     }
    136     return pWidget;
    13765}
    13866
    139 void UIWizardNewVMDiskPage::createConnections()
     67void UIWizardNewVMSummaryPage::retranslateUi()
    14068{
    141     if (m_pDiskSourceButtonGroup)
    142         connect(m_pDiskSourceButtonGroup, static_cast<void(QButtonGroup::*)(QAbstractButton *)>(&QButtonGroup::buttonClicked),
    143                 this, &UIWizardNewVMDiskPage::sltSelectedDiskSourceChanged);
    144     if (m_pDiskSelector)
    145         connect(m_pDiskSelector, static_cast<void(UIMediaComboBox::*)(int)>(&UIMediaComboBox::currentIndexChanged),
    146                 this, &UIWizardNewVMDiskPage::sltMediaComboBoxIndexChanged);
    147     if (m_pDiskSelectionButton)
    148         connect(m_pDiskSelectionButton, &QIToolButton::clicked,
    149                 this, &UIWizardNewVMDiskPage::sltGetWithFileOpenDialog);
    150     if (m_pMediumSizeEditor)
    151         connect(m_pMediumSizeEditor, &UIMediumSizeEditor::sigSizeChanged,
    152                 this, &UIWizardNewVMDiskPage::sltHandleSizeEditorChange);
    153     if (m_pFixedCheckBox)
    154         connect(m_pFixedCheckBox, &QCheckBox::toggled,
    155                 this, &UIWizardNewVMDiskPage::sltFixedCheckBoxToggled);
     69    setTitle(UIWizardNewVM::tr("Summary"));
    15670}
    15771
    158 void UIWizardNewVMDiskPage::sltSelectedDiskSourceChanged()
    159 {
    160     UIWizardNewVM *pWizard = wizardWindow<UIWizardNewVM>();
    161     AssertReturnVoid(m_pDiskSelector && m_pDiskSourceButtonGroup && pWizard);
    162     m_userModifiedParameters << "SelectedDiskSource";
    163     if (m_pDiskSourceButtonGroup->checkedButton() == m_pDiskEmpty)
    164         m_enmSelectedDiskSource = SelectedDiskSource_Empty;
    165     else if (m_pDiskSourceButtonGroup->checkedButton() == m_pDiskExisting)
    166     {
    167         m_enmSelectedDiskSource = SelectedDiskSource_Existing;
    168         pWizard->setVirtualDisk(m_pDiskSelector->id());
    169     }
    170     else
    171         m_enmSelectedDiskSource = SelectedDiskSource_New;
    172 
    173     setEnableDiskSelectionWidgets(m_enmSelectedDiskSource == SelectedDiskSource_Existing);
    174     setEnableNewDiskWidgets(m_enmSelectedDiskSource == SelectedDiskSource_New);
    175 
    176     emit completeChanged();
    177 }
    178 
    179 void UIWizardNewVMDiskPage::sltMediaComboBoxIndexChanged()
    180 {
    181     AssertReturnVoid(m_pDiskSelector && wizardWindow<UIWizardNewVM>());
    182     m_userModifiedParameters << "SelectedExistingMediumIndex";
    183     wizardWindow<UIWizardNewVM>()->setVirtualDisk(m_pDiskSelector->id());
    184     emit completeChanged();
    185 }
    186 
    187 void UIWizardNewVMDiskPage::sltGetWithFileOpenDialog()
    188 {
    189     UIWizardNewVM *pWizard = wizardWindow<UIWizardNewVM>();
    190     AssertReturnVoid(pWizard);
    191     const CGuestOSType &comOSType = pWizard->guestOSType();
    192     AssertReturnVoid(!comOSType.isNull());
    193     QUuid uMediumId = UIWizardNewVMDiskCommon::getWithFileOpenDialog(comOSType.GetId(),
    194                                                                      pWizard->machineFolder(),
    195                                                                      pWizard->machineBaseName(),
    196                                                                      this);
    197     if (!uMediumId.isNull())
    198     {
    199         m_pDiskSelector->setCurrentItem(uMediumId);
    200         m_pDiskSelector->setFocus();
    201     }
    202 }
    203 
    204 void UIWizardNewVMDiskPage::retranslateUi()
    205 {
    206     setTitle(UIWizardNewVM::tr("Virtual Hard disk"));
    207 
    208     if (m_pLabel)
    209         m_pLabel->setText(UIWizardNewVM::tr("<p>If you wish you can add a virtual hard disk to the new machine. "
    210                                             "You can either create a new hard disk file or select an existing one. "
    211                                             "Alternatively you can create a virtual machine without a virtual hard disk.</p>"));
    212 
    213     if (m_pDiskEmpty)
    214         m_pDiskEmpty->setText(UIWizardNewVM::tr("&Do Not Add a Virtual Hard Disk"));
    215     if (m_pDiskNew)
    216         m_pDiskNew->setText(UIWizardNewVM::tr("&Create a Virtual Hard Disk Now"));
    217     if (m_pDiskExisting)
    218         m_pDiskExisting->setText(UIWizardNewVM::tr("U&se an Existing Virtual Hard Disk File"));
    219     if (m_pDiskSelectionButton)
    220         m_pDiskSelectionButton->setToolTip(UIWizardNewVM::tr("Choose a Virtual Hard Fisk File..."));
    221 
    222     if (m_pMediumSizeEditorLabel)
    223         m_pMediumSizeEditorLabel->setText(UIWizardNewVM::tr("D&isk Size:"));
    224 
    225     if (m_pFixedCheckBox)
    226     {
    227         m_pFixedCheckBox->setText(UIWizardNewVM::tr("Pre-allocate &Full Size"));
    228         m_pFixedCheckBox->setToolTip(UIWizardNewVM::tr("<p>When checked, the virtual disk image will be fully allocated at "
    229                                                        "VM creation time, rather than being allocated dynamically at VM run-time.</p>"));
    230     }
    231 
    232     /* Translate rich text labels: */
    233     if (m_pDescriptionLabel)
    234         m_pDescriptionLabel->setText(UIWizardNewVM::tr("Please choose whether the new virtual hard disk file should grow as it is used "
    235                                                        "(dynamically allocated) or if it should be created at its maximum size (fixed size)."));
    236     if (m_pDynamicLabel)
    237         m_pDynamicLabel->setText(UIWizardNewVM::tr("<p>A <b>dynamically allocated</b> hard disk file will only use space "
    238                                                    "on your physical hard disk as it fills up (up to a maximum <b>fixed size</b>), "
    239                                                    "although it will not shrink again automatically when space on it is freed.</p>"));
    240     if (m_pFixedLabel)
    241         m_pFixedLabel->setText(UIWizardNewVM::tr("<p>A <b>fixed size</b> hard disk file may take longer to create on some "
    242                                                  "systems but is often faster to use.</p>"));
    243 }
    244 
    245 void UIWizardNewVMDiskPage::initializePage()
     72void UIWizardNewVMSummaryPage::initializePage()
    24673{
    24774    retranslateUi();
    24875
    249     UIWizardNewVM *pWizard = wizardWindow<UIWizardNewVM>();
    250     AssertReturnVoid(pWizard);
    251 
    252     LONG64 iRecommendedSize = 0;
    253     CGuestOSType type = pWizard->guestOSType();
    254     if (!type.isNull() && !m_userModifiedParameters.contains("SelectedDiskSource"))
    255     {
    256         iRecommendedSize = type.GetRecommendedHDD();
    257         if (iRecommendedSize != 0)
    258         {
    259             if (m_pDiskNew)
    260             {
    261                 m_pDiskNew->setFocus();
    262                 m_pDiskNew->setChecked(true);
    263             }
    264             m_enmSelectedDiskSource = SelectedDiskSource_New;
    265             m_fRecommendedNoDisk = false;
    266         }
    267         else
    268         {
    269             if (m_pDiskEmpty)
    270             {
    271                 m_pDiskEmpty->setFocus();
    272                 m_pDiskEmpty->setChecked(true);
    273             }
    274             m_enmSelectedDiskSource = SelectedDiskSource_Empty;
    275             m_fRecommendedNoDisk = true;
    276         }
    277     }
    278 
    279     if (m_pDiskSelector && !m_userModifiedParameters.contains("SelectedExistingMediumIndex"))
    280         m_pDiskSelector->setCurrentIndex(0);
    281     setEnableDiskSelectionWidgets(m_enmSelectedDiskSource == SelectedDiskSource_Existing);
    282     setEnableNewDiskWidgets(m_enmSelectedDiskSource == SelectedDiskSource_New);
    283 
    284     if (!m_fVDIFormatFound)
    285     {
    286         /* We do not have any UI elements for HDD format selection since we default to VDI in case of guided wizard mode: */
    287         CSystemProperties properties = uiCommon().virtualBox().GetSystemProperties();
    288         const QVector<CMediumFormat> &formats = properties.GetMediumFormats();
    289         foreach (const CMediumFormat &format, formats)
    290         {
    291             if (format.GetName() == "VDI")
    292             {
    293                 pWizard->setMediumFormat(format);
    294                 m_fVDIFormatFound = true;
    295             }
    296         }
    297         if (!m_fVDIFormatFound)
    298             AssertMsgFailed(("No medium format corresponding to VDI could be found!"));
    299         setWidgetVisibility(pWizard->mediumFormat());
    300     }
    301     QString strDefaultExtension =  UIDiskFormatsGroupBox::defaultExtension(pWizard->mediumFormat(), KDeviceType_HardDisk);
    302 
    303     /* We set the medium name and path according to machine name/path and do not allow user change these in the guided mode: */
    304     QString strDefaultName = pWizard->machineBaseName().isEmpty() ? QString("NewVirtualDisk1") : pWizard->machineBaseName();
    305     const QString &strMachineFolder = pWizard->machineFolder();
    306     QString strMediumPath =
    307         UIDiskEditorGroupBox::constructMediumFilePath(UIDiskEditorGroupBox::appendExtension(strDefaultName,
    308                                                                                   strDefaultExtension), strMachineFolder);
    309     pWizard->setMediumPath(strMediumPath);
    310 
    311     /* Set the recommended disk size if user has already not done so: */
    312     if (m_pMediumSizeEditor && !m_userModifiedParameters.contains("MediumSize"))
    313     {
    314         m_pMediumSizeEditor->blockSignals(true);
    315         m_pMediumSizeEditor->setMediumSize(iRecommendedSize);
    316         m_pMediumSizeEditor->blockSignals(false);
    317         pWizard->setMediumSize(iRecommendedSize);
    318     }
    319 
    320     /* Initialize medium variant parameter of the wizard (only if user has not touched the checkbox yet): */
    321     if (!m_userModifiedParameters.contains("MediumVariant"))
    322     {
    323         if (m_pFixedCheckBox)
    324         {
    325             if (m_pFixedCheckBox->isChecked())
    326                 pWizard->setMediumVariant((qulonglong)KMediumVariant_Fixed);
    327             else
    328                 pWizard->setMediumVariant((qulonglong)KMediumVariant_Standard);
    329         }
    330         else
    331             pWizard->setMediumVariant((qulonglong)KMediumVariant_Standard);
    332     }
    33376}
    33477
    335 bool UIWizardNewVMDiskPage::isComplete() const
     78bool UIWizardNewVMSummaryPage::isComplete() const
    33679{
    337     UIWizardNewVM *pWizard = wizardWindow<UIWizardNewVM>();
    338     AssertReturn(pWizard, false);
    339 
    340     const qulonglong uSize = pWizard->mediumSize();
    341     if (m_enmSelectedDiskSource == SelectedDiskSource_New)
    342         return uSize >= m_uMediumSizeMin && uSize <= m_uMediumSizeMax;
    343 
    344     if (m_enmSelectedDiskSource == SelectedDiskSource_Existing)
    345         return !pWizard->virtualDisk().isNull();
    34680
    34781    return true;
    34882}
    34983
    350 bool UIWizardNewVMDiskPage::validatePage()
     84bool UIWizardNewVMSummaryPage::validatePage()
    35185{
    35286    bool fResult = true;
    … …  
    35589
    35690    /* Make sure user really intents to creae a vm with no hard drive: */
    357     if (m_enmSelectedDiskSource == SelectedDiskSource_Empty)
     91    if (pWizard->diskSource() == SelectedDiskSource_Empty)
    35892    {
    35993        /* Ask user about disk-less machine unless that's the recommendation: */
    360         if (!m_fRecommendedNoDisk)
    361         {
    362             if (!msgCenter().confirmHardDisklessMachine(this))
    363                 return false;
    364         }
     94        // if (!m_fRecommendedNoDisk)
     95        // {
     96        //     if (!msgCenter().confirmHardDisklessMachine(this))
     97        //         return false;
     98        // }
    36599    }
    366     else if (m_enmSelectedDiskSource == SelectedDiskSource_New)
     100    else if (pWizard->diskSource() == SelectedDiskSource_New)
    367101    {
    368102        /* Check if the path we will be using for hard drive creation exists: */
    … …  
    383117            return fResult;
    384118        }
     119
     120        /* Try to create the hard drive:*/
     121        fResult = pWizard->createVirtualDisk();
     122        /*Don't show any error message here since UIWizardNewVM::createVirtualDisk already does so: */
     123        if (!fResult)
     124            return fResult;
    385125    }
    386     if (pWizard)
    387     {
    388             if (m_enmSelectedDiskSource == SelectedDiskSource_New)
    389             {
    390                 /* Try to create the hard drive:*/
    391                 fResult = pWizard->createVirtualDisk();
    392                 /*Don't show any error message here since UIWizardNewVM::createVirtualDisk already does so: */
    393                 if (!fResult)
    394                     return fResult;
    395             }
    396126
    397             fResult = pWizard->createVM();
    398             /* Try to delete the hard disk: */
    399             if (!fResult)
    400                 pWizard->deleteVirtualDisk();
    401     }
    402     // endProcessing();
     127    fResult = pWizard->createVM();
     128    /* Try to delete the hard disk: */
     129    if (!fResult)
     130        pWizard->deleteVirtualDisk();
    403131
    404132    return fResult;
    405133}
    406 
    407 void UIWizardNewVMDiskPage::sltHandleSizeEditorChange(qulonglong uSize)
    408 {
    409     AssertReturnVoid(wizardWindow<UIWizardNewVM>());
    410     wizardWindow<UIWizardNewVM>()->setMediumSize(uSize);
    411     m_userModifiedParameters << "MediumSize";
    412     emit completeChanged();
    413 }
    414 
    415 void UIWizardNewVMDiskPage::sltFixedCheckBoxToggled(bool fChecked)
    416 {
    417     AssertReturnVoid(wizardWindow<UIWizardNewVM>());
    418     qulonglong uMediumVariant = (qulonglong)KMediumVariant_Max;
    419     if (fChecked)
    420         uMediumVariant = (qulonglong)KMediumVariant_Fixed;
    421     else
    422         uMediumVariant = (qulonglong)KMediumVariant_Standard;
    423     wizardWindow<UIWizardNewVM>()->setMediumVariant(uMediumVariant);
    424     m_userModifiedParameters << "MediumVariant";
    425 }
    426 
    427 void UIWizardNewVMDiskPage::setEnableNewDiskWidgets(bool fEnable)
    428 {
    429     if (m_pMediumSizeEditor)
    430         m_pMediumSizeEditor->setEnabled(fEnable);
    431     if (m_pMediumSizeEditorLabel)
    432         m_pMediumSizeEditorLabel->setEnabled(fEnable);
    433     if (m_pFixedCheckBox)
    434         m_pFixedCheckBox->setEnabled(fEnable);
    435 }
    436 
    437 QWidget *UIWizardNewVMDiskPage::createDiskWidgets()
    438 {
    439     QWidget *pDiskContainer = new QWidget;
    440     QGridLayout *pDiskLayout = new QGridLayout(pDiskContainer);
    441     pDiskLayout->setContentsMargins(0, 0, 0, 0);
    442     m_pDiskSourceButtonGroup = new QButtonGroup;
    443     m_pDiskEmpty = new QRadioButton;
    444     m_pDiskNew = new QRadioButton;
    445     m_pDiskExisting = new QRadioButton;
    446     m_pDiskSourceButtonGroup->addButton(m_pDiskEmpty);
    447     m_pDiskSourceButtonGroup->addButton(m_pDiskNew);
    448     m_pDiskSourceButtonGroup->addButton(m_pDiskExisting);
    449     QStyleOptionButton options;
    450     options.initFrom(m_pDiskExisting);
    451     int iWidth = m_pDiskExisting->style()->pixelMetric(QStyle::PM_ExclusiveIndicatorWidth, &options, m_pDiskExisting);
    452     pDiskLayout->setColumnMinimumWidth(0, iWidth);
    453     m_pDiskSelector = new UIMediaComboBox;
    454     {
    455         m_pDiskSelector->setType(UIMediumDeviceType_HardDisk);
    456         m_pDiskSelector->repopulate();
    457     }
    458     m_pDiskSelectionButton = new QIToolButton;
    459     {
    460         m_pDiskSelectionButton->setAutoRaise(true);
    461         m_pDiskSelectionButton->setIcon(UIIconPool::iconSet(":/select_file_16px.png", ":/select_file_disabled_16px.png"));
    462     }
    463     pDiskLayout->addWidget(m_pDiskNew, 0, 0, 1, 6);
    464     pDiskLayout->addWidget(createNewDiskWidgets(), 1, 2, 3, 4);
    465     pDiskLayout->addWidget(m_pDiskExisting, 4, 0, 1, 6);
    466     pDiskLayout->addWidget(m_pDiskSelector, 5, 2, 1, 3);
    467     pDiskLayout->addWidget(m_pDiskSelectionButton, 5, 5, 1, 1);
    468     pDiskLayout->addWidget(m_pDiskEmpty, 6, 0, 1, 6);
    469     return pDiskContainer;
    470 }
    471 
    472 QWidget *UIWizardNewVMDiskPage::createMediumVariantWidgets(bool fWithLabels)
    473 {
    474     QWidget *pContainerWidget = new QWidget;
    475     QVBoxLayout *pMainLayout = new QVBoxLayout(pContainerWidget);
    476     if (pMainLayout)
    477     {
    478         QVBoxLayout *pVariantLayout = new QVBoxLayout;
    479         if (pVariantLayout)
    480         {
    481             m_pFixedCheckBox = new QCheckBox;
    482             pVariantLayout->addWidget(m_pFixedCheckBox);
    483         }
    484         if (fWithLabels)
    485         {
    486             m_pDescriptionLabel = new QIRichTextLabel;
    487             m_pDynamicLabel = new QIRichTextLabel;
    488             m_pFixedLabel = new QIRichTextLabel;
    489 
    490             pMainLayout->addWidget(m_pDescriptionLabel);
    491             pMainLayout->addWidget(m_pDynamicLabel);
    492             pMainLayout->addWidget(m_pFixedLabel);
    493         }
    494         pMainLayout->addLayout(pVariantLayout);
    495         pMainLayout->addStretch();
    496         pMainLayout->setContentsMargins(0, 0, 0, 0);
    497     }
    498     return pContainerWidget;
    499 }
    500 
    501 void UIWizardNewVMDiskPage::setEnableDiskSelectionWidgets(bool fEnabled)
    502 {
    503     if (!m_pDiskSelector || !m_pDiskSelectionButton)
    504         return;
    505 
    506     m_pDiskSelector->setEnabled(fEnabled);
    507     m_pDiskSelectionButton->setEnabled(fEnabled);
    508 }
    509 
    510 void UIWizardNewVMDiskPage::setWidgetVisibility(const CMediumFormat &mediumFormat)
    511 {
    512     ULONG uCapabilities = 0;
    513     QVector<KMediumFormatCapabilities> capabilities;
    514     capabilities = mediumFormat.GetCapabilities();
    515     for (int i = 0; i < capabilities.size(); i++)
    516         uCapabilities |= capabilities[i];
    517 
    518     bool fIsCreateDynamicPossible = uCapabilities & KMediumFormatCapabilities_CreateDynamic;
    519     bool fIsCreateFixedPossible = uCapabilities & KMediumFormatCapabilities_CreateFixed;
    520     if (m_pFixedCheckBox)
    521     {
    522         if (!fIsCreateDynamicPossible)
    523         {
    524             m_pFixedCheckBox->setChecked(true);
    525             m_pFixedCheckBox->setEnabled(false);
    526         }
    527         if (!fIsCreateFixedPossible)
    528         {
    529             m_pFixedCheckBox->setChecked(false);
    530             m_pFixedCheckBox->setEnabled(false);
    531         }
    532     }
    533     if (m_pDynamicLabel)
    534         m_pDynamicLabel->setHidden(!fIsCreateDynamicPossible);
    535     if (m_pFixedLabel)
    536         m_pFixedLabel->setHidden(!fIsCreateFixedPossible);
    537     if (m_pFixedCheckBox)
    538         m_pFixedCheckBox->setHidden(!fIsCreateFixedPossible);
    539 }

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

    r91059 r91106  
    11/* $Id$ */
    22/** @file
    3  * VBox Qt GUI - UIWizardNewVMDiskPage class declaration.
     3 * VBox Qt GUI - UIWizardNewVMSummaryPage class declaration.
    44 */
    55
    … …  
    1616 */
    1717
    18 #ifndef FEQT_INCLUDED_SRC_wizards_newvm_UIWizardNewVMDiskPage_h
    19 #define FEQT_INCLUDED_SRC_wizards_newvm_UIWizardNewVMDiskPage_h
     18#ifndef FEQT_INCLUDED_SRC_wizards_newvm_UIWizardNewVMSummaryPage_h
     19#define FEQT_INCLUDED_SRC_wizards_newvm_UIWizardNewVMSummaryPage_h
    2020#ifndef RT_WITHOUT_PRAGMA_ONCE
    2121# pragma once
    … …  
    4343class UIMediumSizeEditor;
    4444
    45 enum SelectedDiskSource
    46 {
    47     SelectedDiskSource_Empty = 0,
    48     SelectedDiskSource_New,
    49     SelectedDiskSource_Existing,
    50     SelectedDiskSource_Max
    51 };
    5245
    53 namespace UIWizardNewVMDiskCommon
    54 {
    55     QUuid getWithFileOpenDialog(const QString &strOSTypeID,
    56                                 const QString &strMachineFolder,
    57                                 const QString &strMachineBaseName,
    58                                 QWidget *pCaller);
    59 }
    60 
    61 
    62 class UIWizardNewVMDiskPage : public UINativeWizardPage
     46class UIWizardNewVMSummaryPage : public UINativeWizardPage
    6347{
    6448    Q_OBJECT;
    … …  
    6650public:
    6751
    68     UIWizardNewVMDiskPage();
     52    UIWizardNewVMSummaryPage();
    6953
    7054protected:
    … …  
    7357private slots:
    7458
    75     void sltSelectedDiskSourceChanged();
    76     void sltMediaComboBoxIndexChanged();
    77     void sltGetWithFileOpenDialog();
    78     void sltHandleSizeEditorChange(qulonglong uSize);
    79     void sltFixedCheckBoxToggled(bool fChecked);
    8059
    8160private:
    … …  
    8362    void prepare();
    8463    void createConnections();
    85     QWidget *createNewDiskWidgets();
    86     void setEnableNewDiskWidgets(bool fEnable);
    87     QWidget *createDiskWidgets();
    88     QWidget *createMediumVariantWidgets(bool fWithLabels);
     64
    8965
    9066    virtual void retranslateUi() /* override final */;
    … …  
    9369    virtual bool validatePage() /* override final */;
    9470
    95     void setEnableDiskSelectionWidgets(bool fEnabled);
    96     void setWidgetVisibility(const CMediumFormat &mediumFormat);
     71
    9772
    9873    /** @name Widgets
    9974     * @{ */
    100        QButtonGroup *m_pDiskSourceButtonGroup;
    101        QRadioButton *m_pDiskEmpty;
    102        QRadioButton *m_pDiskNew;
    103        QRadioButton *m_pDiskExisting;
    104        UIMediaComboBox *m_pDiskSelector;
    105        QIToolButton *m_pDiskSelectionButton;
    10675       QIRichTextLabel *m_pLabel;
    107        QLabel          *m_pMediumSizeEditorLabel;
    108        UIMediumSizeEditor *m_pMediumSizeEditor;
    109        QIRichTextLabel *m_pDescriptionLabel;
    110        QIRichTextLabel *m_pDynamicLabel;
    111        QIRichTextLabel *m_pFixedLabel;
    112        QCheckBox *m_pFixedCheckBox;
    11376    /** @} */
    11477
    115     /** @name Variables
    116      * @{ */
    117       SelectedDiskSource m_enmSelectedDiskSource;
    118       bool m_fRecommendedNoDisk;
    119       QSet<QString> m_userModifiedParameters;
    120       bool m_fVDIFormatFound;
    121       qulonglong m_uMediumSizeMin;
    122       qulonglong m_uMediumSizeMax;
    123     /** @} */
     78
    12479};
    12580
    126 #endif /* !FEQT_INCLUDED_SRC_wizards_newvm_UIWizardNewVMDiskPage_h */
     81#endif /* !FEQT_INCLUDED_SRC_wizards_newvm_UIWizardNewVMSummaryPage_h */
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