/*************************************************************************
 *
 *  $RCSfile: AccessibleTextHelper.cxx,v $
 *
 *  $Revision: 1.1 $
 *
 *  last change: $Author: thb $ $Date: 2002-05-16 16:10:57 $
 *
 *  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): _______________________________________
 *
 *
 ************************************************************************/

#pragma hdrstop

//------------------------------------------------------------------------
//
// Global header
//
//------------------------------------------------------------------------

#include <limits.h>
#include <memory>
#include <algorithm>

#ifndef _VOS_MUTEX_HXX_
#include <vos/mutex.hxx>
#endif

#ifndef _COM_SUN_STAR_UNO_ANY_HXX_
#include <com/sun/star/uno/Any.hxx>
#endif

#ifndef _COM_SUN_STAR_UNO_REFERENCE_HXX_
#include <com/sun/star/uno/Reference.hxx>
#endif

#ifndef _CPPUHELPER_WEAKREF_HXX_
#include <cppuhelper/weakref.hxx>
#endif

#ifndef _COM_SUN_STAR_AWT_POINT_HPP_
#include <com/sun/star/awt/Point.hpp>
#endif

#ifndef _COM_SUN_STAR_AWT_RECTANGLE_HPP_
#include <com/sun/star/awt/Rectangle.hpp>
#endif

#ifndef _DRAFTS_COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEEVENTID_HPP_
#include <drafts/com/sun/star/accessibility/AccessibleEventId.hpp>
#endif

#ifndef _DRAFTS_COM_SUN_STAR_ACCESSIBILITY_XACCESSIBLE_HPP_
#include <drafts/com/sun/star/accessibility/XAccessible.hpp>
#endif

#ifndef _DRAFTS_COM_SUN_STAR_ACCESSIBILITY_XACCESSIBLECONTEXT_HPP_
#include <drafts/com/sun/star/accessibility/XAccessibleContext.hpp>
#endif

#ifndef _DRAFTS_COM_SUN_STAR_ACCESSIBILITY_XACCESSIBLECOMPONENT_HPP_
#include <drafts/com/sun/star/accessibility/XAccessibleComponent.hpp>
#endif

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

#ifndef _DRAFTS_COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLETEXTTYPE_HPP_
#include <drafts/com/sun/star/accessibility/AccessibleTextType.hpp>
#endif

#ifndef _DRAFTS_COM_SUN_STAR_ACCESSIBILITY_XACCESSIBLETEXT_HPP_
#include <drafts/com/sun/star/accessibility/XAccessibleText.hpp>
#endif

#ifndef _DRAFTS_COM_SUN_STAR_ACCESSIBILITY_XACCESSIBLEEDITABLETEXT_HPP_
#include <drafts/com/sun/star/accessibility/XAccessibleEditableText.hpp>
#endif

#ifndef _DRAFTS_COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLESTATETYPE_HPP_
#include <drafts/com/sun/star/accessibility/AccessibleStateType.hpp>
#endif

#ifndef _UTL_ACCESSIBLESTATESETHELPER_HXX_
#include <unotools/accessiblestatesethelper.hxx>
#endif


//------------------------------------------------------------------------
//
// Project-local header
//
//------------------------------------------------------------------------

#ifndef _SVX_UNOEDACC_HXX_
#include "unoedacc.hxx"
#endif

#ifndef _SVX_UNOSHAPE_HXX
#include "unoshape.hxx"
#endif

#ifndef _UNO_LINGU_HXX
#include "unolingu.hxx"
#endif

#ifndef _SVX_UNOTEXT_HXX
#include "unotext.hxx"
#endif

#include "unoedhlp.hxx"
#include "unopracc.hxx"
#include "AccessibleParaManager.hxx"
#include "AccessibleEditableTextPara.hxx"
#include "svdmodel.hxx"
#include "svdpntv.hxx"
#include "editdata.hxx"
#include "editeng.hxx"
#include "editview.hxx"

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


//------------------------------------------------------------------------
//
// SvxAccessibleTextHelper_Impl declaration
//
//------------------------------------------------------------------------

class SvxAccessibleTextHelper_Impl : public SfxListener
{

public:

    // receive pointer to our frontend class and view window
    SvxAccessibleTextHelper_Impl( const uno::Reference< XAccessible >& rInterface );
    ~SvxAccessibleTextHelper_Impl();

    // XAccessibleContext child handling methods
    sal_Int32 SAL_CALL getAccessibleChildCount() throw (uno::RuntimeException);
    uno::Reference< XAccessible > SAL_CALL getAccessibleChild( sal_Int32 i ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException);

