VirtualBox

Changeset 90748 in vbox for trunk/src


Ignore:
Timestamp:
Aug 19, 2021 2:36:02 PM (3 years ago)
Author:
vboxsync
Message:

FE/Qt: bugref:9996. Initial commit for refactoring clone vd wizard.

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

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VirtualBox/src/medium/UIMediumManager.cpp

    r90564 r90748  
    475475    /* Show Clone VD wizard: */
    476476    UIMedium medium = pMediumItem->medium();
    477     UISafePointerWizard pWizard = new UIWizardCloneVD(currentTreeWidget(), medium.medium());
    478     pWizard->prepare();
     477    QPointer<UINativeWizard> pWizard = new UIWizardCloneVD(currentTreeWidget(), medium.medium());
    479478    pWizard->exec();
    480479

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/clonevd/UIWizardCloneVD.cpp

    r90564 r90748  
    3232
    3333UIWizardCloneVD::UIWizardCloneVD(QWidget *pParent, const CMedium &comSourceVirtualDisk)
    34     : UIWizard(pParent, WizardType_CloneVD)
     34    : UINativeWizard(pParent, WizardType_CloneVD)
    3535    , m_comSourceVirtualDisk(comSourceVirtualDisk)
    3636    , m_enmSourceVirtualDiskDeviceType(m_comSourceVirtualDisk.GetDeviceType())
    … …  
    3838#ifndef VBOX_WS_MAC
    3939    /* Assign watermark: */
    40     assignWatermark(":/wizard_new_harddisk.png");
     40    setPixmapName(":/wizard_new_harddisk.png");
    4141#else /* VBOX_WS_MAC */
    4242    /* Assign background image: */
    43     assignBackground(":/wizard_new_harddisk_bg.png");
     43    setPixmapName(":/wizard_new_harddisk_bg.png");
    4444#endif /* VBOX_WS_MAC */
    4545}
    … …  
    4848{
    4949    /* Gather attributes: */
    50     const CMediumFormat comMediumFormat = field("mediumFormat").value<CMediumFormat>();
    51     const qulonglong uVariant = field("mediumVariant").toULongLong();
    52     const QString strMediumPath = field("mediumPath").toString();
    53     const qulonglong uSize = field("mediumSize").toULongLong();
    54     /* Check attributes: */
    55     AssertReturn(!strMediumPath.isNull(), false);
    56     AssertReturn(uSize > 0, false);
     50    // const CMediumFormat comMediumFormat = field("mediumFormat").value<CMediumFormat>();
     51    // const qulonglong uVariant = field("mediumVariant").toULongLong();
     52    // const QString strMediumPath = field("mediumPath").toString();
     53    // const qulonglong uSize = field("mediumSize").toULongLong();
     54    // /* Check attributes: */
     55    // AssertReturn(!strMediumPath.isNull(), false);
     56    // AssertReturn(uSize > 0, false);
    5757
    58     /* Get VBox object: */
    59     CVirtualBox comVBox = uiCommon().virtualBox();
     58    // /* Get VBox object: */
     59    // CVirtualBox comVBox = uiCommon().virtualBox();
    6060
    61     /* Create new virtual disk image: */
    62     CMedium comVirtualDisk = comVBox.CreateMedium(comMediumFormat.GetName(), strMediumPath, KAccessMode_ReadWrite, m_enmSourceVirtualDiskDeviceType);
    63     if (!comVBox.isOk())
    64     {
    65         msgCenter().cannotCreateMediumStorage(comVBox, strMediumPath, this);
    66         return false;
    67     }
     61    // /* Create new virtual disk image: */
     62    // CMedium comVirtualDisk = comVBox.CreateMedium(comMediumFormat.GetName(), strMediumPath, KAccessMode_ReadWrite, m_enmSourceVirtualDiskDeviceType);
     63    // if (!comVBox.isOk())
     64    // {
     65    //     msgCenter().cannotCreateMediumStorage(comVBox, strMediumPath, this);
     66    //     return false;
     67    // }
    6868
    69     /* Compose medium-variant: */
    70     QVector<KMediumVariant> variants(sizeof(qulonglong) * 8);
    71     for (int i = 0; i < variants.size(); ++i)
    72     {
    73         qulonglong temp = uVariant;
    74         temp &= Q_UINT64_C(1) << i;
    75         variants[i] = (KMediumVariant)temp;
    76     }
     69    // /* Compose medium-variant: */
     70    // QVector<KMediumVariant> variants(sizeof(qulonglong) * 8);
     71    // for (int i = 0; i < variants.size(); ++i)
     72    // {
     73    //     qulonglong temp = uVariant;
     74    //     temp &= Q_UINT64_C(1) << i;
     75    //     variants[i] = (KMediumVariant)temp;
     76    // }
    7777
    78     /* Copy medium: */
    79     UINotificationProgressMediumCopy *pNotification = new UINotificationProgressMediumCopy(m_comSourceVirtualDisk,
    80                                                                                            comVirtualDisk,
    81                                                                                            variants);
    82     connect(pNotification, &UINotificationProgressMediumCopy::sigMediumCopied,
    83             &uiCommon(), &UICommon::sltHandleMediumCreated);
    84     gpNotificationCenter->append(pNotification);
     78    // /* Copy medium: */
     79    // UINotificationProgressMediumCopy *pNotification = new UINotificationProgressMediumCopy(m_comSourceVirtualDisk,
     80    //                                                                                        comVirtualDisk,
     81    //                                                                                        variants);
     82    // connect(pNotification, &UINotificationProgressMediumCopy::sigMediumCopied,
     83    //         &uiCommon(), &UICommon::sltHandleMediumCreated);
     84    // gpNotificationCenter->append(pNotification);
    8585
    8686    /* Positive: */
    … …  
    9090void UIWizardCloneVD::retranslateUi()
    9191{
    92     /* Call to base-class: */
    93     UIWizard::retranslateUi();
    94 
    9592    /* Translate wizard: */
    9693    setWindowTitle(tr("Copy Virtual Disk Image"));
    97     setButtonText(QWizard::FinishButton, tr("Copy"));
     94    UINativeWizard::retranslateUi();
    9895}
    9996
    100 void UIWizardCloneVD::prepare()
     97void UIWizardCloneVD::populatePages()
    10198{
    10299    /* Create corresponding pages: */
    … …  
    104101    {
    105102        case WizardMode_Basic:
     103        case WizardMode_Expert:
    106104        {
    107             setPage(Page1, new UIWizardCloneVDPageBasic1(m_enmSourceVirtualDiskDeviceType));
    108             setPage(Page2, new UIWizardCloneVDPageBasic2(m_enmSourceVirtualDiskDeviceType));
    109             setPage(Page3, new UIWizardCloneVDPageBasic3);
     105            addPage(new UIWizardCloneVDPageBasic1(m_enmSourceVirtualDiskDeviceType));
     106            addPage(new UIWizardCloneVDPageBasic2(m_enmSourceVirtualDiskDeviceType));
     107            addPage(new UIWizardCloneVDPageBasic3);
    110108            break;
    111109        }
    112         case WizardMode_Expert:
    113         {
    114             setPage(PageExpert, new UIWizardCloneVDPageExpert(m_enmSourceVirtualDiskDeviceType));
    115             break;
    116         }
     110        // case WizardMode_Expert:
     111        // {
     112        //     setPage(PageExpert, new UIWizardCloneVDPageExpert(m_enmSourceVirtualDiskDeviceType));
     113        //     break;
     114        // }
    117115        default:
    118116        {
    … …  
    121119        }
    122120    }
    123     /* Call to base-class: */
    124     UIWizard::prepare();
    125121}

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/clonevd/UIWizardCloneVD.h

    r90271 r90748  
    2323
    2424/* GUI includes: */
    25 #include "UIWizard.h"
     25#include "UINativeWizard.h"
    2626
    2727/* COM includes: */
    … …  
    3131
    3232/** UIWizard subclass to clone virtual disk image files. */
    33 class UIWizardCloneVD : public UIWizard
     33class UIWizardCloneVD : public UINativeWizard
    3434{
    3535    Q_OBJECT;
    3636
    3737public:
    38 
    39     /** Basic Page IDs. */
    40     enum
    41     {
    42         Page1,
    43         Page2,
    44         Page3
    45     };
    46 
    47     /** Expert Page IDs. */
    48     enum
    49     {
    50         PageExpert
    51     };
    5238
    5339    /** Constructs wizard to clone @a comSourceVirtualDisk passing @a pParent to the base-class. */
    … …  
    6349    bool copyVirtualDisk();
    6450
     51protected:
     52
     53    virtual void populatePages() /* final override */;
     54
    6555private:
    6656
    6757    /** Handles translation event. */
    6858    virtual void retranslateUi() /* override */;
    69 
    70     /** Prepares all. */
    71     virtual void prepare() /* override */;
    7259
    7360    /** Holds the source virtual disk wrapper. */

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/clonevd/UIWizardCloneVDPageBasic1.cpp

    r82968 r90748  
    2525#include "UIWizardCloneVDPageBasic1.h"
    2626#include "UIWizardCloneVD.h"
     27#include "UIWizardDiskEditors.h"
    2728#include "UICommon.h"
    2829#include "QIRichTextLabel.h"
    … …  
    3233
    3334
    34 UIWizardCloneVDPage1::UIWizardCloneVDPage1()
    35 {
    36 }
    37 
    38 void UIWizardCloneVDPage1::addFormatButton(QWidget *pParent, QVBoxLayout *pFormatLayout, KDeviceType enmDeviceType, CMediumFormat comMediumFormat, bool fPreferred /* = false */)
    39 {
    40     /* Check that medium format supports creation: */
    41     ULONG uFormatCapabilities = 0;
    42     QVector<KMediumFormatCapabilities> capabilities;
    43     capabilities = comMediumFormat.GetCapabilities();
    44     for (int i = 0; i < capabilities.size(); i++)
    45         uFormatCapabilities |= capabilities[i];
    46 
    47     if (!(uFormatCapabilities & KMediumFormatCapabilities_CreateFixed ||
    48           uFormatCapabilities & KMediumFormatCapabilities_CreateDynamic))
    49         return;
    50 
    51     /* Check that medium format supports creation of virtual disk images: */
    52     QVector<QString> fileExtensions;
    53     QVector<KDeviceType> deviceTypes;
    54     comMediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
    55     if (!deviceTypes.contains(enmDeviceType))
    56         return;
    57 
    58     /* Create/add corresponding radio-button: */
    59     QRadioButton *pFormatButton = new QRadioButton(pParent);
    60     AssertPtrReturnVoid(pFormatButton);
     35// UIWizardCloneVDPage1::UIWizardCloneVDPage1()
     36// {
     37// }
     38
     39// void UIWizardCloneVDPage1::addFormatButton(QWidget *pParent, QVBoxLayout *pFormatLayout, KDeviceType enmDeviceType, CMediumFormat comMediumFormat, bool fPreferred /* = false */)
     40// {
     41//     /* Check that medium format supports creation: */
     42//     ULONG uFormatCapabilities = 0;
     43//     QVector<KMediumFormatCapabilities> capabilities;
     44//     capabilities = comMediumFormat.GetCapabilities();
     45//     for (int i = 0; i < capabilities.size(); i++)
     46//         uFormatCapabilities |= capabilities[i];
     47
     48//     if (!(uFormatCapabilities & KMediumFormatCapabilities_CreateFixed ||
     49//           uFormatCapabilities & KMediumFormatCapabilities_CreateDynamic))
     50//         return;
     51
     52//     /* Check that medium format supports creation of virtual disk images: */
     53//     QVector<QString> fileExtensions;
     54//     QVector<KDeviceType> deviceTypes;
     55//     comMediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
     56//     if (!deviceTypes.contains(enmDeviceType))
     57//         return;
     58
     59//     /* Create/add corresponding radio-button: */
     60//     QRadioButton *pFormatButton = new QRadioButton(pParent);
     61//     AssertPtrReturnVoid(pFormatButton);
     62//     {
     63//         /* Make the preferred button font bold: */
     64//         if (fPreferred)
     65//         {
     66//             QFont font = pFormatButton->font();
     67//             font.setBold(true);
     68//             pFormatButton->setFont(font);
     69//         }
     70//         pFormatLayout->addWidget(pFormatButton);
     71//         m_formats << comMediumFormat;
     72//         m_formatNames << comMediumFormat.GetName();
     73//         m_pFormatButtonGroup->addButton(pFormatButton, m_formatNames.size() - 1);
     74//     }
     75// }
     76
     77// CMediumFormat UIWizardCloneVDPage1::mediumFormat() const
     78// {
     79//     return m_pFormatButtonGroup->checkedButton() ? m_formats[m_pFormatButtonGroup->checkedId()] : CMediumFormat();
     80// }
     81
     82// void UIWizardCloneVDPage1::setMediumFormat(const CMediumFormat &comMediumFormat)
     83// {
     84//     int iPosition = m_formats.indexOf(comMediumFormat);
     85//     if (iPosition >= 0)
     86//     {
     87//         m_pFormatButtonGroup->button(iPosition)->click();
     88//         m_pFormatButtonGroup->button(iPosition)->setFocus();
     89//     }
     90// }
     91
     92UIWizardCloneVDPageBasic1::UIWizardCloneVDPageBasic1(KDeviceType enmDeviceType)
     93    : m_pLabel(0)
     94    , m_pFormatGroupBox(0)
     95{
     96    prepare(enmDeviceType);
     97    // /* Create widgets: */
     98    // QVBoxLayout *pMainLayout = new QVBoxLayout(this);
     99    // {
     100
     101    //     QVBoxLayout *pFormatLayout = new QVBoxLayout;
     102    //     {
     103    //         m_pFormatButtonGroup = new QButtonGroup(this);
     104    //         {
     105    //             /* Enumerate medium formats in special order: */
     106    //             CSystemProperties properties = uiCommon().virtualBox().GetSystemProperties();
     107    //             const QVector<CMediumFormat> &formats = properties.GetMediumFormats();
     108    //             QMap<QString, CMediumFormat> vdi, preferred, others;
     109    //             foreach (const CMediumFormat &format, formats)
     110    //             {
     111    //                 /* VDI goes first: */
     112    //                 if (format.GetName() == "VDI")
     113    //                     vdi[format.GetId()] = format;
     114    //                 else
     115    //                 {
     116    //                     const QVector<KMediumFormatCapabilities> &capabilities = format.GetCapabilities();
     117    //                     /* Then preferred: */
     118    //                     if (capabilities.contains(KMediumFormatCapabilities_Preferred))
     119    //                         preferred[format.GetId()] = format;
     120    //                     /* Then others: */
     121    //                     else
     122    //                         others[format.GetId()] = format;
     123    //                 }
     124    //             }
     125
     126    //             /* Create buttons for VDI and preferred: */
     127    //             foreach (const QString &strId, vdi.keys())
     128    //                 addFormatButton(this, pFormatLayout, enmDeviceType, vdi.value(strId));
     129    //             foreach (const QString &strId, preferred.keys())
     130    //                 addFormatButton(this, pFormatLayout, enmDeviceType, preferred.value(strId));
     131    //             if (enmDeviceType == KDeviceType_DVD || enmDeviceType == KDeviceType_Floppy)
     132    //                 foreach (const QString &strId, others.keys())
     133    //                     addFormatButton(this, pFormatLayout, enmDeviceType, others.value(strId));
     134
     135    //             if (!m_pFormatButtonGroup->buttons().isEmpty())
     136    //             {
     137    //                 m_pFormatButtonGroup->button(0)->click();
     138    //                 m_pFormatButtonGroup->button(0)->setFocus();
     139    //             }
     140    //         }
     141    //     }
     142    //     pMainLayout->addWidget(m_pLabel);
     143    //     pMainLayout->addLayout(pFormatLayout);
     144    //     pMainLayout->addStretch();
     145    // }
     146
     147    // /* Setup connections: */
     148    // connect(m_pFormatButtonGroup, static_cast<void(QButtonGroup::*)(QAbstractButton*)>(&QButtonGroup::buttonClicked),
     149    //         this, &UIWizardCloneVDPageBasic1::completeChanged);
     150}
     151
     152void UIWizardCloneVDPageBasic1::prepare(KDeviceType enmDeviceType)
     153{
     154    QVBoxLayout *pMainLayout = new QVBoxLayout(this);
     155    m_pLabel = new QIRichTextLabel(this);
     156    if (m_pLabel)
     157        pMainLayout->addWidget(m_pLabel);
     158    m_pFormatGroupBox = new UIDiskFormatsGroupBox(false /* expert mode */, enmDeviceType, 0);
     159    if (m_pFormatGroupBox)
    61160    {
    62         /* Make the preferred button font bold: */
    63         if (fPreferred)
    64         {
    65             QFont font = pFormatButton->font();
    66             font.setBold(true);
    67             pFormatButton->setFont(font);
    68         }
    69         pFormatLayout->addWidget(pFormatButton);
    70         m_formats << comMediumFormat;
    71         m_formatNames << comMediumFormat.GetName();
    72         m_pFormatButtonGroup->addButton(pFormatButton, m_formatNames.size() - 1);
     161        pMainLayout->addWidget(m_pFormatGroupBox);
     162        // connect(m_pFormatButtonGroup, &UIDiskFormatsGroupBox::sigMediumFormatChanged,
     163        //         this, &UIWizardCloneVDPageBasic1::sltMediumFormatChanged);
    73164    }
    74 }
    75 
    76 CMediumFormat UIWizardCloneVDPage1::mediumFormat() const
    77 {
    78     return m_pFormatButtonGroup->checkedButton() ? m_formats[m_pFormatButtonGroup->checkedId()] : CMediumFormat();
    79 }
    80 
    81 void UIWizardCloneVDPage1::setMediumFormat(const CMediumFormat &comMediumFormat)
    82 {
    83     int iPosition = m_formats.indexOf(comMediumFormat);
    84     if (iPosition >= 0)
    85     {
    86         m_pFormatButtonGroup->button(iPosition)->click();
    87         m_pFormatButtonGroup->button(iPosition)->setFocus();
    88     }
    89 }
    90 
    91 UIWizardCloneVDPageBasic1::UIWizardCloneVDPageBasic1(KDeviceType enmDeviceType)
    92 {
    93     /* Create widgets: */
    94     QVBoxLayout *pMainLayout = new QVBoxLayout(this);
    95     {
    96         m_pLabel = new QIRichTextLabel(this);
    97         QVBoxLayout *pFormatLayout = new QVBoxLayout;
    98         {
    99             m_pFormatButtonGroup = new QButtonGroup(this);
    100             {
    101                 /* Enumerate medium formats in special order: */
    102                 CSystemProperties properties = uiCommon().virtualBox().GetSystemProperties();
    103                 const QVector<CMediumFormat> &formats = properties.GetMediumFormats();
    104                 QMap<QString, CMediumFormat> vdi, preferred, others;
    105                 foreach (const CMediumFormat &format, formats)
    106                 {
    107                     /* VDI goes first: */
    108                     if (format.GetName() == "VDI")
    109                         vdi[format.GetId()] = format;
    110                     else
    111                     {
    112                         const QVector<KMediumFormatCapabilities> &capabilities = format.GetCapabilities();
    113                         /* Then preferred: */
    114                         if (capabilities.contains(KMediumFormatCapabilities_Preferred))
    115                             preferred[format.GetId()] = format;
    116                         /* Then others: */
    117                         else
    118                             others[format.GetId()] = format;
    119                     }
    120                 }
    121 
    122                 /* Create buttons for VDI and preferred: */
    123                 foreach (const QString &strId, vdi.keys())
    124                     addFormatButton(this, pFormatLayout, enmDeviceType, vdi.value(strId));
    125                 foreach (const QString &strId, preferred.keys())
    126                     addFormatButton(this, pFormatLayout, enmDeviceType, preferred.value(strId));
    127                 if (enmDeviceType == KDeviceType_DVD || enmDeviceType == KDeviceType_Floppy)
    128                     foreach (const QString &strId, others.keys())
    129                         addFormatButton(this, pFormatLayout, enmDeviceType, others.value(strId));
    130 
    131                 if (!m_pFormatButtonGroup->buttons().isEmpty())
    132                 {
    133                     m_pFormatButtonGroup->button(0)->click();
    134                     m_pFormatButtonGroup->button(0)->setFocus();
    135                 }
    136             }
    137         }
    138         pMainLayout->addWidget(m_pLabel);
    139         pMainLayout->addLayout(pFormatLayout);
    140         pMainLayout->addStretch();
    141     }
    142 
    143     /* Setup connections: */
    144     connect(m_pFormatButtonGroup, static_cast<void(QButtonGroup::*)(QAbstractButton*)>(&QButtonGroup::buttonClicked),
    145             this, &UIWizardCloneVDPageBasic1::completeChanged);
    146 
    147     /* Register classes: */
    148     qRegisterMetaType<CMediumFormat>();
    149     /* Register fields: */
    150     registerField("mediumFormat", this, "mediumFormat");
     165    pMainLayout->addStretch();
     166    retranslateUi();
    151167}
    152168
    … …  
    160176                                          "for the new virtual disk image. If you do not need to use it "
    161177                                          "with other virtualization software you can leave this setting unchanged."));
    162     QList<QAbstractButton*> buttons = m_pFormatButtonGroup->buttons();
    163     for (int i = 0; i < buttons.size(); ++i)
    164     {
    165         QAbstractButton *pButton = buttons[i];
    166         UIMediumFormat enmFormat = gpConverter->fromInternalString<UIMediumFormat>(m_formatNames[m_pFormatButtonGroup->id(pButton)]);
    167         pButton->setText(gpConverter->toString(enmFormat));
    168     }
     178    // QList<QAbstractButton*> buttons = m_pFormatButtonGroup->buttons();
     179    // for (int i = 0; i < buttons.size(); ++i)
     180    // {
     181    //     QAbstractButton *pButton = buttons[i];
     182    //     UIMediumFormat enmFormat = gpConverter->fromInternalString<UIMediumFormat>(m_formatNames[m_pFormatButtonGroup->id(pButton)]);
     183    //     pButton->setText(gpConverter->toString(enmFormat));
     184    // }
    169185}
    170186
    … …  
    178194{
    179195    /* Make sure medium format is correct: */
    180     return !mediumFormat().isNull();
    181 }
    182 
    183 int UIWizardCloneVDPageBasic1::nextId() const
    184 {
    185     /* Show variant page only if there is something to show: */
    186     CMediumFormat mf = mediumFormat();
    187     if (mf.isNull())
    188     {
    189         AssertMsgFailed(("No medium format set!"));
    190     }
    191     else
    192     {
    193         ULONG uCapabilities = 0;
    194         QVector<KMediumFormatCapabilities> capabilities;
    195         capabilities = mf.GetCapabilities();
    196         for (int i = 0; i < capabilities.size(); i++)
    197             uCapabilities |= capabilities[i];
    198 
    199         int cTest = 0;
    200         if (uCapabilities & KMediumFormatCapabilities_CreateDynamic)
    201             ++cTest;
    202         if (uCapabilities & KMediumFormatCapabilities_CreateFixed)
    203             ++cTest;
    204         if (uCapabilities & KMediumFormatCapabilities_CreateSplit2G)
    205             ++cTest;
    206         if (cTest > 1)
    207             return UIWizardCloneVD::Page3;
    208     }
    209     /* Skip otherwise: */
    210     return UIWizardCloneVD::Page3;
    211 }
     196    //return !mediumFormat().isNull();
     197    return true;
     198}
     199
     200// int UIWizardCloneVDPageBasic1::nextId() const
     201// {
     202//     /* Show variant page only if there is something to show: */
     203//     CMediumFormat mf = mediumFormat();
     204//     if (mf.isNull())
     205//     {
     206//         AssertMsgFailed(("No medium format set!"));
     207//     }
     208//     else
     209//     {
     210//         ULONG uCapabilities = 0;
     211//         QVector<KMediumFormatCapabilities> capabilities;
     212//         capabilities = mf.GetCapabilities();
     213//         for (int i = 0; i < capabilities.size(); i++)
     214//             uCapabilities |= capabilities[i];
     215
     216//         int cTest = 0;
     217//         if (uCapabilities & KMediumFormatCapabilities_CreateDynamic)
     218//             ++cTest;
     219//         if (uCapabilities & KMediumFormatCapabilities_CreateFixed)
     220//             ++cTest;
     221//         if (uCapabilities & KMediumFormatCapabilities_CreateSplit2G)
     222//             ++cTest;
     223//         if (cTest > 1)
     224//             return UIWizardCloneVD::Page3;
     225//     }
     226//     /* Skip otherwise: */
     227//     return UIWizardCloneVD::Page3;
     228// }

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/clonevd/UIWizardCloneVDPageBasic1.h

    r82968 r90748  
    2323
    2424/* GUI includes: */
    25 #include "UIWizardPage.h"
     25#include "UINativeWizardPage.h"
    2626
    2727/* COM includes: */
    … …  
    3030
    3131/* Forward declarations: */
    32 class QVBoxLayout;
    33 class QButtonGroup;
    34 class QRadioButton;
    3532class QIRichTextLabel;
     33class UIDiskFormatsGroupBox;
    3634
    3735
    38 /** 1st page of the Clone Virtual Disk Image wizard (base part): */
    39 class UIWizardCloneVDPage1 : public UIWizardPageBase
    40 {
    41 protected:
     36// /** 1st page of the Clone Virtual Disk Image wizard (base part): */
     37// class UIWizardCloneVDPage1 : public UIWizardPageBase
     38// {
     39// protected:
    4240
    43     /** Constructs page basis. */
    44     UIWizardCloneVDPage1();
     41//     /** Constructs page basis. */
     42//     UIWizardCloneVDPage1();
    4543
    46     /** Adds format button.
    47       * @param  pParent          Brings the parent to add button to.
    48       * @param  pFormatsLayout   Brings the layout to insert button to.
    49       * @param  enmDeviceType    Brings the device type all buttons should be restricted to.
    50       * @param  comMediumFormat  Brings the medium format object to acquire format from.
    51       * @param  fPreferred       Brings whether curretn format is preferred or not. */
    52     void addFormatButton(QWidget *pParent,
    53                          QVBoxLayout *pFormatsLayout,
    54                          KDeviceType enmDeviceType,
    55                          CMediumFormat comMediumFormat,
    56                          bool fPreferred = false);
     44//     /** Adds format button.
     45//       * @param  pParent          Brings the parent to add button to.
     46//       * @param  pFormatsLayout   Brings the layout to insert button to.
     47//       * @param  enmDeviceType    Brings the device type all buttons should be restricted to.
     48//       * @param  comMediumFormat  Brings the medium format object to acquire format from.
     49//       * @param  fPreferred       Brings whether curretn format is preferred or not. */
     50//     void addFormatButton(QWidget *pParent,
     51//                          QVBoxLayout *pFormatsLayout,
     52//                          KDeviceType enmDeviceType,
     53//                          CMediumFormat comMediumFormat,
     54//                          bool fPreferred = false);
    5755
    58     /** Returns 'mediumFormat' field value. */
    59     CMediumFormat mediumFormat() const;
    60     /** Defines 'mediumFormat' field value. */
    61     void setMediumFormat(const CMediumFormat &comMediumFormat);
     56//     /** Returns 'mediumFormat' field value. */
     57//     CMediumFormat mediumFormat() const;
     58//     /** Defines 'mediumFormat' field value. */
     59//     void setMediumFormat(const CMediumFormat &comMediumFormat);
    6260
    63     /** Holds the format button-group instance. */
    64     QButtonGroup         *m_pFormatButtonGroup;
    65     /** Holds the format description list. */
    66     QList<CMediumFormat>  m_formats;
    67     /** Holds the format name list. */
    68     QStringList           m_formatNames;
    69 };
     61//     /** Holds the format button-group instance. */
     62//     QButtonGroup         *m_pFormatButtonGroup;
     63//     /** Holds the format description list. */
     64//     QList<CMediumFormat>  m_formats;
     65//     /** Holds the format name list. */
     66//     QStringList           m_formatNames;
     67// };
    7068
    7169
    7270/** 2nd page of the Clone Virtual Disk Image wizard (basic extension): */
    73 class UIWizardCloneVDPageBasic1 : public UIWizardPage, public UIWizardCloneVDPage1
     71class UIWizardCloneVDPageBasic1 : public UINativeWizardPage
    7472{
    7573    Q_OBJECT;
    76     Q_PROPERTY(CMediumFormat mediumFormat READ mediumFormat WRITE setMediumFormat);
    7774
    7875public:
    … …  
    8683    /** Handles translation event. */
    8784    virtual void retranslateUi() /* override */;
     85    void prepare(KDeviceType enmDeviceType);
    8886
    8987    /** Prepares the page. */
    … …  
    9391    virtual bool isComplete() const /* override */;
    9492
    95     /** Returns the ID of the next page to traverse to. */
    96     virtual int nextId() const /* override */;
    97 
    9893    /** Holds the description label instance. */
    9994    QIRichTextLabel *m_pLabel;
     95    UIDiskFormatsGroupBox *m_pFormatGroupBox;
    10096};
    10197

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/clonevd/UIWizardCloneVDPageBasic2.cpp

    r82968 r90748  
    3131
    3232
    33 UIWizardCloneVDPage2::UIWizardCloneVDPage2()
     33// UIWizardCloneVDPage2::UIWizardCloneVDPage2()
     34// {
     35// }
     36
     37// qulonglong UIWizardCloneVDPage2::mediumVariant() const
     38// {
     39//     /* Initial value: */
     40//     qulonglong uMediumVariant = (qulonglong)KMediumVariant_Max;
     41
     42//     /* Exclusive options: */
     43//     if (m_pDynamicalButton->isChecked())
     44//         uMediumVariant = (qulonglong)KMediumVariant_Standard;
     45//     else if (m_pFixedButton->isChecked())
     46//         uMediumVariant = (qulonglong)KMediumVariant_Fixed;
     47
     48//     /* Additional options: */
     49//     if (m_pSplitBox->isChecked())
     50//         uMediumVariant |= (qulonglong)KMediumVariant_VmdkSplit2G;
     51
     52//     /* Return options: */
     53//     return uMediumVariant;
     54// }
     55
     56// void UIWizardCloneVDPage2::setMediumVariant(qulonglong uMediumVariant)
     57// {
     58//     /* Exclusive options: */
     59//     if (uMediumVariant & (qulonglong)KMediumVariant_Fixed)
     60//     {
     61//         m_pFixedButton->click();
     62//         m_pFixedButton->setFocus();
     63//     }
     64//     else
     65//     {
     66//         m_pDynamicalButton->click();
     67//         m_pDynamicalButton->setFocus();
     68//     }
     69
     70//     /* Additional options: */
     71//     m_pSplitBox->setChecked(uMediumVariant & (qulonglong)KMediumVariant_VmdkSplit2G);
     72// }
     73
     74UIWizardCloneVDPageBasic2::UIWizardCloneVDPageBasic2(KDeviceType /*enmDeviceType*/)
    3475{
     76    prepare();
     77    /* Create widgets: */
     78    // QVBoxLayout *pMainLayout = new QVBoxLayout(this);
     79    // {
     80    //     m_pDescriptionLabel = new QIRichTextLabel(this);
     81    //     m_pDynamicLabel = new QIRichTextLabel(this);
     82    //     m_pFixedLabel = new QIRichTextLabel(this);
     83    //     m_pSplitLabel = new QIRichTextLabel(this);
     84    //     QVBoxLayout *pVariantLayout = new QVBoxLayout;
     85    //     {
     86    //         m_pVariantButtonGroup = new QButtonGroup(this);
     87    //         {
     88    //             m_pDynamicalButton = new QRadioButton(this);
     89    //             if (enmDeviceType == KDeviceType_HardDisk)
     90    //             {
     91    //                 m_pDynamicalButton->click();
     92    //                 m_pDynamicalButton->setFocus();
     93    //             }
     94    //             m_pFixedButton = new QRadioButton(this);
     95    //             if (   enmDeviceType == KDeviceType_DVD
     96    //                 || enmDeviceType == KDeviceType_Floppy)
     97    //             {
     98    //                 m_pFixedButton->click();
     99    //                 m_pFixedButton->setFocus();
     100    //             }
     101    //             m_pVariantButtonGroup->addButton(m_pDynamicalButton, 0);
     102    //             m_pVariantButtonGroup->addButton(m_pFixedButton, 1);
     103    //         }
     104    //         m_pSplitBox = new QCheckBox(this);
     105    //         pVariantLayout->addWidget(m_pDynamicalButton);
     106    //         pVariantLayout->addWidget(m_pFixedButton);
     107    //         pVariantLayout->addWidget(m_pSplitBox);
     108    //     }
     109    //     pMainLayout->addWidget(m_pDescriptionLabel);
     110    //     pMainLayout->addWidget(m_pDynamicLabel);
     111    //     pMainLayout->addWidget(m_pFixedLabel);
     112    //     pMainLayout->addWidget(m_pSplitLabel);
     113    //     pMainLayout->addLayout(pVariantLayout);
     114    //     pMainLayout->addStretch();
     115    // }
     116
     117    // /* Setup connections: */
     118    // connect(m_pVariantButtonGroup, static_cast<void(QButtonGroup::*)(QAbstractButton*)>(&QButtonGroup::buttonClicked),
     119    //         this, &UIWizardCloneVDPageBasic2::completeChanged);
     120    // connect(m_pSplitBox, &QCheckBox::stateChanged,
     121    //         this, &UIWizardCloneVDPageBasic2::completeChanged);
    35122}
    36123
    37 qulonglong UIWizardCloneVDPage2::mediumVariant() const
     124void UIWizardCloneVDPageBasic2::prepare()
    38125{
    39     /* Initial value: */
    40     qulonglong uMediumVariant = (qulonglong)KMediumVariant_Max;
    41 
    42     /* Exclusive options: */
    43     if (m_pDynamicalButton->isChecked())
    44         uMediumVariant = (qulonglong)KMediumVariant_Standard;
    45     else if (m_pFixedButton->isChecked())
    46         uMediumVariant = (qulonglong)KMediumVariant_Fixed;
    47 
    48     /* Additional options: */
    49     if (m_pSplitBox->isChecked())
    50         uMediumVariant |= (qulonglong)KMediumVariant_VmdkSplit2G;
    51 
    52     /* Return options: */
    53     return uMediumVariant;
     126    QVBoxLayout *pMainLayout = new QVBoxLayout(this);
     127    Q_UNUSED(pMainLayout);
    54128}
    55129
    56 void UIWizardCloneVDPage2::setMediumVariant(qulonglong uMediumVariant)
    57 {
    58     /* Exclusive options: */
    59     if (uMediumVariant & (qulonglong)KMediumVariant_Fixed)
    60     {
    61         m_pFixedButton->click();
    62         m_pFixedButton->setFocus();
    63     }
    64     else
    65     {
    66         m_pDynamicalButton->click();
    67         m_pDynamicalButton->setFocus();
    68     }
    69 
    70     /* Additional options: */
    71     m_pSplitBox->setChecked(uMediumVariant & (qulonglong)KMediumVariant_VmdkSplit2G);
    72 }
    73 
    74 UIWizardCloneVDPageBasic2::UIWizardCloneVDPageBasic2(KDeviceType enmDeviceType)
    75 {
    76     /* Create widgets: */
    77     QVBoxLayout *pMainLayout = new QVBoxLayout(this);
    78     {
    79         m_pDescriptionLabel = new QIRichTextLabel(this);
    80         m_pDynamicLabel = new QIRichTextLabel(this);
    81         m_pFixedLabel = new QIRichTextLabel(this);
    82         m_pSplitLabel = new QIRichTextLabel(this);
    83         QVBoxLayout *pVariantLayout = new QVBoxLayout;
    84         {
    85             m_pVariantButtonGroup = new QButtonGroup(this);
    86             {
    87                 m_pDynamicalButton = new QRadioButton(this);
    88                 if (enmDeviceType == KDeviceType_HardDisk)
    89                 {
    90                     m_pDynamicalButton->click();
    91                     m_pDynamicalButton->setFocus();
    92                 }
    93                 m_pFixedButton = new QRadioButton(this);
    94                 if (   enmDeviceType == KDeviceType_DVD
    95                     || enmDeviceType == KDeviceType_Floppy)
    96                 {
    97                     m_pFixedButton->click();
    98                     m_pFixedButton->setFocus();
    99                 }
    100                 m_pVariantButtonGroup->addButton(m_pDynamicalButton, 0);
    101                 m_pVariantButtonGroup->addButton(m_pFixedButton, 1);
    102             }
    103             m_pSplitBox = new QCheckBox(this);
    104             pVariantLayout->addWidget(m_pDynamicalButton);
    105             pVariantLayout->addWidget(m_pFixedButton);
    106             pVariantLayout->addWidget(m_pSplitBox);
    107         }
    108         pMainLayout->addWidget(m_pDescriptionLabel);
    109         pMainLayout->addWidget(m_pDynamicLabel);
    110         pMainLayout->addWidget(m_pFixedLabel);
    111         pMainLayout->addWidget(m_pSplitLabel);
    112         pMainLayout->addLayout(pVariantLayout);
    113         pMainLayout->addStretch();
    114     }
    115 
    116     /* Setup connections: */
    117     connect(m_pVariantButtonGroup, static_cast<void(QButtonGroup::*)(QAbstractButton*)>(&QButtonGroup::buttonClicked),
    118             this, &UIWizardCloneVDPageBasic2::completeChanged);
    119     connect(m_pSplitBox, &QCheckBox::stateChanged,
    120             this, &UIWizardCloneVDPageBasic2::completeChanged);
    121 
    122     /* Register fields: */
    123     registerField("mediumVariant", this, "mediumVariant");
    124 }
    125130
    126131void UIWizardCloneVDPageBasic2::retranslateUi()
    … …  
    129134    setTitle(UIWizardCloneVD::tr("Storage on physical hard disk"));
    130135
    131     /* Translate widgets: */
    132     m_pDescriptionLabel->setText(UIWizardCloneVD::tr("Please choose whether the new virtual disk image file should grow as it is used "
    133                                                      "(dynamically allocated) or if it should be created at its maximum size (fixed size)."));
    134     m_pDynamicLabel->setText(UIWizardCloneVD::tr("<p>A <b>dynamically allocated</b> disk image file will only use space "
    135                                                  "on your physical hard disk as it fills up (up to a maximum <b>fixed size</b>), "
    136                                                  "although it will not shrink again automatically when space on it is freed.</p>"));
    137     m_pFixedLabel->setText(UIWizardCloneVD::tr("<p>A <b>fixed size</b> disk image file may take longer to create on some "
    138                                                "systems but is often faster to use.</p>"));
    139     m_pSplitLabel->setText(UIWizardCloneVD::tr("<p>You can also choose to <b>split</b> the disk image file into several files "
    140                                                "of up to two gigabytes each. This is mainly useful if you wish to store the "
    141                                                "virtual machine on removable USB devices or old systems, some of which cannot "
    142                                                "handle very large files."));
    143     m_pDynamicalButton->setText(UIWizardCloneVD::tr("&Dynamically allocated"));
    144     m_pFixedButton->setText(UIWizardCloneVD::tr("&Fixed size"));
    145     m_pSplitBox->setText(UIWizardCloneVD::tr("&Split into files of less than 2GB"));
     136//     /* Translate widgets: */
     137//     m_pDescriptionLabel->setText(UIWizardCloneVD::tr("Please choose whether the new virtual disk image file should grow as it is used "
     138//                                                      "(dynamically allocated) or if it should be created at its maximum size (fixed size)."));
     139//     m_pDynamicLabel->setText(UIWizardCloneVD::tr("<p>A <b>dynamically allocated</b> disk image file will only use space "
     140//                                                  "on your physical hard disk as it fills up (up to a maximum <b>fixed size</b>), "
     141//                                                  "although it will not shrink again automatically when space on it is freed.</p>"));
     142//     m_pFixedLabel->setText(UIWizardCloneVD::tr("<p>A <b>fixed size</b> disk image file may take longer to create on some "
     143//                                                "systems but is often faster to use.</p>"));
     144//     m_pSplitLabel->setText(UIWizardCloneVD::tr("<p>You can also choose to <b>split</b> the disk image file into several files "
     145//                                                "of up to two gigabytes each. This is mainly useful if you wish to store the "
     146//                                                "virtual machine on removable USB devices or old systems, some of which cannot "
     147//                                                "handle very large files."));
     148//     m_pDynamicalButton->setText(UIWizardCloneVD::tr("&Dynamically allocated"));
     149//     m_pFixedButton->setText(UIWizardCloneVD::tr("&Fixed size"));
     150//     m_pSplitBox->setText(UIWizardCloneVD::tr("&Split into files of less than 2GB"));
    146151}
    147152
    … …  
    151156    retranslateUi();
    152157
    153     /* Setup visibility: */
    154     CMediumFormat mediumFormat = field("mediumFormat").value<CMediumFormat>();
    155     ULONG uCapabilities = 0;
    156     QVector<KMediumFormatCapabilities> capabilities;
    157     capabilities = mediumFormat.GetCapabilities();
    158     for (int i = 0; i < capabilities.size(); i++)
    159         uCapabilities |= capabilities[i];
     158    // /* Setup visibility: */
     159    // CMediumFormat mediumFormat = field("mediumFormat").value<CMediumFormat>();
     160    // ULONG uCapabilities = 0;
     161    // QVector<KMediumFormatCapabilities> capabilities;
     162    // capabilities = mediumFormat.GetCapabilities();
     163    // for (int i = 0; i < capabilities.size(); i++)
     164    //     uCapabilities |= capabilities[i];
    160165
    161     bool fIsCreateDynamicPossible = uCapabilities & KMediumFormatCapabilities_CreateDynamic;
    162     bool fIsCreateFixedPossible = uCapabilities & KMediumFormatCapabilities_CreateFixed;
    163     bool fIsCreateSplitPossible = uCapabilities & KMediumFormatCapabilities_CreateSplit2G;
    164     m_pDynamicLabel->setHidden(!fIsCreateDynamicPossible);
    165     m_pDynamicalButton->setHidden(!fIsCreateDynamicPossible);
    166     m_pFixedLabel->setHidden(!fIsCreateFixedPossible);
    167     m_pFixedButton->setHidden(!fIsCreateFixedPossible);
    168     m_pSplitLabel->setHidden(!fIsCreateSplitPossible);
    169     m_pSplitBox->setHidden(!fIsCreateSplitPossible);
     166    // bool fIsCreateDynamicPossible = uCapabilities & KMediumFormatCapabilities_CreateDynamic;
     167    // bool fIsCreateFixedPossible = uCapabilities & KMediumFormatCapabilities_CreateFixed;
     168    // bool fIsCreateSplitPossible = uCapabilities & KMediumFormatCapabilities_CreateSplit2G;
     169    // m_pDynamicLabel->setHidden(!fIsCreateDynamicPossible);
     170    // m_pDynamicalButton->setHidden(!fIsCreateDynamicPossible);
     171    // m_pFixedLabel->setHidden(!fIsCreateFixedPossible);
     172    // m_pFixedButton->setHidden(!fIsCreateFixedPossible);
     173    // m_pSplitLabel->setHidden(!fIsCreateSplitPossible);
     174    // m_pSplitBox->setHidden(!fIsCreateSplitPossible);
    170175}
    171176
    172177bool UIWizardCloneVDPageBasic2::isComplete() const
    173178{
    174     /* Make sure medium variant is correct: */
    175     return mediumVariant() != (qulonglong)KMediumVariant_Max;
     179    return true;
     180    // /* Make sure medium variant is correct: */
     181    // return mediumVariant() != (qulonglong)KMediumVariant_Max;
    176182}

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/clonevd/UIWizardCloneVDPageBasic2.h

    r82968 r90748  
    2323
    2424/* GUI includes: */
    25 #include "UIWizardPage.h"
     25#include "UINativeWizardPage.h"
    2626
    2727/* COM includes: */
    … …  
    3535
    3636
    37 /** 3rd page of the Clone Virtual Disk Image wizard (base part): */
    38 class UIWizardCloneVDPage2 : public UIWizardPageBase
    39 {
    40 protected:
     37// /** 3rd page of the Clone Virtual Disk Image wizard (base part): */
     38// class UIWizardCloneVDPage2 : public UIWizardPageBase
     39// {
     40// protected:
    4141
    42     /** Constructs page basis. */
    43     UIWizardCloneVDPage2();
     42//     /** Constructs page basis. */
     43//     UIWizardCloneVDPage2();
    4444
    45     /** Returns 'mediumVariant' field value. */
    46     qulonglong mediumVariant() const;
    47     /** Defines 'mediumVariant' field value. */
    48     void setMediumVariant(qulonglong uMediumVariant);
     45//     /** Returns 'mediumVariant' field value. */
     46//     qulonglong mediumVariant() const;
     47//     /** Defines 'mediumVariant' field value. */
     48//     void setMediumVariant(qulonglong uMediumVariant);
    4949
    50     /** Holds the variant button-group instance. */
    51     QButtonGroup *m_pVariantButtonGroup;
    52     /** Holds the 'Dynamical' button instance. */
    53     QRadioButton *m_pDynamicalButton;
    54     /** Holds the 'Fixed' button instance. */
    55     QRadioButton *m_pFixedButton;
    56     /** Holds the 'Split to 2GB files' check-box instance. */
    57     QCheckBox    *m_pSplitBox;
    58 };
     50//     /** Holds the variant button-group instance. */
     51//     QButtonGroup *m_pVariantButtonGroup;
     52//     /** Holds the 'Dynamical' button instance. */
     53//     QRadioButton *m_pDynamicalButton;
     54//     /** Holds the 'Fixed' button instance. */
     55//     QRadioButton *m_pFixedButton;
     56//     /** Holds the 'Split to 2GB files' check-box instance. */
     57//     QCheckBox    *m_pSplitBox;
     58// };
    5959
    6060
    61 /** 3rd page of the Clone Virtual Disk Image wizard (basic extension): */
    62 class UIWizardCloneVDPageBasic2 : public UIWizardPage, public UIWizardCloneVDPage2
     61class UIWizardCloneVDPageBasic2 : public UINativeWizardPage
    6362{
    6463    Q_OBJECT;
    65     Q_PROPERTY(qulonglong mediumVariant READ mediumVariant WRITE setMediumVariant);
    6664
    6765public:
    … …  
    7472    /** Handles translation event. */
    7573    virtual void retranslateUi() /* override */;
     74    void prepare();
    7675
    7776    /** Prepares the page. */

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/clonevd/UIWizardCloneVDPageBasic3.cpp

    r82968 r90748  
    3636
    3737
    38 UIWizardCloneVDPage3::UIWizardCloneVDPage3()
    39 {
    40 }
    41 
    42 void UIWizardCloneVDPage3::onSelectLocationButtonClicked()
    43 {
    44     /* Get current folder and filename: */
    45     QFileInfo fullFilePath(mediumPath());
    46     QDir folder = fullFilePath.path();
    47     QString strFileName = fullFilePath.fileName();
    48 
    49     /* Set the first parent folder that exists as the current: */
    50     while (!folder.exists() && !folder.isRoot())
    51     {
    52         QFileInfo folderInfo(folder.absolutePath());
    53         if (folder == QDir(folderInfo.absolutePath()))
    54             break;
    55         folder = folderInfo.absolutePath();
    56     }
    57 
    58     /* But if it doesn't exists at all: */
    59     if (!folder.exists() || folder.isRoot())
    60     {
    61         /* Use recommended one folder: */
    62         QFileInfo defaultFilePath(absoluteFilePath(strFileName, m_strDefaultPath));
    63         folder = defaultFilePath.path();
    64     }
    65 
    66     /* Prepare backends list: */
    67     QVector<QString> fileExtensions;
    68     QVector<KDeviceType> deviceTypes;
    69     CMediumFormat mediumFormat = fieldImp("mediumFormat").value<CMediumFormat>();
    70     mediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
    71     QStringList validExtensionList;
    72     for (int i = 0; i < fileExtensions.size(); ++i)
    73         if (deviceTypes[i] == static_cast<UIWizardCloneVD*>(wizardImp())->sourceVirtualDiskDeviceType())
    74             validExtensionList << QString("*.%1").arg(fileExtensions[i]);
    75     /* Compose full filter list: */
    76     QString strBackendsList = QString("%1 (%2)").arg(mediumFormat.GetName()).arg(validExtensionList.join(" "));
    77 
    78     /* Open corresponding file-dialog: */
    79     QString strChosenFilePath = QIFileDialog::getSaveFileName(folder.absoluteFilePath(strFileName),
    80                                                               strBackendsList, thisImp(),
    81                                                               UIWizardCloneVD::tr("Please choose a location for new virtual disk image file"));
    82 
    83     /* If there was something really chosen: */
    84     if (!strChosenFilePath.isEmpty())
    85     {
    86         /* If valid file extension is missed, append it: */
    87         if (QFileInfo(strChosenFilePath).suffix().isEmpty())
    88             strChosenFilePath += QString(".%1").arg(m_strDefaultExtension);
    89         m_pDestinationDiskEditor->setText(QDir::toNativeSeparators(strChosenFilePath));
    90         m_pDestinationDiskEditor->selectAll();
    91         m_pDestinationDiskEditor->setFocus();
    92     }
    93 }
    94 
    95 /* static */
    96 QString UIWizardCloneVDPage3::toFileName(const QString &strName, const QString &strExtension)
    97 {
    98     /* Convert passed name to native separators (it can be full, actually): */
    99     QString strFileName = QDir::toNativeSeparators(strName);
    100 
    101     /* Remove all trailing dots to avoid multiple dots before extension: */
    102     int iLen;
    103     while (iLen = strFileName.length(), iLen > 0 && strFileName[iLen - 1] == '.')
    104         strFileName.truncate(iLen - 1);
    105 
    106     /* Add passed extension if its not done yet: */
    107     if (QFileInfo(strFileName).suffix().toLower() != strExtension)
    108         strFileName += QString(".%1").arg(strExtension);
    109 
    110     /* Return result: */
    111     return strFileName;
    112 }
    113 
    114 /* static */
    115 QString UIWizardCloneVDPage3::absoluteFilePath(const QString &strFileName, const QString &strDefaultPath)
    116 {
    117     /* Wrap file-info around received file name: */
    118     QFileInfo fileInfo(strFileName);
    119     /* If path-info is relative or there is no path-info at all: */
    120     if (fileInfo.fileName() == strFileName || fileInfo.isRelative())
    121     {
    122         /* Resolve path on the basis of default path we have: */
    123         fileInfo = QFileInfo(strDefaultPath, strFileName);
    124     }
    125     /* Return full absolute disk image file path: */
    126     return QDir::toNativeSeparators(fileInfo.absoluteFilePath());
    127 }
    128 
    129 /* static */
    130 void UIWizardCloneVDPage3::acquireExtensions(const CMediumFormat &comMediumFormat, KDeviceType enmDeviceType,
    131                                              QStringList &aAllowedExtensions, QString &strDefaultExtension)
    132 {
    133     /* Load extension / device list: */
    134     QVector<QString> fileExtensions;
    135     QVector<KDeviceType> deviceTypes;
    136     CMediumFormat mediumFormat(comMediumFormat);
    137     mediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
    138     for (int i = 0; i < fileExtensions.size(); ++i)
    139         if (deviceTypes[i] == enmDeviceType)
    140             aAllowedExtensions << fileExtensions[i].toLower();
    141     AssertReturnVoid(!aAllowedExtensions.isEmpty());
    142     strDefaultExtension = aAllowedExtensions.first();
    143 }
    144 
    145 QString UIWizardCloneVDPage3::mediumPath() const
    146 {
    147     /* Acquire chosen file path, and what is important user suffix: */
    148     const QString strChosenFilePath = m_pDestinationDiskEditor->text();
    149     QString strSuffix = QFileInfo(strChosenFilePath).suffix().toLower();
    150     /* If there is no suffix of it's not allowed: */
    151     if (   strSuffix.isEmpty()
    152         || !m_aAllowedExtensions.contains(strSuffix))
    153         strSuffix = m_strDefaultExtension;
    154     /* Compose full file path finally: */
    155     return absoluteFilePath(toFileName(m_pDestinationDiskEditor->text(), strSuffix), m_strDefaultPath);
    156 }
    157 
    158 qulonglong UIWizardCloneVDPage3::mediumSize()
    159 {
    160     UIWizardCloneVD *pWizard = qobject_cast<UIWizardCloneVD*>(wizardImp());
    161     if (!pWizard)
    162         return 0;
    163     const CMedium &sourceVirtualDisk = pWizard->sourceVirtualDisk();
    164     return sourceVirtualDisk.isNull() ? 0 : sourceVirtualDisk.GetLogicalSize();
    165 }
     38// UIWizardCloneVDPage3::UIWizardCloneVDPage3()
     39// {
     40// }
     41
     42// void UIWizardCloneVDPage3::onSelectLocationButtonClicked()
     43// {
     44//     // /* Get current folder and filename: */
     45//     // QFileInfo fullFilePath(mediumPath());
     46//     // QDir folder = fullFilePath.path();
     47//     // QString strFileName = fullFilePath.fileName();
     48
     49//     // /* Set the first parent folder that exists as the current: */
     50//     // while (!folder.exists() && !folder.isRoot())
     51//     // {
     52//     //     QFileInfo folderInfo(folder.absolutePath());
     53//     //     if (folder == QDir(folderInfo.absolutePath()))
     54//     //         break;
     55//     //     folder = folderInfo.absolutePath();
     56//     // }
     57
     58//     // /* But if it doesn't exists at all: */
     59//     // if (!folder.exists() || folder.isRoot())
     60//     // {
     61//     //     /* Use recommended one folder: */
     62//     //     QFileInfo defaultFilePath(absoluteFilePath(strFileName, m_strDefaultPath));
     63//     //     folder = defaultFilePath.path();
     64//     // }
     65
     66//     // /* Prepare backends list: */
     67//     // QVector<QString> fileExtensions;
     68//     // QVector<KDeviceType> deviceTypes;
     69//     // CMediumFormat mediumFormat = fieldImp("mediumFormat").value<CMediumFormat>();
     70//     // mediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
     71//     // QStringList validExtensionList;
     72//     // for (int i = 0; i < fileExtensions.size(); ++i)
     73//     //     if (deviceTypes[i] == static_cast<UIWizardCloneVD*>(wizardImp())->sourceVirtualDiskDeviceType())
     74//     //         validExtensionList << QString("*.%1").arg(fileExtensions[i]);
     75//     // /* Compose full filter list: */
     76//     // QString strBackendsList = QString("%1 (%2)").arg(mediumFormat.GetName()).arg(validExtensionList.join(" "));
     77
     78//     // /* Open corresponding file-dialog: */
     79//     // QString strChosenFilePath = QIFileDialog::getSaveFileName(folder.absoluteFilePath(strFileName),
     80//     //                                                           strBackendsList, thisImp(),
     81//     //                                                           UIWizardCloneVD::tr("Please choose a location for new virtual disk image file"));
     82
     83//     // /* If there was something really chosen: */
     84//     // if (!strChosenFilePath.isEmpty())
     85//     // {
     86//     //     /* If valid file extension is missed, append it: */
     87//     //     if (QFileInfo(strChosenFilePath).suffix().isEmpty())
     88//     //         strChosenFilePath += QString(".%1").arg(m_strDefaultExtension);
     89//     //     m_pDestinationDiskEditor->setText(QDir::toNativeSeparators(strChosenFilePath));
     90//     //     m_pDestinationDiskEditor->selectAll();
     91//     //     m_pDestinationDiskEditor->setFocus();
     92//     // }
     93// }
     94
     95// /* static */
     96// QString UIWizardCloneVDPage3::toFileName(const QString &strName, const QString &strExtension)
     97// {
     98//     /* Convert passed name to native separators (it can be full, actually): */
     99//     QString strFileName = QDir::toNativeSeparators(strName);
     100
     101//     /* Remove all trailing dots to avoid multiple dots before extension: */
     102//     int iLen;
     103//     while (iLen = strFileName.length(), iLen > 0 && strFileName[iLen - 1] == '.')
     104//         strFileName.truncate(iLen - 1);
     105
     106//     /* Add passed extension if its not done yet: */
     107//     if (QFileInfo(strFileName).suffix().toLower() != strExtension)
     108//         strFileName += QString(".%1").arg(strExtension);
     109
     110//     /* Return result: */
     111//     return strFileName;
     112// }
     113
     114// /* static */
     115// QString UIWizardCloneVDPage3::absoluteFilePath(const QString &strFileName, const QString &strDefaultPath)
     116// {
     117//     /* Wrap file-info around received file name: */
     118//     QFileInfo fileInfo(strFileName);
     119//     /* If path-info is relative or there is no path-info at all: */
     120//     if (fileInfo.fileName() == strFileName || fileInfo.isRelative())
     121//     {
     122//         /* Resolve path on the basis of default path we have: */
     123//         fileInfo = QFileInfo(strDefaultPath, strFileName);
     124//     }
     125//     /* Return full absolute disk image file path: */
     126//     return QDir::toNativeSeparators(fileInfo.absoluteFilePath());
     127// }
     128
     129// /* static */
     130// void UIWizardCloneVDPage3::acquireExtensions(const CMediumFormat &comMediumFormat, KDeviceType enmDeviceType,
     131//                                              QStringList &aAllowedExtensions, QString &strDefaultExtension)
     132// {
     133//     /* Load extension / device list: */
     134//     QVector<QString> fileExtensions;
     135//     QVector<KDeviceType> deviceTypes;
     136//     CMediumFormat mediumFormat(comMediumFormat);
     137//     mediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
     138//     for (int i = 0; i < fileExtensions.size(); ++i)
     139//         if (deviceTypes[i] == enmDeviceType)
     140//             aAllowedExtensions << fileExtensions[i].toLower();
     141//     AssertReturnVoid(!aAllowedExtensions.isEmpty());
     142//     strDefaultExtension = aAllowedExtensions.first();
     143// }
     144
     145// QString UIWizardCloneVDPage3::mediumPath() const
     146// {
     147//     /* Acquire chosen file path, and what is important user suffix: */
     148//     const QString strChosenFilePath = m_pDestinationDiskEditor->text();
     149//     QString strSuffix = QFileInfo(strChosenFilePath).suffix().toLower();
     150//     /* If there is no suffix of it's not allowed: */
     151//     if (   strSuffix.isEmpty()
     152//         || !m_aAllowedExtensions.contains(strSuffix))
     153//         strSuffix = m_strDefaultExtension;
     154//     /* Compose full file path finally: */
     155//     return absoluteFilePath(toFileName(m_pDestinationDiskEditor->text(), strSuffix), m_strDefaultPath);
     156// }
     157
     158// qulonglong UIWizardCloneVDPage3::mediumSize()
     159// {
     160//     // UIWizardCloneVD *pWizard = qobject_cast<UIWizardCloneVD*>(wizardImp());
     161//     // if (!pWizard)
     162//     //     return 0;
     163//     // const CMedium &sourceVirtualDisk = pWizard->sourceVirtualDisk();
     164//     // return sourceVirtualDisk.isNull() ? 0 : sourceVirtualDisk.GetLogicalSize();
     165//     return 0;
     166// }
    166167
    167168UIWizardCloneVDPageBasic3::UIWizardCloneVDPageBasic3()
    168169{
    169     /* Create widgets: */
     170    prepare();
     171    // /* Create widgets: */
     172    // QVBoxLayout *pMainLayout = new QVBoxLayout(this);
     173    // {
     174    //     m_pLabel = new QIRichTextLabel(this);
     175    //     QHBoxLayout *pLocationLayout = new QHBoxLayout;
     176    //     {
     177    //         m_pDestinationDiskEditor = new QLineEdit(this);
     178    //         m_pDestinationDiskOpenButton = new QIToolButton(this);
     179    //         {
     180    //             m_pDestinationDiskOpenButton->setAutoRaise(true);
     181    //             m_pDestinationDiskOpenButton->setIcon(UIIconPool::iconSet(":/select_file_16px.png", "select_file_disabled_16px.png"));
     182    //         }
     183    //         pLocationLayout->addWidget(m_pDestinationDiskEditor);
     184    //         pLocationLayout->addWidget(m_pDestinationDiskOpenButton);
     185    //     }
     186    //     pMainLayout->addWidget(m_pLabel);
     187    //     pMainLayout->addLayout(pLocationLayout);
     188    //     pMainLayout->addStretch();
     189    // }
     190
     191    // /* Setup page connections: */
     192    // connect(m_pDestinationDiskEditor, &QLineEdit::textChanged,    this, &UIWizardCloneVDPageBasic3::completeChanged);
     193    // connect(m_pDestinationDiskOpenButton, &QIToolButton::clicked, this, &UIWizardCloneVDPageBasic3::sltSelectLocationButtonClicked);
     194}
     195
     196void UIWizardCloneVDPageBasic3::prepare()
     197{
    170198    QVBoxLayout *pMainLayout = new QVBoxLayout(this);
    171     {
    172         m_pLabel = new QIRichTextLabel(this);
    173         QHBoxLayout *pLocationLayout = new QHBoxLayout;
    174         {
    175             m_pDestinationDiskEditor = new QLineEdit(this);
    176             m_pDestinationDiskOpenButton = new QIToolButton(this);
    177             {
    178                 m_pDestinationDiskOpenButton->setAutoRaise(true);
    179                 m_pDestinationDiskOpenButton->setIcon(UIIconPool::iconSet(":/select_file_16px.png", "select_file_disabled_16px.png"));
    180             }
    181             pLocationLayout->addWidget(m_pDestinationDiskEditor);
    182             pLocationLayout->addWidget(m_pDestinationDiskOpenButton);
    183         }
    184         pMainLayout->addWidget(m_pLabel);
    185         pMainLayout->addLayout(pLocationLayout);
    186         pMainLayout->addStretch();
    187     }
    188 
    189     /* Setup page connections: */
    190     connect(m_pDestinationDiskEditor, &QLineEdit::textChanged,    this, &UIWizardCloneVDPageBasic3::completeChanged);
    191     connect(m_pDestinationDiskOpenButton, &QIToolButton::clicked, this, &UIWizardCloneVDPageBasic3::sltSelectLocationButtonClicked);
    192 
    193     /* Register fields: */
    194     registerField("mediumPath", this, "mediumPath");
    195     registerField("mediumSize", this, "mediumSize");
     199    Q_UNUSED(pMainLayout);
    196200}
    197201
    … …  
    199203{
    200204    /* Call to base-class: */
    201     onSelectLocationButtonClicked();
     205    //onSelectLocationButtonClicked();
    202206}
    203207
    … …  
    207211    setTitle(UIWizardCloneVD::tr("New disk image to create"));
    208212
    209     /* Translate widgets: */
    210     m_pLabel->setText(UIWizardCloneVD::tr("Please type the name of the new virtual disk image file into the box below or "
    211                                           "click on the folder icon to select a different folder to create the file in."));
    212     m_pDestinationDiskOpenButton->setToolTip(UIWizardCloneVD::tr("Choose a location for new virtual disk image file..."));
     213    // /* Translate widgets: */
     214    // m_pLabel->setText(UIWizardCloneVD::tr("Please type the name of the new virtual disk image file into the box below or "
     215    //                                       "click on the folder icon to select a different folder to create the file in."));
     216    // m_pDestinationDiskOpenButton->setToolTip(UIWizardCloneVD::tr("Choose a location for new virtual disk image file..."));
    213217}
    214218
    215219void UIWizardCloneVDPageBasic3::initializePage()
    216220{
    217     /* Translate page: */
    218     retranslateUi();
    219 
    220     UIWizardCloneVD *pWizard = qobject_cast<UIWizardCloneVD*>(wizardImp());
    221     if (!pWizard)
    222         return;
    223     const CMedium &comMedium = pWizard->sourceVirtualDisk();
    224 
    225     /* Get source virtual-disk file-information: */
    226     QFileInfo sourceFileInfo(comMedium.GetLocation());
    227     /* Get default path for virtual-disk copy: */
    228     m_strDefaultPath = sourceFileInfo.absolutePath();
    229     /* Get default extension for virtual-disk copy: */
    230     acquireExtensions(field("mediumFormat").value<CMediumFormat>(),
    231                       static_cast<UIWizardCloneVD*>(wizardImp())->sourceVirtualDiskDeviceType(),
    232                       m_aAllowedExtensions, m_strDefaultExtension);
    233     /* Compose default-name for virtual-disk copy: */
    234     QString strMediumName = UIWizardCloneVD::tr("%1_copy", "copied virtual disk image name").arg(sourceFileInfo.completeBaseName());
    235     /* Set default-name as text for location editor: */
    236     m_pDestinationDiskEditor->setText(strMediumName);
     221    // /* Translate page: */
     222    // retranslateUi();
     223
     224    // UIWizardCloneVD *pWizard = qobject_cast<UIWizardCloneVD*>(wizardImp());
     225    // if (!pWizard)
     226    //     return;
     227    // const CMedium &comMedium = pWizard->sourceVirtualDisk();
     228
     229    // /* Get source virtual-disk file-information: */
     230    // QFileInfo sourceFileInfo(comMedium.GetLocation());
     231    // /* Get default path for virtual-disk copy: */
     232    // m_strDefaultPath = sourceFileInfo.absolutePath();
     233    // /* Get default extension for virtual-disk copy: */
     234    // acquireExtensions(field("mediumFormat").value<CMediumFormat>(),
     235    //                   static_cast<UIWizardCloneVD*>(wizardImp())->sourceVirtualDiskDeviceType(),
     236    //                   m_aAllowedExtensions, m_strDefaultExtension);
     237    // /* Compose default-name for virtual-disk copy: */
     238    // QString strMediumName = UIWizardCloneVD::tr("%1_copy", "copied virtual disk image name").arg(sourceFileInfo.completeBaseName());
     239    // /* Set default-name as text for location editor: */
     240    // m_pDestinationDiskEditor->setText(strMediumName);
    237241}
    238242
    … …  
    240244{
    241245    /* Make sure current name is not empty: */
    242     return !m_pDestinationDiskEditor->text().trimmed().isEmpty();
     246    /*return !m_pDestinationDiskEditor->text().trimmed().isEmpty();*/
     247    return true;
    243248}
    244249
    … …  
    248253    bool fResult = true;
    249254
    250     /* Make sure such file doesn't exists already: */
    251     QString strMediumPath(mediumPath());
    252     fResult = !QFileInfo(strMediumPath).exists();
    253     if (!fResult)
    254         msgCenter().cannotOverwriteHardDiskStorage(strMediumPath, this);
    255 
    256     if (fResult)
    257     {
    258         /* Lock finish button: */
    259         startProcessing();
    260 
    261         /* Try to copy virtual disk image file: */
    262         fResult = qobject_cast<UIWizardCloneVD*>(wizard())->copyVirtualDisk();
    263 
    264         /* Unlock finish button: */
    265         endProcessing();
    266     }
     255    // /* Make sure such file doesn't exists already: */
     256    // QString strMediumPath(mediumPath());
     257    // fResult = !QFileInfo(strMediumPath).exists();
     258    // if (!fResult)
     259    //     msgCenter().cannotOverwriteHardDiskStorage(strMediumPath, this);
     260
     261    // if (fResult)
     262    // {
     263    //     /* Lock finish button: */
     264    //     startProcessing();
     265
     266    //     /* Try to copy virtual disk image file: */
     267    //     fResult = qobject_cast<UIWizardCloneVD*>(wizard())->copyVirtualDisk();
     268
     269    //     /* Unlock finish button: */
     270    //     endProcessing();
     271    // }
    267272
    268273    /* Return result: */

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/clonevd/UIWizardCloneVDPageBasic3.h

    r82968 r90748  
    2626
    2727/* GUI includes: */
    28 #include "UIWizardPage.h"
     28#include "UINativeWizardPage.h"
    2929
    3030/* COM includes: */
    … …  
    3838
    3939
    40 /** 4th page of the Clone Virtual Disk Image wizard (base part): */
    41 class UIWizardCloneVDPage3 : public UIWizardPageBase
    42 {
    43 protected:
     40// /** 4th page of the Clone Virtual Disk Image wizard (base part): */
     41// class UIWizardCloneVDPage3 : public UIWizardPageBase
     42// {
     43// protected:
    4444
    45     /** Constructs page basis. */
    46     UIWizardCloneVDPage3();
     45//     /** Constructs page basis. */
     46//     UIWizardCloneVDPage3();
    4747
    48     /** Handles command to open target disk. */
    49     void onSelectLocationButtonClicked();
     48//     /** Handles command to open target disk. */
     49//     void onSelectLocationButtonClicked();
    5050
    51     /** Helps to compose full file name on the basis of incoming @a strName and @a strExtension. */
    52     static QString toFileName(const QString &strName, const QString &strExtension);
    53     /** Converts the @a strFileName to absolute one if necessary using @a strDefaultPath as advice. */
    54     static QString absoluteFilePath(const QString &strFileName, const QString &strDefaultPath);
    55     /** Acquires the list of @a aAllowedExtensions and @a strDefaultExtension
    56       * on the basis of incoming @a comMediumFormat and @a enmDeviceType. */
    57     static void acquireExtensions(const CMediumFormat &comMediumFormat, KDeviceType enmDeviceType,
    58                                   QStringList &aAllowedExtensions, QString &strDefaultExtension);
     51//     /** Helps to compose full file name on the basis of incoming @a strName and @a strExtension. */
     52//     static QString toFileName(const QString &strName, const QString &strExtension);
     53//     /** Converts the @a strFileName to absolute one if necessary using @a strDefaultPath as advice. */
     54//     static QString absoluteFilePath(const QString &strFileName, const QString &strDefaultPath);
     55//     /** Acquires the list of @a aAllowedExtensions and @a strDefaultExtension
     56//       * on the basis of incoming @a comMediumFormat and @a enmDeviceType. */
     57//     static void acquireExtensions(const CMediumFormat &comMediumFormat, KDeviceType enmDeviceType,
     58//                                   QStringList &aAllowedExtensions, QString &strDefaultExtension);
    5959
    60     /** Returns 'mediumPath' field value. */
    61     QString mediumPath() const;
     60//     /** Returns 'mediumPath' field value. */
     61//     QString mediumPath() const;
    6262
    63     /** Returns 'mediumSize' field value. */
    64     qulonglong mediumSize();
     63//     /** Returns 'mediumSize' field value. */
     64//     qulonglong mediumSize();
    6565
    66     /** Holds the default path. */
    67     QString      m_strDefaultPath;
    68     /** Holds the default extension. */
    69     QString      m_strDefaultExtension;
    70     /** Holds the allowed extensions. */
    71     QStringList  m_aAllowedExtensions;
     66//     /** Holds the default path. */
     67//     QString      m_strDefaultPath;
     68//     /** Holds the default extension. */
     69//     QString      m_strDefaultExtension;
     70//     /** Holds the allowed extensions. */
     71//     QStringList  m_aAllowedExtensions;
    7272
    73     /** Holds the target disk path editor instance. */
    74     QLineEdit    *m_pDestinationDiskEditor;
    75     /** Holds the open-target-disk button instance. */
    76     QIToolButton *m_pDestinationDiskOpenButton;
    77 };
     73//     /** Holds the target disk path editor instance. */
     74//     QLineEdit    *m_pDestinationDiskEditor;
     75//     /** Holds the open-target-disk button instance. */
     76//     QIToolButton *m_pDestinationDiskOpenButton;
     77// };
    7878
    7979
    80 /** 4th page of the Clone Virtual Disk Image wizard (basic extension): */
    81 class UIWizardCloneVDPageBasic3 : public UIWizardPage, public UIWizardCloneVDPage3
     80// /** 4th page of the Clone Virtual Disk Image wizard (basic extension): */
     81class UIWizardCloneVDPageBasic3 : public UINativeWizardPage
    8282{
    8383    Q_OBJECT;
    84     Q_PROPERTY(QString mediumPath READ mediumPath);
    85     Q_PROPERTY(qulonglong mediumSize READ mediumSize);
    8684
    8785public:
    … …  
    8987    /** Constructs basic page. */
    9088    UIWizardCloneVDPageBasic3();
    91 
    92 protected:
    93 
    94     /** Allows to access 'wizard()' from base part. */
    95     UIWizard *wizardImp() const { return wizard(); }
    96     /** Allows to access 'this' from base part. */
    97     UIWizardPage* thisImp() { return this; }
    98     /** Allows to access 'field()' from base part. */
    99     QVariant fieldImp(const QString &strFieldName) const { return UIWizardPage::field(strFieldName); }
    10089
    10190private slots:
    … …  
    10897    /** Handles translation event. */
    10998    virtual void retranslateUi() /* override */;
     99    void prepare();
    110100
    111101    /** Prepares the page. */

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/clonevd/UIWizardCloneVDPageExpert.cpp

    r82968 r90748  
    4040
    4141
    42 UIWizardCloneVDPageExpert::UIWizardCloneVDPageExpert(KDeviceType enmDeviceType)
    43 {
    44     /* Create widgets: */
    45     QGridLayout *pMainLayout = new QGridLayout(this);
    46     {
    47         m_pDestinationCnt = new QGroupBox(this);
    48         {
    49             m_pDestinationCnt->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
    50             QHBoxLayout *pLocationCntLayout = new QHBoxLayout(m_pDestinationCnt);
    51             {
    52                 m_pDestinationDiskEditor = new QLineEdit(m_pDestinationCnt);
    53                 m_pDestinationDiskOpenButton = new QIToolButton(m_pDestinationCnt);
    54                 {
    55                     m_pDestinationDiskOpenButton->setAutoRaise(true);
    56                     m_pDestinationDiskOpenButton->setIcon(UIIconPool::iconSet(":/select_file_16px.png", "select_file_disabled_16px.png"));
    57                 }
    58             }
    59             pLocationCntLayout->addWidget(m_pDestinationDiskEditor);
    60             pLocationCntLayout->addWidget(m_pDestinationDiskOpenButton);
    61         }
    62         m_pFormatCnt = new QGroupBox(this);
    63         {
    64             m_pFormatCnt->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
    65             QVBoxLayout *pFormatCntLayout = new QVBoxLayout(m_pFormatCnt);
    66             {
    67                 m_pFormatButtonGroup = new QButtonGroup(m_pFormatCnt);
    68                 {
    69                     /* Enumerate medium formats in special order: */
    70                     CSystemProperties properties = uiCommon().virtualBox().GetSystemProperties();
    71                     const QVector<CMediumFormat> &formats = properties.GetMediumFormats();
    72                     QMap<QString, CMediumFormat> vdi, preferred, others;
    73                     foreach (const CMediumFormat &format, formats)
    74                     {
    75                         /* VDI goes first: */
    76                         if (format.GetName() == "VDI")
    77                             vdi[format.GetId()] = format;
    78                         else
    79                         {
    80                             const QVector<KMediumFormatCapabilities> &capabilities = format.GetCapabilities();
    81                             /* Then goes preferred: */
    82                             if (capabilities.contains(KMediumFormatCapabilities_Preferred))
    83                                 preferred[format.GetId()] = format;
    84                             /* Then others: */
    85                             else
    86                                 others[format.GetId()] = format;
    87                         }
    88                     }
    89 
    90                     /* Create buttons for VDI, preferred and others: */
    91                     foreach (const QString &strId, vdi.keys())
    92                         addFormatButton(this, pFormatCntLayout, enmDeviceType, vdi.value(strId), true);
    93                     foreach (const QString &strId, preferred.keys())
    94                         addFormatButton(this, pFormatCntLayout, enmDeviceType, preferred.value(strId), true);
    95                     foreach (const QString &strId, others.keys())
    96                         addFormatButton(this, pFormatCntLayout, enmDeviceType, others.value(strId));
    97 
    98                     if (!m_pFormatButtonGroup->buttons().isEmpty())
    99                     {
    100                         m_pFormatButtonGroup->button(0)->click();
    101                         m_pFormatButtonGroup->button(0)->setFocus();
    102                     }
    103                 }
    104             }
    105         }
    106         m_pVariantCnt = new QGroupBox(this);
    107         {
    108             m_pVariantCnt->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
    109             QVBoxLayout *pVariantCntLayout = new QVBoxLayout(m_pVariantCnt);
    110             {
    111                 m_pVariantButtonGroup = new QButtonGroup(m_pVariantCnt);
    112                 {
    113                     m_pDynamicalButton = new QRadioButton(m_pVariantCnt);
    114                     if (enmDeviceType == KDeviceType_HardDisk)
    115                     {
    116                         m_pDynamicalButton->click();
    117                         m_pDynamicalButton->setFocus();
    118                     }
    119                     m_pFixedButton = new QRadioButton(m_pVariantCnt);
    120                     if (   enmDeviceType == KDeviceType_DVD
    121                         || enmDeviceType == KDeviceType_Floppy)
    122                     {
    123                         m_pFixedButton->click();
    124                         m_pFixedButton->setFocus();
    125                     }
    126                     m_pVariantButtonGroup->addButton(m_pDynamicalButton, 0);
    127                     m_pVariantButtonGroup->addButton(m_pFixedButton, 1);
    128                 }
    129                 m_pSplitBox = new QCheckBox(m_pVariantCnt);
    130                 pVariantCntLayout->addWidget(m_pDynamicalButton);
    131                 pVariantCntLayout->addWidget(m_pFixedButton);
    132                 pVariantCntLayout->addWidget(m_pSplitBox);
    133             }
    134         }
    135         pMainLayout->addWidget(m_pDestinationCnt, 1, 0, 1, 2);
    136         pMainLayout->addWidget(m_pFormatCnt, 2, 0, Qt::AlignTop);
    137         pMainLayout->addWidget(m_pVariantCnt, 2, 1, Qt::AlignTop);
    138     }
    139 
    140     /* Setup connections: */
    141     connect(m_pFormatButtonGroup, static_cast<void(QButtonGroup::*)(QAbstractButton*)>(&QButtonGroup::buttonClicked),
    142             this, &UIWizardCloneVDPageExpert::sltMediumFormatChanged);
    143     connect(m_pVariantButtonGroup, static_cast<void(QButtonGroup::*)(QAbstractButton*)>(&QButtonGroup::buttonClicked),
    144             this, &UIWizardCloneVDPageExpert::completeChanged);
    145     connect(m_pSplitBox, &QCheckBox::stateChanged,
    146             this, &UIWizardCloneVDPageExpert::completeChanged);
    147     connect(m_pDestinationDiskEditor, &QLineEdit::textChanged,
    148             this, &UIWizardCloneVDPageExpert::completeChanged);
    149     connect(m_pDestinationDiskOpenButton, &QIToolButton::clicked,
    150             this, &UIWizardCloneVDPageExpert::sltSelectLocationButtonClicked);
    151 
    152     /* Register classes: */
    153     qRegisterMetaType<CMedium>();
    154     qRegisterMetaType<CMediumFormat>();
    155     /* Register fields: */
    156     registerField("mediumFormat", this, "mediumFormat");
    157     registerField("mediumVariant", this, "mediumVariant");
    158     registerField("mediumPath", this, "mediumPath");
    159     registerField("mediumSize", this, "mediumSize");
     42UIWizardCloneVDPageExpert::UIWizardCloneVDPageExpert(KDeviceType /*enmDeviceType*/)
     43{
     44    // /* Create widgets: */
     45    // QGridLayout *pMainLayout = new QGridLayout(this);
     46    // {
     47    //     m_pDestinationCnt = new QGroupBox(this);
     48    //     {
     49    //         m_pDestinationCnt->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
     50    //         QHBoxLayout *pLocationCntLayout = new QHBoxLayout(m_pDestinationCnt);
     51    //         {
     52    //             m_pDestinationDiskEditor = new QLineEdit(m_pDestinationCnt);
     53    //             m_pDestinationDiskOpenButton = new QIToolButton(m_pDestinationCnt);
     54    //             {
     55    //                 m_pDestinationDiskOpenButton->setAutoRaise(true);
     56    //                 m_pDestinationDiskOpenButton->setIcon(UIIconPool::iconSet(":/select_file_16px.png", "select_file_disabled_16px.png"));
     57    //             }
     58    //         }
     59    //         pLocationCntLayout->addWidget(m_pDestinationDiskEditor);
     60    //         pLocationCntLayout->addWidget(m_pDestinationDiskOpenButton);
     61    //     }
     62    //     m_pFormatCnt = new QGroupBox(this);
     63    //     {
     64    //         m_pFormatCnt->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
     65    //         QVBoxLayout *pFormatCntLayout = new QVBoxLayout(m_pFormatCnt);
     66    //         {
     67    //             m_pFormatButtonGroup = new QButtonGroup(m_pFormatCnt);
     68    //             {
     69    //                 /* Enumerate medium formats in special order: */
     70    //                 CSystemProperties properties = uiCommon().virtualBox().GetSystemProperties();
     71    //                 const QVector<CMediumFormat> &formats = properties.GetMediumFormats();
     72    //                 QMap<QString, CMediumFormat> vdi, preferred, others;
     73    //                 foreach (const CMediumFormat &format, formats)
     74    //                 {
     75    //                     /* VDI goes first: */
     76    //                     if (format.GetName() == "VDI")
     77    //                         vdi[format.GetId()] = format;
     78    //                     else
     79    //                     {
     80    //                         const QVector<KMediumFormatCapabilities> &capabilities = format.GetCapabilities();
     81    //                         /* Then goes preferred: */
     82    //                         if (capabilities.contains(KMediumFormatCapabilities_Preferred))
     83    //                             preferred[format.GetId()] = format;
     84    //                         /* Then others: */
     85    //                         else
     86    //                             others[format.GetId()] = format;
     87    //                     }
     88    //                 }
     89
     90    //                 /* Create buttons for VDI, preferred and others: */
     91    //                 foreach (const QString &strId, vdi.keys())
     92    //                     addFormatButton(this, pFormatCntLayout, enmDeviceType, vdi.value(strId), true);
     93    //                 foreach (const QString &strId, preferred.keys())
     94    //                     addFormatButton(this, pFormatCntLayout, enmDeviceType, preferred.value(strId), true);
     95    //                 foreach (const QString &strId, others.keys())
     96    //                     addFormatButton(this, pFormatCntLayout, enmDeviceType, others.value(strId));
     97
     98    //                 if (!m_pFormatButtonGroup->buttons().isEmpty())
     99    //                 {
     100    //                     m_pFormatButtonGroup->button(0)->click();
     101    //                     m_pFormatButtonGroup->button(0)->setFocus();
     102    //                 }
     103    //             }
     104    //         }
     105    //     }
     106    //     m_pVariantCnt = new QGroupBox(this);
     107    //     {
     108    //         m_pVariantCnt->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
     109    //         QVBoxLayout *pVariantCntLayout = new QVBoxLayout(m_pVariantCnt);
     110    //         {
     111    //             m_pVariantButtonGroup = new QButtonGroup(m_pVariantCnt);
     112    //             {
     113    //                 m_pDynamicalButton = new QRadioButton(m_pVariantCnt);
     114    //                 if (enmDeviceType == KDeviceType_HardDisk)
     115    //                 {
     116    //                     m_pDynamicalButton->click();
     117    //                     m_pDynamicalButton->setFocus();
     118    //                 }
     119    //                 m_pFixedButton = new QRadioButton(m_pVariantCnt);
     120    //                 if (   enmDeviceType == KDeviceType_DVD
     121    //                     || enmDeviceType == KDeviceType_Floppy)
     122    //                 {
     123    //                     m_pFixedButton->click();
     124    //                     m_pFixedButton->setFocus();
     125    //                 }
     126    //                 m_pVariantButtonGroup->addButton(m_pDynamicalButton, 0);
     127    //                 m_pVariantButtonGroup->addButton(m_pFixedButton, 1);
     128    //             }
     129    //             m_pSplitBox = new QCheckBox(m_pVariantCnt);
     130    //             pVariantCntLayout->addWidget(m_pDynamicalButton);
     131    //             pVariantCntLayout->addWidget(m_pFixedButton);
     132    //             pVariantCntLayout->addWidget(m_pSplitBox);
     133    //         }
     134    //     }
     135    //     pMainLayout->addWidget(m_pDestinationCnt, 1, 0, 1, 2);
     136    //     pMainLayout->addWidget(m_pFormatCnt, 2, 0, Qt::AlignTop);
     137    //     pMainLayout->addWidget(m_pVariantCnt, 2, 1, Qt::AlignTop);
     138    // }
     139
     140    // /* Setup connections: */
     141    // connect(m_pFormatButtonGroup, static_cast<void(QButtonGroup::*)(QAbstractButton*)>(&QButtonGroup::buttonClicked),
     142    //         this, &UIWizardCloneVDPageExpert::sltMediumFormatChanged);
     143    // connect(m_pVariantButtonGroup, static_cast<void(QButtonGroup::*)(QAbstractButton*)>(&QButtonGroup::buttonClicked),
     144    //         this, &UIWizardCloneVDPageExpert::completeChanged);
     145    // connect(m_pSplitBox, &QCheckBox::stateChanged,
     146    //         this, &UIWizardCloneVDPageExpert::completeChanged);
     147    // connect(m_pDestinationDiskEditor, &QLineEdit::textChanged,
     148    //         this, &UIWizardCloneVDPageExpert::completeChanged);
     149    // connect(m_pDestinationDiskOpenButton, &QIToolButton::clicked,
     150    //         this, &UIWizardCloneVDPageExpert::sltSelectLocationButtonClicked);
    160151}
    161152
    162153void UIWizardCloneVDPageExpert::setTargetLocation()
    163154{
    164     UIWizardCloneVD *pWizard = qobject_cast<UIWizardCloneVD*>(wizard());
    165     if (!pWizard)
    166         return;
    167     /* Get source virtual-disk file-information: */
    168     QFileInfo sourceFileInfo(pWizard->sourceVirtualDisk().GetLocation());
    169     /* Get default path for virtual-disk copy: */
    170     m_strDefaultPath = sourceFileInfo.absolutePath();
    171     /* Compose name for virtual-disk copy: */
    172     QString strMediumName = UIWizardCloneVD::tr("%1_copy", "copied virtual disk image name").arg(sourceFileInfo.baseName());
    173     /* Set text to location editor: */
    174     m_pDestinationDiskEditor->setText(strMediumName);
    175 
    176     /* Broadcast complete-change: */
    177     emit completeChanged();
     155    // UIWizardCloneVD *pWizard = qobject_cast<UIWizardCloneVD*>(wizard());
     156    // if (!pWizard)
     157    //     return;
     158    // /* Get source virtual-disk file-information: */
     159    // QFileInfo sourceFileInfo(pWizard->sourceVirtualDisk().GetLocation());
     160    // /* Get default path for virtual-disk copy: */
     161    // m_strDefaultPath = sourceFileInfo.absolutePath();
     162    // /* Compose name for virtual-disk copy: */
     163    // QString strMediumName = UIWizardCloneVD::tr("%1_copy", "copied virtual disk image name").arg(sourceFileInfo.baseName());
     164    // /* Set text to location editor: */
     165    // m_pDestinationDiskEditor->setText(strMediumName);
     166
     167    // /* Broadcast complete-change: */
     168    // emit completeChanged();
    178169}
    179170
    180171void UIWizardCloneVDPageExpert::sltMediumFormatChanged()
    181172{
    182     /* Get medium format: */
    183     CMediumFormat mf = mediumFormat();
    184     if (mf.isNull())
    185     {
    186         AssertMsgFailed(("No medium format set!"));
    187         return;
    188     }
    189 
    190     /* Enable/disable widgets: */
    191     ULONG uCapabilities = 0;
    192     QVector<KMediumFormatCapabilities> capabilities;
    193     capabilities = mf.GetCapabilities();
    194     for (int i = 0; i < capabilities.size(); i++)
    195         uCapabilities |= capabilities[i];
    196 
    197     bool fIsCreateDynamicPossible = uCapabilities & KMediumFormatCapabilities_CreateDynamic;
    198     bool fIsCreateFixedPossible = uCapabilities & KMediumFormatCapabilities_CreateFixed;
    199     bool fIsCreateSplitPossible = uCapabilities & KMediumFormatCapabilities_CreateSplit2G;
    200     m_pDynamicalButton->setEnabled(fIsCreateDynamicPossible);
    201     m_pFixedButton->setEnabled(fIsCreateFixedPossible);
    202     m_pSplitBox->setEnabled(fIsCreateSplitPossible);
    203 
    204     /* Compose virtual-disk extension: */
    205     acquireExtensions(mf, static_cast<UIWizardCloneVD*>(wizardImp())->sourceVirtualDiskDeviceType(),
    206                       m_aAllowedExtensions, m_strDefaultExtension);
    207 
    208     /* Broadcast complete-change: */
    209     emit completeChanged();
     173    // /* Get medium format: */
     174    // CMediumFormat mf = mediumFormat();
     175    // if (mf.isNull())
     176    // {
     177    //     AssertMsgFailed(("No medium format set!"));
     178    //     return;
     179    // }
     180
     181    // /* Enable/disable widgets: */
     182    // ULONG uCapabilities = 0;
     183    // QVector<KMediumFormatCapabilities> capabilities;
     184    // capabilities = mf.GetCapabilities();
     185    // for (int i = 0; i < capabilities.size(); i++)
     186    //     uCapabilities |= capabilities[i];
     187
     188    // bool fIsCreateDynamicPossible = uCapabilities & KMediumFormatCapabilities_CreateDynamic;
     189    // bool fIsCreateFixedPossible = uCapabilities & KMediumFormatCapabilities_CreateFixed;
     190    // bool fIsCreateSplitPossible = uCapabilities & KMediumFormatCapabilities_CreateSplit2G;
     191    // m_pDynamicalButton->setEnabled(fIsCreateDynamicPossible);
     192    // m_pFixedButton->setEnabled(fIsCreateFixedPossible);
     193    // m_pSplitBox->setEnabled(fIsCreateSplitPossible);
     194
     195    // /* Compose virtual-disk extension: */
     196    // acquireExtensions(mf, static_cast<UIWizardCloneVD*>(wizardImp())->sourceVirtualDiskDeviceType(),
     197    //                   m_aAllowedExtensions, m_strDefaultExtension);
     198
     199    // /* Broadcast complete-change: */
     200    // emit completeChanged();
    210201}
    211202
    … …  
    213204{
    214205    /* Call to base-class: */
    215     onSelectLocationButtonClicked();
     206    //onSelectLocationButtonClicked();
    216207}
    217208
    … …  
    219210{
    220211    /* Translate widgets: */
    221     m_pDestinationCnt->setTitle(UIWizardCloneVD::tr("&New disk image to create"));
    222     m_pDestinationDiskOpenButton->setToolTip(UIWizardCloneVD::tr("Choose a location for new virtual disk image file..."));
    223     m_pFormatCnt->setTitle(UIWizardCloneVD::tr("Disk image file &type"));
    224     QList<QAbstractButton*> buttons = m_pFormatButtonGroup->buttons();
    225     for (int i = 0; i < buttons.size(); ++i)
    226     {
    227         QAbstractButton *pButton = buttons[i];
    228         UIMediumFormat enmFormat = gpConverter->fromInternalString<UIMediumFormat>(m_formatNames[m_pFormatButtonGroup->id(pButton)]);
    229         pButton->setText(gpConverter->toString(enmFormat));
    230     }
    231     m_pVariantCnt->setTitle(UIWizardCloneVD::tr("Storage on physical hard disk"));
    232     m_pDynamicalButton->setText(UIWizardCloneVD::tr("&Dynamically allocated"));
    233     m_pFixedButton->setText(UIWizardCloneVD::tr("&Fixed size"));
    234     m_pSplitBox->setText(UIWizardCloneVD::tr("&Split into files of less than 2GB"));
     212    // m_pDestinationCnt->setTitle(UIWizardCloneVD::tr("&New disk image to create"));
     213    // m_pDestinationDiskOpenButton->setToolTip(UIWizardCloneVD::tr("Choose a location for new virtual disk image file..."));
     214    // m_pFormatCnt->setTitle(UIWizardCloneVD::tr("Disk image file &type"));
     215    // QList<QAbstractButton*> buttons = m_pFormatButtonGroup->buttons();
     216    // for (int i = 0; i < buttons.size(); ++i)
     217    // {
     218    //     QAbstractButton *pButton = buttons[i];
     219    //     UIMediumFormat enmFormat = gpConverter->fromInternalString<UIMediumFormat>(m_formatNames[m_pFormatButtonGroup->id(pButton)]);
     220    //     pButton->setText(gpConverter->toString(enmFormat));
     221    // }
     222    // m_pVariantCnt->setTitle(UIWizardCloneVD::tr("Storage on physical hard disk"));
     223    // m_pDynamicalButton->setText(UIWizardCloneVD::tr("&Dynamically allocated"));
     224    // m_pFixedButton->setText(UIWizardCloneVD::tr("&Fixed size"));
     225    // m_pSplitBox->setText(UIWizardCloneVD::tr("&Split into files of less than 2GB"));
    235226}
    236227
    … …  
    246237bool UIWizardCloneVDPageExpert::isComplete() const
    247238{
    248     UIWizardCloneVD *pWizard = qobject_cast<UIWizardCloneVD*>(wizard());
    249     if (!pWizard)
    250         return false;
    251     /* Check what source virtual-disk feats the rules,
    252      * medium format/variant is correct,
    253      * current name is not empty: */
    254     return !pWizard->sourceVirtualDisk().isNull() &&
    255            !mediumFormat().isNull() &&
    256            mediumVariant() != (qulonglong)KMediumVariant_Max &&
    257            !m_pDestinationDiskEditor->text().trimmed().isEmpty();
     239    // UIWizardCloneVD *pWizard = qobject_cast<UIWizardCloneVD*>(wizard());
     240    // if (!pWizard)
     241    //     return false;
     242    // /* Check what source virtual-disk feats the rules,
     243    //  * medium format/variant is correct,
     244    //  * current name is not empty: */
     245    // return !pWizard->sourceVirtualDisk().isNull() &&
     246    //        !mediumFormat().isNull() &&
     247    //        mediumVariant() != (qulonglong)KMediumVariant_Max &&
     248    //        !m_pDestinationDiskEditor->text().trimmed().isEmpty();
     249    return true;
    258250}
    259251
    … …  
    263255    bool fResult = true;
    264256
    265     /* Lock finish button: */
    266     startProcessing();
    267 
    268     /* Make sure such virtual-disk doesn't exists: */
    269     QString strMediumPath(mediumPath());
    270     fResult = !QFileInfo(strMediumPath).exists();
    271     if (!fResult)
    272         msgCenter().cannotOverwriteHardDiskStorage(strMediumPath, this);
    273 
    274     /* Try to copy virtual-disk: */
    275     if (fResult)
    276         fResult = qobject_cast<UIWizardCloneVD*>(wizard())->copyVirtualDisk();
    277 
    278     /* Unlock finish button: */
    279     endProcessing();
     257    // /* Lock finish button: */
     258    // startProcessing();
     259
     260    // /* Make sure such virtual-disk doesn't exists: */
     261    // QString strMediumPath(mediumPath());
     262    // fResult = !QFileInfo(strMediumPath).exists();
     263    // if (!fResult)
     264    //     msgCenter().cannotOverwriteHardDiskStorage(strMediumPath, this);
     265
     266    // /* Try to copy virtual-disk: */
     267    // if (fResult)
     268    //     fResult = qobject_cast<UIWizardCloneVD*>(wizard())->copyVirtualDisk();
     269
     270    // /* Unlock finish button: */
     271    // endProcessing();
    280272
    281273    /* Return result: */

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/clonevd/UIWizardCloneVDPageExpert.h

    r82968 r90748  
    2323
    2424/* GUI includes: */
    25 #include "UIWizardCloneVDPageBasic1.h"
    26 #include "UIWizardCloneVDPageBasic2.h"
     25#include "UINativeWizardPage.h"
    2726#include "UIWizardCloneVDPageBasic3.h"
    2827
    … …  
    3231
    3332/** Expert page of the Clone Virtual Disk Image wizard: */
    34 class UIWizardCloneVDPageExpert : public UIWizardPage,
    35                                   public UIWizardCloneVDPage1,
    36                                   public UIWizardCloneVDPage2,
    37                                   public UIWizardCloneVDPage3
     33class UIWizardCloneVDPageExpert : public UINativeWizardPage
    3834{
    3935    Q_OBJECT;
    40     Q_PROPERTY(CMediumFormat mediumFormat READ mediumFormat WRITE setMediumFormat);
    41     Q_PROPERTY(qulonglong mediumVariant READ mediumVariant WRITE setMediumVariant);
    42     Q_PROPERTY(QString mediumPath READ mediumPath);
    43     Q_PROPERTY(qulonglong mediumSize READ mediumSize);
    4436
    4537public:
    … …  
    4941      * @param  enmDeviceType         Brings the device type to limit format to. */
    5042    UIWizardCloneVDPageExpert(KDeviceType enmDeviceType);
    51 
    52 protected:
    53 
    54     /** Allows to access 'wizard()' from base part. */
    55     UIWizard *wizardImp() const { return wizard(); }
    56     /** Allows to access 'this' from base part. */
    57     UIWizardPage* thisImp() { return this; }
    58     /** Allows to access 'field()' from base part. */
    59     QVariant fieldImp(const QString &strFieldName) const { return UIWizardPage::field(strFieldName); }
    6043
    6144private slots:

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

    r90576 r90748  
    9393
    9494/* static */
    95 QString UIDiskEditorGroupBox::defaultExtensionForMediumFormat(const CMediumFormat &mediumFormatRef)
    96 {
    97     if (!mediumFormatRef.isNull())
    98     {
    99         /* Load extension / device list: */
    100         QVector<QString> fileExtensions;
    101         QVector<KDeviceType> deviceTypes;
    102         CMediumFormat mediumFormat(mediumFormatRef);
    103         mediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
    104         for (int i = 0; i < fileExtensions.size(); ++i)
    105             if (deviceTypes[i] == KDeviceType_HardDisk)
    106                 return fileExtensions[i].toLower();
    107     }
    108     AssertMsgFailed(("Extension can't be NULL!\n"));
    109     return QString();
    110 }
    111 
    112 /* static */
    11395bool UIDiskEditorGroupBox::checkFATSizeLimitation(const qulonglong uVariant, const QString &strMediumPath, const qulonglong uSize)
    11496{
    … …  
    137119*********************************************************************************************************************************/
    138120
    139 UIDiskFormatsGroupBox::UIDiskFormatsGroupBox(bool fExpertMode, QWidget *pParent /* = 0 */)
     121UIDiskFormatsGroupBox::UIDiskFormatsGroupBox(bool fExpertMode, KDeviceType enmDeviceType, QWidget *pParent /* = 0 */)
    140122    : UIDiskEditorGroupBox(fExpertMode, pParent)
    141123    , m_pFormatButtonGroup(0)
    142124{
    143     prepare();
     125    prepare(enmDeviceType);
    144126}
    145127
    … …  
    164146}
    165147
    166 void UIDiskFormatsGroupBox::prepare()
     148void UIDiskFormatsGroupBox::prepare(KDeviceType enmDeviceType)
    167149{
    168150    QVBoxLayout *pContainerLayout = new QVBoxLayout(this);
    … …  
    193175    /* Create buttons for VDI, preferred and others: */
    194176    foreach (const QString &strId, vdi.keys())
    195         addFormatButton(pContainerLayout, vdi.value(strId), true);
     177        addFormatButton(pContainerLayout, vdi.value(strId), enmDeviceType, true);
    196178    foreach (const QString &strId, preferred.keys())
    197         addFormatButton(pContainerLayout, preferred.value(strId), true);
    198 
    199     if (m_fExpertMode)
     179        addFormatButton(pContainerLayout, preferred.value(strId), enmDeviceType, true);
     180
     181    if (m_fExpertMode || enmDeviceType == KDeviceType_DVD || enmDeviceType == KDeviceType_Floppy)
    200182    {
    201183        foreach (const QString &strId, others.keys())
    202             addFormatButton(pContainerLayout, others.value(strId));
     184            addFormatButton(pContainerLayout, others.value(strId), enmDeviceType);
    203185    }
    204186
    … …  
    230212}
    231213
    232 void UIDiskFormatsGroupBox::addFormatButton(QVBoxLayout *pFormatLayout, CMediumFormat medFormat, bool fPreferred /* = false */)
     214void UIDiskFormatsGroupBox::addFormatButton(QVBoxLayout *pFormatLayout, CMediumFormat medFormat,
     215                                            KDeviceType enmDeviceType, bool fPreferred /* = false */)
    233216{
    234217    /* Check that medium format supports creation: */
    … …  
    247230    QVector<KDeviceType> deviceTypes;
    248231    medFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
    249     if (!deviceTypes.contains(KDeviceType_HardDisk))
     232    if (!deviceTypes.contains(enmDeviceType))
    250233        return;
    251234
    … …  
    265248        m_formatNames << medFormat.GetName();
    266249        m_pFormatButtonGroup->addButton(pFormatButton, m_formatNames.size() - 1);
    267         m_formatExtensions << defaultExtension(medFormat);
     250        m_formatExtensions << defaultExtension(medFormat, enmDeviceType);
    268251    }
    269252}
    … …  
    275258
    276259/* static */
    277 QString UIDiskFormatsGroupBox::defaultExtension(const CMediumFormat &mediumFormatRef)
     260QString UIDiskFormatsGroupBox::defaultExtension(const CMediumFormat &mediumFormatRef, KDeviceType enmDeviceType)
    278261{
    279262    if (!mediumFormatRef.isNull())
    … …  
    285268        mediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
    286269        for (int i = 0; i < fileExtensions.size(); ++i)
    287             if (deviceTypes[i] == KDeviceType_HardDisk)
     270            if (deviceTypes[i] == enmDeviceType)
    288271                return fileExtensions[i].toLower();
    289272    }
    … …  
    544527}
    545528
    546 void UIMediumSizeAndPathGroupBox::updateMediumPath(const CMediumFormat &mediumFormat, const QStringList &formatExtensions)
     529void UIMediumSizeAndPathGroupBox::updateMediumPath(const CMediumFormat &mediumFormat, const QStringList &formatExtensions,
     530                                                   KDeviceType enmDeviceType)
    547531{
    548532    /* Compose virtual-disk extension: */
    549     QString strDefaultExtension = UIDiskFormatsGroupBox::defaultExtension(mediumFormat);
     533    QString strDefaultExtension = UIDiskFormatsGroupBox::defaultExtension(mediumFormat, enmDeviceType);
    550534    /* Update m_pLocationEditor's text if necessary: */
    551535    if (!m_pLocationEditor->text().isEmpty() && !strDefaultExtension.isEmpty())

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

    r90401 r90748  
    6060    static QString appendExtension(const QString &strName, const QString &strExtension);
    6161    static QString constructMediumFilePath(const QString &strFileName, const QString &strPath);
    62     static QString defaultExtensionForMediumFormat(const CMediumFormat &mediumFormatRef);
    6362    static bool checkFATSizeLimitation(const qulonglong uVariant, const QString &strMediumPath, const qulonglong uSize);
    6463
    … …  
    7877public:
    7978
    80     UIDiskFormatsGroupBox(bool fExpertMode, QWidget *pParent = 0);
     79    UIDiskFormatsGroupBox(bool fExpertMode, KDeviceType enmDeviceType, QWidget *pParent = 0);
    8180    CMediumFormat mediumFormat() const;
    8281    void setMediumFormat(const CMediumFormat &mediumFormat);
    8382    const CMediumFormat &VDIMediumFormat() const;
    8483    const QStringList formatExtensions() const;
    85     static QString defaultExtension(const CMediumFormat &mediumFormatRef);
     84    static QString defaultExtension(const CMediumFormat &mediumFormatRef, KDeviceType enmDeviceType);
    8685
    8786private:
    8887
    89     void prepare();
    90     void addFormatButton(QVBoxLayout *pFormatLayout, CMediumFormat medFormat, bool fPreferred = false);
     88    void prepare(KDeviceType enmDeviceType);
     89    void addFormatButton(QVBoxLayout *pFormatLayout, CMediumFormat medFormat, KDeviceType enmDeviceType, bool fPreferred = false);
    9190
    9291    virtual void retranslateUi() /* override final */;
    … …  
    152151    QString mediumPath() const;
    153152    void setMediumPath(const QString &strMediumPath);
    154     void updateMediumPath(const CMediumFormat &mediumFormat, const QStringList &formatExtensions);
     153    /** Checks if the file extension is correct. Fixs it if necessary. */
     154    void updateMediumPath(const CMediumFormat &mediumFormat, const QStringList &formatExtensions, KDeviceType enmDeviceType);
    155155    qulonglong mediumSize() const;
    156156    void setMediumSize(qulonglong uSize);

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

    r90576 r90748  
    6565    QGridLayout *pMainLayout = new QGridLayout(this);
    6666    m_pSizeAndPathGroup = new UIMediumSizeAndPathGroupBox(true /* fExpertMode */, 0);
    67     m_pFormatGroup = new UIDiskFormatsGroupBox(true /* fExpertMode */, 0);
     67    m_pFormatGroup = new UIDiskFormatsGroupBox(true /* fExpertMode */, KDeviceType_HardDisk, 0);
    6868    m_pVariantGroup = new UIDiskVariantGroupBox(true /* fExpertMode */, 0);
    6969
    … …  
    9898    QString strMediumPath =
    9999        UIDiskEditorGroupBox::appendExtension(strPath,
    100                                               UIDiskEditorGroupBox::defaultExtensionForMediumFormat(pWizard->mediumFormat()));
     100                                              UIDiskFormatsGroupBox::defaultExtension(pWizard->mediumFormat(), KDeviceType_HardDisk));
    101101    newVDWizardPropertySet(MediumPath, strMediumPath);
    102102    emit completeChanged();
    … …  
    126126    QString strMediumPath =
    127127        UIDiskEditorGroupBox::appendExtension(strSelectedPath,
    128                                               UIDiskEditorGroupBox::defaultExtensionForMediumFormat(pWizard->mediumFormat()));
     128                                              UIDiskFormatsGroupBox::defaultExtension(pWizard->mediumFormat(), KDeviceType_HardDisk));
    129129    QFileInfo mediumPath(strMediumPath);
    130130    m_pSizeAndPathGroup->setMediumPath(QDir::toNativeSeparators(mediumPath.absoluteFilePath()));
    … …  
    144144    newVDWizardPropertySet(MediumFormat, comMediumFormat);
    145145
    146     QString strExtension = UIDiskEditorGroupBox::defaultExtensionForMediumFormat(comMediumFormat);
     146    QString strExtension = UIDiskFormatsGroupBox::defaultExtension(comMediumFormat, KDeviceType_HardDisk);
    147147    QString strMediumFilePath =
    148148        UIDiskEditorGroupBox::constructMediumFilePath(UIDiskVariantGroupBox::appendExtension(m_strDefaultName,
    … …  
    223223
    224224    m_pSizeAndPathGroup->blockSignals(true);
    225     m_pSizeAndPathGroup->updateMediumPath(comMediumFormat, m_pFormatGroup->formatExtensions());
     225    m_pSizeAndPathGroup->updateMediumPath(comMediumFormat, m_pFormatGroup->formatExtensions(), KDeviceType_HardDisk);
    226226    m_pSizeAndPathGroup->blockSignals(false);
    227227    /* Update the wizard parameters explicitly since we blocked th signals: */

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

    r90430 r90748  
    3939    m_pLabel = new QIRichTextLabel(this);
    4040    pMainLayout->addWidget(m_pLabel);
    41     m_pFormatButtonGroup = new UIDiskFormatsGroupBox(false, 0);
     41    m_pFormatButtonGroup = new UIDiskFormatsGroupBox(false, KDeviceType_HardDisk, 0);
    4242    pMainLayout->addWidget(m_pFormatButtonGroup, false);
    4343

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

    r90576 r90748  
    107107    QString strMediumPath =
    108108        UIDiskEditorGroupBox::appendExtension(strSelectedPath,
    109                                               UIDiskEditorGroupBox::defaultExtensionForMediumFormat(pWizard->mediumFormat()));
     109                                              UIDiskFormatsGroupBox::defaultExtension(pWizard->mediumFormat(), KDeviceType_HardDisk));
    110110    QFileInfo mediumPath(strMediumPath);
    111111    m_pMediumSizePathGroup->setMediumPath(QDir::toNativeSeparators(mediumPath.absoluteFilePath()));
    … …  
    126126    QString strMediumPath =
    127127        UIDiskEditorGroupBox::appendExtension(strPath,
    128                                               UIDiskEditorGroupBox::defaultExtensionForMediumFormat(pWizard->mediumFormat()));
     128                                              UIDiskFormatsGroupBox::defaultExtension(pWizard->mediumFormat(), KDeviceType_HardDisk));
    129129    newVDWizardPropertySet(MediumPath, strMediumPath);
    130130    emit completeChanged();
    … …  
    145145        const CMediumFormat comMediumFormat = pWizard->mediumFormat();
    146146        AssertReturnVoid(!comMediumFormat.isNull());
    147         QString strExtension = UIDiskEditorGroupBox::defaultExtensionForMediumFormat(comMediumFormat);
     147        QString strExtension = UIDiskFormatsGroupBox::defaultExtension(comMediumFormat, KDeviceType_HardDisk);
    148148        QString strMediumFilePath =
    149149            UIDiskEditorGroupBox::constructMediumFilePath(UIDiskVariantGroupBox::appendExtension(m_strDefaultName,

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

    r90427 r90748  
    334334        setWidgetVisibility(pWizard->mediumFormat());
    335335    }
    336     QString strDefaultExtension =  UIDiskEditorGroupBox::defaultExtensionForMediumFormat(pWizard->mediumFormat());
     336    QString strDefaultExtension =  UIDiskFormatsGroupBox::defaultExtension(pWizard->mediumFormat(), KDeviceType_HardDisk);
    337337
    338338    /* We set the medium name and path according to machine name/path and do not allow user change these in the guided mode: */

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

    r90413 r90748  
    455455    m_pSizeAndLocationGroup = new UIMediumSizeAndPathGroupBox(true, 0);
    456456    pDiskContainerLayout->addWidget(m_pSizeAndLocationGroup, 0, 0, 2, 2);
    457     m_pFormatButtonGroup = new UIDiskFormatsGroupBox(true, 0);
     457    m_pFormatButtonGroup = new UIDiskFormatsGroupBox(true, KDeviceType_HardDisk, 0);
    458458    pDiskContainerLayout->addWidget(m_pFormatButtonGroup, 2, 0, 4, 1);
    459459    m_pDiskVariantGroupBox  = new UIDiskVariantGroupBox(true, 0);
    … …  
    697697    QString strMediumPath =
    698698        UIDiskEditorGroupBox::appendExtension(strSelectedPath,
    699                                               UIDiskEditorGroupBox::defaultExtensionForMediumFormat(pWizard->mediumFormat()));
     699                                              UIDiskFormatsGroupBox::defaultExtension(pWizard->mediumFormat(), KDeviceType_HardDisk));
    700700    QFileInfo mediumPath(strMediumPath);
    701701    m_pSizeAndLocationGroup->setMediumPath(QDir::toNativeSeparators(mediumPath.absoluteFilePath()));
    … …  
    801801            strMediumPath = uiCommon().virtualBox().GetSystemProperties().GetDefaultMachineFolder();
    802802    }
    803     QString strExtension = UIDiskEditorGroupBox::defaultExtensionForMediumFormat(pWizard->mediumFormat());
     803    QString strExtension = UIDiskFormatsGroupBox::defaultExtension(pWizard->mediumFormat(), KDeviceType_HardDisk);
    804804    if (m_pSizeAndLocationGroup)
    805805    {
    … …  
    827827
    828828    m_pSizeAndLocationGroup->blockSignals(true);
    829     m_pSizeAndLocationGroup->updateMediumPath(comMediumFormat, m_pFormatButtonGroup->formatExtensions());
     829    m_pSizeAndLocationGroup->updateMediumPath(comMediumFormat, m_pFormatButtonGroup->formatExtensions(), KDeviceType_HardDisk);
    830830    m_pSizeAndLocationGroup->blockSignals(false);
    831831    /* Update the wizard parameters explicitly since we blocked th signals: */
Note: See TracChangeset for help on using the changeset viewer.

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