Changeset 26878 in vbox for trunk/src

Timestamp:

Feb 26, 2010 11:56:51 PM (15 years ago)

Author:

vboxsync

Message:

FE/Qt4: New running VM core: guest auto-resize feature fixed.

Location:

trunk/src/VBox/Frontends/VirtualBox/src/runtime

Files:

• UIFrameBuffer.cpp (modified) (1 diff)
• UIMachineView.cpp (modified) (20 diffs)
• UIMachineView.h (modified) (11 diffs)
• UIMachineWindow.cpp (modified) (2 diffs)
• UIMachineWindow.h (modified) (3 diffs)
• normal/UIMachineViewNormal.cpp (modified) (9 diffs)
• normal/UIMachineViewNormal.h (modified) (2 diffs)
• normal/UIMachineWindowNormal.cpp (modified) (5 diffs)
• normal/UIMachineWindowNormal.h (modified) (1 diff)

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIFrameBuffer.cpp

@@ -184 +184 @@
         return E_POINTER;
     *pbSupported = TRUE;
-    QRect screen = m_pMachineView->desktopGeometry();
+    QSize screen = m_pMachineView->desktopGeometry();
     if ((screen.width() != 0) && (uWidth > (ULONG)screen.width()))
         *pbSupported = FALSE;

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.cpp

@@ -148 +148 @@
 }
 
+void UIMachineView::destroy(UIMachineView *pWhichView)
+{
+    delete pWhichView;
+}
+
 int UIMachineView::keyboardState() const
 {
@@ -197 +202 @@
     , m_bIsHostkeyAlone (false)
     , m_bIsHostkeyInCapture(false)
-    , m_bIsMachineWindowResizeIgnored(true)
+    , m_bIsMachineWindowResizeIgnored(false)
     , m_bIsFrameBufferResizeIgnored(false)
     , m_fPassCAD(false)
 #ifdef VBOX_WITH_VIDEOHWACCEL
     , m_fAccelerate2DVideo(bAccelerate2DVideo)
-#endif
-#if 0 // TODO: Do we need this?
-    , mDoResize(false)
 #endif
 #if defined(Q_WS_MAC)
@@ -214 +216 @@
     , mDockIconEnabled(true)
 #endif
-    , m_desktopGeometryType(DesktopGeo_Invalid)
-      /* Don't show a hardware pointer until we have one to show */
 {
 }
@@ -277 +277 @@
 }
 
