void UIVMInformationDialog::prepareTabWidget()
{
/* Create tab-widget: */
m_pTabWidget = new QITabWidget;
AssertPtrReturnVoid(m_pTabWidget);
{
/* Prepare tab-widget: */
m_pTabWidget->setTabIcon(0, UIIconPool::iconSet(":/session_info_details_16px.png"));
m_pTabWidget->setTabIcon(1, UIIconPool::iconSet(":/session_info_runtime_16px.png"));
/* Create Configuration Details tab: */
UIInformationConfiguration *pInformationConfigurationWidget =
new UIInformationConfiguration(this, m_pMachineWindow->machine(), m_pMachineWindow->console());
if (pInformationConfigurationWidget)
{
m_tabs.insert(0, pInformationConfigurationWidget);
m_pTabWidget->addTab(m_tabs.value(0), QString());
}
/* Create Runtime Information tab: */
UIInformationRuntime *pInformationRuntimeWidget =
new UIInformationRuntime(this, m_pMachineWindow->machine(), m_pMachineWindow->console());
if (pInformationRuntimeWidget)
{
m_tabs.insert(1, pInformationRuntimeWidget);
m_pTabWidget->addTab(m_tabs.value(1), QString());
}
QString strMachineName;
if (m_pMachineWindow && m_pMachineWindow->console().isOk())
{
CMachine comMachine = m_pMachineWindow->console().GetMachine();
if (comMachine.isOk())
strMachineName = comMachine.GetName();
}
UIGuestProcessControlWidget *pGuestProcessControlWidget =
new UIGuestProcessControlWidget(EmbedTo_Dialog, m_pMachineWindow->console().GetGuest(),
this, strMachineName, false /* fShowToolbar */);
if (pGuestProcessControlWidget)
{
m_tabs.insert(2, pGuestProcessControlWidget);
m_pTabWidget->addTab(m_tabs.value(2), QString());
}
/* Set Runtime Information tab as default: */
m_pTabWidget->setCurrentIndex(1);
/* Assign tab-widget page change handler: */
connect(m_pTabWidget, &QITabWidget::currentChanged, this, &UIVMInformationDialog::sltHandlePageChanged);
/* Add tab-widget into main-layout: */
centralWidget()->layout()->addWidget(m_pTabWidget);
}
}
/* static */
bool UIMachine::startMachine(const QString &strID)
{
/* Some restrictions: */
AssertMsgReturn(vboxGlobal().isValid(), ("VBoxGlobal is invalid.."), false);
AssertMsgReturn(!vboxGlobal().virtualMachine(), ("Machine already started.."), false);
/* Restore current snapshot if requested: */
if (vboxGlobal().shouldRestoreCurrentSnapshot())
{
/* Create temporary session: */
CSession session = vboxGlobal().openSession(strID, KLockType_VM);
if (session.isNull())
return false;
/* Which VM we operate on? */
CMachine machine = session.GetMachine();
/* Which snapshot we are restoring? */
CSnapshot snapshot = machine.GetCurrentSnapshot();
/* Prepare restore-snapshot progress: */
CProgress progress = machine.RestoreSnapshot(snapshot);
if (!machine.isOk())
return msgCenter().cannotRestoreSnapshot(machine, snapshot.GetName(), machine.GetName());
/* Show the snapshot-discarding progress: */
msgCenter().showModalProgressDialog(progress, machine.GetName(), ":/progress_snapshot_discard_90px.png");
if (progress.GetResultCode() != 0)
return msgCenter().cannotRestoreSnapshot(progress, snapshot.GetName(), machine.GetName());
/* Unlock session finally: */
session.UnlockMachine();
/* Clear snapshot-restoring request: */
vboxGlobal().setShouldRestoreCurrentSnapshot(false);
}
/* For separate process we should launch VM before UI: */
if (vboxGlobal().isSeparateProcess())
{
/* Get corresponding machine: */
CMachine machine = vboxGlobal().virtualBox().FindMachine(vboxGlobal().managedVMUuid());
AssertMsgReturn(!machine.isNull(), ("VBoxGlobal::managedVMUuid() should have filter that case before!\n"), false);
/* Try to launch corresponding machine: */
if (!vboxGlobal().launchMachine(machine, VBoxGlobal::LaunchMode_Separate))
return false;
}
/* Try to create machine UI: */
return create();
}
void UIMachineWindow::closeEvent(QCloseEvent *pCloseEvent)
{
/* Always ignore close-event first: */
pCloseEvent->ignore();
/* Make sure machine is in one of the allowed states: */
if (!uisession()->isRunning() && !uisession()->isPaused() && !uisession()->isStuck())
return;
/* If there is a close hook script defined: */
const QString strScript = gEDataManager->machineCloseHookScript(vboxGlobal().managedVMUuid());
if (!strScript.isEmpty())
{
/* Execute asynchronously and leave: */
QProcess::startDetached(strScript, QStringList() << machine().GetId());
return;
}
/* Choose the close action: */
MachineCloseAction closeAction = MachineCloseAction_Invalid;
/* If default close-action defined and not restricted: */
MachineCloseAction defaultCloseAction = uisession()->defaultCloseAction();
MachineCloseAction restrictedCloseActions = uisession()->restrictedCloseActions();
if ((defaultCloseAction != MachineCloseAction_Invalid) &&
!(restrictedCloseActions & defaultCloseAction))
{
switch (defaultCloseAction)
{
/* If VM is stuck, and the default close-action is 'detach', 'save-state' or 'shutdown',
* we should ask the user about what to do: */
case MachineCloseAction_Detach:
case MachineCloseAction_SaveState:
case MachineCloseAction_Shutdown:
closeAction = uisession()->isStuck() ? MachineCloseAction_Invalid : defaultCloseAction;
break;
/* Otherwise we just use what we have: */
default:
closeAction = defaultCloseAction;
break;
}
}
/* If the close-action still undefined: */
if (closeAction == MachineCloseAction_Invalid)
{
/* Prepare close-dialog: */
QWidget *pParentDlg = windowManager().realParentWindow(this);
QPointer<UIVMCloseDialog> pCloseDlg = new UIVMCloseDialog(pParentDlg, machine(),
console().GetGuestEnteredACPIMode(),
restrictedCloseActions);
/* Make sure close-dialog is valid: */
if (pCloseDlg->isValid())
{
/* We are going to show close-dialog: */
bool fShowCloseDialog = true;
/* Check if VM is paused or stuck: */
const bool fWasPaused = uisession()->isPaused();
const bool fIsStuck = uisession()->isStuck();
/* If VM is NOT paused and NOT stuck: */
if (!fWasPaused && !fIsStuck)
{
/* We should pause it first: */
const bool fIsPaused = uisession()->pause();
/* If we were unable to pause VM: */
if (!fIsPaused)
{
/* If that is NOT the separate VM process UI: */
if (!vboxGlobal().isSeparateProcess())
{
/* We are not going to show close-dialog: */
fShowCloseDialog = false;
}
/* If that is the separate VM process UI: */
else
{
/* We are going to show close-dialog only
* if headless frontend stopped/killed already: */
CMachine machine = uisession()->machine();
KMachineState machineState = machine.GetState();
fShowCloseDialog = !machine.isOk() || machineState == KMachineState_Null;
}
}
}
/* If we are going to show close-dialog: */
if (fShowCloseDialog)
{
/* Show close-dialog to let the user make the choice: */
windowManager().registerNewParent(pCloseDlg, pParentDlg);
closeAction = static_cast<MachineCloseAction>(pCloseDlg->exec());
/* Make sure the dialog still valid: */
if (!pCloseDlg)
return;
/* If VM was not paused before but paused now,
* we should resume it if user canceled dialog or chosen shutdown: */
if (!fWasPaused && uisession()->isPaused() &&
(closeAction == MachineCloseAction_Invalid ||
closeAction == MachineCloseAction_Detach ||
closeAction == MachineCloseAction_Shutdown))
{
/* If we unable to resume VM, cancel closing: */
if (!uisession()->unpause())
closeAction = MachineCloseAction_Invalid;
}
}
}
else
{
/* Else user misconfigured .vbox file, we will reject closing UI: */
closeAction = MachineCloseAction_Invalid;
}
/* Cleanup close-dialog: */
delete pCloseDlg;
}
/* Depending on chosen result: */
switch (closeAction)
{
case MachineCloseAction_Detach:
{
/* Just close Runtime UI: */
LogRel(("GUI: Request for close-action to detach GUI.\n"));
machineLogic()->detach();
break;
}
case MachineCloseAction_SaveState:
{
/* Save VM state: */
LogRel(("GUI: Request for close-action to save VM state.\n"));
machineLogic()->saveState();
break;
}
case MachineCloseAction_Shutdown:
{
/* Shutdown VM: */
LogRel(("GUI: Request for close-action to shutdown VM.\n"));
machineLogic()->shutdown();
break;
}
case MachineCloseAction_PowerOff:
case MachineCloseAction_PowerOff_RestoringSnapshot:
{
/* Power VM off: */
LogRel(("GUI: Request for close-action to power VM off.\n"));
machineLogic()->powerOff(closeAction == MachineCloseAction_PowerOff_RestoringSnapshot);
break;
}
default:
break;
}
}
bool UIWizardNewVM::createVM()
{
/* Get VBox object: */
CVirtualBox vbox = vboxGlobal().virtualBox();
/* OS type: */
CGuestOSType type = field("type").value<CGuestOSType>();
QString strTypeId = type.GetId();
/* Create virtual machine: */
if (m_machine.isNull())
{
QVector<QString> groups;
if (!m_strGroup.isEmpty())
groups << m_strGroup;
m_machine = vbox.CreateMachine(field("machineFilePath").toString(),
field("machineBaseName").toString(),
groups, strTypeId, QString());
if (!vbox.isOk())
{
msgCenter().cannotCreateMachine(vbox, this);
return false;
}
/* The First RUN Wizard is to be shown:
* 1. if we don't attach any virtual hard-drive
* 2. or attach a new (empty) one.
* Usually we are assigning extra-data values through UIExtraDataManager,
* but in that special case VM was not registered yet, so UIExtraDataManager is unaware of it. */
if (field("virtualDiskId").toString().isNull() || !field("virtualDisk").value<CMedium>().isNull())
m_machine.SetExtraData(GUI_FirstRun, "yes");
}
/* RAM size: */
m_machine.SetMemorySize(field("ram").toInt());
/* VRAM size - select maximum between recommended and minimum for fullscreen: */
m_machine.SetVRAMSize(qMax(type.GetRecommendedVRAM(), (ULONG)(VBoxGlobal::requiredVideoMemory(strTypeId) / _1M)));
/* Selecting recommended chipset type: */
m_machine.SetChipsetType(type.GetRecommendedChipset());
/* Selecting recommended Audio Controller: */
m_machine.GetAudioAdapter().SetAudioController(type.GetRecommendedAudioController());
/* And the Audio Codec: */
m_machine.GetAudioAdapter().SetAudioCodec(type.GetRecommendedAudioCodec());
/* Enabling audio by default: */
m_machine.GetAudioAdapter().SetEnabled(true);
/* Enable the OHCI and EHCI controller by default for new VMs. (new in 2.2): */
CUSBDeviceFilters usbDeviceFilters = m_machine.GetUSBDeviceFilters();
bool fOhciEnabled = false;
if (!usbDeviceFilters.isNull() && type.GetRecommendedUSB3() && m_machine.GetUSBProxyAvailable())
{
/* USB 3.0 is only available if the proper ExtPack is installed. */
CExtPackManager manager = vboxGlobal().virtualBox().GetExtensionPackManager();
if (manager.IsExtPackUsable(GUI_ExtPackName))
{
m_machine.AddUSBController("XHCI", KUSBControllerType_XHCI);
/* xHci includes OHCI */
fOhciEnabled = true;
}
}
if ( !fOhciEnabled
&& !usbDeviceFilters.isNull() && type.GetRecommendedUSB() && m_machine.GetUSBProxyAvailable())
{
m_machine.AddUSBController("OHCI", KUSBControllerType_OHCI);
fOhciEnabled = true;
/* USB 2.0 is only available if the proper ExtPack is installed.
* Note. Configuring EHCI here and providing messages about
* the missing extpack isn't exactly clean, but it is a
* necessary evil to patch over legacy compatability issues
* introduced by the new distribution model. */
CExtPackManager manager = vboxGlobal().virtualBox().GetExtensionPackManager();
if (manager.IsExtPackUsable(GUI_ExtPackName))
m_machine.AddUSBController("EHCI", KUSBControllerType_EHCI);
}
/* Create a floppy controller if recommended: */
QString strFloppyName = getNextControllerName(KStorageBus_Floppy);
if (type.GetRecommendedFloppy())
{
m_machine.AddStorageController(strFloppyName, KStorageBus_Floppy);
CStorageController flpCtr = m_machine.GetStorageControllerByName(strFloppyName);
flpCtr.SetControllerType(KStorageControllerType_I82078);
}
/* Create recommended DVD storage controller: */
KStorageBus strDVDBus = type.GetRecommendedDVDStorageBus();
QString strDVDName = getNextControllerName(strDVDBus);
m_machine.AddStorageController(strDVDName, strDVDBus);
/* Set recommended DVD storage controller type: */
CStorageController dvdCtr = m_machine.GetStorageControllerByName(strDVDName);
KStorageControllerType dvdStorageControllerType = type.GetRecommendedDVDStorageController();
dvdCtr.SetControllerType(dvdStorageControllerType);
/* Create recommended HD storage controller if it's not the same as the DVD controller: */
KStorageBus ctrHDBus = type.GetRecommendedHDStorageBus();
KStorageControllerType hdStorageControllerType = type.GetRecommendedHDStorageController();
CStorageController hdCtr;
QString strHDName;
if (ctrHDBus != strDVDBus || hdStorageControllerType != dvdStorageControllerType)
{
strHDName = getNextControllerName(ctrHDBus);
m_machine.AddStorageController(strHDName, ctrHDBus);
hdCtr = m_machine.GetStorageControllerByName(strHDName);
hdCtr.SetControllerType(hdStorageControllerType);
}
else
{
/* The HD controller is the same as DVD: */
hdCtr = dvdCtr;
strHDName = strDVDName;
}
/* Liomit the AHCI port count if it's used because windows has trouble with
too many ports and other guest (OS X in particular) may take extra long
to boot: */
if (hdStorageControllerType == KStorageControllerType_IntelAhci)
hdCtr.SetPortCount(1 + (dvdStorageControllerType == KStorageControllerType_IntelAhci));
else if (dvdStorageControllerType == KStorageControllerType_IntelAhci)
dvdCtr.SetPortCount(1);
/* Turn on PAE, if recommended: */
m_machine.SetCPUProperty(KCPUPropertyType_PAE, type.GetRecommendedPAE());
/* Set the recommended triple fault behavior: */
m_machine.SetCPUProperty(KCPUPropertyType_TripleFaultReset, type.GetRecommendedTFReset());
/* Set recommended firmware type: */
KFirmwareType fwType = type.GetRecommendedFirmware();
m_machine.SetFirmwareType(fwType);
/* Set recommended human interface device types: */
if (type.GetRecommendedUSBHID())
{
m_machine.SetKeyboardHIDType(KKeyboardHIDType_USBKeyboard);
m_machine.SetPointingHIDType(KPointingHIDType_USBMouse);
if (!fOhciEnabled && !usbDeviceFilters.isNull())
m_machine.AddUSBController("OHCI", KUSBControllerType_OHCI);
}
if (type.GetRecommendedUSBTablet())
{
m_machine.SetPointingHIDType(KPointingHIDType_USBTablet);
if (!fOhciEnabled && !usbDeviceFilters.isNull())
m_machine.AddUSBController("OHCI", KUSBControllerType_OHCI);
}
/* Set HPET flag: */
m_machine.SetHPETEnabled(type.GetRecommendedHPET());
/* Set UTC flags: */
m_machine.SetRTCUseUTC(type.GetRecommendedRTCUseUTC());
/* Set graphic bits: */
if (type.GetRecommended2DVideoAcceleration())
m_machine.SetAccelerate2DVideoEnabled(type.GetRecommended2DVideoAcceleration());
if (type.GetRecommended3DAcceleration())
m_machine.SetAccelerate3DEnabled(type.GetRecommended3DAcceleration());
/* Register the VM prior to attaching hard disks: */
vbox.RegisterMachine(m_machine);
if (!vbox.isOk())
{
msgCenter().cannotRegisterMachine(vbox, m_machine.GetName(), this);
return false;
}
/* Attach default devices: */
{
bool success = false;
QString strMachineId = m_machine.GetId();
CSession session = vboxGlobal().openSession(strMachineId);
if (!session.isNull())
{
CMachine machine = session.GetMachine();
QString strId = field("virtualDiskId").toString();
/* Boot virtual hard drive: */
if (!strId.isNull())
{
UIMedium vmedium = vboxGlobal().medium(strId);
CMedium medium = vmedium.medium(); // @todo r=dj can this be cached somewhere?
machine.AttachDevice(strHDName, 0, 0, KDeviceType_HardDisk, medium);
if (!machine.isOk())
msgCenter().cannotAttachDevice(machine, UIMediumType_HardDisk, field("virtualDiskLocation").toString(),
StorageSlot(ctrHDBus, 0, 0), this);
}
/* Attach empty optical drive: */
machine.AttachDevice(strDVDName, 1, 0, KDeviceType_DVD, CMedium());
if (!machine.isOk())
msgCenter().cannotAttachDevice(machine, UIMediumType_DVD, QString(), StorageSlot(strDVDBus, 1, 0), this);
/* Attach an empty floppy drive if recommended */
if (type.GetRecommendedFloppy()) {
machine.AttachDevice(strFloppyName, 0, 0, KDeviceType_Floppy, CMedium());
if (!machine.isOk())
msgCenter().cannotAttachDevice(machine, UIMediumType_Floppy, QString(),
StorageSlot(KStorageBus_Floppy, 0, 0), this);
}
if (machine.isOk())
{
machine.SaveSettings();
if (machine.isOk())
success = true;
else
msgCenter().cannotSaveMachineSettings(machine, this);
}
session.UnlockMachine();
}
if (!success)
{
/* Unregister on failure */
QVector<CMedium> aMedia = m_machine.Unregister(KCleanupMode_UnregisterOnly); // @todo replace with DetachAllReturnHardDisksOnly once a progress dialog is in place below
if (vbox.isOk())
{
CProgress progress = m_machine.DeleteConfig(aMedia);
progress.WaitForCompletion(-1); // @todo do this nicely with a progress dialog, this can delete lots of files
}
return false;
}
}
/* Ensure we don't try to delete a newly created virtual hard drive on success: */
if (!field("virtualDisk").value<CMedium>().isNull())
field("virtualDisk").value<CMedium>().detach();
return true;
}
bool UIWizardCloneVM::cloneVM()
{
/* Get clone name: */
QString strName = field("cloneName").toString();
/* Should we reinit mac status? */
bool fReinitMACs = field("reinitMACs").toBool();
/* Should we create linked clone? */
bool fLinked = field("linkedClone").toBool();
/* Get clone mode: */
KCloneMode cloneMode = (mode() == UIWizardMode_Basic && page(Page3)) ||
(mode() == UIWizardMode_Expert && page(PageExpert)) ?
field("cloneMode").value<KCloneMode>() : KCloneMode_MachineState;
/* Get VBox object: */
CVirtualBox vbox = vboxGlobal().virtualBox();
/* Prepare machine for cloning: */
CMachine srcMachine = m_machine;
/* If the user like to create a linked clone from the current machine, we
* have to take a little bit more action. First we create an snapshot, so
* that new differencing images on the source VM are created. Based on that
* we could use the new snapshot machine for cloning. */
if (fLinked && m_snapshot.isNull())
{
/* Open session: */
CSession session = vboxGlobal().openSession(m_machine.GetId());
if (session.isNull())
return false;
/* Prepare console: */
CConsole console = session.GetConsole();
/* Take the snapshot: */
QString strSnapshotName = tr("Linked Base for %1 and %2").arg(m_machine.GetName()).arg(strName);
CProgress progress = console.TakeSnapshot(strSnapshotName, "");
if (console.isOk())
{
/* Show the "Taking Snapshot" progress dialog: */
msgCenter().showModalProgressDialog(progress, m_machine.GetName(), ":/progress_snapshot_create_90px.png", this, true);
if (!progress.isOk() || progress.GetResultCode() != 0)
{
msgCenter().cannotTakeSnapshot(progress);
return false;
}
}
else
{
msgCenter().cannotTakeSnapshot(console);
return false;
}
/* Unlock machine finally: */
session.UnlockMachine();
/* Get the new snapshot and the snapshot machine. */
const CSnapshot &newSnapshot = m_machine.FindSnapshot(strSnapshotName);
if (newSnapshot.isNull())
{
msgCenter().cannotFindSnapshotByName(this, m_machine, strSnapshotName);
return false;
}
srcMachine = newSnapshot.GetMachine();
}
/* Create a new machine object. */
const QString &strSettingsFile = vbox.ComposeMachineFilename(strName, QString::null /**< @todo group support */, QString::null, QString::null);
CMachine cloneMachine = vbox.CreateMachine(strSettingsFile, strName, QVector<QString>(), QString::null, QString::null);
if (!vbox.isOk())
{
msgCenter().cannotCreateMachine(vbox, this);
return false;
}
/* Add the keep all MACs option to the import settings when requested. */
QVector<KCloneOptions> options;
if (!fReinitMACs)
options.append(KCloneOptions_KeepAllMACs);
/* Linked clones requested? */
if (fLinked)
options.append(KCloneOptions_Link);
/* Start cloning. */
CProgress progress = srcMachine.CloneTo(cloneMachine, cloneMode, options);
if (!srcMachine.isOk())
{
msgCenter().cannotCreateClone(srcMachine, this);
return false;
}
/* Wait until done. */
msgCenter().showModalProgressDialog(progress, windowTitle(), ":/progress_clone_90px.png", this, true);
if (progress.GetCanceled())
return false;
if (!progress.isOk() || progress.GetResultCode() != 0)
{
msgCenter().cannotCreateClone(srcMachine, progress, this);
return false;
}
/* Finally register the clone machine. */
vbox.RegisterMachine(cloneMachine);
if (!vbox.isOk())
{
msgCenter().cannotRegisterMachine(vbox, cloneMachine, this);
return false;
}
return true;
}
bool UINewVMWzdPage5::constructMachine()
{
CVirtualBox vbox = vboxGlobal().virtualBox();
/* OS type */
CGuestOSType type = field("type").value<CGuestOSType>();
AssertMsg(!type.isNull(), ("GuestOSType must return non-null type"));
QString typeId = type.GetId();
/* Create a machine with the default settings file location */
if (m_Machine.isNull())
{
m_Machine = vbox.CreateMachine(QString::null, // auto-compose filename
field("name").toString(),
typeId,
QString::null, // machine ID
false); // forceOverwrite
if (!vbox.isOk())
{
msgCenter().cannotCreateMachine(vbox, this);
return false;
}
/* The FirstRun wizard is to be shown only when we don't attach any hard disk or attach a new (empty) one.
* Selecting an existing hard disk will cancel the wizard. */
if (field("hardDiskId").toString().isNull() || !field("hardDisk").value<CMedium>().isNull())
m_Machine.SetExtraData(VBoxDefs::GUI_FirstRun, "yes");
}
/* RAM size */
m_Machine.SetMemorySize(field("ram").toInt());
/* VRAM size - select maximum between recommended and minimum for fullscreen */
m_Machine.SetVRAMSize (qMax (type.GetRecommendedVRAM(),
(ULONG) (VBoxGlobal::requiredVideoMemory(typeId) / _1M)));
/* Selecting recommended chipset type */
m_Machine.SetChipsetType(type.GetRecommendedChipset());
/* Selecting recommended Audio Controller */
m_Machine.GetAudioAdapter().SetAudioController(type.GetRecommendedAudioController());
/* Enabling audio by default */
m_Machine.GetAudioAdapter().SetEnabled(true);
/* Enable the OHCI and EHCI controller by default for new VMs. (new in 2.2) */
CUSBController usbController = m_Machine.GetUSBController();
if ( !usbController.isNull()
&& usbController.GetProxyAvailable())
{
usbController.SetEnabled(true);
/*
* USB 2.0 is only available if the proper ExtPack is installed.
*
* Note. Configuring EHCI here and providing messages about
* the missing extpack isn't exactly clean, but it is a
* necessary evil to patch over legacy compatability issues
* introduced by the new distribution model.
*/
CExtPackManager manager = vboxGlobal().virtualBox().GetExtensionPackManager();
if (manager.IsExtPackUsable(UI_ExtPackName))
usbController.SetEnabledEhci(true);
}
/* Create recommended DVD storage controller */
KStorageBus ctrDvdBus = type.GetRecommendedDvdStorageBus();
QString ctrDvdName = getNextControllerName(ctrDvdBus);
m_Machine.AddStorageController(ctrDvdName, ctrDvdBus);
/* Set recommended DVD storage controller type */
CStorageController dvdCtr = m_Machine.GetStorageControllerByName(ctrDvdName);
KStorageControllerType dvdStorageControllerType = type.GetRecommendedDvdStorageController();
dvdCtr.SetControllerType(dvdStorageControllerType);
/* Create recommended HD storage controller if it's not the same as the DVD controller */
KStorageBus ctrHdBus = type.GetRecommendedHdStorageBus();
KStorageControllerType hdStorageControllerType = type.GetRecommendedHdStorageController();
CStorageController hdCtr;
QString ctrHdName;
if (ctrHdBus != ctrDvdBus || hdStorageControllerType != dvdStorageControllerType)
{
ctrHdName = getNextControllerName(ctrHdBus);
m_Machine.AddStorageController(ctrHdName, ctrHdBus);
hdCtr = m_Machine.GetStorageControllerByName(ctrHdName);
hdCtr.SetControllerType(hdStorageControllerType);
/* Set the port count to 1 if SATA is used. */
if (hdStorageControllerType == KStorageControllerType_IntelAhci)
hdCtr.SetPortCount(1);
}
else
{
/* The HD controller is the same as DVD */
hdCtr = dvdCtr;
ctrHdName = ctrDvdName;
}
/* Turn on PAE, if recommended */
m_Machine.SetCPUProperty(KCPUPropertyType_PAE, type.GetRecommendedPae());
/* Set recommended firmware type */
KFirmwareType fwType = type.GetRecommendedFirmware();
m_Machine.SetFirmwareType(fwType);
/* Set recommended human interface device types */
if (type.GetRecommendedUsbHid())
{
m_Machine.SetKeyboardHidType(KKeyboardHidType_USBKeyboard);
m_Machine.SetPointingHidType(KPointingHidType_USBMouse);
if (!usbController.isNull())
usbController.SetEnabled(true);
}
if (type.GetRecommendedUsbTablet())
{
m_Machine.SetPointingHidType(KPointingHidType_USBTablet);
if (!usbController.isNull())
usbController.SetEnabled(true);
}
/* Set HPET flag */
m_Machine.SetHpetEnabled(type.GetRecommendedHpet());
/* Set UTC flags */
m_Machine.SetRTCUseUTC(type.GetRecommendedRtcUseUtc());
/* Register the VM prior to attaching hard disks */
vbox.RegisterMachine(m_Machine);
if (!vbox.isOk())
{
msgCenter().cannotCreateMachine(vbox, m_Machine, this);
return false;
}
/* Attach default devices */
{
bool success = false;
QString machineId = m_Machine.GetId();
CSession session = vboxGlobal().openSession(machineId);
if (!session.isNull())
{
CMachine m = session.GetMachine();
QString strId = field("hardDiskId").toString();
/* Boot hard disk */
if (!strId.isNull())
{
VBoxMedium vmedium = vboxGlobal().findMedium(strId);
CMedium medium = vmedium.medium(); // @todo r=dj can this be cached somewhere?
m.AttachDevice(ctrHdName, 0, 0, KDeviceType_HardDisk, medium);
if (!m.isOk())
msgCenter().cannotAttachDevice(m, VBoxDefs::MediumType_HardDisk, field("hardDiskLocation").toString(),
StorageSlot(ctrHdBus, 0, 0), this);
}
/* Attach empty CD/DVD ROM Device */
m.AttachDevice(ctrDvdName, 1, 0, KDeviceType_DVD, CMedium());
if (!m.isOk())
msgCenter().cannotAttachDevice(m, VBoxDefs::MediumType_DVD, QString(), StorageSlot(ctrDvdBus, 1, 0), this);
if (m.isOk())
{
m.SaveSettings();
if (m.isOk())
success = true;
else
msgCenter().cannotSaveMachineSettings(m, this);
}
session.UnlockMachine();
}
if (!success)
{
/* Unregister on failure */
QVector<CMedium> aMedia = m_Machine.Unregister(KCleanupMode_UnregisterOnly); // @todo replace with DetachAllReturnHardDisksOnly once a progress dialog is in place below
if (vbox.isOk())
{
CProgress progress = m_Machine.Delete(aMedia);
progress.WaitForCompletion(-1); // @todo do this nicely with a progress dialog, this can delete lots of files
}
return false;
}
}
/* Ensure we don't try to delete a newly created hard disk on success */
if (!field("hardDisk").value<CMedium>().isNull())
field("hardDisk").value<CMedium>().detach();
return true;
}
bool UICloneVMWizard::createClone(const QString &strName, KCloneMode mode, bool fReinitMACs, bool fLinked /* = false */)
{
CVirtualBox vbox = vboxGlobal().virtualBox();
const QString &strSettingsFile = vbox.ComposeMachineFilename(strName, QString::null);
CMachine srcMachine = m_machine;
/* If the user like to create a linked clone from the current machine, we
* have to take a little bit more action. First we create an snapshot, so
* that new differencing images on the source VM are created. Based on that
* we could use the new snapshot machine for cloning. */
if ( fLinked
&& m_snapshot.isNull())
{
const QString &strId = m_machine.GetId();
CSession session = vboxGlobal().openSession(strId);
if (session.isNull())
return false;
CConsole console = session.GetConsole();
/* Take the snapshot */
QString strSnapshotName = tr("Linked Base for %1 and %2").arg(m_machine.GetName()).arg(strName);
CProgress progress = console.TakeSnapshot(strSnapshotName, "");
if (console.isOk())
{
/* Show the "Taking Snapshot" progress dialog */
msgCenter().showModalProgressDialog(progress, m_machine.GetName(), ":/progress_snapshot_create_90px.png", this, true);
if (!progress.isOk() || progress.GetResultCode() != 0)
{
msgCenter().cannotTakeSnapshot(progress);
return false;
}
}
else
{
msgCenter().cannotTakeSnapshot(console);
return false;
}
/* Unlock machine finally: */
session.UnlockMachine();
/* Get the new snapshot and the snapshot machine. */
const CSnapshot &newSnapshot = m_machine.FindSnapshot(strSnapshotName);
if (newSnapshot.isNull())
{
msgCenter().cannotFindSnapshotByName(this, m_machine, strSnapshotName);
return false;
}
srcMachine = newSnapshot.GetMachine();
}
/* Create a new machine object. */
CMachine cloneMachine = vbox.CreateMachine(strSettingsFile, strName, QString::null, QString::null, false);
if (!vbox.isOk())
{
msgCenter().cannotCreateMachine(vbox, this);
return false;
}
/* Add the keep all MACs option to the import settings when requested. */
QVector<KCloneOptions> options;
if (!fReinitMACs)
options.append(KCloneOptions_KeepAllMACs);
/* Linked clones requested? */
if (fLinked)
options.append(KCloneOptions_Link);
/* Start cloning. */
CProgress progress = srcMachine.CloneTo(cloneMachine, mode, options);
if (!srcMachine.isOk())
{
msgCenter().cannotCreateClone(srcMachine, this);
return false;
}
/* Wait until done. */
msgCenter().showModalProgressDialog(progress, windowTitle(), ":/progress_clone_90px.png", this, true);
if (progress.GetCanceled())
return false;
if (!progress.isOk() || progress.GetResultCode() != 0)
{
msgCenter().cannotCreateClone(srcMachine, progress, this);
return false;
}
/* Finally register the clone machine. */
vbox.RegisterMachine(cloneMachine);
if (!vbox.isOk())
{
msgCenter().cannotRegisterMachine(vbox, cloneMachine, this);
return false;
}
return true;
}
