/**
* Releases the kernel module and closes its CTF data.
*
* @param pMod Pointer to the module handle.
* @param pCTF Pointer to the module's CTF handle.
*/
static void rtR0DbgKrnlInfoModRelease(modctl_t *pMod, ctf_file_t *pCTF)
{
AssertPtrReturnVoid(pMod);
AssertPtrReturnVoid(pCTF);
ctf_close(pCTF);
}
/**
* Get the information needed to map the area used by the host to send back
* requests.
*
* @param pCtx the context containing the heap to use
* @param cbVRAM how much video RAM is allocated to the device
* @param offVRAMBaseMapping the offset of the basic communication structures
* into the guest's VRAM
* @param poffVRAMHostArea where to store the offset into VRAM of the host
* heap area
* @param pcbHostArea where to store the size of the host heap area
*/
RTDECL(void) VBoxHGSMIGetHostAreaMapping(PHGSMIGUESTCOMMANDCONTEXT pCtx,
uint32_t cbVRAM,
uint32_t offVRAMBaseMapping,
uint32_t *poffVRAMHostArea,
uint32_t *pcbHostArea)
{
uint32_t offVRAMHostArea = offVRAMBaseMapping, cbHostArea = 0;
AssertPtrReturnVoid(poffVRAMHostArea);
AssertPtrReturnVoid(pcbHostArea);
VBoxQueryConfHGSMI(pCtx, VBOX_VBVA_CONF32_HOST_HEAP_SIZE, &cbHostArea);
if (cbHostArea != 0)
{
uint32_t cbHostAreaMaxSize = cbVRAM / 4;
/** @todo what is the idea of this? */
if (cbHostAreaMaxSize >= VBVA_ADAPTER_INFORMATION_SIZE)
{
cbHostAreaMaxSize -= VBVA_ADAPTER_INFORMATION_SIZE;
}
if (cbHostArea > cbHostAreaMaxSize)
{
cbHostArea = cbHostAreaMaxSize;
}
/* Round up to 4096 bytes. */
cbHostArea = (cbHostArea + 0xFFF) & ~0xFFF;
offVRAMHostArea = offVRAMBaseMapping - cbHostArea;
}
*pcbHostArea = cbHostArea;
*poffVRAMHostArea = offVRAMHostArea;
LogFunc(("offVRAMHostArea = 0x%08X, cbHostArea = 0x%08X\n",
offVRAMHostArea, cbHostArea));
}
void UISettingsSerializerProgress::sltHandleOperationProgressChange(ulong iOperations, QString strOperation,
ulong iOperation, ulong iPercent)
{
/* Update the sub-operation progress label and bar: */
AssertPtrReturnVoid(m_pLabelSubOperationProgress);
AssertPtrReturnVoid(m_pBarSubOperationProgress);
m_pLabelSubOperationProgress->show();
m_pBarSubOperationProgress->show();
m_pLabelSubOperationProgress->setText(s_strProgressDescriptionTemplate.arg(strOperation).arg(iOperation).arg(iOperations));
m_pBarSubOperationProgress->setValue(iPercent);
}
DECLINLINE(void) tftpProcessRRQ(PNATState pData, PCTFTPIPHDR pTftpIpHeader, int pktlen)
{
PTFTPSESSION pTftpSession = NULL;
uint8_t *pu8Payload = NULL;
int cbPayload = 0;
size_t cbFileName = 0;
int rc = VINF_SUCCESS;
AssertPtrReturnVoid(pTftpIpHeader);
AssertPtrReturnVoid(pData);
AssertReturnVoid(pktlen > sizeof(TFTPIPHDR));
LogFlowFunc(("ENTER: pTftpIpHeader:%p, pktlen:%d\n", pTftpIpHeader, pktlen));
rc = tftpAllocateSession(pData, pTftpIpHeader, &pTftpSession);
if ( RT_FAILURE(rc)
|| pTftpSession == NULL)
{
LogFlowFuncLeave();
return;
}
pu8Payload = (uint8_t *)&pTftpIpHeader->Core;
cbPayload = pktlen - sizeof(TFTPIPHDR);
cbFileName = RTStrNLen((char *)pu8Payload, cbPayload);
/* We assume that file name should finish with '\0' and shouldn't bigger
* than buffer for name storage.
*/
AssertReturnVoid( cbFileName < cbPayload
&& cbFileName < TFTP_FILENAME_MAX /* current limit in tftp session handle */
&& cbFileName);
/* Dont't bother with rest processing in case of invalid access */
if (RT_FAILURE(tftpSecurityFilenameCheck(pData, pTftpSession)))
{
tftpSendError(pData, pTftpSession, 2, "Access violation", pTftpIpHeader);
LogFlowFuncLeave();
return;
}
if (RT_UNLIKELY(!tftpIsSupportedTransferMode(pTftpSession)))
{
tftpSendError(pData, pTftpSession, 4, "Unsupported transfer mode", pTftpIpHeader);
LogFlowFuncLeave();
return;
}
tftpSendOACK(pData, pTftpSession, pTftpIpHeader);
LogFlowFuncLeave();
return;
}
void Display::getFramebufferDimensions(int32_t *px1, int32_t *py1,
int32_t *px2, int32_t *py2)
{
AssertPtrReturnVoid(px1);
AssertPtrReturnVoid(py1);
AssertPtrReturnVoid(px2);
AssertPtrReturnVoid(py2);
*px1 = 0;
*py1 = 0;
*px2 = getWidth();
*py2 = getHeight();
}
/* static */
void UIDnDEnumFormatEtc::CopyFormat(FORMATETC *pDest, FORMATETC *pSource)
{
AssertPtrReturnVoid(pDest);
AssertPtrReturnVoid(pSource);
*pDest = *pSource;
if (pSource->ptd)
{
pDest->ptd = (DVTARGETDEVICE*)CoTaskMemAlloc(sizeof(DVTARGETDEVICE));
*(pDest->ptd) = *(pSource->ptd);
}
}
static void paStreamCbSuccess(pa_stream *pStream, int fSuccess, void *pvUser)
{
AssertPtrReturnVoid(pStream);
PPULSEAUDIOSTREAM pStrm = (PPULSEAUDIOSTREAM)pvUser;
AssertPtrReturnVoid(pStrm);
pStrm->fOpSuccess = fSuccess;
if (fSuccess)
paSignalWaiter(pStrm->pDrv);
else
paError(pStrm->pDrv, "Failed to finish stream operation");
}
static void drvHostPulseAudioCbSuccess(pa_stream *pStream, int fSuccess, void *pvContext)
{
AssertPtrReturnVoid(pStream);
PPULSEAUDIOSTREAM pStrm = (PPULSEAUDIOSTREAM)pvContext;
AssertPtrReturnVoid(pStrm);
pStrm->fOpSuccess = fSuccess;
if (fSuccess)
drvHostPulseAudioAbortMainLoop();
else
drvHostPulseAudioError(pStrm->pDrv, "Failed to finish stream operation");
}
void UIMachineSettingsGeneral::putToCache()
{
/* Prepare general data: */
UIDataSettingsMachineGeneral generalData = m_cache.base();
/* 'Basic' tab data: */
AssertPtrReturnVoid(m_pNameAndSystemEditor);
generalData.m_strName = m_pNameAndSystemEditor->name();
generalData.m_strGuestOsTypeId = m_pNameAndSystemEditor->type().GetId();
/* 'Advanced' tab data: */
AssertPtrReturnVoid(mPsSnapshot);
AssertPtrReturnVoid(mCbClipboard);
AssertPtrReturnVoid(mCbDragAndDrop);
generalData.m_strSnapshotsFolder = mPsSnapshot->path();
generalData.m_clipboardMode = (KClipboardMode)mCbClipboard->currentIndex();
generalData.m_dndMode = (KDnDMode)mCbDragAndDrop->currentIndex();
/* 'Description' tab data: */
AssertPtrReturnVoid(mTeDescription);
generalData.m_strDescription = mTeDescription->toPlainText().isEmpty() ?
QString::null : mTeDescription->toPlainText();
/* 'Encryption' tab data: */
AssertPtrReturnVoid(m_pCheckBoxEncryption);
AssertPtrReturnVoid(m_pComboCipher);
AssertPtrReturnVoid(m_pEditorEncryptionPassword);
generalData.m_fEncryptionEnabled = m_pCheckBoxEncryption->isChecked();
generalData.m_fEncryptionCipherChanged = m_fEncryptionCipherChanged;
generalData.m_fEncryptionPasswordChanged = m_fEncryptionPasswordChanged;
generalData.m_iEncryptionCipherIndex = m_pComboCipher->currentIndex();
generalData.m_strEncryptionPassword = m_pEditorEncryptionPassword->text();
/* If encryption status, cipher or password is changed: */
if (generalData.m_fEncryptionEnabled != m_cache.base().m_fEncryptionEnabled ||
generalData.m_fEncryptionCipherChanged != m_cache.base().m_fEncryptionCipherChanged ||
generalData.m_fEncryptionPasswordChanged != m_cache.base().m_fEncryptionPasswordChanged)
{
/* Ask for the disk encryption passwords if necessary: */
if (!m_cache.base().m_encryptedMediums.isEmpty())
{
/* Create corresponding dialog: */
QWidget *pDlgParent = windowManager().realParentWindow(window());
QPointer<UIAddDiskEncryptionPasswordDialog> pDlg =
new UIAddDiskEncryptionPasswordDialog(pDlgParent,
generalData.m_strName,
generalData.m_encryptedMediums);
/* Execute it and acquire the result: */
if (pDlg->exec() == QDialog::Accepted)
generalData.m_encryptionPasswords = pDlg->encryptionPasswords();
/* Delete dialog if still valid: */
if (pDlg)
delete pDlg;
}
}
/* Cache general data: */
m_cache.cacheCurrentData(generalData);
}
void UIHostNetworkManagerWidget::prepareTreeWidget()
{
/* Create tree-widget: */
m_pTreeWidget = new QITreeWidget;
AssertPtrReturnVoid(m_pTreeWidget);
{
/* Configure tree-widget: */
m_pTreeWidget->setRootIsDecorated(false);
m_pTreeWidget->setAlternatingRowColors(true);
m_pTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
m_pTreeWidget->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_pTreeWidget->setColumnCount(Column_Max);
m_pTreeWidget->setSortingEnabled(true);
m_pTreeWidget->sortByColumn(Column_Name, Qt::AscendingOrder);
m_pTreeWidget->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Expanding);
connect(m_pTreeWidget, &QITreeWidget::currentItemChanged,
this, &UIHostNetworkManagerWidget::sltHandleCurrentItemChange);
connect(m_pTreeWidget, &QITreeWidget::customContextMenuRequested,
this, &UIHostNetworkManagerWidget::sltHandleContextMenuRequest);
connect(m_pTreeWidget, &QITreeWidget::itemChanged,
this, &UIHostNetworkManagerWidget::sltHandleItemChange);
connect(m_pTreeWidget, &QITreeWidget::itemDoubleClicked,
m_pActionPool->action(UIActionIndexST_M_Network_T_Details), &QAction::setChecked);
/* Add into layout: */
layout()->addWidget(m_pTreeWidget);
}
}
void UIMachineWindowFullscreen::adjustMachineViewSize()
{
/* Call to base-class: */
UIMachineWindow::adjustMachineViewSize();
#ifndef Q_WS_MAC
/* If mini-toolbar present: */
if (m_pMiniToolBar)
{
/* Make sure this window has fullscreen logic: */
const UIMachineLogicFullscreen *pFullscreenLogic = qobject_cast<UIMachineLogicFullscreen*>(machineLogic());
AssertPtrReturnVoid(pFullscreenLogic);
/* Which host-screen should that machine-window located on? */
const int iHostScreen = pFullscreenLogic->hostScreenForGuestScreen(m_uScreenId);
#ifndef Q_WS_X11
/* Move mini-toolbar into appropriate place: */
m_pMiniToolBar->adjustGeometry(iHostScreen);
#else /* Q_WS_X11 */
/* On modern WMs we are mapping mini-toolbar to corresponding host-screen directly. */
const bool fSupportsNativeFullScreen = VBoxGlobal::supportsFullScreenMonitorsProtocolX11() &&
!gEDataManager->legacyFullscreenModeRequested();
/* Adjust mini-toolbar and move into appropriate place if necessary: */
m_pMiniToolBar->adjustGeometry(fSupportsNativeFullScreen ? -1 : iHostScreen);
#endif /* Q_WS_X11 */
}
#endif /* !Q_WS_MAC */
}
void UIActionPool::updateMenuHelp()
{
/* Get corresponding menu: */
UIMenu *pMenu = action(UIActionIndex_Menu_Help)->menu();
AssertPtrReturnVoid(pMenu);
/* Clear contents: */
pMenu->clear();
/* Separator? */
bool fSeparator = false;
/* 'Contents' action: */
fSeparator = addAction(pMenu, action(UIActionIndex_Simple_Contents)) || fSeparator;;
/* 'Web Site' action: */
fSeparator = addAction(pMenu, action(UIActionIndex_Simple_WebSite)) || fSeparator;;
/* Separator? */
if (fSeparator)
{
pMenu->addSeparator();
fSeparator = false;
}
#ifndef RT_OS_DARWIN
/* 'About' action: */
fSeparator = addAction(pMenu, action(UIActionIndex_Simple_About)) || fSeparator;;
#endif /* !RT_OS_DARWIN */
/* Mark menu as valid: */
m_invalidations.remove(UIActionIndex_Menu_Help);
}
void UIHostNetworkManagerWidget::prepareToolBar()
{
/* Create toolbar: */
m_pToolBar = new UIToolBar(parentWidget());
AssertPtrReturnVoid(m_pToolBar);
{
/* Configure toolbar: */
const int iIconMetric = (int)(QApplication::style()->pixelMetric(QStyle::PM_LargeIconSize));
m_pToolBar->setIconSize(QSize(iIconMetric, iIconMetric));
m_pToolBar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
/* Add toolbar actions: */
m_pToolBar->addAction(m_pActionPool->action(UIActionIndexST_M_Network_S_Create));
m_pToolBar->addSeparator();
m_pToolBar->addAction(m_pActionPool->action(UIActionIndexST_M_Network_S_Remove));
m_pToolBar->addAction(m_pActionPool->action(UIActionIndexST_M_Network_T_Details));
// m_pToolBar->addSeparator();
// m_pToolBar->addAction(m_pActionPool->action(UIActionIndexST_M_Network_S_Refresh));
#ifdef VBOX_WS_MAC
/* Check whether we are embedded into a stack: */
if (m_enmEmbedding == EmbedTo_Stack)
{
/* Add into layout: */
layout()->addWidget(m_pToolBar);
}
#else
/* Add into layout: */
layout()->addWidget(m_pToolBar);
#endif
}
}
void UIPopupCenter::setPopupStackOrientation(QWidget *pParent, UIPopupStackOrientation newStackOrientation)
{
/* Make sure parent is set! */
AssertPtrReturnVoid(pParent);
/* Composing corresponding popup-stack ID: */
const QString strPopupStackID(popupStackID(pParent));
/* Looking for current popup-stack orientation, create if it doesn't exists: */
UIPopupStackOrientation &stackOrientation = m_stackOrientations[strPopupStackID];
/* Make sure stack-orientation has changed: */
if (stackOrientation == newStackOrientation)
return;
/* Remember new stack orientation: */
LogRelFlow(("UIPopupCenter::setPopupStackType: Changing orientation of popup-stack with ID = '%s' from '%s' to '%s'.\n",
strPopupStackID.toAscii().constData(),
stackOrientation == UIPopupStackOrientation_Top ? "top oriented" : "bottom oriented",
newStackOrientation == UIPopupStackOrientation_Top ? "top oriented" : "bottom oriented"));
stackOrientation = newStackOrientation;
/* Update orientation for popup-stack if it currently exists: */
if (m_stacks.contains(strPopupStackID))
m_stacks[strPopupStackID]->setOrientation(stackOrientation);
}
static void drvHostPulseAudioCbSuccess(pa_stream *pStream, int fSuccess, void *pvContext)
{
AssertPtrReturnVoid(pStream);
PPULSEAUDIOSTREAM pStrm = (PPULSEAUDIOSTREAM)pvContext;
AssertPtrReturnVoid(pStrm);
pStrm->fOpSuccess = fSuccess;
if (fSuccess)
{
pa_threaded_mainloop_signal(g_pMainLoop, 0 /* fWait */);
}
else
drvHostPulseAudioError(pStrm->pDrv, "Failed to finish stream operation");
}
void VBoxAboutDlg::prepareCloseButton()
{
/* Create button-box: */
QDialogButtonBox *pButtonBox = new QDialogButtonBox;
AssertPtrReturnVoid(pButtonBox);
{
/* Create close-button: */
QPushButton *pCloseButton = pButtonBox->addButton(QDialogButtonBox::Close);
AssertPtrReturnVoid(pCloseButton);
/* Prepare close-button: */
connect(pButtonBox, SIGNAL(rejected()), this, SLOT(reject()));
/* Add button-box to the main-layout: */
m_pMainLayout->addWidget(pButtonBox);
}
}
UIInformationItem::UIInformationItem(QObject *pParent)
: QStyledItemDelegate(pParent)
{
/* Create text-document: */
m_pTextDocument = new QTextDocument(this);
AssertPtrReturnVoid(m_pTextDocument);
}
void UIVMInformationDialog::prepareTabWidget()
{
/* Create tab-widget: */
m_pTabWidget = new QITabWidget;
AssertPtrReturnVoid(m_pTabWidget);
{
/* Create tabs: */
/* Create Configuration details tab: */
UIGInformation *pInformationWidget = new UIGInformation(this);
QList<UIVMItem*> items;
items << new UIVMItem(gpMachine->uisession()->machine());
pInformationWidget->setItems(items);
m_tabs.insert(0, pInformationWidget);
m_pTabWidget->addTab(m_tabs.value(0), QString());
for (int iTabIndex = 1; iTabIndex < 2; ++iTabIndex)
prepareTab(iTabIndex);
/* Configure tab-widget: */
m_pTabWidget->setTabIcon(0, UIIconPool::iconSet(":/session_info_details_16px.png"));
m_pTabWidget->setTabIcon(1, UIIconPool::iconSet(":/session_info_runtime_16px.png"));
m_pTabWidget->setCurrentIndex(1);
/* Add tab-widget into main-layout: */
centralWidget()->layout()->addWidget(m_pTabWidget);
}
}
void UIInformationModel::addItem(UIInformationDataItem *pItem)
{
/* Make sure item is valid: */
AssertPtrReturnVoid(pItem);
/* Add item: */
m_list.append(pItem);
}
void UIMachineWindowFullscreen::prepareMiniToolbar()
{
/* Make sure mini-toolbar is not restricted: */
if (!gEDataManager->miniToolbarEnabled(vboxGlobal().managedVMUuid()))
return;
/* Create mini-toolbar: */
m_pMiniToolBar = new UIMiniToolBar(this,
GeometryType_Full,
gEDataManager->miniToolbarAlignment(vboxGlobal().managedVMUuid()),
gEDataManager->autoHideMiniToolbar(vboxGlobal().managedVMUuid()));
AssertPtrReturnVoid(m_pMiniToolBar);
{
/* Configure mini-toolbar: */
m_pMiniToolBar->addMenus(actionPool()->menus());
connect(m_pMiniToolBar, SIGNAL(sigMinimizeAction()),
this, SLOT(showMinimized()), Qt::QueuedConnection);
connect(m_pMiniToolBar, SIGNAL(sigExitAction()),
actionPool()->action(UIActionIndexRT_M_View_T_Fullscreen), SLOT(trigger()));
connect(m_pMiniToolBar, SIGNAL(sigCloseAction()),
actionPool()->action(UIActionIndex_M_Application_S_Close), SLOT(trigger()));
connect(m_pMiniToolBar, SIGNAL(sigNotifyAboutWindowActivationStolen()),
this, SLOT(sltRevokeWindowActivation()), Qt::QueuedConnection);
# ifdef Q_WS_X11
// WORKAROUND:
// Due to Unity bug we want native full-screen flag to be set
// for mini-toolbar _before_ trying to show it in full-screen mode.
// That significantly improves of chances to have required geometry.
if (vboxGlobal().typeOfWindowManager() == X11WMType_Compiz)
vboxGlobal().setFullScreenFlag(m_pMiniToolBar);
# endif /* Q_WS_X11 */
}
}
void GuestBase::unregisterEvent(GuestWaitEvent *pEvent)
{
AssertPtrReturnVoid(pEvent);
int rc = RTCritSectEnter(&mWaitEventCritSect);
if (RT_SUCCESS(rc))
{
const std::list<VBoxEventType_T> lstTypes = pEvent->Types();
for (std::list<VBoxEventType_T>::const_iterator itEvents = lstTypes.begin();
itEvents != lstTypes.end(); itEvents++)
{
/** @todo Slow O(n) lookup. Optimize this. */
GuestWaitEvents::iterator itCurEvent = mWaitEvents[(*itEvents)].begin();
while (itCurEvent != mWaitEvents[(*itEvents)].end())
{
if ((*itCurEvent) == pEvent)
{
itCurEvent = mWaitEvents[(*itEvents)].erase(itCurEvent);
break;
}
else
itCurEvent++;
}
}
delete pEvent;
int rc2 = RTCritSectLeave(&mWaitEventCritSect);
if (RT_SUCCESS(rc))
rc = rc2;
}
}
void UIMachineWindowFullscreen::sltEnterNativeFullscreen(UIMachineWindow *pMachineWindow)
{
/* Make sure this slot is called only under ML and next: */
AssertReturnVoid(vboxGlobal().osRelease() > MacOSXRelease_Lion);
/* Make sure it is NULL or 'this' window passed: */
if (pMachineWindow && pMachineWindow != this)
return;
/* Make sure this window has fullscreen logic: */
UIMachineLogicFullscreen *pFullscreenLogic = qobject_cast<UIMachineLogicFullscreen*>(machineLogic());
AssertPtrReturnVoid(pFullscreenLogic);
/* Make sure this window should be shown and mapped to host-screen: */
if (!uisession()->isScreenVisible(m_uScreenId) ||
!pFullscreenLogic->hasHostScreenForGuestScreen(m_uScreenId))
return;
/* Mark window 'transitioned to fullscreen': */
m_fIsInFullscreenTransition = true;
/* Enter native fullscreen mode if necessary: */
if ( (pFullscreenLogic->screensHaveSeparateSpaces() || m_uScreenId == 0)
&& !darwinIsInFullscreenMode(this))
darwinToggleFullscreenMode(this);
}
/* static */
void VBoxDnDDropTarget::DumpFormats(IDataObject *pDataObject)
{
AssertPtrReturnVoid(pDataObject);
/* Enumerate supported source formats. This shouldn't happen too often
* on day to day use, but still keep it in here. */
IEnumFORMATETC *pEnumFormats;
HRESULT hr2 = pDataObject->EnumFormatEtc(DATADIR_GET, &pEnumFormats);
if (SUCCEEDED(hr2))
{
LogRel(("DnD: The following formats were offered to us:\n"));
FORMATETC curFormatEtc;
while (pEnumFormats->Next(1, &curFormatEtc,
NULL /* pceltFetched */) == S_OK)
{
WCHAR wszCfName[128]; /* 128 chars should be enough, rest will be truncated. */
hr2 = GetClipboardFormatNameW(curFormatEtc.cfFormat, wszCfName,
sizeof(wszCfName) / sizeof(WCHAR));
LogRel(("\tcfFormat=%RI16 (%s), tyMed=%RI32, dwAspect=%RI32, strCustomName=%ls, hr=%Rhrc\n",
curFormatEtc.cfFormat,
VBoxDnDDataObject::ClipboardFormatToString(curFormatEtc.cfFormat),
curFormatEtc.tymed,
curFormatEtc.dwAspect,
wszCfName, hr2));
}
pEnumFormats->Release();
}
}
void UIMachineWindowFullscreen::prepareMiniToolbar()
{
/* Make sure mini-toolbar is not restricted: */
if (!gEDataManager->miniToolbarEnabled(vboxGlobal().managedVMUuid()))
return;
/* Create mini-toolbar: */
m_pMiniToolBar = new UIMiniToolBar(this,
GeometryType_Full,
gEDataManager->miniToolbarAlignment(vboxGlobal().managedVMUuid()),
gEDataManager->autoHideMiniToolbar(vboxGlobal().managedVMUuid()));
AssertPtrReturnVoid(m_pMiniToolBar);
{
/* Configure mini-toolbar: */
m_pMiniToolBar->addMenus(actionPool()->menus());
connect(m_pMiniToolBar, SIGNAL(sigMinimizeAction()),
this, SLOT(showMinimized()), Qt::QueuedConnection);
connect(m_pMiniToolBar, SIGNAL(sigExitAction()),
actionPool()->action(UIActionIndexRT_M_View_T_Fullscreen), SLOT(trigger()));
connect(m_pMiniToolBar, SIGNAL(sigCloseAction()),
actionPool()->action(UIActionIndex_M_Application_S_Close), SLOT(trigger()));
connect(m_pMiniToolBar, SIGNAL(sigNotifyAboutWindowActivationStolen()),
this, SLOT(sltRevokeWindowActivation()), Qt::QueuedConnection);
}
}
void UIMachineLogicNormal::sltOpenStatusBarSettings()
{
/* Do not process if window(s) missed! */
AssertReturnVoid(isMachineWindowsCreated());
/* Make sure status-bar is enabled: */
const bool fEnabled = actionPool()->action(UIActionIndexRT_M_View_M_StatusBar_T_Visibility)->isChecked();
AssertReturnVoid(fEnabled);
/* Prevent user from opening another one editor or toggle status-bar: */
actionPool()->action(UIActionIndexRT_M_View_M_StatusBar_S_Settings)->setEnabled(false);
actionPool()->action(UIActionIndexRT_M_View_M_StatusBar_T_Visibility)->setEnabled(false);
/* Create status-bar editor: */
UIStatusBarEditorWindow *pStatusBarEditor = new UIStatusBarEditorWindow(activeMachineWindow());
AssertPtrReturnVoid(pStatusBarEditor);
{
/* Configure status-bar editor: */
connect(pStatusBarEditor, SIGNAL(destroyed(QObject*)),
this, SLOT(sltStatusBarSettingsClosed()));
#ifdef Q_WS_MAC
connect(this, SIGNAL(sigNotifyAbout3DOverlayVisibilityChange(bool)),
pStatusBarEditor, SLOT(sltActivateWindow()));
#endif /* Q_WS_MAC */
/* Show window: */
pStatusBarEditor->show();
}
}
void VDMemDiskDestroy(PVDMEMDISK pMemDisk)
{
AssertPtrReturnVoid(pMemDisk);
RTAvlrU64Destroy(pMemDisk->pTreeSegments, vdMemDiskDestroy, NULL);
RTMemFree(pMemDisk->pTreeSegments);
RTMemFree(pMemDisk);
}
void UIVMInformationDialog::prepareCentralWidget()
{
/* Create central-widget: */
setCentralWidget(new QWidget);
AssertPtrReturnVoid(centralWidget());
{
/* Create main-layout: */
new QVBoxLayout(centralWidget());
AssertPtrReturnVoid(centralWidget()->layout());
{
/* Create tab-widget: */
prepareTabWidget();
/* Create button-box: */
prepareButtonBox();
}
}
}
void UIInformationModel::updateData(UIInformationDataItem *pItem)
{
/* Updates data: */
AssertPtrReturnVoid(pItem);
int iRow = m_list.indexOf(pItem);
QModelIndex index = createIndex(iRow, 0);
emit dataChanged(index, index);
}
void UINetworkRequest::cleanupNetworkReply()
{
/* Destroy network-reply: */
AssertPtrReturnVoid(m_pReply.data());
m_pReply->disconnect();
m_pReply->deleteLater();
m_pReply = 0;
}
/**
* Pops the topmost value from the value stack.
*
* @returns nothing.
* @param pThis The interpreter context.
* @param pVal Where to store the value.
*/
DECLINLINE(void) vdScriptInterpreterPopValue(PVDSCRIPTINTERPCTX pThis, PVDSCRIPTARG pVal)
{
PVDSCRIPTARG pValStack = (PVDSCRIPTARG)vdScriptStackGetUsed(&pThis->StackValues);
AssertPtrReturnVoid(pValStack);
*pVal = *pValStack;
vdScriptStackPop(&pThis->StackValues);
}
