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

Timestamp:

Mar 4, 2010 7:45:10 PM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

58372

Message:

FE/Qt4: New running VM core: fullscreen mode rework: seamless functionality partially merged into fullscreen, some code cleaning.

Location:

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

Files:

• UIMachineViewFullscreen.cpp (modified) (11 diffs)
• UIMachineViewFullscreen.h (modified) (3 diffs)
• UIMachineWindowFullscreen.cpp (modified) (7 diffs)
• UIMachineWindowFullscreen.h (modified) (5 diffs)

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

@@ -25 +25 @@
 #include <QApplication>
 #include <QDesktopWidget>
+#include <QTimer>
+#ifdef Q_WS_MAC
 #include <QMenuBar>
-#include <QTimer>
+#endif
+#ifdef Q_WS_X11
+#include <limits.h>
+#endif
 
 /* Local includes */
-#include "VBoxGlobal.h"
 #include "UISession.h"
 #include "UIActionsPool.h"
@@ -50 +54 @@
 #endif
                     , uMonitor)
-, m_bIsGuestAutoresizeEnabled(pMachineWindow->machineLogic()->actionsPool()->action(UIActionIndex_Toggle_GuestAutoresize)->isChecked())
+    , m_fIsInitialResizeEventProcessed(false)
+    , m_bIsGuestAutoresizeEnabled(pMachineWindow->machineLogic()->actionsPool()->action(UIActionIndex_Toggle_GuestAutoresize)->isChecked())
     , m_fShouldWeDoResize(false)
 {
@@ -82 +87 @@
     /* Cleanup frame buffer: */
     cleanupFrameBuffer();
-}
-
-void UIMachineViewFullscreen::sltAdditionsStateChanged()
-{
-    /* Check if we should restrict minimum size: */
-    maybeRestrictMinimumSize();
 }
 
@@ -105 +104 @@
         AssertMsg(newSize.isValid(), ("This size should be valid!\n"));
 
-        /* Subtracting frame in case we basing on machine view size: */
-        if (!toSize.isValid())
-            newSize -= QSize(frameWidth() * 2, frameWidth() * 2);
-
         /* Do not send the same hints as we already have: */
         if ((newSize.width() == storedConsoleSize().width()) && (newSize.height() == storedConsoleSize().height()))
             return;
 
-        /* We only actually send the hint if
-         * 1) the autoresize property is set to true and
-         * 2) either an explicit new size was given (e.g. if the request
-         *    was triggered directly by a console resize event) or if no
-         *    explicit size was specified but a resize is flagged as being
-         *    needed (e.g. the autoresize was just enabled and the console
-         *    was resized while it was disabled). */
+        /* We only actually send the hint if either an explicit new size was given
+         * (e.g. if the request was triggered directly by a console resize event) or
+         * if no explicit size was specified but a resize is flagged as being needed
+         * (e.g. the autoresize was just enabled and the console was resized while it was disabled). */
         if (toSize.isValid() || m_fShouldWeDoResize)
         {
-            /* Remember the new size. */
+            /* Remember the new size: */
             storeConsoleSize(newSize.width(), newSize.height());
 
@@ -128 +120 @@
             session().GetConsole().GetDisplay().SetVideoModeHint(newSize.width(), newSize.height(), 0, screenId());
         }
-        /* We had requested resize now, rejecting accident requests: */
+
+        /* We had requested resize now, rejecting other accident requests: */
         m_fShouldWeDoResize = false;
     }
 }
 
-/* If the desktop geometry is set automatically, this will update it: */
+void UIMachineViewFullscreen::sltAdditionsStateChanged()
+{
+    /* Check if we should restrict minimum size: */
+    maybeRestrictMinimumSize();
+}
+
 void UIMachineViewFullscreen::sltDesktopResized()
 {
+    /* If the desktop geometry is set automatically, this will update it: */
     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<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)
