AOO410/main/sw/source/core/access/acccontext.cxx

/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/

 

// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sw.hxx"
#if (OSL_DEBUG_LEVEL > 1) && defined TEST_MIB
	#ifndef _STRING_HXX
	#include <tools/string.hxx>
	#endif

	#ifndef _STREAM_HXX
	#include <tools/stream.hxx>
	#endif
#endif // #if (OSL_DEBUG_LEVEL > 1) && defined TEST_MIB
#include <tools/debug.hxx>
#include <vcl/window.hxx>
#include <errhdl.hxx>
#include <swtypes.hxx>

#include <com/sun/star/accessibility/XAccessible.hpp>
#include <com/sun/star/accessibility/XAccessibleStateSet.hpp>
#include <com/sun/star/accessibility/AccessibleStateType.hpp>
#include <com/sun/star/accessibility/AccessibleEventId.hpp>
#include <vos/mutex.hxx>
#include <vcl/svapp.hxx>
#include <unotools/accessiblestatesethelper.hxx>
#include <unotools/accessiblerelationsethelper.hxx>
#include <viewsh.hxx>
#include <crsrsh.hxx>
#include <fesh.hxx>
#include <txtfrm.hxx>
#include <ndtxt.hxx>
#include <pagefrm.hxx>
#include <flyfrm.hxx>
#include <dflyobj.hxx>
#include <pam.hxx>
#include <viewimp.hxx>
#include <accmap.hxx>
#include <accfrmobjslist.hxx>
#include <acccontext.hxx>
#include <svx/AccessibleShape.hxx>
#include <comphelper/accessibleeventnotifier.hxx>
#ifndef _ACCPARA_HXX
#include "accpara.hxx"
#endif
#include <PostItMgr.hxx>

using namespace sw::access;

#if (OSL_DEBUG_LEVEL > 1) && defined TEST_MIB
#define DBG_MSG( _msg ) \
	lcl_SwAccessibleContext_DbgMsg( this, _msg, 0, sal_False );
#define DBG_MSG_CD( _msg ) \
	lcl_SwAccessibleContext_DbgMsg( this, _msg, 0, sal_True );
#define DBG_MSG_PARAM( _msg, _param ) \
	lcl_SwAccessibleContext_DbgMsg( this, _msg, _param, sal_False );
#define DBG_MSG_THIS_PARAM( _msg, _this, _param ) \
	lcl_SwAccessibleContext_DbgMsg( _this, _msg, _param, sal_False );

void lcl_SwAccessibleContext_DbgMsg( SwAccessibleContext *pThisAcc,
									 const char *pMsg,
								     SwAccessibleContext *pChildAcc,
								  	 sal_Bool bConstrDestr );
#else
#define DBG_MSG( _msg )
#define DBG_MSG_PARAM( _msg, _param )
#define DBG_MSG_THIS_PARAM( _msg, _this, _param )
#define DBG_MSG_CD( _msg )
#endif

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

void SwAccessibleContext::InitStates()
{
    bIsShowingState = GetMap() ? IsShowing( *(GetMap()) ) : sal_False;

	ViewShell *pVSh = GetMap()->GetShell();
    bIsEditableState = pVSh && IsEditable( pVSh );
	bIsOpaqueState = pVSh && IsOpaque( pVSh );
	bIsDefuncState = sal_False;
}

void SwAccessibleContext::SetParent( SwAccessibleContext *pParent )
{
	vos::OGuard aGuard( aMutex );

	uno::Reference < XAccessible > xParent( pParent );
	xWeakParent = xParent;
}

uno::Reference< XAccessible > SwAccessibleContext::GetWeakParent() const
{
	vos::OGuard aGuard( aMutex );

	uno::Reference< XAccessible > xParent( xWeakParent );
	return xParent;
}

Window *SwAccessibleContext::GetWindow()
{
	Window *pWin = 0;

	if( GetMap() )
	{
		const ViewShell *pVSh = GetMap()->GetShell();
		ASSERT( pVSh, "no view shell" );
		if( pVSh )
			pWin = pVSh->GetWin();

		ASSERT( pWin, "no window" );
	}

	return pWin;
}

// get ViewShell from accessibility map, and cast to cursor shell
SwCrsrShell* SwAccessibleContext::GetCrsrShell()
{
    SwCrsrShell* pCrsrShell;
    ViewShell* pViewShell = GetMap() ? GetMap()->GetShell() : 0;
	ASSERT( pViewShell, "no view shell" );
    if( pViewShell && pViewShell->ISA( SwCrsrShell ) )
        pCrsrShell = static_cast<SwCrsrShell*>( pViewShell );
    else
        pCrsrShell = NULL;

    return pCrsrShell;
}

const SwCrsrShell* SwAccessibleContext::GetCrsrShell() const
{
    // just like non-const GetCrsrShell
    const SwCrsrShell* pCrsrShell;
    const ViewShell* pViewShell = GetMap() ? GetMap()->GetShell() : 0;
	ASSERT( pViewShell, "no view shell" );
    if( pViewShell && pViewShell->ISA( SwCrsrShell ) )
        pCrsrShell = static_cast<const SwCrsrShell*>( pViewShell );
    else
        pCrsrShell = NULL;

    return pCrsrShell;
}


enum Action { NONE, SCROLLED, SCROLLED_WITHIN,
						  SCROLLED_IN, SCROLLED_OUT };

