CATAccessible.cpp

Go to the documentation of this file.

/// \file CATAccessible.cpp
/// \brief Base class for Microsoft's IAccessible handling
/// \ingroup CATGUI
///
/// Copyright (c) 2007-2008 by Michael Ellison.
/// See COPYING.txt for the \ref gaslicense License (MIT License).
///
// $Author: mikeellison $
// $Date: 2008-01-25 05:11:25 -0600 (Fri, 25 Jan 2008) $
// $Revision: $
// $NoKeywords: $

#include "CATAccessible.h"
#include "CATControl.h"
#include "CATWindow.h"

// Sorry about the defines, it's just the interface as it originally comes
// from OLEAcc is 100% unreadable to me. Trying to minimize the text to where
// I can get it in a glance.
#define CATACC HRESULT STDMETHODCALLTYPE


CATAccessible::CATAccessible(CATGuiObj* object, CATWindow* baseWindow)
{
    CATTRACE("CATAccessible");
    fObject   = object;    
    fWindow   = baseWindow;
    fRefCount = 2; 
}

void CATAccessible::ObjectDeath()
{
    CATTRACE("CATAccessible::ObjectDeath");
    fObject = 0;
    this->Release();
}

CATAccessible::~CATAccessible()
{
    CATTRACE("CATAccessible::~CATAccessible");
    CATASSERT(fRefCount == 0, "RefCount should be 0 here...");
}

CATACC CATAccessible::get_accParent(    IDispatch**     ppdispParent)
{
    CATTRACE("CATAccessible::get_accParent");
    if (fObject)
    {
        if (0 == wcscmp(L"Window",fObject->GetType()))
        {
            *ppdispParent = 0;
            return S_FALSE;
        }
        
        *ppdispParent = ((CATGuiObj*)fObject->GetParent())->GetAccessible();
        return S_OK;
    }
    *ppdispParent = 0;
    return S_FALSE;
}

CATACC CATAccessible::get_accChildCount(long *          pcountChildren)
{
    CATTRACE("CATAccessible::get_accChildCount");
    if (!fObject)
    {
        *pcountChildren = 0;
        return S_FALSE;
    }

    long numChildren = (long)fObject->GetNumChildren();
    *pcountChildren = numChildren;
    return S_OK;
}

CATACC CATAccessible::get_accChild(     VARIANT         varChild,
                                        IDispatch **    ppdispChild)
{
    CATTRACE("CATAccessible::get_accChild");
    if (!fObject)
    {
        *ppdispChild = 0;
        return S_FALSE;
    }

    if (varChild.vt != VT_I4)
    {
        *ppdispChild = NULL;
        return E_INVALIDARG;
    }
    
    if (varChild.lVal == CHILDID_SELF)
    {
        *ppdispChild = (IDispatch*)this;
        return S_OK;
    }

    if ((CATUInt32)varChild.lVal < fObject->GetNumChildren())
    {
        CATGuiObj* obj = (CATGuiObj*)fObject->GetChild((CATUInt32)varChild.lVal);
        if (obj)
        {
            *ppdispChild = (IDispatch*)obj->GetAccessible();
            return S_OK;
        }
    }
    *ppdispChild = 0;
    return S_FALSE;
}

CATACC CATAccessible::get_accName(      VARIANT         varChild,
                                        BSTR *          pszName)
{
    CATTRACE("CATAccessible::get_accName");
    if (!fObject)
    {
        *pszName = 0;
        return S_FALSE;
    }
    if (varChild.vt != VT_I4)
    {
        *pszName = NULL;
        return E_INVALIDARG;
    }
    
    if (varChild.lVal == CHILDID_SELF)
    {
        *pszName = SysAllocString((const wchar_t*)fObject->GetName());
        return S_OK;
    }

    if ((CATUInt32)varChild.lVal < fObject->GetNumChildren())
    {
        CATGuiObj* obj = (CATGuiObj*)fObject->GetChild((CATUInt32)varChild.lVal);
        if (obj)
        {
            *pszName = SysAllocString((const wchar_t*)obj->GetName());
            return S_OK;
        }
    }
    
    *pszName = 0;
    return S_FALSE;
}

