Changeset 30637 – Oracle VirtualBox

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

-              r30408
+              r30637
         src/runtime/UIActionsPool.h \
         src/runtime/UIIndicatorsPool.h \
+        src/runtime/UIKeyboardHandler.h \
         src/runtime/UIMouseHandler.h \
         src/runtime/UIMachineLogic.h \
         src/runtime/UIMachineView.h \
         src/runtime/UIMultiScreenLayout.h \
+        src/runtime/normal/UIKeyboardHandlerNormal.h \
         src/runtime/normal/UIMachineLogicNormal.h \
         src/runtime/normal/UIMachineWindowNormal.h \
         src/runtime/normal/UIMachineViewNormal.h \
+        src/runtime/fullscreen/UIKeyboardHandlerFullscreen.h \
         src/runtime/fullscreen/UIMachineLogicFullscreen.h \
         src/runtime/fullscreen/UIMachineWindowFullscreen.h \
         src/runtime/fullscreen/UIMachineViewFullscreen.h \
+        src/runtime/seamless/UIKeyboardHandlerSeamless.h \
         src/runtime/seamless/UIMachineLogicSeamless.h \
         src/runtime/seamless/UIMachineWindowSeamless.h \
 …
         src/runtime/UIActionsPool.cpp \
         src/runtime/UIIndicatorsPool.cpp \
+        src/runtime/UIKeyboardHandler.cpp \
         src/runtime/UIMouseHandler.cpp \
         src/runtime/UIFrameBuffer.cpp \
 …
         src/runtime/UIMachineMenuBar.cpp \
         src/runtime/UIMultiScreenLayout.cpp \
+        src/runtime/normal/UIKeyboardHandlerNormal.cpp \
         src/runtime/normal/UIMachineLogicNormal.cpp \
         src/runtime/normal/UIMachineWindowNormal.cpp \
         src/runtime/normal/UIMachineViewNormal.cpp \
+        src/runtime/fullscreen/UIKeyboardHandlerFullscreen.cpp \
         src/runtime/fullscreen/UIMachineLogicFullscreen.cpp \
         src/runtime/fullscreen/UIMachineWindowFullscreen.cpp \
         src/runtime/fullscreen/UIMachineViewFullscreen.cpp \
+        src/runtime/seamless/UIKeyboardHandlerSeamless.cpp \
         src/runtime/seamless/UIMachineLogicSeamless.cpp \
         src/runtime/seamless/UIMachineWindowSeamless.cpp \

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

-              r30458
+              r30637
+ *
  * VBox frontends: Qt GUI ("VirtualBox"):
  * UIMachineView class implementation
+ * UIKeyboardHandler class implementation
  */
 …
 /* Global includes */
+#include <QDesktopWidget>
+#include <QTimer>
+#include <QPainter>
+#include <QScrollBar>
+#include <VBox/VBoxVideo.h>
+#include <QKeyEvent>
 /* Local includes */
 #include "VBoxGlobal.h"
 #include "VBoxProblemReporter.h"
+#include "UIFrameBuffer.h"
+#include "UIFrameBufferQGL.h"
+#include "UIFrameBufferQImage.h"
+#include "UIFrameBufferQuartz2D.h"
+#include "UIFrameBufferSDL.h"
+#include "VBoxFBOverlay.h"
+#include "UIActionsPool.h"
+#include "UIKeyboardHandlerNormal.h"
+#include "UIKeyboardHandlerFullscreen.h"
+#include "UIKeyboardHandlerSeamless.h"
+#include "UIMouseHandler.h"
 #include "UISession.h"
-#include "UIActionsPool.h"
-#include "UIMouseHandler.h"
 #include "UIMachineLogic.h"
-#include "UIMachineWindow.h"
-#include "UIMachineView.h"
 #include "UIMachineWindowNormal.h"
 #include "UIMachineWindowFullscreen.h"
 #include "UIMachineWindowSeamless.h"
+#include "UIMachineViewNormal.h"
+#include "UIMachineViewFullscreen.h"
+#include "UIMachineViewSeamless.h"
+#ifdef Q_WS_PM
+# include "QIHotKeyEdit.h"
+#endif /* defined (Q_WS_PM) */
+#ifdef Q_WS_WIN
+#undef LOWORD
+#undef HIWORD
+#undef LOBYTE
+#undef HIBYTE
+#include <windows.h>
+static UIMachineView *gView = 0;
+static HHOOK gKbdHook = 0;
+#endif /* defined (Q_WS_WIN) */
+#include "UIMachineView.h"
 #ifdef Q_WS_X11
 # include <QX11Info>
-# define XK_XKB_KEYS
-# define XK_MISCELLANY
 # include <X11/XKBlib.h>
 # include <X11/keysym.h>
 …
 #  undef FocusOut
 #  undef FocusIn
 # endif
+# endif /* KeyPress */
 # include "XKeyboard.h"
+#endif /* defined (Q_WS_X11) */
+#ifdef Q_WS_MAC
+# include "DockIconPreview.h"
+# include "DarwinKeyboard.h"
+# include "UICocoaApplication.h"
+# include <VBox/err.h>
+# include <Carbon/Carbon.h>
+#endif /* Q_WS_MAC */
+class VBoxViewport: public QWidget
+{
+public:
+    VBoxViewport(QWidget *pParent) : QWidget(pParent)
+    {
+        /* No need for background drawing: */
+        setAttribute(Qt::WA_OpaquePaintEvent);
+    }
+    QPaintEngine *paintEngine() const
+    {
+        if (testAttribute(Qt::WA_PaintOnScreen))
+            return NULL;
+        else
+            return QWidget::paintEngine();
+    }
+};
+#endif /* Q_WS_X11 */
+/* Enums representing different keyboard-states: */
 enum { KeyExtended = 0x01, KeyPressed = 0x02, KeyPause = 0x04, KeyPrint = 0x08 };
 enum { IsKeyPressed = 0x01, IsExtKeyPressed = 0x02, IsKbdCaptured = 0x80 };
+UIMachineView* UIMachineView::create(  UIMachineWindow *pMachineWindow
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                                     , bool bAccelerate2DVideo
+#endif
+                                     , UIVisualStateType visualStateType
+                                     , ulong uScreenId)
+{
+    UIMachineView *view = 0;
+#ifdef Q_WS_WIN
+UIKeyboardHandler* UIKeyboardHandler::m_pKeyboardHandler = 0;
+#endif /* Q_WS_WIN */
+/* Factory function to create keyboard-handler: */
+UIKeyboardHandler* UIKeyboardHandler::create(UIMachineLogic *pMachineLogic,
+                                             UIVisualStateType visualStateType)
+{
+    /* Prepare keyboard-handler: */
+    UIKeyboardHandler *pKeyboardHandler = 0;
+    /* Depending on visual-state type: */
     switch (visualStateType)
+    {
         case UIVisualStateType_Normal:
+            view = new UIMachineViewNormal(  pMachineWindow
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                                           , bAccelerate2DVideo
+#endif
+                                           , uScreenId);
+            pKeyboardHandler = new UIKeyboardHandlerNormal(pMachineLogic);
             break;
         case UIVisualStateType_Fullscreen:
+            view = new UIMachineViewFullscreen(  pMachineWindow
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                                               , bAccelerate2DVideo
+#endif
+                                               , uScreenId);
+            pKeyboardHandler = new UIKeyboardHandlerFullscreen(pMachineLogic);
             break;
         case UIVisualStateType_Seamless:
+            view = new UIMachineViewSeamless(  pMachineWindow
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                                             , bAccelerate2DVideo
+#endif
+                                             , uScreenId);
+            pKeyboardHandler = new UIKeyboardHandlerSeamless(pMachineLogic);
             break;
         default:
             break;
+    }
+    return view;
+}
+void UIMachineView::destroy(UIMachineView *pWhichView)
+{
+    delete pWhichView;
+}
+int UIMachineView::keyboardState() const
+{
+    return (m_bIsKeyboardCaptured ? UIViewStateType_KeyboardCaptured : 0) |
+#ifdef Q_WS_WIN
+    /* Its required to have static pointer to created handler
+     * because windows keyboard-hook works only with static members: */
+    m_pKeyboardHandler = pKeyboardHandler;
+#endif /* Q_WS_WIN */
+    /* Return prepared keyboard-handler: */
+    return pKeyboardHandler;
+}
+/* Factory function to destroy keyboard-handler: */
+void UIKeyboardHandler::destroy(UIKeyboardHandler *pKeyboardHandler)
+{
+    /* Delete keyboard-handler: */
+#ifdef Q_WS_WIN
+    m_pKeyboardHandler = 0;
+#endif /* Q_WS_WIN */
+    delete pKeyboardHandler;
+}
+/* Prepare listened objects: */
+void UIKeyboardHandler::prepareListener(ulong uIndex, UIMachineWindow *pMachineWindow)
+{
+    /* If that window is NOT registered yet: */
+    if (!m_windows.contains(uIndex))
+    {
+        /* Add window: */
+        m_windows.insert(uIndex, pMachineWindow);
+        /* Install event-filter for window: */
+        switch (machineLogic()->visualStateType())
+        {
+            case UIVisualStateType_Normal:
+                static_cast<UIMachineWindowNormal*>(m_windows[uIndex])->installEventFilter(this);
+                break;
+            case UIVisualStateType_Fullscreen:
+                static_cast<UIMachineWindowFullscreen*>(m_windows[uIndex])->installEventFilter(this);
+                break;
+            case UIVisualStateType_Seamless:
+                static_cast<UIMachineWindowSeamless*>(m_windows[uIndex])->installEventFilter(this);
+                break;
+            default:
+                break;
+        }
+    }
+    /* If that view is NOT registered yet: */
+    if (!m_views.contains(uIndex))
+    {
+        /* Add view: */
+        m_views.insert(uIndex, pMachineWindow->machineView());
+        /* Install event-filter for view: */
+        m_views[uIndex]->installEventFilter(this);
+    }
+}
+/* Cleanup listened objects: */
+void UIKeyboardHandler::cleanupListener(ulong uIndex)
+{
+    /* If window still registered: */
+    if (m_windows.contains(uIndex))
+    {
+        /* Remove window: */
+        m_windows.remove(uIndex);
+    }
+    /* If view still registered: */
+    if (m_views.contains(uIndex))
+    {
+        /* Remove view: */
+        m_views.remove(uIndex);
+    }
+}
+void UIKeyboardHandler::captureKeyboard(ulong uScreenId)
+{
+    /* Do NOT capture keyboard if its captured already: */
+    if (m_fIsKeyboardCaptured)
+        return;
+    /* If such view exists: */
+    if (m_views.contains(uScreenId))
+    {
+        /* Store new keyboard-captured state value: */
+        m_fIsKeyboardCaptured = true;
+        /* Remember which screen had captured keyboard: */
+        m_iKeyboardCaptureViewIndex = uScreenId;
+#if defined(Q_WS_WIN)
+        /* On Win, keyboard grabbing is ineffective, a low-level keyboard hook is used instead. */
+#elif defined(Q_WS_X11)
+        /* On X11, we are using passive XGrabKey for normal (windowed) mode
+         * instead of XGrabKeyboard (called by QWidget::grabKeyboard())
+         * because XGrabKeyboard causes a problem under metacity - a window cannot be moved
+         * using the mouse if it is currently actively grabing the keyboard;
+         * For static modes we are using usual (active) keyboard grabbing. */
+        switch (machineLogic()->visualStateType())
+        {
+            /* If window is moveable we are making passive keyboard grab: */
+            case UIVisualStateType_Normal:
+            {
+                XGrabKey(QX11Info::display(), AnyKey, AnyModifier, m_windows[m_iKeyboardCaptureViewIndex]->machineWindow()->winId(), False, GrabModeAsync, GrabModeAsync);
+                break;
+            }
+            /* If window is NOT moveable we are making active keyboard grab: */
+            case UIVisualStateType_Fullscreen:
+            case UIVisualStateType_Seamless:
+            {
+                /* Keyboard grabbing can fail because of some keyboard shortcut is still grabbed by window manager.
+                 * We can't be sure this shortcut will be released at all, so we will retry to grab keyboard for 50 times,
+                 * and after we will just ignore that issue: */
+                int cTriesLeft = 50;
+                while (cTriesLeft && XGrabKeyboard(QX11Info::display(), m_windows[m_iKeyboardCaptureViewIndex]->machineWindow()->winId(), False, GrabModeAsync, GrabModeAsync, CurrentTime)) { --cTriesLeft; }
+                break;
+            }
+            /* Should we try to grab keyboard in default case? I think - NO. */
+            default:
+                break;
+        }
+#elif defined(Q_WS_MAC)
+        /* On Mac, we use the Qt methods + disabling global hot keys + watching modifiers (for right/left separation). */
+        ::DarwinDisableGlobalHotKeys(true);
+        m_views[m_iKeyboardCaptureViewIndex]->grabKeyboard();
+#else
+        /* On other platforms we are just praying Qt method will work. */
+        m_views[m_iKeyboardCaptureViewIndex]->grabKeyboard();
+#endif
+        /* Notify all the listeners: */
+        emit keyboardStateChanged(keyboardState());
+    }
+}
+void UIKeyboardHandler::releaseKeyboard()
+{
+    /* Do NOT capture keyboard if its captured already: */
+    if (!m_fIsKeyboardCaptured)
+        return;
+    /* If such view exists: */
+    if (m_views.contains(m_iKeyboardCaptureViewIndex))
+    {
+        /* Store new keyboard-captured state value: */
+        m_fIsKeyboardCaptured = false;
+#if defined(Q_WS_WIN)
+        /* On Win, keyboard grabbing is ineffective, a low-level keyboard hook is used instead. */
+#elif defined(Q_WS_X11)
+        /* On X11, we are using passive XGrabKey for normal (windowed) mode
+         * instead of XGrabKeyboard (called by QWidget::grabKeyboard())
+         * because XGrabKeyboard causes a problem under metacity - a window cannot be moved
+         * using the mouse if it is currently actively grabing the keyboard;
+         * For static modes we are using usual (active) keyboard grabbing. */
+        switch (machineLogic()->visualStateType())
+        {
+            /* If window is moveable we are making passive keyboard ungrab: */
+            case UIVisualStateType_Normal:
+            {
+                XUngrabKey(QX11Info::display(), AnyKey, AnyModifier, m_windows[m_iKeyboardCaptureViewIndex]->machineWindow()->winId());
+                break;
+            }
+            /* If window is NOT moveable we are making active keyboard ungrab: */
+            case UIVisualStateType_Fullscreen:
+            case UIVisualStateType_Seamless:
+            {
+                XUngrabKeyboard(QX11Info::display(), CurrentTime);
+                break;
+            }
+            /* Should we try to release keyboard in default case? I think - NO. */
+            default:
+                break;
+        }
+#elif defined(Q_WS_MAC)
+        ::DarwinDisableGlobalHotKeys(false);
+        m_views[m_iKeyboardCaptureViewIndex]->releaseKeyboard();
+#else
+        m_views[m_iKeyboardCaptureViewIndex]->releaseKeyboard();
+#endif
+        /* Reset keyboard-capture index: */
+        m_iKeyboardCaptureViewIndex = -1;
+        /* Notify all the listeners: */
+        emit keyboardStateChanged(keyboardState());
+    }
+}
+/* Current keyboard state: */
+int UIKeyboardHandler::keyboardState() const
+{
+    return (m_fIsKeyboardCaptured ? UIViewStateType_KeyboardCaptured : 0) |
            (m_bIsHostkeyPressed ? UIViewStateType_HostKeyPressed : 0);
+}
+UIMachineView::UIMachineView(  UIMachineWindow *pMachineWindow
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                             , bool bAccelerate2DVideo
+#if defined(Q_WS_WIN)
+bool UIKeyboardHandler::winEventFilter(MSG *pMsg, ulong uScreenId)
+{
+    /* Check if some system event should be filtered-out.
+     * Returning 'true' means filtering-out,
+     * Returning 'false' means passing event to Qt. */
+    bool fResult = false; /* Pass to Qt by default: */
+    switch (pMsg->message)
+    {
+        case WM_KEYDOWN:
+        case WM_KEYUP:
+        case WM_SYSKEYDOWN:
+        case WM_SYSKEYUP:
+        {
+            /* Check for the special flag possibly set at the end of this function: */
+            if (pMsg->lParam & (0x1 << 25))
+            {
+                pMsg->lParam &= ~(0x1 << 25);
+                fResult = false;
+                break;
+            }
+            /* Scancodes 0x80 and 0x00 are ignored: */
+            uint8_t scan = (pMsg->lParam >> 16) & 0x7F;
+            if (!scan)
+            {
+                fResult = true;
+                break;
+            }
+            int vkey = pMsg->wParam;
+            /* When one of the SHIFT keys is held and one of the cursor movement
+             * keys is pressed, Windows duplicates SHIFT press/release messages,
+             * but with the virtual key code set to 0xFF. These virtual keys are also
+             * sent in some other situations (Pause, PrtScn, etc.). Ignore suc messages. */
+            if (vkey == 0xFF)
+            {
+                fResult = true;
+                break;
+            }
+            int flags = 0;
+            if (pMsg->lParam & 0x1000000)
+                flags |= KeyExtended;
+            if (!(pMsg->lParam & 0x80000000))
+                flags |= KeyPressed;
+            switch (vkey)
+            {
+                case VK_SHIFT:
+                case VK_CONTROL:
+                case VK_MENU:
+                {
+                    /* Overcome stupid Win32 modifier key generalization: */
+                    int keyscan = scan;
+                    if (flags & KeyExtended)
+                        keyscan |= 0xE000;
+                    switch (keyscan)
+                    {
+                        case 0x002A: vkey = VK_LSHIFT; break;
+                        case 0x0036: vkey = VK_RSHIFT; break;
+                        case 0x001D: vkey = VK_LCONTROL; break;
+                        case 0xE01D: vkey = VK_RCONTROL; break;
+                        case 0x0038: vkey = VK_LMENU; break;
+                        case 0xE038: vkey = VK_RMENU; break;
+                    }
+                    break;
+                }
+                case VK_NUMLOCK:
+                    /* Win32 sets the extended bit for the NumLock key. Reset it: */
+                    flags &= ~KeyExtended;
+                    break;
+                case VK_SNAPSHOT:
+                    flags |= KeyPrint;
+                    break;
+                case VK_PAUSE:
+                    flags |= KeyPause;
+                    break;
+            }
+            bool result = keyEvent(vkey, scan, flags, uScreenId);
+            if (!result && m_fIsKeyboardCaptured)
+            {
+                /* keyEvent() returned that it didn't process the message, but since the
+                 * keyboard is captured, we don't want to pass it to Windows. We just want
+                 * to let Qt process the message (to handle non-alphanumeric <HOST>+key
+                 * shortcuts for example). So send it direcltly to the window with the
+                 * special flag in the reserved area of lParam (to avoid recursion). */
+                ::SendMessage(pMsg->hwnd, pMsg->message,
+                              pMsg->wParam, pMsg->lParam | (0x1 << 25));
+                fResult = true;
+                break;
+            }
+            /* These special keys have to be handled by Windows as well to update the
+             * internal modifier state and to enable/disable the keyboard LED */
+            if (vkey == VK_NUMLOCK || vkey == VK_CAPITAL || vkey == VK_LSHIFT || vkey == VK_RSHIFT)
+            {
+                fResult = false;
+                break;
+            }
+            fResult = result;
+            break;
+        }
+        default:
+            break;
+    }
+    /* Return result: */
+    return fResult;
+}
+#elif defined(Q_WS_X11)
+static Bool UIKeyboardHandlerCompEvent(Display*, XEvent *pEvent, XPointer pvArg)
+{
+    XEvent *pKeyEvent = (XEvent*)pvArg;
+    if ((pEvent->type == XKeyPress) && (pEvent->xkey.keycode == pKeyEvent->xkey.keycode))
+        return True;
+    else
+        return False;
+}
+bool UIKeyboardHandler::x11EventFilter(XEvent *pEvent, ulong uScreenId)
+{
+    /* Check if some system event should be filtered-out.
+     * Returning 'true' means filtering-out,
+     * Returning 'false' means passing event to Qt. */
+    bool fResult = false; /* Pass to Qt by default: */
+    switch (pEvent->type)
+    {
+        /* We have to handle XFocusOut right here as this event is not passed to UIMachineView::event().
+         * Handling this event is important for releasing the keyboard before the screen saver gets active.
+         * See public ticket #3894: Apparently this makes problems with newer versions of Qt
+         * and this hack is probably not necessary anymore. So disable it for Qt >= 4.5.0. */
+        case XFocusOut:
+        case XFocusIn:
+        {
+            if (uisession()->isRunning())
+            {
+                if (VBoxGlobal::qtRTVersion() < ((4 << 16) | (5 << 8) | 0))
+                {
+                    if (pEvent->type == XFocusIn)
+                    {
+                        /* Capture keyboard by chosen view number: */
+                        captureKeyboard(uScreenId);
+                        /* Reset the single-time disable capture flag: */
+                        if (uisession()->isAutoCaptureDisabled())
+                            uisession()->setAutoCaptureDisabled(false);
+                    }
+                    else
+                    {
+                        /* Release keyboard: */
+                        releaseKeyboard();
+                        /* And all pressed keys including host-one: */
+                        releaseAllPressedKeys(true);
+                    }
+                }
+            }
+            fResult = false;
+        }
+        case XKeyPress:
+        case XKeyRelease:
+        {
+            /* Translate the keycode to a PC scan code. */
+            uint8_t scan = handleXKeyEvent(pEvent);
+            /* Scancodes 0x00 (no valid translation) and 0x80 are ignored: */
+            if (!scan & 0x7F)
+            {
+                fResult = true;
+                break;
+            }
+            /* Fix for http://www.virtualbox.org/ticket/1296:
+             * when X11 sends events for repeated keys, it always inserts an XKeyRelease before the XKeyPress. */
+            XEvent returnEvent;
+            if ((pEvent->type == XKeyRelease) && (XCheckIfEvent(pEvent->xkey.display, &returnEvent,
+                UIKeyboardHandlerCompEvent, (XPointer)pEvent) == True))
+            {
+                XPutBackEvent(pEvent->xkey.display, &returnEvent);
+                fResult = true;
+                break;
+            }
+            KeySym ks = ::XKeycodeToKeysym(pEvent->xkey.display, pEvent->xkey.keycode, 0);
+            int flags = 0;
+            if (scan >> 8)
+                flags |= KeyExtended;
+            if (pEvent->type == XKeyPress)
+                flags |= KeyPressed;
+            /* Remove the extended flag: */
+            scan &= 0x7F;
+            switch (ks)
+            {
+                case XK_Print:
+                    flags |= KeyPrint;
+                    break;
+                case XK_Pause:
+                    flags |= KeyPause;
+                    break;
+            }
+            fResult = keyEvent(ks, scan, flags, uScreenId);
+        }
+        default:
+            break;
+    }
+    /* Return result: */
+    return fResult;
+}
 #endif
+                             , ulong uScreenId)
+// TODO_NEW_CORE: really think of if this is right
+//    : QAbstractScrollArea(((QMainWindow*)pMachineWindow->machineWindow())->centralWidget())
+    : QAbstractScrollArea(pMachineWindow->machineWindow())
+    , m_pMachineWindow(pMachineWindow)
+    , m_uScreenId(uScreenId)
+/* Machine state-change handler: */
+void UIKeyboardHandler::sltMachineStateChanged()
+{
+    /* Get machine state: */
+    KMachineState state = uisession()->machineState();
+    /* Handle particular machine states: */
+    switch (state)
+    {
+        case KMachineState_Paused:
+        case KMachineState_TeleportingPausedVM:
+        case KMachineState_Stuck:
+        {
+            /* Release the keyboard: */
+            releaseKeyboard();
+            /* And all pressed keys except the host-one : */
+            releaseAllPressedKeys(false /* release host-key? */);
+            break;
+        }
+        case KMachineState_Running:
+        {
+            /* Capture the keyboard by the first focused view: */
+            QList<ulong> theListOfViewIds = m_views.keys();
+            for (int i = 0; i < theListOfViewIds.size(); ++i)
+            {
+                if (m_views[theListOfViewIds[i]]->hasFocus())
+                {
+                    captureKeyboard(theListOfViewIds[i]);
+                    break;
+                }
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}
+/* Keyboard-handler constructor: */
+UIKeyboardHandler::UIKeyboardHandler(UIMachineLogic *pMachineLogic)
+    : QObject(pMachineLogic)
+    , m_pMachineLogic(pMachineLogic)
+    , m_iKeyboardCaptureViewIndex(-1)
     , m_globalSettings(vboxGlobal().settings())
+    , m_pFrameBuffer(0)
+    , m_previousState(KMachineState_Null)
+    , m_desktopGeometryType(DesktopGeo_Invalid)
+    , m_bIsKeyboardCaptured(false)
+    , m_fIsKeyboardCaptured(false)
     , m_bIsHostkeyPressed(false)
     , m_bIsHostkeyAlone (false)
     , m_bIsHostkeyInCapture(false)
-    , m_bIsMachineWindowResizeIgnored(false)
     , m_fPassCAD(false)
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    , m_fAccelerate2DVideo(bAccelerate2DVideo)
+#endif /* VBOX_WITH_VIDEOHWACCEL */
+#ifdef Q_WS_MAC
+#if defined(Q_WS_WIN)
+    , m_iKeyboardHookViewIndex(-1)
+#elif defined(Q_WS_MAC)
     , m_darwinKeyModifiers(0)
+    , m_fKeyboardGrabbed (false)
+#endif /* Q_WS_MAC */
+{
+}
+UIMachineView::~UIMachineView()
+{
+}
+UISession* UIMachineView::uisession() const
+{
+    return machineLogic()->uisession();
+}
+CSession& UIMachineView::session()
+{
+    return uisession()->session();
+}
+QSize UIMachineView::sizeHint() const
+{
+#ifdef VBOX_WITH_DEBUGGER
+    // TODO: Fix all DEBUGGER stuff!
+    /* HACK ALERT! Really ugly workaround for the resizing to 9x1 done by DevVGA if provoked before power on. */
+    QSize fb(m_pFrameBuffer->width(), m_pFrameBuffer->height());
+    if ((fb.width() < 16 || fb.height() < 16) && (vboxGlobal().isStartPausedEnabled() || vboxGlobal().isDebuggerAutoShowEnabled()))
+        fb = QSize(640, 480);
+    return QSize(fb.width() + frameWidth() * 2, fb.height() + frameWidth() * 2);
+#else
+    return QSize(m_pFrameBuffer->width() + frameWidth() * 2, m_pFrameBuffer->height() + frameWidth() * 2);
+    , m_fKeyboardGrabbed(false)
 #endif
+}
+int UIMachineView::contentsX() const
+{
+    return horizontalScrollBar()->value();
+}
+int UIMachineView::contentsY() const
+{
+    return verticalScrollBar()->value();
+}
+int UIMachineView::contentsWidth() const
+{
+    return m_pFrameBuffer->width();
+}
+int UIMachineView::contentsHeight() const
+{
+    return m_pFrameBuffer->height();
+}
+int UIMachineView::visibleWidth() const
+{
+    return horizontalScrollBar()->pageStep();
+}
+int UIMachineView::visibleHeight() const
+{
+    return verticalScrollBar()->pageStep();
+}
+UIMachineLogic* UIMachineView::machineLogic() const
+{
+    return machineWindowWrapper()->machineLogic();
+}
+QSize UIMachineView::desktopGeometry() const
+{
+    QSize geometry;
+    switch (m_desktopGeometryType)
+    {
+        case DesktopGeo_Fixed:
+        case DesktopGeo_Automatic:
+            geometry = QSize(qMax(m_desktopGeometry.width(), m_storedConsoleSize.width()),
+                             qMax(m_desktopGeometry.height(), m_storedConsoleSize.height()));
+            break;
+        case DesktopGeo_Any:
+            geometry = QSize(0, 0);
+            break;
+        default:
+            AssertMsgFailed(("Bad geometry type %d!\n", m_desktopGeometryType));
+    }
+    return geometry;
+}
+QSize UIMachineView::guestSizeHint()
+{
+    /* Result: */
+    QSize sizeHint;
+    /* Get current machine: */
+    CMachine machine = session().GetMachine();
+    /* Load machine view hint: */
+    QString strKey = m_uScreenId == 0 ? QString("%1").arg(VBoxDefs::GUI_LastGuestSizeHint) :
+                     QString("%1%2").arg(VBoxDefs::GUI_LastGuestSizeHint).arg(m_uScreenId);
+    QString strValue = machine.GetExtraData(strKey);
+    bool ok = true;
+    int width = 0, height = 0;
+    if (ok)
+        width = strValue.section(',', 0, 0).toInt(&ok);
+    if (ok)
+        height = strValue.section(',', 1, 1).toInt(&ok);
+    if (ok /* If previous parameters were read correctly! */)
+    {
+        /* Compose guest size hint from loaded values: */
+        sizeHint = QSize(width, height);
+    }
+    else
+    {
+        /* Compose guest size hint from default attributes: */
+        sizeHint = QSize(800, 600);
+    }
+    /* Return result: */
+    return sizeHint;
+}
+void UIMachineView::setDesktopGeometry(DesktopGeo geometry, int aWidth, int aHeight)
+{
+    switch (geometry)
+    {
+        case DesktopGeo_Fixed:
+            m_desktopGeometryType = DesktopGeo_Fixed;
+            if (aWidth != 0 && aHeight != 0)
+                m_desktopGeometry = QSize(aWidth, aHeight);
+            else
+                m_desktopGeometry = QSize(0, 0);
+            storeConsoleSize(0, 0);
+            break;
+        case DesktopGeo_Automatic:
+            m_desktopGeometryType = DesktopGeo_Automatic;
+            m_desktopGeometry = QSize(0, 0);
+            storeConsoleSize(0, 0);
+            break;
+        case DesktopGeo_Any:
+            m_desktopGeometryType = DesktopGeo_Any;
+            m_desktopGeometry = QSize(0, 0);
+            break;
+        default:
+            AssertMsgFailed(("Invalid desktop geometry type %d\n", geometry));
+            m_desktopGeometryType = DesktopGeo_Invalid;
+    }
+}
+void UIMachineView::storeConsoleSize(int iWidth, int iHeight)
+{
+    m_storedConsoleSize = QSize(iWidth, iHeight);
+}
+void UIMachineView::storeGuestSizeHint(const QSize &sizeHint)
+{
+    /* Get current machine: */
+    CMachine machine = session().GetMachine();
+    /* Save machine view hint: */
+    QString strKey = m_uScreenId == 0 ? QString("%1").arg(VBoxDefs::GUI_LastGuestSizeHint) :
+                     QString("%1%2").arg(VBoxDefs::GUI_LastGuestSizeHint).arg(m_uScreenId);
+    QString strValue = QString("%1,%2").arg(sizeHint.width()).arg(sizeHint.height());
+    machine.SetExtraData(strKey, strValue);
+}
+void UIMachineView::updateSliders()
+{
+    QSize p = viewport()->size();
+    QSize m = maximumViewportSize();
+    QSize v = QSize(frameBuffer()->width(), frameBuffer()->height());
+    /* No scroll bars needed: */
+    if (m.expandedTo(v) == m)
+        p = m;
+    horizontalScrollBar()->setRange(0, v.width() - p.width());
+    verticalScrollBar()->setRange(0, v.height() - p.height());
+    horizontalScrollBar()->setPageStep(p.width());
+    verticalScrollBar()->setPageStep(p.height());
+}
+void UIMachineView::prepareFrameBuffer()
+{
+    /* Prepare viewport: */
+#ifdef VBOX_GUI_USE_QGLFB
+    QWidget *pViewport;
+    switch (vboxGlobal().vmRenderMode())
+    {
+        case VBoxDefs::QGLMode:
+            pViewport = new VBoxGLWidget(session().GetConsole(), this, NULL);
+            break;
+        default:
+            pViewport = new VBoxViewport(this);
+    }
+#else
+    VBoxViewport *pViewport = new VBoxViewport(this);
+#endif
+    setViewport(pViewport);
+    CDisplay display = session().GetConsole().GetDisplay();
+    Assert(!display.isNull());
+    m_pFrameBuffer = NULL;
+    switch (vboxGlobal().vmRenderMode())
+    {
+#ifdef VBOX_GUI_USE_QIMAGE
+        case VBoxDefs::QImageMode:
+# ifdef VBOX_WITH_VIDEOHWACCEL
+            if (m_fAccelerate2DVideo)
+            {
+                UIFrameBuffer* pFramebuffer = uisession()->frameBuffer(screenId());
+                if (pFramebuffer)
+                    pFramebuffer->setView(this);
+                else
+                {
+                    /* these two additional template args is a workaround to this [VBox|UI] duplication
+                     * @todo: they are to be removed once VBox stuff is gone */
+                    pFramebuffer = new VBoxOverlayFrameBuffer<UIFrameBufferQImage, UIMachineView, UIResizeEvent>(this, &machineWindowWrapper()->session(), (uint32_t)screenId());
+                    uisession()->setFrameBuffer(screenId(), pFramebuffer);
+                }
+                m_pFrameBuffer = pFramebuffer;
+            }
+            else
+                m_pFrameBuffer = new UIFrameBufferQImage(this);
+# else
+            m_pFrameBuffer = new UIFrameBufferQImage(this);
+# endif
+            break;
+#endif /* VBOX_GUI_USE_QIMAGE */
+#ifdef VBOX_GUI_USE_QGLFB
+        case VBoxDefs::QGLMode:
+            m_pFrameBuffer = new UIFrameBufferQGL(this);
+            break;
+//        case VBoxDefs::QGLOverlayMode:
+//            m_pFrameBuffer = new UIQGLOverlayFrameBuffer(this);
+//            break;
+#endif /* VBOX_GUI_USE_QGLFB */
+#ifdef VBOX_GUI_USE_SDL
+        case VBoxDefs::SDLMode:
+            /* Indicate that we are doing all drawing stuff ourself: */
+            // TODO_NEW_CORE
+            viewport()->setAttribute(Qt::WA_PaintOnScreen);
+# ifdef Q_WS_X11
+            /* This is somehow necessary to prevent strange X11 warnings on i386 and segfaults on x86_64: */
+            XFlush(QX11Info::display());
+# endif
+# if defined(VBOX_WITH_VIDEOHWACCEL) && defined(DEBUG_misha) /* not tested yet */
+            if (m_fAccelerate2DVideo)
+            {
+                class UIFrameBuffer* pFramebuffer = uisession()->frameBuffer(screenId());
+                if (pFramebuffer)
+                    pFramebuffer->setView(this);
+                else
+                {
+                    /* these two additional template args is a workaround to this [VBox|UI] duplication
+                     * @todo: they are to be removed once VBox stuff is gone */
+                    pFramebuffer = new VBoxOverlayFrameBuffer<UIFrameBufferSDL, UIMachineView, UIResizeEvent>(this, &machineWindowWrapper()->session(), (uint32_t)screenId());
+                    uisession()->setFrameBuffer(screenId(), pFramebuffer);
+                }
+                m_pFrameBuffer = pFramebuffer;
+            }
+            else
+                m_pFrameBuffer = new UIFrameBufferSDL(this);
+# else
+            m_pFrameBuffer = new UIFrameBufferSDL(this);
+# endif
+            /* Disable scrollbars because we cannot correctly draw in a scrolled window using SDL: */
+            horizontalScrollBar()->setEnabled(false);
+            verticalScrollBar()->setEnabled(false);
+            break;
+#endif /* VBOX_GUI_USE_SDL */
+#if 0 // TODO: Enable DDraw frame buffer!
+#ifdef VBOX_GUI_USE_DDRAW
+        case VBoxDefs::DDRAWMode:
+            m_pFrameBuffer = new UIDDRAWFrameBuffer(this);
+            if (!m_pFrameBuffer || m_pFrameBuffer->address() == NULL)
+            {
+                if (m_pFrameBuffer)
+                    delete m_pFrameBuffer;
+                m_mode = VBoxDefs::QImageMode;
+                m_pFrameBuffer = new UIFrameBufferQImage(this);
+            }
+            break;
+#endif /* VBOX_GUI_USE_DDRAW */
+#endif
+#ifdef VBOX_GUI_USE_QUARTZ2D
+        case VBoxDefs::Quartz2DMode:
+            /* Indicate that we are doing all drawing stuff ourself: */
+            viewport()->setAttribute(Qt::WA_PaintOnScreen);
+# ifdef VBOX_WITH_VIDEOHWACCEL
+            if (m_fAccelerate2DVideo)
+            {
+                UIFrameBuffer* pFramebuffer = uisession()->frameBuffer(screenId());
+                if (pFramebuffer)
+                    pFramebuffer->setView(this);
+                else
+                {
+                    /* these two additional template args is a workaround to this [VBox|UI] duplication
+                     * @todo: they are to be removed once VBox stuff is gone */
+                    pFramebuffer = new VBoxOverlayFrameBuffer<UIFrameBufferQuartz2D, UIMachineView, UIResizeEvent>(this, &machineWindowWrapper()->session(), (uint32_t)screenId());
+                    uisession()->setFrameBuffer(screenId(), pFramebuffer);
+                }
+                m_pFrameBuffer = pFramebuffer;
+            }
+            else
+                m_pFrameBuffer = new UIFrameBufferQuartz2D(this);
+# else
+            m_pFrameBuffer = new UIFrameBufferQuartz2D(this);
+# endif
+            break;
+#endif /* VBOX_GUI_USE_QUARTZ2D */
+        default:
+            AssertReleaseMsgFailed(("Render mode must be valid: %d\n", vboxGlobal().vmRenderMode()));
+            LogRel(("Invalid render mode: %d\n", vboxGlobal().vmRenderMode()));
+            qApp->exit(1);
+            break;
+    }
+    if (m_pFrameBuffer)
+    {
+#ifdef VBOX_WITH_VIDEOHWACCEL
+        CFramebuffer fb(NULL);
+        if (m_fAccelerate2DVideo)
+        {
+            LONG XOrigin, YOrigin;
+            /* check if the framebuffer is already assigned
+             * in this case we do not need to re-assign it
+             * neither do we need to AddRef */
+            display.GetFramebuffer(m_uScreenId, fb, XOrigin, YOrigin);
+        }
+        if (fb.raw() != m_pFrameBuffer) /* <-this will evaluate to true iff m_fAccelerate2DVideo is disabled or iff no framebuffer is yet assigned */
+#endif
+        {
+            m_pFrameBuffer->AddRef();
+        }
+        /* always perform SetFramebuffer to ensure 3D gets notified */
+        display.SetFramebuffer(m_uScreenId, CFramebuffer(m_pFrameBuffer));
+    }
+#ifdef Q_WS_X11
+    /* Processing pseudo resize-event to synchronize frame-buffer
+     * with stored framebuffer size in case of machine state was 'saved': */
+    if (session().GetMachine().GetState() == KMachineState_Saved)
+    {
+        QSize size = guestSizeHint();
+        UIResizeEvent event(FramebufferPixelFormat_Opaque, NULL, 0, 0, size.width(), size.height());
+        frameBuffer()->resizeEvent(&event);
+    }
+#endif /* Q_WS_X11 */
+}
+void UIMachineView::prepareCommon()
+{
+    /* Prepare view frame: */
+    setFrameStyle(QFrame::NoFrame);
+{
+    /* Prepare: */
+    prepareCommon();
+    /* Load settings: */
+    loadSettings();
+    /* Initialize: */
+    sltMachineStateChanged();
+}
+/* Keyboard-handler destructor: */
+UIKeyboardHandler::~UIKeyboardHandler()
+{
+    /* Cleanup: */
+    cleanupCommon();
+}
+void UIKeyboardHandler::prepareCommon()
+{
+    /* Machine state-change updater: */
+    connect(uisession(), SIGNAL(sigMachineStateChange()), this, SLOT(sltMachineStateChanged()));
     /* Pressed keys: */
     ::memset(m_pressedKeys, 0, sizeof(m_pressedKeys));
+    /* Setup palette: */
+    QPalette palette(viewport()->palette());
+    palette.setColor(viewport()->backgroundRole(), Qt::black);
+    viewport()->setPalette(palette);
+    /* Setup focus policy: */
+    setFocusPolicy(Qt::WheelFocus);
+#if defined Q_WS_PM
+    bool ok = VBoxHlpInstallKbdHook(0, winId(), UM_PREACCEL_CHAR);
+    Assert(ok);
+    NOREF(ok);
+}
+void UIKeyboardHandler::loadSettings()
+{
+    /* Global settings: */
+#ifdef Q_WS_X11
+    /* Initialize the X keyboard subsystem: */
+    initMappedX11Keyboard(QX11Info::display(), vboxGlobal().settings().publicProperty("GUI/RemapScancodes"));
 #endif
+    /* Register mouse-handler: */
+    machineLogic()->mouseHandler()->addMachineView(screenId(), this);
+}
+void UIMachineView::prepareFilters()
+{
+    /* Enable MouseMove events: */
+    viewport()->setMouseTracking(true);
+    /* QScrollView does the below on its own, but let's
+     * do it anyway for the case it will not do it in the future: */
+    viewport()->installEventFilter(this);
+    /* We want to be notified on some parent's events: */
+    machineWindowWrapper()->machineWindow()->installEventFilter(this);
+}
+void UIMachineView::prepareConsoleConnections()
+{
+    /* Machine state-change updater: */
+    connect(uisession(), SIGNAL(sigMachineStateChange()), this, SLOT(sltMachineStateChanged()));
+}
+void UIMachineView::loadMachineViewSettings()
+{
+    /* Global settings: */
+    {
+#ifdef Q_WS_X11
+        /* Initialize the X keyboard subsystem: */
+        initMappedX11Keyboard(QX11Info::display(), vboxGlobal().settings().publicProperty("GUI/RemapScancodes"));
+#endif
+        /* Remember the desktop geometry and register for geometry
+         * change events for telling the guest about video modes we like: */
+        QString desktopGeometry = vboxGlobal().settings().publicProperty("GUI/MaxGuestResolution");
+        if ((desktopGeometry == QString::null) || (desktopGeometry == "auto"))
+            setDesktopGeometry(DesktopGeo_Automatic, 0, 0);
+        else if (desktopGeometry == "any")
+            setDesktopGeometry(DesktopGeo_Any, 0, 0);
+        else
+        {
+            int width = desktopGeometry.section(',', 0, 0).toInt();
+            int height = desktopGeometry.section(',', 1, 1).toInt();
+            setDesktopGeometry(DesktopGeo_Fixed, width, height);
+        }
+    }
+    /* Exatra data settings: */
+    /* Extra data settings: */
+    {
         /* CAD settings: */
         QString passCAD = session().GetConsole().GetMachine().GetExtraData(VBoxDefs::GUI_PassCAD);
         if (!passCAD.isEmpty() && ((passCAD != "false") || (passCAD != "no")))
+        if (!passCAD.isEmpty() && passCAD != "false" && passCAD != "no")
             m_fPassCAD = true;
+    }
+}
+void UIMachineView::cleanupCommon()
+{
+    /* Unregister mouse-handler: */
+    machineLogic()->mouseHandler()->delMachineView(screenId());
+#ifdef Q_WS_PM
+    bool ok = VBoxHlpUninstallKbdHook(0, winId(), UM_PREACCEL_CHAR);
+    Assert(ok);
+    NOREF(ok);
+#endif /* Q_WS_PM */
+#ifdef Q_WS_WIN
+    if (gKbdHook)
+        UnhookWindowsHookEx(gKbdHook);
+    gView = 0;
+#endif /* Q_WS_WIN */
+#ifdef Q_WS_MAC
+    /* We have to make sure the callback for the keyboard events is released
+     * when closing this view. */
+void UIKeyboardHandler::cleanupCommon()
+{
+#if defined(Q_WS_WIN)
+    /* Cleaning keyboard-hook: */
+    if (m_keyboardHook)
+    {
+        UnhookWindowsHookEx(m_keyboardHook);
+        m_keyboardHook = NULL;
+    }
+#elif defined(Q_WS_MAC)
+    /* We have to make sure the callback for the keyboard events
+     * is released when closing this view. */
     if (m_fKeyboardGrabbed)
+        darwinGrabKeyboardEvents (false);
+#endif /* Q_WS_MAC */
+}
+void UIMachineView::cleanupFrameBuffer()
+{
+    if (m_pFrameBuffer)
+    {
+        /* Process pending frame-buffer resize events: */
+        QApplication::sendPostedEvents(this, VBoxDefs::ResizeEventType);
+#ifdef VBOX_WITH_VIDEOHWACCEL
+        if (m_fAccelerate2DVideo)
+        {
+            /* When 2D is enabled we do not re-create Framebuffers. This is done to
+             * 1. avoid 2D command loss during the time slot when no framebuffer is assigned to the display
+             * 2. make it easier to preserve the current 2D state */
+            Assert(m_pFrameBuffer == uisession()->frameBuffer(screenId()));
+            m_pFrameBuffer->setView(NULL);
+        }
+        else
+        darwinGrabKeyboardEvents(false);
 #endif
+        {
+            /* Warn framebuffer about its no more necessary: */
+            m_pFrameBuffer->setDeleted(true);
+            /* Detach framebuffer from Display: */
+            CDisplay display = session().GetConsole().GetDisplay();
+            display.SetFramebuffer(m_uScreenId, CFramebuffer(NULL));
+            /* Release the reference: */
+            m_pFrameBuffer->Release();
+//          delete m_pFrameBuffer; // TODO_NEW_CORE: possibly necessary to really cleanup
+            m_pFrameBuffer = NULL;
+        }
+    }
+}
+bool UIMachineView::event(QEvent *pEvent)
+{
+    switch (pEvent->type())
+    {
+        case QEvent::FocusIn:
+        {
+            if (uisession()->isRunning())
+                focusEvent(true);
+            break;
+        }
+        case QEvent::FocusOut:
+        {
+            if (uisession()->isRunning())
+                focusEvent(false);
+            else
+            {
+                /* Release the host key and all other pressed keys too even when paused
+                 * (otherwise, we will get stuck keys in the guest when doing sendChangedKeyStates() on resume
+                 * because key presses were already recorded in m_pressedKeys but key releases will most likely
+                 * not reach us but the new focus window instead): */
+                releaseAllPressedKeys(true /* including host key? */);
+            }
+            break;
+        }
+        case VBoxDefs::RepaintEventType:
+        {
+            UIRepaintEvent *pPaintEvent = static_cast<UIRepaintEvent*>(pEvent);
+            viewport()->repaint(pPaintEvent->x() - contentsX(), pPaintEvent->y() - contentsY(),
+                                pPaintEvent->width(), pPaintEvent->height());
+            return true;
+        }
+#ifdef VBOX_WITH_VIDEOHWACCEL
+        case VBoxDefs::VHWACommandProcessType:
+        {
+            m_pFrameBuffer->doProcessVHWACommand(pEvent);
+            return true;
+        }
+#endif
+        case QEvent::KeyPress:
+        case QEvent::KeyRelease:
+        {
+            QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
+#ifdef Q_WS_PM
+            // TODO: that a temporary solution to send Alt+Tab and friends to the guest.
+            // The proper solution is to write a keyboard driver that will steal these combos from the host
+            // (it's impossible to do so using hooks on OS/2):
+            if (m_bIsHostkeyPressed)
+            {
+                bool pressed = pEvent->type() == QEvent::KeyPress;
+                CKeyboard keyboard = session().GetConsole().GetKeyboard();
+                /* Whether the host key is Shift so that it will modify the hot key values?
+                 * Note that we don't distinguish between left and right shift here (too much hassle): */
+                const bool kShift = (m_globalSettings.hostKey() == VK_SHIFT ||
+                                    m_globalSettings.hostKey() == VK_LSHIFT) &&
+                                    (pKeyEvent->state() & Qt::ShiftModifier);
+                /* define hot keys according to the Shift state */
+                const int kAltTab      = kShift ? Qt::Key_Exclam     : Qt::Key_1;
+                const int kAltShiftTab = kShift ? Qt::Key_At         : Qt::Key_2;
+                const int kCtrlEsc     = kShift ? Qt::Key_AsciiTilde : Qt::Key_QuoteLeft;
+                /* Simulate Alt+Tab on Host+1 and Alt+Shift+Tab on Host+2 */
+                if (pKeyEvent->key() == kAltTab || pKeyEvent->key() == kAltShiftTab)
+                {
+                    if (pressed)
+}
+/* Machine-logic getter: */
+UIMachineLogic* UIKeyboardHandler::machineLogic() const
+{
+    return m_pMachineLogic;
+}
+/* UI Session getter: */
+UISession* UIKeyboardHandler::uisession() const
+{
+    return machineLogic()->uisession();
+}
+/* Main Session getter: */
+CSession& UIKeyboardHandler::session() const
+{
+    return uisession()->session();
+}
+/* Event handler for prepared listener(s): */
+bool UIKeyboardHandler::eventFilter(QObject *pWatchedObject, QEvent *pEvent)
+{
+    /* Check if pWatchedObject object is window: */
+    if (UIMachineWindow *pWatchedWindow = isItListenedWindow(pWatchedObject))
+    {
+        /* Get corresponding screen index: */
+        ulong uScreenId = m_windows.key(pWatchedWindow);
+        NOREF(uScreenId);
+        /* Handle window events: */
+        switch (pEvent->type())
+        {
+#if defined(Q_WS_WIN)
+            /* Install/uninstall low-level keyboard-hook on every activation/deactivation to:
+             * a) avoid excess hook calls when we're not active and;
+             * b) be always in front of any other possible hooks. */
+            case QEvent::WindowActivate:
+            {
+                /* If keyboard hook is NOT currently created;
+                 * Or created but NOT for that window: */
+                if (!m_keyboardHook || m_iKeyboardHookViewIndex != uScreenId)
+                {
+                    /* If keyboard-hook present: */
+                    if (m_keyboardHook)
+                    {
+                        /* Send the Alt press to the guest */
+                        if (!(m_pressedKeysCopy[0x38] & IsKeyPressed))
+                        {
+                            /* Store the press in *Copy to have it automatically
+                             * released when the Host key is released: */
+                            m_pressedKeysCopy[0x38] |= IsKeyPressed;
+                            keyboard.PutScancode(0x38);
+                        }
+                        /* Make sure Shift is pressed if it's Key_2 and released if it's Key_1: */
+                        if (pKeyEvent->key() == kAltTab &&
+                            (m_pressedKeysCopy[0x2A] & IsKeyPressed))
+                        {
+                            m_pressedKeysCopy[0x2A] &= ~IsKeyPressed;
+                            keyboard.PutScancode(0xAA);
+                        }
+                        else
+                        if (pKeyEvent->key() == kAltShiftTab &&
+                            !(m_pressedKeysCopy[0x2A] & IsKeyPressed))
+                        {
+                            m_pressedKeysCopy[0x2A] |= IsKeyPressed;
+                            keyboard.PutScancode(0x2A);
+                        }
+                        /* We should remove existing keyboard-hook first: */
+                        UnhookWindowsHookEx(m_keyboardHook);
+                        m_keyboardHook = NULL;
+                    }
+                    keyboard.PutScancode(pressed ? 0x0F : 0x8F);
+                    pKeyEvent->accept();
+                    return true;
+                }
+                /* Simulate Ctrl+Esc on Host+Tilde */
+                if (pKeyEvent->key() == kCtrlEsc)
+                {
+                    /* Send the Ctrl press to the guest */
+                    if (pressed && !(m_pressedKeysCopy[0x1d] & IsKeyPressed))
+                    {
+                        /* store the press in *Copy to have it automatically
+                         * released when the Host key is released */
+                        m_pressedKeysCopy[0x1d] |= IsKeyPressed;
+                        keyboard.PutScancode(0x1d);
+                    }
+                    keyboard.PutScancode(pressed ? 0x01 : 0x81);
+                    pKeyEvent->accept();
+                    return true;
+                }
+            }
+#endif /* Q_WS_PM */
+            if (m_bIsHostkeyPressed && pEvent->type() == QEvent::KeyPress)
+            {
+                /* Passing F1-F12 keys to the guest: */
+                if (pKeyEvent->key() >= Qt::Key_F1 && pKeyEvent->key() <= Qt::Key_F12)
+                {
+                    QVector <LONG> combo(6);
+                    combo[0] = 0x1d; /* Ctrl down */
+                    combo[1] = 0x38; /* Alt  down */
+                    combo[4] = 0xb8; /* Alt  up   */
+                    combo[5] = 0x9d; /* Ctrl up   */
+                    if (pKeyEvent->key() >= Qt::Key_F1 && pKeyEvent->key() <= Qt::Key_F10)
+                    {
+                        combo[2] = 0x3b + (pKeyEvent->key() - Qt::Key_F1); /* F1-F10 down */
+                        combo[3] = 0xbb + (pKeyEvent->key() - Qt::Key_F1); /* F1-F10 up   */
+                    }
+                    /* some scan slice */
+                    else if (pKeyEvent->key() >= Qt::Key_F11 && pKeyEvent->key() <= Qt::Key_F12)
+                    {
+                        combo[2] = 0x57 + (pKeyEvent->key() - Qt::Key_F11); /* F11-F12 down */
+                        combo[3] = 0xd7 + (pKeyEvent->key() - Qt::Key_F11); /* F11-F12 up   */
+                    }
+                    else
+                        Assert(0);
+                    CKeyboard keyboard = session().GetConsole().GetKeyboard();
+                    keyboard.PutScancodes(combo);
+                }
+                /* Process hot keys not processed in keyEvent() (as in case of non-alphanumeric keys): */
+                machineWindowWrapper()->machineLogic()->actionsPool()->processHotKey(QKeySequence(pKeyEvent->key()));
+            }
+            else if (!m_bIsHostkeyPressed && pEvent->type() == QEvent::KeyRelease)
+            {
+                /* Show a possible warning on key release which seems to be more expected by the end user: */
+                if (uisession()->isPaused())
+                {
+                    /* Iif the reminder is disabled we pass the event to Qt to enable normal
+                     * keyboard functionality (for example, menu access with Alt+Letter): */
+                    if (!vboxProblem().remindAboutPausedVMInput())
+                        break;
+                }
+            }
+            pKeyEvent->accept();
+            return true;
+        }
+#ifdef Q_WS_MAC
+        /* posted OnShowWindow */
+        case VBoxDefs::ShowWindowEventType:
+        {
+            /* Dunno what Qt3 thinks a window that has minimized to the dock should be - it is not hidden,
+             * neither is it minimized. OTOH it is marked shown and visible, but not activated.
+             * This latter isn't of much help though, since at this point nothing is marked activated.
+             * I might have overlooked something, but I'm buggered what if I know what. So, I'll just always
+             * show & activate the stupid window to make it get out of the dock when the user wishes to show a VM: */
+            window()->show();
+            window()->activateWindow();
+            return true;
+        }
+#endif
+        default:
+            break;
+    }
+    return QAbstractScrollArea::event(pEvent);
+}
+bool UIMachineView::eventFilter(QObject *pWatched, QEvent *pEvent)
+{
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    if (pWatched == viewport())
+    {
+        switch (pEvent->type())
+        {
+            case QEvent::Resize:
+            {
+                if (m_pFrameBuffer)
+                    m_pFrameBuffer->viewportResized(static_cast<QResizeEvent*>(pEvent));
+                break;
+            }
+            default:
+                break;
+        }
+    }
+#endif /* VBOX_WITH_VIDEOHWACCEL */
+    if (pWatched == machineWindowWrapper()->machineWindow())
+    {
+        switch (pEvent->type())
+        {
+            case QEvent::WindowStateChange:
+            {
+                /* During minimizing and state restoring machineWindowWrapper() gets
+                 * the focus which belongs to console view window, so returning it properly. */
+                QWindowStateChangeEvent *pWindowEvent = static_cast<QWindowStateChangeEvent*>(pEvent);
+                if (pWindowEvent->oldState() & Qt::WindowMinimized)
+                {
+                    if (QApplication::focusWidget())
+                    {
+                        QApplication::focusWidget()->clearFocus();
+                        qApp->processEvents();
+                    }
+                    QTimer::singleShot(0, this, SLOT(setFocus()));
+                }
+                break;
+            }
+#ifdef Q_WS_WIN
+            /* Install/uninstall low-level kbd hook on every activation/deactivation to:
+             * a) avoid excess hook calls when we're not active and
+             * b) be always in front of any other possible hooks */
+            case QEvent::WindowActivate:
+            {
+                gView = this;
+                gKbdHook = SetWindowsHookEx(WH_KEYBOARD_LL, lowLevelKeyboardProc, GetModuleHandle(NULL), 0);
+                AssertMsg(gKbdHook, ("SetWindowsHookEx(): err=%d", GetLastError()));
+                    /* Register new keyboard-hook: */
+                    m_keyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, lowLevelKeyboardProc, GetModuleHandle(NULL), 0);
+                    AssertMsg(m_keyboardHook, ("SetWindowsHookEx(): err=%d", GetLastError()));
+                    /* Remember which view had captured keyboard: */
+                    m_iKeyboardHookViewIndex = uScreenId;
+                }
                 break;
+            }
             case QEvent::WindowDeactivate:
+            {
+                if (gKbdHook)
+                {
+                    UnhookWindowsHookEx(gKbdHook);
+                    gKbdHook = NULL;
+                    if (gView == this)
+                        gView = 0;
+                }
+                break;
+            }
+#endif /* Q_WS_WIN */
+#ifdef Q_WS_MAC
+            /* Install/remove the keyboard event handler: */
+                /* If keyboard is currently captured: */
+                if (m_keyboardHook && m_iKeyboardHookViewIndex == uScreenId)
+                {
+                    /* We should remove existing keyboard-hook: */
+                    UnhookWindowsHookEx(m_keyboardHook);
+                    m_keyboardHook = NULL;
+                    /* Remember what there is no window captured keyboard: */
+                    m_iKeyboardHookViewIndex = -1;
+                }
+                break;
+            }
+#elif defined(Q_WS_MAC)
+            /* Install the keyboard event handler: */
             case QEvent::WindowActivate:
                 darwinGrabKeyboardEvents(true);
                 break;
+            /* Remove the keyboard event handler: */
             case QEvent::WindowDeactivate:
                 darwinGrabKeyboardEvents(false);
                 break;
 #endif /* Q_WS_MAC */
+#endif
             default:
                 break;
 …
+    }
-    return QAbstractScrollArea::eventFilter (pWatched, pEvent);
+}
-void UIMachineView::sltMachineStateChanged()
+{
-    /* Get machine state: */
-    KMachineState state = uisession()->machineState();
-    switch (state)
+    {
-        case KMachineState_Paused:
-        case KMachineState_TeleportingPausedVM:
+        {
-            if (vboxGlobal().vmRenderMode() != VBoxDefs::TimerMode &&  m_pFrameBuffer &&
-                (state != KMachineState_TeleportingPausedVM || m_previousState != KMachineState_Teleporting))
+            {
-                /* Take a screen snapshot. Note that TakeScreenShot() always needs a 32bpp image: */
-                QImage shot = QImage(m_pFrameBuffer->width(), m_pFrameBuffer->height(), QImage::Format_RGB32);
-                /* If TakeScreenShot fails or returns no image, just show a black image. */
-                shot.fill(0);
-                CDisplay dsp = session().GetConsole().GetDisplay();
-                dsp.TakeScreenShot(screenId(), shot.bits(), shot.width(), shot.height());
-                /* TakeScreenShot() may fail if, e.g. the Paused notification was delivered
-                 * after the machine execution was resumed. It's not fatal: */
-                if (dsp.isOk())
+                {
-                    dimImage(shot);
+                }
-                m_pauseShot = QPixmap::fromImage(shot);
-                /* Fully repaint to pick up m_pauseShot: */
-                viewport()->repaint();
+            }
-            /* Reuse the focus event handler to uncapture keyboard: */
-            if (hasFocus())
-                focusEvent(false /* aHasFocus*/, false /* aReleaseHostKey */);
-            break;
+        }
-        case KMachineState_Stuck:
+        {
-            /* Reuse the focus event handler to uncapture keyboard: */
-            if (hasFocus())
-                focusEvent(false /* aHasFocus*/, false /* aReleaseHostKey */);
-            break;
+        }
-        case KMachineState_Running:
+        {
-            if (   m_previousState == KMachineState_Paused
-                || m_previousState == KMachineState_TeleportingPausedVM
-                || m_previousState == KMachineState_Restoring)
+            {
-                if (vboxGlobal().vmRenderMode() != VBoxDefs::TimerMode && m_pFrameBuffer)
+                {
-                    /* Reset the pixmap to free memory: */
-                    m_pauseShot = QPixmap();
-                    /* Ask for full guest display update (it will also update
-                     * the viewport through IFramebuffer::NotifyUpdate): */
-                    CDisplay dsp = session().GetConsole().GetDisplay();
-                    dsp.InvalidateAndUpdate();
+                }
+            }
-            /* Reuse the focus event handler to capture keyboard: */
-            if (hasFocus())
-                focusEvent(true /* aHasFocus */);
-            break;
+        }
-        default:
-            break;
+    }
-    m_previousState = state;
+}
-void UIMachineView::focusEvent(bool fHasFocus, bool fReleaseHostKey /* = true */)
+{
-    if (fHasFocus)
+    {
-#ifdef Q_WS_WIN32
-        if (!uisession()->isAutoCaptureDisabled() && m_globalSettings.autoCapture() && GetAncestor(winId(), GA_ROOT) == GetForegroundWindow())
-#else
-        if (!uisession()->isAutoCaptureDisabled() && m_globalSettings.autoCapture())
-#endif
+        {
-            captureKbd(true);
+        }
-        /* Reset the single-time disable capture flag: */
-        if (uisession()->isAutoCaptureDisabled())
-            uisession()->setAutoCaptureDisabled(false);
+    }
     else
+    {
+        captureKbd(false, false);
+        releaseAllPressedKeys(fReleaseHostKey);
+    }
+}
+bool UIMachineView::keyEvent(int iKey, uint8_t uScan, int fFlags, wchar_t *pUniKey /* = NULL */)
+{
+    const bool isHostKey = iKey == m_globalSettings.hostKey();
+    LONG buf[16];
+    LONG *codes = buf;
+    uint count = 0;
+    uint8_t whatPressed = 0;
+    if (!isHostKey && !m_bIsHostkeyPressed)
+    {
+        if (fFlags & KeyPrint)
+        {
+            static LONG PrintMake[] = { 0xE0, 0x2A, 0xE0, 0x37 };
+            static LONG PrintBreak[] = { 0xE0, 0xB7, 0xE0, 0xAA };
+            if (fFlags & KeyPressed)
+            {
+                codes = PrintMake;
+                count = SIZEOF_ARRAY(PrintMake);
+            }
+            else
+            {
+                codes = PrintBreak;
+                count = SIZEOF_ARRAY(PrintBreak);
+            }
+        }
+        else if (fFlags & KeyPause)
+        {
+            if (fFlags & KeyPressed)
+            {
+                static LONG Pause[] = { 0xE1, 0x1D, 0x45, 0xE1, 0x9D, 0xC5 };
+                codes = Pause;
+                count = SIZEOF_ARRAY(Pause);
+            }
+            else
+            {
+                /* Pause shall not produce a break code */
+                return true;
+            }
+        }
+        else
+        {
+            if (fFlags & KeyPressed)
+            {
+                /* Check if the guest has the same view on the modifier keys (NumLock,
+                 * CapsLock, ScrollLock) as the X server. If not, send KeyPress events
+                 * to synchronize the state. */
+                fixModifierState(codes, &count);
+            }
+            /* Check if it's C-A-D and GUI/PassCAD is not true */
+            if (!m_fPassCAD &&
+                uScan == 0x53 /* Del */ &&
+                ((m_pressedKeys[0x38] & IsKeyPressed) /* Alt */ ||
+                 (m_pressedKeys[0x38] & IsExtKeyPressed)) &&
+                ((m_pressedKeys[0x1d] & IsKeyPressed) /* Ctrl */ ||
+                 (m_pressedKeys[0x1d] & IsExtKeyPressed)))
+            {
+                /* Use the C-A-D combination as a last resort to get the
+                 * keyboard and mouse back to the host when the user forgets
+                 * the Host Key. Note that it's always possible to send C-A-D
+                 * to the guest using the Host+Del combination. BTW, it would
+                 * be preferrable to completely ignore C-A-D in guests, but
+                 * that's not possible because we cannot predict what other
+                 * keys will be pressed next when one of C, A, D is held. */
+                if (uisession()->isRunning() && m_bIsKeyboardCaptured)
+                {
+                    captureKbd(false);
+                    if (!(uisession()->isMouseSupportsAbsolute() && uisession()->isMouseIntegrated()))
+                        machineLogic()->mouseHandler()->captureMouse(screenId());
+                }
+                return true;
+            }
+            /* Process the scancode and update the table of pressed keys: */
+            whatPressed = IsKeyPressed;
+            if (fFlags & KeyExtended)
+            {
+                codes[count++] = 0xE0;
+                whatPressed = IsExtKeyPressed;
+            }
+            if (fFlags & KeyPressed)
+            {
+                codes[count++] = uScan;
+                m_pressedKeys[uScan] |= whatPressed;
+            }
+            else
+            {
+                /* If we haven't got this key's press message, we ignore its release: */
+                if (!(m_pressedKeys[uScan] & whatPressed))
+                    return true;
+                codes[count++] = uScan | 0x80;
+                m_pressedKeys[uScan] &= ~whatPressed;
+            }
+            if (m_bIsKeyboardCaptured)
+                m_pressedKeys[uScan] |= IsKbdCaptured;
+            else
+                m_pressedKeys[uScan] &= ~IsKbdCaptured;
+        }
+    }
+    else
+    {
+        /* Currently this is used in winLowKeyboardEvent() only: */
+        m_bIsHostkeyInCapture = m_bIsKeyboardCaptured;
+    }
+    bool emitSignal = false;
+    int hotkey = 0;
+    /* Process the host key: */
+    if (fFlags & KeyPressed)
+    {
+        if (isHostKey)
+        {
+            if (!m_bIsHostkeyPressed)
+            {
+                m_bIsHostkeyPressed = m_bIsHostkeyAlone = true;
+    /* Check if pWatchedObject object is view: */
+    if (UIMachineView *pWatchedView = isItListenedView(pWatchedObject))
+    {
+        /* Get corresponding screen index: */
+        ulong uScreenId = m_views.key(pWatchedView);
+        NOREF(uScreenId);
+        /* Handle view events: */
+        switch (pEvent->type())
+        {
+            case QEvent::FocusIn:
                 if (uisession()->isRunning())
+                    saveKeyStates();
+                emitSignal = true;
+            }
+        }
+        else
+        {
+            if (m_bIsHostkeyPressed)
+            {
+                if (m_bIsHostkeyAlone)
+                {
+                    hotkey = iKey;
+                    m_bIsHostkeyAlone = false;
+                }
+            }
+        }
+    }
+    else
+    {
+        if (isHostKey)
+        {
+            if (m_bIsHostkeyPressed)
+            {
+                m_bIsHostkeyPressed = false;
+                if (m_bIsHostkeyAlone)
+                {
+                {
+                    /* Capture keyboard: */
+#ifdef Q_WS_WIN
+                    if (!uisession()->isAutoCaptureDisabled() && m_globalSettings.autoCapture() &&
+                        GetAncestor(pWatchedView->winId(), GA_ROOT) == GetForegroundWindow())
+#else /* Q_WS_WIN */
+                    if (!uisession()->isAutoCaptureDisabled() && m_globalSettings.autoCapture())
+#endif /* !Q_WS_WIN */
+                        captureKeyboard(uScreenId);
+                    /* Reset the single-time disable capture flag: */
+                    if (uisession()->isAutoCaptureDisabled())
+                        uisession()->setAutoCaptureDisabled(false);
+                }
+                break;
+            case QEvent::FocusOut:
+                /* Release keyboard: */
+                if (uisession()->isRunning())
+                    releaseKeyboard();
+                /* And all pressed keys: */
+                releaseAllPressedKeys(true);
+                break;
+            case QEvent::KeyPress:
+            case QEvent::KeyRelease:
+            {
+                QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
+                if (m_bIsHostkeyPressed && pEvent->type() == QEvent::KeyPress)
+                {
+                    /* Passing F1-F12 keys to the guest: */
+                    if (pKeyEvent->key() >= Qt::Key_F1 && pKeyEvent->key() <= Qt::Key_F12)
+                    {
+                        QVector <LONG> combo(6);
+                        combo[0] = 0x1d; /* Ctrl down */
+                        combo[1] = 0x38; /* Alt  down */
+                        combo[4] = 0xb8; /* Alt  up   */
+                        combo[5] = 0x9d; /* Ctrl up   */
+                        if (pKeyEvent->key() >= Qt::Key_F1 && pKeyEvent->key() <= Qt::Key_F10)
+                        {
+                            combo[2] = 0x3b + (pKeyEvent->key() - Qt::Key_F1); /* F1-F10 down */
+                            combo[3] = 0xbb + (pKeyEvent->key() - Qt::Key_F1); /* F1-F10 up   */
+                        }
+                        /* There is some scan slice between F10 and F11 keys, so its separated: */
+                        else if (pKeyEvent->key() >= Qt::Key_F11 && pKeyEvent->key() <= Qt::Key_F12)
+                        {
+                            combo[2] = 0x57 + (pKeyEvent->key() - Qt::Key_F11); /* F11-F12 down */
+                            combo[3] = 0xd7 + (pKeyEvent->key() - Qt::Key_F11); /* F11-F12 up   */
+                        }
+                        CKeyboard keyboard = session().GetConsole().GetKeyboard();
+                        keyboard.PutScancodes(combo);
+                    }
+                    /* Process hot keys not processed in keyEvent() (as in case of non-alphanumeric keys): */
+                    machineLogic()->actionsPool()->processHotKey(QKeySequence(pKeyEvent->key()));
+                }
+                else if (!m_bIsHostkeyPressed && pEvent->type() == QEvent::KeyRelease)
+                {
+                    /* Show a possible warning on key release which seems to be more expected by the end user: */
                     if (uisession()->isPaused())
+                    {
+                        vboxProblem().remindAboutPausedVMInput();
+                        /* If the reminder is disabled we pass the event to Qt to enable normal
+                         * keyboard functionality (for example, menu access with Alt+Letter): */
+                        if (!vboxProblem().remindAboutPausedVMInput())
+                            break;
+                    }
+                    else if (uisession()->isRunning())
+                    {
+                        bool captured = m_bIsKeyboardCaptured;
+                        bool ok = true;
+                        if (!captured)
+                        {
+                            /* temporarily disable auto capture that will take
+                             * place after this dialog is dismissed because
+                             * the capture state is to be defined by the
+                             * dialog result itself */
+                            uisession()->setAutoCaptureDisabled(true);
+                            bool autoConfirmed = false;
+                            ok = vboxProblem().confirmInputCapture (&autoConfirmed);
+                            if (autoConfirmed)
+                                uisession()->setAutoCaptureDisabled(false);
+                            /* otherwise, the disable flag will be reset in
+                             * the next console view's foucs in event (since
+                             * may happen asynchronously on some platforms,
+                             * after we return from this code) */
+                        }
+                        if (ok)
+                        {
+                            captureKbd (!captured, false);
+                            if (!(uisession()->isMouseSupportsAbsolute() && uisession()->isMouseIntegrated()))
+                            {
+#ifdef Q_WS_X11
+                                /* make sure that pending FocusOut events from the
+                                 * previous message box are handled, otherwise the
+                                 * mouse is immediately ungrabbed. */
+                                qApp->processEvents();
+#endif
+                                if (m_bIsKeyboardCaptured)
+                                    machineLogic()->mouseHandler()->captureMouse(screenId());
+                                else
+                                    machineLogic()->mouseHandler()->releaseMouse();
+                            }
+                        }
+                    }
+                }
+                if (uisession()->isRunning())
+                    sendChangedKeyStates();
+                emitSignal = true;
+            }
+        }
+        else
+        {
+            if (m_bIsHostkeyPressed)
+                m_bIsHostkeyAlone = false;
+        }
+    }
+    /* emit the keyboard state change signal */
+    if (emitSignal)
+        emitKeyboardStateChanged();
+    /* Process Host+<key> shortcuts. currently, <key> is limited to
+     * alphanumeric chars. Other Host+<key> combinations are handled in
+     * event(). */
+    if (hotkey)
+    {
+        bool processed = false;
+#if defined (Q_WS_WIN32)
+        NOREF(pUniKey);
+        int n = GetKeyboardLayoutList(0, NULL);
+        Assert (n);
+        HKL *list = new HKL[n];
+        GetKeyboardLayoutList(n, list);
+        for (int i = 0; i < n && !processed; i++)
+        {
+            wchar_t ch;
+            static BYTE keys[256] = {0};
+            if (!ToUnicodeEx(hotkey, 0, keys, &ch, 1, 0, list[i]) == 1)
+                ch = 0;
+            if (ch)
+                processed = machineWindowWrapper()->machineLogic()->actionsPool()->processHotKey(QKeySequence((Qt::UNICODE_ACCEL + QChar(ch).toUpper().unicode())));
+        }
+        delete[] list;
+#elif defined (Q_WS_X11)
+        NOREF(pUniKey);
+        Display *display = QX11Info::display();
+        int keysyms_per_keycode = getKeysymsPerKeycode();
+        KeyCode kc = XKeysymToKeycode (display, iKey);
+        for (int i = 0; i < keysyms_per_keycode && !processed; i += 2)
+        {
+            KeySym ks = XKeycodeToKeysym(display, kc, i);
+            char ch = 0;
+            if (!XkbTranslateKeySym(display, &ks, 0, &ch, 1, NULL) == 1)
+                ch = 0;
+            if (ch)
+                QChar c = QString::fromLocal8Bit(&ch, 1)[0];
+        }
+#elif defined (Q_WS_MAC)
+        if (pUniKey && pUniKey[0] && !pUniKey[1])
+            processed = machineWindowWrapper()->machineLogic()->actionsPool()->processHotKey(QKeySequence(Qt::UNICODE_ACCEL + QChar(pUniKey[0]).toUpper().unicode()));
+        /* Don't consider the hot key as pressed since the guest never saw
+         * it. (probably a generic thing) */
+        m_pressedKeys[uScan] &= ~whatPressed;
+#endif
+        /* Grab the key from Qt if processed, or pass it to Qt otherwise
+         * in order to process non-alphanumeric keys in event(), after they are
+         * converted to Qt virtual keys. */
+        return processed;
+    }
+    /* No more to do, if the host key is in action or the VM is paused: */
+    if (m_bIsHostkeyPressed || isHostKey || uisession()->isPaused())
+    {
+        /* Grab the key from Qt and from VM if it's a host key,
+         * otherwise just pass it to Qt */
+        return isHostKey;
+    }
+    CKeyboard keyboard = session().GetConsole().GetKeyboard();
+    Assert(!keyboard.isNull());
+#if defined (Q_WS_WIN32)
+    /* send pending WM_PAINT events */
+    ::UpdateWindow(viewport()->winId());
+#endif
+    std::vector <LONG> scancodes(codes, &codes[count]);
+    keyboard.PutScancodes(QVector<LONG>::fromStdVector(scancodes));
+    /* Grab the key from Qt: */
+    return true;
+}
+void UIMachineView::resizeEvent(QResizeEvent *pEvent)
+{
+    updateSliders();
+    return QAbstractScrollArea::resizeEvent(pEvent);
+}
+void UIMachineView::moveEvent(QMoveEvent *pEvent)
+{
+    return QAbstractScrollArea::moveEvent(pEvent);
+}
+void UIMachineView::paintEvent(QPaintEvent *pPaintEvent)
+{
+    if (m_pauseShot.isNull())
+    {
+        /* Delegate the paint function to the VBoxFrameBuffer interface: */
+        if (m_pFrameBuffer)
+            m_pFrameBuffer->paintEvent(pPaintEvent);
+#ifdef Q_WS_MAC
+        /* Update the dock icon if we are in the running state */
+        if (uisession()->isRunning())
+            updateDockIcon();
+#endif /* Q_WS_MAC */
+        return;
+    }
+#ifdef VBOX_GUI_USE_QUARTZ2D
+    if (vboxGlobal().vmRenderMode() == VBoxDefs::Quartz2DMode && m_pFrameBuffer)
+    {
+        m_pFrameBuffer->paintEvent(pPaintEvent);
+        updateDockIcon();
+    }
+    else
+#endif /* VBOX_GUI_USE_QUARTZ2D */
+    {
+        /* We have a snapshot for the paused state: */
+        QRect r = pPaintEvent->rect().intersect(viewport()->rect());
+        /* We have to disable paint on screen if we are using the regular painter: */
+        bool paintOnScreen = viewport()->testAttribute(Qt::WA_PaintOnScreen);
+        viewport()->setAttribute(Qt::WA_PaintOnScreen, false);
+        QPainter pnt(viewport());
+        pnt.drawPixmap(r.x(), r.y(), m_pauseShot, r.x() + contentsX(), r.y() + contentsY(), r.width(), r.height());
+        /* Restore the attribute to its previous state: */
+        viewport()->setAttribute(Qt::WA_PaintOnScreen, paintOnScreen);
+#ifdef Q_WS_MAC
+        updateDockIcon();
+#endif /* Q_WS_MAC */
+    }
+}
+#if defined(Q_WS_WIN32)
+LRESULT CALLBACK UIMachineView::lowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
+{
+    if (gView && nCode == HC_ACTION && gView->winLowKeyboardEvent(wParam, *(KBDLLHOOKSTRUCT *)lParam))
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    /* Else just propagate to base-class: */
+    return QObject::eventFilter(pWatchedObject, pEvent);
+}
+#if defined(Q_WS_WIN)
+LRESULT CALLBACK UIKeyboardHandler::lowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
+{
+    if (nCode == HC_ACTION && m_pKeyboardHandler->winLowKeyboardEvent(wParam, *(KBDLLHOOKSTRUCT*)lParam))
         return 1;
 …
+}
 bool UIMachineView::winLowKeyboardEvent(UINT msg, const KBDLLHOOKSTRUCT &event)
+bool UIKeyboardHandler::winLowKeyboardEvent(UINT msg, const KBDLLHOOKSTRUCT &event)
+{
     /* Sometimes it happens that Win inserts additional events on some key
 …
      * of these strange events.  Let's hope we are not missing anything else
      * of importance! */
     if (hasFocus() && (event.scanCode & ~0xFF))
+    if (m_views[m_iKeyboardHookViewIndex]->hasFocus() && (event.scanCode & ~0xFF))
+    {
         if (event.vkCode == VK_CAPITAL)
 …
+    }
     if (!m_bIsKeyboardCaptured)
+    if (!m_fIsKeyboardCaptured)
         return false;
     /* it's possible that a key has been pressed while the keyboard was not
+    /* It's possible that a key has been pressed while the keyboard was not
      * captured, but is being released under the capture. Detect this situation
      * and return false to let Windows process the message normally and update
 …
     MSG message;
     message.hwnd = winId();
+    message.hwnd = m_views[m_iKeyboardHookViewIndex]->winId();
     message.message = msg;
     message.wParam = event.vkCode;
 …
         message.lParam &= ~0x1000000;
     /* we suppose here that this hook is always called on the main GUI thread */
+    /* We suppose here that this hook is always called on the main GUI thread */
     long dummyResult;
+    return winEvent(&message, &dummyResult);
+}
+bool UIMachineView::winEvent(MSG *aMsg, long* /* aResult */)
+{
+    if (!(aMsg->message == WM_KEYDOWN || aMsg->message == WM_SYSKEYDOWN ||
+          aMsg->message == WM_KEYUP || aMsg->message == WM_SYSKEYUP))
+    return m_views[m_iKeyboardHookViewIndex]->winEvent(&message, &dummyResult);
+}
+#elif defined(Q_WS_MAC)
+void UIKeyboardHandler::darwinGrabKeyboardEvents(bool fGrab)
+{
+    m_fKeyboardGrabbed = fGrab;
+    if (fGrab)
+    {
+        /* Disable mouse and keyboard event compression/delaying to make sure we *really* get all of the events. */
+        ::CGSetLocalEventsSuppressionInterval(0.0);
+        machineLogic()->mouseHandler()->setMouseCoalescingEnabled(false);
+        /* Register the event callback/hook and grab the keyboard. */
+        UICocoaApplication::instance()->registerForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */,
+                                                                UIKeyboardHandler::darwinEventHandlerProc, this);
+        ::DarwinGrabKeyboard(false);
+    }
+    else
+    {
+        ::DarwinReleaseKeyboard();
+        UICocoaApplication::instance()->unregisterForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */,
+                                                                  UIKeyboardHandler::darwinEventHandlerProc, this);
+    }
+}
+bool UIKeyboardHandler::darwinEventHandlerProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser)
+{
+    UIKeyboardHandler *pKeyboardHandler = (UIKeyboardHandler*)pvUser;
+    EventRef inEvent = (EventRef)pvCarbonEvent;
+    UInt32 eventClass = ::GetEventClass(inEvent);
+    /* Check if this is an application key combo. In that case we will not pass
+     * the event to the guest, but let the host process it. */
+    if (::darwinIsApplicationCommand(pvCocoaEvent))
         return false;
+    /* Check for the special flag possibly set at the end of this function */
+    if (aMsg->lParam & (0x1 << 25))
+    {
+        aMsg->lParam &= ~(0x1 << 25);
+        return false;
+    }
+    int scan = (aMsg->lParam >> 16) & 0x7F;
+    /* scancodes 0x80 and 0x00 are ignored */
+    if (!scan)
+        return true;
+    int vkey = aMsg->wParam;
+    /* When one of the SHIFT keys is held and one of the cursor movement
+     * keys is pressed, Windows duplicates SHIFT press/release messages,
+     * but with the virtual key code set to 0xFF. These virtual keys are also
+     * sent in some other situations (Pause, PrtScn, etc.). Ignore such
+     * messages. */
+    if (vkey == 0xFF)
+        return true;
+    int flags = 0;
+    if (aMsg->lParam & 0x1000000)
+        flags |= KeyExtended;
+    if (!(aMsg->lParam & 0x80000000))
+        flags |= KeyPressed;
+    switch (vkey)
+    {
+        case VK_SHIFT:
+        case VK_CONTROL:
+        case VK_MENU:
+        {
+            /* overcome stupid Win32 modifier key generalization */
+            int keyscan = scan;
+            if (flags & KeyExtended)
+                keyscan |= 0xE000;
+            switch (keyscan)
+            {
+                case 0x002A: vkey = VK_LSHIFT; break;
+                case 0x0036: vkey = VK_RSHIFT; break;
+                case 0x001D: vkey = VK_LCONTROL; break;
+                case 0xE01D: vkey = VK_RCONTROL; break;
+                case 0x0038: vkey = VK_LMENU; break;
+                case 0xE038: vkey = VK_RMENU; break;
+            }
+            break;
+        }
+        case VK_NUMLOCK:
+            /* Win32 sets the extended bit for the NumLock key. Reset it. */
+            flags &= ~KeyExtended;
+            break;
+        case VK_SNAPSHOT:
+            flags |= KeyPrint;
+            break;
+        case VK_PAUSE:
+            flags |= KeyPause;
+            break;
+    }
+    bool result = keyEvent(vkey, scan, flags);
+    if (!result && m_bIsKeyboardCaptured)
+    {
+        /* keyEvent() returned that it didn't process the message, but since the
+         * keyboard is captured, we don't want to pass it to Windows. We just want
+         * to let Qt process the message (to handle non-alphanumeric <HOST>+key
+         * shortcuts for example). So send it direcltly to the window with the
+         * special flag in the reserved area of lParam (to avoid recursion). */
+        ::SendMessage(aMsg->hwnd, aMsg->message,
+                      aMsg->wParam, aMsg->lParam | (0x1 << 25));
+        return true;
+    }
+    /* These special keys have to be handled by Windows as well to update the
+     * internal modifier state and to enable/disable the keyboard LED */
+    if (vkey == VK_NUMLOCK || vkey == VK_CAPITAL || vkey == VK_LSHIFT || vkey == VK_RSHIFT)
+        return false;
+    return result;
+}
+#elif defined(Q_WS_PM)
+bool UIMachineView::pmEvent(QMSG *aMsg)
+{
+    if (aMsg->msg == UM_PREACCEL_CHAR)
+    {
+        /* We are inside the input hook
+         * let the message go through the normal system pipeline. */
+        if (!m_bIsKeyboardCaptured)
+            return false;
+    }
+    if (aMsg->msg != WM_CHAR && aMsg->msg != UM_PREACCEL_CHAR)
+        return false;
+    /* check for the special flag possibly set at the end of this function */
+    if (SHORT2FROMMP(aMsg->mp2) & 0x8000)
+    {
+        aMsg->mp2 = MPFROM2SHORT(SHORT1FROMMP(aMsg->mp2), SHORT2FROMMP(aMsg->mp2) & ~0x8000);
+        return false;
+    }
+    USHORT ch = SHORT1FROMMP(aMsg->mp2);
+    USHORT f = SHORT1FROMMP(aMsg->mp1);
+    int scan = (unsigned int)CHAR4FROMMP(aMsg->mp1);
+    if (!scan || scan > 0x7F)
+        return true;
+    int vkey = QIHotKeyEdit::virtualKey(aMsg);
+    int flags = 0;
+    if ((ch & 0xFF) == 0xE0)
+    {
+        flags |= KeyExtended;
+        scan = ch >> 8;
+    }
+    else if (scan == 0x5C && (ch & 0xFF) == '/')
+    {
+        /* this is the '/' key on the keypad */
+        scan = 0x35;
+        flags |= KeyExtended;
+    }
+    else
+    {
+        /* For some keys, the scan code passed in QMSG is a pseudo scan
+         * code. We replace it with a real hardware scan code, according to
+         * http://www.computer-engineering.org/ps2keyboard/scancodes1.html.
+         * Also detect Pause and PrtScn and set flags. */
+        switch (vkey)
+        {
+            case VK_ENTER:     scan = 0x1C; flags |= KeyExtended; break;
+            case VK_CTRL:      scan = 0x1D; flags |= KeyExtended; break;
+            case VK_ALTGRAF:   scan = 0x38; flags |= KeyExtended; break;
+            case VK_LWIN:      scan = 0x5B; flags |= KeyExtended; break;
+            case VK_RWIN:      scan = 0x5C; flags |= KeyExtended; break;
+            case VK_WINMENU:   scan = 0x5D; flags |= KeyExtended; break;
+            case VK_FORWARD:   scan = 0x69; flags |= KeyExtended; break;
+            case VK_BACKWARD:  scan = 0x6A; flags |= KeyExtended; break;
+#if 0
+            /// @todo this would send 0xE0 0x46 0xE0 0xC6. It's not fully
+            // clear what is more correct
+            case VK_BREAK:     scan = 0x46; flags |= KeyExtended; break;
+#else
+            case VK_BREAK:     scan = 0;    flags |= KeyPause; break;
+#endif
+            case VK_PAUSE:     scan = 0;    flags |= KeyPause;    break;
+            case VK_PRINTSCRN: scan = 0;    flags |= KeyPrint;    break;
+            default:;
+        }
+    }
+    if (!(f & KC_KEYUP))
+        flags |= KeyPressed;
+    bool result = keyEvent (vkey, scan, flags);
+    if (!result && m_bIsKeyboardCaptured)
+    {
+        /* keyEvent() returned that it didn't process the message, but since the
+         * keyboard is captured, we don't want to pass it to PM. We just want
+         * to let Qt process the message (to handle non-alphanumeric <HOST>+key
+         * shortcuts for example). So send it direcltly to the window with the
+         * special flag in the reserved area of lParam (to avoid recursion). */
+        ::WinSendMsg (aMsg->hwnd, WM_CHAR, aMsg->mp1,
+                      MPFROM2SHORT (SHORT1FROMMP (aMsg->mp2), SHORT2FROMMP (aMsg->mp2) | 0x8000));
+        return true;
+    }
+    return result;
+}
+#elif defined(Q_WS_X11)
+static Bool VBoxConsoleViewCompEvent(Display *, XEvent *pEvent, XPointer pvArg)
+{
+    XEvent *pKeyEvent = (XEvent*)pvArg;
+    if ((pEvent->type == XKeyPress) && (pEvent->xkey.keycode == pKeyEvent->xkey.keycode))
+        return True;
+    else
+        return False;
+}
+bool UIMachineView::x11Event(XEvent *pEvent)
+{
+    switch (pEvent->type)
+    {
+        /* We have to handle XFocusOut right here as this event is not passed
+         * to UIMachineView::event(). Handling this event is important for
+         * releasing the keyboard before the screen saver gets active.
+         *
+         * See public ticket #3894: Apparently this makes problems with newer
+         * versions of Qt and this hack is probably not necessary anymore.
+         * So disable it for Qt >= 4.5.0. */
+        case XFocusOut:
+        case XFocusIn:
+            if (uisession()->isRunning())
+            {
+                if (VBoxGlobal::qtRTVersion() < ((4 << 16) | (5 << 8) | 0))
+                {
+                    focusEvent(pEvent->type == XFocusIn);
+                    if (pEvent->type == XFocusOut)
+                        machineLogic()->mouseHandler()->releaseMouse();
+                }
+            }
+            return false;
+        case XKeyPress:
+        case XKeyRelease:
+            break;
+        default:
+            return false; /* pass the event to Qt */
+    }
+    /* Translate the keycode to a PC scan code. */
+    unsigned scan = handleXKeyEvent(pEvent);
+    /* scancodes 0x00 (no valid translation) and 0x80 are ignored */
+    if (!scan & 0x7F)
+        return true;
+    /* Fix for http://www.virtualbox.org/ticket/1296:
+     * when X11 sends events for repeated keys, it always inserts an
+     * XKeyRelease before the XKeyPress. */
+    XEvent returnEvent;
+    if ((pEvent->type == XKeyRelease) && (XCheckIfEvent(pEvent->xkey.display, &returnEvent,
+        VBoxConsoleViewCompEvent, (XPointer)pEvent) == True))
+    {
+        XPutBackEvent(pEvent->xkey.display, &returnEvent);
+        /* Discard it, don't pass it to Qt. */
+        return true;
+    }
+    KeySym ks = ::XKeycodeToKeysym(pEvent->xkey.display, pEvent->xkey.keycode, 0);
+    int flags = 0;
+    if (scan >> 8)
+        flags |= KeyExtended;
+    if (pEvent->type == XKeyPress)
+        flags |= KeyPressed;
+    /* Remove the extended flag */
+    scan &= 0x7F;
+    switch (ks)
+    {
+        case XK_Print:
+            flags |= KeyPrint;
+            break;
+        case XK_Pause:
+            flags |= KeyPause;
+            break;
+    }
+    return keyEvent(ks, scan, flags);
+}
+#elif defined(Q_WS_MAC)
+bool UIMachineView::darwinKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent)
+    /* All keyboard class events needs to be handled. */
+    if (eventClass == kEventClassKeyboard)
+    {
+        if (pKeyboardHandler->darwinKeyboardEvent(pvCocoaEvent, inEvent))
+            return true;
+    }
+    /* Pass the event along. */
+    return false;
+}
+bool UIKeyboardHandler::darwinKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent)
+{
     bool ret = false;
 …
     if (EventKind != kEventRawKeyModifiersChanged)
+    {
         /* convert keycode to set 1 scan code. */
+        /* Convert keycode to set 1 scan code. */
         UInt32 keyCode = ~0U;
         ::GetEventParameter(inEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof (keyCode), NULL, &keyCode);
         unsigned scanCode = ::DarwinKeycodeToSet1Scancode(keyCode);
+        uint8_t scanCode = ::DarwinKeycodeToSet1Scancode(keyCode);
         if (scanCode)
+        {
             /* calc flags. */
+            /* Calc flags. */
             int flags = 0;
             if (EventKind != kEventRawKeyUp)
 …
             scanCode &= VBOXKEY_SCANCODE_MASK;
             /* get the unicode string (if present). */
+            /* Get the unicode string (if present). */
             AssertCompileSize(wchar_t, 2);
             AssertCompileSize(UniChar, 2);
 …
             ucs[cbWritten / sizeof(wchar_t)] = 0; /* The api doesn't terminate it. */
             ret = keyEvent(keyCode, scanCode, flags, ucs[0] ? ucs : NULL);
+            ret = keyEvent(keyCode, scanCode, flags, uScreenId, ucs[0] ? ucs : NULL);
+        }
+    }
 …
                 if (!(changed & (1 << bit)))
                     continue;
                 unsigned scanCode = ::DarwinModifierMaskToSet1Scancode(1 << bit);
+                uint8_t scanCode = ::DarwinModifierMaskToSet1Scancode(1 << bit);
                 if (!scanCode)
                     continue;
 …
                         flags |= KeyExtended;
                     scanCode &= VBOXKEY_SCANCODE_MASK;
                     ret |= keyEvent(keyCode, scanCode & 0xff, flags);
+                    ret |= keyEvent(keyCode, scanCode & 0xff, flags, uScreenId);
+                }
                 else
 …
                         flags |= KeyExtended;
                     scanCode &= VBOXKEY_SCANCODE_MASK;
                     keyEvent(keyCode, scanCode, flags | KeyPressed);
                     keyEvent(keyCode, scanCode, flags);
+                    keyEvent(keyCode, scanCode, flags | KeyPressed, uScreenId);
+                    keyEvent(keyCode, scanCode, flags, uScreenId);
+                }
+            }
 …
+}
+void UIMachineView::darwinGrabKeyboardEvents(bool fGrab)
+{
+    m_fKeyboardGrabbed = fGrab;
+    if (fGrab)
+    {
+        /* Disable mouse and keyboard event compression/delaying to make sure we *really* get all of the events. */
+        ::CGSetLocalEventsSuppressionInterval(0.0);
+        machineLogic()->mouseHandler()->setMouseCoalescingEnabled(false);
+        /* Register the event callback/hook and grab the keyboard. */
+        UICocoaApplication::instance()->registerForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */,
+                                                                UIMachineView::darwinEventHandlerProc, this);
+        ::DarwinGrabKeyboard (false);
+#endif
+bool UIKeyboardHandler::keyEvent(int iKey, uint8_t uScan, int fFlags, ulong uScreenId, wchar_t *pUniKey /* = NULL */)
+{
+    const bool isHostKey = iKey == m_globalSettings.hostKey();
+    LONG buf[16];
+    LONG *codes = buf;
+    uint count = 0;
+    uint8_t whatPressed = 0;
+    if (!isHostKey && !m_bIsHostkeyPressed)
+    {
+        if (fFlags & KeyPrint)
+        {
+            static LONG PrintMake[] = { 0xE0, 0x2A, 0xE0, 0x37 };
+            static LONG PrintBreak[] = { 0xE0, 0xB7, 0xE0, 0xAA };
+            if (fFlags & KeyPressed)
+            {
+                codes = PrintMake;
+                count = SIZEOF_ARRAY(PrintMake);
+            }
+            else
+            {
+                codes = PrintBreak;
+                count = SIZEOF_ARRAY(PrintBreak);
+            }
+        }
+        else if (fFlags & KeyPause)
+        {
+            if (fFlags & KeyPressed)
+            {
+                static LONG Pause[] = { 0xE1, 0x1D, 0x45, 0xE1, 0x9D, 0xC5 };
+                codes = Pause;
+                count = SIZEOF_ARRAY(Pause);
+            }
+            else
+            {
+                /* Pause shall not produce a break code */
+                return true;
+            }
+        }
+        else
+        {
+            if (fFlags & KeyPressed)
+            {
+                /* Check if the guest has the same view on the modifier keys (NumLock,
+                 * CapsLock, ScrollLock) as the X server. If not, send KeyPress events
+                 * to synchronize the state. */
+                fixModifierState(codes, &count);
+            }
+            /* Check if it's C-A-D and GUI/PassCAD is not true */
+            if (!m_fPassCAD &&
+                uScan == 0x53 /* Del */ &&
+                ((m_pressedKeys[0x38] & IsKeyPressed) /* Alt */ ||
+                 (m_pressedKeys[0x38] & IsExtKeyPressed)) &&
+                ((m_pressedKeys[0x1d] & IsKeyPressed) /* Ctrl */ ||
+                 (m_pressedKeys[0x1d] & IsExtKeyPressed)))
+            {
+                /* Use the C-A-D combination as a last resort to get the
+                 * keyboard and mouse back to the host when the user forgets
+                 * the Host Key. Note that it's always possible to send C-A-D
+                 * to the guest using the Host+Del combination. BTW, it would
+                 * be preferrable to completely ignore C-A-D in guests, but
+                 * that's not possible because we cannot predict what other
+                 * keys will be pressed next when one of C, A, D is held. */
+                if (uisession()->isRunning() && m_fIsKeyboardCaptured)
+                {
+                    releaseKeyboard();
+                    if (!uisession()->isMouseSupportsAbsolute() || !uisession()->isMouseIntegrated())
+                        machineLogic()->mouseHandler()->releaseMouse();
+                }
+                return true;
+            }
+            /* Process the scancode and update the table of pressed keys: */
+            whatPressed = IsKeyPressed;
+            if (fFlags & KeyExtended)
+            {
+                codes[count++] = 0xE0;
+                whatPressed = IsExtKeyPressed;
+            }
+            if (fFlags & KeyPressed)
+            {
+                codes[count++] = uScan;
+                m_pressedKeys[uScan] |= whatPressed;
+            }
+            else
+            {
+                /* If we haven't got this key's press message, we ignore its release: */
+                if (!(m_pressedKeys[uScan] & whatPressed))
+                    return true;
+                codes[count++] = uScan | 0x80;
+                m_pressedKeys[uScan] &= ~whatPressed;
+            }
+            if (m_fIsKeyboardCaptured)
+                m_pressedKeys[uScan] |= IsKbdCaptured;
+            else
+                m_pressedKeys[uScan] &= ~IsKbdCaptured;
+        }
+    }
     else
+    {
+        ::DarwinReleaseKeyboard();
+        UICocoaApplication::instance()->unregisterForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */,
+                                                                  UIMachineView::darwinEventHandlerProc, this);
+    }
+}
+bool UIMachineView::darwinEventHandlerProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser)
+{
+    UIMachineView *view = (UIMachineView*)pvUser;
+    EventRef inEvent = (EventRef)pvCarbonEvent;
+    UInt32 eventClass = ::GetEventClass(inEvent);
+    /* Check if this is an application key combo. In that case we will not pass
+     * the event to the guest, but let the host process it. */
+    if (::darwinIsApplicationCommand(pvCocoaEvent))
+        return false;
+    /* All keyboard class events needs to be handled. */
+    if (eventClass == kEventClassKeyboard)
+    {
+        if (view->darwinKeyboardEvent (pvCocoaEvent, inEvent))
+            return true;
+    }
+    /* Pass the event along. */
+    return false;
+}
+        /* Currently this is used in winLowKeyboardEvent() only: */
+        m_bIsHostkeyInCapture = m_fIsKeyboardCaptured;
+    }
+    bool emitSignal = false;
+    int hotkey = 0;
+    /* Process the host key: */
+    if (fFlags & KeyPressed)
+    {
+        if (isHostKey)
+        {
+            if (!m_bIsHostkeyPressed)
+            {
+                m_bIsHostkeyPressed = m_bIsHostkeyAlone = true;
+                if (uisession()->isRunning())
+                    saveKeyStates();
+                emitSignal = true;
+            }
+        }
+        else
+        {
+            if (m_bIsHostkeyPressed)
+            {
+                if (m_bIsHostkeyAlone)
+                {
+                    hotkey = iKey;
+                    m_bIsHostkeyAlone = false;
+                }
+            }
+        }
+    }
+    else
+    {
+        if (isHostKey)
+        {
+            if (m_bIsHostkeyPressed)
+            {
+                m_bIsHostkeyPressed = false;
+                if (m_bIsHostkeyAlone)
+                {
+                    if (uisession()->isPaused())
+                    {
+                        vboxProblem().remindAboutPausedVMInput();
+                    }
+                    else if (uisession()->isRunning())
+                    {
+                        bool ok = true;
+                        if (!m_fIsKeyboardCaptured)
+                        {
+                            /* Temporarily disable auto capture that will take
+                             * place after this dialog is dismissed because
+                             * the capture state is to be defined by the
+                             * dialog result itself */
+                            uisession()->setAutoCaptureDisabled(true);
+                            bool autoConfirmed = false;
+                            ok = vboxProblem().confirmInputCapture(&autoConfirmed);
+                            if (autoConfirmed)
+                                uisession()->setAutoCaptureDisabled(false);
+                            /* Otherwise, the disable flag will be reset in
+                             * the next console view's foucs in event (since
+                             * may happen asynchronously on some platforms,
+                             * after we return from this code) */
+                        }
+                        if (ok)
+                        {
+                            if (m_fIsKeyboardCaptured)
+                                releaseKeyboard();
+                            else
+                                captureKeyboard(uScreenId);
+                            if (!uisession()->isMouseSupportsAbsolute() || !uisession()->isMouseIntegrated())
+                            {
+#ifdef Q_WS_X11
+                                /* Make sure that pending FocusOut events from the
+                                 * previous message box are handled, otherwise the
+                                 * mouse is immediately ungrabbed. */
+                                qApp->processEvents();
 #endif
+void UIMachineView::fixModifierState(LONG *piCodes, uint *puCount)
+                                if (m_fIsKeyboardCaptured)
+                                    machineLogic()->mouseHandler()->captureMouse(uScreenId);
+                                else
+                                    machineLogic()->mouseHandler()->releaseMouse();
+                            }
+                        }
+                    }
+                }
+                if (uisession()->isRunning())
+                    sendChangedKeyStates();
+                emitSignal = true;
+            }
+        }
+        else
+        {
+            if (m_bIsHostkeyPressed)
+                m_bIsHostkeyAlone = false;
+        }
+    }
+    /* Notify all listeners: */
+    emit keyboardStateChanged(keyboardState());
+    /* Process Host+<key> shortcuts. currently, <key> is limited to
+     * alphanumeric chars. Other Host+<key> combinations are handled in
+     * event(). */
+    if (hotkey)
+    {
+        bool processed = false;
+#if defined (Q_WS_WIN)
+        NOREF(pUniKey);
+        int n = GetKeyboardLayoutList(0, NULL);
+        Assert(n);
+        HKL *list = new HKL[n];
+        GetKeyboardLayoutList(n, list);
+        for (int i = 0; i < n && !processed; i++)
+        {
+            wchar_t ch;
+            static BYTE keys[256] = {0};
+            if (!ToUnicodeEx(hotkey, 0, keys, &ch, 1, 0, list[i]) == 1)
+                ch = 0;
+            if (ch)
+                processed = machineLogic()->actionsPool()->processHotKey(QKeySequence((Qt::UNICODE_ACCEL + QChar(ch).toUpper().unicode())));
+        }
+        delete[] list;
+#elif defined (Q_WS_X11)
+        NOREF(pUniKey);
+        Display *display = QX11Info::display();
+        int keysyms_per_keycode = getKeysymsPerKeycode();
+        KeyCode kc = XKeysymToKeycode (display, iKey);
+        for (int i = 0; i < keysyms_per_keycode && !processed; i += 2)
+        {
+            KeySym ks = XKeycodeToKeysym(display, kc, i);
+            char ch = 0;
+            if (!XkbTranslateKeySym(display, &ks, 0, &ch, 1, NULL) == 1)
+                ch = 0;
+            if (ch)
+                QChar c = QString::fromLocal8Bit(&ch, 1)[0];
+        }
+#elif defined (Q_WS_MAC)
+        if (pUniKey && pUniKey[0] && !pUniKey[1])
+            processed = machineLogic()->actionsPool()->processHotKey(QKeySequence(Qt::UNICODE_ACCEL + QChar(pUniKey[0]).toUpper().unicode()));
+        /* Don't consider the hot key as pressed since the guest never saw
+         * it. (probably a generic thing) */
+        m_pressedKeys[uScan] &= ~whatPressed;
+#endif
+        /* Grab the key from Qt if processed, or pass it to Qt otherwise
+         * in order to process non-alphanumeric keys in event(), after they are
+         * converted to Qt virtual keys. */
+        return processed;
+    }
+    /* No more to do, if the host key is in action or the VM is paused: */
+    if (m_bIsHostkeyPressed || isHostKey || uisession()->isPaused())
+    {
+        /* Grab the key from Qt and from VM if it's a host key,
+         * otherwise just pass it to Qt */
+        return isHostKey;
+    }
+    CKeyboard keyboard = session().GetConsole().GetKeyboard();
+    Assert(!keyboard.isNull());
+#ifdef Q_WS_WIN
+    /* Send pending WM_PAINT events: */
+    ::UpdateWindow(m_views[uScreenId]->viewport()->winId());
+#endif /* Q_WS_WIN */
+    std::vector <LONG> scancodes(codes, &codes[count]);
+    keyboard.PutScancodes(QVector<LONG>::fromStdVector(scancodes));
+    /* Grab the key from Qt: */
+    return true;
+}
+void UIKeyboardHandler::fixModifierState(LONG *piCodes, uint *puCount)
+{
     /* Synchronize the views of the host and the guest to the modifier keys.
      * This function will add up to 6 additional keycodes to codes. */
 #if defined(Q_WS_X11)
     Window   wDummy1, wDummy2;
     int      iDummy3, iDummy4, iDummy5, iDummy6;
 …
+        }
+    }
+#elif defined(Q_WS_WIN32)
+#elif defined(Q_WS_WIN)
     if (uisession()->numLockAdaptionCnt() && (uisession()->isNumLock() ^ !!(GetKeyState(VK_NUMLOCK))))
+    {
 …
+        }
+    }
 #elif defined(Q_WS_MAC)
     /* if (uisession()->numLockAdaptionCnt()) ... - NumLock isn't implemented by Mac OS X so ignore it. */
     if (uisession()->capsLockAdaptionCnt() && (uisession()->isCapsLock() ^ !!(::GetCurrentEventKeyModifiers() & alphaLock)))
 …
+        }
+    }
 #else
+//#warning Adapt UIMachineView::fixModifierState
+//#warning Adapt UIKeyboardHandler::fixModifierState
 #endif
+}
+QPoint UIMachineView::viewportToContents(const QPoint &vp) const
+{
+    return QPoint(vp.x() + contentsX(), vp.y() + contentsY());
+}
+void UIMachineView::scrollBy(int dx, int dy)
+{
+    horizontalScrollBar()->setValue(horizontalScrollBar()->value() + dx);
+    verticalScrollBar()->setValue(verticalScrollBar()->value() + dy);
+}
+#ifdef VBOX_WITH_VIDEOHWACCEL
+void UIMachineView::scrollContentsBy(int dx, int dy)
+{
+    if (m_pFrameBuffer)
+    {
+        m_pFrameBuffer->viewportScrolled(dx, dy);
+    }
+    QAbstractScrollArea::scrollContentsBy(dx, dy);
+}
+#endif
+void UIMachineView::emitKeyboardStateChanged()
+{
+    emit keyboardStateChanged(keyboardState());
+}
+void UIMachineView::captureKbd(bool fCapture, bool fEmitSignal /* = true */)
+{
+    if (m_bIsKeyboardCaptured == fCapture)
+        return;
+#if defined(Q_WS_WIN32)
+    /* On Win32, keyboard grabbing is ineffective, a low-level keyboard hook is used instead. */
+#elif defined(Q_WS_X11)
+    /* On X11, we are using passive XGrabKey for normal (windowed) mode
+     * instead of XGrabKeyboard (called by QWidget::grabKeyboard())
+     * because XGrabKeyboard causes a problem under metacity - a window cannot be moved
+     * using the mouse if it is currently actively grabing the keyboard;
+     * For static modes we are using usual (active) keyboard grabbing. */
+    switch (machineLogic()->visualStateType())
+    {
+        /* If window is moveable we are making passive keyboard grab: */
+        case UIVisualStateType_Normal:
+        {
+            if (fCapture)
+                XGrabKey(QX11Info::display(), AnyKey, AnyModifier, machineWindowWrapper()->machineWindow()->winId(), False, GrabModeAsync, GrabModeAsync);
+            else
+                XUngrabKey(QX11Info::display(), AnyKey, AnyModifier, machineWindowWrapper()->machineWindow()->winId());
+            break;
+        }
+        /* If window is NOT moveable we are making active keyboard grab: */
+        case UIVisualStateType_Fullscreen:
+        case UIVisualStateType_Seamless:
+        {
+            if (fCapture)
+            {
+                /* Keyboard grabbing can fail because of some keyboard shortcut is still grabbed by window manager.
+                 * We can't be sure this shortcut will be released at all, so we will retry to grab keyboard for 50 times,
+                 * and after we will just ignore that issue: */
+                int cTriesLeft = 50;
+                while (cTriesLeft && XGrabKeyboard(QX11Info::display(), machineWindowWrapper()->machineWindow()->winId(), False, GrabModeAsync, GrabModeAsync, CurrentTime)) { --cTriesLeft; }
+            }
+            else
+                XUngrabKeyboard(QX11Info::display(), CurrentTime);
+            break;
+        }
+        /* Should we try to grab keyboard in default case? I think - NO. */
+        default:
+            break;
+    }
+#elif defined(Q_WS_MAC)
+    /* On Mac OS X, we use the Qt methods + disabling global hot keys + watching modifiers
+     * (for right/left separation). */
+    if (fCapture)
+    {
+        ::DarwinDisableGlobalHotKeys(true);
+        grabKeyboard();
+    }
+    else
+    {
+        ::DarwinDisableGlobalHotKeys(false);
+        releaseKeyboard();
+    }
+#else
+    if (fCapture)
+        grabKeyboard();
+    else
+        releaseKeyboard();
+#endif
+    m_bIsKeyboardCaptured = fCapture;
+    if (fEmitSignal)
+        emitKeyboardStateChanged();
+}
+void UIMachineView::saveKeyStates()
+void UIKeyboardHandler::saveKeyStates()
+{
     ::memcpy(m_pressedKeysCopy, m_pressedKeys, sizeof(m_pressedKeys));
+}
 void UIMachineView::releaseAllPressedKeys(bool aReleaseHostKey /* = true */)
+void UIKeyboardHandler::releaseAllPressedKeys(bool aReleaseHostKey /* = true */)
+{
     CKeyboard keyboard = session().GetConsole().GetKeyboard();
 …
     m_darwinKeyModifiers &=
         alphaLock | kEventKeyModifierNumLockMask |
         (aReleaseHostKey ? 0 : ::DarwinKeyCodeToDarwinModifierMask (m_globalSettings.hostKey()));
+        (aReleaseHostKey ? 0 : ::DarwinKeyCodeToDarwinModifierMask(m_globalSettings.hostKey()));
 #endif
     emitKeyboardStateChanged();
+}
 void UIMachineView::sendChangedKeyStates()
+    emit keyboardStateChanged(keyboardState());
+}
+void UIKeyboardHandler::sendChangedKeyStates()
+{
     QVector <LONG> codes(2);
 …
+}
+void UIMachineView::dimImage(QImage &img)
+{
+    for (int y = 0; y < img.height(); ++ y)
+    {
+        if (y % 2)
+        {
+            if (img.depth() == 32)
+            {
+                for (int x = 0; x < img.width(); ++ x)
+                {
+                    int gray = qGray(img.pixel (x, y)) / 2;
+                    img.setPixel(x, y, qRgb (gray, gray, gray));
+                }
+            }
+            else
+            {
+                ::memset(img.scanLine (y), 0, img.bytesPerLine());
+            }
+        }
+        else
+        {
+            if (img.depth() == 32)
+            {
+                for (int x = 0; x < img.width(); ++ x)
+                {
+                    int gray = (2 * qGray (img.pixel (x, y))) / 3;
+                    img.setPixel(x, y, qRgb (gray, gray, gray));
+                }
+            }
+        }
+    }
+}
+#ifdef Q_WS_MAC
+CGImageRef UIMachineView::vmContentImage()
+{
+    if (!m_pauseShot.isNull())
+    {
+        CGImageRef pauseImg = ::darwinToCGImageRef(&m_pauseShot);
+        /* Use the pause image as background */
+        return pauseImg;
+    }
+    else
+    {
+# ifdef VBOX_GUI_USE_QUARTZ2D
+        if (vboxGlobal().vmRenderMode() == VBoxDefs::Quartz2DMode)
+        {
+            /* If the render mode is Quartz2D we could use the CGImageRef
+             * of the framebuffer for the dock icon creation. This saves
+             * some conversion time. */
+            CGImageRef image = static_cast<UIFrameBufferQuartz2D*>(m_pFrameBuffer)->imageRef();
+            CGImageRetain(image); /* Retain it, cause the consumer will release it. */
+            return image;
+        }
+        else
+# endif /* VBOX_GUI_USE_QUARTZ2D */
+            /* In image mode we have to create the image ref out of the
+             * framebuffer */
+            return frameBuffertoCGImageRef(m_pFrameBuffer);
+    }
+    return 0;
+}
+CGImageRef UIMachineView::frameBuffertoCGImageRef(UIFrameBuffer *pFrameBuffer)
+{
+    CGColorSpaceRef cs = CGColorSpaceCreateDeviceRGB();
+    Assert(cs);
+    /* Create the image copy of the framebuffer */
+    CGDataProviderRef dp = CGDataProviderCreateWithData(pFrameBuffer, pFrameBuffer->address(), pFrameBuffer->bitsPerPixel() / 8 * pFrameBuffer->width() * pFrameBuffer->height(), NULL);
+    Assert(dp);
+    CGImageRef ir = CGImageCreate(pFrameBuffer->width(), pFrameBuffer->height(), 8, 32, pFrameBuffer->bytesPerLine(), cs,
+                                  kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host, dp, 0, false,
+                                  kCGRenderingIntentDefault);
+    Assert(ir);
+    CGDataProviderRelease(dp);
+    CGColorSpaceRelease(cs);
+    return ir;
+}
+void UIMachineView::updateDockIcon()
+{
+    machineLogic()->updateDockIcon();
+}
+#endif /* Q_WS_MAC */
+UIMachineWindow* UIKeyboardHandler::isItListenedWindow(QObject *pWatchedObject) const
+{
+    UIMachineWindow *pResultWindow = 0;
+    QMap<ulong, UIMachineWindow*>::const_iterator i = m_windows.constBegin();
+    while (!pResultWindow && i != m_windows.constEnd())
+    {
+        switch (machineLogic()->visualStateType())
+        {
+            case UIVisualStateType_Normal:
+            {
+                UIMachineWindowNormal *pIteratedWindow = static_cast<UIMachineWindowNormal*>(i.value());
+                if (pIteratedWindow == pWatchedObject)
+                {
+                    pResultWindow = pIteratedWindow;
+                    continue;
+                }
+                break;
+            }
+            case UIVisualStateType_Fullscreen:
+            {
+                UIMachineWindowFullscreen *pIteratedWindow = static_cast<UIMachineWindowFullscreen*>(i.value());
+                if (pIteratedWindow == pWatchedObject)
+                {
+                    pResultWindow = pIteratedWindow;
+                    continue;
+                }
+                break;
+            }
+            case UIVisualStateType_Seamless:
+            {
+                UIMachineWindowSeamless *pIteratedWindow = static_cast<UIMachineWindowSeamless*>(i.value());
+                if (pIteratedWindow == pWatchedObject)
+                {
+                    pResultWindow = pIteratedWindow;
+                    continue;
+                }
+                break;
+            }
+            default:
+                break;
+        }
+        ++i;
+    }
+    return pResultWindow;
+}
+UIMachineView* UIKeyboardHandler::isItListenedView(QObject *pWatchedObject) const
+{
+    UIMachineView *pResultView = 0;
+    QMap<ulong, UIMachineView*>::const_iterator i = m_views.constBegin();
+    while (!pResultView && i != m_views.constEnd())
+    {
+        UIMachineView *pIteratedView = qobject_cast<UIMachineView*>(i.value());
+        if (pIteratedView == pWatchedObject)
+        {
+            pResultView = pIteratedView;
+            continue;
+        }
+        ++i;
+    }
+    return pResultView;
+}

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

-              r30458
+              r30637
+ *
  * VBox frontends: Qt GUI ("VirtualBox"):
  * UIMachineView class declaration
+ * UIKeyboardHandler class declaration
  */
 …
  */
 #ifndef ___UIMachineView_h___
 #define ___UIMachineView_h___
+#ifndef ___UIKeyboardHandler_h___
+#define ___UIKeyboardHandler_h___
 /* Global includes */
 #include <QAbstractScrollArea>
 #include <QEventLoop>
+#include <QObject>
+#include <QMap>
 /* Local includes */
+#include "UIMachineDefs.h"
 #include "COMDefs.h"
-#include "UIMachineDefs.h"
+#ifdef Q_WS_MAC
+# include <CoreFoundation/CFBase.h>
+#endif /* Q_WS_MAC */
+/* Global forwards */
+class QWidget;
 /* Local forwards */
+class CSession;
 class UISession;
 class UIFrameBuffer;
+class UIMachineLogic;
 class UIMachineWindow;
 class UIMachineLogic;
+class UIMachineView;
 class VBoxGlobalSettings;
+#ifdef Q_WS_X11
+typedef union  _XEvent XEvent;
+#endif /* Q_WS_X11 */
+class UIMachineView : public QAbstractScrollArea
+/* Delegate to control VM keyboard functionality: */
+class UIKeyboardHandler : public QObject
+{
     Q_OBJECT;
 …
 public:
+    /* Desktop geometry types: */
+    enum DesktopGeo { DesktopGeo_Invalid = 0, DesktopGeo_Fixed, DesktopGeo_Automatic, DesktopGeo_Any };
+    /* Factory functions to create/destroy keyboard-handler: */
+    static UIKeyboardHandler* create(UIMachineLogic *pMachineLogic, UIVisualStateType visualStateType);
+    static void destroy(UIKeyboardHandler *pKeyboardHandler);
+    /* Factory function to create required view sub-child: */
+    static UIMachineView* create(  UIMachineWindow *pMachineWindow
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                                 , bool bAccelerate2DVideo
+#endif
+                                 , UIVisualStateType visualStateType
+                                 , ulong uScreenId);
+    static void destroy(UIMachineView *pWhichView);
+    /* Prepare/cleanup listeners: */
+    void prepareListener(ulong uIndex, UIMachineWindow *pMachineWindow);
+    void cleanupListener(ulong uIndex);
+    /* Public getters: */
+    /* Commands to capture/release keyboard: */
+    void captureKeyboard(ulong uScreenId);
+    void releaseKeyboard();
+    /* Current keyboard state: */
     int keyboardState() const;
-    virtual QRegion lastVisibleRegion() const { return QRegion(); }
+    /* Public setters: */
+    virtual void setGuestAutoresizeEnabled(bool /* fEnabled */) {}
+    /* Public members: */
+    virtual void normalizeGeometry(bool /* bAdjustPosition = false */) = 0;
+signals:
+    /* Keyboard state-change signals: */
+    void keyboardStateChanged(int iState);
+    /* Utility signals: */
+    void resizeHintDone();
+protected:
+    /* Machine view constructor/destructor: */
+    UIMachineView(  UIMachineWindow *pMachineWindow
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                  , bool bAccelerate2DVideo
+#endif
+                  , ulong uScreenId);
+    virtual ~UIMachineView();
+    /* Protected getters: */
+    UISession* uisession() const;
+    CSession& session();
+    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; }
+    UIMachineWindow* machineWindowWrapper() const { return m_pMachineWindow; }
+    UIMachineLogic* machineLogic() const;
+    /* Some getters required by side-code: */
     bool isHostKeyPressed() const { return m_bIsHostkeyPressed; }
-    bool isMachineWindowResizeIgnored() const { return m_bIsMachineWindowResizeIgnored; }
-    const QPixmap& pauseShot() const { return m_pauseShot; }
-    QSize storedConsoleSize() const { return m_storedConsoleSize; }
-    DesktopGeo desktopGeometryType() const { return m_desktopGeometryType; }
-    QSize desktopGeometry() const;
-    QSize guestSizeHint();
 #ifdef Q_WS_MAC
-    /* These getters are temporary here while UIKeyboardHandler is not implemented: */
     bool isHostKeyAlone() const { return m_bIsHostkeyAlone; }
     bool isKeyboardGrabbed() const { return m_fKeyboardGrabbed; }
 #endif /* Q_WS_MAC */
+    /* Protected setters: */
+    void setDesktopGeometry(DesktopGeo geometry, int iWidth, int iHeight);
+    void storeConsoleSize(int iWidth, int iHeight);
+    void setMachineWindowResizeIgnored(bool fIgnore = true) { m_bIsMachineWindowResizeIgnored = fIgnore; }
+    void storeGuestSizeHint(const QSize &sizeHint);
+    /* External event-filters: */
+#if defined(Q_WS_WIN)
+    bool winEventFilter(MSG *pMsg, ulong uScreenId);
+#elif defined(Q_WS_X11)
+    bool x11EventFilter(XEvent *pEvent, ulong uScreenId);
+#endif
+    /* Protected helpers: */
+    virtual QRect workingArea() = 0;
+    virtual void calculateDesktopGeometry() = 0;
+    virtual void maybeRestrictMinimumSize() = 0;
+    virtual void updateSliders();
+signals:
+#ifdef Q_WS_MAC
+    void updateDockIcon();
+    CGImageRef vmContentImage();
+    CGImageRef frameBuffertoCGImageRef(UIFrameBuffer *pFrameBuffer);
+#endif /* Q_WS_MAC */
+    /* Prepare routines: */
+    virtual void prepareFrameBuffer();
+    virtual void prepareCommon();
+    virtual void prepareFilters();
+    virtual void prepareConsoleConnections();
+    virtual void loadMachineViewSettings();
+    /* Cleanup routines: */
+    //virtual void saveMachineViewSettings() {}
+    //virtual void cleanupConsoleConnections() {}
+    //virtual void cleanupFilters() {}
+    virtual void cleanupCommon();
+    virtual void cleanupFrameBuffer();
+    /* Cross-platforms event processors: */
+    bool event(QEvent *pEvent);
+    bool eventFilter(QObject *pWatched, QEvent *pEvent);
+    /* Protected variables: */
+    QSize m_desktopGeometry;
+    /* Notifies listeners about keyboard state-change: */
+    void keyboardStateChanged(int iNewState);
 protected slots:
     /* Console callback handlers: */
+    /* Machine state-change handler: */
     virtual void sltMachineStateChanged();
-    virtual void sltPerformGuestResize(const QSize & /* toSize */) {};
+    /* Various helper slots: */
+    virtual void sltNormalizeGeometry() { normalizeGeometry(true); }
+protected:
+private:
+    /* Keyboard-handler constructor/destructor: */
+    UIKeyboardHandler(UIMachineLogic *pMachineLogic);
+    virtual ~UIKeyboardHandler();
+    /* Cross-platforms event processors: */
+    void focusEvent(bool aHasFocus, bool aReleaseHostKey = true);
+    bool keyEvent(int aKey, uint8_t aScan, int aFlags, wchar_t *aUniKey = NULL);
+    void resizeEvent(QResizeEvent *pEvent);
+    void moveEvent(QMoveEvent *pEvent);
+    void paintEvent(QPaintEvent *pEvent);
+    /* Prepare helpers: */
+    virtual void prepareCommon();
+    virtual void loadSettings();
+    /* Platform specific event processors: */
+#if defined(Q_WS_WIN32)
+    /* Cleanup helpers: */
+    //virtual void saveSettings() {}
+    virtual void cleanupCommon();
+    /* Common getters: */
+    UIMachineLogic* machineLogic() const;
+    UISession* uisession() const;
+    CSession& session() const;
+    /* Event handler for registered machine-view(s): */
+    bool eventFilter(QObject *pWatchedObject, QEvent *pEvent);
+#if defined(Q_WS_WIN)
     static LRESULT CALLBACK lowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam);
     bool winLowKeyboardEvent(UINT msg, const KBDLLHOOKSTRUCT &event);
-    bool winEvent(MSG *aMsg, long *aResult);
-#elif defined(Q_WS_PM)
-    bool pmEvent(QMSG *aMsg);
-#elif defined(Q_WS_X11)
-    bool x11Event(XEvent *event);
 #elif defined(Q_WS_MAC)
+    void darwinGrabKeyboardEvents(bool fGrab);
     bool darwinKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent);
-    void darwinGrabKeyboardEvents(bool fGrab);
     static bool darwinEventHandlerProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser);
 #endif
+    /* Separate function to handle most of existing keyboard-events: */
+    bool keyEvent(int iKey, uint8_t uScan, int fFlags, ulong uScreenId, wchar_t *pUniKey = 0);
     /* Private helpers: */
     void fixModifierState(LONG *piCodes, uint *puCount);
-    QPoint viewportToContents(const QPoint &vp) const;
-    void scrollBy(int dx, int dy);
-#ifdef VBOX_WITH_VIDEOHWACCEL
-    void scrollContentsBy(int dx, int dy);
-#endif
-    void emitKeyboardStateChanged();
-    void captureKbd(bool fCapture, bool fEmitSignal = true);
     void saveKeyStates();
     void releaseAllPressedKeys(bool aReleaseHostKey = true);
     void sendChangedKeyStates();
+    static void dimImage(QImage &img);
+    UIMachineWindow* isItListenedWindow(QObject *pWatchedObject) const;
+    UIMachineView* isItListenedView(QObject *pWatchedObject) const;
+    /* Private members: */
+    UIMachineWindow *m_pMachineWindow;
+    ulong m_uScreenId;
+    /* Machine logic parent: */
+    UIMachineLogic *m_pMachineLogic;
+    /* Registered machine-window(s): */
+    QMap<ulong, UIMachineWindow*> m_windows;
+    /* Registered machine-view(s): */
+    QMap<ulong, UIMachineView*> m_views;
+    /* Other keyboard variables: */
+    int m_iKeyboardCaptureViewIndex;
     const VBoxGlobalSettings &m_globalSettings;
-    UIFrameBuffer *m_pFrameBuffer;
-    KMachineState m_previousState;
-    DesktopGeo m_desktopGeometryType;
-    QSize m_storedConsoleSize;
     uint8_t m_pressedKeys[128];
     uint8_t m_pressedKeysCopy[128];
     bool m_bIsKeyboardCaptured : 1;
+    bool m_fIsKeyboardCaptured : 1;
     bool m_bIsHostkeyPressed : 1;
     bool m_bIsHostkeyAlone : 1;
     bool m_bIsHostkeyInCapture : 1;
-    bool m_bIsMachineWindowResizeIgnored : 1;
     bool m_fPassCAD : 1;
-#ifdef VBOX_WITH_VIDEOHWACCEL
-    bool m_fAccelerate2DVideo;
-#endif
+#ifdef Q_WS_MAC
+    /** The current modifier key mask. Used to figure out which modifier
+     *  key was pressed when we get a kEventRawKeyModifiersChanged event. */
+#if defined(Q_WS_WIN)
+    /* Keyboard hook required to capture keyboard event under windows. */
+    static UIKeyboardHandler *m_pKeyboardHandler;
+    HHOOK m_keyboardHook;
+    int m_iKeyboardHookViewIndex;
+#elif defined(Q_WS_MAC)
+    /* The current modifier key mask. Used to figure out which modifier
+     * key was pressed when we get a kEventRawKeyModifiersChanged event. */
     UInt32 m_darwinKeyModifiers;
     bool m_fKeyboardGrabbed;
+#endif /* Q_WS_MAC */
+    QPixmap m_pauseShot;
+    /* Friend classes: */
+    friend class UIMouseHandler;
+    friend class UIMachineLogic;
+    friend class UIFrameBuffer;
+    friend class UIFrameBufferQImage;
+    friend class UIFrameBufferQuartz2D;
+    friend class UIFrameBufferQGL;
+    template<class, class, class> friend class VBoxOverlayFrameBuffer;
+#endif
 };
+/* This maintenance class is a part of future roll-back mechanism.
+ * It allows to block main GUI thread until specific event received.
+ * Later it will become more abstract but now its just used to help
+ * fullscreen & seamless modes to restore normal guest size hint. */
+class UIMachineViewBlocker : public QEventLoop
+{
+    Q_OBJECT;
+#endif // !___UIKeyboardHandler_h___
-public:
-    UIMachineViewBlocker()
-        : QEventLoop(0)
-        , m_iTimerId(0)
+    {
-        /* Also start timer to unlock pool in case of
-         * required condition doesn't happens by some reason: */
-        m_iTimerId = startTimer(3000);
+    }
-    virtual ~UIMachineViewBlocker()
+    {
-        /* Kill the timer: */
-        killTimer(m_iTimerId);
+    }
-protected:
-    void timerEvent(QTimerEvent *pEvent)
+    {
-        /* If that timer event occurs => it seems
-         * guest resize event doesn't comes in time,
-         * shame on it, but we just unlocking 'this': */
-        QEventLoop::timerEvent(pEvent);
-        exit();
+    }
-    int m_iTimerId;
-};
-#endif // !___UIMachineView_h___

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

-              r30543
+              r30637
 #include "UIDownloaderAdditions.h"
 #include "UIIconPool.h"
+#include "UIKeyboardHandler.h"
 #include "UIMouseHandler.h"
 #include "UIMachineLogic.h"
 …
+{
     m_machineWindowsList << pMachineWindow;
+}
+void UIMachineLogic::setKeyboardHandler(UIKeyboardHandler *pKeyboardHandler)
+{
+    m_pKeyboardHandler = pKeyboardHandler;
+}
 …
 void UIMachineLogic::prepareHandlers()
+{
+    /* Create keyboard-handler: */
+    setKeyboardHandler(UIKeyboardHandler::create(this, visualStateType()));
     /* Create mouse-handler: */
     setMouseHandler(UIMouseHandler::create(this, visualStateType()));
 …
     /* Cleanup mouse-handler: */
     UIMouseHandler::destroy(mouseHandler());
+    /* Cleanup keyboard-handler: */
+    UIKeyboardHandler::destroy(keyboardHandler());
+}

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

-              r30543
+              r30637
 class UISession;
 class UIActionsPool;
+class UIKeyboardHandler;
 class UIMouseHandler;
 class UIMachineWindow;
 …
     UIVisualStateType visualStateType() const { return m_visualStateType; }
     const QList<UIMachineWindow*>& machineWindows() const { return m_machineWindowsList; }
+    UIKeyboardHandler* keyboardHandler() const { return m_pKeyboardHandler; }
     UIMouseHandler* mouseHandler() const { return m_pMouseHandler; }
     UIMachineWindow* mainMachineWindow() const;
 …
     /* Protected members: */
+    void setKeyboardHandler(UIKeyboardHandler *pKeyboardHandler);
     void setMouseHandler(UIMouseHandler *pMouseHandler);
     void addMachineWindow(UIMachineWindow *pMachineWindow);
 …
     UIActionsPool *m_pActionsPool;
     UIVisualStateType m_visualStateType;
+    UIKeyboardHandler *m_pKeyboardHandler;
     UIMouseHandler *m_pMouseHandler;
     QList<UIMachineWindow*> m_machineWindowsList;

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

-              r30551
+              r30637
 #include "UISession.h"
 #include "UIActionsPool.h"
+#include "UIKeyboardHandler.h"
 #include "UIMouseHandler.h"
 #include "UIMachineLogic.h"
 …
 #include "UIMachineViewSeamless.h"
-#ifdef Q_WS_WIN
-#undef LOWORD
-#undef HIWORD
-#undef LOBYTE
-#undef HIBYTE
-#include <windows.h>
-static UIMachineView *gView = 0;
-static HHOOK gKbdHook = 0;
-#endif /* Q_WS_WIN */
 #ifdef Q_WS_X11
 # include <QX11Info>
-# define XK_XKB_KEYS
-# define XK_MISCELLANY
 # include <X11/XKBlib.h>
-# include <X11/keysym.h>
 # ifdef KeyPress
 const int XFocusOut = FocusOut;
 …
 #  undef FocusIn
 # endif
-# include "XKeyboard.h"
 #endif /* Q_WS_X11 */
 …
 };
-enum { KeyExtended = 0x01, KeyPressed = 0x02, KeyPause = 0x04, KeyPrint = 0x08 };
-enum { IsKeyPressed = 0x01, IsExtKeyPressed = 0x02, IsKbdCaptured = 0x80 };
 UIMachineView* UIMachineView::create(  UIMachineWindow *pMachineWindow
                                      , ulong uScreenId
 …
+{
     delete pMachineView;
+}
-int UIMachineView::keyboardState() const
+{
-    return (m_bIsKeyboardCaptured ? UIViewStateType_KeyboardCaptured : 0) |
-           (m_bIsHostkeyPressed ? UIViewStateType_HostKeyPressed : 0);
+}
 …
                 viewport()->repaint();
+            }
-            /* Reuse the focus event handler to uncapture keyboard: */
-            if (hasFocus())
-                focusEvent(false /* aHasFocus*/, false /* aReleaseHostKey */);
-            break;
+        }
-        case KMachineState_Stuck:
+        {
-            /* Reuse the focus event handler to uncapture keyboard: */
-            if (hasFocus())
-                focusEvent(false /* aHasFocus*/, false /* aReleaseHostKey */);
             break;
+        }
 …
+                }
+            }
-            /* Reuse the focus event handler to capture keyboard: */
-            if (hasFocus())
-                focusEvent(true /* aHasFocus */);
             break;
+        }
 …
     , m_pMachineWindow(pMachineWindow)
     , m_uScreenId(uScreenId)
-    , m_globalSettings(vboxGlobal().settings())
     , m_pFrameBuffer(0)
     , m_previousState(KMachineState_Null)
     , m_desktopGeometryType(DesktopGeo_Invalid)
-    , m_bIsKeyboardCaptured(false)
-    , m_bIsHostkeyPressed(false)
-    , m_bIsHostkeyAlone (false)
-    , m_bIsHostkeyInCapture(false)
     , m_bIsMachineWindowResizeIgnored(false)
-    , m_fPassCAD(false)
 #ifdef VBOX_WITH_VIDEOHWACCEL
     , m_fAccelerate2DVideo(bAccelerate2DVideo)
 #endif /* VBOX_WITH_VIDEOHWACCEL */
-#ifdef Q_WS_MAC
-    , m_darwinKeyModifiers(0)
-    , m_fKeyboardGrabbed (false)
-#endif /* Q_WS_MAC */
+{
+}
 …
     setFrameStyle(QFrame::NoFrame);
-    /* Pressed keys: */
-    ::memset(m_pressedKeys, 0, sizeof(m_pressedKeys));
     /* Setup palette: */
     QPalette palette(viewport()->palette());
 …
     /* Global settings: */
+    {
-#ifdef Q_WS_X11
-        /* Initialize the X keyboard subsystem: */
-        initMappedX11Keyboard(QX11Info::display(), vboxGlobal().settings().publicProperty("GUI/RemapScancodes"));
-#endif /* Q_WS_X11 */
         /* Remember the desktop geometry and register for geometry
          * change events for telling the guest about video modes we like: */
 …
+        }
+    }
-    /* Exatra data settings: */
+    {
-        /* CAD settings: */
-        QString passCAD = session().GetConsole().GetMachine().GetExtraData(VBoxDefs::GUI_PassCAD);
-        if (!passCAD.isEmpty() && ((passCAD != "false") || (passCAD != "no")))
-            m_fPassCAD = true;
+    }
+}
-void UIMachineView::cleanupCommon()
+{
-#ifdef Q_WS_WIN
-    if (gKbdHook)
-        UnhookWindowsHookEx(gKbdHook);
-    gView = 0;
-#endif /* Q_WS_WIN */
-#ifdef Q_WS_MAC
-    /* We have to make sure the callback for the keyboard events is released
-     * when closing this view. */
-    if (m_fKeyboardGrabbed)
-        darwinGrabKeyboardEvents (false);
-#endif /* Q_WS_MAC */
+}
 …
+}
-void UIMachineView::fixModifierState(LONG *piCodes, uint *puCount)
+{
-    /* Synchronize the views of the host and the guest to the modifier keys.
-     * This function will add up to 6 additional keycodes to codes. */
-#if defined(Q_WS_X11)
-    Window   wDummy1, wDummy2;
-    int      iDummy3, iDummy4, iDummy5, iDummy6;
-    unsigned uMask;
-    unsigned uKeyMaskNum = 0, uKeyMaskCaps = 0, uKeyMaskScroll = 0;
-    uKeyMaskCaps          = LockMask;
-    XModifierKeymap* map  = XGetModifierMapping(QX11Info::display());
-    KeyCode keyCodeNum    = XKeysymToKeycode(QX11Info::display(), XK_Num_Lock);
-    KeyCode keyCodeScroll = XKeysymToKeycode(QX11Info::display(), XK_Scroll_Lock);
-    for (int i = 0; i < 8; ++ i)
+    {
-        if (keyCodeNum != NoSymbol && map->modifiermap[map->max_keypermod * i] == keyCodeNum)
-            uKeyMaskNum = 1 << i;
-        else if (keyCodeScroll != NoSymbol && map->modifiermap[map->max_keypermod * i] == keyCodeScroll)
-            uKeyMaskScroll = 1 << i;
+    }
-    XQueryPointer(QX11Info::display(), DefaultRootWindow(QX11Info::display()), &wDummy1, &wDummy2,
-                  &iDummy3, &iDummy4, &iDummy5, &iDummy6, &uMask);
-    XFreeModifiermap(map);
-    if (uisession()->numLockAdaptionCnt() && (uisession()->isNumLock() ^ !!(uMask & uKeyMaskNum)))
+    {
-        uisession()->setNumLockAdaptionCnt(uisession()->numLockAdaptionCnt() - 1);
-        piCodes[(*puCount)++] = 0x45;
-        piCodes[(*puCount)++] = 0x45 | 0x80;
+    }
-    if (uisession()->capsLockAdaptionCnt() && (uisession()->isCapsLock() ^ !!(uMask & uKeyMaskCaps)))
+    {
-        uisession()->setCapsLockAdaptionCnt(uisession()->capsLockAdaptionCnt() - 1);
-        piCodes[(*puCount)++] = 0x3a;
-        piCodes[(*puCount)++] = 0x3a | 0x80;
-        /* Some keyboard layouts require shift to be pressed to break
-         * capslock.  For simplicity, only do this if shift is not
-         * already held down. */
-        if (uisession()->isCapsLock() && !(m_pressedKeys[0x2a] & IsKeyPressed))
+        {
-            piCodes[(*puCount)++] = 0x2a;
-            piCodes[(*puCount)++] = 0x2a | 0x80;
+        }
+    }
-#elif defined(Q_WS_WIN)
-    if (uisession()->numLockAdaptionCnt() && (uisession()->isNumLock() ^ !!(GetKeyState(VK_NUMLOCK))))
+    {
-        uisession()->setNumLockAdaptionCnt(uisession()->numLockAdaptionCnt() - 1);
-        piCodes[(*puCount)++] = 0x45;
-        piCodes[(*puCount)++] = 0x45 | 0x80;
+    }
-    if (uisession()->capsLockAdaptionCnt() && (uisession()->isCapsLock() ^ !!(GetKeyState(VK_CAPITAL))))
+    {
-        uisession()->setCapsLockAdaptionCnt(uisession()->capsLockAdaptionCnt() - 1);
-        piCodes[(*puCount)++] = 0x3a;
-        piCodes[(*puCount)++] = 0x3a | 0x80;
-        /* Some keyboard layouts require shift to be pressed to break
-         * capslock.  For simplicity, only do this if shift is not
-         * already held down. */
-        if (uisession()->isCapsLock() && !(m_pressedKeys[0x2a] & IsKeyPressed))
+        {
-            piCodes[(*puCount)++] = 0x2a;
-            piCodes[(*puCount)++] = 0x2a | 0x80;
+        }
+    }
-#elif defined(Q_WS_MAC)
-    /* if (uisession()->numLockAdaptionCnt()) ... - NumLock isn't implemented by Mac OS X so ignore it. */
-    if (uisession()->capsLockAdaptionCnt() && (uisession()->isCapsLock() ^ !!(::GetCurrentEventKeyModifiers() & alphaLock)))
+    {
-        uisession()->setCapsLockAdaptionCnt(uisession()->capsLockAdaptionCnt() - 1);
-        piCodes[(*puCount)++] = 0x3a;
-        piCodes[(*puCount)++] = 0x3a | 0x80;
-        /* Some keyboard layouts require shift to be pressed to break
-         * capslock.  For simplicity, only do this if shift is not
-         * already held down. */
-        if (uisession()->isCapsLock() && !(m_pressedKeys[0x2a] & IsKeyPressed))
+        {
-            piCodes[(*puCount)++] = 0x2a;
-            piCodes[(*puCount)++] = 0x2a | 0x80;
+        }
+    }
-#else
-//#warning Adapt UIMachineView::fixModifierState
-#endif
+}
 QPoint UIMachineView::viewportToContents(const QPoint &vp) const
+{
 …
     horizontalScrollBar()->setValue(horizontalScrollBar()->value() + dx);
     verticalScrollBar()->setValue(verticalScrollBar()->value() + dy);
+}
-void UIMachineView::emitKeyboardStateChanged()
+{
-    emit keyboardStateChanged(keyboardState());
+}
-void UIMachineView::captureKbd(bool fCapture, bool fEmitSignal /* = true */)
+{
-    if (m_bIsKeyboardCaptured == fCapture)
-        return;
-#if defined(Q_WS_WIN)
-    /* On Win32, keyboard grabbing is ineffective, a low-level keyboard hook is used instead. */
-#elif defined(Q_WS_X11)
-    /* On X11, we are using passive XGrabKey for normal (windowed) mode
-     * instead of XGrabKeyboard (called by QWidget::grabKeyboard())
-     * because XGrabKeyboard causes a problem under metacity - a window cannot be moved
-     * using the mouse if it is currently actively grabing the keyboard;
-     * For static modes we are using usual (active) keyboard grabbing. */
-    switch (machineLogic()->visualStateType())
+    {
-        /* If window is moveable we are making passive keyboard grab: */
-        case UIVisualStateType_Normal:
+        {
-            if (fCapture)
-                XGrabKey(QX11Info::display(), AnyKey, AnyModifier, machineWindowWrapper()->machineWindow()->winId(), False, GrabModeAsync, GrabModeAsync);
-            else
-                XUngrabKey(QX11Info::display(), AnyKey, AnyModifier, machineWindowWrapper()->machineWindow()->winId());
-            break;
+        }
-        /* If window is NOT moveable we are making active keyboard grab: */
-        case UIVisualStateType_Fullscreen:
-        case UIVisualStateType_Seamless:
+        {
-            if (fCapture)
+            {
-                /* Keyboard grabbing can fail because of some keyboard shortcut is still grabbed by window manager.
-                 * We can't be sure this shortcut will be released at all, so we will retry to grab keyboard for 50 times,
-                 * and after we will just ignore that issue: */
-                int cTriesLeft = 50;
-                while (cTriesLeft && XGrabKeyboard(QX11Info::display(), machineWindowWrapper()->machineWindow()->winId(), False, GrabModeAsync, GrabModeAsync, CurrentTime)) { --cTriesLeft; }
+            }
-            else
-                XUngrabKeyboard(QX11Info::display(), CurrentTime);
-            break;
+        }
-        /* Should we try to grab keyboard in default case? I think - NO. */
-        default:
-            break;
+    }
-#elif defined(Q_WS_MAC)
-    /* On Mac OS X, we use the Qt methods + disabling global hot keys + watching modifiers
-     * (for right/left separation). */
-    if (fCapture)
+    {
-        ::DarwinDisableGlobalHotKeys(true);
-        grabKeyboard();
+    }
-    else
+    {
-        ::DarwinDisableGlobalHotKeys(false);
-        releaseKeyboard();
+    }
-#else
-    if (fCapture)
-        grabKeyboard();
-    else
-        releaseKeyboard();
-#endif
-    m_bIsKeyboardCaptured = fCapture;
-    if (fEmitSignal)
-        emitKeyboardStateChanged();
+}
-void UIMachineView::saveKeyStates()
+{
-    ::memcpy(m_pressedKeysCopy, m_pressedKeys, sizeof(m_pressedKeys));
+}
-void UIMachineView::releaseAllPressedKeys(bool aReleaseHostKey /* = true */)
+{
-    CKeyboard keyboard = session().GetConsole().GetKeyboard();
-    bool fSentRESEND = false;
-    /* Send a dummy scan code (RESEND) to prevent the guest OS from recognizing
-     * a single key click (for ex., Alt) and performing an unwanted action
-     * (for ex., activating the menu) when we release all pressed keys below.
-     * Note, that it's just a guess that sending RESEND will give the desired
-     * effect :), but at least it works with NT and W2k guests. */
-    for (uint i = 0; i < SIZEOF_ARRAY (m_pressedKeys); i++)
+    {
-        if (m_pressedKeys[i] & IsKeyPressed)
+        {
-            if (!fSentRESEND)
+            {
-                keyboard.PutScancode (0xFE);
-                fSentRESEND = true;
+            }
-            keyboard.PutScancode(i | 0x80);
+        }
-        else if (m_pressedKeys[i] & IsExtKeyPressed)
+        {
-            if (!fSentRESEND)
+            {
-                keyboard.PutScancode(0xFE);
-                fSentRESEND = true;
+            }
-            QVector <LONG> codes(2);
-            codes[0] = 0xE0;
-            codes[1] = i | 0x80;
-            keyboard.PutScancodes(codes);
+        }
-        m_pressedKeys[i] = 0;
+    }
-    if (aReleaseHostKey)
-        m_bIsHostkeyPressed = false;
-#ifdef Q_WS_MAC
-    /* Clear most of the modifiers: */
-    m_darwinKeyModifiers &=
-        alphaLock | kEventKeyModifierNumLockMask |
-        (aReleaseHostKey ? 0 : ::DarwinKeyCodeToDarwinModifierMask (m_globalSettings.hostKey()));
-#endif /* Q_WS_MAC */
-    emitKeyboardStateChanged();
+}
-void UIMachineView::sendChangedKeyStates()
+{
-    QVector <LONG> codes(2);
-    CKeyboard keyboard = session().GetConsole().GetKeyboard();
-    for (uint i = 0; i < SIZEOF_ARRAY(m_pressedKeys); ++ i)
+    {
-        uint8_t os = m_pressedKeysCopy[i];
-        uint8_t ns = m_pressedKeys[i];
-        if ((os & IsKeyPressed) != (ns & IsKeyPressed))
+        {
-            codes[0] = i;
-            if (!(ns & IsKeyPressed))
-                codes[0] |= 0x80;
-            keyboard.PutScancode(codes[0]);
+        }
-        else if ((os & IsExtKeyPressed) != (ns & IsExtKeyPressed))
+        {
-            codes[0] = 0xE0;
-            codes[1] = i;
-            if (!(ns & IsExtKeyPressed))
-                codes[1] |= 0x80;
-            keyboard.PutScancodes(codes);
+        }
+    }
+}
 …
     switch (pEvent->type())
