Changeset 26889 in vbox for trunk/src/VBox/Frontends

Timestamp:

Feb 28, 2010 2:57:36 PM (15 years ago)

Author:

vboxsync

Message:

FE/Qt4: new core: initial fs support

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• Makefile.kmk (modified) (3 diffs)
• src/globals/VBoxGlobal.cpp (modified) (2 diffs)
• src/runtime/UIMachineLogic.cpp (modified) (2 diffs)
• src/runtime/UIMachineView.cpp (modified) (7 diffs)
• src/runtime/UIMachineView.h (modified) (5 diffs)
• src/runtime/UIMachineWindow.cpp (modified) (3 diffs)
• src/runtime/fullscreen (added)
• src/runtime/fullscreen/UIMachineLogicFullscreen.cpp (copied) (copied from trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineLogicNormal.cpp ) (12 diffs)
• src/runtime/fullscreen/UIMachineLogicFullscreen.h (copied) (copied from trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineLogicNormal.h ) (6 diffs)
• src/runtime/fullscreen/UIMachineViewFullscreen.cpp (copied) (copied from trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineViewNormal.cpp ) (10 diffs)
• src/runtime/fullscreen/UIMachineViewFullscreen.h (copied) (copied from trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineViewNormal.h ) (6 diffs)
• src/runtime/fullscreen/UIMachineWindowFullscreen.cpp (copied) (copied from trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineWindowNormal.cpp ) (14 diffs)
• src/runtime/fullscreen/UIMachineWindowFullscreen.h (copied) (copied from trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineWindowNormal.h ) (7 diffs)
• src/runtime/normal/UIMachineViewNormal.cpp (modified) (4 diffs)
• src/runtime/normal/UIMachineViewNormal.h (modified) (3 diffs)

trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk

@@ -225 +225 @@
 VBOX_GUI_INC_DIRS += \
     ./src/runtime \
-        ./src/runtime/normal
+        ./src/runtime/normal \
+        ./src/runtime/fullscreen
 endif
 
@@ -372 +373 @@
         src/runtime/normal/UIMachineLogicNormal.h \
         src/runtime/normal/UIMachineWindowNormal.h \
-        src/runtime/normal/UIMachineViewNormal.h
+        src/runtime/normal/UIMachineViewNormal.h \
+        src/runtime/fullscreen/UIMachineLogicFullscreen.h \
+        src/runtime/fullscreen/UIMachineWindowFullscreen.h \
+        src/runtime/fullscreen/UIMachineViewFullscreen.h
 endif
 
@@ -501 +505 @@
         src/runtime/normal/UIMachineLogicNormal.cpp \
         src/runtime/normal/UIMachineWindowNormal.cpp \
-        src/runtime/normal/UIMachineViewNormal.cpp
+        src/runtime/normal/UIMachineViewNormal.cpp \
+        src/runtime/fullscreen/UIMachineLogicFullscreen.cpp \
+        src/runtime/fullscreen/UIMachineWindowFullscreen.cpp \
+        src/runtime/fullscreen/UIMachineViewFullscreen.cpp
 endif
 

trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxGlobal.cpp

@@ -395 +395 @@
         else if (mGlobal.isVMConsoleProcess())
         {
+#ifndef VBOX_WITH_NEW_RUNTIME_CORE
+            /* TODO_NEW_CORE */
             /* Check for the currently running machine */
             CMachine machine = mGlobal.consoleWnd().session().GetMachine();
@@ -409 +411 @@
                 }
             }
+#endif /* VBOX_WITH_NEW_RUNTIME_CORE */
         }
 #endif /* Q_WS_MAC */

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

@@ -45 +45 @@
 #include "UIMachineLogic.h"
 #include "UIMachineLogicNormal.h"
-//#include "UIMachineLogicFullscreen.h"
+#include "UIMachineLogicFullscreen.h"
 //#include "UIMachineLogicSeamless.h"
 #include "UIMachineWindow.h"
@@ -352 +352 @@
             break;
         case UIVisualStateType_Fullscreen:
-            // logic = new UIMachineLogicFullscreen(pParent, pSession, pActionsPool);
-            logic = new UIMachineLogicNormal(pParent, pSession, pActionsPool);
+            logic = new UIMachineLogicFullscreen(pParent, pSession, pActionsPool);
             break;
         case UIVisualStateType_Seamless:

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

@@ -43 +43 @@
 #include "UIMachineView.h"
 #include "UIMachineViewNormal.h"
+#include "UIMachineViewFullscreen.h"
 
 #ifdef Q_WS_PM
@@ -127 +128 @@
             break;
         case UIVisualStateType_Fullscreen:
-            view = new UIMachineViewNormal(  pMachineWindow
-                                           , renderMode
+            view = new UIMachineViewFullscreen(  pMachineWindow
+                                               , renderMode
 #ifdef VBOX_WITH_VIDEOHWACCEL
-                                           , bAccelerate2DVideo
-#endif
-                                          );
+                                               , bAccelerate2DVideo
+#endif
+                                              );
             break;
         case UIVisualStateType_Seamless:
@@ -184 +185 @@
 }
 
+#include <QMainWindow>
 UIMachineView::UIMachineView(  UIMachineWindow *pMachineWindow
                              , VBoxDefs::RenderMode renderMode
@@ -190 +192 @@
 #endif
                             )
+// TODO_NEW_CORE: really think of if this is right
+//    : QAbstractScrollArea(((QMainWindow*)pMachineWindow->machineWindow())->centralWidget())
     : QAbstractScrollArea(pMachineWindow->machineWindow())
+    , m_desktopGeometryType(DesktopGeo_Invalid)
     , m_pMachineWindow(pMachineWindow)
     , m_mode(renderMode)
