bool UIMachineView::x11Event(XEvent *pEvent)
{
/* Check if some system event should be filtered-out.
* Returning 'true' means filtering-out,
* Returning 'false' means passing event to Qt. */
bool fResult = false; /* Pass to Qt by default: */
switch (pEvent->type)
{
case XFocusOut:
case XFocusIn:
case XKeyPress:
case XKeyRelease:
{
/* Filter using keyboard-filter: */
bool fKeyboardFilteringResult = machineLogic()->keyboardHandler()->x11EventFilter(pEvent, screenId());
/* Filter using mouse-filter: */
bool fMouseFilteringResult = machineLogic()->mouseHandler()->x11EventFilter(pEvent, screenId());
/* If at least one of filters wants to filter event out then the result is 'true': */
fResult = fKeyboardFilteringResult || fMouseFilteringResult;
break;
}
default:
break;
}
/* Return result: */
return fResult;
}
/* Machine state-change handler: */
void UIMouseHandler::sltMachineStateChanged()
{
/* Get machine state: */
KMachineState state = uisession()->machineState();
/* Handle particular machine states: */
switch (state)
{
case KMachineState_Paused:
case KMachineState_TeleportingPausedVM:
case KMachineState_Stuck:
{
/* Release the mouse: */
releaseMouse();
break;
}
default:
break;
}
/* Recall reminder about paused VM input
* if we are not in paused VM state already: */
if (machineLogic()->activeMachineWindow() &&
state != KMachineState_Paused &&
state != KMachineState_TeleportingPausedVM)
popupCenter().forgetAboutPausedVMInput(machineLogic()->activeMachineWindow());
// TODO: Is it really required?
/* Notify all listeners: */
emit mouseStateChanged(mouseState());
}
void UIMachineWindow::handleStandardWindowButtonCallback(StandardWindowButtonType enmButtonType, bool fWithOptionKey)
{
switch (enmButtonType)
{
case StandardWindowButtonType_Zoom:
{
/* Handle 'Zoom' button for 'Normal' and 'Scaled' modes: */
if ( machineLogic()->visualStateType() == UIVisualStateType_Normal
|| machineLogic()->visualStateType() == UIVisualStateType_Scale)
{
if (fWithOptionKey)
{
/* Toggle window zoom: */
darwinToggleWindowZoom(this);
}
else
{
/* Enter 'full-screen' mode: */
uisession()->setRequestedVisualState(UIVisualStateType_Invalid);
uisession()->changeVisualState(UIVisualStateType_Fullscreen);
}
}
break;
}
default:
break;
}
}
void UIMachineWindow::prepareHandlers()
{
/* Register keyboard-handler: */
machineLogic()->keyboardHandler()->prepareListener(m_uScreenId, this);
/* Register mouse-handler: */
machineLogic()->mouseHandler()->prepareListener(m_uScreenId, this);
}
void UIMachineWindow::cleanupHandlers()
{
/* Unregister mouse-handler: */
machineLogic()->mouseHandler()->cleanupListener(m_uScreenId);
/* Unregister keyboard-handler: */
machineLogic()->keyboardHandler()->cleanupListener(m_uScreenId);
}
void UIMachineWindowNormal::prepareSessionConnections()
{
/* Call to base-class: */
UIMachineWindow::prepareSessionConnections();
/* We should watch for console events: */
connect(machineLogic()->uisession(), SIGNAL(sigMediumChange(const CMediumAttachment &)),
this, SLOT(sltMediumChange(const CMediumAttachment &)));
connect(machineLogic()->uisession(), SIGNAL(sigUSBControllerChange()),
this, SLOT(sltUSBControllerChange()));
connect(machineLogic()->uisession(), SIGNAL(sigUSBDeviceStateChange(const CUSBDevice &, bool, const CVirtualBoxErrorInfo &)),
this, SLOT(sltUSBDeviceStateChange()));
connect(machineLogic()->uisession(), &UISession::sigAudioAdapterChange,
this, &UIMachineWindowNormal::sltAudioAdapterChange);
connect(machineLogic()->uisession(), SIGNAL(sigNetworkAdapterChange(const CNetworkAdapter &)),
this, SLOT(sltNetworkAdapterChange()));
connect(machineLogic()->uisession(), SIGNAL(sigSharedFolderChange()),
this, SLOT(sltSharedFolderChange()));
connect(machineLogic()->uisession(), SIGNAL(sigRecordingChange()),
this, SLOT(sltRecordingChange()));
connect(machineLogic()->uisession(), SIGNAL(sigCPUExecutionCapChange()),
this, SLOT(sltCPUExecutionCapChange()));
connect(machineLogic()->uisession(), SIGNAL(sigInitialized()),
this, SLOT(sltHandleSessionInitialized()));
}
void UIMachineWindowNormal::prepareHandlers()
{
/* Call to base-class: */
UIMachineWindow::prepareHandlers();
/* Keyboard state-change updater: */
connect(machineLogic()->keyboardHandler(), SIGNAL(keyboardStateChanged(int)), indicatorsPool()->indicator(UIIndicatorIndex_Hostkey), SLOT(setState(int)));
/* Mouse state-change updater: */
connect(machineLogic()->mouseHandler(), SIGNAL(mouseStateChanged(int)), indicatorsPool()->indicator(UIIndicatorIndex_Mouse), SLOT(setState(int)));
/* Early initialize required connections: */
indicatorsPool()->indicator(UIIndicatorIndex_Hostkey)->setState(machineLogic()->keyboardHandler()->keyboardState());
indicatorsPool()->indicator(UIIndicatorIndex_Mouse)->setState(machineLogic()->mouseHandler()->mouseState());
}
void UIMachineWindowSeamless::prepareMachineView()
{
#ifdef VBOX_WITH_VIDEOHWACCEL
/* Need to force the QGL framebuffer in case 2D Video Acceleration is supported & enabled: */
bool bAccelerate2DVideo = session().GetMachine().GetAccelerate2DVideoEnabled() && VBoxGlobal::isAcceleration2DVideoAvailable();
#endif
/* Set central widget: */
setCentralWidget(new QWidget);
/* Set central widget layout: */
centralWidget()->setLayout(m_pMachineViewContainer);
m_pMachineView = UIMachineView::create( this
, m_uScreenId
, machineLogic()->visualStateType()
#ifdef VBOX_WITH_VIDEOHWACCEL
, bAccelerate2DVideo
#endif
);
/* Add machine view into layout: */
m_pMachineViewContainer->addWidget(m_pMachineView, 1, 1, Qt::AlignVCenter | Qt::AlignHCenter);
/* This might be required to correctly mask: */
centralWidget()->setAutoFillBackground(false);
}
void UIMachineWindowSeamless::prepareVisualState()
{
/* Call to base-class: */
UIMachineWindow::prepareVisualState();
/* This might be required to correctly mask: */
centralWidget()->setAutoFillBackground(false);
#ifdef Q_WS_WIN
/* Get corresponding screen: */
int iScreen = qobject_cast<UIMachineLogicSeamless*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
/* Prepare previous region: */
m_prevRegion = vboxGlobal().availableGeometry(iScreen);
#endif /* Q_WS_WIN */
#ifdef Q_WS_MAC
/* Please note: All the stuff below has to be done after the window has
* switched to fullscreen. Qt changes the winId on the fullscreen
* switch and make this stuff useless with the old winId. So please be
* careful on rearrangement of the method calls. */
::darwinSetShowsWindowTransparent(this, true);
#endif /* Q_WS_MAC */
#ifndef Q_WS_MAC
/* Prepare mini-toolbar: */
prepareMiniToolbar();
#endif /* !Q_WS_MAC */
}
bool UIMachineView::winEvent(MSG *pMsg, long* /* piResult */)
{
/* Check if some system event should be filtered-out.
* Returning 'true' means filtering-out,
* Returning 'false' means passing event to Qt. */
bool fResult = false; /* Pass to Qt by default: */
switch (pMsg->message)
{
case WM_KEYDOWN:
case WM_KEYUP:
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
{
/* Filter using keyboard-filter: */
bool fKeyboardFilteringResult = machineLogic()->keyboardHandler()->winEventFilter(pMsg, screenId());
/* Keyboard filter rules the result: */
fResult = fKeyboardFilteringResult;
break;
}
default:
break;
}
/* Return result: */
return fResult;
}
void UIMachineWindowFullscreen::prepareMachineView()
{
#ifdef VBOX_WITH_VIDEOHWACCEL
/* Need to force the QGL framebuffer in case 2D Video Acceleration is supported & enabled: */
bool bAccelerate2DVideo = session().GetMachine().GetAccelerate2DVideoEnabled() && VBoxGlobal::isAcceleration2DVideoAvailable();
#endif
/* Set central widget: */
setCentralWidget(new QWidget);
/* Set central widget layout: */
centralWidget()->setLayout(m_pMachineViewContainer);
m_pMachineView = UIMachineView::create( this
, m_uScreenId
, machineLogic()->visualStateType()
#ifdef VBOX_WITH_VIDEOHWACCEL
, bAccelerate2DVideo
#endif
);
/* Add machine view into layout: */
m_pMachineViewContainer->addWidget(m_pMachineView, 1, 1, Qt::AlignVCenter | Qt::AlignHCenter);
/* The background has to go black: */
QPalette palette(centralWidget()->palette());
palette.setColor(centralWidget()->backgroundRole(), Qt::black);
centralWidget()->setPalette(palette);
centralWidget()->setAutoFillBackground(true);
setAutoFillBackground(true);
}
QRect UIMachineViewFullscreen::workingArea() const
{
/* Get corresponding screen: */
int iScreen = static_cast<UIMachineLogicFullscreen*>(machineLogic())->hostScreenForGuestScreen(screenId());
/* Return available geometry for that screen: */
return QApplication::desktop()->screenGeometry(iScreen);
}
QRect UIMachineViewSeamless::workingArea() const
{
/* Get corresponding screen: */
int iScreen = static_cast<UIMachineLogicSeamless*>(machineLogic())->hostScreenForGuestScreen(screenId());
/* Return available geometry for that screen: */
return vboxGlobal().availableGeometry(iScreen);
}
void UIMachineWindow::prepareMachineView()
{
#ifdef VBOX_WITH_VIDEOHWACCEL
/* Need to force the QGL framebuffer in case 2D Video Acceleration is supported & enabled: */
bool bAccelerate2DVideo = machine().GetAccelerate2DVideoEnabled() && VBoxGlobal::isAcceleration2DVideoAvailable();
#endif /* VBOX_WITH_VIDEOHWACCEL */
/* Get visual-state type: */
UIVisualStateType visualStateType = machineLogic()->visualStateType();
/* Create machine-view: */
m_pMachineView = UIMachineView::create( this
, m_uScreenId
, visualStateType
#ifdef VBOX_WITH_VIDEOHWACCEL
, bAccelerate2DVideo
#endif /* VBOX_WITH_VIDEOHWACCEL */
);
/* Listen for frame-buffer resize: */
connect(m_pMachineView, SIGNAL(sigFrameBufferResize()), this, SIGNAL(sigFrameBufferResize()));
/* Add machine-view into main-layout: */
m_pMainLayout->addWidget(m_pMachineView, 1, 1, viewAlignment(visualStateType));
/* Install focus-proxy: */
setFocusProxy(m_pMachineView);
}
void UIMachineWindowSeamless::showInNecessaryMode()
{
/* Make sure this window has seamless logic: */
UIMachineLogicSeamless *pSeamlessLogic = qobject_cast<UIMachineLogicSeamless*>(machineLogic());
AssertPtrReturnVoid(pSeamlessLogic);
/* Make sure this window should be shown and mapped to some host-screen: */
if (!uisession()->isScreenVisible(m_uScreenId) ||
!pSeamlessLogic->hasHostScreenForGuestScreen(m_uScreenId))
{
#ifndef Q_WS_MAC
/* If there is mini-toolbar: */
if (m_pMiniToolBar)
{
/* Just hide mini-toolbar: */
m_pMiniToolBar->hide();
}
#endif /* !Q_WS_MAC */
/* Hide window: */
hide();
return;
}
/* Make sure this window is not minimized: */
if (isMinimized())
return;
/* Make sure this window is maximized and placed on valid screen: */
placeOnScreen();
/* Show in normal mode: */
show();
/* Adjust machine-view size if necessary: */
adjustMachineViewSize();
#ifndef Q_WS_MAC
/* If there is mini-toolbar: */
if (m_pMiniToolBar)
{
# if defined(Q_WS_WIN)
/* Just show mini-toolbar: */
m_pMiniToolBar->show();
# elif defined(Q_WS_X11)
/* Allow mini-toolbar to be located on full-screen area: */
m_pMiniToolBar->showMaximized();
/* Make sure mini-toolbar is always on top of machine-window: */
VBoxGlobal::setTransientFor(m_pMiniToolBar, this);
# endif /* Q_WS_X11 */
}
#endif /* !Q_WS_MAC */
/* Make sure machine-view have focus: */
m_pMachineView->setFocus();
}
void UIMachineWindowFullscreen::placeOnScreen()
{
/* Get corresponding host-screen: */
const int iHostScreen = qobject_cast<UIMachineLogicFullscreen*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
/* And corresponding working area: */
const QRect workingArea = vboxGlobal().screenGeometry(iHostScreen);
#if defined(Q_WS_WIN) || defined(Q_WS_X11)
/* Set appropriate geometry for window: */
resize(workingArea.size());
move(workingArea.topLeft());
/* If there is a mini-toolbar: */
if (m_pMiniToolBar)
{
/* Set appropriate geometry for mini-toolbar: */
m_pMiniToolBar->resize(workingArea.size());
m_pMiniToolBar->move(workingArea.topLeft());
}
#elif defined(Q_WS_MAC)
/* Make sure this window has fullscreen logic: */
UIMachineLogicFullscreen *pFullscreenLogic = qobject_cast<UIMachineLogicFullscreen*>(machineLogic());
AssertPtrReturnVoid(pFullscreenLogic);
/* Move window to the appropriate position: */
move(workingArea.topLeft());
/* Resize window to the appropriate size on Lion and previous: */
if (vboxGlobal().osRelease() <= MacOSXRelease_Lion)
resize(workingArea.size());
/* Resize window to the appropriate size on ML and next
* only if that screen has no own user-space: */
else if (!pFullscreenLogic->screensHaveSeparateSpaces() && m_uScreenId != 0)
resize(workingArea.size());
else
{
/* Load normal geometry first of all: */
QRect geo = gEDataManager->machineWindowGeometry(UIVisualStateType_Normal, m_uScreenId, vboxGlobal().managedVMUuid());
/* If normal geometry is null => use frame-buffer size: */
if (geo.isNull())
{
const UIFrameBuffer *pFrameBuffer = uisession()->frameBuffer(m_uScreenId);
geo = QRect(QPoint(0, 0), QSize(pFrameBuffer->width(), pFrameBuffer->height()).boundedTo(workingArea.size()));
}
/* If frame-buffer size is null => use default size: */
if (geo.isNull())
geo = QRect(QPoint(0, 0), QSize(800, 600).boundedTo(workingArea.size()));
/* Move window to the center of working-area: */
geo.moveCenter(workingArea.center());
setGeometry(geo);
}
#endif /* Q_WS_MAC */
}
void UIMachineWindowNormal::saveSettings()
{
/* Save window geometry: */
{
gEDataManager->setMachineWindowGeometry(machineLogic()->visualStateType(),
m_uScreenId, m_normalGeometry,
isMaximizedChecked(), vboxGlobal().managedVMUuid());
}
/* Call to base-class: */
UIMachineWindow::saveSettings();
}
void UIMachineWindowNormal::prepareSessionConnections()
{
/* Call to base-class: */
UIMachineWindow::prepareSessionConnections();
/* Medium change updater: */
connect(machineLogic()->uisession(), SIGNAL(sigMediumChange(const CMediumAttachment &)),
this, SLOT(sltMediumChange(const CMediumAttachment &)));
/* USB controller change updater: */
connect(machineLogic()->uisession(), SIGNAL(sigUSBControllerChange()),
this, SLOT(sltUSBControllerChange()));
/* USB device state-change updater: */
connect(machineLogic()->uisession(), SIGNAL(sigUSBDeviceStateChange(const CUSBDevice &, bool, const CVirtualBoxErrorInfo &)),
this, SLOT(sltUSBDeviceStateChange()));
/* Network adapter change updater: */
connect(machineLogic()->uisession(), SIGNAL(sigNetworkAdapterChange(const CNetworkAdapter &)),
this, SLOT(sltNetworkAdapterChange()));
/* Shared folder change updater: */
connect(machineLogic()->uisession(), SIGNAL(sigSharedFolderChange()),
this, SLOT(sltSharedFolderChange()));
/* CPU execution cap change updater: */
connect(machineLogic()->uisession(), SIGNAL(sigCPUExecutionCapChange()),
this, SLOT(sltCPUExecutionCapChange()));
}
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 UIMachineWindowSeamless::showSeamless()
{
/* Show manually maximized window: */
sltPlaceOnScreen();
show();
#ifdef Q_WS_MAC
/* Make sure it is really on the right place (especially on the Mac): */
int iScreen = static_cast<UIMachineLogicSeamless*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
QRect r = vboxGlobal().availableGeometry(iScreen);
move(r.topLeft());
#endif /* Q_WS_MAC */
}
void UIMachineWindowSeamless::placeOnScreen()
{
/* Get corresponding screen: */
int iScreen = qobject_cast<UIMachineLogicSeamless*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
/* Calculate working area: */
QRect workingArea = QApplication::desktop()->availableGeometry(iScreen);
/* Move to the appropriate position: */
move(workingArea.topLeft());
/* Resize to the appropriate size: */
resize(workingArea.size());
}
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 UIMachineWindowFullscreen::sltPlaceOnScreen()
{
/* Get corresponding screen: */
int iScreen = static_cast<UIMachineLogicFullscreen*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
/* Calculate working area: */
QRect workingArea = QApplication::desktop()->screenGeometry(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 UIMachineWindowSeamless::showInNecessaryMode()
{
/* Make sure window has seamless logic: */
UIMachineLogicSeamless *pSeamlessLogic = qobject_cast<UIMachineLogicSeamless*>(machineLogic());
AssertPtrReturnVoid(pSeamlessLogic);
/* Make sure window should be shown and mapped to some host-screen: */
if (!uisession()->isScreenVisible(m_uScreenId) ||
!pSeamlessLogic->hasHostScreenForGuestScreen(m_uScreenId))
{
#if defined(Q_WS_WIN) || defined(Q_WS_X11)
/* If there is a mini-toolbar: */
if (m_pMiniToolBar)
{
/* Hide mini-toolbar: */
m_pMiniToolBar->hide();
}
#endif /* Q_WS_WIN || Q_WS_X11 */
/* Hide window: */
hide();
}
else
{
/* Ignore if window minimized: */
if (isMinimized())
return;
/* Make sure window have appropriate geometry: */
placeOnScreen();
/* Show window in normal mode: */
show();
#if defined(Q_WS_WIN) || defined(Q_WS_X11)
/* If there is a mini-toolbar: */
if (m_pMiniToolBar)
{
/* Show mini-toolbar in normal mode: */
m_pMiniToolBar->show();
}
#endif /* Q_WS_WIN || Q_WS_X11 */
/* Adjust machine-view size if necessary: */
adjustMachineViewSize();
/* Make sure machine-view have focus: */
m_pMachineView->setFocus();
}
}
void UIMachineWindowSeamless::prepareSeamless()
{
#ifdef Q_WS_WIN
/* Get corresponding screen: */
int iScreen = static_cast<UIMachineLogicSeamless*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
/* Prepare previous region: */
m_prevRegion = vboxGlobal().availableGeometry(iScreen);
#endif
#ifdef Q_WS_MAC
/* Please note: All the stuff below has to be done after the window has
* switched to fullscreen. Qt changes the winId on the fullscreen
* switch and make this stuff useless with the old winId. So please be
* careful on rearrangement of the method calls. */
::darwinSetShowsWindowTransparent(this, true);
#endif
}
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());
#ifndef Q_WS_MAC
/* Move mini-toolbar into appropriate place: */
if (m_pMiniToolBar)
m_pMiniToolBar->adjustGeometry();
#endif /* !Q_WS_MAC */
/* Process pending move & resize events: */
qApp->processEvents();
}
void UIMachineWindowSeamless::placeOnScreen()
{
/* Get corresponding host-screen: */
const int iHostScreen = qobject_cast<UIMachineLogicSeamless*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
/* And corresponding working area: */
const QRect workingArea = vboxGlobal().availableGeometry(iHostScreen);
/* Set appropriate geometry for window: */
resize(workingArea.size());
move(workingArea.topLeft());
#if defined(Q_WS_WIN) || defined(Q_WS_X11)
/* If there is a mini-toolbar: */
if (m_pMiniToolBar)
{
/* Set appropriate geometry for mini-toolbar: */
m_pMiniToolBar->resize(workingArea.size());
m_pMiniToolBar->move(workingArea.topLeft());
}
#endif /* Q_WS_WIN || Q_WS_X11 */
}
void UIMachine::cleanupMachineLogic()
{
/* Session UI can have requested visual state: */
if (uisession())
{
/* Get requested visual state: */
UIVisualStateType requestedVisualState = uisession()->requestedVisualState();
/* Or current visual state if requested is invalid: */
if (requestedVisualState == UIVisualStateType_Invalid)
requestedVisualState = m_visualState;
/* Save requested visual state: */
gEDataManager->setRequestedVisualState(requestedVisualState, vboxGlobal().managedVMUuid());
}
/* Destroy machine-logic if exists: */
if (machineLogic())
{
m_pMachineLogic->cleanup();
UIMachineLogic::destroy(m_pMachineLogic);
}
}
void UIMachineWindowNormal::prepareStatusBar()
{
/* Call to base-class: */
UIMachineWindow::prepareStatusBar();
/* Create status-bar: */
setStatusBar(new QIStatusBar);
AssertPtrReturnVoid(statusBar());
{
/* Configure status-bar: */
statusBar()->setContextMenuPolicy(Qt::CustomContextMenu);
connect(statusBar(), SIGNAL(customContextMenuRequested(const QPoint&)),
this, SLOT(sltHandleStatusBarContextMenuRequest(const QPoint&)));
/* Create indicator-pool: */
m_pIndicatorsPool = new UIIndicatorsPool(machineLogic()->uisession());
AssertPtrReturnVoid(m_pIndicatorsPool);
{
/* Configure indicator-pool: */
connect(m_pIndicatorsPool, SIGNAL(sigContextMenuRequest(IndicatorType, const QPoint&)),
this, SLOT(sltHandleIndicatorContextMenuRequest(IndicatorType, const QPoint&)));
/* Add indicator-pool into status-bar: */
statusBar()->addPermanentWidget(m_pIndicatorsPool, 0);
}
/* Post-configure status-bar: */
connect(gEDataManager, SIGNAL(sigStatusBarConfigurationChange(const QUuid &)),
this, SLOT(sltHandleStatusBarConfigurationChange(const QUuid &)));
#ifdef VBOX_WS_MAC
/* Make sure the status-bar is aware of action hovering: */
connect(actionPool(), SIGNAL(sigActionHovered(UIAction *)),
this, SLOT(sltActionHovered(UIAction *)));
#endif /* VBOX_WS_MAC */
}
#ifdef VBOX_WS_MAC
/* For the status-bar on Cocoa: */
setUnifiedTitleAndToolBarOnMac(true);
#endif /* VBOX_WS_MAC */
}
void UIMachineWindowScale::prepareMachineView()
{
#ifdef VBOX_WITH_VIDEOHWACCEL
/* Need to force the QGL framebuffer in case 2D Video Acceleration is supported & enabled: */
bool bAccelerate2DVideo = session().GetMachine().GetAccelerate2DVideoEnabled() && VBoxGlobal::isAcceleration2DVideoAvailable();
#endif
/* Set central widget: */
setCentralWidget(new QWidget);
/* Set central widget layout: */
centralWidget()->setLayout(m_pMachineViewContainer);
m_pMachineView = UIMachineView::create( this
, m_uScreenId
, machineLogic()->visualStateType()
#ifdef VBOX_WITH_VIDEOHWACCEL
, bAccelerate2DVideo
#endif
);
/* Add machine view into layout: */
m_pMachineViewContainer->addWidget(m_pMachineView, 1, 1);
}