VirtualBox

Changeset 90800 in vbox for trunk/src


Ignore:
Timestamp:
Aug 23, 2021 4:48:32 PM (3 years ago)
Author:
vboxsync
Message:

FE/Qt: bugref:9996. Working on the expert page of the clone vd

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

Legend:

Unmodified
Added
Removed

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

    r90761 r90800  
    5353bool UIWizardCloneVD::copyVirtualDisk()
    5454{
    55     /* Gather attributes: */
    56     // const CMediumFormat comMediumFormat = field("mediumFormat").value<CMediumFormat>();
    57     // const qulonglong uVariant = field("mediumVariant").toULongLong();
    58     // const QString strMediumPath = field("mediumPath").toString();
    59     // const qulonglong uSize = field("mediumSize").toULongLong();
    60     // /* Check attributes: */
    61     // AssertReturn(!strMediumPath.isNull(), false);
    62     // AssertReturn(uSize > 0, false);
    63 
    64     // /* Get VBox object: */
    65     // CVirtualBox comVBox = uiCommon().virtualBox();
    66 
    67     // /* Create new virtual disk image: */
    68     // CMedium comVirtualDisk = comVBox.CreateMedium(comMediumFormat.GetName(), strMediumPath, KAccessMode_ReadWrite, m_enmDeviceType);
    69     // if (!comVBox.isOk())
    70     // {
    71     //     msgCenter().cannotCreateMediumStorage(comVBox, strMediumPath, this);
    72     //     return false;
    73     // }
    74 
    75     // /* Compose medium-variant: */
    76     // QVector<KMediumVariant> variants(sizeof(qulonglong) * 8);
    77     // for (int i = 0; i < variants.size(); ++i)
    78     // {
    79     //     qulonglong temp = uVariant;
    80     //     temp &= Q_UINT64_C(1) << i;
    81     //     variants[i] = (KMediumVariant)temp;
    82     // }
    83 
    84     // /* Copy medium: */
    85     // UINotificationProgressMediumCopy *pNotification = new UINotificationProgressMediumCopy(m_comSourceVirtualDisk,
    86     //                                                                                        comVirtualDisk,
    87     //                                                                                        variants);
    88     // connect(pNotification, &UINotificationProgressMediumCopy::sigMediumCopied,
    89     //         &uiCommon(), &UICommon::sltHandleMediumCreated);
    90     // gpNotificationCenter->append(pNotification);
     55    /* Check attributes: */
     56    AssertReturn(!m_strMediumPath.isNull(), false);
     57    AssertReturn(m_uMediumSize > 0, false);
     58
     59    /* Get VBox object: */
     60    CVirtualBox comVBox = uiCommon().virtualBox();
     61
     62    /* Create new virtual disk image: */
     63    CMedium comVirtualDisk = comVBox.CreateMedium(m_comMediumFormat.GetName(), m_strMediumPath, KAccessMode_ReadWrite, m_enmDeviceType);
     64    if (!comVBox.isOk())
     65    {
     66        msgCenter().cannotCreateMediumStorage(comVBox, m_strMediumPath, this);
     67        return false;
     68    }
     69
     70    /* Compose medium-variant: */
     71    QVector<KMediumVariant> variants(sizeof(qulonglong) * 8);
     72    for (int i = 0; i < variants.size(); ++i)
     73    {
     74        qulonglong temp = m_uMediumVariant;
     75        temp &= Q_UINT64_C(1) << i;
     76        variants[i] = (KMediumVariant)temp;
     77    }
     78
     79    /* Copy medium: */
     80    UINotificationProgressMediumCopy *pNotification = new UINotificationProgressMediumCopy(m_comSourceVirtualDisk,
     81                                                                                           comVirtualDisk,
     82                                                                                           variants);
     83    connect(pNotification, &UINotificationProgressMediumCopy::sigMediumCopied,
     84            &uiCommon(), &UICommon::sltHandleMediumCreated);
     85    gpNotificationCenter->append(pNotification);
    9186
    9287    /* Positive: */
    … …  
    107102    {
    108103        case WizardMode_Basic:
    109         case WizardMode_Expert:
    110         {
     104
     105            {
    111106            addPage(new UIWizardCloneVDPageBasic1(m_enmDeviceType));
    112107            m_iMediumVariantPageIndex = addPage(new UIWizardCloneVDPageBasic2(m_enmDeviceType));
    … …  
    114109            break;
    115110        }
    116         // case WizardMode_Expert:
    117         // {
    118         //     setPage(PageExpert, new UIWizardCloneVDPageExpert(m_enmDeviceType));
    119         //     break;
    120         // }
     111        case WizardMode_Expert:
     112        {
     113            addPage(new UIWizardCloneVDPageExpert(m_enmDeviceType, sourceDiskLogicalSize()));
     114            break;
     115        }
    121116        default:
    122117        {

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

    r90755 r90800  
    3232#include "CSystemProperties.h"
    3333
    34 
    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 
    9234UIWizardCloneVDPageBasic1::UIWizardCloneVDPageBasic1(KDeviceType enmDeviceType)
    9335    : m_pLabel(0)
    … …  
    9537{
    9638    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);
    15039}
    15140
    … …  
    17665                                          "for the new virtual disk image. If you do not need to use it "
    17766                                          "with other virtualization software you can leave this setting unchanged."));
    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     // }
    18567}
    18668
    … …  
    19880bool UIWizardCloneVDPageBasic1::isComplete() const
    19981{
    200     /* Make sure medium format is correct: */
    201     //return !mediumFormat().isNull();
     82    if (m_pFormatGroupBox)
     83    {
     84        if (m_pFormatGroupBox->mediumFormat().isNull())
     85            return false;
     86    }
    20287    return true;
    20388}
    … …  
    21196}
    21297
    213 // int UIWizardCloneVDPageBasic1::nextId() const
    214 // {
    215 //     /* Show variant page only if there is something to show: */
    216 //     CMediumFormat mf = mediumFormat();
    217 //     if (mf.isNull())
    218 //     {
    219 //         AssertMsgFailed(("No medium format set!"));
    220 //     }
    221 //     else
    222 //     {
    223 //         ULONG uCapabilities = 0;
    224 //         QVector<KMediumFormatCapabilities> capabilities;
    225 //         capabilities = mf.GetCapabilities();
    226 //         for (int i = 0; i < capabilities.size(); i++)
    227 //             uCapabilities |= capabilities[i];
    228 
    229 //         int cTest = 0;
    230 //         if (uCapabilities & KMediumFormatCapabilities_CreateDynamic)
    231 //             ++cTest;
    232 //         if (uCapabilities & KMediumFormatCapabilities_CreateFixed)
    233 //             ++cTest;
    234 //         if (uCapabilities & KMediumFormatCapabilities_CreateSplit2G)
    235 //             ++cTest;
    236 //         if (cTest > 1)
    237 //             return UIWizardCloneVD::Page3;
    238 //     }
    239 //     /* Skip otherwise: */
    240 //     return UIWizardCloneVD::Page3;
    241 // }
    242 
    24398UIWizardCloneVD *UIWizardCloneVDPageBasic1::cloneWizard() const
    24499{

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

    r90755 r90800  
    3636class UIDiskFormatsGroupBox;
    3737class UIWizardCloneVD;
    38 
    39 // /** 1st page of the Clone Virtual Disk Image wizard (base part): */
    40 // class UIWizardCloneVDPage1 : public UIWizardPageBase
    41 // {
    42 // protected:
    43 
    44 //     /** Constructs page basis. */
    45 //     UIWizardCloneVDPage1();
    46 
    47 //     /** Adds format button.
    48 //       * @param  pParent          Brings the parent to add button to.
    49 //       * @param  pFormatsLayout   Brings the layout to insert button to.
    50 //       * @param  enmDeviceType    Brings the device type all buttons should be restricted to.
    51 //       * @param  comMediumFormat  Brings the medium format object to acquire format from.
    52 //       * @param  fPreferred       Brings whether curretn format is preferred or not. */
    53 //     void addFormatButton(QWidget *pParent,
    54 //                          QVBoxLayout *pFormatsLayout,
    55 //                          KDeviceType enmDeviceType,
    56 //                          CMediumFormat comMediumFormat,
    57 //                          bool fPreferred = false);
    58 
    59 //     /** Returns 'mediumFormat' field value. */
    60 //     CMediumFormat mediumFormat() const;
    61 //     /** Defines 'mediumFormat' field value. */
    62 //     void setMediumFormat(const CMediumFormat &comMediumFormat);
    63 
    64 //     /** Holds the format button-group instance. */
    65 //     QButtonGroup         *m_pFormatButtonGroup;
    66 //     /** Holds the format description list. */
    67 //     QList<CMediumFormat>  m_formats;
    68 //     /** Holds the format name list. */
    69 //     QStringList           m_formatNames;
    70 // };
    7138
    7239

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

    r90755 r90800  
    3232
    3333
    34 // UIWizardCloneVDPage2::UIWizardCloneVDPage2()
    35 // {
    36 // }
    37 
    38 // qulonglong UIWizardCloneVDPage2::mediumVariant() const
    39 // {
    40 //     /* Initial value: */
    41 //     qulonglong uMediumVariant = (qulonglong)KMediumVariant_Max;
    42 
    43 //     /* Exclusive options: */
    44 //     if (m_pDynamicalButton->isChecked())
    45 //         uMediumVariant = (qulonglong)KMediumVariant_Standard;
    46 //     else if (m_pFixedButton->isChecked())
    47 //         uMediumVariant = (qulonglong)KMediumVariant_Fixed;
    48 
    49 //     /* Additional options: */
    50 //     if (m_pSplitBox->isChecked())
    51 //         uMediumVariant |= (qulonglong)KMediumVariant_VmdkSplit2G;
    52 
    53 //     /* Return options: */
    54 //     return uMediumVariant;
    55 // }
    56 
    57 // void UIWizardCloneVDPage2::setMediumVariant(qulonglong uMediumVariant)
    58 // {
    59 //     /* Exclusive options: */
    60 //     if (uMediumVariant & (qulonglong)KMediumVariant_Fixed)
    61 //     {
    62 //         m_pFixedButton->click();
    63 //         m_pFixedButton->setFocus();
    64 //     }
    65 //     else
    66 //     {
    67 //         m_pDynamicalButton->click();
    68 //         m_pDynamicalButton->setFocus();
    69 //     }
    70 
    71 //     /* Additional options: */
    72 //     m_pSplitBox->setChecked(uMediumVariant & (qulonglong)KMediumVariant_VmdkSplit2G);
    73 // }
    74 
    7534UIWizardCloneVDPageBasic2::UIWizardCloneVDPageBasic2(KDeviceType /*enmDeviceType*/)
    7635    : m_pDescriptionLabel(0)
    … …  
    8140{
    8241    prepare();
    83     /* Create widgets: */
    84     // QVBoxLayout *pMainLayout = new QVBoxLayout(this);
    85     // {
    86     //     QVBoxLayout *pVariantLayout = new QVBoxLayout;
    87     //     {
    88     //         m_pVariantButtonGroup = new QButtonGroup(this);
    89     //         {
    90     //             m_pDynamicalButton = new QRadioButton(this);
    91     //             if (enmDeviceType == KDeviceType_HardDisk)
    92     //             {
    93     //                 m_pDynamicalButton->click();
    94     //                 m_pDynamicalButton->setFocus();
    95     //             }
    96     //             m_pFixedButton = new QRadioButton(this);
    97     //             if (   enmDeviceType == KDeviceType_DVD
    98     //                 || enmDeviceType == KDeviceType_Floppy)
    99     //             {
    100     //                 m_pFixedButton->click();
    101     //                 m_pFixedButton->setFocus();
    102     //             }
    103     //             m_pVariantButtonGroup->addButton(m_pDynamicalButton, 0);
    104     //             m_pVariantButtonGroup->addButton(m_pFixedButton, 1);
    105     //         }
    106     //         m_pSplitBox = new QCheckBox(this);
    107     //         pVariantLayout->addWidget(m_pDynamicalButton);
    108     //         pVariantLayout->addWidget(m_pFixedButton);
    109     //         pVariantLayout->addWidget(m_pSplitBox);
    110     //     }
    111     //     pMainLayout->addWidget(m_pDescriptionLabel);
    112     //     pMainLayout->addWidget(m_pDynamicLabel);
    113     //     pMainLayout->addWidget(m_pFixedLabel);
    114     //     pMainLayout->addWidget(m_pSplitLabel);
    115     //     pMainLayout->addLayout(pVariantLayout);
    116     //     pMainLayout->addStretch();
    117     // }
    118 
    119     // /* Setup connections: */
    120     // connect(m_pVariantButtonGroup, static_cast<void(QButtonGroup::*)(QAbstractButton*)>(&QButtonGroup::buttonClicked),
    121     //         this, &UIWizardCloneVDPageBasic2::completeChanged);
    122     // connect(m_pSplitBox, &QCheckBox::stateChanged,
    123     //         this, &UIWizardCloneVDPageBasic2::completeChanged);
    12442}
    12543
    … …  
    17492    if (m_pVariantGroupBox)
    17593        cloneWizard()->setMediumVariant(m_pVariantGroupBox->mediumVariant());
    176     // /* Setup visibility: */
    177     // CMediumFormat mediumFormat = field("mediumFormat").value<CMediumFormat>();
    178     // ULONG uCapabilities = 0;
    179     // QVector<KMediumFormatCapabilities> capabilities;
    180     // capabilities = mediumFormat.GetCapabilities();
    181     // for (int i = 0; i < capabilities.size(); i++)
    182     //     uCapabilities |= capabilities[i];
    183 
    184     // bool fIsCreateDynamicPossible = uCapabilities & KMediumFormatCapabilities_CreateDynamic;
    185     // bool fIsCreateFixedPossible = uCapabilities & KMediumFormatCapabilities_CreateFixed;
    186     // bool fIsCreateSplitPossible = uCapabilities & KMediumFormatCapabilities_CreateSplit2G;
    187     // m_pDynamicLabel->setHidden(!fIsCreateDynamicPossible);
    188     // m_pDynamicalButton->setHidden(!fIsCreateDynamicPossible);
    189     // m_pFixedLabel->setHidden(!fIsCreateFixedPossible);
    190     // m_pFixedButton->setHidden(!fIsCreateFixedPossible);
    191     // m_pSplitLabel->setHidden(!fIsCreateSplitPossible);
    192     // m_pSplitBox->setHidden(!fIsCreateSplitPossible);
    19394}
    19495
    19596bool UIWizardCloneVDPageBasic2::isComplete() const
    19697{
    197     return true;
    198     // /* Make sure medium variant is correct: */
    199     // return mediumVariant() != (qulonglong)KMediumVariant_Max;
     98    AssertReturn(m_pVariantGroupBox, false);
     99    return m_pVariantGroupBox->isComplete();
    200100}
    201101

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

    r90755 r90800  
    3737class UIDiskVariantGroupBox;
    3838
    39 // /** 3rd page of the Clone Virtual Disk Image wizard (base part): */
    40 // class UIWizardCloneVDPage2 : public UIWizardPageBase
    41 // {
    42 // protected:
    43 
    44 //     /** Constructs page basis. */
    45 //     UIWizardCloneVDPage2();
    46 
    47 //     /** Returns 'mediumVariant' field value. */
    48 //     qulonglong mediumVariant() const;
    49 //     /** Defines 'mediumVariant' field value. */
    50 //     void setMediumVariant(qulonglong uMediumVariant);
    51 
    52 //     /** Holds the variant button-group instance. */
    53 //     QButtonGroup *m_pVariantButtonGroup;
    54 //     /** Holds the 'Dynamical' button instance. */
    55 //     QRadioButton *m_pDynamicalButton;
    56 //     /** Holds the 'Fixed' button instance. */
    57 //     QRadioButton *m_pFixedButton;
    58 //     /** Holds the 'Split to 2GB files' check-box instance. */
    59 //     QCheckBox    *m_pSplitBox;
    60 // };
    61 
    62 
    6339class UIWizardCloneVDPageBasic2 : public UINativeWizardPage
    6440{

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

    r90762 r90800  
    3232/* COM includes: */
    3333#include "CMediumFormat.h"
    34 
    35 
    36 // UIWizardCloneVDPage3::UIWizardCloneVDPage3()
    37 // {
    38 // }
    39 
    40 // void UIWizardCloneVDPage3::onSelectLocationButtonClicked()
    41 // {
    42 //     // /* Get current folder and filename: */
    43 //     // QFileInfo fullFilePath(mediumPath());
    44 //     // QDir folder = fullFilePath.path();
    45 //     // QString strFileName = fullFilePath.fileName();
    46 
    47 //     // /* Set the first parent folder that exists as the current: */
    48 //     // while (!folder.exists() && !folder.isRoot())
    49 //     // {
    50 //     //     QFileInfo folderInfo(folder.absolutePath());
    51 //     //     if (folder == QDir(folderInfo.absolutePath()))
    52 //     //         break;
    53 //     //     folder = folderInfo.absolutePath();
    54 //     // }
    55 
    56 //     // /* But if it doesn't exists at all: */
    57 //     // if (!folder.exists() || folder.isRoot())
    58 //     // {
    59 //     //     /* Use recommended one folder: */
    60 //     //     QFileInfo defaultFilePath(absoluteFilePath(strFileName, m_strDefaultPath));
    61 //     //     folder = defaultFilePath.path();
    62 //     // }
    63 
    64 //     // /* Prepare backends list: */
    65 //     // QVector<QString> fileExtensions;
    66 //     // QVector<KDeviceType> deviceTypes;
    67 //     // CMediumFormat mediumFormat = fieldImp("mediumFormat").value<CMediumFormat>();
    68 //     // mediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
    69 //     // QStringList validExtensionList;
    70 //     // for (int i = 0; i < fileExtensions.size(); ++i)
    71 //     //     if (deviceTypes[i] == static_cast<UIWizardCloneVD*>(wizardImp())->sourceVirtualDiskDeviceType())
    72 //     //         validExtensionList << QString("*.%1").arg(fileExtensions[i]);
    73 //     // /* Compose full filter list: */
    74 //     // QString strBackendsList = QString("%1 (%2)").arg(mediumFormat.GetName()).arg(validExtensionList.join(" "));
    75 
    76 //     // /* Open corresponding file-dialog: */
    77 //     // QString strChosenFilePath = QIFileDialog::getSaveFileName(folder.absoluteFilePath(strFileName),
    78 //     //                                                           strBackendsList, thisImp(),
    79 //     //                                                           UIWizardCloneVD::tr("Please choose a location for new virtual disk image file"));
    80 
    81 //     // /* If there was something really chosen: */
    82 //     // if (!strChosenFilePath.isEmpty())
    83 //     // {
    84 //     //     /* If valid file extension is missed, append it: */
    85 //     //     if (QFileInfo(strChosenFilePath).suffix().isEmpty())
    86 //     //         strChosenFilePath += QString(".%1").arg(m_strDefaultExtension);
    87 //     //     m_pDestinationDiskEditor->setText(QDir::toNativeSeparators(strChosenFilePath));
    88 //     //     m_pDestinationDiskEditor->selectAll();
    89 //     //     m_pDestinationDiskEditor->setFocus();
    90 //     // }
    91 // }
    92 
    93 // /* static */
    94 // QString UIWizardCloneVDPage3::toFileName(const QString &strName, const QString &strExtension)
    95 // {
    96 //     /* Convert passed name to native separators (it can be full, actually): */
    97 //     QString strFileName = QDir::toNativeSeparators(strName);
    98 
    99 //     /* Remove all trailing dots to avoid multiple dots before extension: */
    100 //     int iLen;
    101 //     while (iLen = strFileName.length(), iLen > 0 && strFileName[iLen - 1] == '.')
    102 //         strFileName.truncate(iLen - 1);
    103 
    104 //     /* Add passed extension if its not done yet: */
    105 //     if (QFileInfo(strFileName).suffix().toLower() != strExtension)
    106 //         strFileName += QString(".%1").arg(strExtension);
    107 
    108 //     /* Return result: */
    109 //     return strFileName;
    110 // }
    111 
    112 // /* static */
    113 // QString UIWizardCloneVDPage3::absoluteFilePath(const QString &strFileName, const QString &strDefaultPath)
    114 // {
    115 //     /* Wrap file-info around received file name: */
    116 //     QFileInfo fileInfo(strFileName);
    117 //     /* If path-info is relative or there is no path-info at all: */
    118 //     if (fileInfo.fileName() == strFileName || fileInfo.isRelative())
    119 //     {
    120 //         /* Resolve path on the basis of default path we have: */
    121 //         fileInfo = QFileInfo(strDefaultPath, strFileName);
    122 //     }
    123 //     /* Return full absolute disk image file path: */
    124 //     return QDir::toNativeSeparators(fileInfo.absoluteFilePath());
    125 // }
    126 
    127 // /* static */
    128 // void UIWizardCloneVDPage3::acquireExtensions(const CMediumFormat &comMediumFormat, KDeviceType enmDeviceType,
    129 //                                              QStringList &aAllowedExtensions, QString &strDefaultExtension)
    130 // {
    131 //     /* Load extension / device list: */
    132 //     QVector<QString> fileExtensions;
    133 //     QVector<KDeviceType> deviceTypes;
    134 //     CMediumFormat mediumFormat(comMediumFormat);
    135 //     mediumFormat.DescribeFileExtensions(fileExtensions, deviceTypes);
    136 //     for (int i = 0; i < fileExtensions.size(); ++i)
    137 //         if (deviceTypes[i] == enmDeviceType)
    138 //             aAllowedExtensions << fileExtensions[i].toLower();
    139 //     AssertReturnVoid(!aAllowedExtensions.isEmpty());
    140 //     strDefaultExtension = aAllowedExtensions.first();
    141 // }
    142 
    143 // QString UIWizardCloneVDPage3::mediumPath() const
    144 // {
    145 //     /* Acquire chosen file path, and what is important user suffix: */
    146 //     const QString strChosenFilePath = m_pDestinationDiskEditor->text();
    147 //     QString strSuffix = QFileInfo(strChosenFilePath).suffix().toLower();
    148 //     /* If there is no suffix of it's not allowed: */
    149 //     if (   strSuffix.isEmpty()
    150 //         || !m_aAllowedExtensions.contains(strSuffix))
    151 //         strSuffix = m_strDefaultExtension;
    152 //     /* Compose full file path finally: */
    153 //     return absoluteFilePath(toFileName(m_pDestinationDiskEditor->text(), strSuffix), m_strDefaultPath);
    154 // }
    155 
    156 // qulonglong UIWizardCloneVDPage3::mediumSize()
    157 // {
    158 //     // UIWizardCloneVD *pWizard = qobject_cast<UIWizardCloneVD*>(wizardImp());
    159 //     // if (!pWizard)
    160 //     //     return 0;
    161 //     // const CMedium &sourceVirtualDisk = pWizard->sourceVirtualDisk();
    162 //     // return sourceVirtualDisk.isNull() ? 0 : sourceVirtualDisk.GetLogicalSize();
    163 //     return 0;
    164 // }
    16534
    16635UIWizardCloneVDPageBasic3::UIWizardCloneVDPageBasic3(qulonglong uSourceDiskLogicaSize)
    … …  
    21180    if (!m_userModifiedParameters.contains("MediumPath"))
    21281    {
    213         const CMediumFormat comMediumFormat = pWizard->mediumFormat();
    214         AssertReturnVoid(!comMediumFormat.isNull());
    215         QString strExtension = UIDiskFormatsGroupBox::defaultExtension(comMediumFormat, KDeviceType_HardDisk);
     82        QString strExtension = UIDiskFormatsGroupBox::defaultExtension(pWizard->mediumFormat(), KDeviceType_HardDisk);
    21683        QString strSourceDiskPath = QDir::toNativeSeparators(QFileInfo(pWizard->sourceDiskFilePath()).absolutePath());
    21784        /* Disk name without the format extension: */
    … …  
    22996bool UIWizardCloneVDPageBasic3::isComplete() const
    23097{
    231     /* Make sure current name is not empty: */
    232     /*return !m_pDestinationDiskEditor->text().trimmed().isEmpty();*/
    233     return true;
     98    AssertReturn(m_pMediumSizePathGroupBox, false);
     99
     100    return m_pMediumSizePathGroupBox->isComplete();
    234101}
    235102
    236103bool UIWizardCloneVDPageBasic3::validatePage()
    237104{
    238     /* Initial result: */
    239     bool fResult = true;
    240 
    241     // /* Make sure such file doesn't exists already: */
    242     // QString strMediumPath(mediumPath());
    243     // fResult = !QFileInfo(strMediumPath).exists();
    244     // if (!fResult)
    245     //     msgCenter().cannotOverwriteHardDiskStorage(strMediumPath, this);
    246 
    247     // if (fResult)
    248     // {
    249     //     /* Lock finish button: */
    250     //     startProcessing();
    251 
    252     //     /* Try to copy virtual disk image file: */
    253     //     fResult = qobject_cast<UIWizardCloneVD*>(wizard())->copyVirtualDisk();
    254 
    255     //     /* Unlock finish button: */
    256     //     endProcessing();
    257     // }
    258 
    259     /* Return result: */
    260     return fResult;
     105    UIWizardCloneVD *pWizard = cloneWizard();
     106    AssertReturn(pWizard, false);
     107    /* Make sure such file doesn't exists already: */
     108    QString strMediumPath(pWizard->mediumPath());
     109    if (QFileInfo(strMediumPath).exists())
     110    {
     111        msgCenter().cannotOverwriteHardDiskStorage(strMediumPath, this);
     112        return false;
     113    }
     114    return pWizard->copyVirtualDisk();
    261115}
    262116

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

    r90748 r90800  
    1717
    1818/* Qt includes: */
    19 #include <QButtonGroup>
    20 #include <QCheckBox>
    21 #include <QFileInfo>
     19#include <QDir>
    2220#include <QGridLayout>
    23 #include <QGroupBox>
    24 #include <QHBoxLayout>
    25 #include <QLineEdit>
    26 #include <QRadioButton>
    27 #include <QVBoxLayout>
    2821
    2922/* GUI includes: */
    … …  
    3528#include "UIWizardCloneVD.h"
    3629#include "UIWizardCloneVDPageExpert.h"
     30#include "UIWizardDiskEditors.h"
    3731
    3832/* COM includes: */
    … …  
    4034
    4135
    42 UIWizardCloneVDPageExpert::UIWizardCloneVDPageExpert(KDeviceType /*enmDeviceType*/)
     36UIWizardCloneVDPageExpert::UIWizardCloneVDPageExpert(KDeviceType enmDeviceType, qulonglong uSourceDiskLogicaSize)
     37    :m_pFormatGroupBox(0)
     38    , m_pVariantGroupBox(0)
     39    , m_pMediumSizePathGroupBox(0)
     40
    4341{
    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);
     42    prepare(enmDeviceType, uSourceDiskLogicaSize);
    15143}
    15244
    153 void UIWizardCloneVDPageExpert::setTargetLocation()
     45void UIWizardCloneVDPageExpert::prepare(KDeviceType enmDeviceType, qulonglong uSourceDiskLogicaSize)
    15446{
    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);
     47    QGridLayout *pMainLayout = new QGridLayout(this);
    16648
    167     // /* Broadcast complete-change: */
    168     // emit completeChanged();
     49    m_pMediumSizePathGroupBox = new UIMediumSizeAndPathGroupBox(true /* expert mode */, 0 /* parent */, uSourceDiskLogicaSize);
     50
     51    if (m_pMediumSizePathGroupBox)
     52        pMainLayout->addWidget(m_pMediumSizePathGroupBox, 0, 0, 2, 2);
     53
     54    m_pFormatGroupBox = new UIDiskFormatsGroupBox(true /* expert mode */, enmDeviceType, 0);
     55    if (m_pFormatGroupBox)
     56        pMainLayout-> addWidget(m_pFormatGroupBox, 2, 0, 6, 1);
     57
     58    m_pVariantGroupBox = new UIDiskVariantGroupBox(true /* expert mode */, 0);
     59    if (m_pVariantGroupBox)
     60        pMainLayout-> addWidget(m_pVariantGroupBox, 2, 1, 6, 1);
    16961}
     62
    17063
    17164void UIWizardCloneVDPageExpert::sltMediumFormatChanged()
    17265{
    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();
    20166}
    20267
    20368void UIWizardCloneVDPageExpert::sltSelectLocationButtonClicked()
    20469{
    205     /* Call to base-class: */
    206     //onSelectLocationButtonClicked();
     70
    20771}
    20872
    20973void UIWizardCloneVDPageExpert::retranslateUi()
    21074{
    211     /* Translate widgets: */
    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"));
     75
    22676}
    22777
    22878void UIWizardCloneVDPageExpert::initializePage()
    22979{
     80    AssertReturnVoid(cloneWizard() && m_pMediumSizePathGroupBox && m_pFormatGroupBox && m_pVariantGroupBox);
     81    UIWizardCloneVD *pWizard = cloneWizard();
     82
     83    pWizard->setMediumFormat(m_pFormatGroupBox->mediumFormat());
     84
     85    pWizard->setMediumVariant(m_pVariantGroupBox->mediumVariant());
     86    m_pVariantGroupBox->setWidgetVisibility(pWizard->mediumFormat());
     87
     88    /* Initialize medium size widget and wizard's medium size parameter: */
     89    m_pMediumSizePathGroupBox->blockSignals(true);
     90    m_pMediumSizePathGroupBox->setMediumSize(pWizard->sourceDiskLogicalSize());
     91    pWizard->setMediumSize(m_pMediumSizePathGroupBox->mediumSize());
     92    QString strExtension = UIDiskFormatsGroupBox::defaultExtension(pWizard->mediumFormat(), KDeviceType_HardDisk);
     93    QString strSourceDiskPath = QDir::toNativeSeparators(QFileInfo(pWizard->sourceDiskFilePath()).absolutePath());
     94    /* Disk name without the format extension: */
     95    QString strDiskName = QString("%1_%2").arg(QFileInfo(pWizard->sourceDiskName()).completeBaseName()).arg(tr("copy"));
     96    QString strMediumFilePath =
     97        UIDiskEditorGroupBox::constructMediumFilePath(UIDiskVariantGroupBox::appendExtension(strDiskName,
     98                                                                                             strExtension), strSourceDiskPath);
     99    m_pMediumSizePathGroupBox->setMediumPath(strMediumFilePath);
     100    pWizard->setMediumPath(strMediumFilePath);
     101    m_pMediumSizePathGroupBox->blockSignals(false);
     102
    230103    /* Translate page: */
    231104    retranslateUi();
    232 
    233     setTargetLocation();
    234     sltMediumFormatChanged();
    235105}
    236106
    237107bool UIWizardCloneVDPageExpert::isComplete() const
    238108{
    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;
     109    bool fResult = true;
     110
     111    if (m_pFormatGroupBox)
     112        fResult = m_pFormatGroupBox->mediumFormat().isNull();
     113    if (m_pVariantGroupBox)
     114        fResult = m_pVariantGroupBox->isComplete();
     115    if (m_pMediumSizePathGroupBox)
     116        fResult =  m_pMediumSizePathGroupBox->isComplete();
     117
     118    return fResult;
    250119}
    251120
    252121bool UIWizardCloneVDPageExpert::validatePage()
    253122{
    254     /* Initial result: */
    255     bool fResult = true;
     123    UIWizardCloneVD *pWizard = cloneWizard();
     124    AssertReturn(pWizard, false);
    256125
    257     // /* Lock finish button: */
    258     // startProcessing();
     126    QString strMediumPath(pWizard->mediumPath());
    259127
    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);
     128    if (QFileInfo(strMediumPath).exists())
     129    {
     130        msgCenter().cannotOverwriteHardDiskStorage(strMediumPath, this);
     131        return false;
     132    }
     133    return pWizard->copyVirtualDisk();
     134}
    265135
    266     // /* Try to copy virtual-disk: */
    267     // if (fResult)
    268     //     fResult = qobject_cast<UIWizardCloneVD*>(wizard())->copyVirtualDisk();
    269 
    270     // /* Unlock finish button: */
    271     // endProcessing();
    272 
    273     /* Return result: */
    274     return fResult;
     136UIWizardCloneVD *UIWizardCloneVDPageExpert::cloneWizard()
     137{
     138    return qobject_cast<UIWizardCloneVD*>(wizard());
    275139}

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

    r90748 r90800  
    2727
    2828/* Forward declarations: */
    29 class QGroupBox;
     29class UIDiskFormatsGroupBox;
     30class UIDiskVariantGroupBox;
     31class UIMediumSizeAndPathGroupBox;
    3032
    3133
    … …  
    4042      * @param  comSourceVirtualDisk  Brings the initial source disk to make copy from.
    4143      * @param  enmDeviceType         Brings the device type to limit format to. */
    42     UIWizardCloneVDPageExpert(KDeviceType enmDeviceType);
     44    UIWizardCloneVDPageExpert(KDeviceType enmDeviceType, qulonglong uSourceDiskLogicaSize);
    4345
    4446private slots:
    … …  
    6466    virtual bool validatePage() /* override */;
    6567
     68    void prepare(KDeviceType enmDeviceType, qulonglong uSourceDiskLogicaSize);
     69
    6670    /** Sets the target disk name and location. */
    6771    void setTargetLocation();
     72    UIWizardCloneVD *cloneWizard();
    6873
    69     /** Holds the format container instance. */
    70     QGroupBox *m_pFormatCnt;
    71     /** Holds the variant container instance. */
    72     QGroupBox *m_pVariantCnt;
    73     /** Holds the target disk container instance. */
    74     QGroupBox *m_pDestinationCnt;
     74
     75
     76    UIDiskFormatsGroupBox *m_pFormatGroupBox;
     77    UIDiskVariantGroupBox *m_pVariantGroupBox;
     78    UIMediumSizeAndPathGroupBox *m_pMediumSizePathGroupBox;
     79
     80
    7581};
    7682

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

    r90762 r90800  
    114114
    115115/* static */
    116 QString UIDiskEditorGroupBox::openFileDialogForDiskFile(const QString &strInitialPath, CMediumFormat &comMediumFormat,
     116QString UIDiskEditorGroupBox::openFileDialogForDiskFile(const QString &strInitialPath, const CMediumFormat &comMediumFormat,
    117117                                                        KDeviceType enmDeviceType, QWidget *pParent)
    118118{
    … …  
    386386}
    387387
    388 void UIDiskVariantGroupBox::setWidgetVisibility(CMediumFormat &mediumFormat)
     388void UIDiskVariantGroupBox::setWidgetVisibility(const CMediumFormat &mediumFormat)
    389389{
    390390    ULONG uCapabilities = 0;
    … …  
    413413        m_pFixedCheckBox->setHidden(!m_fIsCreateFixedPossible);
    414414    if (m_pSplitBox)
     415    {
    415416        m_pSplitBox->setHidden(!m_fIsCreateSplitPossible);
     417        if (!m_fIsCreateSplitPossible)
     418            m_pSplitBox->setChecked(false);
     419    }
    416420}
    417421
    … …  
    490494{
    491495    prepare(uMinimumMediumSize);
     496}
     497
     498bool UIMediumSizeAndPathGroupBox::isComplete() const
     499{
     500    if (QFileInfo(mediumPath()).exists())
     501    {
     502        m_pLocationEditor->mark(true, tr("Disk file name is not unique"));
     503        return false;
     504    }
     505    m_pLocationEditor->mark(false);
     506    return true;
    492507}
    493508

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

    r90762 r90800  
    6262    static QString constructMediumFilePath(const QString &strFileName, const QString &strPath);
    6363    static bool checkFATSizeLimitation(const qulonglong uVariant, const QString &strMediumPath, const qulonglong uSize);
    64     static QString openFileDialogForDiskFile(const QString &strInitialPath, CMediumFormat &comMediumFormat,
     64    static QString openFileDialogForDiskFile(const QString &strInitialPath, const CMediumFormat &comMediumFormat,
    6565                                             KDeviceType enmDeviceType, QWidget *pParent);
    6666
    … …  
    115115    qulonglong mediumVariant() const;
    116116    void setMediumVariant(qulonglong uMediumVariant);
    117     void setWidgetVisibility(CMediumFormat &mediumFormat);
     117    void setWidgetVisibility(const CMediumFormat &mediumFormat);
    118118    bool isComplete() const;
    119119
    … …  
    159159    void setMediumSize(qulonglong uSize);
    160160
     161    bool isComplete() const;
     162
    161163private:
    162164

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

    r90763 r90800  
    6464    UIWizardNewVD *pWizard = qobject_cast<UIWizardNewVD*>(wizard());
    6565    AssertReturnVoid(pWizard);
    66     CMediumFormat comMediumFormat(pWizard->mediumFormat());
    6766    QString strSelectedPath =
    68         UIDiskEditorGroupBox::openFileDialogForDiskFile(pWizard->mediumPath(), comMediumFormat,
     67        UIDiskEditorGroupBox::openFileDialogForDiskFile(pWizard->mediumPath(), pWizard->mediumFormat(),
    6968                                                                KDeviceType_HardDisk, pWizard);
    7069
    … …  
    109108    if (!m_userModifiedParameters.contains("MediumPath"))
    110109    {
    111         const CMediumFormat comMediumFormat = pWizard->mediumFormat();
    112         AssertReturnVoid(!comMediumFormat.isNull());
    113         QString strExtension = UIDiskFormatsGroupBox::defaultExtension(comMediumFormat, KDeviceType_HardDisk);
     110        QString strExtension = UIDiskFormatsGroupBox::defaultExtension(pWizard->mediumFormat(), KDeviceType_HardDisk);
    114111        QString strMediumFilePath =
    115112            UIDiskEditorGroupBox::constructMediumFilePath(UIDiskVariantGroupBox::appendExtension(m_strDefaultName,
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