libreoffice/svx/source/accessibility/AccessibleContextBase.cxx

/*************************************************************************
 *
 *  $RCSfile: AccessibleContextBase.cxx,v $
 *
 *  $Revision: 1.5 $
 *
 *  last change: $Author: af $ $Date: 2002-03-18 10:11:54 $
 *
 *  The Contents of this file are made available subject to the terms of
 *  either of the following licenses
 *
 *         - GNU Lesser General Public License Version 2.1
 *         - Sun Industry Standards Source License Version 1.1
 *
 *  Sun Microsystems Inc., October, 2000
 *
 *  GNU Lesser General Public License Version 2.1
 *  =============================================
 *  Copyright 2000 by Sun Microsystems, Inc.
 *  901 San Antonio Road, Palo Alto, CA 94303, USA
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License version 2.1, as published by the Free Software Foundation.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *  MA  02111-1307  USA
 *
 *
 *  Sun Industry Standards Source License Version 1.1
 *  =================================================
 *  The contents of this file are subject to the Sun Industry Standards
 *  Source License Version 1.1 (the "License"); You may not use this file
 *  except in compliance with the License. You may obtain a copy of the
 *  License at http://www.openoffice.org/license.html.
 *
 *  Software provided under this License is provided on an "AS IS" basis,
 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
 *  See the License for the specific provisions governing your rights and
 *  obligations concerning the Software.
 *
 *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
 *
 *  Copyright: 2000 by Sun Microsystems, Inc.
 *
 *  All Rights Reserved.
 *
 *  Contributor(s): _______________________________________
 *
 *
 ************************************************************************/


#include "AccessibleContextBase.hxx"

#ifndef _DRAFTS_COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEROLE_HPP_
#include <drafts/com/sun/star/accessibility/AccessibleRole.hpp>
#endif

#ifndef _COM_SUN_STAR_BEANS_PROPERTYCHANGEEVENT_HPP_
#include <com/sun/star/beans/PropertyChangeEvent.hpp>
#endif
#ifndef _DRAFTS_COM_SUN_STAR_ACCESSIBILITY_XACCESSIBLEEVENTLISTENER_HPP_
#include <drafts/com/sun/star/accessibility/XAccessibleEventListener.hpp>
#endif


#ifndef _RTL_UUID_H_
#include <rtl/uuid.h>
#endif

#include <vos/mutex.hxx>
#include <vcl/svapp.hxx>

using namespace ::rtl;
using namespace ::com::sun::star;
using namespace ::drafts::com::sun::star::accessibility;

