Changeset 5132 in vbox for trunk/src/VBox/Frontends

Timestamp:

Oct 1, 2007 9:41:31 PM (17 years ago)

Author:

vboxsync

Message:

FE/Qt: OS/2: Implemented keyboard input to the VM.

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• include/QIHotKeyEdit.h (modified) (4 diffs)
• include/VBoxConsoleView.h (modified) (3 diffs)
• src/QIHotKeyEdit.cpp (modified) (25 diffs)
• src/VBoxConsoleView.cpp (modified) (18 diffs)
• src/VBoxGlobal.cpp (modified) (1 diff)
• src/VBoxGlobalSettings.cpp (modified) (4 diffs)

trunk/src/VBox/Frontends/VirtualBox/include/QIHotKeyEdit.h

@@ -28 +28 @@
 #endif
 
+#if defined(Q_WS_PM)
+/* Extra virtual keys returned by QIHotKeyEdit::virtualKey() */
+#define VK_LSHIFT   VK_USERFIRST + 0
+#define VK_LCTRL    VK_USERFIRST + 1
+#define VK_LWIN     VK_USERFIRST + 2
+#define VK_RWIN     VK_USERFIRST + 3
+#define VK_WINMENU  VK_USERFIRST + 4
+#define VK_FORWARD  VK_USERFIRST + 5
+#define VK_BACKWARD VK_USERFIRST + 6
+#endif
 
 class QIHotKeyEdit : public QLabel
@@ -35 +45 @@
 public:
 
-    QIHotKeyEdit( QWidget * parent, const char * name = 0 );
+    QIHotKeyEdit (QWidget *aParent, const char *aName = 0);
     virtual ~QIHotKeyEdit();
 
-    void setKey( int keyval );
-    int key() const { return keyval; }
+    void setKey (int aKeyVal);
+    int key() const { return mKeyVal; }
 
-    QString symbolicName() const { return symbname; }
+    QString symbolicName() const { return mSymbName; }
 
     QSize sizeHint() const;
     QSize minimumSizeHint() const;
 
-#if defined(Q_WS_X11)
-    static void languageChange(void);
+#if defined (Q_WS_PM)
+    static int virtualKey (QMSG *aMsg);
 #endif
-    static QString keyName (int key);
-    static bool isValidKey (int k);
+
+#if defined (Q_WS_PM) || defined (Q_WS_X11)
+    static void languageChange();
+#endif
+    static QString keyName (int aKeyVal);
+    static bool isValidKey (int aKeyVal);
 
 public slots:
@@ -58 +72 @@
 protected:
 
-#if defined(Q_WS_WIN32)
-    bool winEvent( MSG *msg );
-#elif defined(Q_WS_X11)
-    bool x11Event( XEvent *event );
-#elif defined(Q_WS_MAC)
-    static pascal OSStatus darwinEventHandlerProc( EventHandlerCallRef inHandlerCallRef,
-                                                   EventRef inEvent, void *inUserData );
-    bool darwinKeyboardEvent( EventRef inEvent );
+#if defined (Q_WS_WIN32)
+    bool winEvent (MSG *msg);
+#elif defined (Q_WS_PM)
+    bool pmEvent (QMSG *aMsg);
+#elif defined (Q_WS_X11)
+    bool x11Event (XEvent *event);
+#elif defined (Q_WS_MAC)
+    static pascal OSStatus darwinEventHandlerProc (EventHandlerCallRef inHandlerCallRef,
+                                                   EventRef inEvent, void *inUserData);
+    bool darwinKeyboardEvent (EventRef inEvent);
 #endif
 
-    void focusInEvent( QFocusEvent * );
-    void focusOutEvent( QFocusEvent * );
+    void focusInEvent (QFocusEvent *);
+    void focusOutEvent (QFocusEvent *);
 
-    void drawContents( QPainter * p );
+    void drawContents (QPainter *p);
 
 private:
@@ -77 +93 @@
     void updateText();
 
-    int keyval;
-    QString symbname;
+    int mKeyVal;
+    QString mSymbName;
 
-    QColorGroup true_acg;
+    QColorGroup mTrueACG;
 
-#if defined(Q_WS_X11)
-    static QMap<QString, QString> keyNames;
+#if defined (Q_WS_PM)
+    static QMap <int, QString> sKeyNames;
+#elif defined (Q_WS_X11)
+    static QMap <QString, QString> sKeyNames;
 #endif
 
-#if defined(Q_WS_MAC)
+#if defined (Q_WS_MAC)
     /** Event handler reference. NULL if the handler isn't installed. */
-    EventHandlerRef m_darwinEventHandlerRef;
+    EventHandlerRef mDarwinEventHandlerRef;
     /** The current modifier key mask. Used to figure out which modifier
      *  key was pressed when we get a kEventRawKeyModifiersChanged event. */
-    UInt32 m_darwinKeyModifiers;
+    UInt32 mDarwinKeyModifiers;
 #endif
 
-    static const char *NoneSymbName;
+    static const char *kNoneSymbName;
 };
 

trunk/src/VBox/Frontends/VirtualBox/include/VBoxConsoleView.h

@@ -110 +110 @@
 
     // events
-    bool event( QEvent *e );
-    bool eventFilter( QObject *watched, QEvent *e );
+    bool event (QEvent *e);
+    bool eventFilter (QObject *watched, QEvent *e);
 
 #if defined(Q_WS_WIN32)
     bool winLowKeyboardEvent (UINT msg, const KBDLLHOOKSTRUCT &event);
     bool winEvent (MSG *msg);
+#elif defined(Q_WS_PM)
+    bool pmEvent (QMSG *aMsg);
 #elif defined(Q_WS_X11)
-    bool x11Event (XEvent *event );
+    bool x11Event (XEvent *event);
 #elif defined(Q_WS_MAC)
     bool darwinKeyboardEvent (EventRef inEvent);
@@ -125 +127 @@
 private:
 
-    // flags for keyEvent()
+    /** Flags for keyEvent(). */
     enum {
         KeyExtended = 0x01,
@@ -134 +136 @@
 
     void focusEvent (bool focus);
-    bool keyEvent (int key, uint8_t scan, int flags, wchar_t *aUniKey = NULL);
+    bool keyEvent (int aKey, uint8_t aScan, int aFlags,
+                   wchar_t *aUniKey = NULL);
     bool mouseEvent (int aType, const QPoint &aPos, const QPoint &aGlobalPos,
                      ButtonState aButton,

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

@@ -26 +26 @@
 
 #ifdef Q_WS_WIN
-// VBox/cdefs.h defines these:
+/* VBox/cdefs.h defines these: */
 #undef LOWORD
 #undef HIWORD
@@ -34 +34 @@
 #endif
 
+#if defined (Q_WS_PM)
+QMap <int, QString> QIHotKeyEdit::sKeyNames;
+#endif
+
 #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.
+/* 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
@@ -56 +60 @@
 #endif
 #include "XKeyboard.h"
-QMap<QString, QString> QIHotKeyEdit::keyNames;
+QMap <QString, QString> QIHotKeyEdit::sKeyNames;
 #endif
 
@@ -64 +68 @@
 
 
-#ifdef Q_WS_WIN32
+#if defined (Q_WS_WIN32)
 /**
  *  Returns the correct modifier vkey for the *last* keyboard message,
@@ -71 +75 @@
  *  unchanged.
  */
-int qi_distinguish_modifier_vkey( WPARAM wParam )
+int qi_distinguish_modifier_vkey (WPARAM wParam)
 {
     int keyval = wParam;
-    switch ( wParam ) {
+    switch (wParam)
+    {
         case VK_SHIFT:
-            if ( ::GetKeyState( VK_LSHIFT ) & 0x8000 ) keyval = VK_LSHIFT;
-            else if ( ::GetKeyState( VK_RSHIFT ) & 0x8000 ) keyval = VK_RSHIFT;
+            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;
+            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;
+            if (::GetKeyState (VK_LMENU) & 0x8000) keyval = VK_LMENU;
+            else if (::GetKeyState (VK_RMENU) & 0x8000) keyval = VK_RMENU;
             break;
     }
@@ -97 +102 @@
  */
 
-const char *QIHotKeyEdit::NoneSymbName = "<none>";
-
-QIHotKeyEdit::QIHotKeyEdit( QWidget * parent, const char * name ) :
-    QLabel( parent, name )
+const char *QIHotKeyEdit::kNoneSymbName = "<none>";
+
+QIHotKeyEdit::QIHotKeyEdit (QWidget *aParent, const char *aName) :
+    QLabel (aParent, aName)
 {
 #ifdef Q_WS_X11
     // initialize the X keyboard subsystem
-    initXKeyboard( this->x11Display() );
+    initXKeyboard (this->x11Display());
 #endif
 
     clear();
 
-    setFrameStyle( LineEditPanel | Sunken );
-    setAlignment( AlignHCenter | AlignBottom );
-    setFocusPolicy( StrongFocus );
+    setFrameStyle (LineEditPanel | Sunken);
+    setAlignment (AlignHCenter | AlignBottom);
+    setFocusPolicy (StrongFocus);
 
     QPalette p = palette();
-    p.setColor( QPalette::Active, QColorGroup::Foreground,
-        p.color( QPalette::Active, QColorGroup::HighlightedText )
-    );
-    p.setColor( QPalette::Active, QColorGroup::Background,
-        p.color( QPalette::Active, QColorGroup::Highlight )
-    );
-    p.setColor( QPalette::Inactive, QColorGroup::Foreground,
-        p.color( QPalette::Active, QColorGroup::Text )
-    );
-    p.setColor( QPalette::Inactive, QColorGroup::Background,
-        p.color( QPalette::Active, QColorGroup::Base )
-    );
-
-    true_acg = p.active();
-    p.setActive( p.inactive() );
-    setPalette( p );
+    p.setColor (QPalette::Active, QColorGroup::Foreground,
+        p.color (QPalette::Active, QColorGroup::HighlightedText));
+    p.setColor (QPalette::Active, QColorGroup::Background,
+        p.color (QPalette::Active, QColorGroup::Highlight));
+    p.setColor (QPalette::Inactive, QColorGroup::Foreground,
+        p.color (QPalette::Active, QColorGroup::Text));
+    p.setColor (QPalette::Inactive, QColorGroup::Background,
+        p.color (QPalette::Active, QColorGroup::Base));
+
+    mTrueACG = p.active();
+    p.setActive (p.inactive());
+    setPalette (p);
 
 #ifdef Q_WS_MAC
-    m_darwinKeyModifiers = GetCurrentEventKeyModifiers();
+    mDarwinKeyModifiers = GetCurrentEventKeyModifiers();
 
     EventTypeSpec eventTypes[4];
@@ -144 +145 @@
     eventTypes[3].eventKind  = kEventRawKeyModifiersChanged;
 
-    EventHandlerUPP eventHandler = ::NewEventHandlerUPP( QIHotKeyEdit::darwinEventHandlerProc );
-
-    m_darwinEventHandlerRef = NULL;
-    ::InstallApplicationEventHandler( eventHandler, RT_ELEMENTS( eventTypes ), &eventTypes[0],
-                                      this, &m_darwinEventHandlerRef );
-    ::DisposeEventHandlerUPP( eventHandler );
-    ::DarwinGrabKeyboard( false /* just modifiers */ );
-
-#endif
-
+    EventHandlerUPP eventHandler = ::NewEventHandlerUPP (QIHotKeyEdit::darwinEventHandlerProc);
+
+    mDarwinEventHandlerRef = NULL;
+    ::InstallApplicationEventHandler (eventHandler, RT_ELEMENTS( eventTypes ), &eventTypes[0],
+                                      this, &mDarwinEventHandlerRef);
+    ::DisposeEventHandlerUPP (eventHandler);
+    ::DarwinGrabKeyboard (false /* just modifiers */);
+#endif
 }
 
@@ -160 +159 @@
 #ifdef Q_WS_MAC
     ::DarwinReleaseKeyboard();
-    ::RemoveEventHandler( m_darwinEventHandlerRef );
-    m_darwinEventHandlerRef = NULL;
+    ::RemoveEventHandler (mDarwinEventHandlerRef);
+    mDarwinEventHandlerRef = NULL;
 #endif
 }
@@ -176 +175 @@
  *      to the keycode.
  */
-void QIHotKeyEdit::setKey (int k)
-{
-    keyval = k;
-    symbname = QIHotKeyEdit::keyName (k);
+void QIHotKeyEdit::setKey (int aKeyVal)
+{
+    mKeyVal = aKeyVal;
+    mSymbName = QIHotKeyEdit::keyName (aKeyVal);
     updateText();
 }
@@ -204 +203 @@
     int w = fm.width( 'x' ) * 17; // "some"
     int m = frameWidth() * 2;
-    return (style().sizeFromContents(QStyle::CT_LineEdit, this,
-                                     QSize (w + m, h + m)
-                                     .expandedTo(QApplication::globalStrut())));
+    return (style().sizeFromContents (QStyle::CT_LineEdit, this,
+                                      QSize (w + m, h + m)
+                                      .expandedTo(QApplication::globalStrut())));
 }
 
@@ -222 +221 @@
 }
 
-#if defined(Q_WS_X11)
+#if defined (Q_WS_PM)
+/** 
+ *  Returns the virtual key extracted from the QMSG structure.
+ *
+ *  This function tries to detect some extra virtual keys definitions missing
+ *  in PM (like Left Shift, Left Ctrl, Win keys). In all other cases it simply
+ *  returns SHORT2FROMMP (aMsg->mp2).
+ * 
+ *  @param aMsg  Pointer to the QMSG structure to extract the virtual key from.
+ *  @return The extracted virtual key code or zero if there is no virtual key.
+ */
+/* static */
+int QIHotKeyEdit::virtualKey (QMSG *aMsg)
+{
+    USHORT f = SHORT1FROMMP (aMsg->mp1);
+    CHAR scan = CHAR4FROMMP (aMsg->mp1);
+    USHORT ch = SHORT1FROMMP (aMsg->mp2);
+    int vkey = (unsigned int) SHORT2FROMMP (aMsg->mp2);
+
+    if (f & KC_VIRTUALKEY)
+    {
+        /* distinguish Left Shift from Right Shift) */
+        if (vkey == VK_SHIFT && scan == 0x2A)
+            vkey = VK_LSHIFT;
+        /* distinguish Left Ctrl from Right Ctrl */
+        else if (vkey == VK_CTRL && scan == 0x1D)
+            vkey = VK_LCTRL;
+        /* distinguish Ctrl+ScrLock from Ctrl+Break */
+        else if (vkey == VK_BREAK && scan == 0x46 && f & KC_CTRL)
+            vkey = VK_SCRLLOCK;
+    }
+    else if (!(f & KC_CHAR))
+    {
+        /* detect some special keys that have a pseudo char code in the high
+         * byte of ch (probably this is less device-dependent than
+         * scancode) */
+        switch (ch)
+        {
+            case 0xEC00: vkey = VK_LWIN; break;
+            case 0xED00: vkey = VK_RWIN; break;
+            case 0xEE00: vkey = VK_WINMENU; break;
+            case 0xF900: vkey = VK_FORWARD; break;
+            case 0xFA00: vkey = VK_BACKWARD; break;
+            default: vkey = 0;
+        }
+    }
+
+    return vkey;
+}
+#endif
+
+#if defined (Q_WS_PM)
 /**
- * Updates the associative array containing the translations of X11 key strings to human
- * readable key names.
- */
-// static
-void QIHotKeyEdit::languageChange(void)
-{
-    keyNames ["Shift_L"]          = tr ("Left Shift");
-    keyNames ["Shift_R"]          = tr ("Right Shift");
-    keyNames ["Control_L"]        = tr ("Left Ctrl");
-    keyNames ["Control_R"]        = tr ("Right Ctrl");
-    keyNames ["Alt_L"]            = tr ("Left Alt");
-    keyNames ["Alt_R"]            = tr ("Right Alt");
-    keyNames ["Super_L"]          = tr ("Left WinKey");
-    keyNames ["Super_R"]          = tr ("Right WinKey");
-    keyNames ["Menu"]             = tr ("Menu key");
-    keyNames ["ISO_Level3_Shift"] = tr ("Alt Gr");
-    keyNames ["Caps_Lock"]        = tr ("Caps Lock");
-    keyNames ["Scroll_Lock"]      = tr ("Scroll Lock");
+ *  Updates the associative array containing the translations of PM virtual
+ *  keys to human readable key names.
+ */
+/* static */
+void QIHotKeyEdit::languageChange()
+{
+    /* Note: strings for the same key must match strings in languageChange()
+     * versions for all platforms, to keep translators happy. */
+
+    sKeyNames [VK_LSHIFT]        = tr ("Left Shift");
+    sKeyNames [VK_SHIFT]         = tr ("Right Shift");
+    sKeyNames [VK_LCTRL]         = tr ("Left Ctrl");
+    sKeyNames [VK_CTRL]          = tr ("Right Ctrl");
+    sKeyNames [VK_ALT]           = tr ("Left Alt");
+    sKeyNames [VK_ALTGRAF]       = tr ("Right Alt");
+    sKeyNames [VK_LWIN]          = tr ("Left WinKey");
+    sKeyNames [VK_RWIN]          = tr ("Right WinKey");
+    sKeyNames [VK_WINMENU]       = tr ("Menu key");
+    sKeyNames [VK_CAPSLOCK]      = tr ("Caps Lock");
+    sKeyNames [VK_SCRLLOCK]      = tr ("Scroll Lock");
+
+    sKeyNames [VK_PAUSE]         = tr ("Pause");
+    sKeyNames [VK_PRINTSCRN]     = tr ("Print Screen");
+
+    sKeyNames [VK_F1]            = tr ("F1");
+    sKeyNames [VK_F2]            = tr ("F2");
+    sKeyNames [VK_F3]            = tr ("F3");
+    sKeyNames [VK_F4]            = tr ("F4");
+    sKeyNames [VK_F5]            = tr ("F5");
+    sKeyNames [VK_F6]            = tr ("F6");
+    sKeyNames [VK_F7]            = tr ("F7");
+    sKeyNames [VK_F8]            = tr ("F8");
+    sKeyNames [VK_F9]            = tr ("F9");
+    sKeyNames [VK_F10]           = tr ("F10");
+    sKeyNames [VK_F11]           = tr ("F11");
+    sKeyNames [VK_F12]           = tr ("F12");
+    sKeyNames [VK_F13]           = tr ("F13");
+    sKeyNames [VK_F14]           = tr ("F14");
+    sKeyNames [VK_F15]           = tr ("F15");
+    sKeyNames [VK_F16]           = tr ("F16");
+    sKeyNames [VK_F17]           = tr ("F17");
+    sKeyNames [VK_F18]           = tr ("F18");
+    sKeyNames [VK_F19]           = tr ("F19");
+    sKeyNames [VK_F20]           = tr ("F20");
+    sKeyNames [VK_F21]           = tr ("F21");
+    sKeyNames [VK_F22]           = tr ("F22");
+    sKeyNames [VK_F23]           = tr ("F23");
+    sKeyNames [VK_F24]           = tr ("F24");
+
+    sKeyNames [VK_NUMLOCK]       = tr ("Num Lock");
+    sKeyNames [VK_FORWARD]       = tr ("Forward");
+    sKeyNames [VK_BACKWARD]      = tr ("Back");
+}
+#elif defined (Q_WS_X11)
+/**
+ *  Updates the associative array containing the translations of X11 key strings to human
+ *  readable key names.
+ */
+/* static */
+void QIHotKeyEdit::languageChange()
+{
+    /* Note: strings for the same key must match strings in languageChange()
+     * versions for all platforms, to keep translators happy. */
+
+    sKeyNames ["Shift_L"]          = tr ("Left Shift");
+    sKeyNames ["Shift_R"]          = tr ("Right Shift");
+    sKeyNames ["Control_L"]        = tr ("Left Ctrl");
+    sKeyNames ["Control_R"]        = tr ("Right Ctrl");
+    sKeyNames ["Alt_L"]            = tr ("Left Alt");
+    sKeyNames ["Alt_R"]            = tr ("Right Alt");
+    sKeyNames ["Super_L"]          = tr ("Left WinKey");
+    sKeyNames ["Super_R"]          = tr ("Right WinKey");
+    sKeyNames ["Menu"]             = tr ("Menu key");
+    sKeyNames ["ISO_Level3_Shift"] = tr ("Alt Gr");
+    sKeyNames ["Caps_Lock"]        = tr ("Caps Lock");
+    sKeyNames ["Scroll_Lock"]      = tr ("Scroll Lock");
 }
 #endif
@@ -253 +361 @@
  *      to the keycode.
  */
-// static
-QString QIHotKeyEdit::keyName (int key)
+/* static */
+QString QIHotKeyEdit::keyName (int aKeyVal)
 {
     QString name;
 
-    if ( !key )
-    {
-        name = tr (NoneSymbName);
+    if (!aKeyVal)
+    {
+        name = tr (kNoneSymbName);
     }
     else
@@ -269 +377 @@
          * hand. */
         int scan;
-        switch (key)
+        switch (aKeyVal)
         {
             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;
-            default: scan = ::MapVirtualKey( key, 0 ) << 16;
+            default: scan = ::MapVirtualKey (aKeyVal, 0) << 16;
         }
         TCHAR *str = new TCHAR[256];
         if (::GetKeyNameText (scan, str, 256))
+        {
             name = QString::fromUcs2 (str);
+        }
         else
-            name = QString (tr ("<key_%1>")).arg (key);
+        {
+            AssertFailed();
+            name = QString (tr ("<key_%1>")).arg (aKeyVal);
+        }
         delete[] str;
+#elif defined (Q_WS_PM)
+        name = sKeyNames [aKeyVal];
+        if (name.isNull())
+        {
+            AssertFailed();
+            name = QString (tr ("<key_%1>")).arg (aKeyVal);
+        }
 #elif defined (Q_WS_X11)
-        char *sn = ::XKeysymToString( (KeySym) key );
+        char *sn = ::XKeysymToString ((KeySym) aKeyVal);
         if (sn)
         {
-            name = keyNames [sn];
+            name = sKeyNames [sn];
             if (name.isEmpty())
                 name = sn;
         }
         else
-            name = QString (tr ("<key_%1>")).arg (key);
+        {
+            AssertFailed();
+            name = QString (tr ("<key_%1>")).arg (aKeyVal);
+        }
 #elif defined(Q_WS_MAC)
-        UInt32 modMask = DarwinKeyCodeToDarwinModifierMask (key);
+        UInt32 modMask = DarwinKeyCodeToDarwinModifierMask (aKeyVal);
         switch (modMask)
         {
@@ -331 +454 @@
         }
 #else
-        name = QString ("<key_%1>").arg (key);
+        AssertFailed();
+        name = QString (tr ("<key_%1>")).arg (aKeyVal);
 #endif
     }
@@ -338 +462 @@
 }
 
-// static
-bool QIHotKeyEdit::isValidKey( int k )
+/* static */
+bool QIHotKeyEdit::isValidKey (int aKeyVal)
 {
 #if defined(Q_WS_WIN32)
     return (
-        (k >= VK_SHIFT && k <= VK_CAPITAL) ||
-        k == VK_PRINT ||
-        k == VK_LWIN || k == VK_RWIN ||
-        k == VK_APPS ||
-        (k >= VK_F1 && k <= VK_F24) ||
-        k == VK_NUMLOCK || k == VK_SCROLL ||
-        (k >= VK_LSHIFT && k <= VK_RMENU)
-    );
+        (aKeyVal >= VK_SHIFT && aKeyVal <= VK_CAPITAL) ||
+        aKeyVal == VK_PRINT ||
+        aKeyVal == VK_LWIN || aKeyVal == VK_RWIN ||
+        aKeyVal == VK_APPS ||
+        (aKeyVal >= VK_F1 && aKeyVal <= VK_F24) ||
+        aKeyVal == VK_NUMLOCK || aKeyVal == VK_SCROLL ||
+        (aKeyVal >= VK_LSHIFT && aKeyVal <= VK_RMENU));
+#elif defined(Q_WS_PM)
+    return (
+        (aKeyVal >= VK_SHIFT && aKeyVal <= VK_CAPSLOCK) ||
+        aKeyVal == VK_PRINTSCRN ||
+        (aKeyVal >= VK_F1 && aKeyVal <= VK_F24) ||
+        aKeyVal == VK_NUMLOCK || aKeyVal == VK_SCRLLOCK ||
+        (aKeyVal >= VK_LSHIFT && aKeyVal <= VK_BACKWARD));
 #elif defined(Q_WS_X11)
-    KeySym ks = (KeySym) k;
+    KeySym ks = (KeySym) aKeyVal;
     return
         (
@@ -359 +489 @@
         ) && (
             ks == XK_Scroll_Lock ||
-            IsModifierKey( ks ) ||
-            IsFunctionKey( ks ) ||
-            IsMiscFunctionKey( ks )
+            IsModifierKey (ks) ||
+            IsFunctionKey (ks) ||
+            IsMiscFunctionKey (ks)
         );
 #elif defined(Q_WS_MAC)
-    UInt32 modMask = ::DarwinKeyCodeToDarwinModifierMask( k );
-    switch ( modMask ) {
+    UInt32 modMask = ::DarwinKeyCodeToDarwinModifierMask (aKeyVal);
+    switch (modMask)
+    {
         case shiftKey:
         case optionKey:
@@ -379 +510 @@
     }
 #else
-    Q_UNUSED( k );
+    Q_UNUSED (aKeyVal);
     return true;
 #endif
@@ -389 +520 @@
 void QIHotKeyEdit::clear()
 {
-    keyval = 0;
-    symbname = tr (NoneSymbName);
+    mKeyVal = 0;
+    mSymbName = tr (kNoneSymbName);
     updateText();
 }
@@ -400 +531 @@
 /////////////////////////////////////////////////////////////////////////////
 
-#if defined(Q_WS_WIN32)
-
-bool QIHotKeyEdit::winEvent( MSG *msg )
-{
-    if ( !(
-        msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN ||
-        msg->message == WM_KEYUP || msg->message == WM_SYSKEYUP ||
-        msg->message == WM_CHAR || msg->message == WM_SYSCHAR ||
-        msg->message == WM_DEADCHAR || msg->message == WM_SYSDEADCHAR ||
-        msg->message == WM_CONTEXTMENU
-    ) )
+#if defined (Q_WS_WIN32)
+
+bool QIHotKeyEdit::winEvent (MSG *msg)
+{
+    if (!(msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN ||
+          msg->message == WM_KEYUP || msg->message == WM_SYSKEYUP ||
+          msg->message == WM_CHAR || msg->message == WM_SYSCHAR ||
+          msg->message == WM_DEADCHAR || msg->message == WM_SYSDEADCHAR ||
+          msg->message == WM_CONTEXTMENU))
         return false;
 
-    // ignore if not valid hot key
-    if ( !isValidKey( msg->wParam ) )
+    /* ignore if not a valid hot key */
+    if (!isValidKey (msg->wParam))
         return false;
 
-//    V_DEBUG((
-//        "%WM_%04X: vk=%04X rep=%05d scan=%02X ext=%01d rzv=%01X ctx=%01d prev=%01d tran=%01d",
-//        msg->message, msg->wParam,
-//        (msg->lParam & 0xFFFF),
-//        ((msg->lParam >> 16) & 0xFF),
-//        ((msg->lParam >> 24) & 0x1),
-//        ((msg->lParam >> 25) & 0xF),
-//        ((msg->lParam >> 29) & 0x1),
-//        ((msg->lParam >> 30) & 0x1),
-//        ((msg->lParam >> 31) & 0x1)
-//    ));
-
-    if ( msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN) {
-        // determine platform-dependent key
-        keyval = qi_distinguish_modifier_vkey( msg->wParam );
-        // determine symbolic name
-        TCHAR *str = new TCHAR[256];
-        if ( ::GetKeyNameText( msg->lParam, str, 256 ) )
-            symbname = QString::fromUcs2( str );
+#if 0
+    LogFlow (("%WM_%04X: vk=%04X rep=%05d scan=%02X ext=%01d"
+              "rzv=%01X ctx=%01d prev=%01d tran=%01d\n",
+              msg->message, msg->wParam,
+              (msg->lParam & 0xFFFF),
+              ((msg->lParam >> 16) & 0xFF),
+              ((msg->lParam >> 24) & 0x1),
+              ((msg->lParam >> 25) & 0xF),
+              ((msg->lParam >> 29) & 0x1),
+              ((msg->lParam >> 30) & 0x1),
+              ((msg->lParam >> 31) & 0x1)));
+#endif
+
+    if (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN)
+    {
+        /* determine platform-dependent key */
+        mKeyVal = qi_distinguish_modifier_vkey (msg->wParam);
+        /* determine symbolic name */
+        TCHAR *str = new TCHAR [256];
+        if (::GetKeyNameText (msg->lParam, str, 256))
+        {
+            mSymbName = QString::fromUcs2 (str);
+        }
         else
-            symbname = QString( "<key_%1>" ).arg( keyval );
+        {
+            AssertFailed();
+            mSymbName = QString (tr ("<key_%1>")).arg (mKeyVal);
+        }
         delete[] str;
-        // update the display
+        /* update the display */
         updateText();
     }
@@ -446 +582 @@
 }
 
-#elif defined(Q_WS_X11)
-
-bool QIHotKeyEdit::x11Event( XEvent *event )
-{
-    switch ( event->type ) {
+#elif defined (Q_WS_PM)
+
+bool QIHotKeyEdit::pmEvent (QMSG *aMsg)
+{
+    if (aMsg->msg != WM_CHAR)
+        return false;
+
+    USHORT f = SHORT1FROMMP (aMsg->mp1);
+
+    int vkey = QIHotKeyEdit::virtualKey (aMsg);
+
+    /* ignore if not a valid hot key */
+    if (!isValidKey (vkey))
+        return false;
+
+    if (!(f & KC_KEYUP))
+    {
+        /* determine platform-dependent key */
+        mKeyVal = vkey;
+        /* determine symbolic name */
+        mSymbName = QIHotKeyEdit::keyName (mKeyVal);
+        /* update the display */
+        updateText();
+    }
+
+    return true;
+}
+
+#elif defined (Q_WS_X11)
+
+bool QIHotKeyEdit::x11Event (XEvent *event)
+{
+    switch (event->type)
+    {
         case XKeyPress:
-        case XKeyRelease: {
+        case XKeyRelease:
+        {
             XKeyEvent *ke = (XKeyEvent *) event;
-            KeySym ks = ::XKeycodeToKeysym( ke->display, ke->keycode, 0 );
-            // ignore if not valid hot key
-            if ( !isValidKey( (int) ks ) )
+            KeySym ks = ::XKeycodeToKeysym (ke->display, ke->keycode, 0);
+            /* ignore if not a valid hot key */
+            if (!isValidKey ((int) ks))
                 return false;
 
-            // skip key releases
-            if ( event->type == XKeyRelease )
+            /* skip key releases */
+            if (event->type == XKeyRelease)
                 return true;
 
-            // determine platform-dependent key
-            keyval = (int) ks;
-            // determine symbolic name
-            char *name = ::XKeysymToString( ks );
-            if ( name )
-            {
-                if ( keyNames.contains(name) )
-                    symbname = keyNames[name];
-                else
-                    symbname = name;
-            }
-            else
-                symbname = QString( tr ("<key_%1>") ).arg( (int) ks );
-            // update the display
+            /* determine platform-dependent key */
+            mKeyVal = (int) ks;
+            /* determine symbolic name */
+            mSymbName = QIHotKeyEdit::keyName (mKeyVal);
+            /* update the display */
             updateText();
-//V_DEBUG((
-//    "%s: state=%08X keycode=%08X keysym=%08X symb=%s",
-//    event->type == XKeyPress ? "XKeyPress" : "XKeyRelease",
-//    ke->state, ke->keycode, ks,
-//    symbname.latin1()
-//));
+#if 0
+            LogFlow (("%s: state=%08X keycode=%08X keysym=%08X symb=%s\n",
+                      event->type == XKeyPress ? "XKeyPress" : "XKeyRelease",
+                      ke->state, ke->keycode, ks,
+                      symbname.latin1()));
+#endif
             return true;
         }
@@ -491 +648 @@
 }
 
-#elif defined(Q_WS_MAC)
+#elif defined (Q_WS_MAC)
 
 /* static */
-pascal OSStatus QIHotKeyEdit::darwinEventHandlerProc( EventHandlerCallRef inHandlerCallRef,
-                                                      EventRef inEvent, void *inUserData )
-{
-    QIHotKeyEdit *edit = (QIHotKeyEdit *)inUserData;
-    UInt32 EventClass = ::GetEventClass( inEvent );
+pascal OSStatus QIHotKeyEdit::darwinEventHandlerProc (EventHandlerCallRef inHandlerCallRef,
+                                                      EventRef inEvent, void *inUserData)
+{
+    QIHotKeyEdit *edit = (QIHotKeyEdit *) inUserData;
+    UInt32 EventClass = ::GetEventClass (inEvent);
     if (EventClass == kEventClassKeyboard)
     {
-        if (edit->darwinKeyboardEvent( inEvent ))
+        if (edit->darwinKeyboardEvent (inEvent))
             return 0;
     }
@@ -507 +664 @@
 }
 
-bool QIHotKeyEdit::darwinKeyboardEvent( EventRef inEvent )
+bool QIHotKeyEdit::darwinKeyboardEvent (EventRef inEvent)
 {
     /* ignore key changes unless we're the focus widget */
@@ -513 +670 @@
         return false;
 
-    UInt32 eventKind = ::GetEventKind( inEvent );
-    switch ( eventKind ) {
+    UInt32 eventKind = ::GetEventKind (inEvent);
+    switch (eventKind)
+    {
         /*case kEventRawKeyDown:
         case kEventRawKeyUp:
         case kEventRawKeyRepeat:*/
-        case kEventRawKeyModifiersChanged: {
+        case kEventRawKeyModifiersChanged:
+        {
             UInt32 modifierMask = 0;
-            ::GetEventParameter( inEvent, kEventParamKeyModifiers, typeUInt32, NULL,
-                                 sizeof( modifierMask ), NULL, &modifierMask );
-
-            modifierMask = ::DarwinAdjustModifierMask(modifierMask);
-            UInt32 changed = m_darwinKeyModifiers ^ modifierMask;
-            m_darwinKeyModifiers = modifierMask;
-
-            // skip key releases
-            if ( changed && ( changed & modifierMask ) )
+            ::GetEventParameter (inEvent, kEventParamKeyModifiers, typeUInt32, NULL,
+                                 sizeof (modifierMask), NULL, &modifierMask);
+
+            modifierMask = ::DarwinAdjustModifierMask (modifierMask);
+            UInt32 changed = mDarwinKeyModifiers ^ modifierMask;
+            mDarwinKeyModifiers = modifierMask;
+
+            /* skip key releases */
+            if (changed && (changed & modifierMask))
                 break;
 
-            // convert to keycode and skip keycodes we don't care about.
-            unsigned keyCode = ::DarwinModifierMaskToDarwinKeycode( changed );
-            if ( !keyCode || keyCode == ~0U || !isValidKey( keyCode ) )
+            /* 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.
-            keyval = keyCode;
-            symbname = QIHotKeyEdit::keyName( keyCode );
+            /* update key current key. */
+            mKeyVal = keyCode;
+            mSymbName = QIHotKeyEdit::keyName (keyCode);
             updateText();
             break; //return true;
@@ -551 +710 @@
 #endif
 
-void QIHotKeyEdit::focusInEvent( QFocusEvent * ) {
+void QIHotKeyEdit::focusInEvent (QFocusEvent *)
+{
     QPalette p = palette();
-    p.setActive( true_acg );
-    setPalette( p );
-}
-
-void QIHotKeyEdit::focusOutEvent( QFocusEvent * ) {
+    p.setActive (mTrueACG);
+    setPalette (p);
+}
+
+void QIHotKeyEdit::focusOutEvent (QFocusEvent *)
+{
     QPalette p = palette();
-    p.setActive( p.inactive() );
-    setPalette( p );
-}
-
-void QIHotKeyEdit::drawContents( QPainter * p )
-{
-    QLabel::drawContents( p );
-    if ( hasFocus() ) {
-        style().drawPrimitive(
+    p.setActive (p.inactive());
+    setPalette (p);
+}
+
+void QIHotKeyEdit::drawContents (QPainter * p)
+{
+    QLabel::drawContents (p);
+    if (hasFocus())
+    {
+        style().drawPrimitive (
             QStyle::PE_FocusRect, p, contentsRect(), colorGroup(),
             QStyle::Style_Default,
-            QStyleOption( colorGroup().background() )
-        );
+            QStyleOption( colorGroup().background()));
     }
 }
@@ -580 +741 @@
 void QIHotKeyEdit::updateText()
 {
-    setText( QString( " %1 " ).arg( symbname ) );
-}
-
+    setText (QString (" %1 ").arg (mSymbName));
+}

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

@@ -6 +6 @@
 
 /*
- * Copyright (C) 2006-2007 innotek GmbH
+ * Copyright (C) 22006-2007 innotek GmbH
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -23 +23 @@
 #include "VBoxGlobal.h"
 #include "VBoxProblemReporter.h"
+
+#ifdef Q_WS_PM
+#include "QIHotKeyEdit.h"
+#endif
 
 #include <qapplication.h>
@@ -993 +997 @@
             case QEvent::FocusOut:
             {
-                focusEvent (false);
+                if (isRunning())
+                    focusEvent (false);
                 break;
             }
@@ -1503 +1508 @@
  * Get Win32 messages before they are passed to Qt. This allows us to get
  * the keyboard events directly and bypass the harmful Qt translation. A
- * return value of TRUE indicates to Qt that the event has been handled.
+ * return value of @c true indicates to Qt that the event has been handled.
  */
 bool VBoxConsoleView::winEvent (MSG *msg)
@@ -1518 +1523 @@
 
 #if 0
-    LogFlow (("*** WM_%04X: vk=%04X rep=%05d scan=%02X ext=%01d rzv=%01X ctx=%01d prev=%01d tran=%01d",
-              msg->message, msg->wParam,
-              (msg->lParam & 0xFFFF),
-              ((msg->lParam >> 16) & 0xFF),
-              ((msg->lParam >> 24) & 0x1),
-              ((msg->lParam >> 25) & 0xF),
-              ((msg->lParam >> 29) & 0x1),
-              ((msg->lParam >> 30) & 0x1),
-              ((msg->lParam >> 31) & 0x1)));
     char buf [256];
     sprintf (buf, "WM_%04X: vk=%04X rep=%05d scan=%02X ext=%01d rzv=%01X ctx=%01d prev=%01d tran=%01d",
@@ -1538 +1534 @@
              ((msg->lParam >> 31) & 0x1));
     mainwnd->statusBar()->message (buf);
+    LogFlow (("%s\n", buf));
 #endif
 
@@ -1604 +1601 @@
         ::SendMessage (msg->hwnd, msg->message,
                        msg->wParam, msg->lParam | (0x1 << 25));
+        return true;
+    }
+    return result;
+}
+
+#elif defined (Q_WS_PM)
+
+/**
+ *  Get PM messages before they are passed to Qt. This allows us to get
+ *  the keyboard events directly and bypass the harmful Qt translation. A
+ *  return value of @c true indicates to Qt that the event has been handled.
+ */
+bool VBoxConsoleView::pmEvent (QMSG *aMsg)
+{
+    if (!attached || aMsg->msg != WM_CHAR)
+        return false;
+
+    /* check for the special flag possibly set at the end of this function */
+    if (SHORT2FROMMP (aMsg->mp2) & 0x8000)
+        return false;
+
+#if 0
+    {
+        char buf [256];
+        sprintf (buf, "*** WM_CHAR: f=%04X rep=%03d scan=%02X ch=%04X vk=%04X",
+                 SHORT1FROMMP (aMsg->mp1), CHAR3FROMMP (aMsg->mp1),
+                 CHAR4FROMMP (aMsg->mp1), SHORT1FROMMP (aMsg->mp2),
+                 SHORT2FROMMP (aMsg->mp2));
+        mainwnd->statusBar()->message (buf);
+        LogFlow (("%s\n", buf));
+    }
+#endif
+
+    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 && kbd_captured)
+    {
+        /* 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, aMsg->msg,
+                      aMsg->mp1,
+                      MPFROM2SHORT (SHORT1FROMMP (aMsg->mp2),
+                                    SHORT2FROMMP (aMsg->mp2) | 0x8000));
         return true;
     }
@@ -1829 +1925 @@
 }
 
-#endif
+#endif // defined (Q_WS_WIN)
 
 //
@@ -1972 +2068 @@
  *  @return     true to consume the event and false to pass it to Qt
  */
-bool VBoxConsoleView::keyEvent (int key, uint8_t scan, int flags, wchar_t *aUniKey/* = NULL*/)
-{
-//    char bbbuf[256];
-//    sprintf (bbbuf,
-//             "key=%08X scan=%02X flags=%08X",
-//             key, scan, flags);
-//    ((QMainWindow*)mainwnd)->statusBar()->message (bbbuf);
-
-    const bool is_hostkey = key == gs.hostKey();
+bool VBoxConsoleView::keyEvent (int aKey, uint8_t aScan, int aFlags,
+                                wchar_t *aUniKey/* = NULL*/)
+{
+#if 0
+    {
+        char buf [256];
+        sprintf (buf, "aKey=%08X aScan=%02X aFlags=%08X",
+                 aKey, aScan, aFlags);
+        mainwnd->statusBar()->message (buf);
+    }
+#endif
+
+    const bool isHostKey = aKey == gs.hostKey();
 
     LONG buf [16];
     LONG *codes = buf;
     uint count = 0;
-    uint8_t what_pressed = 0;
-
-    if (!is_hostkey)
-    {
-        if (flags & KeyPrint)
+    uint8_t whatPressed = 0;
+
+    if (!isHostKey)
+    {
+        if (aFlags & KeyPrint)
         {
             static LONG PrintMake[] = { 0xE0, 0x2A, 0xE0, 0x37 };
             static LONG PrintBreak[] = { 0xE0, 0xB7, 0xE0, 0xAA };
-            if (flags & KeyPressed)
+            if (aFlags & KeyPressed)
             {
                 codes = PrintMake;
@@ -2004 +2104 @@
             }
         }
-        else if ((flags & (KeyPause | KeyPressed)) == (KeyPause | KeyPressed))
-        {
-            static LONG Pause[] = { 0xE1, 0x1D, 0x45, 0xE1, 0x9D, 0xC5 };
-            codes = Pause;
-            count = SIZEOF_ARRAY (Pause);
+        else if (aFlags & KeyPause)
+        {
+            if (aFlags & 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 (flags & 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.
+            if (aFlags & 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);
             }
 
-            // process the scancode and update the table of pressed keys
-            what_pressed = IsKeyPressed;
-
-            if (flags & KeyExtended)
+            /* process the scancode and update the table of pressed keys */
+            whatPressed = IsKeyPressed;
+
+            if (aFlags & KeyExtended)
             {
                 codes [count++] = 0xE0;
-                what_pressed = IsExtKeyPressed;
-            }
-
-            if (flags & KeyPressed)
-            {
-                codes [count++] = scan;
-                keys_pressed [scan] |= what_pressed;
+                whatPressed = IsExtKeyPressed;
+            }
+
+            if (aFlags & KeyPressed)
+            {
+                codes [count++] = aScan;
+                keys_pressed [aScan] |= whatPressed;
             }
             else
             {
-                // if we haven't got this key's press message, we ignore its release
-                if (!(keys_pressed [scan] & what_pressed))
+                /* if we haven't got this key's press message, we ignore its
+                 * release */
+                if (!(keys_pressed [aScan] & whatPressed))
                     return true;
-                codes [count++] = scan | 0x80;
-                keys_pressed [scan] &= ~what_pressed;
+                codes [count++] = aScan | 0x80;
+                keys_pressed [aScan] &= ~whatPressed;
             }
 
             if (kbd_captured)
-                keys_pressed [scan] |= IsKbdCaptured;
+                keys_pressed [aScan] |= IsKbdCaptured;
             else
-                keys_pressed [scan] &= ~IsKbdCaptured;
+                keys_pressed [aScan] &= ~IsKbdCaptured;
         }
     }
     else
     {
-        // currently this is used in winLowKeyboardEvent() only
+        /* currently this is used in winLowKeyboardEvent() only */
         hostkey_in_capture = kbd_captured;
     }
@@ -2058 +2167 @@
     int hotkey = 0;
 
-    // process the host key
-    if (flags & KeyPressed)
-    {
-        if (is_hostkey)
+    /* process the host key */
+    if (aFlags & KeyPressed)
+    {
+        if (isHostKey)
         {
             if (!hostkey_pressed)
@@ -2077 +2186 @@
                 if (hostkey_alone)
                 {
-                    hotkey = key;
+                    hotkey = aKey;
                     hostkey_alone = false;
                 }
@@ -2085 +2194 @@
     else
     {
-        if (is_hostkey)
+        if (isHostKey)
         {
             if (hostkey_pressed)
@@ -2118 +2227 @@
         }
     }
-    // emit the keyboard state change signal
+
+    /* emit the keyboard state change signal */
     if (emit_signal)
         emitKeyboardStateChanged();
 
-    // process HOST+<key> shortcuts. currently, <key> is limited to
-    // alphanumeric chars.
+    /* process HOST+<key> shortcuts. currently, <key> is limited to
+     * alphanumeric chars. */
     if (hotkey)
     {
@@ -2149 +2259 @@
         Display *display = x11Display();
         int keysyms_per_keycode = getKeysymsPerKeycode();
-        KeyCode kc = XKeysymToKeycode (display, key);
+        KeyCode kc = XKeysymToKeycode (display, aKey);
         // iterate over the first level (not shifted) keysyms in every group
         for (int i = 0; i < keysyms_per_keycode && !processed; i += 2)
@@ -2171 +2281 @@
                                        mainwnd->menuBar());
 
-        /* Don't consider the hot key as pressed since the guest never saw it. (probably a generic thing) */
-        keys_pressed [scan] &= ~what_pressed;
-#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.
+        /* Don't consider the hot key as pressed since the guest never saw
+         * it. (probably a generic thing) */
+        keys_pressed [aScan] &= ~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 (hostkey_pressed || is_hostkey || isPaused())
-    {
-        // grab the key from Qt and from VM if it's a host key,
-        // otherwise just pass it to Qt
-        return is_hostkey;
+    /* no more to do, if the host key is in action or the VM is paused */
+    if (hostkey_pressed || isHostKey || isPaused())
+    {
+        /* grab the key from Qt and from VM if it's a host key,
+         * otherwise just pass it to Qt */
+        return isHostKey;
     }
 
@@ -2193 +2304 @@
 
 #if defined (Q_WS_WIN32)
-    // send pending WM_PAINT events
+    /* send pending WM_PAINT events */
     ::UpdateWindow (viewport()->winId());
 #endif
 
-//    LogFlow (("*** Putting scan codes: "));
-//    for (unsigned i = 0; i < count; i++)
-//        LogFlow (("%02x ", codes [i]));
-//    LogFlow (("\n"));
+#if 0
+    {
+        char buf [256];
+        sprintf (buf, "*** SCANS: ");
+        for (uint i = 0; i < count; ++ i)
+            sprintf (buf + strlen (buf), "%02X ", codes [i]);
+        mainwnd->statusBar()->message (buf);
+        LogFlow (("%s\n", buf));
+    }
+#endif
 
     keyboard.PutScancodes (codes, count);
 
-    // grab the key from Qt
+    /* grab the key from Qt */
     return true;
 }
@@ -2225 +2342 @@
              aType, aPos.x(), aPos.y(), aButton, aState, aStateAfter,
              aWheelDelta, aWheelDir);
-    ((QMainWindow*)mainwnd)->statusBar()->message (buf);
+    mainwnd->statusBar()->message (buf);
 #else
     Q_UNUSED (aButton);

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

@@ -2138 +2138 @@
     detailReportTemplatesReady = false;
 
-#if defined (Q_WS_X11)
-    /* As X11 does not (to my knowledge) have functionality for providing
+#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. */

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

@@ -39 +39 @@
     hostkey = 0xA3; // VK_RCONTROL
 //    hostkey = 165; // VK_RMENU
+#elif defined (Q_WS_PM)
+    hostkey = VK_CTRL;
 #elif defined (Q_WS_X11)
     hostkey = 0xffe4; // XK_Control_R
@@ -56 +58 @@
 }
 
-VBoxGlobalSettingsData::VBoxGlobalSettingsData( const VBoxGlobalSettingsData &that ) {
+VBoxGlobalSettingsData::VBoxGlobalSettingsData (const VBoxGlobalSettingsData &that)
+{
     hostkey = that.hostkey;
     autoCapture = that.autoCapture;
@@ -67 +70 @@
 }
 
-bool VBoxGlobalSettingsData::operator==( const VBoxGlobalSettingsData &that ) const
-{
-    return this == &that || (
-        hostkey == that.hostkey &&
-        autoCapture == that.autoCapture &&
-        guiFeatures == that.guiFeatures &&
-        languageId  == that.languageId
-    );
+bool VBoxGlobalSettingsData::operator== (const VBoxGlobalSettingsData &that) const
+{
+    return this == &that ||
+        (hostkey == that.hostkey &&
+         autoCapture == that.autoCapture &&
+         guiFeatures == that.guiFeatures &&
+         languageId  == that.languageId);
 }
 
@@ -253 +255 @@
         if (ok)
         {
+            /* The individual setter may have set a specific error */
+            if (!last_err.isNull())
+                return;
+
             last_err = QString::null;
             emit propertyChanged (gPropertyMap [index].publicName,