don't keep dangling m_prevRadio pointer (2nd part of patch 1836644)

[wxWidgets.git] / src / msw / ole / access.cpp

diff --git a/src/msw/ole/access.cpp b/src/msw/ole/access.cpp
index 3bc308ca4789ddef3ae4eedaa4f4674ed9d66970..b1ddbb9a34fd99441217f2526ac5c4c548160e61 100644 (file)
--- a/src/msw/ole/access.cpp
+++ b/src/msw/ole/access.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        msw/ole/access.cpp
+// Name:        src/msw/ole/access.cpp

 // Purpose:     implementation of wxIAccessible and wxAccessible
 // Author:      Julian Smart
 // Modified by:
 // Purpose:     implementation of wxIAccessible and wxAccessible
 // Author:      Julian Smart
 // Modified by:


@@ -17,28 +17,22 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // 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
 // 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
 
 
 #if wxUSE_OLE && wxUSE_ACCESSIBILITY
 

-#include "wx/log.h"

 #include "wx/access.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__)
 
 // for some compilers, the entire ole2.h must be included, not only oleauto.h
 #if wxUSE_NORLANDER_HEADERS || defined(__WATCOMC__)


@@ -47,6 +41,7 @@
 
 #include <oleauto.h>
 #include <oleacc.h>
 
 #include <oleauto.h>
 #include <oleacc.h>

+#include <winable.h>

 
 #include "wx/msw/ole/oleutils.h"
 
 
 #include "wx/msw/ole/oleutils.h"
 


@@ -70,6 +65,7 @@ int wxConvertToWindowsSelFlag(wxAccSelectionFlags sel);
 // Convert from Windows selection flag
 wxAccSelectionFlags wxConvertFromWindowsSelFlag(int sel);
 
 // Convert from Windows selection flag
 wxAccSelectionFlags wxConvertFromWindowsSelFlag(int sel);
 

+#if wxUSE_VARIANT

 // ----------------------------------------------------------------------------
 // wxIEnumVARIANT interface implementation
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxIEnumVARIANT interface implementation
 // ----------------------------------------------------------------------------


@@ -78,7 +74,7 @@ class wxIEnumVARIANT : public IEnumVARIANT
 {
 public:
     wxIEnumVARIANT(const wxVariant& variant);
 {
 public:
     wxIEnumVARIANT(const wxVariant& variant);

-    ~wxIEnumVARIANT() { }
+    virtual ~wxIEnumVARIANT() { }

 
     DECLARE_IUNKNOWN_METHODS;
 
 
     DECLARE_IUNKNOWN_METHODS;
 


@@ -181,6 +177,7 @@ STDMETHODIMP wxIEnumVARIANT::Clone(IEnumVARIANT **ppenum)
     return S_OK;
 }
 
     return S_OK;
 }
 

+#endif // wxUSE_VARIANT

 
 // ----------------------------------------------------------------------------
 // wxIAccessible implementation of IAccessible interface
 
 // ----------------------------------------------------------------------------
 // wxIAccessible implementation of IAccessible interface


@@ -198,12 +195,12 @@ public:
 // Navigation and Hierarchy
 
         // Retrieves the child element or child object at a given point on the screen.
 // 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
 
     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);
 
 
     STDMETHODIMP accLocation ( long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varID);
 


@@ -214,29 +211,29 @@ public:
 
         // Retrieves the address of an IDispatch interface for the specified child.
         // All objects must support this property.
 
         // 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_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_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 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 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.
     STDMETHODIMP get_accDefaultAction ( VARIANT varID, BSTR* pszDefaultAction);
 
         // Retrieves a string that describes the visual appearance of the specified object.


@@ -252,18 +249,18 @@ public:
         // 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.
         // 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_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_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.
     STDMETHODIMP get_accName ( VARIANT varID, BSTR* pszName);
 
         // Retrieves information that describes the role of the specified object.


@@ -273,9 +270,9 @@ public:
 
         // Retrieves the current state of the specified object.
         // All objects support this property.
 
         // Retrieves the current state of the specified object.
         // All objects support this property.

-    
+

     STDMETHODIMP get_accState ( VARIANT varID, VARIANT* pVarState);
     STDMETHODIMP get_accState ( VARIANT varID, VARIANT* pVarState);

-    
+

         // Retrieves the value of the specified object.
         // Not all objects have a value.
 
         // Retrieves the value of the specified object.
         // Not all objects have a value.
 


@@ -291,18 +288,18 @@ public:
 
         // Retrieves the object that has the keyboard focus. All objects
         // that receive the keyboard focus must support this property.
 
         // 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_accFocus ( VARIANT* pVarID);
 
         // Retrieves the selected children of this object. All objects
         // selected must support this property.

-        
+

     STDMETHODIMP get_accSelection ( VARIANT * pVarChildren);
 
 // Obsolete
 
     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
 
 
 // IDispatch
 


@@ -321,11 +318,21 @@ public:
 
         // Invoke
 
 
         // 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 );
 
                         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
 
 private:
     wxAccessible *m_pAccessible;      // pointer to C++ class we belong to
 


@@ -355,33 +362,34 @@ wxIAccessible::wxIAccessible(wxAccessible *pAccessible)
 }
 
 // Retrieves the child element or child object at a given point on the screen.
 }
 
 // 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)
 {
 
 STDMETHODIMP wxIAccessible::accHitTest(long xLeft, long yLeft, VARIANT* pVarID)
 {

+    wxLogTrace(wxT("access"), wxT("accHitTest"));

     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;
     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;

-    
+

     wxAccessible* childObject = NULL;
     int childId = 0;
     VariantInit(pVarID);
     wxAccessible* childObject = NULL;
     int childId = 0;
     VariantInit(pVarID);

-    
+

     wxAccStatus status = m_pAccessible->HitTest(wxPoint(xLeft, yLeft), & childId, & childObject);
     wxAccStatus status = m_pAccessible->HitTest(wxPoint(xLeft, yLeft), & childId, & childObject);

-    
+

     if (status == wxACC_FAIL)
         return E_FAIL;
     if (status == wxACC_FAIL)
         return E_FAIL;

-    
+

     if (status == wxACC_NOT_IMPLEMENTED)
     {
         // Use standard interface instead.
         IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
         if (!stdInterface)
     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);
     }
         else
             return stdInterface->accHitTest(xLeft, yLeft, pVarID);
     }

-    
+

     if (childObject)
     {
         if (childObject == m_pAccessible)
     if (childObject)
     {
         if (childObject == m_pAccessible)


@@ -394,13 +402,12 @@ STDMETHODIMP wxIAccessible::accHitTest(long xLeft, long yLeft, VARIANT* pVarID)
         {
             wxIAccessible* childIA = childObject->GetIAccessible();
             if (!childIA)
         {
             wxIAccessible* childIA = childObject->GetIAccessible();
             if (!childIA)

+                return E_NOTIMPL;
+
+            if (childIA->QueryInterface(IID_IDispatch, (LPVOID*) & pVarID->pdispVal) != S_OK)

                 return E_FAIL;
 
                 return E_FAIL;
 

-               if (childIA->QueryInterface(IID_IDispatch, (LPVOID*) pVarID->pdispVal) != S_OK)
-                   return E_FAIL;
-            

             pVarID->vt = VT_DISPATCH;
             pVarID->vt = VT_DISPATCH;

-            pVarID->pdispVal->AddRef();

             return S_OK;
         }
     }
             return S_OK;
         }
     }


@@ -415,33 +422,48 @@ STDMETHODIMP wxIAccessible::accHitTest(long xLeft, long yLeft, VARIANT* pVarID)
         pVarID->vt = VT_EMPTY;
         return S_FALSE;
     }
         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
 }
 
 // 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)
 {
 
 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;
     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;
     wxRect rect;
 
     wxAccStatus status = m_pAccessible->GetLocation(rect, varID.lVal);
     if (status == wxACC_FAIL)
         return E_FAIL;

-    
+

     if (status == wxACC_NOT_IMPLEMENTED)
     {
     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
     {
     }
     else
     {


@@ -452,7 +474,7 @@ STDMETHODIMP wxIAccessible::accLocation ( long* pxLeft, long* pyTop, long* pcxWi
         return S_OK;
     }
 
         return S_OK;
     }
 

-    return E_FAIL;
+    return E_NOTIMPL;

 }
 
 // Traverses to another user interface element within a container and retrieves the object.
 }
 
 // Traverses to another user interface element within a container and retrieves the object.


@@ -463,107 +485,169 @@ STDMETHODIMP wxIAccessible::accNavigate ( long navDir, VARIANT varStart, VARIANT
     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;
     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;
         return E_INVALIDARG;

-    
+    }
+

     wxAccessible* elementObject = NULL;
     int elementId = 0;
     VariantInit(pVarEnd);
     wxNavDir navDirWX = wxNAVDIR_FIRSTCHILD;
 
     wxAccessible* elementObject = NULL;
     int elementId = 0;
     VariantInit(pVarEnd);
     wxNavDir navDirWX = wxNAVDIR_FIRSTCHILD;
 