void SwAccessibleContext::ChildrenScrolled( const SwFrm *pFrm,
                                            const SwRect& rOldVisArea )
{
	const SwRect& rNewVisArea = GetVisArea();
    const bool bVisibleChildrenOnly = SwAccessibleChild( pFrm ).IsVisibleChildrenOnly();

    const SwAccessibleChildSList aList( *pFrm, *(GetMap()) );
    SwAccessibleChildSList::const_iterator aIter( aList.begin() );
	while( aIter != aList.end() )
	{
        const SwAccessibleChild& rLower = *aIter;
        const SwRect aBox( rLower.GetBox( *(GetMap()) ) );
		if( rLower.IsAccessible( GetShell()->IsPreView() ) )
		{
			Action eAction = NONE;
			if( aBox.IsOver( rNewVisArea ) )
			{
				if( aBox.IsOver( rOldVisArea ) )
				{
					eAction = SCROLLED_WITHIN;
				}
				else
				{
                    if ( bVisibleChildrenOnly &&
                         !rLower.AlwaysIncludeAsChild() )
                    {
						eAction = SCROLLED_IN;
                    }
					else
                    {
						eAction = SCROLLED;
                    }
				}
			}
			else if( aBox.IsOver( rOldVisArea ) )
			{
                if ( bVisibleChildrenOnly &&
                     !rLower.AlwaysIncludeAsChild() )
                {
					eAction = SCROLLED_OUT;
                }
				else
                {
					eAction = SCROLLED;
                }
			}
            else if( !bVisibleChildrenOnly ||
                     rLower.AlwaysIncludeAsChild() )
			{
				// This wouldn't be required if the SwAccessibleFrame,
				// wouldn't know about the vis area.
				eAction = SCROLLED;
			}
			if( NONE != eAction )
			{
                if ( rLower.GetSwFrm() )
				{
                    ASSERT( !rLower.AlwaysIncludeAsChild(),
                            "<SwAccessibleContext::ChildrenScrolled(..)> - always included child not considered!" );
                    const SwFrm* pLower( rLower.GetSwFrm() );
					::vos::ORef< SwAccessibleContext > xAccImpl =
						//O is: GetMap()->GetContextImpl( pLower, SCROLLED_OUT == eAction ||
						//						SCROLLED_IN == eAction );
						GetMap()->GetContextImpl( pLower, sal_True );
					if( xAccImpl.isValid() )
					{
						switch( eAction )
						{
						case SCROLLED:
							xAccImpl->Scrolled( rOldVisArea );
							break;
						case SCROLLED_WITHIN:
							xAccImpl->ScrolledWithin( rOldVisArea );
							break;
						case SCROLLED_IN:
							xAccImpl->ScrolledIn();
							break;
						case SCROLLED_OUT:
							xAccImpl->ScrolledOut( rOldVisArea );
							break;
						case NONE:
							break;
						}
					}
					else
					{
						ChildrenScrolled( pLower, rOldVisArea );
					}
				}
                else if ( rLower.GetDrawObject() )
				{
                    ASSERT( !rLower.AlwaysIncludeAsChild(),
                            "<SwAccessibleContext::ChildrenScrolled(..)> - always included child not considered!" );
					::vos::ORef< ::accessibility::AccessibleShape > xAccImpl =
						//O is:	GetMap()->GetContextImpl( rLower.GetSdrObject(),
						//						  this,
						//						  SCROLLED_OUT == eAction ||
						//						  SCROLLED_IN == eAction ); 
                        GetMap()->GetContextImpl( rLower.GetDrawObject(),
												  this,
												  sal_True );
					if( xAccImpl.isValid() )
					{
						switch( eAction )
						{
						case SCROLLED:
						case SCROLLED_WITHIN:
							xAccImpl->ViewForwarderChanged(
								::accessibility::IAccessibleViewForwarderListener::VISIBLE_AREA,
								GetMap() );
							break;
						case SCROLLED_IN:
                            ScrolledInShape( rLower.GetDrawObject(),
											 xAccImpl.getBodyPtr() );
							break;
						case SCROLLED_OUT:
							{
								xAccImpl->ViewForwarderChanged(
									::accessibility::IAccessibleViewForwarderListener::VISIBLE_AREA,
									GetMap() );
								//Remove
								//DisposeShape( rLower.GetDrawObject(),
								//			  xAccImpl.getBodyPtr() );
							}
							break;
						case NONE:
							break;
						}
					}
				}
                else if ( rLower.GetWindow() )
                {
                    // nothing to do - as such children are always included as children.
                    ASSERT( rLower.AlwaysIncludeAsChild(),
                            "<SwAccessibleContext::ChildrenScrolled(..)> - not always included child not considered!" );
                }
			}
		}
        else if ( rLower.GetSwFrm() &&
                  ( !bVisibleChildrenOnly ||
                    aBox.IsOver( rOldVisArea ) ||
                    aBox.IsOver( rNewVisArea ) ) )
		{
			// There are no unaccessible SdrObjects that need to be notified
            ChildrenScrolled( rLower.GetSwFrm(), rOldVisArea );
		}
		++aIter;
	}
}

void SwAccessibleContext::Scrolled( const SwRect& rOldVisArea )
{
	SetVisArea( GetMap()->GetVisArea() );

	ChildrenScrolled( GetFrm(), rOldVisArea );

	sal_Bool bIsOldShowingState;
    sal_Bool bIsNewShowingState = IsShowing( *(GetMap()) );
	{
		vos::OGuard aGuard( aMutex );
		bIsOldShowingState = bIsShowingState;
		bIsShowingState = bIsNewShowingState;
	}

	if( bIsOldShowingState != bIsNewShowingState )
		FireStateChangedEvent( AccessibleStateType::SHOWING,
							   bIsNewShowingState  );
}

void SwAccessibleContext::ScrolledWithin( const SwRect& rOldVisArea )
{
	SetVisArea( GetMap()->GetVisArea() );

	ChildrenScrolled( GetFrm(), rOldVisArea );

	FireVisibleDataEvent();
}

void SwAccessibleContext::ScrolledIn()
{
	// This accessible should be freshly created, because it
	// was not visisble before. Therefor, its vis area must already
	// reflect the scrolling.
	ASSERT( GetVisArea() == GetMap()->GetVisArea(),
			"Vis area of child is wrong. Did it exist already?" );

	// Send child event at parent. That's all we have to do here.
    const SwFrm* pParent = GetParent();
	::vos::ORef< SwAccessibleContext > xParentImpl(
		 GetMap()->GetContextImpl( pParent, sal_False ) );
	uno::Reference < XAccessibleContext > xThis( this );
	if( xParentImpl.isValid() )
	{
		SetParent( xParentImpl.getBodyPtr() );

		AccessibleEventObject aEvent;
		aEvent.EventId = AccessibleEventId::CHILD;
		aEvent.NewValue <<= xThis;

		xParentImpl->FireAccessibleEvent( aEvent );
		DBG_MSG_PARAM( "AccessibleChild (added)", xChildImpl.getBodyPtr() );

		if( HasCursor() )
		{
			Window *pWin = GetWindow();
			if( pWin && pWin->HasFocus() )
			{
				FireStateChangedEvent( AccessibleStateType::FOCUSED, sal_True );
			}
		}

	}
}

void SwAccessibleContext::ScrolledOut( const SwRect& rOldVisArea )
{
	SetVisArea( GetMap()->GetVisArea() );

	// First of all, update the children. That's required to dispose
	// all children that are existing only if they are visible. They
	// are not disposed by the recusive Dispose call that follows later on,
	// because this call will only dispose children that are in the
	// new vis area. The children we want to dispode however are in the
	// old vis area all.
	ChildrenScrolled( GetFrm(), rOldVisArea );

	// Broadcast a state changed event for the showing state.
	// It might be that the child is freshly created just to send
	// the child event. In this case no listener will exist.
	FireStateChangedEvent( AccessibleStateType::SHOWING, sal_False );

	//Remove Dispose When scrolledout
	// We now dispose the frame
	//	Dispose( sal_True );
}

// --> OD 2005-12-12 #i27301# - use new type definition for <_nStates>
void SwAccessibleContext::InvalidateChildrenStates( const SwFrm* _pFrm,
                                                    tAccessibleStates _nStates )
{
    const SwAccessibleChildSList aVisList( GetVisArea(), *_pFrm, *(GetMap()) );

    SwAccessibleChildSList::const_iterator aIter( aVisList.begin() );
	while( aIter != aVisList.end() )
	{
        const SwAccessibleChild& rLower = *aIter;
        const SwFrm* pLower = rLower.GetSwFrm();
		if( pLower )
		{
			::vos::ORef< SwAccessibleContext > xAccImpl;
			if( rLower.IsAccessible( GetShell()->IsPreView() ) )
				xAccImpl = GetMap()->GetContextImpl( pLower, sal_False );
			if( xAccImpl.isValid() )
                xAccImpl->InvalidateStates( _nStates );
			else
                InvalidateChildrenStates( pLower, _nStates );
		}
        else if ( rLower.GetDrawObject() )
		{
			// TODO: SdrObjects
		}
        else if ( rLower.GetWindow() )
        {
            // nothing to do ?
        }

		++aIter;
	}
}
// <--

void SwAccessibleContext::DisposeChildren( const SwFrm *pFrm,
									   sal_Bool bRecursive )
{
    const SwAccessibleChildSList aVisList( GetVisArea(), *pFrm, *(GetMap()) );
    SwAccessibleChildSList::const_iterator aIter( aVisList.begin() );
	while( aIter != aVisList.end() )
	{
        const SwAccessibleChild& rLower = *aIter;
        const SwFrm* pLower = rLower.GetSwFrm();
		if( pLower )
		{
			::vos::ORef< SwAccessibleContext > xAccImpl;
			if( rLower.IsAccessible( GetShell()->IsPreView() ) )
				xAccImpl = GetMap()->GetContextImpl( pLower, sal_False );
			if( xAccImpl.isValid() )
				xAccImpl->Dispose( bRecursive );
			else if( bRecursive )
				DisposeChildren( pLower, bRecursive );
		}
        else if ( rLower.GetDrawObject() )
		{
			::vos::ORef< ::accessibility::AccessibleShape > xAccImpl(
                    GetMap()->GetContextImpl( rLower.GetDrawObject(),
										  this, sal_False )  );
			if( xAccImpl.isValid() )
                DisposeShape( rLower.GetDrawObject(), xAccImpl.getBodyPtr() );
		}
        else if ( rLower.GetWindow() )
        {
            DisposeChild( rLower, sal_False );
        }
		++aIter;
	}
}

void SwAccessibleContext::_InvalidateContent( sal_Bool )
{
}

void SwAccessibleContext::_InvalidateCursorPos()
{
}

void SwAccessibleContext::_InvalidateFocus()
{
}

void SwAccessibleContext::FireAccessibleEvent( AccessibleEventObject& rEvent )
{
	ASSERT( GetFrm(), "fire event for diposed frame?" );
	if( !GetFrm() )
		return;

	if( !rEvent.Source.is() )
	{
		uno::Reference < XAccessibleContext > xThis( this );
		rEvent.Source = xThis;
	}

	if (nClientId)
		comphelper::AccessibleEventNotifier::addEvent( nClientId, rEvent );
}

void SwAccessibleContext::FireVisibleDataEvent()
{
	AccessibleEventObject aEvent;
	aEvent.EventId = AccessibleEventId::VISIBLE_DATA_CHANGED;

	FireAccessibleEvent( aEvent );
	DBG_MSG( "AccessibleVisibleData" )
}

void SwAccessibleContext::FireStateChangedEvent( sal_Int16 nState,
												 sal_Bool bNewState )
{
	AccessibleEventObject aEvent;

	aEvent.EventId = AccessibleEventId::STATE_CHANGED;
	if( bNewState )
		aEvent.NewValue <<= nState;
	else
		aEvent.OldValue <<= nState;

	FireAccessibleEvent( aEvent );
	DBG_MSG( "StateChanged" )
}

void SwAccessibleContext::GetStates(
		::utl::AccessibleStateSetHelper& rStateSet )
{
	vos::OGuard aGuard(Application::GetSolarMutex());

	// SHOWING
	if( bIsShowingState )
		rStateSet.AddState( AccessibleStateType::SHOWING );

	// EDITABLE
	if( bIsEditableState )
	//Solution:Set editable state to graphic and other object when the document is editable
	{
		rStateSet.AddState( AccessibleStateType::EDITABLE );
		rStateSet.AddState( AccessibleStateType::RESIZABLE );
		rStateSet.AddState( AccessibleStateType::MOVEABLE );
	}
	// ENABLED
	rStateSet.AddState( AccessibleStateType::ENABLED );

	// OPAQUE
	if( bIsOpaqueState )
		rStateSet.AddState( AccessibleStateType::OPAQUE );

	// VISIBLE
	rStateSet.AddState( AccessibleStateType::VISIBLE );

	if( bIsDefuncState )
		rStateSet.AddState( AccessibleStateType::DEFUNC );
}

sal_Bool SwAccessibleContext::IsEditableState()
{
	sal_Bool bRet;
	{
		vos::OGuard aGuard( aMutex );
		bRet = bIsEditableState;
	}

	return bRet;
}

SwAccessibleContext::SwAccessibleContext( SwAccessibleMap *pM,
										  sal_Int16 nR,
                                          const SwFrm *pF )
    : SwAccessibleFrame( pM->GetVisArea().SVRect(), pF,
                         pM->GetShell()->IsPreView() )
    , pMap( pM )
    , nClientId(0)
    , nRole( nR )
    , bDisposing( sal_False )
    , bRegisteredAtAccessibleMap( true )
    //Solution:Initialize the begin document load and IfAsynLoad to true
    , bBeginDocumentLoad( sal_True )
	, isIfAsynLoad( sal_True )
	, bIsSeletedInDoc( sal_False)
{
	InitStates();
	DBG_MSG_CD( "constructed" )
}

SwAccessibleContext::~SwAccessibleContext()
{
	if(Application::GetUnoWrapper())
		vos::OGuard aGuard(Application::GetSolarMutex());

	DBG_MSG_CD( "destructed" )
    RemoveFrmFromAccessibleMap();
}

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

sal_Int32 SAL_CALL SwAccessibleContext::getAccessibleChildCount( void )
        throw (uno::RuntimeException)
{
	vos::OGuard aGuard(Application::GetSolarMutex());

	CHECK_FOR_DEFUNC( XAccessibleContext )
	//Solution:Notify the frame is a document
	if( nRole == AccessibleRole::DOCUMENT )		
		bIsAccDocUse = sal_True;

    return bDisposing ? 0 : GetChildCount( *(GetMap()) );
}

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

	CHECK_FOR_DEFUNC( XAccessibleContext )

	//Solution:Notify the frame is a document
	if( nRole == AccessibleRole::DOCUMENT )		
		bIsAccDocUse = sal_True;

    const SwAccessibleChild aChild( GetChild( *(GetMap()), nIndex ) );
	if( !aChild.IsValid() )
	{
		uno::Reference < XAccessibleContext > xThis( this );
		lang::IndexOutOfBoundsException aExcept(
				OUString( RTL_CONSTASCII_USTRINGPARAM("index out of bounds") ),
				xThis );
		throw aExcept;
	}

	uno::Reference< XAccessible > xChild;
	if( aChild.GetSwFrm() )
	{
		::vos::ORef < SwAccessibleContext > xChildImpl(
				GetMap()->GetContextImpl( aChild.GetSwFrm(), !bDisposing )  );
		//Solution:Send out accessible event when begin load.
		if( bBeginDocumentLoad && nRole == AccessibleRole::DOCUMENT )
		{
			
			FireStateChangedEvent( AccessibleStateType::FOCUSABLE,sal_True );
			FireStateChangedEvent( AccessibleStateType::BUSY,sal_True );
			if( !isIfAsynLoad )
			{
				FireStateChangedEvent( AccessibleStateType::FOCUSED,sal_True );
				// IA2 CWS. MT: OFFSCREEN == !SHOWING, should stay consistent
				// FireStateChangedEvent( AccessibleStateType::OFFSCREEN,sal_True );
				FireStateChangedEvent( AccessibleStateType::SHOWING,sal_True );
			    FireStateChangedEvent( AccessibleStateType::BUSY,sal_False );
				// MT: OFFSCREEN again?
			    // FireStateChangedEvent( AccessibleStateType::OFFSCREEN,sal_False );	
			}
			bBeginDocumentLoad = sal_False;
		}
		if( xChildImpl.isValid() )
		{
			xChildImpl->SetParent( this );
			xChild = xChildImpl.getBodyPtr();
		}
	}
    else if ( aChild.GetDrawObject() )
	{
		::vos::ORef < ::accessibility::AccessibleShape > xChildImpl(
                GetMap()->GetContextImpl( aChild.GetDrawObject(),
										  this, !bDisposing )  );
		if( xChildImpl.isValid() )
			xChild = xChildImpl.getBodyPtr();
	}
    else if ( aChild.GetWindow() )
    {
        xChild = aChild.GetWindow()->GetAccessible();
    }

	return xChild;
}

uno::Reference< XAccessible> SAL_CALL SwAccessibleContext::getAccessibleParent (void)
        throw (uno::RuntimeException)
{
	vos::OGuard aGuard(Application::GetSolarMutex());

	CHECK_FOR_DEFUNC( XAccessibleContext )

	const SwFrm *pUpper = GetParent();
	ASSERT( pUpper != 0 || bDisposing, "no upper found" );

	uno::Reference< XAccessible > xAcc;
	if( pUpper )
		xAcc = GetMap()->GetContext( pUpper, !bDisposing );

	ASSERT( xAcc.is() || bDisposing, "no parent found" );

	// Remember the parent as weak ref.
	{
        vos::OGuard aWeakParentGuard( aMutex );
		xWeakParent = xAcc;
	}

	return xAcc;
}

sal_Int32 SAL_CALL SwAccessibleContext::getAccessibleIndexInParent (void)
        throw (uno::RuntimeException)
{
	vos::OGuard aGuard(Application::GetSolarMutex());

	CHECK_FOR_DEFUNC( XAccessibleContext )

	const SwFrm *pUpper = GetParent();
	ASSERT( pUpper != 0 || bDisposing, "no upper found" );

	sal_Int32 nIndex = -1;
	if( pUpper )
	{
		::vos::ORef < SwAccessibleContext > xAccImpl(
			GetMap()->GetContextImpl( pUpper, !bDisposing )  );
		ASSERT( xAccImpl.isValid() || bDisposing, "no parent found" );
		if( xAccImpl.isValid() )
            nIndex = xAccImpl->GetChildIndex( *(GetMap()), SwAccessibleChild(GetFrm()) );
	}

	return nIndex;
}

sal_Int16 SAL_CALL SwAccessibleContext::getAccessibleRole (void)
        throw (uno::RuntimeException)
{
	return nRole;
}

OUString SAL_CALL SwAccessibleContext::getAccessibleDescription (void)
        throw (uno::RuntimeException)
{
	ASSERT( !this, "description needs to be overloaded" );
	THROW_RUNTIME_EXCEPTION( XAccessibleContext, "internal error (method must be overloaded)" );
}

OUString SAL_CALL SwAccessibleContext::getAccessibleName (void)
        throw (uno::RuntimeException)
{
	return sName;
}

uno::Reference< XAccessibleRelationSet> SAL_CALL
	SwAccessibleContext::getAccessibleRelationSet (void)
        throw (uno::RuntimeException)
{
	// by default there are no relations
	uno::Reference< XAccessibleRelationSet> xRet( new utl::AccessibleRelationSetHelper() );
	return xRet;
}

uno::Reference<XAccessibleStateSet> SAL_CALL
	SwAccessibleContext::getAccessibleStateSet (void)
        throw (uno::RuntimeException)
{
	vos::OGuard aGuard(Application::GetSolarMutex());

	CHECK_FOR_DEFUNC( XAccessibleContext )

	::utl::AccessibleStateSetHelper *pStateSet =
		new ::utl::AccessibleStateSetHelper;

	if( bIsSeletedInDoc )
		pStateSet->AddState( AccessibleStateType::SELECTED );

	uno::Reference<XAccessibleStateSet> xStateSet( pStateSet );
	GetStates( *pStateSet );

	return xStateSet;
}

lang::Locale SAL_CALL SwAccessibleContext::getLocale (void)
		throw (IllegalAccessibleComponentStateException, uno::RuntimeException)
{
	vos::OGuard aGuard(Application::GetSolarMutex());

	lang::Locale aLoc( Application::GetSettings().GetLocale() );
	return aLoc;
}

void SAL_CALL SwAccessibleContext::addEventListener(
			const uno::Reference< XAccessibleEventListener >& xListener )
		throw (uno::RuntimeException)
{
	DBG_MSG( "accessible event listener added" )

	if (xListener.is())
    {
    	vos::OGuard aGuard(Application::GetSolarMutex());
		if (!nClientId)
            nClientId = comphelper::AccessibleEventNotifier::registerClient( );
		comphelper::AccessibleEventNotifier::addEventListener( nClientId, xListener );
    }
}

void SAL_CALL SwAccessibleContext::removeEventListener(
			const uno::Reference< XAccessibleEventListener >& xListener )
		throw (uno::RuntimeException)
{
	DBG_MSG( "accessible event listener removed" )

	if (xListener.is())
	{
    	vos::OGuard aGuard(Application::GetSolarMutex());
		sal_Int32 nListenerCount = comphelper::AccessibleEventNotifier::removeEventListener( nClientId, xListener );
		if ( !nListenerCount )
		{
			// no listeners anymore
			// -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
			// and at least to us not firing any events anymore, in case somebody calls
			// NotifyAccessibleEvent, again
			comphelper::AccessibleEventNotifier::revokeClient( nClientId );
			nClientId = 0;
		}
	}
}

static sal_Bool lcl_PointInRectangle(const awt::Point & aPoint,
                                     const awt::Rectangle & aRect)
{
    long nDiffX = aPoint.X - aRect.X;
    long nDiffY = aPoint.Y - aRect.Y;

    return
        nDiffX >= 0 && nDiffX < aRect.Width && nDiffY >= 0 &&
        nDiffY < aRect.Height;

}

sal_Bool SAL_CALL SwAccessibleContext::containsPoint(
			const awt::Point& aPoint )
		throw (uno::RuntimeException)
{
    awt::Rectangle aPixBounds = getBoundsImpl(sal_True);
    aPixBounds.X = 0;
    aPixBounds.Y = 0;

    return lcl_PointInRectangle(aPoint, aPixBounds);
}

uno::Reference< XAccessible > SAL_CALL SwAccessibleContext::getAccessibleAtPoint(
				const awt::Point& aPoint )
		throw (uno::RuntimeException)
{
	vos::OGuard aGuard(Application::GetSolarMutex());

	CHECK_FOR_DEFUNC( XAccessibleComponent )

	uno::Reference< XAccessible > xAcc;

	Window *pWin = GetWindow();
	CHECK_FOR_WINDOW( XAccessibleComponent, pWin )

	Point aPixPoint( aPoint.X, aPoint.Y ); // px rel to parent
	if( !GetFrm()->IsRootFrm() )
	{
        SwRect aLogBounds( GetBounds( *(GetMap()), GetFrm() ) ); // twip rel to doc root
		Point aPixPos( GetMap()->CoreToPixel( aLogBounds.SVRect() ).TopLeft() );
		aPixPoint.X() += aPixPos.X();
		aPixPoint.Y() += aPixPos.Y();
	}

    const SwAccessibleChild aChild( GetChildAtPixel( aPixPoint, *(GetMap()) ) );
	if( aChild.GetSwFrm() )
	{
		xAcc = GetMap()->GetContext( aChild.GetSwFrm() );
	}
    else if( aChild.GetDrawObject() )
	{
        xAcc = GetMap()->GetContext( aChild.GetDrawObject(), this );
	}
    else if ( aChild.GetWindow() )
    {
        xAcc = aChild.GetWindow()->GetAccessible();
    }

	return xAcc;
}


/**
   Get bounding box.

   There are two modes.

   - realative

     Return bounding box relative to parent if parent is no root
     frame. Otherwise return the absolute bounding box.

   - absolute

     Return the absolute bounding box.

   @param bRelative
   true: Use relative mode.
   false: Use absolute mode.
*/
awt::Rectangle SAL_CALL SwAccessibleContext::getBoundsImpl(sal_Bool bRelative)
		throw (uno::RuntimeException)
{
	vos::OGuard aGuard(Application::GetSolarMutex());

	CHECK_FOR_DEFUNC( XAccessibleComponent )

	const SwFrm *pParent = GetParent();
	ASSERT( pParent, "no Parent found" );
	Window *pWin = GetWindow();

	CHECK_FOR_WINDOW( XAccessibleComponent, pWin && pParent )

    SwRect aLogBounds( GetBounds( *(GetMap()), GetFrm() ) ); // twip rel to doc root
	Rectangle aPixBounds( 0, 0, 0, 0 );
	if( GetFrm()->IsPageFrm() &&
		static_cast < const SwPageFrm * >( GetFrm() )->IsEmptyPage() )
	{
		ASSERT( GetShell()->IsPreView(), "empty page accessible?" );
		if( GetShell()->IsPreView() )
        {
            // OD 15.01.2003 #103492# - adjust method call <GetMap()->GetPreViewPageSize()>
            sal_uInt16 nPageNum =
                static_cast < const SwPageFrm * >( GetFrm() )->GetPhyPageNum();
            aLogBounds.SSize( GetMap()->GetPreViewPageSize( nPageNum ) );
        }
	}
	if( !aLogBounds.IsEmpty() )
	{
		aPixBounds = GetMap()->CoreToPixel( aLogBounds.SVRect() );
		if( !pParent->IsRootFrm() && bRelative)
		{
            SwRect aParentLogBounds( GetBounds( *(GetMap()), pParent ) ); // twip rel to doc root
			Point aParentPixPos( GetMap()->CoreToPixel( aParentLogBounds.SVRect() ).TopLeft() );
			aPixBounds.Move( -aParentPixPos.X(), -aParentPixPos.Y() );
		}
	}

	awt::Rectangle aBox( aPixBounds.Left(), aPixBounds.Top(),
						 aPixBounds.GetWidth(), aPixBounds.GetHeight() );

	return aBox;
}


awt::Rectangle SAL_CALL SwAccessibleContext::getBounds()
		throw (uno::RuntimeException)
{
    return getBoundsImpl(sal_True);
}

awt::Point SAL_CALL SwAccessibleContext::getLocation()
    throw (uno::RuntimeException)
{
    awt::Rectangle aRect = getBoundsImpl(sal_True);
    awt::Point aPoint(aRect.X, aRect.Y);

    return aPoint;
}



awt::Point SAL_CALL SwAccessibleContext::getLocationOnScreen()
		throw (uno::RuntimeException)
{
    awt::Rectangle aRect = getBoundsImpl(sal_False);

    Point aPixPos(aRect.X, aRect.Y);

    /* getBoundsImpl already checked that GetWindow returns valid pointer. */
    aPixPos = GetWindow()->OutputToAbsoluteScreenPixel(aPixPos);
    awt::Point aPoint(aPixPos.X(), aPixPos.Y());

    return aPoint;
}


awt::Size SAL_CALL SwAccessibleContext::getSize()
		throw (uno::RuntimeException)
{
    awt::Rectangle aRect = getBoundsImpl(sal_False);
	awt::Size aSize( aRect.Width, aRect.Height );

	return aSize;
}

void SAL_CALL SwAccessibleContext::grabFocus()
		throw (uno::RuntimeException)
{
	vos::OGuard aGuard(Application::GetSolarMutex());

	CHECK_FOR_DEFUNC( XAccessibleContext );

	if( GetFrm()->IsFlyFrm() )
	{
		const SdrObject *pObj =
			static_cast < const SwFlyFrm * >( GetFrm() )->GetVirtDrawObj();
		if( pObj )
			Select( const_cast < SdrObject * >( pObj ), sal_False );
	}
	else
	{
		const SwCntntFrm *pCFrm = 0;
		if( GetFrm()->IsCntntFrm() )
			pCFrm = static_cast< const SwCntntFrm * >( GetFrm() );
		else if( GetFrm()->IsLayoutFrm() )
			pCFrm = static_cast< const SwLayoutFrm * >( GetFrm() )->ContainsCntnt();

		if( pCFrm && pCFrm->IsTxtFrm() )
		{
			const SwTxtFrm *pTxtFrm = static_cast< const SwTxtFrm * >( pCFrm );
			const SwTxtNode *pTxtNd = pTxtFrm->GetTxtNode();
			if( pTxtNd )
			{
				// create pam for selection
				SwIndex aIndex( const_cast< SwTxtNode * >( pTxtNd ),
								pTxtFrm->GetOfst() );
				SwPosition aStartPos( *pTxtNd, aIndex );
				SwPaM aPaM( aStartPos );

				// set PaM at cursor shell
				Select( aPaM );
			}
		}
	}
}


uno::Any SAL_CALL SwAccessibleContext::getAccessibleKeyBinding()
		throw (uno::RuntimeException)
{
	// There are no key bindings
	return uno::Any();
}

sal_Int32 SAL_CALL SwAccessibleContext::getForeground()
		throw (uno::RuntimeException)
{
	return COL_BLACK;
}

sal_Int32 SAL_CALL SwAccessibleContext::getBackground()
		throw (uno::RuntimeException)
{
	return COL_WHITE;
}


OUString SAL_CALL SwAccessibleContext::getImplementationName()
        throw( uno::RuntimeException )
{
	ASSERT( !this, "implementation name needs to be overloaded" );

	THROW_RUNTIME_EXCEPTION( lang::XServiceInfo, "implementation name needs to be overloaded" )
}

sal_Bool SAL_CALL
    SwAccessibleContext::supportsService (const ::rtl::OUString& )
        throw (uno::RuntimeException)
{
	ASSERT( !this, "supports service needs to be overloaded" );
	THROW_RUNTIME_EXCEPTION( lang::XServiceInfo, "supports service needs to be overloaded" )
}

uno::Sequence< OUString > SAL_CALL SwAccessibleContext::getSupportedServiceNames()
		throw( uno::RuntimeException )
{
	ASSERT( !this, "supported services names needs to be overloaded" );
	THROW_RUNTIME_EXCEPTION( lang::XServiceInfo, "supported services needs to be overloaded" )
}

void SwAccessibleContext::DisposeShape( const SdrObject *pObj,
								::accessibility::AccessibleShape *pAccImpl )
{
	::vos::ORef< ::accessibility::AccessibleShape > xAccImpl( pAccImpl );
	if( !xAccImpl.isValid() )
		xAccImpl = GetMap()->GetContextImpl( pObj, this, sal_True );

	AccessibleEventObject aEvent;
	aEvent.EventId = AccessibleEventId::CHILD;
	uno::Reference< XAccessible > xAcc( xAccImpl.getBodyPtr() );
	aEvent.OldValue <<= xAcc;
	FireAccessibleEvent( aEvent );

	GetMap()->RemoveContext( pObj );
	xAccImpl->dispose();
}

void SwAccessibleContext::ScrolledInShape( const SdrObject* ,
								::accessibility::AccessibleShape *pAccImpl )
{
	if(NULL == pAccImpl)
	{
		return ; 
	}
	AccessibleEventObject aEvent;
	aEvent.EventId = AccessibleEventId::CHILD;
	uno::Reference< XAccessible > xAcc( pAccImpl );
	aEvent.NewValue <<= xAcc;
	FireAccessibleEvent( aEvent );

	if( pAccImpl->GetState( AccessibleStateType::FOCUSED ) )
	{
		Window *pWin = GetWindow();
		if( pWin && pWin->HasFocus() )
		{
            AccessibleEventObject aStateChangedEvent;
            aStateChangedEvent.EventId = AccessibleEventId::STATE_CHANGED;
            aStateChangedEvent.NewValue <<= AccessibleStateType::FOCUSED;
            aStateChangedEvent.Source = xAcc;

            FireAccessibleEvent( aStateChangedEvent );
		}
	}
}

void SwAccessibleContext::Dispose( sal_Bool bRecursive )
{
	vos::OGuard aGuard(Application::GetSolarMutex());

	ASSERT( GetFrm() && GetMap(), "already disposed" );
	ASSERT( GetMap()->GetVisArea() == GetVisArea(),
				"invalid vis area for dispose" );

	bDisposing = sal_True;

	// dispose children
	if( bRecursive )
		DisposeChildren( GetFrm(), bRecursive );

	// get parent
	uno::Reference< XAccessible > xParent( GetWeakParent() );
	uno::Reference < XAccessibleContext > xThis( this );

	// send child event at parent
	if( xParent.is() )
	{
		SwAccessibleContext *pAcc = (SwAccessibleContext *)xParent.get();

		AccessibleEventObject aEvent;
		aEvent.EventId = AccessibleEventId::CHILD;
		aEvent.OldValue <<= xThis;
		pAcc->FireAccessibleEvent( aEvent );
		DBG_MSG_THIS_PARAM( "AccessibleChild (removed)", pAcc, this )
	}

	// set defunc state (its not required to broadcast a state changed
	// event if the object is diposed afterwards)
	{
        vos::OGuard aDefuncStateGuard( aMutex );
		bIsDefuncState = sal_True;
	}

	// broadcast dispose event
	if ( nClientId )
	{
        comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( nClientId, *this );
		nClientId =  0;
		DBG_MSG_CD( "dispose" )
	}

    RemoveFrmFromAccessibleMap();
	ClearFrm();
	pMap = 0;

	bDisposing = sal_False;
}

void SwAccessibleContext::DisposeChild( const SwAccessibleChild& rChildFrmOrObj,
										sal_Bool bRecursive )
{
	vos::OGuard aGuard(Application::GetSolarMutex());

    if ( IsShowing( *(GetMap()), rChildFrmOrObj ) ||
         rChildFrmOrObj.AlwaysIncludeAsChild() ||
         !SwAccessibleChild( GetFrm() ).IsVisibleChildrenOnly() )
	{
		// If the object could have existed before, than there is nothing to do,
		// because no wrapper exists now and therefor no one is interested to
		// get notified of the movement.
		if( rChildFrmOrObj.GetSwFrm() )
		{
			::vos::ORef< SwAccessibleContext > xAccImpl =
					GetMap()->GetContextImpl( rChildFrmOrObj.GetSwFrm(),
											  sal_True );
			xAccImpl->Dispose( bRecursive );
		}
        else if ( rChildFrmOrObj.GetDrawObject() )
		{
			::vos::ORef< ::accessibility::AccessibleShape > xAccImpl =
                    GetMap()->GetContextImpl( rChildFrmOrObj.GetDrawObject(),
											  this, sal_True );
            DisposeShape( rChildFrmOrObj.GetDrawObject(),
						  xAccImpl.getBodyPtr() );
		}
        else if ( rChildFrmOrObj.GetWindow() )
        {
            AccessibleEventObject aEvent;
            aEvent.EventId = AccessibleEventId::CHILD;
            uno::Reference< XAccessible > xAcc =
                                    rChildFrmOrObj.GetWindow()->GetAccessible();
            aEvent.OldValue <<= xAcc;
            FireAccessibleEvent( aEvent );
        }
	}
	else if( bRecursive && rChildFrmOrObj.GetSwFrm() )
		DisposeChildren( rChildFrmOrObj.GetSwFrm(), bRecursive );
}

void SwAccessibleContext::InvalidatePosOrSize( const SwRect& )
{
	vos::OGuard aGuard(Application::GetSolarMutex());

	ASSERT( GetFrm() && !GetFrm()->Frm().IsEmpty(), "context should have a size" );

	sal_Bool bIsOldShowingState;
    sal_Bool bIsNewShowingState = IsShowing( *(GetMap()) );
	{
        vos::OGuard aShowingStateGuard( aMutex );
		bIsOldShowingState = bIsShowingState;
		bIsShowingState = bIsNewShowingState;
	}

	if( bIsOldShowingState != bIsNewShowingState )
	{
		FireStateChangedEvent( AccessibleStateType::SHOWING,
							   bIsNewShowingState  );
	}
	else if( bIsNewShowingState )
	{
		// The frame stays visible -> broadcast event
		FireVisibleDataEvent();
	}

    if( !bIsNewShowingState &&
        SwAccessibleChild( GetParent() ).IsVisibleChildrenOnly() )
	{
		// The frame is now invisible -> dispose it
		//Remove
		//Dispose( sal_True );
	}
	else
	{
		_InvalidateContent( sal_True );
	}
}