    // XAccessibleEventBroadcaster child related methods
    void SAL_CALL addEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) throw (uno::RuntimeException);
    void SAL_CALL removeEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) throw (uno::RuntimeException);

    // XAccessibleComponent child related methods
    uno::Reference< XAccessible > SAL_CALL getAccessibleAt( const awt::Point& aPoint ) throw (uno::RuntimeException);

    SvxEditSourceAdapter& GetEditSource() const throw (uno::RuntimeException);
    void SetEditSource( ::std::auto_ptr< SvxEditSource > pEditSource ) throw (uno::RuntimeException);

    void SetOffset( const Point& );
    const Point& GetOffset() const { return maOffset; } // Strictly correct only with locked solar mutex!

    sal_Bool IsSelected() const;

    // do NOT hold object mutex when calling this! Danger of deadlock
    void FireEvent( const sal_Int16 nEventId, const uno::Any& rNewValue = uno::Any(), const uno::Any& rOldValue = uno::Any() ) const;

#ifdef DBG_UTIL
    void CheckInvariants() const;
#endif

    // checks all children for visibility, throws away invisible ones
    void UpdateVisibleChildren();

private:

    // syntactic sugar for FireEvent
    void GotPropertyEvent( const uno::Any& rNewValue, const sal_Int16 nEventId ) const { FireEvent( nEventId, rNewValue ); }
    void LostPropertyEvent( const uno::Any& rOldValue, const sal_Int16 nEventId ) const { FireEvent( nEventId, uno::Any(), rOldValue ); }

    // shutdown usage of current edit source on myself and the children.
    void ShutdownEditSource() throw (uno::RuntimeException);

    virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint );

    // lock solar mutex before
    SvxTextForwarder& GetTextForwarder() const throw (uno::RuntimeException);
    // lock solar mutex before
    SvxViewForwarder& GetViewForwarder() const throw (uno::RuntimeException);
    // lock solar mutex before
    SvxEditViewForwarder& GetEditViewForwarder( sal_Bool bCreate = sal_False ) const throw (uno::RuntimeException);

    // are we in edit mode?
    sal_Bool IsActive() const throw (uno::RuntimeException);

    void UpdateVisibleData();

    // calls SetSelection on the forwarder and updates maLastSelection
    // cache. Caution: calls StateChangeEvent and sets object into
    // edit mode!
    void UpdateSelection( const ESelection& );

    /// our current offset to the containing shape/cell (guarded by solar mutex)
    Point maOffset;

    // our frontend class (the one implementing the actual
    // interface). That's not necessarily the one containing the impl
    // pointer!
    const uno::Reference< XAccessible > mxFrontEnd;

    // a wrapper for the text forwarders (guarded by solar mutex)
    mutable SvxEditSourceAdapter maEditSource;

    // store last selection (to correctly report selection changes, guarded by solar mutex)
    ESelection maLastSelection;

    // cache range of visible children (guarded by solar mutex)
    sal_Int32 mnFirstVisibleChild;
    sal_Int32 mnLastVisibleChild;

    // the object handling our children (guarded by solar mutex)
    accessibility::AccessibleParaManager maParaManager;

    // must be before maStateListeners, has to live longer
    mutable ::osl::Mutex maMutex;

    // handles our event listeners (guarded by maMutex)
    ::cppu::OInterfaceContainerHelper maStateListeners;

};

//------------------------------------------------------------------------
//
// SvxAccessibleTextHelper_Impl implementation
//
//------------------------------------------------------------------------

SvxAccessibleTextHelper_Impl::SvxAccessibleTextHelper_Impl( const uno::Reference< XAccessible >& rInterface ) :
    maOffset(0,0),
    mxFrontEnd( rInterface ),
    maLastSelection( 0,0,0,0 ),
    mnFirstVisibleChild( -1 ),
    mnLastVisibleChild( -2 ),
    maStateListeners( maMutex )
{
}

SvxAccessibleTextHelper_Impl::~SvxAccessibleTextHelper_Impl()
{
    ::vos::OGuard aGuard( Application::GetSolarMutex() );

    try
    {
        // shutdown and release edit source
        SetEditSource( ::std::auto_ptr< SvxEditSource >() );
    }
    catch( const uno::RuntimeException& ) {}

    // owner is responsible for dispose and clear on listeners
}

SvxTextForwarder& SvxAccessibleTextHelper_Impl::GetTextForwarder() const throw (uno::RuntimeException)
{
    if( !maEditSource.IsValid() )
        throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown edit source")), mxFrontEnd);

    SvxTextForwarder* pTextForwarder = maEditSource.GetTextForwarder();

    if( !pTextForwarder )
        throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Unable to fetch text forwarder, model might be dead")), mxFrontEnd);

    if( pTextForwarder->IsValid() )
        return *pTextForwarder;
    else
        throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Text forwarder is invalid, model might be dead")), mxFrontEnd);
}

SvxViewForwarder& SvxAccessibleTextHelper_Impl::GetViewForwarder() const throw (uno::RuntimeException)
{
    if( !maEditSource.IsValid() )
        throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown edit source")), mxFrontEnd);

    SvxViewForwarder* pViewForwarder = maEditSource.GetViewForwarder();

    if( !pViewForwarder )
        throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Unable to fetch view forwarder, model might be dead")), mxFrontEnd);

    if( pViewForwarder->IsValid() )
        return *pViewForwarder;
    else
        throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("View forwarder is invalid, model might be dead")), mxFrontEnd);
}