+    wxString navStr;
+

     switch (navDir)
     {
     case NAVDIR_DOWN:
         navDirWX = wxNAVDIR_DOWN;
     switch (navDir)
     {
     case NAVDIR_DOWN:
         navDirWX = wxNAVDIR_DOWN;

+        navStr = wxT("wxNAVDIR_DOWN");

         break;
 
     case NAVDIR_FIRSTCHILD:
         navDirWX = wxNAVDIR_FIRSTCHILD;
         break;
 
     case NAVDIR_FIRSTCHILD:
         navDirWX = wxNAVDIR_FIRSTCHILD;

+        navStr = wxT("wxNAVDIR_FIRSTCHILD");

         break;
 
     case NAVDIR_LASTCHILD:
         navDirWX = wxNAVDIR_LASTCHILD;
         break;
 
     case NAVDIR_LASTCHILD:
         navDirWX = wxNAVDIR_LASTCHILD;

+        navStr = wxT("wxNAVDIR_LASTCHILD");

         break;
 
     case NAVDIR_LEFT:
         navDirWX = wxNAVDIR_LEFT;
         break;
 
     case NAVDIR_LEFT:
         navDirWX = wxNAVDIR_LEFT;

+        navStr = wxT("wxNAVDIR_LEFT");

         break;
 
     case NAVDIR_NEXT:
         navDirWX = wxNAVDIR_NEXT;
         break;
 
     case NAVDIR_NEXT:
         navDirWX = wxNAVDIR_NEXT;

+        navStr = wxT("wxNAVDIR_NEXT");

         break;
 
     case NAVDIR_PREVIOUS:
         navDirWX = wxNAVDIR_PREVIOUS;
         break;
 
     case NAVDIR_PREVIOUS:
         navDirWX = wxNAVDIR_PREVIOUS;

+        navStr = wxT("wxNAVDIR_PREVIOUS");

         break;
 
     case NAVDIR_RIGHT:
         navDirWX = wxNAVDIR_RIGHT;
         break;
 
     case NAVDIR_RIGHT:
         navDirWX = wxNAVDIR_RIGHT;

+        navStr = wxT("wxNAVDIR_RIGHT");

         break;
 
     case NAVDIR_UP:
         navDirWX = wxNAVDIR_UP;
         break;
 
     case NAVDIR_UP:
         navDirWX = wxNAVDIR_UP;

+        navStr = wxT("wxNAVDIR_UP");

         break;
         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)
     wxAccStatus status = m_pAccessible->Navigate(navDirWX, varStart.lVal, & elementId,
         & elementObject);
 
     if (status == wxACC_FAIL)

+    {
+        wxLogTrace(wxT("access"), wxT("wxAccessible::Navigate failed"));

         return E_FAIL;
         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)
     {
     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)
         {
     }
     else
     {
         if (elementObject)
         {

+            wxLogTrace(wxT("access"), wxT("Getting wxIAccessible and calling QueryInterface for Navigate"));

             wxIAccessible* objectIA = elementObject->GetIAccessible();
             if (!objectIA)
             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;
                 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->vt = VT_DISPATCH;

-            pVarEnd->pdispVal->AddRef();

             return S_OK;
         }
         else if (elementId > 0)
         {
             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
         {
             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;
         }
     }
 
             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.
 }
 
 // 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)
 {
 STDMETHODIMP wxIAccessible::get_accChild ( VARIANT varChildID, IDispatch** ppDispChild)
 {

+    wxLogTrace(wxT("access"), wxT("get_accChild"));

     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;
     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;

-    
+

     if (varChildID.vt != VT_I4)
     if (varChildID.vt != VT_I4)

+    {
+        wxLogTrace(wxT("access"), wxT("Invalid arg for get_accChild"));

         return E_INVALIDARG;
         return E_INVALIDARG;

+    }

 
     if (varChildID.lVal == CHILDID_SELF)
     {
 
     if (varChildID.lVal == CHILDID_SELF)
     {


@@ -571,21 +655,27 @@ STDMETHODIMP wxIAccessible::get_accChild ( VARIANT varChildID, IDispatch** ppDis
         AddRef();
         return S_OK;
     }
         AddRef();
         return S_OK;
     }

-    
+

     wxAccessible* child = NULL;
 
     wxAccStatus status = m_pAccessible->GetChild(varChildID.lVal, & child);
     if (status == wxACC_FAIL)
     wxAccessible* child = NULL;
 
     wxAccStatus status = m_pAccessible->GetChild(varChildID.lVal, & child);
     if (status == wxACC_FAIL)

+    {
+        wxLogTrace(wxT("access"), wxT("GetChild failed"));

         return E_FAIL;
         return E_FAIL;

-    
+    }
+

     if (status == wxACC_NOT_IMPLEMENTED)
     {
         // Use standard interface instead.
         IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
         if (!stdInterface)
     if (status == wxACC_NOT_IMPLEMENTED)
     {
         // Use standard interface instead.
         IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
         if (!stdInterface)

-            return E_FAIL;
+            return E_NOTIMPL;

         else
         else

+        {
+            wxLogTrace(wxT("access"), wxT("Using standard interface for get_accChild"));

             return stdInterface->get_accChild (varChildID, ppDispChild);
             return stdInterface->get_accChild (varChildID, ppDispChild);

+        }

     }
     else
     {
     }
     else
     {


@@ -593,40 +683,60 @@ STDMETHODIMP wxIAccessible::get_accChild ( VARIANT varChildID, IDispatch** ppDis
         {
             wxIAccessible* objectIA = child->GetIAccessible();
             if (!objectIA)
         {
             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;
                 return E_FAIL;

-            *ppDispChild = objectIA;
-            objectIA->AddRef();
+            }
+

             return S_OK;
         }
         else
             return S_OK;
         }
         else

+        {
+            wxLogTrace(wxT("access"), wxT("Not an accessible object"));

             return S_FALSE; // Indicates it's 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.
 }
 
 // Retrieves the number of children that belong to this object.
 // All objects must support this property.

-    
+

 STDMETHODIMP wxIAccessible::get_accChildCount ( long* pCountChildren)
 {
 STDMETHODIMP wxIAccessible::get_accChildCount ( long* pCountChildren)
 {

+    wxLogTrace(wxT("access"), wxT("get_accChildCount"));

     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;
     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;
     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)
     if (status == wxACC_NOT_IMPLEMENTED)
     {
         // Use standard interface instead.
         IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
         if (!stdInterface)

-            return E_FAIL;
+            return E_NOTIMPL;

         else
         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
     {
     }
     else
     {


@@ -634,29 +744,39 @@ STDMETHODIMP wxIAccessible::get_accChildCount ( long* pCountChildren)
         return S_OK;
     }
 
         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.
 }
 
 // Retrieves the IDispatch interface of the object's parent.
 // All objects support this property.

-    
+

 STDMETHODIMP wxIAccessible::get_accParent ( IDispatch** ppDispParent)
 {
 STDMETHODIMP wxIAccessible::get_accParent ( IDispatch** ppDispParent)
 {

+    wxLogTrace(wxT("access"), wxT("get_accParent"));

     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;
     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;

-    
+

     wxAccessible* parent = NULL;
     wxAccStatus status = m_pAccessible->GetParent(& parent);
     wxAccessible* parent = NULL;
     wxAccStatus status = m_pAccessible->GetParent(& parent);

+

     if (status == wxACC_FAIL)
         return E_FAIL;
     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)
         // Use standard interface instead.
         IAccessible* stdInterface = (IAccessible*)m_pAccessible->GetIAccessibleStd();
         if (!stdInterface)

-            return E_FAIL;
+            return E_NOTIMPL;

         else
             return stdInterface->get_accParent (ppDispParent);
     }
         else
             return stdInterface->get_accParent (ppDispParent);
     }


@@ -668,89 +788,120 @@ STDMETHODIMP wxIAccessible::get_accParent ( IDispatch** ppDispParent)
             if (!objectIA)
                 return E_FAIL;
 
             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;
                 return E_FAIL;

-            objectIA->AddRef();
-            *ppDispParent = objectIA;
+            }
+
+            wxLogTrace(wxT("access"), wxT("Returning S_OK for get_accParent"));

             return S_OK;
             return S_OK;

-*/

         }
         else
         {
         }
         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;
             *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.
 }
 
 // Performs the object's default action. Not all objects have a default
 // action.

-    
+

 STDMETHODIMP wxIAccessible::accDoDefaultAction(VARIANT varID)
 {
 STDMETHODIMP wxIAccessible::accDoDefaultAction(VARIANT varID)
 {

+    wxLogTrace(wxT("access"), wxT("accDoDefaultAction"));

     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;
     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;

-    
+

     if (varID.vt != VT_I4)
     if (varID.vt != VT_I4)

+    {
+        wxLogTrace(wxT("access"), wxT("Invalid arg for accDoDefaultAction"));

         return E_INVALIDARG;
         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;
     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)
     {
     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.
     }
     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)
 {
 STDMETHODIMP wxIAccessible::get_accDefaultAction ( VARIANT varID, BSTR* pszDefaultAction)
 {

+    wxLogTrace(wxT("access"), wxT("get_accDefaultAction"));

     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;
     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;

-    
+

     if (varID.vt != VT_I4)
     if (varID.vt != VT_I4)

+    {
+        wxLogTrace(wxT("access"), wxT("Invalid arg for get_accDefaultAction"));

         return E_INVALIDARG;
         return E_INVALIDARG;

-    
+    }
+

     wxString defaultAction;
     wxAccStatus status = m_pAccessible->GetDefaultAction(varID.lVal, & defaultAction);
     if (status == wxACC_FAIL)
         return E_FAIL;
     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_SUPPORTED)
         return DISP_E_MEMBERNOTFOUND;

-    
+

     if (status == wxACC_NOT_IMPLEMENTED)
     {
     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
     {
     }
     else
     {


@@ -774,30 +925,44 @@ STDMETHODIMP wxIAccessible::get_accDefaultAction ( VARIANT varID, BSTR* pszDefau
 
 STDMETHODIMP wxIAccessible::get_accDescription ( VARIANT varID, BSTR* pszDescription)
 {
 
 STDMETHODIMP wxIAccessible::get_accDescription ( VARIANT varID, BSTR* pszDescription)
 {

+    wxLogTrace(wxT("access"), wxT("get_accDescription"));

     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;
     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;

-    
+

     if (varID.vt != VT_I4)
     if (varID.vt != VT_I4)

+    {
+        wxLogTrace(wxT("access"), wxT("Invalid arg for get_accDescription"));

         return E_INVALIDARG;
         return E_INVALIDARG;

-    
+    }
+

     wxString description;
     wxAccStatus status = m_pAccessible->GetDescription(varID.lVal, & description);
     if (status == wxACC_FAIL)
         return E_FAIL;
     wxString description;
     wxAccStatus status = m_pAccessible->GetDescription(varID.lVal, & description);
     if (status == wxACC_FAIL)
         return E_FAIL;

-    
+

     if (status == wxACC_NOT_IMPLEMENTED)
     {
     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
     {
     }
     else
     {

-        if (description.IsEmpty())
+        if (description.empty())

         {
             * pszDescription = NULL;
             return S_FALSE;
         {
             * pszDescription = NULL;
             return S_FALSE;


@@ -807,9 +972,9 @@ STDMETHODIMP wxIAccessible::get_accDescription ( VARIANT varID, BSTR* pszDescrip
             wxBasicString basicString(description);
             * pszDescription = basicString.Get();
             return S_OK;
             wxBasicString basicString(description);
             * pszDescription = basicString.Get();
             return S_OK;

-        }        
+        }

     }
     }

-    return E_FAIL;
+    return E_NOTIMPL;

 }
 
 // Retrieves an object's Help property string.
 }
 
 // Retrieves an object's Help property string.


@@ -817,30 +982,44 @@ STDMETHODIMP wxIAccessible::get_accDescription ( VARIANT varID, BSTR* pszDescrip
 
 STDMETHODIMP wxIAccessible::get_accHelp ( VARIANT varID, BSTR* pszHelp)
 {
 
 STDMETHODIMP wxIAccessible::get_accHelp ( VARIANT varID, BSTR* pszHelp)
 {

+    wxLogTrace(wxT("access"), wxT("get_accHelp"));

     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;
     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;

-    
+

     if (varID.vt != VT_I4)
     if (varID.vt != VT_I4)

+    {
+        wxLogTrace(wxT("access"), wxT("Invalid arg for get_accHelp"));

         return E_INVALIDARG;
         return E_INVALIDARG;

-    
+    }
+

     wxString helpString;
     wxAccStatus status = m_pAccessible->GetHelpText(varID.lVal, & helpString);
     if (status == wxACC_FAIL)
         return E_FAIL;
     wxString helpString;
     wxAccStatus status = m_pAccessible->GetHelpText(varID.lVal, & helpString);
     if (status == wxACC_FAIL)
         return E_FAIL;

-    
+

     if (status == wxACC_NOT_IMPLEMENTED)
     {
     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
     {
     }
     else
     {

-        if (helpString.IsEmpty())
+        if (helpString.empty())

         {
             * pszHelp = NULL;
             return S_FALSE;
         {
             * pszHelp = NULL;
             return S_FALSE;


@@ -850,74 +1029,102 @@ STDMETHODIMP wxIAccessible::get_accHelp ( VARIANT varID, BSTR* pszHelp)
             wxBasicString basicString(helpString);
             * pszHelp = basicString.Get();
             return S_OK;
             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.
 }
 
 // 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.
 // GetHelpText instead.

-        
+

 STDMETHODIMP wxIAccessible::get_accHelpTopic ( BSTR* pszHelpFile, VARIANT varChild, long* pidTopic)
 {
 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;
     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;

-    
+

     if (varChild.vt != VT_I4)
     if (varChild.vt != VT_I4)

+    {
+        wxLogTrace(wxT("access"), wxT("Invalid arg for get_accHelpTopic"));

         return E_INVALIDARG;
         return E_INVALIDARG;

-    
+    }
+

     wxAccStatus status = wxACC_NOT_IMPLEMENTED;
     if (status == wxACC_FAIL)
         return E_FAIL;
     wxAccStatus status = wxACC_NOT_IMPLEMENTED;
     if (status == wxACC_FAIL)
         return E_FAIL;

-    
+

     if (status == wxACC_NOT_IMPLEMENTED)
     {
     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.
 }
 
 // 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)
 {
 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;
     *pszKeyboardShortcut = NULL;
 
     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;

-    
+

     if (varID.vt != VT_I4)
     if (varID.vt != VT_I4)

+    {
+        wxLogTrace(wxT("access"), wxT("Invalid arg for get_accKeyboardShortcut"));

         return E_INVALIDARG;
         return E_INVALIDARG;

-    
+    }
+

     wxString keyboardShortcut;
     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_FAIL)
         return E_FAIL;

-    
+

     if (status == wxACC_NOT_IMPLEMENTED)
     {
     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
     {
     }
     else
     {

-        if (keyboardShortcut.IsEmpty())
+        if (keyboardShortcut.empty())

         {
             * pszKeyboardShortcut = NULL;
             return S_FALSE;
         {
             * pszKeyboardShortcut = NULL;
             return S_FALSE;


@@ -927,16 +1134,17 @@ STDMETHODIMP wxIAccessible::get_accKeyboardShortcut ( VARIANT varID, BSTR* pszKe
             wxBasicString basicString(keyboardShortcut);
             * pszKeyboardShortcut = basicString.Get();
             return S_OK;
             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.
 }
 
 // Retrieves the name of the specified object.
 // All objects support this property.

-    
+

 STDMETHODIMP wxIAccessible::get_accName ( VARIANT varID, BSTR* pszName)
 {
 STDMETHODIMP wxIAccessible::get_accName ( VARIANT varID, BSTR* pszName)
 {

+    wxLogTrace(wxT("access"), wxT("get_accName"));

     *pszName = NULL;
 
     wxASSERT (m_pAccessible != NULL);
     *pszName = NULL;
 
     wxASSERT (m_pAccessible != NULL);


@@ -944,23 +1152,36 @@ STDMETHODIMP wxIAccessible::get_accName ( VARIANT varID, BSTR* pszName)
         return E_FAIL;
 
     if (varID.vt != VT_I4)
         return E_FAIL;
 
     if (varID.vt != VT_I4)

+    {
+        wxLogTrace(wxT("access"), wxT("Invalid arg for get_accName"));

         return E_INVALIDARG;
         return E_INVALIDARG;

-    
+    }
+

     wxString name;
     wxString name;

-    
+

     wxAccStatus status = m_pAccessible->GetName(varID.lVal, & name);
     wxAccStatus status = m_pAccessible->GetName(varID.lVal, & name);

-    
+

     if (status == wxACC_FAIL)
         return E_FAIL;
     if (status == wxACC_FAIL)
         return E_FAIL;

-    
+

     if (status == wxACC_NOT_IMPLEMENTED)
     {
     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
     {
     }
     else
     {


@@ -968,7 +1189,7 @@ STDMETHODIMP wxIAccessible::get_accName ( VARIANT varID, BSTR* pszName)
         *pszName = basicString.Get();
         return S_OK;
     }
         *pszName = basicString.Get();
         return S_OK;
     }

-    return E_FAIL;
+    return E_NOTIMPL;

 }
 
 // Retrieves information that describes the role of the specified object.
 }
 
 // Retrieves information that describes the role of the specified object.


@@ -976,30 +1197,44 @@ STDMETHODIMP wxIAccessible::get_accName ( VARIANT varID, BSTR* pszName)
 
 STDMETHODIMP wxIAccessible::get_accRole ( VARIANT varID, VARIANT* pVarRole)
 {
 
 STDMETHODIMP wxIAccessible::get_accRole ( VARIANT varID, VARIANT* pVarRole)
 {

+    wxLogTrace(wxT("access"), wxT("get_accRole"));

     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;
     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;

-    
+

     if (varID.vt != VT_I4)
     if (varID.vt != VT_I4)

+    {
+        wxLogTrace(wxT("access"), wxT("Invalid arg for get_accRole"));

         return E_INVALIDARG;
         return E_INVALIDARG;

-    
+    }
+

     VariantInit(pVarRole);
 
     wxAccRole role = wxROLE_NONE;
     VariantInit(pVarRole);
 
     wxAccRole role = wxROLE_NONE;

-    
+

     wxAccStatus status = m_pAccessible->GetRole(varID.lVal, & role);
     wxAccStatus status = m_pAccessible->GetRole(varID.lVal, & role);

-    
+

     if (status == wxACC_FAIL)
         return E_FAIL;
     if (status == wxACC_FAIL)
         return E_FAIL;

-    
+

     if (status == wxACC_NOT_IMPLEMENTED)
     {
     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
     {
     }
     else
     {


@@ -1014,35 +1249,49 @@ STDMETHODIMP wxIAccessible::get_accRole ( VARIANT varID, VARIANT* pVarRole)
 
         return S_OK;
     }
 
         return S_OK;
     }

-    return E_FAIL;
+    return E_NOTIMPL;

 }
 
 // Retrieves the current state of the specified object.
 // All objects support this property.
 }
 
 // Retrieves the current state of the specified object.
 // All objects support this property.

-    
+

 STDMETHODIMP wxIAccessible::get_accState ( VARIANT varID, VARIANT* pVarState)
 {
 STDMETHODIMP wxIAccessible::get_accState ( VARIANT varID, VARIANT* pVarState)
 {

+    wxLogTrace(wxT("access"), wxT("get_accState"));

     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;
     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;
         return E_INVALIDARG;

+    }

 
     long wxstate = 0;
 
     long wxstate = 0;

-    
+

     wxAccStatus status = m_pAccessible->GetState(varID.lVal, & wxstate);
     if (status == wxACC_FAIL)
         return E_FAIL;
     wxAccStatus status = m_pAccessible->GetState(varID.lVal, & wxstate);
     if (status == wxACC_FAIL)
         return E_FAIL;

-    
+

     if (status == wxACC_NOT_IMPLEMENTED)
     {
     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
     {
     }
     else
     {


@@ -1051,36 +1300,50 @@ STDMETHODIMP wxIAccessible::get_accState ( VARIANT varID, VARIANT* pVarState)
         pVarState->vt = VT_I4;
         return S_OK;
     }
         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)
 {
 // 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;
     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;

-    
+

     if (varID.vt != VT_I4)
     if (varID.vt != VT_I4)

+    {
+        wxLogTrace(wxT("access"), wxT("Invalid arg for get_accValue"));

         return E_INVALIDARG;
         return E_INVALIDARG;

-    
+    }
+

     wxString strValue;
     wxString strValue;

-    
+

     wxAccStatus status = m_pAccessible->GetValue(varID.lVal, & strValue);
     wxAccStatus status = m_pAccessible->GetValue(varID.lVal, & strValue);

-    
+

     if (status == wxACC_FAIL)
         return E_FAIL;
     if (status == wxACC_FAIL)
         return E_FAIL;

-    
+

     if (status == wxACC_NOT_IMPLEMENTED)
     {
     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
     {
     }
     else
     {


@@ -1088,7 +1351,7 @@ STDMETHODIMP wxIAccessible::get_accValue ( VARIANT varID, BSTR* pszValue)
         * pszValue = basicString.Get();
         return S_OK;
     }
         * pszValue = basicString.Get();
         return S_OK;
     }

-    return E_FAIL;
+    return E_NOTIMPL;

 }
 
 // Modifies the selection or moves the keyboard focus of the
 }
 
 // Modifies the selection or moves the keyboard focus of the


@@ -1097,57 +1360,72 @@ STDMETHODIMP wxIAccessible::get_accValue ( VARIANT varID, BSTR* pszValue)
 
 STDMETHODIMP wxIAccessible::accSelect ( long flagsSelect, VARIANT varID )
 {
 
 STDMETHODIMP wxIAccessible::accSelect ( long flagsSelect, VARIANT varID )
 {

+    wxLogTrace(wxT("access"), wxT("get_accSelect"));

     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;
     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;
         return E_INVALIDARG;

-    
+    }
+

     wxAccSelectionFlags wxsel = wxConvertFromWindowsSelFlag(flagsSelect);
 
     wxAccStatus status = m_pAccessible->Select(varID.lVal, wxsel);
     if (status == wxACC_FAIL)
         return E_FAIL;
     wxAccSelectionFlags wxsel = wxConvertFromWindowsSelFlag(flagsSelect);
 
     wxAccStatus status = m_pAccessible->Select(varID.lVal, wxsel);
     if (status == wxACC_FAIL)
         return E_FAIL;

-    
+

     if (status == wxACC_NOT_IMPLEMENTED)
     {
     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;
 
     }
     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.
 }
 
 // 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)
 {
 STDMETHODIMP wxIAccessible::get_accFocus ( VARIANT* pVarID)
 {

+    wxLogTrace(wxT("access"), wxT("get_accFocus"));

     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;
     wxASSERT (m_pAccessible != NULL);
     if (!m_pAccessible)
         return E_FAIL;

-    
+

     wxAccessible* childObject = NULL;
     int childId = 0;
     VariantInit(pVarID);
     wxAccessible* childObject = NULL;
     int childId = 0;
     VariantInit(pVarID);

-    
+

     wxAccStatus status = m_pAccessible->GetFocus(& childId, & childObject);
     if (status == wxACC_FAIL)
         return E_FAIL;
     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)
     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);
     }
         else
             return stdInterface->get_accFocus (pVarID);
     }


@@ -1157,19 +1435,17 @@ STDMETHODIMP wxIAccessible::get_accFocus ( VARIANT* pVarID)
         {
             pVarID->vt = VT_I4;
             pVarID->lVal = CHILDID_SELF;
         {
             pVarID->vt = VT_I4;
             pVarID->lVal = CHILDID_SELF;

-            return S_OK;
-        }
+            return S_OK;        }

         else
         {
             wxIAccessible* childIA = childObject->GetIAccessible();
             if (!childIA)
         else
         {
             wxIAccessible* childIA = childObject->GetIAccessible();
             if (!childIA)

+                return E_NOTIMPL;
+
+            if (childIA->QueryInterface(IID_IDispatch, (LPVOID*) & pVarID->pdispVal) != S_OK)

                 return E_FAIL;
 
                 return E_FAIL;
 

-               if (childIA->QueryInterface(IID_IDispatch, (LPVOID*) pVarID->pdispVal) != S_OK)
-                   return E_FAIL;
-            

             pVarID->vt = VT_DISPATCH;
             pVarID->vt = VT_DISPATCH;

-            pVarID->pdispVal->AddRef();

             return S_OK;
         }
     }
             return S_OK;
         }
     }


@@ -1184,32 +1460,38 @@ STDMETHODIMP wxIAccessible::get_accFocus ( VARIANT* pVarID)
         pVarID->vt = VT_EMPTY;
         return S_FALSE;
     }
         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.
 }
 
 // Retrieves the selected children of this object. All objects
 // selected must support this property.

-        
+

 STDMETHODIMP wxIAccessible::get_accSelection ( VARIANT * pVarChildren)
 {
 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);
     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;
     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)
     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);
     }
         else
             return stdInterface->get_accSelection (pVarChildren);
     }


@@ -1227,13 +1509,12 @@ STDMETHODIMP wxIAccessible::get_accSelection ( VARIANT * pVarChildren)
             wxAccessible* childObject = (wxAccessible*) selections.GetVoidPtr();
             wxIAccessible* childIA = childObject->GetIAccessible();
             if (!childIA)
             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;
 
                 return E_FAIL;
 

-               if (childIA->QueryInterface(IID_IDispatch, (LPVOID*) pVarChildren->pdispVal) != S_OK)
-                   return E_FAIL;
-            

             pVarChildren->vt = VT_DISPATCH;
             pVarChildren->vt = VT_DISPATCH;

-            pVarChildren->pdispVal->AddRef();

 
             return S_OK;
         }
 
             return S_OK;
         }


@@ -1250,13 +1531,16 @@ STDMETHODIMP wxIAccessible::get_accSelection ( VARIANT * pVarChildren)
             return S_OK;
         }
     }
             return S_OK;
         }
     }

+#else
+    wxUnusedVar(pVarChildren);
+#endif // wxUSE_VARIANT

 
 

-    return E_FAIL;
+    return E_NOTIMPL;

 }
 
 // Get type info
 
 }
 
 // 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;
 {
     *ppTypeInfo = NULL;
     return E_NOTIMPL;


@@ -1272,22 +1556,135 @@ STDMETHODIMP wxIAccessible::GetTypeInfoCount(unsigned int* typeInfoCount)
 
 // Get ids of names
 
 
 // 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
 
 {
     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;
 }
 
 {
     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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxAccessible implementation
 // ----------------------------------------------------------------------------


@@ -1323,13 +1720,8 @@ void* wxAccessible::GetIAccessibleStd()
 
     if (GetWindow())
     {
 
     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);
         HRESULT retCode = ::CreateStdAccessibleObject((HWND) GetWindow()->GetHWND(),
                 OBJID_CLIENT, IID_IAccessible, (void**) & m_pIAccessibleStd);

-#endif

         if (retCode == S_OK)
             return m_pIAccessibleStd;
         else
         if (retCode == S_OK)
             return m_pIAccessibleStd;
         else


@@ -1341,6 +1733,14 @@ void* wxAccessible::GetIAccessibleStd()
     return NULL;
 }
 
     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
 // Utilities
 
 // Convert to Windows role


@@ -1348,6 +1748,8 @@ int wxConvertToWindowsRole(wxAccRole wxrole)
 {
     switch (wxrole)
     {
 {
     switch (wxrole)
     {

+    case wxROLE_NONE:
+        return 0;

     case wxROLE_SYSTEM_ALERT:
         return ROLE_SYSTEM_ALERT;
     case wxROLE_SYSTEM_ANIMATION:
     case wxROLE_SYSTEM_ALERT:
         return ROLE_SYSTEM_ALERT;
     case wxROLE_SYSTEM_ANIMATION:


@@ -1564,15 +1966,15 @@ int wxConvertToWindowsSelFlag(wxAccSelectionFlags wxsel)
 {
     int sel = 0;
 
 {
     int sel = 0;
 

-    if (sel & wxACC_SEL_TAKEFOCUS)
+    if (wxsel & wxACC_SEL_TAKEFOCUS)

         sel |= SELFLAG_TAKEFOCUS;
         sel |= SELFLAG_TAKEFOCUS;

-    if (sel & wxACC_SEL_TAKESELECTION)
+    if (wxsel & wxACC_SEL_TAKESELECTION)

         sel |= SELFLAG_TAKESELECTION;
         sel |= SELFLAG_TAKESELECTION;

-    if (sel & wxACC_SEL_EXTENDSELECTION)
+    if (wxsel & wxACC_SEL_EXTENDSELECTION)

         sel |= SELFLAG_EXTENDSELECTION;
         sel |= SELFLAG_EXTENDSELECTION;

-    if (sel & wxACC_SEL_ADDSELECTION)
+    if (wxsel & wxACC_SEL_ADDSELECTION)

         sel |= SELFLAG_ADDSELECTION;
         sel |= SELFLAG_ADDSELECTION;

-    if (sel & wxACC_SEL_REMOVESELECTION)
+    if (wxsel & wxACC_SEL_REMOVESELECTION)

         sel |= SELFLAG_REMOVESELECTION;
     return sel;
 }
         sel |= SELFLAG_REMOVESELECTION;
     return sel;
 }


@@ -1596,4 +1998,4 @@ wxAccSelectionFlags wxConvertFromWindowsSelFlag(int sel)
 }
 
 
 }
 
 

-#endif  //USE_ACCESSIBILITY
+#endif  // wxUSE_OLE && wxUSE_ACCESSIBILITY