+    {
-        case QEvent::FocusIn:
+        {
-            if (uisession()->isRunning())
-                focusEvent(true);
-            break;
+        }
-        case QEvent::FocusOut:
+        {
-            if (uisession()->isRunning())
-                focusEvent(false);
-            else
+            {
-                /* Release the host key and all other pressed keys too even when paused
-                 * (otherwise, we will get stuck keys in the guest when doing sendChangedKeyStates() on resume
-                 * because key presses were already recorded in m_pressedKeys but key releases will most likely
-                 * not reach us but the new focus window instead): */
-                releaseAllPressedKeys(true /* including host key? */);
+            }
-            break;
+        }
         case VBoxDefs::RepaintEventType:
+        {
 …
             viewport()->repaint(pPaintEvent->x() - contentsX(), pPaintEvent->y() - contentsY(),
                                 pPaintEvent->width(), pPaintEvent->height());
-            return true;
+        }
-        case QEvent::KeyPress:
-        case QEvent::KeyRelease:
+        {
-            QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
-            if (m_bIsHostkeyPressed && pEvent->type() == QEvent::KeyPress)
+            {
-                /* Passing F1-F12 keys to the guest: */
-                if (pKeyEvent->key() >= Qt::Key_F1 && pKeyEvent->key() <= Qt::Key_F12)
+                {
-                    QVector <LONG> combo(6);
-                    combo[0] = 0x1d; /* Ctrl down */
-                    combo[1] = 0x38; /* Alt  down */
-                    combo[4] = 0xb8; /* Alt  up   */
-                    combo[5] = 0x9d; /* Ctrl up   */
-                    if (pKeyEvent->key() >= Qt::Key_F1 && pKeyEvent->key() <= Qt::Key_F10)
+                    {
-                        combo[2] = 0x3b + (pKeyEvent->key() - Qt::Key_F1); /* F1-F10 down */
-                        combo[3] = 0xbb + (pKeyEvent->key() - Qt::Key_F1); /* F1-F10 up   */
+                    }
-                    /* some scan slice */
-                    else if (pKeyEvent->key() >= Qt::Key_F11 && pKeyEvent->key() <= Qt::Key_F12)
+                    {
-                        combo[2] = 0x57 + (pKeyEvent->key() - Qt::Key_F11); /* F11-F12 down */
-                        combo[3] = 0xd7 + (pKeyEvent->key() - Qt::Key_F11); /* F11-F12 up   */
+                    }
-                    else
-                        Assert(0);
-                    CKeyboard keyboard = session().GetConsole().GetKeyboard();
-                    keyboard.PutScancodes(combo);
+                }
-                /* Process hot keys not processed in keyEvent() (as in case of non-alphanumeric keys): */
-                machineWindowWrapper()->machineLogic()->actionsPool()->processHotKey(QKeySequence(pKeyEvent->key()));
+            }
-            else if (!m_bIsHostkeyPressed && pEvent->type() == QEvent::KeyRelease)
+            {
-                /* Show a possible warning on key release which seems to be more expected by the end user: */
-                if (uisession()->isPaused())
+                {
-                    /* Iif the reminder is disabled we pass the event to Qt to enable normal
-                     * keyboard functionality (for example, menu access with Alt+Letter): */
-                    if (!vboxProblem().remindAboutPausedVMInput())
-                        break;
+                }
+            }
-            pKeyEvent->accept();
             return true;
+        }
 …
                 break;
+            }
-#ifdef Q_WS_WIN
-            /* Install/uninstall low-level kbd hook on every activation/deactivation to:
-             * a) avoid excess hook calls when we're not active and
-             * b) be always in front of any other possible hooks */
-            case QEvent::WindowActivate:
+            {
-                gView = this;
-                gKbdHook = SetWindowsHookEx(WH_KEYBOARD_LL, lowLevelKeyboardProc, GetModuleHandle(NULL), 0);
-                AssertMsg(gKbdHook, ("SetWindowsHookEx(): err=%d", GetLastError()));
-                break;
+            }
-            case QEvent::WindowDeactivate:
+            {
-                if (gKbdHook)
+                {
-                    UnhookWindowsHookEx(gKbdHook);
-                    gKbdHook = NULL;
-                    if (gView == this)
-                        gView = 0;
+                }
-                break;
+            }
-#endif /* Q_WS_WIN */
-#ifdef Q_WS_MAC
-            /* Install/remove the keyboard event handler: */
-            case QEvent::WindowActivate:
-                darwinGrabKeyboardEvents(true);
-                break;
-            case QEvent::WindowDeactivate:
-                darwinGrabKeyboardEvents(false);
-                break;
-#endif /* Q_WS_MAC */
             default:
                 break;
 …
     return QAbstractScrollArea::eventFilter(pWatched, pEvent);
+}
-void UIMachineView::focusEvent(bool fHasFocus, bool fReleaseHostKey /* = true */)
+{
-    if (fHasFocus)
+    {
-#ifdef Q_WS_WIN
-        if (!uisession()->isAutoCaptureDisabled() && m_globalSettings.autoCapture() && GetAncestor(winId(), GA_ROOT) == GetForegroundWindow())
-#else /* Q_WS_WIN */
-        if (!uisession()->isAutoCaptureDisabled() && m_globalSettings.autoCapture())
-#endif /* !Q_WS_WIN */
+        {
-            captureKbd(true);
+        }
-        /* Reset the single-time disable capture flag: */
-        if (uisession()->isAutoCaptureDisabled())
-            uisession()->setAutoCaptureDisabled(false);
+    }
-    else
+    {
-        captureKbd(false, false);
-        releaseAllPressedKeys(fReleaseHostKey);
+    }
+}
-bool UIMachineView::keyEvent(int iKey, uint8_t uScan, int fFlags, wchar_t *pUniKey /* = NULL */)
+{
-    const bool isHostKey = iKey == m_globalSettings.hostKey();
-    LONG buf[16];
-    LONG *codes = buf;
-    uint count = 0;
-    uint8_t whatPressed = 0;
-    if (!isHostKey && !m_bIsHostkeyPressed)
+    {
-        if (fFlags & KeyPrint)
+        {
-            static LONG PrintMake[] = { 0xE0, 0x2A, 0xE0, 0x37 };
-            static LONG PrintBreak[] = { 0xE0, 0xB7, 0xE0, 0xAA };
-            if (fFlags & KeyPressed)
+            {
-                codes = PrintMake;
-                count = SIZEOF_ARRAY(PrintMake);
+            }
-            else
+            {
-                codes = PrintBreak;
-                count = SIZEOF_ARRAY(PrintBreak);
+            }
+        }
-        else if (fFlags & KeyPause)
+        {
-            if (fFlags & KeyPressed)
+            {
-                static LONG Pause[] = { 0xE1, 0x1D, 0x45, 0xE1, 0x9D, 0xC5 };
-                codes = Pause;
-                count = SIZEOF_ARRAY(Pause);
+            }
-            else
+            {
-                /* Pause shall not produce a break code */
-                return true;
+            }
+        }
-        else
+        {
-            if (fFlags & KeyPressed)
+            {
-                /* Check if the guest has the same view on the modifier keys (NumLock,
-                 * CapsLock, ScrollLock) as the X server. If not, send KeyPress events
-                 * to synchronize the state. */
-                fixModifierState(codes, &count);
+            }
-            /* Check if it's C-A-D and GUI/PassCAD is not true */
-            if (!m_fPassCAD &&
-                uScan == 0x53 /* Del */ &&
-                ((m_pressedKeys[0x38] & IsKeyPressed) /* Alt */ ||
-                 (m_pressedKeys[0x38] & IsExtKeyPressed)) &&
-                ((m_pressedKeys[0x1d] & IsKeyPressed) /* Ctrl */ ||
-                 (m_pressedKeys[0x1d] & IsExtKeyPressed)))
+            {
-                /* Use the C-A-D combination as a last resort to get the
-                 * keyboard and mouse back to the host when the user forgets
-                 * the Host Key. Note that it's always possible to send C-A-D
-                 * to the guest using the Host+Del combination. BTW, it would
-                 * be preferrable to completely ignore C-A-D in guests, but
-                 * that's not possible because we cannot predict what other
-                 * keys will be pressed next when one of C, A, D is held. */
-                if (uisession()->isRunning() && m_bIsKeyboardCaptured)
+                {
-                    captureKbd(false);
-                    if (!(uisession()->isMouseSupportsAbsolute() && uisession()->isMouseIntegrated()))
-                        machineLogic()->mouseHandler()->captureMouse(screenId());
+                }
-                return true;
+            }
-            /* Process the scancode and update the table of pressed keys: */
-            whatPressed = IsKeyPressed;
-            if (fFlags & KeyExtended)
+            {
-                codes[count++] = 0xE0;
-                whatPressed = IsExtKeyPressed;
+            }
-            if (fFlags & KeyPressed)
+            {
-                codes[count++] = uScan;
-                m_pressedKeys[uScan] |= whatPressed;
+            }
-            else
+            {
-                /* If we haven't got this key's press message, we ignore its release: */
-                if (!(m_pressedKeys[uScan] & whatPressed))
-                    return true;
-                codes[count++] = uScan | 0x80;
-                m_pressedKeys[uScan] &= ~whatPressed;
+            }
-            if (m_bIsKeyboardCaptured)
-                m_pressedKeys[uScan] |= IsKbdCaptured;
-            else
-                m_pressedKeys[uScan] &= ~IsKbdCaptured;
+        }
+    }
-    else
+    {
-        /* Currently this is used in winLowKeyboardEvent() only: */
-        m_bIsHostkeyInCapture = m_bIsKeyboardCaptured;
+    }
-    bool emitSignal = false;
-    int hotkey = 0;
-    /* Process the host key: */
-    if (fFlags & KeyPressed)
+    {
-        if (isHostKey)
+        {
-            if (!m_bIsHostkeyPressed)
+            {
-                m_bIsHostkeyPressed = m_bIsHostkeyAlone = true;
-                if (uisession()->isRunning())
-                    saveKeyStates();
-                emitSignal = true;
+            }
+        }
-        else
+        {
-            if (m_bIsHostkeyPressed)
+            {
-                if (m_bIsHostkeyAlone)
+                {
-                    hotkey = iKey;
-                    m_bIsHostkeyAlone = false;
+                }
+            }
+        }
+    }
-    else
+    {
-        if (isHostKey)
+        {
-            if (m_bIsHostkeyPressed)
+            {
-                m_bIsHostkeyPressed = false;
-                if (m_bIsHostkeyAlone)
+                {
-                    if (uisession()->isPaused())
+                    {
-                        vboxProblem().remindAboutPausedVMInput();
+                    }
-                    else if (uisession()->isRunning())
+                    {
-                        bool captured = m_bIsKeyboardCaptured;
-                        bool ok = true;
-                        if (!captured)
+                        {
-                            /* temporarily disable auto capture that will take
-                             * place after this dialog is dismissed because
-                             * the capture state is to be defined by the
-                             * dialog result itself */
-                            uisession()->setAutoCaptureDisabled(true);
-                            bool autoConfirmed = false;
-                            ok = vboxProblem().confirmInputCapture (&autoConfirmed);
-                            if (autoConfirmed)
-                                uisession()->setAutoCaptureDisabled(false);
-                            /* otherwise, the disable flag will be reset in
-                             * the next console view's foucs in event (since
-                             * may happen asynchronously on some platforms,
-                             * after we return from this code) */
+                        }
-                        if (ok)
+                        {
-                            captureKbd (!captured, false);
-                            if (!(uisession()->isMouseSupportsAbsolute() && uisession()->isMouseIntegrated()))
+                            {
-#ifdef Q_WS_X11
-                                /* make sure that pending FocusOut events from the
-                                 * previous message box are handled, otherwise the
-                                 * mouse is immediately ungrabbed. */
-                                qApp->processEvents();
-#endif /* Q_WS_X11 */
-                                if (m_bIsKeyboardCaptured)
-                                    machineLogic()->mouseHandler()->captureMouse(screenId());
-                                else
-                                    machineLogic()->mouseHandler()->releaseMouse();
+                            }
+                        }
+                    }
+                }
-                if (uisession()->isRunning())
-                    sendChangedKeyStates();
-                emitSignal = true;
+            }
+        }
-        else
+        {
-            if (m_bIsHostkeyPressed)
-                m_bIsHostkeyAlone = false;
+        }
+    }
-    /* emit the keyboard state change signal */
-    if (emitSignal)
-        emitKeyboardStateChanged();
-    /* Process Host+<key> shortcuts. currently, <key> is limited to
-     * alphanumeric chars. Other Host+<key> combinations are handled in
-     * event(). */
-    if (hotkey)
+    {
-        bool processed = false;
-#if defined (Q_WS_WIN)
-        NOREF(pUniKey);
-        int n = GetKeyboardLayoutList(0, NULL);
-        Assert (n);
-        HKL *list = new HKL[n];
-        GetKeyboardLayoutList(n, list);
-        for (int i = 0; i < n && !processed; i++)
+        {
-            wchar_t ch;
-            static BYTE keys[256] = {0};
-            if (!ToUnicodeEx(hotkey, 0, keys, &ch, 1, 0, list[i]) == 1)
-                ch = 0;
-            if (ch)
-                processed = machineWindowWrapper()->machineLogic()->actionsPool()->processHotKey(QKeySequence((Qt::UNICODE_ACCEL + QChar(ch).toUpper().unicode())));
+        }
-        delete[] list;
-#elif defined (Q_WS_X11)
-        NOREF(pUniKey);
-        Display *display = QX11Info::display();
-        int keysyms_per_keycode = getKeysymsPerKeycode();
-        KeyCode kc = XKeysymToKeycode (display, iKey);
-        for (int i = 0; i < keysyms_per_keycode && !processed; i += 2)
+        {
-            KeySym ks = XKeycodeToKeysym(display, kc, i);
-            char ch = 0;
-            if (!XkbTranslateKeySym(display, &ks, 0, &ch, 1, NULL) == 1)
-                ch = 0;
-            if (ch)
-                QChar c = QString::fromLocal8Bit(&ch, 1)[0];
+        }
-#elif defined (Q_WS_MAC)
-        if (pUniKey && pUniKey[0] && !pUniKey[1])
-            processed = machineWindowWrapper()->machineLogic()->actionsPool()->processHotKey(QKeySequence(Qt::UNICODE_ACCEL + QChar(pUniKey[0]).toUpper().unicode()));
-        /* Don't consider the hot key as pressed since the guest never saw
-         * it. (probably a generic thing) */
-        m_pressedKeys[uScan] &= ~whatPressed;
-#endif
-        /* Grab the key from Qt if processed, or pass it to Qt otherwise
-         * in order to process non-alphanumeric keys in event(), after they are
-         * converted to Qt virtual keys. */
-        return processed;
+    }
-    /* No more to do, if the host key is in action or the VM is paused: */
-    if (m_bIsHostkeyPressed || isHostKey || uisession()->isPaused())
+    {
-        /* Grab the key from Qt and from VM if it's a host key,
-         * otherwise just pass it to Qt */
-        return isHostKey;
+    }
-    CKeyboard keyboard = session().GetConsole().GetKeyboard();
-    Assert(!keyboard.isNull());
-#ifdef Q_WS_WIN
-    /* send pending WM_PAINT events */
-    ::UpdateWindow(viewport()->winId());
-#endif /* Q_WS_WIN */
-    std::vector <LONG> scancodes(codes, &codes[count]);
-    keyboard.PutScancodes(QVector<LONG>::fromStdVector(scancodes));
-    /* Grab the key from Qt: */
-    return true;
+}
 …
 #if defined(Q_WS_WIN)
+LRESULT CALLBACK UIMachineView::lowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
+{
+    if (gView && nCode == HC_ACTION && gView->winLowKeyboardEvent(wParam, *(KBDLLHOOKSTRUCT *)lParam))
+        return 1;
+    return CallNextHookEx(NULL, nCode, wParam, lParam);
+}
+bool UIMachineView::winLowKeyboardEvent(UINT msg, const KBDLLHOOKSTRUCT &event)
+{
+    /* Sometimes it happens that Win inserts additional events on some key
+     * press/release. For example, it prepends ALT_GR in German layout with
+     * the VK_LCONTROL vkey with curious 0x21D scan code (seems to be necessary
+     * to specially treat ALT_GR to enter additional chars to regular apps).
+     * These events are definitely unwanted in VM, so filter them out. */
+    /* Note (michael): it also sometimes sends the VK_CAPITAL vkey with scan
+     * code 0x23a. If this is not passed through then it is impossible to
+     * cancel CapsLock on a French keyboard.  I didn't find any other examples
+     * of these strange events.  Let's hope we are not missing anything else
+     * of importance! */
+    if (hasFocus() && (event.scanCode & ~0xFF))
+    {
+        if (event.vkCode == VK_CAPITAL)
+            return false;
+        else
+            return true;
+    }
+    if (!m_bIsKeyboardCaptured)
+        return false;
+    /* it's possible that a key has been pressed while the keyboard was not
+     * captured, but is being released under the capture. Detect this situation
+     * and return false to let Windows process the message normally and update
+     * its key state table (to avoid the stuck key effect). */
+    uint8_t what_pressed = (event.flags & 0x01) && (event.vkCode != VK_RSHIFT) ? IsExtKeyPressed : IsKeyPressed;
+    if ((event.flags & 0x80) /* released */ &&
+        ((event.vkCode == m_globalSettings.hostKey() && !m_bIsHostkeyInCapture) ||
+         (m_pressedKeys[event.scanCode] & (IsKbdCaptured | what_pressed)) == what_pressed))
+        return false;
+    MSG message;
+    message.hwnd = winId();
+    message.message = msg;
+    message.wParam = event.vkCode;
+    message.lParam = 1 | (event.scanCode & 0xFF) << 16 | (event.flags & 0xFF) << 24;
+    /* Windows sets here the extended bit when the Right Shift key is pressed,
+     * which is totally wrong. Undo it. */
+    if (event.vkCode == VK_RSHIFT)
+        message.lParam &= ~0x1000000;
+    /* we suppose here that this hook is always called on the main GUI thread */
+    long dummyResult;
+    return winEvent(&message, &dummyResult);
+}
+bool UIMachineView::winEvent(MSG *aMsg, long* /* aResult */)
+{
+    if (!(aMsg->message == WM_KEYDOWN || aMsg->message == WM_SYSKEYDOWN ||
+          aMsg->message == WM_KEYUP || aMsg->message == WM_SYSKEYUP))
+        return false;
+    /* Check for the special flag possibly set at the end of this function */
+    if (aMsg->lParam & (0x1 << 25))
+    {
+        aMsg->lParam &= ~(0x1 << 25);
+        return false;
+    }
+    int scan = (aMsg->lParam >> 16) & 0x7F;
+    /* scancodes 0x80 and 0x00 are ignored */
+    if (!scan)
+        return true;
+    int vkey = aMsg->wParam;
+    /* When one of the SHIFT keys is held and one of the cursor movement
+     * keys is pressed, Windows duplicates SHIFT press/release messages,
+     * but with the virtual key code set to 0xFF. These virtual keys are also
+     * sent in some other situations (Pause, PrtScn, etc.). Ignore such
+     * messages. */
+    if (vkey == 0xFF)
+        return true;
+    int flags = 0;
+    if (aMsg->lParam & 0x1000000)
+        flags |= KeyExtended;
+    if (!(aMsg->lParam & 0x80000000))
+        flags |= KeyPressed;
+    switch (vkey)
+    {
+        case VK_SHIFT:
+        case VK_CONTROL:
+        case VK_MENU:
+        {
+            /* overcome stupid Win32 modifier key generalization */
+            int keyscan = scan;
+            if (flags & KeyExtended)
+                keyscan |= 0xE000;
+            switch (keyscan)
+            {
+                case 0x002A: vkey = VK_LSHIFT; break;
+                case 0x0036: vkey = VK_RSHIFT; break;
+                case 0x001D: vkey = VK_LCONTROL; break;
+                case 0xE01D: vkey = VK_RCONTROL; break;
+                case 0x0038: vkey = VK_LMENU; break;
+                case 0xE038: vkey = VK_RMENU; break;
+            }
+            break;
+        }
+        case VK_NUMLOCK:
+            /* Win32 sets the extended bit for the NumLock key. Reset it. */
+            flags &= ~KeyExtended;
+            break;
+        case VK_SNAPSHOT:
+            flags |= KeyPrint;
+            break;
+        case VK_PAUSE:
+            flags |= KeyPause;
+            break;
+    }
+    bool result = keyEvent(vkey, scan, flags);
+    if (!result && m_bIsKeyboardCaptured)
+    {
+        /* keyEvent() returned that it didn't process the message, but since the
+         * keyboard is captured, we don't want to pass it to Windows. We just want
+         * to let Qt process the message (to handle non-alphanumeric <HOST>+key
+         * shortcuts for example). So send it direcltly to the window with the
+         * special flag in the reserved area of lParam (to avoid recursion). */
+        ::SendMessage(aMsg->hwnd, aMsg->message,
+                      aMsg->wParam, aMsg->lParam | (0x1 << 25));
+        return true;
+    }
+    /* These special keys have to be handled by Windows as well to update the
+     * internal modifier state and to enable/disable the keyboard LED */
+    if (vkey == VK_NUMLOCK || vkey == VK_CAPITAL || vkey == VK_LSHIFT || vkey == VK_RSHIFT)
+        return false;
+    return result;
+bool UIMachineView::winEvent(MSG *pMsg, long* /* piResult */)
+{
+    /* Check if some system event should be filtered-out.
+     * Returning 'true' means filtering-out,
+     * Returning 'false' means passing event to Qt. */
+    bool fResult = false; /* Pass to Qt by default: */
+    switch (pMsg->message)
+    {
+        case WM_KEYDOWN:
+        case WM_KEYUP:
+        case WM_SYSKEYDOWN:
+        case WM_SYSKEYUP:
+        {
+            /* Filter using keyboard-filter: */
+            bool fKeyboardFilteringResult = machineLogic()->keyboardHandler()->winEventFilter(pMsg, screenId());
+            /* Keyboard filter rules the result: */
+            fResult = fKeyboardFilteringResult;
+            break;
+        }
+        default:
+            break;
+    }
+    /* Return result: */
+    return fResult;
+}
 #elif defined(Q_WS_X11)
-static Bool VBoxConsoleViewCompEvent(Display *, XEvent *pEvent, XPointer pvArg)
+{
-    XEvent *pKeyEvent = (XEvent*)pvArg;
-    if ((pEvent->type == XKeyPress) && (pEvent->xkey.keycode == pKeyEvent->xkey.keycode))
-        return True;
-    else
-        return False;
+}
 bool UIMachineView::x11Event(XEvent *pEvent)
+{
+    /* Check if some system event should be filtered-out.
+     * Returning 'true' means filtering-out,
+     * Returning 'false' means passing event to Qt. */
+    bool fResult = false; /* Pass to Qt by default: */
     switch (pEvent->type)
+    {
-        /* We have to handle XFocusOut right here as this event is not passed
-         * to UIMachineView::event(). Handling this event is important for
-         * releasing the keyboard before the screen saver gets active.
+         *
-         * See public ticket #3894: Apparently this makes problems with newer
-         * versions of Qt and this hack is probably not necessary anymore.
-         * So disable it for Qt >= 4.5.0. */
         case XFocusOut:
         case XFocusIn:
-            if (uisession()->isRunning())
+            {
-                if (VBoxGlobal::qtRTVersion() < ((4 << 16) | (5 << 8) | 0))
+                {
-                    focusEvent(pEvent->type == XFocusIn);
-                    if (pEvent->type == XFocusOut)
-                        machineLogic()->mouseHandler()->releaseMouse();
+                }
+            }
-            return false;
         case XKeyPress:
         case XKeyRelease:
+            break;
+        {
+            /* Filter using keyboard-filter: */
+            bool fKeyboardFilteringResult = machineLogic()->keyboardHandler()->x11EventFilter(pEvent, screenId());
+            /* Filter using mouse-filter: */
+            bool fMouseFilteringResult = machineLogic()->mouseHandler()->x11EventFilter(pEvent, screenId());
+            /* If at least one of filters wants to filter event out then the result is 'true': */
+            fResult = fKeyboardFilteringResult || fMouseFilteringResult;
+            break;
+        }
         default:
+            return false; /* pass the event to Qt */
+    }
+    /* Translate the keycode to a PC scan code. */
+    unsigned scan = handleXKeyEvent(pEvent);
+    /* scancodes 0x00 (no valid translation) and 0x80 are ignored */
+    if (!scan & 0x7F)
+        return true;
+    /* Fix for http://www.virtualbox.org/ticket/1296:
+     * when X11 sends events for repeated keys, it always inserts an
+     * XKeyRelease before the XKeyPress. */
+    XEvent returnEvent;
+    if ((pEvent->type == XKeyRelease) && (XCheckIfEvent(pEvent->xkey.display, &returnEvent,
+        VBoxConsoleViewCompEvent, (XPointer)pEvent) == True))
+    {
+        XPutBackEvent(pEvent->xkey.display, &returnEvent);
+        /* Discard it, don't pass it to Qt. */
+        return true;
+    }
+    KeySym ks = ::XKeycodeToKeysym(pEvent->xkey.display, pEvent->xkey.keycode, 0);
+    int flags = 0;
+    if (scan >> 8)
+        flags |= KeyExtended;
+    if (pEvent->type == XKeyPress)
+        flags |= KeyPressed;
+    /* Remove the extended flag */
+    scan &= 0x7F;
+    switch (ks)
+    {
+        case XK_Print:
+            flags |= KeyPrint;
+            break;
+        case XK_Pause:
+            flags |= KeyPause;
+            break;
+    }
+    return keyEvent(ks, scan, flags);
+}
+#elif defined(Q_WS_MAC)
+void UIMachineView::darwinGrabKeyboardEvents(bool fGrab)
+{
+    m_fKeyboardGrabbed = fGrab;
+    if (fGrab)
+    {
+        /* Disable mouse and keyboard event compression/delaying to make sure we *really* get all of the events. */
+        ::CGSetLocalEventsSuppressionInterval(0.0);
+        machineLogic()->mouseHandler()->setMouseCoalescingEnabled(false);
+        /* Register the event callback/hook and grab the keyboard. */
+        UICocoaApplication::instance()->registerForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */,
+                                                                UIMachineView::darwinEventHandlerProc, this);
+        ::DarwinGrabKeyboard (false);
+    }
+    else
+    {
+        ::DarwinReleaseKeyboard();
+        UICocoaApplication::instance()->unregisterForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */,
+                                                                  UIMachineView::darwinEventHandlerProc, this);
+    }
+}
+bool UIMachineView::darwinEventHandlerProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser)
+{
+    UIMachineView *view = (UIMachineView*)pvUser;
+    EventRef inEvent = (EventRef)pvCarbonEvent;
+    UInt32 eventClass = ::GetEventClass(inEvent);
+    /* Check if this is an application key combo. In that case we will not pass
+     * the event to the guest, but let the host process it. */
+    if (::darwinIsApplicationCommand(pvCocoaEvent))
+        return false;
+    /* All keyboard class events needs to be handled. */
+    if (eventClass == kEventClassKeyboard)
+    {
+        if (view->darwinKeyboardEvent (pvCocoaEvent, inEvent))
+            return true;
+    }
+    /* Pass the event along. */
+    return false;
+}
+bool UIMachineView::darwinKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent)
+{
+    bool ret = false;
+    UInt32 EventKind = ::GetEventKind(inEvent);
+    if (EventKind != kEventRawKeyModifiersChanged)
+    {
+        /* convert keycode to set 1 scan code. */
+        UInt32 keyCode = ~0U;
+        ::GetEventParameter(inEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof (keyCode), NULL, &keyCode);
+        unsigned scanCode = ::DarwinKeycodeToSet1Scancode(keyCode);
+        if (scanCode)
+        {
+            /* calc flags. */
+            int flags = 0;
+            if (EventKind != kEventRawKeyUp)
+                flags |= KeyPressed;
+            if (scanCode & VBOXKEY_EXTENDED)
+                flags |= KeyExtended;
+            /** @todo KeyPause, KeyPrint. */
+            scanCode &= VBOXKEY_SCANCODE_MASK;
+            /* get the unicode string (if present). */
+            AssertCompileSize(wchar_t, 2);
+            AssertCompileSize(UniChar, 2);
+            ByteCount cbWritten = 0;
+            wchar_t ucs[8];
+            if (::GetEventParameter(inEvent, kEventParamKeyUnicodes, typeUnicodeText, NULL,
+                                    sizeof(ucs), &cbWritten, &ucs[0]) != 0)
+                cbWritten = 0;
+            ucs[cbWritten / sizeof(wchar_t)] = 0; /* The api doesn't terminate it. */
+            ret = keyEvent(keyCode, scanCode, flags, ucs[0] ? ucs : NULL);
+        }
+    }
+    else
+    {
+        /* May contain multiple modifier changes, kind of annoying. */
+        UInt32 newMask = 0;
+        ::GetEventParameter(inEvent, kEventParamKeyModifiers, typeUInt32, NULL,
+                            sizeof(newMask), NULL, &newMask);
+        newMask = ::DarwinAdjustModifierMask(newMask, pvCocoaEvent);
+        UInt32 changed = newMask ^ m_darwinKeyModifiers;
+        if (changed)
+        {
+            for (UInt32 bit = 0; bit < 32; bit++)
+            {
+                if (!(changed & (1 << bit)))
+                    continue;
+                unsigned scanCode = ::DarwinModifierMaskToSet1Scancode(1 << bit);
+                if (!scanCode)
+                    continue;
+                unsigned keyCode = ::DarwinModifierMaskToDarwinKeycode(1 << bit);
+                Assert(keyCode);
+                if (!(scanCode & VBOXKEY_LOCK))
+                {
+                    unsigned flags = (newMask & (1 << bit)) ? KeyPressed : 0;
+                    if (scanCode & VBOXKEY_EXTENDED)
+                        flags |= KeyExtended;
+                    scanCode &= VBOXKEY_SCANCODE_MASK;
+                    ret |= keyEvent(keyCode, scanCode & 0xff, flags);
+                }
+                else
+                {
+                    unsigned flags = 0;
+                    if (scanCode & VBOXKEY_EXTENDED)
+                        flags |= KeyExtended;
+                    scanCode &= VBOXKEY_SCANCODE_MASK;
+                    keyEvent(keyCode, scanCode, flags | KeyPressed);
+                    keyEvent(keyCode, scanCode, flags);
+                }
+            }
+        }
+        m_darwinKeyModifiers = newMask;
+        /* Always return true here because we'll otherwise getting a Qt event
+           we don't want and that will only cause the Pause warning to pop up. */
+        ret = true;
+    }
+    return ret;
+            break;
+    }
+    /* Return result: */
+    return fResult;
+}

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

-              r30636
+              r30637
 class UIMachineWindow;
 class UIFrameBuffer;
-class VBoxGlobalSettings;
 class UIMachineView : public QAbstractScrollArea
 …
     static void destroy(UIMachineView *pMachineView);
-    /* Public getters: */
-    int keyboardState() const;
     /* Public setters: */
     virtual void setGuestAutoresizeEnabled(bool /* fEnabled */) {}
 …
 signals:
-    /* Keyboard state-change signals: */
-    void keyboardStateChanged(int iState);
     /* Utility signals: */
 …
     //virtual void cleanupConsoleConnections() {}
     //virtual void cleanupFilters() {}
     virtual void cleanupCommon();
+    //virtual void cleanupCommon() {}
     virtual void cleanupFrameBuffer();
 …
     ulong screenId() const { return m_uScreenId; }
     UIFrameBuffer* frameBuffer() const { return m_pFrameBuffer; }
-    bool isHostKeyPressed() const { return m_bIsHostkeyPressed; }
     bool isMachineWindowResizeIgnored() const { return m_bIsMachineWindowResizeIgnored; }
     const QPixmap& pauseShot() const { return m_pauseShot; }
 …
     QSize desktopGeometry() const;
     QSize guestSizeHint();
