VirtualBox

Changeset 90356 in vbox for trunk/src


Ignore:
Timestamp:
Jul 27, 2021 2:06:35 PM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
145921
Message:

FE/Qt: bugref:9996. started refactoring new disk wizard. it is totally broken now.

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

Legend:

Unmodified
Added
Removed

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

    r90300 r90356  
    653653        src/wizards/editors/UIHostnameDomainNameEditor.h \
    654654        src/wizards/editors/UIUserNamePasswordEditor.h \
    655         src/wizards/editors/UIWizardDiskEditors.h \
    656655        src/wizards/editors/UIWizardNewVMEditors.h \
    657656        src/wizards/newcloudvm/UIWizardNewCloudVM.h \
    … …  
    917916        src/wizards/UIWizard.h \
    918917        src/wizards/UIWizardPage.h \
     918        src/wizards/editors/UIWizardDiskEditors.h \
    919919        src/wizards/newvd/UIWizardNewVD.h \
    920920        src/wizards/newvd/UIWizardNewVDPageFileType.h \
    … …  
    14701470        src/wizards/UIWizard.cpp \
    14711471        src/wizards/UIWizardPage.cpp \
     1472        src/wizards/editors/UIWizardDiskEditors.cpp \
    14721473        src/wizards/newvd/UIWizardNewVD.cpp \
    14731474        src/wizards/newvd/UIWizardNewVDPageFileType.cpp \

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

    r90295 r90356  
    4747*********************************************************************************************************************************/
    4848
    49 UIDiskFormatsGroupBox::UIDiskFormatsGroupBox(QWidget *pParent /* = 0 */)
     49UIDiskFormatsGroupBox::UIDiskFormatsGroupBox(bool fExpertMode, QWidget *pParent /* = 0 */)
    5050    : QIWithRetranslateUI<QGroupBox>(pParent)
    5151    , m_pFormatButtonGroup(0)
     52    , m_fExpertMode(fExpertMode)
    5253{
    5354    prepare();
    … …  
    7778{
    7879    QVBoxLayout *pContainerLayout = new QVBoxLayout(this);
     80    if (!m_fExpertMode)
     81        setFlat(true);
    7982
    8083    m_pFormatButtonGroup = new QButtonGroup;
    … …  
    106109    foreach (const QString &strId, preferred.keys())
    107110        addFormatButton(pContainerLayout, preferred.value(strId), true);
    108     foreach (const QString &strId, others.keys())
    109         addFormatButton(pContainerLayout, others.value(strId));
     111
     112    if (m_fExpertMode)
     113    {
     114        foreach (const QString &strId, others.keys())
     115            addFormatButton(pContainerLayout, others.value(strId));
     116    }
    110117
    111118    /* Select VDI: */
    … …  
    124131void UIDiskFormatsGroupBox::retranslateUi()
    125132{
    126     setTitle(tr("Hard Disk File &Type"));
    127 
    128     if (m_pFormatButtonGroup)
    129     {
    130         QList<QAbstractButton*> buttons = m_pFormatButtonGroup->buttons();
    131         for (int i = 0; i < buttons.size(); ++i)
    132         {
    133             QAbstractButton *pButton = buttons[i];
    134             UIMediumFormat enmFormat = gpConverter->fromInternalString<UIMediumFormat>(m_formatNames[m_pFormatButtonGroup->id(pButton)]);
    135             pButton->setText(gpConverter->toString(enmFormat));
    136         }
     133    if (m_fExpertMode)
     134        setTitle(tr("Hard Disk File &Type"));
     135
     136    QList<QAbstractButton*> buttons = m_pFormatButtonGroup ? m_pFormatButtonGroup->buttons() : QList<QAbstractButton*>();
     137    for (int i = 0; i < buttons.size(); ++i)
     138    {
     139        QAbstractButton *pButton = buttons[i];
     140        UIMediumFormat enmFormat = gpConverter->fromInternalString<UIMediumFormat>(m_formatNames[m_pFormatButtonGroup->id(pButton)]);
     141        pButton->setText(gpConverter->toString(enmFormat));
    137142    }
    138143}
    … …  
    163168    {
    164169        /* Make the preferred button font bold: */
    165         if (fPreferred)
     170        if (fPreferred && m_fExpertMode)
    166171        {
    167172            QFont font = pFormatButton->font();
    … …  
    173178        m_formatNames << medFormat.GetName();
    174179        m_pFormatButtonGroup->addButton(pFormatButton, m_formatNames.size() - 1);
    175         m_formatExtensions << UIWizardNewVMDiskPage::defaultExtension(medFormat);
     180        m_formatExtensions << defaultExtension(medFormat);
    176181    }
    177182}
    … …  
    181186    return m_formatExtensions;
    182187}
     188
     189/* static */
     190QString UIDiskFormatsGroupBox::defaultExtension(const CMediumFormat &mediumFormatRef)
     191{
     192    if (!mediumFormatRef.isNull())
     193    {
     194        /* Load extension / device list: */
     195        QVector<QString> fileExtensions;
     196        QVector<KDeviceType> deviceTypes;
     197        CMediumFormat mediumFormat(mediumFormatRef);
     198        mediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
     199        for (int i = 0; i < fileExtensions.size(); ++i)
     200            if (deviceTypes[i] == KDeviceType_HardDisk)
     201                return fileExtensions[i].toLower();
     202    }
     203    AssertMsgFailed(("Extension can't be NULL!\n"));
     204    return QString();
     205}
     206
    183207
    184208/*********************************************************************************************************************************
    … …  
    187211
    188212
    189 UIDiskVariantGroupBox::UIDiskVariantGroupBox(QWidget *pParent /* = 0 */)
     213UIDiskVariantGroupBox::UIDiskVariantGroupBox(bool fExpertMode, QWidget *pParent /* = 0 */)
    190214    : QIWithRetranslateUI<QGroupBox>(pParent)
    191215    , m_pFixedCheckBox(0)
    192216    , m_pSplitBox(0)
     217    , m_fExpertMode(fExpertMode)
    193218{
    194219    prepare();
    … …  
    197222void UIDiskVariantGroupBox::prepare()
    198223{
     224    if (!m_fExpertMode)
     225        setFlat(true);
    199226    QVBoxLayout *pVariantLayout = new QVBoxLayout(this);
    200227    AssertReturnVoid(pVariantLayout);
    … …  
    211238void UIDiskVariantGroupBox::retranslateUi()
    212239{
    213     setTitle(tr("Storage on Physical Hard Disk"));
     240    if (m_fExpertMode)
     241        setTitle(tr("Storage on Physical Hard Disk"));
    214242    if (m_pFixedCheckBox)
    215243    {
    … …  
    401429{
    402430    /* Compose virtual-disk extension: */
    403     QString strDefaultExtension = UIWizardNewVMDiskPage::defaultExtension(mediumFormat);
     431    QString strDefaultExtension = UIDiskFormatsGroupBox::defaultExtension(mediumFormat);
    404432    /* Update m_pLocationEditor's text if necessary: */
    405433    if (!m_pLocationEditor->text().isEmpty() && !strDefaultExtension.isEmpty())

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

    r90295 r90356  
    4949#include "CMediumFormat.h"
    5050
    51 class UIDiskFormatsGroupBox : public QIWithRetranslateUI<QGroupBox>
     51class SHARED_LIBRARY_STUFF UIDiskFormatsGroupBox : public QIWithRetranslateUI<QGroupBox>
    5252{
    5353    Q_OBJECT;
    … …  
    5959public:
    6060
    61     UIDiskFormatsGroupBox(QWidget *pParent = 0);
     61    UIDiskFormatsGroupBox(bool fExpertMode, QWidget *pParent = 0);
    6262    CMediumFormat mediumFormat() const;
    6363    void setMediumFormat(const CMediumFormat &mediumFormat);
    6464    const CMediumFormat &VDIMediumFormat() const;
    6565    const QStringList formatExtensions() const;
     66    static QString defaultExtension(const CMediumFormat &mediumFormatRef);
    6667
    6768private:
    … …  
    7778    QStringList m_formatExtensions;
    7879    QButtonGroup *m_pFormatButtonGroup;
     80    bool m_fExpertMode;
    7981};
    8082
    81 class UIDiskVariantGroupBox : public QIWithRetranslateUI<QGroupBox>
     83class SHARED_LIBRARY_STUFF UIDiskVariantGroupBox : public QIWithRetranslateUI<QGroupBox>
    8284{
    8385    Q_OBJECT;
    … …  
    8991public:
    9092
    91     UIDiskVariantGroupBox(QWidget *pParent = 0);
     93    UIDiskVariantGroupBox(bool fExpertMode, QWidget *pParent = 0);
    9294    void updateMediumVariantWidgetsAfterFormatChange(const CMediumFormat &mediumFormat);
    9395    qulonglong mediumVariant() const;
    … …  
    107109    QCheckBox *m_pFixedCheckBox;
    108110    QCheckBox *m_pSplitBox;
     111    bool m_fExpertMode;
    109112};
    110113
    111114
    112 class UIMediumSizeAndPathGroupBox : public QIWithRetranslateUI<QGroupBox>
     115class SHARED_LIBRARY_STUFF UIMediumSizeAndPathGroupBox : public QIWithRetranslateUI<QGroupBox>
    113116{
    114117    Q_OBJECT;

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvd/UIWizardNewVD.cpp

    r90327 r90356  
    3636
    3737UIWizardNewVD::UIWizardNewVD(QWidget *pParent,
    38                              const QString &strDefaultName, const QString &strDefaultPath,
     38                             const QString &strDefaultName,
     39                             const QString &strDefaultPath,
    3940                             qulonglong uDefaultSize,
    4041                             WizardMode mode)
    41     : UIWizard(pParent, WizardType_NewVD, mode)
     42    : UINativeWizard(pParent, WizardType_NewVD, mode)
    4243    , m_strDefaultName(strDefaultName)
    4344    , m_strDefaultPath(strDefaultPath)
    … …  
    4647#ifndef VBOX_WS_MAC
    4748    /* Assign watermark: */
    48     assignWatermark(":/wizard_new_harddisk.png");
     49    setPixmapName(":/wizard_new_harddisk.png");
    4950#else /* VBOX_WS_MAC */
    5051    /* Assign background image: */
    51     assignBackground(":/wizard_new_harddisk_bg.png");
     52    setPixmapName(":/wizard_new_harddisk_bg.png");
    5253#endif /* VBOX_WS_MAC */
     54}
     55
     56void UIWizardNewVD::populatePages()
     57{
     58    switch (mode())
     59    {
     60        case WizardMode_Basic:
     61        case WizardMode_Expert:
     62        {
     63            addPage(new UIWizardNewVDPageFileType);
     64            addPage(new UIWizardNewVDPageVariant);
     65            break;
     66        }
     67
     68        // {
     69        //     //addPage(new UIWizardNewVMPageExpert);
     70        //     break;
     71        // }
     72        default:
     73        {
     74            AssertMsgFailed(("Invalid mode: %d", mode()));
     75            break;
     76        }
     77    }
    5378}
    5479
    … …  
    5681{
    5782    /* Gather attributes: */
    58     const CMediumFormat comMediumFormat = field("mediumFormat").value<CMediumFormat>();
    59     const qulonglong uVariant = field("mediumVariant").toULongLong();
    60     const QString strMediumPath = field("mediumPath").toString();
    61     const qulonglong uSize = field("mediumSize").toULongLong();
    62     /* Check attributes: */
    63     AssertReturn(!strMediumPath.isNull(), false);
    64     AssertReturn(uSize > 0, false);
     83    // const CMediumFormat comMediumFormat = field("mediumFormat").value<CMediumFormat>();
     84    // const qulonglong uVariant = field("mediumVariant").toULongLong();
     85    // const QString strMediumPath = field("mediumPath").toString();
     86    // const qulonglong uSize = field("mediumSize").toULongLong();
     87    // /* Check attributes: */
     88    // AssertReturn(!strMediumPath.isNull(), false);
     89    // AssertReturn(uSize > 0, false);
    6590
    66     /* Get VBox object: */
    67     CVirtualBox comVBox = uiCommon().virtualBox();
     91    // /* Get VBox object: */
     92    // CVirtualBox comVBox = uiCommon().virtualBox();
    6893
    69     /* Create new virtual disk image: */
    70     CMedium comVirtualDisk = comVBox.CreateMedium(comMediumFormat.GetName(), strMediumPath, KAccessMode_ReadWrite, KDeviceType_HardDisk);
    71     if (!comVBox.isOk())
    72     {
    73         msgCenter().cannotCreateMediumStorage(comVBox, strMediumPath, this);
    74         return false;
    75     }
     94    // /* Create new virtual disk image: */
     95    // CMedium comVirtualDisk = comVBox.CreateMedium(comMediumFormat.GetName(), strMediumPath, KAccessMode_ReadWrite, KDeviceType_HardDisk);
     96    // if (!comVBox.isOk())
     97    // {
     98    //     msgCenter().cannotCreateMediumStorage(comVBox, strMediumPath, this);
     99    //     return false;
     100    // }
    76101
    77     /* Compose medium-variant: */
    78     QVector<KMediumVariant> variants(sizeof(qulonglong) * 8);
    79     for (int i = 0; i < variants.size(); ++i)
    80     {
    81         qulonglong temp = uVariant;
    82         temp &= Q_UINT64_C(1) << i;
    83         variants[i] = (KMediumVariant)temp;
    84     }
     102    // /* Compose medium-variant: */
     103    // QVector<KMediumVariant> variants(sizeof(qulonglong) * 8);
     104    // for (int i = 0; i < variants.size(); ++i)
     105    // {
     106    //     qulonglong temp = uVariant;
     107    //     temp &= Q_UINT64_C(1) << i;
     108    //     variants[i] = (KMediumVariant)temp;
     109    // }
    85110
    86     /* Copy medium: */
    87     UINotificationProgressMediumCreate *pNotification = new UINotificationProgressMediumCreate(comVirtualDisk,
    88                                                                                                uSize,
    89                                                                                                variants);
    90     connect(pNotification, &UINotificationProgressMediumCreate::sigMediumCreated,
    91             &uiCommon(), &UICommon::sltHandleMediumCreated);
    92     notificationCenter().append(pNotification);
     111    // /* Copy medium: */
     112    // UINotificationProgressMediumCreate *pNotification = new UINotificationProgressMediumCreate(comVirtualDisk,
     113    //                                                                                            uSize,
     114    //                                                                                            variants);
     115    // connect(pNotification, &UINotificationProgressMediumCreate::sigMediumCreated,
     116    //         &uiCommon(), &UICommon::sltHandleMediumCreated);
     117    // notificationCenter().append(pNotification);
    93118
    94119    /* Positive: */
    … …  
    98123void UIWizardNewVD::retranslateUi()
    99124{
    100     /* Call to base-class: */
    101     UIWizard::retranslateUi();
    102 
    103     /* Translate wizard: */
     125    UINativeWizard::retranslateUi();
    104126    setWindowTitle(tr("Create Virtual Hard Disk"));
    105     setButtonText(QWizard::FinishButton, tr("Create"));
    106127}
    107128
    108129void UIWizardNewVD::prepare()
    109130{
    110     /* Create corresponding pages: */
    111     switch (mode())
    112     {
    113         case WizardMode_Basic:
    114         {
    115             setPage(Page1, new UIWizardNewVDPageFileType);
    116             setPage(Page2, new UIWizardNewVDPageVariant);
    117             setPage(Page3, new UIWizardNewVDPageSizeLocation(m_strDefaultName, m_strDefaultPath, m_uDefaultSize));
    118             break;
    119         }
    120         case WizardMode_Expert:
    121         {
    122             setPage(PageExpert, new UIWizardNewVDPageExpert(m_strDefaultName, m_strDefaultPath, m_uDefaultSize));
    123             break;
    124         }
    125         default:
    126         {
    127             AssertMsgFailed(("Invalid mode: %d", mode()));
    128             break;
    129         }
    130     }
    131     /* Call to base-class: */
    132     UIWizard::prepare();
     131    // /* Create corresponding pages: */
     132    // switch (mode())
     133    // {
     134    //     case WizardMode_Basic:
     135    //     {
     136    //         setPage(Page1, new UIWizardNewVDPageFileType);
     137    //         setPage(Page2, new UIWizardNewVDPageVariant);
     138    //         setPage(Page3, new UIWizardNewVDPageSizeLocation(m_strDefaultName, m_strDefaultPath, m_uDefaultSize));
     139    //         break;
     140    //     }
     141    //     case WizardMode_Expert:
     142    //     {
     143    //         setPage(PageExpert, new UIWizardNewVDPageExpert(m_strDefaultName, m_strDefaultPath, m_uDefaultSize));
     144    //         break;
     145    //     }
     146    //     default:
     147    //     {
     148    //         AssertMsgFailed(("Invalid mode: %d", mode()));
     149    //         break;
     150    //     }
     151    // }
     152
    133153}

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvd/UIWizardNewVD.h

    r90327 r90356  
    2323
    2424/* GUI includes: */
    25 #include "UIWizard.h"
     25#include "UINativeWizard.h"
    2626
    2727/* COM includes: */
    … …  
    3030
    3131/* New Virtual Hard Drive wizard: */
    32 class SHARED_LIBRARY_STUFF UIWizardNewVD : public UIWizard
     32class SHARED_LIBRARY_STUFF UIWizardNewVD : public UINativeWizard
    3333{
    3434    Q_OBJECT;
    … …  
    6464    bool createVirtualDisk();
    6565
    66     /* Who will be able to create virtual-disk: */
    67     friend class UIWizardNewVDPageSizeLocation;
    68     friend class UIWizardNewVDPageExpert;
     66    virtual void populatePages() /* final override */;
    6967
    7068private:

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvd/UIWizardNewVDPageExpert.cpp

    r88599 r90356  
    4545
    4646
    47 UIWizardNewVDPageExpert::UIWizardNewVDPageExpert(const QString &strDefaultName, const QString &strDefaultPath, qulonglong uDefaultSize)
    48     : UIWizardNewVDPageBaseSizeLocation(strDefaultName, strDefaultPath)
     47UIWizardNewVDPageExpert::UIWizardNewVDPageExpert(const QString &/*strDefaultName*/, const QString &/*strDefaultPath*/, qulonglong /*uDefaultSize*/)
     48    : UINativeWizardPage()
    4949    , m_pFormatGroupBox(0)
    5050    , m_pVariantGroupBox(0)
    … …  
    5454    /* Get default extension for new virtual-disk: */
    5555    /* Create widgets: */
    56     QGridLayout *pMainLayout = new QGridLayout(this);
    57     {
    58         m_pLocationGroupBox = new QGroupBox(this);
    59         {
    60             m_pLocationGroupBox->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
    61             QHBoxLayout *pLocationGroupBoxLayout = new QHBoxLayout(m_pLocationGroupBox);
    62             {
    63                 m_pLocationEditor = new QLineEdit(m_pLocationGroupBox);
    64                 m_pLocationOpenButton = new QIToolButton(m_pLocationGroupBox);
    65                 {
    66                     m_pLocationOpenButton->setAutoRaise(true);
    67                     m_pLocationOpenButton->setIcon(UIIconPool::iconSet(":/select_file_16px.png", "select_file_disabled_16px.png"));
    68                 }
    69                 pLocationGroupBoxLayout->addWidget(m_pLocationEditor);
    70                 pLocationGroupBoxLayout->addWidget(m_pLocationOpenButton);
    71             }
    72         }
    73         m_pSizeGroupBox = new QGroupBox(this);
    74         {
    75             m_pSizeGroupBox->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
    76             QVBoxLayout *pSizeGroupBoxLayout = new QVBoxLayout(m_pSizeGroupBox);
    77             {
    78                 m_pMediumSizeEditor = new UIMediumSizeEditor;
    79                 {
    80                     pSizeGroupBoxLayout->addWidget(m_pMediumSizeEditor);
    81                 }
    82             }
    83         }
    84         m_pFormatGroupBox = new QGroupBox(this);
    85         {
    86             m_pFormatGroupBox->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
    87             QVBoxLayout *pFormatGroupBoxLayout = new QVBoxLayout(m_pFormatGroupBox);
    88             pFormatGroupBoxLayout->addWidget(createFormatButtonGroup(true));
    89         }
    90         m_pVariantGroupBox = new QGroupBox(this);
    91         {
    92             m_pVariantGroupBox->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
    93             QVBoxLayout *pVariantGroupBoxLayout = new QVBoxLayout(m_pVariantGroupBox);
    94             {
    95                 m_pFixedCheckBox = new QCheckBox;
    96                 m_pSplitBox = new QCheckBox(m_pVariantGroupBox);
    97                 pVariantGroupBoxLayout->addWidget(m_pFixedCheckBox);
    98                 pVariantGroupBoxLayout->addWidget(m_pSplitBox);
    99             }
    100         }
    101         pMainLayout->addWidget(m_pLocationGroupBox, 0, 0, 1, 2);
    102         pMainLayout->addWidget(m_pSizeGroupBox, 1, 0, 1, 2);
    103         pMainLayout->addWidget(m_pFormatGroupBox, 2, 0, Qt::AlignTop);
    104         pMainLayout->addWidget(m_pVariantGroupBox, 2, 1, Qt::AlignTop);
    105         setMediumSize(uDefaultSize);
    106         sltMediumFormatChanged();
    107     }
    108 
    109     /* Setup connections: */
    110     connect(m_pFormatButtonGroup, static_cast<void(QButtonGroup::*)(QAbstractButton*)>(&QButtonGroup::buttonClicked),
    111             this, &UIWizardNewVDPageExpert::sltMediumFormatChanged);
    112     connect(m_pFixedCheckBox, &QAbstractButton::toggled,
    113             this, &UIWizardNewVDPageExpert::completeChanged);
    114     connect(m_pSplitBox, &QCheckBox::stateChanged,
    115             this, &UIWizardNewVDPageExpert::completeChanged);
    116     connect(m_pLocationEditor, &QLineEdit::textChanged,
    117             this, &UIWizardNewVDPageExpert::completeChanged);
    118     connect(m_pLocationOpenButton, &QIToolButton::clicked,
    119             this, &UIWizardNewVDPageExpert::sltSelectLocationButtonClicked);
    120     connect(m_pMediumSizeEditor, &UIMediumSizeEditor::sigSizeChanged,
    121             this, &UIWizardNewVDPageExpert::completeChanged);
    122 
    123     /* Register classes: */
    124     qRegisterMetaType<CMediumFormat>();
    125     /* Register fields: */
    126     registerField("mediumFormat", this, "mediumFormat");
    127     registerField("mediumVariant", this, "mediumVariant");
    128     registerField("mediumPath", this, "mediumPath");
    129     registerField("mediumSize", this, "mediumSize");
     56//     QGridLayout *pMainLayout = new QGridLayout(this);
     57//     {
     58//         m_pLocationGroupBox = new QGroupBox(this);
     59//         {
     60//             m_pLocationGroupBox->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
     61//             QHBoxLayout *pLocationGroupBoxLayout = new QHBoxLayout(m_pLocationGroupBox);
     62//             {
     63//                 m_pLocationEditor = new QLineEdit(m_pLocationGroupBox);
     64//                 m_pLocationOpenButton = new QIToolButton(m_pLocationGroupBox);
     65//                 {
     66//                     m_pLocationOpenButton->setAutoRaise(true);
     67//                     m_pLocationOpenButton->setIcon(UIIconPool::iconSet(":/select_file_16px.png", "select_file_disabled_16px.png"));
     68//                 }
     69//                 pLocationGroupBoxLayout->addWidget(m_pLocationEditor);
     70//                 pLocationGroupBoxLayout->addWidget(m_pLocationOpenButton);
     71//             }
     72//         }
     73//         m_pSizeGroupBox = new QGroupBox(this);
     74//         {
     75//             m_pSizeGroupBox->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
     76//             QVBoxLayout *pSizeGroupBoxLayout = new QVBoxLayout(m_pSizeGroupBox);
     77//             {
     78//                 m_pMediumSizeEditor = new UIMediumSizeEditor;
     79//                 {
     80//                     pSizeGroupBoxLayout->addWidget(m_pMediumSizeEditor);
     81//                 }
     82//             }
     83//         }
     84//         m_pFormatGroupBox = new QGroupBox(this);
     85//         {
     86//             m_pFormatGroupBox->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
     87//             QVBoxLayout *pFormatGroupBoxLayout = new QVBoxLayout(m_pFormatGroupBox);
     88//             pFormatGroupBoxLayout->addWidget(createFormatButtonGroup(true));
     89//         }
     90//         m_pVariantGroupBox = new QGroupBox(this);
     91//         {
     92//             m_pVariantGroupBox->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
     93//             QVBoxLayout *pVariantGroupBoxLayout = new QVBoxLayout(m_pVariantGroupBox);
     94//             {
     95//                 m_pFixedCheckBox = new QCheckBox;
     96//                 m_pSplitBox = new QCheckBox(m_pVariantGroupBox);
     97//                 pVariantGroupBoxLayout->addWidget(m_pFixedCheckBox);
     98//                 pVariantGroupBoxLayout->addWidget(m_pSplitBox);
     99//             }
     100//         }
     101//         pMainLayout->addWidget(m_pLocationGroupBox, 0, 0, 1, 2);
     102//         pMainLayout->addWidget(m_pSizeGroupBox, 1, 0, 1, 2);
     103//         pMainLayout->addWidget(m_pFormatGroupBox, 2, 0, Qt::AlignTop);
     104//         pMainLayout->addWidget(m_pVariantGroupBox, 2, 1, Qt::AlignTop);
     105//         setMediumSize(uDefaultSize);
     106//         sltMediumFormatChanged();
     107//     }
     108
     109//     /* Setup connections: */
     110//     connect(m_pFormatButtonGroup, static_cast<void(QButtonGroup::*)(QAbstractButton*)>(&QButtonGroup::buttonClicked),
     111//             this, &UIWizardNewVDPageExpert::sltMediumFormatChanged);
     112//     connect(m_pFixedCheckBox, &QAbstractButton::toggled,
     113//             this, &UIWizardNewVDPageExpert::completeChanged);
     114//     connect(m_pSplitBox, &QCheckBox::stateChanged,
     115//             this, &UIWizardNewVDPageExpert::completeChanged);
     116//     connect(m_pLocationEditor, &QLineEdit::textChanged,
     117//             this, &UIWizardNewVDPageExpert::completeChanged);
     118//     connect(m_pLocationOpenButton, &QIToolButton::clicked,
     119//             this, &UIWizardNewVDPageExpert::sltSelectLocationButtonClicked);
     120//     connect(m_pMediumSizeEditor, &UIMediumSizeEditor::sigSizeChanged,
     121//             this, &UIWizardNewVDPageExpert::completeChanged);
     122
     123//     /* Register classes: */
     124//     qRegisterMetaType<CMediumFormat>();
     125//     /* Register fields: */
     126//     registerField("mediumFormat", this, "mediumFormat");
     127//     registerField("mediumVariant", this, "mediumVariant");
     128//     registerField("mediumPath", this, "mediumPath");
     129//     registerField("mediumSize", this, "mediumSize");
    130130}
    131131
    132132void UIWizardNewVDPageExpert::sltMediumFormatChanged()
    133133{
    134     CMediumFormat comMediumFormat = mediumFormat();
    135     if (comMediumFormat.isNull())
    136     {
    137         AssertMsgFailed(("No medium format set!"));
    138         return;
    139     }
    140     updateMediumVariantWidgetsAfterFormatChange(comMediumFormat);
    141     updateLocationEditorAfterFormatChange(comMediumFormat, m_formatExtensions);
    142 
    143     /* Broadcast complete-change: */
    144     completeChanged();
     134    // CMediumFormat comMediumFormat = mediumFormat();
     135    // if (comMediumFormat.isNull())
     136    // {
     137    //     AssertMsgFailed(("No medium format set!"));
     138    //     return;
     139    // }
     140    // updateMediumVariantWidgetsAfterFormatChange(comMediumFormat);
     141    // updateLocationEditorAfterFormatChange(comMediumFormat, m_formatExtensions);
     142
     143    // /* Broadcast complete-change: */
     144    // completeChanged();
    145145}
    146146
    … …  
    148148{
    149149    /* Call to base-class: */
    150     onSelectLocationButtonClicked();
     150    //onSelectLocationButtonClicked();
    151151}
    152152
    153153void UIWizardNewVDPageExpert::retranslateUi()
    154154{
    155     UIWizardNewVDPageBaseFileType::retranslateWidgets();
    156     UIWizardNewVDPageBaseVariant::retranslateWidgets();
    157     UIWizardNewVDPageBaseSizeLocation::retranslateWidgets();
    158     /* Translate widgets: */
    159     if (m_pLocationGroupBox)
    160         m_pLocationGroupBox->setTitle(UIWizardNewVD::tr("Hard disk file &location"));
    161     if (m_pSizeGroupBox)
    162         m_pSizeGroupBox->setTitle(UIWizardNewVD::tr("Hard disk file &size"));
    163     if (m_pFormatGroupBox)
    164         m_pFormatGroupBox->setTitle(UIWizardNewVD::tr("Hard disk file &type"));
    165     if (m_pFormatButtonGroup)
    166     {
    167         QList<QAbstractButton*> buttons = m_pFormatButtonGroup->buttons();
    168         for (int i = 0; i < buttons.size(); ++i)
    169         {
    170             QAbstractButton *pButton = buttons[i];
    171             UIMediumFormat enmFormat = gpConverter->fromInternalString<UIMediumFormat>(m_formatNames[m_pFormatButtonGroup->id(pButton)]);
    172             pButton->setText(gpConverter->toString(enmFormat));
    173         }
    174     }
    175     if (m_pVariantGroupBox)
    176         m_pVariantGroupBox->setTitle(UIWizardNewVD::tr("Storage on physical hard disk"));
    177     if (m_pSplitBox)
    178         m_pSplitBox->setText(UIWizardNewVD::tr("&Split into files of less than 2GB"));
     155//     UIWizardNewVDPageBaseFileType::retranslateWidgets();
     156//     UIWizardNewVDPageBaseVariant::retranslateWidgets();
     157//     UIWizardNewVDPageBaseSizeLocation::retranslateWidgets();
     158//     /* Translate widgets: */
     159//     if (m_pLocationGroupBox)
     160//         m_pLocationGroupBox->setTitle(UIWizardNewVD::tr("Hard disk file &location"));
     161//     if (m_pSizeGroupBox)
     162//         m_pSizeGroupBox->setTitle(UIWizardNewVD::tr("Hard disk file &size"));
     163//     if (m_pFormatGroupBox)
     164//         m_pFormatGroupBox->setTitle(UIWizardNewVD::tr("Hard disk file &type"));
     165//     if (m_pFormatButtonGroup)
     166//     {
     167//         QList<QAbstractButton*> buttons = m_pFormatButtonGroup->buttons();
     168//         for (int i = 0; i < buttons.size(); ++i)
     169//         {
     170//             QAbstractButton *pButton = buttons[i];
     171//             UIMediumFormat enmFormat = gpConverter->fromInternalString<UIMediumFormat>(m_formatNames[m_pFormatButtonGroup->id(pButton)]);
     172//             pButton->setText(gpConverter->toString(enmFormat));
     173//         }
     174//     }
     175//     if (m_pVariantGroupBox)
     176//         m_pVariantGroupBox->setTitle(UIWizardNewVD::tr("Storage on physical hard disk"));
     177//     if (m_pSplitBox)
     178//         m_pSplitBox->setText(UIWizardNewVD::tr("&Split into files of less than 2GB"));
    179179}
    180180
    181181void UIWizardNewVDPageExpert::initializePage()
    182182{
    183     /* Get default extension for new virtual-disk: */
    184     m_strDefaultExtension = defaultExtension(field("mediumFormat").value<CMediumFormat>());
    185     /* Set default name as text for location editor: */
    186     if (m_pLocationEditor)
    187         m_pLocationEditor->setText(absoluteFilePath(m_strDefaultName, m_strDefaultPath, m_strDefaultExtension));
    188 
    189 
    190     /* Translate page: */
    191     retranslateUi();
     183    // /* Get default extension for new virtual-disk: */
     184    // m_strDefaultExtension = defaultExtension(field("mediumFormat").value<CMediumFormat>());
     185    // /* Set default name as text for location editor: */
     186    // if (m_pLocationEditor)
     187    //     m_pLocationEditor->setText(absoluteFilePath(m_strDefaultName, m_strDefaultPath, m_strDefaultExtension));
     188
     189
     190    // /* Translate page: */
     191    // retranslateUi();
    192192}
    193193
    … …  
    196196    /* Make sure medium format/variant is correct,
    197197     * current name is not empty and current size feats the bounds: */
    198     return !mediumFormat().isNull() &&
    199            mediumVariant() != (qulonglong)KMediumVariant_Max &&
    200            !m_pLocationEditor->text().trimmed().isEmpty() &&
    201            mediumSize() >= m_uMediumSizeMin && mediumSize() <= m_uMediumSizeMax;
     198    // return !mediumFormat().isNull() &&
     199    //        mediumVariant() != (qulonglong)KMediumVariant_Max &&
     200    //        !m_pLocationEditor->text().trimmed().isEmpty() &&
     201    //        mediumSize() >= m_uMediumSizeMin && mediumSize() <= m_uMediumSizeMax;
     202    return false;
    202203}
    203204
    … …  
    207208    bool fResult = true;
    208209
    209     /* Make sure such file doesn't exist already: */
    210     const QString strMediumPath(mediumPath());
    211     fResult = !QFileInfo(strMediumPath).exists();
    212     if (!fResult)
    213     {
    214         msgCenter().cannotOverwriteHardDiskStorage(strMediumPath, this);
    215         return fResult;
    216     }
    217 
    218     /* Make sure we are passing FAT size limitation: */
    219     fResult = UIWizardNewVDPageBaseSizeLocation::checkFATSizeLimitation(fieldImp("mediumVariant").toULongLong(),
    220                                                          fieldImp("mediumPath").toString(),
    221                                                          fieldImp("mediumSize").toULongLong());
    222     if (!fResult)
    223     {
    224         msgCenter().cannotCreateHardDiskStorageInFAT(strMediumPath, this);
    225         return fResult;
    226     }
    227 
    228     /* Lock finish button: */
    229     startProcessing();
    230     /* Try to create virtual-disk: */
    231     fResult = qobject_cast<UIWizardNewVD*>(wizard())->createVirtualDisk();
    232     /* Unlock finish button: */
    233     endProcessing();
     210    // /* Make sure such file doesn't exist already: */
     211    // const QString strMediumPath(mediumPath());
     212    // fResult = !QFileInfo(strMediumPath).exists();
     213    // if (!fResult)
     214    // {
     215    //     msgCenter().cannotOverwriteHardDiskStorage(strMediumPath, this);
     216    //     return fResult;
     217    // }
     218
     219    // /* Make sure we are passing FAT size limitation: */
     220    // fResult = UIWizardNewVDPageBaseSizeLocation::checkFATSizeLimitation(fieldImp("mediumVariant").toULongLong(),
     221    //                                                      fieldImp("mediumPath").toString(),
     222    //                                                      fieldImp("mediumSize").toULongLong());
     223    // if (!fResult)
     224    // {
     225    //     msgCenter().cannotCreateHardDiskStorageInFAT(strMediumPath, this);
     226    //     return fResult;
     227    // }
     228
     229    // /* Lock finish button: */
     230    // startProcessing();
     231    // /* Try to create virtual-disk: */
     232    // fResult = qobject_cast<UIWizardNewVD*>(wizard())->createVirtualDisk();
     233    // /* Unlock finish button: */
     234    // endProcessing();
    234235
    235236    /* Return result: */

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvd/UIWizardNewVDPageExpert.h

    r88599 r90356  
    2323
    2424/* GUI includes: */
    25 #include "UIWizardNewVDPageFileType.h"
    26 #include "UIWizardNewVDPageVariant.h"
    27 #include "UIWizardNewVDPageSizeLocation.h"
     25#include "UINativeWizardPage.h"
    2826
    2927/* Forward declarations: */
    … …  
    3129
    3230/* Expert page of the New Virtual Hard Drive wizard: */
    33 class SHARED_LIBRARY_STUFF UIWizardNewVDPageExpert : public UIWizardPage,
    34                                                      public UIWizardNewVDPageBaseFileType,
    35                                                      public UIWizardNewVDPageBaseVariant,
    36                                                      public UIWizardNewVDPageBaseSizeLocation
     31class SHARED_LIBRARY_STUFF UIWizardNewVDPageExpert : public UINativeWizardPage
    3732{
    3833    Q_OBJECT;
    39     Q_PROPERTY(CMediumFormat mediumFormat READ mediumFormat WRITE setMediumFormat);
    40     Q_PROPERTY(qulonglong mediumVariant READ mediumVariant WRITE setMediumVariant);
    41     Q_PROPERTY(QString mediumPath READ mediumPath);
    42     Q_PROPERTY(qulonglong mediumSize READ mediumSize WRITE setMediumSize);
    4334
    4435public:
    … …  
    4940protected:
    5041
    51     /* Wrapper to access 'this' from base part: */
    52     UIWizardPage* thisImp() { return this; }
    53     /* Wrapper to access 'wizard-field' from base part: */
    54     QVariant fieldImp(const QString &strFieldName) const { return UIWizardPage::field(strFieldName); }
    5542
    5643private slots:

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvd/UIWizardNewVDPageFileType.cpp

    r90159 r90356  
    2323/* GUI includes: */
    2424#include "UIConverter.h"
     25#include "UIWizardDiskEditors.h"
    2526#include "UIWizardNewVDPageFileType.h"
    2627#include "UIWizardNewVDPageSizeLocation.h"
    … …  
    3233#include "CSystemProperties.h"
    3334
     35// UIWizardNewVDPageBaseFileType::UIWizardNewVDPageBaseFileType()
     36//     : m_pFormatButtonGroup(0)
     37// {
     38// }
    3439
    35 UIWizardNewVDPageBaseFileType::UIWizardNewVDPageBaseFileType()
    36     : m_pFormatButtonGroup(0)
     40// void UIWizardNewVDPageBaseFileType::addFormatButton(QWidget *pParent, QVBoxLayout *pFormatLayout, CMediumFormat medFormat, bool fPreferred /* = false */)
     41// {
     42//     /* Check that medium format supports creation: */
     43//     ULONG uFormatCapabilities = 0;
     44//     QVector<KMediumFormatCapabilities> capabilities;
     45//     capabilities = medFormat.GetCapabilities();
     46//     for (int i = 0; i < capabilities.size(); i++)
     47//         uFormatCapabilities |= capabilities[i];
     48
     49//     if (!(uFormatCapabilities & KMediumFormatCapabilities_CreateFixed ||
     50//           uFormatCapabilities & KMediumFormatCapabilities_CreateDynamic))
     51//         return;
     52
     53//     /* Check that medium format supports creation of virtual hard-disks: */
     54//     QVector<QString> fileExtensions;
     55//     QVector<KDeviceType> deviceTypes;
     56//     medFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
     57//     if (!deviceTypes.contains(KDeviceType_HardDisk))
     58//         return;
     59
     60//     /* Create/add corresponding radio-button: */
     61//     QRadioButton *pFormatButton = new QRadioButton(pParent);
     62//     AssertPtrReturnVoid(pFormatButton);
     63//     {
     64//         /* Make the preferred button font bold: */
     65//         if (fPreferred)
     66//         {
     67//             QFont font = pFormatButton->font();
     68//             font.setBold(true);
     69//             pFormatButton->setFont(font);
     70//         }
     71//         pFormatLayout->addWidget(pFormatButton);
     72//         m_formats << medFormat;
     73//         m_formatNames << medFormat.GetName();
     74//         m_pFormatButtonGroup->addButton(pFormatButton, m_formatNames.size() - 1);
     75//         m_formatExtensions << UIWizardNewVDPageBaseSizeLocation::defaultExtension(medFormat);
     76//     }
     77// }
     78
     79
     80// CMediumFormat UIWizardNewVDPageBaseFileType::mediumFormat() const
     81// {
     82//     return m_pFormatButtonGroup && m_pFormatButtonGroup->checkedButton() ? m_formats[m_pFormatButtonGroup->checkedId()] : CMediumFormat();
     83// }
     84
     85// void UIWizardNewVDPageBaseFileType::setMediumFormat(const CMediumFormat &mediumFormat)
     86// {
     87//     int iPosition = m_formats.indexOf(mediumFormat);
     88//     if (iPosition >= 0)
     89//     {
     90//         m_pFormatButtonGroup->button(iPosition)->click();
     91//         m_pFormatButtonGroup->button(iPosition)->setFocus();
     92//     }
     93// }
     94
     95// void UIWizardNewVDPageBaseFileType::retranslateWidgets()
     96// {
     97//     if (m_pFormatButtonGroup)
     98//     {
     99//         QList<QAbstractButton*> buttons = m_pFormatButtonGroup->buttons();
     100//         for (int i = 0; i < buttons.size(); ++i)
     101//         {
     102//             QAbstractButton *pButton = buttons[i];
     103//             UIMediumFormat enmFormat = gpConverter->fromInternalString<UIMediumFormat>(m_formatNames[m_pFormatButtonGroup->id(pButton)]);
     104//             pButton->setText(gpConverter->toString(enmFormat));
     105//         }
     106//     }
     107// }
     108
     109UIWizardNewVDPageFileType::UIWizardNewVDPageFileType()
     110    : m_pLabel(0)
     111    , m_pFormatButtonGroup(0)
    37112{
     113    prepare();
     114    /* Create widgets: */
     115
     116    // /* Setup connections: */
     117    // connect(m_pFormatButtonGroup, static_cast<void(QButtonGroup::*)(QAbstractButton*)>(&QButtonGroup::buttonClicked),
     118    //         this, &UIWizardNewVDPageFileType::completeChanged);
     119
     120    // /* Register classes: */
     121    // qRegisterMetaType<CMediumFormat>();
     122    // /* Register fields: */
     123    // registerField("mediumFormat", this, "mediumFormat");
    38124}
    39125
    40 void UIWizardNewVDPageBaseFileType::addFormatButton(QWidget *pParent, QVBoxLayout *pFormatLayout, CMediumFormat medFormat, bool fPreferred /* = false */)
     126void UIWizardNewVDPageFileType::prepare()
    41127{
    42     /* Check that medium format supports creation: */
    43     ULONG uFormatCapabilities = 0;
    44     QVector<KMediumFormatCapabilities> capabilities;
    45     capabilities = medFormat.GetCapabilities();
    46     for (int i = 0; i < capabilities.size(); i++)
    47         uFormatCapabilities |= capabilities[i];
     128    QVBoxLayout *pMainLayout = new QVBoxLayout(this);
     129    m_pLabel = new QIRichTextLabel(this);
     130    pMainLayout->addWidget(m_pLabel);
     131    m_pFormatButtonGroup = new UIDiskFormatsGroupBox(false, 0);
     132    pMainLayout->addWidget(m_pFormatButtonGroup, false);
    48133
    49     if (!(uFormatCapabilities & KMediumFormatCapabilities_CreateFixed ||
    50           uFormatCapabilities & KMediumFormatCapabilities_CreateDynamic))
    51         return;
    52 
    53     /* Check that medium format supports creation of virtual hard-disks: */
    54     QVector<QString> fileExtensions;
    55     QVector<KDeviceType> deviceTypes;
    56     medFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
    57     if (!deviceTypes.contains(KDeviceType_HardDisk))
    58         return;
    59 
    60     /* Create/add corresponding radio-button: */
    61     QRadioButton *pFormatButton = new QRadioButton(pParent);
    62     AssertPtrReturnVoid(pFormatButton);
    63     {
    64         /* Make the preferred button font bold: */
    65         if (fPreferred)
    66         {
    67             QFont font = pFormatButton->font();
    68             font.setBold(true);
    69             pFormatButton->setFont(font);
    70         }
    71         pFormatLayout->addWidget(pFormatButton);
    72         m_formats << medFormat;
    73         m_formatNames << medFormat.GetName();
    74         m_pFormatButtonGroup->addButton(pFormatButton, m_formatNames.size() - 1);
    75         m_formatExtensions << UIWizardNewVDPageBaseSizeLocation::defaultExtension(medFormat);
    76     }
    77 }
    78 
    79 QWidget *UIWizardNewVDPageBaseFileType::createFormatButtonGroup(bool fExpertMode)
    80 {
    81     QWidget *pContainerWidget = new QWidget;
    82     QVBoxLayout *pContainerLayout = new QVBoxLayout(pContainerWidget);
    83     pContainerLayout->setContentsMargins(0, 0, 0, 0);
    84 
    85     m_pFormatButtonGroup = new QButtonGroup;
    86     if (m_pFormatButtonGroup)
    87     {
    88         /* Enumerate medium formats in special order: */
    89         CSystemProperties properties = uiCommon().virtualBox().GetSystemProperties();
    90         const QVector<CMediumFormat> &formats = properties.GetMediumFormats();
    91         QMap<QString, CMediumFormat> vdi, preferred, others;
    92         foreach (const CMediumFormat &format, formats)
    93         {
    94             /* VDI goes first: */
    95             if (format.GetName() == "VDI")
    96                 vdi[format.GetId()] = format;
    97             else
    98             {
    99                 const QVector<KMediumFormatCapabilities> &capabilities = format.GetCapabilities();
    100                 /* Then goes preferred: */
    101                 if (capabilities.contains(KMediumFormatCapabilities_Preferred))
    102                     preferred[format.GetId()] = format;
    103                 /* Then others: */
    104                 else
    105                     others[format.GetId()] = format;
    106             }
    107         }
    108 
    109         /* Create buttons for VDI, preferred and others: */
    110         foreach (const QString &strId, vdi.keys())
    111             addFormatButton(pContainerWidget, pContainerLayout, vdi.value(strId), fExpertMode);
    112         foreach (const QString &strId, preferred.keys())
    113             addFormatButton(pContainerWidget, pContainerLayout, preferred.value(strId), fExpertMode);
    114         if (fExpertMode)
    115         {
    116             foreach (const QString &strId, others.keys())
    117                 addFormatButton(pContainerWidget, pContainerLayout, others.value(strId));
    118         }
    119 
    120         if (!m_pFormatButtonGroup->buttons().isEmpty())
    121         {
    122             m_pFormatButtonGroup->button(0)->click();
    123             m_pFormatButtonGroup->button(0)->setFocus();
    124         }
    125     }
    126     return pContainerWidget;
    127 }
    128 
    129 CMediumFormat UIWizardNewVDPageBaseFileType::mediumFormat() const
    130 {
    131     return m_pFormatButtonGroup && m_pFormatButtonGroup->checkedButton() ? m_formats[m_pFormatButtonGroup->checkedId()] : CMediumFormat();
    132 }
    133 
    134 void UIWizardNewVDPageBaseFileType::setMediumFormat(const CMediumFormat &mediumFormat)
    135 {
    136     int iPosition = m_formats.indexOf(mediumFormat);
    137     if (iPosition >= 0)
    138     {
    139         m_pFormatButtonGroup->button(iPosition)->click();
    140         m_pFormatButtonGroup->button(iPosition)->setFocus();
    141     }
    142 }
    143 
    144 void UIWizardNewVDPageBaseFileType::retranslateWidgets()
    145 {
    146     if (m_pFormatButtonGroup)
    147     {
    148         QList<QAbstractButton*> buttons = m_pFormatButtonGroup->buttons();
    149         for (int i = 0; i < buttons.size(); ++i)
    150         {
    151             QAbstractButton *pButton = buttons[i];
    152             UIMediumFormat enmFormat = gpConverter->fromInternalString<UIMediumFormat>(m_formatNames[m_pFormatButtonGroup->id(pButton)]);
    153             pButton->setText(gpConverter->toString(enmFormat));
    154         }
    155     }
    156 }
    157 
    158 UIWizardNewVDPageFileType::UIWizardNewVDPageFileType()
    159 {
    160     /* Create widgets: */
    161     QVBoxLayout *pMainLayout = new QVBoxLayout(this);
    162     {
    163         m_pLabel = new QIRichTextLabel(this);
    164         pMainLayout->addWidget(m_pLabel);
    165         pMainLayout->addWidget(createFormatButtonGroup(false));
    166 
    167         pMainLayout->addStretch();
    168     }
    169 
    170     /* Setup connections: */
    171     connect(m_pFormatButtonGroup, static_cast<void(QButtonGroup::*)(QAbstractButton*)>(&QButtonGroup::buttonClicked),
    172             this, &UIWizardNewVDPageFileType::completeChanged);
    173 
    174     /* Register classes: */
    175     qRegisterMetaType<CMediumFormat>();
    176     /* Register fields: */
    177     registerField("mediumFormat", this, "mediumFormat");
     134    pMainLayout->addStretch();
     135    retranslateUi();
    178136}
    179137
    180138void UIWizardNewVDPageFileType::retranslateUi()
    181139{
    182     retranslateWidgets();
    183     /* Translate page: */
    184140    setTitle(UIWizardNewVD::tr("Virtual Hard disk file type"));
    185141
    186     /* Translate widgets: */
    187142    m_pLabel->setText(UIWizardNewVD::tr("Please choose the type of file that you would like to use "
    188143                                        "for the new virtual hard disk. If you do not need to use it "
    … …  
    199154{
    200155    /* Make sure medium format is correct: */
    201     return !mediumFormat().isNull();
     156    //return !mediumFormat().isNull();
     157    return true;
    202158}
    203159
    204 int UIWizardNewVDPageFileType::nextId() const
    205 {
    206     /* Show variant page only if there is something to show: */
    207     CMediumFormat mf = mediumFormat();
    208     if (mf.isNull())
    209     {
    210         AssertMsgFailed(("No medium format set!"));
    211     }
    212     else
    213     {
    214         ULONG uCapabilities = 0;
    215         QVector<KMediumFormatCapabilities> capabilities;
    216         capabilities = mf.GetCapabilities();
    217         for (int i = 0; i < capabilities.size(); i++)
    218             uCapabilities |= capabilities[i];
     160// int UIWizardNewVDPageFileType::nextId() const
     161// {
     162//     /* Show variant page only if there is something to show: */
     163//     CMediumFormat mf = mediumFormat();
     164//     if (mf.isNull())
     165//     {
     166//         AssertMsgFailed(("No medium format set!"));
     167//     }
     168//     else
     169//     {
     170//         ULONG uCapabilities = 0;
     171//         QVector<KMediumFormatCapabilities> capabilities;
     172//         capabilities = mf.GetCapabilities();
     173//         for (int i = 0; i < capabilities.size(); i++)
     174//             uCapabilities |= capabilities[i];
    219175
    220         int cTest = 0;
    221         if (uCapabilities & KMediumFormatCapabilities_CreateDynamic)
    222             ++cTest;
    223         if (uCapabilities & KMediumFormatCapabilities_CreateFixed)
    224             ++cTest;
    225         if (uCapabilities & KMediumFormatCapabilities_CreateSplit2G)
    226             ++cTest;
    227         if (cTest > 1)
    228             return UIWizardNewVD::Page2;
    229     }
    230     /* Skip otherwise: */
    231     return UIWizardNewVD::Page3;
    232 }
     176//         int cTest = 0;
     177//         if (uCapabilities & KMediumFormatCapabilities_CreateDynamic)
     178//             ++cTest;
     179//         if (uCapabilities & KMediumFormatCapabilities_CreateFixed)
     180//             ++cTest;
     181//         if (uCapabilities & KMediumFormatCapabilities_CreateSplit2G)
     182//             ++cTest;
     183//         if (cTest > 1)
     184//             return UIWizardNewVD::Page2;
     185//     }
     186//     /* Skip otherwise: */
     187//     return UIWizardNewVD::Page3;
     188// }

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvd/UIWizardNewVDPageFileType.h

    r88597 r90356  
    2323
    2424/* GUI includes: */
    25 #include "UIWizardPage.h"
     25#include "UINativeWizardPage.h"
    2626
    2727/* COM includes: */
    … …  
    3434class QRadioButton;
    3535class QIRichTextLabel;
     36class UIDiskFormatsGroupBox;
     37
     38namespace UIWizardNewVDFileType
     39{
     40//     void addFormatButton(QWidget *pParent, QVBoxLayout *pFormatsLayout, CMediumFormat medFormat, bool fPreferred = false);
     41
     42   // QWidget *createFormatButtonGroup(QButtonGroup *&pFormatButtonGroup, bool fExperMode);
     43
     44//     CMediumFormat mediumFormat() const;
     45//     void setMediumFormat(const CMediumFormat &mediumFormat);
     46//     void retranslateWidgets();
    3647
    3748
    38 /* 1st page of the New Virtual Hard Drive wizard (base part): */
    39 class SHARED_LIBRARY_STUFF UIWizardNewVDPageBaseFileType : public UIWizardPageBase
    40 {
    41 protected:
    42 
    43     /* Constructor: */
    44     UIWizardNewVDPageBaseFileType();
    45 
    46     /* Helping stuff: */
    47     void addFormatButton(QWidget *pParent, QVBoxLayout *pFormatsLayout, CMediumFormat medFormat, bool fPreferred = false);
    48 
    49     QWidget *createFormatButtonGroup(bool fExperMode);
    50 
    51     /* Stuff for 'mediumFormat' field: */
    52     CMediumFormat mediumFormat() const;
    53     void setMediumFormat(const CMediumFormat &mediumFormat);
    54     void retranslateWidgets();
    55 
    56     /* Variables: */
    57     QButtonGroup *m_pFormatButtonGroup;
    58     QList<CMediumFormat> m_formats;
    59     QStringList m_formatNames;
    60     QStringList m_formatExtensions;
    61 };
     49//     QList<CMediumFormat> m_formats;
     50//     QStringList m_formatNames;
     51//     QStringList m_formatExtensions;
     52}
    6253
    6354
    6455/* 1st page of the New Virtual Hard Drive wizard (basic extension): */
    65 class SHARED_LIBRARY_STUFF UIWizardNewVDPageFileType : public UIWizardPage, public UIWizardNewVDPageBaseFileType
     56class SHARED_LIBRARY_STUFF UIWizardNewVDPageFileType : public UINativeWizardPage
    6657{
    6758    Q_OBJECT;
    68     Q_PROPERTY(CMediumFormat mediumFormat READ mediumFormat WRITE setMediumFormat);
    6959
    7060public:
    … …  
    7565private:
    7666
    77     /* Translation stuff: */
    7867    void retranslateUi();
    79 
    80     /* Prepare stuff: */
     68    void prepare();
    8169    void initializePage();
    8270
    … …  
    8472    bool isComplete() const;
    8573
    86     /* Navigation stuff: */
    87     int nextId() const;
    8874
    89     /* Widgets: */
    9075    QIRichTextLabel *m_pLabel;
     76    UIDiskFormatsGroupBox *m_pFormatButtonGroup;
    9177};
    9278

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvd/UIWizardNewVDPageSizeLocation.cpp

    r88599 r90356  
    3737#include "QILineEdit.h"
    3838#include "UIMediumSizeEditor.h"
     39#include "UIWizardDiskEditors.h"
    3940
    4041/* COM includes: */
    … …  
    4748
    4849
    49 UIWizardNewVDPageBaseSizeLocation::UIWizardNewVDPageBaseSizeLocation(const QString &strDefaultName, const QString &strDefaultPath)
    50     : m_strDefaultName(strDefaultName.isEmpty() ? QString("NewVirtualDisk1") : strDefaultName)
    51     , m_strDefaultPath(strDefaultPath)
    52     , m_uMediumSizeMin(_4M)
    53     , m_uMediumSizeMax(uiCommon().virtualBox().GetSystemProperties().GetInfoVDSize())
    54     , m_pLocationEditor(0)
    55     , m_pLocationOpenButton(0)
    56     , m_pMediumSizeEditor(0)
    57     , m_pMediumSizeEditorLabel(0)
    58     , m_pLocationLabel(0)
    59     , m_pSizeLabel(0)
    60 {
    61 }
    62 
    63 UIWizardNewVDPageBaseSizeLocation::UIWizardNewVDPageBaseSizeLocation()
    64     : m_uMediumSizeMin(_4M)
    65     , m_uMediumSizeMax(uiCommon().virtualBox().GetSystemProperties().GetInfoVDSize())
    66     , m_pLocationEditor(0)
    67     , m_pLocationOpenButton(0)
    68     , m_pMediumSizeEditor(0)
    69     , m_pMediumSizeEditorLabel(0)
    70     , m_pLocationLabel(0)
    71     , m_pSizeLabel(0)
    72 {
    73 }
    74 
    75 void UIWizardNewVDPageBaseSizeLocation::onSelectLocationButtonClicked()
    76 {
    77     /* Get current folder and filename: */
    78     QFileInfo fullFilePath(mediumPath());
    79     QDir folder = fullFilePath.path();
    80     QString strFileName = fullFilePath.fileName();
    81 
    82     /* Set the first parent folder that exists as the current: */
    83     while (!folder.exists() && !folder.isRoot())
    84     {
    85         QFileInfo folderInfo(folder.absolutePath());
    86         if (folder == QDir(folderInfo.absolutePath()))
    87             break;
    88         folder = folderInfo.absolutePath();
    89     }
    90 
    91     /* But if it doesn't exists at all: */
    92     if (!folder.exists() || folder.isRoot())
    93     {
    94         /* Use recommended one folder: */
    95         QFileInfo defaultFilePath(absoluteFilePath(strFileName, m_strDefaultPath));
    96         folder = defaultFilePath.path();
    97     }
    98 
    99     /* Prepare backends list: */
    100     QVector<QString> fileExtensions;
    101     QVector<KDeviceType> deviceTypes;
    102     CMediumFormat mediumFormat = fieldImp("mediumFormat").value<CMediumFormat>();
    103     mediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
    104     QStringList validExtensionList;
    105     for (int i = 0; i < fileExtensions.size(); ++i)
    106         if (deviceTypes[i] == KDeviceType_HardDisk)
    107             validExtensionList << QString("*.%1").arg(fileExtensions[i]);
    108     /* Compose full filter list: */
    109     QString strBackendsList = QString("%1 (%2)").arg(mediumFormat.GetName()).arg(validExtensionList.join(" "));
    110 
    111     /* Open corresponding file-dialog: */
    112     QString strChosenFilePath = QIFileDialog::getSaveFileName(folder.absoluteFilePath(strFileName),
    113                                                               strBackendsList, thisImp(),
    114                                                               UICommon::tr("Please choose a location for new virtual hard disk file"));
    115 
    116     /* If there was something really chosen: */
    117     if (!strChosenFilePath.isEmpty())
    118     {
    119         /* If valid file extension is missed, append it: */
    120         if (QFileInfo(strChosenFilePath).suffix().isEmpty())
    121             strChosenFilePath += QString(".%1").arg(m_strDefaultExtension);
    122         if (m_pLocationEditor)
    123         {
    124             m_pLocationEditor->setText(QDir::toNativeSeparators(strChosenFilePath));
    125             m_pLocationEditor->selectAll();
    126             m_pLocationEditor->setFocus();
    127         }
    128     }
    129 }
    130 
    131 /* static */
    132 QString UIWizardNewVDPageBaseSizeLocation::toFileName(const QString &strName, const QString &strExtension)
    133 {
    134     /* Convert passed name to native separators (it can be full, actually): */
    135     QString strFileName = QDir::toNativeSeparators(strName);
    136 
    137     /* Remove all trailing dots to avoid multiple dots before extension: */
    138     int iLen;
    139     while (iLen = strFileName.length(), iLen > 0 && strFileName[iLen - 1] == '.')
    140         strFileName.truncate(iLen - 1);
    141 
    142     /* Add passed extension if its not done yet: */
    143     if (QFileInfo(strFileName).suffix().toLower() != strExtension)
    144         strFileName += QString(".%1").arg(strExtension);
    145 
    146     /* Return result: */
    147     return strFileName;
    148 }
    149 
    150 /* static */
    151 QString UIWizardNewVDPageBaseSizeLocation::absoluteFilePath(const QString &strFileName, const QString &strPath)
    152 {
    153     /* Wrap file-info around received file name: */
    154     QFileInfo fileInfo(strFileName);
    155     /* If path-info is relative or there is no path-info at all: */
    156     if (fileInfo.fileName() == strFileName || fileInfo.isRelative())
    157     {
    158         /* Resolve path on the basis of  path we have: */
    159         fileInfo = QFileInfo(strPath, strFileName);
    160     }
    161     /* Return full absolute hard disk file path: */
    162     return QDir::toNativeSeparators(fileInfo.absoluteFilePath());
    163 }
    164 
    165 /*static */
    166 QString UIWizardNewVDPageBaseSizeLocation::absoluteFilePath(const QString &strFileName, const QString &strPath, const QString &strExtension)
    167 {
    168     QString strFilePath = absoluteFilePath(strFileName, strPath);
    169     if (QFileInfo(strFilePath).suffix().isEmpty())
    170         strFilePath += QString(".%1").arg(strExtension);
    171     return strFilePath;
    172 }
    173 
    174 /* static */
    175 QString UIWizardNewVDPageBaseSizeLocation::defaultExtension(const CMediumFormat &mediumFormatRef)
    176 {
    177     if (!mediumFormatRef.isNull())
    178     {
    179         /* Load extension / device list: */
    180         QVector<QString> fileExtensions;
    181         QVector<KDeviceType> deviceTypes;
    182         CMediumFormat mediumFormat(mediumFormatRef);
    183         mediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
    184         for (int i = 0; i < fileExtensions.size(); ++i)
    185             if (deviceTypes[i] == KDeviceType_HardDisk)
    186                 return fileExtensions[i].toLower();
    187     }
    188     AssertMsgFailed(("Extension can't be NULL!\n"));
    189     return QString();
    190 }
    191 
    192 /* static */
    193 bool UIWizardNewVDPageBaseSizeLocation::checkFATSizeLimitation(const qulonglong uVariant, const QString &strMediumPath, const qulonglong uSize)
    194 {
    195     /* If the hard disk is split into 2GB parts then no need to make further checks: */
    196     if (uVariant & KMediumVariant_VmdkSplit2G)
    197         return true;
    198 
    199     RTFSTYPE enmType;
    200     int rc = RTFsQueryType(QFileInfo(strMediumPath).absolutePath().toLatin1().constData(), &enmType);
    201     if (RT_SUCCESS(rc))
    202     {
    203         if (enmType == RTFSTYPE_FAT)
    204         {
    205             /* Limit the medium size to 4GB. minus 128 MB for file overhead: */
    206             qulonglong fatLimit = _4G - _128M;
    207             if (uSize >= fatLimit)
    208                 return false;
    209         }
    210     }
    211 
    212     return true;
    213 }
    214 
    215 QString UIWizardNewVDPageBaseSizeLocation::mediumPath() const
    216 {
    217     if (!m_pLocationEditor)
    218         return QString();
    219     return absoluteFilePath(toFileName(m_pLocationEditor->text(), m_strDefaultExtension), m_strDefaultPath);
    220 }
    221 
    222 qulonglong UIWizardNewVDPageBaseSizeLocation::mediumSize() const
    223 {
    224     return m_pMediumSizeEditor ? m_pMediumSizeEditor->mediumSize() : 0;
    225 }
    226 
    227 void UIWizardNewVDPageBaseSizeLocation::setMediumSize(qulonglong uMediumSize)
    228 {
    229     if (m_pMediumSizeEditor)
    230         m_pMediumSizeEditor->setMediumSize(uMediumSize);
    231 }
    232 
    233 /* static */
    234 QString UIWizardNewVDPageBaseSizeLocation::stripFormatExtension(const QString &strFileName, const QStringList &formatExtensions)
    235 {
    236     QString result(strFileName);
    237     foreach (const QString &strExtension, formatExtensions)
    238     {
    239         if (strFileName.endsWith(strExtension, Qt::CaseInsensitive))
    240         {
    241             /* Add the dot to extenstion: */
    242             QString strExtensionWithDot(strExtension);
    243             strExtensionWithDot.prepend('.');
    244             int iIndex = strFileName.lastIndexOf(strExtensionWithDot, -1, Qt::CaseInsensitive);
    245             result.remove(iIndex, strExtensionWithDot.length());
    246         }
    247     }
    248     return result;
    249 }
    250 
    251 void UIWizardNewVDPageBaseSizeLocation::updateLocationEditorAfterFormatChange(const CMediumFormat &mediumFormat, const QStringList &formatExtensions)
    252 {
    253     /* Compose virtual-disk extension: */
    254     m_strDefaultExtension = defaultExtension(mediumFormat);
    255     /* Update m_pLocationEditor's text if necessary: */
    256     if (!m_pLocationEditor->text().isEmpty() && !m_strDefaultExtension.isEmpty())
    257     {
    258         QFileInfo fileInfo(m_pLocationEditor->text());
    259         if (fileInfo.suffix() != m_strDefaultExtension)
    260         {
    261             QFileInfo newFileInfo(fileInfo.absolutePath(),
    262                                   QString("%1.%2").
    263                                   arg(stripFormatExtension(fileInfo.fileName(), formatExtensions)).
    264                                   arg(m_strDefaultExtension));
    265             m_pLocationEditor->setText(newFileInfo.absoluteFilePath());
    266         }
    267     }
    268 }
    269 
    270 void UIWizardNewVDPageBaseSizeLocation::retranslateWidgets()
    271 {
    272     if (m_pLocationOpenButton)
    273         m_pLocationOpenButton->setToolTip(UIWizardNewVD::tr("Choose a location for new virtual hard disk file..."));
    274 
    275     if (m_pLocationLabel)
    276         m_pLocationLabel->setText(UIWizardNewVD::tr("Please type the name of the new virtual hard disk file into the box below or "
    277                                                     "click on the folder icon to select a different folder to create the file in."));
    278     if (m_pSizeLabel)
    279         m_pSizeLabel->setText(UIWizardNewVD::tr("Select the size of the virtual hard disk in megabytes. "
    280                                                 "This size is the limit on the amount of file data "
    281                                                 "that a virtual machine will be able to store on the hard disk."));
    282     if (m_pMediumSizeEditorLabel)
    283         m_pMediumSizeEditorLabel->setText(UIWizardNewVD::tr("D&isk Size:"));
    284 }
    285 
    286 UIWizardNewVDPageSizeLocation::UIWizardNewVDPageSizeLocation(const QString &strDefaultName, const QString &strDefaultPath, qulonglong uDefaultSize)
    287     : UIWizardNewVDPageBaseSizeLocation(strDefaultName, strDefaultPath)
    288 {
    289     /* Create widgets: */
     50// UIWizardNewVDPageBaseSizeLocation::UIWizardNewVDPageBaseSizeLocation(const QString &strDefaultName, const QString &strDefaultPath)
     51//     : m_strDefaultName(strDefaultName.isEmpty() ? QString("NewVirtualDisk1") : strDefaultName)
     52//     , m_strDefaultPath(strDefaultPath)
     53//     , m_uMediumSizeMin(_4M)
     54//     , m_uMediumSizeMax(uiCommon().virtualBox().GetSystemProperties().GetInfoVDSize())
     55//     , m_pLocationEditor(0)
     56//     , m_pLocationOpenButton(0)
     57//     , m_pMediumSizeEditor(0)
     58//     , m_pMediumSizeEditorLabel(0)
     59//     , m_pLocationLabel(0)
     60//     , m_pSizeLabel(0)
     61// {
     62// }
     63
     64// UIWizardNewVDPageBaseSizeLocation::UIWizardNewVDPageBaseSizeLocation()
     65//     : m_uMediumSizeMin(_4M)
     66//     , m_uMediumSizeMax(uiCommon().virtualBox().GetSystemProperties().GetInfoVDSize())
     67//     , m_pLocationEditor(0)
     68//     , m_pLocationOpenButton(0)
     69//     , m_pMediumSizeEditor(0)
     70//     , m_pMediumSizeEditorLabel(0)
     71//     , m_pLocationLabel(0)
     72//     , m_pSizeLabel(0)
     73// {
     74// }
     75
     76// void UIWizardNewVDPageBaseSizeLocation::onSelectLocationButtonClicked()
     77// {
     78//     /* Get current folder and filename: */
     79//     QFileInfo fullFilePath(mediumPath());
     80//     QDir folder = fullFilePath.path();
     81//     QString strFileName = fullFilePath.fileName();
     82
     83//     /* Set the first parent folder that exists as the current: */
     84//     while (!folder.exists() && !folder.isRoot())
     85//     {
     86//         QFileInfo folderInfo(folder.absolutePath());
     87//         if (folder == QDir(folderInfo.absolutePath()))
     88//             break;
     89//         folder = folderInfo.absolutePath();
     90//     }
     91
     92//     /* But if it doesn't exists at all: */
     93//     if (!folder.exists() || folder.isRoot())
     94//     {
     95//         /* Use recommended one folder: */
     96//         QFileInfo defaultFilePath(absoluteFilePath(strFileName, m_strDefaultPath));
     97//         folder = defaultFilePath.path();
     98//     }
     99
     100//     /* Prepare backends list: */
     101//     QVector<QString> fileExtensions;
     102//     QVector<KDeviceType> deviceTypes;
     103//     CMediumFormat mediumFormat = fieldImp("mediumFormat").value<CMediumFormat>();
     104//     mediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
     105//     QStringList validExtensionList;
     106//     for (int i = 0; i < fileExtensions.size(); ++i)
     107//         if (deviceTypes[i] == KDeviceType_HardDisk)
     108//             validExtensionList << QString("*.%1").arg(fileExtensions[i]);
     109//     /* Compose full filter list: */
     110//     QString strBackendsList = QString("%1 (%2)").arg(mediumFormat.GetName()).arg(validExtensionList.join(" "));
     111
     112//     /* Open corresponding file-dialog: */
     113//     QString strChosenFilePath = QIFileDialog::getSaveFileName(folder.absoluteFilePath(strFileName),
     114//                                                               strBackendsList, thisImp(),
     115//                                                               UICommon::tr("Please choose a location for new virtual hard disk file"));
     116
     117//     /* If there was something really chosen: */
     118//     if (!strChosenFilePath.isEmpty())
     119//     {
     120//         /* If valid file extension is missed, append it: */
     121//         if (QFileInfo(strChosenFilePath).suffix().isEmpty())
     122//             strChosenFilePath += QString(".%1").arg(m_strDefaultExtension);
     123//         if (m_pLocationEditor)
     124//         {
     125//             m_pLocationEditor->setText(QDir::toNativeSeparators(strChosenFilePath));
     126//             m_pLocationEditor->selectAll();
     127//             m_pLocationEditor->setFocus();
     128//         }
     129//     }
     130// }
     131
     132// /* static */
     133// QString UIWizardNewVDPageBaseSizeLocation::toFileName(const QString &strName, const QString &strExtension)
     134// {
     135//     /* Convert passed name to native separators (it can be full, actually): */
     136//     QString strFileName = QDir::toNativeSeparators(strName);
     137
     138//     /* Remove all trailing dots to avoid multiple dots before extension: */
     139//     int iLen;
     140//     while (iLen = strFileName.length(), iLen > 0 && strFileName[iLen - 1] == '.')
     141//         strFileName.truncate(iLen - 1);
     142
     143//     /* Add passed extension if its not done yet: */
     144//     if (QFileInfo(strFileName).suffix().toLower() != strExtension)
     145//         strFileName += QString(".%1").arg(strExtension);
     146
     147//     /* Return result: */
     148//     return strFileName;
     149// }
     150
     151// /* static */
     152// QString UIWizardNewVDPageBaseSizeLocation::absoluteFilePath(const QString &strFileName, const QString &strPath)
     153// {
     154//     /* Wrap file-info around received file name: */
     155//     QFileInfo fileInfo(strFileName);
     156//     /* If path-info is relative or there is no path-info at all: */
     157//     if (fileInfo.fileName() == strFileName || fileInfo.isRelative())
     158//     {
     159//         /* Resolve path on the basis of  path we have: */
     160//         fileInfo = QFileInfo(strPath, strFileName);
     161//     }
     162//     /* Return full absolute hard disk file path: */
     163//     return QDir::toNativeSeparators(fileInfo.absoluteFilePath());
     164// }
     165
     166// /*static */
     167// QString UIWizardNewVDPageBaseSizeLocation::absoluteFilePath(const QString &strFileName, const QString &strPath, const QString &strExtension)
     168// {
     169//     QString strFilePath = absoluteFilePath(strFileName, strPath);
     170//     if (QFileInfo(strFilePath).suffix().isEmpty())
     171//         strFilePath += QString(".%1").arg(strExtension);
     172//     return strFilePath;
     173// }
     174
     175// /* static */
     176// QString UIWizardNewVDPageBaseSizeLocation::defaultExtension(const CMediumFormat &mediumFormatRef)
     177// {
     178//     if (!mediumFormatRef.isNull())
     179//     {
     180//         /* Load extension / device list: */
     181//         QVector<QString> fileExtensions;
     182//         QVector<KDeviceType> deviceTypes;
     183//         CMediumFormat mediumFormat(mediumFormatRef);
     184//         mediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
     185//         for (int i = 0; i < fileExtensions.size(); ++i)
     186//             if (deviceTypes[i] == KDeviceType_HardDisk)
     187//                 return fileExtensions[i].toLower();
     188//     }
     189//     AssertMsgFailed(("Extension can't be NULL!\n"));
     190//     return QString();
     191// }
     192
     193// /* static */
     194// bool UIWizardNewVDPageBaseSizeLocation::checkFATSizeLimitation(const qulonglong uVariant, const QString &strMediumPath, const qulonglong uSize)
     195// {
     196//     /* If the hard disk is split into 2GB parts then no need to make further checks: */
     197//     if (uVariant & KMediumVariant_VmdkSplit2G)
     198//         return true;
     199
     200//     RTFSTYPE enmType;
     201//     int rc = RTFsQueryType(QFileInfo(strMediumPath).absolutePath().toLatin1().constData(), &enmType);
     202//     if (RT_SUCCESS(rc))
     203//     {
     204//         if (enmType == RTFSTYPE_FAT)
     205//         {
     206//             /* Limit the medium size to 4GB. minus 128 MB for file overhead: */
     207//             qulonglong fatLimit = _4G - _128M;
     208//             if (uSize >= fatLimit)
     209//                 return false;
     210//         }
     211//     }
     212
     213//     return true;
     214// }
     215
     216// QString UIWizardNewVDPageBaseSizeLocation::mediumPath() const
     217// {
     218//     if (!m_pLocationEditor)
     219//         return QString();
     220//     return absoluteFilePath(toFileName(m_pLocationEditor->text(), m_strDefaultExtension), m_strDefaultPath);
     221// }
     222
     223// qulonglong UIWizardNewVDPageBaseSizeLocation::mediumSize() const
     224// {
     225//     return m_pMediumSizeEditor ? m_pMediumSizeEditor->mediumSize() : 0;
     226// }
     227
     228// void UIWizardNewVDPageBaseSizeLocation::setMediumSize(qulonglong uMediumSize)
     229// {
     230//     if (m_pMediumSizeEditor)
     231//         m_pMediumSizeEditor->setMediumSize(uMediumSize);
     232// }
     233
     234// /* static */
     235// QString UIWizardNewVDPageBaseSizeLocation::stripFormatExtension(const QString &strFileName, const QStringList &formatExtensions)
     236// {
     237//     QString result(strFileName);
     238//     foreach (const QString &strExtension, formatExtensions)
     239//     {
     240//         if (strFileName.endsWith(strExtension, Qt::CaseInsensitive))
     241//         {
     242//             /* Add the dot to extenstion: */
     243//             QString strExtensionWithDot(strExtension);
     244//             strExtensionWithDot.prepend('.');
     245//             int iIndex = strFileName.lastIndexOf(strExtensionWithDot, -1, Qt::CaseInsensitive);
     246//             result.remove(iIndex, strExtensionWithDot.length());
     247//         }
     248//     }
     249//     return result;
     250// }
     251
     252// void UIWizardNewVDPageBaseSizeLocation::updateLocationEditorAfterFormatChange(const CMediumFormat &mediumFormat, const QStringList &formatExtensions)
     253// {
     254//     /* Compose virtual-disk extension: */
     255//     m_strDefaultExtension = defaultExtension(mediumFormat);
     256//     /* Update m_pLocationEditor's text if necessary: */
     257//     if (!m_pLocationEditor->text().isEmpty() && !m_strDefaultExtension.isEmpty())
     258//     {
     259//         QFileInfo fileInfo(m_pLocationEditor->text());
     260//         if (fileInfo.suffix() != m_strDefaultExtension)
     261//         {
     262//             QFileInfo newFileInfo(fileInfo.absolutePath(),
     263//                                   QString("%1.%2").
     264//                                   arg(stripFormatExtension(fileInfo.fileName(), formatExtensions)).
     265//                                   arg(m_strDefaultExtension));
     266//             m_pLocationEditor->setText(newFileInfo.absoluteFilePath());
     267//         }
     268//     }
     269// }
     270
     271// void UIWizardNewVDPageBaseSizeLocation::retranslateWidgets()
     272// {
     273//     if (m_pLocationOpenButton)
     274//         m_pLocationOpenButton->setToolTip(UIWizardNewVD::tr("Choose a location for new virtual hard disk file..."));
     275
     276
     277//     if (m_pMediumSizeEditorLabel)
     278//         m_pMediumSizeEditorLabel->setText(UIWizardNewVD::tr("D&isk Size:"));
     279// }
     280
     281UIWizardNewVDPageSizeLocation::UIWizardNewVDPageSizeLocation(const QString &/*strDefaultName*/, const QString &/*strDefaultPath*/, qulonglong /*uDefaultSize*/)
     282    : m_pMediumSizePathGroup(0)
     283{
     284
     285
     286
     287//     /* Setup connections: */
     288//     connect(m_pLocationEditor, &QLineEdit::textChanged,    this, &UIWizardNewVDPageSizeLocation::completeChanged);
     289//     connect(m_pLocationOpenButton, &QIToolButton::clicked, this, &UIWizardNewVDPageSizeLocation::sltSelectLocationButtonClicked);
     290//     connect(m_pMediumSizeEditor, &UIMediumSizeEditor::sigSizeChanged, this, &UIWizardNewVDPageSizeLocation::completeChanged);
     291
     292//     /* Register fields: */
     293//     registerField("mediumPath", this, "mediumPath");
     294//     registerField("mediumSize", this, "mediumSize");
     295    prepare();
     296}
     297
     298void UIWizardNewVDPageSizeLocation::prepare()
     299{
    290300    QVBoxLayout *pMainLayout = new QVBoxLayout(this);
    291     {
    292         m_pLocationLabel = new QIRichTextLabel(this);
    293         QHBoxLayout *pLocationLayout = new QHBoxLayout;
    294         {
    295             m_pLocationEditor = new QLineEdit(this);
    296             m_pLocationOpenButton = new QIToolButton(this);
    297             {
    298                 m_pLocationOpenButton->setAutoRaise(true);
    299                 m_pLocationOpenButton->setIcon(UIIconPool::iconSet(":/select_file_16px.png", "select_file_disabled_16px.png"));
    300             }
    301             pLocationLayout->addWidget(m_pLocationEditor);
    302             pLocationLayout->addWidget(m_pLocationOpenButton);
    303         }
    304         m_pSizeLabel = new QIRichTextLabel(this);
    305         m_pMediumSizeEditor = new UIMediumSizeEditor;
    306         setMediumSize(uDefaultSize);
    307         pMainLayout->addWidget(m_pLocationLabel);
    308         pMainLayout->addLayout(pLocationLayout);
    309         pMainLayout->addWidget(m_pSizeLabel);
    310         pMainLayout->addWidget(m_pMediumSizeEditor);
    311         pMainLayout->addStretch();
    312     }
    313 
    314     /* Setup connections: */
    315     connect(m_pLocationEditor, &QLineEdit::textChanged,    this, &UIWizardNewVDPageSizeLocation::completeChanged);
    316     connect(m_pLocationOpenButton, &QIToolButton::clicked, this, &UIWizardNewVDPageSizeLocation::sltSelectLocationButtonClicked);
    317     connect(m_pMediumSizeEditor, &UIMediumSizeEditor::sigSizeChanged, this, &UIWizardNewVDPageSizeLocation::completeChanged);
    318 
    319     /* Register fields: */
    320     registerField("mediumPath", this, "mediumPath");
    321     registerField("mediumSize", this, "mediumSize");
     301    AssertReturnVoid(pMainLayout);
     302//     {
     303//         m_pLocationLabel = new QIRichTextLabel(this);
     304//         QHBoxLayout *pLocationLayout = new QHBoxLayout;
     305//         {
     306//             m_pLocationEditor = new QLineEdit(this);
     307//             m_pLocationOpenButton = new QIToolButton(this);
     308//             {
     309//                 m_pLocationOpenButton->setAutoRaise(true);
     310//                 m_pLocationOpenButton->setIcon(UIIconPool::iconSet(":/select_file_16px.png", "select_file_disabled_16px.png"));
     311//             }
     312//             pLocationLayout->addWidget(m_pLocationEditor);
     313//             pLocationLayout->addWidget(m_pLocationOpenButton);
     314//         }
     315//         m_pSizeLabel = new QIRichTextLabel(this);
     316//         m_pMediumSizeEditor = new UIMediumSizeEditor;
     317//         setMediumSize(uDefaultSize);
     318//         pMainLayout->addWidget(m_pLocationLabel);
     319//         pMainLayout->addLayout(pLocationLayout);
     320//         pMainLayout->addWidget(m_pSizeLabel);
     321//         pMainLayout->addWidget(m_pMediumSizeEditor);
     322//         pMainLayout->addStretch();
     323//     }
     324    retranslateUi();
    322325}
    323326
    … …  
    325328{
    326329    /* Call to base-class: */
    327     onSelectLocationButtonClicked();
     330    //onSelectLocationButtonClicked();
    328331}
    329332
    330333void UIWizardNewVDPageSizeLocation::retranslateUi()
    331334{
    332     retranslateWidgets();
    333     /* Translate page: */
    334335    setTitle(UIWizardNewVD::tr("File location and size"));
     336    // if (m_pLocationLabel)
     337    //     m_pLocationLabel->setText(UIWizardNewVD::tr("Please type the name of the new virtual hard disk file into the box below or "
     338    //                                                 "click on the folder icon to select a different folder to create the file in."));
     339    // if (m_pSizeLabel)
     340    //     m_pSizeLabel->setText(UIWizardNewVD::tr("Select the size of the virtual hard disk in megabytes. "
     341    //                                             "This size is the limit on the amount of file data "
     342    //                                             "that a virtual machine will be able to store on the hard disk."));
    335343}
    336344
    337345void UIWizardNewVDPageSizeLocation::initializePage()
    338346{
    339     /* Translate page: */
    340     retranslateUi();
    341 
    342     /* Get default extension for new virtual-disk: */
    343     m_strDefaultExtension = defaultExtension(field("mediumFormat").value<CMediumFormat>());
    344     /* Set default name as text for location editor: */
    345     if (m_pLocationEditor)
    346         m_pLocationEditor->setText(absoluteFilePath(m_strDefaultName, m_strDefaultPath, m_strDefaultExtension));
     347    // /* Translate page: */
     348    // retranslateUi();
     349
     350    // /* Get default extension for new virtual-disk: */
     351    // m_strDefaultExtension = defaultExtension(field("mediumFormat").value<CMediumFormat>());
     352    // /* Set default name as text for location editor: */
     353    // if (m_pLocationEditor)
     354    //     m_pLocationEditor->setText(absoluteFilePath(m_strDefaultName, m_strDefaultPath, m_strDefaultExtension));
    347355}
    348356
    349357bool UIWizardNewVDPageSizeLocation::isComplete() const
    350358{
    351     if (!m_pLocationEditor)
    352         return false;
    353     /* Make sure current name is not empty and current size fits the bounds: */
    354     return !m_pLocationEditor->text().trimmed().isEmpty() &&
    355            mediumSize() >= m_uMediumSizeMin && mediumSize() <= m_uMediumSizeMax;
     359    // if (!m_pLocationEditor)
     360    //     return false;
     361    // /* Make sure current name is not empty and current size fits the bounds: */
     362    // return !m_pLocationEditor->text().trimmed().isEmpty() &&
     363    //        mediumSize() >= m_uMediumSizeMin && mediumSize() <= m_uMediumSizeMax;
     364    return false;
    356365}
    357366
    … …  
    361370    bool fResult = true;
    362371
    363     /* Make sure such file doesn't exist already: */
    364     const QString strMediumPath(mediumPath());
    365     fResult = !QFileInfo(strMediumPath).exists();
    366     if (!fResult)
    367     {
    368         msgCenter().cannotOverwriteHardDiskStorage(strMediumPath, this);
    369         return fResult;
    370     }
    371 
    372     /* Make sure we are passing FAT size limitation: */
    373     fResult = checkFATSizeLimitation(fieldImp("mediumVariant").toULongLong(),
    374                                      fieldImp("mediumPath").toString(),
    375                                      fieldImp("mediumSize").toULongLong());
    376     if (!fResult)
    377     {
    378         msgCenter().cannotCreateHardDiskStorageInFAT(strMediumPath, this);
    379         return fResult;
    380     }
    381 
    382     /* Lock finish button: */
    383     startProcessing();
    384     /* Try to create virtual-disk: */
    385     fResult = qobject_cast<UIWizardNewVD*>(wizard())->createVirtualDisk();
    386     /* Unlock finish button: */
    387     endProcessing();
     372    // /* Make sure such file doesn't exist already: */
     373    // const QString strMediumPath(mediumPath());
     374    // fResult = !QFileInfo(strMediumPath).exists();
     375    // if (!fResult)
     376    // {
     377    //     msgCenter().cannotOverwriteHardDiskStorage(strMediumPath, this);
     378    //     return fResult;
     379    // }
     380
     381    // /* Make sure we are passing FAT size limitation: */
     382    // fResult = checkFATSizeLimitation(fieldImp("mediumVariant").toULongLong(),
     383    //                                  fieldImp("mediumPath").toString(),
     384    //                                  fieldImp("mediumSize").toULongLong());
     385    // if (!fResult)
     386    // {
     387    //     msgCenter().cannotCreateHardDiskStorageInFAT(strMediumPath, this);
     388    //     return fResult;
     389    // }
     390
     391    // /* Lock finish button: */
     392    // startProcessing();
     393    // /* Try to create virtual-disk: */
     394    // fResult = qobject_cast<UIWizardNewVD*>(wizard())->createVirtualDisk();
     395    // /* Unlock finish button: */
     396    // endProcessing();
    388397
    389398    /* Return result: */

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvd/UIWizardNewVDPageSizeLocation.h

    r88599 r90356  
    2323
    2424/* GUI includes: */
    25 #include "UIWizardPage.h"
     25#include "UINativeWizardPage.h"
    2626
    2727/* Forward declarations: */
    … …  
    3232class QIRichTextLabel;
    3333class UIMediumSizeEditor;
     34class UIMediumSizeAndPathGroupBox;
    3435
     36// /* 3rd page of the New Virtual Hard Drive wizard (base part): */
     37// class SHARED_LIBRARY_STUFF UIWizardNewVDPageBaseSizeLocation : public UIWizardPageBase
     38// {
    3539
    36 /* 3rd page of the New Virtual Hard Drive wizard (base part): */
    37 class SHARED_LIBRARY_STUFF UIWizardNewVDPageBaseSizeLocation : public UIWizardPageBase
    38 {
     40// public:
    3941
    40 public:
     42//     static QString defaultExtension(const CMediumFormat &mediumFormatRef);
     43//     /* Checks if the medium file is bigger than what is allowed in FAT file systems. */
     44//     static bool checkFATSizeLimitation(const qulonglong uVariant, const QString &strMediumPath, const qulonglong uSize);
    4145
    42     static QString defaultExtension(const CMediumFormat &mediumFormatRef);
    43     /* Checks if the medium file is bigger than what is allowed in FAT file systems. */
    44     static bool checkFATSizeLimitation(const qulonglong uVariant, const QString &strMediumPath, const qulonglong uSize);
     46// protected:
    4547
    46 protected:
     48//     UIWizardNewVDPageBaseSizeLocation(const QString &strDefaultName, const QString &strDefaultPath);
     49//     UIWizardNewVDPageBaseSizeLocation();
    4750
    48     UIWizardNewVDPageBaseSizeLocation(const QString &strDefaultName, const QString &strDefaultPath);
    49     UIWizardNewVDPageBaseSizeLocation();
     51//     void onSelectLocationButtonClicked();
    5052
    51     void onSelectLocationButtonClicked();
     53//     static QString toFileName(const QString &strName, const QString &strExtension);
     54//     /** Returns the full image file path except the extension. */
     55//     static QString absoluteFilePath(const QString &strFileName, const QString &strPath);
     56//     /** Returns the full image file path including the extension. */
     57//     static QString absoluteFilePath(const QString &strFileName, const QString &strPath, const QString &strExtension);
    5258
    53     static QString toFileName(const QString &strName, const QString &strExtension);
    54     /** Returns the full image file path except the extension. */
    55     static QString absoluteFilePath(const QString &strFileName, const QString &strPath);
    56     /** Returns the full image file path including the extension. */
    57     static QString absoluteFilePath(const QString &strFileName, const QString &strPath, const QString &strExtension);
     59//     virtual QString mediumPath() const;
     60//     /** A utility function thar strips the format extension from the @p strFileName.
     61//       * foo.dd.vdi becomes foo.dd. any extension which is not a format extension is left alone. */
     62//     static QString stripFormatExtension(const QString &strFileName, const QStringList &formatExtensions);
     63//     void updateLocationEditorAfterFormatChange(const CMediumFormat &mediumFormat, const QStringList &formatExtensions);
    5864
    59     virtual QString mediumPath() const;
    60     /** A utility function thar strips the format extension from the @p strFileName.
    61       * foo.dd.vdi becomes foo.dd. any extension which is not a format extension is left alone. */
    62     static QString stripFormatExtension(const QString &strFileName, const QStringList &formatExtensions);
    63     void updateLocationEditorAfterFormatChange(const CMediumFormat &mediumFormat, const QStringList &formatExtensions);
     65//     qulonglong mediumSize() const;
     66//     void setMediumSize(qulonglong uMediumSize);
     67//     void retranslateWidgets();
    6468
    65     qulonglong mediumSize() const;
    66     void setMediumSize(qulonglong uMediumSize);
    67     void retranslateWidgets();
     69//     /** @name Widgets
     70//      * @{ */
     71//        QString m_strDefaultName;
     72//        QString m_strDefaultPath;
     73//        QString m_strDefaultExtension;
     74//        qulonglong m_uMediumSizeMin;
     75//        qulonglong m_uMediumSizeMax;
     76//     /** @} */
    6877
    69     /** @name Widgets
    70      * @{ */
    71        QString m_strDefaultName;
    72        QString m_strDefaultPath;
    73        QString m_strDefaultExtension;
    74        qulonglong m_uMediumSizeMin;
    75        qulonglong m_uMediumSizeMax;
    76     /** @} */
     78//     /** @name Widgets
     79//      * @{ */
     80//        QLineEdit *m_pLocationEditor;
     81//        QIToolButton *m_pLocationOpenButton;
     82//        UIMediumSizeEditor *m_pMediumSizeEditor;
     83//        QLabel          *m_pMediumSizeEditorLabel;
    7784
    78     /** @name Widgets
    79      * @{ */
    80        QLineEdit *m_pLocationEditor;
    81        QIToolButton *m_pLocationOpenButton;
    82        UIMediumSizeEditor *m_pMediumSizeEditor;
    83        QLabel          *m_pMediumSizeEditorLabel;
    84        QIRichTextLabel *m_pLocationLabel;
    85        QIRichTextLabel *m_pSizeLabel;
    86     /** @} */
    87 };
     85//     /** @} */
     86// };
    8887
    8988
    9089/* 3rd page of the New Virtual Hard Drive wizard (basic extension): */
    91 class SHARED_LIBRARY_STUFF UIWizardNewVDPageSizeLocation : public UIWizardPage, public UIWizardNewVDPageBaseSizeLocation
     90class SHARED_LIBRARY_STUFF UIWizardNewVDPageSizeLocation : public UINativeWizardPage
    9291{
    9392    Q_OBJECT;
    94     Q_PROPERTY(QString mediumPath READ mediumPath);
    95     Q_PROPERTY(qulonglong mediumSize READ mediumSize WRITE setMediumSize);
    9693
    9794public:
    … …  
    10198protected:
    10299
    103     /** Wrapper to access 'this' from base part: */
    104     UIWizardPage* thisImp() { return this; }
    105     /** Wrapper to access 'wizard-field' from base part: */
    106     QVariant fieldImp(const QString &strFieldName) const { return UIWizardPage::field(strFieldName); }
    107100
    108101private slots:
    … …  
    117110    bool isComplete() const;
    118111    bool validatePage();
     112    void prepare();
     113
     114    UIMediumSizeAndPathGroupBox *m_pMediumSizePathGroup;
    119115};
    120116

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvd/UIWizardNewVDPageVariant.cpp

    r88598 r90356  
    2323
    2424/* GUI includes: */
     25#include "UIWizardDiskEditors.h"
    2526#include "UIWizardNewVDPageVariant.h"
    2627#include "UIWizardNewVD.h"
    … …  
    3031#include "CMediumFormat.h"
    3132
    32 UIWizardNewVDPageBaseVariant::UIWizardNewVDPageBaseVariant()
    33     : m_pFixedCheckBox(0)
    34     , m_pSplitBox(0)
    35     , m_pDescriptionLabel(0)
     33// UIWizardNewVDPageBaseVariant::UIWizardNewVDPageBaseVariant()
     34//     : m_pFixedCheckBox(0)
     35//     , m_pSplitBox(0)
     36//     , m_pDescriptionLabel(0)
     37//     , m_pDynamicLabel(0)
     38//     , m_pFixedLabel(0)
     39//     , m_pSplitLabel(0)
     40// {
     41// }
     42
     43// QWidget *UIWizardNewVDPageBaseVariant::createMediumVariantWidgets(bool fWithLabels)
     44// {
     45//     QWidget *pContainerWidget = new QWidget;
     46//     return pContainerWidget;
     47// }
     48
     49// qulonglong UIWizardNewVDPageBaseVariant::mediumVariant() const
     50// {
     51//     /* Initial value: */
     52//     qulonglong uMediumVariant = (qulonglong)KMediumVariant_Max;
     53
     54//     /* Exclusive options: */
     55//     if (m_pFixedCheckBox && m_pFixedCheckBox->isChecked())
     56//         uMediumVariant = (qulonglong)KMediumVariant_Fixed;
     57//     else
     58//         uMediumVariant = (qulonglong)KMediumVariant_Standard;
     59
     60//     /* Additional options: */
     61//     if (m_pSplitBox && m_pSplitBox->isChecked())
     62//         uMediumVariant |= (qulonglong)KMediumVariant_VmdkSplit2G;
     63
     64//     /* Return options: */
     65//     return uMediumVariant;
     66// }
     67
     68// void UIWizardNewVDPageBaseVariant::setMediumVariant(qulonglong uMediumVariant)
     69// {
     70//     /* Exclusive options: */
     71//     if (uMediumVariant & (qulonglong)KMediumVariant_Fixed)
     72//     {
     73//         m_pFixedCheckBox->click();
     74//         m_pFixedCheckBox->setFocus();
     75//     }
     76
     77//     /* Additional options: */
     78//     m_pSplitBox->setChecked(uMediumVariant & (qulonglong)KMediumVariant_VmdkSplit2G);
     79// }
     80
     81// void UIWizardNewVDPageBaseVariant::retranslateWidgets()
     82// {
     83//     if (m_pFixedCheckBox)
     84//     {
     85//         m_pFixedCheckBox->setText(UIWizardNewVD::tr("Pre-allocate &Full Size"));
     86//         m_pFixedCheckBox->setToolTip(UIWizardNewVD::tr("<p>When checked, the virtual disk image will be fully allocated at "
     87//                                                        "VM creation time, rather than being allocated dynamically at VM run-time.</p>"));
     88//     }
     89
     90//     if (m_pSplitBox)
     91//         m_pSplitBox->setText(UIWizardNewVD::tr("&Split Into Files of Less Than 2GB"));
     92
     93
     94// }
     95
     96// void UIWizardNewVDPageBaseVariant::setWidgetVisibility(CMediumFormat &mediumFormat)
     97// {
     98//     ULONG uCapabilities = 0;
     99//     QVector<KMediumFormatCapabilities> capabilities;
     100//     capabilities = mediumFormat.GetCapabilities();
     101//     for (int i = 0; i < capabilities.size(); i++)
     102//         uCapabilities |= capabilities[i];
     103
     104//     bool fIsCreateDynamicPossible = uCapabilities & KMediumFormatCapabilities_CreateDynamic;
     105//     bool fIsCreateFixedPossible = uCapabilities & KMediumFormatCapabilities_CreateFixed;
     106//     bool fIsCreateSplitPossible = uCapabilities & KMediumFormatCapabilities_CreateSplit2G;
     107//     if (m_pFixedCheckBox)
     108//     {
     109//         if (!fIsCreateDynamicPossible)
     110//         {
     111//             m_pFixedCheckBox->setChecked(true);
     112//             m_pFixedCheckBox->setEnabled(false);
     113//         }
     114//         if (!fIsCreateFixedPossible)
     115//         {
     116//             m_pFixedCheckBox->setChecked(false);
     117//             m_pFixedCheckBox->setEnabled(false);
     118//         }
     119//     }
     120//     if (m_pDynamicLabel)
     121//         m_pDynamicLabel->setHidden(!fIsCreateDynamicPossible);
     122//     if (m_pFixedLabel)
     123//         m_pFixedLabel->setHidden(!fIsCreateFixedPossible);
     124//     if (m_pFixedCheckBox)
     125//         m_pFixedCheckBox->setHidden(!fIsCreateFixedPossible);
     126//     if (m_pSplitLabel)
     127//         m_pSplitLabel->setHidden(!fIsCreateSplitPossible);
     128//     if (m_pSplitBox)
     129//         m_pSplitBox->setHidden(!fIsCreateSplitPossible);
     130// }
     131
     132// void UIWizardNewVDPageBaseVariant::updateMediumVariantWidgetsAfterFormatChange(const CMediumFormat &mediumFormat)
     133// {
     134//     /* Enable/disable widgets: */
     135//     ULONG uCapabilities = 0;
     136//     QVector<KMediumFormatCapabilities> capabilities;
     137//     capabilities = mediumFormat.GetCapabilities();
     138//     for (int i = 0; i < capabilities.size(); i++)
     139//         uCapabilities |= capabilities[i];
     140
     141//     bool fIsCreateDynamicPossible = uCapabilities & KMediumFormatCapabilities_CreateDynamic;
     142//     bool fIsCreateFixedPossible = uCapabilities & KMediumFormatCapabilities_CreateFixed;
     143//     bool fIsCreateSplitPossible = uCapabilities & KMediumFormatCapabilities_CreateSplit2G;
     144
     145//     if (m_pFixedCheckBox)
     146//     {
     147//         m_pFixedCheckBox->setEnabled(fIsCreateDynamicPossible || fIsCreateFixedPossible);
     148//         if (!fIsCreateDynamicPossible)
     149//             m_pFixedCheckBox->setChecked(true);
     150//         if (!fIsCreateFixedPossible)
     151//             m_pFixedCheckBox->setChecked(false);
     152//     }
     153//     m_pSplitBox->setEnabled(fIsCreateSplitPossible);
     154// }
     155
     156UIWizardNewVDPageVariant::UIWizardNewVDPageVariant()
     157    : m_pDescriptionLabel(0)
    36158    , m_pDynamicLabel(0)
    37159    , m_pFixedLabel(0)
    38160    , m_pSplitLabel(0)
    39 {
    40 }
    41 
    42 QWidget *UIWizardNewVDPageBaseVariant::createMediumVariantWidgets(bool fWithLabels)
    43 {
    44     QWidget *pContainerWidget = new QWidget;
    45     QVBoxLayout *pMainLayout = new QVBoxLayout(pContainerWidget);
    46     if (pMainLayout)
    47     {
    48         if (fWithLabels)
    49         {
    50             m_pDescriptionLabel = new QIRichTextLabel;
    51             m_pDynamicLabel = new QIRichTextLabel;
    52             m_pFixedLabel = new QIRichTextLabel;
    53             m_pSplitLabel = new QIRichTextLabel;
    54         }
    55         QVBoxLayout *pVariantLayout = new QVBoxLayout;
    56         if (pVariantLayout)
    57         {
    58             m_pFixedCheckBox = new QCheckBox;
    59             m_pSplitBox = new QCheckBox;
    60             pVariantLayout->addWidget(m_pFixedCheckBox);
    61             pVariantLayout->addWidget(m_pSplitBox);
    62         }
    63         if (fWithLabels)
    64         {
    65             pMainLayout->addWidget(m_pDescriptionLabel);
    66             pMainLayout->addWidget(m_pDynamicLabel);
    67             pMainLayout->addWidget(m_pFixedLabel);
    68             pMainLayout->addWidget(m_pSplitLabel);
    69         }
    70         pMainLayout->addLayout(pVariantLayout);
    71         pMainLayout->addStretch();
    72         pMainLayout->setContentsMargins(0, 0, 0, 0);
    73     }
    74     return pContainerWidget;
    75 }
    76 
    77 qulonglong UIWizardNewVDPageBaseVariant::mediumVariant() const
    78 {
    79     /* Initial value: */
    80     qulonglong uMediumVariant = (qulonglong)KMediumVariant_Max;
    81 
    82     /* Exclusive options: */
    83     if (m_pFixedCheckBox && m_pFixedCheckBox->isChecked())
    84         uMediumVariant = (qulonglong)KMediumVariant_Fixed;
    85     else
    86         uMediumVariant = (qulonglong)KMediumVariant_Standard;
    87 
    88     /* Additional options: */
    89     if (m_pSplitBox && m_pSplitBox->isChecked())
    90         uMediumVariant |= (qulonglong)KMediumVariant_VmdkSplit2G;
    91 
    92     /* Return options: */
    93     return uMediumVariant;
    94 }
    95 
    96 void UIWizardNewVDPageBaseVariant::setMediumVariant(qulonglong uMediumVariant)
    97 {
    98     /* Exclusive options: */
    99     if (uMediumVariant & (qulonglong)KMediumVariant_Fixed)
    100     {
    101         m_pFixedCheckBox->click();
    102         m_pFixedCheckBox->setFocus();
    103     }
    104 
    105     /* Additional options: */
    106     m_pSplitBox->setChecked(uMediumVariant & (qulonglong)KMediumVariant_VmdkSplit2G);
    107 }
    108 
    109 void UIWizardNewVDPageBaseVariant::retranslateWidgets()
    110 {
    111     if (m_pFixedCheckBox)
    112     {
    113         m_pFixedCheckBox->setText(UIWizardNewVD::tr("Pre-allocate &Full Size"));
    114         m_pFixedCheckBox->setToolTip(UIWizardNewVD::tr("<p>When checked, the virtual disk image will be fully allocated at "
    115                                                        "VM creation time, rather than being allocated dynamically at VM run-time.</p>"));
    116     }
    117 
    118     if (m_pSplitBox)
    119         m_pSplitBox->setText(UIWizardNewVD::tr("&Split Into Files of Less Than 2GB"));
    120 
    121 
    122     /* Translate rich text labels: */
     161    , m_pVariantGroupBox(0)
     162{
     163    prepare();
     164}
     165
     166void UIWizardNewVDPageVariant::prepare()
     167{
     168
     169    QVBoxLayout *pMainLayout = new QVBoxLayout(this);
     170    AssertReturnVoid(pMainLayout);
     171
     172    m_pDescriptionLabel = new QIRichTextLabel;
     173    m_pDynamicLabel = new QIRichTextLabel;
     174    m_pFixedLabel = new QIRichTextLabel;
     175    m_pSplitLabel = new QIRichTextLabel;
     176
     177    pMainLayout->addWidget(m_pDescriptionLabel);
     178    pMainLayout->addWidget(m_pDynamicLabel);
     179    pMainLayout->addWidget(m_pFixedLabel);
     180    pMainLayout->addWidget(m_pSplitLabel);
     181
     182    m_pVariantGroupBox = new UIDiskVariantGroupBox(false, 0);
     183    pMainLayout->addWidget(m_pVariantGroupBox);
     184
     185    pMainLayout->addStretch();
     186
     187    retranslateUi();
     188
     189    /* Create widgets: */
     190    // QVBoxLayout *pMainLayout = new QVBoxLayout(this);
     191    // pMainLayout->addWidget(createMediumVariantWidgets(true));
     192    // pMainLayout->addStretch();
     193
     194    // /* Setup connections: */
     195    // connect(m_pFixedCheckBox, &QAbstractButton::toggled,
     196    //         this, &UIWizardNewVDPageVariant::completeChanged);
     197    // connect(m_pSplitBox, &QCheckBox::stateChanged,
     198    //         this, &UIWizardNewVDPageVariant::completeChanged);
     199
     200    // /* Register fields: */
     201    // registerField("mediumVariant", this, "mediumVariant");
     202}
     203
     204void UIWizardNewVDPageVariant::retranslateUi()
     205{
     206    setTitle(UIWizardNewVD::tr("Storage on physical hard disk"));
     207
    123208    if (m_pDescriptionLabel)
    124209        m_pDescriptionLabel->setText(UIWizardNewVD::tr("Please choose whether the new virtual hard disk file should grow as it is used "
    … …  
    138223}
    139224
    140 void UIWizardNewVDPageBaseVariant::setWidgetVisibility(CMediumFormat &mediumFormat)
    141 {
    142     ULONG uCapabilities = 0;
    143     QVector<KMediumFormatCapabilities> capabilities;
    144     capabilities = mediumFormat.GetCapabilities();
    145     for (int i = 0; i < capabilities.size(); i++)
    146         uCapabilities |= capabilities[i];
    147 
    148     bool fIsCreateDynamicPossible = uCapabilities & KMediumFormatCapabilities_CreateDynamic;
    149     bool fIsCreateFixedPossible = uCapabilities & KMediumFormatCapabilities_CreateFixed;
    150     bool fIsCreateSplitPossible = uCapabilities & KMediumFormatCapabilities_CreateSplit2G;
    151     if (m_pFixedCheckBox)
    152     {
    153         if (!fIsCreateDynamicPossible)
    154         {
    155             m_pFixedCheckBox->setChecked(true);
    156             m_pFixedCheckBox->setEnabled(false);
    157         }
    158         if (!fIsCreateFixedPossible)
    159         {
    160             m_pFixedCheckBox->setChecked(false);
    161             m_pFixedCheckBox->setEnabled(false);
    162         }
    163     }
    164     if (m_pDynamicLabel)
    165         m_pDynamicLabel->setHidden(!fIsCreateDynamicPossible);
    166     if (m_pFixedLabel)
    167         m_pFixedLabel->setHidden(!fIsCreateFixedPossible);
    168     if (m_pFixedCheckBox)
    169         m_pFixedCheckBox->setHidden(!fIsCreateFixedPossible);
    170     if (m_pSplitLabel)
    171         m_pSplitLabel->setHidden(!fIsCreateSplitPossible);
    172     if (m_pSplitBox)
    173         m_pSplitBox->setHidden(!fIsCreateSplitPossible);
    174 }
    175 
    176 void UIWizardNewVDPageBaseVariant::updateMediumVariantWidgetsAfterFormatChange(const CMediumFormat &mediumFormat)
    177 {
    178     /* Enable/disable widgets: */
    179     ULONG uCapabilities = 0;
    180     QVector<KMediumFormatCapabilities> capabilities;
    181     capabilities = mediumFormat.GetCapabilities();
    182     for (int i = 0; i < capabilities.size(); i++)
    183         uCapabilities |= capabilities[i];
    184 
    185     bool fIsCreateDynamicPossible = uCapabilities & KMediumFormatCapabilities_CreateDynamic;
    186     bool fIsCreateFixedPossible = uCapabilities & KMediumFormatCapabilities_CreateFixed;
    187     bool fIsCreateSplitPossible = uCapabilities & KMediumFormatCapabilities_CreateSplit2G;
    188 
    189     if (m_pFixedCheckBox)
    190     {
    191         m_pFixedCheckBox->setEnabled(fIsCreateDynamicPossible || fIsCreateFixedPossible);
    192         if (!fIsCreateDynamicPossible)
    193             m_pFixedCheckBox->setChecked(true);
    194         if (!fIsCreateFixedPossible)
    195             m_pFixedCheckBox->setChecked(false);
    196     }
    197     m_pSplitBox->setEnabled(fIsCreateSplitPossible);
    198 }
    199 
    200 UIWizardNewVDPageVariant::UIWizardNewVDPageVariant()
    201 {
    202     /* Create widgets: */
    203     QVBoxLayout *pMainLayout = new QVBoxLayout(this);
    204     pMainLayout->addWidget(createMediumVariantWidgets(true));
    205     pMainLayout->addStretch();
    206 
    207     /* Setup connections: */
    208     connect(m_pFixedCheckBox, &QAbstractButton::toggled,
    209             this, &UIWizardNewVDPageVariant::completeChanged);
    210     connect(m_pSplitBox, &QCheckBox::stateChanged,
    211             this, &UIWizardNewVDPageVariant::completeChanged);
    212 
    213     /* Register fields: */
    214     registerField("mediumVariant", this, "mediumVariant");
    215 }
    216 
    217 void UIWizardNewVDPageVariant::retranslateUi()
    218 {
    219     retranslateWidgets();
    220     /* Translate page: */
    221     setTitle(UIWizardNewVD::tr("Storage on physical hard disk"));
    222 }
    223 
    224225void UIWizardNewVDPageVariant::initializePage()
    225226{
    226     /* Translate page: */
    227     retranslateUi();
    228     CMediumFormat mediumFormat = field("mediumFormat").value<CMediumFormat>();
    229     setWidgetVisibility(mediumFormat);
     227    // retranslateUi();
     228    // CMediumFormat mediumFormat = field("mediumFormat").value<CMediumFormat>();
     229    // setWidgetVisibility(mediumFormat);
    230230}
    231231
    232232bool UIWizardNewVDPageVariant::isComplete() const
    233233{
    234     /* Make sure medium variant is correct: */
    235     return mediumVariant() != (qulonglong)KMediumVariant_Max;
    236 }
     234    //return mediumVariant() != (qulonglong)KMediumVariant_Max;
     235    return false;
     236}

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvd/UIWizardNewVDPageVariant.h

    r88598 r90356  
    2323
    2424/* GUI includes: */
    25 #include "UIWizardPage.h"
     25#include "UINativeWizardPage.h"
    2626
    2727/* Forward declarations: */
    … …  
    3030class QCheckBox;
    3131class QIRichTextLabel;
     32class UIDiskVariantGroupBox;
    3233
     34// /* 2nd page of the New Virtual Hard Drive wizard (base part): */
     35// class SHARED_LIBRARY_STUFF UIWizardNewVDPageBaseVariant : public UIWizardPageBase
     36// {
     37// protected:
    3338
    34 /* 2nd page of the New Virtual Hard Drive wizard (base part): */
    35 class SHARED_LIBRARY_STUFF UIWizardNewVDPageBaseVariant : public UIWizardPageBase
    36 {
    37 protected:
     39//     /** Constructor: */
     40//     UIWizardNewVDPageBaseVariant();
    3841
    39     /** Constructor: */
    40     UIWizardNewVDPageBaseVariant();
     42//     QWidget *createMediumVariantWidgets(bool fWithLabels);
     43//     qulonglong mediumVariant() const;
     44//     void setMediumVariant(qulonglong uMediumVariant);
     45//     void retranslateWidgets();
     46//     /** Check Medium format capability and decide if certain widgets can be shown. */
     47//     void setWidgetVisibility(CMediumFormat &mediumFormat);
     48//     void updateMediumVariantWidgetsAfterFormatChange(const CMediumFormat &mediumFormat);
    4149
    42     QWidget *createMediumVariantWidgets(bool fWithLabels);
    43     qulonglong mediumVariant() const;
    44     void setMediumVariant(qulonglong uMediumVariant);
    45     void retranslateWidgets();
    46     /** Check Medium format capability and decide if certain widgets can be shown. */
    47     void setWidgetVisibility(CMediumFormat &mediumFormat);
    48     void updateMediumVariantWidgetsAfterFormatChange(const CMediumFormat &mediumFormat);
    49     /** @name Widgets
    50      * @{ */
    51         QCheckBox *m_pFixedCheckBox;
    52         QCheckBox *m_pSplitBox;
    53     /** @} */
     50// };
    5451
    55     /** @name Rich text labels. Declared/defined here since the are shared in more than one child class
    56      * @{ */
    57         QIRichTextLabel *m_pDescriptionLabel;
    58         QIRichTextLabel *m_pDynamicLabel;
    59         QIRichTextLabel *m_pFixedLabel;
    60         QIRichTextLabel *m_pSplitLabel;
    61     /** @} */
    62 };
    63 
    64 /* 2nd page of the New Virtual Hard Drive wizard (basic extension): */
    65 class SHARED_LIBRARY_STUFF UIWizardNewVDPageVariant : public UIWizardPage, public UIWizardNewVDPageBaseVariant
     52class SHARED_LIBRARY_STUFF UIWizardNewVDPageVariant : public UINativeWizardPage
    6653{
    6754    Q_OBJECT;
    68     Q_PROPERTY(qulonglong mediumVariant READ mediumVariant WRITE setMediumVariant);
    6955
    7056public:
    … …  
    7763    void initializePage();
    7864    bool isComplete() const;
     65    void prepare();
     66
     67    QIRichTextLabel *m_pDescriptionLabel;
     68    QIRichTextLabel *m_pDynamicLabel;
     69    QIRichTextLabel *m_pFixedLabel;
     70    QIRichTextLabel *m_pSplitLabel;
     71    UIDiskVariantGroupBox *m_pVariantGroupBox;
    7972};
    8073

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

    r90275 r90356  
    5353UIWizardNewVM::UIWizardNewVM(QWidget *pParent, const QString &strMachineGroup /* = QString() */,
    5454                             WizardMode enmMode /* = WizardMode_Auto */)
    55     : UINativeWizard(pParent, WizardType_NewCloudVM, enmMode)
     55    : UINativeWizard(pParent, WizardType_NewVM, enmMode)
    5656    , m_strMachineGroup(strMachineGroup)
    5757    , m_iIDECount(0)

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

    r90295 r90356  
    466466    m_pSizeAndLocationGroup = new UIMediumSizeAndPathGroupBox;
    467467    pDiskContainerLayout->addWidget(m_pSizeAndLocationGroup, 0, 0, 2, 2);
    468     m_pFormatButtonGroup = new UIDiskFormatsGroupBox;
     468    m_pFormatButtonGroup = new UIDiskFormatsGroupBox(true, 0);
    469469    pDiskContainerLayout->addWidget(m_pFormatButtonGroup, 2, 0, 4, 1);
    470     m_pDiskVariantGroupBox  = new UIDiskVariantGroupBox;
     470    m_pDiskVariantGroupBox  = new UIDiskVariantGroupBox(true, 0);
    471471    pDiskContainerLayout->addWidget(m_pDiskVariantGroupBox, 2, 1, 2, 1);
    472472
Note: See TracChangeset for help on using the changeset viewer.

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