-    {
-        m_bIsGuestAutoresizeEnabled = fEnabled;
-
-        maybeRestrictMinimumSize();
-
-        sltPerformGuestResize();
-    }
-}
-
-void UIMachineViewFullscreen::normalizeGeometry(bool bAdjustPosition /* = false */)
-{
-    QWidget *pTopLevelWidget = window();
-
-    /* Make no normalizeGeometry in case we are in manual resize mode or main window is maximized: */
-    if (pTopLevelWidget->isMaximized())
-        return;
-
-    /* Calculate client window offsets: */
-    QRect frameGeo = pTopLevelWidget->frameGeometry();
-    QRect geo = pTopLevelWidget->geometry();
-    int dl = geo.left() - frameGeo.left();
-    int dt = geo.top() - frameGeo.top();
-    int dr = frameGeo.right() - geo.right();
-    int db = frameGeo.bottom() - geo.bottom();
-
-    /* Get the best size w/o scroll bars: */
-    QSize s = pTopLevelWidget->sizeHint();
-
-    /* Resize the frame to fit the contents: */
-    s -= pTopLevelWidget->size();
-    frameGeo.setRight(frameGeo.right() + s.width());
-    frameGeo.setBottom(frameGeo.bottom() + s.height());
-
-    if (bAdjustPosition)
-    {
-        QRegion availableGeo;
-        QDesktopWidget *dwt = QApplication::desktop();
-        if (dwt->isVirtualDesktop())
-            /* Compose complex available region */
-            for (int i = 0; i < dwt->numScreens(); ++ i)
-                availableGeo += dwt->availableGeometry(i);
-        else
-            /* Get just a simple available rectangle */
-            availableGeo = dwt->availableGeometry(pTopLevelWidget->pos());
-
-        frameGeo = VBoxGlobal::normalizeGeometry(frameGeo, availableGeo, mode() != VBoxDefs::SDLMode /* canResize */);
-    }
-
-#if 0
-    /* Center the frame on the desktop: */
-    frameGeo.moveCenter(availableGeo.center());
-#endif
-
-    /* Finally, set the frame geometry */
-    pTopLevelWidget->setGeometry(frameGeo.left() + dl, frameGeo.top() + dt, frameGeo.width() - dl - dr, frameGeo.height() - dt - db);
-}
-
-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.
-     * Currently, the restriction is set only in SDL mode and only when the auto-resize feature is inactive.
-     * We need to do that because we cannot correctly draw in a scrolled window in SDL mode.
-     * In all other modes, or when auto-resize is in force, this function does nothing. */
-    if (mode() == VBoxDefs::SDLMode)
-    {
-        if (!uisession()->isGuestSupportsGraphics() || !m_bIsGuestAutoresizeEnabled)
-            setMinimumSize(sizeHint());
-        else
-            setMinimumSize(0, 0);
-    }
-}
-
 bool UIMachineViewFullscreen::event(QEvent *pEvent)
 {
@@ -267 +144 @@
         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: */
+            /* Some situations require framebuffer resize events to be ignored,
+             * leaving machine window & machine view & framebuffer sizes preserved: */
             if (uisession()->isGuestResizeIgnored())
                 return true;
 
+            /* We are starting to perform machine view resize: */
             bool oldIgnoreMainwndResize = isMachineWindowResizeIgnored();
             setMachineWindowResizeIgnored(true);
 
+            /* Get guest resize-event: */
             UIResizeEvent *pResizeEvent = static_cast<UIResizeEvent*>(pEvent);
 
-            /* Store the new size to prevent unwanted resize hints being sent back. */
+            /* Perform framebuffer resize: */
+            frameBuffer()->resizeEvent(pResizeEvent);
+
+            /* Reapply maximum size restriction for machine view: */
+            setMaximumSize(sizeHint());
+
+            /* Store the new size to prevent unwanted resize hints being sent back: */
             storeConsoleSize(pResizeEvent->width(), pResizeEvent->height());
 
-            /* 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();
+            /* Perform machine view resize: */
+            resize(pResizeEvent->width(), pResizeEvent->height());
 
             /* Let our toplevel widget calculate its sizeHint properly. */
@@ -326 +178 @@
 #endif /* Q_WS_X11 */
 
-            if (!isFrameBufferResizeIgnored())
-                normalizeGeometry(true /* adjustPosition */);
+#ifdef Q_WS_MAC
+            // TODO_NEW_CORE
+//            mDockIconPreview->setOriginalSize(pResizeEvent->width(), pResizeEvent->height());
+#endif /* Q_WS_MAC */
+
+            /* 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: */
+            if (uisession()->isValidPointerShapePresent())
+                viewport()->setCursor(uisession()->cursor());
+            else if (uisession()->isHidingHostPointer())
+                viewport()->setCursor(Qt::BlankCursor);
+            /* 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();
+
+            /* May be we have to restrict minimum size? */
+            maybeRestrictMinimumSize();
 
             /* Report to the VM thread that we finished resizing */
             session().GetConsole().GetDisplay().ResizeCompleted(screenId());
 
+            /* We are finishing to perform machine view resize: */
             setMachineWindowResizeIgnored(oldIgnoreMainwndResize);
-
-            /* Update geometry after entering fullscreen */
-            updateGeometry();
 
             /* Make sure that all posted signals are processed: */
             qApp->processEvents();
 
+            /* We also recalculate the desktop geometry if this is determined automatically.
+             * In fact, we only need this on the first resize,
+             * but it is done every time to keep the code simpler. */
+            calculateDesktopGeometry();
+
             /* Emit a signal about guest was resized: */
             emit resizeHintDone();
-
-            /* 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;
@@ -365 +230 @@
                 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);
+#if 0 // TODO: Activate Main Menu!
+                    // should we create it first?
+#endif
                 }
                 else
@@ -386 +246 @@
 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)
     {
@@ -397 +254 @@
             case QEvent::Resize:
             {
+                /* Ignore initial resize event: */
+                if (!m_fIsInitialResizeEventProcessed)
+                {
+                    m_fIsInitialResizeEventProcessed = true;
+                    break;
+                }
+
                 /* Set the "guest needs to resize" hint.
                  * This hint is acted upon when (and only when) the autoresize property is "true": */
                 m_fShouldWeDoResize = uisession()->isGuestSupportsGraphics();
                 if (!isMachineWindowResizeIgnored() && m_bIsGuestAutoresizeEnabled && uisession()->isGuestSupportsGraphics())
-                    QTimer::singleShot(300, this, SLOT(sltPerformGuestResize()));
+                    QTimer::singleShot(0, 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)
+#ifdef Q_WS_MAC // TODO: Is it really needed?
+    QMenuBar *pMenuBar = machineWindowWrapper() && machineWindowWrapper()->machineWindow() ?
+                         qobject_cast<QIMainDialog*>(machineWindowWrapper()->machineWindow())->menuBar() : 0;
+    if (pWatched != 0 && pWatched == pMenuBar)
     {
         /* Sometimes when we press ESC in the menu it brings the focus away (Qt bug?)
@@ -445 +300 @@
         }
     }
+#endif /* Q_WS_MAC */
     return UIMachineView::eventFilter(pWatched, pEvent);
 }
 
+void UIMachineViewFullscreen::prepareCommon()
+{
+    /* Base class common settings: */
+    UIMachineView::prepareCommon();
+
+    /* Store old machine view size before bramebuffer resized: */
+    m_normalSize = QSize(frameBuffer()->width(), frameBuffer()->height());
+
+    /* Minimum size is ignored: */
+    setMinimumSize(0, 0);
+    /* No scrollbars: */
+    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+}
+
+void UIMachineViewFullscreen::prepareFilters()
+{
+    /* Base class filters: */
+    UIMachineView::prepareFilters();
+
+#ifdef Q_WS_MAC // TODO: Is it really needed? See UIMachineViewSeamless::eventFilter(...);
+    /* Menu bar filter: */
+    qobject_cast<QIMainDialog*>(machineWindowWrapper()->machineWindow())->menuBar()->installEventFilter(this);
+#endif
+}
+
+void UIMachineViewFullscreen::prepareConnections()
+{
+    connect(QApplication::desktop(), SIGNAL(resized(int)), this, SLOT(sltDesktopResized()));
+}
+
+void UIMachineViewFullscreen::prepareConsoleConnections()
+{
+    /* Base class connections: */
+    UIMachineView::prepareConsoleConnections();
+
+    /* Guest additions state-change updater: */
+    connect(uisession(), SIGNAL(sigAdditionsStateChange()), this, SLOT(sltAdditionsStateChanged()));
+}
+
+void UIMachineViewFullscreen::setGuestAutoresizeEnabled(bool fEnabled)
+{
+    if (m_bIsGuestAutoresizeEnabled != fEnabled)
+    {
+        m_bIsGuestAutoresizeEnabled = fEnabled;
+
+        maybeRestrictMinimumSize();
+
+        sltPerformGuestResize();
+    }
+}
+
+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.
+     * Currently, the restriction is set only in SDL mode and only when the auto-resize feature is inactive.
+     * We need to do that because we cannot correctly draw in a scrolled window in SDL mode.
+     * In all other modes, or when auto-resize is in force, this function does nothing. */
+    if (mode() == VBoxDefs::SDLMode)
+    {
+        if (!uisession()->isGuestSupportsGraphics() || !m_bIsGuestAutoresizeEnabled)
+            setMinimumSize(sizeHint());
+        else
+            setMinimumSize(0, 0);
+    }
+}
+

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

@@ -44 +44 @@
 private slots:
 
+    /* Slot to perform guest resize: */
+    void sltPerformGuestResize(const QSize &aSize = QSize());
+
     /* Console callback handlers: */
     void sltAdditionsStateChanged();
-
-    /* Slot to perform guest resize: */
-    void sltPerformGuestResize(const QSize &aSize = QSize());
 
     /* Watch dog for desktop resizes: */
@@ -55 +55 @@
 private:
 
+    /* Event handlers: */
+    bool event(QEvent *pEvent);
+    bool eventFilter(QObject *pWatched, QEvent *pEvent);
+
     /* Prepare routines: */
     void prepareCommon();
     void prepareFilters();
+    void prepareConnections();
     void prepareConsoleConnections();
-    void loadMachineViewSettings();
+
+    /* Cleanup routines: */
+    //void cleanupConsoleConnections() {}
+    //void cleanupConnections() {}
+    //void cleanupFilters() {}
+    //void cleanupCommon() {}
 
     /* Private setters: */
@@ -65 +75 @@
 
     /* 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_fIsInitialResizeEventProcessed : 1;
     bool m_bIsGuestAutoresizeEnabled : 1;
     bool m_fShouldWeDoResize : 1;
+    QSize m_normalSize;
 
     /* Friend classes: */

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

@@ -24 +24 @@
 /* Global includes */
 #include <QDesktopWidget>
-#include <QMenuBar>
-#include <QTimer>
-#include <QContextMenuEvent>
+#ifdef Q_WS_MAC
+# include <QMenuBar>
+#endif /* Q_WS_MAC */
 
 /* Local includes */
 #include "VBoxGlobal.h"
 
+#ifdef Q_WS_MAC
 #include "UISession.h"
-#include "UIActionsPool.h"
+#endif /* Q_WS_MAC */
 #include "UIMachineLogic.h"
 #include "UIMachineView.h"
@@ -38 +39 @@
 
 UIMachineWindowFullscreen::UIMachineWindowFullscreen(UIMachineLogic *pMachineLogic, ulong uScreenId)
-    : QIWithRetranslateUI<QIMainDialog>(0)
+    : QIWithRetranslateUI2<QIMainDialog>(0, Qt::Window)
     , UIMachineWindow(pMachineLogic, uScreenId)
 {
@@ -64 +65 @@
     prepareMachineView();
 
+#ifdef Q_WS_MAC
     /* Load normal window settings: */
     loadWindowSettings();
+#endif /* Q_WS_MAC */
 
     /* Update all the elements: */
@@ -71 +74 @@
 
     /* Show window: */
-//    show();
+    showFullScreen();
 }
 
 UIMachineWindowFullscreen::~UIMachineWindowFullscreen()
 {
-    /* Save normal window settings: */
-    saveWindowSettings();
-
     /* Cleanup normal machine view: */
     cleanupMachineView();
@@ -148 +148 @@
 
     /* Set central widget: */
-    setCentralWidget(new QWidget(this));
+    setCentralWidget(new QWidget);
 
     /* Set central widget layout: */
@@ -163 +163 @@
     /* Add machine view into layout: */
     m_pMachineViewContainer->addWidget(m_pMachineView, 1, 1, Qt::AlignVCenter | Qt::AlignHCenter);
-}
 
-void UIMachineWindowFullscreen::loadWindowSettings()
-{
-    /* Toggle console to manual resize mode. */
-    m_pMachineView->setFrameBufferResizeIgnored(true);
-
-    /* The background has to go black */
+    /* The background has to go black: */
     QPalette palette(centralWidget()->palette());
     palette.setColor(centralWidget()->backgroundRole(), Qt::black);
@@ -176 +170 @@
     centralWidget()->setAutoFillBackground(true);
     setAutoFillBackground(true);
-
-    /* Here we are going really fullscreen */
-    setWindowState(windowState() | Qt::WindowFullScreen);
-
-    /* Show the window */
-    show();
-    /* Make sure it is really on the right place (especially on the Mac) */
-    move(0, 0);
 }
 
-void UIMachineWindowFullscreen::saveWindowSettings()
+#ifdef Q_WS_MAC
+void UIMachineWindowFullscreen::loadWindowSettings()
 {
+    /* Load global settings: */
+    {
+        VBoxGlobalSettings settings = vboxGlobal().settings();
+        menuBar()->setHidden(settings.isFeatureActive("noMenuBar"));
+    }
 }
+#endif
 
 void UIMachineWindowFullscreen::cleanupMachineView()

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

@@ -24 +24 @@
 #define __UIMachineWindowFullscreen_h__
 
-/* Global includes */
-#include <QLabel>
-
 /* Local includes */
-#include "VBoxDefs.h"
 #include "QIWithRetranslateUI.h"
 #include "QIMainDialog.h"
@@ -36 +32 @@
 #endif
 
-#ifdef Q_WS_MAC
-# include <ApplicationServices/ApplicationServices.h>
-#endif /* Q_WS_MAC */
-
-/* Local forwards */
-class CMediumAttachment;
-
-class UIMachineWindowFullscreen : public QIWithRetranslateUI<QIMainDialog>, public UIMachineWindow
+class UIMachineWindowFullscreen : public QIWithRetranslateUI2<QIMainDialog>, public UIMachineWindow
 {
     Q_OBJECT;
@@ -49 +38 @@
 protected:
 
-    /* Normal machine window constructor/destructor: */
+    /* Fullscreen machine window constructor/destructor: */
     UIMachineWindowFullscreen(UIMachineLogic *pMachineLogic, ulong uScreenId);
     virtual ~UIMachineWindowFullscreen();
@@ -69 +58 @@
 #ifdef Q_WS_X11
     bool x11Event(XEvent *pEvent);
-#endif
+#endif /* Q_WS_X11 */
     void closeEvent(QCloseEvent *pEvent);
 
@@ -77 +66 @@
 #endif /* Q_WS_MAC */
     void prepareMachineView();
+#ifdef Q_WS_MAC
     void loadWindowSettings();
+#endif /* Q_WS_MAC */
 
     /* Cleanup helpers: */
-    void saveWindowSettings();
+#ifdef Q_WS_MAC
+    //void saveWindowSettings() {}
+#endif /* Q_WS_MAC */
     void cleanupMachineView();
+#ifdef Q_WS_MAC
     //void cleanupMenu() {}
-    //void cleanupConsoleConnections() {}
-
-    /* Other members: */
-    QRect m_normalGeometry;
+#endif /* Q_WS_MAC */
 
     /* Factory support: */