void UIMachineView::cleanupFrameBuffer()
{
if (m_pFrameBuffer)
{
/* Process pending frame-buffer resize events: */
QApplication::sendPostedEvents(this, VBoxDefs::ResizeEventType);
#ifdef VBOX_WITH_VIDEOHWACCEL
if (m_fAccelerate2DVideo)
{
/* When 2D is enabled we do not re-create Framebuffers. This is done to
* 1. avoid 2D command loss during the time slot when no framebuffer is assigned to the display
* 2. make it easier to preserve the current 2D state */
Assert(m_pFrameBuffer == uisession()->frameBuffer(screenId()));
m_pFrameBuffer->setView(NULL);
#ifdef VBOX_WITH_CROGL
/* Call SetFramebuffer to ensure 3D gets notified of view being destroyed */
CDisplay display = session().GetConsole().GetDisplay();
display.SetFramebuffer(m_uScreenId, CFramebuffer(m_pFrameBuffer));
#endif
}
else
#endif /* VBOX_WITH_VIDEOHWACCEL */
{
/* Warn framebuffer about its no more necessary: */
m_pFrameBuffer->setDeleted(true);
/* Detach framebuffer from Display: */
CDisplay display = session().GetConsole().GetDisplay();
display.SetFramebuffer(m_uScreenId, CFramebuffer(NULL));
/* Release the reference: */
m_pFrameBuffer->Release();
// delete m_pFrameBuffer; // TODO_NEW_CORE: possibly necessary to really cleanup
m_pFrameBuffer = NULL;
}
}
}
void UIMachine::prepareMachineLogic()
{
/* Prepare async visual state type change handler: */
qRegisterMetaType<UIVisualStateType>();
connect(this, SIGNAL(sigRequestAsyncVisualStateChange(UIVisualStateType)),
this, SLOT(sltChangeVisualState(UIVisualStateType)),
Qt::QueuedConnection);
/* Load restricted visual states: */
UIVisualStateType restrictedVisualStates = gEDataManager->restrictedVisualStates(vboxGlobal().managedVMUuid());
/* Acquire allowed visual states: */
m_allowedVisualStates = static_cast<UIVisualStateType>(UIVisualStateType_All ^ restrictedVisualStates);
/* Load requested visual state: */
UIVisualStateType requestedVisualState = gEDataManager->requestedVisualState(vboxGlobal().managedVMUuid());
/* Check if requested visual state is allowed: */
if (isVisualStateAllowed(requestedVisualState))
{
switch (requestedVisualState)
{
/* Direct transition to scale/fullscreen mode allowed: */
case UIVisualStateType_Scale: m_initialVisualState = UIVisualStateType_Scale; break;
case UIVisualStateType_Fullscreen: m_initialVisualState = UIVisualStateType_Fullscreen; break;
/* While to seamless is not, so we have to make request to do transition later: */
case UIVisualStateType_Seamless: uisession()->setRequestedVisualState(UIVisualStateType_Seamless); break;
default: break;
}
}
/* Enter initial visual state: */
enterInitialVisualState();
}
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()));
}
}
bool UIMachineViewFullscreen::eventFilter(QObject *pWatched, QEvent *pEvent)
{
/* Who are we watching? */
QMainWindow *pMainDialog = machineWindowWrapper() && machineWindowWrapper()->machineWindow() ?
qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow()) : 0;
if (pWatched != 0 && pWatched == pMainDialog)
{
switch (pEvent->type())
{
case QEvent::Resize:
{
/* Send guest-resize hint only if top window resizing to required dimension: */
QResizeEvent *pResizeEvent = static_cast<QResizeEvent*>(pEvent);
if (pResizeEvent->size() != workingArea().size())
break;
/* Set the "guest needs to resize" hint.
* This hint is acted upon when (and only when) the autoresize property is "true": */
m_fShouldWeDoResize = uisession()->isGuestSupportsGraphics();
if (m_bIsGuestAutoresizeEnabled && m_fShouldWeDoResize)
QTimer::singleShot(0, this, SLOT(sltPerformGuestResize()));
break;
}
default:
break;
}
}
return UIMachineView::eventFilter(pWatched, pEvent);
}
void UIMachineWindowNormal::sltHandleStatusBarConfigurationChange(const QUuid &uMachineID)
{
/* Skip unrelated machine IDs: */
if (vboxGlobal().managedVMUuid() != uMachineID)
return;
/* Check whether status-bar is enabled: */
const bool fEnabled = gEDataManager->statusBarEnabled(vboxGlobal().managedVMUuid());
/* Update settings action 'enable' state: */
QAction *pActionStatusBarSettings = actionPool()->action(UIActionIndexRT_M_View_M_StatusBar_S_Settings);
pActionStatusBarSettings->setEnabled(fEnabled);
/* Update switch action 'checked' state: */
QAction *pActionStatusBarSwitch = actionPool()->action(UIActionIndexRT_M_View_M_StatusBar_T_Visibility);
pActionStatusBarSwitch->blockSignals(true);
pActionStatusBarSwitch->setChecked(fEnabled);
pActionStatusBarSwitch->blockSignals(false);
/* Update status-bar visibility: */
statusBar()->setVisible(pActionStatusBarSwitch->isChecked());
/* Update status-bar indicators-pool: */
m_pIndicatorsPool->setAutoUpdateIndicatorStates(statusBar()->isVisible() && uisession()->isRunning());
/* Normalize geometry without moving: */
normalizeGeometry(false /* adjust position */);
}
void UIMachineWindowSeamless::showInNecessaryMode()
{
/* Should we show window?: */
if (uisession()->isScreenVisible(m_uScreenId))
{
/* Do we have the seamless logic? */
if (UIMachineLogicSeamless *pSeamlessLogic = qobject_cast<UIMachineLogicSeamless*>(machineLogic()))
{
/* Is this guest screen has own host screen? */
if (pSeamlessLogic->hasHostScreenForGuestScreen(m_uScreenId))
{
/* Show manually maximized window: */
placeOnScreen();
/* Show normal window: */
show();
#ifdef Q_WS_MAC
/* Make sure it is really on the right place (especially on the Mac): */
QRect r = vboxGlobal().availableGeometry(qobject_cast<UIMachineLogicSeamless*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId));
move(r.topLeft());
#endif /* Q_WS_MAC */
/* Return early: */
return;
}
}
}
/* Hide in other cases: */
hide();
}
bool UIMachineLogicSeamless::checkAvailability()
{
/* Check if there is enough physical memory to enter seamless: */
if (uisession()->isGuestSupportsSeamless())
{
quint64 availBits = machine().GetVRAMSize() /* VRAM */ * _1M /* MiB to bytes */ * 8 /* to bits */;
quint64 usedBits = m_pScreenLayout->memoryRequirements();
if (availBits < usedBits)
{
msgCenter().cannotEnterSeamlessMode(0, 0, 0,
(((usedBits + 7) / 8 + _1M - 1) / _1M) * _1M);
return false;
}
}
/* Show the info message. */
const UIShortcut &shortcut =
gShortcutPool->shortcut(actionPool()->shortcutsExtraDataID(),
actionPool()->action(UIActionIndexRT_M_View_T_Seamless)->shortcutExtraDataID());
const QString strHotKey = QString("Host+%1").arg(shortcut.toString());
if (!msgCenter().confirmGoingSeamless(strHotKey))
return false;
return true;
}
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 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);
}
bool UIMachineViewSeamless::eventFilter(QObject *pWatched, QEvent *pEvent)
{
if (pWatched != 0 && pWatched == machineWindow())
{
switch (pEvent->type())
{
case QEvent::Resize:
{
/* Send guest-resize hint only if top window resizing to required dimension: */
QResizeEvent *pResizeEvent = static_cast<QResizeEvent*>(pEvent);
if (pResizeEvent->size() != workingArea().size())
break;
/* Recalculate max guest size: */
setMaxGuestSize();
/* And resize guest to that size: */
if (uisession()->isGuestSupportsGraphics())
QTimer::singleShot(0, this, SLOT(sltPerformGuestResize()));
break;
}
default:
break;
}
}
return UIMachineView::eventFilter(pWatched, pEvent);
}
bool UIMouseHandler::x11EventFilter(XEvent *pEvent, ulong /* uScreenId */)
{
/* 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)
{
/* We have to handle XFocusOut right here as this event is not passed to UIMachineView::event().
* Handling this event is important for releasing the keyboard before the screen saver gets active.
* See public ticket #3894: Apparently this makes problems with newer versions of Qt
* and this hack is probably not necessary anymore. So disable it for Qt >= 4.5.0. */
case XFocusOut:
{
if (uisession()->isRunning())
{
if (VBoxGlobal::qtRTVersion() < ((4 << 16) | (5 << 8) | 0))
releaseMouse();
}
fResult = false;
}
default:
break;
}
/* Return result: */
return fResult;
}
void UIMachineViewFullscreen::sltPerformGuestResize(const QSize &toSize)
{
if (m_bIsGuestAutoresizeEnabled && uisession()->isGuestSupportsGraphics())
{
/* Get machine window: */
QMainWindow *pMachineWindow = machineWindowWrapper() && machineWindowWrapper()->machineWindow() ?
qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow()) : 0;
/* If this slot is invoked directly then use the passed size otherwise get
* the available size for the guest display. We assume here that centralWidget()
* contains this view only and gives it all available space: */
QSize newSize(toSize.isValid() ? toSize : pMachineWindow ? pMachineWindow->centralWidget()->size() : QSize());
AssertMsg(newSize.isValid(), ("Size should be valid!\n"));
/* Do not send the same hints as we already have: */
if ((newSize.width() == storedConsoleSize().width()) && (newSize.height() == storedConsoleSize().height()))
return;
/* We only actually send the hint if either an explicit new size was given
* (e.g. if the request was triggered directly by a console resize event) or
* if no explicit size was specified but a resize is flagged as being needed
* (e.g. the autoresize was just enabled and the console was resized while it was disabled). */
if (toSize.isValid() || m_fShouldWeDoResize)
{
/* Remember the new size: */
storeConsoleSize(newSize.width(), newSize.height());
/* Send new size-hint to the guest: */
session().GetConsole().GetDisplay().SetVideoModeHint(newSize.width(), newSize.height(), 0, screenId());
}
/* We had requested resize now, rejecting other accident requests: */
m_fShouldWeDoResize = false;
}
}
void UIMachineWindow::updateAppearanceOf(int iElement)
{
/* Update window title: */
if (iElement & UIVisualElement_WindowTitle)
{
/* Get machine: */
const CMachine &m = machine();
/* Get machine state: */
KMachineState state = uisession()->machineState();
/* Prepare full name: */
QString strSnapshotName;
if (m.GetSnapshotCount() > 0)
{
CSnapshot snapshot = m.GetCurrentSnapshot();
strSnapshotName = " (" + snapshot.GetName() + ")";
}
QString strMachineName = m.GetName() + strSnapshotName;
if (state != KMachineState_Null)
strMachineName += " [" + gpConverter->toString(state) + "]";
/* Unusual on the Mac. */
#ifndef Q_WS_MAC
strMachineName += " - " + defaultWindowTitle();
#endif /* !Q_WS_MAC */
if (m.GetMonitorCount() > 1)
strMachineName += QString(" : %1").arg(m_uScreenId + 1);
setWindowTitle(strMachineName);
}
}
void UIMachineViewSeamless::cleanupSeamless()
{
/* If machine still running: */
if (uisession()->isRunning())
/* Reset seamless feature flag of the guest: */
session().GetConsole().GetDisplay().SetSeamlessMode(false);
}
/* 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());
}
UIMachineWindow::UIMachineWindow(UIMachineLogic *pMachineLogic, ulong uScreenId)
: QIWithRetranslateUI2<QMainWindow>(0, pMachineLogic->windowFlags(uScreenId))
, m_pMachineLogic(pMachineLogic)
, m_pMachineView(0)
, m_uScreenId(uScreenId)
, m_pMainLayout(0)
, m_pTopSpacer(0)
, m_pBottomSpacer(0)
, m_pLeftSpacer(0)
, m_pRightSpacer(0)
{
#ifndef Q_WS_MAC
/* On Mac OS X window icon referenced in info.plist is used. */
/* Set default window icon (will be changed to VM-specific icon little bit later): */
setWindowIcon(QIcon(":/VirtualBox_48px.png"));
/* Set redefined machine-window icon if any: */
QIcon *pMachineWidnowIcon = uisession()->machineWindowIcon();
if (pMachineWidnowIcon)
setWindowIcon(*pMachineWidnowIcon);
/* Or set default machine-window icon: */
else
setWindowIcon(vboxGlobal().vmGuestOSTypeIcon(machine().GetOSTypeId()));
#endif /* !Q_WS_MAC */
}
void UIMouseHandler::captureMouse(ulong uScreenId)
{
/* Do not try to capture mouse if its captured already: */
if (uisession()->isMouseCaptured())
return;
/* If such viewport exists: */
if (m_viewports.contains(uScreenId))
{
/* Store mouse-capturing state value: */
uisession()->setMouseCaptured(true);
/* Memorize the index of machine-view-viewport captured mouse: */
m_iMouseCaptureViewIndex = uScreenId;
/* Memorize the host position where the cursor was captured: */
m_capturedMousePos = QCursor::pos();
/* Acquiring visible viewport rectangle in global coodrinates: */
QRect visibleRectangle = m_viewports[m_iMouseCaptureViewIndex]->visibleRegion().boundingRect();
QPoint visibleRectanglePos = m_views[m_iMouseCaptureViewIndex]->mapToGlobal(m_viewports[m_iMouseCaptureViewIndex]->pos());
visibleRectangle.translate(visibleRectanglePos);
visibleRectangle = visibleRectangle.intersected(QApplication::desktop()->availableGeometry(machineLogic()->machineWindows()[m_iMouseCaptureViewIndex]));
#ifdef Q_WS_WIN
/* Move the mouse to the center of the visible area: */
m_lastMousePos = visibleRectangle.center();
QCursor::setPos(m_lastMousePos);
/* Update mouse clipping: */
updateMouseCursorClipping();
#elif defined (Q_WS_MAC)
/* Grab all mouse events: */
::darwinMouseGrab(m_viewports[m_iMouseCaptureViewIndex]);
#else /* Q_WS_MAC */
/* Remember current mouse position: */
m_lastMousePos = QCursor::pos();
/* Grab all mouse events: */
m_viewports[m_iMouseCaptureViewIndex]->grabMouse();
#endif /* !Q_WS_MAC */
/* Switch guest mouse to the relative mode: */
mouse().PutMouseEvent(0, 0, 0, 0, 0);
/* Notify all the listeners: */
emit sigStateChange(state());
}
}
bool UIMachineViewNormal::eventFilter(QObject *pWatched, QEvent *pEvent)
{
if (pWatched != 0 && pWatched == machineWindow())
{
switch (pEvent->type())
{
case QEvent::Resize:
{
/* We call this on every resize as:
* * Window frame geometry can change on resize.
* * On X11 we set information here which becomes available
* asynchronously at an unknown time after window
* creation. As long as the information is not available
* we make a best guess.
*/
setMaxGuestSize();
if (pEvent->spontaneous() && m_bIsGuestAutoresizeEnabled && uisession()->isGuestSupportsGraphics())
QTimer::singleShot(300, this, SLOT(sltPerformGuestResize()));
break;
}
#if defined (Q_WS_WIN32)
# if defined (VBOX_GUI_USE_DDRAW)
case QEvent::Move:
{
/* Notification from our parent that it has moved. We need this in order
* to possibly adjust the direct screen blitting: */
if (frameBuffer())
frameBuffer()->moveEvent(static_cast<QMoveEvent*>(pEvent));
break;
}
# endif /* defined (VBOX_GUI_USE_DDRAW) */
#endif /* defined (Q_WS_WIN32) */
default:
break;
}
}
#ifdef Q_WS_WIN
else if (pWatched != 0 && pWatched == machineWindow()->menuBar())
{
/* Due to windows host uses separate 'focus set' to let menubar to
* operate while popped up (see UIMachineViewNormal::event() for details),
* it also requires backward processing: */
switch (pEvent->type())
{
/* If menubar gets the focus while not popped up => give it back: */
case QEvent::FocusIn:
{
if (!QApplication::activePopupWidget())
setFocus();
}
default:
break;
}
}
#endif /* Q_WS_WIN */
return UIMachineView::eventFilter(pWatched, pEvent);
}
void UIMachineWindowNormal::prepareMenu()
{
/* Call to base-class: */
UIMachineWindow::prepareMenu();
/* Prepare menu-bar: */
setMenuBar(uisession()->newMenuBar());
}
void UIMachineViewSeamless::normalizeGeometry(bool /* fAdjustPosition */)
{
/* Check if we should adjust guest to new size: */
if ((int)frameBuffer()->width() != workingArea().size().width() ||
(int)frameBuffer()->height() != workingArea().size().height())
if (uisession()->isGuestSupportsGraphics())
sltPerformGuestResize(workingArea().size());
}
void UIMachineWindowSeamless::prepareMenu()
{
/* Call to base-class: */
UIMachineWindow::prepareMenu();
/* Prepare menu: */
m_pMainMenu = uisession()->newMenu();
}
void UIMachineViewFullscreen::prepareConsoleConnections()
{
/* Base class connections: */
UIMachineView::prepareConsoleConnections();
/* Guest additions state-change updater: */
connect(uisession(), SIGNAL(sigAdditionsStateChange()), this, SLOT(sltAdditionsStateChanged()));
}
void UIMachineViewFullscreen::cleanupFullscreen()
{
/* If machine still running: */
if (uisession()->isRunning())
{
/* And guest supports advanced graphics management which is enabled: */
if (m_bIsGuestAutoresizeEnabled && uisession()->isGuestSupportsGraphics())
{
/* Rollback seamless frame-buffer size to normal: */
machineWindowWrapper()->machineWindow()->hide();
sltPerformGuestResize(guestSizeHint());
m_pSyncBlocker->exec();
/* Request to delete sync-blocker: */
m_pSyncBlocker->deleteLater();
}
}
}
void UIMachineWindowScale::showInNecessaryMode()
{
/* Show window if we have to: */
if (uisession()->isScreenVisible(m_uScreenId))
show();
/* Else hide window: */
else
hide();
}
void UIMachineViewSeamless::adjustGuestScreenSize()
{
/* Acquire working-area size: */
const QSize workingAreaSize = workingArea().size();
/* Acquire frame-buffer size: */
QSize frameBufferSize(frameBuffer()->width(), frameBuffer()->height());
/* Take the scale-factor(s) into account: */
frameBufferSize = scaledForward(frameBufferSize);
/* Check if we should adjust guest-screen to new size: */
if (frameBuffer()->isAutoEnabled() ||
frameBufferSize != workingAreaSize)
if (uisession()->isGuestSupportsGraphics() &&
uisession()->isScreenVisible(screenId()))
{
frameBuffer()->setAutoEnabled(false);
sltPerformGuestResize(workingArea().size());
}
}
void UIMachineLogicSeamless::prepareMenu()
{
/* Call to base-class: */
UIMachineLogic::prepareMenu();
/* Finally update view-menu, if necessary: */
if (uisession()->allowedActionsMenuView() & RuntimeMenuViewActionType_Multiscreen)
m_pScreenLayout->setViewMenu(gActionPool->action(UIActionIndexRuntime_Menu_View)->menu());
}
void UIMachineLogicSeamless::sltMachineStateChanged()
{
/* Call to base-class: */
UIMachineLogic::sltMachineStateChanged();
/* If machine-state changed from 'paused' to 'running': */
if (uisession()->isRunning() && uisession()->wasPaused())
{
LogRel(("GUI: UIMachineLogicSeamless::sltMachineStateChanged:"
"Machine-state changed from 'paused' to 'running': "
"Adjust machine-window geometry...\n"));
/* Make sure further code will be called just once: */
uisession()->forgetPreviousMachineState();
/* Adjust machine-window geometry if necessary: */
adjustMachineWindowsGeometry();
}
}
void UIMachineView::sltMachineStateChanged()
{
/* Get machine state: */
KMachineState state = uisession()->machineState();
switch (state)
{
case KMachineState_Paused:
case KMachineState_TeleportingPausedVM:
{
if ( vboxGlobal().vmRenderMode() != VBoxDefs::TimerMode
&& m_pFrameBuffer
&&
( state != KMachineState_TeleportingPausedVM
|| m_previousState != KMachineState_Teleporting))
{
takePauseShotLive();
/* Fully repaint to pick up m_pauseShot: */
viewport()->update();
}
break;
}
case KMachineState_Restoring:
{
/* Only works with the primary screen currently. */
if (screenId() == 0)
{
takePauseShotSnapshot();
/* Fully repaint to pick up m_pauseShot: */
viewport()->update();
}
break;
}
case KMachineState_Running:
{
if ( m_previousState == KMachineState_Paused
|| m_previousState == KMachineState_TeleportingPausedVM
|| m_previousState == KMachineState_Restoring)
{
if (vboxGlobal().vmRenderMode() != VBoxDefs::TimerMode && m_pFrameBuffer)
{
/* Reset the pixmap to free memory: */
resetPauseShot();
/* Ask for full guest display update (it will also update
* the viewport through IFramebuffer::NotifyUpdate): */
CDisplay dsp = session().GetConsole().GetDisplay();
dsp.InvalidateAndUpdate();
}
}
break;
}
default:
break;
}
m_previousState = state;
}
void UIMachineViewFullscreen::setGuestAutoresizeEnabled(bool fEnabled)
{
if (m_bIsGuestAutoresizeEnabled != fEnabled)
{
m_bIsGuestAutoresizeEnabled = fEnabled;
if (m_bIsGuestAutoresizeEnabled && uisession()->isGuestSupportsGraphics())
sltPerformGuestResize();
}
}
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();
}