Changeset 26834 in vbox for trunk/src/VBox/Frontends/VBoxBFE

Timestamp:

Feb 26, 2010 12:10:36 PM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

58109

Message:

FE/BFE: resynchronise MouseImpl from Main

Location:

trunk/src/VBox/Frontends/VBoxBFE

Files:

• COMDefs.h (modified) (1 diff)
• ConsoleImpl.h (modified) (2 diffs)
• MouseImpl.cpp (modified) (12 diffs)
• MouseImpl.h (modified) (3 diffs)
• SDLConsole.cpp (modified) (9 diffs)
• VBoxBFE.cpp (modified) (3 diffs)
• VMMDevInterface.cpp (modified) (1 diff)

trunk/src/VBox/Frontends/VBoxBFE/COMDefs.h

@@ -61 +61 @@
 # define E_UNEXPECTED   ((unsigned long) 0x8000ffffL)
 # define E_INVALIDARG   ((unsigned long) 0x80070057L)
+#define E_ACCESSDENIED  ((unsigned long) 0x80070005L)
+#define VBOX_E_IPRT_ERROR ((unsigned long) 0x80BB0005L)
 
 # if ! defined(FALSE)

trunk/src/VBox/Frontends/VBoxBFE/ConsoleImpl.h

@@ -23 +23 @@
 #ifndef ____H_CONSOLEIMPL
 #define ____H_CONSOLEIMPL
+
+#include <VBox/types.h>
 
 /*
@@ -100 +102 @@
 } CONEVENT;
 
+/**
+ *  Checks the availability of the underlying VM device driver corresponding
+ *  to the COM interface (IKeyboard, IMouse, IDisplay, etc.). When the driver is
+ *  not available (NULL), sets error info and returns returns E_ACCESSDENIED.
+ *  The translatable error message is defined in null context.
+ *
+ *  Intended to used only within Console children (i.e. Keyboard, Mouse,
+ *  Display, etc.).
+ *
+ *  @param drv  driver pointer to check (compare it with NULL)
+ */
+#define CHECK_CONSOLE_DRV(drv) \
+    do { \
+        if (!(drv)) \
+            return setError(E_ACCESSDENIED, tr("The console is not powered up")); \
+    } while (0)
+
 class Console
 {

trunk/src/VBox/Frontends/VBoxBFE/MouseImpl.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * VBox frontends: Basic Frontend (BFE):
- * Implementation of Mouse class
+ * VirtualBox VBoxBFE/COM class implementation
  */
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -21 +20 @@
  */
 
-#ifdef VBOXBFE_WITHOUT_COM
-# include "COMDefs.h"
-#else
-# include <VBox/com/defs.h>
-#endif
-#include <VBox/pdm.h>
-#include <VBox/cfgm.h>
-#include <VBox/err.h>
-#include <iprt/assert.h>
-#include <VBox/log.h>
-#include <iprt/asm.h>
-#include <iprt/uuid.h>
-#include <VBox/VMMDev.h>
 #include "MouseImpl.h"
 #include "DisplayImpl.h"
-#include "VMMDevInterface.h"
+#ifdef VBOXBFE_WITHOUT_COM
+# include "VMMDevInterface.h"
+# include <iprt/uuid.h>
+class AutoInitSpan
+{
+public:
+    AutoInitSpan(VirtualBoxBase *) {}
+    bool isOk() { return true; }
+    void setSucceeded() {}
+};
+
+class AutoUninitSpan
+{
+public:
+    AutoUninitSpan(VirtualBoxBase *) {}
+    bool uninitDone() { return false; }
+};
+
+class AutoCaller
+{
+public:
+    AutoCaller(VirtualBoxBase *) {}
+    int rc() { return S_OK; }
+};
+
+class AutoWriteLock
+{
+public:
+    AutoWriteLock(VirtualBoxBase *) {}
+};
+#define COMMA_LOCKVAL_SRC_POS
+enum
+{
+    MouseButtonState_LeftButton = 1,
+    MouseButtonState_RightButton = 2,
+    MouseButtonState_MiddleButton = 4,
+    MouseButtonState_XButton1 = 8,
+    MouseButtonState_XButton2 = 16,
+};
+#else
+# include "VMMDev.h"
+
+# include "AutoCaller.h"
+#endif
+#include "Logging.h"
+
+#include <VBox/pdmdrv.h>
+#include <iprt/asm.h>
+#include <VBox/VMMDev.h>
 
 /**
@@ -43 +77 @@
 typedef struct DRVMAINMOUSE
 {
-    /** Pointer to the associated mouse driver. */
-    Mouse                      *mpDrv;
+    /** Pointer to the mouse object. */
+    Mouse                      *pMouse;
     /** Pointer to the driver instance structure. */
     PPDMDRVINS                  pDrvIns;
@@ -50 +84 @@
     PPDMIMOUSEPORT              pUpPort;
     /** Our mouse connector interface. */
-    PDMIMOUSECONNECTOR          Connector;
+    PDMIMOUSECONNECTOR          IConnector;
 } DRVMAINMOUSE, *PDRVMAINMOUSE;
 
+
+// constructor / destructor
+/////////////////////////////////////////////////////////////////////////////
+
+DEFINE_EMPTY_CTOR_DTOR (Mouse)
+
+HRESULT Mouse::FinalConstruct()
+{
+    mpDrv = NULL;
+    uDevCaps = MOUSE_DEVCAP_RELATIVE;
+    fVMMDevCanAbs = false;
+    fVMMDevNeedsHostCursor = false;
+    mLastAbsX = 0x8000;
+    mLastAbsY = 0x8000;
+    mLastButtons = 0;
+    return S_OK;
+}
+
+void Mouse::FinalRelease()
+{
+    uninit();
+}
+
+// public methods only for internal purposes
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Initializes the mouse object.
+ *
+ * @returns COM result indicator
+ * @param parent handle of our parent object
+ */
+HRESULT Mouse::init (Console *parent)
+{
+    LogFlowThisFunc(("\n"));
+
+    ComAssertRet(parent, E_INVALIDARG);
+
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan(this);
+    AssertReturn(autoInitSpan.isOk(), E_FAIL);
+
+#ifdef VBOXBFE_WITHOUT_COM
+    mParent = parent;
+#else
+    unconst(mParent) = parent;
+#endif
+
+#ifdef RT_OS_L4
+    /* L4 console has no own mouse cursor */
+    uHostCaps = VMMDEV_MOUSE_HOST_CANNOT_HWPOINTER;
+#else
+    uHostCaps = 0;
+#endif
+    uDevCaps = 0;
+
+    /* Confirm a successful initialization */
+    autoInitSpan.setSucceeded();
+
+    return S_OK;
+}
+
+/**
+ *  Uninitializes the instance and sets the ready flag to FALSE.
+ *  Called either from FinalRelease() or by the parent when it gets destroyed.
+ */
+void Mouse::uninit()
+{
+    LogFlowThisFunc(("\n"));
+
+    /* Enclose the state transition Ready->InUninit->NotReady */
+    AutoUninitSpan autoUninitSpan(this);
+    if (autoUninitSpan.uninitDone())
+        return;
+
+    if (mpDrv)
+        mpDrv->pMouse = NULL;
+    mpDrv = NULL;
+
+#ifdef VBOXBFE_WITHOUT_COM
+    mParent = NULL;
+#else
+    unconst(mParent).setNull();
+#endif
+}
+
+
+// IMouse properties
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef VBOXBFE_WITHOUT_COM
+int Mouse::getVMMDevMouseCaps(uint32_t *pfCaps)
+{
+    gVMMDev->QueryMouseCapabilities(pfCaps);
+    return S_OK;
+}
+
+int Mouse::setVMMDevMouseCaps(uint32_t fCaps)
+{
+    gVMMDev->SetMouseCapabilities(fCaps);
+    return S_OK;
+}
+#else
+int Mouse::getVMMDevMouseCaps(uint32_t *pfCaps)
+{
+    AssertPtrReturn(pfCaps, E_POINTER);
+    VMMDev *pVMMDev = mParent->getVMMDev();
+    ComAssertRet(pVMMDev, E_FAIL);
+    PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
+    ComAssertRet(pVMMDevPort, E_FAIL);
+
+    int rc = pVMMDevPort->pfnQueryMouseCapabilities(pVMMDevPort, pfCaps);
+    return RT_SUCCESS(rc) ? S_OK : E_FAIL;
+}
+
+int Mouse::setVMMDevMouseCaps(uint32_t fCaps)
+{
+    VMMDev *pVMMDev = mParent->getVMMDev();
+    ComAssertRet(pVMMDev, E_FAIL);
+    PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
+    ComAssertRet(pVMMDevPort, E_FAIL);
+
+    int rc = pVMMDevPort->pfnSetMouseCapabilities(pVMMDevPort, fCaps);
+    return RT_SUCCESS(rc) ? S_OK : E_FAIL;
+}
+#endif /* !VBOXBFE_WITHOUT_COM */
+
+/**
+ * Returns whether the current setup can accept absolute mouse
+ * events.
+ *
+ * @returns COM status code
+ * @param absoluteSupported address of result variable
+ */
+STDMETHODIMP Mouse::COMGETTER(AbsoluteSupported) (BOOL *absoluteSupported)
+{
+    if (!absoluteSupported)
+        return E_POINTER;
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    CHECK_CONSOLE_DRV (mpDrv);
+
+    if (uDevCaps & MOUSE_DEVCAP_ABSOLUTE)
+        *absoluteSupported = TRUE;
+    else
+        *absoluteSupported = fVMMDevCanAbs;
+
+    return S_OK;
+}
+
+/**
+ * Returns whether the current setup can accept relative mouse
+ * events.
+ *
+ * @returns COM status code
+ * @param relativeSupported address of result variable
+ */
+STDMETHODIMP Mouse::COMGETTER(RelativeSupported) (BOOL *relativeSupported)
+{
+    if (!relativeSupported)
+        return E_POINTER;
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    CHECK_CONSOLE_DRV (mpDrv);
+
+    if (uDevCaps & MOUSE_DEVCAP_RELATIVE)
+        *relativeSupported = TRUE;
+
+    return S_OK;
+}
+
+/**
+ * Returns whether the guest can currently draw the mouse cursor itself.
+ *
+ * @returns COM status code
+ * @param pfNeedsHostCursor address of result variable
+ */
+STDMETHODIMP Mouse::COMGETTER(NeedsHostCursor) (BOOL *pfNeedsHostCursor)
+{
+    if (!pfNeedsHostCursor)
+        return E_POINTER;
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    CHECK_CONSOLE_DRV (mpDrv);
+
+    *pfNeedsHostCursor = fVMMDevNeedsHostCursor;
+    return S_OK;
+}
 
 // IMouse methods
 /////////////////////////////////////////////////////////////////////////////
 
-int Mouse::setAbsoluteCoordinates(bool a_fAbsolute)
-{
-    this->fAbsolute = a_fAbsolute;
-    return S_OK;
-}
-
-int Mouse::setNeedsHostCursor(bool a_fNeedsHostCursor)
-{
-    this->fNeedsHostCursor = a_fNeedsHostCursor;
-    return S_OK;
-}
-
-int Mouse::setHostCursor(bool enable)
-{
-    uHostCaps = enable ? 0 : VMMDEV_MOUSE_HOST_CANNOT_HWPOINTER;
-    gVMMDev->SetMouseCapabilities(uHostCaps);
+static uint32_t mouseButtonsToPDM(LONG buttonState)
+{
+    uint32_t fButtons = 0;
+    if (buttonState & MouseButtonState_LeftButton)
+        fButtons |= PDMIMOUSEPORT_BUTTON_LEFT;
+    if (buttonState & MouseButtonState_RightButton)
+        fButtons |= PDMIMOUSEPORT_BUTTON_RIGHT;
+    if (buttonState & MouseButtonState_MiddleButton)
+        fButtons |= PDMIMOUSEPORT_BUTTON_MIDDLE;
+    if (buttonState & MouseButtonState_XButton1)
+        fButtons |= PDMIMOUSEPORT_BUTTON_X1;
+    if (buttonState & MouseButtonState_XButton2)
+        fButtons |= PDMIMOUSEPORT_BUTTON_X2;
+    return fButtons;
+}
+
+
+/**
+ * Send a relative event to the mouse device.
+ *
+ * @returns   COM status code
+ */
+int Mouse::reportRelEventToMouseDev(int32_t dx, int32_t dy, int32_t dz,
+                                    int32_t dw, uint32_t fButtons)
+{
+    if (dx || dy || dz || dw || fButtons != mLastButtons)
+    {
+        PPDMIMOUSEPORT pUpPort = mpDrv->pUpPort;
+        int vrc = pUpPort->pfnPutEvent(pUpPort, dx, dy, dz, dw, fButtons);
+
+        if (RT_FAILURE(vrc))
+            setError(VBOX_E_IPRT_ERROR,
+                     tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
+                     vrc);
+        AssertRCReturn(vrc, VBOX_E_IPRT_ERROR);
+    }
+    return S_OK;
+}
+
+
+/**
+ * Send an absolute position event to the mouse device.
+ *
+ * @returns   COM status code
+ */
+int Mouse::reportAbsEventToMouseDev(uint32_t mouseXAbs, uint32_t mouseYAbs,
+                                    int32_t dz, int32_t dw, uint32_t fButtons)
+{
+    if (   mouseXAbs != mLastAbsX
+        || mouseYAbs != mLastAbsY
+        || dz
+        || dw
+        || fButtons != mLastButtons)
+    {
+        int vrc = mpDrv->pUpPort->pfnPutEventAbs(mpDrv->pUpPort, mouseXAbs,
+                                                 mouseYAbs, dz, dw, fButtons);
+        if (RT_FAILURE(vrc))
+            setError(VBOX_E_IPRT_ERROR,
+                     tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
+                     vrc);
+        AssertRCReturn(vrc, VBOX_E_IPRT_ERROR);
+    }
+    return S_OK;
+}
+
+
+/**
+ * Send an absolute position event to the VMM device.
+ *
+ * @returns   COM status code
+ */
+int Mouse::reportAbsEventToVMMDev(uint32_t mouseXAbs, uint32_t mouseYAbs)
+{
+#ifdef VBOXBFE_WITHOUT_COM
+    VMMDev *pVMMDev = gVMMDev;
+#else
+    VMMDev *pVMMDev = mParent->getVMMDev();
+#endif
+    ComAssertRet(pVMMDev, E_FAIL);
+    PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
+    ComAssertRet(pVMMDevPort, E_FAIL);
+
+    if (mouseXAbs != mLastAbsX || mouseYAbs != mLastAbsY)
+    {
+        int vrc = pVMMDevPort->pfnSetAbsoluteMouse(pVMMDevPort,
+                                                   mouseXAbs, mouseYAbs);
+        if (RT_FAILURE(vrc))
+            setError(VBOX_E_IPRT_ERROR,
+                     tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
+                     vrc);
+        AssertRCReturn(vrc, VBOX_E_IPRT_ERROR);
+    }
     return S_OK;
 }
@@ -85 +395 @@
  * @param buttonState The mouse button state
  */
-int Mouse::PutMouseEvent(LONG dx, LONG dy, LONG dz, LONG buttonState)
-{
-    uint32_t mouseCaps;
-    gVMMDev->QueryMouseCapabilities(&mouseCaps);
-
-    /*
-     * This method being called implies that the host no
-     * longer wants to use absolute coordinates. If the VMM
-     * device isn't aware of that yet, tell it.
-     */
-    if (mouseCaps & VMMDEV_MOUSE_HOST_CAN_ABSOLUTE)
-    {
-        gVMMDev->SetMouseCapabilities(uHostCaps);
-    }
-
-    uint32_t fButtons = 0;
-    if (buttonState & PDMIMOUSEPORT_BUTTON_LEFT)
-        fButtons |= PDMIMOUSEPORT_BUTTON_LEFT;
-    if (buttonState & PDMIMOUSEPORT_BUTTON_RIGHT)
-        fButtons |= PDMIMOUSEPORT_BUTTON_RIGHT;
-    if (buttonState & PDMIMOUSEPORT_BUTTON_MIDDLE)
-        fButtons |= PDMIMOUSEPORT_BUTTON_MIDDLE;
-
-    int vrc = mpDrv->pUpPort->pfnPutEvent(mpDrv->pUpPort, dx, dy, dz, 0 /* Horizontal wheel */, fButtons);
-    if (RT_FAILURE (vrc))
-        return E_FAIL;
-
-    return S_OK;
-}
+STDMETHODIMP Mouse::PutMouseEvent(LONG dx, LONG dy, LONG dz, LONG dw, LONG buttonState)
+{
+    HRESULT rc = S_OK;
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    CHECK_CONSOLE_DRV (mpDrv);
+
+    LogRel3(("%s: dx=%d, dy=%d, dz=%d, dw=%d\n", __PRETTY_FUNCTION__,
+             dx, dy, dz, dw));
+    if (!(uDevCaps & MOUSE_DEVCAP_ABSOLUTE))
+    {
+        /*
+         * This method being called implies that the host no
+         * longer wants to use absolute coordinates. If the VMM
+         * device isn't aware of that yet, tell it.
+         */
+        uint32_t mouseCaps;
+        rc = getVMMDevMouseCaps(&mouseCaps);
+        ComAssertComRCRet(rc, rc);
+
+        if (mouseCaps & VMMDEV_MOUSE_HOST_CAN_ABSOLUTE)
+            setVMMDevMouseCaps(uHostCaps);
+    }
+
+    uint32_t fButtons = mouseButtonsToPDM(buttonState);
+    rc = reportRelEventToMouseDev(dx, dy, dz, dw, fButtons);
+    if (SUCCEEDED(rc))
+        mLastButtons = fButtons;
+
+    return rc;
+}
+
+/**
+ * Convert an X value in screen co-ordinates to a value from 0 to 0xffff
+ *
+ * @returns   COM status value
+ */
+int Mouse::convertDisplayWidth(LONG x, uint32_t *pcX)
+{
+    AssertPtrReturn(pcX, E_POINTER);
+#ifndef VBOXBFE_WITHOUT_COM
+    Display *pDisplay = mParent->getDisplay();
+    ComAssertRet(pDisplay, E_FAIL);
+#endif
+
+    ULONG displayWidth;
+#ifdef VBOXBFE_WITHOUT_COM
+    displayWidth = gDisplay->getWidth();
+#else
+    int rc = pDisplay->COMGETTER(Width)(&displayWidth);
+    ComAssertComRCRet(rc, rc);
+#endif
+
+    *pcX = displayWidth ? (x * 0xFFFF) / displayWidth: 0;
+    return S_OK;
+}
+
+/**
+ * Convert a Y value in screen co-ordinates to a value from 0 to 0xffff
+ *
+ * @returns   COM status value
+ */
+int Mouse::convertDisplayHeight(LONG y, uint32_t *pcY)
+{
+    AssertPtrReturn(pcY, E_POINTER);
+#ifndef VBOXBFE_WITHOUT_COM
+    Display *pDisplay = mParent->getDisplay();
+    ComAssertRet(pDisplay, E_FAIL);
+#endif
+
+    ULONG displayHeight;
+#ifdef VBOXBFE_WITHOUT_COM
+    displayHeight = gDisplay->getHeight();
+#else
+    int rc = pDisplay->COMGETTER(Height)(&displayHeight);
+    ComAssertComRCRet(rc, rc);
+#endif
+
+    *pcY = displayHeight ? (y * 0xFFFF) / displayHeight: 0;
+    return S_OK;
+}
+
 
 /**
@@ -125 +492 @@
  * @param buttonState The mouse button state
  */
-int Mouse::PutMouseEventAbsolute(LONG x, LONG y, LONG dz, LONG buttonState)
-{
-    uint32_t mouseCaps;
-    gVMMDev->QueryMouseCapabilities(&mouseCaps);
-
-    /*
-     * This method being called implies that the host no
-     * longer wants to use absolute coordinates. If the VMM
-     * device isn't aware of that yet, tell it.
-     */
-    if (!(mouseCaps & VMMDEV_MOUSE_HOST_CAN_ABSOLUTE))
-    {
-        gVMMDev->SetMouseCapabilities(uHostCaps | VMMDEV_MOUSE_HOST_CAN_ABSOLUTE);
-    }
-
-    ULONG displayWidth;
-    ULONG displayHeight;
-    displayHeight = gDisplay->getHeight();
-    displayWidth  = gDisplay->getWidth();
-
-    uint32_t mouseXAbs = (x * 0xFFFF) / displayWidth;
-    uint32_t mouseYAbs = (y * 0xFFFF) / displayHeight;
-
-    /*
-     * Send the absolute mouse position to the VMM device
-     */
-    int vrc = gVMMDev->SetAbsoluteMouse(mouseXAbs, mouseYAbs);
-    AssertRC(vrc);
-
-    // check if the guest actually wants absolute mouse positions
-    if (mouseCaps & VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE)
-    {
-        uint32_t fButtons = 0;
-        if (buttonState & PDMIMOUSEPORT_BUTTON_LEFT)
-            fButtons |= PDMIMOUSEPORT_BUTTON_LEFT;
-        if (buttonState & PDMIMOUSEPORT_BUTTON_RIGHT)
-            fButtons |= PDMIMOUSEPORT_BUTTON_RIGHT;
-        if (buttonState & PDMIMOUSEPORT_BUTTON_MIDDLE)
-            fButtons |= PDMIMOUSEPORT_BUTTON_MIDDLE;
-
-        vrc = mpDrv->pUpPort->pfnPutEvent(mpDrv->pUpPort, 1, 1, dz, 0 /* Horizontal wheel */, fButtons);
-        if (RT_FAILURE (vrc))
-            return E_FAIL;
-    }
-
-    return S_OK;
-}
-
+STDMETHODIMP Mouse::PutMouseEventAbsolute(LONG x, LONG y, LONG dz, LONG dw,
+                                          LONG buttonState)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    LogRel3(("%s: x=%d, y=%d, dz=%d, dw=%d, buttonState=0x%x\n",
+             __PRETTY_FUNCTION__, x, y, dz, dw, buttonState));
+
+    CHECK_CONSOLE_DRV(mpDrv);
+
+    uint32_t mouseXAbs;
+    HRESULT rc = convertDisplayWidth(x, &mouseXAbs);
+    ComAssertComRCRet(rc, rc);
+    if (mouseXAbs > 0xffff)
+        mouseXAbs = mLastAbsX;
+
+    uint32_t mouseYAbs;
+    rc = convertDisplayHeight(y, &mouseYAbs);
+    ComAssertComRCRet(rc, rc);
+    if (mouseYAbs > 0xffff)
+        mouseYAbs = mLastAbsY;
+
+    uint32_t fButtons = mouseButtonsToPDM(buttonState);
+
+    /* Older guest additions rely on a small phony movement event on the
+     * PS/2 device to notice absolute events. */
+    bool fNeedsJiggle = false;
+
+    if (uDevCaps & MOUSE_DEVCAP_ABSOLUTE)
+        rc = reportAbsEventToMouseDev(mouseXAbs, mouseYAbs, dz, dw, fButtons);
+    else
+    {
+        uint32_t mouseCaps;
+        rc = getVMMDevMouseCaps(&mouseCaps);
+        ComAssertComRCRet(rc, rc);
+
+        /*
+         * This method being called implies that the host wants
+         * to use absolute coordinates. If the VMM device isn't
+         * aware of that yet, tell it.
+         */
+        if (!(mouseCaps & VMMDEV_MOUSE_HOST_CAN_ABSOLUTE))
+            setVMMDevMouseCaps(uHostCaps | VMMDEV_MOUSE_HOST_CAN_ABSOLUTE);
+
+        /*
+         * Send the absolute mouse position to the VMM device.
+         */
+        rc = reportAbsEventToVMMDev(mouseXAbs, mouseYAbs);
+        fNeedsJiggle = !(mouseCaps & VMMDEV_MOUSE_GUEST_USES_VMMDEV);
+    }
+    ComAssertComRCRet(rc, rc);
+
+    mLastAbsX = mouseXAbs;
+    mLastAbsY = mouseYAbs;
+
+    if (!(uDevCaps & MOUSE_DEVCAP_ABSOLUTE))
+    {
+        /* We may need to send a relative event for button information or to
+         * wake the guest up to the changed absolute co-ordinates.
+         * If the event is a pure wake up one, we make sure it contains some
+         * (possibly phony) event data to make sure it isn't just discarded on
+         * the way. */
+        if (fNeedsJiggle || fButtons != mLastButtons || dz || dw)
+        {
+            rc = reportRelEventToMouseDev(fNeedsJiggle ? 1 : 0, 0, dz, dw,
+                                          fButtons);
+            ComAssertComRCRet(rc, rc);
+        }
+    }
+    mLastButtons = fButtons;
+    return rc;
+}
+
+// private methods
 /////////////////////////////////////////////////////////////////////////////
 
+
+void Mouse::sendMouseCapsCallback(void)
+{
+    bool fAbsSupported =   uDevCaps & MOUSE_DEVCAP_ABSOLUTE
+                         ? true : fVMMDevCanAbs;
+#ifndef VBOXBFE_WITHOUT_COM
+    mParent->onMouseCapabilityChange(fAbsSupported, uDevCaps & MOUSE_DEVCAP_RELATIVE, fVMMDevNeedsHostCursor);
+#endif
+}
+
+
+/**
+ * @interface_method_impl{PDMIMOUSECONNECTOR,pfnAbsModeChange}
+ */
+DECLCALLBACK(void) Mouse::mouseAbsModeChange(PPDMIMOUSECONNECTOR pInterface, bool fEnabled)
+{
+    PDRVMAINMOUSE pDrv = RT_FROM_MEMBER(pInterface, DRVMAINMOUSE, IConnector);
+    if (fEnabled)
+        pDrv->pMouse->uDevCaps |= MOUSE_DEVCAP_ABSOLUTE;
+    else
+        pDrv->pMouse->uDevCaps &= ~MOUSE_DEVCAP_ABSOLUTE;
+
+    pDrv->pMouse->sendMouseCapsCallback();
+}
+
+
 /**
  * @interface_method_impl{PDMIBASE,pfnQueryInterface}
@@ -180 +602 @@
 DECLCALLBACK(void *)  Mouse::drvQueryInterface(PPDMIBASE pInterface, const char *pszIID)
 {
-    PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
-    PDRVMAINMOUSE pDrv = PDMINS_2_DATA(pDrvIns, PDRVMAINMOUSE);
-    if (RTUuidCompare2Strs(pszIID, PDMIBASE_IID) == 0)
-        return &pDrvIns->IBase;
-    if (RTUuidCompare2Strs(pszIID, PDMIMOUSECONNECTOR_IID) == 0)
-        return &pDrv->Connector;
+    PPDMDRVINS      pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
+    PDRVMAINMOUSE   pDrv    = PDMINS_2_DATA(pDrvIns, PDRVMAINMOUSE);
+
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMOUSECONNECTOR, &pDrv->IConnector);
     return NULL;
 }
@@ -198 +619 @@
 DECLCALLBACK(void) Mouse::drvDestruct(PPDMDRVINS pDrvIns)
 {
-    //PDRVMAINMOUSE pData = PDMINS_2_DATA(pDrvIns, PDRVMAINMOUSE);
+    PDRVMAINMOUSE pData = PDMINS_2_DATA(pDrvIns, PDRVMAINMOUSE);
     LogFlow(("Mouse::drvDestruct: iInstance=%d\n", pDrvIns->iInstance));
+    PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
+
+    if (pData->pMouse)
+    {
+        AutoWriteLock mouseLock(pData->pMouse COMMA_LOCKVAL_SRC_POS);
+        pData->pMouse->mpDrv = NULL;
+    }
 }
 
@@ -212 +640 @@
     PDRVMAINMOUSE pData = PDMINS_2_DATA(pDrvIns, PDRVMAINMOUSE);
     LogFlow(("drvMainMouse_Construct: iInstance=%d\n", pDrvIns->iInstance));
+    PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
 
     /*
@@ -227 +656 @@
     pDrvIns->IBase.pfnQueryInterface        = Mouse::drvQueryInterface;
 
+    pData->IConnector.pfnAbsModeChange      = Mouse::mouseAbsModeChange;
+
     /*
      * Get the IMousePort interface of the above driver/device.
      */
-        pData->pUpPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIMOUSEPORT);
+    pData->pUpPort = (PPDMIMOUSEPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMIMOUSEPORT_IID);
     if (!pData->pUpPort)
     {
@@ -247 +678 @@
         return rc;
     }
-
-    pData->mpDrv = (Mouse*)pv;        /** @todo Check this cast! */
-    pData->mpDrv->mpDrv = pData;
+    pData->pMouse = (Mouse *)pv;        /** @todo Check this cast! */
+    pData->pMouse->mpDrv = pData;
 
     return VINF_SUCCESS;
@@ -305 +735 @@
     PDM_DRVREG_VERSION
 };
-
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */

trunk/src/VBox/Frontends/VBoxBFE/MouseImpl.h

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * VBox frontends: Basic Frontend (BFE):
- * Declaration of Mouse class
+ * VirtualBox VBoxBFE/COM class implementation
  */
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -24 +23 @@
 #define ____H_MOUSEIMPL
 
-#include <VBox/pdm.h>
+#include "VirtualBoxBase.h"
+#ifndef VBOXBFE_WITHOUT_COM
+# include "ConsoleEvents.h"
+#endif
+#include "ConsoleImpl.h"
+#include <VBox/pdmdrv.h>
 
 /** Simple mouse event class. */
@@ -30 +34 @@
 {
 public:
-    MouseEvent() : dx(0), dy(0), dz(0), state(-1) {}
-    MouseEvent(int _dx, int _dy, int _dz, int _state) :
-        dx(_dx), dy(_dy), dz(_dz), state(_state) {}
+    MouseEvent() : dx(0), dy(0), dz(0), dw(0), state(-1) {}
+    MouseEvent(int32_t _dx, int32_t _dy, int32_t _dz, int32_t _dw, int32_t _state) :
+        dx(_dx), dy(_dy), dz(_dz), dw(_dw), state(_state) {}
     bool isValid()
     {
         return state != -1;
     }
-    // not logical to be int but that's how it's defined in QEMU
-    /** @todo r=bird: and what is the logical declaration then? We'll be using int32_t btw. */
-    int dx, dy, dz;
-    int state;
+    /* Note: dw is the horizontal scroll wheel */
+    int32_t dx, dy, dz, dw;
+    int32_t state;
+};
+#ifndef VBOXBFE_WITHOUT_COM
+// template instantiation
+typedef ConsoleEventBuffer<MouseEvent> MouseEventBuffer;
+#endif
+
+enum
+{
+    MOUSE_DEVCAP_RELATIVE = 1,
+    MOUSE_DEVCAP_ABSOLUTE = 2
 };
 
-class Mouse
+class ATL_NO_VTABLE Mouse :
+    public VirtualBoxBase
+#ifndef VBOXBFE_WITHOUT_COM
+    ,
+    public VirtualBoxSupportErrorInfoImpl<Mouse, IMouse>,
+    public VirtualBoxSupportTranslation<Mouse>,
+    VBOX_SCRIPTABLE_IMPL(IMouse)
+#endif
 {
 public:
 
-    Mouse() : fAbsolute(false), fNeedsHostCursor(false), mpDrv(NULL), uHostCaps(0) {}
+#ifndef VBOXBFE_WITHOUT_COM
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (Mouse)
+
+    DECLARE_NOT_AGGREGATABLE(Mouse)
+
+    DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+    BEGIN_COM_MAP(Mouse)
+        COM_INTERFACE_ENTRY  (ISupportErrorInfo)
+        COM_INTERFACE_ENTRY  (IMouse)
+        COM_INTERFACE_ENTRY2 (IDispatch, IMouse)
+    END_COM_MAP()
+#endif
+
+    DECLARE_EMPTY_CTOR_DTOR (Mouse)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Console *parent);
+    void uninit();
+
+    // IMouse properties
+    STDMETHOD(COMGETTER(AbsoluteSupported)) (BOOL *absoluteSupported);
+    STDMETHOD(COMGETTER(RelativeSupported)) (BOOL *relativeSupported);
+    STDMETHOD(COMGETTER(NeedsHostCursor)) (BOOL *needsHostCursor);
 
     // IMouse methods
-    int  PutMouseEvent(LONG dx, LONG dy, LONG dz, LONG buttonState);
-    int  PutMouseEventAbsolute(LONG x, LONG y, LONG dz, LONG buttonState);
+    STDMETHOD(PutMouseEvent)(LONG dx, LONG dy, LONG dz, LONG dw,
+                             LONG buttonState);
+    STDMETHOD(PutMouseEventAbsolute)(LONG x, LONG y, LONG dz, LONG dw,
+                                     LONG buttonState);
 
-    int  setAbsoluteCoordinates(bool fAbsolute);
-    int  setNeedsHostCursor(bool fNeedsHostCursor);
-#ifdef RT_OS_L4
-    // So far L4Con does not support an own mouse pointer.
-    bool getAbsoluteCoordinates() { return false; }
-#else
-    bool getAbsoluteCoordinates() { return fAbsolute; }
-#endif
-    bool getNeedsHostCursor() { return fNeedsHostCursor; }
-    int  setHostCursor(bool enable);
+    // for VirtualBoxSupportErrorInfoImpl
+    static const wchar_t *getComponentName() { return L"Mouse"; }
 
     static const PDMDRVREG  DrvReg;
+
+#ifndef VBOXBFE_WITHOUT_COM
+    Console *getParent() const
+    {
+        return mParent;
+    }
+#endif
+
+    // for VMMDevInterface
+    void onVMMDevCanAbsChange(bool canAbs)
+    {
+        fVMMDevCanAbs = canAbs;
+        sendMouseCapsCallback();
+    }
+
+    void onVMMDevNeedsHostChange(bool needsHost)
+    {
+        fVMMDevNeedsHostCursor = needsHost;
+        sendMouseCapsCallback();
+    }
 
 private:
 
     static DECLCALLBACK(void *) drvQueryInterface(PPDMIBASE pInterface, const char *pszIID);
+    static DECLCALLBACK(void)   mouseAbsModeChange (PPDMIMOUSECONNECTOR pInterface, bool fAbs);
     static DECLCALLBACK(int)    drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
     static DECLCALLBACK(void)   drvDestruct(PPDMDRVINS pDrvIns);
+    
+    int getVMMDevMouseCaps(uint32_t *pfCaps);
+    int setVMMDevMouseCaps(uint32_t fCaps);
+    int reportRelEventToMouseDev(int32_t dx, int32_t dy, int32_t dz,
+                                 int32_t dw, uint32_t fButtons);
+    int reportAbsEventToMouseDev(uint32_t mouseXAbs, uint32_t mouseYAbs,
+                                 int32_t dz, int32_t dw, uint32_t fButtons);
+    int reportAbsEventToVMMDev(uint32_t mouseXAbs, uint32_t mouseYAbs);
+    int convertDisplayWidth(LONG x, uint32_t *pcX);
+    int convertDisplayHeight(LONG y, uint32_t *pcY);
+    
+    void sendMouseCapsCallback(void);
 
-    /** Guest supports absolute coordinates */
-    bool fAbsolute;
-    /** Guest is not able to draw a cursor itself */
-    bool fNeedsHostCursor;
+#ifdef VBOXBFE_WITHOUT_COM
+    Console *mParent;
+#else
+    const ComObjPtr<Console, ComWeakRef> mParent;
+#endif
     /** Pointer to the associated mouse driver. */
     struct DRVMAINMOUSE    *mpDrv;
-    /** Host capabilities */
+
     LONG uHostCaps;
+    LONG uDevCaps;
+    bool fVMMDevCanAbs;
+    bool fVMMDevNeedsHostCursor;
+    uint32_t mLastAbsX;
+    uint32_t mLastAbsY;
+    uint32_t mLastButtons;
 };
 
+#ifdef VBOXBFE_WITHOUT_COM
 extern Mouse *gMouse;
+#endif
 
 #endif // !____H_MOUSEIMPL
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */

trunk/src/VBox/Frontends/VBoxBFE/SDLConsole.cpp

@@ -135 +135 @@
      */
     SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
+
+    /*
+     * Initialise "children" (so far only Mouse)
+     */
+    if (FAILED(gMouse->init(this)))
+    {
+        RTPrintf("VBoxBFE: failed to initialise the mouse device\n");
+        return;
+    }
+
     mfInitialized = true;
 }
@@ -142 +152 @@
     if (mfInputGrab)
         inputGrabEnd();
+
+    /*
+     * Uninitialise "children" (so far only Mouse)
+     */
+    gMouse->uninit();
+
     if (mWMIcon)
     {
@@ -277 +293 @@
         case SDL_MOUSEMOTION:
         {
-            if (mfInputGrab || gMouse->getAbsoluteCoordinates())
+            bool fMouseAbsolute;
+            gMouse->COMGETTER(AbsoluteSupported)(&fMouseAbsolute);
+            if (mfInputGrab || fMouseAbsolute)
                 mouseSendEvent(0);
             break;
@@ -288 +306 @@
         case SDL_MOUSEBUTTONUP:
         {
+            bool fMouseAbsolute;
+            gMouse->COMGETTER(AbsoluteSupported)(&fMouseAbsolute);
             SDL_MouseButtonEvent *bev = &ev->button;
-            if (!mfInputGrab && !gMouse->getAbsoluteCoordinates())
+            if (!mfInputGrab && !fMouseAbsolute)
             {
                 if (ev->type == SDL_MOUSEBUTTONDOWN && (bev->state & SDL_BUTTON_LMASK))
@@ -1137 +1157 @@
 void SDLConsole::inputGrabStart()
 {
+    bool fNeedsHostCursor;
+    gMouse->COMGETTER(NeedsHostCursor)(&fNeedsHostCursor);
 #ifdef RT_OS_DARWIN
     DisableGlobalHotKeys(true);
 #endif
-    if (!gMouse->getNeedsHostCursor())
+    if (!fNeedsHostCursor)
         SDL_ShowCursor(SDL_DISABLE);
     SDL_WM_GrabInput(SDL_GRAB_ON);
@@ -1154 +1176 @@
 void SDLConsole::inputGrabEnd()
 {
+    bool fNeedsHostCursor;
+    gMouse->COMGETTER(NeedsHostCursor)(&fNeedsHostCursor);
     SDL_WM_GrabInput(SDL_GRAB_OFF);
-    if (!gMouse->getNeedsHostCursor())
+    if (!fNeedsHostCursor)
         SDL_ShowCursor(SDL_ENABLE);
 #ifdef RT_OS_DARWIN
@@ -1177 +1201 @@
     int x, y, state, buttons;
     bool abs;
-
-    abs = (gMouse->getAbsoluteCoordinates() && !mfInputGrab) || gMouse->getNeedsHostCursor();
+    bool fMouseAbsolute;
+    bool fNeedsHostCursor;
+
+    gMouse->COMGETTER(AbsoluteSupported)(&fMouseAbsolute);
+    gMouse->COMGETTER(NeedsHostCursor)(&fNeedsHostCursor);
+    abs = (fMouseAbsolute && !mfInputGrab) || fNeedsHostCursor;
 
     state = abs ? SDL_GetMouseState(&x, &y) : SDL_GetRelativeMouseState(&x, &y);
@@ -1202 +1230 @@
         /* only send if outside the extra offset area */
         if (y >= gFramebuffer->getYOffset())
-            gMouse->PutMouseEventAbsolute(x + 1, y + 1 - gFramebuffer->getYOffset(), dz, buttons);
+            gMouse->PutMouseEventAbsolute(x + 1, y + 1 - gFramebuffer->getYOffset(), dz, 0, buttons);
     }
     else
     {
-        gMouse->PutMouseEvent(x, y, dz, buttons);
+        gMouse->PutMouseEvent(x, y, dz, 0, buttons);
     }
 }
@@ -1325 +1353 @@
      * don't do anything if there are no guest additions loaded (anymore)
      */
-    if (!gMouse->getAbsoluteCoordinates())
+    bool fMouseAbsolute;
+    gMouse->COMGETTER(AbsoluteSupported)(&fMouseAbsolute);
+    if (!fMouseAbsolute)
         return;
 

trunk/src/VBox/Frontends/VBoxBFE/VBoxBFE.cpp

@@ -790 +790 @@
     gKeyboard = new Keyboard();
     gMouse = new Mouse();
+    if (FAILED(gMouse->FinalConstruct()))
+        goto leave;
     gVMMDev = new VMMDev();
     gDisplay = new VMDisplay();
@@ -979 +981 @@
     delete gDisplay;
     delete gKeyboard;
+    gMouse->FinalRelease();
     delete gMouse;
     delete gStatus;
@@ -1257 +1260 @@
     }
 #endif /* VBOXBFE_WITH_USB */
-
-#ifdef RT_OS_L4
-    /* L4 console cannot draw a host cursor */
-    gMouse->setHostCursor(false);
-#else
-    gMouse->setHostCursor(true);
-#endif
 
     /*

trunk/src/VBox/Frontends/VBoxBFE/VMMDevInterface.cpp

@@ -173 +173 @@
     if (gMouse)
     {
-        gMouse->setAbsoluteCoordinates(!!(newCapabilities & VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE));
-        gMouse->setNeedsHostCursor(!!(newCapabilities & VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR));
+        gMouse->onVMMDevCanAbsChange(!!(newCapabilities & VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE));
+        gMouse->onVMMDevNeedsHostChange(!!(newCapabilities & VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR));
     }
     if (gConsole)