VirtualBox

Changeset 50592 in vbox for trunk/src/VBox/Main/src-client


Ignore:
Timestamp:
Feb 25, 2014 7:56:18 PM (11 years ago)
Author:
vboxsync
Message:

6813 src-client/MouseImpl.cpp changes backed out to clear clbr burns

Location:
trunk/src/VBox/Main/src-client
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/src-client/MouseImpl.cpp

    r50589 r50592  
    156156 * thus to the guest.
    157157 * @note all calls out of this object are made with no locks held! */
    158 HRESULT Mouse::i_updateVMMDevMouseCaps(uint32_t fCapsAdded,
    159                                        uint32_t fCapsRemoved)
     158HRESULT Mouse::updateVMMDevMouseCaps(uint32_t fCapsAdded,
     159                                     uint32_t fCapsRemoved)
    160160{
    161161    VMMDevMouseInterface *pVMMDev = mParent->getVMMDevMouseInterface();
    … …  
    179179 * @param absoluteSupported address of result variable
    180180 */
    181 HRESULT Mouse::getAbsoluteSupported(BOOL *aAbsoluteSupported)
    182 {
    183     *aAbsoluteSupported = i_supportsAbs();
     181STDMETHODIMP Mouse::COMGETTER(AbsoluteSupported) (BOOL *absoluteSupported)
     182{
     183    if (!absoluteSupported)
     184        return E_POINTER;
     185
     186    AutoCaller autoCaller(this);
     187    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     188
     189    *absoluteSupported = supportsAbs();
    184190    return S_OK;
    185191}
    … …  
    192198 * @param relativeSupported address of result variable
    193199 */
    194 HRESULT Mouse::getRelativeSupported(BOOL *aRelativeSupported)
    195 {
    196 
    197     *aRelativeSupported = i_supportsRel();
     200STDMETHODIMP Mouse::COMGETTER(RelativeSupported) (BOOL *relativeSupported)
     201{
     202    if (!relativeSupported)
     203        return E_POINTER;
     204
     205    AutoCaller autoCaller(this);
     206    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     207
     208    *relativeSupported = supportsRel();
    198209    return S_OK;
    199210}
    … …  
    206217 * @param multiTouchSupported address of result variable
    207218 */
    208 HRESULT Mouse::getMultiTouchSupported(BOOL *aMultiTouchSupported)
    209 {
    210 
    211     *aMultiTouchSupported = i_supportsMT();
     219STDMETHODIMP Mouse::COMGETTER(MultiTouchSupported) (BOOL *multiTouchSupported)
     220{
     221    if (!multiTouchSupported)
     222        return E_POINTER;
     223
     224    AutoCaller autoCaller(this);
     225    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     226
     227    *multiTouchSupported = supportsMT();
    212228    return S_OK;
    213229}
    … …  
    220236 * @param pfNeedsHostCursor address of result variable
    221237 */
    222 HRESULT Mouse::getNeedsHostCursor(BOOL *aNeedsHostCursor)
    223 {
    224 
    225     *aNeedsHostCursor = i_guestNeedsHostCursor();
     238STDMETHODIMP Mouse::COMGETTER(NeedsHostCursor) (BOOL *pfNeedsHostCursor)
     239{
     240    if (!pfNeedsHostCursor)
     241        return E_POINTER;
     242
     243    AutoCaller autoCaller(this);
     244    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     245
     246    *pfNeedsHostCursor = guestNeedsHostCursor();
    226247    return S_OK;
    227248}
    … …  
    233254 * held down from the format used by the front-end to the format used by PDM
    234255 * and the emulated pointing devices. */
    235 static uint32_t i_mouseButtonsToPDM(LONG buttonState)
     256static uint32_t mouseButtonsToPDM(LONG buttonState)
    236257{
    237258    uint32_t fButtons = 0;
    … …  
    249270}
    250271
    251 HRESULT Mouse::getEventSource(ComPtr<IEventSource> &aEventSource)
    252 {
     272STDMETHODIMP Mouse::COMGETTER(EventSource)(IEventSource ** aEventSource)
     273{
     274    CheckComArgOutPointerValid(aEventSource);
     275
     276    AutoCaller autoCaller(this);
     277    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     278
    253279    // no need to lock - lifetime constant
    254     mEventSource.queryInterfaceTo(aEventSource.asOutParam());
     280    mEventSource.queryInterfaceTo(aEventSource);
     281
    255282    return S_OK;
    256283}
    … …  
    262289 * @returns   COM status code
    263290 */
    264 HRESULT Mouse::i_reportRelEventToMouseDev(int32_t dx, int32_t dy, int32_t dz,
    265                                           int32_t dw, uint32_t fButtons)
     291HRESULT Mouse::reportRelEventToMouseDev(int32_t dx, int32_t dy, int32_t dz,
     292                                        int32_t dw, uint32_t fButtons)
    266293{
    267294    if (dx || dy || dz || dw || fButtons != mfLastButtons)
    … …  
    298325 * @returns   COM status code
    299326 */
    300 HRESULT Mouse::i_reportAbsEventToMouseDev(int32_t x, int32_t y,
    301                                           int32_t dz, int32_t dw, uint32_t fButtons)
     327HRESULT Mouse::reportAbsEventToMouseDev(int32_t x, int32_t y,
     328                                        int32_t dz, int32_t dw, uint32_t fButtons)
    302329{
    303330    if (   x < VMMDEV_MOUSE_RANGE_MIN
    … …  
    335362}
    336363
    337 HRESULT Mouse::i_reportMultiTouchEventToDevice(uint8_t cContacts,
    338                                                const uint64_t *pau64Contacts,
    339                                                uint32_t u32ScanTime)
     364HRESULT Mouse::reportMultiTouchEventToDevice(uint8_t cContacts,
     365                                             const uint64_t *pau64Contacts,
     366                                             uint32_t u32ScanTime)
    340367{
    341368    HRESULT hrc = S_OK;
    … …  
    380407 * @returns   COM status code
    381408 */
    382 HRESULT Mouse::i_reportAbsEventToVMMDev(int32_t x, int32_t y)
     409HRESULT Mouse::reportAbsEventToVMMDev(int32_t x, int32_t y)
    383410{
    384411    VMMDevMouseInterface *pVMMDev = mParent->getVMMDevMouseInterface();
    … …  
    406433 * @returns   COM status code
    407434 */
    408 HRESULT Mouse::i_reportAbsEvent(int32_t x, int32_t y,
    409                                 int32_t dz, int32_t dw, uint32_t fButtons,
    410                                 bool fUsesVMMDevEvent)
     435HRESULT Mouse::reportAbsEvent(int32_t x, int32_t y,
     436                              int32_t dz, int32_t dw, uint32_t fButtons,
     437                              bool fUsesVMMDevEvent)
    411438{
    412439    HRESULT rc;
    … …  
    416443    LONG cJiggle = 0;
    417444
    418     if (i_vmmdevCanAbs())
     445    if (vmmdevCanAbs())
    419446    {
    420447        /*
    … …  
    423450        if (x != mcLastX || y != mcLastY)
    424451        {
    425             rc = i_reportAbsEventToVMMDev(x, y);
     452            rc = reportAbsEventToVMMDev(x, y);
    426453            cJiggle = !fUsesVMMDevEvent;
    427454        }
    428         rc = i_reportRelEventToMouseDev(cJiggle, 0, dz, dw, fButtons);
     455        rc = reportRelEventToMouseDev(cJiggle, 0, dz, dw, fButtons);
    429456    }
    430457    else
    431         rc = i_reportAbsEventToMouseDev(x, y, dz, dw, fButtons);
     458        rc = reportAbsEventToMouseDev(x, y, dz, dw, fButtons);
    432459
    433460    mcLastX = x;
    … …  
    436463}
    437464
    438 void Mouse::i_fireMouseEvent(bool fAbsolute, LONG x, LONG y, LONG dz, LONG dw,
    439                              LONG fButtons)
     465void Mouse::fireMouseEvent(bool fAbsolute, LONG x, LONG y, LONG dz, LONG dw,
     466                           LONG fButtons)
    440467{
    441468    /* If mouse button is pressed, we generate new event, to avoid reusable events coalescing and thus
    … …  
    462489}
    463490
    464 void Mouse::i_fireMultiTouchEvent(uint8_t cContacts,
    465                                   const LONG64 *paContacts,
    466                                   uint32_t u32ScanTime)
     491void Mouse::fireMultiTouchEvent(uint8_t cContacts,
     492                                const LONG64 *paContacts,
     493                                uint32_t u32ScanTime)
    467494{
    468495    com::SafeArray<SHORT> xPositions(cContacts);
    … …  
    501528 * @param fButtons    The mouse button state
    502529 */
    503 HRESULT Mouse::putMouseEvent(LONG dx, LONG dy, LONG dz, LONG dw,
    504                              LONG aButtonState)
     530STDMETHODIMP Mouse::PutMouseEvent(LONG dx, LONG dy, LONG dz, LONG dw,
     531                                  LONG fButtons)
    505532{
    506533    HRESULT rc;
    507534    uint32_t fButtonsAdj;
    508535
     536    AutoCaller autoCaller(this);
     537    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    509538    LogRel3(("%s: dx=%d, dy=%d, dz=%d, dw=%d\n", __PRETTY_FUNCTION__,
    510539                 dx, dy, dz, dw));
    511540
    512     fButtonsAdj = i_mouseButtonsToPDM(aButtonState);
     541    fButtonsAdj = mouseButtonsToPDM(fButtons);
    513542    /* Make sure that the guest knows that we are sending real movement
    514543     * events to the PS/2 device and not just dummy wake-up ones. */
    515     i_updateVMMDevMouseCaps(0, VMMDEV_MOUSE_HOST_WANTS_ABSOLUTE);
    516     rc = i_reportRelEventToMouseDev(dx, dy, dz, dw, fButtonsAdj);
    517 
    518     i_fireMouseEvent(false, dx, dy, dz, dw, aButtonState);
     544    updateVMMDevMouseCaps(0, VMMDEV_MOUSE_HOST_WANTS_ABSOLUTE);
     545    rc = reportRelEventToMouseDev(dx, dy, dz, dw, fButtonsAdj);
     546
     547    fireMouseEvent(false, dx, dy, dz, dw, fButtons);
    519548
    520549    return rc;
    … …  
    536565 * @returns   COM status value
    537566 */
    538 HRESULT Mouse::i_convertDisplayRes(LONG x, LONG y, int32_t *pxAdj, int32_t *pyAdj,
    539                                    bool *pfValid)
     567HRESULT Mouse::convertDisplayRes(LONG x, LONG y, int32_t *pxAdj, int32_t *pyAdj,
     568                                 bool *pfValid)
    540569{
    541570    AssertPtrReturn(pxAdj, E_POINTER);
    … …  
    600629 * @param fButtons   The mouse button state
    601630 */
    602 HRESULT Mouse::putMouseEventAbsolute(LONG x, LONG y, LONG dz, LONG dw,
    603                                      LONG aButtonState)
    604 {
     631STDMETHODIMP Mouse::PutMouseEventAbsolute(LONG x, LONG y, LONG dz, LONG dw,
     632                                          LONG fButtons)
     633{
     634    AutoCaller autoCaller(this);
     635    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     636
    605637    LogRel3(("%s: x=%d, y=%d, dz=%d, dw=%d, fButtons=0x%x\n",
    606              __PRETTY_FUNCTION__, x, y, dz, dw, aButtonState));
     638             __PRETTY_FUNCTION__, x, y, dz, dw, fButtons));
    607639
    608640    int32_t xAdj, yAdj;
    … …  
    613645    /** @note Or maybe not... races are pretty inherent in everything done in
    614646     *        this object and not really bad as far as I can see. */
    615     HRESULT rc = i_convertDisplayRes(x, y, &xAdj, &yAdj, &fValid);
     647    HRESULT rc = convertDisplayRes(x, y, &xAdj, &yAdj, &fValid);
    616648    if (FAILED(rc)) return rc;
    617649
    618     fButtonsAdj = i_mouseButtonsToPDM(aButtonState);
     650    fButtonsAdj = mouseButtonsToPDM(fButtons);
    619651    /* If we are doing old-style (IRQ-less) absolute reporting to the VMM
    620652     * device then make sure the guest is aware of it, so that it knows to
    621653     * ignore relative movement on the PS/2 device. */
    622     i_updateVMMDevMouseCaps(VMMDEV_MOUSE_HOST_WANTS_ABSOLUTE, 0);
     654    updateVMMDevMouseCaps(VMMDEV_MOUSE_HOST_WANTS_ABSOLUTE, 0);
    623655    if (fValid)
    624656    {
    625         rc = i_reportAbsEvent(xAdj, yAdj, dz, dw, fButtonsAdj,
    626                               RT_BOOL(  mfVMMDevGuestCaps
    627                                       & VMMDEV_MOUSE_NEW_PROTOCOL));
    628 
    629         i_fireMouseEvent(true, x, y, dz, dw, aButtonState);
     657        rc = reportAbsEvent(xAdj, yAdj, dz, dw, fButtonsAdj,
     658                            RT_BOOL(  mfVMMDevGuestCaps
     659                                    & VMMDEV_MOUSE_NEW_PROTOCOL));
     660
     661        fireMouseEvent(true, x, y, dz, dw, fButtons);
    630662    }
    631663
    … …  
    642674 * @param aScanTime  Timestamp.
    643675 */
    644 HRESULT Mouse::putEventMultiTouch(LONG aCount,
    645                                   const std::vector<LONG64> &aContacts,
    646                                   ULONG aScanTime)
    647 {
    648     com::SafeArray <LONG64> arrayContacts(aContacts);
     676STDMETHODIMP Mouse::PutEventMultiTouch(LONG aCount,
     677                                       ComSafeArrayIn(LONG64, aContacts),
     678                                       ULONG aScanTime)
     679{
     680    AutoCaller autoCaller(this);
     681    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     682
     683    com::SafeArray <LONG64> arrayContacts(ComSafeArrayInArg(aContacts));
    649684
    650685    LogRel3(("%s: aCount %d(actual %d), aScanTime %u\n",
    … …  
    657692        LONG64* paContacts = arrayContacts.raw();
    658693
    659         rc = i_putEventMultiTouch(aCount, paContacts, aScanTime);
     694        rc = putEventMultiTouch(aCount, paContacts, aScanTime);
    660695    }
    661696    else
    … …  
    675710 * @param aScanTime  Timestamp.
    676711 */
    677 HRESULT Mouse::putEventMultiTouchString(LONG aCount,
    678                                         const com::Utf8Str &aContacts,
    679                                         ULONG aScanTime)
     712STDMETHODIMP Mouse::PutEventMultiTouchString(LONG aCount,
     713                                             IN_BSTR aContacts,
     714                                             ULONG aScanTime)
    680715{
    681716    /** @todo implement: convert the string to LONG64 array and call putEventMultiTouch. */
    … …  
    691726
    692727/* Used by PutEventMultiTouch and PutEventMultiTouchString. */
    693 HRESULT Mouse::i_putEventMultiTouch(LONG aCount,
    694                                     LONG64 *paContacts,
    695                                     ULONG aScanTime)
     728HRESULT Mouse::putEventMultiTouch(LONG aCount,
     729                                  LONG64 *paContacts,
     730                                  ULONG aScanTime)
    696731{
    697732    if (aCount >= 256)
    … …  
    784819    if (SUCCEEDED(rc))
    785820    {
    786         rc = i_reportMultiTouchEventToDevice(cContacts, cContacts? pau64Contacts: NULL, (uint32_t)aScanTime);
     821        rc = reportMultiTouchEventToDevice(cContacts, cContacts? pau64Contacts: NULL, (uint32_t)aScanTime);
    787822
    788823        /* Send the original contact information. */
    789         i_fireMultiTouchEvent(cContacts, cContacts? paContacts: NULL, (uint32_t)aScanTime);
     824        fireMultiTouchEvent(cContacts, cContacts? paContacts: NULL, (uint32_t)aScanTime);
    790825    }
    791826
    … …  
    798833/** Does the guest currently rely on the host to draw the mouse cursor or
    799834 * can it switch to doing it itself in software? */
    800 bool Mouse::i_guestNeedsHostCursor(void)
     835bool Mouse::guestNeedsHostCursor(void)
    801836{
    802837    return RT_BOOL(mfVMMDevGuestCaps & VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR);
    … …  
    806841/** Check what sort of reporting can be done using the devices currently
    807842 * enabled.  Does not consider the VMM device. */
    808 void Mouse::i_getDeviceCaps(bool *pfAbs, bool *pfRel, bool *pfMT)
     843void Mouse::getDeviceCaps(bool *pfAbs, bool *pfRel, bool *pfMT)
    809844{
    810845    bool fAbsDev = false;
    … …  
    834869
    835870/** Does the VMM device currently support absolute reporting? */
    836 bool Mouse::i_vmmdevCanAbs(void)
     871bool Mouse::vmmdevCanAbs(void)
    837872{
    838873    bool fRelDev;
    839874
    840     i_getDeviceCaps(NULL, &fRelDev, NULL);
     875    getDeviceCaps(NULL, &fRelDev, NULL);
    841876    return    (mfVMMDevGuestCaps & VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE)
    842877           && fRelDev;
    … …  
    845880
    846881/** Does the VMM device currently support absolute reporting? */
    847 bool Mouse::i_deviceCanAbs(void)
     882bool Mouse::deviceCanAbs(void)
    848883{
    849884    bool fAbsDev;
    850885
    851     i_getDeviceCaps(&fAbsDev, NULL, NULL);
     886    getDeviceCaps(&fAbsDev, NULL, NULL);
    852887    return fAbsDev;
    853888}
    … …  
    855890
    856891/** Can we currently send relative events to the guest? */
    857 bool Mouse::i_supportsRel(void)
     892bool Mouse::supportsRel(void)
    858893{
    859894    bool fRelDev;
    860895
    861     i_getDeviceCaps(NULL, &fRelDev, NULL);
     896    getDeviceCaps(NULL, &fRelDev, NULL);
    862897    return fRelDev;
    863898}
    … …  
    865900
    866901/** Can we currently send absolute events to the guest? */
    867 bool Mouse::i_supportsAbs(void)
     902bool Mouse::supportsAbs(void)
    868903{
    869904    bool fAbsDev;
    870905
    871     i_getDeviceCaps(&fAbsDev, NULL, NULL);
    872     return fAbsDev || i_vmmdevCanAbs();
     906    getDeviceCaps(&fAbsDev, NULL, NULL);
     907    return fAbsDev || vmmdevCanAbs();
    873908}
    874909
    875910
    876911/** Can we currently send absolute events to the guest? */
    877 bool Mouse::i_supportsMT(void)
     912bool Mouse::supportsMT(void)
    878913{
    879914    bool fMTDev;
    880915
    881     i_getDeviceCaps(NULL, NULL, &fMTDev);
     916    getDeviceCaps(NULL, NULL, &fMTDev);
    882917    return fMTDev;
    883918}
    … …  
    887922 * enabled (including the VMM device) and notify the guest and the front-end.
    888923 */
    889 void Mouse::i_sendMouseCapsNotifications(void)
     924void Mouse::sendMouseCapsNotifications(void)
    890925{
    891926    bool fAbsDev, fRelDev, fMTDev, fCanAbs, fNeedsHostCursor;
    … …  
    894929        AutoReadLock aLock(this COMMA_LOCKVAL_SRC_POS);
    895930
    896         i_getDeviceCaps(&fAbsDev, &fRelDev, &fMTDev);
    897         fCanAbs = i_supportsAbs();
    898         fNeedsHostCursor = i_guestNeedsHostCursor();
     931        getDeviceCaps(&fAbsDev, &fRelDev, &fMTDev);
     932        fCanAbs = supportsAbs();
     933        fNeedsHostCursor = guestNeedsHostCursor();
    899934    }
    900935    if (fAbsDev)
    901         i_updateVMMDevMouseCaps(VMMDEV_MOUSE_HOST_HAS_ABS_DEV, 0);
     936        updateVMMDevMouseCaps(VMMDEV_MOUSE_HOST_HAS_ABS_DEV, 0);
    902937    else
    903         i_updateVMMDevMouseCaps(0, VMMDEV_MOUSE_HOST_HAS_ABS_DEV);
     938        updateVMMDevMouseCaps(0, VMMDEV_MOUSE_HOST_HAS_ABS_DEV);
    904939    /** @todo this call takes the Console lock in order to update the cached
    905940     * callback data atomically.  However I can't see any sign that the cached
    … …  
    913948 * A virtual device is notifying us about its current state and capabilities
    914949 */
    915 DECLCALLBACK(void) Mouse::i_mouseReportModes(PPDMIMOUSECONNECTOR pInterface, bool fRel, bool fAbs, bool fMT)
     950DECLCALLBACK(void) Mouse::mouseReportModes(PPDMIMOUSECONNECTOR pInterface, bool fRel, bool fAbs, bool fMT)
    916951{
    917952    PDRVMAINMOUSE pDrv = RT_FROM_MEMBER(pInterface, DRVMAINMOUSE, IConnector);
    … …  
    929964        pDrv->u32DevCaps &= ~MOUSE_DEVCAP_MULTI_TOUCH;
    930965
    931     pDrv->pMouse->i_sendMouseCapsNotifications();
     966    pDrv->pMouse->sendMouseCapsNotifications();
    932967}
    933968
    … …  
    936971 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
    937972 */
    938 DECLCALLBACK(void *)  Mouse::i_drvQueryInterface(PPDMIBASE pInterface, const char *pszIID)
     973DECLCALLBACK(void *)  Mouse::drvQueryInterface(PPDMIBASE pInterface, const char *pszIID)
    939974{
    940975    PPDMDRVINS      pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
    … …  
    953988 * @param   pDrvIns     The driver instance data.
    954989 */
    955 DECLCALLBACK(void) Mouse::i_drvDestruct(PPDMDRVINS pDrvIns)
     990DECLCALLBACK(void) Mouse::drvDestruct(PPDMDRVINS pDrvIns)
    956991{
    957992    PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
    … …  
    9771012 * @copydoc FNPDMDRVCONSTRUCT
    9781013 */
    979 DECLCALLBACK(int) Mouse::i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
     1014DECLCALLBACK(int) Mouse::drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
    9801015{
    9811016    PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
    … …  
    9951030     * IBase.
    9961031     */
    997     pDrvIns->IBase.pfnQueryInterface        = Mouse::i_drvQueryInterface;
    998 
    999     pThis->IConnector.pfnReportModes        = Mouse::i_mouseReportModes;
     1032    pDrvIns->IBase.pfnQueryInterface        = Mouse::drvQueryInterface;
     1033
     1034    pThis->IConnector.pfnReportModes        = Mouse::mouseReportModes;
    10001035
    10011036    /*
    … …  
    10621097    sizeof(DRVMAINMOUSE),
    10631098    /* pfnConstruct */
    1064     Mouse::i_drvConstruct,
     1099    Mouse::drvConstruct,
    10651100    /* pfnDestruct */
    1066     Mouse::i_drvDestruct,
     1101    Mouse::drvDestruct,
    10671102    /* pfnRelocate */
    10681103    NULL,

  • trunk/src/VBox/Main/src-client/VMMDevInterface.cpp

    r50589 r50592  
    339339    Mouse *pMouse = pConsole->getMouse();
    340340    if (pMouse)  /** @todo and if not?  Can that actually happen? */
    341         pMouse->i_onVMMDevGuestCapsChange(fNewCaps & VMMDEV_MOUSE_GUEST_MASK);
     341        pMouse->onVMMDevGuestCapsChange(fNewCaps & VMMDEV_MOUSE_GUEST_MASK);
    342342}
    343343

  • trunk/src/VBox/Main/src-client/xpcom/module.cpp

    r50589 r50592  
    7878NS_DECL_CLASSINFO(Keyboard)
    7979NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Keyboard, IKeyboard)
     80NS_DECL_CLASSINFO(Mouse)
     81NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Mouse, IMouse)
    8082NS_DECL_CLASSINFO(Display)
    8183NS_IMPL_THREADSAFE_ISUPPORTS2_CI(Display, IDisplay, IEventListener)
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette