Changeset 1285 in vbox

Timestamp:

Mar 7, 2007 5:34:38 AM (18 years ago)

Author:

vboxsync

Message:

Darwin: fixed the screen update issue and started implementing the keyboard stuff.

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• Makefile (modified) (2 diffs)
• include/QIHotKeyEdit.h (modified) (4 diffs)
• include/VBoxConsoleView.h (modified) (5 diffs)
• src/QIHotKeyEdit.cpp (modified) (5 diffs)
• src/VBoxConsoleView.cpp (modified) (10 diffs)
• src/VBoxConsoleWnd.cpp (modified) (1 diff)
• src/VBoxFrameBuffer.cpp (modified) (1 diff)
• src/VMGlobalSettings.cpp (modified) (1 diff)

trunk/src/VBox/Frontends/VirtualBox/Makefile

@@ -128 +128 @@
         src/linux/keyboard.c
 endif
+
+VirtualBox_SOURCES.darwin = \
+        src/darwin/DarwinKeyboard.cpp
 
 VirtualBox_DEFS           = VBOX_GUI_SEPARATE_VM_PROCESS
@@ -175 +178 @@
  endif
 endif
+VirtualBox_LDFLAGS.darwin = -framework IOKit
 VirtualBox_LIBS.win       = \
         $(PATH_SDK_WINPSDK_LIB)/Htmlhelp.Lib \

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

@@ -25 +25 @@
 
 #include <qlabel.h>
+#ifdef Q_WS_MAC
+#include <Carbon/Carbon.h>
+#endif
+
 
 class QIHotKeyEdit : public QLabel
@@ -33 +37 @@
 
     QIHotKeyEdit( QWidget * parent, const char * name = 0 );
+    virtual ~QIHotKeyEdit();
 
     void setKey( int keyval );
@@ -55 +60 @@
 #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
 
@@ -71 +80 @@
     QColorGroup true_acg;
 
+#if defined(Q_WS_MAC)
+    /** Event handler reference. NULL if the handler isn't installed. */
+    EventHandlerRef m_darwinEventHandlerRef;
+    /** The current modifier key mask. Used to figure out which modifier
+     *  key was pressed when we get a kEventRawKeyModifiersChanged event. */
+    UInt32 m_darwinKeyModifiers;
+#endif
+
     static const char *NoneSymbName;
 };

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

@@ -36 +36 @@
 #include <qkeysequence.h>
 
+#if defined (Q_WS_MAC)
+# include <Carbon/Carbon.h>
+#endif
+
 class VBoxConsoleWnd;
 class MousePointerChangeEvent;
@@ -103 +107 @@
 #elif defined(Q_WS_X11)
     bool x11Event (XEvent *event );
+#elif defined(Q_WS_MAC)
+    bool darwinKeyboardEvent (EventRef inEvent);
+    void darwinGrabKeyboardEvents (bool fGrab);
 #endif
 
@@ -116 +123 @@
 
     void focusEvent (bool focus);
-    bool keyEvent (int key, uint8_t scan, int flags);
+    bool keyEvent (int key, uint8_t scan, int flags, wchar_t *aUniKey = NULL);
     bool mouseEvent (int aType, const QPoint &aPos, const QPoint &aGlobalPos,
                      ButtonState aButton,
@@ -210 +217 @@
 #endif
 
+#if defined(Q_WS_MAC)
+    /** Event handler reference. NULL if the handler isn't installed. */
+    EventHandlerRef m_darwinEventHandlerRef;
+    /** The current modifier key mask. Used to figure out which modifier
+     *  key was pressed when we get a kEventRawKeyModifiersChanged event. */
+    UInt32 m_darwinKeyModifiers;
+#endif
+
 #if defined (VBOX_GUI_USE_REFRESH_TIMER)
     QPixmap pm;
@@ -223 +238 @@
     static LRESULT CALLBACK lowLevelKeyboardProc (int nCode,
                                                   WPARAM wParam, LPARAM lParam);
+#elif defined (Q_WS_MAC)
+    static pascal OSStatus darwinEventHandlerProc (EventHandlerCallRef inHandlerCallRef,
+                                                   EventRef inEvent, void *inUserData);
 #endif
 

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

@@ -62 +62 @@
 #endif
 
+#ifdef Q_WS_MAC
+#include "DarwinKeyboard.h"
+#endif
+
 
 #ifdef Q_WS_WIN32
@@ -129 +133 @@
     p.setActive( p.inactive() );
     setPalette( p );
+
+#ifdef Q_WS_MAC
+    m_darwinKeyModifiers = GetCurrentEventKeyModifiers();
+
+    EventTypeSpec eventTypes[4];
+    eventTypes[0].eventClass = kEventClassKeyboard;
+    eventTypes[0].eventKind  = kEventRawKeyDown;
+    eventTypes[1].eventClass = kEventClassKeyboard;
+    eventTypes[1].eventKind  = kEventRawKeyUp;
+    eventTypes[2].eventClass = kEventClassKeyboard;
+    eventTypes[2].eventKind  = kEventRawKeyRepeat;
+    eventTypes[3].eventClass = kEventClassKeyboard;
+    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
+
+}
+
+QIHotKeyEdit::~QIHotKeyEdit()
+{
+#ifdef Q_WS_MAC
+    ::DarwinReleaseKeyboard();
+    ::RemoveEventHandler( m_darwinEventHandlerRef );
+    m_darwinEventHandlerRef = NULL;
+#endif
 }
 
@@ -226 +263 @@
         else
             name = QString( "<key_%1>" ).arg( key );
+#elif defined(Q_WS_MAC)
+        UInt32 modMask = DarwinKeyCodeToDarwinModifierMask( key );
+        switch ( modMask ) {
+            case shiftKey:
+            case optionKey:
+            case controlKey:
+            case cmdKey:
+                name = tr("Left ");
+                break;
+            case rightShiftKey:
+            case rightOptionKey:
+            case rightControlKey:
+            case kEventKeyModifierRightCmdKeyMask:
+                name = tr("Right ");
+                break;
+            default:
+                AssertMsgFailedReturn(( "modMask=%#x\n", modMask ), QString());
+        }
+        switch ( modMask ) {
+            case shiftKey:
+            case rightShiftKey:
+                name += QChar( kShiftUnicode );
+                break;
+            case optionKey:
+            case rightOptionKey:
+                name += QChar( kOptionUnicode );
+                break;
+            case controlKey:
+            case rightControlKey:
+                name += QChar( kControlUnicode );
+                break;
+            case cmdKey:
+            case kEventKeyModifierRightCmdKeyMask:
+                name += QChar( kCommandUnicode );
+                break;
+        }
 #else
         name = QString( "<key_%1>" ).arg( key );
@@ -259 +332 @@
             IsMiscFunctionKey( ks )
         );
+#elif defined(Q_WS_MAC)
+    UInt32 modMask = ::DarwinKeyCodeToDarwinModifierMask( k );
+    switch ( modMask ) {
+        case shiftKey:
+        case optionKey:
+        case controlKey:
+        case rightShiftKey:
+        case rightOptionKey:
+        case rightControlKey:
+        case cmdKey:
+        case kEventKeyModifierRightCmdKeyMask:
+            return true;
+        default:
+            return false;
+    }
 #else
     Q_UNUSED( k );
@@ -367 +455 @@
 }
 