-#ifdef Q_WS_MAC
-    /* These getters are temporary here while UIKeyboardHandler is not implemented: */
-    bool isHostKeyAlone() const { return m_bIsHostkeyAlone; }
-    bool isKeyboardGrabbed() const { return m_fKeyboardGrabbed; }
-#endif /* Q_WS_MAC */
     /* Protected setters: */
 …
     virtual void maybeRestrictMinimumSize() = 0;
     virtual void updateSliders();
-    void fixModifierState(LONG *piCodes, uint *puCount);
     QPoint viewportToContents(const QPoint &vp) const;
     void scrollBy(int dx, int dy);
-    void emitKeyboardStateChanged();
-    void captureKbd(bool fCapture, bool fEmitSignal = true);
-    void saveKeyStates();
-    void releaseAllPressedKeys(bool aReleaseHostKey = true);
-    void sendChangedKeyStates();
     static void dimImage(QImage &img);
 #ifdef VBOX_WITH_VIDEOHWACCEL
 …
     bool event(QEvent *pEvent);
     bool eventFilter(QObject *pWatched, QEvent *pEvent);
-    void focusEvent(bool aHasFocus, bool aReleaseHostKey = true);
-    bool keyEvent(int aKey, uint8_t aScan, int aFlags, wchar_t *aUniKey = NULL);
     void resizeEvent(QResizeEvent *pEvent);
     void moveEvent(QMoveEvent *pEvent);
 …
     /* Platform specific event processors: */
 #if defined(Q_WS_WIN)
-    static LRESULT CALLBACK lowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam);
-    bool winLowKeyboardEvent(UINT msg, const KBDLLHOOKSTRUCT &event);
     bool winEvent(MSG *pMsg, long *puResult);
 #elif defined(Q_WS_X11)
     bool x11Event(XEvent *event);
-#elif defined(Q_WS_MAC)
-    void darwinGrabKeyboardEvents(bool fGrab);
-    static bool darwinEventHandlerProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser);
-    bool darwinKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent);
 #endif
 …
     UIMachineWindow *m_pMachineWindow;
     ulong m_uScreenId;
-    const VBoxGlobalSettings &m_globalSettings;
     UIFrameBuffer *m_pFrameBuffer;
     KMachineState m_previousState;
 …
     QSize m_storedConsoleSize;
-    uint8_t m_pressedKeys[128];
-    uint8_t m_pressedKeysCopy[128];
-    bool m_bIsKeyboardCaptured : 1;
-    bool m_bIsHostkeyPressed : 1;
-    bool m_bIsHostkeyAlone : 1;
-    bool m_bIsHostkeyInCapture : 1;
     bool m_bIsMachineWindowResizeIgnored : 1;
-    bool m_fPassCAD : 1;
 #ifdef VBOX_WITH_VIDEOHWACCEL
     bool m_fAccelerate2DVideo : 1;
 #endif /* VBOX_WITH_VIDEOHWACCEL */
-#ifdef Q_WS_MAC
-    /** The current modifier key mask. Used to figure out which modifier
-     *  key was pressed when we get a kEventRawKeyModifiersChanged event. */
-    UInt32 m_darwinKeyModifiers;
-    bool m_fKeyboardGrabbed;
-#endif /* Q_WS_MAC */
     QPixmap m_pauseShot;
     /* Friend classes: */
+    friend class UIKeyboardHandler;
     friend class UIMouseHandler;
     friend class UIMachineLogic;

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

-              r30636
+              r30637
 #include "UISession.h"
 #include "UIActionsPool.h"
+#include "UIKeyboardHandler.h"
 #include "UIMouseHandler.h"
 #include "UIMachineLogic.h"
 …
 void UIMachineWindow::prepareHandlers()
+{
+    /* Register keyboard-handler: */
+    machineLogic()->keyboardHandler()->prepareListener(m_uScreenId, this);
     /* Register machine-view in mouse-handler: */
     machineLogic()->mouseHandler()->addMachineView(m_uScreenId, this->machineView());
 …
     /* Unregister machine-view from mouse-handler: */
     machineLogic()->mouseHandler()->delMachineView(m_uScreenId);
+    /* Unregister keyboard-handler: */
+    machineLogic()->keyboardHandler()->cleanupListener(m_uScreenId);
+}

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

-              r30448
+              r30637
 #include "VBoxGlobal.h"
 #include "VBoxProblemReporter.h"
+#include "UIKeyboardHandler.h"
 #include "UIMouseHandler.h"
 #include "UISession.h"
 #include "UIMachineLogic.h"
 #include "UIMachineView.h"
+#ifdef Q_WS_X11
+# include <X11/XKBlib.h>
+# ifdef KeyPress
+const int XFocusOut = FocusOut;
+const int XFocusIn = FocusIn;
+const int XKeyPress = KeyPress;
+const int XKeyRelease = KeyRelease;
+#  undef KeyRelease
+#  undef KeyPress
+#  undef FocusOut
+#  undef FocusIn
+# endif /* KeyPress */
+#endif /* Q_WS_X11 */
 #ifdef Q_WS_MAC
 …
+}
 #endif /* Q_WS_MAC */
+#ifdef Q_WS_X11
+bool UIMouseHandler::x11EventFilter(XEvent *pEvent, ulong /* uScreenId */)
+{
+    /* Check if some system event should be filtered-out.
+     * Returning 'true' means filtering-out,
+     * Returning 'false' means passing event to Qt. */
+    bool fResult = false; /* Pass to Qt by default: */
+    switch (pEvent->type)
+    {
+        /* We have to handle XFocusOut right here as this event is not passed to UIMachineView::event().
+         * Handling this event is important for releasing the keyboard before the screen saver gets active.
+         * See public ticket #3894: Apparently this makes problems with newer versions of Qt
+         * and this hack is probably not necessary anymore. So disable it for Qt >= 4.5.0. */
+        case XFocusOut:
+        {
+            if (uisession()->isRunning())
+            {
+                if (VBoxGlobal::qtRTVersion() < ((4 << 16) | (5 << 8) | 0))
+                    releaseMouse();
+            }
+            fResult = false;
+        }
+        default:
+            break;
+    }
+    /* Return result: */
+    return fResult;
+}
+#endif /* Q_WS_X11 */
 /* Machine state-change handler: */
 …
                      * Only do this if the keyboard/mouse is grabbed
                      * (this is when we have a valid event handler): */
                     if (m_views[uScreenId]->isKeyboardGrabbed())
+                    if (machineLogic()->keyboardHandler()->isKeyboardGrabbed())
                         setMouseCoalescingEnabled(false);
                     break;
 …
 #ifdef Q_WS_MAC
     /* Simulate the right click on host-key + left-mouse-button: */
     if (m_views[uScreenId]->isHostKeyPressed() &&
         m_views[uScreenId]->isHostKeyAlone() &&
+    if (machineLogic()->keyboardHandler()->isHostKeyPressed() &&
+        machineLogic()->keyboardHandler()->isHostKeyAlone() &&
         iMouseButtonsState == KMouseButtonState_LeftButton)
         iMouseButtonsState = KMouseButtonState_RightButton;
 …
                         qApp->processEvents();
 #endif
+                        /* Actually that will be a call to keyboard-handler, not no machine-view,
+                         * but now keyboard-handler is not implemented yet. */
+                        m_views[uScreenId]->captureKbd(true);
+                        machineLogic()->keyboardHandler()->captureKeyboard(uScreenId);
                         captureMouse(uScreenId);
+                    }

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

-              r30410
+              r30637
 class UIMachineLogic;
 class UIMachineView;
+#ifdef Q_WS_X11
+typedef union  _XEvent XEvent;
+#endif /* Q_WS_X11 */
 /* Delegate to control VM mouse functionality: */
 …
     void setMouseCoalescingEnabled(bool fOn);
 #endif /* Q_WS_MAC */
+#ifdef Q_WS_X11
+    bool x11EventFilter(XEvent *pEvent, ulong uScreenId);
+#endif /* Q_WS_X11 */
 signals:

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

-              r30551
+              r30637
+ *
  * VBox frontends: Qt GUI ("VirtualBox"):
  * UIMachineViewFullscreen class implementation
+ * UIKeyboardHandlerFullscreen class implementation
  */
 …
 /* Global includes */
+#include <QApplication>
+#include <QDesktopWidget>
+#include <QMainWindow>
+#include <QKeyEvent>
 #include <QTimer>
+#ifdef Q_WS_MAC
+#include <QMenuBar>
+#endif
+#ifdef Q_WS_X11
+#include <limits.h>
+#endif
+#include <QWidget>
 /* Local includes */
+#include "VBoxGlobal.h"
+#include "UISession.h"
+#include "UIActionsPool.h"
+#include "UIMachineLogic.h"
+#include "UIKeyboardHandlerFullscreen.h"
 #include "UIMachineWindow.h"
-#include "UIFrameBuffer.h"
-#include "UIMachineLogicFullscreen.h"
-#include "UIMachineViewFullscreen.h"
+UIMachineViewFullscreen::UIMachineViewFullscreen(  UIMachineWindow *pMachineWindow
+                                                 , ulong uScreenId
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                                                 , bool bAccelerate2DVideo
+#endif
+                                                 )
+    : UIMachineView(  pMachineWindow
+                    , uScreenId
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                    , bAccelerate2DVideo
+#endif
+                    )
+    , m_bIsGuestAutoresizeEnabled(pMachineWindow->machineLogic()->actionsPool()->action(UIActionIndex_Toggle_GuestAutoresize)->isChecked())
+    , m_fShouldWeDoResize(false)
+    , m_pSyncBlocker(0)
+/* Fullscreen keyboard-handler constructor: */
+UIKeyboardHandlerFullscreen::UIKeyboardHandlerFullscreen(UIMachineLogic* pMachineLogic)
+    : UIKeyboardHandler(pMachineLogic)
+{
-    /* Load machine view settings: */
-    loadMachineViewSettings();
-    /* Prepare frame buffer: */
-    prepareFrameBuffer();
-    /* Prepare common things: */
-    prepareCommon();
-    /* Prepare event-filters: */
-    prepareFilters();
-    /* Prepare console connections: */
-    prepareConsoleConnections();
-    /* Prepare fullscreen: */
-    prepareFullscreen();
-    /* Initialization: */
-    sltMachineStateChanged();
+}
+UIMachineViewFullscreen::~UIMachineViewFullscreen()
+/* Fullscreen keyboard-handler destructor: */
+UIKeyboardHandlerFullscreen::~UIKeyboardHandlerFullscreen()
+{
-    /* Cleanup fullscreen: */
-    cleanupFullscreen();
-    /* Cleanup common things: */
-    cleanupCommon();
-    /* Cleanup frame buffer: */
-    cleanupFrameBuffer();
+}
+void UIMachineViewFullscreen::sltPerformGuestResize(const QSize &toSize)
+/* Event handler for prepared listener(s): */
+bool UIKeyboardHandlerFullscreen::eventFilter(QObject *pWatchedObject, QEvent *pEvent)
+{
+    if (m_bIsGuestAutoresizeEnabled && uisession()->isGuestSupportsGraphics())
+    /* Check if pWatchedObject object is view: */
+    if (UIMachineView *pWatchedView = isItListenedView(pWatchedObject))
+    {
+        /* Get machine window: */
+        QMainWindow *pMachineWindow = machineWindowWrapper() && machineWindowWrapper()->machineWindow() ?
+                                      qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow()) : 0;
+        /* If this slot is invoked directly then use the passed size otherwise get
+         * the available size for the guest display. We assume here that centralWidget()
+         * contains this view only and gives it all available space: */
+        QSize newSize(toSize.isValid() ? toSize : pMachineWindow ? pMachineWindow->centralWidget()->size() : QSize());
+        AssertMsg(newSize.isValid(), ("Size should be valid!\n"));
+        /* Do not send the same hints as we already have: */
+        if ((newSize.width() == storedConsoleSize().width()) && (newSize.height() == storedConsoleSize().height()))
+            return;
+        /* We only actually send the hint if either an explicit new size was given
+         * (e.g. if the request was triggered directly by a console resize event) or
+         * if no explicit size was specified but a resize is flagged as being needed
+         * (e.g. the autoresize was just enabled and the console was resized while it was disabled). */
+        if (toSize.isValid() || m_fShouldWeDoResize)
+        {
+            /* Remember the new size: */
+            storeConsoleSize(newSize.width(), newSize.height());
+            /* Send new size-hint to the guest: */
+            session().GetConsole().GetDisplay().SetVideoModeHint(newSize.width(), newSize.height(), 0, screenId());
+        }
+        /* We had requested resize now, rejecting other accident requests: */
+        m_fShouldWeDoResize = false;
+    }
+}
+void UIMachineViewFullscreen::sltAdditionsStateChanged()
+{
+    /* Check if we should restrict minimum size: */
+    maybeRestrictMinimumSize();
+    /* Check if we should resize guest to fullscreen, all the
+     * required features will be tested in sltPerformGuestResize(...): */
+    if ((int)frameBuffer()->width() != workingArea().size().width() ||
+        (int)frameBuffer()->height() != workingArea().size().height())
+        sltPerformGuestResize(workingArea().size());
+}
+void UIMachineViewFullscreen::sltDesktopResized()
+{
+    /* If the desktop geometry is set automatically, this will update it: */
+    calculateDesktopGeometry();
+}
+bool UIMachineViewFullscreen::event(QEvent *pEvent)
+{
+    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 */
+            /* 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:
+        {
+            /* Get key-event: */
+            QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
+            /* Process Host+Home for menu popup: */
+            if (isHostKeyPressed() && pEvent->type() == QEvent::KeyPress)
+            {
+                if (pKeyEvent->key() == Qt::Key_Home)
+                    QTimer::singleShot(0, machineWindowWrapper()->machineWindow(), SLOT(sltPopupMainMenu()));
+                else
+                    pEvent->ignore();
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return UIMachineView::event(pEvent);
+}
+bool UIMachineViewFullscreen::eventFilter(QObject *pWatched, QEvent *pEvent)
+{
+    /* Who are we watching? */
+    QMainWindow *pMainDialog = machineWindowWrapper() && machineWindowWrapper()->machineWindow() ?
+                               qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow()) : 0;
+    if (pWatched != 0 && pWatched == pMainDialog)
+    {
+        /* Get corresponding screen index: */
+        ulong uScreenId = m_views.key(pWatchedView);
+        NOREF(uScreenId);
+        /* Handle view events: */
         switch (pEvent->type())
+        {
             case QEvent::Resize:
+            case QEvent::KeyPress:
+            {
+                /* Send guest-resize hint only if top window resizing to required dimension: */
+                QResizeEvent *pResizeEvent = static_cast<QResizeEvent*>(pEvent);
+                if (pResizeEvent->size() != workingArea().size())
+                    break;
+                /* Set the "guest needs to resize" hint.
+                 * This hint is acted upon when (and only when) the autoresize property is "true": */
+                m_fShouldWeDoResize = uisession()->isGuestSupportsGraphics();
+                if (m_bIsGuestAutoresizeEnabled && m_fShouldWeDoResize)
+                    QTimer::singleShot(0, this, SLOT(sltPerformGuestResize()));
+                /* Get key-event: */
+                QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
+                /* Process Host+Home for menu popup: */
+                if (isHostKeyPressed() && pEvent->type() == QEvent::KeyPress)
+                {
+                    if (pKeyEvent->key() == Qt::Key_Home)
+                    {
+                        /* Post request to show popup-menu: */
+                        QTimer::singleShot(0, m_windows[uScreenId]->machineWindow(), SLOT(sltPopupMainMenu()));
+                        /* Filter-out this event: */
+                        return true;
+                    }
+                }
                 break;
+            }
 …
+    }
+    return UIMachineView::eventFilter(pWatched, pEvent);
+    /* Else just propagate to base-class: */
+    return UIKeyboardHandler::eventFilter(pWatchedObject, pEvent);
+}
-void UIMachineViewFullscreen::prepareCommon()
+{
-    /* Base class common settings: */
-    UIMachineView::prepareCommon();
-    /* Setup size-policy: */
-    setSizePolicy(QSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum));
-    /* Maximum size to sizehint: */
-    setMaximumSize(sizeHint());
-    /* Minimum size is ignored: */
-    setMinimumSize(0, 0);
-    /* No scrollbars: */
-    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
-    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+}
-void UIMachineViewFullscreen::prepareFilters()
+{
-    /* Base class filters: */
-    UIMachineView::prepareFilters();
-#ifdef Q_WS_MAC // TODO: Is it really needed? See UIMachineViewSeamless::eventFilter(...);
-    /* Menu bar filter: */
-    qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow())->menuBar()->installEventFilter(this);
-#endif
+}
-void UIMachineViewFullscreen::prepareConnections()
+{
-    connect(QApplication::desktop(), SIGNAL(resized(int)), this, SLOT(sltDesktopResized()));
+}
-void UIMachineViewFullscreen::prepareConsoleConnections()
+{
-    /* Base class connections: */
-    UIMachineView::prepareConsoleConnections();
-    /* Guest additions state-change updater: */
-    connect(uisession(), SIGNAL(sigAdditionsStateChange()), this, SLOT(sltAdditionsStateChanged()));
+}
-void UIMachineViewFullscreen::prepareFullscreen()
+{
-    /* Create sync-blocker: */
-    m_pSyncBlocker = new UIMachineViewBlocker;
+}
-void UIMachineViewFullscreen::cleanupFullscreen()
+{
-    /* If machine still running: */
-    if (uisession()->isRunning())
+    {
-        /* And guest supports advanced graphics management which is enabled: */
-        if (m_bIsGuestAutoresizeEnabled && uisession()->isGuestSupportsGraphics())
+        {
-            /* Rollback seamless frame-buffer size to normal: */
-            machineWindowWrapper()->machineWindow()->hide();
-            sltPerformGuestResize(guestSizeHint());
-            m_pSyncBlocker->exec();
-            /* Request to delete sync-blocker: */
-            m_pSyncBlocker->deleteLater();
+        }
+    }
+}
-void UIMachineViewFullscreen::setGuestAutoresizeEnabled(bool fEnabled)
+{
-    if (m_bIsGuestAutoresizeEnabled != fEnabled)
+    {
-        m_bIsGuestAutoresizeEnabled = fEnabled;
-        maybeRestrictMinimumSize();
-        sltPerformGuestResize();
+    }
+}
-QRect UIMachineViewFullscreen::workingArea()
+{
-    /* Get corresponding screen: */
-    int iScreen = static_cast<UIMachineLogicFullscreen*>(machineLogic())->hostScreenForGuestScreen(screenId());
-    /* Return available geometry for that screen: */
-    return QApplication::desktop()->screenGeometry(iScreen);
+}
-void UIMachineViewFullscreen::calculateDesktopGeometry()
+{
-    /* This method should not get called until we have initially set up the desktop geometry type: */
-    Assert((desktopGeometryType() != DesktopGeo_Invalid));
-    /* If we are not doing automatic geometry calculation then there is nothing to do: */
-    if (desktopGeometryType() == DesktopGeo_Automatic)
-        m_desktopGeometry = workingArea().size();
+}
-void UIMachineViewFullscreen::maybeRestrictMinimumSize()
+{
-    /* Sets the minimum size restriction depending on the auto-resize feature state and the current rendering mode.
-     * Currently, the restriction is set only in SDL mode and only when the auto-resize feature is inactive.
-     * We need to do that because we cannot correctly draw in a scrolled window in SDL mode.
-     * In all other modes, or when auto-resize is in force, this function does nothing. */
-    if (vboxGlobal().vmRenderMode() == VBoxDefs::SDLMode)
+    {
-        if (!uisession()->isGuestSupportsGraphics() || !m_bIsGuestAutoresizeEnabled)
-            setMinimumSize(sizeHint());
-        else
-            setMinimumSize(0, 0);
+    }
+}

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

-              r30551
+              r30637
+ *
  * VBox frontends: Qt GUI ("VirtualBox"):
  * UIMachineViewFullscreen class declaration
+ * UIKeyboardHandlerFullscreen class declaration
  */
 …
  */
 #ifndef ___UIMachineViewFullscreen_h___
 #define ___UIMachineViewFullscreen_h___
+#ifndef ___UIKeyboardHandlerFullscreen_h___
+#define ___UIKeyboardHandlerFullscreen_h___
 /* Local includes */
 #include "UIMachineView.h"
+#include "UIKeyboardHandler.h"
 class UIMachineViewFullscreen : public UIMachineView
+class UIKeyboardHandlerFullscreen : public UIKeyboardHandler
+{
     Q_OBJECT;
 …
 protected:
+    /* Fullscreen machine-view constructor: */
+    UIMachineViewFullscreen(  UIMachineWindow *pMachineWindow
+                            , ulong uScreenId
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                            , bool bAccelerate2DVideo
+#endif
+    );
+    /* Fullscreen machine-view destructor: */
+    virtual ~UIMachineViewFullscreen();
+private slots:
+    /* Slot to perform guest resize: */
+    void sltPerformGuestResize(const QSize &aSize = QSize());
+    /* Console callback handlers: */
+    void sltAdditionsStateChanged();
+    /* Watch dog for desktop resizes: */
+    void sltDesktopResized();
+    /* Fullscreen keyboard-handler constructor/destructor: */
+    UIKeyboardHandlerFullscreen(UIMachineLogic *pMachineLogic);
+    virtual ~UIKeyboardHandlerFullscreen();
 private:
     /* Event handlers: */
-    bool event(QEvent *pEvent);
     bool eventFilter(QObject *pWatched, QEvent *pEvent);
-    /* Prepare routines: */
-    void prepareCommon();
-    void prepareFilters();
-    void prepareConnections();
-    void prepareConsoleConnections();
-    void prepareFullscreen();
-    /* Cleanup routines: */
-    void cleanupFullscreen();
-    //void cleanupConsoleConnections() {}
-    //void cleanupConnections() {}
-    //void cleanupFilters() {}
-    //void cleanupCommon() {}
-    /* Private setters: */
-    void setGuestAutoresizeEnabled(bool bEnabled);
-    /* Private helpers: */
-    void normalizeGeometry(bool /* fAdjustPosition */) {}
-    QRect workingArea();
-    void calculateDesktopGeometry();
-    void maybeRestrictMinimumSize();
-    /* Private variables: */
-    bool m_bIsGuestAutoresizeEnabled : 1;
-    bool m_fShouldWeDoResize : 1;
-    UIMachineViewBlocker *m_pSyncBlocker;
     /* Friend classes: */
     friend class UIMachineView;
+    friend class UIKeyboardHandler;
 };
 #endif // !___UIMachineViewFullscreen_h___
+#endif // !___UIKeyboardHandlerFullscreen_h___

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

-              r30544
+              r30637
     cleanupFullscreen();
-    /* Cleanup common things: */
-    cleanupCommon();
     /* Cleanup frame buffer: */
     cleanupFrameBuffer();
 …
             return true;
+        }
-        case QEvent::KeyPress:
-        case QEvent::KeyRelease:
+        {
-            /* Get key-event: */
-            QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
-            /* Process Host+Home for menu popup: */
-            if (isHostKeyPressed() && pEvent->type() == QEvent::KeyPress)
+            {
-                if (pKeyEvent->key() == Qt::Key_Home)
-                    QTimer::singleShot(0, machineWindowWrapper()->machineWindow(), SLOT(sltPopupMainMenu()));
-                else
-                    pEvent->ignore();
+            }
-            break;
+        }

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

-              r30551
+              r30637
+ *
  * VBox frontends: Qt GUI ("VirtualBox"):
  * UIMachineViewNormal class implementation
+ * UIKeyboardHandlerNormal class implementation
  */
 …
 /* Global includes */
-#include <QApplication>
-#include <QDesktopWidget>
 #include <QMainWindow>
 #include <QMenuBar>
+#include <QScrollBar>
+#include <QTimer>
+#include <QKeyEvent>
 /* Local includes */
+#include "VBoxGlobal.h"
+#include "UISession.h"
+#include "UIActionsPool.h"
+#include "UIMachineLogic.h"
+#include "UIKeyboardHandlerNormal.h"
 #include "UIMachineWindow.h"
