Changeset 41114 in vbox

Timestamp:

May 2, 2012 1:07:55 PM (13 years ago)

Author:

vboxsync

Message:

FE/Qt: Runtime UI: General machine-window refactoring/cleanup.

Location:

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

Files:

• UIMachineDefs.h (modified) (2 diffs)
• UIMachineWindow.cpp (modified) (23 diffs)
• UIMachineWindow.h (modified) (5 diffs)
• fullscreen/UIMachineLogicFullscreen.cpp (modified) (1 diff)
• fullscreen/UIMachineWindowFullscreen.cpp (modified) (11 diffs)
• fullscreen/UIMachineWindowFullscreen.h (modified) (2 diffs)
• normal/UIMachineLogicNormal.cpp (modified) (1 diff)
• normal/UIMachineWindowNormal.cpp (modified) (34 diffs)
• normal/UIMachineWindowNormal.h (modified) (3 diffs)
• scale/UIMachineLogicScale.cpp (modified) (1 diff)
• scale/UIMachineWindowScale.cpp (modified) (8 diffs)
• scale/UIMachineWindowScale.h (modified) (3 diffs)
• seamless/UIMachineLogicSeamless.cpp (modified) (1 diff)
• seamless/UIMachineWindowSeamless.cpp (modified) (10 diffs)
• seamless/UIMachineWindowSeamless.h (modified) (1 diff)

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

@@ -35 +35 @@
 enum UIVisualElement
 {
-    UIVisualElement_WindowCaption         = RT_BIT(0),
+    UIVisualElement_WindowTitle           = RT_BIT(0),
     UIVisualElement_MouseIntegrationStuff = RT_BIT(1),
     UIVisualElement_PauseStuff            = RT_BIT(2),
@@ -46 +46 @@
     UIVisualElement_SharedFolderStuff     = RT_BIT(9),
     UIVisualElement_VirtualizationStuff   = RT_BIT(10),
+    UIVisualElement_MiniToolBar           = RT_BIT(11),
     UIVisualElement_AllStuff              = 0xFFFF
 };

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

@@ -18 +18 @@
  */
 
-/* Global includes */
+/* Global includes: */
 #include <QCloseEvent>
 #include <QTimer>
-
 #include <VBox/version.h>
 #ifdef VBOX_BLEEDING_EDGE
@@ -27 +26 @@
 #endif /* VBOX_BLEEDING_EDGE */
 
-/* Local includes */
+/* Local includes: */
 #include "COMDefs.h"
 #include "VBoxGlobal.h"
 #include "UIMessageCenter.h"
-
 #include "UIKeyboardHandler.h"
+#include "UIMachineWindow.h"
 #include "UIMachineLogic.h"
 #include "UIMachineView.h"
-#include "UIMachineWindow.h"
+#include "UIMachineWindowNormal.h"
 #include "UIMachineWindowFullscreen.h"
-#include "UIMachineWindowNormal.h"
+#include "UIMachineWindowSeamless.h"
 #include "UIMachineWindowScale.h"
-#include "UIMachineWindowSeamless.h"
 #include "UIMouseHandler.h"
 #include "UISession.h"
 #include "UIVMCloseDialog.h"
-
 #ifdef Q_WS_X11
 # include <X11/Xlib.h>
-#endif
-
-UIMachineWindow* UIMachineWindow::create(UIMachineLogic *pMachineLogic, UIVisualStateType visualStateType, ulong uScreenId)
-{
-    UIMachineWindow *window = 0;
-    switch (visualStateType)
+#endif /* Q_WS_X11 */
+
+/* static */
+UIMachineWindow* UIMachineWindow::create(UIMachineLogic *pMachineLogic, ulong uScreenId)
+{
+    /* Create machine-window: */
+    UIMachineWindow *pMachineWindow = 0;
+    switch (pMachineLogic->visualStateType())
     {
         case UIVisualStateType_Normal:
-            window = new UIMachineWindowNormal(pMachineLogic, uScreenId);
+            pMachineWindow = new UIMachineWindowNormal(pMachineLogic, uScreenId);
             break;
         case UIVisualStateType_Fullscreen:
-            window = new UIMachineWindowFullscreen(pMachineLogic, uScreenId);
+            pMachineWindow = new UIMachineWindowFullscreen(pMachineLogic, uScreenId);
             break;
         case UIVisualStateType_Seamless:
-            window = new UIMachineWindowSeamless(pMachineLogic, uScreenId);
+            pMachineWindow = new UIMachineWindowSeamless(pMachineLogic, uScreenId);
             break;
         case UIVisualStateType_Scale:
-            window = new UIMachineWindowScale(pMachineLogic, uScreenId);
+            pMachineWindow = new UIMachineWindowScale(pMachineLogic, uScreenId);
             break;
-    }
-    return window;
-}
-
+        default:
+            AssertMsgFailed(("Incorrect visual state!"));
+            break;
+    }
+    /* Prepare machine-window: */
+    pMachineWindow->prepare();
+    /* Return machine-window: */
+    return pMachineWindow;
+}
+
+/* static */
 void UIMachineWindow::destroy(UIMachineWindow *pWhichWindow)
 {
+    /* Cleanup machine-window: */
+    pWhichWindow->cleanup();
+    /* Delete machine-window: */
     delete pWhichWindow;
 }
 
+void UIMachineWindow::prepare()
+{
+    /* Prepare session-connections: */
+    prepareSessionConnections();
+
+    /* Prepare main-layout: */
+    prepareMainLayout();
+
+    /* Prepare menu: */
+    prepareMenu();
+
+    /* Prepare status-bar: */
+    prepareStatusBar();
+
+    /* Prepare machine-view: */
+    prepareMachineView();
+
+    /* Prepare visual-state: */
+    prepareVisualState();
+
+    /* Prepare handlers: */
+    prepareHandlers();
+
+    /* Load settings: */
+    loadSettings();
+
+    /* Retranslate window: */
+    retranslateUi();
+
+    /* Update all the elements: */
+    updateAppearanceOf(UIVisualElement_AllStuff);
+
+    /* Show: */
+    showInNecessaryMode();
+}
+
+void UIMachineWindow::cleanup()
+{
+    /* Save window settings: */
+    saveSettings();
+
+    /* Cleanup handlers: */
+    cleanupHandlers();
+
+    /* Cleanup visual-state: */
+    cleanupVisualState();
+
+    /* Cleanup machine-view: */
+    cleanupMachineView();
+
+    /* Cleanup status-bar: */
+    cleanupStatusBar();
+
+    /* Cleanup menu: */
+    cleanupMenu();
+
+    /* Cleanup main layout: */
+    cleanupMainLayout();
+
+    /* Cleanup session connections: */
+    cleanupSessionConnections();
+}
+
+void UIMachineWindow::sltMachineStateChanged()
+{
+    /* Update window-title: */
+    updateAppearanceOf(UIVisualElement_WindowTitle);
+}
+
+void UIMachineWindow::sltGuestMonitorChange(KGuestMonitorChangedEventType changeType, ulong uScreenId, QRect /* screenGeo */)
+{
+    /* Ignore change events for other screens: */
+    if (uScreenId != m_uScreenId)
+        return;
+    /* Ignore KGuestMonitorChangedEventType_NewOrigin change event: */
+    if (changeType == KGuestMonitorChangedEventType_NewOrigin)
+        return;
+
+    /* Process KGuestMonitorChangedEventType_Enabled change event: */
+    if (isHidden() && changeType == KGuestMonitorChangedEventType_Enabled)
+        showInNecessaryMode();
+    /* Process KGuestMonitorChangedEventType_Disabled change event: */
+    else if (!isHidden() && changeType == KGuestMonitorChangedEventType_Disabled)
+        hide();
+}
+
 void UIMachineWindow::sltTryClose()
 {
-    /* Do not try to close if restricted: */
+    /* Do not try to close window if restricted: */
     if (machineLogic()->isPreventAutoClose())
         return;
 
-    /* First close any open modal & popup widgets.
+#if 0
+    // TODO: Is that really needed?
+    /* This thing here is from Qt3.
+     * First close any open modal & popup widgets.
      * Use a single shot with timeout 0 to allow the widgets to cleanly close and test then again.
      * If all open widgets are closed destroy ourself: */
-    QWidget *widget = QApplication::activeModalWidget() ?
-                      QApplication::activeModalWidget() :
-                      QApplication::activePopupWidget() ?
-                      QApplication::activePopupWidget() : 0;
-    if (widget)
-    {
-        widget->close();
+    QWidget *pWidget = QApplication::activeModalWidget() ? QApplication::activeModalWidget() :
+                       QApplication::activePopupWidget() ? QApplication::activePopupWidget() : 0;
+    if (pWidget)
+    {
+        pWidget->close();
         QTimer::singleShot(0, this, SLOT(sltTryClose()));
     }
     else
-        close();
+#endif
+
+    close();
 }
 
@@ -99 +197 @@
     : QIWithRetranslateUI2<QMainWindow>(0, windowFlags(pMachineLogic->visualStateType()))
     , m_pMachineLogic(pMachineLogic)
+    , m_pMachineView(0)
     , m_uScreenId(uScreenId)
-    , m_pMachineViewContainer(0)
+    , m_pMainLayout(0)
     , m_pTopSpacer(0)
     , m_pBottomSpacer(0)
     , m_pLeftSpacer(0)
     , m_pRightSpacer(0)
-    , m_pMachineView(0)
-{
+{
+#ifndef Q_WS_MAC
+    /* On Mac OS X application icon referenced in info.plist is used. */
+
+    /* Set default application icon (will be changed to VM-specific icon little bit later): */
+    setWindowIcon(QIcon(":/VirtualBox_48px.png"));
+
+    /* Set VM-specific application icon: */
+    setWindowIcon(vboxGlobal().vmGuestOSTypeIcon(machine().GetOSTypeId()));
+#endif /* !Q_WS_MAC */
+
+    /* Set the main application window for VBoxGlobal: */
+    if (m_uScreenId == 0)
+        vboxGlobal().setMainWindow(this);
 }
 
 UIMachineWindow::~UIMachineWindow()
 {
-    /* Close any opened modal & popup widgets: */
+#if 0
+    // TODO: Is that really needed?
+    /* This thing here is from Qt3.
+     * Close any opened modal & popup widgets: */
     while (QWidget *pWidget = QApplication::activeModalWidget() ? QApplication::activeModalWidget() :
                               QApplication::activePopupWidget() ? QApplication::activePopupWidget() : 0)
@@ -126 +240 @@
         pWidget->deleteLater();
     }
+#endif
 }
 
@@ -138 +253 @@
 }
 
+CMachine UIMachineWindow::machine() const
+{
+    return session().GetMachine();
+}
+
 void UIMachineWindow::retranslateUi()
 {
+    /* Compose window-title prefix: */
     m_strWindowTitlePrefix = VBOX_PRODUCT;
 #ifdef VBOX_BLEEDING_EDGE
-    m_strWindowTitlePrefix += UIMachineLogic::tr(" EXPERIMENTAL build %1r%2 - %3")
+    m_strWindowTitlePrefix += UIMachineWindow::tr(" EXPERIMENTAL build %1r%2 - %3")
                               .arg(RTBldCfgVersion())
                               .arg(RTBldCfgRevisionStr())
                               .arg(VBOX_BLEEDING_EDGE);
-#endif
-    updateAppearanceOf(UIVisualElement_WindowCaption);
+#endif /* VBOX_BLEEDING_EDGE */
+    /* Update appearance of the window-title: */
+    updateAppearanceOf(UIVisualElement_WindowTitle);
 }
 