-QRect UIMachineView::desktopGeometry() const
-{
-    QRect geometry;
-    switch (m_desktopGeometryType)
-    {
-        case DesktopGeo_Fixed:
-        case DesktopGeo_Automatic:
-            geometry = QRect(0, 0,
-                             qMax(m_desktopGeometry.width(), m_storedConsoleSize.width()),
-                             qMax(m_desktopGeometry.height(), m_storedConsoleSize.height()));
-            break;
-        case DesktopGeo_Any:
-            geometry = QRect(0, 0, 0, 0);
-            break;
-        default:
-            AssertMsgFailed(("Bad geometry type %d!\n", m_desktopGeometryType));
-    }
-    return geometry;
-}
-
-void UIMachineView::calculateDesktopGeometry()
-{
-    /* This method should not get called until we have initially set up the m_desktopGeometryType: */
-    Assert((m_desktopGeometryType != DesktopGeo_Invalid));
-    /* If we are not doing automatic geometry calculation then there is nothing to do: */
-    if (DesktopGeo_Automatic == m_desktopGeometryType)
-    {
-        /* Available geometry of the desktop.  If the desktop is a single
-         * screen, this will exclude space taken up by desktop taskbars
-         * and things, but this is unfortunately not true for the more
-         * complex case of a desktop spanning multiple screens: */
-        QRect desktop = availableGeometry();
-        /* The area taken up by the machine window on the desktop,
-         * including window frame, title and menu bar and whatnot: */
-        QRect frame = machineWindowWrapper()->machineWindow()->frameGeometry();
-        /* The area taken up by the machine view, so excluding all decorations: */
-        QRect window = geometry();
-        /* To work out how big we can make the console window while still
-         * fitting on the desktop, we calculate desktop - frame + window.
-         * This works because the difference between frame and window
-         * (or at least its width and height) is a constant. */
-        m_desktopGeometry = QRect(0, 0, desktop.width() - frame.width() + window.width(),
-                                        desktop.height() - frame.height() + window.height());
-    }
-}
-
-void UIMachineView::setDesktopGeometry(DesktopGeo geometry, int aWidth, int aHeight)
-{
-    switch (geometry)
-    {
-        case DesktopGeo_Fixed:
-            m_desktopGeometryType = DesktopGeo_Fixed;
-            if (aWidth != 0 && aHeight != 0)
-                m_desktopGeometry = QRect(0, 0, aWidth, aHeight);
-            else
-                m_desktopGeometry = QRect(0, 0, 0, 0);
-            storeConsoleSize(0, 0);
-            break;
-        case DesktopGeo_Automatic:
-            m_desktopGeometryType = DesktopGeo_Automatic;
-            m_desktopGeometry = QRect(0, 0, 0, 0);
-            storeConsoleSize(0, 0);
-            break;
-        case DesktopGeo_Any:
-            m_desktopGeometryType = DesktopGeo_Any;
-            m_desktopGeometry = QRect(0, 0, 0, 0);
-            break;
-        default:
-            AssertMsgFailed(("Invalid desktop geometry type %d\n", geometry));
-            m_desktopGeometryType = DesktopGeo_Invalid;
-    }
-}
-
-void UIMachineView::storeConsoleSize(int aWidth, int aHeight)
-{
-    LogFlowThisFunc(("aWidth=%d, aHeight=%d\n", aWidth, aHeight));
-    m_storedConsoleSize = QRect(0, 0, aWidth, aHeight);
-}
-
-QRect UIMachineView::availableGeometry()
-{
-    return machineWindowWrapper()->machineWindow()->isFullScreen() ?
-           QApplication::desktop()->screenGeometry(this) :
-           QApplication::desktop()->availableGeometry(this);
+void UIMachineView::updateMouseClipping()
+{
+    if (uisession()->isMouseCaptured())
+    {
+        viewport()->setCursor(QCursor(Qt::BlankCursor));
+#ifdef Q_WS_WIN32
+        QRect r = viewport()->rect();
+        r.moveTopLeft(viewport()->mapToGlobal(QPoint (0, 0)));
+        RECT rect = { r.left(), r.top(), r.right() + 1, r.bottom() + 1 };
+        ::ClipCursor(&rect);
+#endif
+    }
+    else
+    {
+#ifdef Q_WS_WIN32
+        ::ClipCursor(NULL);
+#endif
+        /* return the cursor to where it was when we captured it and show it */
+        QCursor::setPos(m_capturedMousePos);
+        viewport()->unsetCursor();
+    }
+}
+
+void UIMachineView::updateSliders()
+{
+    QSize p = viewport()->size();
+    QSize m = maximumViewportSize();
+
+    QSize v = QSize(m_pFrameBuffer->width(), m_pFrameBuffer->height());
+    /* no scroll bars needed */
+    if (m.expandedTo(v) == m)
+        p = m;
+
+    horizontalScrollBar()->setRange(0, v.width() - p.width());
+    verticalScrollBar()->setRange(0, v.height() - p.height());
+    horizontalScrollBar()->setPageStep(p.width());
+    verticalScrollBar()->setPageStep(p.height());
 }
 
@@ -543 +496 @@
 void UIMachineView::prepareConsoleConnections()
 {
-    /* UISession notifier: */
-    UISession *sender = machineWindowWrapper()->machineLogic()->uisession();
-
     /* Machine state-change updater: */
-    connect(sender, SIGNAL(sigMachineStateChange()), this, SLOT(sltMachineStateChanged()));
-
-    /* Guest additions state-change updater: */
-    connect(sender, SIGNAL(sigAdditionsStateChange()), this, SLOT(sltAdditionsStateChanged()));
+    connect(uisession(), SIGNAL(sigMachineStateChange()), this, SLOT(sltMachineStateChanged()));
 
     /* Mouse pointer shape state-change updater: */
-    connect(sender, SIGNAL(sigMousePointerShapeChange()), this, SLOT(sltMousePointerShapeChanged()));
+    connect(uisession(), SIGNAL(sigMousePointerShapeChange()), this, SLOT(sltMousePointerShapeChanged()));
 
     /* Mouse capability state-change updater: */
-    connect(sender, SIGNAL(sigMouseCapabilityChange()), this, SLOT(sltMouseCapabilityChanged()));
+    connect(uisession(), SIGNAL(sigMouseCapabilityChange()), this, SLOT(sltMouseCapabilityChanged()));
 }
 
@@ -563 +510 @@
     /* Global settings: */
     {
-        /* Remember the desktop geometry and register for geometry
-         * change events for telling the guest about video modes we like: */
-        QString desktopGeometry = vboxGlobal().settings().publicProperty("GUI/MaxGuestResolution");
-        if ((desktopGeometry == QString::null) || (desktopGeometry == "auto"))
-            setDesktopGeometry(DesktopGeo_Automatic, 0, 0);
-        else if (desktopGeometry == "any")
-            setDesktopGeometry(DesktopGeo_Any, 0, 0);
-        else
-        {
-            int width = desktopGeometry.section(',', 0, 0).toInt();
-            int height = desktopGeometry.section(',', 1, 1).toInt();
-            setDesktopGeometry(DesktopGeo_Fixed, width, height);
-        }
-        connect(QApplication::desktop(), SIGNAL(resized(int)), this, SLOT(sltDesktopResized()));
-
 #ifdef Q_WS_X11
         /* Initialize the X keyboard subsystem: */
@@ -644 +576 @@
 }
 
-void UIMachineView::sltMachineStateChanged()
-{
-    /* Get machine state: */
-    KMachineState state = uisession()->machineState();
-    switch (state)
-    {
-        case KMachineState_Paused:
-        case KMachineState_TeleportingPausedVM:
-        {
-            if (mode() != VBoxDefs::TimerMode &&  m_pFrameBuffer &&
-                (state != KMachineState_TeleportingPausedVM || m_previousState != KMachineState_Teleporting))
-            {
-                /* Take a screen snapshot. Note that TakeScreenShot() always needs a 32bpp image: */
-                QImage shot = QImage(m_pFrameBuffer->width(), m_pFrameBuffer->height(), QImage::Format_RGB32);
-                CDisplay dsp = session().GetConsole().GetDisplay();
-                dsp.TakeScreenShot(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);
-                    /* Fully repaint to pick up m_pauseShot: */
-                    repaint();
-                }
-            }
-        }
-        case KMachineState_Stuck:
-        {
-            /* Reuse the focus event handler to uncapture everything: */
-            if (hasFocus())
-                focusEvent(false /* aHasFocus*/, false /* aReleaseHostKey */);
-            break;
-        }
-        case KMachineState_Running:
-        {
-            if (m_previousState == KMachineState_Paused || m_previousState == KMachineState_TeleportingPausedVM)
-            {
-                if (mode() != VBoxDefs::TimerMode && m_pFrameBuffer)
-                {
-                    /* Reset the pixmap to free memory: */
-                    m_pauseShot = QPixmap();
-                    /* Ask for full guest display update (it will also update
-                     * the viewport through IFramebuffer::NotifyUpdate): */
-                    CDisplay dsp = session().GetConsole().GetDisplay();
-                    dsp.InvalidateAndUpdate();
-                }
-            }
-            /* Reuse the focus event handler to capture input: */
-            if (hasFocus())
-                focusEvent(true /* aHasFocus */);
-            break;
-        }
-        default:
-            break;
-    }
-
-#ifdef Q_WS_MAC
-    /* Update Dock Overlay: */
-    updateDockOverlay();
-#endif /* Q_WS_MAC */
-
-    m_previousState = state;
-}
-
-void UIMachineView::sltAdditionsStateChanged()
-{
-    /* Check if we should restrict minimum size: */
-    maybeRestrictMinimumSize();
-
-#if 0 // TODO: Do we need this?
-    if (!mDoResize && !isGuestSupportsGraphics() && fIsGuestSupportsGraphics &&
-        (machineWindowWrapper()->isTrueSeamless() || machineWindowWrapper()->isTrueFullscreen()))
-        mDoResize = true;
-    /* This will only be acted upon if mDoResize is true: */
-    sltPerformGuestResize();
-#endif
-}
-
-void UIMachineView::sltMousePointerShapeChanged()
-{
-    if (uisession()->isMouseSupportsAbsolute())
-    {
-        /* Should we hide/show pointer? */
-        if (uisession()->isHidingHostPointer())
-            viewport()->setCursor(Qt::BlankCursor);
-        else
-            viewport()->setCursor(uisession()->cursor());
-    }
-}
-
-void UIMachineView::sltMouseCapabilityChanged()
-{
-    /* Correct the mouse capture state and reset the cursor to the default shape if necessary: */
-    if (uisession()->isMouseSupportsAbsolute())
-    {
-        CMouse mouse = session().GetConsole().GetMouse();
-        mouse.PutMouseEventAbsolute(-1, -1, 0, 0, 0);
-        captureMouse(false, false);
-    }
-    else
-        viewport()->unsetCursor();
-
-    /* Notify user about mouse integration state: */
-    vboxProblem().remindAboutMouseIntegration(uisession()->isMouseSupportsAbsolute());
-
-    /* Notify all listeners: */
-    emitMouseStateChanged();
-}
-
-/* If the desktop geometry is set automatically, this will update it: */
-void UIMachineView::sltDesktopResized()
-{
-    calculateDesktopGeometry();
-}
-
-#ifdef Q_WS_MAC
-void UIMachineView::sltChangeDockIconUpdate(const VBoxChangeDockIconUpdateEvent &event)
-{
-    setDockIconEnabled(event.mChanged);
-    updateDockOverlay();
-}
-
-# ifdef QT_MAC_USE_COCOA
-void UIMachineView::sltChangePresentationMode(const VBoxChangePresentationModeEvent &event)
-{
-    // TODO_NEW_CORE
-    // this is full screen related
-#if 0
-    if (mIsFullscreen)
-    {
-        /* First check if we are on the primary screen, only than the presentation mode have to be changed. */
-        QDesktopWidget* pDesktop = QApplication::desktop();
-        if (pDesktop->screenNumber(this) == pDesktop->primaryScreen())
-        {
-            QString testStr = vboxGlobal().virtualBox().GetExtraData(VBoxDefs::GUI_PresentationModeEnabled).toLower();
-            /* Default to false if it is an empty value */
-            if (testStr.isEmpty() || testStr == "false")
-                SetSystemUIMode(kUIModeAllHidden, 0);
-            else
-                SetSystemUIMode(kUIModeAllSuppressed, 0);
-        }
-    }
-    else
-        SetSystemUIMode(kUIModeNormal, 0);
-#endif
-}
-# endif /* QT_MAC_USE_COCOA */
-#endif
-
 bool UIMachineView::event(QEvent *pEvent)
 {
@@ -818 +600 @@
         }
 
-        case VBoxDefs::ResizeEventType:
-        {
-            /* Some situations require initial VGA Resize Request
-             * to be ignored at all, leaving previous framebuffer,
-             * machine view and machine window sizes preserved: */
-            if (uisession()->isGuestResizeIgnored())
-                return true;
-
-            bool oldIgnoreMainwndResize = m_bIsMachineWindowResizeIgnored;
-            m_bIsMachineWindowResizeIgnored = true;
-
-            UIResizeEvent *pResizeEvent = static_cast<UIResizeEvent*>(pEvent);
-
-            /* Store the new size to prevent unwanted resize hints being sent back. */
-            storeConsoleSize(pResizeEvent->width(), pResizeEvent->height());
-
-            /* Unfortunately restoreOverrideCursor() is broken in Qt 4.4.0 if WA_PaintOnScreen widgets are present.
-             * This is the case on linux with SDL. As workaround we save/restore the arrow cursor manually.
-             * See http://trolltech.com/developer/task-tracker/index_html?id=206165&method=entry for details.
-             * Moreover the current cursor, which could be set by the guest, should be restored after resize: */
-            QCursor cursor;
-            if (uisession()->isHidingHostPointer())
-                cursor = QCursor(Qt::BlankCursor);
-            else
-                cursor = viewport()->cursor();
-            m_pFrameBuffer->resizeEvent(pResizeEvent);
-            viewport()->setCursor(cursor);
-
-#ifdef Q_WS_MAC
-            // TODO_NEW_CORE
-//            mDockIconPreview->setOriginalSize(pResizeEvent->width(), pResizeEvent->height());
-#endif /* Q_WS_MAC */
-
-            /* This event appears in case of guest video was changed for somehow even without video resolution change.
-             * In this last case the host VM window will not be resized according this event and the host mouse cursor
-             * which was unset to default here will not be hidden in capture state. So it is necessary to perform
-             * updateMouseClipping() for the guest resize event if the mouse cursor was captured: */
-            if (uisession()->isMouseCaptured())
-                updateMouseClipping();
-
-            /* Apply maximum size restriction: */
-            setMaximumSize(sizeHint());
-
-            /* May be we have to restrict minimum size? */
-            maybeRestrictMinimumSize();
-
-            /* Resize the guest canvas: */
-            if (!m_bIsFrameBufferResizeIgnored)
-                resize(pResizeEvent->width(), pResizeEvent->height());
-            updateSliders();
-
-            /* Let our toplevel widget calculate its sizeHint properly. */
-#ifdef Q_WS_X11
-            /* We use processEvents rather than sendPostedEvents & set the time out value to max cause on X11 otherwise
-             * the layout isn't calculated correctly. Dosn't find the bug in Qt, but this could be triggered through
-             * the async nature of the X11 window event system. */
-            QCoreApplication::processEvents(QEventLoop::AllEvents, INT_MAX);
-#else /* Q_WS_X11 */
-            QCoreApplication::sendPostedEvents(0, QEvent::LayoutRequest);
-#endif /* Q_WS_X11 */
-
-            if (!m_bIsFrameBufferResizeIgnored)
-                normalizeGeometry(true /* adjustPosition */);
-
-            /* Report to the VM thread that we finished resizing */
-            session().GetConsole().GetDisplay().ResizeCompleted(0);
-
-            m_bIsMachineWindowResizeIgnored = oldIgnoreMainwndResize;
-
-            /* Make sure that all posted signals are processed: */
-            qApp->processEvents();
-
-            /* Emit a signal about guest was resized: */
-            emit resizeHintDone();
-
-            /* 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();
-
-            /* Enable frame-buffer resize watching: */
-            if (m_bIsFrameBufferResizeIgnored)
-                m_bIsFrameBufferResizeIgnored = false;
-
-            return true;
-        }
-
-        /* See VBox[QImage|SDL]FrameBuffer::NotifyUpdate(): */
         case VBoxDefs::RepaintEventType:
         {
@@ -1021 +715 @@
             if (m_bIsHostkeyPressed && pEvent->type() == QEvent::KeyPress)
             {
+                /* Passing F1-F12 keys to the guest: */
                 if (pKeyEvent->key() >= Qt::Key_F1 && pKeyEvent->key() <= Qt::Key_F12)
                 {
@@ -1048 +743 @@
                 if (pKeyEvent->key() == Qt::Key_Home)
                 {
-#if 0 // TODO: Divide tha code to specific parts and move it there:
+#if 0 // TODO: Divide tha code to specific parts of fullscreen & seamless and move it there:
                     /* Activate the main menu */
                     if (machineWindowWrapper()->isTrueSeamless() || machineWindowWrapper()->isTrueFullscreen())
                         machineWindowWrapper()->popupMainMenu (uisession()->isMouseCaptured());
-                    else
-                    {
-                        /* In Qt4 it is not enough to just set the focus to menu-bar.
-                         * So to get the menu-bar we have to send Qt::Key_Alt press/release events directly: */
-                        QKeyEvent e1(QEvent::KeyPress, Qt::Key_Alt, Qt::NoModifier);
-                        QKeyEvent e2(QEvent::KeyRelease, Qt::Key_Alt, Qt::NoModifier);
-                        QApplication::sendEvent(machineWindowWrapper()->menuBar(), &e1);
-                        QApplication::sendEvent(machineWindowWrapper()->menuBar(), &e2);
-                    }
 #endif
                 }
@@ -1190 +876 @@
         switch (pEvent->type())
         {
-#if 0 // TODO Move to normal specific event handler:
-            case QEvent::Resize:
-            {
-                /* Set the "guest needs to resize" hint. This hint is acted upon when (and only when)
-                 * the autoresize property is "true": */
-                mDoResize = isGuestSupportsGraphics() || machineWindowWrapper()->isTrueFullscreen();
-                if (!m_bIsMachineWindowResizeIgnored && isGuestSupportsGraphics() && m_bIsGuestAutoresizeEnabled)
-                    QTimer::singleShot(300, this, SLOT(sltPerformGuestResize()));
-                break;
-            }
-#endif
             case QEvent::WindowStateChange:
             {
-                /* During minimizing and state restoring machineWindowWrapper() gets the focus
-                 * which belongs to console view window, so returning it properly. */
+                /* During minimizing and state restoring machineWindowWrapper() gets
+                 * the focus which belongs to console view window, so returning it properly. */
                 QWindowStateChangeEvent *pWindowEvent = static_cast<QWindowStateChangeEvent*>(pEvent);
                 if (pWindowEvent->oldState() & Qt::WindowMinimized)
@@ -1218 +893 @@
             }
 #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 (m_pFrameBuffer)
-                    m_pFrameBuffer->moveEvent(static_cast<QMoveEvent*>(pEvent));
-                break;
-            }
-#endif
             /* Install/uninstall low-level kbd hook on every activation/deactivation to:
              * a) avoid excess hook calls when we're not active and
@@ -1260 +925 @@
         }
     }
-#if 0 // TODO Move to normal specific event handler:
-    else if (pWatched == machineWindowWrapper()->menuBar())
-    {
-        /* Sometimes when we press ESC in the menu it brings the focus away (Qt bug?)
-         * causing no widget to have a focus, or holds the focus itself, instead of
-         * returning the focus to the console window. Here we fix this: */
-        switch (pEvent->type())
-        {
-            case QEvent::FocusOut:
-            {
-                if (qApp->focusWidget() == 0)
-                    setFocus();
-                break;
-            }
-            case QEvent::KeyPress:
-            {
-                QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
-                if (pKeyEvent->key() == Qt::Key_Escape && (pKeyEvent->modifiers() == Qt::NoModifier))
-                    if (machineWindowWrapper()->menuBar()->hasFocus())
-                        setFocus();
-                break;
-            }
-            default:
-                break;
-        }
-    }
-#endif
 
     return QAbstractScrollArea::eventFilter (pWatched, pEvent);
 }
+
+void UIMachineView::sltMachineStateChanged()
+{
+    /* Get machine state: */
+    KMachineState state = uisession()->machineState();
+    switch (state)
+    {
+        case KMachineState_Paused:
+        case KMachineState_TeleportingPausedVM:
+        {
+            if (mode() != VBoxDefs::TimerMode &&  m_pFrameBuffer &&
+                (state != KMachineState_TeleportingPausedVM || m_previousState != KMachineState_Teleporting))
+            {
+                /* Take a screen snapshot. Note that TakeScreenShot() always needs a 32bpp image: */
+                QImage shot = QImage(m_pFrameBuffer->width(), m_pFrameBuffer->height(), QImage::Format_RGB32);
+                CDisplay dsp = session().GetConsole().GetDisplay();
+                dsp.TakeScreenShot(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);
+                    /* Fully repaint to pick up m_pauseShot: */
+                    repaint();
+                }
+            }
+        }
+        case KMachineState_Stuck:
+        {
+            /* Reuse the focus event handler to uncapture everything: */
+            if (hasFocus())
+                focusEvent(false /* aHasFocus*/, false /* aReleaseHostKey */);
+            break;
+        }
+        case KMachineState_Running:
+        {
+            if (m_previousState == KMachineState_Paused || m_previousState == KMachineState_TeleportingPausedVM)
+            {
+                if (mode() != VBoxDefs::TimerMode && m_pFrameBuffer)
+                {
+                    /* Reset the pixmap to free memory: */
+                    m_pauseShot = QPixmap();
+                    /* Ask for full guest display update (it will also update
+                     * the viewport through IFramebuffer::NotifyUpdate): */
+                    CDisplay dsp = session().GetConsole().GetDisplay();
+                    dsp.InvalidateAndUpdate();
+                }
+            }
+            /* Reuse the focus event handler to capture input: */
+            if (hasFocus())
+                focusEvent(true /* aHasFocus */);
+            break;
+        }
+        default:
+            break;
+    }
+
+#ifdef Q_WS_MAC
+    /* Update Dock Overlay: */
+    updateDockOverlay();
+#endif /* Q_WS_MAC */
+
+    m_previousState = state;
+}
+
+void UIMachineView::sltMousePointerShapeChanged()
+{
+    if (uisession()->isMouseSupportsAbsolute())
+    {
+        /* Should we hide/show pointer? */
+        if (uisession()->isHidingHostPointer())
+            viewport()->setCursor(Qt::BlankCursor);
+        else
+            viewport()->setCursor(uisession()->cursor());
+    }
+}
+
+void UIMachineView::sltMouseCapabilityChanged()
+{
+    /* Correct the mouse capture state and reset the cursor to the default shape if necessary: */
+    if (uisession()->isMouseSupportsAbsolute())
+    {
+        CMouse mouse = session().GetConsole().GetMouse();
+        mouse.PutMouseEventAbsolute(-1, -1, 0, 0, 0);
+        captureMouse(false, false);
+    }
+    else
+        viewport()->unsetCursor();
+
+    /* Notify user about mouse integration state: */
+    vboxProblem().remindAboutMouseIntegration(uisession()->isMouseSupportsAbsolute());
+
+    /* Notify all listeners: */
+    emitMouseStateChanged();
+}
+
+#ifdef Q_WS_MAC
+void UIMachineView::sltChangeDockIconUpdate(const VBoxChangeDockIconUpdateEvent &event)
+{
+    setDockIconEnabled(event.mChanged);
+    updateDockOverlay();
+}
+
+# ifdef QT_MAC_USE_COCOA
+void UIMachineView::sltChangePresentationMode(const VBoxChangePresentationModeEvent &event)
+{
+    // TODO_NEW_CORE
+    // this is full screen related
+#if 0
+    if (mIsFullscreen)
+    {
+        /* First check if we are on the primary screen, only than the presentation mode have to be changed. */
+        QDesktopWidget* pDesktop = QApplication::desktop();
+        if (pDesktop->screenNumber(this) == pDesktop->primaryScreen())
+        {
+            QString testStr = vboxGlobal().virtualBox().GetExtraData(VBoxDefs::GUI_PresentationModeEnabled).toLower();
+            /* Default to false if it is an empty value */
+            if (testStr.isEmpty() || testStr == "false")
+                SetSystemUIMode(kUIModeAllHidden, 0);
+            else
+                SetSystemUIMode(kUIModeAllSuppressed, 0);
+        }
+    }
+    else
+        SetSystemUIMode(kUIModeNormal, 0);
+#endif
+}
+# endif /* QT_MAC_USE_COCOA */
+#endif
 
 void UIMachineView::focusEvent(bool fHasFocus, bool fReleaseHostKey /* = true */)
@@ -1599 +1367 @@
 
 bool UIMachineView::mouseEvent(int aType, const QPoint &aPos, const QPoint &aGlobalPos,
-                               Qt::MouseButtons aButtons, Qt::KeyboardModifiers aModifiers,
+                               Qt::MouseButtons aButtons, Qt::KeyboardModifiers /* aModifiers */,
                                int aWheelDelta, Qt::Orientation aWheelDir)
 {
-#if 0
-    LogRel3(("%s: type=%03d x=%03d y=%03d btns=%08X wdelta=%03d wdir=%s\n",
-             __PRETTY_FUNCTION__ , aType, aPos.x(), aPos.y(),
-               (aButtons & Qt::LeftButton ? 1 : 0)
-             | (aButtons & Qt::RightButton ? 2 : 0)
-             | (aButtons & Qt::MidButton ? 4 : 0)
-             | (aButtons & Qt::XButton1 ? 8 : 0)
-             | (aButtons & Qt::XButton2 ? 16 : 0),
-             aWheelDelta,
-               aWheelDir == Qt::Horizontal ? "Horizontal"
-             : aWheelDir == Qt::Vertical ? "Vertical" : "Unknown"));
-    Q_UNUSED (aModifiers);
-#else
-    Q_UNUSED (aModifiers);
-#endif
-
     int state = 0;
     if (aButtons & Qt::LeftButton)
@@ -1631 +1383 @@
 
 #ifdef Q_WS_MAC
-    /* Simulate the right click on
-     * Host+Left Mouse */
+    /* Simulate the right click on Host+Left Mouse: */
     if (m_bIsHostkeyPressed &&
         m_bIsHostkeyAlone &&
@@ -1655 +1406 @@
 #ifdef Q_WS_WIN32
         /* send pending WM_PAINT events */
-        ::UpdateWindow (viewport()->winId());
+        ::UpdateWindow(viewport()->winId());
 #endif
 
@@ -2519 +2270 @@
 }
 
-void UIMachineView::updateSliders()
-{
-    QSize p = viewport()->size();
-    QSize m = maximumViewportSize();
-
-    QSize v = QSize(m_pFrameBuffer->width(), m_pFrameBuffer->height());
-    /* no scroll bars needed */
-    if (m.expandedTo(v) == m)
-        p = m;
-
-    horizontalScrollBar()->setRange(0, v.width() - p.width());
-    verticalScrollBar()->setRange(0, v.height() - p.height());
-    horizontalScrollBar()->setPageStep(p.width());
-    verticalScrollBar()->setPageStep(p.height());
-}
-
 void UIMachineView::scrollBy(int dx, int dy)
 {
@@ -2577 +2312 @@
 #elif defined(Q_WS_X11)
         if (fCapture)
-                XGrabKey(QX11Info::display(), AnyKey, AnyModifier, window()->winId(), False, GrabModeAsync, GrabModeAsync);
+            XGrabKey(QX11Info::display(), AnyKey, AnyModifier, window()->winId(), False, GrabModeAsync, GrabModeAsync);
         else
-                XUngrabKey(QX11Info::display(), AnyKey, AnyModifier, window()->winId());
+            XUngrabKey(QX11Info::display(), AnyKey, AnyModifier, window()->winId());
 #elif defined(Q_WS_MAC)
     if (fCapture)
@@ -2636 +2371 @@
         /* Release mouse buttons: */
         CMouse mouse = session().GetConsole().GetMouse();
-        mouse.PutMouseEvent (0, 0, 0, 0 /* Horizontal wheel */, 0);
+        mouse.PutMouseEvent(0, 0, 0, 0 /* Horizontal wheel */, 0);
     }
 
@@ -2724 +2459 @@
             keyboard.PutScancodes(codes);
         }
-    }
-}
-
-void UIMachineView::updateMouseClipping()
-{
-    if (uisession()->isMouseCaptured())
-    {
-        viewport()->setCursor(QCursor(Qt::BlankCursor));
-#ifdef Q_WS_WIN32
-        QRect r = viewport()->rect();
-        r.moveTopLeft(viewport()->mapToGlobal(QPoint (0, 0)));
-        RECT rect = { r.left(), r.top(), r.right() + 1, r.bottom() + 1 };
-        ::ClipCursor(&rect);
-#endif
-    }
-    else
-    {
-#ifdef Q_WS_WIN32
-        ::ClipCursor(NULL);
-#endif
-        /* return the cursor to where it was when we captured it and show it */
-        QCursor::setPos(m_capturedMousePos);
-        viewport()->unsetCursor();
     }
 }

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.h

@@ -59 +59 @@
 #endif
                                  , UIVisualStateType visualStateType);
+    static void destroy(UIMachineView *pWhichView);
 
     /* Public getters: */
@@ -67 +68 @@
     virtual void setGuestAutoresizeEnabled(bool bEnabled) = 0;
     virtual void setMouseIntegrationEnabled(bool bEnabled);
-    //void setMachineViewFinalized(bool fTrue = true) { m_bIsMachineWindowResizeIgnored = !fTrue; }
 
     /* Public members: */
@@ -85 +85 @@
     void mouseStateChanged(int iState);
 
-    /* Utility signals: */
-    void resizeHintDone();
-
 protected:
 
@@ -99 +96 @@
     virtual ~UIMachineView();
 
-    /* Desktop geometry types: */
-    enum DesktopGeo { DesktopGeo_Invalid = 0, DesktopGeo_Fixed, DesktopGeo_Automatic, DesktopGeo_Any };
-
     /* Protected getters: */
     UISession* uisession() const;
     CSession& session();
-    UIMachineWindow* machineWindowWrapper() const { return m_pMachineWindow; }
-    VBoxDefs::RenderMode mode() const { return m_mode; }
     QSize sizeHint() const;
     int contentsX() const;
@@ -114 +106 @@
     int visibleWidth() const;
     int visibleHeight() const;
-    QRect desktopGeometry() const;
+    VBoxDefs::RenderMode mode() const { return m_mode; }
+    UIFrameBuffer* frameBuffer() const { return m_pFrameBuffer; }
+    UIMachineWindow* machineWindowWrapper() const { return m_pMachineWindow; }
+    bool isHostKeyPressed() const { return m_bIsHostkeyPressed; }
+    bool isMachineWindowResizeIgnored() const { return m_bIsMachineWindowResizeIgnored; }
+    bool isFrameBufferResizeIgnored() const { return m_bIsFrameBufferResizeIgnored; }
     const QPixmap& pauseShot() const { return m_pauseShot; }
-
-    /* Protected members: */
-    void calculateDesktopGeometry();
-    void setDesktopGeometry(DesktopGeo geometry, int iWidth, int iHeight);
-    void storeConsoleSize(int iWidth, int iHeight);
-    QRect availableGeometry();
-    virtual void maybeRestrictMinimumSize() = 0;
+    virtual QSize desktopGeometry() const = 0;
+
+    /* Protected setters: */
+    void setMachineWindowResizeIgnored(bool fIgnore = true) { m_bIsMachineWindowResizeIgnored = fIgnore; }
+    void setFrameBufferResizeIgnored(bool fIgnore = true) { m_bIsFrameBufferResizeIgnored = fIgnore; }
+
+    /* Protected helpers: */
+    void updateMouseClipping();
+    void updateSliders();
 
     /* Prepare routines: */
@@ -138 +137 @@
     virtual void cleanupFrameBuffer();
 
+    /* Cross-platforms event processors: */
+    bool event(QEvent *pEvent);
+    bool eventFilter(QObject *pWatched, QEvent *pEvent);
+
 protected slots:
 
     /* Console callback handlers: */
     virtual void sltMachineStateChanged();
-    virtual void sltAdditionsStateChanged();
     virtual void sltMousePointerShapeChanged();
     virtual void sltMouseCapabilityChanged();
 
-    /* Initiate resize request to guest: */
-    virtual void sltPerformGuestResize(const QSize &aSize = QSize()) = 0;
-
 private slots:
-
-    /* Watch dog for desktop resizes: */
-    void sltDesktopResized();
 
 #ifdef Q_WS_MAC
@@ -166 +162 @@
 
     /* Cross-platforms event processors: */
-    bool event(QEvent *pEvent);
-    bool eventFilter(QObject *pWatched, QEvent *pEvent);
     void focusEvent(bool aHasFocus, bool aReleaseHostKey = true);
     bool keyEvent(int aKey, uint8_t aScan, int aFlags, wchar_t *aUniKey = NULL);
@@ -199 +193 @@
     void fixModifierState(int *piCodes, uint *puCount);
     QPoint viewportToContents(const QPoint &vp) const;
-    void updateSliders();
     void scrollBy(int dx, int dy);
 #ifdef VBOX_WITH_VIDEOHWACCEL
@@ -211 +204 @@
     void releaseAllPressedKeys(bool aReleaseHostKey = true);
     void sendChangedKeyStates();
-    void updateMouseClipping();
 
     static void dimImage(QImage &img);
@@ -239 +231 @@
 #ifdef VBOX_WITH_VIDEOHWACCEL
     bool m_fAccelerate2DVideo;
-#endif
-#if 0 // TODO: Do we need this flag?
-    bool mDoResize : 1;
 #endif
 
@@ -263 +252 @@
     bool mDockIconEnabled;
 #endif
-    DesktopGeo m_desktopGeometryType;
-    QRect m_desktopGeometry;
-    QRect m_storedConsoleSize;
 
     /* Friend classes: */

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineWindow.cpp

@@ -91 +91 @@
     : m_pMachineLogic(pMachineLogic)
     , m_pMachineWindow(0)
+    , m_pMachineViewContainer(0)
+    , m_pTopSpacer(0)
+    , m_pBottomSpacer(0)
+    , m_pLeftSpacer(0)
+    , m_pRightSpacer(0)
     , m_pMachineView(0)
 {
@@ -490 +495 @@
 }
 
+void UIMachineWindow::prepareMachineViewContainer()
+{
+    /* Create view container.
+     * After it will be passed to parent widget of some mode,
+     * there will be no need to delete it, so no need to cleanup: */
+    m_pMachineViewContainer = new QGridLayout();
+    m_pMachineViewContainer->setMargin(0);
+    m_pMachineViewContainer->setSpacing(0);
+
+    /* Create and add shifting spacers.
+     * After they will be inserted into layout, it will get the parentness
+     * of those spacers, so there will be no need to cleanup them. */
+    m_pTopSpacer = new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding);
+    m_pBottomSpacer = new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding);
+    m_pLeftSpacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Fixed);
+    m_pRightSpacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Fixed);
+    m_pMachineViewContainer->addItem(m_pTopSpacer, 0, 1);
+    m_pMachineViewContainer->addItem(m_pBottomSpacer, 2, 1);
+    m_pMachineViewContainer->addItem(m_pLeftSpacer, 1, 0);
+    m_pMachineViewContainer->addItem(m_pRightSpacer, 1, 2);
+}
+
 void UIMachineWindow::updateAppearanceOf(int iElement)
 {

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineWindow.h

@@ -29 +29 @@
 /* Global forwards */
 class QWidget;
+class QGridLayout;
+class QSpacerItem;
 class QCloseEvent;
 
@@ -81 +83 @@
 #endif
     virtual void prepareMenuHelp();
+    virtual void prepareMachineViewContainer();
     //virtual void loadWindowSettings() {}
 
     /* Cleanup helpers: */
     //virtual void saveWindowSettings() {}
+    //virtual void cleanupMachineViewContainer() {}
+    //virtual void cleanupMenuHelp() {}
 #ifdef VBOX_WITH_DEBUGGER_GUI
     //virtual void prepareMenuDebug() {}
@@ -102 +107 @@
     UIMachineLogic *m_pMachineLogic;
     QWidget *m_pMachineWindow;
+
+    QGridLayout *m_pMachineViewContainer;
+    QSpacerItem *m_pTopSpacer;
+    QSpacerItem *m_pBottomSpacer;
+    QSpacerItem *m_pLeftSpacer;
+    QSpacerItem *m_pRightSpacer;
+
     UIMachineView *m_pMachineView;
     QString m_strWindowTitlePrefix;

trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineViewNormal.cpp

@@ -25 +25 @@
 #include <QApplication>
 #include <QDesktopWidget>
-#include <QMainWindow>
 #include <QMenuBar>
+#include <QTimer>
 
 /* Local includes */
@@ -34 +34 @@
 #include "UIMachineLogic.h"
 #include "UIMachineWindow.h"
+#include "UIFrameBuffer.h"
 #include "UIMachineViewNormal.h"
+#include "QIMainDialog.h"
 
 UIMachineViewNormal::UIMachineViewNormal(  UIMachineWindow *pMachineWindow
@@ -48 +50 @@
 #endif
                    )
+    , m_desktopGeometryType(DesktopGeo_Invalid)
+    , m_bIsGuestAutoresizeEnabled(pMachineWindow->machineLogic()->actionsPool()->action(UIActionIndex_Toggle_GuestAutoresize)->isChecked())
+    , m_fShouldWeDoResize(false)
 {
     /* Prepare frame buffer: */
@@ -80 +85 @@
 }
 
-void UIMachineViewNormal::sltPerformGuestResize(const QSize & /* toSize */)
-{
-#if 0 // TODO: fix that logic!
-    if (isGuestSupportsGraphics() && m_bIsGuestAutoresizeEnabled)
-    {
+void UIMachineViewNormal::sltAdditionsStateChanged()
+{
+    /* Check if we should restrict minimum size: */
+    maybeRestrictMinimumSize();
+}
+
+void UIMachineViewNormal::sltPerformGuestResize(const QSize &toSize)
+{
+    if (m_bIsGuestAutoresizeEnabled && uisession()->isGuestSupportsGraphics())
+    {
+        /* Taking Main Dialog: */
+        QIMainDialog *pMainDialog = machineWindowWrapper() && machineWindowWrapper()->machineWindow() ?
+                                    qobject_cast<QIMainDialog*>(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 the centralWidget() contains this view only
          * and gives it all available space. */
-        QSize sz(toSize.isValid() ? toSize : machineWindow()->centralWidget()->size());
+        QSize newSize(toSize.isValid() ? toSize : pMainDialog ? pMainDialog->centralWidget()->size() : QSize());
+        AssertMsg(newSize.isValid(), ("This size should be valid!\n"));
+
+        /* Subtracting frame in case we basing on machine view size: */
         if (!toSize.isValid())
-            sz -= QSize(frameWidth() * 2, frameWidth() * 2);
-        /* Do not send out useless hints. */
-        if ((sz.width() == mStoredConsoleSize.width()) && (sz.height() == mStoredConsoleSize.height()))
+            newSize -= QSize(frameWidth() * 2, frameWidth() * 2);
+
+        /* Do not send the same hints as we already have: */
+        if ((newSize.width() == m_storedConsoleSize.width()) && (newSize.height() == m_storedConsoleSize.height()))
             return;
+
         /* We only actually send the hint if
          * 1) the autoresize property is set to true and
@@ -102 +121 @@
          *    needed (e.g. the autoresize was just enabled and the console
          *    was resized while it was disabled). */
-        if (m_bIsGuestAutoresizeEnabled && (toSize.isValid() || mDoResize))
+        if (toSize.isValid() || m_fShouldWeDoResize)
         {
             /* Remember the new size. */
-            storeConsoleSize(sz.width(), sz.height());
-
-            mConsole.GetDisplay().SetVideoModeHint(sz.width(), sz.height(), 0, 0);
+            m_storedConsoleSize = newSize;
+
+            /* Send new size-hint to the guest: */
+            session().GetConsole().GetDisplay().SetVideoModeHint(newSize.width(), newSize.height(), 0, 0);
         }
-        /* We have resized now... */
-        mDoResize = false;
-    }
-#endif
-}
-
-void UIMachineViewNormal::sltAdditionsStateChanged()
-{
-    /* Base-class additions state-change-handler: */
-    UIMachineView::sltAdditionsStateChanged();
-
-    /* Enable/Disable guest auto-resizing depending on advanced graphics availablability: */
-    setGuestAutoresizeEnabled(m_bIsGuestAutoresizeEnabled && uisession()->isGuestSupportsGraphics());
+        /* We had requested resize now, rejecting accident requests: */
+        m_fShouldWeDoResize = false;
+    }
+}
+
+/* If the desktop geometry is set automatically, this will update it: */
+void UIMachineViewNormal::sltDesktopResized()
+{
+    calculateDesktopGeometry();
 }
 
 void UIMachineViewNormal::prepareFilters()
 {
-    /* Prepare base-class filters: */
+    /* Base class filters: */
     UIMachineView::prepareFilters();
 
-    /* Normal window filters: */
-    qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow())->menuBar()->installEventFilter(this);
+    /* Menu bar filters: */
+    qobject_cast<QIMainDialog*>(machineWindowWrapper()->machineWindow())->menuBar()->installEventFilter(this);
+}
+
+void UIMachineViewNormal::prepareConsoleConnections()
+{
+    /* Base class connections: */
+    UIMachineView::prepareConsoleConnections();
+
+    /* Guest additions state-change updater: */
+    connect(uisession(), SIGNAL(sigAdditionsStateChange()), this, SLOT(sltAdditionsStateChanged()));
+}
+
+void UIMachineViewNormal::loadMachineViewSettings()
+{
+    /* Base class settings: */
+    UIMachineView::loadMachineViewSettings();
+
+    /* Global settings: */
+    {
+        /* Remember the desktop geometry and register for geometry
+         * change events for telling the guest about video modes we like: */
+        QString desktopGeometry = vboxGlobal().settings().publicProperty("GUI/MaxGuestResolution");
+        if ((desktopGeometry == QString::null) || (desktopGeometry == "auto"))
+            setDesktopGeometry(DesktopGeo_Automatic, 0, 0);
+        else if (desktopGeometry == "any")
+            setDesktopGeometry(DesktopGeo_Any, 0, 0);
+        else
+        {
+            int width = desktopGeometry.section(',', 0, 0).toInt();
+            int height = desktopGeometry.section(',', 1, 1).toInt();
+            setDesktopGeometry(DesktopGeo_Fixed, width, height);
+        }
+        connect(QApplication::desktop(), SIGNAL(resized(int)), this, SLOT(sltDesktopResized()));
+    }
 }
 
@@ -141 +190 @@
         maybeRestrictMinimumSize();
 
-        if (uisession()->isGuestSupportsGraphics() && m_bIsGuestAutoresizeEnabled)
+        if (m_bIsGuestAutoresizeEnabled && uisession()->isGuestSupportsGraphics())
             sltPerformGuestResize();
     }
 }
 
-void UIMachineViewNormal::normalizeGeometry(bool bAdjustPosition /* = false */)
+QSize UIMachineViewNormal::desktopGeometry() const
+{
+    QSize geometry;
+    switch (m_desktopGeometryType)
+    {
+        case DesktopGeo_Fixed:
+        case DesktopGeo_Automatic:
+            geometry = QSize(qMax(m_desktopGeometry.width(), m_storedConsoleSize.width()),
+                             qMax(m_desktopGeometry.height(), m_storedConsoleSize.height()));
+            break;
+        case DesktopGeo_Any:
+            geometry = QSize(0, 0);
+            break;
+        default:
+            AssertMsgFailed(("Bad geometry type %d!\n", m_desktopGeometryType));
+    }
+    return geometry;
+}
+
+void UIMachineViewNormal::normalizeGeometry(bool bAdjustPosition)
 {
     QWidget *pTopLevelWidget = window();
@@ -182 +250 @@
             availableGeo = dwt->availableGeometry(pTopLevelWidget->pos());
 
-        frameGeo = VBoxGlobal::normalizeGeometry(frameGeo, availableGeo, mode() != VBoxDefs::SDLMode /* canResize */);
+        frameGeo = VBoxGlobal::normalizeGeometry(frameGeo, availableGeo, mode() != VBoxDefs::SDLMode /* can resize? */);
     }
 
@@ -192 +260 @@
     /* Finally, set the frame geometry */
     pTopLevelWidget->setGeometry(frameGeo.left() + dl, frameGeo.top() + dt, frameGeo.width() - dl - dr, frameGeo.height() - dt - db);
+}
+
+void UIMachineViewNormal::calculateDesktopGeometry()
+{
+    /* This method should not get called until we have initially set up the m_desktopGeometryType: */
+    Assert((m_desktopGeometryType != DesktopGeo_Invalid));
+    /* If we are not doing automatic geometry calculation then there is nothing to do: */
+    if (DesktopGeo_Automatic == m_desktopGeometryType)
+    {
+        /* Available geometry of the desktop.  If the desktop is a single
+         * screen, this will exclude space taken up by desktop taskbars
+         * and things, but this is unfortunately not true for the more
+         * complex case of a desktop spanning multiple screens: */
+        QRect desktop = availableGeometry();
+        /* The area taken up by the machine window on the desktop,
+         * including window frame, title and menu bar and whatnot: */
+        QRect frame = machineWindowWrapper()->machineWindow()->frameGeometry();
+        /* The area taken up by the machine view, so excluding all decorations: */
+        QRect window = geometry();
+        /* To work out how big we can make the console window while still
+         * fitting on the desktop, we calculate desktop - frame + window.
+         * This works because the difference between frame and window
+         * (or at least its width and height) is a constant. */
+        m_desktopGeometry = QSize(desktop.width() - frame.width() + window.width(),
+                                  desktop.height() - frame.height() + window.height());
+    }
+}
+
+QRect UIMachineViewNormal::availableGeometry()
+{
+    return machineWindowWrapper()->machineWindow()->isFullScreen() ?
+           QApplication::desktop()->screenGeometry(this) :
+           QApplication::desktop()->availableGeometry(this);
+}
+
+void UIMachineViewNormal::setDesktopGeometry(DesktopGeo geometry, int aWidth, int aHeight)
+{
+    switch (geometry)
+    {
+        case DesktopGeo_Fixed:
+            m_desktopGeometryType = DesktopGeo_Fixed;
+            if (aWidth != 0 && aHeight != 0)
+                m_desktopGeometry = QSize(aWidth, aHeight);
+            else
+                m_desktopGeometry = QSize(0, 0);
+            storeConsoleSize(0, 0);
+            break;
+        case DesktopGeo_Automatic:
+            m_desktopGeometryType = DesktopGeo_Automatic;
+            m_desktopGeometry = QSize(0, 0);
+            storeConsoleSize(0, 0);
+            break;
+        case DesktopGeo_Any:
+            m_desktopGeometryType = DesktopGeo_Any;
+            m_desktopGeometry = QSize(0, 0);
+            break;
+        default:
+            AssertMsgFailed(("Invalid desktop geometry type %d\n", geometry));
+            m_desktopGeometryType = DesktopGeo_Invalid;
+    }
+}
+
+void UIMachineViewNormal::storeConsoleSize(int iWidth, int iHeight)
+{
+    m_storedConsoleSize = QSize(iWidth, iHeight);
 }
 
@@ -209 +342 @@
 }
 
