VirtualBox

Ignore:
Timestamp:
Jul 5, 2021 7:35:04 AM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
145507
Message:

FE/Qt: bugref:9996: Some more cleaning and refactoring

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

Legend:

Unmodified
Added
Removed

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

    r90009 r90018  
    519519}
    520520
    521 QString UIWizardNewVM::getStringFieldValue(const QString &strFieldName) const
    522 {
    523     Q_UNUSED(strFieldName);
    524     // QVariant fieldValue = field(strFieldName);
    525     // if (!fieldValue.isNull() && fieldValue.isValid() && fieldValue.canConvert(QMetaType::QString))
    526     //     return fieldValue.toString();
    527     return QString();
    528 }
    529 
    530 bool UIWizardNewVM::getBoolFieldValue(const QString &strFieldName) const
    531 {
    532     Q_UNUSED(strFieldName);
    533     // QVariant fieldValue = field(strFieldName);
    534     // if (!fieldValue.isNull() && fieldValue.isValid() && fieldValue.canConvert(QMetaType::Bool))
    535     //     return fieldValue.toBool();
    536     return false;
    537 }
    538 
    539521void UIWizardNewVM::sltHandleWizardCancel()
    540522{
    541     // switch (mode())
    542     // {
    543     //     case WizardMode_Basic:
    544     //     {
    545     //         UIWizardNewVMPageNameOSType *pPage = qobject_cast<UIWizardNewVMPageNameOSType*> (page(Page1));
    546     //         /* Make sure that we were able to find the page that created the folder. */
    547     //         Assert(pPage);
    548     //         if (pPage)
    549     //             pPage->cleanupMachineFolder(true);
    550     //         break;
    551     //     }
    552     //     case WizardMode_Expert:
    553     //     {
    554     //         UIWizardNewVMPageExpert *pPage = qobject_cast<UIWizardNewVMPageExpert*> (page(PageExpert));
    555     //         if (pPage)
    556     //             pPage->cleanupMachineFolder(true);
    557     //         break;
    558     //     }
    559     //     default:
    560     //         break;
    561     // }
    562 }
    563 
    564 void UIWizardNewVM::sltHandleDetectedOSTypeChange()
    565 {
    566     // UIWizardNewVMPageNameOSType *pPage = qobject_cast<UIWizardNewVMPageNameOSType*>(page(Page1));
    567     // if (!pPage)
    568     //     return;
    569     // pPage->setTypeByISODetectedOSType(getStringFieldValue("detectedOSTypeId"));
    570 }
     523    UIWizardNewVMNameOSTypePage::cleanupMachineFolder(this, true);
     524}
     525
     526// void UIWizardNewVM::sltHandleDetectedOSTypeChange()
     527// {
     528//     // UIWizardNewVMPageNameOSType *pPage = qobject_cast<UIWizardNewVMPageNameOSType*>(page(Page1));
     529//     // if (!pPage)
     530//     //     return;
     531//     // pPage->setTypeByISODetectedOSType(getStringFieldValue("detectedOSTypeId"));
     532// }
    571533
    572534void UIWizardNewVM::sltCustomButtonClicked(int iId)
    … …  
    669631QString UIWizardNewVM::ISOFilePath() const
    670632{
    671     QString strPath = getStringFieldValue("ISOFilePath");
    672     if (strPath.isNull() || strPath.isEmpty())
    673         return QString();
    674     QFileInfo isoFileInfo(strPath);
    675     if (isoFileInfo.exists() && isoFileInfo.isReadable())
    676         return strPath;
     633    // QString strPath = getStringFieldValue("ISOFilePath");
     634    // if (strPath.isNull() || strPath.isEmpty())
     635    //     return QString();
     636    // QFileInfo isoFileInfo(strPath);
     637    // if (isoFileInfo.exists() && isoFileInfo.isReadable())
     638    //     return strPath;
    677639    return QString();
    678640}
    … …  
    732694}
    733695
     696const QString &UIWizardNewVM::createdMachineFolder() const
     697{
     698    return m_strCreatedFolder;
     699}
     700
     701void UIWizardNewVM::setCreatedMachineFolder(const QString &strCreatedMachineFolder)
     702{
     703    m_strCreatedFolder = strCreatedMachineFolder;
     704}
     705
    734706const QString &UIWizardNewVM::detectedOSTypeId() const
    735707{
    … …  
    744716const UIUnattendedInstallData &UIWizardNewVM::unattendedInstallData() const
    745717{
    746     m_unattendedInstallData.m_strISOPath = getStringFieldValue("ISOFilePath");
    747     m_unattendedInstallData.m_strUserName = getStringFieldValue("userName");
    748     m_unattendedInstallData.m_strHostname = getStringFieldValue("hostname");
    749     m_unattendedInstallData.m_strPassword = getStringFieldValue("password");
    750     m_unattendedInstallData.m_strDetectedOSTypeId = getStringFieldValue("detectedOSTypeId");
    751     // m_unattendedInstallData.m_strDetectedOSVersion = getStringFieldValue("detectedOSVersion");
    752     // m_unattendedInstallData.m_strDetectedOSFlavor = getStringFieldValue("detectedOSFlavor");
    753     // m_unattendedInstallData.m_strDetectedOSLanguages = getStringFieldValue("detectedOSLanguages");
    754     // m_unattendedInstallData.m_strDetectedOSHints = getStringFieldValue("detectedOSHints");
    755     m_unattendedInstallData.m_strProductKey = getStringFieldValue("productKey");
    756     m_unattendedInstallData.m_strGuestAdditionsISOPath = getStringFieldValue("guestAdditionsISOPath");
    757 
    758     m_unattendedInstallData.m_fUnattendedEnabled = getBoolFieldValue("isUnattendedEnabled");
    759     m_unattendedInstallData.m_fStartHeadless = getBoolFieldValue("startHeadless");
    760     m_unattendedInstallData.m_fInstallGuestAdditions = getBoolFieldValue("installGuestAdditions");
    761 
    762     m_unattendedInstallData.m_uMachineUid = createdMachineId();
     718    // m_unattendedInstallData.m_strISOPath = getStringFieldValue("ISOFilePath");
     719    // m_unattendedInstallData.m_strUserName = getStringFieldValue("userName");
     720    // m_unattendedInstallData.m_strHostname = getStringFieldValue("hostname");
     721    // m_unattendedInstallData.m_strPassword = getStringFieldValue("password");
     722    // m_unattendedInstallData.m_strDetectedOSTypeId = getStringFieldValue("detectedOSTypeId");
     723    // // m_unattendedInstallData.m_strDetectedOSVersion = getStringFieldValue("detectedOSVersion");
     724    // // m_unattendedInstallData.m_strDetectedOSFlavor = getStringFieldValue("detectedOSFlavor");
     725    // // m_unattendedInstallData.m_strDetectedOSLanguages = getStringFieldValue("detectedOSLanguages");
     726    // // m_unattendedInstallData.m_strDetectedOSHints = getStringFieldValue("detectedOSHints");
     727    // m_unattendedInstallData.m_strProductKey = getStringFieldValue("productKey");
     728    // m_unattendedInstallData.m_strGuestAdditionsISOPath = getStringFieldValue("guestAdditionsISOPath");
     729
     730    // m_unattendedInstallData.m_fUnattendedEnabled = getBoolFieldValue("isUnattendedEnabled");
     731    // m_unattendedInstallData.m_fStartHeadless = getBoolFieldValue("startHeadless");
     732    // m_unattendedInstallData.m_fInstallGuestAdditions = getBoolFieldValue("installGuestAdditions");
     733
     734    // m_unattendedInstallData.m_uMachineUid = createdMachineId();
    763735
    764736    return m_unattendedInstallData;
    … …  
    774746}
    775747
    776 bool UIWizardNewVM::isGuestOSTypeWindows() const
    777 {
    778     return getStringFieldValue("guestOSFamiyId").contains("windows", Qt::CaseInsensitive);
    779 }
     748// bool UIWizardNewVM::isGuestOSTypeWindows() const
     749// {
     750//     return getStringFieldValue("guestOSFamiyId").contains("windows", Qt::CaseInsensitive);
     751// }

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

    r90009 r90018  
    8383    const UIUnattendedInstallData &unattendedInstallData() const;
    8484    bool isUnattendedEnabled() const;
    85     bool isGuestOSTypeWindows() const;
     85    //bool isGuestOSTypeWindows() const;
    8686    CMedium &virtualDisk();
    8787    void setVirtualDisk(const CMedium &medium);
    … …  
    9898    const QString &machineBaseName() const;
    9999    void setMachineBaseName(const QString &strMachineBaseName);
     100
     101    const QString &createdMachineFolder() const;
     102    void setCreatedMachineFolder(const QString &strCreatedMachineFolder);
    100103
    101104    const QString &detectedOSTypeId() const;
    … …  
    114117    bool attachDefaultDevices(const CGuestOSType &comGuestType);
    115118
    116     QString getStringFieldValue(const QString &strFieldName) const;
    117     bool getBoolFieldValue(const QString &strFieldName) const;
    118 
    119119    friend class UIWizardNewVMPageDisk;
    120120    friend class UIWizardNewVMPageExpert;
    … …  
    123123
    124124    void sltHandleWizardCancel();
    125     void sltHandleDetectedOSTypeChange();
     125    //void sltHandleDetectedOSTypeChange();
    126126    virtual void sltCustomButtonClicked(int iId) /* override */;
    127127

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

    r90009 r90018  
    199199
    200200void UIWizardNewVMNameOSTypePage::composeMachineFilePath(UINameAndSystemEditor *pNameAndSystemEditor,
    201                                                          UINativeWizard *pWizard)
    202 {
    203     UIWizardNewVM *pNewVMWizard = qobject_cast<UIWizardNewVM*>(pWizard);
    204     if (!pNameAndSystemEditor || !pNewVMWizard)
     201                                                         UIWizardNewVM *pWizard)
     202{
     203    if (!pNameAndSystemEditor || !pWizard)
    205204        return;
    206205    if (pNameAndSystemEditor->name().isEmpty() || pNameAndSystemEditor->path().isEmpty())
    … …  
    210209
    211210    /* Compose machine filename: */
    212     pNewVMWizard->setMachineFilePath(vbox.ComposeMachineFilename(pNameAndSystemEditor->name(),
    213                                                                  pNewVMWizard->machineGroup(),
     211    pWizard->setMachineFilePath(vbox.ComposeMachineFilename(pNameAndSystemEditor->name(),
     212                                                                 pWizard->machineGroup(),
    214213                                                                 QString(),
    215214                                                                 pNameAndSystemEditor->path()));
    216215    /* Compose machine folder/basename: */
    217     const QFileInfo fileInfo(pNewVMWizard->machineFilePath());
    218     pNewVMWizard->setMachineFolder(fileInfo.absolutePath());
    219     pNewVMWizard->setMachineBaseName(fileInfo.completeBaseName());
     216    const QFileInfo fileInfo(pWizard->machineFilePath());
     217    pWizard->setMachineFolder(fileInfo.absolutePath());
     218    pWizard->setMachineBaseName(fileInfo.completeBaseName());
    220219}
    221220
    222221bool UIWizardNewVMNameOSTypePage::createMachineFolder(UINameAndSystemEditor *pNameAndSystemEditor,
    223222                                                      UINativeWizardPage *pCaller,
    224                                                       const QString &strMachineFolder,
    225                                                       QString &strCreatedFolder)
    226 {
    227     if (!pNameAndSystemEditor)
    228         return false;
     223                                                      UIWizardNewVM *pWizard)
     224{
     225    if (!pNameAndSystemEditor || !pWizard)
     226        return false;
     227    const QString &strMachineFolder = pWizard->machineFolder();
     228    const QString &strCreatedFolder = pWizard->createdMachineFolder();
     229
    229230    /* Cleanup previosly created folder if any: */
    230     if (!cleanupMachineFolder(strMachineFolder, strCreatedFolder))
     231    if (!cleanupMachineFolder(pWizard))
    231232    {
    232233        msgCenter().cannotRemoveMachineFolder(strMachineFolder, pCaller);
    … …  
    255256        return false;
    256257    }
    257     strCreatedFolder = strMachineFolder;
     258    pWizard->setCreatedMachineFolder(strMachineFolder);
    258259    return true;
    259260}
    260261
    261 bool UIWizardNewVMNameOSTypePage::cleanupMachineFolder(const QString &strMachineFolder,
    262                                                        QString &strCreatedFolder, bool fWizardCancel /* = false */)
    263 {
     262bool UIWizardNewVMNameOSTypePage::cleanupMachineFolder(UIWizardNewVM *pWizard, bool fWizardCancel /* = false */)
     263{
     264    if (!pWizard)
     265        return false;
     266    const QString &strMachineFolder = pWizard->machineFolder();
     267    const QString &strCreatedFolder = pWizard->createdMachineFolder();
    264268    /* Make sure folder was previosly created: */
    265269    if (strCreatedFolder.isEmpty())
    … …  
    272276        /* Reset machine folder value: */
    273277        if (fMachineFolderRemoved)
    274             strCreatedFolder = QString();
     278            pWizard->setCreatedMachineFolder(QString());
    275279        /* Return cleanup result: */
    276280        return fMachineFolderRemoved;
    … …  
    278282    return true;
    279283}
    280 
    281 // QString UIWizardNewVMNameOSTypePage::machineFilePath() const
    282 // {
    283 //     return m_strMachineFilePath;
    284 // }
    285 
    286 // void UIWizardNewVMNameOSTypePage::setMachineFilePath(const QString &strMachineFilePath)
    287 // {
    288 //     m_strMachineFilePath = strMachineFilePath;
    289 // }
    290 
    291 // QString UIWizardNewVMNameOSTypePage::machineFolder() const
    292 // {
    293 //     return m_strMachineFolder;
    294 // }
    295 
    296 // void UIWizardNewVMNameOSTypePage::setMachineFolder(const QString &strMachineFolder)
    297 // {
    298 //     m_strMachineFolder = strMachineFolder;
    299 // }
    300284
    301285// QString UIWizardNewVMNameOSTypePage::machineBaseName() const
    … …  
    316300// }
    317301
    318 // void UIWizardNewVMNameOSTypePage::markWidgets() const
    319 // {
    320 //     if (m_pNameAndSystemEditor)
    321 //     {
    322 //         m_pNameAndSystemEditor->markNameEditor(m_pNameAndSystemEditor->name().isEmpty());
    323 //         m_pNameAndSystemEditor->markImageEditor(!checkISOFile(), UIWizardNewVM::tr("Invalid file path or unreadable file"));
    324 //     }
    325 // }
    326 
    327302
    328303// QString UIWizardNewVMNameOSTypePage::ISOFilePath() const
    … …  
    333308// }
    334309
    335 // bool UIWizardNewVMNameOSTypePage::isUnattendedEnabled() const
    336 // {
    337 //     if (!m_pNameAndSystemEditor)
    338 //         return false;
    339 //     const QString &strPath = m_pNameAndSystemEditor->image();
    340 //     if (strPath.isNull() || strPath.isEmpty())
    341 //         return false;
    342 //     if (m_pSkipUnattendedCheckBox && m_pSkipUnattendedCheckBox->isChecked())
    343 //         return false;
    344 //     return true;
    345 // }
    346 
    347 // const QString &UIWizardNewVMNameOSTypePage::detectedOSTypeId() const
    348 // {
    349 //     return m_strDetectedOSTypeId;
    350 // }
    351 
    352 void UIWizardNewVMNameOSTypePage::determineOSType(const QString &strISOPath, UINativeWizard *pWizard)
    353 {
    354     UIWizardNewVM *pNewVMWizard = qobject_cast<UIWizardNewVM*>(pWizard);
    355     if (!pNewVMWizard)
     310
     311void UIWizardNewVMNameOSTypePage::determineOSType(const QString &strISOPath, UIWizardNewVM *pWizard)
     312{
     313    if (!pWizard)
    356314        return;
    357315
    … …  
    359317    if (!isoFileInfo.exists())
    360318    {
    361         pNewVMWizard->setDetectedOSTypeId(QString());
     319        pWizard->setDetectedOSTypeId(QString());
    362320        return;
    363321    }
    … …  
    366324    comUnatteded.SetIsoPath(strISOPath);
    367325    comUnatteded.DetectIsoOS();
    368     pNewVMWizard->setDetectedOSTypeId(comUnatteded.GetDetectedOSTypeId());
     326    pWizard->setDetectedOSTypeId(comUnatteded.GetDetectedOSTypeId());
    369327}
    370328
    … …  
    374332// }
    375333
    376 // bool UIWizardNewVMNameOSTypePage::checkISOFile() const
    377 // {
    378 //     if (!m_pNameAndSystemEditor)
    379 //         return true;
    380 //     const QString &strPath = m_pNameAndSystemEditor->image();
    381 //     if (strPath.isNull() || strPath.isEmpty())
    382 //         return true;
    383 //     QFileInfo fileInfo(strPath);
    384 //     if (!fileInfo.exists() || !fileInfo.isReadable())
    385 //         return false;
    386 //     return true;
    387 // }
    388 
    389 // void UIWizardNewVMNameOSTypePage::setSkipCheckBoxEnable()
    390 // {
    391 //     if (!m_pSkipUnattendedCheckBox)
    392 //         return;
    393 //     if (m_pNameAndSystemEditor)
    394 //     {
    395 //         const QString &strPath = m_pNameAndSystemEditor->image();
    396 //         m_pSkipUnattendedCheckBox->setEnabled(!strPath.isNull() && !strPath.isEmpty());
    397 //     }
    398 // }
    399 
    400 // void UIWizardNewVMNameOSTypePage::setTypeByISODetectedOSType(const QString &strDetectedOSType)
    401 // {
    402 //     Q_UNUSED(strDetectedOSType);
    403 //     if (!strDetectedOSType.isEmpty())
    404 //         onNameChanged(strDetectedOSType);
    405 // }
    406 
     334bool UIWizardNewVMNameOSTypePage::checkISOFile(UINameAndSystemEditor *pNameAndSystemEditor)
     335{
     336    if (!pNameAndSystemEditor)
     337        return false;
     338    const QString &strPath = pNameAndSystemEditor->image();
     339    if (strPath.isNull() || strPath.isEmpty())
     340        return true;
     341    QFileInfo fileInfo(strPath);
     342    if (!fileInfo.exists() || !fileInfo.isReadable())
     343        return false;
     344    return true;
     345}
    407346
    408347UIWizardNewVMNameOSTypePageBasic::UIWizardNewVMNameOSTypePageBasic()
    … …  
    412351    , m_pNameOSTypeLabel(0)
    413352{
     353    m_pWizard = qobject_cast<UIWizardNewVM*>(wizard());
    414354    prepare();
    415355}
    … …  
    457397bool UIWizardNewVMNameOSTypePageBasic::isComplete() const
    458398{
    459     // markWidgets();
    460     // if (m_pNameAndSystemEditor->name().isEmpty())
    461     //     return false;
    462     // return checkISOFile();
     399    markWidgets();
     400    if (m_pNameAndSystemEditor->name().isEmpty())
     401        return false;
     402    return UIWizardNewVMNameOSTypePage::checkISOFile(m_pNameAndSystemEditor);
    463403    return true;
    464404}
    … …  
    468408    Q_UNUSED(strNewName);
    469409    UIWizardNewVMNameOSTypePage::onNameChanged(m_pNameAndSystemEditor, strNewName);
    470     UIWizardNewVMNameOSTypePage::composeMachineFilePath(m_pNameAndSystemEditor, wizard());
     410    UIWizardNewVMNameOSTypePage::composeMachineFilePath(m_pNameAndSystemEditor, m_pWizard);
    471411}
    472412
    … …  
    474414{
    475415    Q_UNUSED(strNewPath);
    476     UIWizardNewVMNameOSTypePage::composeMachineFilePath(m_pNameAndSystemEditor, wizard());
     416    UIWizardNewVMNameOSTypePage::composeMachineFilePath(m_pNameAndSystemEditor, m_pWizard);
    477417}
    478418
    … …  
    517457void UIWizardNewVMNameOSTypePageBasic::cleanupPage()
    518458{
    519     /* Cleanup: */
    520459    // cleanupMachineFolder();
    521460    // /* Call to base-class: */
    … …  
    526465{
    527466    /* Try to create machine folder: */
    528     //composeMachineFilePath
    529     //return createMachineFolder();
    530     return true;
     467    return UIWizardNewVMNameOSTypePage::createMachineFolder(m_pNameAndSystemEditor, this, m_pWizard);
    531468}
    532469
    533470void UIWizardNewVMNameOSTypePageBasic::sltISOPathChanged(const QString &strPath)
    534471{
    535     UIWizardNewVMNameOSTypePage::determineOSType(strPath, wizard());
    536     // setTypeByISODetectedOSType(m_strDetectedOSTypeId);
    537     // /* Update the global recent ISO path: */
    538     // QFileInfo fileInfo(strPath);
    539     // if (fileInfo.exists() && fileInfo.isReadable())
    540     //     uiCommon().updateRecentlyUsedMediumListAndFolder(UIMediumDeviceType_DVD, strPath);
     472    UIWizardNewVMNameOSTypePage::determineOSType(strPath, m_pWizard);
     473    if (m_pWizard && !m_pWizard->detectedOSTypeId().isEmpty())
     474        UIWizardNewVMNameOSTypePage::onNameChanged(m_pNameAndSystemEditor, m_pWizard->detectedOSTypeId());
     475    /* Update the global recent ISO path: */
     476    QFileInfo fileInfo(strPath);
     477    if (fileInfo.exists() && fileInfo.isReadable())
     478        uiCommon().updateRecentlyUsedMediumListAndFolder(UIMediumDeviceType_DVD, strPath);
    541479    // setSkipCheckBoxEnable();
    542480    // emit completeChanged();
    … …  
    574512    return pContainerWidget;
    575513}
     514
     515void UIWizardNewVMNameOSTypePageBasic::markWidgets() const
     516{
     517    if (m_pNameAndSystemEditor)
     518    {
     519        m_pNameAndSystemEditor->markNameEditor(m_pNameAndSystemEditor->name().isEmpty());
     520        m_pNameAndSystemEditor->markImageEditor(!UIWizardNewVMNameOSTypePage::checkISOFile(m_pNameAndSystemEditor),
     521                                                UIWizardNewVM::tr("Invalid file path or unreadable file"));
     522    }
     523}
     524
     525void UIWizardNewVMNameOSTypePageBasic::setSkipCheckBoxEnable()
     526{
     527    if (!m_pSkipUnattendedCheckBox)
     528        return;
     529    if (m_pNameAndSystemEditor)
     530    {
     531        const QString &strPath = m_pNameAndSystemEditor->image();
     532        m_pSkipUnattendedCheckBox->setEnabled(!strPath.isNull() && !strPath.isEmpty());
     533    }
     534}
     535
     536bool UIWizardNewVMNameOSTypePageBasic::isUnattendedEnabled() const
     537{
     538    if (!m_pNameAndSystemEditor)
     539        return false;
     540    const QString &strPath = m_pNameAndSystemEditor->image();
     541    if (strPath.isNull() || strPath.isEmpty())
     542        return false;
     543    if (m_pSkipUnattendedCheckBox && m_pSkipUnattendedCheckBox->isChecked())
     544        return false;
     545    return true;
     546}

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

    r90009 r90018  
    3636class UIFilePathSelector;
    3737class UINameAndSystemEditor;
    38 class UINativeWizard;
     38class UIWizardNewVM;
    3939
    4040namespace UIWizardNewVMNameOSTypePage
    … …  
    4343    bool createMachineFolder(UINameAndSystemEditor *pNameAndSystemEditor,
    4444                             UINativeWizardPage *pCaller,
    45                              const QString &strMachineFolder,
    46                              QString &strCreatedFolder);
     45                             UIWizardNewVM *pWizard);
    4746
    4847    /** Removes a previously created folder (if exists) before creating a new one.
    4948     *  used during page cleanup and new folder creation. Called upon page Next/Back and
    5049     *  wizard cancel */
    51     bool cleanupMachineFolder(const QString &strMachineFolder,
    52                               QString &strCreatedFolder,bool fWizardCancel = false);
    53     void composeMachineFilePath(UINameAndSystemEditor *pNameAndSystemEditor, UINativeWizard *pWizard);
    54     void determineOSType(const QString &strISOPath, UINativeWizard *pWizard);
    55 
     50    bool cleanupMachineFolder(UIWizardNewVM *pWizard, bool fWizardCancel = false);
     51    void composeMachineFilePath(UINameAndSystemEditor *pNameAndSystemEditor, UIWizardNewVM *pWizard);
     52    void determineOSType(const QString &strISOPath, UIWizardNewVM *pWizard);
     53    /** Return false if ISO path is not empty but points to an missing or unreadable file. */
     54    bool checkISOFile(UINameAndSystemEditor *pNameAndSystemEditor);
    5655//     /** @name Property getters/setters
    5756//       * @{ */
    58 //         QString machineFilePath() const;
    59 //         void setMachineFilePath(const QString &strMachineFilePath);
    60 
    61 //         QString machineFolder() const;
    62 //         void setMachineFolder(const QString &strMachineFolder);
    63 
    64 //         QString machineBaseName() const;
    65 //         void setMachineBaseName(const QString &strMachineBaseName);
    6657
    6758//         QString guestOSFamiyId() const;
    6859
    69 //         bool isUnattendedEnabled() const;
    7060//         const QString &detectedOSTypeId() const;
    7161
    … …  
    7565
    7666//     /** Colors the widgets red if they cause isComplete to fail. */
    77 //     void markWidgets() const;
    7867//     void retranslateWidgets();
    7968//     QString ISOFilePath() const;
    8069
    81 //     void setTypeByISODetectedOSType(const QString &strDetectedOSType);
    82 //     /** Return false if ISO path is not empty but points to an missing or unreadable file. */
    83 //     bool checkISOFile() const;
    84 //     void setSkipCheckBoxEnable();
    8570
    8671//
    … …  
    129114    void cleanupPage();
    130115    QWidget *createNameOSTypeWidgets();
     116    void markWidgets() const;
     117    void setSkipCheckBoxEnable();
     118    bool isUnattendedEnabled() const;
    131119
     120
     121    UIWizardNewVM *m_pWizard;
    132122
    133123    /** @name Widgets
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