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 UIMachineViewNormal::adjustGuestScreenSize()
{
/* Should we adjust guest-screen size? Logging paranoia is required here to reveal the truth. */
LogRel(("GUI: UIMachineViewNormal::adjustGuestScreenSize: Adjust guest-screen size if necessary.\n"));
bool fAdjust = false;
/* Step 1: Is the guest-screen of another size than necessary? */
if (!fAdjust)
{
/* Acquire frame-buffer size: */
QSize frameBufferSize(frameBuffer()->width(), frameBuffer()->height());
/* Take the scale-factor(s) into account: */
frameBufferSize = scaledForward(frameBufferSize);
/* Acquire central-widget size: */
const QSize centralWidgetSize = machineWindow()->centralWidget()->size();
if (frameBufferSize != centralWidgetSize)
{
LogRel2(("GUI: UIMachineViewNormal::adjustGuestScreenSize: Guest-screen is of another size than necessary, adjustment is required.\n"));
fAdjust = true;
}
}
/* Step 2: Is guest-additions supports graphics? */
if (fAdjust)
{
if (!uisession()->isGuestSupportsGraphics())
{
LogRel2(("GUI: UIMachineViewNormal::adjustGuestScreenSize: Guest-additions are not supporting graphics, adjustment is omitted.\n"));
fAdjust = false;
}
}
/* Step 3: Is guest-screen visible? */
if (fAdjust)
{
if (!uisession()->isScreenVisible(screenId()))
{
LogRel2(("GUI: UIMachineViewNormal::adjustGuestScreenSize: Guest-screen is not visible, adjustment is omitted.\n"));
fAdjust = false;
}
}
/* Step 4: Is guest-screen auto-resize enabled? */
if (fAdjust)
{
if (!m_bIsGuestAutoresizeEnabled)
{
LogRel2(("GUI: UIMachineViewNormal::adjustGuestScreenSize: Guest-screen auto-resize is disabled, adjustment is omitted.\n"));
fAdjust = false;
}
}
/* Final step: Adjust if requested/allowed. */
if (fAdjust)
{
sltPerformGuestResize(machineWindow()->centralWidget()->size());
}
}
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 UIMachineViewScale::takePauseShotLive()
{
/* Take a screen snapshot. Note that TakeScreenShot() always needs a 32bpp image: */
QImage shot = QImage(m_pFrameBuffer->width(), m_pFrameBuffer->height(), QImage::Format_RGB32);
/* If TakeScreenShot fails or returns no image, just show a black image. */
shot.fill(0);
CDisplay dsp = session().GetConsole().GetDisplay();
dsp.TakeScreenShot(screenId(), shot.bits(), shot.width(), shot.height());
m_pPauseImage = new QImage(shot);
scalePauseShot();
}
void UIMachineView::takePauseShotLive()
{
/* Take a screen snapshot. Note that TakeScreenShot() always needs a 32bpp image: */
QImage shot = QImage(m_pFrameBuffer->width(), m_pFrameBuffer->height(), QImage::Format_RGB32);
/* If TakeScreenShot fails or returns no image, just show a black image. */
shot.fill(0);
CDisplay dsp = session().GetConsole().GetDisplay();
dsp.TakeScreenShot(screenId(), shot.bits(), shot.width(), shot.height());
/* TakeScreenShot() may fail if, e.g. the Paused notification was delivered
* after the machine execution was resumed. It's not fatal: */
if (dsp.isOk())
dimImage(shot);
m_pauseShot = QPixmap::fromImage(shot);
}
void UIMachineViewNormal::resendSizeHint()
{
/* Get the last guest-screen size-hint, taking the scale factor into account. */
const QSize sizeHint = scaledBackward(guestScreenSizeHint());
LogRel(("GUI: UIMachineViewNormal::resendSizeHint: Restoring guest size-hint for screen %d to %dx%d\n",
(int)screenId(), sizeHint.width(), sizeHint.height()));
/* Expand current limitations: */
setMaxGuestSize(sizeHint);
/* Temporarily restrict the size to prevent a brief resize to the
* frame-buffer dimensions when we exit full-screen. This is only
* applied if the frame-buffer is at full-screen dimensions and
* until the first machine view resize. */
m_sizeHintOverride = QSize(800, 600).expandedTo(sizeHint);
/* Send saved size-hint to the guest: */
/// @todo What if not m_bIsGuestAutoresizeEnabled?
/// Just let the guest start at the default 800x600?
display().SetVideoModeHint(screenId(),
guestScreenVisibilityStatus(),
false, 0, 0, sizeHint.width(), sizeHint.height(), 0);
uisession()->setScreenVisibleHostDesires(screenId(), guestScreenVisibilityStatus());
}
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());
}
}
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 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;
}
}
bool UIMachineViewFullscreen::event(QEvent *pEvent)
{
switch (pEvent->type())
{
case VBoxDefs::ResizeEventType:
{
/* Some situations require framebuffer resize events to be ignored at all,
* leaving machine-window, machine-view and framebuffer sizes preserved: */
if (uisession()->isGuestResizeIgnored())
return true;
/* We are starting to perform machine-view resize,
* we should temporary ignore other if they are trying to be: */
bool fWasMachineWindowResizeIgnored = isMachineWindowResizeIgnored();
setMachineWindowResizeIgnored(true);
/* Get guest resize-event: */
UIResizeEvent *pResizeEvent = static_cast<UIResizeEvent*>(pEvent);
/* Perform framebuffer resize: */
frameBuffer()->resizeEvent(pResizeEvent);
/* Reapply maximum size restriction for machine-view: */
setMaximumSize(sizeHint());
/* Store the new size to prevent unwanted resize hints being sent back: */
storeConsoleSize(pResizeEvent->width(), pResizeEvent->height());
/* Perform machine-view resize: */
resize(pResizeEvent->width(), pResizeEvent->height());
/* May be we have to restrict minimum size? */
maybeRestrictMinimumSize();
/* Let our toplevel widget calculate its sizeHint properly: */
QCoreApplication::sendPostedEvents(0, QEvent::LayoutRequest);
#ifdef Q_WS_MAC
machineLogic()->updateDockIconSize(screenId(), pResizeEvent->width(), pResizeEvent->height());
#endif /* Q_WS_MAC */
/* Update machine-view sliders: */
updateSliders();
/* Report to the VM thread that we finished resizing: */
session().GetConsole().GetDisplay().ResizeCompleted(screenId());
/* We are finishing to perform machine-view resize: */
setMachineWindowResizeIgnored(fWasMachineWindowResizeIgnored);
/* We also recalculate the desktop geometry if this is determined
* automatically. In fact, we only need this on the first resize,
* but it is done every time to keep the code simpler. */
calculateDesktopGeometry();
/* Emit a signal about guest was resized: */
emit resizeHintDone();
/* Unlock after processing guest resize event: */
if (m_pSyncBlocker && m_pSyncBlocker->isRunning())
m_pSyncBlocker->quit();
pEvent->accept();
return true;
}
default:
break;
}
return UIMachineView::event(pEvent);
}
bool UIMachineViewScale::event(QEvent *pEvent)
{
switch (pEvent->type())
{
case VBoxDefs::ResizeEventType:
{
/* Some situations require framebuffer resize events to be ignored at all,
* leaving machine-window, machine-view and framebuffer sizes preserved: */
if (uisession()->isGuestResizeIgnored())
return true;
/* We are starting to perform machine-view resize,
* we should temporary ignore other if they are trying to be: */
bool fWasMachineWindowResizeIgnored = isMachineWindowResizeIgnored();
setMachineWindowResizeIgnored(true);
/* Get guest resize-event: */
UIResizeEvent *pResizeEvent = static_cast<UIResizeEvent*>(pEvent);
/* Perform framebuffer resize: */
frameBuffer()->setScaledSize(size());
frameBuffer()->resizeEvent(pResizeEvent);
/* Store the new size to prevent unwanted resize hints being sent back: */
storeConsoleSize(pResizeEvent->width(), pResizeEvent->height());
/* Let our toplevel widget calculate its sizeHint properly: */
QCoreApplication::sendPostedEvents(0, QEvent::LayoutRequest);
#ifdef Q_WS_MAC
machineLogic()->updateDockIconSize(screenId(), pResizeEvent->width(), pResizeEvent->height());
#endif /* Q_WS_MAC */
/* Report to the VM thread that we finished resizing: */
session().GetConsole().GetDisplay().ResizeCompleted(screenId());
/* We are finishing to perform machine-view resize: */
setMachineWindowResizeIgnored(fWasMachineWindowResizeIgnored);
/* We also recalculate the desktop geometry if this is determined
* automatically. In fact, we only need this on the first resize,
* but it is done every time to keep the code simpler. */
calculateDesktopGeometry();
/* Emit a signal about guest was resized: */
emit resizeHintDone();
pEvent->accept();
return true;
}
case VBoxDefs::RepaintEventType:
{
UIRepaintEvent *pPaintEvent = static_cast<UIRepaintEvent*>(pEvent);
QSize scaledSize = frameBuffer()->scaledSize();
double xRatio = (double)scaledSize.width() / frameBuffer()->width();
double yRatio = (double)scaledSize.height() / frameBuffer()->height();
AssertMsg(contentsX() == 0, ("This can't be, else notify Dsen!\n"));
AssertMsg(contentsY() == 0, ("This can't be, else notify Dsen!\n"));
/* Make sure we update always a bigger rectangle than requested to
* catch all rounding errors. (use 1 time the ratio factor and
* round down on top/left, but round up for the width/height) */
viewport()->update((int)(pPaintEvent->x() * xRatio) - ((int)xRatio) - 1,
(int)(pPaintEvent->y() * yRatio) - ((int)yRatio) - 1,
(int)(pPaintEvent->width() * xRatio) + ((int)xRatio + 2) * 2,
(int)(pPaintEvent->height() * yRatio) + ((int)yRatio + 2) * 2);
pEvent->accept();
return true;
}
default:
break;
}
return UIMachineView::event(pEvent);
}
void UIMachineViewFullscreen::adjustGuestScreenSize()
{
/* Should we adjust guest-screen size? Logging paranoia is required here to reveal the truth. */
LogRel(("GUI: UIMachineViewFullscreen::adjustGuestScreenSize: Adjust guest-screen size if necessary.\n"));
bool fAdjust = false;
/* Step 1: Was the guest-screen enabled automatically? */
if (!fAdjust)
{
if (frameBuffer()->isAutoEnabled())
{
LogRel2(("GUI: UIMachineViewFullscreen::adjustGuestScreenSize: Guest-screen was enabled automatically, adjustment is required.\n"));
fAdjust = true;
}
}
/* Step 2: Is the guest-screen of another size than necessary? */
if (!fAdjust)
{
/* Acquire frame-buffer size: */
QSize frameBufferSize(frameBuffer()->width(), frameBuffer()->height());
/* Take the scale-factor(s) into account: */
frameBufferSize = scaledForward(frameBufferSize);
/* Acquire working-area size: */
const QSize workingAreaSize = workingArea().size();
if (frameBufferSize != workingAreaSize)
{
LogRel2(("GUI: UIMachineViewFullscreen::adjustGuestScreenSize: Guest-screen is of another size than necessary, adjustment is required.\n"));
fAdjust = true;
}
}
/* Step 3: Is guest-additions supports graphics? */
if (fAdjust)
{
if (!uisession()->isGuestSupportsGraphics())
{
LogRel2(("GUI: UIMachineViewFullscreen::adjustGuestScreenSize: Guest-additions are not supporting graphics, adjustment is omitted.\n"));
fAdjust = false;
}
}
/* Step 4: Is guest-screen visible? */
if (fAdjust)
{
if (!uisession()->isScreenVisible(screenId()))
{
LogRel2(("GUI: UIMachineViewFullscreen::adjustGuestScreenSize: Guest-screen is not visible, adjustment is omitted.\n"));
fAdjust = false;
}
}
/* Step 5: Is guest-screen auto-resize enabled? */
if (fAdjust)
{
if (!m_bIsGuestAutoresizeEnabled)
{
LogRel2(("GUI: UIMachineViewFullscreen::adjustGuestScreenSize: Guest-screen auto-resize is disabled, adjustment is omitted.\n"));
fAdjust = false;
}
}
/* Final step: Adjust if requested/allowed. */
if (fAdjust)
{
frameBuffer()->setAutoEnabled(false);
sltPerformGuestResize(workingArea().size());
/* And remember the size to know what we are resizing out of when we exit: */
uisession()->setLastFullScreenSize(screenId(), scaledForward(scaledBackward(workingArea().size())));
}
}
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;
}
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 UIMachineView::prepareFrameBuffer()
{
/* Prepare frame-buffer depending on render-mode: */
switch (vboxGlobal().vmRenderMode())
{
#ifdef VBOX_GUI_USE_QIMAGE
case VBoxDefs::QImageMode:
# ifdef VBOX_WITH_VIDEOHWACCEL
if (m_fAccelerate2DVideo)
{
UIFrameBuffer* pFramebuffer = uisession()->frameBuffer(screenId());
if (pFramebuffer)
pFramebuffer->setView(this);
else
{
/* these two additional template args is a workaround to this [VBox|UI] duplication
* @todo: they are to be removed once VBox stuff is gone */
pFramebuffer = new VBoxOverlayFrameBuffer<UIFrameBufferQImage, UIMachineView, UIResizeEvent>(this, &machineWindowWrapper()->session(), (uint32_t)screenId());
uisession()->setFrameBuffer(screenId(), pFramebuffer);
}
m_pFrameBuffer = pFramebuffer;
}
else
m_pFrameBuffer = new UIFrameBufferQImage(this);
# else /* VBOX_WITH_VIDEOHWACCEL */
m_pFrameBuffer = new UIFrameBufferQImage(this);
# endif /* !VBOX_WITH_VIDEOHWACCEL */
break;
#endif /* VBOX_GUI_USE_QIMAGE */
#ifdef VBOX_GUI_USE_QGLFB
case VBoxDefs::QGLMode:
m_pFrameBuffer = new UIFrameBufferQGL(this);
break;
// case VBoxDefs::QGLOverlayMode:
// m_pFrameBuffer = new UIQGLOverlayFrameBuffer(this);
// break;
#endif /* VBOX_GUI_USE_QGLFB */
#ifdef VBOX_GUI_USE_SDL
case VBoxDefs::SDLMode:
/* Indicate that we are doing all drawing stuff ourself: */
// TODO_NEW_CORE
viewport()->setAttribute(Qt::WA_PaintOnScreen);
# ifdef Q_WS_X11
/* This is somehow necessary to prevent strange X11 warnings on i386 and segfaults on x86_64: */
XFlush(QX11Info::display());
# endif /* Q_WS_X11 */
# if defined(VBOX_WITH_VIDEOHWACCEL) && defined(DEBUG_misha) /* not tested yet */
if (m_fAccelerate2DVideo)
{
class UIFrameBuffer* pFramebuffer = uisession()->frameBuffer(screenId());
if (pFramebuffer)
pFramebuffer->setView(this);
else
{
/* these two additional template args is a workaround to this [VBox|UI] duplication
* @todo: they are to be removed once VBox stuff is gone */
pFramebuffer = new VBoxOverlayFrameBuffer<UIFrameBufferSDL, UIMachineView, UIResizeEvent>(this, &machineWindowWrapper()->session(), (uint32_t)screenId());
uisession()->setFrameBuffer(screenId(), pFramebuffer);
}
m_pFrameBuffer = pFramebuffer;
}
else
m_pFrameBuffer = new UIFrameBufferSDL(this);
# else
m_pFrameBuffer = new UIFrameBufferSDL(this);
# endif
/* Disable scrollbars because we cannot correctly draw in a scrolled window using SDL: */
horizontalScrollBar()->setEnabled(false);
verticalScrollBar()->setEnabled(false);
break;
#endif /* VBOX_GUI_USE_SDL */
#if 0 // TODO: Enable DDraw frame buffer!
#ifdef VBOX_GUI_USE_DDRAW
case VBoxDefs::DDRAWMode:
m_pFrameBuffer = new UIDDRAWFrameBuffer(this);
if (!m_pFrameBuffer || m_pFrameBuffer->address() == NULL)
{
if (m_pFrameBuffer)
delete m_pFrameBuffer;
m_mode = VBoxDefs::QImageMode;
m_pFrameBuffer = new UIFrameBufferQImage(this);
}
break;
#endif /* VBOX_GUI_USE_DDRAW */
#endif
#ifdef VBOX_GUI_USE_QUARTZ2D
case VBoxDefs::Quartz2DMode:
/* Indicate that we are doing all drawing stuff ourself: */
viewport()->setAttribute(Qt::WA_PaintOnScreen);
# ifdef VBOX_WITH_VIDEOHWACCEL
if (m_fAccelerate2DVideo)
{
UIFrameBuffer* pFramebuffer = uisession()->frameBuffer(screenId());
if (pFramebuffer)
pFramebuffer->setView(this);
else
{
/* these two additional template args is a workaround to this [VBox|UI] duplication
* @todo: they are to be removed once VBox stuff is gone */
pFramebuffer = new VBoxOverlayFrameBuffer<UIFrameBufferQuartz2D, UIMachineView, UIResizeEvent>(this, &machineWindowWrapper()->session(), (uint32_t)screenId());
uisession()->setFrameBuffer(screenId(), pFramebuffer);
}
m_pFrameBuffer = pFramebuffer;
}
else
m_pFrameBuffer = new UIFrameBufferQuartz2D(this);
# else /* VBOX_WITH_VIDEOHWACCEL */
m_pFrameBuffer = new UIFrameBufferQuartz2D(this);
# endif /* !VBOX_WITH_VIDEOHWACCEL */
break;
#endif /* VBOX_GUI_USE_QUARTZ2D */
default:
AssertReleaseMsgFailed(("Render mode must be valid: %d\n", vboxGlobal().vmRenderMode()));
LogRel(("Invalid render mode: %d\n", vboxGlobal().vmRenderMode()));
qApp->exit(1);
break;
}
/* If frame-buffer was prepared: */
if (m_pFrameBuffer)
{
/* Prepare display: */
CDisplay display = session().GetConsole().GetDisplay();
Assert(!display.isNull());
#ifdef VBOX_WITH_VIDEOHWACCEL
CFramebuffer fb(NULL);
if (m_fAccelerate2DVideo)
{
LONG XOrigin, YOrigin;
/* Check if the framebuffer is already assigned;
* in this case we do not need to re-assign it neither do we need to AddRef. */
display.GetFramebuffer(m_uScreenId, fb, XOrigin, YOrigin);
}
if (fb.raw() != m_pFrameBuffer) /* <-this will evaluate to true iff m_fAccelerate2DVideo is disabled or iff no framebuffer is yet assigned */
#endif /* VBOX_WITH_VIDEOHWACCEL */
{
m_pFrameBuffer->AddRef();
}
/* Always perform SetFramebuffer to ensure 3D gets notified: */
display.SetFramebuffer(m_uScreenId, CFramebuffer(m_pFrameBuffer));
}
QSize size;
#ifdef Q_WS_X11
/* Processing pseudo resize-event to synchronize frame-buffer with stored
* framebuffer size. On X11 this will be additional done when the machine
* state was 'saved'. */
if (session().GetMachine().GetState() == KMachineState_Saved)
size = guestSizeHint();
#endif /* Q_WS_X11 */
/* If there is a preview image saved, we will resize the framebuffer to the
* size of that image. */
ULONG buffer = 0, width = 0, height = 0;
CMachine machine = session().GetMachine();
machine.QuerySavedScreenshotPNGSize(0, buffer, width, height);
if (buffer > 0)
{
/* Init with the screenshot size */
size = QSize(width, height);
/* Try to get the real guest dimensions from the save state */
ULONG guestWidth = 0, guestHeight = 0;
machine.QuerySavedGuestSize(0, guestWidth, guestHeight);
if ( guestWidth > 0
&& guestHeight > 0)
size = QSize(guestWidth, guestHeight);
}
/* If we have a valid size, resize the framebuffer. */
if ( size.width() > 0
&& size.height() > 0)
{
UIResizeEvent event(FramebufferPixelFormat_Opaque, NULL, 0, 0, size.width(), size.height());
frameBuffer()->resizeEvent(&event);
}
}