SvxEditViewForwarder& SvxAccessibleTextHelper_Impl::GetEditViewForwarder( sal_Bool bCreate ) const throw (uno::RuntimeException)
{
    if( !maEditSource.IsValid() )
        throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown edit source")), mxFrontEnd);

    SvxEditViewForwarder* pViewForwarder = maEditSource.GetEditViewForwarder( bCreate );

    if( !pViewForwarder )
    {
        if( bCreate )
            throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Unable to fetch edit view forwarder, model might be dead")), mxFrontEnd);
        else
            throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("No edit view forwarder, object not in edit mode")), mxFrontEnd);
    }

    if( pViewForwarder->IsValid() )
        return *pViewForwarder;
    else
    {
        if( bCreate )
            throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("View forwarder is invalid, model might be dead")), mxFrontEnd);
        else
            throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("View forwarder is invalid, object not in edit mode")), mxFrontEnd);
    }
}

SvxEditSourceAdapter& SvxAccessibleTextHelper_Impl::GetEditSource() const throw (uno::RuntimeException)
{
    if( maEditSource.IsValid() )
        return maEditSource;
    else
        throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SvxAccessibleTextHelper_Impl::GetEditSource: no edit source")), mxFrontEnd );
}

sal_Bool SvxAccessibleTextHelper_Impl::IsSelected() const
{
    sal_Bool bRet = sal_False;

    try
    {
        ESelection aSelection;
        bRet = GetEditViewForwarder().GetSelection( aSelection );
    }
    catch( const uno::RuntimeException& ) {}

    return bRet;
}

sal_Bool SvxAccessibleTextHelper_Impl::IsActive() const throw (uno::RuntimeException)
{
    SvxEditSource& rEditSource = GetEditSource();
    SvxEditViewForwarder* pViewForwarder = rEditSource.GetEditViewForwarder();

    if( !pViewForwarder )
        return sal_False;

    if( pViewForwarder->IsValid() )
        return sal_True;
    else
        return sal_False;
}

void SvxAccessibleTextHelper_Impl::UpdateSelection( const ESelection& rSelection )
{
    if( !maLastSelection.IsEqual( rSelection ) )
    {
        // notify all affected paragraphs (TODO: may be suboptimal,
        // since some paragraphs might stay selected)

        maParaManager.FireEvent( maLastSelection.nStartPara,
                                 maLastSelection.nEndPara,
                                 AccessibleEventId::ACCESSIBLE_SELECTION_EVENT );

        maParaManager.FireEvent( maLastSelection.nStartPara,
                                 maLastSelection.nStartPara,
                                 AccessibleEventId::ACCESSIBLE_CARET_EVENT );

        maParaManager.FireEvent( rSelection.nStartPara,
                                 rSelection.nEndPara,
                                 AccessibleEventId::ACCESSIBLE_SELECTION_EVENT );

        maParaManager.FireEvent( rSelection.nStartPara,
                                 rSelection.nStartPara,
                                 AccessibleEventId::ACCESSIBLE_CARET_EVENT );

        maLastSelection = rSelection;
    }
}

// functor for sending child events
class SvxAccessibleTextHelper_SendAccessibleChildEvent : public ::std::unary_function< accessibility::AccessibleEditableTextPara&, void >
{
public:
    SvxAccessibleTextHelper_SendAccessibleChildEvent( SvxAccessibleTextHelper_Impl& rImpl ) : mrImpl(rImpl) {}
    void operator()( accessibility::AccessibleEditableTextPara& rPara )
    {
        uno::Reference< XAccessible > xChild( static_cast< ::cppu::OWeakObject* > ( &rPara ), uno::UNO_QUERY );
        mrImpl.FireEvent(AccessibleEventId::ACCESSIBLE_CHILD_EVENT, uno::Any(), uno::makeAny( xChild ) );
    }

private:
    SvxAccessibleTextHelper_Impl&   mrImpl;
};

void SvxAccessibleTextHelper_Impl::ShutdownEditSource() throw (uno::RuntimeException)
{
    // This should only be called with solar mutex locked, i.e. from the main office thread

    // invalidate children
    maParaManager.SetEditSource( NULL );

    // loosing all children
    maParaManager.ForEach( SvxAccessibleTextHelper_SendAccessibleChildEvent( *this ) );
    maParaManager.SetNum(0);

    // quit listen on stale edit source
    if( maEditSource.IsValid() )
        EndListening( maEditSource.GetBroadcaster() );

    maEditSource.SetEditSource( ::std::auto_ptr< SvxEditSource >(NULL) );
}

void SvxAccessibleTextHelper_Impl::SetEditSource( ::std::auto_ptr< SvxEditSource > pEditSource ) throw (uno::RuntimeException)
{
    // This should only be called with solar mutex locked, i.e. from the main office thread

    // shutdown old edit source
    ShutdownEditSource();

    // set new edit source
    maEditSource.SetEditSource( pEditSource );

    // init child vector to the current child count
    if( maEditSource.IsValid() )
    {
        maParaManager.SetNum( GetTextForwarder().GetParagraphCount() );

        // listen on new edit source
        StartListening( maEditSource.GetBroadcaster() );

        UpdateVisibleChildren();
    }
}

