Changeset 98037 in vbox

Timestamp:

Jan 10, 2023 11:04:46 AM (23 months ago)

Author:

vboxsync

Message:

FE/Qt: Runtime UI: Get rid of friend classes, part #1 (general interfaces).

Location:

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

Files:

• UIMachineLogic.cpp (modified) (2 diffs)
• UIMachineLogic.h (modified) (3 diffs)
• UIMachineView.cpp (modified) (10 diffs)
• UIMachineView.h (modified) (10 diffs)
• UIMachineWindow.cpp (modified) (2 diffs)
• UIMachineWindow.h (modified) (4 diffs)

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

@@ -2770 +2770 @@
 }
 
+#ifdef VBOX_WITH_DEBUGGER_GUI
+void UIMachineLogic::dbgAdjustRelativePos()
+{
+    if (m_pDbgGui)
+    {
+        const QRect rct = activeMachineWindow()->frameGeometry();
+        m_pDbgGuiVT->pfnAdjustRelativePos(m_pDbgGui, rct.x(), rct.y(), rct.width(), rct.height());
+    }
+}
+#endif /* VBOX_WITH_DEBUGGER_GUI */
+
 void UIMachineLogic::updateMenuDevicesStorage(QMenu *pMenu)
 {
@@ -3363 +3374 @@
     }
 }
-
-void UIMachineLogic::dbgAdjustRelativePos()
-{
-    if (m_pDbgGui)
-    {
-        QRect rct = activeMachineWindow()->frameGeometry();
-        m_pDbgGuiVT->pfnAdjustRelativePos(m_pDbgGui, rct.x(), rct.y(), rct.width(), rct.height());
-    }
-}
 #endif /* VBOX_WITH_DEBUGGER_GUI */
 

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

@@ -156 +156 @@
     void typeHostKeyComboPressRelease(bool fToggleSequence);
 
+#ifdef VBOX_WITH_DEBUGGER_GUI
+    /** Adjusts relative position for debugger window. */
+    void dbgAdjustRelativePos();
+#endif /* VBOX_WITH_DEBUGGER_GUI */
+
 protected slots:
 
@@ -421 +426 @@
     bool dbgCreated();
     void dbgDestroy();
-    void dbgAdjustRelativePos();
     /* The handle to the debugger GUI: */
     PDBGGUI m_pDbgGui;
@@ -459 +463 @@
     QVector<X11ScreenSaverInhibitMethod*> m_methods;
 #endif
-    /* Friend classes: */
-    friend class UIMachineWindow;
 };
 

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

@@ -261 +261 @@
 }
 
+UISession *UIMachineView::uisession() const
+{
+    return machineWindow()->uisession();
+}
+
+UIMachineLogic *UIMachineView::machineLogic() const
+{
+    return machineWindow()->machineLogic();
+}
+
+int UIMachineView::contentsWidth() const
+{
+    return frameBuffer()->width();
+}
+
+int UIMachineView::contentsHeight() const
+{
+    return frameBuffer()->height();
+}
+
+int UIMachineView::contentsX() const
+{
+    return horizontalScrollBar()->value();
+}
+
+int UIMachineView::contentsY() const
+{
+    return verticalScrollBar()->value();
+}
+
+int UIMachineView::visibleWidth() const
+{
+    return horizontalScrollBar()->pageStep();
+}
+
+int UIMachineView::visibleHeight() const
+{
+    return verticalScrollBar()->pageStep();
+}
+
+QPoint UIMachineView::viewportToContents(const QPoint &viewportPoint) const
+{
+    /* Get physical contents shifts of scroll-bars: */
+    int iContentsX = contentsX();
+    int iContentsY = contentsY();
+
+    /* Take the device-pixel-ratio into account: */
+    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
+    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
+    if (!frameBuffer()->useUnscaledHiDPIOutput())
+    {
+        iContentsX *= dDevicePixelRatioActual;
+        iContentsY *= dDevicePixelRatioActual;
+    }
+    iContentsX /= dDevicePixelRatioFormal;
+    iContentsY /= dDevicePixelRatioFormal;
+
+    /* Return point shifted according scroll-bars: */
+    return QPoint(viewportPoint.x() + iContentsX, viewportPoint.y() + iContentsY);
+}
+
+void UIMachineView::scrollBy(int iDx, int iDy)
+{
+    horizontalScrollBar()->setValue(horizontalScrollBar()->value() + iDx);
+    verticalScrollBar()->setValue(verticalScrollBar()->value() + iDy);
+}
+
+UIVisualStateType UIMachineView::visualStateType() const
+{
+    return machineLogic()->visualStateType();
+}
+
 double UIMachineView::aspectRatio() const
 {
@@ -266 +338 @@
 }
 
+void UIMachineView::setMaximumGuestSize(const QSize &minimumSizeHint /* = QSize() */)
+{
+    QSize maxSize;
+    switch (m_enmMaximumGuestScreenSizePolicy)
+    {
+        case MaximumGuestScreenSizePolicy_Fixed:
+            maxSize = m_fixedMaxGuestSize;
+            break;
+        case MaximumGuestScreenSizePolicy_Automatic:
+            maxSize = calculateMaxGuestSize().expandedTo(minimumSizeHint);
+            break;
+        case MaximumGuestScreenSizePolicy_Any:
+            /* (0, 0) means any of course. */
+            maxSize = QSize(0, 0);
+    }
+    ASMAtomicWriteU64(&m_u64MaximumGuestSize,
+                      RT_MAKE_U64(maxSize.height(), maxSize.width()));
+}
+
+QSize UIMachineView::maximumGuestSize()
+{
+    uint64_t u64Size = ASMAtomicReadU64(&m_u64MaximumGuestSize);
+    return QSize(int(RT_HI_U32(u64Size)), int(RT_LO_U32(u64Size)));
+}
+
 void UIMachineView::updateViewport()
 {
     display().ViewportChanged(screenId(), contentsX(), contentsY(), visibleWidth(), visibleHeight());
+}
+
+#ifdef VBOX_WITH_DRAG_AND_DROP
+int UIMachineView::dragCheckPending()
+{
+    int rc;
+
+    if (!dragAndDropIsActive())
+        rc = VERR_ACCESS_DENIED;
+# ifdef VBOX_WITH_DRAG_AND_DROP_GH
+    else if (!m_fIsDraggingFromGuest)
+    {
+        /// @todo Add guest->guest DnD functionality here by getting
+        //       the source of guest B (when copying from B to A).
+        rc = m_pDnDHandler->dragCheckPending(screenId());
+        if (RT_SUCCESS(rc))
+            m_fIsDraggingFromGuest = true;
+    }
+    else /* Already dragging, so report success. */
+        rc = VINF_SUCCESS;
+# else
+    rc = VERR_NOT_SUPPORTED;
+# endif
+
+    DNDDEBUG(("DnD: dragCheckPending ended with rc=%Rrc\n", rc));
+    return rc;
+}
+
+int UIMachineView::dragStart()
+{
+    int rc;
+
+    if (!dragAndDropIsActive())
+        rc = VERR_ACCESS_DENIED;
+# ifdef VBOX_WITH_DRAG_AND_DROP_GH
+    else if (!m_fIsDraggingFromGuest)
+        rc = VERR_WRONG_ORDER;
+    else
+    {
+        /// @todo Add guest->guest DnD functionality here by getting
+        //       the source of guest B (when copying from B to A).
+        rc = m_pDnDHandler->dragStart(screenId());
+
+        m_fIsDraggingFromGuest = false;
+    }
+# else
+    rc = VERR_NOT_SUPPORTED;
+# endif
+
+    DNDDEBUG(("DnD: dragStart ended with rc=%Rrc\n", rc));
+    return rc;
+}
+
+int UIMachineView::dragStop()
+{
+    int rc;
+
+    if (!dragAndDropIsActive())
+        rc = VERR_ACCESS_DENIED;
+# ifdef VBOX_WITH_DRAG_AND_DROP_GH
+    else if (!m_fIsDraggingFromGuest)
+        rc = VERR_WRONG_ORDER;
+    else
+        rc = m_pDnDHandler->dragStop(screenId());
+# else
+    rc = VERR_NOT_SUPPORTED;
+# endif
+
+    DNDDEBUG(("DnD: dragStop ended with rc=%Rrc\n", rc));
+    return rc;
+}
+#endif /* VBOX_WITH_DRAG_AND_DROP */
+
+bool UIMachineView::nativeEventPreprocessor(const QByteArray &eventType, void *pMessage)
+{
+    /* Check if some event should be filtered out.
+     * Returning @c true means filtering-out,
+     * Returning @c false means passing event to Qt. */
+
+# if defined(VBOX_WS_MAC)
+
+    /* Make sure it's generic NSEvent: */
+    if (eventType != "mac_generic_NSEvent")
+        return false;
+    EventRef event = static_cast<EventRef>(darwinCocoaToCarbonEvent(pMessage));
+
+    switch (::GetEventClass(event))
+    {
+        // Keep in mind that this stuff should not be enabled while we are still using
+        // own native keyboard filter installed through cocoa API, to be reworked.
+        // S.a. registerForNativeEvents call in UIKeyboardHandler implementation.
+#if 0
+        /* Watch for keyboard-events: */
+        case kEventClassKeyboard:
+        {
+            switch (::GetEventKind(event))
+            {
+                /* Watch for key-events: */
+                case kEventRawKeyDown:
+                case kEventRawKeyRepeat:
+                case kEventRawKeyUp:
+                case kEventRawKeyModifiersChanged:
+                {
+                    /* Delegate key-event handling to the keyboard-handler: */
+                    return machineLogic()->keyboardHandler()->nativeEventFilter(pMessage, screenId());
+                }
+                default:
+                    break;
+            }
+            break;
+        }
+#endif
+        /* Watch for mouse-events: */
+        case kEventClassMouse:
+        {
+            switch (::GetEventKind(event))
+            {
+                /* Watch for button-events: */
+                case kEventMouseDown:
+                case kEventMouseUp:
+                {
+                    /* Delegate button-event handling to the mouse-handler: */
+                    return machineLogic()->mouseHandler()->nativeEventFilter(pMessage, screenId());
+                }
+                default:
+                    break;
+            }
+            break;
+        }
+        default:
+            break;
+    }
+
+# elif defined(VBOX_WS_WIN)
+
+    /* Make sure it's generic MSG event: */
+    if (eventType != "windows_generic_MSG")
+        return false;
+    MSG *pEvent = static_cast<MSG*>(pMessage);
+
+    switch (pEvent->message)
+    {
+        /* Watch for key-events: */
+        case WM_KEYDOWN:
+        case WM_SYSKEYDOWN:
+        case WM_KEYUP:
+        case WM_SYSKEYUP:
+        {
+            // WORKAROUND:
+            // There is an issue in the Windows Qt5 event processing sequence
+            // causing QAbstractNativeEventFilter to receive Windows native events
+            // coming not just to the top-level window but to actual target as well.
+            // They are calling one - "global event" and another one - "context event".
+            // That way native events are always duplicated with almost no possibility
+            // to distinguish copies except the fact that synthetic event always have
+            // time set to 0 (actually that field was not initialized at all, we had
+            // fixed that in our private Qt tool). We should skip such events instantly.
+            if (pEvent->time == 0)
+                return false;
+
+            /* Delegate key-event handling to the keyboard-handler: */
+            return machineLogic()->keyboardHandler()->nativeEventFilter(pMessage, screenId());
+        }
+        default:
+            break;
+    }
+
+# elif defined(VBOX_WS_X11)
+
+    /* Make sure it's generic XCB event: */
+    if (eventType != "xcb_generic_event_t")
+        return false;
+    xcb_generic_event_t *pEvent = static_cast<xcb_generic_event_t*>(pMessage);
+
+    switch (pEvent->response_type & ~0x80)
+    {
+        /* Watch for key-events: */
+        case XCB_KEY_PRESS:
+        case XCB_KEY_RELEASE:
+        {
+            /* Delegate key-event handling to the keyboard-handler: */
+            return machineLogic()->keyboardHandler()->nativeEventFilter(pMessage, screenId());
+        }
+        /* Watch for button-events: */
+        case XCB_BUTTON_PRESS:
+        case XCB_BUTTON_RELEASE:
+        {
+            /* Delegate button-event handling to the mouse-handler: */
+            return machineLogic()->mouseHandler()->nativeEventFilter(pMessage, screenId());
+        }
+        default:
+            break;
+    }
+
+# else
+
+#  warning "port me!"
+
+# endif
+
+    /* Filter nothing by default: */
+    return false;
+}
+
+void UIMachineView::sltHandleNotifyChange(int iWidth, int iHeight)
+{
+    /* Sanity check: */
+    if (!frameBuffer())
+        return;
+
+    LogRel2(("GUI: UIMachineView::sltHandleNotifyChange: Screen=%d, Size=%dx%d\n",
+             (unsigned long)m_uScreenId, iWidth, iHeight));
+
+    /* Some situations require frame-buffer resize-events to be ignored at all,
+     * leaving machine-window, machine-view and frame-buffer sizes preserved: */
+    if (uisession()->isGuestResizeIgnored())
+        return;
+
+    /* In some situations especially in some VM states, guest-screen is not drawable: */
+    if (uisession()->isGuestScreenUnDrawable())
+        return;
+
+    /* Get old frame-buffer size: */
+    const QSize frameBufferSizeOld = QSize(frameBuffer()->width(),
+                                           frameBuffer()->height());
+
+    /* Perform frame-buffer mode-change: */
+    frameBuffer()->handleNotifyChange(iWidth, iHeight);
+
+    /* Get new frame-buffer size: */
+    const QSize frameBufferSizeNew = QSize(frameBuffer()->width(),
+                                           frameBuffer()->height());
+
+    /* For 'scale' mode: */
+    if (visualStateType() == UIVisualStateType_Scale)
+    {
+        /* Assign new frame-buffer logical-size: */
+        QSize scaledSize = size();
+        const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
+        const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
+        scaledSize *= dDevicePixelRatioFormal;
+        if (!frameBuffer()->useUnscaledHiDPIOutput())
+            scaledSize /= dDevicePixelRatioActual;
+        frameBuffer()->setScaledSize(scaledSize);
+
+        /* Forget the last full-screen size: */
+        uisession()->setLastFullScreenSize(screenId(), QSize(-1, -1));
+    }
+    /* For other than 'scale' mode: */
+    else
+    {
+        /* Adjust maximum-size restriction for machine-view: */
+        setMaximumSize(sizeHint());
+
+        /* Disable the resize hint override hack and forget the last full-screen size: */
+        m_sizeHintOverride = QSize(-1, -1);
+        if (visualStateType() == UIVisualStateType_Normal)
+            uisession()->setLastFullScreenSize(screenId(), QSize(-1, -1));
+
+        /* Force machine-window update own layout: */
+        QCoreApplication::sendPostedEvents(0, QEvent::LayoutRequest);
+
+        /* Update machine-view sliders: */
+        updateSliders();
+
+        /* By some reason Win host forgets to update machine-window central-widget
+         * after main-layout was updated, let's do it for all the hosts: */
+        machineWindow()->centralWidget()->update();
+
+        /* Normalize 'normal' machine-window geometry if necessary: */
+        if (visualStateType() == UIVisualStateType_Normal &&
+            frameBufferSizeNew != frameBufferSizeOld)
+            machineWindow()->normalizeGeometry(true /* adjust position */, machineWindow()->shouldResizeToGuestDisplay());
+    }
+
+    /* Perform frame-buffer rescaling: */
+    frameBuffer()->performRescale();
+
+#ifdef VBOX_WS_MAC
+    /* Update MacOS X dock icon size: */
+    machineLogic()->updateDockIconSize(screenId(), frameBufferSizeNew.width(), frameBufferSizeNew.height());
+#endif /* VBOX_WS_MAC */
+
+    /* Notify frame-buffer resize: */
+    emit sigFrameBufferResize();
+
+    /* Ask for just required guest display update (it will also update
+     * the viewport through IFramebuffer::NotifyUpdate): */
+    display().InvalidateAndUpdateScreen(m_uScreenId);
+
+    /* If we are in normal or scaled mode and if GA are active,
+     * remember the guest-screen size to be able to restore it when necessary: */
+    /* As machines with Linux/Solaris and VMSVGA are not able to tell us
+     * whether a resize was due to the system or user interaction we currently
+     * do not store hints for these systems except when we explicitly send them
+     * ourselves.  Windows guests should use VBoxVGA controllers, not VMSVGA. */
+    if (   !isFullscreenOrSeamless()
+        && uisession()->isGuestSupportsGraphics()
+        && (machine().GetGraphicsAdapter().GetGraphicsControllerType() != KGraphicsControllerType_VMSVGA))
+        setStoredGuestScreenSizeHint(frameBufferSizeNew);
+
+    LogRel2(("GUI: UIMachineView::sltHandleNotifyChange: Complete for Screen=%d, Size=%dx%d\n",
+             (unsigned long)m_uScreenId, frameBufferSizeNew.width(), frameBufferSizeNew.height()));
+}
+
+void UIMachineView::sltHandleNotifyUpdate(int iX, int iY, int iWidth, int iHeight)
+{
+    /* Sanity check: */
+    if (!frameBuffer())
+        return;
+
+    /* Prepare corresponding viewport part: */
+    QRect rect(iX, iY, iWidth, iHeight);
+
+    /* Take the scaling into account: */
+    const double dScaleFactor = frameBuffer()->scaleFactor();
+    const QSize scaledSize = frameBuffer()->scaledSize();
+    if (scaledSize.isValid())
+    {
+        /* Calculate corresponding scale-factors: */
+        const double xScaleFactor = visualStateType() == UIVisualStateType_Scale ?
+                                    (double)scaledSize.width()  / frameBuffer()->width()  : dScaleFactor;
+        const double yScaleFactor = visualStateType() == UIVisualStateType_Scale ?
+                                    (double)scaledSize.height() / frameBuffer()->height() : dScaleFactor;
+        /* Adjust corresponding viewport part: */
+        rect.moveTo((int)floor((double)rect.x() * xScaleFactor) - 1,
+                    (int)floor((double)rect.y() * yScaleFactor) - 1);
+        rect.setSize(QSize((int)ceil((double)rect.width()  * xScaleFactor) + 2,
+                           (int)ceil((double)rect.height() * yScaleFactor) + 2));
+    }
+
+    /* Shift has to be scaled by the device-pixel-ratio
+     * but not scaled by the scale-factor. */
+    rect.translate(-contentsX(), -contentsY());
+
+    /* Take the device-pixel-ratio into account: */
+    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
+    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
+    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
+    {
+        rect.moveTo((int)floor((double)rect.x() * dDevicePixelRatioActual) - 1,
+                    (int)floor((double)rect.y() * dDevicePixelRatioActual) - 1);
+        rect.setSize(QSize((int)ceil((double)rect.width()  * dDevicePixelRatioActual) + 2,
+                           (int)ceil((double)rect.height() * dDevicePixelRatioActual) + 2));
+    }
+    if (dDevicePixelRatioFormal != 1.0)
+    {
+        rect.moveTo((int)floor((double)rect.x() / dDevicePixelRatioFormal) - 1,
+                    (int)floor((double)rect.y() / dDevicePixelRatioFormal) - 1);
+        rect.setSize(QSize((int)ceil((double)rect.width()  / dDevicePixelRatioFormal) + 2,
+                           (int)ceil((double)rect.height() / dDevicePixelRatioFormal) + 2));
+    }
+
+    /* Limit the resulting part by the viewport rectangle: */
+    rect &= viewport()->rect();
+
+    /* Update corresponding viewport part: */
+    viewport()->update(rect);
+}
+
+void UIMachineView::sltHandleSetVisibleRegion(QRegion region)
+{
+    /* Used only in seamless-mode. */
+    Q_UNUSED(region);
 }
 
@@ -505 +966 @@
 }
 
-void UIMachineView::sltHandleNotifyChange(int iWidth, int iHeight)
-{
-    /* Sanity check: */
-    if (!frameBuffer())
-        return;
-
-    LogRel2(("GUI: UIMachineView::sltHandleNotifyChange: Screen=%d, Size=%dx%d\n",
-             (unsigned long)m_uScreenId, iWidth, iHeight));
-
-    /* Some situations require frame-buffer resize-events to be ignored at all,
-     * leaving machine-window, machine-view and frame-buffer sizes preserved: */
-    if (uisession()->isGuestResizeIgnored())
-        return;
-
-    /* In some situations especially in some VM states, guest-screen is not drawable: */
-    if (uisession()->isGuestScreenUnDrawable())
-        return;
-
-    /* Get old frame-buffer size: */
-    const QSize frameBufferSizeOld = QSize(frameBuffer()->width(),
-                                           frameBuffer()->height());
-
-    /* Perform frame-buffer mode-change: */
-    frameBuffer()->handleNotifyChange(iWidth, iHeight);
-
-    /* Get new frame-buffer size: */
-    const QSize frameBufferSizeNew = QSize(frameBuffer()->width(),
-                                           frameBuffer()->height());
-
-    /* For 'scale' mode: */
-    if (visualStateType() == UIVisualStateType_Scale)
-    {
-        /* Assign new frame-buffer logical-size: */
-        QSize scaledSize = size();
-        const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
-        const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
-        scaledSize *= dDevicePixelRatioFormal;
-        if (!frameBuffer()->useUnscaledHiDPIOutput())
-            scaledSize /= dDevicePixelRatioActual;
-        frameBuffer()->setScaledSize(scaledSize);
-
-        /* Forget the last full-screen size: */
-        uisession()->setLastFullScreenSize(screenId(), QSize(-1, -1));
-    }
-    /* For other than 'scale' mode: */
-    else
-    {
-        /* Adjust maximum-size restriction for machine-view: */
-        setMaximumSize(sizeHint());
-
-        /* Disable the resize hint override hack and forget the last full-screen size: */
-        m_sizeHintOverride = QSize(-1, -1);
-        if (visualStateType() == UIVisualStateType_Normal)
-            uisession()->setLastFullScreenSize(screenId(), QSize(-1, -1));
-
-        /* Force machine-window update own layout: */
-        QCoreApplication::sendPostedEvents(0, QEvent::LayoutRequest);
-
-        /* Update machine-view sliders: */
-        updateSliders();
-
-        /* By some reason Win host forgets to update machine-window central-widget
-         * after main-layout was updated, let's do it for all the hosts: */
-        machineWindow()->centralWidget()->update();
-
-        /* Normalize 'normal' machine-window geometry if necessary: */
-        if (visualStateType() == UIVisualStateType_Normal &&
-            frameBufferSizeNew != frameBufferSizeOld)
-            machineWindow()->normalizeGeometry(true /* adjust position */, machineWindow()->shouldResizeToGuestDisplay());
-    }
-
-    /* Perform frame-buffer rescaling: */
-    frameBuffer()->performRescale();
-
-#ifdef VBOX_WS_MAC
-    /* Update MacOS X dock icon size: */
-    machineLogic()->updateDockIconSize(screenId(), frameBufferSizeNew.width(), frameBufferSizeNew.height());
-#endif /* VBOX_WS_MAC */
-
-    /* Notify frame-buffer resize: */
-    emit sigFrameBufferResize();
-
-    /* Ask for just required guest display update (it will also update
-     * the viewport through IFramebuffer::NotifyUpdate): */
-    display().InvalidateAndUpdateScreen(m_uScreenId);
-
-    /* If we are in normal or scaled mode and if GA are active,
-     * remember the guest-screen size to be able to restore it when necessary: */
-    /* As machines with Linux/Solaris and VMSVGA are not able to tell us
-     * whether a resize was due to the system or user interaction we currently
-     * do not store hints for these systems except when we explicitly send them
-     * ourselves.  Windows guests should use VBoxVGA controllers, not VMSVGA. */
-    if (   !isFullscreenOrSeamless()
-        && uisession()->isGuestSupportsGraphics()
-        && (machine().GetGraphicsAdapter().GetGraphicsControllerType() != KGraphicsControllerType_VMSVGA))
-        setStoredGuestScreenSizeHint(frameBufferSizeNew);
-
-    LogRel2(("GUI: UIMachineView::sltHandleNotifyChange: Complete for Screen=%d, Size=%dx%d\n",
-             (unsigned long)m_uScreenId, frameBufferSizeNew.width(), frameBufferSizeNew.height()));
-}
-
-void UIMachineView::sltHandleNotifyUpdate(int iX, int iY, int iWidth, int iHeight)
-{
-    /* Sanity check: */
-    if (!frameBuffer())
-        return;
-
-    /* Prepare corresponding viewport part: */
-    QRect rect(iX, iY, iWidth, iHeight);
-
-    /* Take the scaling into account: */
-    const double dScaleFactor = frameBuffer()->scaleFactor();
-    const QSize scaledSize = frameBuffer()->scaledSize();
-    if (scaledSize.isValid())
-    {
-        /* Calculate corresponding scale-factors: */
-        const double xScaleFactor = visualStateType() == UIVisualStateType_Scale ?
-                                    (double)scaledSize.width()  / frameBuffer()->width()  : dScaleFactor;
-        const double yScaleFactor = visualStateType() == UIVisualStateType_Scale ?
-                                    (double)scaledSize.height() / frameBuffer()->height() : dScaleFactor;
-        /* Adjust corresponding viewport part: */
-        rect.moveTo((int)floor((double)rect.x() * xScaleFactor) - 1,
-                    (int)floor((double)rect.y() * yScaleFactor) - 1);
-        rect.setSize(QSize((int)ceil((double)rect.width()  * xScaleFactor) + 2,
-                           (int)ceil((double)rect.height() * yScaleFactor) + 2));
-    }
-
-    /* Shift has to be scaled by the device-pixel-ratio
-     * but not scaled by the scale-factor. */
-    rect.translate(-contentsX(), -contentsY());
-
-    /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
-    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
-    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
-    {
-        rect.moveTo((int)floor((double)rect.x() * dDevicePixelRatioActual) - 1,
-                    (int)floor((double)rect.y() * dDevicePixelRatioActual) - 1);
-        rect.setSize(QSize((int)ceil((double)rect.width()  * dDevicePixelRatioActual) + 2,
-                           (int)ceil((double)rect.height() * dDevicePixelRatioActual) + 2));
-    }
-    if (dDevicePixelRatioFormal != 1.0)
-    {
-        rect.moveTo((int)floor((double)rect.x() / dDevicePixelRatioFormal) - 1,
-                    (int)floor((double)rect.y() / dDevicePixelRatioFormal) - 1);
-        rect.setSize(QSize((int)ceil((double)rect.width()  / dDevicePixelRatioFormal) + 2,
-                           (int)ceil((double)rect.height() / dDevicePixelRatioFormal) + 2));
-    }
-
-    /* Limit the resulting part by the viewport rectangle: */
-    rect &= viewport()->rect();
-
-    /* Update corresponding viewport part: */
-    viewport()->update(rect);
-}
-
-void UIMachineView::sltHandleSetVisibleRegion(QRegion region)
-{
-    /* Used only in seamless-mode. */
-    Q_UNUSED(region);
-}
-
 void UIMachineView::sltDesktopResized()
 {
@@ -1120 +1419 @@
 }
 
-UISession* UIMachineView::uisession() const
-{
-    return machineWindow()->uisession();
-}
-
 CSession& UIMachineView::session() const
 {
@@ -1153 +1447 @@
 {
     return machineWindow()->actionPool();
-}
-
-UIMachineLogic* UIMachineView::machineLogic() const
-{
-    return machineWindow()->machineLogic();
 }
 
@@ -1191 +1480 @@
     /* Return the resulting size-hint: */
     return QSize(size.width() + frameWidth() * 2, size.height() + frameWidth() * 2);
-}
-
-int UIMachineView::contentsX() const
-{
-    return horizontalScrollBar()->value();
-}
-
-int UIMachineView::contentsY() const
-{
-    return verticalScrollBar()->value();
-}
-
-int UIMachineView::contentsWidth() const
-{
-    return frameBuffer()->width();
-}
-
-int UIMachineView::contentsHeight() const
-{
-    return frameBuffer()->height();
-}
-
-int UIMachineView::visibleWidth() const
-{
-    return horizontalScrollBar()->pageStep();
-}
-
-int UIMachineView::visibleHeight() const
-{
-    return verticalScrollBar()->pageStep();
-}
-
-void UIMachineView::setMaximumGuestSize(const QSize &minimumSizeHint /* = QSize() */)
-{
-    QSize maxSize;
-    switch (m_enmMaximumGuestScreenSizePolicy)
-    {
-        case MaximumGuestScreenSizePolicy_Fixed:
-            maxSize = m_fixedMaxGuestSize;
-            break;
-        case MaximumGuestScreenSizePolicy_Automatic:
-            maxSize = calculateMaxGuestSize().expandedTo(minimumSizeHint);
-            break;
-        case MaximumGuestScreenSizePolicy_Any:
-            /* (0, 0) means any of course. */
-            maxSize = QSize(0, 0);
-    }
-    ASMAtomicWriteU64(&m_u64MaximumGuestSize,
-                      RT_MAKE_U64(maxSize.height(), maxSize.width()));
-}
-
-QSize UIMachineView::maximumGuestSize()
-{
-    uint64_t u64Size = ASMAtomicReadU64(&m_u64MaximumGuestSize);
-    return QSize(int(RT_HI_U32(u64Size)), int(RT_LO_U32(u64Size)));
 }
 
