Changeset 35730 in vbox for trunk

Timestamp:

Jan 27, 2011 10:49:44 AM (14 years ago)

Author:

vboxsync

Message:

FE/Qt: 5245: GUI support for complex host-key combinations. Initial build for Win/X11.

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• Makefile.kmk (modified) (4 diffs)
• src/VBoxGlobalSettings.cpp (modified) (7 diffs)
• src/VBoxGlobalSettings.h (modified) (4 diffs)
• src/globals/VBoxGlobal.cpp (modified) (3 diffs)
• src/globals/VBoxProblemReporter.cpp (modified) (6 diffs)
• src/runtime/UIKeyboardHandler.cpp (modified) (20 diffs)
• src/runtime/UIKeyboardHandler.h (modified) (3 diffs)
• src/runtime/normal/UIMachineWindowNormal.cpp (modified) (4 diffs)
• src/settings/global/UIGlobalSettingsInput.cpp (modified) (5 diffs)
• src/settings/global/UIGlobalSettingsInput.h (modified) (1 diff)
• src/settings/global/UIGlobalSettingsInput.ui (modified) (4 diffs)
• src/widgets/UIHotKeyEditor.cpp (moved) (moved from trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIHotKeyEdit.cpp ) (14 diffs)
• src/widgets/UIHotKeyEditor.h (moved) (moved from trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIHotKeyEdit.h ) (4 diffs)

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

@@ -276 +276 @@
         src/extensions/QIDialog.h \
         src/extensions/QIFileDialog.h \
-        src/extensions/QIHotKeyEdit.h \
         src/extensions/QIHttp.h \
         src/extensions/QILabel.h \
@@ -328 +327 @@
         src/widgets/UIDownloaderAdditions.h \
         src/widgets/UIDownloaderUserManual.h \
+        src/widgets/UIHotKeyEditor.h \
         src/widgets/UIPopupBox.h \
         src/widgets/UIProgressDialog.h \
@@ -443 +443 @@
         src/extensions/QIDialogButtonBox.cpp \
         src/extensions/QIFileDialog.cpp \
-        src/extensions/QIHotKeyEdit.cpp \
         src/extensions/QILabel.cpp \
         src/extensions/QILabelSeparator.cpp \
@@ -493 +492 @@
         src/widgets/UIDownloaderAdditions.cpp \
         src/widgets/UIDownloaderUserManual.cpp \
+        src/widgets/UIHotKeyEditor.cpp \
         src/widgets/UIPopupBox.cpp \
         src/widgets/UIProgressDialog.cpp \

trunk/src/VBox/Frontends/VirtualBox/src/VBoxGlobalSettings.cpp

@@ -7 +7 @@
 
 /*
- * Copyright (C) 2006-2007 Oracle Corporation
+ * Copyright (C) 2006-2011 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -27 +27 @@
 
 #include "VBoxGlobalSettings.h"
-#include "QIHotKeyEdit.h"
+#include "UIHotKeyEditor.h"
 #include "COMDefs.h"
 #endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
@@ -40 +40 @@
 {
     /* default settings */
-#if defined (Q_WS_WIN32)
-    hostkey = 0xA3; // VK_RCONTROL
-//    hostkey = 165; // VK_RMENU
-#elif defined (Q_WS_PM)
-    hostkey = VK_CTRL;
+#if defined (Q_WS_WIN)
+    hostCombo = "163"; // VK_RCONTROL
 #elif defined (Q_WS_X11)
-    hostkey = 0xffe4; // XK_Control_R
-//    hostkey = 65514; // XK_Alt_R
+    hostCombo = "65508"; // XK_Control_R
 #elif defined (Q_WS_MAC)
-//    hostkey = 0x36; // QZ_RMETA
-    hostkey = 0x37; // QZ_LMETA
-//    hostkey = 0x3e; // QZ_RCTRL
-//    hostkey = 0x3d; // QZ_RALT
+    hostCombo = "55"; // QZ_LMETA
 #else
 # warning "port me!"
-    hostkey = 0;
 #endif
     autoCapture = true;
@@ -69 +61 @@
 VBoxGlobalSettingsData::VBoxGlobalSettingsData (const VBoxGlobalSettingsData &that)
 {
-    hostkey = that.hostkey;
+    hostCombo = that.hostCombo;
     autoCapture = that.autoCapture;
     guiFeatures = that.guiFeatures;
@@ -87 +79 @@
 {
     return this == &that ||
-        (hostkey == that.hostkey &&
+        (hostCombo == that.hostCombo &&
          autoCapture == that.autoCapture &&
          guiFeatures == that.guiFeatures &&
@@ -117 +109 @@
 gPropertyMap[] =
 {
-    { "GUI/Input/HostKey",                         "hostKey",                 "0|\\d*[1-9]\\d*", true },
+    { "GUI/Input/HostCombo",                       "hostCombo",               "0|\\d*[1-9]\\d*(,\\d*[1-9]\\d*)?(,\\d*[1-9]\\d*)?", true },
     { "GUI/Input/AutoCapture",                     "autoCapture",             "true|false", true },
     { "GUI/Customizations",                        "guiFeatures",             "\\S+", true },
@@ -127 +119 @@
     { VBoxDefs::GUI_PresentationModeEnabled,       "presentationModeEnabled", "true|false", true },
 #endif /* Q_WS_MAC */
-    { "GUI/HostScreenSaverDisabled",               "hostScreenSaverDisabled",     "true|false", true }
+    { "GUI/HostScreenSaverDisabled",               "hostScreenSaverDisabled", "true|false", true }
 };
 
-void VBoxGlobalSettings::setHostKey (int key)
-{
-    if (!QIHotKeyEdit::isValidKey (key))
-    {
-        last_err = tr ("'%1 (0x%2)' is an invalid host key code.")
-                       .arg (key).arg (key, 0, 16);
+void VBoxGlobalSettings::setHostCombo (const QString &hostCombo)
+{
+    if (!UIHotKeyCombination::isValidKeyCombo (hostCombo))
+    {
+        last_err = tr ("'%1' is an invalid host-combination code-sequence.").arg (hostCombo);
         return;
     }
-
-    mData()->hostkey = key;
+    mData()->hostCombo = hostCombo;
     resetError();
 }

trunk/src/VBox/Frontends/VirtualBox/src/VBoxGlobalSettings.h

@@ -6 +6 @@
 
 /*
- * Copyright (C) 2006-2007 Oracle Corporation
+ * Copyright (C) 2006-2011 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -38 +38 @@
 private:
 
-    int hostkey;
+    QString hostCombo;
     bool autoCapture;
     QString guiFeatures;
@@ -56 +56 @@
 {
     Q_OBJECT
-    Q_PROPERTY (int hostKey READ hostKey WRITE setHostKey)
+    Q_PROPERTY (QString hostCombo READ hostCombo WRITE setHostCombo)
     Q_PROPERTY (bool autoCapture READ autoCapture WRITE setAutoCapture)
     Q_PROPERTY (QString guiFeatures READ guiFeatures WRITE setGuiFeatures)
@@ -79 +79 @@
     // Properties
 
-    int hostKey() const { return data()->hostkey; }
-    void setHostKey (int key);
+    QString hostCombo() const { return data()->hostCombo; }
+    void setHostCombo (const QString &hostCombo);
 
     bool autoCapture() const { return data()->autoCapture; }

trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxGlobal.cpp

@@ -25 +25 @@
 #include "VBoxSelectorWnd.h"
 #include "VBoxProblemReporter.h"
-#include "QIHotKeyEdit.h"
 #include "QIMessageBox.h"
 #include "QIDialogButtonBox.h"
@@ -73 +72 @@
 
 #ifdef Q_WS_X11
+# include "UIHotKeyEditor.h"
 # ifndef VBOX_OSE
 #  include "VBoxLicenseViewer.h"
@@ -3016 +3016 @@
         it->refresh();
 
-#if defined (Q_WS_PM) || defined (Q_WS_X11)
-    /* As PM and X11 do not (to my knowledge) have functionality for providing
-     * human readable key names, we keep a table of them, which must be
-     * updated when the language is changed. */
-    QIHotKeyEdit::retranslateUi();
-#endif
+#ifdef Q_WS_X11
+    /* As X11 do not have functionality for providing human readable key names,
+     * we keep a table of them, which must be updated when the language is changed. */
+    UIHotKey::retranslateKeyNames();
+#endif /* Q_WS_X11 */
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxProblemReporter.cpp

@@ -39 +39 @@
 #include "UIMachine.h"
 #include "VBoxAboutDlg.h"
-#include "QIHotKeyEdit.h"
+#include "UIHotKeyEditor.h"
 #ifdef Q_WS_MAC
 # include "VBoxUtils-darwin.h"
@@ -1677 +1677 @@
         tr ("<p>The host key is currently defined as <b>%1</b>.</p>",
             "additional message box paragraph")
-            .arg (QIHotKeyEdit::keyName (vboxGlobal().settings().hostKey())),
+            .arg (UIHotKeyCombination::toReadableString (vboxGlobal().settings().hostCombo())),
         "confirmInputCapture",
         QIMessageBox::Ok | QIMessageBox::Default,
@@ -1710 +1710 @@
         tr ("<p>The host key is currently defined as <b>%1</b>.</p>",
             "additional message box paragraph")
-            .arg (QIHotKeyEdit::keyName (vboxGlobal().settings().hostKey())),
+            .arg (UIHotKeyCombination::toReadableString (vboxGlobal().settings().hostCombo())),
         "remindAboutAutoCapture");
 }
@@ -1878 +1878 @@
             "You can access it by pressing <b>Host+Home</b>.</p>")
             .arg (aHotKey)
-            .arg (QIHotKeyEdit::keyName (vboxGlobal().settings().hostKey())),
+            .arg (UIHotKeyCombination::toReadableString (vboxGlobal().settings().hostCombo())),
         "confirmGoingFullscreen",
         tr ("Switch", "fullscreen"));
@@ -1898 +1898 @@
             "You can access it by pressing <b>Host+Home</b>.</p>")
             .arg (aHotKey)
-            .arg (QIHotKeyEdit::keyName (vboxGlobal().settings().hostKey())),
+            .arg (UIHotKeyCombination::toReadableString (vboxGlobal().settings().hostCombo())),
         "confirmGoingSeamless",
         tr ("Switch", "seamless"));
@@ -1918 +1918 @@
             "You can access it by pressing <b>Host+Home</b>.</p>")
             .arg (aHotKey)
-            .arg (QIHotKeyEdit::keyName (vboxGlobal().settings().hostKey())),
+            .arg (UIHotKeyCombination::toReadableString (vboxGlobal().settings().hostCombo())),
         "confirmGoingScale",
         tr ("Switch", "scale"));

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

@@ -34 +34 @@
 #include "UIMachineWindow.h"
 #include "UIMachineView.h"
+#include "UIHotKeyEditor.h"
 
 #ifdef Q_WS_X11
@@ -64 +65 @@
 
 #ifdef Q_WS_WIN
-UIKeyboardHandler* UIKeyboardHandler::m_pKeyboardHandler = 0;
+UIKeyboardHandler* UIKeyboardHandler::m_spKeyboardHandler = 0;
 #endif /* Q_WS_WIN */
 
@@ -94 +95 @@
     /* Its required to have static pointer to created handler
      * because windows keyboard-hook works only with static members: */
-    m_pKeyboardHandler = pKeyboardHandler;
+    m_spKeyboardHandler = pKeyboardHandler;
 #endif /* Q_WS_WIN */
     /* Return prepared keyboard-handler: */
@@ -105 +106 @@
     /* Delete keyboard-handler: */
 #ifdef Q_WS_WIN
-    m_pKeyboardHandler = 0;
+    m_spKeyboardHandler = 0;
 #endif /* Q_WS_WIN */
     delete pKeyboardHandler;
@@ -307 +308 @@
 
     if (aReleaseHostKey)
-        m_bIsHostkeyPressed = false;
+        m_bIsHostComboPressed = false;
 
 #ifdef Q_WS_MAC
-    /* Clear most of the modifiers: */
-    m_darwinKeyModifiers &=
-        alphaLock | kEventKeyModifierNumLockMask |
-        (aReleaseHostKey ? 0 : ::DarwinKeyCodeToDarwinModifierMask(m_globalSettings.hostKey()));
+    // TODO: To NaN: Please fix:
+//    /* Clear most of the modifiers: */
+//    m_darwinKeyModifiers &=
+//        alphaLock | kEventKeyModifierNumLockMask |
+//        (aReleaseHostKey ? 0 : ::DarwinKeyCodeToDarwinModifierMask(m_globalSettings.hostKey()));
 #endif
 
@@ -323 +325 @@
 {
     return (m_fIsKeyboardCaptured ? UIViewStateType_KeyboardCaptured : 0) |
-           (m_bIsHostkeyPressed ? UIViewStateType_HostKeyPressed : 0);
+           (m_bIsHostComboPressed ? UIViewStateType_HostKeyPressed : 0);
 }
 
@@ -368 +370 @@
              * on the host, the scancode in lParam might be 0x71/0x72 or 0xF1/0xF2.
              * In either case, we must deliver 0xF1/0xF2 scancode to the guest when
-             * the key is pressed and nothing when it's released.
-             */
+             * the key is pressed and nothing when it's released. */
             if (scan == 0x71 || scan == 0x72)
             {
@@ -393 +394 @@
                 case VK_MENU:
                 {
-                    /* Overcome stupid Win32 modifier key generalization: */
+                    /* Overcome Win32 modifier key generalization: */
                     int keyscan = scan;
                     if (flags & KeyExtended)
@@ -631 +632 @@
     , m_globalSettings(vboxGlobal().settings())
     , m_fIsKeyboardCaptured(false)
-    , m_bIsHostkeyPressed(false)
-    , m_bIsHostkeyAlone (false)
-    , m_bIsHostkeyInCapture(false)
+    , m_bIsHostComboPressed(false)
+    , m_bIsHostComboAlone (false)
     , m_fPassCAD(false)
 #if defined(Q_WS_WIN)
+    , m_bIsHostkeyInCapture(false)
     , m_iKeyboardHookViewIndex(-1)
 #elif defined(Q_WS_MAC)
@@ -846 +847 @@
                 QKeyEvent *pKeyEvent = static_cast<QKeyEvent*>(pEvent);
 
-                if (m_bIsHostkeyPressed && pEvent->type() == QEvent::KeyPress)
+                if (m_bIsHostComboPressed && pEvent->type() == QEvent::KeyPress)
                 {
                     /* Passing F1-F12 keys to the guest: */
@@ -873 +874 @@
                     machineLogic()->actionsPool()->processHotKey(QKeySequence(pKeyEvent->key()));
                 }
-                else if (!m_bIsHostkeyPressed && pEvent->type() == QEvent::KeyRelease)
+                else if (!m_bIsHostComboPressed && pEvent->type() == QEvent::KeyRelease)
                 {
                     /* Show a possible warning on key release which seems to be more expected by the end user: */
@@ -899 +900 @@
 LRESULT CALLBACK UIKeyboardHandler::lowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
 {
-    if (nCode == HC_ACTION && m_pKeyboardHandler && m_pKeyboardHandler->winLowKeyboardEvent(wParam, *(KBDLLHOOKSTRUCT*)lParam))
+    if (nCode == HC_ACTION && m_spKeyboardHandler && m_spKeyboardHandler->winLowKeyboardEvent(wParam, *(KBDLLHOOKSTRUCT*)lParam))
         return 1;
 
@@ -909 +910 @@
     /* Check what related machine-view was NOT unregistered yet: */
     if (!m_views.contains(m_iKeyboardHookViewIndex))
+        return false;
+
+    if (!m_fIsKeyboardCaptured)
         return false;
 
@@ -929 +933 @@
     }
 
-    if (!m_fIsKeyboardCaptured)
-        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
@@ -938 +939 @@
     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) ||
+        ((UIHotKeyCombination::toKeyCodeList(m_globalSettings.hostCombo()).contains(event.vkCode) && !m_bIsHostkeyInCapture) ||
          (m_pressedKeys[event.scanCode] & (IsKbdCaptured | what_pressed)) == what_pressed))
         return false;
@@ -1102 +1103 @@
 #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 */
+bool UIKeyboardHandler::keyEvent(int iKey, uint8_t uScan, int fFlags, ulong uScreenId, wchar_t *pUniKey /* = 0 */)
+{
+    /* Get host-combo key list: */
+    QSet<int> allHostComboKeys = UIHotKeyCombination::toKeyCodeList(m_globalSettings.hostCombo()).toSet();
+
+    /* Update the map of pressed host-combo keys: */
+    if (fFlags & KeyPressed)
+    {
+        if (allHostComboKeys.contains(iKey))
+        {
+            if (!m_pressedHostComboKeys.contains(iKey))
+                m_pressedHostComboKeys.insert(iKey, uScan);
+            else if (m_bIsHostComboPressed)
                 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 preferable 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
+    {
+        if (allHostComboKeys.contains(iKey) && m_pressedHostComboKeys.contains(iKey))
+            m_pressedHostComboKeys.remove(iKey);
+    }
+    /* Check if we are currently holding FULL host-combo: */
+    bool fIsFullHostComboPresent = allHostComboKeys == m_pressedHostComboKeys.keys().toSet();
+    /* Check if currently pressed/released key had changed host-combo state: */
+    const bool isHostComboStateChanged = (!m_bIsHostComboPressed && fIsFullHostComboPresent) ||
+                                         (m_bIsHostComboPressed && !fIsFullHostComboPresent);
+
+#ifdef Q_WS_WIN
+    if (m_bIsHostComboPressed || isHostComboStateChanged)
     {
         /* Currently this is used in winLowKeyboardEvent() only: */
         m_bIsHostkeyInCapture = m_fIsKeyboardCaptured;
     }
-
-    bool emitSignal = false;
-    int hotkey = 0;
-
-    /* Process the host key: */
+#endif /* Q_WS_WIN */
+
+    /* 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: */
+        if (uisession()->isRunning() && m_fIsKeyboardCaptured)
+        {
+            releaseKeyboard();
+            if (!uisession()->isMouseSupportsAbsolute() || !uisession()->isMouseIntegrated())
+                machineLogic()->mouseHandler()->releaseMouse();
+        }
+        return true;
+    }
+
+    /* Prepare empty code-buffer: */
+    LONG aCodesBuffer[16];
+    LONG *pCodes = aCodesBuffer;
+    uint uCodesCount = 0;
+    /* Processing usual key-presses/releases without host-key being held: */
+    if (!m_bIsHostComboPressed || isHostComboStateChanged)
+    {
+        /* Special flags handling (KeyPrint): */
+        if (fFlags & KeyPrint)
+        {
+            if (fFlags & KeyPressed)
+            {
+                static LONG PrintMake[] = { 0xE0, 0x2A, 0xE0, 0x37 };
+                pCodes = PrintMake;
+                uCodesCount = SIZEOF_ARRAY(PrintMake);
+            }
+            else
+            {
+                static LONG PrintBreak[] = { 0xE0, 0xB7, 0xE0, 0xAA };
+                pCodes = PrintBreak;
+                uCodesCount = SIZEOF_ARRAY(PrintBreak);
+            }
+        }
+        /* Special flags handling (KeyPause): */
+        else if (fFlags & KeyPause)
+        {
+            if (fFlags & KeyPressed)
+            {
+                static LONG Pause[] = { 0xE1, 0x1D, 0x45, 0xE1, 0x9D, 0xC5 };
+                pCodes = Pause;
+                uCodesCount = SIZEOF_ARRAY(Pause);
+            }
+            else
+            {
+                /* Pause shall not produce a break code: */
+                return true;
+            }
+        }
+        /* Common flags handling: */
+        else
+        {
+            /* Get the type of key - simple or extended: */
+            uint8_t uWhatPressed = fFlags & KeyExtended ? IsExtKeyPressed : IsKeyPressed;
+
+            /* If some key was pressed or some previously pressed key was released =>
+             * we are updating the list of pressed keys and preparing scancodes: */
+            if ((fFlags & KeyPressed) || (m_pressedKeys[uScan] & uWhatPressed))
+            {
+                /* 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: */
+                if (fFlags & KeyPressed)
+                    fixModifierState(pCodes, &uCodesCount);
+
+                /* Prepend 'extended' scancode if needed: */
+                if (fFlags & KeyExtended)
+                    pCodes[uCodesCount++] = 0xE0;
+
+                /* Process key-press: */
+                if (fFlags & KeyPressed)
+                {
+                    /* Append scancode: */
+                    pCodes[uCodesCount++] = uScan;
+                    m_pressedKeys[uScan] |= uWhatPressed;
+                }
+                /* Process key-release if that key was pressed before: */
+                else if (m_pressedKeys[uScan] & uWhatPressed)
+                {
+                    /* Append scancode: */
+                    pCodes[uCodesCount++] = uScan | 0x80;
+                    m_pressedKeys[uScan] &= ~uWhatPressed;
+                }
+
+                /* Update keyboard-captured flag: */
+                if (m_fIsKeyboardCaptured)
+                    m_pressedKeys[uScan] |= IsKbdCaptured;
+                else
+                    m_pressedKeys[uScan] &= ~IsKbdCaptured;
+            }
+            /* Ignore key-release if that key was NOT pressed before,
+             * but only if thats not one of the host-combination keys: */
+            else if (!allHostComboKeys.contains(iKey))
+                return true;
+        }
+    }
+
+    /* Process the host-combo funtionality: */
     if (fFlags & KeyPressed)
     {
-        if (isHostKey)
-        {
-            if (!m_bIsHostkeyPressed)
-            {
-                m_bIsHostkeyPressed = m_bIsHostkeyAlone = true;
+        if (isHostComboStateChanged)
+        {
+            if (!m_bIsHostComboPressed)
+            {
+                m_bIsHostComboPressed = true;
+                m_bIsHostComboAlone = true;
                 if (uisession()->isRunning())
                     saveKeyStates();
-                emitSignal = true;
             }
         }
         else
         {
-            if (m_bIsHostkeyPressed)
-            {
-                if (m_bIsHostkeyAlone)
-                {
-                    hotkey = iKey;
-                    m_bIsHostkeyAlone = false;
+            if (m_bIsHostComboPressed)
+            {
+                if (m_bIsHostComboAlone)
+                {
+                    m_bIsHostComboAlone = false;
+                    m_pressedHostComboKeys.clear();
+                    /* Process Host+<key> shortcuts.
+                     * Currently, <key> is limited to alphanumeric chars.
+                     * Other Host+<key> combinations are handled in Qt event(): */
+                    return processHotKey(iKey, pUniKey);
                 }
             }
@@ -1241 +1275 @@
     else
     {
-        if (isHostKey)
-        {
-            if (m_bIsHostkeyPressed)
-            {
-                m_bIsHostkeyPressed = false;
-
-                if (m_bIsHostkeyAlone)
-                {
-                    if (uisession()->isPaused())
-                    {
-                        vboxProblem().remindAboutPausedVMInput();
-                    }
-                    else if (uisession()->isRunning())
+        if (isHostComboStateChanged)
+        {
+            if (m_bIsHostComboPressed)
+            {
+                m_bIsHostComboPressed = false;
+                if (m_bIsHostComboAlone)
+                {
+                    /* Capturing/releasing keyboard/mouse: */
+                    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 */
+                            /* 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)
+                            bool fIsAutoConfirmed = false;
+                            ok = vboxProblem().confirmInputCapture(&fIsAutoConfirmed);
+                            if (fIsAutoConfirmed)
                                 uisession()->setAutoCaptureDisabled(false);
-                            /* Otherwise, the disable flag will be reset in
-                             * the next console view's focus in event (since
-                             * may happen asynchronously on some platforms,
-                             * after we return from this code) */
+                            else
+                                m_pressedHostComboKeys.clear();
+                            /* Otherwise, the disable flag will be reset in the next
+                             * machine-view's focus-in event (since may happen asynchronously
+                             * on some platforms, after we return from this code): */
                         }
-
                         if (ok)
                         {
@@ -1284 +1313 @@
                                 /* Make sure that pending FocusOut events from the
                                  * previous message box are handled, otherwise the
-                                 * mouse is immediately ungrabbed. */
+                                 * mouse is immediately ungrabbed: */
                                 qApp->processEvents();
-#endif
+#endif /* Q_WS_X11 */
                                 if (m_fIsKeyboardCaptured)
                                     machineLogic()->mouseHandler()->captureMouse(uScreenId);
@@ -1295 +1324 @@
                     }
                 }
-
                 if (uisession()->isRunning())
                     sendChangedKeyStates();
-
-                emitSignal = true;
             }
         }
         else
         {
-            if (m_bIsHostkeyPressed)
-                m_bIsHostkeyAlone = false;
+            if (m_bIsHostComboPressed)
+                m_bIsHostComboAlone = false;
         }
     }
@@ -1312 +1338 @@
     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];
-                processed = machineLogic()->actionsPool()->processHotKey(QKeySequence((Qt::UNICODE_ACCEL + QChar(c).toUpper().unicode())));
-            }
-        }
-#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());
+    /* If the VM is NOT paused and there are scancodes to send: */
+    if (!uisession()->isPaused() && uCodesCount)
+    {
+        /* Get the  VM keyboard to pass key in there: */
+        CKeyboard keyboard = session().GetConsole().GetKeyboard();
+        Assert(!keyboard.isNull());
+
+        /* Pass this key to the guest: */
+        std::vector<LONG> scancodes(pCodes, &pCodes[uCodesCount]);
+        keyboard.PutScancodes(QVector<LONG>::fromStdVector(scancodes));
+
+        /* If full host-key sequence was just finalized
+         * and the last key of host-combination was just sent to the guest =>
+         * we have to notify guest to make it release keys from the host-combination: */
+        if (isHostComboStateChanged && m_bIsHostComboPressed)
+        {
+            QList<uint8_t> hostComboScans = m_pressedHostComboKeys.values();
+            for (int i = 0 ; i < hostComboScans.size(); ++i)
+            {
+                uint8_t uScan = hostComboScans[i];
+                if (m_pressedKeys[uScan] & IsKeyPressed)
+                {
+                    keyboard.PutScancode(uScan | 0x80);
+                }
+                else if (m_pressedKeys[uScan] & IsExtKeyPressed)
+                {
+                    QVector<LONG> scancodes(2);
+                    scancodes[0] = 0xE0;
+                    scancodes[1] = uScan | 0x80;
+                    keyboard.PutScancodes(scancodes);
+                }
+                m_pressedKeys[uScan] = 0;
+            }
+        }
+    }
+
+    /* Prevent the key from going to Qt: */
+    return true;
+}
+
+bool UIKeyboardHandler::processHotKey(int iHotKey, wchar_t *pHotKey)
+{
+    /* Prepare processing result: */
+    bool fWasProcessed = false;
 
 #ifdef Q_WS_WIN
-    /* Send pending WM_PAINT events: */
-    ::UpdateWindow(m_views[uScreenId]->viewport()->winId());
+    Q_UNUSED(pHotKey);
+    int iKeyboardLayout = GetKeyboardLayoutList(0, NULL);
+    Assert(iKeyboardLayout);
+    HKL *pList = new HKL[iKeyboardLayout];
+    GetKeyboardLayoutList(iKeyboardLayout, pList);
+    for (int i = 0; i < iKeyboardLayout && !fWasProcessed; ++i)
+    {
+        wchar_t symbol;
+        static BYTE keys[256] = {0};
+        if (!ToUnicodeEx(iHotKey, 0, keys, &symbol, 1, 0, pList[i]) == 1)
+            symbol = 0;
+        if (symbol)
+            fWasProcessed = machineLogic()->actionsPool()->processHotKey(QKeySequence((Qt::UNICODE_ACCEL + QChar(symbol).toUpper().unicode())));
+    }
+    delete[] pList;
 #endif /* Q_WS_WIN */
 
-    std::vector <LONG> scancodes(codes, &codes[count]);
-    keyboard.PutScancodes(QVector<LONG>::fromStdVector(scancodes));
-
-    /* Grab the key from Qt: */
-    return true;
+#ifdef Q_WS_X11
+    Q_UNUSED(pHotKey);
+    Display *pDisplay = QX11Info::display();
+    int iKeysymsPerKeycode = getKeysymsPerKeycode();
+    KeyCode keyCode = XKeysymToKeycode(pDisplay, iHotKey);
+    for (int i = 0; i < iKeysymsPerKeycode && !fWasProcessed; i += 2)
+    {
+        KeySym ks = XKeycodeToKeysym(pDisplay, keyCode, i);
+        char symbol = 0;
+        if (!XkbTranslateKeySym(pDisplay, &ks, 0, &symbol, 1, NULL) == 1)
+            symbol = 0;
+        if (symbol)
+        {
+            QChar qtSymbol = QString::fromLocal8Bit(&symbol, 1)[0];
+            fWasProcessed = machineLogic()->actionsPool()->processHotKey(QKeySequence((Qt::UNICODE_ACCEL + qtSymbol.toUpper().unicode())));
+        }
+    }
+#endif /* Q_WS_X11 */
+
+#ifdef Q_WS_MAC
+    Q_UNUSED(iHotKey);
+    if (pHotKey && pHotKey[0] && !pHotKey[1])
+        fWasProcessed = machineLogic()->actionsPool()->processHotKey(QKeySequence(Qt::UNICODE_ACCEL + QChar(pHotKey[0]).toUpper().unicode()));
+#endif /* Q_WS_MAC */
+
+    /* Grab the key from the Qt if it was processed, or pass it to the Qt otherwise
+     * in order to process non-alphanumeric keys in event(), after they are converted to Qt virtual keys: */
+    return fWasProcessed;
 }
 

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

@@ -71 +71 @@
 
     /* Some getters required by side-code: */
-    bool isHostKeyPressed() const { return m_bIsHostkeyPressed; }
+    bool isHostKeyPressed() const { return m_bIsHostComboPressed; }
 #ifdef Q_WS_MAC
-    bool isHostKeyAlone() const { return m_bIsHostkeyAlone; }
+    bool isHostKeyAlone() const { return m_bIsHostComboAlone; }
     bool isKeyboardGrabbed() const { return m_fKeyboardGrabbed; }
 #endif /* Q_WS_MAC */
@@ -126 +126 @@
     /* Separate function to handle most of existing keyboard-events: */
     bool keyEvent(int iKey, uint8_t uScan, int fFlags, ulong uScreenId, wchar_t *pUniKey = 0);
+    bool processHotKey(int iHotKey, wchar_t *pUniKey);
 
     /* Private helpers: */
@@ -150 +151 @@
     uint8_t m_pressedKeysCopy[128];
 
+    QMap<int, uint8_t> m_pressedHostComboKeys;
+
     bool m_fIsKeyboardCaptured : 1;
-    bool m_bIsHostkeyPressed : 1;
-    bool m_bIsHostkeyAlone : 1;
-    bool m_bIsHostkeyInCapture : 1;
+    bool m_bIsHostComboPressed : 1;
+    bool m_bIsHostComboAlone : 1;
     bool m_fPassCAD : 1;
 
 #if defined(Q_WS_WIN)
+    /* Currently this is used in winLowKeyboardEvent() only: */
+    bool m_bIsHostkeyInCapture;
     /* Keyboard hook required to capture keyboard event under windows. */
-    static UIKeyboardHandler *m_pKeyboardHandler;
+    static UIKeyboardHandler *m_spKeyboardHandler;
     HHOOK m_keyboardHook;
     int m_iKeyboardHookViewIndex;

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

@@ -45 +45 @@
 #include "QIStatusBar.h"
 #include "QIStateIndicator.h"
-#include "QIHotKeyEdit.h"
+#include "UIHotKeyEditor.h"
 
 UIMachineWindowNormal::UIMachineWindowNormal(UIMachineLogic *pMachineLogic, ulong uScreenId)
@@ -262 +262 @@
 void UIMachineWindowNormal::sltProcessGlobalSettingChange(const char * /* aPublicName */, const char * /* aName */)
 {
-    m_pNameHostkey->setText(QIHotKeyEdit::keyName(vboxGlobal().settings().hostKey()));
+    m_pNameHostkey->setText(UIHotKeyCombination::toReadableString(vboxGlobal().settings().hostCombo()));
 }
 
@@ -275 +275 @@
            "capture state. It can also be used in combination with other keys "
            "to quickly perform actions from the main menu."));
-    m_pNameHostkey->setText(QIHotKeyEdit::keyName(vboxGlobal().settings().hostKey()));
+    m_pNameHostkey->setText(UIHotKeyCombination::toReadableString(vboxGlobal().settings().hostCombo()));
 }
 
@@ -443 +443 @@
     pIndicatorBoxHLayout->addWidget(m_pCntHostkey);
     pHostkeyLedContainerLayout->addWidget(indicatorsPool()->indicator(UIIndicatorIndex_Hostkey));
-    m_pNameHostkey = new QLabel(QIHotKeyEdit::keyName(vboxGlobal().settings().hostKey()));
+    m_pNameHostkey = new QLabel(UIHotKeyCombination::toReadableString(vboxGlobal().settings().hostCombo()));
     pHostkeyLedContainerLayout->addWidget(m_pNameHostkey);
 

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsInput.cpp

@@ -40 +40 @@
 
     /* Load to cache: */
-    m_cache.m_iHostKey = m_settings.hostKey();
+    m_cache.m_strHostCombo = m_settings.hostCombo();
     m_cache.m_fAutoCapture = m_settings.autoCapture();
 
@@ -52 +52 @@
 {
     /* Fetch from cache: */
-    m_pHostKeyEditor->setKey(m_cache.m_iHostKey);
+    m_pHostKeyEditor->setCombo(m_cache.m_strHostCombo);
     m_pEnableAutoGrabCheckbox->setChecked(m_cache.m_fAutoCapture);
 }
@@ -61 +61 @@
 {
     /* Upload to cache: */
-    m_cache.m_iHostKey = m_pHostKeyEditor->key();
+    m_cache.m_strHostCombo = m_pHostKeyEditor->combo();
     m_cache.m_fAutoCapture = m_pEnableAutoGrabCheckbox->isChecked();
 }
@@ -73 +73 @@
 
     /* Save from cache: */
-    m_settings.setHostKey(m_cache.m_iHostKey);
+    m_settings.setHostCombo(m_cache.m_strHostCombo);
     m_settings.setAutoCapture(m_cache.m_fAutoCapture);
 
@@ -84 +84 @@
 {
     setTabOrder(pWidget, m_pHostKeyEditor);
-    setTabOrder(m_pHostKeyEditor, m_pResetHostKeyButton);
-    setTabOrder(m_pResetHostKeyButton, m_pEnableAutoGrabCheckbox);
+    setTabOrder(m_pHostKeyEditor, m_pEnableAutoGrabCheckbox);
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsInput.h

@@ -27 +27 @@
 struct UISettingsCacheGlobalInput
 {
-    int m_iHostKey;
+    QString m_strHostCombo;
     bool m_fAutoCapture;
 };

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsInput.ui

@@ -54 +54 @@
    </item>
    <item row="0" column="2">
-    <widget class="QIHotKeyEdit" name="m_pHostKeyEditor">
+    <widget class="UIHotKeyEditor" name="m_pHostKeyEditor">
      <property name="whatsThis">
       <string>Displays the key used as a Host Key in the VM window. Activate the entry field and press a new Host Key. Note that alphanumeric, cursor movement and editing keys cannot be used.</string>
@@ -66 +66 @@
     </widget>
    </item>
-   <item row="0" column="3">
-    <widget class="UIResetButton" name="m_pResetHostKeyButton">
-     <property name="focusPolicy">
-      <enum>Qt::StrongFocus</enum>
-     </property>
-     <property name="toolTip">
-      <string>Reset Host Key</string>
-     </property>
-     <property name="whatsThis">
-      <string>Resets the key used as a Host Key in the VM window.</string>
-     </property>
-     <property name="icon">
-      <iconset><normaloff>:/delete_16px.png</normaloff>:/delete_16px.png</iconset>
-     </property>
-    </widget>
-   </item>
-   <item row="0" column="4">
-    <spacer>
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <property name="sizeType">
-      <enum>QSizePolicy::Fixed</enum>
-     </property>
-     <property name="sizeHint" stdset="0">
-      <size>
-       <width>40</width>
-       <height>20</height>
-      </size>
-     </property>
-    </spacer>
-   </item>
-   <item row="1" column="2" colspan="3">
+   <item row="1" column="2">
     <widget class="QCheckBox" name="m_pEnableAutoGrabCheckbox">
      <property name="whatsThis">
@@ -108 +76 @@
     </widget>
    </item>
-   <item row="2" column="0" colspan="5">
+   <item row="2" column="0" colspan="3">
     <spacer>
      <property name="orientation">
@@ -125 +93 @@
  <customwidgets>
   <customwidget>
-   <class>QIHotKeyEdit</class>
+   <class>UIHotKeyEditor</class>
    <extends>QLabel</extends>
-   <header>QIHotKeyEdit.h</header>
+   <header>UIHotKeyEditor.h</header>
   </customwidget>
   <customwidget>

trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIHotKeyEditor.cpp

@@ -3 +3 @@
  *
  * VBox frontends: Qt GUI ("VirtualBox"):
- * VirtualBox Qt extensions: QIHotKeyEdit class implementation
+ * VirtualBox Qt extensions: UIHotKeyEditor class implementation
  */
 
@@ -19 +19 @@
 
 /* Local includes */
-#include "QIHotKeyEdit.h"
+#include "UIHotKeyEditor.h"
 #include "VBoxDefs.h"
 #include "VBoxGlobal.h"
@@ -27 +27 @@
 #include <QStyleOption>
 #include <QStylePainter>
+#include <QKeyEvent>
 
 #ifdef Q_WS_WIN
-/* VBox/cdefs.h defines these: */
 # undef LOWORD
 # undef HIWORD
@@ -38 +38 @@
 
 #ifdef Q_WS_X11
-/* We need to capture some X11 events directly which
- * requires the XEvent structure to be defined. However,
- * including the Xlib header file will cause some nasty
- * conflicts with Qt. Therefore we use the following hack
- * to redefine those conflicting identifiers. */
-# define XK_XKB_KEYS
-# define XK_MISCELLANY
-# include <X11/Xlib.h>
+# include <QX11Info>
 # include <X11/Xutil.h>
-# include <X11/keysymdef.h>
+# include "XKeyboard.h"
 # ifdef KeyPress
-const int XFocusOut = FocusOut;
-const int XFocusIn = FocusIn;
-const int XKeyPress = KeyPress;
-const int XKeyRelease = KeyRelease;
+   const int XKeyPress = KeyPress;
+   const int XKeyRelease = KeyRelease;
+#  undef KeyPress
 #  undef KeyRelease
-#  undef KeyPress
-#  undef FocusOut
-#  undef FocusIn
 # endif /* KeyPress */
-# include "XKeyboard.h"
-QMap<QString, QString> QIHotKeyEdit::s_keyNames;
-# include <QX11Info>
 #endif /* Q_WS_X11 */
 
@@ -68 +54 @@
 # include "VBoxUtils.h"
 # include <Carbon/Carbon.h>
-#endif
-
+#endif /* Q_WS_MAC */
+
+
+#ifdef Q_WS_X11
+namespace UIHotKey
+{
+    QMap<QString, QString> m_keyNames;
+}
+#endif /* Q_WS_X11 */
+
+QString UIHotKey::toString(int iKeyCode)
+{
+    QString strKeyName;
 
 #ifdef Q_WS_WIN
-/* Returns the correct modifier vkey for the *last* keyboard message,
- * distinguishing between left and right keys. If both are pressed
- * the left key wins. If the pressed key not a modifier, wParam is returned
- * unchanged. */
-int qi_distinguish_modifier_vkey(WPARAM wParam)
-{
-    int keyval = wParam;
-    switch (wParam)
-    {
-        case VK_SHIFT:
-            if (::GetKeyState(VK_LSHIFT) & 0x8000) keyval = VK_LSHIFT;
-            else if (::GetKeyState(VK_RSHIFT) & 0x8000) keyval = VK_RSHIFT;
-            break;
-        case VK_CONTROL:
-            if (::GetKeyState(VK_LCONTROL) & 0x8000) keyval = VK_LCONTROL;
-            else if (::GetKeyState(VK_RCONTROL) & 0x8000) keyval = VK_RCONTROL;
-            break;
-        case VK_MENU:
-            if (::GetKeyState(VK_LMENU) & 0x8000) keyval = VK_LMENU;
-            else if (::GetKeyState(VK_RMENU) & 0x8000) keyval = VK_RMENU;
-            break;
-    }
-    return keyval;
-}
+    /* MapVirtualKey doesn't distinguish between right and left vkeys,
+     * even under XP, despite that it stated in MSDN. Do it by hands.
+     * Besides that it can't recognize such virtual keys as
+     * VK_DIVIDE & VK_PAUSE, this is also known bug. */
+    int iScan;
+    switch (iKeyCode)
+    {
+        /* Processing special keys... */
+        case VK_PAUSE: iScan = 0x45 << 16; break;
+        case VK_RSHIFT: iScan = 0x36 << 16; break;
+        case VK_RCONTROL: iScan = (0x1D << 16) | (1 << 24); break;
+        case VK_RMENU: iScan = (0x38 << 16) | (1 << 24); break;
+        /* Processing extended keys... */
+        case VK_APPS:
+        case VK_LWIN:
+        case VK_RWIN:
+        case VK_NUMLOCK: iScan = (::MapVirtualKey(iKeyCode, 0) | 256) << 16; break;
+        default: iScan = ::MapVirtualKey(iKeyCode, 0) << 16;
+    }
+    TCHAR *pKeyName = new TCHAR[256];
+    if (::GetKeyNameText(iScan, pKeyName, 256))
+    {
+        strKeyName = QString::fromUtf16(pKeyName);
+    }
+    else
+    {
+        AssertMsgFailed(("That key have no name!\n"));
+        strKeyName = UIHotKeyEditor::tr("<key_%1>").arg(iKeyCode);
+    }
+    delete[] pKeyName;
 #endif /* Q_WS_WIN */
 
-
-const char *QIHotKeyEdit::m_spNoneSymbName = "None";
-
-QIHotKeyEdit::QIHotKeyEdit(QWidget *pParent)
-    : QLabel(pParent)
-{
 #ifdef Q_WS_X11
-    /* Initialize the X keyboard subsystem: */
-    initMappedX11Keyboard(QX11Info::display(), vboxGlobal().settings().publicProperty("GUI/RemapScancodes"));
+    if (char *pNativeKeyName = ::XKeysymToString((KeySym)iKeyCode))
+    {
+        strKeyName = m_keyNames[pNativeKeyName].isEmpty() ?
+                     QString(pNativeKeyName) : m_keyNames[pNativeKeyName];
+    }
+    else
+    {
+        AssertMsgFailed(("That key have no name!\n"));
+        strKeyName = UIHotKeyEditor::tr("<key_%1>").arg(iKeyCode);
+    }
 #endif /* Q_WS_X11 */
 
-    clear();
-
+#ifdef Q_WS_MAC
+    UInt32 modMask = DarwinKeyCodeToDarwinModifierMask(iKeyCode);
+    switch (modMask)
+    {
+        case shiftKey:
+        case optionKey:
+        case controlKey:
+        case cmdKey:
+            strKeyName = tr("Left ");
+            break;
+        case rightShiftKey:
+        case rightOptionKey:
+        case rightControlKey:
+        case kEventKeyModifierRightCmdKeyMask:
+            strKeyName = tr("Right ");
+            break;
+        default:
+            AssertMsgFailedReturn(("modMask=%#x\n", modMask), QString());
+    }
+    switch (modMask)
+    {
+        case shiftKey:
+        case rightShiftKey:
+            strKeyName += QChar(kShiftUnicode);
+            break;
+        case optionKey:
+        case rightOptionKey:
+            strKeyName += QChar(kOptionUnicode);
+            break;
+        case controlKey:
+        case rightControlKey:
+            strKeyName += QChar(kControlUnicode);
+            break;
+        case cmdKey:
+        case kEventKeyModifierRightCmdKeyMask:
+            strKeyName += QChar(kCommandUnicode);
+            break;
+    }
+#endif /* Q_WS_MAC */
+
+    return strKeyName;
+}
+
+bool UIHotKey::isValidKey(int iKeyCode)
+{
 #ifdef Q_WS_WIN
-    /* Qt documentation hasn't mentioned this is windows-only flag,
-     * but looks like that is so, anyway it is required for winEvent() handler only: */
-    setAttribute(Qt::WA_NativeWindow);
+    return ((iKeyCode >= VK_SHIFT && iKeyCode <= VK_CAPITAL) ||
+            (iKeyCode >= VK_LSHIFT && iKeyCode <= VK_RMENU) ||
+            (iKeyCode >= VK_F1 && iKeyCode <= VK_F24) ||
+            iKeyCode == VK_NUMLOCK || iKeyCode == VK_SCROLL ||
+            iKeyCode == VK_LWIN || iKeyCode == VK_RWIN ||
+            iKeyCode == VK_APPS ||
+            iKeyCode == VK_PRINT);
 #endif /* Q_WS_WIN */
-    setFrameStyle(QFrame::StyledPanel | Sunken);
-    setAlignment(Qt::AlignCenter);
-    setFocusPolicy(Qt::StrongFocus);
-    setAutoFillBackground(true);
-
-    QPalette p = palette();
-    p.setColor(QPalette::Active, QPalette::Foreground, p.color(QPalette::Active, QPalette::Text));
-    p.setColor(QPalette::Active, QPalette::Background, p.color(QPalette::Active, QPalette::Base));
-    setPalette(p);
+
+#ifdef Q_WS_X11
+    return (IsModifierKey(iKeyCode) /* allow modifiers */ ||
+            IsFunctionKey(iKeyCode) /* allow function keys */ ||
+            IsMiscFunctionKey(iKeyCode) /* allow miscellaneous function keys */ ||
+            iKeyCode == XK_Scroll_Lock /* allow 'Scroll Lock' missed in IsModifierKey() */) &&
+           (iKeyCode != NoSymbol /* ignore some special symbol */ &&
+            iKeyCode != XK_Insert /* ignore 'insert' included into IsMiscFunctionKey */);
+#endif /* Q_WS_X11 */
 
 #ifdef Q_WS_MAC
-    m_uDarwinKeyModifiers = GetCurrentEventKeyModifiers();
-    UICocoaApplication::instance()->registerForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */, QIHotKeyEdit::darwinEventHandlerProc, this);
-    ::DarwinGrabKeyboard(false /* just modifiers */);
-#endif /* Q_WS_MAC */
-}
-
-QIHotKeyEdit::~QIHotKeyEdit()
-{
-#ifdef Q_WS_MAC
-    ::DarwinReleaseKeyboard();
-    UICocoaApplication::instance()->unregisterForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */, QIHotKeyEdit::darwinEventHandlerProc, this);
-#endif
-}
-
-/**
- *  Set the hot key value. O means there is no hot key.
- *
- *  @note
- *      The key value is platform-dependent. On Win32 it is the
- *      virtual key, on Linux it is the first (0) keysym corresponding
- *      to the keycode.
- */
-void QIHotKeyEdit::setKey(int iKeyVal)
-{
-    m_iKeyVal = iKeyVal;
-    m_strSymbName = QIHotKeyEdit::keyName(iKeyVal);
-    updateText();
-}
-
-/**@@ QIHotKeyEdit::key() const
- *
- *  Returns the value of the last recorded hot key.
- *  O means there is no hot key.
- *
- *  @note
- *      The key value is platform-dependent. On Win32 it is the
- *      virtual key, on Linux it is the first (0) keysym corresponding
- *      to the keycode.
- */
-
-QSize QIHotKeyEdit::sizeHint() const
-{
-    ensurePolished();
-    QFontMetrics fm(font());
-    int h = qMax(fm.lineSpacing(), 14) + 2;
-    int w = fm.width('x') * 17;
-    int m = frameWidth() * 2;
-    QStyleOption option;
-    option.initFrom(this);
-    return (style()->sizeFromContents(QStyle::CT_LineEdit, &option,
-                                      QSize(w + m, h + m)
-                                      .expandedTo(QApplication::globalStrut()),
-                                      this));
-}
-
-QSize QIHotKeyEdit::minimumSizeHint() const
-{
-    ensurePolished();
-    QFontMetrics fm = fontMetrics();
-    int h = fm.height() + qMax(2, fm.leading());
-    int w = fm.maxWidth();
-    int m = frameWidth() * 2;
-    return QSize(w + m, h + m);
-}
-
-/**
- *  Returns the string representation of a given key.
- *
- *  @note
- *      The key value is platform-dependent. On Win32 it is the
- *      virtual key, on Linux it is the first (0) keysym corresponding
- *      to the keycode.
- */
-/* static */
-QString QIHotKeyEdit::keyName(int iKeyVal)
-{
-    QString strName;
-
-    if (!iKeyVal)
-    {
-        strName = tr(m_spNoneSymbName);
-    }
-    else
-    {
-#if defined (Q_WS_WIN)
-        /* Stupid MapVirtualKey doesn't distinguish between right and left
-         * vkeys, even under XP, despite that it stated in msdn. Do it by
-         * hands. Besides that it can't recognize such virtual keys as
-         * VK_DIVIDE & VK_PAUSE, this is also known bug. */
-        int scan;
-        switch (iKeyVal)
-        {
-            /* Processing special keys... */
-            case VK_PAUSE: scan = 0x45 << 16; break;
-            case VK_RSHIFT: scan = 0x36 << 16; break;
-            case VK_RCONTROL: scan = (0x1D << 16) | (1 << 24); break;
-            case VK_RMENU: scan = (0x38 << 16) | (1 << 24); break;
-            /* Processing extended keys... */
-            case VK_APPS:
-            case VK_LWIN:
-            case VK_RWIN:
-            case VK_NUMLOCK: scan = (::MapVirtualKey(iKeyVal, 0) | 256) << 16; break;
-            default: scan = ::MapVirtualKey(iKeyVal, 0) << 16;
-        }
-        TCHAR *str = new TCHAR[256];
-        if (::GetKeyNameText(scan, str, 256))
-        {
-            strName = QString::fromUtf16(str);
-        }
-        else
-        {
-            AssertFailed();
-            strName = QString(tr("<key_%1>")).arg(iKeyVal);
-        }
-        delete[] str;
-#elif defined (Q_WS_X11)
-        char *sn = ::XKeysymToString((KeySym)iKeyVal);
-        if (sn)
-        {
-            strName = s_keyNames[sn];
-            if (strName.isEmpty())
-                strName = sn;
-        }
-        else
-        {
-            AssertFailed();
-            strName = QString(tr("<key_%1>")).arg(iKeyVal);
-        }
-#elif defined(Q_WS_MAC)
-        UInt32 modMask = DarwinKeyCodeToDarwinModifierMask(iKeyVal);
-        switch (modMask)
-        {
-            case shiftKey:
-            case optionKey:
-            case controlKey:
-            case cmdKey:
-                strName = tr("Left ");
-                break;
-            case rightShiftKey:
-            case rightOptionKey:
-            case rightControlKey:
-            case kEventKeyModifierRightCmdKeyMask:
-                strName = tr("Right ");
-                break;
-            default:
-                AssertMsgFailedReturn(("modMask=%#x\n", modMask), QString());
-        }
-        switch (modMask)
-        {
-            case shiftKey:
-            case rightShiftKey:
-                strName += QChar(kShiftUnicode);
-                break;
-            case optionKey:
-            case rightOptionKey:
-                strName += QChar(kOptionUnicode);
-                break;
-            case controlKey:
-            case rightControlKey:
-                strName += QChar(kControlUnicode);
-                break;
-            case cmdKey:
-            case kEventKeyModifierRightCmdKeyMask:
-                strName += QChar(kCommandUnicode);
-                break;
-        }
-#else
-        AssertFailed();
-        strName = QString(tr("<key_%1>")).arg(iKeyVal);
-#endif
-    }
-
-    return strName;
-}
-
-/* static */
-bool QIHotKeyEdit::isValidKey(int iKeyVal)
-{
-    /* Empty value is correct: */
-    if (iKeyVal == 0)
-        return true;
-#if defined(Q_WS_WIN)
-    return ((iKeyVal >= VK_SHIFT && iKeyVal <= VK_CAPITAL) ||
-            iKeyVal == VK_PRINT ||
-            iKeyVal == VK_LWIN || iKeyVal == VK_RWIN ||
-            iKeyVal == VK_APPS ||
-            (iKeyVal >= VK_F1 && iKeyVal <= VK_F24) ||
-            iKeyVal == VK_NUMLOCK || iKeyVal == VK_SCROLL ||
-            (iKeyVal >= VK_LSHIFT && iKeyVal <= VK_RMENU));
-#elif defined(Q_WS_X11)
-    KeySym ks = (KeySym)iKeyVal;
-    return (ks != NoSymbol && ks != XK_Insert) &&
-           (ks == XK_Scroll_Lock || IsModifierKey(ks) || IsFunctionKey(ks) || IsMiscFunctionKey(ks));
-#elif defined(Q_WS_MAC)
-    UInt32 modMask = ::DarwinKeyCodeToDarwinModifierMask(iKeyVal);
+    UInt32 modMask = ::DarwinKeyCodeToDarwinModifierMask(iKeyCode);
     switch (modMask)
     {
@@ -336 +194 @@
             return false;
     }
-#else
-    Q_UNUSED(iKeyVal);
+#endif /* Q_WS_MAC */
+
+    return false;
+}
+
+#ifdef Q_WS_WIN
+int UIHotKey::distinguishModifierVKey(int wParam)
+{
+    int iKeyCode = wParam;
+    switch (iKeyCode)
+    {
+        case VK_SHIFT:
+            if (::GetKeyState(VK_LSHIFT) & 0x8000) iKeyCode = VK_LSHIFT;
+            else if (::GetKeyState(VK_RSHIFT) & 0x8000) iKeyCode = VK_RSHIFT;
+            break;
+        case VK_CONTROL:
+            if (::GetKeyState(VK_LCONTROL) & 0x8000) iKeyCode = VK_LCONTROL;
+            else if (::GetKeyState(VK_RCONTROL) & 0x8000) iKeyCode = VK_RCONTROL;
+            break;
+        case VK_MENU:
+            if (::GetKeyState(VK_LMENU) & 0x8000) iKeyCode = VK_LMENU;
+            else if (::GetKeyState(VK_RMENU) & 0x8000) iKeyCode = VK_RMENU;
+            break;
+    }
+    return iKeyCode;
+}
+#endif /* Q_WS_WIN */
+
+#ifdef Q_WS_X11
+void UIHotKey::retranslateKeyNames()
+{
+    m_keyNames["Shift_L"]          = UIHotKeyEditor::tr("Left Shift");
+    m_keyNames["Shift_R"]          = UIHotKeyEditor::tr("Right Shift");
+    m_keyNames["Control_L"]        = UIHotKeyEditor::tr("Left Ctrl");
+    m_keyNames["Control_R"]        = UIHotKeyEditor::tr("Right Ctrl");
+    m_keyNames["Alt_L"]            = UIHotKeyEditor::tr("Left Alt");
+    m_keyNames["Alt_R"]            = UIHotKeyEditor::tr("Right Alt");
+    m_keyNames["Super_L"]          = UIHotKeyEditor::tr("Left WinKey");
+    m_keyNames["Super_R"]          = UIHotKeyEditor::tr("Right WinKey");
+    m_keyNames["Menu"]             = UIHotKeyEditor::tr("Menu key");
+    m_keyNames["ISO_Level3_Shift"] = UIHotKeyEditor::tr("Alt Gr");
+    m_keyNames["Caps_Lock"]        = UIHotKeyEditor::tr("Caps Lock");
+    m_keyNames["Scroll_Lock"]      = UIHotKeyEditor::tr("Scroll Lock");
+}
+#endif /* Q_WS_X11 */
+
+
+QString UIHotKeyCombination::toReadableString(const QString &strKeyCombo)
+{
+    QStringList encodedKeyList = strKeyCombo.split(',');
+    QStringList readableKeyList;
+    for (int i = 0; i < encodedKeyList.size(); ++i)
+        if (int iKeyCode = encodedKeyList[i].toInt())
+            readableKeyList << UIHotKey::toString(iKeyCode);
+    return readableKeyList.isEmpty() ? UIHotKeyEditor::tr("None") : readableKeyList.join(" + ");
+}
+
+QList<int> UIHotKeyCombination::toKeyCodeList(const QString &strKeyCombo)
+{
+    QStringList encodedKeyList = strKeyCombo.split(',');
+    QList<int> keyCodeList;
+    for (int i = 0; i < encodedKeyList.size(); ++i)
+        if (int iKeyCode = encodedKeyList[i].toInt())
+            keyCodeList << iKeyCode;
+    return keyCodeList;
+}
+
+bool UIHotKeyCombination::isValidKeyCombo(const QString &strKeyCombo)
+{
+    QList<int> keyCodeList = toKeyCodeList(strKeyCombo);
+    for (int i = 0; i < keyCodeList.size(); ++i)
+        if (!UIHotKey::isValidKey(keyCodeList[i]))
+            return false;
     return true;
-#endif
-}
+}
+
+
+UIHotKeyEditor::UIHotKeyEditor(QWidget *pParent)
+    : QLabel(pParent)
+    , m_fStartNewSequence(true)
+{
+    /* Configure widget: */
+    setAttribute(Qt::WA_NativeWindow);
+    setFrameStyle(QFrame::StyledPanel | Sunken);
+    setAlignment(Qt::AlignCenter);
+    setFocusPolicy(Qt::StrongFocus);
+    setAutoFillBackground(true);
+
+    /* Setup palette: */
+    QPalette p = palette();
+    p.setColor(QPalette::Active, QPalette::Foreground, p.color(QPalette::Active, QPalette::Text));
+    p.setColor(QPalette::Active, QPalette::Background, p.color(QPalette::Active, QPalette::Base));
+    setPalette(p);
 
 #ifdef Q_WS_X11
-/* Updates the associative array containing the translations
- * of X11 key strings to human readable key names. */
-void QIHotKeyEdit::retranslateUi()
-{
-    /* Note: strings for the same key must match strings in retranslateUi()
-     * versions for all platforms, to keep translators happy. */
-
-    s_keyNames["Shift_L"]          = tr("Left Shift");
-    s_keyNames["Shift_R"]          = tr("Right Shift");
-    s_keyNames["Control_L"]        = tr("Left Ctrl");
-    s_keyNames["Control_R"]        = tr("Right Ctrl");
-    s_keyNames["Alt_L"]            = tr("Left Alt");
-    s_keyNames["Alt_R"]            = tr("Right Alt");
-    s_keyNames["Super_L"]          = tr("Left WinKey");
-    s_keyNames["Super_R"]          = tr("Right WinKey");
-    s_keyNames["Menu"]             = tr("Menu key");
-    s_keyNames["ISO_Level3_Shift"] = tr("Alt Gr");
-    s_keyNames["Caps_Lock"]        = tr("Caps Lock");
-    s_keyNames["Scroll_Lock"]      = tr("Scroll Lock");
-}
+    /* Initialize the X keyboard subsystem: */
+    initMappedX11Keyboard(QX11Info::display(), vboxGlobal().settings().publicProperty("GUI/RemapScancodes"));
 #endif /* Q_WS_X11 */
 
-void QIHotKeyEdit::clear()
-{
-    m_iKeyVal = 0;
-    m_strSymbName = tr(m_spNoneSymbName);
+#ifdef Q_WS_MAC
+    m_uDarwinKeyModifiers = GetCurrentEventKeyModifiers();
+    UICocoaApplication::instance()->registerForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */, UIHotKeyEditor::darwinEventHandlerProc, this);
+    ::DarwinGrabKeyboard(false /* just modifiers */);
+#endif /* Q_WS_MAC */
+}
+
+UIHotKeyEditor::~UIHotKeyEditor()
+{
+#ifdef Q_WS_MAC
+    ::DarwinReleaseKeyboard();
+    UICocoaApplication::instance()->unregisterForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */, UIHotKeyEditor::darwinEventHandlerProc, this);
+#endif /* Q_WS_MAC */
+}
+
+void UIHotKeyEditor::setCombo(const QString &strKeyCombo)
+{
+    /* Cleanup old combo: */
+    m_shownKeys.clear();
+    /* Parse newly passed combo: */
+    QList<int> keyCodeList = UIHotKeyCombination::toKeyCodeList(strKeyCombo);
+    for (int i = 0; i < keyCodeList.size(); ++i)
+        if (int iKeyCode = keyCodeList[i])
+            m_shownKeys.insert(iKeyCode, UIHotKey::toString(iKeyCode));
+    /* Update text: */
     updateText();
 }
 
-#if defined (Q_WS_WIN)
-
-bool QIHotKeyEdit::winEvent(MSG *pMsg, long* /* pResult */)
-{
-    if (!(pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN ||
-          pMsg->message == WM_KEYUP || pMsg->message == WM_SYSKEYUP ||
-          pMsg->message == WM_CHAR || pMsg->message == WM_SYSCHAR ||
-          pMsg->message == WM_DEADCHAR || pMsg->message == WM_SYSDEADCHAR ||
-          pMsg->message == WM_CONTEXTMENU))
-        return false;
-
-    /* Ignore if not a valid hot key: */
-    if (!isValidKey(pMsg->wParam))
-        return false;
-
-#if 0
-    LogFlow(("%WM_%04X: vk=%04X rep=%05d scan=%02X ext=%01d"
-             "rzv=%01X ctx=%01d prev=%01d tran=%01d\n",
-             pMsg->message, pMsg->wParam,
-             (pMsg->lParam & 0xFFFF),
-             ((pMsg->lParam >> 16) & 0xFF),
-             ((pMsg->lParam >> 24) & 0x1),
-             ((pMsg->lParam >> 25) & 0xF),
-             ((pMsg->lParam >> 29) & 0x1),
-             ((pMsg->lParam >> 30) & 0x1),
-             ((pMsg->lParam >> 31) & 0x1)));
-#endif
-
-    if (pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN)
-    {
-        /* Determine platform-dependent key: */
-        m_iKeyVal = qi_distinguish_modifier_vkey(pMsg->wParam);
-        /* Determine symbolic name: */
-        TCHAR *pStr = new TCHAR[256];
-        if (::GetKeyNameText(pMsg->lParam, pStr, 256))
+QString UIHotKeyEditor::combo() const
+{
+    /* Compose current combination: */
+    QStringList keyCodeStringList;
+    QList<int> keyCodeList = m_shownKeys.keys();
+    for (int i = 0; i < keyCodeList.size(); ++i)
+        keyCodeStringList << QString::number(keyCodeList[i]);
+    /* Return current combination or "0" for "None": */
+    return keyCodeStringList.isEmpty() ? "0" : keyCodeStringList.join(",");
+}
+
+QSize UIHotKeyEditor::sizeHint() const
+{
+    ensurePolished();
+    QFontMetrics fm(font());
+    int h = qMax(fm.lineSpacing(), 14) + 2;
+    int w = fm.width('x') * 17;
+    int m = frameWidth() * 2;
+    QStyleOption option;
+    option.initFrom(this);
+    return (style()->sizeFromContents(QStyle::CT_LineEdit, &option,
+                                      QSize(w + m, h + m).expandedTo(QApplication::globalStrut()),
+                                      this));
+}
+
+QSize UIHotKeyEditor::minimumSizeHint() const
+{
+    ensurePolished();
+    QFontMetrics fm = fontMetrics();
+    int h = fm.height() + qMax(2, fm.leading());
+    int w = fm.maxWidth();
+    int m = frameWidth() * 2;
+    return QSize(w + m, h + m);
+}
+
+#ifdef Q_WS_WIN
+bool UIHotKeyEditor::winEvent(MSG *pMsg, long* /* pResult */)
+{
+    switch (pMsg->message)
+    {
+        case WM_KEYDOWN:
+        case WM_SYSKEYDOWN:
+        case WM_KEYUP:
+        case WM_SYSKEYUP:
         {
-            m_strSymbName = QString::fromUtf16(pStr);
+            /* Get key-code: */
+            int iKeyCode = UIHotKey::distinguishModifierVKey((int)pMsg->wParam);
+
+            /* Check if symbol is valid else pass it to Qt: */
+            if (!UIHotKey::isValidKey(iKeyCode))
+                return false;
+
+            /* Key press: */
+            if (pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN)
+            {
+                /* Clear reflected symbols if new sequence started: */
+                if (m_fStartNewSequence)
+                    m_shownKeys.clear();
+
+                /* Remember pressed symbol: */
+                m_pressedKeys << pMsg->wParam;
+                m_shownKeys.insert(iKeyCode, UIHotKey::toString(iKeyCode));
+
+                /* Remember what we already started a sequence: */
+                m_fStartNewSequence = false;
+            }
+            /* Key release: */
+            else if (pMsg->message == WM_KEYUP || pMsg->message == WM_SYSKEYUP)
+            {
+                /* Remove pressed symbol: */
+                m_pressedKeys.remove(pMsg->wParam);
+
+                /* If pressed keys map is empty => start new sequence: */
+                if (m_pressedKeys.isEmpty())
+                    m_fStartNewSequence = true;
+            }
+
+            /* Update text: */
+            updateText();
+
+            /* Prevent passing to Qt: */
+            return true;
         }
-        else
-        {
-            AssertFailed();
-            m_strSymbName = QString(tr("<key_%1>")).arg(m_iKeyVal);
-        }
-        delete[] pStr;
-        /* Update the display: */
-        updateText();
-    }
-
-    return true;
-}
-
-#elif defined (Q_WS_X11)
-
-bool QIHotKeyEdit::x11Event(XEvent *pEvent)
+        default:
+            break;
+    }
+
+    return false;
+}
+#endif /* Q_WS_WIN */
+
+#ifdef Q_WS_X11
+bool UIHotKeyEditor::x11Event(XEvent *pEvent)
 {
     switch (pEvent->type)
@@ -432 +420 @@
         case XKeyRelease:
         {
+            /* Get key-code: */
             XKeyEvent *pKeyEvent = (XKeyEvent*)pEvent;
             KeySym ks = ::XKeycodeToKeysym(pKeyEvent->display, pKeyEvent->keycode, 0);
-            /* Ignore if not a valid hot key: */
-            if (!isValidKey((int)ks))
+            int iKeySym = (int)ks;
+
+            /* Check if symbol is valid else pass it to Qt: */
+            if (!UIHotKey::isValidKey(iKeySym))
                 return false;
 
-            /* Skip key releases: */
-            if (pEvent->type == XKeyRelease)
-                return true;
-
-            /* Determine platform-dependent key: */
-            m_iKeyVal = (int)ks;
-            /* Determine symbolic name: */
-            m_strSymbName = QIHotKeyEdit::keyName(m_iKeyVal);
-            /* Update the display: */
+            /* Key press: */
+            if (pEvent->type == XKeyPress)
+            {
+                /* Clear reflected symbols if new sequence started: */
+                if (m_fStartNewSequence)
+                    m_shownKeys.clear();
+
+                /* Remember pressed symbol: */
+                m_pressedKeys << iKeySym;
+                m_shownKeys.insert(iKeySym, UIHotKey::toString(iKeySym));
+
+                /* Remember what we already started a sequence: */
+                m_fStartNewSequence = false;
+            }
+            /* Key release: */
+            else if (pEvent->type == XKeyRelease)
+            {
+                /* Remove pressed symbol: */
+                m_pressedKeys.remove(iKeySym);
+
+                /* If pressed keys map is empty => start new sequence: */
+                if (m_pressedKeys.isEmpty())
+                    m_fStartNewSequence = true;
+            }
+
+            /* Update text: */
             updateText();
-#if 0
-            LogFlow(("%s: state=%08X keycode=%08X keysym=%08X symb=%s\n",
-                     pEvent->type == XKeyPress ? "XKeyPress" : "XKeyRelease",
-                     pKeyEvent->state, pKeyEvent->keycode, ks,
-                     symbname.latin1()));
-#endif
+
+            /* Prevent passing to Qt: */
             return true;
         }
@@ -460 +464 @@
     return false;
 }
-
-#elif defined (Q_WS_MAC)
-
+#endif /* Q_WS_X11 */
+
+#ifdef Q_WS_MAC
 /* static */
-bool QIHotKeyEdit::darwinEventHandlerProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser)
-{
-    QIHotKeyEdit *edit = (QIHotKeyEdit*)pvUser;
+bool UIHotKeyEditor::darwinEventHandlerProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser)
+{
+    UIHotKeyEditor *edit = (UIHotKeyEditor*)pvUser;
     EventRef inEvent = (EventRef)pvCarbonEvent;
     UInt32 EventClass = ::GetEventClass(inEvent);
@@ -474 +478 @@
 }
 
-bool QIHotKeyEdit::darwinKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent)
-{
-#if 0 /* for debugging */
-    ::darwinDebugPrintEvent("QIHotKeyEdit", inEvent);
-#endif
-
+bool UIHotKeyEditor::darwinKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent)
+{
     /* Ignore key changes unless we're the focus widget: */
     if (!hasFocus())
@@ -487 +487 @@
     switch (eventKind)
     {
-        /*case kEventRawKeyDown:
-        case kEventRawKeyUp:
-        case kEventRawKeyRepeat:*/
+        //case kEventRawKeyDown:
+        //case kEventRawKeyUp:
+        //case kEventRawKeyRepeat:
         case kEventRawKeyModifiersChanged:
         {
+            /* Get modifier mask: */
             UInt32 modifierMask = 0;
             ::GetEventParameter(inEvent, kEventParamKeyModifiers, typeUInt32, NULL,
                                 sizeof(modifierMask), NULL, &modifierMask);
-
             modifierMask = ::DarwinAdjustModifierMask(modifierMask, pvCocoaEvent);
             UInt32 changed = m_uDarwinKeyModifiers ^ modifierMask;
             m_uDarwinKeyModifiers = modifierMask;
 
-            /* Skip key releases: */
-            if (changed && (changed & modifierMask))
+            /* Convert to keycode: */
+            int iKeyCode = ::DarwinModifierMaskToDarwinKeycode(changed);
+
+            /* Check if symbol is valid else pass it to Qt: */
+            if (!iKeyCode || iKeyCode == ~0U || !UIHotKey::isValidKey(iKeyCode))
                 break;
 
-            /* Convert to keycode and skip keycodes we don't care about. */
-            unsigned keyCode = ::DarwinModifierMaskToDarwinKeycode(changed);
-            if (!keyCode || keyCode == ~0U || !isValidKey(keyCode))
-                break;
-
-            /* Update key current key: */
-            m_iKeyVal = keyCode;
-            m_strSymbName = QIHotKeyEdit::keyName(keyCode);
+            if (changed)
+            {
+                /* Key release: */
+                if (changed & modifierMask)
+                {
+                    /* Remove pressed symbol: */
+                    m_pressedKeys.remove(iKeyCode);
+
+                    /* If pressed key map is empty => start new sequence: */
+                    if (m_pressedKeys.isEmpty())
+                        m_fStartNewSequence = true;
+                }
+                /* Key press: */
+                else
+                {
+                    /* Clear reflected symbols if new sequence started: */
+                    if (m_fStartNewSequence)
+                        m_shownKeys.clear();
+
+                    /* Remember pressed symbol: */
+                    m_pressedKeys << iKeyCode;
+                    m_shownKeys.insert(iKeyCode, UIHotKey::toString(iKeyCode));
+
+                    /* Remember what we already started a sequence: */
+                    m_fStartNewSequence = false;
+                }
+            }
+
+            /* Update text: */
             updateText();
-            break; //return true;
         }
         break;
@@ -519 +542 @@
     return false;
 }
-
-#else
-# warning "Port me!"
-#endif
-
-void QIHotKeyEdit::focusInEvent(QFocusEvent *pEvent)
+#endif /* Q_WS_MAC */
+
+void UIHotKeyEditor::keyPressEvent(QKeyEvent *pEvent)
+{
+    switch (pEvent->key())
+    {
+        case Qt::Key_Delete:
+        case Qt::Key_Backspace:
+            m_shownKeys.clear();
+            updateText();
+            break;
+        default:
+            QWidget::keyPressEvent(pEvent);
+            break;
+    }
+}
+
+void UIHotKeyEditor::focusInEvent(QFocusEvent *pEvent)
 {
     QLabel::focusInEvent(pEvent);
@@ -534 +569 @@
 }
 
-void QIHotKeyEdit::focusOutEvent(QFocusEvent *pEvent)
+void UIHotKeyEditor::focusOutEvent(QFocusEvent *pEvent)
 {
     QLabel::focusOutEvent(pEvent);
@@ -544 +579 @@
 }
 
-void QIHotKeyEdit::paintEvent(QPaintEvent *pEvent)
+void UIHotKeyEditor::paintEvent(QPaintEvent *pEvent)
 {
     if (hasFocus())
@@ -558 +593 @@
 }
 
-void QIHotKeyEdit::updateText()
-{
-    setText(QString(" %1 ").arg(m_strSymbName));
-}
-
+void UIHotKeyEditor::updateText()
+{
+    QStringList shownKeyNames(m_shownKeys.values());
+    setText(shownKeyNames.isEmpty() ? tr("None") : shownKeyNames.join(" + "));
+}
+

trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIHotKeyEditor.h

@@ -2 +2 @@
  *
  * VBox frontends: Qt GUI ("VirtualBox"):
- * VirtualBox Qt extensions: QIHotKeyEdit class declaration
+ * VirtualBox Qt extensions: UIHotKeyEditor class declaration
  */
 
@@ -17 +17 @@
  */
 
-#ifndef ___QIHotKeyEdit_h___
-#define ___QIHotKeyEdit_h___
+#ifndef ___UIHotKeyEditor_h___
+#define ___UIHotKeyEditor_h___
 
 /* Global includes */
 #include <QLabel>
+#include <QMap>
+#include <QSet>
 
+/* Hot-key namespace to unify
+ * all the related hot-key processing stuff: */
+namespace UIHotKey
+{
+    QString toString(int iKeyCode);
+    bool isValidKey(int iKeyCode);
+#ifdef Q_WS_WIN
+    int distinguishModifierVKey(int wParam);
+#endif /* Q_WS_WIN */
 #ifdef Q_WS_X11
-# include <QMap>
+    void retranslateKeyNames();
 #endif /* Q_WS_X11 */
+}
 
-class QIHotKeyEdit : public QLabel
+/* Hot-combo namespace to unify
+ * all the related hot-combo processing stuff: */
+namespace UIHotKeyCombination
 {
-    Q_OBJECT
+    QString toReadableString(const QString &strKeyCombo);
+    QList<int> toKeyCodeList(const QString &strKeyCombo);
+    bool isValidKeyCombo(const QString &strKeyCombo);
+}
+
+class UIHotKeyEditor : public QLabel
+{
+    Q_OBJECT;
 
 public:
 
-    QIHotKeyEdit(QWidget *pParent);
-    virtual ~QIHotKeyEdit();
+    UIHotKeyEditor(QWidget *pParent);
+    virtual ~UIHotKeyEditor();
 
-    void setKey(int iKeyVal);
-    int key() const { return m_iKeyVal; }
-
-    QString symbolicName() const { return m_strSymbName; }
+    void setCombo(const QString &strKeyCombo);
+    QString combo() const;
 
     QSize sizeHint() const;
     QSize minimumSizeHint() const;
 
-    static QString keyName(int iKeyVal);
-    static bool isValidKey(int iKeyVal);
-#ifdef Q_WS_X11
-    static void retranslateUi();
-#endif /* Q_WS_X11 */
-
-public slots:
-
-    void clear();
-
 protected:
 
-#if defined (Q_WS_WIN32)
+#ifdef Q_WS_WIN
     bool winEvent(MSG *pMsg, long *pResult);
-#elif defined (Q_WS_X11)
+#endif /* Q_WS_WIN */
+#ifdef Q_WS_X11
     bool x11Event(XEvent *pEvent);
-#elif defined (Q_WS_MAC)
+#endif /* Q_WS_X11 */
+#ifdef Q_WS_MAC
     static bool darwinEventHandlerProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser);
     bool darwinKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent);
-#endif
+#endif /* Q_WS_MAC */
 
+    void keyPressEvent(QKeyEvent *pEvent);
     void focusInEvent(QFocusEvent *pEvent);
     void focusOutEvent(QFocusEvent *pEvent);
@@ -73 +85 @@
     void updateText();
 
-    int m_iKeyVal;
-    QString m_strSymbName;
+    QSet<int> m_pressedKeys;
+    QMap<int, QString> m_shownKeys;
 
-#ifdef Q_WS_X11
-    static QMap<QString, QString> s_keyNames;
-#endif /* Q_WS_X11 */
+    bool m_fStartNewSequence;
 
 #ifdef Q_WS_MAC
@@ -85 +95 @@
     uint32_t m_uDarwinKeyModifiers;
 #endif /* Q_WS_MAC */
-
-    static const char *m_spNoneSymbName;
 };
 
-#endif // !___QIHotKeyEdit_h___
+#endif // !___UIHotKeyEditor_h___