namespace accessibility {

//=====  internal  ============================================================

AccessibleContextBase::AccessibleContextBase (
        const uno::Reference<XAccessible>& rxParent,
        const sal_Int16 aRole)
    :
    maRole(aRole),
    mxParent(rxParent)
{
}




AccessibleContextBase::~AccessibleContextBase(void)
{
}




//=====  XAccessible  =========================================================

uno::Reference< XAccessibleContext> SAL_CALL
    AccessibleContextBase::getAccessibleContext (void)
    throw (uno::RuntimeException)
{
    return this;
}




//=====  XAccessibleContext  ==================================================

/** No children.
*/
sal_Int32 SAL_CALL
       AccessibleContextBase::getAccessibleChildCount (void)
    throw (uno::RuntimeException)
{
    return 0;
}




/** Forward the request to the shape.  Return the requested shape or throw
    an exception for a wrong index.
*/
uno::Reference<XAccessible> SAL_CALL
    AccessibleContextBase::getAccessibleChild (long nIndex)
    throw (::com::sun::star::uno::RuntimeException)
{
    throw lang::IndexOutOfBoundsException (
        ::rtl::OUString::createFromAscii ("no child with index " + nIndex),
        NULL);
}




uno::Reference<XAccessible> SAL_CALL
       AccessibleContextBase::getAccessibleParent (void)
    throw (::com::sun::star::uno::RuntimeException)
{
    return mxParent;
}




sal_Int32 SAL_CALL
       AccessibleContextBase::getAccessibleIndexInParent (void)
    throw (::com::sun::star::uno::RuntimeException)
{
    //  Use a simple but slow solution for now.  Optimize later.

    //  Iterate over all the parent's children and search for this object.
    if (mxParent.is())
    {
        uno::Reference<XAccessibleContext> xParentContext (
            mxParent->getAccessibleContext());
        if (xParentContext.is())
        {
            sal_Int32 nChildCount = xParentContext->getAccessibleChildCount();
            for (sal_Int32 i=0; i<nChildCount; i++)
            {
                uno::Reference<XAccessible> xChild (xParentContext->getAccessibleChild (i));
                if (xChild.is())
                {
                    uno::Reference<XAccessibleContext> xChildContext = xChild->getAccessibleContext();
                    if (xChildContext == (XAccessibleContext*)this)
                        return i;
                }
            }
        }
   }

   //   Return -1 to indicate that this object's parent does not know about the
   //   object.
   return -1;
}




sal_Int16 SAL_CALL
    AccessibleContextBase::getAccessibleRole (void)
    throw (::com::sun::star::uno::RuntimeException)
{
    return maRole;
}




::rtl::OUString SAL_CALL
       AccessibleContextBase::getAccessibleDescription (void)
    throw (::com::sun::star::uno::RuntimeException)
{
    if ( ! msDescription.getLength())
        SetAccessibleDescription (CreateAccessibleDescription());
    return msDescription;
}



OUString SAL_CALL
       AccessibleContextBase::getAccessibleName (void)
    throw (::com::sun::star::uno::RuntimeException)
{
    if ( !msName.getLength())
        SetAccessibleDescription (CreateAccessibleName());
    return msName;
}




/** Return empty reference to indicate that the relation set is not
    supported.
*/
uno::Reference<XAccessibleRelationSet> SAL_CALL
       AccessibleContextBase::getAccessibleRelationSet (void)
    throw (::com::sun::star::uno::RuntimeException)
{
    return uno::Reference<XAccessibleRelationSet>();
}




/** Create the set of states the object is in.  Possible states are:
        EDITABLE
        ENABLED
        SHOWING
        VISIBLE
    For now, return only an empty reference and wait for an implementation of
    the XAccessibleStateSet interface.
*/
uno::Reference<XAccessibleStateSet> SAL_CALL
    AccessibleContextBase::getAccessibleStateSet (void)
    throw (::com::sun::star::uno::RuntimeException)
{
    return uno::Reference<XAccessibleStateSet>();
}




lang::Locale SAL_CALL
       AccessibleContextBase::getLocale (void)
    throw (IllegalAccessibleComponentStateException,
        ::com::sun::star::uno::RuntimeException)
{
    // Delegate request to parent.
    if (mxParent.is())
    {
        uno::Reference<XAccessibleContext> xParentContext (
            mxParent->getAccessibleContext());
        if (xParentContext.is())
            return xParentContext->getLocale ();
    }

    //  No locale and no parent.  Therefore throw exception to indicate this
    //  cluelessness.
    throw IllegalAccessibleComponentStateException ();
}




//=====  XAccessibleEventListener  ============================================

void SAL_CALL
    AccessibleContextBase::addEventListener (
        const uno::Reference<XAccessibleEventListener >& xListener)
    throw (uno::RuntimeException)
{
    if (xListener.is())
    {
        ::vos::OGuard aGuard (maMutex);
           mxEventListeners.insert (
            mxEventListeners.begin(),
            xListener);
        OSL_ASSERT (mxEventListeners.begin()!=mxEventListeners.end());
    }
}




void SAL_CALL
    AccessibleContextBase::removeEventListener (
        const uno::Reference<XAccessibleEventListener >& xListener )
    throw (uno::RuntimeException)
{
    if (xListener.is())
    {
        ::vos::OGuard aGuard (maMutex);
        mxEventListeners.erase (xListener);
    }
}




//=====  XComponent  ==========================================================

void SAL_CALL AccessibleContextBase::dispose (void)
    throw (::com::sun::star::uno::RuntimeException)
{
}


void SAL_CALL AccessibleContextBase::addEventListener (
    const ::com::sun::star::uno::Reference<
    ::com::sun::star::lang::XEventListener >& xListener)
    throw (::com::sun::star::uno::RuntimeException)
{
}




void SAL_CALL AccessibleContextBase::removeEventListener (
    const ::com::sun::star::uno::Reference<
    ::com::sun::star::lang::XEventListener >& aListener)
    throw (::com::sun::star::uno::RuntimeException)
{
}



//=====  XServiceInfo  ========================================================

::rtl::OUString SAL_CALL
       AccessibleContextBase::getImplementationName (void)
    throw (::com::sun::star::uno::RuntimeException)
{
    return OUString(RTL_CONSTASCII_USTRINGPARAM ("AccessibleContextBase"));
}




sal_Bool SAL_CALL
     AccessibleContextBase::supportsService (const OUString& sServiceName)
    throw (::com::sun::star::uno::RuntimeException)
{
    //  Iterate over all supported service names and return true if on of them
    //  matches the given name.
    uno::Sequence< ::rtl::OUString> aSupportedServices (
        getSupportedServiceNames ());
    for (int i=0; i<aSupportedServices.getLength(); i++)
        if (sServiceName == aSupportedServices[i])
            return sal_True;
    return sal_False;
}




uno::Sequence< ::rtl::OUString> SAL_CALL
       AccessibleContextBase::getSupportedServiceNames (void)
    throw (::com::sun::star::uno::RuntimeException)
{
    const OUString sServiceName (
        RTL_CONSTASCII_USTRINGPARAM ("drafts.com.sun.star.accessibility.AccessibleContext"));
    return uno::Sequence<OUString> (&sServiceName, 1);
}




//=====  XTypeProvider  =======================================================

uno::Sequence< ::com::sun::star::uno::Type>
    AccessibleContextBase::getTypes (void)
    throw (::com::sun::star::uno::RuntimeException)
{
    const ::com::sun::star::uno::Type aTypeList[] = {
        ::getCppuType((const uno::Reference<
            XAccessible>*)0),
        ::getCppuType((const uno::Reference<
            XAccessibleContext>*)0),
        ::getCppuType((const uno::Reference<
            XAccessibleEventBroadcaster>*)0),
        ::getCppuType((const uno::Reference<
            lang::XServiceInfo>*)0),
        ::getCppuType((const uno::Reference<
            lang::XTypeProvider>*)0),
        ::getCppuType((const uno::Reference<
            lang::XServiceName>*)0)
        };
    ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type>
        aTypeSequence (aTypeList, 6);
    return aTypeSequence;
}




uno::Sequence<sal_Int8> SAL_CALL
    AccessibleContextBase::getImplementationId (void)
    throw (::com::sun::star::uno::RuntimeException)
{
    static uno::Sequence<sal_Int8> aId;
    if (aId.getLength() == 0)
    {
        ::vos::OGuard aGuard (maMutex);
        aId.realloc (16);
        rtl_createUuid ((sal_uInt8 *)aId.getArray(), 0, sal_True);
    }
    return aId;
}




//=====  XServiceName  ========================================================

::rtl::OUString
    AccessibleContextBase::getServiceName (void)
    throw (::com::sun::star::uno::RuntimeException)
{
    return OUString(
        RTL_CONSTASCII_USTRINGPARAM ("drafts.com.sun.star.accessibility.AccessibleContext"));
}




//=====  internal  ============================================================

void AccessibleContextBase::SetAccessibleDescription (const ::rtl::OUString& rDescription)
    throw (uno::RuntimeException)
{
    if (msDescription != rDescription)
    {
        uno::Any aOldValue, aNewValue;
        aOldValue <<= msDescription;
        aNewValue <<= rDescription;

        msDescription = rDescription;

        CommitChange(
            AccessibleEventId::ACCESSIBLE_DESCRIPTION_EVENT,
            aNewValue,
            aOldValue);
    }
}




void AccessibleContextBase::SetAccessibleName (const ::rtl::OUString& rName)
    throw (uno::RuntimeException)
{
    if (msName != rName)
    {
        uno::Any aOldValue, aNewValue;
        aOldValue <<= msName;
        aNewValue <<= rName;

        msName = rName;

        CommitChange(
            AccessibleEventId::ACCESSIBLE_NAME_EVENT,
            aNewValue,
            aOldValue);
    }
}




::rtl::OUString AccessibleContextBase::CreateAccessibleDescription (void)
    throw (::com::sun::star::uno::RuntimeException)
{
    return ::rtl::OUString::createFromAscii ("Empty Description");
}




::rtl::OUString AccessibleContextBase::CreateAccessibleName (void)
    throw (::com::sun::star::uno::RuntimeException)
{
    return ::rtl::OUString::createFromAscii ("Empty Name");
}




void AccessibleContextBase::CommitChange (
    sal_Int16 nEventId,
    const uno::Any& rNewValue,
    const uno::Any& rOldValue)
{
    AccessibleEventObject aEvent (
        static_cast<uno::XWeak*>(this),
        nEventId,
        rNewValue,
        rOldValue);

    FireEvent (aEvent);
}




void AccessibleContextBase::FireEvent (const AccessibleEventObject& aEvent)
{
    uno::Reference<XAccessibleEventListener>* aListeners;
    int nListenerCount;
    EventListenerListType::iterator I;

    {
        // Guarded by the mutex copy list of listeners into a local list.
        // This is necessary to be able to call the listeners outside the
        // scope of the mutex and to not to be disturbed by outside changes
        // to the list of listeners.
        ::vos::OGuard aGuard (maMutex);
        nListenerCount = mxEventListeners.size();
        aListeners = new uno::Reference<XAccessibleEventListener>[nListenerCount];
        int i=0;
        for (I=mxEventListeners.begin(); I!=mxEventListeners.end(); I++)
        {
            aListeners[i++] = *I;
        }
    }

    // Now call the listeners.
    for (int i=0; i<nListenerCount; i++)
    {
        if (aListeners[i].is())
        {
            OSL_TRACE ("Fireing event %d.", aEvent.EventId);
            aListeners[i]->notifyEvent (aEvent);
        }
        else
            OSL_TRACE ("listener invalid.");
    }

    delete [] aListeners;
}




} // end of namespace accessibility