@@ -1502 +1736 @@
     horizontalScrollBar()->setPageStep(curViewportSize.width());
     verticalScrollBar()->setPageStep(curViewportSize.height());
-}
-
-QPoint UIMachineView::viewportToContents(const QPoint &vp) const
-{
-    /* Get physical contents shifts of scroll-bars: */
-    int iContentsX = contentsX();
-    int iContentsY = contentsY();
-
-    /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
-    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
-    if (!frameBuffer()->useUnscaledHiDPIOutput())
-    {
-        iContentsX *= dDevicePixelRatioActual;
-        iContentsY *= dDevicePixelRatioActual;
-    }
-    iContentsX /= dDevicePixelRatioFormal;
-    iContentsY /= dDevicePixelRatioFormal;
-
-    /* Return point shifted according scroll-bars: */
-    return QPoint(vp.x() + iContentsX, vp.y() + iContentsY);
-}
-
-void UIMachineView::scrollBy(int dx, int dy)
-{
-    horizontalScrollBar()->setValue(horizontalScrollBar()->value() + dx);
-    verticalScrollBar()->setValue(verticalScrollBar()->value() + dy);
 }
 
@@ -1609 +1816 @@
 }
 #endif /* VBOX_WS_MAC */
-
-UIVisualStateType UIMachineView::visualStateType() const
-{
-    return machineLogic()->visualStateType();
-}
 
 bool UIMachineView::isFullscreenOrSeamless() const
@@ -1899 +2101 @@
 }
 
-int UIMachineView::dragCheckPending(void)
-{
-    int rc;
-
-    if (!dragAndDropIsActive())
-        rc = VERR_ACCESS_DENIED;
-# ifdef VBOX_WITH_DRAG_AND_DROP_GH
-    else if (!m_fIsDraggingFromGuest)
-    {
-        /// @todo Add guest->guest DnD functionality here by getting
-        //       the source of guest B (when copying from B to A).
-        rc = m_pDnDHandler->dragCheckPending(screenId());
-        if (RT_SUCCESS(rc))
-            m_fIsDraggingFromGuest = true;
-    }
-    else /* Already dragging, so report success. */
-        rc = VINF_SUCCESS;
-# else
-    rc = VERR_NOT_SUPPORTED;
-# endif
-
-    DNDDEBUG(("DnD: dragCheckPending ended with rc=%Rrc\n", rc));
-    return rc;
-}
-
-int UIMachineView::dragStart(void)
-{
-    int rc;
-
-    if (!dragAndDropIsActive())
-        rc = VERR_ACCESS_DENIED;
-# ifdef VBOX_WITH_DRAG_AND_DROP_GH
-    else if (!m_fIsDraggingFromGuest)
-        rc = VERR_WRONG_ORDER;
-    else
-    {
-        /// @todo Add guest->guest DnD functionality here by getting
-        //       the source of guest B (when copying from B to A).
-        rc = m_pDnDHandler->dragStart(screenId());
-
-        m_fIsDraggingFromGuest = false;
-    }
-# else
-    rc = VERR_NOT_SUPPORTED;
-# endif
-
-    DNDDEBUG(("DnD: dragStart ended with rc=%Rrc\n", rc));
-    return rc;
-}
-
-int UIMachineView::dragStop(void)
-{
-    int rc;
-
-    if (!dragAndDropIsActive())
-        rc = VERR_ACCESS_DENIED;
-# ifdef VBOX_WITH_DRAG_AND_DROP_GH
-    else if (!m_fIsDraggingFromGuest)
-        rc = VERR_WRONG_ORDER;
-    else
-        rc = m_pDnDHandler->dragStop(screenId());
-# else
-    rc = VERR_NOT_SUPPORTED;
-# endif
-
-    DNDDEBUG(("DnD: dragStop ended with rc=%Rrc\n", rc));
-    return rc;
-}
-
 void UIMachineView::dropEvent(QDropEvent *pEvent)
 {
@@ -1995 +2128 @@
 
 #endif /* VBOX_WITH_DRAG_AND_DROP */
-
-bool UIMachineView::nativeEventPreprocessor(const QByteArray &eventType, void *pMessage)
-{
-    /* Check if some event should be filtered out.
-     * Returning @c true means filtering-out,
-     * Returning @c false means passing event to Qt. */
-
-# if defined(VBOX_WS_MAC)
-
-    /* Make sure it's generic NSEvent: */
-    if (eventType != "mac_generic_NSEvent")
-        return false;
-    EventRef event = static_cast<EventRef>(darwinCocoaToCarbonEvent(pMessage));
-
-    switch (::GetEventClass(event))
-    {
-        // Keep in mind that this stuff should not be enabled while we are still using
-        // own native keyboard filter installed through cocoa API, to be reworked.
-        // S.a. registerForNativeEvents call in UIKeyboardHandler implementation.
-#if 0
-        /* Watch for keyboard-events: */
-        case kEventClassKeyboard:
-        {
-            switch (::GetEventKind(event))
-            {
-                /* Watch for key-events: */
-                case kEventRawKeyDown:
-                case kEventRawKeyRepeat:
-                case kEventRawKeyUp:
-                case kEventRawKeyModifiersChanged:
-                {
-                    /* Delegate key-event handling to the keyboard-handler: */
-                    return machineLogic()->keyboardHandler()->nativeEventFilter(pMessage, screenId());
-                }
-                default:
-                    break;
-            }
-            break;
-        }
-#endif
-        /* Watch for mouse-events: */
-        case kEventClassMouse:
-        {
-            switch (::GetEventKind(event))
-            {
-                /* Watch for button-events: */
-                case kEventMouseDown:
-                case kEventMouseUp:
-                {
-                    /* Delegate button-event handling to the mouse-handler: */
-                    return machineLogic()->mouseHandler()->nativeEventFilter(pMessage, screenId());
-                }
-                default:
-                    break;
-            }
-            break;
-        }
-        default:
-            break;
-    }
-
-# elif defined(VBOX_WS_WIN)
-
-    /* Make sure it's generic MSG event: */
-    if (eventType != "windows_generic_MSG")
-        return false;
-    MSG *pEvent = static_cast<MSG*>(pMessage);
-
-    switch (pEvent->message)
-    {
-        /* Watch for key-events: */
-        case WM_KEYDOWN:
-        case WM_SYSKEYDOWN:
-        case WM_KEYUP:
-        case WM_SYSKEYUP:
-        {
-            // WORKAROUND:
-            // There is an issue in the Windows Qt5 event processing sequence
-            // causing QAbstractNativeEventFilter to receive Windows native events
-            // coming not just to the top-level window but to actual target as well.
-            // They are calling one - "global event" and another one - "context event".
-            // That way native events are always duplicated with almost no possibility
-            // to distinguish copies except the fact that synthetic event always have
-            // time set to 0 (actually that field was not initialized at all, we had
-            // fixed that in our private Qt tool). We should skip such events instantly.
-            if (pEvent->time == 0)
-                return false;
-
-            /* Delegate key-event handling to the keyboard-handler: */
-            return machineLogic()->keyboardHandler()->nativeEventFilter(pMessage, screenId());
-        }
-        default:
-            break;
-    }
-
-# elif defined(VBOX_WS_X11)
-
-    /* Make sure it's generic XCB event: */
-    if (eventType != "xcb_generic_event_t")
-        return false;
-    xcb_generic_event_t *pEvent = static_cast<xcb_generic_event_t*>(pMessage);
-
-    switch (pEvent->response_type & ~0x80)
-    {
-        /* Watch for key-events: */
-        case XCB_KEY_PRESS:
-        case XCB_KEY_RELEASE:
-        {
-            /* Delegate key-event handling to the keyboard-handler: */
-            return machineLogic()->keyboardHandler()->nativeEventFilter(pMessage, screenId());
-        }
-        /* Watch for button-events: */
-        case XCB_BUTTON_PRESS:
-        case XCB_BUTTON_RELEASE:
-        {
-            /* Delegate button-event handling to the mouse-handler: */
-            return machineLogic()->mouseHandler()->nativeEventFilter(pMessage, screenId());
-        }
-        default:
-            break;
-    }
-
-# else
-
-#  warning "port me!"
-
-# endif
-
-    /* Filter nothing by default: */
-    return false;
-}
 
 QSize UIMachineView::scaledForward(QSize size) const

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

@@ -109 +109 @@
     virtual void applyMachineViewScaleFactor();
 
+    /** Returns screen ID for this view. */
+    ulong screenId() const { return m_uScreenId; }
+
+    /** Returns the session UI reference. */
+    UISession *uisession() const;
+    /** Returns the machine-logic reference. */
+    UIMachineLogic *machineLogic() const;
+    /** Returns the machine-window reference. */
+    UIMachineWindow *machineWindow() const { return m_pMachineWindow; }
+    /** Returns view's frame-buffer reference. */
+    UIFrameBuffer *frameBuffer() const { return m_pFrameBuffer; }
+
+    /** Returns actual contents width. */
+    int contentsWidth() const;
+    /** Returns actual contents height. */
+    int contentsHeight() const;
+    /** Returns actual contents x origin. */
+    int contentsX() const;
+    /** Returns actual contents y origin. */
+    int contentsY() const;
+    /** Returns visible contents width. */
+    int visibleWidth() const;
+    /** Returns visible contents height. */
+    int visibleHeight() const;
+    /** Translates viewport point to contents point. */
+    QPoint viewportToContents(const QPoint &viewportPoint) const;
+    /** Scrolls contents by @a iDx x iDy pixels. */
+    void scrollBy(int iDx, int iDy);
+
+    /** What view mode (normal, fullscreen etc.) are we in? */
+    UIVisualStateType visualStateType() const;
+
+    /** Returns cached mouse cursor. */
+    QCursor cursor() const { return m_cursor; }
+
     /* Framebuffer aspect ratio: */
     double aspectRatio() const;
+
+    /** Atomically store the maximum guest resolution which we currently wish
+     * to handle for @a maximumGuestSize() to read.  Should be called if anything
+     * happens (e.g. a screen hotplug) which might cause the value to change.
+     * @sa m_u64MaximumGuestSize. */
+    void setMaximumGuestSize(const QSize &minimumSizeHint = QSize());
+    /** Atomically read the maximum guest resolution which we currently wish to
+     * handle.  This may safely be called from another thread (called by
+     * UIFramebuffer on EMT).
+     * @sa m_u64MaximumGuestSize. */
+    QSize maximumGuestSize();
 
     /** Updates console's display viewport.
       * @remarks Used to update 3D-service overlay viewport as well. */
     void updateViewport();
+
+#ifdef VBOX_WITH_DRAG_AND_DROP
+    /** Checks for a pending drag and drop event within the guest and
+      * (optionally) starts a drag and drop operation on the host. */
+    int dragCheckPending();
+    /** Starts a drag and drop operation from guest to the host.
+      * This internally either uses Qt's abstract QDrag methods
+      * or some other OS-dependent implementation. */
+    int dragStart();
+    /** Aborts (and resets) the current (pending)
+      * guest to host drag and drop operation. */
+    int dragStop();
+#endif /* VBOX_WITH_DRAG_AND_DROP */
+
+    /** Performs pre-processing of all the native events. */
+    virtual bool nativeEventPreprocessor(const QByteArray &eventType, void *pMessage);
+
+public slots:
+
+    /** Handles NotifyChange event received from frame-buffer.
+      * @todo To make it right, this have to be protected, but
+      *       connection should be moved from frame-buffer to this class. */
+    virtual void sltHandleNotifyChange(int iWidth, int iHeight);
+
+    /** Handles NotifyUpdate event received from frame-buffer.
+      * @todo To make it right, this have to be protected, but
+      *       connection should be moved from frame-buffer to this class. */
+    virtual void sltHandleNotifyUpdate(int iX, int iY, int iWidth, int iHeight);
+
+    /** Handles SetVisibleRegion event received from frame-buffer.
+      * @todo To make it right, this have to be protected, but
+      *       connection should be moved from frame-buffer to this class. */
+    virtual void sltHandleSetVisibleRegion(QRegion region);
 
 protected slots:
@@ -137 +216 @@
     void sltHandleActionTriggerViewScreenResize(int iScreen, const QSize &size);
 
-    /* Handler: Frame-buffer NotifyChange stuff: */
-    virtual void sltHandleNotifyChange(int iWidth, int iHeight);
-
-    /* Handler: Frame-buffer NotifyUpdate stuff: */
-    virtual void sltHandleNotifyUpdate(int iX, int iY, int iWidth, int iHeight);
-
-    /* Handler: Frame-buffer SetVisibleRegion stuff: */
-    virtual void sltHandleSetVisibleRegion(QRegion region);
-
     /* Watch dog for desktop resizes: */
     void sltDesktopResized();
@@ -195 +265 @@
     virtual void cleanupNativeFilters();
     //virtual void saveMachineViewSettings() {}
-
-    /** Returns the session UI reference. */
-    UISession* uisession() const;
 
     /** Returns the session reference. */
@@ -211 +278 @@
 
     /* Protected getters: */
-    UIMachineWindow* machineWindow() const { return m_pMachineWindow; }
     UIActionPool* actionPool() const;
-    UIMachineLogic* machineLogic() const;
     QSize sizeHint() const;
-    int contentsX() const;
-    int contentsY() const;
-    int contentsWidth() const;
-    int contentsHeight() const;
-    int visibleWidth() const;
-    int visibleHeight() const;
-    ulong screenId() const { return m_uScreenId; }
-    UIFrameBuffer* frameBuffer() const { return m_pFrameBuffer; }
-
-    /** Atomically store the maximum guest resolution which we currently wish
-     * to handle for @a maximumGuestSize() to read.  Should be called if anything
-     * happens (e.g. a screen hotplug) which might cause the value to change.
-     * @sa m_u64MaximumGuestSize. */
-    void setMaximumGuestSize(const QSize &minimumSizeHint = QSize());
-    /** Atomically read the maximum guest resolution which we currently wish to
-     * handle.  This may safely be called from another thread (called by
-     * UIFramebuffer on EMT).
-     * @sa m_u64MaximumGuestSize. */
-    QSize maximumGuestSize();
 
     /** Retrieves the last guest-screen size-hint from extra-data. */
@@ -262 +308 @@
     void updateScaledPausePixmap();
 
-    /** Returns cached mouse cursor. */
-    QCursor cursor() const { return m_cursor; }
-
     /** The available area on the current screen for application windows. */
     virtual QRect workingArea() const = 0;
@@ -271 +314 @@
     virtual QSize calculateMaxGuestSize() const = 0;
     virtual void updateSliders();
-    QPoint viewportToContents(const QPoint &vp) const;
-    void scrollBy(int dx, int dy);
     static void dimImage(QImage &img);
     void scrollContentsBy(int dx, int dy);
@@ -280 +321 @@
     CGImageRef frameBuffertoCGImageRef(UIFrameBuffer *pFrameBuffer);
 #endif /* VBOX_WS_MAC */
-    /** What view mode (normal, fullscreen etc.) are we in? */
-    UIVisualStateType visualStateType() const;
     /** Is this a fullscreen-type view? */
     bool isFullscreenOrSeamless() const;
@@ -337 +376 @@
 
     /**
-     * Guest -> Host: Checks for a pending drag and drop event within the guest
-     *                and (optionally) starts a drag and drop operation on the host.
-     */
-    int dragCheckPending(void);
-
-    /**
-     * Guest -> Host: Starts a drag and drop operation from guest to the host. This
-     *                internally either uses Qt's abstract QDrag methods or some other
-     *                OS-dependent implementation.
-     */
-    int dragStart(void);
-
-    /**
-     * Guest -> Host: Aborts (and resets) the current (pending) guest to host
-     *                drag and drop operation.
-     */
-    int dragStop(void);
-
-    /**
      * Host -> Guest: Issued when the host drops data into the guest (VM) window.
      *
@@ -362 +382 @@
     void dropEvent(QDropEvent *pEvent);
 #endif /* VBOX_WITH_DRAG_AND_DROP */
-
-    /** Qt5: Performs pre-processing of all the native events. */
-    virtual bool nativeEventPreprocessor(const QByteArray &eventType, void *pMessage);
 
     /** Scales passed size forward. */
@@ -427 +444 @@
     /** Holds the native event filter instance. */
     UINativeEventFilter *m_pNativeEventFilter;
-    /** Allows the native event filter to redirect
-      * events directly to nativeEventPreprocessor(). */
-    friend class UINativeEventFilter;
-
-    /* Friend classes: */
-    friend class UIKeyboardHandler;
-    friend class UIMouseHandler;
-    friend class UIMachineLogic;
-    friend class UIFrameBuffer;
-    friend class UIFrameBufferPrivate;
-    friend class VBoxOverlayFrameBuffer;
 };
 

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

