Changeset 30259 in vbox for trunk/src

Timestamp:

Jun 16, 2010 4:43:39 PM (15 years ago)

Author:

vboxsync

Message:

FE/Qt: New running VM core: Fixed bug in VBoxDefs::ResizeEventType event processing for fullscreen, seamless modes; Some common code moved into specific normal, fullscreen, seamless parts.

Location:

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

Files:

• UIMachineView.cpp (modified) (1 diff)
• fullscreen/UIMachineViewFullscreen.cpp (modified) (2 diffs)
• normal/UIMachineViewNormal.cpp (modified) (2 diffs)
• seamless/UIMachineViewSeamless.cpp (modified) (2 diffs)

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

@@ -793 +793 @@
             }
             break;
-        }
-
-        case VBoxDefs::ResizeEventType:
-        {
-            /* Some situations require framebuffer resize events to be ignored,
-             * leaving machine window & machine view & framebuffer sizes preserved: */
-            if (uisession()->isGuestResizeIgnored())
-                return true;
-
-            /* We are starting to perform machine view resize: */
-            bool oldIgnoreMainwndResize = isMachineWindowResizeIgnored();
-            setMachineWindowResizeIgnored(true);
-
-            /* Get guest resize-event: */
-            UIResizeEvent *pResizeEvent = static_cast<UIResizeEvent*>(pEvent);
-
-            /* Perform framebuffer resize: */
-            frameBuffer()->resizeEvent(pResizeEvent);
-
-            /* Reapply maximum size restriction for machine view: */
-            setMaximumSize(sizeHint());
-
-            /* Store the new size to prevent unwanted resize hints being sent back: */
-            storeConsoleSize(pResizeEvent->width(), pResizeEvent->height());
-
-            /* Perform machine-view resize: */
-            resize(pResizeEvent->width(), pResizeEvent->height());
-
-            /* Let our toplevel widget calculate its sizeHint properly. */
-#ifdef Q_WS_X11
-            /* We use processEvents rather than sendPostedEvents & set the time out value to max cause on X11 otherwise
-             * the layout isn't calculated correctly. Dosn't find the bug in Qt, but this could be triggered through
-             * the async nature of the X11 window event system. */
-            QCoreApplication::processEvents(QEventLoop::AllEvents, INT_MAX);
-#else /* Q_WS_X11 */
-            QCoreApplication::sendPostedEvents(0, QEvent::LayoutRequest);
-#endif /* Q_WS_X11 */
-
-#ifdef Q_WS_MAC
-            machineLogic()->updateDockIconSize(screenId(), pResizeEvent->width(), pResizeEvent->height());
-#endif /* Q_WS_MAC */
-
-            /* Update mouse cursor shape: */
-            updateMouseCursorShape();
-
-            /* May be we have to restrict minimum size? */
-            maybeRestrictMinimumSize();
-
-            /* Update machine-view sliders: */
-            updateSliders();
-
-            /* Normalize geometry: */
-            normalizeGeometry(true /* adjustPosition */);
-
-            /* Report to the VM thread that we finished resizing */
-            session().GetConsole().GetDisplay().ResizeCompleted(screenId());
-
-            /* We are finishing to perform machine-view resize: */
-            setMachineWindowResizeIgnored(oldIgnoreMainwndResize);
-
-            /* Make sure that all posted signals are processed: */
-            qApp->processEvents();
-
-            /* We also recalculate the desktop geometry if this is determined
-             * automatically.  In fact, we only need this on the first resize,
-             * but it is done every time to keep the code simpler. */
-            calculateDesktopGeometry();
-
-            /* Emit a signal about guest was resized: */
-            emit resizeHintDone();
-
-            return true;
         }
 

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

