486 lines
16 KiB
C++
486 lines
16 KiB
C++
// Copyright (c) 2000-2000 Microsoft Corporation
|
|
|
|
// --------------------------------------------------------------------------
|
|
//
|
|
// wrap_annotation
|
|
//
|
|
// Wrapper class to implement annotation for IAccessibles
|
|
//
|
|
// --------------------------------------------------------------------------
|
|
|
|
#include "oleacc_p.h"
|
|
|
|
#include "PropMgr_Client.h"
|
|
#include "PropMgr_Util.h"
|
|
|
|
#include "wrap_base.h"
|
|
|
|
|
|
|
|
class AccWrap_AddIAccProp: public AccWrap_Base
|
|
{
|
|
HWND m_FakeIAccPropHwnd;
|
|
BOOL m_fCheckedForFakeIAccProp;
|
|
|
|
|
|
BOOL CanFakeIAccIdentity( HWND * phwnd )
|
|
{
|
|
// Can we fale IAccIdentity for this object?
|
|
// Yes, if:
|
|
// * It supports IAccessible
|
|
// * It has a parent
|
|
// * The parent supports IAccIdentity
|
|
// * Parent's identity is HWND-base,d and is OBJID_WINDOW.
|
|
// We can 99.9% assume that the child is an OBJID_CLIENT object.
|
|
//
|
|
// (TODO - also check that its HWND matches that of its parent?)
|
|
//
|
|
// This is useful where native IAccessible is implementing IAccessible
|
|
// for a client (ie. where it's not something complicated like Trident
|
|
// with multiple levels). Since the native IAccessible won't implement
|
|
// IAccIdentity (since that was spec'd only recently), annotation
|
|
// won't work for it.
|
|
// However, if we can determine that it is a simple IAccessible - and
|
|
// we do so by checking that it's parent is a OBJID_WINDOW object -
|
|
// we can supply the identity for it.
|
|
// This works because noone has ever wanted to supply an IAccessible
|
|
// for anything other than the OBJID_CLIENT child of an OBJID_WINDOW.
|
|
|
|
|
|
// Note that we use the AccWrap_Base::get_accParent here instead of
|
|
// using get_accParent - if we used the latter, we'd end up trying
|
|
// to use annotation (to see if the parent was annotated), but we're
|
|
// in the middle ot QI'ing for an annotation interface, so that would
|
|
// be freaky. So we explicitly call the base class to short-circuit-out
|
|
// the annotated version of get_accParent.
|
|
IDispatch * pdispParent = NULL;
|
|
HRESULT hr = AccWrap_Base::get_accParent( & pdispParent );
|
|
if( hr != S_OK || pdispParent == NULL )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// This is very important - we want to talk to the real parent IAccessible -
|
|
// not its wrapper, so that when we QI it for IAccIdentity, we will know
|
|
// for sure if the parent actually supports it or not. (If we didn't do this,
|
|
// the parent's wrapper would try to implement IAccIdentity for it, by
|
|
// calling back into this method on the parent, which would in turn do the same
|
|
// for the parent's parent, and so on up the tree. Eventually, that would all
|
|
// correctly return 'FALSE', but it's a particularly expensive way to calculate
|
|
// FALSE, especially where deep trees are used, eg. in a trident doc.)
|
|
//
|
|
// We get the real parent by QI'ing for IServiceProvider, and then QS'ing for
|
|
// IIS_AccWrapBase_GetIUnknown. (These are implemented in wrap_base.cpp).
|
|
|
|
IServiceProvider * psvc = NULL;
|
|
hr = pdispParent->QueryInterface( IID_IServiceProvider, (void **) & psvc );
|
|
pdispParent->Release();
|
|
if( hr != S_OK || psvc == NULL )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// QS allows us to both get the real parent, and QI it (for IAccIdentity) in one go...
|
|
IAccIdentity * pParentID = NULL;
|
|
hr = psvc->QueryService( IIS_AccWrapBase_GetIUnknown, IID_IAccIdentity, (void **) & pParentID );
|
|
psvc->Release();
|
|
if( hr != S_OK || pParentID == NULL )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Got the parent's identity interface - now get its identity string...
|
|
BYTE * pIDString = NULL;
|
|
DWORD dwStringLen = 0;
|
|
hr = pParentID->GetIdentityString( CHILDID_SELF, & pIDString, & dwStringLen );
|
|
pParentID->Release();
|
|
if( hr != S_OK || pIDString == NULL )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Finally check if it is a OBJID_WINDOW thing...
|
|
HWND hwnd;
|
|
DWORD idObject;
|
|
DWORD idChild;
|
|
BOOL fGotIt = DecodeHwndKey( pIDString, dwStringLen, & hwnd, & idObject, & idChild );
|
|
CoTaskMemFree( pIDString );
|
|
|
|
if( ! fGotIt || hwnd == NULL || idObject != OBJID_WINDOW || idChild != CHILDID_SELF )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
* phwnd = hwnd;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
public:
|
|
|
|
AccWrap_AddIAccProp( IUnknown * punk )
|
|
: AccWrap_Base( punk ),
|
|
m_FakeIAccPropHwnd( NULL ),
|
|
m_fCheckedForFakeIAccProp( FALSE )
|
|
{
|
|
}
|
|
|
|
|
|
~AccWrap_AddIAccProp()
|
|
{
|
|
}
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE QueryInterface( REFIID riid, void ** ppv )
|
|
{
|
|
HRESULT hr = AccWrap_Base::QueryInterface( riid, ppv );
|
|
|
|
if( hr == E_NOINTERFACE && riid == IID_IAccIdentity )
|
|
{
|
|
if( ! m_fCheckedForFakeIAccProp )
|
|
{
|
|
// Check if we can fake an IAccIdentity, if we haven't
|
|
// checked already...
|
|
HWND hwnd;
|
|
m_fCheckedForFakeIAccProp = TRUE;
|
|
if( CanFakeIAccIdentity( & hwnd ) )
|
|
{
|
|
m_FakeIAccPropHwnd = hwnd;
|
|
}
|
|
}
|
|
|
|
if( m_FakeIAccPropHwnd )
|
|
{
|
|
// Yes, we can fake it...
|
|
*ppv = (IAccIdentity *) this;
|
|
AddRef();
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE GetIdentityString (
|
|
DWORD dwIDChild,
|
|
BYTE ** ppIDString,
|
|
DWORD * pdwIDStringLen
|
|
)
|
|
{
|
|
*ppIDString = NULL;
|
|
*pdwIDStringLen = 0;
|
|
|
|
if( ! m_fCheckedForFakeIAccProp )
|
|
{
|
|
// Object supports this interface natively - call through...
|
|
return AccWrap_Base::GetIdentityString( dwIDChild, ppIDString, pdwIDStringLen );
|
|
}
|
|
|
|
if( ! m_FakeIAccPropHwnd )
|
|
{
|
|
// This shouldn't happen - if we've checked for the interface, but didn't
|
|
// get a valid HWND to use, then we'd have returned E_NOINTERFACE in QI, so
|
|
// the caller shouldn't have got an interface to call us on.
|
|
Assert( FALSE );
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
// Ok, we need to fake a key for an object that doesn't itself support IAccIdentity,
|
|
// but which is fakeable (see CanFakeIAccIdentity for more details
|
|
// on what that means.) Basically assume it's OBJID_CLIENT, and construct
|
|
// a win32/hwnd key.
|
|
BYTE * pKeyData = (BYTE *) CoTaskMemAlloc( HWNDKEYSIZE );
|
|
if( ! pKeyData )
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
MakeHwndKey( pKeyData, m_FakeIAccPropHwnd, OBJID_CLIENT, dwIDChild );
|
|
|
|
*ppIDString = pKeyData;
|
|
*pdwIDStringLen = HWNDKEYSIZE;
|
|
|
|
return S_OK;
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// Note on member m_pAccPropID:
|
|
//
|
|
// This is a pointer to an interface on *this* object - so we don't need
|
|
// to AddRef it. It is actually important that we don't AddRef() it,
|
|
// otherwise we'd be keeping a ref to ourself - so we'd never get
|
|
// destroyed (circular ref problem).
|
|
// We get this interface pointer from QI on this object - the base
|
|
// class AccWrap_Base will only return a pointer if the object we're
|
|
// wrapping supports it too.
|
|
// As soon as we get the ptr from QI, we Release() to undo the effect
|
|
// of the AddRef in QI. It is still valid to use this pointer, however,
|
|
// since it is a pointer to ourself.
|
|
// This weirdness applies only because this is a pointer back to
|
|
// ourself. If the pointer pointed to any other object, we'd have to
|
|
// do the usual Release-only-when-done-with-ptr-eg.-in-the-dtor stuff.
|
|
//
|
|
// (Why not just cast instead of using QI? Well, the base class only
|
|
// returns a pointer via QI if the object we're wrapping also supports
|
|
// this inteface. If we did a cast, we'd always succeed, even if the
|
|
// object we're wrapping doesn't support this interface.)
|
|
//
|
|
|
|
class AccWrap_Annotate: public AccWrap_AddIAccProp
|
|
{
|
|
BOOL m_fInited;
|
|
IAccIdentity * m_pAccPropID; // See note above
|
|
|
|
// This function calls our ctor...
|
|
friend HRESULT WrapObject( IUnknown * punk, REFIID riid, void ** ppv );
|
|
|
|
|
|
AccWrap_Annotate( IUnknown * punk )
|
|
: AccWrap_AddIAccProp( punk ),
|
|
m_fInited( FALSE ),
|
|
m_pAccPropID( NULL )
|
|
{
|
|
}
|
|
|
|
|
|
~AccWrap_Annotate()
|
|
{
|
|
// We *don't* release m_pAccPropID, since it points to this object.
|
|
// See note at top of class for more details.
|
|
}
|
|
|
|
void Init()
|
|
{
|
|
if( ! m_fInited )
|
|
{
|
|
// Get the identity interface for this IAccessible - if it has one...
|
|
IAccIdentity * pAccPropID = NULL;
|
|
HRESULT hr = this->QueryInterface( IID_IAccIdentity, (void **) & pAccPropID );
|
|
if( hr == S_OK && pAccPropID )
|
|
{
|
|
m_pAccPropID = pAccPropID;
|
|
|
|
// We *must* release m_pAccPropID now, even though we're going to use it later.
|
|
// This is only because it points to this object.
|
|
// See note at top of class for more details.
|
|
m_pAccPropID->Release();
|
|
}
|
|
}
|
|
m_fInited = TRUE;
|
|
}
|
|
|
|
public:
|
|
|
|
// Factory method - the AccWrap_Base calls this when it needs to wrap outgoing
|
|
// params to the IAccessible methods.
|
|
IUnknown * WrapFactory( IUnknown * punk )
|
|
{
|
|
return static_cast<IAccessible *>( new AccWrap_Annotate( punk ) );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Forwarding methods...
|
|
|
|
|
|
BOOL GetGenericProp( VARIANT varChild, PROPINDEX idxProp, short vt, VARIANT * pvar )
|
|
{
|
|
// We do the 'check if annotation is active' check before calculating the key (in Init()).
|
|
// This saves calc'ing the key - which can be slightly expensive for out-of-proc objects
|
|
// (cross proc calls involved - at least QI.) - if nothing is using annotation anyhow.
|
|
if( varChild.vt != VT_I4 || ! PropMgrClient_CheckAlive() )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
Init();
|
|
|
|
if( ! m_pAccPropID )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BYTE * pIDString = NULL;
|
|
DWORD dwIDStringLen = 0;
|
|
HRESULT hr = m_pAccPropID->GetIdentityString( varChild.lVal, & pIDString, & dwIDStringLen );
|
|
if( hr != S_OK || pIDString == NULL )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL fLookup = PropMgrClient_LookupProp( pIDString, dwIDStringLen, idxProp, pvar );
|
|
|
|
CoTaskMemFree( pIDString );
|
|
|
|
if( ! fLookup )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// If vt is not VT_EMPTY, then check the type is what we expect...
|
|
if( vt != VT_EMPTY && pvar->vt != vt )
|
|
{
|
|
VariantClear( pvar );
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define FORWARD_BSTR( name, idProp ) /**/\
|
|
HRESULT STDMETHODCALLTYPE get_acc ## name ( VARIANT varChild, BSTR * pbstr )\
|
|
{\
|
|
VARIANT var;\
|
|
if( GetGenericProp( varChild, idProp, VT_BSTR, & var ) )\
|
|
{\
|
|
*pbstr = var.bstrVal;\
|
|
return S_OK;\
|
|
}\
|
|
return AccWrap_Base::get_acc ## name( varChild, pbstr );\
|
|
}
|
|
|
|
#define FORWARD_VTI4( name, idProp ) /**/\
|
|
HRESULT STDMETHODCALLTYPE get_acc ## name ( VARIANT varChild, VARIANT * pvar )\
|
|
{\
|
|
if( GetGenericProp( varChild, idProp, VT_I4, pvar ) )\
|
|
{\
|
|
return S_OK;\
|
|
}\
|
|
return AccWrap_Base::get_acc ## name( varChild, pvar );\
|
|
}
|
|
|
|
|
|
FORWARD_BSTR( Name, PROPINDEX_NAME )
|
|
FORWARD_BSTR( Value, PROPINDEX_VALUE )
|
|
FORWARD_BSTR( Description, PROPINDEX_DESCRIPTION )
|
|
FORWARD_BSTR( Help, PROPINDEX_HELP )
|
|
FORWARD_BSTR( KeyboardShortcut, PROPINDEX_KEYBOARDSHORTCUT )
|
|
FORWARD_BSTR( DefaultAction, PROPINDEX_DEFAULTACTION )
|
|
|
|
FORWARD_VTI4( Role, PROPINDEX_ROLE )
|
|
FORWARD_VTI4( State, PROPINDEX_STATE )
|
|
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE get_accParent( IDispatch ** ppdispParent )
|
|
{
|
|
VARIANT varChild;
|
|
varChild.vt = VT_I4;
|
|
varChild.lVal = CHILDID_SELF;
|
|
VARIANT var;
|
|
if( GetGenericProp( varChild, PROPINDEX_PARENT, VT_DISPATCH, & var ) )
|
|
{
|
|
*ppdispParent = var.pdispVal;
|
|
return S_OK;
|
|
}
|
|
|
|
return AccWrap_Base::get_accParent( ppdispParent );
|
|
}
|
|
|
|
HRESULT STDMETHODCALLTYPE get_accFocus( VARIANT * pvar )
|
|
{
|
|
VARIANT varChild;
|
|
varChild.vt = VT_I4;
|
|
varChild.lVal = CHILDID_SELF;
|
|
if( GetGenericProp( varChild, PROPINDEX_FOCUS, VT_EMPTY, pvar ) )
|
|
{
|
|
return S_OK;
|
|
}
|
|
return AccWrap_Base::get_accFocus( pvar );
|
|
}
|
|
|
|
HRESULT STDMETHODCALLTYPE get_accSelection( VARIANT * pvar )
|
|
{
|
|
VARIANT varChild;
|
|
varChild.vt = VT_I4;
|
|
varChild.lVal = CHILDID_SELF;
|
|
if( GetGenericProp( varChild, PROPINDEX_SELECTION, VT_EMPTY, pvar ) )
|
|
{
|
|
return S_OK;
|
|
}
|
|
return AccWrap_Base::get_accSelection( pvar );
|
|
}
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE accNavigate( long NavDir, VARIANT varStart, VARIANT * pvar )
|
|
{
|
|
PROPINDEX idxProp;
|
|
|
|
switch( NavDir )
|
|
{
|
|
case NAVDIR_UP: idxProp = PROPINDEX_NAV_UP; break;
|
|
case NAVDIR_DOWN: idxProp = PROPINDEX_NAV_DOWN; break;
|
|
case NAVDIR_LEFT: idxProp = PROPINDEX_NAV_LEFT; break;
|
|
case NAVDIR_RIGHT: idxProp = PROPINDEX_NAV_RIGHT; break;
|
|
case NAVDIR_NEXT: idxProp = PROPINDEX_NAV_NEXT; break;
|
|
case NAVDIR_PREVIOUS: idxProp = PROPINDEX_NAV_RIGHT; break;
|
|
case NAVDIR_LASTCHILD: idxProp = PROPINDEX_NAV_LASTCHILD; break;
|
|
case NAVDIR_FIRSTCHILD: idxProp = PROPINDEX_NAV_FIRSTCHILD; break;
|
|
|
|
default:
|
|
return AccWrap_Base::accNavigate( NavDir, varStart, pvar );
|
|
}
|
|
|
|
if( GetGenericProp( varStart, idxProp, VT_EMPTY, pvar ) )
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
return AccWrap_Base::accNavigate( NavDir, varStart, pvar );
|
|
}
|
|
|
|
|
|
HRESULT STDMETHODCALLTYPE accDoDefaultAction( VARIANT varChild )
|
|
{
|
|
VARIANT varResult;
|
|
if( GetGenericProp( varChild, PROPINDEX_DODEFAULTACTION, VT_I4, & varResult ) )
|
|
{
|
|
return varResult.lVal;
|
|
}
|
|
return AccWrap_Base::accDoDefaultAction( varChild );
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
//
|
|
// AccessibleObjectFromWindow calls this to wrap outgoing objects...
|
|
//
|
|
|
|
|
|
HRESULT WrapObject( IUnknown * punk, REFIID riid, void ** ppv )
|
|
{
|
|
if( AccWrap_Base::AlreadyWrapped( punk ) )
|
|
{
|
|
return punk->QueryInterface( riid, ppv );
|
|
}
|
|
else
|
|
{
|
|
IUnknown * punkWrap = (IAccessible *) new AccWrap_Annotate( punk );
|
|
// TODO - error check if NULL...
|
|
if( ! punkWrap )
|
|
return E_OUTOFMEMORY;
|
|
|
|
HRESULT hr = punkWrap->QueryInterface( riid, ppv );
|
|
punkWrap->Release();
|
|
|
|
return hr;
|
|
}
|
|
}
|