@@ -265 +265 @@
 }
 #endif /* VBOX_WITH_MASKED_SEAMLESS */
+
+void UIMachineWindow::updateAppearanceOf(int iElement)
+{
+    /* Update window title: */
+    if (iElement & UIVisualElement_WindowTitle)
+    {
+        /* Make sure machine state is one of valid: */
+        const KMachineState enmState = uisession()->machineState();
+        if (enmState == KMachineState_Null)
+            return;
+
+        /* Prepare full name: */
+        QString strMachineName = machineName();
+
+        /* Append snapshot name: */
+        if (machine().GetSnapshotCount() > 0)
+        {
+            const CSnapshot comSnapshot = machine().GetCurrentSnapshot();
+            strMachineName += " (" + comSnapshot.GetName() + ")";
+        }
+
+        /* Append state name: */
+        strMachineName += " [" + gpConverter->toString(enmState) + "]";
+
+#ifndef VBOX_WS_MAC
+        /* Append user product name (besides macOS): */
+        const QString strUserProductName = uisession()->machineWindowNamePostfix();
+        strMachineName += " - " + (strUserProductName.isEmpty() ? defaultWindowTitle() : strUserProductName);
+#endif /* !VBOX_WS_MAC */
+
+        /* Check if we can get graphics adapter: */
+        CGraphicsAdapter comAdapter = machine().GetGraphicsAdapter();
+        if (machine().isOk() && comAdapter.isNotNull())
+        {
+            /* Append screen number only if there are more than one present: */
+            if (comAdapter.GetMonitorCount() > 1)
+                strMachineName += QString(" : %1").arg(m_uScreenId + 1);
+        }
+
+        /* Assign title finally: */
+        setWindowTitle(strMachineName);
+    }
+}
 
 void UIMachineWindow::retranslateUi()
@@ -588 +631 @@
 }
 
-void UIMachineWindow::updateAppearanceOf(int iElement)
-{
-    /* Update window title: */
-    if (iElement & UIVisualElement_WindowTitle)
-    {
-        /* Make sure machine state is one of valid: */
-        const KMachineState enmState = uisession()->machineState();
-        if (enmState == KMachineState_Null)
-            return;
-
-        /* Prepare full name: */
-        QString strMachineName = machineName();
-
-        /* Append snapshot name: */
-        if (machine().GetSnapshotCount() > 0)
-        {
-            const CSnapshot comSnapshot = machine().GetCurrentSnapshot();
-            strMachineName += " (" + comSnapshot.GetName() + ")";
-        }
-
-        /* Append state name: */
-        strMachineName += " [" + gpConverter->toString(enmState) + "]";
-
-#ifndef VBOX_WS_MAC
-        /* Append user product name (besides macOS): */
-        const QString strUserProductName = uisession()->machineWindowNamePostfix();
-        strMachineName += " - " + (strUserProductName.isEmpty() ? defaultWindowTitle() : strUserProductName);
-#endif /* !VBOX_WS_MAC */
-
-        /* Check if we can get graphics adapter: */
-        CGraphicsAdapter comAdapter = machine().GetGraphicsAdapter();
-        if (machine().isOk() && comAdapter.isNotNull())
-        {
-            /* Append screen number only if there are more than one present: */
-            if (comAdapter.GetMonitorCount() > 1)
-                strMachineName += QString(" : %1").arg(m_uScreenId + 1);
-        }
-
-        /* Assign title finally: */
-        setWindowTitle(strMachineName);
-    }
-}
-
 #ifdef VBOX_WITH_DEBUGGER_GUI
 void UIMachineWindow::updateDbgWindows()

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

@@ -122 +122 @@
 #endif /* VBOX_WITH_MASKED_SEAMLESS */
 
+    /** Makes sure window is exposed in required mode/state. */
+    virtual void showInNecessaryMode() = 0;
+
+    /** Updates appearance for specified @a iElement. */
+    virtual void updateAppearanceOf(int iElement);
+
 protected slots:
 
@@ -139 +145 @@
     /* Constructor: */
     UIMachineWindow(UIMachineLogic *pMachineLogic, ulong uScreenId);
-
-    /* Show stuff: */
-    virtual void showInNecessaryMode() = 0;
 
     /* Translate stuff: */
@@ -191 +194 @@
 
     /* Update stuff: */
-    virtual void updateAppearanceOf(int iElement);
 #ifdef VBOX_WITH_DEBUGGER_GUI
     void updateDbgWindows();
@@ -223 +225 @@
     QSpacerItem *m_pLeftSpacer;
     QSpacerItem *m_pRightSpacer;
-
-    /* Friend classes: */
-    friend class UIMachineLogic;
-    friend class UIMachineLogicFullscreen;
-    friend class UIMachineLogicSeamless;
 };
 
 #endif /* !FEQT_INCLUDED_SRC_runtime_UIMachineWindow_h */
-