void SvxAccessibleTextHelper_Impl::SetOffset( const Point& rPoint )
{
    maOffset = rPoint;
    maParaManager.SetEEOffset( rPoint );

    // in all cases, check visibility afterwards.
    UpdateVisibleChildren();
}

void SvxAccessibleTextHelper_Impl::UpdateVisibleChildren()
{
    try
    {
        SvxTextForwarder& rCacheTF = GetTextForwarder();
        SvxViewForwarder& rCacheVF = GetViewForwarder();

        Rectangle aViewArea = rCacheVF.GetVisArea();

        if( IsActive() )
        {
            // maybe the edit view scrolls, adapt aViewArea
            Rectangle aEditViewArea = GetEditViewForwarder().GetVisArea();
            aViewArea += aEditViewArea.TopLeft();

            // now determine intersection
            aViewArea.Intersection( aEditViewArea );
        }

        Rectangle aTmpBB, aParaBB;
        sal_Bool bFirstChild = sal_True;
        sal_Int32 nCurrPara;
        sal_Int32 nParas=rCacheTF.GetParagraphCount();

        mnFirstVisibleChild = -1;
        mnLastVisibleChild = -2;

        for( nCurrPara=0; nCurrPara<nParas; ++nCurrPara )
        {
            DBG_ASSERT(nCurrPara >= 0 && nCurrPara <= USHRT_MAX,
                       "SvxAccessibleTextHelper_Impl::UpdateVisibleChildren: index value overflow");

            aTmpBB = rCacheTF.GetParaBounds( static_cast< USHORT >( nCurrPara ) );

            // convert to screen coordinates
            aParaBB = accessibility::AccessibleEditableTextPara::LogicToPixel( aTmpBB, rCacheTF.GetMapMode(), rCacheVF );

            if( aParaBB.IsOver( aViewArea ) )
            {
                // at least partially visible
                if( bFirstChild )
                {
                    bFirstChild = sal_False;
                    mnFirstVisibleChild = nCurrPara;
                }

                mnLastVisibleChild = nCurrPara;

                GotPropertyEvent( uno::makeAny( getAccessibleChild(nCurrPara) ), AccessibleEventId::ACCESSIBLE_CHILD_EVENT );
            }
            else
            {
                // not or no longer visible
                if( maParaManager.IsReferencable( nCurrPara ) )
                {
                    LostPropertyEvent( uno::makeAny( getAccessibleChild(nCurrPara) ), AccessibleEventId::ACCESSIBLE_CHILD_EVENT );

                    // clear reference
                    maParaManager.Release( nCurrPara );
                }
            }
        }
    }
    catch( const uno::RuntimeException& )
    {
        DBG_ERROR("SvxAccessibleTextHelper_Impl::UpdateVisibleChildren error while determining visible children");

        // something failed - currently no children
        mnFirstVisibleChild = -1;
        mnLastVisibleChild = -2;

        maParaManager.ForEach( SvxAccessibleTextHelper_SendAccessibleChildEvent( *this ) );
        maParaManager.SetNum(0);
    }
}

// functor for checking changes in paragraph bounding boxes
class SvxAccessibleTextHelper_UpdateChildBounds : public ::std::unary_function< const accessibility::AccessibleParaManager::WeakChild&,
                                                  accessibility::AccessibleParaManager::WeakChild >
{
public:
    SvxAccessibleTextHelper_UpdateChildBounds( SvxAccessibleTextHelper_Impl& rImpl ) : mrImpl(rImpl) {}
    accessibility::AccessibleParaManager::WeakChild operator()( const accessibility::AccessibleParaManager::WeakChild& rChild )
    {
        // retrieve hard reference from weak one
        accessibility::AccessibleParaManager::WeakPara::HardRefType aHardRef( rChild.first.get() );

        if( aHardRef.is() )
        {
            awt::Rectangle          aNewRect = aHardRef->getBounds();
            const awt::Rectangle&   aOldRect = rChild.second;

            if( aNewRect.X != aOldRect.X ||
                aNewRect.Y != aOldRect.Y ||
                aNewRect.Width != aOldRect.Width ||
                aNewRect.Height != aOldRect.Height )
            {
                // visible data changed
                aHardRef->FireEvent( AccessibleEventId::ACCESSIBLE_VISIBLE_DATA_EVENT );

                // update bounds
                return accessibility::AccessibleParaManager::WeakChild( rChild.first, aNewRect );
            }
        }

        // identity transform
        return rChild;
    }

private:
    SvxAccessibleTextHelper_Impl&   mrImpl;
};

void SvxAccessibleTextHelper_Impl::UpdateVisibleData()
{
    // send CHILD_EVENT to affected children
    ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator begin = maParaManager.begin();
    ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator end = begin;

    ::std::advance< ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator, sal_Int32 >( begin, mnFirstVisibleChild );
    ::std::advance< ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator, sal_Int32 >( end, mnLastVisibleChild );

    ::std::for_each( begin, end, SvxAccessibleTextHelper_UpdateChildBounds( *this ) );
}

