/* static */
void UIApplianceEditorWidget::initSystemSettings()
{
if (m_minGuestRAM == -1)
{
/* We need some global defaults from the current VirtualBox
installation */
CSystemProperties sp = vboxGlobal().virtualBox().GetSystemProperties();
m_minGuestRAM = sp.GetMinGuestRAM();
m_maxGuestRAM = sp.GetMaxGuestRAM();
m_minGuestCPUCount = sp.GetMinGuestCPUCount();
m_maxGuestCPUCount = sp.GetMaxGuestCPUCount();
}
}
void UIMachineWindowScale::loadSettings()
{
/* Call to base-class: */
UIMachineWindow::loadSettings();
/* Load extra-data settings: */
{
/* Load extra-data: */
QRect geo = gEDataManager->machineWindowGeometry(machineLogic()->visualStateType(),
m_uScreenId, vboxGlobal().managedVMUuid());
/* If we do have proper geometry: */
if (!geo.isNull())
{
/* Restore window geometry: */
m_normalGeometry = geo;
setGeometry(m_normalGeometry);
/* Maximize (if necessary): */
if (gEDataManager->machineWindowShouldBeMaximized(machineLogic()->visualStateType(),
m_uScreenId, vboxGlobal().managedVMUuid()))
setWindowState(windowState() | Qt::WindowMaximized);
}
/* If we do NOT have proper geometry: */
else
{
/* Get available geometry, for screen with (x,y) coords if possible: */
QRect availableGeo = !geo.isNull() ? QApplication::desktop()->availableGeometry(QPoint(geo.x(), geo.y())) :
QApplication::desktop()->availableGeometry(this);
/* Resize to default size: */
resize(640, 480);
/* Move newly created window to the screen-center: */
m_normalGeometry = geometry();
m_normalGeometry.moveCenter(availableGeo.center());
setGeometry(m_normalGeometry);
}
}
}
void UIWizardNewVDPage3::setMediumSize(qulonglong uMediumSize)
{
/* Block signals: */
m_pSizeSlider->blockSignals(true);
m_pSizeEditor->blockSignals(true);
/* Set values: */
m_pSizeSlider->setValue(sizeMBToSlider(uMediumSize, m_iSliderScale));
m_pSizeEditor->setText(vboxGlobal().formatSize(uMediumSize));
updateSizeToolTips(uMediumSize);
/* Unblock signals: */
m_pSizeSlider->blockSignals(false);
m_pSizeEditor->blockSignals(false);
}
/* UIMachineSettingsSerial stuff */
UIMachineSettingsSerial::UIMachineSettingsSerial(UIMachineSettingsSerialPage *pParent)
: QIWithRetranslateUI<QWidget> (0)
, m_pParent(pParent)
, mValidator(0)
, m_iSlot(-1)
{
/* Apply UI decorations */
Ui::UIMachineSettingsSerial::setupUi (this);
/* Setup validation */
mLeIRQ->setValidator (new QIULongValidator (0, 255, this));
mLeIOPort->setValidator (new QIULongValidator (0, 0xFFFF, this));
mLePath->setValidator (new QRegExpValidator (QRegExp (".+"), this));
/* Setup constraints */
mLeIRQ->setFixedWidth (mLeIRQ->fontMetrics().width ("8888"));
mLeIOPort->setFixedWidth (mLeIOPort->fontMetrics().width ("8888888"));
/* Set initial values */
/* Note: If you change one of the following don't forget retranslateUi. */
mCbNumber->insertItem (0, vboxGlobal().toCOMPortName (0, 0));
mCbNumber->insertItems (0, vboxGlobal().COMPortNames());
mCbMode->addItem (""); /* KPortMode_Disconnected */
mCbMode->addItem (""); /* KPortMode_HostPipe */
mCbMode->addItem (""); /* KPortMode_HostDevice */
mCbMode->addItem (""); /* KPortMode_RawFile */
/* Setup connections */
connect (mGbSerial, SIGNAL (toggled (bool)),
this, SLOT (mGbSerialToggled (bool)));
connect (mCbNumber, SIGNAL (activated (const QString &)),
this, SLOT (mCbNumberActivated (const QString &)));
connect (mCbMode, SIGNAL (activated (const QString &)),
this, SLOT (mCbModeActivated (const QString &)));
/* Applying language settings */
retranslateUi();
}
void UIMachineWindowSeamless::placeOnScreen()
{
/* Get corresponding screen: */
int iScreen = qobject_cast<UIMachineLogicSeamless*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
/* Calculate working area: */
QRect workingArea = vboxGlobal().availableGeometry(iScreen);
/* Move to the appropriate position: */
move(workingArea.topLeft());
/* Resize to the appropriate size: */
resize(workingArea.size());
/* Process pending move & resize events: */
qApp->processEvents();
}
void UIMachineSettingsSerial::mCbNumberActivated (const QString &aText)
{
ulong IRQ, IOBase;
bool std = vboxGlobal().toCOMPortNumbers (aText, IRQ, IOBase);
mLeIRQ->setEnabled (!std);
mLeIOPort->setEnabled (!std);
if (std)
{
mLeIRQ->setText (QString::number (IRQ));
mLeIOPort->setText ("0x" + QString::number (IOBase, 16).toUpper());
}
}
void UIMachineWindowFullscreen::handleNativeNotification(const QString &strNativeNotificationName)
{
/* Make sure this method is only used for ML and next: */
AssertReturnVoid(vboxGlobal().osRelease() > MacOSXRelease_Lion);
/* Log all arrived notifications: */
LogRel(("UIMachineWindowFullscreen::handleNativeNotification: Notification '%s' received.\n",
strNativeNotificationName.toAscii().constData()));
/* Handle 'NSWindowWillEnterFullScreenNotification' notification: */
if (strNativeNotificationName == "NSWindowWillEnterFullScreenNotification")
{
LogRel(("UIMachineWindowFullscreen::handleNativeNotification: "
"Native fullscreen mode about to enter, notifying listener...\n"));
emit sigNotifyAboutNativeFullscreenWillEnter();
}
/* Handle 'NSWindowDidEnterFullScreenNotification' notification: */
else if (strNativeNotificationName == "NSWindowDidEnterFullScreenNotification")
{
/* Mark window transition complete: */
m_fIsInFullscreenTransition = false;
LogRel(("UIMachineWindowFullscreen::handleNativeNotification: "
"Native fullscreen mode entered, notifying listener...\n"));
emit sigNotifyAboutNativeFullscreenDidEnter();
}
/* Handle 'NSWindowWillExitFullScreenNotification' notification: */
else if (strNativeNotificationName == "NSWindowWillExitFullScreenNotification")
{
LogRel(("UIMachineWindowFullscreen::handleNativeNotification: "
"Native fullscreen mode about to exit, notifying listener...\n"));
emit sigNotifyAboutNativeFullscreenWillExit();
}
/* Handle 'NSWindowDidExitFullScreenNotification' notification: */
else if (strNativeNotificationName == "NSWindowDidExitFullScreenNotification")
{
/* Mark window transition complete: */
m_fIsInFullscreenTransition = false;
LogRel(("UIMachineWindowFullscreen::handleNativeNotification: "
"Native fullscreen mode exited, notifying listener...\n"));
emit sigNotifyAboutNativeFullscreenDidExit();
}
/* Handle 'NSWindowDidFailToEnterFullScreenNotification' notification: */
else if (strNativeNotificationName == "NSWindowDidFailToEnterFullScreenNotification")
{
/* Mark window transition complete: */
m_fIsInFullscreenTransition = false;
LogRel(("UIMachineWindowFullscreen::handleNativeNotification: "
"Native fullscreen mode fail to enter, notifying listener...\n"));
emit sigNotifyAboutNativeFullscreenFailToEnter();
}
}
bool UIWizardCloneVD::copyVirtualDisk()
{
/* Gather attributes: */
CMedium sourceVirtualDisk = field("sourceVirtualDisk").value<CMedium>();
CMediumFormat mediumFormat = field("mediumFormat").value<CMediumFormat>();
qulonglong uVariant = field("mediumVariant").toULongLong();
QString strMediumPath = field("mediumPath").toString();
qulonglong uSize = field("mediumSize").toULongLong();
/* Check attributes: */
AssertReturn(!strMediumPath.isNull(), false);
AssertReturn(uSize > 0, false);
/* Get VBox object: */
CVirtualBox vbox = vboxGlobal().virtualBox();
/* Create new virtual-disk: */
CMedium virtualDisk = vbox.CreateHardDisk(mediumFormat.GetName(), strMediumPath);
CProgress progress;
if (!vbox.isOk())
{
msgCenter().cannotCreateHardDiskStorage(this, vbox, strMediumPath, virtualDisk, progress);
return false;
}
/* Copy existing virtual-disk to the new virtual-disk: */
progress = sourceVirtualDisk.CloneTo(virtualDisk, uVariant, CMedium());
if (!virtualDisk.isOk())
{
msgCenter().cannotCreateHardDiskStorage(this, vbox, strMediumPath, virtualDisk, progress);
return false;
}
/* Show creation progress: */
msgCenter().showModalProgressDialog(progress, windowTitle(), ":/progress_media_create_90px.png", this, true);
if (progress.GetCanceled())
return false;
if (!progress.isOk() || progress.GetResultCode() != 0)
{
msgCenter().cannotCreateHardDiskStorage(this, vbox, strMediumPath, virtualDisk, progress);
return false;
}
/* Remember created virtual-disk: */
m_virtualDisk = virtualDisk;
/* Just close the created medium, it is not necessary yet: */
m_virtualDisk.Close();
return true;
}
void UIMachineWindowScale::prepareVisualState()
{
/* Call to base-class: */
UIMachineWindow::prepareVisualState();
/* Beta label? */
if (vboxGlobal().isBeta())
{
QPixmap betaLabel = ::betaLabel(QSize(100, 16));
::darwinLabelWindow(this, &betaLabel, true);
}
/* For 'Yosemite' and above: */
if (vboxGlobal().osRelease() >= MacOSXRelease_Yosemite)
{
/* Enable fullscreen support for every screen which requires it: */
if (darwinScreensHaveSeparateSpaces() || m_uScreenId == 0)
darwinEnableFullscreenSupport(this);
/* Register 'Zoom' button to use our full-screen: */
UICocoaApplication::instance()->registerCallbackForStandardWindowButton(this, StandardWindowButtonType_Zoom,
UIMachineWindow::handleStandardWindowButtonCallback);
}
}
UIWizardNewVMPageBasic2::UIWizardNewVMPageBasic2()
{
/* Create widget: */
QVBoxLayout *pMainLayout = new QVBoxLayout(this);
{
m_pLabel = new QIRichTextLabel(this);
QGridLayout *pMemoryLayout = new QGridLayout;
{
m_pRamSlider = new VBoxGuestRAMSlider(this);
{
m_pRamSlider->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
m_pRamSlider->setOrientation(Qt::Horizontal);
}
m_pRamEditor = new QSpinBox(this);
{
m_pRamEditor->setMinimum(m_pRamSlider->minRAM());
m_pRamEditor->setMaximum(m_pRamSlider->maxRAM());
vboxGlobal().setMinimumWidthAccordingSymbolCount(m_pRamEditor, 5);
}
m_pRamUnits = new QLabel(this);
{
m_pRamUnits->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
}
m_pRamMin = new QLabel(this);
{
m_pRamMin->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
}
m_pRamMax = new QLabel(this);
{
m_pRamMax->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
}
pMemoryLayout->addWidget(m_pRamSlider, 0, 0, 1, 3);
pMemoryLayout->addWidget(m_pRamEditor, 0, 3);
pMemoryLayout->addWidget(m_pRamUnits, 0, 4);
pMemoryLayout->addWidget(m_pRamMin, 1, 0);
pMemoryLayout->setColumnStretch(1, 1);
pMemoryLayout->addWidget(m_pRamMax, 1, 2);
}
pMainLayout->addWidget(m_pLabel);
pMainLayout->addLayout(pMemoryLayout);
pMainLayout->addStretch();
}
/* Setup connections: */
connect(m_pRamSlider, SIGNAL(valueChanged(int)), this, SLOT(sltRamSliderValueChanged()));
connect(m_pRamEditor, SIGNAL(valueChanged(int)), this, SLOT(sltRamEditorValueChanged()));
/* Register fields: */
registerField("ram", m_pRamSlider, "value", SIGNAL(valueChanged(int)));
}
UIDownloaderUserManual::UIDownloaderUserManual()
{
/* Prepare instance: */
if (!s_pInstance)
s_pInstance = this;
/* Get version number and adjust it for test and trunk builds. The server only has official releases. */
const QString strVersion = UIVersion(vboxGlobal().vboxVersionStringNormalized()).effectiveReleasedVersion().toString();
/* Compose User Manual filename: */
QString strUserManualFullFileName = vboxGlobal().helpFile();
QString strUserManualShortFileName = QFileInfo(strUserManualFullFileName).fileName();
/* Add sources: */
QString strSource1 = QString("https://download.virtualbox.org/virtualbox/%1/").arg(strVersion) + strUserManualShortFileName;
QString strSource2 = QString("https://download.virtualbox.org/virtualbox/") + strUserManualShortFileName;
addSource(strSource1);
addSource(strSource2);
/* Set target: */
QString strUserManualDestination = QDir(vboxGlobal().homeFolder()).absoluteFilePath(strUserManualShortFileName);
setTarget(strUserManualDestination);
}
/* Insert hard-disks to the passed uimedium map.
* Get existing one from the previous map if any. */
foreach (CMedium medium, inputMediums)
{
/* If VBoxGlobal is cleaning up, abort immediately: */
if (vboxGlobal().isCleaningUp())
break;
/* Prepare uimedium on the basis of current medium: */
QString strMediumID = medium.GetId();
UIMedium uimedium = m_mediums.contains(strMediumID) ? m_mediums[strMediumID] :
UIMedium(medium, mediumType);
/* Insert uimedium into map: */
outputMediums.insert(uimedium.id(), uimedium);
}
UIGInformationElementInterface::UIGInformationElementInterface(UIGInformationSet *pParent, DetailsElementType type, bool fOpened)
: UIGInformationElement(pParent, type, fOpened)
, m_pTask(0)
{
/* Assign corresponding icon: */
setIcon(gpConverter->toIcon(elementType()));
/* Listen for the global thread-pool: */
connect(vboxGlobal().threadPool(), SIGNAL(sigTaskComplete(UITask*)),
this, SLOT(sltUpdateAppearanceFinished(UITask*)));
/* Translate finally: */
retranslateUi();
}
void UITextEditor::open()
{
QString fileName = QIFileDialog::getOpenFileName(vboxGlobal().documentsPath(), tr("Text (*.txt);;All (*.*)"), this, tr("Select a file to open..."));
if (!fileName.isEmpty())
{
QFile file(fileName);
if (file.open(QFile::ReadOnly))
{
QTextStream in(&file);
m_pTextEdit->setPlainText(in.readAll());
}
}
}
void UIVMInformationDialog::saveSettings()
{
/* Save window geometry: */
{
/* Save geometry: */
#ifdef VBOX_WS_MAC
gEDataManager->setInformationWindowGeometry(m_geometry, ::darwinIsWindowMaximized(this), vboxGlobal().managedVMUuid());
#else /* VBOX_WS_MAC */
gEDataManager->setInformationWindowGeometry(m_geometry, isMaximized(), vboxGlobal().managedVMUuid());
#endif /* !VBOX_WS_MAC */
LogRel2(("GUI: UIVMInformationDialog: Geometry saved as: Origin=%dx%d, Size=%dx%d\n",
m_geometry.x(), m_geometry.y(), m_geometry.width(), m_geometry.height()));
}
}
void UIMachineWindowScale::prepareVisualState()
{
/* Call to base-class: */
UIMachineWindow::prepareVisualState();
/* Install the resize delegate for keeping the aspect ratio. */
::darwinInstallResizeDelegate(this);
/* Beta label? */
if (vboxGlobal().isBeta())
{
QPixmap betaLabel = ::betaLabel(QSize(100, 16));
::darwinLabelWindow(this, &betaLabel, true);
}
}
/* Load data to cache from corresponding external object(s),
* this task COULD be performed in other than GUI thread: */
void UIGlobalSettingsExtension::loadToCacheFrom(QVariant &data)
{
/* Fetch data to properties & settings: */
UISettingsPageGlobal::fetchData(data);
/* Load to cache: */
const CExtPackManager &manager = vboxGlobal().virtualBox().GetExtensionPackManager();
const CExtPackVector &packages = manager.GetInstalledExtPacks();
for (int i = 0; i < packages.size(); ++i)
m_cache.m_items << fetchData(packages[i]);
/* Upload properties & settings to data: */
UISettingsPageGlobal::uploadData(data);
}
void UIWizardExportAppPage2::chooseDefaultStorageType()
{
/* Select default storage type: */
#if 0
/* Load storage-type from GUI extra data: */
bool ok;
StorageType storageType = StorageType(vboxGlobal().virtualBox().GetExtraData(GUI_Export_StorageType).toInt(&ok));
if (ok)
setStorageType(storageType);
#else
/* Just select first of types: */
setStorageType(Filesystem);
#endif
}
void UIMachineViewFullscreen::maybeRestrictMinimumSize()
{
/* Sets the minimum size restriction depending on the auto-resize feature state and the current rendering mode.
* Currently, the restriction is set only in SDL mode and only when the auto-resize feature is inactive.
* We need to do that because we cannot correctly draw in a scrolled window in SDL mode.
* In all other modes, or when auto-resize is in force, this function does nothing. */
if (vboxGlobal().vmRenderMode() == SDLMode)
{
if (!uisession()->isGuestSupportsGraphics() || !m_bIsGuestAutoresizeEnabled)
setMinimumSize(sizeHint());
else
setMinimumSize(0, 0);
}
}
void UIMachineLogicSeamless::prepareMachineWindows()
{
/* Do not create machine-window(s) if they created already: */
if (isMachineWindowsCreated())
return;
#ifdef VBOX_WS_MAC
/* We have to make sure that we are getting the front most process.
* This is necessary for Qt versions > 4.3.3: */
darwinSetFrontMostProcess();
#endif /* VBOX_WS_MAC */
/* Update the multi-screen layout: */
m_pScreenLayout->update();
/* Create machine-window(s): */
for (uint cScreenId = 0; cScreenId < machine().GetMonitorCount(); ++cScreenId)
addMachineWindow(UIMachineWindow::create(this, cScreenId));
/* Listen for frame-buffer resize: */
foreach (UIMachineWindow *pMachineWindow, machineWindows())
connect(pMachineWindow, SIGNAL(sigFrameBufferResize()),
this, SIGNAL(sigFrameBufferResize()));
emit sigFrameBufferResize();
/* Connect multi-screen layout change handler: */
connect(m_pScreenLayout, SIGNAL(sigScreenLayoutChange()),
this, SLOT(sltScreenLayoutChanged()));
/* Mark machine-window(s) created: */
setMachineWindowsCreated(true);
#ifdef VBOX_WS_X11
switch (vboxGlobal().typeOfWindowManager())
{
case X11WMType_GNOMEShell:
case X11WMType_Mutter:
{
// WORKAROUND:
// Under certain WMs we can loose machine-window activation due to any Qt::Tool
// overlay asynchronously shown above it. Qt is not become aware of such event.
// We are going to ask to return machine-window activation in let's say 100ms.
QTimer::singleShot(100, machineWindows().first(), SLOT(sltActivateWindow()));
break;
}
default:
break;
}
#endif /* VBOX_WS_X11 */
}
void UIGInformationElementInterface::updateAppearance()
{
/* Call to base-class: */
UIGInformationElement::updateAppearance();
/* Prepare/start update task: */
if (!m_pTask)
{
/* Prepare update task: */
m_pTask = createUpdateTask();
/* Post task into global thread-pool: */
vboxGlobal().threadPool()->enqueueTask(m_pTask);
}
}
void UIWizardNewVMPage3::getWithFileOpenDialog()
{
/* Get opened medium id: */
QString strMediumId = vboxGlobal().openMediumWithFileOpenDialog(UIMediumType_HardDisk, thisImp());
if (!strMediumId.isNull())
{
/* Update medium-combo if necessary: */
m_pDiskSelector->setCurrentItem(strMediumId);
/* Update hard disk source: */
updateVirtualDiskSource();
/* Focus on hard disk combo: */
m_pDiskSelector->setFocus();
}
}
UIDownloaderAdditions::UIDownloaderAdditions()
{
/* Prepare instance: */
if (!m_spInstance)
m_spInstance = this;
/* Get version number and adjust it for test and trunk builds, both have
odd build numbers. The server only has official releases. */
QString strVersion = vboxGlobal().vboxVersionStringNormalized();
QChar qchLastDigit = strVersion[strVersion.length() - 1];
if ( qchLastDigit == '1'
|| qchLastDigit == '3'
|| qchLastDigit == '5'
|| qchLastDigit == '7'
|| qchLastDigit == '9')
{
if ( !strVersion.endsWith(".51")
&& !strVersion.endsWith(".53")
&& !strVersion.endsWith(".97")
&& !strVersion.endsWith(".99"))
strVersion[strVersion.length() - 1] = qchLastDigit.toLatin1() - 1;
else
{
strVersion.chop(2);
strVersion += "10"; /* Current for 5.0.x */
}
}
/* Prepare source/target: */
const QString &strName = QString("VBoxGuestAdditions_%1.iso").arg(strVersion);
const QString &strSource = QString("http://download.virtualbox.org/virtualbox/%1/").arg(strVersion) + strName;
const QString &strTarget = QDir(vboxGlobal().homeFolder()).absoluteFilePath(strName);
/* Set source/target: */
setSource(strSource);
setTarget(strTarget);
}
void VBoxSnapshotsWgt::sltRestoreSnapshot(bool fSuppressNonCriticalWarnings /* = false*/)
{
/* Get currently chosen item: */
SnapshotWgtItem *pItem = mTreeWidget->currentItem() ? static_cast<SnapshotWgtItem*>(mTreeWidget->currentItem()) : 0;
AssertReturn(pItem, (void)0);
/* Detemine snapshot id: */
QString strSnapshotId = pItem->snapshotId();
AssertReturn(!strSnapshotId.isNull(), (void)0);
/* Get currently desired snapshot: */
CSnapshot snapshot = mMachine.FindSnapshot(strSnapshotId);
/* Ask the user if he really wants to restore the snapshot: */
int iResultCode = AlertButton_Ok;
if (!fSuppressNonCriticalWarnings || mMachine.GetCurrentStateModified())
{
iResultCode = msgCenter().confirmSnapshotRestoring(snapshot.GetName(), mMachine.GetCurrentStateModified());
if (iResultCode & AlertButton_Cancel)
return;
}
/* If user also confirmed new snapshot creation: */
if (iResultCode & AlertOption_CheckBox)
{
/* Take snapshot of changed current state: */
mTreeWidget->setCurrentItem(curStateItem());
if (!takeSnapshot())
return;
}
/* Open a direct session (this call will handle all errors): */
CSession session = vboxGlobal().openSession(mMachineId);
if (session.isNull())
return;
/* Restore chosen snapshot: */
CConsole console = session.GetConsole();
CProgress progress = console.RestoreSnapshot(snapshot);
if (console.isOk())
{
msgCenter().showModalProgressDialog(progress, mMachine.GetName(), ":/progress_snapshot_restore_90px.png");
if (progress.GetResultCode() != 0)
msgCenter().cannotRestoreSnapshot(progress, snapshot.GetName(), mMachine.GetName());
}
else
msgCenter().cannotRestoreSnapshot(console, snapshot.GetName(), mMachine.GetName());
/* Unlock machine finally: */
session.UnlockMachine();
}
void VBoxOSTypeSelectorWidget::onFamilyChanged (int aIndex)
{
/* Lock the signals of mCbType to prevent it's reaction on clearing */
mCbType->blockSignals (true);
mCbType->clear();
/* Populate combo-box with OS Types related to currently selected Family ID */
QString familyId (mCbFamily->itemData (aIndex, RoleTypeID).toString());
QList <CGuestOSType> types (vboxGlobal().vmGuestOSTypeList (familyId));
for (int i = 0; i < types.size(); ++ i)
{
if (types [i].GetIs64Bit() && (!m_fSupportsHWVirtEx || !m_fSupportsLongMode))
continue;
int index = mCbType->count();
mCbType->insertItem (index, types [i].GetDescription());
mCbType->setItemData (index, types [i].GetId(), RoleTypeID);
}
/* Select the most recently chosen item */
if (mCurrentIds.contains (familyId))
{
QString typeId (mCurrentIds [familyId]);
int typeIndex = mCbType->findData (typeId, RoleTypeID);
if (typeIndex != -1)
mCbType->setCurrentIndex (typeIndex);
}
/* Or select WinXP item for Windows family as default */
else if (familyId == "Windows")
{
int xpIndex = mCbType->findData ("WindowsXP", RoleTypeID);
if (xpIndex != -1)
mCbType->setCurrentIndex (xpIndex);
}
/* Or select Ubuntu item for Linux family as default */
else if (familyId == "Linux")
{
int ubIndex = mCbType->findData ("Ubuntu", RoleTypeID);
if (ubIndex != -1)
mCbType->setCurrentIndex (ubIndex);
}
/* Else simply select the first one present */
else mCbType->setCurrentIndex (0);
/* Update all the stuff with new type */
onTypeChanged (mCbType->currentIndex());
/* Unlock the signals of mCbType */
mCbType->blockSignals (false);
}
/* Load data to cache from corresponding external object(s),
* this task COULD be performed in other than GUI thread: */
void UIGlobalSettingsUpdate::loadToCacheFrom(QVariant &data)
{
/* Fetch data to properties & settings: */
UISettingsPageGlobal::fetchData(data);
/* Fill internal variables with corresponding values: */
VBoxUpdateData updateData(vboxGlobal().virtualBox().GetExtraData(GUI_UpdateDate));
m_cache.m_fCheckEnabled = !updateData.isNoNeedToCheck();
m_cache.m_periodIndex = updateData.periodIndex();
m_cache.m_branchIndex = updateData.branchIndex();
m_cache.m_strDate = updateData.date();
/* Upload properties & settings to data: */
UISettingsPageGlobal::uploadData(data);
}
void UIMachineSettingsParallel::polishTab()
{
/* Polish port page: */
ulong uIRQ, uIOBase;
bool fStd = vboxGlobal().toCOMPortNumbers(mCbNumber->currentText(), uIRQ, uIOBase);
mGbParallel->setEnabled(m_pParent->isMachineOffline());
mLbNumber->setEnabled(m_pParent->isMachineOffline());
mCbNumber->setEnabled(m_pParent->isMachineOffline());
mLbIRQ->setEnabled(m_pParent->isMachineOffline());
mLeIRQ->setEnabled(!fStd && m_pParent->isMachineOffline());
mLbIOPort->setEnabled(m_pParent->isMachineOffline());
mLeIOPort->setEnabled(!fStd && m_pParent->isMachineOffline());
mLbPath->setEnabled(m_pParent->isMachineOffline());
mLePath->setEnabled(m_pParent->isMachineOffline());
}
int UINetworkReplyPrivateThread::applyProxyRules()
{
/* Set thread context: */
m_strContext = tr("During proxy configuration");
/* Make sure proxy is enabled in Proxy Manager: */
UIProxyManager proxyManager(vboxGlobal().settings().proxySettings());
if (!proxyManager.proxyEnabled())
return VINF_SUCCESS;
/* Apply proxy rules: */
return applyProxyRules(m_pHttp,
proxyManager.proxyHost(),
proxyManager.proxyPort().toUInt());
}
UIDownloaderExtensionPack::UIDownloaderExtensionPack()
{
/* Prepare instance: */
if (!m_spInstance)
m_spInstance = this;
/* Set description: */
setDescription(tr("VirtualBox Extension Pack"));
/* Prepare source/target: */
QString strExtPackUnderscoredName(QString(GUI_ExtPackName).replace(' ', '_'));
QString strTemplateSourcePath("http://download.virtualbox.org/virtualbox/%1/");
QString strTemplateSourceName(QString("%1-%2.vbox-extpack").arg(strExtPackUnderscoredName));
QString strSourcePath(strTemplateSourcePath.arg(vboxGlobal().vboxVersionStringNormalized()));
QString strSourceName(strTemplateSourceName.arg(vboxGlobal().vboxVersionStringNormalized()));
QString strSource(strSourcePath + strSourceName);
QString strTargetPath(vboxGlobal().virtualBox().GetHomeFolder());
QString strTargetName(strSourceName);
QString strTarget(QDir(strTargetPath).absoluteFilePath(strTargetName));
/* Set source/target: */
setSource(strSource);
setTarget(strTarget);
}
void UIVMPreviewWindow::setUpdateInterval(UpdateInterval interval, bool fSave)
{
switch (interval)
{
case UpdateDisabled:
{
if (fSave)
vboxGlobal().virtualBox().SetExtraData(VBoxDefs::GUI_PreviewUpdate, "disabled");
m_pUpdateTimer->setInterval(0);
m_pUpdateTimer->stop();
m_actions[interval]->setChecked(true);
break;
}
case Update500ms:
{
if (fSave)
vboxGlobal().virtualBox().SetExtraData(VBoxDefs::GUI_PreviewUpdate, "500");
m_pUpdateTimer->setInterval(500);
m_actions[interval]->setChecked(true);
break;
}
case Update1000ms:
{
if (fSave)
vboxGlobal().virtualBox().SetExtraData(VBoxDefs::GUI_PreviewUpdate, "1000");
m_pUpdateTimer->setInterval(1000);
m_actions[interval]->setChecked(true);
break;
}
case Update2000ms:
{
if (fSave)
vboxGlobal().virtualBox().SetExtraData(VBoxDefs::GUI_PreviewUpdate, "2000");
m_pUpdateTimer->setInterval(2000);
m_actions[interval]->setChecked(true);
break;
}
case Update5000ms:
{
if (fSave)
vboxGlobal().virtualBox().SetExtraData(VBoxDefs::GUI_PreviewUpdate, "5000");
m_pUpdateTimer->setInterval(5000);
m_actions[interval]->setChecked(true);
break;
}
case Update10000ms:
{
if (fSave)
vboxGlobal().virtualBox().SetExtraData(VBoxDefs::GUI_PreviewUpdate, "10000");
m_pUpdateTimer->setInterval(10000);
m_actions[interval]->setChecked(true);
break;
}
case UpdateEnd: break;
}
}