@@ -417 +422 @@
 {
     /* Prepare view frame: */
-    //setFrameStyle(QFrame::NoFrame);
+    setFrameStyle(QFrame::NoFrame);
 
     /* Pressed keys: */
@@ -514 +519 @@
         initMappedX11Keyboard(QX11Info::display(), vboxGlobal().settings().publicProperty("GUI/RemapScancodes"));
 #endif
+
+        /* 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);
+        }
     }
 
@@ -532 +551 @@
 #endif
 }
+
+QSize UIMachineView::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 UIMachineView::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 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 = QSize(desktop.width() - frame.width() + window.width(),
+                                  desktop.height() - frame.height() + window.height());
+    }
+}
+
+void UIMachineView::storeConsoleSize(int iWidth, int iHeight)
+{
+    m_storedConsoleSize = QSize(iWidth, iHeight);
+}
+
 
 void UIMachineView::cleanupCommon()

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

@@ -51 +51 @@
 
 public:
+
+    /* Desktop geometry types: */
+    enum DesktopGeo { DesktopGeo_Invalid = 0, DesktopGeo_Fixed, DesktopGeo_Automatic, DesktopGeo_Any };
 
     /* Factory function to create required view sub-child: */
@@ -113 +116 @@
     bool isFrameBufferResizeIgnored() const { return m_bIsFrameBufferResizeIgnored; }
     const QPixmap& pauseShot() const { return m_pauseShot; }
-    virtual QSize desktopGeometry() const = 0;
+    void calculateDesktopGeometry();
+    virtual QSize desktopGeometry() const;
+    void setDesktopGeometry(DesktopGeo geometry, int iWidth, int iHeight);
+    void storeConsoleSize(int iWidth, int iHeight);
 
     /* Protected setters: */
@@ -158 +164 @@
 # endif
 #endif
+protected:
+
+    DesktopGeo m_desktopGeometryType;
+    QSize m_desktopGeometry;
+    QSize m_storedConsoleSize;
 
 private:
@@ -205 +216 @@
     void sendChangedKeyStates();
 
+    virtual QRect availableGeometry() = 0;
+
     static void dimImage(QImage &img);
 
@@ -254 +267 @@
 
     /* Friend classes: */
+    friend class UIMachineWindowFullscreen;
     friend class UIFrameBuffer;
     friend class UIFrameBufferQImage;

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

@@ -38 +38 @@
 #include "UIMachineView.h"
 #include "UIMachineWindowNormal.h"
-//#include "UIMachineWindowFullscreen.h"
+#include "UIMachineWindowFullscreen.h"
 //#include "UIMachineWindowSeamless.h"
 
@@ -50 +50 @@
             break;
         case UIVisualStateType_Fullscreen:
-            // window = new UIMachineWindowFullscreen(pMachineLogic);
-            window = new UIMachineWindowNormal(pMachineLogic);
+            window = new UIMachineWindowFullscreen(pMachineLogic);
             break;
         case UIVisualStateType_Seamless:
@@ -508 +507 @@
     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);

trunk/src/VBox/Frontends/VirtualBox/src/runtime/fullscreen/UIMachineLogicFullscreen.cpp

@@ -3 +3 @@
  *
  * VBox frontends: Qt GUI ("VirtualBox"):
- * UIMachineLogicNormal class implementation
+ * UIMachineLogicFullscreen class implementation
  */
 
@@ -24 +24 @@
 /* Global includes */
 #include <QMenu>
-#include <QTimer>
+#include <QDesktopWidget>
 
 /* Local includes */
@@ -35 +35 @@
 #include "UISession.h"
 #include "UIActionsPool.h"
-#include "UIMachineLogicNormal.h"
+#include "UIMachineLogicFullscreen.h"
 #include "UIMachineWindow.h"
 #include "UIMachineView.h"
@@ -41 +41 @@
 #include "VBoxUtils.h"
 
-UIMachineLogicNormal::UIMachineLogicNormal(QObject *pParent, UISession *pSession, UIActionsPool *pActionsPool)
-    : UIMachineLogic(pParent, pSession, pActionsPool, UIVisualStateType_Normal)
+UIMachineLogicFullscreen::UIMachineLogicFullscreen(QObject *pParent, UISession *pSession, UIActionsPool *pActionsPool)
+    : UIMachineLogic(pParent, pSession, pActionsPool, UIVisualStateType_Fullscreen)
 {
     /* Prepare console connections: */
@@ -56 +56 @@
     prepareRequiredFeatures();
 
-    /* Prepare normal machine window: */
+    /* Prepare machine window: */
     prepareMachineWindow();
 
@@ -65 +65 @@
 }
 
-UIMachineLogicNormal::~UIMachineLogicNormal()
-{
-    /* Cleanup normal machine window: */
+UIMachineLogicFullscreen::~UIMachineLogicFullscreen()
+{
+    /* Cleanup machine window: */
     cleanupMachineWindow();
 }
 
-void UIMachineLogicNormal::sltPrepareNetworkAdaptersMenu()
+void UIMachineLogicFullscreen::sltPrepareNetworkAdaptersMenu()
 {
     QMenu *menu = qobject_cast<QMenu*>(sender());
@@ -79 +79 @@
 }
 
-void UIMachineLogicNormal::sltPrepareSharedFoldersMenu()
+void UIMachineLogicFullscreen::sltPrepareSharedFoldersMenu()
 {
     QMenu *menu = qobject_cast<QMenu*>(sender());
@@ -87 +87 @@
 }
 
-void UIMachineLogicNormal::sltPrepareMouseIntegrationMenu()
+void UIMachineLogicFullscreen::sltPrepareMouseIntegrationMenu()
 {
     QMenu *menu = qobject_cast<QMenu*>(sender());
@@ -95 +95 @@
 }
 
-void UIMachineLogicNormal::prepareActionConnections()
+void UIMachineLogicFullscreen::prepareActionConnections()
 {
     /* Base class connections: */
@@ -109 +109 @@
 }
 
-void UIMachineLogicNormal::prepareMachineWindow()
+void UIMachineLogicFullscreen::prepareRequiredFeatures()
+{
+    // TODO_NEW_CORE
+//    if (session().GetConsole().isAutoresizeGuestActive())
+    {
+//        QRect screen = QApplication::desktop()->screenGeometry(this);
+//        ULONG64 availBits = session().GetMachine().GetVRAMSize() /* vram */
+//                          * _1M /* mb to bytes */
+//                          * 8; /* to bits */
+//        ULONG guestBpp = mConsole->console().GetDisplay().GetBitsPerPixel();
+//        ULONG64 usedBits = (screen.width() /* display width */
+//                         * screen.height() /* display height */
+//                         * guestBpp
+//                         + _1M * 8) /* current cache per screen - may be changed in future */
+//                         * session().GetMachine().GetMonitorCount() /**< @todo fix assumption that all screens have same resolution */
+//                         + 4096 * 8; /* adapter info */
+//        if (availBits < usedBits)
+//        {
+//            int result = vboxProblem().cannotEnterFullscreenMode(
+//                   screen.width(), screen.height(), guestBpp,
+//                   (((usedBits + 7) / 8 + _1M - 1) / _1M) * _1M);
+//            if (result == QIMessageBox::Cancel)
+//                sltClose();
+//        }
+    }
+}
+
+void UIMachineLogicFullscreen::prepareMachineWindow()
 {
     /* Do not prepare window if its ready: */
@@ -213 +240 @@
 }
 
-void UIMachineLogicNormal::cleanupMachineWindow()
+void UIMachineLogicFullscreen::cleanupMachineWindow()
 {
     /* Do not cleanup machine window if it is not present: */
@@ -219 +246 @@
         return;
 
-    /* Cleanup normal machine window: */
+    /* Cleanup machine window: */
     UIMachineWindow::destroy(machineWindowWrapper());
     setMachineWindowWrapper(0);

trunk/src/VBox/Frontends/VirtualBox/src/runtime/fullscreen/UIMachineLogicFullscreen.h

@@ -2 +2 @@
  *
  * VBox frontends: Qt GUI ("VirtualBox"):
- * UIMachineLogicNormal class declaration
+ * UIMachineLogicFullscreen class declaration
  */
 
@@ -21 +21 @@
  */
 
-#ifndef __UIMachineLogicNormal_h__
-#define __UIMachineLogicNormal_h__
+#ifndef __UIMachineLogicFullscreen_h__
+#define __UIMachineLogicFullscreen_h__
 
 /* Local includes */
@@ -30 +30 @@
 class UIActionsPool;
 
-class UIMachineLogicNormal : public UIMachineLogic
+class UIMachineLogicFullscreen : public UIMachineLogic
 {
     Q_OBJECT;
@@ -36 +36 @@
 protected:
 
-    /* Normal machine logic constructor/destructor: */
-    UIMachineLogicNormal(QObject *pParent,
-                         UISession *pSession,
-                         UIActionsPool *pActionsPool);
-    virtual ~UIMachineLogicNormal();
+    /* Fullscreen machine logic constructor/destructor: */
+    UIMachineLogicFullscreen(QObject *pParent,
+                             UISession *pSession,
+                             UIActionsPool *pActionsPool);
+    virtual ~UIMachineLogicFullscreen();
 
 private slots:
@@ -54 +54 @@
     void prepareActionConnections();
     void prepareMachineWindow();
+    void prepareRequiredFeatures();
 
     /* Cleanup helpers: */
@@ -63 +64 @@
 };
 
-#endif // __UIMachineLogicNormal_h__
+#endif // __UIMachineLogicFullscreen_h__
 

trunk/src/VBox/Frontends/VirtualBox/src/runtime/fullscreen/UIMachineViewFullscreen.cpp

@@ -3 +3 @@
  *
  * VBox frontends: Qt GUI ("VirtualBox"):
- * UIMachineViewNormal class implementation
+ * UIMachineViewFullscreen class implementation
  */
 
@@ -25 +25 @@
 #include <QApplication>
 #include <QDesktopWidget>
-#include <QMainWindow>
 #include <QMenuBar>
+#include <QTimer>
 
 /* Local includes */
@@ -34 +34 @@
 #include "UIMachineLogic.h"
 #include "UIMachineWindow.h"
-#include "UIMachineViewNormal.h"
-
-UIMachineViewNormal::UIMachineViewNormal(  UIMachineWindow *pMachineWindow
+#include "UIFrameBuffer.h"
+#include "UIMachineViewFullscreen.h"
+#include "QIMainDialog.h"
+
+UIMachineViewFullscreen::UIMachineViewFullscreen(  UIMachineWindow *pMachineWindow
                                          , VBoxDefs::RenderMode renderMode
 #ifdef VBOX_WITH_VIDEOHWACCEL
@@ -48 +50 @@
 #endif
                    )
+    , m_bIsGuestAutoresizeEnabled(pMachineWindow->machineLogic()->actionsPool()->action(UIActionIndex_Toggle_GuestAutoresize)->isChecked())
+    , m_fShouldWeDoResize(false)
 {
     /* Prepare frame buffer: */
@@ -71 +75 @@
 }
 
-UIMachineViewNormal::~UIMachineViewNormal()
+UIMachineViewFullscreen::~UIMachineViewFullscreen()
 {
     /* Cleanup common things: */
@@ -80 +84 @@
 }
 
-void UIMachineViewNormal::sltPerformGuestResize(const QSize & /* toSize */)
-{
-#if 0 // TODO: fix that logic!
-    if (isGuestSupportsGraphics() && m_bIsGuestAutoresizeEnabled)
-    {
+void UIMachineViewFullscreen::sltAdditionsStateChanged()
+{
+    /* Check if we should restrict minimum size: */
+    maybeRestrictMinimumSize();
+}
+
+void UIMachineViewFullscreen::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 +120 @@
          *    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());
-}
-
-void UIMachineViewNormal::prepareFilters()
-{
-    /* Prepare base-class filters: */
+        /* We had requested resize now, rejecting accident requests: */
+        m_fShouldWeDoResize = false;
+    }
+}
+
+/* If the desktop geometry is set automatically, this will update it: */
+void UIMachineViewFullscreen::sltDesktopResized()
+{
+    calculateDesktopGeometry();
+}
+
+void UIMachineViewFullscreen::prepareCommon()
+{
+    UIMachineView::prepareCommon();
+
+    /* Maximum size of the screen */
+    setMaximumSize(availableGeometry().size());
+    /* Minimum size is ignored too */
+    setMinimumSize(0, 0);
+    /* No scrollbars */
+    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+}
+
+void UIMachineViewFullscreen::prepareFilters()
+{
+    /* Base-class filters: */
     UIMachineView::prepareFilters();
 
     /* Normal window filters: */
-    qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow())->menuBar()->installEventFilter(this);
-}
-
-void UIMachineViewNormal::setGuestAutoresizeEnabled(bool fEnabled)
+    qobject_cast<QIMainDialog*>(machineWindowWrapper()->machineWindow())->menuBar()->installEventFilter(this);
+}
+
+void UIMachineViewFullscreen::prepareConsoleConnections()
+{
+    /* Base class connections: */
+    UIMachineView::prepareConsoleConnections();
+
+    /* Guest additions state-change updater: */
+    connect(uisession(), SIGNAL(sigAdditionsStateChange()), this, SLOT(sltAdditionsStateChanged()));
+}
+
+void UIMachineViewFullscreen::loadMachineViewSettings()
+{
+    /* Base class settings: */
+    UIMachineView::loadMachineViewSettings();
+
+    /* Global settings: */
+    {
+        connect(QApplication::desktop(), SIGNAL(resized(int)), this, SLOT(sltDesktopResized()));
+    }
+}
+
+void UIMachineViewFullscreen::setGuestAutoresizeEnabled(bool fEnabled)
 {
     if (m_bIsGuestAutoresizeEnabled != fEnabled)
@@ -146 +194 @@
 }
 
-void UIMachineViewNormal::normalizeGeometry(bool bAdjustPosition /* = false */)
+void UIMachineViewFullscreen::normalizeGeometry(bool bAdjustPosition /* = false */)
 {
     QWidget *pTopLevelWidget = window();
@@ -194 +242 @@
 }
 
-void UIMachineViewNormal::maybeRestrictMinimumSize()
+QRect UIMachineViewFullscreen::availableGeometry()
+{
+    return QApplication::desktop()->screenGeometry(this);
+}
+
+void UIMachineViewFullscreen::maybeRestrictMinimumSize()
 {
     /* Sets the minimum size restriction depending on the auto-resize feature state and the current rendering mode.
@@ -209 +262 @@
 }
 
+bool UIMachineViewFullscreen::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);
+
+            /* Update geometry after entering fullscreen */
+            updateGeometry();
+
+            /* 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();
+
+            // TODO_NEW_CORE: try to understand this, cause this is bullshit in fullscreen
+            /* 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 UIMachineViewFullscreen::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/fullscreen/UIMachineViewFullscreen.h

@@ -2 +2 @@
  *
  * VBox frontends: Qt GUI ("VirtualBox"):
- * UIMachineViewNormal class declaration
+ * UIMachineViewFullscreen class declaration
  */
 
@@ -21 +21 @@
  */
 
-#ifndef ___UIMachineViewNormal_h___
-#define ___UIMachineViewNormal_h___
+#ifndef ___UIMachineViewFullscreen_h___
+#define ___UIMachineViewFullscreen_h___
 
 /* Local includes */
 #include "UIMachineView.h"
 
-class UIMachineViewNormal : public UIMachineView
+class UIMachineViewFullscreen : public UIMachineView
 {
     Q_OBJECT;
+
+signals:
+
+    /* Utility signals: */
+    void resizeHintDone();
 
 protected:
 
     /* Normal machine view constructor/destructor: */
-    UIMachineViewNormal(  UIMachineWindow *pMachineWindow
+    UIMachineViewFullscreen(  UIMachineWindow *pMachineWindow
                         , VBoxDefs::RenderMode renderMode
 #ifdef VBOX_WITH_VIDEOHWACCEL
@@ -40 +45 @@
 #endif
     );
-    virtual ~UIMachineViewNormal();
+    virtual ~UIMachineViewFullscreen();
 
 private slots:
@@ -50 +55 @@
     void sltPerformGuestResize(const QSize &aSize = QSize());
 
+    /* Watch dog for desktop resizes: */
+    void sltDesktopResized();
+
 private:
 
     /* Prepare routines: */
+    void prepareCommon();
     void prepareFilters();
+    void prepareConsoleConnections();
+    void loadMachineViewSettings();
 
     /* Private setters: */
@@ -60 +71 @@
     /* Private helpers: */
     void normalizeGeometry(bool bAdjustPosition = false);
+    QRect availableGeometry();
     void maybeRestrictMinimumSize();
+
+    bool event(QEvent *pEvent);
+    bool eventFilter(QObject *pWatched, QEvent *pEvent);
 
     /* Private members: */
     bool m_bIsGuestAutoresizeEnabled : 1;
+    bool m_fShouldWeDoResize : 1;
 
     /* Friend classes: */
@@ -69 +85 @@
 };
 
-#endif // !___UIMachineViewNormal_h___
+#endif // !___UIMachineViewFullscreen_h___
 

trunk/src/VBox/Frontends/VirtualBox/src/runtime/fullscreen/UIMachineWindowFullscreen.cpp

@@ -3 +3 @@
  *
  * VBox frontends: Qt GUI ("VirtualBox"):
- * UIMachineWindowNormal class implementation
+ * UIMachineWindowFullscreen class implementation
  */
 
@@ -33 +33 @@
 #include "UISession.h"
 #include "UIActionsPool.h"
-#include "UIIndicatorsPool.h"
 #include "UIMachineLogic.h"
 #include "UIMachineView.h"
-#include "UIMachineWindowNormal.h"
-
-#include "QIStatusBar.h"
-#include "QIStateIndicator.h"
-#include "QIHotKeyEdit.h"
-
-UIMachineWindowNormal::UIMachineWindowNormal(UIMachineLogic *pMachineLogic)
+#include "UIMachineWindowFullscreen.h"
+
+#ifdef Q_WS_MAC
+# ifdef QT_MAC_USE_COCOA
+#  include <Carbon/Carbon.h>
+# endif /* QT_MAC_USE_COCOA */
+#endif /* Q_WS_MAC */
+
+UIMachineWindowFullscreen::UIMachineWindowFullscreen(UIMachineLogic *pMachineLogic)
     : QIWithRetranslateUI<QIMainDialog>(0)
     , UIMachineWindow(pMachineLogic)
-    , m_pIndicatorsPool(new UIIndicatorsPool(pMachineLogic->uisession()->session(), this))
-    , m_pIdleTimer(0)
 {
     /* "This" is machine window: */
@@ -60 +59 @@
     prepareMenu();
 
-    /* Prepare status bar: */
-    prepareStatusBar();
-
     /* Prepare connections: */
     prepareConnections();
@@ -69 +65 @@
     retranslateUi();
 
+    /* Prepare machine view container: */
+    prepareMachineViewContainer();
+
     /* Prepare normal machine view: */
     prepareMachineView();
@@ -79 +78 @@
 
     /* Show window: */
-    show();
-}
-
-UIMachineWindowNormal::~UIMachineWindowNormal()
+//    show();
+}
+
+UIMachineWindowFullscreen::~UIMachineWindowFullscreen()
 {
     /* Save normal window settings: */
     saveWindowSettings();
 
-    /* Cleanup status-bar: */
-    cleanupStatusBar();
-}
-
-void UIMachineWindowNormal::sltMachineStateChanged()
+    /* Cleanup normal machine view: */
+    cleanupMachineView();
+}
+
+void UIMachineWindowFullscreen::sltMachineStateChanged()
 {
     UIMachineWindow::sltMachineStateChanged();
 }
 
-void UIMachineWindowNormal::sltMediumChange(const CMediumAttachment &attachment)
+void UIMachineWindowFullscreen::sltMediumChange(const CMediumAttachment &attachment)
 {
     KDeviceType type = attachment.GetType();
@@ -107 +106 @@
 }
 
-void UIMachineWindowNormal::sltUSBControllerChange()
+void UIMachineWindowFullscreen::sltUSBControllerChange()
 {
     updateAppearanceOf(UIVisualElement_USBStuff);
 }
 
-void UIMachineWindowNormal::sltUSBDeviceStateChange()
+void UIMachineWindowFullscreen::sltUSBDeviceStateChange()
 {
     updateAppearanceOf(UIVisualElement_USBStuff);
 }
 
-void UIMachineWindowNormal::sltNetworkAdapterChange()
+void UIMachineWindowFullscreen::sltNetworkAdapterChange()
 {
     updateAppearanceOf(UIVisualElement_NetworkStuff);
 }
 
-void UIMachineWindowNormal::sltSharedFolderChange()
+void UIMachineWindowFullscreen::sltSharedFolderChange()
 {
     updateAppearanceOf(UIVisualElement_SharedFolderStuff);
 }
 
-void UIMachineWindowNormal::sltTryClose()
+void UIMachineWindowFullscreen::sltTryClose()
 {
     UIMachineWindow::sltTryClose();
 }
 
-void UIMachineWindowNormal::sltUpdateIndicators()
-{
-    CConsole console = session().GetConsole();
-    QIStateIndicator *pStateIndicator = 0;
-
-    pStateIndicator = indicatorsPool()->indicator(UIIndicatorIndex_HardDisks);
-    if (pStateIndicator->state() != KDeviceActivity_Null)
-    {
-        int state = console.GetDeviceActivity(KDeviceType_HardDisk);
-        if (pStateIndicator->state() != state)
-            pStateIndicator->setState(state);
-    }
-    pStateIndicator = indicatorsPool()->indicator(UIIndicatorIndex_OpticalDisks);
-    if (pStateIndicator->state() != KDeviceActivity_Null)
-    {
-        int state = console.GetDeviceActivity(KDeviceType_DVD);
-        if (pStateIndicator->state() != state)
-            pStateIndicator->setState(state);
-    }
-    pStateIndicator = indicatorsPool()->indicator(UIIndicatorIndex_USBDevices);
-    if (pStateIndicator->state() != KDeviceActivity_Null)
-    {
-        int state = console.GetDeviceActivity(KDeviceType_USB);
-        if (pStateIndicator->state() != state)
-            pStateIndicator->setState(state);
-    }
-    pStateIndicator = indicatorsPool()->indicator(UIIndicatorIndex_NetworkAdapters);
-    if (pStateIndicator->state() != KDeviceActivity_Null)
-    {
-        int state = console.GetDeviceActivity(KDeviceType_Network);
-        if (pStateIndicator->state() != state)
-            pStateIndicator->setState(state);
-    }
-    pStateIndicator = indicatorsPool()->indicator(UIIndicatorIndex_SharedFolders);
-    if (pStateIndicator->state() != KDeviceActivity_Null)
-    {
-        int state = console.GetDeviceActivity(KDeviceType_SharedFolder);
-        if (pStateIndicator->state() != state)
-            pStateIndicator->setState(state);
-    }
-}
-
-void UIMachineWindowNormal::sltShowIndicatorsContextMenu(QIStateIndicator *pIndicator, QContextMenuEvent *pEvent)
-{
-    if (pIndicator == indicatorsPool()->indicator(UIIndicatorIndex_OpticalDisks))
-    {
-        if (machineLogic()->actionsPool()->action(UIActionIndex_Menu_OpticalDevices)->isEnabled())
-            machineLogic()->actionsPool()->action(UIActionIndex_Menu_OpticalDevices)->menu()->exec(pEvent->globalPos());
-    }
-    else if (pIndicator == indicatorsPool()->indicator(UIIndicatorIndex_USBDevices))
-    {
-        if (machineLogic()->actionsPool()->action(UIActionIndex_Menu_USBDevices)->isEnabled())
-            machineLogic()->actionsPool()->action(UIActionIndex_Menu_USBDevices)->menu()->exec(pEvent->globalPos());
-    }
-    else if (pIndicator == indicatorsPool()->indicator(UIIndicatorIndex_NetworkAdapters))
-    {
-        if (machineLogic()->actionsPool()->action(UIActionIndex_Menu_NetworkAdapters)->isEnabled())
-            machineLogic()->actionsPool()->action(UIActionIndex_Menu_NetworkAdapters)->menu()->exec(pEvent->globalPos());
-    }
-    else if (pIndicator == indicatorsPool()->indicator(UIIndicatorIndex_SharedFolders))
-    {
-        if (machineLogic()->actionsPool()->action(UIActionIndex_Menu_SharedFolders)->isEnabled())
-            machineLogic()->actionsPool()->action(UIActionIndex_Menu_SharedFolders)->menu()->exec(pEvent->globalPos());
-    }
-    else if (pIndicator == indicatorsPool()->indicator(UIIndicatorIndex_Mouse))
-    {
-        if (machineLogic()->actionsPool()->action(UIActionIndex_Menu_MouseIntegration)->isEnabled())
-            machineLogic()->actionsPool()->action(UIActionIndex_Menu_MouseIntegration)->menu()->exec(pEvent->globalPos());
-    }
-}
-
-void UIMachineWindowNormal::sltProcessGlobalSettingChange(const char * /* aPublicName */, const char * /* aName */)
-{
-    m_pNameHostkey->setText(QIHotKeyEdit::keyName(vboxGlobal().settings().hostKey()));
-}
-
-void UIMachineWindowNormal::retranslateUi()
+void UIMachineWindowFullscreen::sltProcessGlobalSettingChange(const char * /* aPublicName */, const char * /* aName */)
+{
+}
+
+void UIMachineWindowFullscreen::retranslateUi()
 {
     /* Translate parent class: */
@@ -219 +146 @@
 //    m_pDockEnablePreviewMonitor->setText(tr("Show Monitor Preview"));
 #endif /* Q_WS_MAC */
-
-    m_pNameHostkey->setToolTip(
-        tr("Shows the currently assigned Host key.<br>"
-           "This key, when pressed alone, toggles the keyboard and mouse "
-           "capture state. It can also be used in combination with other keys "
-           "to quickly perform actions from the main menu."));
-    m_pNameHostkey->setText(QIHotKeyEdit::keyName(vboxGlobal().settings().hostKey()));
-}
-
-void UIMachineWindowNormal::updateAppearanceOf(int iElement)
+}
+
+void UIMachineWindowFullscreen::updateAppearanceOf(int iElement)
 {
     /* Update parent-class window: */
     UIMachineWindow::updateAppearanceOf(iElement);
-
-    /* Update that machine window: */
-    if (iElement & UIVisualElement_HDStuff)
-        indicatorsPool()->indicator(UIIndicatorIndex_HardDisks)->updateAppearance();
-    if (iElement & UIVisualElement_CDStuff)
-        indicatorsPool()->indicator(UIIndicatorIndex_OpticalDisks)->updateAppearance();
-    if (iElement & UIVisualElement_USBStuff &&
-        !indicatorsPool()->indicator(UIIndicatorIndex_USBDevices)->isHidden())
-        indicatorsPool()->indicator(UIIndicatorIndex_USBDevices)->updateAppearance();
-    if (iElement & UIVisualElement_NetworkStuff)
-        indicatorsPool()->indicator(UIIndicatorIndex_NetworkAdapters)->updateAppearance();
-    if (iElement & UIVisualElement_SharedFolderStuff)
-        indicatorsPool()->indicator(UIIndicatorIndex_SharedFolders)->updateAppearance();
-    if (iElement & UIVisualElement_VirtualizationStuff)
-        indicatorsPool()->indicator(UIIndicatorIndex_Virtualization)->updateAppearance();
-}
-
-bool UIMachineWindowNormal::event(QEvent *pEvent)
-{
+}
+
+bool UIMachineWindowFullscreen::event(QEvent *pEvent)
+{
+    return QIWithRetranslateUI<QIMainDialog>::event(pEvent);
     switch (pEvent->type())
     {
@@ -285 +191 @@
 
 #ifdef Q_WS_X11
-bool UIMachineWindowNormal::x11Event(XEvent *pEvent)
+bool UIMachineWindowFullscreen::x11Event(XEvent *pEvent)
 {
     /* Qt bug: when the console view grabs the keyboard, FocusIn, FocusOut,
@@ -306 +212 @@
 #endif
 
-void UIMachineWindowNormal::closeEvent(QCloseEvent *pEvent)
+void UIMachineWindowFullscreen::closeEvent(QCloseEvent *pEvent)
 {
     return UIMachineWindow::closeEvent(pEvent);
 }
 
-void UIMachineWindowNormal::prepareConsoleConnections()
+void UIMachineWindowFullscreen::prepareConsoleConnections()
 {
     /* Base-class connections: */
@@ -337 +243 @@
 }
 
-void UIMachineWindowNormal::prepareMenu()
+void UIMachineWindowFullscreen::prepareMenu()
 {
     /* Machine submenu: */
@@ -364 +270 @@
 }
 
-void UIMachineWindowNormal::prepareStatusBar()
-{
-    /* Common setup: */
-    setStatusBar(new QIStatusBar(this));
-    QWidget *pIndicatorBox = new QWidget;
-    QHBoxLayout *pIndicatorBoxHLayout = new QHBoxLayout(pIndicatorBox);
-    VBoxGlobal::setLayoutMargin(pIndicatorBoxHLayout, 0);
-    pIndicatorBoxHLayout->setSpacing(5);
-
-    /* Hard Disks: */
-    pIndicatorBoxHLayout->addWidget(indicatorsPool()->indicator(UIIndicatorIndex_HardDisks));
-
-    /* Optical Disks: */
-    QIStateIndicator *pLedOpticalDisks = indicatorsPool()->indicator(UIIndicatorIndex_OpticalDisks);
-    pIndicatorBoxHLayout->addWidget(pLedOpticalDisks);
-    connect(pLedOpticalDisks, SIGNAL(contextMenuRequested(QIStateIndicator*, QContextMenuEvent*)),
-            this, SLOT(sltShowIndicatorsContextMenu(QIStateIndicator*, QContextMenuEvent*)));
-
-    /* USB Devices: */
-    QIStateIndicator *pLedUSBDevices = indicatorsPool()->indicator(UIIndicatorIndex_USBDevices);
-    pIndicatorBoxHLayout->addWidget(pLedUSBDevices);
-    connect(pLedUSBDevices, SIGNAL(contextMenuRequested(QIStateIndicator*, QContextMenuEvent*)),
-            this, SLOT(sltShowIndicatorsContextMenu(QIStateIndicator*, QContextMenuEvent*)));
-
-    /* Network Adapters: */
-    QIStateIndicator *pLedNetworkAdapters = indicatorsPool()->indicator(UIIndicatorIndex_NetworkAdapters);
-    pIndicatorBoxHLayout->addWidget(pLedNetworkAdapters);
-    connect(pLedNetworkAdapters, SIGNAL(contextMenuRequested(QIStateIndicator*, QContextMenuEvent*)),
-            this, SLOT(sltShowIndicatorsContextMenu(QIStateIndicator*, QContextMenuEvent*)));
-
-    /* Shared Folders: */
-    QIStateIndicator *pLedSharedFolders = indicatorsPool()->indicator(UIIndicatorIndex_SharedFolders);
-    pIndicatorBoxHLayout->addWidget(pLedSharedFolders);
-    connect(pLedSharedFolders, SIGNAL(contextMenuRequested(QIStateIndicator*, QContextMenuEvent*)),
-            this, SLOT(sltShowIndicatorsContextMenu(QIStateIndicator*, QContextMenuEvent*)));
-
-    /* Virtualization: */
-    pIndicatorBoxHLayout->addWidget(indicatorsPool()->indicator(UIIndicatorIndex_Virtualization));
-
-    /* Separator: */
-    QFrame *pSeparator = new QFrame;
-    pSeparator->setFrameStyle(QFrame::VLine | QFrame::Sunken);
-    pIndicatorBoxHLayout->addWidget(pSeparator);
-
-    /* Mouse: */
-    QIStateIndicator *pLedMouse = indicatorsPool()->indicator(UIIndicatorIndex_Mouse);
-    pIndicatorBoxHLayout->addWidget(pLedMouse);
-    connect(pLedMouse, SIGNAL(contextMenuRequested(QIStateIndicator*, QContextMenuEvent*)),
-            this, SLOT(sltShowIndicatorsContextMenu(QIStateIndicator*, QContextMenuEvent*)));
-
-    /* Host Key: */
-    m_pCntHostkey = new QWidget;
-    QHBoxLayout *pHostkeyLedContainerLayout = new QHBoxLayout(m_pCntHostkey);
-    VBoxGlobal::setLayoutMargin(pHostkeyLedContainerLayout, 0);
-    pHostkeyLedContainerLayout->setSpacing(3);
-    pIndicatorBoxHLayout->addWidget(m_pCntHostkey);
-    pHostkeyLedContainerLayout->addWidget(indicatorsPool()->indicator(UIIndicatorIndex_Hostkey));
-    m_pNameHostkey = new QLabel(QIHotKeyEdit::keyName(vboxGlobal().settings().hostKey()));
-    pHostkeyLedContainerLayout->addWidget(m_pNameHostkey);
-
-    /* Add to statusbar: */
-    statusBar()->addPermanentWidget(pIndicatorBox, 0);
-
-    /* Create & start timer to update LEDs: */
-    m_pIdleTimer = new QTimer(this);
-    connect(m_pIdleTimer, SIGNAL(timeout()), this, SLOT(sltUpdateIndicators()));
-    m_pIdleTimer->start(50);
-
-#ifdef Q_WS_MAC
-    /* For the status bar on Cocoa: */
-    setUnifiedTitleAndToolBarOnMac(true);
-#endif
-}
-
-void UIMachineWindowNormal::prepareConnections()
+void UIMachineWindowFullscreen::prepareConnections()
 {
     /* Setup global settings change updater: */
@@ -445 +277 @@
 }
 
-void UIMachineWindowNormal::prepareMachineView()
+void UIMachineWindowFullscreen::prepareMachineView()
 {
     CMachine machine = session().GetMachine();
@@ -453 +285 @@
     bool bAccelerate2DVideo = machine.GetAccelerate2DVideoEnabled() && VBoxGlobal::isAcceleration2DVideoAvailable();
 #endif
+
+    /* Set central widget: */
+    setCentralWidget(new QWidget(this));
+
+    /* Set central widget layout: */
+    centralWidget()->setLayout(m_pMachineViewContainer);
 
     m_pMachineView = UIMachineView::create(  this
@@ -461 +299 @@
                                            , machineLogic()->visualStateType());
 
-    setCentralWidget(m_pMachineView);
-
-    /* Setup machine view connections: */
-    if (machineView())
-    {
-        /* Keyboard state-change updater: */
-        connect(machineView(), SIGNAL(keyboardStateChanged(int)), indicatorsPool()->indicator(UIIndicatorIndex_Hostkey), SLOT(setState(int)));
-
-        /* Mouse state-change updater: */
-        connect(machineView(), SIGNAL(mouseStateChanged(int)), indicatorsPool()->indicator(UIIndicatorIndex_Mouse), SLOT(setState(int)));
-
-        /* Early initialize required connections: */
-        indicatorsPool()->indicator(UIIndicatorIndex_Hostkey)->setState(machineView()->keyboardState());
-        indicatorsPool()->indicator(UIIndicatorIndex_Mouse)->setState(machineView()->mouseState());
-    }
-}
-
-void UIMachineWindowNormal::loadWindowSettings()
+    /* Add machine view into layout: */
+    m_pMachineViewContainer->addWidget(m_pMachineView, 1, 1, Qt::AlignVCenter | Qt::AlignHCenter);
+}
+
+void UIMachineWindowFullscreen::loadWindowSettings()
 {
     /* Load normal window settings: */
     CMachine machine = session().GetMachine();
 
-    /* Load extra-data settings: */
-    {
-        QString strPositionSettings = machine.GetExtraData(VBoxDefs::GUI_LastWindowPosition);
-
-        bool ok = false, max = false;
-        int x = 0, y = 0, w = 0, h = 0;
-        x = strPositionSettings.section(',', 0, 0).toInt(&ok);
-        if (ok)
-            y = strPositionSettings.section(',', 1, 1).toInt(&ok);
-        if (ok)
-            w = strPositionSettings.section(',', 2, 2).toInt(&ok);
-        if (ok)
-            h = strPositionSettings.section(',', 3, 3).toInt(&ok);
-        if (ok)
-            max = strPositionSettings.section(',', 4, 4) == VBoxDefs::GUI_LastWindowPosition_Max;
-
-        QRect ar = ok ? QApplication::desktop()->availableGeometry(QPoint(x, y)) :
-                        QApplication::desktop()->availableGeometry(machineWindow());
-
-        if (ok /* if previous parameters were read correctly */)
+    /* Toggle console to manual resize mode. */
+    m_pMachineView->setMachineWindowResizeIgnored(true);
+    m_pMachineView->setFrameBufferResizeIgnored(true);
+
+    /* The background has to go black */
+    QPalette palette(centralWidget()->palette());
+    palette.setColor(centralWidget()->backgroundRole(), Qt::black);
+    centralWidget()->setPalette (palette);
+    centralWidget()->setAutoFillBackground (true);
+    setAutoFillBackground (true);
+
+    /* We have to show the window early, or the position will be wrong on the
+       Mac */
+    show();
+
+#ifdef Q_WS_MAC
+# ifndef QT_MAC_USE_COCOA
+    /* setWindowState removes the window group connection somehow. So save it
+     * temporary. */
+    WindowGroupRef g = GetWindowGroup(::darwinToNativeWindow(this));
+# endif  /* !QT_MAC_USE_COCOA */
+    /* Here we are going really fullscreen */
+    setWindowState(windowState() ^ Qt::WindowFullScreen);
+    setPresentationModeEnabled(true);
+
+# ifndef QT_MAC_USE_COCOA
+    /* Reassign the correct window group. */
+    SetWindowGroup(::darwinToNativeWindow (this), g);
+# endif /* !QT_MAC_USE_COCOA */
+#else /* Q_WS_MAC */
+    setWindowState(windowState() ^ Qt::WindowFullScreen);
+#endif/* !Q_WS_MAC */
+
+    QRect r = geometry();
+    /* Load global settings: */
+    {
+//        VBoxGlobalSettings settings = vboxGlobal().settings();
+//        menuBar()->setHidden(settings.isFeatureActive("noMenuBar"));
+    }
+}
+
+void UIMachineWindowFullscreen::saveWindowSettings()
+{
+    CMachine machine = session().GetMachine();
+
+    /* Save extra-data settings: */
+    {
+    }
+
+    setPresentationModeEnabled(false);
+}
+
+void UIMachineWindowFullscreen::cleanupMachineView()
+{
+    /* Do not cleanup machine view if it is not present: */
+    if (!machineView())
+        return;
+
+    UIMachineView::destroy(m_pMachineView);
+    m_pMachineView = 0;
+}
+
+#ifdef Q_WS_MAC
+# ifdef QT_MAC_USE_COCOA
+void UIMachineWindowFullscreen::setPresentationModeEnabled(bool fEnabled)
+{
+    if (fEnabled)
+    {
+        /* 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())
         {
-            m_normalGeometry = QRect(x, y, w, h);
-            setGeometry(m_normalGeometry);
-
-            /* Normalize view to the optimal size */
-            if (machineView())
-                machineView()->normalizeGeometry(true /* adjust position? */);
-
-            /* Maximize if needed: */
-            if (max)
-                setWindowState(windowState() | Qt::WindowMaximized);
+            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
-        {
-            /* Normalize to the optimal size */
-            if (machineView())
-                machineView()->normalizeGeometry(true /* adjust position? */);
-
-            /* Move newly created window to the screen center: */
-            m_normalGeometry = geometry();
-            m_normalGeometry.moveCenter(ar.center());
-            setGeometry(m_normalGeometry);
-        }
-    }
-
-    /* Load availability settings: */
-    {
-        /* USB Stuff: */
-        CUSBController usbController = machine.GetUSBController();
-        if (usbController.isNull())
-        {
-            /* Hide USB Menu: */
-            indicatorsPool()->indicator(UIIndicatorIndex_USBDevices)->setHidden(true);
-        }
-        else
-        {
-            /* Toggle USB LED: */
-            indicatorsPool()->indicator(UIIndicatorIndex_USBDevices)->setState(
-                usbController.GetEnabled() ? KDeviceActivity_Idle : KDeviceActivity_Null);
-        }
-    }
-
-    /* Load global settings: */
-    {
-        VBoxGlobalSettings settings = vboxGlobal().settings();
-        menuBar()->setHidden(settings.isFeatureActive("noMenuBar"));
-        statusBar()->setHidden(settings.isFeatureActive("noStatusBar"));
-    }
-}
-
-void UIMachineWindowNormal::saveWindowSettings()
-{
-    CMachine machine = session().GetMachine();
-
-    /* Save extra-data settings: */
-    {
-        QString strWindowPosition = QString("%1,%2,%3,%4")
-                                    .arg(m_normalGeometry.x()).arg(m_normalGeometry.y())
-                                    .arg(m_normalGeometry.width()).arg(m_normalGeometry.height());
-        if (isMaximized())
-            strWindowPosition += QString(",%1").arg(VBoxDefs::GUI_LastWindowPosition_Max);
-        machine.SetExtraData(VBoxDefs::GUI_LastWindowPosition, strWindowPosition);
-    }
-}
-
-void UIMachineWindowNormal::cleanupStatusBar()
-{
-    /* Stop LED-update timer: */
-    m_pIdleTimer->stop();
-    m_pIdleTimer->disconnect(SIGNAL(timeout()), this, SLOT(sltUpdateIndicators()));
-}
-
+    }
+    else
+        SetSystemUIMode(kUIModeNormal, 0);
+}
+# endif /* QT_MAC_USE_COCOA */
+#endif /* Q_WS_MAC */

trunk/src/VBox/Frontends/VirtualBox/src/runtime/fullscreen/UIMachineWindowFullscreen.h

@@ -2 +2 @@
  *
  * VBox frontends: Qt GUI ("VirtualBox"):
- * UIMachineWindowNormal class declaration
+ * UIMachineWindowFullscreen class declaration
  */
 
@@ -21 +21 @@
  */
 
-#ifndef __UIMachineWindowNormal_h__
-#define __UIMachineWindowNormal_h__
+#ifndef __UIMachineWindowFullscreen_h__
+#define __UIMachineWindowFullscreen_h__
 
 /* Global includes */
@@ -38 +38 @@
 /* Local forwards */
 class CMediumAttachment;
-class UIIndicatorsPool;
-class QIStateIndicator;
 
-class UIMachineWindowNormal : public QIWithRetranslateUI<QIMainDialog>, public UIMachineWindow
+class UIMachineWindowFullscreen : public QIWithRetranslateUI<QIMainDialog>, public UIMachineWindow
 {
     Q_OBJECT;
@@ -48 +46 @@
 
     /* Normal machine window constructor/destructor: */
-    UIMachineWindowNormal(UIMachineLogic *pMachineLogic);
-    virtual ~UIMachineWindowNormal();
+    UIMachineWindowFullscreen(UIMachineLogic *pMachineLogic);
+    virtual ~UIMachineWindowFullscreen();
 
 private slots:
@@ -62 +60 @@
 
     /* LED connections: */
-    void sltUpdateIndicators();
-    void sltShowIndicatorsContextMenu(QIStateIndicator *pIndicator, QContextMenuEvent *pEvent);
     void sltProcessGlobalSettingChange(const char *aPublicName, const char *aName);
 
@@ -84 +80 @@
     void closeEvent(QCloseEvent *pEvent);
 
-    /* Private getters: */
-    UIIndicatorsPool* indicatorsPool() { return m_pIndicatorsPool; }
-
     /* Prepare helpers: */
     void prepareConsoleConnections();
     void prepareMenu();
-    void prepareStatusBar();
     void prepareConnections();
+    void prepareMachineView();
     void loadWindowSettings();
-    void prepareMachineView();
 
     /* Cleanup helpers: */
-    //void cleanupMachineView() {}
     void saveWindowSettings();
+    void cleanupMachineView();
     //void cleanupConnections() {}
-    void cleanupStatusBar();
     //void cleanupMenu() {}
     //void cleanupConsoleConnections() {}
 
-    /* Indicators pool: */
-    UIIndicatorsPool *m_pIndicatorsPool;
-    /* Other QWidgets: */
-    QWidget *m_pCntHostkey;
-    QLabel *m_pNameHostkey;
-    /* Other QObjects: */
-    QTimer *m_pIdleTimer;
+#ifdef Q_WS_MAC
+# ifdef QT_MAC_USE_COCOA
+    void setPresentationModeEnabled(bool fEnabled);
+# endif /* QT_MAC_USE_COCOA */
+#endif /* Q_WS_MAC */
+
     /* Other members: */
     QRect m_normalGeometry;
@@ -117 +107 @@
 };
 
-#endif // __UIMachineWindowNormal_h__
+#endif // __UIMachineWindowFullscreen_h__
 

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

@@ -50 +50 @@
 #endif
                    )
-    , m_desktopGeometryType(DesktopGeo_Invalid)
     , m_bIsGuestAutoresizeEnabled(pMachineWindow->machineLogic()->actionsPool()->action(UIActionIndex_Toggle_GuestAutoresize)->isChecked())
     , m_fShouldWeDoResize(false)
@@ -165 +164 @@
     /* 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()));
     }
@@ -193 +179 @@
             sltPerformGuestResize();
     }
-}
-
-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;
 }
 
@@ -262 +229 @@
 }
 
-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);
+    return QApplication::desktop()->availableGeometry(this);
 }
 

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

@@ -38 +38 @@
 protected:
 
-    /* Desktop geometry types: */
-    enum DesktopGeo { DesktopGeo_Invalid = 0, DesktopGeo_Fixed, DesktopGeo_Automatic, DesktopGeo_Any };
-
     /* Normal machine view constructor/destructor: */
     UIMachineViewNormal(  UIMachineWindow *pMachineWindow
@@ -76 +73 @@
     void setGuestAutoresizeEnabled(bool bEnabled);
 
-    /* Hidden getters: */
-    QSize desktopGeometry() const;
-
     /* Private helpers: */
     void normalizeGeometry(bool fAdjustPosition);
-    void calculateDesktopGeometry();
     QRect availableGeometry();
-    void setDesktopGeometry(DesktopGeo geometry, int iWidth, int iHeight);
-    void storeConsoleSize(int iWidth, int iHeight);
     void maybeRestrictMinimumSize();
 
@@ -92 +83 @@
 
     /* Private members: */
-    DesktopGeo m_desktopGeometryType;
-    QSize m_desktopGeometry;
-    QSize m_storedConsoleSize;
     bool m_bIsGuestAutoresizeEnabled : 1;
     bool m_fShouldWeDoResize : 1;