float64_t CMultitaskCompositeMachine::apply_one(int32_t i)
{
CMachine* m = (CMachine*)(m_task_machines->get_element(m_current_task));
float64_t result = m->apply_one(i);
SG_UNREF(m);
return result;
}
/* static */
bool UIWizardFirstRun::isBootHardDiskAttached(const CMachine &machine)
{
/* Result is 'false' initially: */
bool fIsBootHardDiskAttached = false;
/* Get 'vbox' global object: */
CVirtualBox vbox = vboxGlobal().virtualBox();
/* Determine machine 'OS type': */
const CGuestOSType &osType = vbox.GetGuestOSType(machine.GetOSTypeId());
/* Determine recommended controller's 'bus' & 'type': */
KStorageBus hdCtrBus = osType.GetRecommendedHDStorageBus();
KStorageControllerType hdCtrType = osType.GetRecommendedHDStorageController();
/* Enumerate attachments vector: */
const CMediumAttachmentVector &attachments = machine.GetMediumAttachments();
for (int i = 0; i < attachments.size(); ++i)
{
/* Get current attachment: */
const CMediumAttachment &attachment = attachments[i];
/* Determine attachment's controller: */
const CStorageController &controller = machine.GetStorageControllerByName(attachment.GetController());
/* If controller's 'bus' & 'type' are recommended and attachment's 'type' is 'hard disk': */
if (controller.GetBus() == hdCtrBus &&
controller.GetControllerType() == hdCtrType &&
attachment.GetType() == KDeviceType_HardDisk)
{
/* Set the result to 'true': */
fIsBootHardDiskAttached = true;
break;
}
}
/* Return result: */
return fIsBootHardDiskAttached;
}
void UIMachineWindowFullscreen::prepareMiniToolBar()
{
/* Get current machine: */
CMachine machine = session().GetConsole().GetMachine();
/* Check if mini tool-bar should present: */
bool fIsActive = machine.GetExtraData(VBoxDefs::GUI_ShowMiniToolBar) != "no";
if (fIsActive)
{
/* Get the mini tool-bar alignment: */
bool fIsAtTop = machine.GetExtraData(VBoxDefs::GUI_MiniToolBarAlignment) == "top";
/* Get the mini tool-bar auto-hide feature availability: */
bool fIsAutoHide = machine.GetExtraData(VBoxDefs::GUI_MiniToolBarAutoHide) != "off";
m_pMiniToolBar = new VBoxMiniToolBar(centralWidget(),
fIsAtTop ? VBoxMiniToolBar::AlignTop : VBoxMiniToolBar::AlignBottom,
true, fIsAutoHide);
m_pMiniToolBar->updateDisplay(true, true);
QList<QMenu*> menus;
QList<QAction*> actions = uisession()->newMenu()->actions();
for (int i=0; i < actions.size(); ++i)
menus << actions.at(i)->menu();
*m_pMiniToolBar << menus;
connect(m_pMiniToolBar, SIGNAL(minimizeAction()), this, SLOT(showMinimized()));
connect(m_pMiniToolBar, SIGNAL(exitAction()),
gActionPool->action(UIActionIndexRuntime_Toggle_Fullscreen), SLOT(trigger()));
connect(m_pMiniToolBar, SIGNAL(closeAction()),
gActionPool->action(UIActionIndexRuntime_Simple_Close), SLOT(trigger()));
}
}
void UIMachineWindowSeamless::prepareMiniToolbar()
{
/* Get machine: */
CMachine m = machine();
/* Make sure mini-toolbar is necessary: */
bool fIsActive = m.GetExtraData(GUI_ShowMiniToolBar) != "no";
if (!fIsActive)
return;
/* Get the mini-toolbar alignment: */
bool fIsAtTop = m.GetExtraData(GUI_MiniToolBarAlignment) == "top";
/* Get the mini-toolbar auto-hide feature availability: */
bool fIsAutoHide = m.GetExtraData(GUI_MiniToolBarAutoHide) != "off";
m_pMiniToolBar = new VBoxMiniToolBar(centralWidget(),
fIsAtTop ? VBoxMiniToolBar::AlignTop : VBoxMiniToolBar::AlignBottom,
true, fIsAutoHide);
m_pMiniToolBar->setSeamlessMode(true);
m_pMiniToolBar->updateDisplay(true, true);
QList<QMenu*> menus;
QList<QAction*> actions = uisession()->newMenu()->actions();
for (int i=0; i < actions.size(); ++i)
menus << actions.at(i)->menu();
*m_pMiniToolBar << menus;
connect(m_pMiniToolBar, SIGNAL(minimizeAction()), this, SLOT(showMinimized()));
connect(m_pMiniToolBar, SIGNAL(exitAction()),
gActionPool->action(UIActionIndexRuntime_Toggle_Seamless), SLOT(trigger()));
connect(m_pMiniToolBar, SIGNAL(closeAction()),
gActionPool->action(UIActionIndexRuntime_Simple_Close), SLOT(trigger()));
connect(m_pMiniToolBar, SIGNAL(geometryUpdated()), this, SLOT(sltUpdateMiniToolBarMask()));
}
void UIMediumEnumerator::sltHandleMachineUpdate(QString strMachineID)
{
LogRelFlow(("UIMediumEnumerator: Machine event received, ID = %s\n", strMachineID.toAscii().constData()));
/* Compose a map of previous usage: */
QStringList oldUsage;
foreach (const QString &strMediumID, mediumIDs())
{
const UIMedium &uimedium = m_mediums[strMediumID];
const QList<QString> &machineIDs = uimedium.machineIds();
if (machineIDs.contains(strMachineID))
oldUsage << strMediumID;
}
LogRelFlow(("UIMediumEnumerator: Old usage: %s\n", oldUsage.isEmpty() ? "<empty>" : oldUsage.join(", ").toAscii().constData()));
/* Compose a map of current usage: */
QStringList newUsage;
QMap<QString, CMedium> newMediumMap;
CMachine machine = vboxGlobal().virtualBox().FindMachine(strMachineID);
if (!machine.isNull())
{
CMediumAttachmentVector attachments = machine.GetMediumAttachments();
foreach (const CMediumAttachment &attachment, attachments)
{
CMedium cmedium = attachment.GetMedium();
if (cmedium.isNull())
continue;
QString strMediumID = cmedium.GetId();
newMediumMap.insert(strMediumID, cmedium);
newUsage << strMediumID;
}
SGVector<float64_t> CBaggingMachine::apply_get_outputs(CFeatures* data)
{
ASSERT(data != NULL);
REQUIRE(m_combination_rule != NULL, "Combination rule is not set!");
ASSERT(m_num_bags == m_bags->get_num_elements());
SGMatrix<float64_t> output(data->get_num_vectors(), m_num_bags);
output.zero();
#pragma omp parallel for num_threads(parallel->get_num_threads())
for (int32_t i = 0; i < m_num_bags; ++i)
{
CMachine* m = dynamic_cast<CMachine*>(m_bags->get_element(i));
CLabels* l = m->apply(data);
SGVector<float64_t> lv = l->get_values();
float64_t* bag_results = output.get_column_vector(i);
memcpy(bag_results, lv.vector, lv.vlen*sizeof(float64_t));
SG_UNREF(l);
SG_UNREF(m);
}
SGVector<float64_t> combined = m_combination_rule->combine(output);
return combined;
}
VBoxTakeSnapshotDlg::VBoxTakeSnapshotDlg(QWidget *pParent, const CMachine &machine)
: QIWithRetranslateUI<QIDialog>(pParent)
{
#ifdef Q_WS_MAC
/* No sheets in another mode than normal for now. Firstly it looks ugly and
* secondly in some cases it is broken. */
if ( vboxGlobal().isSheetWindowsAllowed(pParent)
|| qobject_cast<VBoxSnapshotsWgt*>(pParent))
setWindowFlags(Qt::Sheet);
#endif /* Q_WS_MAC */
/* Apply UI decorations */
Ui::VBoxTakeSnapshotDlg::setupUi(this);
/* Alt key filter */
QIAltKeyFilter *altKeyFilter = new QIAltKeyFilter(this);
altKeyFilter->watchOn(mLeName);
/* Setup connections */
connect (mButtonBox, SIGNAL(helpRequested()), &msgCenter(), SLOT(sltShowHelpHelpDialog()));
connect (mLeName, SIGNAL(textChanged(const QString &)), this, SLOT(nameChanged(const QString &)));
/* Check if machine have immutable attachments */
int immutableMediums = 0;
if (machine.GetState() == KMachineState_Paused)
{
foreach (const CMediumAttachment &attachment, machine.GetMediumAttachments())
{
CMedium medium = attachment.GetMedium();
if (!medium.isNull() && !medium.GetParent().isNull() && medium.GetBase().GetType() == KMediumType_Immutable)
++ immutableMediums;
}
}
QSize UIMachineView::guestSizeHint()
{
/* Result: */
QSize sizeHint;
/* Get current machine: */
CMachine machine = session().GetMachine();
/* Load machine view hint: */
QString strKey = m_uScreenId == 0 ? QString("%1").arg(VBoxDefs::GUI_LastGuestSizeHint) :
QString("%1%2").arg(VBoxDefs::GUI_LastGuestSizeHint).arg(m_uScreenId);
QString strValue = machine.GetExtraData(strKey);
bool ok = true;
int width = 0, height = 0;
if (ok)
width = strValue.section(',', 0, 0).toInt(&ok);
if (ok)
height = strValue.section(',', 1, 1).toInt(&ok);
if (ok /* If previous parameters were read correctly! */)
{
/* Compose guest size hint from loaded values: */
sizeHint = QSize(width, height);
}
else
{
/* Compose guest size hint from default attributes: */
sizeHint = QSize(800, 600);
}
/* Return result: */
return sizeHint;
}
void VBoxSnapshotsWgt::sltCloneSnapshot()
{
SnapshotWgtItem *item = !mTreeWidget->currentItem() ? 0 :
static_cast <SnapshotWgtItem*> (mTreeWidget->currentItem());
AssertReturn (item, (void) 0);
CMachine machine;
CSnapshot snapshot;
if (item->isCurrentStateItem())
machine = item->machine();
else
{
snapshot = item->snapshot();
AssertReturn(!snapshot.isNull(), (void)0);
machine = snapshot.GetMachine();
}
AssertReturn(!machine.isNull(), (void)0);
/* Show Clone VM wizard: */
UISafePointerWizard pWizard = new UIWizardCloneVM(this, machine, snapshot);
pWizard->prepare();
pWizard->exec();
if (pWizard)
delete pWizard;
}
VBoxTakeSnapshotDlg::VBoxTakeSnapshotDlg(QWidget *pParent, const CMachine &machine)
: QIWithRetranslateUI<QIDialog>(pParent)
{
/* Apply UI decorations */
Ui::VBoxTakeSnapshotDlg::setupUi(this);
/* Alt key filter */
QIAltKeyFilter *altKeyFilter = new QIAltKeyFilter(this);
altKeyFilter->watchOn(mLeName);
/* Setup connections */
connect (mButtonBox, SIGNAL(helpRequested()), &msgCenter(), SLOT(sltShowHelpHelpDialog()));
connect (mLeName, SIGNAL(textChanged(const QString &)), this, SLOT(nameChanged(const QString &)));
/* Check if machine have immutable attachments */
int immutableMediums = 0;
if (machine.GetState() == KMachineState_Paused)
{
foreach (const CMediumAttachment &attachment, machine.GetMediumAttachments())
{
CMedium medium = attachment.GetMedium();
if (!medium.isNull() && !medium.GetParent().isNull() && medium.GetBase().GetType() == KMediumType_Immutable)
++ immutableMediums;
}
}
void UIMachineWindowSeamless::prepareMiniToolbar()
{
/* Get machine: */
CMachine m = machine();
/* Make sure mini-toolbar is necessary: */
bool fIsActive = m.GetExtraData(GUI_ShowMiniToolBar) != "no";
if (!fIsActive)
return;
/* Get the mini-toolbar alignment: */
bool fIsAtTop = m.GetExtraData(GUI_MiniToolBarAlignment) == "top";
/* Get the mini-toolbar auto-hide feature availability: */
bool fIsAutoHide = m.GetExtraData(GUI_MiniToolBarAutoHide) != "off";
/* Create mini-toolbar: */
m_pMiniToolBar = new UIRuntimeMiniToolBar(this,
fIsAtTop ? Qt::AlignTop : Qt::AlignBottom,
IntegrationMode_External,
fIsAutoHide);
m_pMiniToolBar->show();
QList<QMenu*> menus;
QList<QAction*> actions = uisession()->newMenu()->actions();
for (int i=0; i < actions.size(); ++i)
menus << actions.at(i)->menu();
m_pMiniToolBar->addMenus(menus);
connect(m_pMiniToolBar, SIGNAL(sigMinimizeAction()), this, SLOT(showMinimized()));
connect(m_pMiniToolBar, SIGNAL(sigExitAction()),
gActionPool->action(UIActionIndexRuntime_Toggle_Seamless), SLOT(trigger()));
connect(m_pMiniToolBar, SIGNAL(sigCloseAction()),
gActionPool->action(UIActionIndexRuntime_Simple_Close), SLOT(trigger()));
}
UICloneVMWizard::UICloneVMWizard(QWidget *pParent, CMachine machine, CSnapshot snapshot /* = CSnapshot() */)
: QIWizard(pParent)
, m_machine(machine)
, m_snapshot(snapshot)
{
/* Create & add pages: */
setPage(PageIntro, new UICloneVMWizardPage1(machine.GetName()));
/* If we are having a snapshot we can show the "Linked" option. */
setPage(PageType, new UICloneVMWizardPage2(snapshot.isNull()));
/* If the machine has no snapshots, we don't bother the user about options
* for it. */
if (machine.GetSnapshotCount() > 0)
setPage(PageMode, new UICloneVMWizardPage3(snapshot.isNull() ? false : snapshot.GetChildrenCount() > 0));
/* Translate wizard: */
retranslateUi();
/* Translate wizard pages: */
retranslateAllPages();
/* Resize wizard to 'golden ratio': */
resizeToGoldenRatio();
#ifdef Q_WS_MAC
setMinimumSize(QSize(600, 400));
/* Assign background image: */
assignBackground(":/vmw_clone_bg.png");
#else /* Q_WS_MAC */
/* Assign watermark: */
assignWatermark(":/vmw_clone.png");
#endif /* Q_WS_MAC */
}
CBinaryLabels* CMulticlassMachine::get_submachine_outputs(int32_t i)
{
CMachine *machine = (CMachine*)m_machines->get_element(i);
ASSERT(machine);
CBinaryLabels* output = machine->apply_binary();
SG_UNREF(machine);
return output;
}
void UIMachineWindowScale::loadSettings()
{
/* Call to base-class: */
UIMachineWindow::loadSettings();
/* Load scale window settings: */
CMachine m = machine();
/* Load extra-data settings: */
{
QString strPositionAddress = m_uScreenId == 0 ? QString("%1").arg(GUI_LastScaleWindowPosition) :
QString("%1%2").arg(GUI_LastScaleWindowPosition).arg(m_uScreenId);
QStringList strPositionSettings = m.GetExtraDataStringList(strPositionAddress);
bool ok = !strPositionSettings.isEmpty(), max = false;
int x = 0, y = 0, w = 0, h = 0;
if (ok && strPositionSettings.size() > 0)
x = strPositionSettings[0].toInt(&ok);
else ok = false;
if (ok && strPositionSettings.size() > 1)
y = strPositionSettings[1].toInt(&ok);
else ok = false;
if (ok && strPositionSettings.size() > 2)
w = strPositionSettings[2].toInt(&ok);
else ok = false;
if (ok && strPositionSettings.size() > 3)
h = strPositionSettings[3].toInt(&ok);
else ok = false;
if (ok && strPositionSettings.size() > 4)
max = strPositionSettings[4] == GUI_LastWindowState_Max;
QRect ar = ok ? QApplication::desktop()->availableGeometry(QPoint(x, y)) :
QApplication::desktop()->availableGeometry(this);
/* If previous parameters were read correctly: */
if (ok)
{
/* Restore window size and position: */
m_normalGeometry = QRect(x, y, w, h);
setGeometry(m_normalGeometry);
/* Maximize if needed: */
if (max)
setWindowState(windowState() | Qt::WindowMaximized);
}
else
{
/* Resize to default size: */
resize(640, 480);
qApp->processEvents();
/* Move newly created window to the screen center: */
m_normalGeometry = geometry();
m_normalGeometry.moveCenter(ar.center());
setGeometry(m_normalGeometry);
}
}
}
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);
}
}
void UIFirstRunWzdPage1::init()
{
/* Current machine */
CMachine machine = field("machine").value<CMachine>();
AssertMsg(!machine.isNull(), ("Field 'machine' must be set!\n"));
/* Hide unnecessary text labels */
bool fIsBootHDAttached = UIFirstRunWzd::isBootHardDiskAttached(machine);
m_pPage1Text1Var1->setHidden(!fIsBootHDAttached);
m_pPage1Text1Var2->setHidden(fIsBootHDAttached);
}
void UIMachineView::storeGuestSizeHint(const QSize &sizeHint)
{
/* Get current machine: */
CMachine machine = session().GetMachine();
/* Save machine view hint: */
QString strKey = m_uScreenId == 0 ? QString("%1").arg(VBoxDefs::GUI_LastGuestSizeHint) :
QString("%1%2").arg(VBoxDefs::GUI_LastGuestSizeHint).arg(m_uScreenId);
QString strValue = QString("%1,%2").arg(sizeHint.width()).arg(sizeHint.height());
machine.SetExtraData(strKey, strValue);
}
void UIMachineWindowFullscreen::saveWindowSettings()
{
/* Get machine: */
CMachine machine = session().GetConsole().GetMachine();
/* Save extra-data settings: */
{
/* Save mini tool-bar settings: */
if (m_pMiniToolBar)
machine.SetExtraData(VBoxDefs::GUI_MiniToolBarAutoHide, m_pMiniToolBar->isAutoHide() ? QString() : "off");
}
}
UIMultiScreenLayout::UIMultiScreenLayout(UIMachineLogic *pMachineLogic)
: m_pMachineLogic(pMachineLogic)
, m_pScreenMap(new QMap<int, int>())
{
CMachine machine = m_pMachineLogic->session().GetMachine();
/* Get host/guest monitor count: */
#if (QT_VERSION >= 0x040600)
m_cHostScreens = QApplication::desktop()->screenCount();
#else /* (QT_VERSION >= 0x040600) */
m_cHostScreens = QApplication::desktop()->numScreens();
#endif /* !(QT_VERSION >= 0x040600) */
m_cGuestScreens = machine.GetMonitorCount();
}
void UIMachineViewScale::takePauseShotSnapshot()
{
CMachine machine = session().GetMachine();
ULONG width = 0, height = 0;
QVector<BYTE> screenData = machine.ReadSavedScreenshotPNGToArray(0, width, height);
if (screenData.size() != 0)
{
ULONG guestWidth = 0, guestHeight = 0;
machine.QuerySavedGuestSize(0, guestWidth, guestHeight);
QImage shot = QImage::fromData(screenData.data(), screenData.size(), "PNG").scaled(guestWidth > 0 ? QSize(guestWidth, guestHeight) : guestSizeHint());
m_pPauseImage = new QImage(shot);
scalePauseShot();
}
}
void UIMachineWindowSeamless::saveWindowSettings()
{
#ifndef Q_WS_MAC
/* Get machine: */
CMachine machine = session().GetConsole().GetMachine();
/* Save extra-data settings: */
{
/* Save mini tool-bar settings: */
if (m_pMiniToolBar)
machine.SetExtraData(VBoxDefs::GUI_MiniToolBarAutoHide, m_pMiniToolBar->isAutoHide() ? QString() : "off");
}
#endif /* Q_WS_MAC */
}
void VBoxSnapshotDetailsDlg::getFromSnapshot (const CSnapshot &aSnapshot)
{
mSnapshot = aSnapshot;
CMachine machine = mSnapshot.GetMachine();
/* Get general properties */
mLeName->setText (aSnapshot.GetName());
mTeDescription->setText (aSnapshot.GetDescription());
/* Get timestamp info */
QDateTime timestamp;
timestamp.setTime_t (mSnapshot.GetTimeStamp() / 1000);
bool dateTimeToday = timestamp.date() == QDate::currentDate();
QString dateTime = dateTimeToday ? timestamp.time().toString (Qt::LocalDate) : timestamp.toString (Qt::LocalDate);
mTxTaken->setText (dateTime);
/* Get thumbnail if present */
ULONG width = 0, height = 0;
QVector <BYTE> thumbData = machine.ReadSavedThumbnailToArray (0, KBitmapFormat_BGR0, width, height);
mThumbnail = thumbData.size() != 0 ? QPixmap::fromImage (QImage (thumbData.data(), width, height, QImage::Format_RGB32).copy()) : QPixmap();
QVector <BYTE> screenData = machine.ReadSavedScreenshotToArray (0, KBitmapFormat_PNG, width, height);
mScreenshot = screenData.size() != 0 ? QPixmap::fromImage (QImage::fromData (screenData.data(), screenData.size(), "PNG")) : QPixmap();
QGridLayout *lt = qobject_cast <QGridLayout*> (layout());
Assert (lt);
if (mThumbnail.isNull())
{
lt->removeWidget (mLbThumbnail);
mLbThumbnail->setHidden (true);
lt->removeWidget (mLeName);
lt->removeWidget (mTxTaken);
lt->addWidget (mLeName, 0, 1, 1, 2);
lt->addWidget (mTxTaken, 1, 1, 1, 2);
}
else
{
lt->removeWidget (mLeName);
lt->removeWidget (mTxTaken);
lt->addWidget (mLeName, 0, 1);
lt->addWidget (mTxTaken, 1, 1);
lt->removeWidget (mLbThumbnail);
lt->addWidget (mLbThumbnail, 0, 2, 2, 1);
mLbThumbnail->setHidden (false);
}
retranslateUi();
}
void UIMachineWindowScale::saveWindowSettings()
{
CMachine machine = session().GetMachine();
/* Save extra-data settings: */
{
QString strWindowPosition = QString("%1,%2,%3,%4")
.arg(m_normalGeometry.x()).arg(m_normalGeometry.y())
.arg(m_normalGeometry.width()).arg(m_normalGeometry.height());
if (isMaximizedChecked())
strWindowPosition += QString(",%1").arg(VBoxDefs::GUI_LastWindowState_Max);
QString strPositionAddress = m_uScreenId == 0 ? QString("%1").arg(VBoxDefs::GUI_LastScaleWindowPosition) :
QString("%1%2").arg(VBoxDefs::GUI_LastScaleWindowPosition).arg(m_uScreenId);
machine.SetExtraData(strPositionAddress, strWindowPosition);
}
}
void VBoxSnapshotDetailsDlg::retranslateUi()
{
/* Translate uic generated strings */
Ui::VBoxSnapshotDetailsDlg::retranslateUi (this);
if(mSnapshot.isNull())
return;
CMachine machine = mSnapshot.GetMachine();
setWindowTitle (tr ("Details of %1 (%2)").arg (mSnapshot.GetName()).arg (machine.GetName()));
mLbThumbnail->setToolTip (mScreenshot.isNull() ? QString() : tr ("Click to enlarge the screenshot."));
mTeDetails->setText (vboxGlobal().detailsReport (machine, false /* with links? */));
}
void UIFirstRunWzdPage2::init()
{
/* Current machine */
CMachine machine = field("machine").value<CMachine>();
AssertMsg(!machine.isNull(), ("Field 'machine' must be set!\n"));
/* Hide unnecessary text labels */
bool fIsBootHDAttached = UIFirstRunWzd::isBootHardDiskAttached(machine);
m_pPage2Text1Var1->setHidden(!fIsBootHDAttached);
m_pPage2Text1Var2->setHidden(fIsBootHDAttached);
/* Assign media selector attributes */
m_pMediaSelector->setMachineId(machine.GetId());
m_pMediaSelector->setType(VBoxDefs::MediumType_DVD);
m_pMediaSelector->repopulate();
}
CMachine CDBOption::GetMachine(int machine_id)
{
stringstream query;
query << "select profile_id,ip from profile_machine where id = ";
query << machine_id;
CMachine buffer;
try
{
int szData = 0;
char szData1[128] = {'\0'};
m_stream->open(1,query.str().data(),*m_conn);
otl_stream_read_iterator < otl_stream, otl_exception,
otl_lob_stream > rs;
rs.attach (*m_stream);
while (rs.next_row ())
{
rs.get ("profile_id", szData);
rs.get ("ip",szData1);
}
rs.detach ();
m_stream->close();
stringstream name;
name << szData;
name << "_";
name << string(szData1);
buffer.setID(machine_id);
buffer.setName(name.str());
return buffer;
}
catch (otl_exception & p)
{
m_stream->close();
this->WriteError ("GetMachine Error: ", p);
}
return buffer;
}
/* 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 UIGInformationUpdateTaskGeneral::run()
{
/* Acquire corresponding machine: */
CMachine machine = property("machine").value<CMachine>();
if (machine.isNull())
return;
/* Prepare table: */
UITextTable table;
/* Gather information: */
if (machine.GetAccessible())
{
/* Machine name: */
table << UITextTableLine(QApplication::translate("UIGInformation", "Name", "details (general)"), machine.GetName());
/* Operating system type: */
table << UITextTableLine(QApplication::translate("UIGInformation", "Operating System", "details (general)"),
vboxGlobal().vmGuestOSTypeDescription(machine.GetOSTypeId()));
/* Get groups: */
QStringList groups = machine.GetGroups().toList();
/* Do not show groups for machine which is in root group only: */
if (groups.size() == 1)
groups.removeAll("/");
/* If group list still not empty: */
if (!groups.isEmpty())
{
/* For every group: */
for (int i = 0; i < groups.size(); ++i)
{
/* Trim first '/' symbol: */
QString &strGroup = groups[i];
if (strGroup.startsWith("/") && strGroup != "/")
strGroup.remove(0, 1);
}
table << UITextTableLine(QApplication::translate("UIGInformation", "Groups", "details (general)"), groups.join(", "));
}
}
else
table << UITextTableLine(QApplication::translate("UIGInformation", "Information Inaccessible", "details"), QString());
/* Save the table as property: */
setProperty("table", QVariant::fromValue(table));
}
int CActionSkillToAlias::Run(CMachine& machine) const
{
CActionSkill actionSkill(
machine.GetObjectIndex(mAlias.c_str()),
mSkillIndex);
actionSkill.Run(
machine);
return 1;
}
void VBoxSnapshotsWgt::setMachine (const CMachine &aMachine)
{
mMachine = aMachine;
if (aMachine.isNull())
{
mMachineId = QString::null;
mSessionState = KSessionState_Null;
m_fShapshotOperationsAllowed = false;
}
else
{
mMachineId = aMachine.GetId();
mSessionState = aMachine.GetSessionState();
m_fShapshotOperationsAllowed = vboxGlobal().shouldWeAllowSnapshotOperations(mMachine);
}
refreshAll();
}