void SwAccessibleContext::InvalidateChildPosOrSize(
                    const SwAccessibleChild& rChildFrmOrObj,
					const SwRect& rOldFrm )
{
	vos::OGuard aGuard(Application::GetSolarMutex());

	ASSERT( !rChildFrmOrObj.GetSwFrm() ||
			!rChildFrmOrObj.GetSwFrm()->Frm().IsEmpty(),
			"child context should have a size" );

    if ( rChildFrmOrObj.AlwaysIncludeAsChild() )
    {
        // nothing to do;
        return;
    }

    const bool bVisibleChildrenOnly = SwAccessibleChild( GetFrm() ).IsVisibleChildrenOnly();
    const bool bNew = rOldFrm.IsEmpty() ||
                     ( rOldFrm.Left() == 0 && rOldFrm.Top() == 0 );
    if( IsShowing( *(GetMap()), rChildFrmOrObj ) )
	{
		// If the object could have existed before, than there is nothing to do,
		// because no wrapper exists now and therefor no one is interested to
		// get notified of the movement.
        if( bNew || (bVisibleChildrenOnly && !IsShowing( rOldFrm )) )
		{
			if( rChildFrmOrObj.GetSwFrm() )
			{
				// The frame becomes visible. A child event must be send.
				::vos::ORef< SwAccessibleContext > xAccImpl =
					GetMap()->GetContextImpl( rChildFrmOrObj.GetSwFrm(),
											  sal_True );
				xAccImpl->ScrolledIn();
			}
            else if ( rChildFrmOrObj.GetDrawObject() )
			{
				::vos::ORef< ::accessibility::AccessibleShape > xAccImpl =
                        GetMap()->GetContextImpl( rChildFrmOrObj.GetDrawObject(),
												  this, sal_True );
                // --> OD 2004-11-29 #i37790#
                if ( xAccImpl.isValid() )
                {
                    ScrolledInShape( rChildFrmOrObj.GetDrawObject(),
                                     xAccImpl.getBodyPtr() );
                }
                else
                {
                    ASSERT( false ,
                            "<SwAccessibleContext::InvalidateChildPosOrSize(..)> - no accessible shape found." );
                }
                // <--
			}
            else if ( rChildFrmOrObj.GetWindow() )
            {
                AccessibleEventObject aEvent;
                aEvent.EventId = AccessibleEventId::CHILD;
                aEvent.NewValue <<= (rChildFrmOrObj.GetWindow()->GetAccessible());
                FireAccessibleEvent( aEvent );
            }
		}
	}
	else
	{
		// If the frame was visible before, than a child event for the parent
		// needs to be send. However, there is no wrapper existing, and so
		// no notifications for grandchildren are required. If the are
		// grandgrandchildren, they would be notified by the layout.
        if( bVisibleChildrenOnly &&
			!bNew && IsShowing( rOldFrm ) )
		{
			if( rChildFrmOrObj.GetSwFrm() )
			{
				::vos::ORef< SwAccessibleContext > xAccImpl =
					GetMap()->GetContextImpl( rChildFrmOrObj.GetSwFrm(),
											  sal_True );
				xAccImpl->SetParent( this );
				xAccImpl->Dispose( sal_True );
			}
            else if ( rChildFrmOrObj.GetDrawObject() )
			{
				::vos::ORef< ::accessibility::AccessibleShape > xAccImpl =
                        GetMap()->GetContextImpl( rChildFrmOrObj.GetDrawObject(),
												  this, sal_True );
                DisposeShape( rChildFrmOrObj.GetDrawObject(),
						  xAccImpl.getBodyPtr() );
			}
            else if ( rChildFrmOrObj.GetWindow() )
            {
                ASSERT( false,
                        "<SwAccessibleContext::InvalidateChildPosOrSize(..)> - not expected to handle dispose of child of type <Window>." );
            }
		}
	}
}

void SwAccessibleContext::InvalidateContent()
{
	vos::OGuard aGuard(Application::GetSolarMutex());

	_InvalidateContent( sal_False );
}

void SwAccessibleContext::InvalidateCursorPos()
{
	vos::OGuard aGuard(Application::GetSolarMutex());

	_InvalidateCursorPos();
}

void SwAccessibleContext::InvalidateFocus()
{
	vos::OGuard aGuard(Application::GetSolarMutex());

	_InvalidateFocus();
}

// --> OD 2005-12-12 #i27301# - use new type definition for <_nStates>
void SwAccessibleContext::InvalidateStates( tAccessibleStates _nStates )
{
	if( GetMap() )
	{
		ViewShell *pVSh = GetMap()->GetShell();
		if( pVSh )
		{
            if( (_nStates & ACC_STATE_EDITABLE) != 0 )
			{
				sal_Bool bIsOldEditableState;
				sal_Bool bIsNewEditableState = IsEditable( pVSh );
				{
					vos::OGuard aGuard( aMutex );
					bIsOldEditableState = bIsEditableState;
					bIsEditableState = bIsNewEditableState;
				}

				if( bIsOldEditableState != bIsNewEditableState )
					FireStateChangedEvent( AccessibleStateType::EDITABLE,
										   bIsNewEditableState  );
			}
            if( (_nStates & ACC_STATE_OPAQUE) != 0 )
			{
				sal_Bool bIsOldOpaqueState;
				sal_Bool bIsNewOpaqueState = IsOpaque( pVSh );
				{
					vos::OGuard aGuard( aMutex );
					bIsOldOpaqueState = bIsOpaqueState;
					bIsOpaqueState = bIsNewOpaqueState;
				}

				if( bIsOldOpaqueState != bIsNewOpaqueState )
					FireStateChangedEvent( AccessibleStateType::OPAQUE,
										   bIsNewOpaqueState  );
			}
		}

        InvalidateChildrenStates( GetFrm(), _nStates );
	}
}
// <--

void SwAccessibleContext::InvalidateRelation( sal_uInt16 nType )
{
	AccessibleEventObject aEvent;
	aEvent.EventId = nType;

    FireAccessibleEvent( aEvent );
}

/** text selection has changed

    OD 2005-12-14 #i27301#

    @author OD
*/
void SwAccessibleContext::InvalidateTextSelection()
{
    AccessibleEventObject aEvent;
    aEvent.EventId = AccessibleEventId::TEXT_SELECTION_CHANGED;

    FireAccessibleEvent( aEvent );
}

/** attributes has changed

    OD 2009-01-06 #i88069#

    @author OD
*/
void SwAccessibleContext::InvalidateAttr()
{
    AccessibleEventObject aEvent;
    aEvent.EventId = AccessibleEventId::TEXT_ATTRIBUTE_CHANGED;

    FireAccessibleEvent( aEvent );
}

sal_Bool SwAccessibleContext::HasCursor()
{
	return sal_False;
}

sal_Bool SwAccessibleContext::Select( SwPaM *pPaM, SdrObject *pObj,
									  sal_Bool bAdd )
{
    SwCrsrShell* pCrsrShell = GetCrsrShell();
	if( !pCrsrShell )
		return sal_False;

    SwFEShell* pFEShell = pCrsrShell->ISA( SwFEShell )
								? static_cast<SwFEShell*>( pCrsrShell )
								: 0;
	// Get rid of activated OLE object
	if( pFEShell )
		pFEShell->FinishOLEObj();

	sal_Bool bRet = sal_False;
	if( pObj )
	{
		if( pFEShell )
		{
			Point aDummy;
			sal_uInt8 nFlags = bAdd ? SW_ADD_SELECT : 0;
			pFEShell->SelectObj( aDummy, nFlags, pObj );
			bRet = sal_True;
		}
	}
	else if( pPaM )
	{
		// Get rid of frame selection. If there is one, make text cursor
		// visible again.
		sal_Bool bCallShowCrsr = sal_False;
		if( pFEShell && (pFEShell->IsFrmSelected() ||
						 pFEShell->IsObjSelected()) )
		{
			Point aPt( LONG_MIN, LONG_MIN );
			pFEShell->SelectObj( aPt, 0 );
			bCallShowCrsr = sal_True;
		}
        pCrsrShell->KillPams();
        pCrsrShell->SetSelection( *pPaM );
		if( bCallShowCrsr )
			pCrsrShell->ShowCrsr();
		bRet = sal_True;
	}

	return bRet;
}

OUString SwAccessibleContext::GetResource( sal_uInt16 nResId,
										   const OUString *pArg1,
										   const OUString *pArg2 )
{
	String sStr;
	{
		vos::OGuard aGuard(Application::GetSolarMutex());

		sStr = SW_RES( nResId );
	}

	if( pArg1 )
	{
		sStr.SearchAndReplace( String::CreateFromAscii(
									RTL_CONSTASCII_STRINGPARAM( "$(ARG1)" )),
							   String( *pArg1 ) );
	}
	if( pArg2 )
	{
		sStr.SearchAndReplace( String::CreateFromAscii(
									RTL_CONSTASCII_STRINGPARAM( "$(ARG2)" )),
							   String( *pArg2 ) );
	}

	return OUString( sStr );
}

void SwAccessibleContext::RemoveFrmFromAccessibleMap()
{
    if( bRegisteredAtAccessibleMap && GetFrm() && GetMap() )
        GetMap()->RemoveContext( GetFrm() );
}

bool SwAccessibleContext::HasAdditionalAccessibleChildren()
{
    bool bRet( false );

    if ( GetFrm()->IsTxtFrm() )
    {
        SwPostItMgr* pPostItMgr = GetMap()->GetShell()->GetPostItMgr();
        if ( pPostItMgr && pPostItMgr->HasNotes() && pPostItMgr->ShowNotes() )
        {
            bRet = pPostItMgr->HasFrmConnectedSidebarWins( *(GetFrm()) );
        }
    }

    return bRet;
}
/** get additional accessible child by index

    OD 2010-01-27 #i88070#

    @author OD
*/
Window* SwAccessibleContext::GetAdditionalAccessibleChild( const sal_Int32 nIndex )
{
    Window* pAdditionalAccessibleChild( 0 );

    if ( GetFrm()->IsTxtFrm() )
    {
        SwPostItMgr* pPostItMgr = GetMap()->GetShell()->GetPostItMgr();
        if ( pPostItMgr && pPostItMgr->HasNotes() && pPostItMgr->ShowNotes() )
        {
            pAdditionalAccessibleChild =
                    pPostItMgr->GetSidebarWinForFrmByIndex( *(GetFrm()), nIndex );
        }
    }

    return pAdditionalAccessibleChild;
}

/** get all additional accessible children

    OD 2010-01-27 #i88070#

    @author OD
*/
void SwAccessibleContext::GetAdditionalAccessibleChildren( std::vector< Window* >* pChildren )
{
    if ( GetFrm()->IsTxtFrm() )
    {
        SwPostItMgr* pPostItMgr = GetMap()->GetShell()->GetPostItMgr();
        if ( pPostItMgr && pPostItMgr->HasNotes() && pPostItMgr->ShowNotes() )
        {
            pPostItMgr->GetAllSidebarWinForFrm( *(GetFrm()), pChildren );
        }
    }
}

#if (OSL_DEBUG_LEVEL > 1) && defined TEST_MIB
void lcl_SwAccessibleContext_DbgMsg( SwAccessibleContext *pThisAcc,
									 const char *pMsg,
								     SwAccessibleContext *pChildAcc,
								  	 sal_Bool bConstrDestr )
{
	static SvFileStream aStrm( String::CreateFromAscii("j:\\acc.log"),
					STREAM_WRITE|STREAM_TRUNC|STREAM_SHARE_DENYNONE	);
	ByteString aName( String(pThisAcc->GetName()),
					  RTL_TEXTENCODING_ISO_8859_1 );
	if( aName.Len() )
	{
		aStrm << aName.GetBuffer()
			  << ": ";
	}
	aStrm << pMsg;
	if( pChildAcc )
	{
		ByteString aChild( String(pChildAcc->GetName()),
						   RTL_TEXTENCODING_ISO_8859_1 );
		aStrm << ": "
		      << aChild.GetBuffer();
	}
	aStrm << "\r\n    (";

	if( !bConstrDestr )
	{
		ByteString aDesc( String(pThisAcc->getAccessibleDescription()),
						   RTL_TEXTENCODING_ISO_8859_1 );
		aStrm << aDesc.GetBuffer()
			  << ", ";
	}

	Rectangle aVisArea( pThisAcc->GetVisArea() );
	aStrm << "VA: "
		  << ByteString::CreateFromInt32( aVisArea.Left() ).GetBuffer()
		  << ","
		  << ByteString::CreateFromInt32( aVisArea.Top() ).GetBuffer()
		  << ","
		  << ByteString::CreateFromInt32( aVisArea.GetWidth() ).GetBuffer()
		  << ","
		  << ByteString::CreateFromInt32( aVisArea.GetHeight() ).GetBuffer();

	if( pThisAcc->GetFrm() )
	{
		Rectangle aBounds( pThisAcc->GetBounds( pThisAcc->GetFrm() ) );
		aStrm << ", BB: "
			  << ByteString::CreateFromInt32( aBounds.Left() ).GetBuffer()
			  << ","
			  << ByteString::CreateFromInt32( aBounds.Top() ).GetBuffer()
			  << ","
			  << ByteString::CreateFromInt32( aBounds.GetWidth() ).GetBuffer()
			  << ","
			  << ByteString::CreateFromInt32( aBounds.GetHeight() ).GetBuffer()
			  << ")\r\n";
	}

	aStrm.Flush();
}
#endif
sal_Bool SwAccessibleContext::SetSelectedState(sal_Bool bSeleted)
{
	if(bIsSeletedInDoc != bSeleted)
	{
		bIsSeletedInDoc = bSeleted;
		FireStateChangedEvent( AccessibleStateType::SELECTED, bSeleted );
		return sal_True;
	}
	return sal_False;
};