CATACC CATAccessible::get_accValue(     VARIANT         varChild,
                                        BSTR *          pszValue)
{
    CATTRACE("CATAccessible::get_accValue");
    if (!fObject)
    {
        *pszValue = 0;
        return S_FALSE;
    }
    if (varChild.vt != VT_I4)
    {
        *pszValue = NULL;
        return E_INVALIDARG;
    }
    
    if (fObject == fWindow)
    {
        *pszValue = 0;
        return S_FALSE;
    }

    if (varChild.lVal == CHILDID_SELF)
    {
        *pszValue = SysAllocString( (CATString)(((CATControl*)fObject)->GetValue()));
        return S_OK;
    }

    if ((CATUInt32)varChild.lVal < fObject->GetNumChildren())
    {
        CATGuiObj* obj = (CATGuiObj*)fObject->GetChild((CATUInt32)varChild.lVal);
        if (obj)
        {
            *pszValue = SysAllocString( (CATString)(((CATControl*)obj)->GetValue()));
            return S_OK;
        }
    }
    
    *pszValue = 0;
    return S_FALSE;
}

CATACC CATAccessible::get_accDescription(VARIANT        varChild,
                                         BSTR *         pszDescription)
{
    CATTRACE("CATAccessible::get_accDescription");

    if (!fObject)
    {
        *pszDescription = 0;
        return S_FALSE;
    }
    if (varChild.vt != VT_I4)
    {
        *pszDescription = NULL;
        return E_INVALIDARG;
    }
    
    if (varChild.lVal == CHILDID_SELF)
    {
        *pszDescription = SysAllocString((const wchar_t*)fObject->GetType());
        return S_OK;
    }

    if ((CATUInt32)varChild.lVal < fObject->GetNumChildren())
    {
        CATGuiObj* obj = (CATGuiObj*)fObject->GetChild((CATUInt32)varChild.lVal);
        if (obj)
        {
            *pszDescription = SysAllocString((const wchar_t*)obj->GetType());
            return S_OK;
        }
    }
    
    *pszDescription= 0;
    return S_FALSE;
}

CATACC CATAccessible::get_accRole(      VARIANT         varChild,
                                        VARIANT *       pvarRole)
{
    if (!fObject)
    {
        pvarRole->vt = VT_EMPTY;
        return S_FALSE;
    }
    
    if (varChild.vt != VT_I4)
    {
        pvarRole->vt = VT_EMPTY;
        return E_INVALIDARG;
    }
    
    if (varChild.lVal == CHILDID_SELF)
    {
        pvarRole->vt    = VT_I4;
        pvarRole->lVal = fObject->GetAccessRole();        
        return S_OK;
    }

    if ((CATUInt32)varChild.lVal < fObject->GetNumChildren())
    {
        CATGuiObj* obj = (CATGuiObj*)fObject->GetChild((CATUInt32)varChild.lVal);
        if (obj)
        {
            pvarRole->vt    = VT_I4;
            pvarRole->lVal = obj->GetAccessRole();        
            return S_OK;
        }
    }
    return S_FALSE;
}

CATACC CATAccessible::get_accState(     VARIANT         varChild, 
                                        VARIANT *       pvarState)
{
    CATTRACE("CATAccessible::get_accState");
    if (!fObject)
    {
        pvarState->vt = VT_EMPTY;
        return S_FALSE;
    }
    
    if (varChild.vt != VT_I4)
    {
        pvarState->vt = VT_EMPTY;
        return E_INVALIDARG;
    }
    
    if (varChild.lVal == CHILDID_SELF)
    {
        pvarState->vt    = VT_I4;
        pvarState->lVal = fObject->GetAccessState();        
        return S_OK;
    }

    if ((CATUInt32)varChild.lVal < fObject->GetNumChildren())
    {
        CATGuiObj* obj = (CATGuiObj*)fObject->GetChild((CATUInt32)varChild.lVal);
        if (obj)
        {
            pvarState->vt    = VT_I4;
            pvarState->lVal  = obj->GetAccessState();
            return S_OK;
        }
    }
    return S_FALSE;
}

CATACC CATAccessible::get_accHelp(      VARIANT         varChild,
                                        BSTR *          pszHelp)
{
    CATTRACE("CATAccessible::get_accHelp");

    if (!fObject)
    {
        *pszHelp = 0;
        return S_FALSE;
    }
    if (varChild.vt != VT_I4)
    {
        *pszHelp = NULL;
        return E_INVALIDARG;
    }
    
    if (varChild.lVal == CHILDID_SELF)
    {
        *pszHelp = SysAllocString((const wchar_t*)fObject->GetHint());
        return S_OK;
    }

    if ((CATUInt32)varChild.lVal < fObject->GetNumChildren())
    {
        CATGuiObj* obj = (CATGuiObj*)fObject->GetChild((CATUInt32)varChild.lVal);
        if (obj)
        {
            *pszHelp = SysAllocString((const wchar_t*)obj->GetHint());
            return S_OK;
        }
    }
    
    *pszHelp = 0;
    return S_FALSE;
}

CATACC CATAccessible::get_accHelpTopic (BSTR *          pszHelpFile,
                                        VARIANT         varChild,
                                        long *          pidTopic)
{
    CATTRACE("CATAccessible::get_accHelpTopic");
    return S_FALSE;
}

CATACC CATAccessible::get_accKeyboardShortcut(VARIANT         varChild,
                                              BSTR *          pszKeyboardShortcut)
{
    CATTRACE("CATAccessible::get_AccKeyboardShortcut");
    return S_FALSE;
}

CATACC CATAccessible::get_accFocus(     VARIANT *       pvarChild)
{
    CATTRACE("CATAccessible::get_accFocus");
    if (!fObject)
    {
        pvarChild->vt = VT_EMPTY;
        return S_FALSE;
    }

    CATControl* control = fWindow->GetFocusControl();
    if (control)
    {
        if (control == fObject)
        {
            pvarChild->vt = VT_I4;
            pvarChild->lVal = CHILDID_SELF;
            return S_OK;
        }

        pvarChild->vt       = VT_DISPATCH;
        pvarChild->pdispVal = control->GetAccessible();
    }

    pvarChild->vt = VT_EMPTY;
    return S_FALSE;
}

CATACC CATAccessible::get_accSelection (VARIANT *       pvarChildren)
{
    CATTRACE("CATAccessible::get_accSelection");
    return S_FALSE;
}

CATACC CATAccessible::get_accDefaultAction(VARIANT         varChild,
                                           BSTR *          pszDefaultAction)
{
    CATTRACE("CATAccessible::get_accDefaultAction");
    return S_FALSE;
}

CATACC CATAccessible::accSelect(        long            flagsSelect,
                                        VARIANT         varChild)
{
    CATTRACE("CATAccessible::accSelect");
    if (varChild.vt != VT_I4)
    {
        return E_INVALIDARG;
    }


    if (varChild.lVal == CHILDID_SELF)
    {
        if (flagsSelect & SELFLAG_TAKEFOCUS)
        {
            fWindow->SetFocus((CATControl*)fObject);
        }
        return S_OK;
    }

    if ((CATUInt32)varChild.lVal < fObject->GetNumChildren())
    {
        CATGuiObj* obj = (CATGuiObj*)fObject->GetChild((CATUInt32)varChild.lVal);
        if (obj)
        {
            if (flagsSelect & SELFLAG_TAKEFOCUS)
            {
                fWindow->SetFocus((CATControl*)obj);
            }
            return S_OK;
        }
    }

    return S_FALSE;
}

CATACC CATAccessible::accLocation(      long *          pxLeft,
                                        long *          pyTop,
                                        long *          pcxWidth,
                                        long *          pcyHeight,
                                         VARIANT        varChild)
{
    CATTRACE("CATAccessible::accLocation");
    return S_FALSE;
}

CATACC CATAccessible::accNavigate(      long            navDir,
                                        VARIANT         varStart,
                                        VARIANT *       pvarEndUpAt)
{
    CATTRACE("CATAccessible::accNavigate");
    if (varStart.vt != VT_I4)
    {
        pvarEndUpAt->vt       = VT_DISPATCH;
        pvarEndUpAt->pdispVal = this;
        return S_OK;
    }

    if (fObject == fWindow)
    {
        pvarEndUpAt->vt = VT_DISPATCH;
        pvarEndUpAt->pdispVal = this;
        CATUInt32 numChildren = fWindow->GetNumChildren();        
        return S_OK;
    }
    
    
    CATControl* curObj = (CATControl*)fObject;
    if (varStart.lVal != CHILDID_SELF)
    {
        if ((CATUInt32)varStart.lVal < fObject->GetNumChildren())
        {
            curObj = (CATControl*)fObject->GetChild((CATUInt32)varStart.lVal);
        }
    }   
    
    CATFINDCONTROLSTRUCT ctrlStruct;
    fWindow->GetControlStruct(ctrlStruct,curObj);
    
    switch (navDir)
    {
        case NAVDIR_FIRSTCHILD:
            pvarEndUpAt->pdispVal = 0;
            break;
        case NAVDIR_LASTCHILD:
            pvarEndUpAt->pdispVal = 0;
            break;
        case NAVDIR_LEFT:
        case NAVDIR_PREVIOUS:
        case NAVDIR_UP:
            if (ctrlStruct.NextControl)
                pvarEndUpAt->pdispVal = ctrlStruct.NextControl->GetAccessible();
            break;
        case NAVDIR_RIGHT:
        case NAVDIR_DOWN:
        case NAVDIR_NEXT:
            if (ctrlStruct.PrevControl)
                pvarEndUpAt->pdispVal = ctrlStruct.PrevControl->GetAccessible();
            break;
    }            

    return S_FALSE;
}

CATACC CATAccessible::accHitTest(       long            xLeft,
                                        long            yTop,
                                        VARIANT *       pvarChild)
{
    CATTRACE("CATAccessible::accHitTest");
    if (!fObject)
    {
        pvarChild->vt = VT_EMPTY;
        return S_FALSE;
    }

    CATPOINT point;
    point.x = xLeft;
    point.y = yTop;
    ::ScreenToClient(fWindow->OSGetWnd(),(LPPOINT)&point);
    CATControl* control = fWindow->HitTest(point);
    if (control)
    {
        if (control == fObject)
        {
            pvarChild->vt = VT_I4;
            pvarChild->lVal = CHILDID_SELF;
            return S_OK;
        }

        pvarChild->vt       = VT_DISPATCH;
        pvarChild->pdispVal = control->GetAccessible();
    }

    pvarChild->vt = VT_EMPTY;
    return S_FALSE;
}

CATACC CATAccessible::accDoDefaultAction(VARIANT        varChild)
{
    CATTRACE("CATAccessible::accDoDefaultAction");
    return S_FALSE;
}

CATACC CATAccessible::put_accName(      VARIANT       varChild,
                                        BSTR          szName)
{
    CATTRACE("CATAccessible::put_accName");
    return S_FALSE;
}

CATACC CATAccessible::put_accValue(VARIANT      varChild,
                                   BSTR         szValue)
{
    CATTRACE("CATAccessible::put_accValue");
    return S_FALSE;
}


CATACC CATAccessible::QueryInterface(   REFIID          riid,
                                        void **         ppvObject)
{
    if (riid == IID_IUnknown)
    {
        *ppvObject = (IUnknown*)this;
        AddRef();
        return S_OK;
    }


    if  (riid == IID_IAccessible)
    {
        *ppvObject = (IAccessible*)this;
        AddRef();
        return S_OK;
    }

    if (riid == IID_IDispatch)
    {
        *ppvObject = (IDispatch*)this;
        AddRef();
        return S_OK;
    }
    return E_NOINTERFACE;
}

ULONG STDMETHODCALLTYPE CATAccessible::AddRef ( void)
{
    CATTRACE("AddRef()");
    return ++fRefCount;
}

ULONG STDMETHODCALLTYPE CATAccessible::Release( void)
{    
    CATTRACE("Release()");
    fRefCount--;    
    
    ULONG retVal = fRefCount;
    
    if (!retVal)
        delete this;
    
    return retVal;    
}

CATACC CATAccessible::GetTypeInfoCount( UINT *          pctinfo)
{
    *pctinfo = 0;
    return E_NOTIMPL;
}

CATACC CATAccessible::GetTypeInfo(      UINT            iTInfo,
                                        LCID            lcid,
                                        ITypeInfo **    ppTInfo)
{
    *ppTInfo = 0;
    return E_NOTIMPL;
}

CATACC CATAccessible::GetIDsOfNames(          REFIID          riid,
                                        __RPC__in_ecount_full(cNames) LPOLESTR *rgszNames,
                                        UINT            cNames,
                                        LCID            lcid,
                                        __RPC__out_ecount_full(cNames) DISPID *rgDispId)
{
    return E_NOTIMPL;
}

CATACC CATAccessible::Invoke(    DISPID          dispIdMember,
                                 REFIID          riid,
                                 LCID            lcid,
                                 WORD            wFlags,
                                 DISPPARAMS *    pDispParams,
                                 VARIANT *       pVarResult,
                                 EXCEPINFO *     pExcepInfo,
                                 UINT *          puArgErr)
{
    return E_NOTIMPL;
}




#undef CATACC

---