#ifdef DBG_UTIL
void SvxAccessibleTextHelper_Impl::CheckInvariants() const
{
    ::vos::OGuard aGuard( Application::GetSolarMutex() );

    if( !mxFrontEnd.is() )
        DBG_ERROR( "SvxAccessibleTextHelper: no frontend" );

    if( mnFirstVisibleChild >= 0 &&
        mnFirstVisibleChild > mnLastVisibleChild )
    {
        DBG_ERROR( "SvxAccessibleTextHelper: range invalid" );
    }
}
#endif

void SvxAccessibleTextHelper_Impl::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
{
    const SfxSimpleHint* pSimpleHint = PTR_CAST( SfxSimpleHint, &rHint );
    const TextHint* pTextHint = PTR_CAST( TextHint, &rHint );
    const SvxViewHint* pViewHint = PTR_CAST( SvxViewHint, &rHint );
    const SvxEditSourceHint* pEditSourceHint = PTR_CAST( SvxEditSourceHint, &rHint );

    try
    {
        // precondition: solar mutex locked
        if( pEditSourceHint )
        {
            if( pEditSourceHint->GetValue() < GetTextForwarder().GetParagraphCount() )
            {
                switch( pEditSourceHint->GetId() )
                {
                    case EDITSOURCE_HINT_PARASMOVED:
                    {
                        DBG_ASSERT( pEditSourceHint->GetStartValue() < GetTextForwarder().GetParagraphCount() &&
                                    pEditSourceHint->GetEndValue() < GetTextForwarder().GetParagraphCount(),
                                    "SvxAccessibleTextHelper_Impl::NotifyHdl: Invalid notification");

                        const sal_Int32 nParas = GetTextForwarder().GetParagraphCount();
                        sal_Int32 nFirst, nMiddle, nLast;

                        /* rotate paragraphs
                         * =================
                         *
                         * Three cases:
                         *
                         * 1.
                         *   ... nParagraph ... nParam1 ... nParam2 ...
                         *       |______________[xxxxxxxxxxx]
                         *              becomes
                         *       [xxxxxxxxxxx]|______________
                         *
                         * tail is 0
                         *
                         * 2.
                         *   ... nParam1 ... nParagraph ... nParam2 ...
                         *       [xxxxxxxxxxx|xxxxxxxxxxxxxx]____________
                         *              becomes
                         *       ____________[xxxxxxxxxxx|xxxxxxxxxxxxxx]
                         *
                         * tail is nParagraph - nParam1
                         *
                         * 3.
                         *   ... nParam1 ... nParam2 ... nParagraph ...
                         *       [xxxxxxxxxxx]___________|____________
                         *              becomes
                         *       ___________|____________[xxxxxxxxxxx]
                         *
                         * tail is nParam2 - nParam1
                         */

                        // sort nParagraph, nParam1 and nParam2 in ascending order, calc range
                        if( pEditSourceHint->GetValue() < pEditSourceHint->GetStartValue() )
                        {
                            nFirst = pEditSourceHint->GetValue();
                            nMiddle = pEditSourceHint->GetStartValue();
                            nLast = pEditSourceHint->GetEndValue();
                        }
                        else if( pEditSourceHint->GetValue() < pEditSourceHint->GetEndValue() )
                        {
                            nFirst = pEditSourceHint->GetStartValue();
                            nMiddle = pEditSourceHint->GetValue();
                            nLast = pEditSourceHint->GetEndValue() + nMiddle - nFirst;
                        }
                        else
                        {
                            nFirst = pEditSourceHint->GetStartValue();
                            nMiddle = pEditSourceHint->GetEndValue();
                            nLast = pEditSourceHint->GetValue() + nMiddle - nFirst;
                        }

                        if( nFirst < nParas && nMiddle < nParas && nLast < nParas )
                        {
                            // since we have no "paragraph index
                            // changed" event on UAA, remove
                            // [first,last] and insert again later (in
                            // UpdateVisibleChildren)

                            // maParaManager.Rotate( nFirst, nMiddle, nLast );

                            maParaManager.Release(nFirst, nLast);

                            // send CHILD_EVENT to affected children
                            ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator begin = maParaManager.begin();
                            ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator end = begin;

                            ::std::advance< ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator, sal_Int32 >( begin, nFirst );
                            ::std::advance< ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator, sal_Int32 >( end, nLast );

                            ::std::for_each( begin, end,
                                             ::accessibility::AccessibleParaManager::WeakChildAdapter< SvxAccessibleTextHelper_SendAccessibleChildEvent >
                                             (SvxAccessibleTextHelper_SendAccessibleChildEvent( *this )) );
                        }
#ifdef DBG_UTIL
                        else
                        {
                            DBG_ERROR("SvxAccessibleTextHelper_Impl::NotifyHdl: Invalid move ranges");
                        }
#endif
                        break;
                    }

                    case EDITSOURCE_HINT_SELECTIONCHANGED:
                        // notify listeners
                        ESelection aSelection;
                        try
                        {
                            if( GetEditViewForwarder().GetSelection( aSelection ) )
                                UpdateSelection( aSelection );
                            else
                                UpdateSelection( ESelection() );
                        }
                        // maybe we're not in edit mode (this is not an error)
                        catch( const uno::RuntimeException& ) {}
                        break;
                }

                // in all cases, check visibility afterwards.
                UpdateVisibleChildren();
            }
#ifdef DBG_UTIL
            else
            {
                DBG_ERROR("SvxAccessibleTextHelper_Impl::NotifyHdl: Invalid notification");
            }
#endif
        }
        else if( pTextHint )
        {
            if( pTextHint->GetValue() < GetTextForwarder().GetParagraphCount() )
            {
                sal_Bool bUpdateVisibleData = sal_False;

                switch( pTextHint->GetId() )
                {
                    case TEXT_HINT_MODIFIED:
                        // notify listeners
                        maParaManager.FireEvent( pTextHint->GetValue(), AccessibleEventId::ACCESSIBLE_TEXT_EVENT );
                        break;

                    case TEXT_HINT_PARAINSERTED:
                    {
                        // resize child vector to the current child count
                        const sal_Int32 nParas = GetTextForwarder().GetParagraphCount();

                        maParaManager.SetNum( nParas );

                        // since we have no "paragraph index
                        // changed" event on UAA, remove
                        // [first,last] and insert again later (in
                        // UpdateVisibleChildren)

                        // move successors of inserted paragraph one position further
                        //maParaManager.MoveRightFrom( pTextHint->GetValue() );

                        // release everything from the insertion position until the end
                        maParaManager.Release(pTextHint->GetValue(), nParas);

                        // send CHILD_EVENT to affected children
                        ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator begin = maParaManager.begin();
                        ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator end = begin;

                        ::std::advance< ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator, sal_Int32 >( begin, pTextHint->GetValue() );
                        ::std::advance< ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator, sal_Int32 >( end, nParas );

                        ::std::for_each( begin, end,
                                         ::accessibility::AccessibleParaManager::WeakChildAdapter< SvxAccessibleTextHelper_SendAccessibleChildEvent >
                                         (SvxAccessibleTextHelper_SendAccessibleChildEvent( *this )) );
                        break;
                    }

                    case TEXT_HINT_PARAREMOVED:
                    {
                        const sal_Int32 nParas = GetTextForwarder().GetParagraphCount();

                        // since we have no "paragraph index
                        // changed" event on UAA, remove
                        // [first,last] and insert again later (in
                        // UpdateVisibleChildren)

                        // move successors of removed paragraph one position closer
                        // maParaManager.MoveLeftFrom( pTextHint->GetValue() );

                        // release everything from the remove position until the end
                        maParaManager.Release(pTextHint->GetValue(), nParas);

                        // send CHILD_EVENT to affected children
                        ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator begin = maParaManager.begin();
                        ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator end = begin;

                        ::std::advance< ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator, sal_Int32 >( begin, pTextHint->GetValue() );
                        ::std::advance< ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator, sal_Int32 >( end, nParas );

                        ::std::for_each( begin, end,
                                         ::accessibility::AccessibleParaManager::WeakChildAdapter< SvxAccessibleTextHelper_SendAccessibleChildEvent >
                                         (SvxAccessibleTextHelper_SendAccessibleChildEvent( *this )) );

                        // resize child vector to the current child count
                        maParaManager.SetNum( nParas );
                        break;
                    }

                    case TEXT_HINT_TEXTHEIGHTCHANGED:
                        bUpdateVisibleData = sal_True;
                        break;

                    case TEXT_HINT_VIEWSCROLLED:
                        bUpdateVisibleData = sal_True;
                        break;
                }

                // in all cases, check visibility afterwards.
                UpdateVisibleChildren();

                if( bUpdateVisibleData )
                    UpdateVisibleData();
            }
#ifdef DBG_UTIL
            else
            {
                DBG_ERROR("SvxAccessibleTextHelper_Impl::NotifyHdl: Invalid notification");

            }
#endif
        }
        else if( pViewHint )
        {
            switch( pViewHint->GetId() )
            {
                case SVX_HINT_VIEWCHANGED:
                    // just check visibility
                    break;
            }

            // in all cases, check visibility afterwards.
            UpdateVisibleChildren();
        }
        // it's VITAL to keep the SfxSimpleHint last! It's the base of some classes above!
        else if( pSimpleHint )
        {
            switch( pSimpleHint->GetId() )
            {
                case SFX_HINT_DYING:
                    // edit source is dying under us, become defunc then
                    try
                    {
                        // make edit source inaccessible
                        // Note: cannot destroy it here, since we're called from there!
                        ShutdownEditSource();
                    }
                    catch( const uno::RuntimeException& ) {}

                    break;
            }
        }
    }
    catch( const uno::RuntimeException& )
    {
#ifdef DBG_UTIL
        DBG_ERROR("SvxAccessibleTextHelper_Impl::Notify: Unhandled exception.");
#endif
    }
}

void SvxAccessibleTextHelper_Impl::FireEvent( const sal_Int16 nEventId, const uno::Any& rNewValue, const uno::Any& rOldValue ) const
{
// -- object locked --
    ::osl::ClearableMutexGuard aGuard( maMutex );

    AccessibleEventObject aEvent(mxFrontEnd, nEventId, rNewValue, rOldValue);

    ::cppu::OInterfaceIteratorHelper aIter( const_cast< SvxAccessibleTextHelper_Impl* >(this)->maStateListeners );

    // no locking necessary, OInterfaceIteratorHelper copies listeners if someone removes/adds in between
    // Further locking, actually, might lead to deadlocks, since we're calling out of this object
    aGuard.clear();
// -- until here --

    while( aIter.hasMoreElements() )
    {
        uno::Reference < XAccessibleEventListener > xListener( aIter.next(), uno::UNO_QUERY );

        if( xListener.is() )
        {
            try
            {
                xListener->notifyEvent( aEvent );
            }
            catch( const uno::RuntimeException& )
            {
#ifdef DBG_UTIL
                DBG_ERROR("SvxAccessibleTextHelper_Impl::StateChangeEvent: Caught runtime exception from listener (bridge/listener dead?).");
#endif
            }
        }
    }
}

// XAccessibleContext
sal_Int32 SAL_CALL SvxAccessibleTextHelper_Impl::getAccessibleChildCount() throw (uno::RuntimeException)
{
    ::vos::OGuard aGuard( Application::GetSolarMutex() );

    return mnLastVisibleChild - mnFirstVisibleChild + 1;
}

uno::Reference< XAccessible > SAL_CALL SvxAccessibleTextHelper_Impl::getAccessibleChild( sal_Int32 i ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
{
    ::vos::OGuard aGuard( Application::GetSolarMutex() );

    if( 0 > i || i > getAccessibleChildCount() ||
        GetTextForwarder().GetParagraphCount() <= i )
    {
        throw lang::IndexOutOfBoundsException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Invalid child index")), mxFrontEnd);
    }

    return maParaManager.GetChild( i, mxFrontEnd, GetEditSource(), mnFirstVisibleChild + i ).first;
}

void SAL_CALL SvxAccessibleTextHelper_Impl::addEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) throw (uno::RuntimeException)
{
    maStateListeners.addInterface( xListener );
}

void SAL_CALL SvxAccessibleTextHelper_Impl::removeEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) throw (uno::RuntimeException)
{
    maStateListeners.removeInterface( xListener );
}

uno::Reference< XAccessible > SAL_CALL SvxAccessibleTextHelper_Impl::getAccessibleAt( const awt::Point& _aPoint ) throw (uno::RuntimeException)
{
    // make given position relative
    if( !mxFrontEnd.is() )
        throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SvxAccessibleTextHelper_Impl::getAccessibleAt: frontend invalid")), mxFrontEnd );

    uno::Reference< XAccessibleContext > xFrontEndContext = mxFrontEnd->getAccessibleContext();

    if( !xFrontEndContext.is() )
        throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SvxAccessibleTextHelper_Impl::getAccessibleAt: frontend invalid")), mxFrontEnd );

    uno::Reference< XAccessibleComponent > xFrontEndComponent( xFrontEndContext, uno::UNO_QUERY );

    if( !xFrontEndComponent.is() )
        throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SvxAccessibleTextHelper_Impl::getAccessibleAt: frontend is no XAccessibleComponent")),
                                    mxFrontEnd );

    Point aPoint( _aPoint.X, _aPoint.Y );
    awt::Point aRefPoint = xFrontEndComponent->getLocationOnScreen();
    aPoint -= Point( aRefPoint.X, aRefPoint.Y );

    // respect EditEngine offset to surrounding shape/cell
    aPoint -= GetOffset();

    // convert to EditEngine coordinate system
    SvxTextForwarder& rCacheTF = GetTextForwarder();
    Point aLogPoint( GetViewForwarder().PixelToLogic( aPoint, rCacheTF.GetMapMode() ) );

    // iterate over all visible children (including those not yet created)
    sal_Int32 nChild;
    for( nChild=mnFirstVisibleChild; nChild <= mnLastVisibleChild; ++nChild )
    {
        DBG_ASSERT(nChild >= 0 && nChild <= USHRT_MAX,
                   "SvxAccessibleTextHelper_Impl::getAccessibleAt: index value overflow");

        Rectangle aParaBounds( rCacheTF.GetParaBounds( static_cast< USHORT > (nChild) ) );

        if( aParaBounds.IsInside( aLogPoint ) )
        {
            DBG_ASSERT(nChild - mnFirstVisibleChild >= 0 && nChild - mnFirstVisibleChild <= USHRT_MAX,
                       "SvxAccessibleTextHelper_Impl::getAccessibleAt: index value overflow");

            return getAccessibleChild( static_cast< USHORT > (nChild - mnFirstVisibleChild) );
        }
    }

    // found none
    return uno::Reference< XAccessible >();
}

//------------------------------------------------------------------------
//
// SvxAccessibleTextHelper implementation (simply forwards to impl)
//
//------------------------------------------------------------------------

SvxAccessibleTextHelper::SvxAccessibleTextHelper( const uno::Reference< XAccessible >&  rInterface,
                                                  ::std::auto_ptr< SvxEditSource >      pEditSource ) :
    mpImpl( new SvxAccessibleTextHelper_Impl( rInterface ) )
{
    ::vos::OGuard aGuard( Application::GetSolarMutex() );

    SetEditSource( pEditSource );
}

SvxAccessibleTextHelper::~SvxAccessibleTextHelper()
{
}

SvxEditSource& SvxAccessibleTextHelper::GetEditSource() const throw (uno::RuntimeException)
{
#ifdef DBG_UTIL
    mpImpl->CheckInvariants();

    SvxEditSource& aEditSource = mpImpl->GetEditSource();

    mpImpl->CheckInvariants();

    return aEditSource;
#else
    return mpImpl->GetEditSource();
#endif
}

void SvxAccessibleTextHelper::SetEditSource( ::std::auto_ptr< SvxEditSource > pEditSource ) throw (uno::RuntimeException)
{
#ifdef DBG_UTIL
    mpImpl->CheckInvariants();

    mpImpl->SetEditSource( pEditSource );

    mpImpl->CheckInvariants();
#else
    mpImpl->SetEditSource( pEditSource );
#endif
}

void SvxAccessibleTextHelper::StateChangeEvent( const sal_Int16 nEventId, const uno::Any& rNewValue, const uno::Any& rOldValue ) const
{
#ifdef DBG_UTIL
    mpImpl->CheckInvariants();

    mpImpl->FireEvent( nEventId, rNewValue, rOldValue );

    mpImpl->CheckInvariants();
#else
    mpImpl->StateChangeEvent( nEventId, rNewValue, rOldValue );
#endif
}

void SvxAccessibleTextHelper::SetOffset( const Point& rPoint )
{
#ifdef DBG_UTIL
    mpImpl->CheckInvariants();

    mpImpl->SetOffset( rPoint );

    mpImpl->CheckInvariants();
#else
    mpImpl->SetOffset( rPoint );
#endif
}

const Point& SvxAccessibleTextHelper::GetOffset() const
{
#ifdef DBG_UTIL
    mpImpl->CheckInvariants();

    const Point& rRef = mpImpl->GetOffset();

    mpImpl->CheckInvariants();

    return rRef;
#else
    return mpImpl->GetOffset();
#endif
}

void SvxAccessibleTextHelper::UpdateChildren() throw (::com::sun::star::uno::RuntimeException)
{
#ifdef DBG_UTIL
    mpImpl->CheckInvariants();

    mpImpl->UpdateVisibleChildren();

    mpImpl->CheckInvariants();
#else
    mpImpl->UpdateVisibleChildren();
#endif
}

sal_Bool SvxAccessibleTextHelper::IsSelected() const
{
#ifdef DBG_UTIL
    mpImpl->CheckInvariants();

    sal_Bool aRet = mpImpl->IsSelected();

    mpImpl->CheckInvariants();

    return aRet;
#else
    return mpImpl->IsSelected();
#endif
}

// XAccessibleContext
sal_Int32 SvxAccessibleTextHelper::GetChildCount() throw (uno::RuntimeException)
{
#ifdef DBG_UTIL
    mpImpl->CheckInvariants();

    sal_Int32 nRet = mpImpl->getAccessibleChildCount();

    mpImpl->CheckInvariants();

    return nRet;
#else
    return mpImpl->getAccessibleChildCount();
#endif
}

uno::Reference< XAccessible > SvxAccessibleTextHelper::GetChild( sal_Int32 i ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
{
#ifdef DBG_UTIL
    mpImpl->CheckInvariants();

    uno::Reference< XAccessible > xRet = mpImpl->getAccessibleChild( i );

    mpImpl->CheckInvariants();

    return xRet;
#else
    return mpImpl->getAccessibleChild( i );
#endif
}

void SvxAccessibleTextHelper::AddEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) throw (uno::RuntimeException)
{
#ifdef DBG_UTIL
    mpImpl->CheckInvariants();

    mpImpl->addEventListener( xListener );

    mpImpl->CheckInvariants();
#else
    mpImpl->addEventListener( xListener );
#endif
}

void SvxAccessibleTextHelper::RemoveEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) throw (uno::RuntimeException)
{
#ifdef DBG_UTIL
    mpImpl->CheckInvariants();

    mpImpl->removeEventListener( xListener );

    mpImpl->CheckInvariants();
#else
    mpImpl->removeEventListener( xListener );
#endif
}

// XAccessibleComponent
uno::Reference< XAccessible > SvxAccessibleTextHelper::GetAt( const awt::Point& aPoint ) throw (uno::RuntimeException)
{
#ifdef DBG_UTIL
    mpImpl->CheckInvariants();

    uno::Reference< XAccessible > xChild = mpImpl->getAccessibleAt( aPoint );

    mpImpl->CheckInvariants();

    return xChild;
#else
    return mpImpl->getAccessibleAt( aPoint );
#endif
}

//------------------------------------------------------------------------