+#elif defined(Q_WS_MAC)
+
+/* static */
+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 ))
+            return 0;
+    }
+    return CallNextEventHandler (inHandlerCallRef, inEvent);
+}
+
+#ifdef DEBUG_bird
+# include <iprt/stream.h>
+#endif
+
+bool QIHotKeyEdit::darwinKeyboardEvent( EventRef inEvent )
+{
+    UInt32 eventKind = ::GetEventKind( inEvent );
+    switch ( eventKind ) {
+        /*case kEventRawKeyDown:
+        case kEventRawKeyUp:
+        case kEventRawKeyRepeat:*/
+        case kEventRawKeyModifiersChanged: {
+            UInt32 modifierMask = 0;
+            ::GetEventParameter( inEvent, kEventParamKeyModifiers, typeUInt32, NULL,
+                                 sizeof( modifierMask ), NULL, &modifierMask );
+
+            modifierMask = ::DarwinAdjustModifierMask(modifierMask);
+            UInt32 changed = m_darwinKeyModifiers ^ modifierMask;
+#ifdef DEBUG_bird
+RTPrintf("old=%04x new=%04x changed=%04x %04x %04x\n",
+         m_darwinKeyModifiers, modifierMask, changed, GetCurrentEventKeyModifiers(), GetCurrentKeyModifiers());
+#endif
+            m_darwinKeyModifiers = modifierMask;
+
+            // skip key releases
+            if ( changed && ( changed & modifierMask ) )
+                break;
+
+            // convert to keycode and skip keycodes we don't care about.
+            unsigned keyCode = ::DarwinModifierMaskToDarwinKeycode( changed );
+RTPrintf("keyCode=%#x valid=%d\n", keyCode, isValidKey( keyCode ));
+            if ( !keyCode || keyCode == ~0U || !isValidKey( keyCode ) )
+                break;
+
+            // update key current key.
+            keyval = keyCode;
+            symbname = QIHotKeyEdit::keyName( keyCode );
+            updateText();
+            break; //return true;
+        }
+        break;
+    }
+    return false;
+}
+
+#else
+# warning "Port me!"
 #endif
 

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

@@ -78 +78 @@
 #endif
 
+#if defined (Q_WS_MAC)
+# include "DarwinKeyboard.h"
+#endif /* defined (Q_WS_MAC) */
+
 #if defined (VBOX_GUI_USE_REFRESH_TIMER)
 enum { UPDATE_FREQ = 1000 / 60 }; // a-la 60Hz
@@ -99 +103 @@
 
 #endif
+
+#if defined (Q_WS_MAC)
+
+/**
+ *  Event handler callback for Mac OS X.
+ */
+/* static */
+pascal OSStatus VBoxConsoleView::darwinEventHandlerProc(EventHandlerCallRef inHandlerCallRef,
+                                                        EventRef inEvent, void *inUserData)
+{
+    VBoxConsoleView *view = (VBoxConsoleView *)inUserData;
+    UInt32 EventClass = ::GetEventClass (inEvent);
+    if (EventClass == kEventClassKeyboard)
+    {
+        if (    view->darwinKeyboardEvent (inEvent)
+            &&  ::GetEventKind (inEvent) != kEventRawKeyModifiersChanged)
+            return 0;
+    }
+    return CallNextEventHandler (inHandlerCallRef, inEvent);
+}
+
+#endif /* Q_WS_MAC */
 
 /** Guest mouse pointer shape change event. */
@@ -358 +384 @@
     , mAlphaCursor (NULL)
 #endif
+#if defined(Q_WS_MAC)
+    , m_darwinEventHandlerRef (NULL)
+    , m_darwinKeyModifiers (0)
+#endif
 {
     Assert (!cconsole.isNull() &&
@@ -752 +782 @@
                 return true;
             }
-/// @todo (dmik) not currently used, but may become necessary later
-//            case VBoxDefs::RepaintEventType: {
-//                VBoxRepaintEvent *re = (VBoxRepaintEvent *) e;
-//                viewport()->repaint (re->x(), re->y(), re->width(), re->height(), false);
-//                cconsole.GetDisplay().UpdateCompleted();
-//                return true;
-//            }
+
+#ifdef Q_WS_MAC /* see VBoxQImageFrameBuffer::NotifyUpdate. */
+            case VBoxDefs::RepaintEventType:
+            {
+                VBoxRepaintEvent *re = (VBoxRepaintEvent *) e;
+                viewport()->repaint (re->x(), re->y(), re->width(), re->height(), false);
+                /*cconsole.GetDisplay().UpdateCompleted(); - the event was acked already */
+                return true;
+            }
+#endif /* Q_WS_MAC */
 
             case VBoxDefs::MousePointerChangeEventType:
@@ -983 +1016 @@
                 break;
             }
-#endif
+#endif /* defined (Q_WS_WIN32) */
+#if defined (Q_WS_MAC)
+            /*
+             *  Install/remove the keyboard event handler.
+             */
+            case QEvent::WindowActivate:
+                darwinGrabKeyboardEvents (true);
+                break;
+            case QEvent::WindowDeactivate:
+                darwinGrabKeyboardEvents (false);
+                break;
+#endif /* defined (Q_WS_MAC) */
             case QEvent::Resize:
             {
@@ -1282 +1326 @@
 }
 
+#elif defined (Q_WS_MAC)
+
+/**
+ *  Invoked by VBoxConsoleView::darwinEventHandlerProc when it gets a raw keyboard event.
+ *
+ *  @param inEvent      The keyboard event.
+ *
+ *  @return true if the key was processed, false if it wasn't processed and should be passed on.
+ */
+bool VBoxConsoleView::darwinKeyboardEvent (EventRef inEvent)
+{
+    bool ret = false;
+    UInt32 EventKind = ::GetEventKind (inEvent);
+    if (EventKind != kEventRawKeyModifiersChanged)
+    {
+        /* convert keycode to set 1 scan code. */
+        UInt32 keyCode = ~0U;
+        ::GetEventParameter (inEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof(keyCode), NULL, &keyCode);
+        unsigned scanCode = ::DarwinKeycodeToSet1Scancode (keyCode);
+        if (scanCode)
+        {
+            /* calc flags. */
+            int flags = 0;
+            UInt32 EventKind = ::GetEventKind (inEvent);
+            if (EventKind == kEventRawKeyDown)
+                flags |= KeyPressed;
+            if (scanCode & 0x8000) /* modifiers */
+            {
+                flags |= KeyPressed;
+                scanCode &= ~0x8000;
+            }
+            if (scanCode & 0x80)
+            {
+                flags |= KeyExtended;
+                scanCode &= ~0x80;
+            }
+            /** @todo KeyPause, KeyPrint. */
+
+            /* get the keycode and unicode string (if present). */
+            UInt32 keyCode = ~0;
+            ::GetEventParameter (inEvent, kEventParamKeyCode, typeUInt32, NULL,
+                                 sizeof (keyCode), NULL, &keyCode);
+            AssertCompileSize(wchar_t, 2);
+            AssertCompileSize(UniChar, 2);
+            wchar_t ucs[32];
+            if (::GetEventParameter (inEvent, kEventParamKeyUnicodes, typeUnicodeText, NULL,
+                                     sizeof (ucs), NULL, &ucs[0]) != 0)
+                ucs[0] = 0;
+
+            ret = keyEvent (keyCode, scanCode, flags, ucs[0] ? ucs : NULL);
+        }
+    }
+    else
+    {
+        /* May contain multiple modifier changes, kind of annoying. */
+        UInt32 newMask = 0;
+        ::GetEventParameter (inEvent, kEventParamKeyModifiers, typeUInt32, NULL,
+                             sizeof (newMask), NULL, &newMask);
+        UInt32 changed = newMask ^ m_darwinKeyModifiers;
+        if (changed)
+        {
+            for (Uint32 bit = 0; bit < 32; bit++)
+            {
+                if (!(changed & (1 << bit)))
+                    continue;
+                unsigned scanCode = ::DarwinModifierMaskToSet1Scancode (1 << bit);
+                if (!scanCode)
+                    continue;
+
+                unsigned flags = (newMask & (1 << bit)) ? KeyPressed : 0;
+                if (scanCode & 0x80)
+                {
+                    flags |= KeyExtended;
+                    scanCode &= ~0x80;
+                }
+                keyEvent (0, scanCode, flags);
+            }
+        }
+
+        m_darwinKeyModifiers = newMask;
+
+        /* ret is intentionally false. */
+    }
+
+    return ret;
+}
+
+
+/**
+ * Installs or removes the keyboard event handler.
+ *
+ * @param   fGrab    True if we're to grab the events, false if we're not to.
+ */
+void VBoxConsoleView::darwinGrabKeyboardEvents (bool fGrab)
+{
+    if (fGrab)
+    {
+        ::SetMouseCoalescingEnabled (false, NULL);      //??
+        ::CGSetLocalEventsSuppressionInterval (0.0);    //??
+
+        EventTypeSpec eventTypes[4];
+        eventTypes[0].eventClass = kEventClassKeyboard;
+        eventTypes[0].eventKind  = kEventRawKeyDown;
+        eventTypes[1].eventClass = kEventClassKeyboard;
+        eventTypes[1].eventKind  = kEventRawKeyUp;
+        eventTypes[2].eventClass = kEventClassKeyboard;
+        eventTypes[2].eventKind  = kEventRawKeyRepeat;
+        eventTypes[3].eventClass = kEventClassKeyboard;
+        eventTypes[3].eventKind  = kEventRawKeyModifiersChanged;
+
+        EventHandlerUPP eventHandler = ::NewEventHandlerUPP (VBoxConsoleView::darwinEventHandlerProc);
+
+        m_darwinEventHandlerRef = NULL;
+        ::InstallApplicationEventHandler (eventHandler, RT_ELEMENTS (eventTypes), &eventTypes[0],
+                                          this, &m_darwinEventHandlerRef);
+        ::DisposeEventHandlerUPP (eventHandler);
+    }
+    else if (m_darwinEventHandlerRef)
+    {
+        ::RemoveEventHandler (m_darwinEventHandlerRef);
+        m_darwinEventHandlerRef = NULL;
+    }
+}
+
 #endif
 
@@ -1396 +1564 @@
  *  @scan       hardware scan code
  *  @flags      flags, a combination of Key* constants
+ *  @aUniKey    Unicode translation of the key. Optional.
  *
  *  @return     true to consume the event and false to pass it to Qt
  */
-bool VBoxConsoleView::keyEvent (int key, uint8_t scan, int flags)
+bool VBoxConsoleView::keyEvent (int key, uint8_t scan, int flags, wchar_t *aUniKey/* = NULL*/)
 {
 //    char bbbuf[256];
@@ -1589 +1758 @@
             }
         }
+#elif defined (Q_WS_MAC)
+        if (aUniKey && aUniKey[0] && !aUniKey[1])
+            processed = processHotKey (QKeySequence (UNICODE_ACCEL +
+                                            QChar (aUniKey [0]).upper().unicode()),
+                                       mainwnd->menuBar());
 #endif
         // grab the key from Qt if processed, or pass it to Qt otherwise
@@ -1959 +2133 @@
      * by QWidget::grabKeyboard()) because the latter causes problems under
      * metacity 2.16 (in particular, due to a bug, a window cannot be moved
-     * using the mouse if it is currently grabing the keyboard). */
+     * using the mouse if it is currently grabing the keyboard). On Mac OS X,
+     * we use the Qt methods + disabling global hot keys + watching modifiers
+     * (for right/left separation). */
 #if defined (Q_WS_WIN32)
     /**/
@@ -1970 +2146 @@
                 XUngrabKey (x11Display(),  AnyKey, AnyModifier,
                     topLevelWidget()->winId());
+#elif defined (Q_WS_MAC)
+    if (capture)
+    {
+        grabKeyboard();
+        ::DarwinGrabKeyboard (true);
+    }
+    else
+    {
+        ::DarwinReleaseKeyboard();
+        releaseKeyboard();
+    }
 #else
     if (capture)

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

@@ -999 +999 @@
                         /*
                          *  set success to true even if we fail to discard the
-                         *  current state later -- the conosle window will be
+                         *  current state later -- the console window will be
                          *  closed anyway
                          */

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

@@ -253 +253 @@
                                                   BOOL *aFinished)
 {
+#ifdef Q_WS_MAC
+    /* we're not on the GUI thread and update() isn't thread safe on Qt 3.3.x
+       on the Mac (4.2.x is), so post the event instead.  */
+    QApplication::postEvent (mView,
+                             new VBoxRepaintEvent (aX, aY, aW, aH));
+
+#else /* !Q_WS_MAC */
     /* we're not on the GUI thread, so update() instead of repaint()! */
     mView->viewport()->update (aX - mView->contentsX(),
                                aY - mView->contentsY(),
                                aW, aH);
+#endif /* !Q_WS_MAC */
     /* the update has been finished, return TRUE */
     *aFinished = TRUE;

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

@@ -46 +46 @@
     hostkey = 0xffe4; // XK_Control_R
 //    hostkey = 65514; // XK_Alt_R
+#elif defined (Q_WS_MAC)
+    hostkey = 0x36; // QZ_RMETA
+//    hostkey = 0x3e; // QZ_RCTRL
+//    hostkey = 0x3d; // QZ_RALT
 #else
+# warning "port me!"
     hostkey = 0;
 #endif