-#include "UIFrameBuffer.h"
-#include "UIMachineViewNormal.h"
+UIMachineViewNormal::UIMachineViewNormal(  UIMachineWindow *pMachineWindow
+                                         , ulong uScreenId
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                                         , bool bAccelerate2DVideo
+#endif
+                                         )
+    : UIMachineView(  pMachineWindow
+                    , uScreenId
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                    , bAccelerate2DVideo
+#endif
+                    )
+    , m_bIsGuestAutoresizeEnabled(pMachineWindow->machineLogic()->actionsPool()->action(UIActionIndex_Toggle_GuestAutoresize)->isChecked())
+    , m_fShouldWeDoResize(false)
+/* Fullscreen keyboard-handler constructor: */
+UIKeyboardHandlerNormal::UIKeyboardHandlerNormal(UIMachineLogic* pMachineLogic)
+    : UIKeyboardHandler(pMachineLogic)
+{
-    /* Load machine view settings: */
-    loadMachineViewSettings();
-    /* Prepare frame buffer: */
-    prepareFrameBuffer();
-    /* Prepare common things: */
-    prepareCommon();
-    /* Prepare event-filters: */
-    prepareFilters();
-    /* Prepare connections: */
-    prepareConnections();
-    /* Prepare console connections: */
-    prepareConsoleConnections();
-    /* Initialization: */
-    sltMachineStateChanged();
-    sltAdditionsStateChanged();
+}
+UIMachineViewNormal::~UIMachineViewNormal()
+/* Fullscreen keyboard-handler destructor: */
+UIKeyboardHandlerNormal::~UIKeyboardHandlerNormal()
+{
-    /* Save machine view settings: */
-    saveMachineViewSettings();
-    /* Cleanup common things: */
-    cleanupCommon();
-    /* Cleanup frame buffer: */
-    cleanupFrameBuffer();
+}
+void UIMachineViewNormal::sltPerformGuestResize(const QSize &toSize)
+/* Event handler for prepared listener(s): */
+bool UIKeyboardHandlerNormal::eventFilter(QObject *pWatchedObject, QEvent *pEvent)
+{
+    if (m_bIsGuestAutoresizeEnabled && uisession()->isGuestSupportsGraphics())
+    /* Check if pWatchedObject object is view: */
+    if (UIMachineView *pWatchedView = isItListenedView(pWatchedObject))
+    {
+        /* Get machine window: */
+        QMainWindow *pMachineWindow = machineWindowWrapper() && machineWindowWrapper()->machineWindow() ?
+                                      qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow()) : 0;
+        /* If this slot is invoked directly then use the passed size otherwise get
+         * the available size for the guest display. We assume here that centralWidget()
+         * contains this view only and gives it all available space: */
+        QSize newSize(toSize.isValid() ? toSize : pMachineWindow ? pMachineWindow->centralWidget()->size() : QSize());
+        AssertMsg(newSize.isValid(), ("Size should be valid!\n"));
+        /* Do not send the same hints as we already have: */
+        if ((newSize.width() == storedConsoleSize().width()) && (newSize.height() == storedConsoleSize().height()))
+            return;
+        /* We only actually send the hint if either an explicit new size was given
+         * (e.g. if the request was triggered directly by a console resize event) or
+         * if no explicit size was specified but a resize is flagged as being needed
+         * (e.g. the autoresize was just enabled and the console was resized while it was disabled). */
+        if (toSize.isValid() || m_fShouldWeDoResize)
+        /* Get corresponding screen index: */
+        ulong uScreenId = m_views.key(pWatchedView);
+        NOREF(uScreenId);
+        /* Handle view events: */
+        switch (pEvent->type())
+        {
-            /* Remember the new size: */
-            storeConsoleSize(newSize.width(), newSize.height());
-            /* Send new size-hint to the guest: */
-            session().GetConsole().GetDisplay().SetVideoModeHint(newSize.width(), newSize.height(), 0, screenId());
+        }
-        /* We had requested resize now, rejecting other accident requests: */
-        m_fShouldWeDoResize = false;
+    }
+}
-void UIMachineViewNormal::sltAdditionsStateChanged()
+{
-    /* Check if we should restrict minimum size: */
-    maybeRestrictMinimumSize();
+}
-void UIMachineViewNormal::sltDesktopResized()
+{
-    /* If the desktop geometry is set automatically, this will update it: */
-    calculateDesktopGeometry();
+}
-bool UIMachineViewNormal::event(QEvent *pEvent)
+{
-    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 */
-            /* 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
+        /* 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:
+        {
+            /* Get key-event: */
+            QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
+            /* Process Host+Home as menu-bar activator: */
+            if (isHostKeyPressed() && pEvent->type() == QEvent::KeyPress)
+            /* 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:
+            {
+                if (pKeyEvent->key() == Qt::Key_Home)
+                /* Get key-event: */
+                QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
+                /* Process Host+Home as menu-bar activator: */
+                if (isHostKeyPressed() && pEvent->type() == QEvent::KeyPress)
+                {
+                    /* Trying to get menu-bar: */
+                    QMenuBar *pMenuBar = machineWindowWrapper() && machineWindowWrapper()->machineWindow() ?
+                                         qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow())->menuBar() : 0;
+                    /* If menu-bar is present and have actions: */
+                    if (pMenuBar && !pMenuBar->actions().isEmpty())
+                    if (pKeyEvent->key() == Qt::Key_Home)
+                    {
+                        /* If 'active' action is NOT chosen: */
+                        if (!pMenuBar->activeAction())
+                            /* Set first menu-bar action as 'active': */
+                            pMenuBar->setActiveAction(pMenuBar->actions()[0]);
+                        /* If 'active' action is chosen: */
+                        if (pMenuBar->activeAction())
+                        /* Trying to get menu-bar: */
+                        QMenuBar *pMenuBar = qobject_cast<QMainWindow*>(m_windows[uScreenId]->machineWindow())->menuBar();
+                        /* If menu-bar is present and have actions: */
+                        if (pMenuBar && !pMenuBar->actions().isEmpty())
+                        {
+                            /* Activate 'active' menu-bar action: */
+                            pMenuBar->activeAction()->activate(QAction::Trigger);
+                            /* If 'active' action is NOT chosen: */
+                            if (!pMenuBar->activeAction())
+                                /* Set first menu-bar action as 'active': */
+                                pMenuBar->setActiveAction(pMenuBar->actions()[0]);
+                            /* If 'active' action is chosen: */
+                            if (pMenuBar->activeAction())
+                            {
+                                /* Activate 'active' menu-bar action: */
+                                pMenuBar->activeAction()->activate(QAction::Trigger);
 #ifdef Q_WS_WIN
                             /* Windows host needs separate 'focus set'
                              * to let menubar operate while popped up: */
                             pMenuBar->setFocus();
+                                /* Windows host needs separate 'focus set'
+                                 * to let menubar operate while popped up: */
+                                pMenuBar->setFocus();
 #endif /* Q_WS_WIN */
+                            /* Accept this event: */
+                            pEvent->accept();
+                            return true;
+                                /* Filter-out this event: */
+                                return true;
+                            }
+                        }
+                    }
+                }
-                else
-                    pEvent->ignore();
+            }
-            break;
+        }
-#endif /* !Q_WS_MAC */
-        default:
-            break;
+    }
-    return UIMachineView::event(pEvent);
+}
-bool UIMachineViewNormal::eventFilter(QObject *pWatched, QEvent *pEvent)
+{
-    /* Who are we watching? */
-    QMainWindow *pMainDialog = machineWindowWrapper() && machineWindowWrapper()->machineWindow() ?
-                               qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow()) : 0;
-#ifdef Q_WS_WIN
-    QMenuBar *pMenuBar = pMainDialog ? pMainDialog->menuBar() : 0;
-#endif /* Q_WS_WIN */
-    if (pWatched != 0 && pWatched == pMainDialog)
+    {
-        switch (pEvent->type())
+        {
-            case QEvent::Resize:
+            {
-                /* Set the "guest needs to resize" hint.
-                 * This hint is acted upon when (and only when) the autoresize property is "true": */
-                m_fShouldWeDoResize = uisession()->isGuestSupportsGraphics();
-                if (!isMachineWindowResizeIgnored() && m_bIsGuestAutoresizeEnabled && uisession()->isGuestSupportsGraphics())
-                    QTimer::singleShot(300, this, SLOT(sltPerformGuestResize()));
                 break;
+            }
+#if defined (Q_WS_WIN32)
+# if defined (VBOX_GUI_USE_DDRAW)
+            case QEvent::Move:
+            {
+                /* Notification from our parent that it has moved. We need this in order
+                 * to possibly adjust the direct screen blitting: */
+                if (frameBuffer())
+                    frameBuffer()->moveEvent(static_cast<QMoveEvent*>(pEvent));
+                break;
+            }
+# endif /* defined (VBOX_GUI_USE_DDRAW) */
+#endif /* defined (Q_WS_WIN32) */
+#endif /* !Q_WS_MAC */
             default:
                 break;
 …
+    }
+#ifdef Q_WS_WIN
+    else if (pWatched != 0 && pWatched == pMenuBar)
+    {
+        /* Due to windows host uses separate 'focus set' to let menubar to
+         * operate while popped up (see UIMachineViewNormal::event() for details),
+         * it also requires backward processing: */
+        switch (pEvent->type())
+        {
+            /* If menubar gets the focus while not popped up => give it back: */
+            case QEvent::FocusIn:
+            {
+                if (!QApplication::activePopupWidget())
+                    setFocus();
+            }
+            default:
+                break;
+        }
+    }
+#endif /* Q_WS_WIN */
+    return UIMachineView::eventFilter(pWatched, pEvent);
+    /* Else just propagate to base-class: */
+    return UIKeyboardHandler::eventFilter(pWatchedObject, pEvent);
+}
-void UIMachineViewNormal::prepareCommon()
+{
-    /* Base class common settings: */
-    UIMachineView::prepareCommon();
-    /* Setup size-policy: */
-    setSizePolicy(QSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum));
-    /* Maximum size to sizehint: */
-    setMaximumSize(sizeHint());
+}
-void UIMachineViewNormal::prepareFilters()
+{
-    /* Base class filters: */
-    UIMachineView::prepareFilters();
-    /* Menu bar filters: */
-    qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow())->menuBar()->installEventFilter(this);
+}
-void UIMachineViewNormal::prepareConnections()
+{
-    connect(QApplication::desktop(), SIGNAL(resized(int)), this, SLOT(sltDesktopResized()));
+}
-void UIMachineViewNormal::prepareConsoleConnections()
+{
-    /* Base class connections: */
-    UIMachineView::prepareConsoleConnections();
-    /* Guest additions state-change updater: */
-    connect(uisession(), SIGNAL(sigAdditionsStateChange()), this, SLOT(sltAdditionsStateChanged()));
+}
-void UIMachineViewNormal::saveMachineViewSettings()
+{
-    /* Store guest size hint: */
-    storeGuestSizeHint(QSize(frameBuffer()->width(), frameBuffer()->height()));
+}
-void UIMachineViewNormal::setGuestAutoresizeEnabled(bool fEnabled)
+{
-    if (m_bIsGuestAutoresizeEnabled != fEnabled)
+    {
-        m_bIsGuestAutoresizeEnabled = fEnabled;
-        maybeRestrictMinimumSize();
-        if (m_bIsGuestAutoresizeEnabled && uisession()->isGuestSupportsGraphics())
-            sltPerformGuestResize();
+    }
+}
-void UIMachineViewNormal::normalizeGeometry(bool bAdjustPosition)
+{
-    QWidget *pTopLevelWidget = window();
-    /* Make no normalizeGeometry in case we are in manual resize mode or main window is maximized: */
-    if (pTopLevelWidget->isMaximized())
-        return;
-    /* Calculate client window offsets: */
-    QRect frameGeo = pTopLevelWidget->frameGeometry();
-    QRect geo = pTopLevelWidget->geometry();
-    int dl = geo.left() - frameGeo.left();
-    int dt = geo.top() - frameGeo.top();
-    int dr = frameGeo.right() - geo.right();
-    int db = frameGeo.bottom() - geo.bottom();
-    /* Get the best size w/o scroll bars: */
-    QSize s = pTopLevelWidget->sizeHint();
-    /* Resize the frame to fit the contents: */
-    s -= pTopLevelWidget->size();
-    frameGeo.setRight(frameGeo.right() + s.width());
-    frameGeo.setBottom(frameGeo.bottom() + s.height());
-    if (bAdjustPosition)
+    {
-        QRegion availableGeo;
-        QDesktopWidget *dwt = QApplication::desktop();
-        if (dwt->isVirtualDesktop())
-            /* Compose complex available region */
-            for (int i = 0; i < dwt->numScreens(); ++ i)
-                availableGeo += dwt->availableGeometry(i);
-        else
-            /* Get just a simple available rectangle */
-            availableGeo = dwt->availableGeometry(pTopLevelWidget->pos());
-        frameGeo = VBoxGlobal::normalizeGeometry(frameGeo, availableGeo, vboxGlobal().vmRenderMode() != VBoxDefs::SDLMode /* can resize? */);
+    }
-#if 0
-    /* Center the frame on the desktop: */
-    frameGeo.moveCenter(availableGeo.center());
-#endif
-    /* Finally, set the frame geometry */
-    pTopLevelWidget->setGeometry(frameGeo.left() + dl, frameGeo.top() + dt, frameGeo.width() - dl - dr, frameGeo.height() - dt - db);
+}
-QRect UIMachineViewNormal::workingArea()
+{
-    return QApplication::desktop()->availableGeometry(this);
+}
-void UIMachineViewNormal::calculateDesktopGeometry()
+{
-    /* This method should not get called until we have initially set up the desktop geometry type: */
-    Assert((desktopGeometryType() != DesktopGeo_Invalid));
-    /* If we are not doing automatic geometry calculation then there is nothing to do: */
-    if (desktopGeometryType() == DesktopGeo_Automatic)
+    {
-        /* The area taken up by the machine window on the desktop,
-         * including window frame, title, menu bar and status bar: */
-        QRect windowGeo = machineWindowWrapper()->machineWindow()->frameGeometry();
-        /* The area taken up by the machine central widget, so excluding all decorations: */
-        QRect centralWidgetGeo = static_cast<QMainWindow*>(machineWindowWrapper()->machineWindow())->centralWidget()->geometry();
-        /* To work out how big we can make the console window while still fitting on the desktop,
-         * we calculate workingArea() - (windowGeo - centralWidgetGeo).
-         * This works because the difference between machine window and machine central widget
-         * (or at least its width and height) is a constant. */
-        m_desktopGeometry = QSize(workingArea().width() - (windowGeo.width() - centralWidgetGeo.width()),
-                                  workingArea().height() - (windowGeo.height() - centralWidgetGeo.height()));
+    }
+}
-void UIMachineViewNormal::maybeRestrictMinimumSize()
+{
-    /* Sets the minimum size restriction depending on the auto-resize feature state and the current rendering mode.
-     * Currently, the restriction is set only in SDL mode and only when the auto-resize feature is inactive.
-     * We need to do that because we cannot correctly draw in a scrolled window in SDL mode.
-     * In all other modes, or when auto-resize is in force, this function does nothing. */
-    if (vboxGlobal().vmRenderMode() == VBoxDefs::SDLMode)
+    {
-        if (!uisession()->isGuestSupportsGraphics() || !m_bIsGuestAutoresizeEnabled)
-            setMinimumSize(sizeHint());
-        else
-            setMinimumSize(0, 0);
+    }
+}

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

-              r30551
+              r30637
+ *
  * VBox frontends: Qt GUI ("VirtualBox"):
  * UIMachineViewNormal class declaration
+ * UIKeyboardHandlerNormal class declaration
  */
 …
  */
 #ifndef ___UIMachineViewNormal_h___
 #define ___UIMachineViewNormal_h___
+#ifndef ___UIKeyboardHandlerNormal_h___
+#define ___UIKeyboardHandlerNormal_h___
 /* Local includes */
 #include "UIMachineView.h"
+#include "UIKeyboardHandler.h"
 class UIMachineViewNormal : public UIMachineView
+class UIKeyboardHandlerNormal : public UIKeyboardHandler
+{
     Q_OBJECT;
 …
 protected:
+    /* Normal machine-view constructor: */
+    UIMachineViewNormal(  UIMachineWindow *pMachineWindow
+                        , ulong uScreenId
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                        , bool bAccelerate2DVideo
+#endif
+    );
+    /* Normal machine-view destructor: */
+    virtual ~UIMachineViewNormal();
+private slots:
+    /* Slot to perform guest resize: */
+    void sltPerformGuestResize(const QSize &size = QSize());
+    /* Console callback handlers: */
+    void sltAdditionsStateChanged();
+    /* Watch dog for desktop resizes: */
+    void sltDesktopResized();
+#ifdef Q_WS_X11
+    /* Slot to perform synchronized geometry normalization.
+     * Currently its only required under X11 as of its async nature: */
+    virtual void sltNormalizeGeometry() { normalizeGeometry(true); }
+#endif /* Q_WS_X11 */
+    /* Fullscreen keyboard-handler constructor/destructor: */
+    UIKeyboardHandlerNormal(UIMachineLogic *pMachineLogic);
+    virtual ~UIKeyboardHandlerNormal();
 private:
     /* Event handlers: */
-    bool event(QEvent *pEvent);
     bool eventFilter(QObject *pWatched, QEvent *pEvent);
-    /* Prepare helpers: */
-    void prepareCommon();
-    void prepareFilters();
-    void prepareConnections();
-    void prepareConsoleConnections();
-    //void loadMachineViewSettings();
-    /* Cleanup helpers: */
-    void saveMachineViewSettings();
-    //void cleanupConsoleConnections() {}
-    //void prepareConnections() {}
-    //void cleanupFilters() {}
-    //void cleanupCommon() {}
-    /* Hidden setters: */
-    void setGuestAutoresizeEnabled(bool bEnabled);
-    /* Private helpers: */
-    void normalizeGeometry(bool fAdjustPosition);
-    QRect workingArea();
-    void calculateDesktopGeometry();
-    void maybeRestrictMinimumSize();
-    /* Private members: */
-    bool m_bIsGuestAutoresizeEnabled : 1;
-    bool m_fShouldWeDoResize : 1;
     /* Friend classes: */
     friend class UIMachineView;
+    friend class UIKeyboardHandler;
 };
 #endif // !___UIMachineViewNormal_h___
+#endif // !___UIKeyboardHandlerNormal_h___

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

-              r30544
+              r30637
     saveMachineViewSettings();
-    /* Cleanup common things: */
-    cleanupCommon();
     /* Cleanup frame buffer: */
     cleanupFrameBuffer();
 …
             return true;
+        }
-#ifndef Q_WS_MAC
-        /* 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:
+        {
-            /* Get key-event: */
-            QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
-            /* Process Host+Home as menu-bar activator: */
-            if (isHostKeyPressed() && pEvent->type() == QEvent::KeyPress)
+            {
-                if (pKeyEvent->key() == Qt::Key_Home)
+                {
-                    /* Trying to get menu-bar: */
-                    QMenuBar *pMenuBar = machineWindowWrapper() && machineWindowWrapper()->machineWindow() ?
-                                         qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow())->menuBar() : 0;
-                    /* If menu-bar is present and have actions: */
-                    if (pMenuBar && !pMenuBar->actions().isEmpty())
+                    {
-                        /* If 'active' action is NOT chosen: */
-                        if (!pMenuBar->activeAction())
-                            /* Set first menu-bar action as 'active': */
-                            pMenuBar->setActiveAction(pMenuBar->actions()[0]);
-                        /* If 'active' action is chosen: */
-                        if (pMenuBar->activeAction())
+                        {
-                            /* Activate 'active' menu-bar action: */
-                            pMenuBar->activeAction()->activate(QAction::Trigger);
-#ifdef Q_WS_WIN
-                            /* Windows host needs separate 'focus set'
-                             * to let menubar operate while popped up: */
-                            pMenuBar->setFocus();
-#endif /* Q_WS_WIN */
-                            /* Accept this event: */
-                            pEvent->accept();
-                            return true;
+                        }
+                    }
+                }
-                else
-                    pEvent->ignore();
+            }
-            break;
+        }
-#endif /* !Q_WS_MAC */
         default:

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

-              r30546
+              r30637
 #include "UIActionsPool.h"
 #include "UIIndicatorsPool.h"
+#include "UIKeyboardHandler.h"
 #include "UIMouseHandler.h"
 #include "UIMachineLogic.h"
 …
+    {
         /* Keyboard state-change updater: */
         connect(machineView(), SIGNAL(keyboardStateChanged(int)), indicatorsPool()->indicator(UIIndicatorIndex_Hostkey), SLOT(setState(int)));
+        connect(machineLogic()->keyboardHandler(), SIGNAL(keyboardStateChanged(int)), indicatorsPool()->indicator(UIIndicatorIndex_Hostkey), SLOT(setState(int)));
         /* Mouse state-change updater: */
 …
         /* Early initialize required connections: */
         indicatorsPool()->indicator(UIIndicatorIndex_Hostkey)->setState(machineView()->keyboardState());
+        indicatorsPool()->indicator(UIIndicatorIndex_Hostkey)->setState(machineLogic()->keyboardHandler()->keyboardState());
         indicatorsPool()->indicator(UIIndicatorIndex_Mouse)->setState(machineLogic()->mouseHandler()->mouseState());
+    }

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

-              r30551
+              r30637
+ *
  * VBox frontends: Qt GUI ("VirtualBox"):
  * UIMachineViewSeamless class implementation
+ * UIKeyboardHandlerSeamless class implementation
  */
 …
 /* Global includes */
+#include <QApplication>
+#include <QDesktopWidget>
+#include <QMainWindow>
+#include <QKeyEvent>
 #include <QTimer>
+#ifdef Q_WS_MAC
+#include <QMenuBar>
+#endif
+#ifdef Q_WS_X11
+#include <limits.h>
+#endif
+#include <QWidget>
 /* Local includes */
+#include "VBoxGlobal.h"
+#include "UISession.h"
+#include "UIKeyboardHandlerSeamless.h"
 #include "UIMachineWindow.h"
-#include "UIMachineLogic.h"
-#include "UIFrameBuffer.h"
-#include "UIMachineLogicSeamless.h"
-#include "UIMachineViewSeamless.h"
+UIMachineViewSeamless::UIMachineViewSeamless(  UIMachineWindow *pMachineWindow
+                                             , ulong uScreenId
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                                             , bool bAccelerate2DVideo
+#endif
+                                             )
+    : UIMachineView(  pMachineWindow
+                    , uScreenId
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                    , bAccelerate2DVideo
+#endif
+                    )
+    , m_fShouldWeDoResize(false)
+    , m_pSyncBlocker(0)
+/* Fullscreen keyboard-handler constructor: */
+UIKeyboardHandlerSeamless::UIKeyboardHandlerSeamless(UIMachineLogic* pMachineLogic)
+    : UIKeyboardHandler(pMachineLogic)
+{
-    /* Load machine view settings: */
-    loadMachineViewSettings();
-    /* Prepare frame buffer: */
-    prepareFrameBuffer();
-    /* Prepare common things: */
-    prepareCommon();
-    /* Prepare event-filters: */
-    prepareFilters();
-    /* Prepare connections: */
-    prepareConnections();
-    /* Prepare console connections: */
-    prepareConsoleConnections();
-    /* Prepare seamless view: */
-    prepareSeamless();
-    /* Initialization: */
-    sltMachineStateChanged();
-    sltAdditionsStateChanged();
+}
+UIMachineViewSeamless::~UIMachineViewSeamless()
+/* Fullscreen keyboard-handler destructor: */
+UIKeyboardHandlerSeamless::~UIKeyboardHandlerSeamless()
+{
-    /* Cleanup seamless mode: */
-    cleanupSeamless();
-    /* Cleanup common things: */
-    cleanupCommon();
-    /* Cleanup frame buffer: */
-    cleanupFrameBuffer();
+}
+void UIMachineViewSeamless::sltPerformGuestResize(const QSize &toSize)
+/* Event handler for prepared listener(s): */
+bool UIKeyboardHandlerSeamless::eventFilter(QObject *pWatchedObject, QEvent *pEvent)
+{
+    if (uisession()->isGuestSupportsGraphics())
+    /* Check if pWatchedObject object is view: */
+    if (UIMachineView *pWatchedView = isItListenedView(pWatchedObject))
+    {
+        /* Get machine window: */
+        QMainWindow *pMachineWindow = machineWindowWrapper() && machineWindowWrapper()->machineWindow() ?
+                                      qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow()) : 0;
+        /* If this slot is invoked directly then use the passed size otherwise get
+         * the available size for the guest display. We assume here that centralWidget()
+         * contains this view only and gives it all available space: */
+        QSize newSize(toSize.isValid() ? toSize : pMachineWindow ? pMachineWindow->centralWidget()->size() : QSize());
+        AssertMsg(newSize.isValid(), ("Size should be valid!\n"));
+        /* Do not send the same hints as we already have: */
+        if ((newSize.width() == storedConsoleSize().width()) && (newSize.height() == storedConsoleSize().height()))
+            return;
+        /* We only actually send the hint if either an explicit new size was given
+         * (e.g. if the request was triggered directly by a console resize event) or
+         * if no explicit size was specified but a resize is flagged as being needed
+         * (e.g. the autoresize was just enabled and the console was resized while it was disabled). */
+        if (toSize.isValid() || m_fShouldWeDoResize)
+        {
+            /* Remember the new size: */
+            storeConsoleSize(newSize.width(), newSize.height());
+            /* Send new size-hint to the guest: */
+            session().GetConsole().GetDisplay().SetVideoModeHint(newSize.width(), newSize.height(), 0, screenId());
+        }
+        /* We had requested resize now, rejecting other accident requests: */
+        m_fShouldWeDoResize = false;
+    }
+}
+void UIMachineViewSeamless::sltAdditionsStateChanged()
+{
+    // TODO: Exit seamless if additions doesn't support it!
+}
+void UIMachineViewSeamless::sltDesktopResized()
+{
+    // TODO: Try to resize framebuffer according new desktop size, exit seamless if resize is failed!
+    /* If the desktop geometry is set automatically, this will update it: */
+    calculateDesktopGeometry();
+}
+bool UIMachineViewSeamless::event(QEvent *pEvent)
+{
+    switch (pEvent->type())
+    {
+        case VBoxDefs::SetRegionEventType:
+        {
+            /* Get region-update event: */
+            UISetRegionEvent *pSetRegionEvent = static_cast<UISetRegionEvent*>(pEvent);
+            /* Apply new region: */
+            if (pSetRegionEvent->region() != m_lastVisibleRegion)
+            {
+                m_lastVisibleRegion = pSetRegionEvent->region();
+                machineWindowWrapper()->setMask(m_lastVisibleRegion);
+            }
+            return true;
+        }
+        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 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:
+        {
+            /* Get key-event: */
+            QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
+            /* Process Host+Home for menu popup: */
+            if (isHostKeyPressed() && pEvent->type() == QEvent::KeyPress)
+            {
+                if (pKeyEvent->key() == Qt::Key_Home)
+                    QTimer::singleShot(0, machineWindowWrapper()->machineWindow(), SLOT(sltPopupMainMenu()));
+                else
+                    pEvent->ignore();
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return UIMachineView::event(pEvent);
+}
+bool UIMachineViewSeamless::eventFilter(QObject *pWatched, QEvent *pEvent)
+{
+    /* Who are we watching? */
+    QMainWindow *pMainDialog = machineWindowWrapper() && machineWindowWrapper()->machineWindow() ?
+                               qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow()) : 0;
+    if (pWatched != 0 && pWatched == pMainDialog)
+    {
+        /* Get corresponding screen index: */
+        ulong uScreenId = m_views.key(pWatchedView);
+        NOREF(uScreenId);
+        /* Handle view events: */
         switch (pEvent->type())
+        {
             case QEvent::Resize:
+            case QEvent::KeyPress:
+            {
+                /* Send guest-resize hint only if top window resizing to required dimension: */
+                QResizeEvent *pResizeEvent = static_cast<QResizeEvent*>(pEvent);
+                if (pResizeEvent->size() != workingArea().size())
+                    break;
+                /* Set the "guest needs to resize" hint.
+                 * This hint is acted upon when (and only when) the autoresize property is "true": */
+                m_fShouldWeDoResize = uisession()->isGuestSupportsGraphics();
+                if (m_fShouldWeDoResize)
+                    QTimer::singleShot(0, this, SLOT(sltPerformGuestResize()));
+                /* Get key-event: */
+                QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
+                /* Process Host+Home for menu popup: */
+                if (isHostKeyPressed() && pEvent->type() == QEvent::KeyPress)
+                {
+                    if (pKeyEvent->key() == Qt::Key_Home)
+                    {
+                        /* Post request to show popup-menu: */
+                        QTimer::singleShot(0, m_windows[uScreenId]->machineWindow(), SLOT(sltPopupMainMenu()));
+                        /* Filter-out this event: */
+                        return true;
+                    }
+                }
                 break;
+            }
 …
+    }
+    return UIMachineView::eventFilter(pWatched, pEvent);
+    /* Else just propagate to base-class: */
+    return UIKeyboardHandler::eventFilter(pWatchedObject, pEvent);
+}
-void UIMachineViewSeamless::prepareCommon()
+{
-    /* Base class common settings: */
-    UIMachineView::prepareCommon();
-    /* Setup size-policy: */
-    setSizePolicy(QSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum));
-    /* Maximum size to sizehint: */
-    setMaximumSize(sizeHint());
-    /* Minimum size is ignored: */
-    setMinimumSize(0, 0);
-    /* No scrollbars: */
-    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
-    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+}
-void UIMachineViewSeamless::prepareFilters()
+{
-    /* Base class filters: */
-    UIMachineView::prepareFilters();
-#ifdef Q_WS_MAC // TODO: Is it really needed? See UIMachineViewSeamless::eventFilter(...);
-    /* Menu bar filter: */
-    qobject_cast<QMainWindow*>(machineWindowWrapper()->machineWindow())->menuBar()->installEventFilter(this);
-#endif
+}
-void UIMachineViewSeamless::prepareConnections()
+{
-    connect(QApplication::desktop(), SIGNAL(resized(int)), this, SLOT(sltDesktopResized()));
+}
-void UIMachineViewSeamless::prepareConsoleConnections()
+{
-    /* Base class connections: */
-    UIMachineView::prepareConsoleConnections();
-    /* Guest additions state-change updater: */
-    connect(uisession(), SIGNAL(sigAdditionsStateChange()), this, SLOT(sltAdditionsStateChanged()));
+}
-void UIMachineViewSeamless::prepareSeamless()
+{
-    /* Set seamless feature flag to the guest: */
-    session().GetConsole().GetDisplay().SetSeamlessMode(true);
-    /* Create sync-blocker: */
-    m_pSyncBlocker = new UIMachineViewBlocker;
+}
-void UIMachineViewSeamless::cleanupSeamless()
+{
-    /* If machine still running: */
-    if (uisession()->isRunning())
+    {
-        /* Reset seamless feature flag of the guest: */
-        session().GetConsole().GetDisplay().SetSeamlessMode(false);
-        /* Rollback seamless frame-buffer size to normal: */
-        machineWindowWrapper()->machineWindow()->hide();
-        sltPerformGuestResize(guestSizeHint());
-        m_pSyncBlocker->exec();
-        /* Delete sync-blocker: */
-        m_pSyncBlocker->deleteLater();
+    }
+}
-QRect UIMachineViewSeamless::workingArea()
+{
-    /* Get corresponding screen: */
-    int iScreen = static_cast<UIMachineLogicSeamless*>(machineLogic())->hostScreenForGuestScreen(screenId());
-    /* Return available geometry for that screen: */
-    return vboxGlobal().availableGeometry(iScreen);
+}
-void UIMachineViewSeamless::calculateDesktopGeometry()
+{
-    /* This method should not get called until we have initially set up the desktop geometry type: */
-    Assert((desktopGeometryType() != DesktopGeo_Invalid));
-    /* If we are not doing automatic geometry calculation then there is nothing to do: */
-    if (desktopGeometryType() == DesktopGeo_Automatic)
-        m_desktopGeometry = workingArea().size();
+}

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

-              r30551
+              r30637
+ *
  * VBox frontends: Qt GUI ("VirtualBox"):
  * UIMachineViewSeamless class declaration
+ * UIKeyboardHandlerSeamless class declaration
  */
 …
  */
 #ifndef ___UIMachineViewSeamless_h___
 #define ___UIMachineViewSeamless_h___
+#ifndef ___UIKeyboardHandlerSeamless_h___
+#define ___UIKeyboardHandlerSeamless_h___
 /* Local includes */
 #include "UIMachineView.h"
+#include "UIKeyboardHandler.h"
 class UIMachineViewSeamless : public UIMachineView
+class UIKeyboardHandlerSeamless : public UIKeyboardHandler
+{
     Q_OBJECT;
-public:
-    /* Public getters: */
-    QRegion lastVisibleRegion() const { return m_lastVisibleRegion; }
 protected:
+    /* Seamless machine-view constructor: */
+    UIMachineViewSeamless(  UIMachineWindow *pMachineWindow
+                          , ulong uScreenId
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                          , bool bAccelerate2DVideo
+#endif
+    );
+    /* Seamless machine-view destructor: */
+    virtual ~UIMachineViewSeamless();
+private slots:
+    /* Slot to perform guest resize: */
+    void sltPerformGuestResize(const QSize &aSize = QSize());
+    /* Console callback handlers: */
+    void sltAdditionsStateChanged();
+    /* Watch dog for desktop resizes: */
+    void sltDesktopResized();
+    /* Fullscreen keyboard-handler constructor/destructor: */
+    UIKeyboardHandlerSeamless(UIMachineLogic *pMachineLogic);
+    virtual ~UIKeyboardHandlerSeamless();
 private:
     /* Event handlers: */
-    bool event(QEvent *pEvent);
     bool eventFilter(QObject *pWatched, QEvent *pEvent);
-    /* Prepare helpers: */
-    void prepareCommon();
-    void prepareFilters();
-    void prepareConnections();
-    void prepareConsoleConnections();
-    void prepareSeamless();
-    /* Cleanup helpers: */
-    void cleanupSeamless();
-    //void cleanupConsoleConnections() {}
-    //void prepareConnections() {}
-    //void cleanupFilters() {}
-    //void cleanupCommon() {}
-    /* Private helpers: */
-    void normalizeGeometry(bool /* fAdjustPosition */) {}
-    QRect workingArea();
-    void calculateDesktopGeometry();
-    void maybeRestrictMinimumSize() {}
-    /* Private variables: */
-    bool m_fShouldWeDoResize : 1;
-    QRegion m_lastVisibleRegion;
-    UIMachineViewBlocker *m_pSyncBlocker;
     /* Friend classes: */
     friend class UIMachineView;
+    friend class UIKeyboardHandler;
 };
 #endif // !___UIMachineViewSeamless_h___
+#endif // !___UIKeyboardHandlerSeamless_h___

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

-              r30544
+              r30637
     cleanupSeamless();
-    /* Cleanup common things: */
-    cleanupCommon();
     /* Cleanup frame buffer: */
     cleanupFrameBuffer();
 …
             return true;
+        }
-        case QEvent::KeyPress:
-        case QEvent::KeyRelease:
+        {
-            /* Get key-event: */
-            QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
-            /* Process Host+Home for menu popup: */
-            if (isHostKeyPressed() && pEvent->type() == QEvent::KeyPress)
+            {
-                if (pKeyEvent->key() == Qt::Key_Home)
-                    QTimer::singleShot(0, machineWindowWrapper()->machineWindow(), SLOT(sltPopupMainMenu()));
-                else
-                    pEvent->ignore();
+            }
-            break;
+        }

Changeset 30637 in vbox

Legend:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Download in other formats: