///////////////////////////////////////////////////////////////////////////////
-// Name: msw/ole/access.cpp
+// Name: src/msw/ole/access.cpp
// Purpose: implementation of wxIAccessible and wxAccessible
// Author: Julian Smart
// Modified by:
// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "access.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#if defined(__BORLANDC__)
#pragma hdrstop
#endif
-#ifndef WX_PRECOMP
-#include "wx/window.h"
-#endif
-
-#include "wx/setup.h"
#if wxUSE_OLE && wxUSE_ACCESSIBILITY
-#include "wx/log.h"
#include "wx/access.h"
-#include <windows.h>
+#ifndef WX_PRECOMP
+ #include "wx/msw/wrapwin.h"
+ #include "wx/window.h"
+ #include "wx/log.h"
+#endif
// for some compilers, the entire ole2.h must be included, not only oleauto.h
#if wxUSE_NORLANDER_HEADERS || defined(__WATCOMC__)
#include <oleauto.h>
#include <oleacc.h>
+#include <winable.h>
#include "wx/msw/ole/oleutils.h"
// Convert from Windows selection flag
wxAccSelectionFlags wxConvertFromWindowsSelFlag(int sel);
+#if wxUSE_VARIANT
// ----------------------------------------------------------------------------
// wxIEnumVARIANT interface implementation
// ----------------------------------------------------------------------------
{
public:
wxIEnumVARIANT(const wxVariant& variant);
- ~wxIEnumVARIANT() { }
+ virtual ~wxIEnumVARIANT() { }
DECLARE_IUNKNOWN_METHODS;
return S_OK;
}
+#endif // wxUSE_VARIANT
// ----------------------------------------------------------------------------
// wxIAccessible implementation of IAccessible interface
// Navigation and Hierarchy
// Retrieves the child element or child object at a given point on the screen.
- // All visual objects support this method; sound objects do not support it.
+ // All visual objects support this method; sound objects do not support it.
STDMETHODIMP accHitTest(long xLeft, long yLeft, VARIANT* pVarID);
// Retrieves the specified object's current screen location. All visual objects must
- // support this method; sound objects do not support it.
+ // support this method; sound objects do not support it.
STDMETHODIMP accLocation ( long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varID);
// Retrieves the address of an IDispatch interface for the specified child.
// All objects must support this property.
-
+
STDMETHODIMP get_accChild ( VARIANT varChildID, IDispatch** ppDispChild);
// Retrieves the number of children that belong to this object.
// All objects must support this property.
-
+
STDMETHODIMP get_accChildCount ( long* pCountChildren);
// Retrieves the IDispatch interface of the object's parent.
// All objects support this property.
-
+
STDMETHODIMP get_accParent ( IDispatch** ppDispParent);
// Descriptive Properties and Methods
// Performs the object's default action. Not all objects have a default
// action.
-
+
STDMETHODIMP accDoDefaultAction(VARIANT varID);
// Retrieves a string that describes the object's default action.
// Not all objects have a default action.
-
+
STDMETHODIMP get_accDefaultAction ( VARIANT varID, BSTR* pszDefaultAction);
// Retrieves a string that describes the visual appearance of the specified object.
// Retrieves the full path of the WinHelp file associated with the specified
// object and the identifier of the appropriate topic within that file.
// Not all objects support this property.
-
+
STDMETHODIMP get_accHelpTopic ( BSTR* pszHelpFile, VARIANT varChild, long* pidTopic);
// Retrieves the specified object's shortcut key or access key, also known as
// the mnemonic. All objects that have a shortcut key or access key support
// this property.
-
+
STDMETHODIMP get_accKeyboardShortcut ( VARIANT varID, BSTR* pszKeyboardShortcut);
// Retrieves the name of the specified object.
// All objects support this property.
-
+
STDMETHODIMP get_accName ( VARIANT varID, BSTR* pszName);
// Retrieves information that describes the role of the specified object.
// Retrieves the current state of the specified object.
// All objects support this property.
-
+
STDMETHODIMP get_accState ( VARIANT varID, VARIANT* pVarState);
-
+
// Retrieves the value of the specified object.
// Not all objects have a value.
// Retrieves the object that has the keyboard focus. All objects
// that receive the keyboard focus must support this property.
-
+
STDMETHODIMP get_accFocus ( VARIANT* pVarID);
// Retrieves the selected children of this object. All objects
// selected must support this property.
-
+
STDMETHODIMP get_accSelection ( VARIANT * pVarChildren);
// Obsolete
- STDMETHODIMP put_accName(VARIANT varChild, BSTR szName) { return E_FAIL; }
- STDMETHODIMP put_accValue(VARIANT varChild, BSTR szName) { return E_FAIL; }
+ STDMETHODIMP put_accName(VARIANT WXUNUSED(varChild), BSTR WXUNUSED(szName)) { return E_FAIL; }
+ STDMETHODIMP put_accValue(VARIANT WXUNUSED(varChild), BSTR WXUNUSED(szName)) { return E_FAIL; }
// IDispatch
// Invoke
- STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
- WORD wFlags, DISPPARAMS *pDispParams,
- VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
+ STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
+ WORD wFlags, DISPPARAMS *pDispParams,
+ VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
unsigned int *puArgErr );
+// Helpers
+
+ // Gets the standard IAccessible interface for the given child or object.
+ // Call Release if this is non-NULL.
+ IAccessible* GetChildStdAccessible(int id);
+
+ // Gets the IAccessible interface for the given child or object.
+ // Call Release if this is non-NULL.
+ IAccessible* GetChildAccessible(int id);
+
private:
wxAccessible *m_pAccessible; // pointer to C++ class we belong to
}
// Retrieves the child element or child object at a given point on the screen.
-// All visual objects support this method; sound objects do not support it.
+// All visual objects support this method; sound objects do not support it.
STDMETHODIMP wxIAccessible::accHitTest(long xLeft, long yLeft, VARIANT* pVarID)
{
+ wxLogTrace(wxT("access"), wxT("accHitTest"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
+
wxAccessible* childObject = NULL;
int childId = 0;
VariantInit(pVarID);
-
+
wxAccStatus status = m_pAccessible->HitTest(wxPoint(xLeft, yLeft), & childId, & childObject);
-
+
if (status == wxACC_FAIL)
return E_FAIL;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
// Use standard interface instead.
IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
if (!stdInterface)
- return E_FAIL;
+ return E_NOTIMPL;
else
return stdInterface->accHitTest(xLeft, yLeft, pVarID);
}
-
+
if (childObject)
{
if (childObject == m_pAccessible)
{
wxIAccessible* childIA = childObject->GetIAccessible();
if (!childIA)
+ return E_NOTIMPL;
+
+ if (childIA->QueryInterface(IID_IDispatch, (LPVOID*) & pVarID->pdispVal) != S_OK)
return E_FAIL;
- if (childIA->QueryInterface(IID_IDispatch, (LPVOID*) pVarID->pdispVal) != S_OK)
- return E_FAIL;
-
pVarID->vt = VT_DISPATCH;
- pVarID->pdispVal->AddRef();
return S_OK;
}
}
pVarID->vt = VT_EMPTY;
return S_FALSE;
}
-
- return E_FAIL;
+
+ #if 0
+ // all cases above already cause some return action so below line
+ // is unreachable and cause unnecessary warning
+ return E_NOTIMPL;
+ #endif
}
// Retrieves the specified object's current screen location. All visual objects must
-// support this method; sound objects do not support it.
+// support this method; sound objects do not support it.
STDMETHODIMP wxIAccessible::accLocation ( long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varID)
{
+ wxLogTrace(wxT("access"), wxT("accLocation"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
+
wxRect rect;
wxAccStatus status = m_pAccessible->GetLocation(rect, varID.lVal);
if (status == wxACC_FAIL)
return E_FAIL;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
- // Use standard interface instead.
- IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
- if (!stdInterface)
- return E_FAIL;
- else
- return stdInterface->accLocation(pxLeft, pyTop, pcxWidth, pcyHeight, varID);
+ // Try to use child object directly.
+ if (varID.lVal > 0)
+ {
+ IAccessible* childAccessible = GetChildAccessible(varID.lVal);
+ if (childAccessible)
+ {
+ varID.lVal = 0;
+ HRESULT hResult = childAccessible->accLocation(pxLeft, pyTop, pcxWidth, pcyHeight, varID);
+ childAccessible->Release();
+ return hResult;
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accLocation(pxLeft, pyTop, pcxWidth, pcyHeight, varID);
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accLocation(pxLeft, pyTop, pcxWidth, pcyHeight, varID);
}
else
{
return S_OK;
}
- return E_FAIL;
+ return E_NOTIMPL;
}
// Traverses to another user interface element within a container and retrieves the object.
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
- if (varStart.vt != VT_I4)
+ wxLogTrace(wxT("access"), wxString(wxT("accNavigate for ")) + m_pAccessible->GetWindow()->GetClassInfo()->GetClassName());
+
+ if ((varStart.vt != VT_I4 && varStart.vt != VT_EMPTY)
+ #if 0
+ // according to MSDN and sources varStart.vt is unsigned
+ // so below line cause warning "Condition is always false"
+ || varStart.vt < 0
+ #endif
+ )
+ {
+ wxLogTrace(wxT("access"), wxT("Invalid arg for accNavigate"));
return E_INVALIDARG;
-
+ }
+
wxAccessible* elementObject = NULL;
int elementId = 0;
VariantInit(pVarEnd);
wxNavDir navDirWX = wxNAVDIR_FIRSTCHILD;
+ wxString navStr;
+
switch (navDir)
{
case NAVDIR_DOWN:
navDirWX = wxNAVDIR_DOWN;
+ navStr = wxT("wxNAVDIR_DOWN");
break;
case NAVDIR_FIRSTCHILD:
navDirWX = wxNAVDIR_FIRSTCHILD;
+ navStr = wxT("wxNAVDIR_FIRSTCHILD");
break;
case NAVDIR_LASTCHILD:
navDirWX = wxNAVDIR_LASTCHILD;
+ navStr = wxT("wxNAVDIR_LASTCHILD");
break;
case NAVDIR_LEFT:
navDirWX = wxNAVDIR_LEFT;
+ navStr = wxT("wxNAVDIR_LEFT");
break;
case NAVDIR_NEXT:
navDirWX = wxNAVDIR_NEXT;
+ navStr = wxT("wxNAVDIR_NEXT");
break;
case NAVDIR_PREVIOUS:
navDirWX = wxNAVDIR_PREVIOUS;
+ navStr = wxT("wxNAVDIR_PREVIOUS");
break;
case NAVDIR_RIGHT:
navDirWX = wxNAVDIR_RIGHT;
+ navStr = wxT("wxNAVDIR_RIGHT");
break;
case NAVDIR_UP:
navDirWX = wxNAVDIR_UP;
+ navStr = wxT("wxNAVDIR_UP");
break;
+ default:
+ {
+ wxLogTrace(wxT("access"), wxT("Unknown NAVDIR symbol"));
+ break;
+ }
}
-
+ wxLogTrace(wxT("access"), navStr);
+
wxAccStatus status = m_pAccessible->Navigate(navDirWX, varStart.lVal, & elementId,
& elementObject);
if (status == wxACC_FAIL)
+ {
+ wxLogTrace(wxT("access"), wxT("wxAccessible::Navigate failed"));
return E_FAIL;
-
+ }
+
+ if (status == wxACC_FALSE)
+ {
+ wxLogTrace(wxT("access"), wxT("wxAccessible::Navigate found no object in this direction"));
+ return S_FALSE;
+ }
+
if (status == wxACC_NOT_IMPLEMENTED)
{
- // Use standard interface instead.
- IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
- if (!stdInterface)
- return E_FAIL;
- else
- return stdInterface->accNavigate ( navDir, varStart, pVarEnd);
+ wxLogTrace(wxT("access"), wxT("Navigate not implemented"));
+
+ // Try to use child object directly.
+ if (varStart.vt == VT_I4 && varStart.lVal > 0)
+ {
+ IAccessible* childAccessible = GetChildAccessible(varStart.lVal);
+ if (childAccessible)
+ {
+ varStart.lVal = 0;
+ HRESULT hResult = childAccessible->accNavigate(navDir, varStart, pVarEnd);
+ childAccessible->Release();
+ return hResult;
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accNavigate(navDir, varStart, pVarEnd);
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accNavigate(navDir, varStart, pVarEnd);
}
else
{
if (elementObject)
{
+ wxLogTrace(wxT("access"), wxT("Getting wxIAccessible and calling QueryInterface for Navigate"));
wxIAccessible* objectIA = elementObject->GetIAccessible();
if (!objectIA)
+ {
+ wxLogTrace(wxT("access"), wxT("No wxIAccessible"));
+ return E_FAIL;
+ }
+
+ HRESULT hResult = objectIA->QueryInterface(IID_IDispatch, (LPVOID*) & pVarEnd->pdispVal);
+ if (hResult != S_OK)
+ {
+ wxLogTrace(wxT("access"), wxT("QueryInterface failed"));
return E_FAIL;
+ }
- if (objectIA->QueryInterface(IID_IDispatch, (LPVOID*) pVarEnd->pdispVal) != S_OK)
- return E_FAIL;
-
+ wxLogTrace(wxT("access"), wxT("Called QueryInterface for Navigate"));
pVarEnd->vt = VT_DISPATCH;
- pVarEnd->pdispVal->AddRef();
return S_OK;
}
else if (elementId > 0)
{
+ wxLogTrace(wxT("access"), wxT("Returning element id from Navigate"));
pVarEnd->vt = VT_I4;
pVarEnd->lVal = elementId;
return S_OK;
}
else
{
+ wxLogTrace(wxT("access"), wxT("No object in accNavigate"));
pVarEnd->vt = VT_EMPTY;
return S_FALSE;
}
}
- return E_FAIL;
+ wxLogTrace(wxT("access"), wxT("Failing Navigate"));
+ return E_NOTIMPL;
}
// Retrieves the address of an IDispatch interface for the specified child.
// All objects must support this property.
-
+
STDMETHODIMP wxIAccessible::get_accChild ( VARIANT varChildID, IDispatch** ppDispChild)
{
+ wxLogTrace(wxT("access"), wxT("get_accChild"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
+
if (varChildID.vt != VT_I4)
+ {
+ wxLogTrace(wxT("access"), wxT("Invalid arg for get_accChild"));
return E_INVALIDARG;
+ }
if (varChildID.lVal == CHILDID_SELF)
{
AddRef();
return S_OK;
}
-
+
wxAccessible* child = NULL;
wxAccStatus status = m_pAccessible->GetChild(varChildID.lVal, & child);
if (status == wxACC_FAIL)
+ {
+ wxLogTrace(wxT("access"), wxT("GetChild failed"));
return E_FAIL;
-
+ }
+
if (status == wxACC_NOT_IMPLEMENTED)
{
// Use standard interface instead.
IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
if (!stdInterface)
- return E_FAIL;
+ return E_NOTIMPL;
else
+ {
+ wxLogTrace(wxT("access"), wxT("Using standard interface for get_accChild"));
return stdInterface->get_accChild (varChildID, ppDispChild);
+ }
}
else
{
{
wxIAccessible* objectIA = child->GetIAccessible();
if (!objectIA)
+ return E_NOTIMPL;
+
+ if (objectIA->QueryInterface(IID_IDispatch, (LPVOID*) ppDispChild) != S_OK)
+ {
+ wxLogTrace(wxT("access"), wxT("QueryInterface failed in get_accChild"));
return E_FAIL;
- *ppDispChild = objectIA;
- objectIA->AddRef();
+ }
+
return S_OK;
}
else
+ {
+ wxLogTrace(wxT("access"), wxT("Not an accessible object"));
return S_FALSE; // Indicates it's not an accessible object
+ }
}
- return E_FAIL;
+ #if 0
+ // all cases above already cause some return action so below line
+ // is unreachable and cause unnecessary warning
+ return E_NOTIMPL;
+ #endif
}
// Retrieves the number of children that belong to this object.
// All objects must support this property.
-
+
STDMETHODIMP wxIAccessible::get_accChildCount ( long* pCountChildren)
{
+ wxLogTrace(wxT("access"), wxT("get_accChildCount"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
+
int childCount = 0;
wxAccStatus status = m_pAccessible->GetChildCount(& childCount);
if (status == wxACC_FAIL)
return E_FAIL;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
// Use standard interface instead.
IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
if (!stdInterface)
- return E_FAIL;
+ return E_NOTIMPL;
else
- return stdInterface->get_accChildCount (pCountChildren);
+ {
+ wxLogTrace(wxT("access"), wxT("Using standard interface for get_accChildCount"));
+ HRESULT res = stdInterface->get_accChildCount (pCountChildren);
+ wxString str;
+ str.Printf(wxT("Number of children was %d"), (int) (*pCountChildren));
+ wxLogTrace(wxT("access"), str);
+ return res;
+ }
}
else
{
return S_OK;
}
- return E_FAIL;
+ #if 0
+ // all cases above already cause some return action so below line
+ // is unreachable and cause unnecessary warning
+ return E_NOTIMPL;
+ #endif
}
// Retrieves the IDispatch interface of the object's parent.
// All objects support this property.
-
+
STDMETHODIMP wxIAccessible::get_accParent ( IDispatch** ppDispParent)
{
+ wxLogTrace(wxT("access"), wxT("get_accParent"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
+
wxAccessible* parent = NULL;
wxAccStatus status = m_pAccessible->GetParent(& parent);
+
if (status == wxACC_FAIL)
return E_FAIL;
-
- if (status == wxACC_NOT_IMPLEMENTED)
+
+ // It doesn't seem acceptable to return S_FALSE with a NULL
+ // ppDispParent, so if we have no wxWidgets parent, we leave
+ // it to the standard interface.
+ if (status == wxACC_NOT_IMPLEMENTED || !parent)
{
+ wxLogTrace(wxT("access"), wxT("Using standard interface to get the parent."));
// Use standard interface instead.
IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
if (!stdInterface)
- return E_FAIL;
+ return E_NOTIMPL;
else
return stdInterface->get_accParent (ppDispParent);
}
if (!objectIA)
return E_FAIL;
- if (objectIA->QueryInterface(IID_IDispatch, (LPVOID*) ppDispParent) != S_OK)
- return E_FAIL;
-
- (*ppDispParent)->AddRef();
- return S_OK;
-/*
- wxIAccessible* objectIA = parent->GetIAccessible();
- if (!objectIA)
+ wxLogTrace(wxT("access"), wxT("About to call QueryInterface"));
+ if (objectIA->QueryInterface(IID_IDispatch, (LPVOID*) ppDispParent) != S_OK)
+ {
+ wxLogTrace(wxT("access"), wxT("Failed QueryInterface"));
return E_FAIL;
- objectIA->AddRef();
- *ppDispParent = objectIA;
+ }
+
+ wxLogTrace(wxT("access"), wxT("Returning S_OK for get_accParent"));
return S_OK;
-*/
}
else
{
+ // This doesn't seem to be allowed, despite the documentation,
+ // so we handle it higher up by using the standard interface.
+ wxLogTrace(wxT("access"), wxT("Returning NULL parent because there was none"));
*ppDispParent = NULL;
- return S_OK;
+ return S_FALSE;
}
}
- return E_FAIL;
+ #if 0
+ // all cases above already cause some return action so below line
+ // is unreachable and cause unnecessary warning
+ return E_NOTIMPL;
+ #endif
}
// Performs the object's default action. Not all objects have a default
// action.
-
+
STDMETHODIMP wxIAccessible::accDoDefaultAction(VARIANT varID)
{
+ wxLogTrace(wxT("access"), wxT("accDoDefaultAction"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
+
if (varID.vt != VT_I4)
+ {
+ wxLogTrace(wxT("access"), wxT("Invalid arg for accDoDefaultAction"));
return E_INVALIDARG;
-
+ }
+
wxAccStatus status = m_pAccessible->DoDefaultAction(varID.lVal);
if (status == wxACC_FAIL)
return E_FAIL;
if (status == wxACC_NOT_SUPPORTED)
return DISP_E_MEMBERNOTFOUND;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
- // Use standard interface instead.
- IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
- if (!stdInterface)
- return E_FAIL;
- else
- return stdInterface->accDoDefaultAction(varID);
+ // Try to use child object directly.
+ if (varID.lVal > 0)
+ {
+ IAccessible* childAccessible = GetChildAccessible(varID.lVal);
+ if (childAccessible)
+ {
+ varID.lVal = 0;
+ HRESULT hResult = childAccessible->accDoDefaultAction(varID);
+ childAccessible->Release();
+ return hResult;
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accDoDefaultAction(varID);
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accDoDefaultAction(varID);
}
return E_FAIL;
}
// Retrieves a string that describes the object's default action.
// Not all objects have a default action.
-
+
STDMETHODIMP wxIAccessible::get_accDefaultAction ( VARIANT varID, BSTR* pszDefaultAction)
{
+ wxLogTrace(wxT("access"), wxT("get_accDefaultAction"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
+
if (varID.vt != VT_I4)
+ {
+ wxLogTrace(wxT("access"), wxT("Invalid arg for get_accDefaultAction"));
return E_INVALIDARG;
-
+ }
+
wxString defaultAction;
wxAccStatus status = m_pAccessible->GetDefaultAction(varID.lVal, & defaultAction);
if (status == wxACC_FAIL)
return E_FAIL;
-
+
if (status == wxACC_NOT_SUPPORTED)
return DISP_E_MEMBERNOTFOUND;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
- // Use standard interface instead.
- IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
- if (!stdInterface)
- return E_FAIL;
- else
- return stdInterface->get_accDefaultAction (varID, pszDefaultAction);
+ // Try to use child object directly.
+ if (varID.lVal > 0)
+ {
+ IAccessible* childAccessible = GetChildAccessible(varID.lVal);
+ if (childAccessible)
+ {
+ varID.lVal = 0;
+ HRESULT hResult = childAccessible->get_accDefaultAction(varID, pszDefaultAction);
+ childAccessible->Release();
+ return hResult;
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accDefaultAction(varID, pszDefaultAction);
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accDefaultAction(varID, pszDefaultAction);
}
else
{
STDMETHODIMP wxIAccessible::get_accDescription ( VARIANT varID, BSTR* pszDescription)
{
+ wxLogTrace(wxT("access"), wxT("get_accDescription"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
+
if (varID.vt != VT_I4)
+ {
+ wxLogTrace(wxT("access"), wxT("Invalid arg for get_accDescription"));
return E_INVALIDARG;
-
+ }
+
wxString description;
wxAccStatus status = m_pAccessible->GetDescription(varID.lVal, & description);
if (status == wxACC_FAIL)
return E_FAIL;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
- // Use standard interface instead.
- IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
- if (!stdInterface)
- return E_FAIL;
- else
- return stdInterface->get_accDescription (varID, pszDescription);
+ // Try to use child object directly.
+ if (varID.lVal > 0)
+ {
+ IAccessible* childAccessible = GetChildAccessible(varID.lVal);
+ if (childAccessible)
+ {
+ varID.lVal = 0;
+ HRESULT hResult = childAccessible->get_accDescription(varID, pszDescription);
+ childAccessible->Release();
+ return hResult;
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accDescription(varID, pszDescription);
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accDescription(varID, pszDescription);
}
else
{
- if (description.IsEmpty())
+ if (description.empty())
{
* pszDescription = NULL;
return S_FALSE;
wxBasicString basicString(description);
* pszDescription = basicString.Get();
return S_OK;
- }
+ }
}
- return E_FAIL;
+ return E_NOTIMPL;
}
// Retrieves an object's Help property string.
STDMETHODIMP wxIAccessible::get_accHelp ( VARIANT varID, BSTR* pszHelp)
{
+ wxLogTrace(wxT("access"), wxT("get_accHelp"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
+
if (varID.vt != VT_I4)
+ {
+ wxLogTrace(wxT("access"), wxT("Invalid arg for get_accHelp"));
return E_INVALIDARG;
-
+ }
+
wxString helpString;
wxAccStatus status = m_pAccessible->GetHelpText(varID.lVal, & helpString);
if (status == wxACC_FAIL)
return E_FAIL;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
- // Use standard interface instead.
- IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
- if (!stdInterface)
- return E_FAIL;
- else
- return stdInterface->get_accHelp (varID, pszHelp);
+ // Try to use child object directly.
+ if (varID.lVal > 0)
+ {
+ IAccessible* childAccessible = GetChildAccessible(varID.lVal);
+ if (childAccessible)
+ {
+ varID.lVal = 0;
+ HRESULT hResult = childAccessible->get_accHelp(varID, pszHelp);
+ childAccessible->Release();
+ return hResult;
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accHelp(varID, pszHelp);
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accHelp (varID, pszHelp);
}
else
{
- if (helpString.IsEmpty())
+ if (helpString.empty())
{
* pszHelp = NULL;
return S_FALSE;
wxBasicString basicString(helpString);
* pszHelp = basicString.Get();
return S_OK;
- }
+ }
}
- return E_FAIL;
+ return E_NOTIMPL;
}
// Retrieves the full path of the WinHelp file associated with the specified
// object and the identifier of the appropriate topic within that file.
// Not all objects support this property.
-// NOTE: not supported by wxWindows at this time. Use
+// NOTE: not supported by wxWidgets at this time. Use
// GetHelpText instead.
-
+
STDMETHODIMP wxIAccessible::get_accHelpTopic ( BSTR* pszHelpFile, VARIANT varChild, long* pidTopic)
{
+ wxLogTrace(wxT("access"), wxT("get_accHelpTopic"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
+
if (varChild.vt != VT_I4)
+ {
+ wxLogTrace(wxT("access"), wxT("Invalid arg for get_accHelpTopic"));
return E_INVALIDARG;
-
+ }
+
wxAccStatus status = wxACC_NOT_IMPLEMENTED;
if (status == wxACC_FAIL)
return E_FAIL;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
- // Use standard interface instead.
- IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
- if (!stdInterface)
- return E_FAIL;
- else
- return stdInterface->get_accHelpTopic (pszHelpFile, varChild, pidTopic);
+ // Try to use child object directly.
+ if (varChild.lVal > 0)
+ {
+ IAccessible* childAccessible = GetChildAccessible(varChild.lVal);
+ if (childAccessible)
+ {
+ varChild.lVal = 0;
+ HRESULT hResult = childAccessible->get_accHelpTopic(pszHelpFile, varChild, pidTopic);
+ childAccessible->Release();
+ return hResult;
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accHelpTopic(pszHelpFile, varChild, pidTopic);
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accHelpTopic (pszHelpFile, varChild, pidTopic);
}
- return E_FAIL;
+ return E_NOTIMPL;
}
// Retrieves the specified object's shortcut key or access key, also known as
// the mnemonic. All objects that have a shortcut key or access key support
// this property.
-
+
STDMETHODIMP wxIAccessible::get_accKeyboardShortcut ( VARIANT varID, BSTR* pszKeyboardShortcut)
{
+ wxLogTrace(wxT("access"), wxT("get_accKeyboardShortcut"));
*pszKeyboardShortcut = NULL;
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
+
if (varID.vt != VT_I4)
+ {
+ wxLogTrace(wxT("access"), wxT("Invalid arg for get_accKeyboardShortcut"));
return E_INVALIDARG;
-
+ }
+
wxString keyboardShortcut;
- wxAccStatus status = m_pAccessible->GetHelpText(varID.lVal, & keyboardShortcut);
+ wxAccStatus status = m_pAccessible->GetKeyboardShortcut(varID.lVal, & keyboardShortcut);
if (status == wxACC_FAIL)
return E_FAIL;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
- // Use standard interface instead.
- IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
- if (!stdInterface)
- return E_FAIL;
- else
- return stdInterface->get_accKeyboardShortcut(varID, pszKeyboardShortcut);
+ // Try to use child object directly.
+ if (varID.lVal > 0)
+ {
+ IAccessible* childAccessible = GetChildAccessible(varID.lVal);
+ if (childAccessible)
+ {
+ varID.lVal = 0;
+ HRESULT hResult = childAccessible->get_accKeyboardShortcut(varID, pszKeyboardShortcut);
+ childAccessible->Release();
+ return hResult;
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accKeyboardShortcut(varID, pszKeyboardShortcut);
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accKeyboardShortcut (varID, pszKeyboardShortcut);
}
else
{
- if (keyboardShortcut.IsEmpty())
+ if (keyboardShortcut.empty())
{
* pszKeyboardShortcut = NULL;
return S_FALSE;
wxBasicString basicString(keyboardShortcut);
* pszKeyboardShortcut = basicString.Get();
return S_OK;
- }
+ }
}
- return E_FAIL;
+ return E_NOTIMPL;
}
// Retrieves the name of the specified object.
// All objects support this property.
-
+
STDMETHODIMP wxIAccessible::get_accName ( VARIANT varID, BSTR* pszName)
{
+ wxLogTrace(wxT("access"), wxT("get_accName"));
*pszName = NULL;
wxASSERT (m_pAccessible != NULL);
return E_FAIL;
if (varID.vt != VT_I4)
+ {
+ wxLogTrace(wxT("access"), wxT("Invalid arg for get_accName"));
return E_INVALIDARG;
-
+ }
+
wxString name;
-
+
wxAccStatus status = m_pAccessible->GetName(varID.lVal, & name);
-
+
if (status == wxACC_FAIL)
return E_FAIL;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
- // Use standard interface instead.
- IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
- if (!stdInterface)
- return E_FAIL;
- else
- return stdInterface->get_accName (varID, pszName);
+ // Try to use child object directly.
+ if (varID.lVal > 0)
+ {
+ IAccessible* childAccessible = GetChildAccessible(varID.lVal);
+ if (childAccessible)
+ {
+ varID.lVal = 0;
+ HRESULT hResult = childAccessible->get_accName(varID, pszName);
+ childAccessible->Release();
+ return hResult;
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accName(varID, pszName);
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accName (varID, pszName);
}
else
{
*pszName = basicString.Get();
return S_OK;
}
- return E_FAIL;
+ return E_NOTIMPL;
}
// Retrieves information that describes the role of the specified object.
STDMETHODIMP wxIAccessible::get_accRole ( VARIANT varID, VARIANT* pVarRole)
{
+ wxLogTrace(wxT("access"), wxT("get_accRole"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
+
if (varID.vt != VT_I4)
+ {
+ wxLogTrace(wxT("access"), wxT("Invalid arg for get_accRole"));
return E_INVALIDARG;
-
+ }
+
VariantInit(pVarRole);
wxAccRole role = wxROLE_NONE;
-
+
wxAccStatus status = m_pAccessible->GetRole(varID.lVal, & role);
-
+
if (status == wxACC_FAIL)
return E_FAIL;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
- // Use standard interface instead.
- IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
- if (!stdInterface)
- return E_FAIL;
- else
- return stdInterface->get_accRole (varID, pVarRole);
+ // Try to use child object directly.
+ if (varID.lVal > 0)
+ {
+ IAccessible* childAccessible = GetChildAccessible(varID.lVal);
+ if (childAccessible)
+ {
+ varID.lVal = 0;
+ HRESULT hResult = childAccessible->get_accRole(varID, pVarRole);
+ childAccessible->Release();
+ return hResult;
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accRole(varID, pVarRole);
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accRole (varID, pVarRole);
}
else
{
return S_OK;
}
- return E_FAIL;
+ return E_NOTIMPL;
}
// Retrieves the current state of the specified object.
// All objects support this property.
-
+
STDMETHODIMP wxIAccessible::get_accState ( VARIANT varID, VARIANT* pVarState)
{
+ wxLogTrace(wxT("access"), wxT("get_accState"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
- if (varID.vt != VT_I4)
+
+ if (varID.vt != VT_I4 && varID.vt != VT_EMPTY)
+ {
+ wxLogTrace(wxT("access"), wxT("Invalid arg for get_accState"));
return E_INVALIDARG;
+ }
long wxstate = 0;
-
+
wxAccStatus status = m_pAccessible->GetState(varID.lVal, & wxstate);
if (status == wxACC_FAIL)
return E_FAIL;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
- // Use standard interface instead.
- IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
- if (!stdInterface)
- return E_FAIL;
- else
- return stdInterface->get_accState (varID, pVarState);
+ // Try to use child object directly.
+ if (varID.lVal > 0)
+ {
+ IAccessible* childAccessible = GetChildAccessible(varID.lVal);
+ if (childAccessible)
+ {
+ varID.lVal = 0;
+ HRESULT hResult = childAccessible->get_accState(varID, pVarState);
+ childAccessible->Release();
+ return hResult;
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accState(varID, pVarState);
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accState (varID, pVarState);
}
else
{
pVarState->vt = VT_I4;
return S_OK;
}
- return E_FAIL;
+ return E_NOTIMPL;
}
-
+
// Retrieves the value of the specified object.
// Not all objects have a value.
STDMETHODIMP wxIAccessible::get_accValue ( VARIANT varID, BSTR* pszValue)
{
+ wxLogTrace(wxT("access"), wxT("get_accValue"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
+
if (varID.vt != VT_I4)
+ {
+ wxLogTrace(wxT("access"), wxT("Invalid arg for get_accValue"));
return E_INVALIDARG;
-
+ }
+
wxString strValue;
-
+
wxAccStatus status = m_pAccessible->GetValue(varID.lVal, & strValue);
-
+
if (status == wxACC_FAIL)
return E_FAIL;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
- // Use standard interface instead.
- IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
- if (!stdInterface)
- return E_FAIL;
- else
- return stdInterface->get_accValue (varID, pszValue);
+ // Try to use child object directly.
+ if (varID.lVal > 0)
+ {
+ IAccessible* childAccessible = GetChildAccessible(varID.lVal);
+ if (childAccessible)
+ {
+ varID.lVal = 0;
+ HRESULT hResult = childAccessible->get_accValue(varID, pszValue);
+ childAccessible->Release();
+ return hResult;
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accValue(varID, pszValue);
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->get_accValue (varID, pszValue);
}
else
{
* pszValue = basicString.Get();
return S_OK;
}
- return E_FAIL;
+ return E_NOTIMPL;
}
// Modifies the selection or moves the keyboard focus of the
STDMETHODIMP wxIAccessible::accSelect ( long flagsSelect, VARIANT varID )
{
+ wxLogTrace(wxT("access"), wxT("get_accSelect"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
- if (varID.vt != VT_I4)
+
+ if (varID.vt != VT_I4 && varID.vt != VT_EMPTY)
+ {
+ wxLogTrace(wxT("access"), wxT("Invalid arg for accSelect"));
return E_INVALIDARG;
-
+ }
+
wxAccSelectionFlags wxsel = wxConvertFromWindowsSelFlag(flagsSelect);
wxAccStatus status = m_pAccessible->Select(varID.lVal, wxsel);
if (status == wxACC_FAIL)
return E_FAIL;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
- // Use standard interface instead.
- IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
- if (!stdInterface)
- return E_FAIL;
- else
- return stdInterface->accSelect ( flagsSelect, varID );
+ // Try to use child object directly.
+ if (varID.lVal > 0 && varID.lVal > 0)
+ {
+ IAccessible* childAccessible = GetChildAccessible(varID.lVal);
+ if (childAccessible)
+ {
+ varID.lVal = 0;
+ HRESULT hResult = childAccessible->accSelect(flagsSelect, varID);
+ childAccessible->Release();
+ return hResult;
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accSelect(flagsSelect, varID);
+ }
+ else if (m_pAccessible->GetIAccessibleStd())
+ return ((IAccessible*) m_pAccessible->GetIAccessibleStd())->accSelect(flagsSelect, varID);
}
else
return S_OK;
- return E_FAIL;
+ return E_NOTIMPL;
}
// Retrieves the object that has the keyboard focus. All objects
// that receive the keyboard focus must support this property.
-
+
STDMETHODIMP wxIAccessible::get_accFocus ( VARIANT* pVarID)
{
+ wxLogTrace(wxT("access"), wxT("get_accFocus"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
-
+
wxAccessible* childObject = NULL;
int childId = 0;
VariantInit(pVarID);
-
+
wxAccStatus status = m_pAccessible->GetFocus(& childId, & childObject);
if (status == wxACC_FAIL)
return E_FAIL;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
// Use standard interface instead.
IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
if (!stdInterface)
- return E_FAIL;
+ return E_NOTIMPL;
else
return stdInterface->get_accFocus (pVarID);
}
{
pVarID->vt = VT_I4;
pVarID->lVal = CHILDID_SELF;
- return S_OK;
- }
+ return S_OK; }
else
{
wxIAccessible* childIA = childObject->GetIAccessible();
if (!childIA)
+ return E_NOTIMPL;
+
+ if (childIA->QueryInterface(IID_IDispatch, (LPVOID*) & pVarID->pdispVal) != S_OK)
return E_FAIL;
- if (childIA->QueryInterface(IID_IDispatch, (LPVOID*) pVarID->pdispVal) != S_OK)
- return E_FAIL;
-
pVarID->vt = VT_DISPATCH;
- pVarID->pdispVal->AddRef();
return S_OK;
}
}
pVarID->vt = VT_EMPTY;
return S_FALSE;
}
-
- return E_FAIL;
+
+ #if 0
+ // all cases above already cause some return action so below line
+ // is unreachable and cause unnecessary warning
+ return E_NOTIMPL;
+ #endif
}
// Retrieves the selected children of this object. All objects
// selected must support this property.
-
+
STDMETHODIMP wxIAccessible::get_accSelection ( VARIANT * pVarChildren)
{
+#if wxUSE_VARIANT
+ wxLogTrace(wxT("access"), wxT("get_accSelection"));
wxASSERT (m_pAccessible != NULL);
if (!m_pAccessible)
return E_FAIL;
VariantInit(pVarChildren);
-
+
wxVariant selections;
wxAccStatus status = m_pAccessible->GetSelections(& selections);
if (status == wxACC_FAIL)
return E_FAIL;
-
+
if (status == wxACC_NOT_IMPLEMENTED)
{
// Use standard interface instead.
IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
if (!stdInterface)
- return E_FAIL;
+ return E_NOTIMPL;
else
return stdInterface->get_accSelection (pVarChildren);
}
wxAccessible* childObject = (wxAccessible*) selections.GetVoidPtr();
wxIAccessible* childIA = childObject->GetIAccessible();
if (!childIA)
+ return E_NOTIMPL;
+
+ if (childIA->QueryInterface(IID_IDispatch, (LPVOID*) & pVarChildren->pdispVal) != S_OK)
return E_FAIL;
- if (childIA->QueryInterface(IID_IDispatch, (LPVOID*) pVarChildren->pdispVal) != S_OK)
- return E_FAIL;
-
pVarChildren->vt = VT_DISPATCH;
- pVarChildren->pdispVal->AddRef();
return S_OK;
}
return S_OK;
}
}
+#else
+ wxUnusedVar(pVarChildren);
+#endif // wxUSE_VARIANT
- return E_FAIL;
+ return E_NOTIMPL;
}
// Get type info
-STDMETHODIMP wxIAccessible::GetTypeInfo(unsigned int typeInfo, LCID lcid, ITypeInfo** ppTypeInfo)
+STDMETHODIMP wxIAccessible::GetTypeInfo(unsigned int WXUNUSED(typeInfo), LCID WXUNUSED(lcid), ITypeInfo** ppTypeInfo)
{
*ppTypeInfo = NULL;
return E_NOTIMPL;
// Get ids of names
-STDMETHODIMP wxIAccessible::GetIDsOfNames(REFIID riid, OLECHAR** names, unsigned int cNames,
- LCID lcid, DISPID* dispId)
+STDMETHODIMP wxIAccessible::GetIDsOfNames(REFIID WXUNUSED(riid), OLECHAR** WXUNUSED(names), unsigned int WXUNUSED(cNames),
+ LCID WXUNUSED(lcid), DISPID* WXUNUSED(dispId))
{
return E_NOTIMPL;
}
// Invoke
-STDMETHODIMP wxIAccessible::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
- WORD wFlags, DISPPARAMS *pDispParams,
- VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
- unsigned int *puArgErr )
+STDMETHODIMP wxIAccessible::Invoke(DISPID WXUNUSED(dispIdMember), REFIID WXUNUSED(riid), LCID WXUNUSED(lcid),
+ WORD WXUNUSED(wFlags), DISPPARAMS *WXUNUSED(pDispParams),
+ VARIANT *WXUNUSED(pVarResult), EXCEPINFO *WXUNUSED(pExcepInfo),
+ unsigned int *WXUNUSED(puArgErr) )
{
return E_NOTIMPL;
}
+// Gets the standard IAccessible interface for the given child or object.
+// Call Release if this is non-NULL.
+IAccessible* wxIAccessible::GetChildStdAccessible(int id)
+{
+ if (id == 0)
+ {
+ IAccessible* obj = (IAccessible*)m_pAccessible->GetIAccessibleStd();
+
+ obj->AddRef();
+ return obj;
+ }
+ else
+ {
+ VARIANT var;
+ VariantInit(& var);
+ var.vt = VT_I4;
+ var.lVal = id;
+ IDispatch* pDispatch = NULL;
+ if (S_OK == get_accChild ( var, & pDispatch))
+ {
+ IAccessible* childAccessible = NULL;
+ if (pDispatch->QueryInterface(IID_IAccessible, (LPVOID*) & childAccessible) == S_OK)
+ {
+ pDispatch->Release();
+ wxIAccessible* c = (wxIAccessible*) childAccessible;
+ IAccessible* stdChildAccessible = (IAccessible*) c->m_pAccessible->GetIAccessibleStd();
+ stdChildAccessible->AddRef();
+ childAccessible->Release();
+ return stdChildAccessible;
+ }
+ else
+ {
+ pDispatch->Release();
+ }
+ }
+ }
+
+#if 0
+ {
+ // Loop until we find the right id
+ long nChildren = 0;
+ this->get_accChildCount(& nChildren);
+
+ int i;
+ for (i = 0; i < nChildren; i++)
+ {
+ long obtained = 0;
+ VARIANT var;
+ VariantInit(& var);
+ var.vt = VT_I4;
+ if (S_OK == AccessibleChildren(this, i, 1, & var, &obtained))
+ {
+ if (var.lVal == id)
+ {
+ VariantInit(& var);
+ var.vt = VT_DISPATCH;
+ if (S_OK == AccessibleChildren(this, i, 1, & var, &obtained))
+ {
+ IAccessible* childAccessible = NULL;
+ if (var.pdispVal->QueryInterface(IID_IAccessible, (LPVOID*) & childAccessible) == S_OK)
+ {
+ var.pdispVal->Release();
+ return childAccessible;
+ }
+ else
+ {
+ var.pdispVal->Release();
+ }
+ }
+ }
+ break;
+ }
+ }
+ }
+#endif
+ return NULL;
+}
+
+// Gets the IAccessible interface for the given child or object.
+// Call Release if this is non-NULL.
+IAccessible* wxIAccessible::GetChildAccessible(int id)
+{
+ if (id == 0)
+ {
+ IAccessible* obj = this;
+
+ obj->AddRef();
+ return obj;
+ }
+ else
+ {
+ VARIANT var;
+ VariantInit(& var);
+ var.vt = VT_I4;
+ var.lVal = id;
+ IDispatch* pDispatch = NULL;
+ if (S_OK == get_accChild ( var, & pDispatch))
+ {
+ IAccessible* childAccessible = NULL;
+ if (pDispatch->QueryInterface(IID_IAccessible, (LPVOID*) & childAccessible) == S_OK)
+ {
+ pDispatch->Release();
+ return childAccessible;
+ }
+ else
+ {
+ pDispatch->Release();
+ }
+ }
+ }
+ return NULL;
+}
+
// ----------------------------------------------------------------------------
// wxAccessible implementation
// ----------------------------------------------------------------------------
if (GetWindow())
{
-#if 0
- HRESULT retCode = ::CreateStdAccessibleProxy((HWND) GetWindow()->GetHWND(),
- wxT("wxWindowClass"), OBJID_CLIENT, IID_IAccessible, (void**) & m_pIAccessibleStd);
-#else
HRESULT retCode = ::CreateStdAccessibleObject((HWND) GetWindow()->GetHWND(),
OBJID_CLIENT, IID_IAccessible, (void**) & m_pIAccessibleStd);
-#endif
if (retCode == S_OK)
return m_pIAccessibleStd;
else
return NULL;
}
+// Sends an event when something changes in an accessible object.
+void wxAccessible::NotifyEvent(int eventType, wxWindow* window, wxAccObject objectType,
+ int objectId)
+{
+ ::NotifyWinEvent((DWORD) eventType, (HWND) window->GetHWND(),
+ (LONG) objectType, (LONG) objectId);
+}
+
// Utilities
// Convert to Windows role
{
int sel = 0;
- if (sel & wxACC_SEL_TAKEFOCUS)
+ if (wxsel & wxACC_SEL_TAKEFOCUS)
sel |= SELFLAG_TAKEFOCUS;
- if (sel & wxACC_SEL_TAKESELECTION)
+ if (wxsel & wxACC_SEL_TAKESELECTION)
sel |= SELFLAG_TAKESELECTION;
- if (sel & wxACC_SEL_EXTENDSELECTION)
+ if (wxsel & wxACC_SEL_EXTENDSELECTION)
sel |= SELFLAG_EXTENDSELECTION;
- if (sel & wxACC_SEL_ADDSELECTION)
+ if (wxsel & wxACC_SEL_ADDSELECTION)
sel |= SELFLAG_ADDSELECTION;
- if (sel & wxACC_SEL_REMOVESELECTION)
+ if (wxsel & wxACC_SEL_REMOVESELECTION)
sel |= SELFLAG_REMOVESELECTION;
return sel;
}
}
-#endif //USE_ACCESSIBILITY
+#endif // wxUSE_OLE && wxUSE_ACCESSIBILITY
projects / wxWidgets.git / blobdiff