@@ -153 +275 @@
 bool UIMachineWindow::x11Event(XEvent *pEvent)
 {
-    // TODO: Check if that is still required!
+    // TODO: Is that really needed?
     /* Qt bug: when the machine-view grabs the keyboard,
      * FocusIn, FocusOut, WindowActivate and WindowDeactivate Qt events are
@@ -171 +293 @@
     return false;
 }
-#endif
+#endif /* Q_WS_X11 */
 
 void UIMachineWindow::closeEvent(QCloseEvent *pEvent)
 {
-    /* Always ignore close event: */
+    /* Always ignore close-event: */
     pEvent->ignore();
 
     /* Should we close application? */
     bool fCloseApplication = false;
-
     switch (uisession()->machineState())
     {
@@ -191 +312 @@
         {
             /* Get the machine: */
-            CMachine machine = session().GetMachine();
+            CMachine m = machine();
 
             /* Check if there is a close hock script defined. */
-            const QString& strScript = machine.GetExtraData(VBoxDefs::GUI_CloseActionHook);
+            const QString& strScript = m.GetExtraData(VBoxDefs::GUI_CloseActionHook);
             if (!strScript.isEmpty())
             {
-                QProcess::startDetached(strScript, QStringList() << machine.GetId());
+                QProcess::startDetached(strScript, QStringList() << m.GetId());
                 return;
             }
-            /* Prepare close dialog: */
+
+            /* Prepare close-dialog: */
             UIVMCloseDialog dlg(this);
 
             /* Assign close-dialog pixmap: */
-            dlg.pmIcon->setPixmap(vboxGlobal().vmGuestOSTypeIcon(machine.GetOSTypeId()));
+            dlg.pmIcon->setPixmap(vboxGlobal().vmGuestOSTypeIcon(m.GetOSTypeId()));
 
             /* Check which close actions are disallowed: */
-            QStringList restictedActionsList = machine.GetExtraData(VBoxDefs::GUI_RestrictedCloseActions).split(',');
+            QStringList restictedActionsList = m.GetExtraData(VBoxDefs::GUI_RestrictedCloseActions).split(',');
             bool fIsStateSavingAllowed = !restictedActionsList.contains("SaveState", Qt::CaseInsensitive);
             bool fIsACPIShutdownAllowed = !restictedActionsList.contains("Shutdown", Qt::CaseInsensitive);
@@ -231 +353 @@
 
             /* Make the Restore Snapshot checkbox visible/hidden depending on snapshots count & restrictions: */
-            dlg.mCbDiscardCurState->setVisible(fIsPowerOffAndRestoreAllowed && machine.GetSnapshotCount() > 0);
-            if (!machine.GetCurrentSnapshot().isNull())
-                dlg.mCbDiscardCurState->setText(dlg.mCbDiscardCurState->text().arg(machine.GetCurrentSnapshot().GetName()));
+            dlg.mCbDiscardCurState->setVisible(fIsPowerOffAndRestoreAllowed && m.GetSnapshotCount() > 0);
+            if (!m.GetCurrentSnapshot().isNull())
+                dlg.mCbDiscardCurState->setText(dlg.mCbDiscardCurState->text().arg(m.GetCurrentSnapshot().GetName()));
 
             /* Choice string tags for close-dialog: */
@@ -242 +364 @@
 
             /* Read the last user's choice for the given VM: */
-            QStringList lastAction = machine.GetExtraData(VBoxDefs::GUI_LastCloseAction).split(',');
+            QStringList lastAction = m.GetExtraData(VBoxDefs::GUI_LastCloseAction).split(',');
 
             /* Check which button should be initially chosen: */
@@ -288 +410 @@
 
             /* This flag will keep the status of every further logical operation: */
-            bool success = true;
+            bool fSuccess = true;
 
             /* Pause before showing dialog if necessary: */
             bool fWasPaused = uisession()->isPaused() || uisession()->machineState() == KMachineState_Stuck;
             if (!fWasPaused)
-                success = uisession()->pause();
-
-            if (success)
+                fSuccess = uisession()->pause();
+
+            if (fSuccess)
             {
                 /* Preventing auto-closure: */
                 machineLogic()->setPreventAutoClose(true);
 
-                /* If close dialog accepted: */
+                /* If close-dialog accepted: */
                 if (dlg.exec() == QDialog::Accepted)
                 {
@@ -306 +428 @@
                     CConsole console = session().GetConsole();
 
-                    success = false;
+                    fSuccess = false;
 
                     if (dlg.mRbSave->isChecked())
@@ -317 +439 @@
                         {
                             /* Show the "VM saving" progress dialog: */
-                            msgCenter().showModalProgressDialog(progress, machine.GetName(), ":/progress_state_save_90px.png", 0, true);
+                            msgCenter().showModalProgressDialog(progress, m.GetName(), ":/progress_state_save_90px.png", 0, true);
                             if (progress.GetResultCode() != 0)
                                 msgCenter().cannotSaveMachineState(progress);
                             else
-                                success = true;
+                                fSuccess = true;
                         }
 
-                        if (success)
+                        if (fSuccess)
                             fCloseApplication = true;
                     }
@@ -338 +460 @@
                             msgCenter().cannotACPIShutdownMachine(console);
                         else
-                            success = true;
+                            fSuccess = true;
                     }
                     else if (dlg.mRbPowerOff->isChecked())
@@ -349 +471 @@
                         {
                             /* Show the power down progress dialog: */
-                            msgCenter().showModalProgressDialog(progress, machine.GetName(), ":/progress_poweroff_90px.png", 0, true);
+                            msgCenter().showModalProgressDialog(progress, m.GetName(), ":/progress_poweroff_90px.png", 0, true);
                             if (progress.GetResultCode() != 0)
                                 msgCenter().cannotStopMachine(progress);
                             else
-                                success = true;
+                                fSuccess = true;
                         }
 
-                        if (success)
+                        if (fSuccess)
                         {
                             /* Discard the current state if requested: */
                             if (dlg.mCbDiscardCurState->isChecked() && dlg.mCbDiscardCurState->isVisibleTo(&dlg))
                             {
-                                CSnapshot snapshot = machine.GetCurrentSnapshot();
+                                CSnapshot snapshot = m.GetCurrentSnapshot();
                                 CProgress progress = console.RestoreSnapshot(snapshot);
                                 if (!console.isOk())
@@ -368 +490 @@
                                 {
                                     /* Show the progress dialog: */
-                                    msgCenter().showModalProgressDialog(progress, machine.GetName(), ":/progress_snapshot_discard_90px.png", 0, true);
+                                    msgCenter().showModalProgressDialog(progress, m.GetName(), ":/progress_snapshot_discard_90px.png", 0, true);
                                     if (progress.GetResultCode() != 0)
                                         msgCenter().cannotRestoreSnapshot(progress, snapshot.GetName());
@@ -375 +497 @@
                         }
 
-                        if (success)
+                        if (fSuccess)
                             fCloseApplication = true;
                     }
 
-                    if (success)
+                    if (fSuccess)
                     {
                         /* Read the last user's choice for the given VM: */
-                        QStringList prevAction = machine.GetExtraData(VBoxDefs::GUI_LastCloseAction).split(',');
+                        QStringList prevAction = m.GetExtraData(VBoxDefs::GUI_LastCloseAction).split(',');
                         /* Memorize the last user's choice for the given VM: */
                         QString lastAction = strPowerOff;
@@ -396 +518 @@
                         if (dlg.mCbDiscardCurState->isChecked())
                             (lastAction += ",") += strDiscardCurState;
-                        machine.SetExtraData(VBoxDefs::GUI_LastCloseAction, lastAction);
+                        m.SetExtraData(VBoxDefs::GUI_LastCloseAction, lastAction);
                     }
                 }
 
                 /* Restore the running state if needed: */
-                if (success && !fCloseApplication && !fWasPaused && uisession()->machineState() == KMachineState_Paused)
+                if (fSuccess && !fCloseApplication && !fWasPaused && uisession()->machineState() == KMachineState_Paused)
                     uisession()->unpause();
 
@@ -407 +529 @@
                 machineLogic()->setPreventAutoClose(false);
             }
-
             break;
         }
-
         default:
             break;
     }
-
     if (fCloseApplication)
     {
-        /* VM has been powered off or saved. We must *safely* close the VM window(s): */
+        /* VM has been powered off or saved. We must *safely* close VM window(s): */
         QTimer::singleShot(0, uisession(), SLOT(sltCloseVirtualSession()));
     }
 }
 
-void UIMachineWindow::prepareWindowIcon()
-{
-#if !(defined (Q_WS_WIN) || defined (Q_WS_MAC))
-    /* The default application icon (will be changed to VM-specific icon little bit later):
-     * 1. On Win32, it's built-in to the executable;
-     * 2. On Mac OS X the icon referenced in info.plist is used. */
-    setWindowIcon(QIcon(":/VirtualBox_48px.png"));
-#endif
-
-#ifndef Q_WS_MAC
-    /* Set the VM-specific application icon except Mac OS X: */
-    setWindowIcon(vboxGlobal().vmGuestOSTypeIcon(session().GetMachine().GetOSTypeId()));
-#endif
-}
-
-void UIMachineWindow::prepareConsoleConnections()
+void UIMachineWindow::prepareSessionConnections()
 {
     /* Machine state-change updater: */
     connect(uisession(), SIGNAL(sigMachineStateChange()), this, SLOT(sltMachineStateChanged()));
 
-    /* Guest monitor change updater: */
+    /* Guest monitor-change updater: */
     connect(uisession(), SIGNAL(sigGuestMonitorChange(KGuestMonitorChangedEventType, ulong, QRect)),
             this, SLOT(sltGuestMonitorChange(KGuestMonitorChangedEventType, ulong, QRect)));
 }
 
-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. */
+void UIMachineWindow::prepareMainLayout()
+{
+    /* Create central-widget: */
+    setCentralWidget(new QWidget);
+
+    /* Create main-layout: */
+    m_pMainLayout = new QGridLayout(centralWidget());
+    m_pMainLayout->setMargin(0);
+    m_pMainLayout->setSpacing(0);
+
+    /* Create shifting-spacers: */
     m_pTopSpacer = new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding);
     m_pBottomSpacer = new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding);
@@ -464 +567 @@
     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);
+    /* Add shifting-spacers into main-layout: */
+    m_pMainLayout->addItem(m_pTopSpacer, 0, 1);
+    m_pMainLayout->addItem(m_pBottomSpacer, 2, 1);
+    m_pMainLayout->addItem(m_pLeftSpacer, 1, 0);
+    m_pMainLayout->addItem(m_pRightSpacer, 1, 2);
+}
+
+void UIMachineWindow::prepareMachineView()
+{
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    /* Need to force the QGL framebuffer in case 2D Video Acceleration is supported & enabled: */
+    bool bAccelerate2DVideo = machine().GetAccelerate2DVideoEnabled() && VBoxGlobal::isAcceleration2DVideoAvailable();
+#endif /* VBOX_WITH_VIDEOHWACCEL */
+
+    /* Get visual-state type: */
+    UIVisualStateType visualStateType = machineLogic()->visualStateType();
+
+    /* Create machine-view: */
+    m_pMachineView = UIMachineView::create(  this
+                                           , m_uScreenId
+                                           , visualStateType
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                                           , bAccelerate2DVideo
+#endif /* VBOX_WITH_VIDEOHWACCEL */
+                                           );
+
+    /* Add machine-view into main-layout: */
+    m_pMainLayout->addWidget(m_pMachineView, 1, 1, viewAlignment(visualStateType));
 }
 
@@ -488 +615 @@
 }
 
+void UIMachineWindow::cleanupMachineView()
+{
+    /* Destroy machine-view: */
+    UIMachineView::destroy(m_pMachineView);
+    m_pMachineView = 0;
+}
+
 void UIMachineWindow::updateAppearanceOf(int iElement)
 {
-    CMachine machine = session().GetMachine();
-
-    if (iElement & UIVisualElement_WindowCaption)
-    {
+    /* Update window title: */
+    if (iElement & UIVisualElement_WindowTitle)
+    {
+        /* Get machine: */
+        const CMachine &m = machine();
         /* Get machine state: */
         KMachineState state = uisession()->machineState();
         /* Prepare full name: */
         QString strSnapshotName;
-        if (machine.GetSnapshotCount() > 0)
+        if (m.GetSnapshotCount() > 0)
         {
-            CSnapshot snapshot = machine.GetCurrentSnapshot();
+            CSnapshot snapshot = m.GetCurrentSnapshot();
             strSnapshotName = " (" + snapshot.GetName() + ")";
         }
-        QString strMachineName = machine.GetName() + strSnapshotName;
+        QString strMachineName = m.GetName() + strSnapshotName;
         if (state != KMachineState_Null)
             strMachineName += " [" + vboxGlobal().toString(state) + "]";
         /* Unusual on the Mac. */
 #ifndef Q_WS_MAC
-        strMachineName += " - " + m_strWindowTitlePrefix;
-#endif /* Q_WS_MAC */
-        if (machine.GetMonitorCount() > 1)
+        strMachineName += " - " + defaultWindowTitle();
+#endif /* !Q_WS_MAC */
+        if (m.GetMonitorCount() > 1)
             strMachineName += QString(" : %1").arg(m_uScreenId + 1);
         setWindowTitle(strMachineName);
@@ -525 +660 @@
 #endif /* VBOX_WITH_DEBUGGER_GUI */
 
-void UIMachineWindow::sltMachineStateChanged()
-{
-    updateAppearanceOf(UIVisualElement_WindowCaption);
-}
-
-void UIMachineWindow::sltGuestMonitorChange(KGuestMonitorChangedEventType changeType, ulong uScreenId, QRect /* screenGeo */)
-{
-    /* Ignore change events for other screens: */
-    if (uScreenId != m_uScreenId)
-        return;
-
-    /* Ignore KGuestMonitorChangedEventType_NewOrigin change event: */
-    if (changeType == KGuestMonitorChangedEventType_NewOrigin)
-        return;
-
-    /* Process KGuestMonitorChangedEventType_Enabled change event: */
-    if (isHidden() && changeType == KGuestMonitorChangedEventType_Enabled)
-        showInNecessaryMode();
-    /* Process KGuestMonitorChangedEventType_Disabled change event: */
-    else if (!isHidden() && changeType == KGuestMonitorChangedEventType_Disabled)
-        hide();
-}
-
+/* static */
 Qt::WindowFlags UIMachineWindow::windowFlags(UIVisualStateType visualStateType)
 {
@@ -561 +674 @@
 }
 
+/* static */
+Qt::Alignment UIMachineWindow::viewAlignment(UIVisualStateType visualStateType)
+{
+    switch (visualStateType)
+    {
+        case UIVisualStateType_Normal: return 0;
+        case UIVisualStateType_Fullscreen: return Qt::AlignVCenter | Qt::AlignHCenter;
+        case UIVisualStateType_Seamless: return 0;
+        case UIVisualStateType_Scale: return 0;
+    }
+    AssertMsgFailed(("Incorrect visual state!"));
+    return 0;
+}
+

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

@@ -20 +20 @@
 #define __UIMachineWindow_h__
 
-/* Global includes */
+/* Global includes: */
 #include <QMainWindow>
 
-/* Local includes */
+/* Local includes: */
 #include "QIWithRetranslateUI.h"
 #include "UIMachineDefs.h"
 #include "COMDefs.h"
 
-/* Global forwards */
-class QWidget;
+/* Forward declarations: */
 class QGridLayout;
 class QSpacerItem;
 class QCloseEvent;
-
-/* Local forwards */
 class CSession;
 class UISession;
@@ -40 +37 @@
 class UIMachineView;
 
+/* Machine-window interface: */
 class UIMachineWindow : public QIWithRetranslateUI2<QMainWindow>
 {
@@ -46 +44 @@
 public:
 
-    /* Factory function to create required machine window child: */
-    static UIMachineWindow* create(UIMachineLogic *pMachineLogic, UIVisualStateType visualStateType, ulong uScreenId = 0);
+    /* Factory functions to create/destroy machine-window: */
+    static UIMachineWindow* create(UIMachineLogic *pMachineLogic, ulong uScreenId = 0);
     static void destroy(UIMachineWindow *pWhichWindow);
 
+    /* Prepare/cleanup machine-window: */
+    void prepare();
+    void cleanup();
+
     /* Public getters: */
-    virtual UIMachineLogic* machineLogic() const { return m_pMachineLogic; }
-    virtual UIMachineView* machineView() const { return m_pMachineView; }
+    UIMachineView* machineView() const { return m_pMachineView; }
+    UIMachineLogic* machineLogic() const { return m_pMachineLogic; }
     UISession* uisession() const;
     CSession& session() const;
+    CMachine machine() const;
 
 protected slots:
@@ -62 +65 @@
     virtual void sltGuestMonitorChange(KGuestMonitorChangedEventType changeType, ulong uScreenId, QRect screenGeo);
 
-    /* Slot to safe close machine-window: */
+    /* Slot to close machine-window: */
     void sltTryClose();
 
 protected:
 
-    /* Machine window constructor/destructor: */
+    /* Constructor/destructor: */
     UIMachineWindow(UIMachineLogic *pMachineLogic, ulong uScreenId);
-    virtual ~UIMachineWindow();
+    ~UIMachineWindow();
 
-    /* Protected getters: */
-    const QString& defaultWindowTitle() const { return m_strWindowTitlePrefix; }
+    /* Show stuff: */
+    virtual void showInNecessaryMode() = 0;
 
-    /* Translate routine: */
-    virtual void retranslateUi();
+    /* Translate stuff: */
+    void retranslateUi();
 
-    /* Common machine window event handlers: */
+    /* Event handlers: */
 #ifdef Q_WS_X11
     bool x11Event(XEvent *pEvent);
-#endif
+#endif /* Q_WS_X11 */
     void closeEvent(QCloseEvent *pEvent);
 
     /* Prepare helpers: */
-    virtual void prepareWindowIcon();
-    virtual void prepareConsoleConnections();
-    virtual void prepareMachineViewContainer();
-    //virtual void loadWindowSettings() {}
+    virtual void prepareSessionConnections();
+    virtual void prepareMainLayout();
+    virtual void prepareMenu() {}
+    virtual void prepareStatusBar() {}
+    virtual void prepareMachineView();
+    virtual void prepareVisualState() {}
     virtual void prepareHandlers();
+    virtual void loadSettings() {}
 
     /* Cleanup helpers: */
+    virtual void saveSettings() {}
     virtual void cleanupHandlers();
-    //virtual void saveWindowSettings() {}
-    //virtual void cleanupMachineViewContainer() {}
-    //virtual void cleanupConsoleConnections() {}
-    //virtual void cleanupWindowIcon() {}
+    virtual void cleanupVisualState() {}
+    virtual void cleanupMachineView();
+    virtual void cleanupStatusBar() {}
+    virtual void cleanupMenu() {}
+    virtual void cleanupMainLayout() {}
+    virtual void cleanupSessionConnections() {}
 
-    /* Update routines: */
+    /* Update stuff: */
     virtual void updateAppearanceOf(int iElement);
 #ifdef VBOX_WITH_DEBUGGER_GUI
-    virtual void updateDbgWindows();
+    void updateDbgWindows();
 #endif /* VBOX_WITH_DEBUGGER_GUI */
 
     /* Helpers: */
-    Qt::WindowFlags windowFlags(UIVisualStateType visualStateType);
+    const QString& defaultWindowTitle() const { return m_strWindowTitlePrefix; }
+    static Qt::WindowFlags windowFlags(UIVisualStateType visualStateType);
+    static Qt::Alignment viewAlignment(UIVisualStateType visualStateType);
 
-    /* Show routine: */
-    virtual void showInNecessaryMode() = 0;
-
-    /* Protected variables: */
+    /* Variables: */
     UIMachineLogic *m_pMachineLogic;
-
-    /* Virtual screen number: */
+    UIMachineView *m_pMachineView;
+    QString m_strWindowTitlePrefix;
     ulong m_uScreenId;
-
-    QGridLayout *m_pMachineViewContainer;
+    QGridLayout *m_pMainLayout;
     QSpacerItem *m_pTopSpacer;
     QSpacerItem *m_pBottomSpacer;
@@ -121 +128 @@
     QSpacerItem *m_pRightSpacer;
 
-    UIMachineView *m_pMachineView;
-    QString m_strWindowTitlePrefix;
-
+    /* Friend classes: */
     friend class UIMachineLogic;
 };

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

@@ -147 +147 @@
     /* Create machine window(s): */
     for (int cScreenId = 0; cScreenId < m_pScreenLayout->guestScreenCount(); ++cScreenId)
-        addMachineWindow(UIMachineWindow::create(this, visualStateType(), cScreenId));
+        addMachineWindow(UIMachineWindow::create(this, cScreenId));
 
     /* Connect screen-layout change handler: */

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

@@ -18 +18 @@
  */
 
-/* Global includes */
+/* Global includes: */
 #include <QDesktopWidget>
 #include <QTimer>
@@ -25 +25 @@
 #endif /* Q_WS_MAC */
 
-/* Local includes */
-#include "VBoxGlobal.h"
+/* Local includes: */
 #include "VBoxMiniToolBar.h"
-
 #include "UISession.h"
 #include "UIActionPoolRuntime.h"
 #include "UIMachineLogicFullscreen.h"
 #include "UIMachineWindowFullscreen.h"
-#include "UIMachineView.h"
 
 UIMachineWindowFullscreen::UIMachineWindowFullscreen(UIMachineLogic *pMachineLogic, ulong uScreenId)
@@ -40 +37 @@
     , m_pMiniToolBar(0)
 {
-    /* Set the main window in VBoxGlobal: */
-    if (uScreenId == 0)
-        vboxGlobal().setMainWindow(this);
-
-    /* Prepare fullscreen window icon: */
-    prepareWindowIcon();
-
-    /* Prepare console connections: */
-    prepareConsoleConnections();
-
-    /* Prepare fullscreen menu: */
-    prepareMenu();
-
-    /* Prepare machine view container: */
-    prepareMachineViewContainer();
-
-    /* Prepare fullscreen machine view: */
-    prepareMachineView();
-
-    /* Prepare handlers: */
-    prepareHandlers();
-
-    /* Prepare mini tool-bar: */
-    prepareMiniToolBar();
-
-    /* Retranslate fullscreen window finally: */
-    retranslateUi();
-
-    /* Update all the elements: */
-    updateAppearanceOf(UIVisualElement_AllStuff);
-
-    /* Show fullscreen window: */
-    showInNecessaryMode();
-}
-
-UIMachineWindowFullscreen::~UIMachineWindowFullscreen()
-{
-    /* Save window settings: */
-    saveWindowSettings();
-
-    /* Cleanup mini tool-bar: */
-    cleanupMiniToolBar();
-
-    /* Prepare handlers: */
-    cleanupHandlers();
-
-    /* Cleanup machine view: */
-    cleanupMachineView();
-
-    /* Cleanup menu: */
-    cleanupMenu();
+}
+
+void UIMachineWindowFullscreen::sltMachineStateChanged()
+{
+    /* Call to base-class: */
+    UIMachineWindow::sltMachineStateChanged();
+
+    /* Update mini-toolbar: */
+    updateAppearanceOf(UIVisualElement_MiniToolBar);
 }
 
@@ -96 +51 @@
 {
     /* Get corresponding screen: */
-    int iScreen = static_cast<UIMachineLogicFullscreen*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
+    int iScreen = qobject_cast<UIMachineLogicFullscreen*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
     /* Calculate working area: */
     QRect workingArea = QApplication::desktop()->screenGeometry(iScreen);
@@ -109 +64 @@
 void UIMachineWindowFullscreen::sltPopupMainMenu()
 {
-    /* Popup main menu if present: */
+    /* Popup main-menu if present: */
     if (m_pMainMenu && !m_pMainMenu->isEmpty())
     {
@@ -119 +74 @@
 void UIMachineWindowFullscreen::prepareMenu()
 {
+    /* Call to base-class: */
+    UIMachineWindow::prepareMenu();
+
+    /* Prepare menu: */
 #ifdef Q_WS_MAC
     setMenuBar(uisession()->newMenuBar());
@@ -125 +84 @@
 }
 
-void UIMachineWindowFullscreen::prepareMiniToolBar()
-{
-    /* Get current machine: */
-    CMachine machine = session().GetConsole().GetMachine();
-    /* Check if mini tool-bar should present: */
-    bool fIsActive = machine.GetExtraData(VBoxDefs::GUI_ShowMiniToolBar) != "no";
-    if (fIsActive)
-    {
-        /* Get the mini tool-bar alignment: */
-        bool fIsAtTop = machine.GetExtraData(VBoxDefs::GUI_MiniToolBarAlignment) == "top";
-        /* Get the mini tool-bar auto-hide feature availability: */
-        bool fIsAutoHide = machine.GetExtraData(VBoxDefs::GUI_MiniToolBarAutoHide) != "off";
-        m_pMiniToolBar = new VBoxMiniToolBar(centralWidget(),
-                                             fIsAtTop ? VBoxMiniToolBar::AlignTop : VBoxMiniToolBar::AlignBottom,
-                                             true, fIsAutoHide);
-        m_pMiniToolBar->updateDisplay(true, true);
-        QList<QMenu*> menus;
-        QList<QAction*> actions = uisession()->newMenu()->actions();
-        for (int i=0; i < actions.size(); ++i)
-            menus << actions.at(i)->menu();
-        *m_pMiniToolBar << menus;
-        connect(m_pMiniToolBar, SIGNAL(minimizeAction()), this, SLOT(showMinimized()));
-        connect(m_pMiniToolBar, SIGNAL(exitAction()),
-                gActionPool->action(UIActionIndexRuntime_Toggle_Fullscreen), SLOT(trigger()));
-        connect(m_pMiniToolBar, SIGNAL(closeAction()),
-                gActionPool->action(UIActionIndexRuntime_Simple_Close), SLOT(trigger()));
-    }
-}
-
-void UIMachineWindowFullscreen::prepareMachineView()
-{
-#ifdef VBOX_WITH_VIDEOHWACCEL
-    /* Need to force the QGL framebuffer in case 2D Video Acceleration is supported & enabled: */
-    bool bAccelerate2DVideo = session().GetMachine().GetAccelerate2DVideoEnabled() && VBoxGlobal::isAcceleration2DVideoAvailable();
-#endif
-
-    /* Set central widget: */
-    setCentralWidget(new QWidget);
-
-    /* Set central widget layout: */
-    centralWidget()->setLayout(m_pMachineViewContainer);
-
-    m_pMachineView = UIMachineView::create(  this
-                                           , m_uScreenId
-                                           , machineLogic()->visualStateType()
-#ifdef VBOX_WITH_VIDEOHWACCEL
-                                           , bAccelerate2DVideo
-#endif
-                                           );
-
-    /* Add machine view into layout: */
-    m_pMachineViewContainer->addWidget(m_pMachineView, 1, 1, Qt::AlignVCenter | Qt::AlignHCenter);
+void UIMachineWindowFullscreen::prepareVisualState()
+{
+    /* Call to base-class: */
+    UIMachineWindow::prepareVisualState();
 
     /* The background has to go black: */
@@ -184 +95 @@
     centralWidget()->setAutoFillBackground(true);
     setAutoFillBackground(true);
-}
-
-void UIMachineWindowFullscreen::saveWindowSettings()
+
+    /* Prepare mini-toolbar: */
+    prepareMiniToolbar();
+}
+
+void UIMachineWindowFullscreen::prepareMiniToolbar()
 {
     /* Get machine: */
-    CMachine machine = session().GetConsole().GetMachine();
-
-    /* Save extra-data settings: */
-    {
-        /* Save mini tool-bar settings: */
-        if (m_pMiniToolBar)
-            machine.SetExtraData(VBoxDefs::GUI_MiniToolBarAutoHide, m_pMiniToolBar->isAutoHide() ? QString() : "off");
-    }
-}
-
-void UIMachineWindowFullscreen::cleanupMachineView()
-{
-    /* Do not cleanup machine view if it is not present: */
-    if (!machineView())
+    CMachine m = machine();
+
+    /* Make sure mini-toolbar is necessary: */
+    bool fIsActive = m.GetExtraData(VBoxDefs::GUI_ShowMiniToolBar) != "no";
+    if (!fIsActive)
         return;
 
-    UIMachineView::destroy(m_pMachineView);
-    m_pMachineView = 0;
-}
-
-void UIMachineWindowFullscreen::cleanupMiniToolBar()
-{
-    if (m_pMiniToolBar)
-    {
-        delete m_pMiniToolBar;
-        m_pMiniToolBar = 0;
-    }
+    /* Get the mini-toolbar alignment: */
+    bool fIsAtTop = m.GetExtraData(VBoxDefs::GUI_MiniToolBarAlignment) == "top";
+    /* Get the mini-toolbar auto-hide feature availability: */
+    bool fIsAutoHide = m.GetExtraData(VBoxDefs::GUI_MiniToolBarAutoHide) != "off";
+    m_pMiniToolBar = new VBoxMiniToolBar(centralWidget(),
+                                         fIsAtTop ? VBoxMiniToolBar::AlignTop : VBoxMiniToolBar::AlignBottom,
+                                         true, fIsAutoHide);
+    m_pMiniToolBar->updateDisplay(true, true);
+    QList<QMenu*> menus;
+    QList<QAction*> actions = uisession()->newMenu()->actions();
+    for (int i=0; i < actions.size(); ++i)
+        menus << actions.at(i)->menu();
+    *m_pMiniToolBar << menus;
+    connect(m_pMiniToolBar, SIGNAL(minimizeAction()), this, SLOT(showMinimized()));
+    connect(m_pMiniToolBar, SIGNAL(exitAction()),
+            gActionPool->action(UIActionIndexRuntime_Toggle_Fullscreen), SLOT(trigger()));
+    connect(m_pMiniToolBar, SIGNAL(closeAction()),
+            gActionPool->action(UIActionIndexRuntime_Simple_Close), SLOT(trigger()));
+}
+
+void UIMachineWindowFullscreen::cleanupMiniToolbar()
+{
+    /* Make sure mini-toolbar was created: */
+    if (!m_pMiniToolBar)
+        return;
+
+    /* Save mini-toolbar settings: */
+    machine().SetExtraData(VBoxDefs::GUI_MiniToolBarAutoHide, m_pMiniToolBar->isAutoHide() ? QString() : "off");
+    /* Delete mini-toolbar: */
+    delete m_pMiniToolBar;
+    m_pMiniToolBar = 0;
+}
+
+void UIMachineWindowFullscreen::cleanupVisualState()
+{
+    /* Cleanup mini-toolbar: */
+    cleanupMiniToolbar();
+
+    /* Call to base-class: */
+    UIMachineWindow::cleanupVisualState();
 }
 
 void UIMachineWindowFullscreen::cleanupMenu()
 {
+    /* Cleanup menu: */
     delete m_pMainMenu;
     m_pMainMenu = 0;
-}
-
-void UIMachineWindowFullscreen::updateAppearanceOf(int iElement)
-{
-    /* Base class update: */
-    UIMachineWindow::updateAppearanceOf(iElement);
-
-    /* If mini tool-bar is present: */
-    if (m_pMiniToolBar)
-    {
-        /* Get machine: */
-        CMachine machine = session().GetConsole().GetMachine();
-        /* Get snapshot(s): */
-        QString strSnapshotName;
-        if (machine.GetSnapshotCount() > 0)
-        {
-            CSnapshot snapshot = machine.GetCurrentSnapshot();
-            strSnapshotName = " (" + snapshot.GetName() + ")";
-        }
-        /* Update mini tool-bar text: */
-        m_pMiniToolBar->setDisplayText(machine.GetName() + strSnapshotName);
-    }
+
+    /* Call to base-class: */
+    UIMachineWindow::cleanupMenu();
 }
 
@@ -251 +167 @@
     BOOL fEnabled = true;
     ULONG guestOriginX = 0, guestOriginY = 0, guestWidth = 0, guestHeight = 0;
-    session().GetMachine().QuerySavedGuestScreenInfo(m_uScreenId, guestOriginX, guestOriginY, guestWidth, guestHeight, fEnabled);
+    machine().QuerySavedGuestScreenInfo(m_uScreenId, guestOriginX, guestOriginY, guestWidth, guestHeight, fEnabled);
     if (fEnabled)
     {
@@ -268 +184 @@
 #ifdef Q_WS_MAC
         /* Make sure it is really on the right place (especially on the Mac): */
-        QRect r = QApplication::desktop()->screenGeometry(static_cast<UIMachineLogicFullscreen*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId));
+        QRect r = QApplication::desktop()->screenGeometry(qobject_cast<UIMachineLogicFullscreen*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId));
         move(r.topLeft());
 #endif /* Q_WS_MAC */
@@ -274 +190 @@
 }
 
+void UIMachineWindowFullscreen::updateAppearanceOf(int iElement)
+{
+    /* Call to base-class: */
+    UIMachineWindow::updateAppearanceOf(iElement);
+
+    /* Update mini-toolbar: */
+    if (iElement & UIVisualElement_MiniToolBar)
+    {
+        if (m_pMiniToolBar)
+        {
+            /* Get machine: */
+            const CMachine &m = machine();
+            /* Get snapshot(s): */
+            QString strSnapshotName;
+            if (m.GetSnapshotCount() > 0)
+            {
+                CSnapshot snapshot = m.GetCurrentSnapshot();
+                strSnapshotName = " (" + snapshot.GetName() + ")";
+            }
+            /* Update mini-toolbar text: */
+            m_pMiniToolBar->setDisplayText(m.GetName() + strSnapshotName);
+        }
+    }
+}
+

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

@@ -20 +20 @@
 #define __UIMachineWindowFullscreen_h__
 
-/* Local includes */
+/* Local includes: */
 #include "UIMachineWindow.h"
 
-/* Local forwards */
+/* Forward declarations: */
 class VBoxMiniToolBar;
 
+/* Fullscreen machine-window implementation: */
 class UIMachineWindowFullscreen : public UIMachineWindow
 {
     Q_OBJECT;
 
-public slots:
-
-    void sltPlaceOnScreen();
-
 protected:
 
-    /* Fullscreen machine window constructor/destructor: */
+    /* Constructor: */
     UIMachineWindowFullscreen(UIMachineLogic *pMachineLogic, ulong uScreenId);
-    virtual ~UIMachineWindowFullscreen();
 
 private slots:
 
-    /* Popup main menu: */
+    /* Session event-handlers: */
+    void sltMachineStateChanged();
+
+    /* Places window on screen: */
+    void sltPlaceOnScreen();
+
+    /* Popup main-menu: */
     void sltPopupMainMenu();
 
@@ -49 +51 @@
     /* Prepare helpers: */
     void prepareMenu();
-    void prepareMiniToolBar();
-    void prepareMachineView();
-    //void loadWindowSettings() {}
+    void prepareVisualState();
+    void prepareMiniToolbar();
 
     /* Cleanup helpers: */
-    void saveWindowSettings();
-    void cleanupMachineView();
-    void cleanupMiniToolBar();
+    void cleanupMiniToolbar();
+    void cleanupVisualState();
     void cleanupMenu();
 
-    /* Update routines: */
+    /* Show stuff: */
+    void showInNecessaryMode();
+
+    /* Update stuff: */
     void updateAppearanceOf(int iElement);
 
-    /* Other members: */
-    void showInNecessaryMode();
-
-    /* Private variables: */
+    /* Widgets: */
     QMenu *m_pMainMenu;
     VBoxMiniToolBar *m_pMiniToolBar;

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

@@ -101 +101 @@
     /* Create machine window(s): */
     for (ulong uScreenId = 0; uScreenId < uMonitorCount; ++ uScreenId)
-        addMachineWindow(UIMachineWindow::create(this, visualStateType(), uScreenId));
+        addMachineWindow(UIMachineWindow::create(this, uScreenId));
     /* Order machine window(s): */
     for (ulong uScreenId = uMonitorCount; uScreenId > 0; -- uScreenId)

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

@@ -18 +18 @@
  */
 
-/* Global includes */
+/* Global includes: */
 #include <QDesktopWidget>
 #include <QMenuBar>
@@ -24 +24 @@
 #include <QContextMenuEvent>
 
-/* Local includes */
+/* Local includes: */
 #include "VBoxGlobal.h"
 #include "UIMessageCenter.h"
 #include "VBoxUtils.h"
-
 #include "UISession.h"
 #include "UIActionPoolRuntime.h"
@@ -44 +43 @@
 # include "UIImageTools.h"
 #endif /* Q_WS_MAC */
-
 #include "QIStatusBar.h"
 #include "QIStateIndicator.h"
@@ -54 +52 @@
     , m_pIdleTimer(0)
 {
-    /* Set the main window in VBoxGlobal */
-    if (uScreenId == 0)
-        vboxGlobal().setMainWindow(this);
-
-    /* Prepare window icon: */
-    prepareWindowIcon();
-
-    /* Prepare console connections: */
-    prepareConsoleConnections();
-
-    /* Prepare menu: */
-    prepareMenu();
-
-    /* Prepare status bar: */
-    prepareStatusBar();
-
-    /* Prepare connections: */
-    prepareConnections();
-
-    /* Retranslate normal window finally: */
-    retranslateUi();
-
-    /* Prepare normal machine view container: */
-    prepareMachineViewContainer();
-
-    /* Prepare normal machine view: */
-    prepareMachineView();
-
-    /* Prepare handlers: */
-    prepareHandlers();
-
-    /* Load normal window settings: */
-    loadWindowSettings();
-
-    /* Update all the elements: */
-    updateAppearanceOf(UIVisualElement_AllStuff);
-
-#ifdef Q_WS_MAC
-    /* Beta label? */
-    if (vboxGlobal().isBeta())
-    {
-        QPixmap betaLabel = ::betaLabel(QSize(100, 16));
-        ::darwinLabelWindow(this, &betaLabel, true);
-    }
-#endif /* Q_WS_MAC */
-
-    /* Show normal window: */
-    showInNecessaryMode();
-}
-
-UIMachineWindowNormal::~UIMachineWindowNormal()
-{
-    /* Save normal window settings: */
-    saveWindowSettings();
-
-    /* Prepare handlers: */
-    cleanupHandlers();
-
-    /* Cleanup normal machine view: */
-    cleanupMachineView();
-
-    /* Cleanup status-bar: */
-    cleanupStatusBar();
 }
 
 void UIMachineWindowNormal::sltMachineStateChanged()
 {
+    /* Call to base-class: */
     UIMachineWindow::sltMachineStateChanged();
+
+    /* Update pause and virtualization stuff: */
     updateAppearanceOf(UIVisualElement_PauseStuff | UIVisualElement_VirtualizationStuff);
 }
@@ -127 +65 @@
 void UIMachineWindowNormal::sltMediumChange(const CMediumAttachment &attachment)
 {
+    /* Update corresponding medium stuff: */
     KDeviceType type = attachment.GetType();
     if (type == KDeviceType_HardDisk)
@@ -138 +77 @@
 void UIMachineWindowNormal::sltUSBControllerChange()
 {
+    /* Update USB stuff: */
     updateAppearanceOf(UIVisualElement_USBStuff);
 }
@@ -143 +83 @@
 void UIMachineWindowNormal::sltUSBDeviceStateChange()
 {
+    /* Update USB stuff: */
     updateAppearanceOf(UIVisualElement_USBStuff);
 }
@@ -148 +89 @@
 void UIMachineWindowNormal::sltNetworkAdapterChange()
 {
+    /* Update network stuff: */
     updateAppearanceOf(UIVisualElement_NetworkStuff);
 }
@@ -153 +95 @@
 void UIMachineWindowNormal::sltSharedFolderChange()
 {
+    /* Update shared-folders stuff: */
     updateAppearanceOf(UIVisualElement_SharedFolderStuff);
 }
@@ -158 +101 @@
 void UIMachineWindowNormal::sltCPUExecutionCapChange()
 {
+    /* Update virtualization stuff: */
     updateAppearanceOf(UIVisualElement_VirtualizationStuff);
 }
@@ -163 +107 @@
 void UIMachineWindowNormal::sltUpdateIndicators()
 {
+    /* Update LEDs: */
     updateIndicatorState(indicatorsPool()->indicator(UIIndicatorIndex_HardDisks), KDeviceType_HardDisk);
     updateIndicatorState(indicatorsPool()->indicator(UIIndicatorIndex_OpticalDisks), KDeviceType_DVD);
@@ -173 +118 @@
 void UIMachineWindowNormal::sltShowIndicatorsContextMenu(QIStateIndicator *pIndicator, QContextMenuEvent *pEvent)
 {
+    /* Show CD/DVD device LED context menu: */
     if (pIndicator == indicatorsPool()->indicator(UIIndicatorIndex_OpticalDisks))
     {
@@ -178 +124 @@
             gActionPool->action(UIActionIndexRuntime_Menu_OpticalDevices)->menu()->exec(pEvent->globalPos());
     }
+    /* Show floppy drive LED context menu: */
     else if (pIndicator == indicatorsPool()->indicator(UIIndicatorIndex_FloppyDisks))
     {
@@ -183 +130 @@
             gActionPool->action(UIActionIndexRuntime_Menu_FloppyDevices)->menu()->exec(pEvent->globalPos());
     }
+    /* Show USB device LED context menu: */
     else if (pIndicator == indicatorsPool()->indicator(UIIndicatorIndex_USBDevices))
     {
@@ -188 +136 @@
             gActionPool->action(UIActionIndexRuntime_Menu_USBDevices)->menu()->exec(pEvent->globalPos());
     }
+    /* Show network adapter LED context menu: */
     else if (pIndicator == indicatorsPool()->indicator(UIIndicatorIndex_NetworkAdapters))
     {
@@ -193 +142 @@
             gActionPool->action(UIActionIndexRuntime_Menu_NetworkAdapters)->menu()->exec(pEvent->globalPos());
     }
+    /* Show shared-folders LED context menu: */
     else if (pIndicator == indicatorsPool()->indicator(UIIndicatorIndex_SharedFolders))
     {
@@ -198 +148 @@
             gActionPool->action(UIActionIndexRuntime_Menu_SharedFolders)->menu()->exec(pEvent->globalPos());
     }
+    /* Show mouse LED context menu: */
     else if (pIndicator == indicatorsPool()->indicator(UIIndicatorIndex_Mouse))
     {
@@ -207 +158 @@
 void UIMachineWindowNormal::sltProcessGlobalSettingChange(const char * /* aPublicName */, const char * /* aName */)
 {
+    /* Update host-combination LED: */
     m_pNameHostkey->setText(UIHotKeyCombination::toReadableString(vboxGlobal().settings().hostCombo()));
 }
 
-void UIMachineWindowNormal::retranslateUi()
-{
-    /* Translate parent class: */
-    UIMachineWindow::retranslateUi();
-
-    m_pNameHostkey->setToolTip(
-        QApplication::translate("UIMachineWindowNormal", "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(UIHotKeyCombination::toReadableString(vboxGlobal().settings().hostCombo()));
-}
-
-void UIMachineWindowNormal::updateAppearanceOf(int iElement)
-{
-    /* Update parent-class window: */
-    UIMachineWindow::updateAppearanceOf(iElement);
-
-    /* Update that machine window: */
-    if (iElement & UIVisualElement_PauseStuff)
-    {
-        if (!statusBar()->isHidden())
-        {
-            if (uisession()->isPaused() && m_pIdleTimer->isActive())
-                m_pIdleTimer->stop();
-            else if (uisession()->isRunning() && !m_pIdleTimer->isActive())
-                m_pIdleTimer->start(100);
-            sltUpdateIndicators();
-        }
-    }
-    if (iElement & UIVisualElement_HDStuff)
-        indicatorsPool()->indicator(UIIndicatorIndex_HardDisks)->updateAppearance();
-    if (iElement & UIVisualElement_CDStuff)
-        indicatorsPool()->indicator(UIIndicatorIndex_OpticalDisks)->updateAppearance();
-    if (iElement & UIVisualElement_FDStuff)
-        indicatorsPool()->indicator(UIIndicatorIndex_FloppyDisks)->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)
-{
-    switch (pEvent->type())
-    {
-        case QEvent::Resize:
-        {
-            QResizeEvent *pResizeEvent = static_cast<QResizeEvent*>(pEvent);
-            if (!isMaximizedChecked())
-            {
-                m_normalGeometry.setSize(pResizeEvent->size());
-#ifdef VBOX_WITH_DEBUGGER_GUI
-                /* Update debugger window position */
-                updateDbgWindows();
-#endif
-            }
-            break;
-        }
-        case QEvent::Move:
-        {
-            if (!isMaximizedChecked())
-            {
-                m_normalGeometry.moveTo(geometry().x(), geometry().y());
-#ifdef VBOX_WITH_DEBUGGER_GUI
-                /* Update debugger window position */
-                updateDbgWindows();
-#endif
-            }
-            break;
-        }
-        default:
-            break;
-    }
-    return QIWithRetranslateUI2<QMainWindow>::event(pEvent);
-}
-
-void UIMachineWindowNormal::prepareConsoleConnections()
-{
-    /* Base-class connections: */
-    UIMachineWindow::prepareConsoleConnections();
+void UIMachineWindowNormal::prepareSessionConnections()
+{
+    /* Call to base-class: */
+    UIMachineWindow::prepareSessionConnections();
 
     /* Medium change updater: */
@@ -324 +194 @@
 void UIMachineWindowNormal::prepareMenu()
 {
+    /* Call to base-class: */
+    UIMachineWindow::prepareMenu();
+
+    /* Prepare menu-bar: */
     setMenuBar(uisession()->newMenuBar());
 }
@@ -329 +203 @@
 void UIMachineWindowNormal::prepareStatusBar()
 {
-    /* Common setup: */
+    /* Call to base-class: */
+    UIMachineWindow::prepareStatusBar();
+
+    /* Setup: */
     setStatusBar(new QIStatusBar(this));
     QWidget *pIndicatorBox = new QWidget;
@@ -393 +270 @@
     pHostkeyLedContainerLayout->addWidget(m_pNameHostkey);
 
-    /* Add to statusbar: */
+    /* Add to status-bar: */
     statusBar()->addPermanentWidget(pIndicatorBox, 0);
 
@@ -402 +279 @@
 
 #ifdef Q_WS_MAC
-    /* For the status bar on Cocoa: */
+    /* For the status-bar on Cocoa: */
     setUnifiedTitleAndToolBarOnMac(true);
-#endif
-}
-
-void UIMachineWindowNormal::prepareConnections()
-{
-    /* Setup global settings change updater: */
-    connect(&vboxGlobal().settings(), SIGNAL(propertyChanged(const char *, const char *)),
-            this, SLOT(sltProcessGlobalSettingChange(const char *, const char *)));
-}
-
-void UIMachineWindowNormal::prepareMachineView()
-{
-#ifdef VBOX_WITH_VIDEOHWACCEL
-    /* Need to force the QGL framebuffer in case 2D Video Acceleration is supported & enabled: */
-    bool bAccelerate2DVideo = session().GetMachine().GetAccelerate2DVideoEnabled() && VBoxGlobal::isAcceleration2DVideoAvailable();
-#endif
-
-    /* Set central widget: */
-    setCentralWidget(new QWidget);
-
-    /* Set central widget layout: */
-    centralWidget()->setLayout(m_pMachineViewContainer);
-
-    m_pMachineView = UIMachineView::create(  this
-                                           , m_uScreenId
-                                           , machineLogic()->visualStateType()
-#ifdef VBOX_WITH_VIDEOHWACCEL
-                                           , bAccelerate2DVideo
-#endif
-                                           );
-
-    /* Add machine view into layout: */
-    m_pMachineViewContainer->addWidget(m_pMachineView, 1, 1);
-
-    /* Setup machine view connections: */
-    if (machineView())
-    {
-        /* Keyboard state-change updater: */
-        connect(machineLogic()->keyboardHandler(), SIGNAL(keyboardStateChanged(int)), indicatorsPool()->indicator(UIIndicatorIndex_Hostkey), SLOT(setState(int)));
-
-        /* Mouse state-change updater: */
-        connect(machineLogic()->mouseHandler(), SIGNAL(mouseStateChanged(int)), indicatorsPool()->indicator(UIIndicatorIndex_Mouse), SLOT(setState(int)));
-
-        /* Early initialize required connections: */
-        indicatorsPool()->indicator(UIIndicatorIndex_Hostkey)->setState(machineLogic()->keyboardHandler()->keyboardState());
-        indicatorsPool()->indicator(UIIndicatorIndex_Mouse)->setState(machineLogic()->mouseHandler()->mouseState());
-    }
+#endif /* Q_WS_MAC */
+}
+
+void UIMachineWindowNormal::prepareVisualState()
+{
+    /* Call to base-class: */
+    UIMachineWindow::prepareVisualState();
 
 #ifdef VBOX_GUI_WITH_CUSTOMIZATIONS1
@@ -460 +297 @@
     setAutoFillBackground(true);
 #endif /* VBOX_GUI_WITH_CUSTOMIZATIONS1 */
-}
-
-void UIMachineWindowNormal::loadWindowSettings()
-{
-    /* Load normal window settings: */
-    CMachine machine = session().GetMachine();
+
+    /* Make sure host-combination LED will be updated: */
+    connect(&vboxGlobal().settings(), SIGNAL(propertyChanged(const char *, const char *)),
+            this, SLOT(sltProcessGlobalSettingChange(const char *, const char *)));
+
+#ifdef Q_WS_MAC
+    /* Beta label? */
+    if (vboxGlobal().isBeta())
+    {
+        QPixmap betaLabel = ::betaLabel(QSize(100, 16));
+        ::darwinLabelWindow(this, &betaLabel, true);
+    }
+#endif /* Q_WS_MAC */
+}
+
+void UIMachineWindowNormal::prepareHandlers()
+{
+    /* Call to base-class: */
+    UIMachineWindow::prepareHandlers();
+
+    /* Keyboard state-change updater: */
+    connect(machineLogic()->keyboardHandler(), SIGNAL(keyboardStateChanged(int)), indicatorsPool()->indicator(UIIndicatorIndex_Hostkey), SLOT(setState(int)));
+    /* Mouse state-change updater: */
+    connect(machineLogic()->mouseHandler(), SIGNAL(mouseStateChanged(int)), indicatorsPool()->indicator(UIIndicatorIndex_Mouse), SLOT(setState(int)));
+    /* Early initialize required connections: */
+    indicatorsPool()->indicator(UIIndicatorIndex_Hostkey)->setState(machineLogic()->keyboardHandler()->keyboardState());
+    indicatorsPool()->indicator(UIIndicatorIndex_Mouse)->setState(machineLogic()->mouseHandler()->mouseState());
+}
+
+void UIMachineWindowNormal::loadSettings()
+{
+    /* Call to base-class: */
+    UIMachineWindow::loadSettings();
+
+    /* Get machine: */
+    CMachine m = machine();
 
     /* Load extra-data settings: */
     {
+        /* Load window position settings: */
         QString strPositionAddress = m_uScreenId == 0 ? QString("%1").arg(VBoxDefs::GUI_LastNormalWindowPosition) :
                                      QString("%1%2").arg(VBoxDefs::GUI_LastNormalWindowPosition).arg(m_uScreenId);
-        QStringList strPositionSettings = machine.GetExtraDataStringList(strPositionAddress);
-
+        QStringList strPositionSettings = m.GetExtraDataStringList(strPositionAddress);
         bool ok = !strPositionSettings.isEmpty(), max = false;
         int x = 0, y = 0, w = 0, h = 0;
-
         if (ok && strPositionSettings.size() > 0)
             x = strPositionSettings[0].toInt(&ok);
@@ -490 +356 @@
         if (ok && strPositionSettings.size() > 4)
             max = strPositionSettings[4] == VBoxDefs::GUI_LastWindowState_Max;
-
         QRect ar = ok ? QApplication::desktop()->availableGeometry(QPoint(x, y)) :
                         QApplication::desktop()->availableGeometry(this);
@@ -498 +363 @@
         {
             /* If previous machine state is SAVED: */
-            if (machine.GetState() == KMachineState_Saved)
+            if (m.GetState() == KMachineState_Saved)
             {
                 /* Restore window size and position: */
@@ -504 +369 @@
                 setGeometry(m_normalGeometry);
             }
-            /* If previous machine state is not SAVED: */
+            /* If previous machine state was not SAVED: */
             else
             {
@@ -511 +376 @@
                 setGeometry(m_normalGeometry);
                 if (machineView())
-                    machineView()->normalizeGeometry(false /* adjust position? */);
+                    machineView()->normalizeGeometry(false);
             }
             /* Maximize if needed: */
@@ -521 +386 @@
             /* Normalize view early to the optimal size: */
             if (machineView())
-                machineView()->normalizeGeometry(true /* adjust position? */);
+                machineView()->normalizeGeometry(true);
             /* Move newly created window to the screen center: */
             m_normalGeometry = geometry();
@@ -528 +393 @@
         }
 
-        /* Normalize view to the optimal size:
-         * Note: Cause of the async behavior of X11 (at least GNOME) we have to delay this a little bit.
-         * On Mac OS X and MS Windows this is not necessary and create even wrong resize events.
-         * So there we set the geometry immediately. */
+        /* Normalize view to the optimal size: */
         if (machineView())
-#ifdef Q_WS_X11
-            QTimer::singleShot(0, machineView(), SLOT(sltNormalizeGeometry()));
-#else /* Q_WS_X11 */
             machineView()->normalizeGeometry(true);
-#endif /* !Q_WS_X11 */
     }
 
@@ -543 +401 @@
     {
         /* USB Stuff: */
-        const CUSBController &usbController = machine.GetUSBController();
+        const CUSBController &usbController = m.GetUSBController();
         if (    usbController.isNull()
             || !usbController.GetEnabled()
             || !usbController.GetProxyAvailable())
         {
-            /* Hide USB Menu: */
+            /* Hide USB menu: */
             indicatorsPool()->indicator(UIIndicatorIndex_USBDevices)->setHidden(true);
         }
@@ -569 +427 @@
 }
 
-void UIMachineWindowNormal::saveWindowSettings()
-{
-    CMachine machine = session().GetMachine();
+void UIMachineWindowNormal::saveSettings()
+{
+    /* Get machine: */
+    CMachine m = machine();
 
     /* Save extra-data settings: */
@@ -582 +441 @@
         QString strPositionAddress = m_uScreenId == 0 ? QString("%1").arg(VBoxDefs::GUI_LastNormalWindowPosition) :
                                      QString("%1%2").arg(VBoxDefs::GUI_LastNormalWindowPosition).arg(m_uScreenId);
-        machine.SetExtraData(strPositionAddress, strWindowPosition);
-    }
-}
-
-void UIMachineWindowNormal::cleanupMachineView()
-{
-    /* Do not cleanup machine view if it is not present: */
-    if (!machineView())
-        return;
-
-    UIMachineView::destroy(m_pMachineView);
-    m_pMachineView = 0;
+        m.SetExtraData(strPositionAddress, strWindowPosition);
+    }
+
+    /* Call to base-class: */
+    UIMachineWindow::saveSettings();
 }
 
@@ -601 +453 @@
     m_pIdleTimer->stop();
     m_pIdleTimer->disconnect(SIGNAL(timeout()), this, SLOT(sltUpdateIndicators()));
+
+    /* Call to base-class: */
+    UIMachineWindow::cleanupStatusBar();
+}
+
+void UIMachineWindowNormal::retranslateUi()
+{
+    /* Call to base-class: */
+    UIMachineWindow::retranslateUi();
+
+    /* Translate host-combo LED: */
+    m_pNameHostkey->setToolTip(
+        QApplication::translate("UIMachineWindowNormal", "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(UIHotKeyCombination::toReadableString(vboxGlobal().settings().hostCombo()));
+}
+
+bool UIMachineWindowNormal::event(QEvent *pEvent)
+{
+    switch (pEvent->type())
+    {
+        case QEvent::Resize:
+        {
+            QResizeEvent *pResizeEvent = static_cast<QResizeEvent*>(pEvent);
+            if (!isMaximizedChecked())
+            {
+                m_normalGeometry.setSize(pResizeEvent->size());
+#ifdef VBOX_WITH_DEBUGGER_GUI
+                /* Update debugger window position: */
+                updateDbgWindows();
+#endif /* VBOX_WITH_DEBUGGER_GUI */
+            }
+            break;
+        }
+        case QEvent::Move:
+        {
+            if (!isMaximizedChecked())
+            {
+                m_normalGeometry.moveTo(geometry().x(), geometry().y());
+#ifdef VBOX_WITH_DEBUGGER_GUI
+                /* Update debugger window position: */
+                updateDbgWindows();
+#endif /* VBOX_WITH_DEBUGGER_GUI */
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return UIMachineWindow::event(pEvent);
 }
 
@@ -608 +512 @@
     BOOL fEnabled = true;
     ULONG guestOriginX = 0, guestOriginY = 0, guestWidth = 0, guestHeight = 0;
-    session().GetMachine().QuerySavedGuestScreenInfo(m_uScreenId, guestOriginX, guestOriginY, guestWidth, guestHeight, fEnabled);
+    machine().QuerySavedGuestScreenInfo(m_uScreenId, guestOriginX, guestOriginY, guestWidth, guestHeight, fEnabled);
     if (fEnabled)
         show();
+}
+
+void UIMachineWindowNormal::updateAppearanceOf(int iElement)
+{
+    /* Call to base-class: */
+    UIMachineWindow::updateAppearanceOf(iElement);
+
+    /* Update machine window content: */
+    if (iElement & UIVisualElement_PauseStuff)
+    {
+        if (!statusBar()->isHidden())
+        {
+            if (uisession()->isPaused() && m_pIdleTimer->isActive())
+                m_pIdleTimer->stop();
+            else if (uisession()->isRunning() && !m_pIdleTimer->isActive())
+                m_pIdleTimer->start(100);
+            sltUpdateIndicators();
+        }
+    }
+    if (iElement & UIVisualElement_HDStuff)
+        indicatorsPool()->indicator(UIIndicatorIndex_HardDisks)->updateAppearance();
+    if (iElement & UIVisualElement_CDStuff)
+        indicatorsPool()->indicator(UIIndicatorIndex_OpticalDisks)->updateAppearance();
+    if (iElement & UIVisualElement_FDStuff)
+        indicatorsPool()->indicator(UIIndicatorIndex_FloppyDisks)->updateAppearance();
+    if (iElement & UIVisualElement_NetworkStuff)
+        indicatorsPool()->indicator(UIIndicatorIndex_NetworkAdapters)->updateAppearance();
+    if (iElement & UIVisualElement_USBStuff &&
+        !indicatorsPool()->indicator(UIIndicatorIndex_USBDevices)->isHidden())
+        indicatorsPool()->indicator(UIIndicatorIndex_USBDevices)->updateAppearance();
+    if (iElement & UIVisualElement_SharedFolderStuff)
+        indicatorsPool()->indicator(UIIndicatorIndex_SharedFolders)->updateAppearance();
+    if (iElement & UIVisualElement_VirtualizationStuff)
+        indicatorsPool()->indicator(UIIndicatorIndex_Virtualization)->updateAppearance();
 }
 

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

@@ -20 +20 @@
 #define __UIMachineWindowNormal_h__
 
-/* Global includes */
+/* Global includes: */
 #include <QLabel>
 
-/* Local includes */
+/* Local includes: */
 #include "UIMachineWindow.h"
 
-/* Local forwards */
+/* Forward declarations: */
 class CMediumAttachment;
 class UIIndicatorsPool;
 class QIStateIndicator;
 
+/* Normal machine-window implementation: */
 class UIMachineWindowNormal : public UIMachineWindow
 {
@@ -37 +38 @@
 protected:
 
-    /* Normal machine window constructor/destructor: */
+    /* Constructor: */
     UIMachineWindowNormal(UIMachineLogic *pMachineLogic, ulong uScreenId);
-    virtual ~UIMachineWindowNormal();
 
 private slots:
 
-    /* Console callback handlers: */
+    /* Session event-handlers: */
     void sltMachineStateChanged();
     void sltMediumChange(const CMediumAttachment &attachment);
@@ -59 +59 @@
 private:
 
-    /* Translate routine: */
-    void retranslateUi();
-
-    /* Update routines: */
-    void updateAppearanceOf(int aElement);
-
-    /* Event handlers: */
-    bool event(QEvent *pEvent);
-
-    /* Private getters: */
-    UIIndicatorsPool* indicatorsPool() { return m_pIndicatorsPool; }
-
     /* Prepare helpers: */
-    void prepareConsoleConnections();
+    void prepareSessionConnections();
     void prepareMenu();
     void prepareStatusBar();
-    void prepareConnections();
-    void prepareMachineView();
-    void loadWindowSettings();
+    void prepareVisualState();
+    void prepareHandlers();
+    void loadSettings();
 
     /* Cleanup helpers: */
-    void saveWindowSettings();
-    void cleanupMachineView();
-    //void cleanupConnections() {}
+    void saveSettings();
+    //void cleanupHandlers() {}
+    //coid cleanupVisualState() {}
     void cleanupStatusBar();
     //void cleanupMenu() {}
     //void cleanupConsoleConnections() {}
 
-    /* Other members: */
+    /* Translate stuff: */
+    void retranslateUi();
+
+    /* Show stuff: */
     void showInNecessaryMode();
+
+    /* Update stuff: */
+    void updateAppearanceOf(int aElement);
+
+    /* Event handler: */
+    bool event(QEvent *pEvent);
+
+    /* Helpers: */
+    UIIndicatorsPool* indicatorsPool() { return m_pIndicatorsPool; }
     bool isMaximizedChecked();
     void updateIndicatorState(QIStateIndicator *pIndicator, KDeviceType deviceType);
 
-    /* Indicators pool: */
+    /* Widgets: */
     UIIndicatorsPool *m_pIndicatorsPool;
-    /* Other QWidgets: */
     QWidget *m_pCntHostkey;
     QLabel *m_pNameHostkey;
-    /* Other QObjects: */
+
+    /* Variables: */
     QTimer *m_pIdleTimer;
-    /* Other members: */
     QRect m_normalGeometry;
 

trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineLogicScale.cpp

@@ -81 +81 @@
     /* Create machine window(s): */
     for (ulong uScreenId = 0; uScreenId < uMonitorCount; ++ uScreenId)
-        addMachineWindow(UIMachineWindow::create(this, visualStateType(), uScreenId));
+        addMachineWindow(UIMachineWindow::create(this, uScreenId));
     /* Order machine window(s): */
     for (ulong uScreenId = uMonitorCount; uScreenId > 0; -- uScreenId)

trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineWindowScale.cpp

@@ -18 +18 @@
  */
 
-/* Global includes */
+/* Global includes: */
 #include <QDesktopWidget>
-#include <QMenuBar>
 #include <QTimer>
 #include <QContextMenuEvent>
-
-/* Local includes */
+#ifdef Q_WS_MAC
+# include <QMenuBar>
+#endif /* Q_WS_MAC */
+
+/* Local includes: */
 #include "VBoxGlobal.h"
 #include "UIMessageCenter.h"
 #include "VBoxUtils.h"
-
 #include "UISession.h"
 #include "UIMachineLogic.h"
@@ -41 +42 @@
     , m_pMainMenu(0)
 {
-    /* Set the main window in VBoxGlobal */
-    if (uScreenId == 0)
-        vboxGlobal().setMainWindow(this);
-
-    /* Prepare window icon: */
-    prepareWindowIcon();
-
-    /* Prepare console connections: */
-    prepareConsoleConnections();
-
-    /* Prepare menu: */
-    prepareMenu();
-
-    /* Retranslate normal window finally: */
-    retranslateUi();
-
-    /* Prepare normal machine view container: */
-    prepareMachineViewContainer();
-
-    /* Prepare normal machine view: */
-    prepareMachineView();
-
-    /* Prepare handlers: */
-    prepareHandlers();
-
-    /* Load normal window settings: */
-    loadWindowSettings();
-
-    /* Update all the elements: */
-    updateAppearanceOf(UIVisualElement_AllStuff);
-
-#ifdef Q_WS_MAC
-    /* Install the resize delegate for keeping the aspect ratio. */
-    ::darwinInstallResizeDelegate(this);
-    /* Beta label? */
-    if (vboxGlobal().isBeta())
-    {
-        QPixmap betaLabel = ::betaLabel(QSize(100, 16));
-        ::darwinLabelWindow(this, &betaLabel, true);
-    }
-#endif /* Q_WS_MAC */
-
-    /* Show scaled window: */
-    showInNecessaryMode();
-}
-
-UIMachineWindowScale::~UIMachineWindowScale()
-{
-#ifdef Q_WS_MAC
-    /* Uninstall the resize delegate for keeping the aspect ratio. */
-    ::darwinUninstallResizeDelegate(this);
-#endif /* Q_WS_MAC */
-
-    /* Save normal window settings: */
-    saveWindowSettings();
-
-    /* Prepare handlers: */
-    cleanupHandlers();
-
-    /* Cleanup normal machine view: */
-    cleanupMachineView();
 }
 
 void UIMachineWindowScale::sltPopupMainMenu()
 {
-    /* Popup main menu if present: */
+    /* Popup main-menu if present: */
     if (m_pMainMenu && !m_pMainMenu->isEmpty())
     {
@@ -114 +54 @@
 }
 
-bool UIMachineWindowScale::event(QEvent *pEvent)
-{
-    switch (pEvent->type())
-    {
-        case QEvent::Resize:
-        {
-            QResizeEvent *pResizeEvent = static_cast<QResizeEvent*>(pEvent);
-            if (!isMaximizedChecked())
-            {
-                m_normalGeometry.setSize(pResizeEvent->size());
-#ifdef VBOX_WITH_DEBUGGER_GUI
-                /* Update debugger window position */
-                updateDbgWindows();
-#endif
-            }
-            break;
-        }
-        case QEvent::Move:
-        {
-            if (!isMaximizedChecked())
-            {
-                m_normalGeometry.moveTo(geometry().x(), geometry().y());
-#ifdef VBOX_WITH_DEBUGGER_GUI
-                /* Update debugger window position */
-                updateDbgWindows();
-#endif
-            }
-            break;
-        }
-        default:
-            break;
-    }
-    return QIWithRetranslateUI2<QMainWindow>::event(pEvent);
-}
-
-#ifdef Q_WS_WIN
-bool UIMachineWindowScale::winEvent(MSG *pMessage, long *pResult)
-{
-    /* Try to keep aspect ratio during window resize if:
-     * 1. machine view exists and 2. event-type is WM_SIZING and 3. shift key is NOT pressed: */
-    if (machineView() && pMessage->message == WM_SIZING && !(QApplication::keyboardModifiers() & Qt::ShiftModifier))
-    {
-        if (double dAspectRatio = machineView()->aspectRatio())
-        {
-            RECT *pRect = reinterpret_cast<RECT*>(pMessage->lParam);
-            switch (pMessage->wParam)
-            {
-                case WMSZ_LEFT:
-                case WMSZ_RIGHT:
-                {
-                    pRect->bottom = pRect->top + (double)(pRect->right - pRect->left) / dAspectRatio;
-                    break;
-                }
-                case WMSZ_TOP:
-                case WMSZ_BOTTOM:
-                {
-                    pRect->right = pRect->left + (double)(pRect->bottom - pRect->top) * dAspectRatio;
-                    break;
-                }
-                case WMSZ_BOTTOMLEFT:
-                case WMSZ_BOTTOMRIGHT:
-                {
-                    pRect->bottom = pRect->top + (double)(pRect->right - pRect->left) / dAspectRatio;
-                    break;
-                }
-                case WMSZ_TOPLEFT:
-                case WMSZ_TOPRIGHT:
-                {
-                    pRect->top = pRect->bottom - (double)(pRect->right - pRect->left) / dAspectRatio;
-                    break;
-                }
-                default:
-                    break;
-            }
-        }
-    }
-    /* Pass event to base-class: */
-    return QMainWindow::winEvent(pMessage, pResult);
-}
-#endif /* Q_WS_WIN */
-
-void UIMachineWindowScale::prepareMenu()
-{
-#ifdef Q_WS_MAC
-    setMenuBar(uisession()->newMenuBar());
-#endif /* Q_WS_MAC */
-    m_pMainMenu = uisession()->newMenu();
-}
-
-void UIMachineWindowScale::prepareMachineViewContainer()
-{
-    /* Call to base-class: */
-    UIMachineWindow::prepareMachineViewContainer();
+void UIMachineWindowScale::prepareMainLayout()
+{
+    /* Call to base-class: */
+    UIMachineWindow::prepareMainLayout();
 
     /* Strict spacers to hide them, they are not necessary for scale-mode: */
@@ -215 +66 @@
 }
 
-void UIMachineWindowScale::prepareMachineView()
-{
-#ifdef VBOX_WITH_VIDEOHWACCEL
-    /* Need to force the QGL framebuffer in case 2D Video Acceleration is supported & enabled: */
-    bool bAccelerate2DVideo = session().GetMachine().GetAccelerate2DVideoEnabled() && VBoxGlobal::isAcceleration2DVideoAvailable();
-#endif
-
-    /* Set central widget: */
-    setCentralWidget(new QWidget);
-
-    /* Set central widget layout: */
-    centralWidget()->setLayout(m_pMachineViewContainer);
-
-    m_pMachineView = UIMachineView::create(  this
-                                           , m_uScreenId
-                                           , machineLogic()->visualStateType()
-#ifdef VBOX_WITH_VIDEOHWACCEL
-                                           , bAccelerate2DVideo
-#endif
-                                           );
-
-    /* Add machine view into layout: */
-    m_pMachineViewContainer->addWidget(m_pMachineView, 1, 1);
-}
-
-void UIMachineWindowScale::loadWindowSettings()
-{
+void UIMachineWindowScale::prepareMenu()
+{
+    /* Call to base-class: */
+    UIMachineWindow::prepareMenu();
+
+#ifdef Q_WS_MAC
+    setMenuBar(uisession()->newMenuBar());
+#endif /* Q_WS_MAC */
+    m_pMainMenu = uisession()->newMenu();
+}
+
+#ifdef Q_WS_MAC
+void UIMachineWindowScale::prepareVisualState()
+{
+    /* Call to base-class: */
+    UIMachineWindow::prepareVisualState();
+
+    /* Install the resize delegate for keeping the aspect ratio. */
+    ::darwinInstallResizeDelegate(this);
+    /* Beta label? */
+    if (vboxGlobal().isBeta())
+    {
+        QPixmap betaLabel = ::betaLabel(QSize(100, 16));
+        ::darwinLabelWindow(this, &betaLabel, true);
+    }
+}
+#endif /* Q_WS_MAC */
+
+void UIMachineWindowScale::loadSettings()
+{
+    /* Call to base-class: */
+    UIMachineWindow::loadSettings();
+
     /* Load scale window settings: */
-    CMachine machine = session().GetMachine();
+    CMachine m = machine();
 
     /* Load extra-data settings: */
@@ -249 +106 @@
         QString strPositionAddress = m_uScreenId == 0 ? QString("%1").arg(VBoxDefs::GUI_LastScaleWindowPosition) :
                                      QString("%1%2").arg(VBoxDefs::GUI_LastScaleWindowPosition).arg(m_uScreenId);
-        QStringList strPositionSettings = machine.GetExtraDataStringList(strPositionAddress);
+        QStringList strPositionSettings = m.GetExtraDataStringList(strPositionAddress);
 
         bool ok = !strPositionSettings.isEmpty(), max = false;
@@ -295 +152 @@
 }
 
-void UIMachineWindowScale::saveWindowSettings()
-{
-    CMachine machine = session().GetMachine();
+void UIMachineWindowScale::saveSettings()
+{
+    /* Get machine: */
+    CMachine m = machine();
 
     /* Save extra-data settings: */
@@ -308 +166 @@
         QString strPositionAddress = m_uScreenId == 0 ? QString("%1").arg(VBoxDefs::GUI_LastScaleWindowPosition) :
                                      QString("%1%2").arg(VBoxDefs::GUI_LastScaleWindowPosition).arg(m_uScreenId);
-        machine.SetExtraData(strPositionAddress, strWindowPosition);
-    }
-}
-
-void UIMachineWindowScale::cleanupMachineView()
-{
-    /* Do not cleanup machine view if it is not present: */
-    if (!machineView())
-        return;
-
-    UIMachineView::destroy(m_pMachineView);
-    m_pMachineView = 0;
-}
+        m.SetExtraData(strPositionAddress, strWindowPosition);
+    }
+
+    /* Call to base-class: */
+    UIMachineWindow::saveSettings();
+}
+
+#ifdef Q_WS_MAC
+void UIMachineWindowScale::cleanupVisualState()
+{
+    /* Uninstall the resize delegate for keeping the aspect ratio. */
+    ::darwinUninstallResizeDelegate(this);
+
+    /* Call to base-class: */
+    UIMachineWindow::cleanupVisualState();
+}
+#endif /* Q_WS_MAC */
 
 void UIMachineWindowScale::cleanupMenu()
 {
+    /* Cleanup menu: */
     delete m_pMainMenu;
     m_pMainMenu = 0;
+
+    /* Call to base-class: */
+    UIMachineWindow::cleanupMenu();
 }
 
@@ -333 +199 @@
     BOOL fEnabled = true;
     ULONG guestOriginX = 0, guestOriginY = 0, guestWidth = 0, guestHeight = 0;
-    session().GetMachine().QuerySavedGuestScreenInfo(m_uScreenId, guestOriginX, guestOriginY, guestWidth, guestHeight, fEnabled);
+    machine().QuerySavedGuestScreenInfo(m_uScreenId, guestOriginX, guestOriginY, guestWidth, guestHeight, fEnabled);
     if (fEnabled)
         show();
 }
+
+bool UIMachineWindowScale::event(QEvent *pEvent)
+{
+    switch (pEvent->type())
+    {
+        case QEvent::Resize:
+        {
+            QResizeEvent *pResizeEvent = static_cast<QResizeEvent*>(pEvent);
+            if (!isMaximizedChecked())
+            {
+                m_normalGeometry.setSize(pResizeEvent->size());
+#ifdef VBOX_WITH_DEBUGGER_GUI
+                /* Update debugger window position: */
+                updateDbgWindows();
+#endif /* VBOX_WITH_DEBUGGER_GUI */
+            }
+            break;
+        }
+        case QEvent::Move:
+        {
+            if (!isMaximizedChecked())
+            {
+                m_normalGeometry.moveTo(geometry().x(), geometry().y());
+#ifdef VBOX_WITH_DEBUGGER_GUI
+                /* Update debugger window position: */
+                updateDbgWindows();
+#endif /* VBOX_WITH_DEBUGGER_GUI */
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return UIMachineWindow::event(pEvent);
+}
+
+#ifdef Q_WS_WIN
+bool UIMachineWindowScale::winEvent(MSG *pMessage, long *pResult)
+{
+    /* Try to keep aspect ratio during window resize if:
+     * 1. machine view exists and 2. event-type is WM_SIZING and 3. shift key is NOT pressed: */
+    if (machineView() && pMessage->message == WM_SIZING && !(QApplication::keyboardModifiers() & Qt::ShiftModifier))
+    {
+        if (double dAspectRatio = machineView()->aspectRatio())
+        {
+            RECT *pRect = reinterpret_cast<RECT*>(pMessage->lParam);
+            switch (pMessage->wParam)
+            {
+                case WMSZ_LEFT:
+                case WMSZ_RIGHT:
+                {
+                    pRect->bottom = pRect->top + (double)(pRect->right - pRect->left) / dAspectRatio;
+                    break;
+                }
+                case WMSZ_TOP:
+                case WMSZ_BOTTOM:
+                {
+                    pRect->right = pRect->left + (double)(pRect->bottom - pRect->top) * dAspectRatio;
+                    break;
+                }
+                case WMSZ_BOTTOMLEFT:
+                case WMSZ_BOTTOMRIGHT:
+                {
+                    pRect->bottom = pRect->top + (double)(pRect->right - pRect->left) / dAspectRatio;
+                    break;
+                }
+                case WMSZ_TOPLEFT:
+                case WMSZ_TOPRIGHT:
+                {
+                    pRect->top = pRect->bottom - (double)(pRect->right - pRect->left) / dAspectRatio;
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+    }
+    /* Call to base-class: */
+    return UIMachineWindow::winEvent(pMessage, pResult);
+}
+#endif /* Q_WS_WIN */
 
 bool UIMachineWindowScale::isMaximizedChecked()

trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineWindowScale.h

@@ -20 +20 @@
 #define __UIMachineWindowScale_h__
 
-/* Local includes */
+/* Local includes: */
 #include "UIMachineWindow.h"
 
+/* Scale machine-window implementation: */
 class UIMachineWindowScale : public UIMachineWindow
 {
@@ -29 +30 @@
 protected:
 
-    /* Scale machine window constructor/destructor: */
+    /* Constructor: */
     UIMachineWindowScale(UIMachineLogic *pMachineLogic, ulong uScreenId);
-    virtual ~UIMachineWindowScale();
 
 private slots:
 
-    /* Popup main menu: */
+    /* Popup main-menu: */
     void sltPopupMainMenu();
 
 private:
+
+    /* Prepare helpers: */
+    void prepareMainLayout();
+    void prepareMenu();
+#ifdef Q_WS_MAC
+    void prepareVisualState();
+#endif /* Q_WS_MAC */
+    void loadSettings();
+
+    /* Cleanup helpers: */
+    void saveSettings();
+#ifdef Q_WS_MAC
+    void cleanupVisualState();
+#endif /* Q_WS_MAC */
+    void cleanupMenu();
+    //void cleanupMainLayout() {}
+
+    /* Show stuff: */
+    void showInNecessaryMode();
 
     /* Event handlers: */
@@ -44 +63 @@
 #ifdef Q_WS_WIN
     bool winEvent(MSG *pMessage, long *pResult);
-#endif
+#endif /* Q_WS_WIN */
 
-    /* Prepare helpers: */
-    void prepareMenu();
-    void prepareMachineViewContainer();
-    void prepareMachineView();
-    void loadWindowSettings();
-
-    /* Cleanup helpers: */
-    void saveWindowSettings();
-    void cleanupMachineView();
-    //void cleanupMachineViewContainer() {}
-    void cleanupMenu();
-
-    /* Other members: */
-    void showInNecessaryMode();
+    /* Helpers: */
     bool isMaximizedChecked();
 
-    /* Other members: */
+    /* Widgets: */
     QMenu *m_pMainMenu;
+
+    /* Variables: */
     QRect m_normalGeometry;
 

trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineLogicSeamless.cpp

@@ -130 +130 @@
     /* Create machine window(s): */
     for (int cScreenId = 0; cScreenId < m_pScreenLayout->guestScreenCount(); ++cScreenId)
-        addMachineWindow(UIMachineWindow::create(this, visualStateType(), cScreenId));
+        addMachineWindow(UIMachineWindow::create(this, cScreenId));
 
     /* Connect screen-layout change handler: */

trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineWindowSeamless.cpp

@@ -18 +18 @@
  */
 
-/* Global includes */
+/* Global includes: */
 #include <QDesktopWidget>
 #include <QTimer>
@@ -25 +25 @@
 #endif /* Q_WS_MAC */
 
-/* Local includes */
+/* Local includes: */
 #include "VBoxGlobal.h"
 #ifndef Q_WS_MAC
 # include "VBoxMiniToolBar.h"
-#endif /* Q_WS_MAC */
-
+#endif /* !Q_WS_MAC */
 #include "UISession.h"
 #include "UIActionPoolRuntime.h"
@@ -36 +35 @@
 #include "UIMachineWindowSeamless.h"
 #include "UIMachineViewSeamless.h"
-
 #ifdef Q_WS_MAC
 # include "VBoxUtils.h"
@@ -46 +44 @@
 #ifndef Q_WS_MAC
     , m_pMiniToolBar(0)
-#endif /* Q_WS_MAC */
-{
-    /* Set the main window in VBoxGlobal: */
-    if (uScreenId == 0)
-        vboxGlobal().setMainWindow(this);
-
-    /* Prepare seamless window icon: */
-    prepareWindowIcon();
-
-    /* Prepare console connections: */
-    prepareConsoleConnections();
-
-    /* Prepare seamless window: */
-    prepareSeamless();
-
-    /* Prepare seamless menu: */
-    prepareMenu();
-
-    /* Prepare machine view container: */
-    prepareMachineViewContainer();
-
-    /* Prepare seamless machine view: */
-    prepareMachineView();
-
-    /* Prepare handlers: */
-    prepareHandlers();
-
-#ifndef Q_WS_MAC
-    /* Prepare mini tool-bar: */
-    prepareMiniToolBar();
-#endif /* Q_WS_MAC */
-
-    /* Retranslate fullscreen window finally: */
-    retranslateUi();
-
-#ifdef Q_WS_MAC
-    /* Load seamless window settings: */
-    loadWindowSettings();
-#endif /* Q_WS_MAC */
-
-    /* Update all the elements: */
-    updateAppearanceOf(UIVisualElement_AllStuff);
-
-    /* Show seamless window: */
-    showInNecessaryMode();
-}
-
-UIMachineWindowSeamless::~UIMachineWindowSeamless()
-{
-    /* Save window settings: */
-    saveWindowSettings();
-
-#ifndef Q_WS_MAC
-    /* Cleanup mini tool-bar: */
-    cleanupMiniToolBar();
-#endif /* Q_WS_MAC */
-
-    /* Prepare handlers: */
-    cleanupHandlers();
-
-    /* Cleanup machine view: */
-    cleanupMachineView();
-
-    /* Cleanup menu: */
-    cleanupMenu();
-}
+#endif /* !Q_WS_MAC */
+{
+}
+
+#ifndef Q_WS_MAC
+void UIMachineWindowSeamless::sltMachineStateChanged()
+{
+    /* Call to base-class: */
+    UIMachineWindow::sltMachineStateChanged();
+
+    /* Update mini-toolbar: */
+    updateAppearanceOf(UIVisualElement_MiniToolBar);
+}
+#endif /* !Q_WS_MAC */
 
 void UIMachineWindowSeamless::sltPlaceOnScreen()
 {
     /* Get corresponding screen: */
-    int iScreen = static_cast<UIMachineLogicSeamless*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
+    int iScreen = qobject_cast<UIMachineLogicSeamless*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
     /* Calculate working area: */
     QRect workingArea = vboxGlobal().availableGeometry(iScreen);
@@ -129 +75 @@
 void UIMachineWindowSeamless::sltPopupMainMenu()
 {
-    /* Popup main menu if present: */
+    /* Popup main-menu if present: */
     if (m_pMainMenu && !m_pMainMenu->isEmpty())
     {
@@ -140 +86 @@
 void UIMachineWindowSeamless::sltUpdateMiniToolBarMask()
 {
-    if (m_pMiniToolBar)
+    if (m_pMiniToolBar && machineView())
         setMask(qobject_cast<UIMachineViewSeamless*>(machineView())->lastVisibleRegion());
 }
-#endif /* Q_WS_MAC */
+#endif /* !Q_WS_MAC */
+
+void UIMachineWindowSeamless::prepareMenu()
+{
+    /* Call to base-class: */
+    UIMachineWindow::prepareMenu();
+
+    /* Prepare menu: */
+#ifdef Q_WS_MAC
+    setMenuBar(uisession()->newMenuBar());
+#endif /* Q_WS_MAC */
+    m_pMainMenu = uisession()->newMenu();
+}
+
+void UIMachineWindowSeamless::prepareVisualState()
+{
+    /* Call to base-class: */
+    UIMachineWindow::prepareVisualState();
+
+    /* This might be required to correctly mask: */
+    centralWidget()->setAutoFillBackground(false);
+
+#ifdef Q_WS_WIN
+    /* Get corresponding screen: */
+    int iScreen = qobject_cast<UIMachineLogicSeamless*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
+    /* Prepare previous region: */
+    m_prevRegion = vboxGlobal().availableGeometry(iScreen);
+#endif /* Q_WS_WIN */
+
+#ifdef Q_WS_MAC
+    /* Please note: All the stuff below has to be done after the window has
+     * switched to fullscreen. Qt changes the winId on the fullscreen
+     * switch and make this stuff useless with the old winId. So please be
+     * careful on rearrangement of the method calls. */
+    ::darwinSetShowsWindowTransparent(this, true);
+#endif /* Q_WS_MAC */
+
+#ifndef Q_WS_MAC
+    /* Prepare mini-toolbar: */
+    prepareMiniToolbar();
+#endif /* !Q_WS_MAC */
+}
+
+#ifndef Q_WS_MAC
+void UIMachineWindowSeamless::prepareMiniToolbar()
+{
+    /* Get machine: */
+    CMachine m = machine();
+
+    /* Make sure mini-toolbar is necessary: */
+    bool fIsActive = m.GetExtraData(VBoxDefs::GUI_ShowMiniToolBar) != "no";
+    if (!fIsActive)
+        return;
+
+    /* Get the mini-toolbar alignment: */
+    bool fIsAtTop = m.GetExtraData(VBoxDefs::GUI_MiniToolBarAlignment) == "top";
+    /* Get the mini-toolbar auto-hide feature availability: */
+    bool fIsAutoHide = m.GetExtraData(VBoxDefs::GUI_MiniToolBarAutoHide) != "off";
+    m_pMiniToolBar = new VBoxMiniToolBar(centralWidget(),
+                                         fIsAtTop ? VBoxMiniToolBar::AlignTop : VBoxMiniToolBar::AlignBottom,
+                                         true, fIsAutoHide);
+    m_pMiniToolBar->setSeamlessMode(true);
+    m_pMiniToolBar->updateDisplay(true, true);
+    QList<QMenu*> menus;
+    QList<QAction*> actions = uisession()->newMenu()->actions();
+    for (int i=0; i < actions.size(); ++i)
+        menus << actions.at(i)->menu();
+    *m_pMiniToolBar << menus;
+    connect(m_pMiniToolBar, SIGNAL(minimizeAction()), this, SLOT(showMinimized()));
+    connect(m_pMiniToolBar, SIGNAL(exitAction()),
+            gActionPool->action(UIActionIndexRuntime_Toggle_Seamless), SLOT(trigger()));
+    connect(m_pMiniToolBar, SIGNAL(closeAction()),
+            gActionPool->action(UIActionIndexRuntime_Simple_Close), SLOT(trigger()));
+    connect(m_pMiniToolBar, SIGNAL(geometryUpdated()), this, SLOT(sltUpdateMiniToolBarMask()));
+}
+#endif /* !Q_WS_MAC */
+
+#ifdef Q_WS_MAC
+void UIMachineWindowSeamless::loadSettings()
+{
+    /* Call to base-class: */
+    UIMachineWindow::loadSettings();
+
+    /* Load global settings: */
+    {
+        VBoxGlobalSettings settings = vboxGlobal().settings();
+        menuBar()->setHidden(settings.isFeatureActive("noMenuBar"));
+    }
+}
+#endif /* Q_WS_MAC */
+
+#ifndef Q_WS_MAC
+void UIMachineWindowSeamless::cleanupMiniToolbar()
+{
+    /* Make sure mini-toolbar was created: */
+    if (!m_pMiniToolBar)
+        return;
+
+    /* Save mini-toolbar settings: */
+    machine().SetExtraData(VBoxDefs::GUI_MiniToolBarAutoHide, m_pMiniToolBar->isAutoHide() ? QString() : "off");
+    /* Delete mini-toolbar: */
+    delete m_pMiniToolBar;
+    m_pMiniToolBar = 0;
+}
+#endif /* !Q_WS_MAC */
+
+void UIMachineWindowSeamless::cleanupVisualState()
+{
+#ifndef Q_WS_MAC
+    /* Cleeanup mini-toolbar: */
+    cleanupMiniToolbar();
+#endif /* !Q_WS_MAC */
+
+    /* Call to base-class: */
+    UIMachineWindow::cleanupVisualState();
+}
+
+void UIMachineWindowSeamless::cleanupMenu()
+{
+    /* Cleanup menu: */
+    delete m_pMainMenu;
+    m_pMainMenu = 0;
+
+    /* Call to base-class: */
+    UIMachineWindow::cleanupMenu();
+}
+
+void UIMachineWindowSeamless::showInNecessaryMode()
+{
+    /* Make sure we really have to show window: */
+    BOOL fEnabled = true;
+    ULONG guestOriginX = 0, guestOriginY = 0, guestWidth = 0, guestHeight = 0;
+    machine().QuerySavedGuestScreenInfo(m_uScreenId, guestOriginX, guestOriginY, guestWidth, guestHeight, fEnabled);
+    if (fEnabled)
+    {
+        /* Show manually maximized window: */
+        sltPlaceOnScreen();
+
+        /* Show normal window: */
+        show();
+
+#ifdef Q_WS_MAC
+        /* Make sure it is really on the right place (especially on the Mac): */
+        int iScreen = qobject_cast<UIMachineLogicSeamless*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
+        QRect r = vboxGlobal().availableGeometry(iScreen);
+        move(r.topLeft());
+#endif /* Q_WS_MAC */
+    }
+}
+
+#ifndef Q_WS_MAC
+void UIMachineWindowSeamless::updateAppearanceOf(int iElement)
+{
+    /* Call to base-class: */
+    UIMachineWindow::updateAppearanceOf(iElement);
+
+    /* Update mini-toolbar: */
+    if (iElement & UIVisualElement_MiniToolBar)
+    {
+        if (m_pMiniToolBar)
+        {
+            /* Get machine: */
+            const CMachine &m = machine();
+            /* Get snapshot(s): */
+            QString strSnapshotName;
+            if (m.GetSnapshotCount() > 0)
+            {
+                CSnapshot snapshot = m.GetCurrentSnapshot();
+                strSnapshotName = " (" + snapshot.GetName() + ")";
+            }
+            /* Update mini-toolbar text: */
+            m_pMiniToolBar->setDisplayText(m.GetName() + strSnapshotName);
+        }
+    }
+}
+#endif /* !Q_WS_MAC */
 
 #ifdef Q_WS_MAC
@@ -159 +280 @@
             break;
     }
-    return QMainWindow::event(pEvent);
-}
-#endif /* Q_WS_MAC */
-
-void UIMachineWindowSeamless::prepareSeamless()
-{
-#ifdef Q_WS_WIN
-    /* Get corresponding screen: */
-    int iScreen = static_cast<UIMachineLogicSeamless*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
-    /* Prepare previous region: */
-    m_prevRegion = vboxGlobal().availableGeometry(iScreen);
-#endif
-
-#ifdef Q_WS_MAC
-    /* Please note: All the stuff below has to be done after the window has
-     * switched to fullscreen. Qt changes the winId on the fullscreen
-     * switch and make this stuff useless with the old winId. So please be
-     * careful on rearrangement of the method calls. */
-    ::darwinSetShowsWindowTransparent(this, true);
-#endif
-}
-
-void UIMachineWindowSeamless::prepareMenu()
-{
-#ifdef Q_WS_MAC
-    setMenuBar(uisession()->newMenuBar());
-#endif /* Q_WS_MAC */
-    m_pMainMenu = uisession()->newMenu();
-}
-
-#ifndef Q_WS_MAC
-void UIMachineWindowSeamless::prepareMiniToolBar()
-{
-    /* Get current machine: */
-    CMachine machine = session().GetConsole().GetMachine();
-    /* Check if mini tool-bar should present: */
-    bool fIsActive = machine.GetExtraData(VBoxDefs::GUI_ShowMiniToolBar) != "no";
-    if (fIsActive)
-    {
-        /* Get the mini tool-bar alignment: */
-        bool fIsAtTop = machine.GetExtraData(VBoxDefs::GUI_MiniToolBarAlignment) == "top";
-        /* Get the mini tool-bar auto-hide feature availability: */
-        bool fIsAutoHide = machine.GetExtraData(VBoxDefs::GUI_MiniToolBarAutoHide) != "off";
-        m_pMiniToolBar = new VBoxMiniToolBar(centralWidget(),
-                                             fIsAtTop ? VBoxMiniToolBar::AlignTop : VBoxMiniToolBar::AlignBottom,
-                                             true, fIsAutoHide);
-        m_pMiniToolBar->setSeamlessMode(true);
-        m_pMiniToolBar->updateDisplay(true, true);
-        QList<QMenu*> menus;
-        QList<QAction*> actions = uisession()->newMenu()->actions();
-        for (int i=0; i < actions.size(); ++i)
-            menus << actions.at(i)->menu();
-        *m_pMiniToolBar << menus;
-        connect(m_pMiniToolBar, SIGNAL(minimizeAction()), this, SLOT(showMinimized()));
-        connect(m_pMiniToolBar, SIGNAL(exitAction()),
-                gActionPool->action(UIActionIndexRuntime_Toggle_Seamless), SLOT(trigger()));
-        connect(m_pMiniToolBar, SIGNAL(closeAction()),
-                gActionPool->action(UIActionIndexRuntime_Simple_Close), SLOT(trigger()));
-        connect(m_pMiniToolBar, SIGNAL(geometryUpdated()), this, SLOT(sltUpdateMiniToolBarMask()));
-    }
-}
-#endif /* Q_WS_MAC */
-
-void UIMachineWindowSeamless::prepareMachineView()
-{
-#ifdef VBOX_WITH_VIDEOHWACCEL
-    /* Need to force the QGL framebuffer in case 2D Video Acceleration is supported & enabled: */
-    bool bAccelerate2DVideo = session().GetMachine().GetAccelerate2DVideoEnabled() && VBoxGlobal::isAcceleration2DVideoAvailable();
-#endif
-
-    /* Set central widget: */
-    setCentralWidget(new QWidget);
-
-    /* Set central widget layout: */
-    centralWidget()->setLayout(m_pMachineViewContainer);
-
-    m_pMachineView = UIMachineView::create(  this
-                                           , m_uScreenId
-                                           , machineLogic()->visualStateType()
-#ifdef VBOX_WITH_VIDEOHWACCEL
-                                           , bAccelerate2DVideo
-#endif
-                                           );
-
-    /* Add machine view into layout: */
-    m_pMachineViewContainer->addWidget(m_pMachineView, 1, 1, Qt::AlignVCenter | Qt::AlignHCenter);
-
-    /* This might be required to correctly mask: */
-    centralWidget()->setAutoFillBackground(false);
-}
-
-#ifdef Q_WS_MAC
-void UIMachineWindowSeamless::loadWindowSettings()
-{
-    /* Load global settings: */
-    {
-        VBoxGlobalSettings settings = vboxGlobal().settings();
-        menuBar()->setHidden(settings.isFeatureActive("noMenuBar"));
-    }
-}
-#endif
-
-void UIMachineWindowSeamless::saveWindowSettings()
-{
-#ifndef Q_WS_MAC
-    /* Get machine: */
-    CMachine machine = session().GetConsole().GetMachine();
-
-    /* Save extra-data settings: */
-    {
-        /* Save mini tool-bar settings: */
-        if (m_pMiniToolBar)
-            machine.SetExtraData(VBoxDefs::GUI_MiniToolBarAutoHide, m_pMiniToolBar->isAutoHide() ? QString() : "off");
-    }
-#endif /* Q_WS_MAC */
-}
-
-void UIMachineWindowSeamless::cleanupMachineView()
-{
-    /* Do not cleanup machine view if it is not present: */
-    if (!machineView())
-        return;
-
-    UIMachineView::destroy(m_pMachineView);
-    m_pMachineView = 0;
-}
-
-#ifndef Q_WS_MAC
-void UIMachineWindowSeamless::cleanupMiniToolBar()
-{
-    if (m_pMiniToolBar)
-    {
-        delete m_pMiniToolBar;
-        m_pMiniToolBar = 0;
-    }
-}
-#endif /* Q_WS_MAC */
-
-void UIMachineWindowSeamless::cleanupMenu()
-{
-    delete m_pMainMenu;
-    m_pMainMenu = 0;
-}
-
-void UIMachineWindowSeamless::updateAppearanceOf(int iElement)
-{
-    /* Base class update: */
-    UIMachineWindow::updateAppearanceOf(iElement);
-
-    /* If mini tool-bar is present: */
-#ifndef Q_WS_MAC
-    if (m_pMiniToolBar)
-    {
-        /* Get machine: */
-        CMachine machine = session().GetConsole().GetMachine();
-        /* Get snapshot(s): */
-        QString strSnapshotName;
-        if (machine.GetSnapshotCount() > 0)
-        {
-            CSnapshot snapshot = machine.GetCurrentSnapshot();
-            strSnapshotName = " (" + snapshot.GetName() + ")";
-        }
-        /* Update mini tool-bar text: */
-        m_pMiniToolBar->setDisplayText(machine.GetName() + strSnapshotName);
-    }
-#endif /* Q_WS_MAC */
-}
-
-void UIMachineWindowSeamless::showInNecessaryMode()
-{
-    /* Make sure we really have to show window: */
-    BOOL fEnabled = true;
-    ULONG guestOriginX = 0, guestOriginY = 0, guestWidth = 0, guestHeight = 0;
-    session().GetMachine().QuerySavedGuestScreenInfo(m_uScreenId, guestOriginX, guestOriginY, guestWidth, guestHeight, fEnabled);
-    if (fEnabled)
-    {
-        /* Show manually maximized window: */
-        sltPlaceOnScreen();
-
-        /* Show normal window: */
-        show();
-
-#ifdef Q_WS_MAC
-        /* Make sure it is really on the right place (especially on the Mac): */
-        int iScreen = static_cast<UIMachineLogicSeamless*>(machineLogic())->hostScreenForGuestScreen(m_uScreenId);
-        QRect r = vboxGlobal().availableGeometry(iScreen);
-        move(r.topLeft());
-#endif /* Q_WS_MAC */
-    }
-}
+    return UIMachineWindow::event(pEvent);
+}
+#endif /* Q_WS_MAC */
 
 void UIMachineWindowSeamless::setMask(const QRegion &constRegion)
@@ -373 +307 @@
         toolBarRegion.translate(QPoint(m_pMiniToolBar->x(), m_pMiniToolBar->y()));
 
-        /* Including mini tool-bar mask: */
+        /* Including mini-toolbar mask: */
         region += toolBarRegion;
     }
-#endif /* Q_WS_MAC */
+#endif /* !Q_WS_MAC */
 
 #if 0 // TODO: Is it really needed now?
@@ -405 +339 @@
     SetWindowRgn(winId(), newReg, FALSE);
     RedrawWindow(0, 0, diffReg, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ALLCHILDREN);
-    RedrawWindow(machineView()->viewport()->winId(), 0, 0, RDW_INVALIDATE);
+    if (machineView())
+        RedrawWindow(machineView()->viewport()->winId(), 0, 0, RDW_INVALIDATE);
 
     m_prevRegion = region;
@@ -436 +371 @@
         // /* Now force the reshaping of the window. This is definitely necessary. */
         // ReshapeCustomWindow (reinterpret_cast <WindowPtr> (winId()));
-        QMainWindow::setMask(region);
+        UIMachineWindow::setMask(region);
         // HIWindowInvalidateShadow (::darwinToWindowRef (mConsole->viewport()));
     }
 #else
-    QMainWindow::setMask(region);
+    UIMachineWindow::setMask(region);
 #endif
 }

trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineWindowSeamless.h

@@ -20 +20 @@
 #define __UIMachineWindowSeamless_h__
 
-/* Local includes */
+/* Local includes: */
 #include "UIMachineWindow.h"
 
-/* Local forwards */
+/* Forward declarations: */
 class VBoxMiniToolBar;
 
+/* Seamless machine-window implementation: */
 class UIMachineWindowSeamless : public UIMachineWindow
 {
     Q_OBJECT;
 
-public slots:
-
-    void sltPlaceOnScreen();
-
 protected:
 
-    /* Seamless machine window constructor/destructor: */
+    /* Constructor: */
     UIMachineWindowSeamless(UIMachineLogic *pMachineLogic, ulong uScreenId);
-    virtual ~UIMachineWindowSeamless();
 
 private slots:
+
+#ifndef Q_WS_MAC
+    /* Session event-handlers: */
+    void sltMachineStateChanged();
+#endif /* !Q_WS_MAC */
+
+    /* Places window on screen: */
+    void sltPlaceOnScreen();
 
     /* Popup main menu: */
     void sltPopupMainMenu();
 
-#ifndef RT_OS_DARWIN /* Something is *really* broken in regards of the moc here */
+#ifndef Q_WS_MAC
     /* Update mini tool-bar mask: */
     void sltUpdateMiniToolBarMask();
-#endif /* RT_OS_DARWIN */
+#endif /* !Q_WS_MAC */
 
 private:
 
+    /* Prepare helpers: */
+    void prepareMenu();
+    void prepareVisualState();
+#ifndef Q_WS_MAC
+    void prepareMiniToolbar();
+#endif /* !Q_WS_MAC */
+#ifdef Q_WS_MAC
+    void loadSettings();
+#endif /* Q_WS_MAC */
+
+    /* Cleanup helpers: */
+#ifdef Q_WS_MAC
+    //void saveSettings() {}
+#endif /* Q_WS_MAC */
+#ifndef Q_WS_MAC
+    void cleanupMiniToolbar();
+#endif /* !Q_WS_MAC */
+    void cleanupVisualState();
+    void cleanupMenu();
+
+    /* Show stuff: */
+    void showInNecessaryMode();
+
+#ifndef Q_WS_MAC
+    /* Update routines: */
+    void updateAppearanceOf(int iElement);
+#endif /* !Q_WS_MAC */
+
+#ifdef Q_WS_MAC
     /* Event handlers: */
-#ifdef Q_WS_MAC
     bool event(QEvent *pEvent);
 #endif /* Q_WS_MAC */
 
-    /* Prepare helpers: */
-    void prepareSeamless();
-    void prepareMenu();
-#ifndef Q_WS_MAC
-    void prepareMiniToolBar();
-#endif /* Q_WS_MAC */
-    void prepareMachineView();
-#ifdef Q_WS_MAC
-    void loadWindowSettings();
-#endif /* Q_WS_MAC */
-
-    /* Cleanup helpers: */
-    void saveWindowSettings();
-    void cleanupMachineView();
-#ifndef Q_WS_MAC
-    void cleanupMiniToolBar();
-#endif /* Q_WS_MAC */
-    void cleanupMenu();
-    //void cleanupSeamless() {}
-
-    /* Update routines: */
-    void updateAppearanceOf(int iElement);
-
-    /* Other members: */
-    void showInNecessaryMode();
+    /* Helpers: */
     void setMask(const QRegion &region);
 
-    /* Private variables: */
+    /* Widgets: */
     QMenu *m_pMainMenu;
 #ifndef Q_WS_MAC
     VBoxMiniToolBar *m_pMiniToolBar;
-#endif /* Q_WS_MAC */
+#endif /* !Q_WS_MAC */
+
+    /* Variables: */
 #ifdef Q_WS_WIN
     QRegion m_prevRegion;