+bool UIMachineViewNormal::event(QEvent *pEvent)
+{
+    switch (pEvent->type())
+    {
+        case VBoxDefs::ResizeEventType:
+        {
+            /* Some situations require initial VGA Resize Request
+             * to be ignored at all, leaving previous framebuffer,
+             * machine view and machine window sizes preserved: */
+            if (uisession()->isGuestResizeIgnored())
+                return true;
+
+            bool oldIgnoreMainwndResize = isMachineWindowResizeIgnored();
+            setMachineWindowResizeIgnored(true);
+
+            UIResizeEvent *pResizeEvent = static_cast<UIResizeEvent*>(pEvent);
+
+            /* Store the new size to prevent unwanted resize hints being sent back. */
+            storeConsoleSize(pResizeEvent->width(), pResizeEvent->height());
+
+            /* Unfortunately restoreOverrideCursor() is broken in Qt 4.4.0 if WA_PaintOnScreen widgets are present.
+             * This is the case on linux with SDL. As workaround we save/restore the arrow cursor manually.
+             * See http://trolltech.com/developer/task-tracker/index_html?id=206165&method=entry for details.
+             * Moreover the current cursor, which could be set by the guest, should be restored after resize: */
+            QCursor cursor;
+            if (uisession()->isHidingHostPointer())
+                cursor = QCursor(Qt::BlankCursor);
+            else
+                cursor = viewport()->cursor();
+            frameBuffer()->resizeEvent(pResizeEvent);
+            viewport()->setCursor(cursor);
+
+#ifdef Q_WS_MAC
+            // TODO_NEW_CORE
+//            mDockIconPreview->setOriginalSize(pResizeEvent->width(), pResizeEvent->height());
+#endif /* Q_WS_MAC */
+
+            /* This event appears in case of guest video was changed for somehow even without video resolution change.
+             * In this last case the host VM window will not be resized according this event and the host mouse cursor
+             * which was unset to default here will not be hidden in capture state. So it is necessary to perform
+             * updateMouseClipping() for the guest resize event if the mouse cursor was captured: */
+            if (uisession()->isMouseCaptured())
+                updateMouseClipping();
+
+            /* Apply maximum size restriction: */
+            setMaximumSize(sizeHint());
+
+            /* May be we have to restrict minimum size? */
+            maybeRestrictMinimumSize();
+
+            /* Resize the guest canvas: */
+            if (!isFrameBufferResizeIgnored())
+                resize(pResizeEvent->width(), pResizeEvent->height());
+            updateSliders();
+
+            /* Let our toplevel widget calculate its sizeHint properly. */
+#ifdef Q_WS_X11
+            /* We use processEvents rather than sendPostedEvents & set the time out value to max cause on X11 otherwise
+             * the layout isn't calculated correctly. Dosn't find the bug in Qt, but this could be triggered through
+             * the async nature of the X11 window event system. */
+            QCoreApplication::processEvents(QEventLoop::AllEvents, INT_MAX);
+#else /* Q_WS_X11 */
+            QCoreApplication::sendPostedEvents(0, QEvent::LayoutRequest);
+#endif /* Q_WS_X11 */
+
+            if (!isFrameBufferResizeIgnored())
+                normalizeGeometry(true /* adjustPosition */);
+
+            /* Report to the VM thread that we finished resizing */
+            session().GetConsole().GetDisplay().ResizeCompleted(0);
+
+            setMachineWindowResizeIgnored(oldIgnoreMainwndResize);
+
+            /* Make sure that all posted signals are processed: */
+            qApp->processEvents();
+
+            /* Emit a signal about guest was resized: */
+            emit resizeHintDone();
+
+            /* 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();
+
+            /* Enable frame-buffer resize watching: */
+            if (isFrameBufferResizeIgnored())
+                setFrameBufferResizeIgnored(false);
+
+            return true;
+        }
+
+        case QEvent::KeyPress:
+        case QEvent::KeyRelease:
+        {
+            QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
+
+            if (isHostKeyPressed() && pEvent->type() == QEvent::KeyPress)
+            {
+                if (pKeyEvent->key() == Qt::Key_Home)
+                {
+                    /* In Qt4 it is not enough to just set the focus to menu-bar.
+                     * So to get the menu-bar we have to send Qt::Key_Alt press/release events directly: */
+                    QKeyEvent e1(QEvent::KeyPress, Qt::Key_Alt, Qt::NoModifier);
+                    QKeyEvent e2(QEvent::KeyRelease, Qt::Key_Alt, Qt::NoModifier);
+                    QMenuBar *pMenuBar = machineWindowWrapper() && machineWindowWrapper()->machineWindow() ?
+                                         qobject_cast<QIMainDialog*>(machineWindowWrapper()->machineWindow())->menuBar() : 0;
+                    QApplication::sendEvent(pMenuBar, &e1);
+                    QApplication::sendEvent(pMenuBar, &e2);
+                }
+                else
+                    pEvent->ignore();
+            }
+        }
+        default:
+            break;
+    }
+    return UIMachineView::event(pEvent);
+}
+
+bool UIMachineViewNormal::eventFilter(QObject *pWatched, QEvent *pEvent)
+{
+    /* Who are we watchin? */
+    QIMainDialog *pMainDialog = machineWindowWrapper() && machineWindowWrapper()->machineWindow() ?
+        qobject_cast<QIMainDialog*>(machineWindowWrapper()->machineWindow()) : 0;
+    QMenuBar *pMenuBar = pMainDialog ? qobject_cast<QIMainDialog*>(pMainDialog)->menuBar() : 0;
+
+    if (pWatched != 0 && pWatched == pMainDialog)
+    {
+        switch (pEvent->type())
+        {
+            case QEvent::Resize:
+            {
+                /* 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 (!isMachineWindowResizeIgnored() && 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
+#endif /* defined (Q_WS_WIN32) */
+            default:
+                break;
+        }
+    }
+    else if (pWatched != 0 && pWatched == pMenuBar)
+    {
+        /* Sometimes when we press ESC in the menu it brings the focus away (Qt bug?)
+         * causing no widget to have a focus, or holds the focus itself, instead of
+         * returning the focus to the console window. Here we fix this: */
+        switch (pEvent->type())
+        {
+            case QEvent::FocusOut:
+            {
+                if (qApp->focusWidget() == 0)
+                    setFocus();
+                break;
+            }
+            case QEvent::KeyPress:
+            {
+                QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
+                if (pKeyEvent->key() == Qt::Key_Escape && (pKeyEvent->modifiers() == Qt::NoModifier))
+                    if (pMenuBar->hasFocus())
+                        setFocus();
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return UIMachineView::eventFilter(pWatched, pEvent);
+}
+

trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineViewNormal.h

@@ -31 +31 @@
     Q_OBJECT;
 
+signals:
+
+    /* Utility signals: */
+    void resizeHintDone();
+
 protected:
+
+    /* Desktop geometry types: */
+    enum DesktopGeo { DesktopGeo_Invalid = 0, DesktopGeo_Fixed, DesktopGeo_Automatic, DesktopGeo_Any };
 
     /* Normal machine view constructor/destructor: */
@@ -48 +56 @@
 
     /* Slot to perform guest resize: */
-    void sltPerformGuestResize(const QSize &aSize = QSize());
+    void sltPerformGuestResize(const QSize &size = QSize());
+
+    /* Watch dog for desktop resizes: */
+    void sltDesktopResized();
 
 private:
 
-    /* Prepare routines: */
+    /* Prepare helpers: */
     void prepareFilters();
+    void prepareConsoleConnections();
+    void loadMachineViewSettings();
 
-    /* Private setters: */
+    /* Cleanup helpers: */
+    //void saveMachineViewSettings() {}
+    //void cleanupConsoleConnections() {}
+    //cleanupFilters() {}
+
+    /* Hidden setters: */
     void setGuestAutoresizeEnabled(bool bEnabled);
 
+    /* Hidden getters: */
+    QSize desktopGeometry() const;
+
     /* Private helpers: */
-    void normalizeGeometry(bool bAdjustPosition = false);
+    void normalizeGeometry(bool fAdjustPosition);
+    void calculateDesktopGeometry();
+    QRect availableGeometry();
+    void setDesktopGeometry(DesktopGeo geometry, int iWidth, int iHeight);
+    void storeConsoleSize(int iWidth, int iHeight);
     void maybeRestrictMinimumSize();
 
+    /* Event handlers: */
+    bool event(QEvent *pEvent);
+    bool eventFilter(QObject *pWatched, QEvent *pEvent);
+
     /* Private members: */
+    DesktopGeo m_desktopGeometryType;
+    QSize m_desktopGeometry;
+    QSize m_storedConsoleSize;
     bool m_bIsGuestAutoresizeEnabled : 1;
+    bool m_fShouldWeDoResize : 1;
 
     /* Friend classes: */

trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineWindowNormal.cpp

@@ -69 +69 @@
     retranslateUi();
 
+    /* Prepare normal machine view container: */
+    prepareMachineViewContainer();
+
     /* Prepare normal machine view: */
     prepareMachineView();
@@ -86 +89 @@
     /* Save normal window settings: */
     saveWindowSettings();
+
+    /* Cleanup normal machine view: */
+    cleanupMachineView();
 
     /* Cleanup status-bar: */
@@ -454 +460 @@
 #endif
 
+    /* Set central widget: */
+    setCentralWidget(new QWidget);
+
+    /* Set central widget layout: */
+    centralWidget()->setLayout(m_pMachineViewContainer);
+
     m_pMachineView = UIMachineView::create(  this
                                            , vboxGlobal().vmRenderMode()
@@ -461 +473 @@
                                            , machineLogic()->visualStateType());
 
-    setCentralWidget(m_pMachineView);
+    /* Add machine view into layout: */
+    m_pMachineViewContainer->addWidget(m_pMachineView, 1, 1);
 
     /* Setup machine view connections: */
@@ -568 +581 @@
 }
 
+void UIMachineWindowNormal::cleanupMachineView()
+{
+    /* Do not cleanup machine view if it is not present: */
+    if (!machineView())
+        return;
+
+    UIMachineView::destroy(m_pMachineView);
+    m_pMachineView = 0;
+}
+
 void UIMachineWindowNormal::cleanupStatusBar()
 {

trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineWindowNormal.h

@@ -92 +92 @@
     void prepareStatusBar();
     void prepareConnections();
+    void prepareMachineView();
     void loadWindowSettings();
-    void prepareMachineView();
 
     /* Cleanup helpers: */
-    //void cleanupMachineView() {}
     void saveWindowSettings();
+    void cleanupMachineView();
     //void cleanupConnections() {}
     void cleanupStatusBar();