@@ -149 +149 @@
     switch (pEvent->type())
     {
+        case VBoxDefs::ResizeEventType:
+        {
+            /* Some situations requires framebuffer resize events to be ignored at all,
+             * leaving machine-window, machine-view and framebuffer sizes preserved: */
+            if (uisession()->isGuestResizeIgnored())
+                return true;
+
+            /* We are starting to perform machine-view resize: */
+            bool oldIgnoreMainwndResize = isMachineWindowResizeIgnored();
+            setMachineWindowResizeIgnored(true);
+
+            /* Get guest resize-event: */
+            UIResizeEvent *pResizeEvent = static_cast<UIResizeEvent*>(pEvent);
+
+            /* Perform framebuffer resize: */
+            frameBuffer()->resizeEvent(pResizeEvent);
+
+            /* Reapply maximum size restriction for machine-view: */
+            setMaximumSize(sizeHint());
+
+            /* Store the new size to prevent unwanted resize hints being sent back: */
+            storeConsoleSize(pResizeEvent->width(), pResizeEvent->height());
+
+            /* Perform machine-view resize: */
+            resize(pResizeEvent->width(), pResizeEvent->height());
+
+            /* Let our toplevel widget calculate its sizeHint properly. */
+#ifdef Q_WS_X11
+            /* We use processEvents rather than sendPostedEvents & set the time out value to max cause on X11 otherwise
+             * the layout isn't calculated correctly. Dosn't find the bug in Qt, but this could be triggered through
+             * the async nature of the X11 window event system. */
+            QCoreApplication::processEvents(QEventLoop::AllEvents, INT_MAX);
+#else /* Q_WS_X11 */
+            QCoreApplication::sendPostedEvents(0, QEvent::LayoutRequest);
+#endif /* Q_WS_X11 */
+
+#ifdef Q_WS_MAC
+            machineLogic()->updateDockIconSize(screenId(), pResizeEvent->width(), pResizeEvent->height());
+#endif /* Q_WS_MAC */
+
+            /* Update mouse cursor shape: */
+            updateMouseCursorShape();
+
+            /* May be we have to restrict minimum size? */
+            maybeRestrictMinimumSize();
+
+            /* Update machine-view sliders: */
+            updateSliders();
+
+            /* Report to the VM thread that we finished resizing */
+            session().GetConsole().GetDisplay().ResizeCompleted(screenId());
+
+            /* We are finishing to perform machine-view resize: */
+            setMachineWindowResizeIgnored(oldIgnoreMainwndResize);
+
+            /* Make sure that all posted signals are processed: */
+            qApp->processEvents();
+
+            /* We also recalculate the desktop geometry if this is determined
+             * automatically.  In fact, we only need this on the first resize,
+             * but it is done every time to keep the code simpler. */
+            calculateDesktopGeometry();
+
+            /* Emit a signal about guest was resized: */
+            emit resizeHintDone();
+
+            /* Unlock after processing guest resize event: */
+            if (m_pSyncBlocker && m_pSyncBlocker->isRunning())
+                m_pSyncBlocker->quit();
+
+            return true;
+        }
+
         case QEvent::KeyPress:
         case QEvent::KeyRelease:
@@ -163 +236 @@
                     pEvent->ignore();
             }
-        }
-
-        case VBoxDefs::ResizeEventType:
-        {
-            /* Unlock after processing guest resize event: */
-            bool fResult = UIMachineView::event(pEvent);
-            if (m_pSyncBlocker && m_pSyncBlocker->isRunning())
-                m_pSyncBlocker->quit();
-            return fResult;
+
+            break;
         }
 

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

@@ -137 +137 @@
 bool UIMachineViewNormal::event(QEvent *pEvent)
 {
-    /* We don't want this on the Mac, cause there the menu bar isn't within the
-     * window and popping up a menu there looks really ugly. */
+    switch (pEvent->type())
+    {
+        case VBoxDefs::ResizeEventType:
+        {
+            /* Some situations require framebuffer resize events to be ignored at all,
+             * leaving machine-window, machine-view and framebuffer sizes preserved: */
+            if (uisession()->isGuestResizeIgnored())
+                return true;
+
+            /* We are starting to perform machine-view resize: */
+            bool oldIgnoreMainwndResize = isMachineWindowResizeIgnored();
+            setMachineWindowResizeIgnored(true);
+
+            /* Get guest resize-event: */
+            UIResizeEvent *pResizeEvent = static_cast<UIResizeEvent*>(pEvent);
+
+            /* Perform framebuffer resize: */
+            frameBuffer()->resizeEvent(pResizeEvent);
+
+            /* Reapply maximum size restriction for machine-view: */
+            setMaximumSize(sizeHint());
+
+            /* Store the new size to prevent unwanted resize hints being sent back: */
+            storeConsoleSize(pResizeEvent->width(), pResizeEvent->height());
+
+            /* Perform machine-view resize: */
+            resize(pResizeEvent->width(), pResizeEvent->height());
+
+            /* Let our toplevel widget calculate its sizeHint properly. */
+#ifdef Q_WS_X11
+            /* We use processEvents rather than sendPostedEvents & set the time out value to max cause on X11 otherwise
+             * the layout isn't calculated correctly. Dosn't find the bug in Qt, but this could be triggered through
+             * the async nature of the X11 window event system. */
+            QCoreApplication::processEvents(QEventLoop::AllEvents, INT_MAX);
+#else /* Q_WS_X11 */
+            QCoreApplication::sendPostedEvents(0, QEvent::LayoutRequest);
+#endif /* Q_WS_X11 */
+
+#ifdef Q_WS_MAC
+            machineLogic()->updateDockIconSize(screenId(), pResizeEvent->width(), pResizeEvent->height());
+#endif /* Q_WS_MAC */
+
+            /* Update mouse cursor shape: */
+            updateMouseCursorShape();
+
+            /* May be we have to restrict minimum size? */
+            maybeRestrictMinimumSize();
+
+            /* Update machine-view sliders: */
+            updateSliders();
+
+            /* Normalize geometry: */
+            normalizeGeometry(true /* adjustPosition */);
+
+            /* Report to the VM thread that we finished resizing */
+            session().GetConsole().GetDisplay().ResizeCompleted(screenId());
+
+            /* We are finishing to perform machine-view resize: */
+            setMachineWindowResizeIgnored(oldIgnoreMainwndResize);
+
+            /* Make sure that all posted signals are processed: */
+            qApp->processEvents();
+
+            /* We also recalculate the desktop geometry if this is determined
+             * automatically.  In fact, we only need this on the first resize,
+             * but it is done every time to keep the code simpler. */
+            calculateDesktopGeometry();
+
+            /* Emit a signal about guest was resized: */
+            emit resizeHintDone();
+
+            return true;
+        }
+
 #ifndef Q_WS_MAC
-    switch (pEvent->type())
-    {
+        /* We don't want this on the Mac, cause there the menu bar isn't within the
+         * window and popping up a menu there looks really ugly. */
         case QEvent::KeyPress:
         case QEvent::KeyRelease:
@@ -186 +258 @@
                     pEvent->ignore();
             }
+
+            break;
         }
+#endif /* !Q_WS_MAC */
+
         default:
             break;
     }
-#endif /* !Q_WS_MAC */
     return UIMachineView::event(pEvent);
 }

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

@@ -161 +161 @@
         }
 
+        case VBoxDefs::ResizeEventType:
+        {
+            /* Some situations require framebuffer resize events to be ignored at all,
+             * leaving machine-window, machine-view and framebuffer sizes preserved: */
+            if (uisession()->isGuestResizeIgnored())
+                return true;
+
+            /* We are starting to perform machine-view resize: */
+            bool oldIgnoreMainwndResize = isMachineWindowResizeIgnored();
+            setMachineWindowResizeIgnored(true);
+
+            /* Get guest resize-event: */
+            UIResizeEvent *pResizeEvent = static_cast<UIResizeEvent*>(pEvent);
+
+            /* Perform framebuffer resize: */
+            frameBuffer()->resizeEvent(pResizeEvent);
+
+            /* Reapply maximum size restriction for machine-view: */
+            setMaximumSize(sizeHint());
+
+            /* Store the new size to prevent unwanted resize hints being sent back: */
+            storeConsoleSize(pResizeEvent->width(), pResizeEvent->height());
+
+            /* Perform machine-view resize: */
+            resize(pResizeEvent->width(), pResizeEvent->height());
+
+            /* Let our toplevel widget calculate its sizeHint properly. */
+#ifdef Q_WS_X11
+            /* We use processEvents rather than sendPostedEvents & set the time out value to max cause on X11 otherwise
+             * the layout isn't calculated correctly. Dosn't find the bug in Qt, but this could be triggered through
+             * the async nature of the X11 window event system. */
+            QCoreApplication::processEvents(QEventLoop::AllEvents, INT_MAX);
+#else /* Q_WS_X11 */
+            QCoreApplication::sendPostedEvents(0, QEvent::LayoutRequest);
+#endif /* Q_WS_X11 */
+
+#ifdef Q_WS_MAC
+            machineLogic()->updateDockIconSize(screenId(), pResizeEvent->width(), pResizeEvent->height());
+#endif /* Q_WS_MAC */
+
+            /* Update mouse cursor shape: */
+            updateMouseCursorShape();
+
+            /* Update machine-view sliders: */
+            updateSliders();
+
+            /* Report to the VM thread that we finished resizing */
+            session().GetConsole().GetDisplay().ResizeCompleted(screenId());
+
+            /* We are finishing to perform machine-view resize: */
+            setMachineWindowResizeIgnored(oldIgnoreMainwndResize);
+
+            /* Make sure that all posted signals are processed: */
+            qApp->processEvents();
+
+            /* We also recalculate the desktop geometry if this is determined
+             * automatically.  In fact, we only need this on the first resize,
+             * but it is done every time to keep the code simpler. */
+            calculateDesktopGeometry();
+
+            /* Emit a signal about guest was resized: */
+            emit resizeHintDone();
+
+            /* Unlock after processing guest resize event: */
+            if (m_pSyncBlocker && m_pSyncBlocker->isRunning())
+                m_pSyncBlocker->quit();
+
+            return true;
+        }
+
         case QEvent::KeyPress:
         case QEvent::KeyRelease:
@@ -175 +245 @@
                     pEvent->ignore();
             }
-        }
-
-        case VBoxDefs::ResizeEventType:
-        {
-            /* Unlock after processing guest resize event: */
-            bool fResult = UIMachineView::event(pEvent);
-            if (m_pSyncBlocker && m_pSyncBlocker->isRunning())
-                m_pSyncBlocker->quit();
-            return fResult;
+
+            break;
         }