/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* 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 .
*/
//------------------------------------------------------------------------
//
// Global header
//
//------------------------------------------------------------------------
#include <limits.h>
#include <vector>
#include <algorithm>
#include <boost/ref.hpp>
#include <osl/mutex.hxx>
#include <vcl/window.hxx>
#include <vcl/svapp.hxx>
#include <comphelper/sequenceasvector.hxx>
#include <com/sun/star/uno/Any.hxx>
#include <com/sun/star/uno/Reference.hxx>
#include <com/sun/star/awt/Point.hpp>
#include <com/sun/star/awt/Rectangle.hpp>
#include <com/sun/star/accessibility/AccessibleTextType.hpp>
//------------------------------------------------------------------------
//
// Project-local header
//
//------------------------------------------------------------------------
#include <editeng/editdata.hxx>
#include <editeng/unopracc.hxx>
#include "editeng/unoedprx.hxx"
#include <editeng/AccessibleStaticTextBase.hxx>
#include "editeng/AccessibleEditableTextPara.hxx"
using namespace ::com::sun::star;
using namespace ::com::sun::star::accessibility;
/* TODO:
=====
- separate adapter functionality from AccessibleStaticText class
- refactor common loops into templates, using mem_fun
*/
namespace accessibility
{
typedef ::comphelper::SequenceAsVector< beans::PropertyValue > PropertyValueVector;
class PropertyValueEqualFunctor : public ::std::binary_function< beans::PropertyValue, beans::PropertyValue, bool >
{
public:
PropertyValueEqualFunctor()
{}
bool operator() ( const beans::PropertyValue& lhs, const beans::PropertyValue& rhs ) const
{
return ( lhs.Name == rhs.Name && lhs.Value == rhs.Value );
}
};
//------------------------------------------------------------------------
//
// Static Helper
//
//------------------------------------------------------------------------
ESelection MakeSelection( sal_Int32 nStartPara, sal_Int32 nStartIndex,
sal_Int32 nEndPara, sal_Int32 nEndIndex )
{
DBG_ASSERT(nStartPara >= 0 && nStartPara <= SAL_MAX_INT32 &&
nStartIndex >= 0 && nStartIndex <= USHRT_MAX &&
nEndPara >= 0 && nEndPara <= SAL_MAX_INT32 &&
nEndIndex >= 0 && nEndIndex <= USHRT_MAX ,
"AccessibleStaticTextBase_Impl::MakeSelection: index value overflow");
return ESelection( nStartPara, static_cast< sal_uInt16 >(nStartIndex),
nEndPara, static_cast< sal_uInt16 >(nEndIndex) );
}
//------------------------------------------------------------------------
//
// AccessibleStaticTextBase_Impl declaration
//
//------------------------------------------------------------------------
DBG_NAME( AccessibleStaticTextBase_Impl );
/** AccessibleStaticTextBase_Impl
This class implements the AccessibleStaticTextBase
functionality, mainly by forwarding the calls to an aggregated
AccessibleEditableTextPara. As this is a therefore non-trivial
adapter, factoring out the common functionality from
AccessibleEditableTextPara might be a profitable future task.
*/
class AccessibleStaticTextBase_Impl
{
public:
// receive pointer to our frontend class and view window
AccessibleStaticTextBase_Impl();
~AccessibleStaticTextBase_Impl();
SvxEditSourceAdapter& GetEditSource() const SAL_THROW((uno::RuntimeException))
{
DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
return maEditSource;
}
SAL_WNODEPRECATED_DECLARATIONS_PUSH
void SetEditSource( ::std::auto_ptr< SvxEditSource > pEditSource ) SAL_THROW((uno::RuntimeException));
SAL_WNODEPRECATED_DECLARATIONS_POP
void SetEventSource( const uno::Reference< XAccessible >& rInterface )
{
DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
mxThis = rInterface;
}
uno::Reference< XAccessible > GetEventSource() const
{
DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
return mxThis;
}
void SetOffset( const Point& );
Point GetOffset() const
{
DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
::osl::MutexGuard aGuard( maMutex ); Point aPoint( maOffset );
return aPoint;
}
void UpdateChildren();
void Dispose();
#ifdef DBG_UTIL
void CheckInvariants() const;
#endif
AccessibleEditableTextPara& GetParagraph( sal_Int32 nPara ) const;
sal_Int32 GetParagraphCount() const;
EPosition Index2Internal( sal_Int32 nFlatIndex ) const
{
DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
return ImpCalcInternal( nFlatIndex, false );
}
EPosition Range2Internal( sal_Int32 nFlatIndex ) const
{
DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
return ImpCalcInternal( nFlatIndex, true );
}
sal_Int32 Internal2Index( EPosition nEEIndex ) const;
void CorrectTextSegment( TextSegment& aTextSegment,
int nPara ) const;
sal_Bool SetSelection( sal_Int32 nStartPara, sal_Int32 nStartIndex,
sal_Int32 nEndPara, sal_Int32 nEndIndex );
sal_Bool CopyText( sal_Int32 nStartPara, sal_Int32 nStartIndex,
sal_Int32 nEndPara, sal_Int32 nEndIndex );
Rectangle GetParagraphBoundingBox() const;
private:
EPosition ImpCalcInternal( sal_Int32 nFlatIndex, bool bExclusive ) const;
// our frontend class (the one implementing the actual
// interface). That's not necessarily the one containing the impl
// pointer
uno::Reference< XAccessible > mxThis;
// implements our functionality, we're just an adapter (guarded by solar mutex)
mutable AccessibleEditableTextPara* mpTextParagraph;
uno::Reference< XAccessible > mxParagraph;
// a wrapper for the text forwarders (guarded by solar mutex)
mutable SvxEditSourceAdapter maEditSource;
// guard for maOffset
mutable ::osl::Mutex maMutex;
/// our current offset to the containing shape/cell (guarded by maMutex)
Point maOffset;
};
//------------------------------------------------------------------------
//
// AccessibleStaticTextBase_Impl implementation
//
//------------------------------------------------------------------------
AccessibleStaticTextBase_Impl::AccessibleStaticTextBase_Impl() :
mxThis( NULL ),
mpTextParagraph( new AccessibleEditableTextPara(NULL) ),
mxParagraph( mpTextParagraph ),
maEditSource(),
maMutex(),
maOffset(0,0)
{
DBG_CTOR( AccessibleStaticTextBase_Impl, NULL );
// TODO: this is still somewhat of a hack, all the more since
// now the maTextParagraph has an empty parent reference set
}
AccessibleStaticTextBase_Impl::~AccessibleStaticTextBase_Impl()
{
DBG_DTOR( AccessibleStaticTextBase_Impl, NULL );
}
SAL_WNODEPRECATED_DECLARATIONS_PUSH
void AccessibleStaticTextBase_Impl::SetEditSource( ::std::auto_ptr< SvxEditSource > pEditSource ) SAL_THROW((uno::RuntimeException))
{
DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
maEditSource.SetEditSource( pEditSource );
if( mpTextParagraph )
mpTextParagraph->SetEditSource( &maEditSource );
}
SAL_WNODEPRECATED_DECLARATIONS_POP
void AccessibleStaticTextBase_Impl::SetOffset( const Point& rPoint )
{
DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
// guard against non-atomic access to maOffset data structure
{
::osl::MutexGuard aGuard( maMutex );
maOffset = rPoint;
}
if( mpTextParagraph )
mpTextParagraph->SetEEOffset( rPoint );
// in all cases, check visibility afterwards.
UpdateChildren();
}
void AccessibleStaticTextBase_Impl::UpdateChildren()
{
DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
// currently no children
}
void AccessibleStaticTextBase_Impl::Dispose()
{
DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
// we're the owner of the paragraph, so destroy it, too
if( mpTextParagraph )
mpTextParagraph->Dispose();
// drop references
mxParagraph = NULL;
mxThis = NULL;
mpTextParagraph = NULL;
}
#ifdef DBG_UTIL
void AccessibleStaticTextBase_Impl::CheckInvariants() const
{
// TODO
}
#endif
AccessibleEditableTextPara& AccessibleStaticTextBase_Impl::GetParagraph( sal_Int32 nPara ) const
{
DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
if( !mpTextParagraph )
throw lang::DisposedException ("object has been already disposed", mxThis );
// TODO: Have a different method on AccessibleEditableTextPara
// that does not care about state changes
mpTextParagraph->SetParagraphIndex( nPara );
return *mpTextParagraph;
}
sal_Int32 AccessibleStaticTextBase_Impl::GetParagraphCount() const
{
DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
if( !mpTextParagraph )
return 0;
else
return mpTextParagraph->GetTextForwarder().GetParagraphCount();
}
sal_Int32 AccessibleStaticTextBase_Impl::Internal2Index( EPosition nEEIndex ) const
{
// XXX checks for overflow and returns maximum if so
sal_Int32 aRes(0);
for(sal_Int32 i=0; i<nEEIndex.nPara; ++i)
{
sal_Int32 nCount = GetParagraph(i).getCharacterCount();
if (SAL_MAX_INT32 - aRes > nCount)
return SAL_MAX_INT32;
aRes += nCount;
}
if (SAL_MAX_INT32 - aRes > nEEIndex.nIndex)
return SAL_MAX_INT32;
return aRes + nEEIndex.nIndex;
}
void AccessibleStaticTextBase_Impl::CorrectTextSegment( TextSegment& aTextSegment,
int nPara ) const
{
// Keep 'invalid' values at the TextSegment
if( aTextSegment.SegmentStart != -1 &&
aTextSegment.SegmentEnd != -1 )
{
// #112814# Correct TextSegment by paragraph offset
sal_Int32 nOffset(0);
int i;
for(i=0; i<nPara; ++i)
nOffset += GetParagraph(i).getCharacterCount();
aTextSegment.SegmentStart += nOffset;
aTextSegment.SegmentEnd += nOffset;
}
}
EPosition AccessibleStaticTextBase_Impl::ImpCalcInternal( sal_Int32 nFlatIndex, bool bExclusive ) const
{
DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
if( nFlatIndex < 0 )
throw lang::IndexOutOfBoundsException("AccessibleStaticTextBase_Impl::Index2Internal: character index out of bounds",
mxThis);
// gratuitously accepting larger indices here, AccessibleEditableTextPara will throw eventually
sal_Int32 nCurrPara, nCurrIndex, nParas, nCurrCount;
for( nCurrPara=0, nParas=GetParagraphCount(), nCurrCount=0, nCurrIndex=0; nCurrPara<nParas; ++nCurrPara )
{
nCurrCount = GetParagraph( nCurrPara ).getCharacterCount();
nCurrIndex += nCurrCount;
if( nCurrIndex > nFlatIndex )
{
// check overflow
DBG_ASSERT(nCurrPara >= 0 && nCurrPara <= SAL_MAX_INT32 &&
nFlatIndex - nCurrIndex + nCurrCount >= 0 && nFlatIndex - nCurrIndex + nCurrCount <= USHRT_MAX ,
"AccessibleStaticTextBase_Impl::Index2Internal: index value overflow");
return EPosition( nCurrPara, static_cast< sal_uInt16 >(nFlatIndex - nCurrIndex + nCurrCount) );
}
}
// #102170# Allow one-past the end for ranges
if( bExclusive && nCurrIndex == nFlatIndex )
{
// check overflow
DBG_ASSERT(nCurrPara > 0 && nCurrPara <= SAL_MAX_INT32 &&
nFlatIndex - nCurrIndex + nCurrCount >= 0 && nFlatIndex - nCurrIndex + nCurrCount <= USHRT_MAX ,
"AccessibleStaticTextBase_Impl::Index2Internal: index value overflow");
return EPosition( nCurrPara-1, static_cast< sal_uInt16 >(nFlatIndex - nCurrIndex + nCurrCount) );
}
// not found? Out of bounds
throw lang::IndexOutOfBoundsException("AccessibleStaticTextBase_Impl::Index2Internal: character index out of bounds",
mxThis);
}
sal_Bool AccessibleStaticTextBase_Impl::SetSelection( sal_Int32 nStartPara, sal_Int32 nStartIndex,
sal_Int32 nEndPara, sal_Int32 nEndIndex )
{
DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
if( !mpTextParagraph )
return sal_False;
try
{
SvxEditViewForwarder& rCacheVF = mpTextParagraph->GetEditViewForwarder( sal_True );
return rCacheVF.SetSelection( MakeSelection(nStartPara, nStartIndex, nEndPara, nEndIndex) );
}
catch( const uno::RuntimeException& )
{
return sal_False;
}
}
sal_Bool AccessibleStaticTextBase_Impl::CopyText( sal_Int32 nStartPara, sal_Int32 nStartIndex,
sal_Int32 nEndPara, sal_Int32 nEndIndex )
{
DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
if( !mpTextParagraph )
return sal_False;
try
{
SvxEditViewForwarder& rCacheVF = mpTextParagraph->GetEditViewForwarder( sal_True );
mpTextParagraph->GetTextForwarder(); // MUST be after GetEditViewForwarder(), see method docs
sal_Bool aRetVal;
// save current selection
ESelection aOldSelection;
rCacheVF.GetSelection( aOldSelection );
rCacheVF.SetSelection( MakeSelection(nStartPara, nStartIndex, nEndPara, nEndIndex) );
aRetVal = rCacheVF.Copy();
rCacheVF.SetSelection( aOldSelection ); // restore
return aRetVal;
}
catch( const uno::RuntimeException& )
{
return sal_False;
}
}
Rectangle AccessibleStaticTextBase_Impl::GetParagraphBoundingBox() const
{
Rectangle aRect;
if( mpTextParagraph )
{
awt::Rectangle aAwtRect = mpTextParagraph->getBounds();
aRect = Rectangle( Point( aAwtRect.X, aAwtRect.Y ), Size( aAwtRect.Width, aAwtRect.Height ) );
}
else
{
aRect.SetEmpty();
}
return aRect;
}
//------------------------------------------------------------------------
//
// AccessibleStaticTextBase implementation
//
//------------------------------------------------------------------------
SAL_WNODEPRECATED_DECLARATIONS_PUSH
AccessibleStaticTextBase::AccessibleStaticTextBase( ::std::auto_ptr< SvxEditSource > pEditSource ) :
mpImpl( new AccessibleStaticTextBase_Impl() )
{
SolarMutexGuard aGuard;
SetEditSource( pEditSource );
}
SAL_WNODEPRECATED_DECLARATIONS_POP
AccessibleStaticTextBase::~AccessibleStaticTextBase()
{
}
const SvxEditSource& AccessibleStaticTextBase::GetEditSource() const SAL_THROW((::com::sun::star::uno::RuntimeException))
{
#ifdef DBG_UTIL
mpImpl->CheckInvariants();
const SvxEditSource& aEditSource = mpImpl->GetEditSource();
mpImpl->CheckInvariants();
return aEditSource;
#else
return mpImpl->GetEditSource();
#endif
}
SAL_WNODEPRECATED_DECLARATIONS_PUSH
void AccessibleStaticTextBase::SetEditSource( ::std::auto_ptr< SvxEditSource > pEditSource ) SAL_THROW((::com::sun::star::uno::RuntimeException))
{
#ifdef DBG_UTIL
// precondition: solar mutex locked
DBG_TESTSOLARMUTEX();
mpImpl->CheckInvariants();
mpImpl->SetEditSource( pEditSource );
mpImpl->CheckInvariants();
#else
mpImpl->SetEditSource( pEditSource );
#endif
}
SAL_WNODEPRECATED_DECLARATIONS_POP
void AccessibleStaticTextBase::SetEventSource( const uno::Reference< XAccessible >& rInterface )
{
#ifdef DBG_UTIL
mpImpl->CheckInvariants();
#endif
mpImpl->SetEventSource( rInterface );
#ifdef DBG_UTIL
mpImpl->CheckInvariants();
#endif
}
uno::Reference< XAccessible > AccessibleStaticTextBase::GetEventSource() const
{
#ifdef DBG_UTIL
mpImpl->CheckInvariants();
uno::Reference< XAccessible > xRet( mpImpl->GetEventSource() );
mpImpl->CheckInvariants();
return xRet;
#else
return mpImpl->GetEventSource();
#endif
}
void AccessibleStaticTextBase::SetOffset( const Point& rPoint )
{
#ifdef DBG_UTIL
// precondition: solar mutex locked
DBG_TESTSOLARMUTEX();
mpImpl->CheckInvariants();
mpImpl->SetOffset( rPoint );
mpImpl->CheckInvariants();
#else
mpImpl->SetOffset( rPoint );
#endif
}
Point AccessibleStaticTextBase::GetOffset() const
{
#ifdef DBG_UTIL
mpImpl->CheckInvariants();
Point aPoint( mpImpl->GetOffset() );
mpImpl->CheckInvariants();
return aPoint;
#else
return mpImpl->GetOffset();
#endif
}
void AccessibleStaticTextBase::UpdateChildren() SAL_THROW((::com::sun::star::uno::RuntimeException))
{
#ifdef DBG_UTIL
// precondition: solar mutex locked
DBG_TESTSOLARMUTEX();
mpImpl->CheckInvariants();
mpImpl->UpdateChildren();
mpImpl->CheckInvariants();
#else
mpImpl->UpdateChildren();
#endif
}
void AccessibleStaticTextBase::Dispose()
{
#ifdef DBG_UTIL
mpImpl->CheckInvariants();
#endif
mpImpl->Dispose();
#ifdef DBG_UTIL
mpImpl->CheckInvariants();
#endif
}
// XAccessibleContext
sal_Int32 SAL_CALL AccessibleStaticTextBase::getAccessibleChildCount() throw (uno::RuntimeException)
{
// no children at all
return 0;
}
uno::Reference< XAccessible > SAL_CALL AccessibleStaticTextBase::getAccessibleChild( sal_Int32 /*i*/ ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
{
// no children at all
return uno::Reference< XAccessible >();
}
uno::Reference< XAccessible > SAL_CALL AccessibleStaticTextBase::getAccessibleAtPoint( const awt::Point& /*_aPoint*/ ) throw (uno::RuntimeException)
{
// no children at all
return uno::Reference< XAccessible >();
}
// XAccessibleText
sal_Int32 SAL_CALL AccessibleStaticTextBase::getCaretPosition() throw (uno::RuntimeException)
{
SolarMutexGuard aGuard;
sal_Int32 i, nPos, nParas;
for( i=0, nPos=-1, nParas=mpImpl->GetParagraphCount(); i<nParas; ++i )
{
if( (nPos=mpImpl->GetParagraph(i).getCaretPosition()) != -1 )
return nPos;
}
return nPos;
}
sal_Bool SAL_CALL AccessibleStaticTextBase::setCaretPosition( sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
{
return setSelection(nIndex, nIndex);
}
sal_Unicode SAL_CALL AccessibleStaticTextBase::getCharacter( sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
{
SolarMutexGuard aGuard;
EPosition aPos( mpImpl->Index2Internal(nIndex) );
return mpImpl->GetParagraph( aPos.nPara ).getCharacter( aPos.nIndex );
}
uno::Sequence< beans::PropertyValue > SAL_CALL AccessibleStaticTextBase::getCharacterAttributes( sal_Int32 nIndex, const ::com::sun::star::uno::Sequence< OUString >& aRequestedAttributes ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
{
SolarMutexGuard aGuard;
EPosition aPos( mpImpl->Index2Internal(nIndex) );
return mpImpl->GetParagraph( aPos.nPara ).getCharacterAttributes( aPos.nIndex, aRequestedAttributes );
}
awt::Rectangle SAL_CALL AccessibleStaticTextBase::getCharacterBounds( sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
{
SolarMutexGuard aGuard;
// #108900# Allow ranges for nIndex, as one-past-the-end
// values are now legal, too.
EPosition aPos( mpImpl->Range2Internal(nIndex) );
// #i70916# Text in spread sheet cells return the wrong extents
AccessibleEditableTextPara& rPara = mpImpl->GetParagraph( aPos.nPara );
awt::Rectangle aParaBounds( rPara.getBounds() );
awt::Rectangle aBounds( rPara.getCharacterBounds( aPos.nIndex ) );
aBounds.X += aParaBounds.X;
aBounds.Y += aParaBounds.Y;
return aBounds;
}
sal_Int32 SAL_CALL AccessibleStaticTextBase::getCharacterCount() throw (uno::RuntimeException)
{
SolarMutexGuard aGuard;
sal_Int32 i, nCount, nParas;
for( i=0, nCount=0, nParas=mpImpl->GetParagraphCount(); i<nParas; ++i )
nCount += mpImpl->GetParagraph(i).getCharacterCount();
return nCount;
}
sal_Int32 SAL_CALL AccessibleStaticTextBase::getIndexAtPoint( const awt::Point& rPoint ) throw (uno::RuntimeException)
{
SolarMutexGuard aGuard;
const sal_Int32 nParas( mpImpl->GetParagraphCount() );
sal_Int32 nIndex;
int i;
for( i=0; i<nParas; ++i )
{
// TODO: maybe exploit the fact that paragraphs are
// ordered vertically for early exit
// #i70916# Text in spread sheet cells return the wrong extents
AccessibleEditableTextPara& rPara = mpImpl->GetParagraph( i );
awt::Rectangle aParaBounds( rPara.getBounds() );
awt::Point aPoint( rPoint );
aPoint.X -= aParaBounds.X;
aPoint.Y -= aParaBounds.Y;
// #112814# Use correct index offset
if ( ( nIndex = rPara.getIndexAtPoint( aPoint ) ) != -1 )
return mpImpl->Internal2Index( EPosition(sal::static_int_cast<sal_uInt16>(i),
sal::static_int_cast<sal_uInt16>(nIndex)) );
}
return -1;
}
OUString SAL_CALL AccessibleStaticTextBase::getSelectedText() throw (uno::RuntimeException)
{
SolarMutexGuard aGuard;
sal_Int32 nStart( getSelectionStart() );
sal_Int32 nEnd( getSelectionEnd() );
// #104481# Return the empty string for 'no selection'
if( nStart < 0 || nEnd < 0 )
return OUString();
return getTextRange( nStart, nEnd );
}
sal_Int32 SAL_CALL AccessibleStaticTextBase::getSelectionStart() throw (uno::RuntimeException)
{
SolarMutexGuard aGuard;
sal_Int32 i, nPos, nParas;
for( i=0, nPos=-1, nParas=mpImpl->GetParagraphCount(); i<nParas; ++i )
{
if( (nPos=mpImpl->GetParagraph(i).getSelectionStart()) != -1 )
return nPos;
}
return nPos;
}
sal_Int32 SAL_CALL AccessibleStaticTextBase::getSelectionEnd() throw (uno::RuntimeException)
{
SolarMutexGuard aGuard;
sal_Int32 i, nPos, nParas;
for( i=0, nPos=-1, nParas=mpImpl->GetParagraphCount(); i<nParas; ++i )
{
if( (nPos=mpImpl->GetParagraph(i).getSelectionEnd()) != -1 )
return nPos;
}
return nPos;
}
sal_Bool SAL_CALL AccessibleStaticTextBase::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
{
SolarMutexGuard aGuard;
EPosition aStartIndex( mpImpl->Range2Internal(nStartIndex) );
EPosition aEndIndex( mpImpl->Range2Internal(nEndIndex) );
return mpImpl->SetSelection( aStartIndex.nPara, aStartIndex.nIndex,
aEndIndex.nPara, aEndIndex.nIndex );
}
OUString SAL_CALL AccessibleStaticTextBase::getText() throw (uno::RuntimeException)
{
SolarMutexGuard aGuard;
sal_Int32 i, nParas;
OUString aRes;
for( i=0, nParas=mpImpl->GetParagraphCount(); i<nParas; ++i )
aRes += mpImpl->GetParagraph(i).getText();
return aRes;
}
OUString SAL_CALL AccessibleStaticTextBase::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
{
SolarMutexGuard aGuard;
if( nStartIndex > nEndIndex )
::std::swap(nStartIndex, nEndIndex);
EPosition aStartIndex( mpImpl->Range2Internal(nStartIndex) );
EPosition aEndIndex( mpImpl->Range2Internal(nEndIndex) );
// #102170# Special case: start and end paragraph are identical
if( aStartIndex.nPara == aEndIndex.nPara )
{
return mpImpl->GetParagraph( aStartIndex.nPara ).getTextRange( aStartIndex.nIndex, aEndIndex.nIndex );
}
else
{
sal_Int32 i( aStartIndex.nPara );
OUString aRes( mpImpl->GetParagraph(i).getTextRange( aStartIndex.nIndex,
mpImpl->GetParagraph(i).getCharacterCount()-1) );
++i;
// paragraphs inbetween are fully included
for( ; i<aEndIndex.nPara; ++i )
aRes += mpImpl->GetParagraph(i).getText();
if( i<=aEndIndex.nPara )
aRes += mpImpl->GetParagraph(i).getTextRange( 0, aEndIndex.nIndex );
return aRes;
}
}
::com::sun::star::accessibility::TextSegment SAL_CALL AccessibleStaticTextBase::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException)
{
SolarMutexGuard aGuard;
EPosition aPos( mpImpl->Range2Internal(nIndex) );
::com::sun::star::accessibility::TextSegment aResult;
if( AccessibleTextType::PARAGRAPH == aTextType )
{
// #106393# Special casing one behind last paragraph is
// not necessary, since then, we return the content and
// boundary of that last paragraph. Range2Internal is
// tolerant against that, and returns the last paragraph
// in aPos.nPara.
// retrieve full text of the paragraph
aResult.SegmentText = mpImpl->GetParagraph( aPos.nPara ).getText();
// #112814# Adapt the start index with the paragraph offset
aResult.SegmentStart = mpImpl->Internal2Index( EPosition( aPos.nPara, 0 ) );
aResult.SegmentEnd = aResult.SegmentStart + aResult.SegmentText.getLength();
}
else
{
// No special handling required, forward to wrapped class
aResult = mpImpl->GetParagraph( aPos.nPara ).getTextAtIndex( aPos.nIndex, aTextType );
// #112814# Adapt the start index with the paragraph offset
mpImpl->CorrectTextSegment( aResult, aPos.nPara );
}
return aResult;
}
::com::sun::star::accessibility::TextSegment SAL_CALL AccessibleStaticTextBase::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException)
{
SolarMutexGuard aGuard;
EPosition aPos( mpImpl->Range2Internal(nIndex) );
::com::sun::star::accessibility::TextSegment aResult;
if( AccessibleTextType::PARAGRAPH == aTextType )
{
if( aPos.nIndex == mpImpl->GetParagraph( aPos.nPara ).getCharacterCount() )
{
// #103589# Special casing one behind the last paragraph
aResult.SegmentText = mpImpl->GetParagraph( aPos.nPara ).getText();
// #112814# Adapt the start index with the paragraph offset
aResult.SegmentStart = mpImpl->Internal2Index( EPosition( aPos.nPara, 0 ) );
}
else if( aPos.nPara > 0 )
{
aResult.SegmentText = mpImpl->GetParagraph( aPos.nPara - 1 ).getText();
// #112814# Adapt the start index with the paragraph offset
aResult.SegmentStart = mpImpl->Internal2Index( EPosition( aPos.nPara - 1, 0 ) );
}
aResult.SegmentEnd = aResult.SegmentStart + aResult.SegmentText.getLength();
}
else
{
// No special handling required, forward to wrapped class
aResult = mpImpl->GetParagraph( aPos.nPara ).getTextBeforeIndex( aPos.nIndex, aTextType );
// #112814# Adapt the start index with the paragraph offset
mpImpl->CorrectTextSegment( aResult, aPos.nPara );
}
return aResult;
}
::com::sun::star::accessibility::TextSegment SAL_CALL AccessibleStaticTextBase::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException)
{
SolarMutexGuard aGuard;
EPosition aPos( mpImpl->Range2Internal(nIndex) );
::com::sun::star::accessibility::TextSegment aResult;
if( AccessibleTextType::PARAGRAPH == aTextType )
{
// Special casing one behind the last paragraph is not
// necessary, this case is invalid here for
// getTextBehindIndex
if( aPos.nPara + 1 < mpImpl->GetParagraphCount() )
{
aResult.SegmentText = mpImpl->GetParagraph( aPos.nPara + 1 ).getText();
// #112814# Adapt the start index with the paragraph offset
aResult.SegmentStart = mpImpl->Internal2Index( EPosition( aPos.nPara + 1, 0 ) );
aResult.SegmentEnd = aResult.SegmentStart + aResult.SegmentText.getLength();
}
}
else
{
// No special handling required, forward to wrapped class
aResult = mpImpl->GetParagraph( aPos.nPara ).getTextBehindIndex( aPos.nIndex, aTextType );
// #112814# Adapt the start index with the paragraph offset
mpImpl->CorrectTextSegment( aResult, aPos.nPara );
}
return aResult;
}
sal_Bool SAL_CALL AccessibleStaticTextBase::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
{
SolarMutexGuard aGuard;
if( nStartIndex > nEndIndex )
::std::swap(nStartIndex, nEndIndex);
EPosition aStartIndex( mpImpl->Range2Internal(nStartIndex) );
EPosition aEndIndex( mpImpl->Range2Internal(nEndIndex) );
return mpImpl->CopyText( aStartIndex.nPara, aStartIndex.nIndex,
aEndIndex.nPara, aEndIndex.nIndex );
}
// XAccessibleTextAttributes
uno::Sequence< beans::PropertyValue > AccessibleStaticTextBase::getDefaultAttributes( const uno::Sequence< OUString >& RequestedAttributes ) throw (uno::RuntimeException)
{
// get the intersection of the default attributes of all paragraphs
SolarMutexGuard aGuard;
PropertyValueVector aDefAttrVec( mpImpl->GetParagraph( 0 ).getDefaultAttributes( RequestedAttributes ) );
const sal_Int32 nParaCount = mpImpl->GetParagraphCount();
for ( sal_Int32 nPara = 1; nPara < nParaCount; ++nPara )
{
uno::Sequence< beans::PropertyValue > aSeq = mpImpl->GetParagraph( nPara ).getDefaultAttributes( RequestedAttributes );
PropertyValueVector aIntersectionVec;
PropertyValueVector::const_iterator aEnd = aDefAttrVec.end();
for ( PropertyValueVector::const_iterator aItr = aDefAttrVec.begin(); aItr != aEnd; ++aItr )
{
const beans::PropertyValue* pItr = aSeq.getConstArray();
const beans::PropertyValue* pEnd = pItr + aSeq.getLength();
const beans::PropertyValue* pFind = ::std::find_if( pItr, pEnd, ::std::bind2nd( PropertyValueEqualFunctor(), boost::cref( *aItr ) ) );
if ( pFind != pEnd )
{
aIntersectionVec.push_back( *pFind );
}
}
aDefAttrVec.swap( aIntersectionVec );
if ( aDefAttrVec.empty() )
{
break;
}
}
return aDefAttrVec.getAsConstList();
}
uno::Sequence< beans::PropertyValue > SAL_CALL AccessibleStaticTextBase::getRunAttributes( sal_Int32 nIndex, const uno::Sequence< OUString >& RequestedAttributes ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
{
// get those default attributes of the paragraph, which are not part
// of the intersection of all paragraphs and add them to the run attributes
SolarMutexGuard aGuard;
EPosition aPos( mpImpl->Index2Internal( nIndex ) );
AccessibleEditableTextPara& rPara = mpImpl->GetParagraph( aPos.nPara );
uno::Sequence< beans::PropertyValue > aDefAttrSeq = rPara.getDefaultAttributes( RequestedAttributes );
uno::Sequence< beans::PropertyValue > aRunAttrSeq = rPara.getRunAttributes( aPos.nIndex, RequestedAttributes );
uno::Sequence< beans::PropertyValue > aIntersectionSeq = getDefaultAttributes( RequestedAttributes );
PropertyValueVector aDiffVec;
const beans::PropertyValue* pDefAttr = aDefAttrSeq.getConstArray();
const sal_Int32 nLength = aDefAttrSeq.getLength();
for ( sal_Int32 i = 0; i < nLength; ++i )
{
const beans::PropertyValue* pItr = aIntersectionSeq.getConstArray();
const beans::PropertyValue* pEnd = pItr + aIntersectionSeq.getLength();
const beans::PropertyValue* pFind = ::std::find_if( pItr, pEnd, ::std::bind2nd( PropertyValueEqualFunctor(), boost::cref( pDefAttr[i] ) ) );
if ( pFind == pEnd && pDefAttr[i].Handle != 0)
{
aDiffVec.push_back( pDefAttr[i] );
}
}
return ::comphelper::concatSequences( aRunAttrSeq, aDiffVec.getAsConstList() );
}
Rectangle AccessibleStaticTextBase::GetParagraphBoundingBox() const
{
return mpImpl->GetParagraphBoundingBox();
}
} // end of namespace accessibility
//------------------------------------------------------------------------
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */