/* -*- 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 <utility>
#include <memory>
#include <vector>
#include <algorithm>
#include <rtl/ustrbuf.hxx>
#include <tools/debug.hxx>
#include <vcl/svapp.hxx>
#include <vcl/unohelp.hxx>
#include <comphelper/sequence.hxx>
#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
#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/AccessibleStaticTextBase.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 std::vector< beans::PropertyValue > PropertyValueVector;
 
namespace {
 
class PropertyValueEqualFunctor
{
    const beans::PropertyValue& m_rPValue;
 
public:
    explicit PropertyValueEqualFunctor(const beans::PropertyValue& rPValue)
        : m_rPValue(rPValue)
    {}
    bool operator() ( const beans::PropertyValue& rhs ) const
    {
        return ( m_rPValue.Name == rhs.Name && m_rPValue.Value == rhs.Value );
    }
};
 
}
 
sal_Unicode const cNewLine(0x0a);
 
 
// Static Helper
 
 
static ESelection MakeSelection( sal_Int32 nStartPara, sal_Int32 nStartIndex,
                          sal_Int32 nEndPara, sal_Int32 nEndIndex )
{
    DBG_ASSERT(nStartPara >= 0 &&
               nStartIndex >= 0 &&
               nEndPara >= 0 &&
               nEndIndex >= 0,
               "AccessibleStaticTextBase_Impl::MakeSelection: index value overflow");
 
    return ESelection(nStartPara, nStartIndex, nEndPara, nEndIndex);
}
 
 
AccessibleEditableTextPara& AccessibleStaticTextBase::GetParagraph( sal_Int32 nPara ) const
{
 
    if( !mxTextParagraph.is() )
        throw lang::DisposedException (u"object has been already disposed"_ustr);
 
    // TODO: Have a different method on AccessibleEditableTextPara
    // that does not care about state changes
    mxTextParagraph->SetParagraphIndex( nPara );
 
    return *mxTextParagraph;
}
 
sal_Int32 AccessibleStaticTextBase::GetParagraphCount() const
{
 
    if( !mxTextParagraph.is() )
        return 0;
    else
        return mxTextParagraph->GetTextForwarder().GetParagraphCount();
}
 
sal_Int32 AccessibleStaticTextBase::Internal2Index(EPaM 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::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;
    }
}
 
EPaM AccessibleStaticTextBase::ImpCalcInternal(sal_Int32 nFlatIndex, bool bExclusive) const
{
 
    if( nFlatIndex < 0 )
        throw lang::IndexOutOfBoundsException(u"AccessibleStaticTextBase_Impl::Index2Internal: character index out of bounds"_ustr);
    // 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 &&
                       nFlatIndex - nCurrIndex + nCurrCount >= 0,
                       "AccessibleStaticTextBase::Index2Internal: index value overflow");
 
            return EPaM(nCurrPara, nFlatIndex - nCurrIndex + nCurrCount);
        }
    }
 
    // #102170# Allow one-past the end for ranges
    if( bExclusive && nCurrIndex == nFlatIndex )
    {
        // check overflow
        DBG_ASSERT(nCurrPara > 0 &&
                   nFlatIndex - nCurrIndex + nCurrCount >= 0,
                   "AccessibleStaticTextBase::Index2Internal: index value overflow");
 
        return EPaM(nCurrPara - 1, nFlatIndex - nCurrIndex + nCurrCount);
    }
 
    // not found? Out of bounds
    throw lang::IndexOutOfBoundsException(u"AccessibleStaticTextBase::Index2Internal: character index out of bounds"_ustr);
}
 
bool AccessibleStaticTextBase::SetSelection( sal_Int32 nStartPara, sal_Int32 nStartIndex,
                                                      sal_Int32 nEndPara, sal_Int32 nEndIndex )
{
 
    if( !mxTextParagraph.is() )
        return false;
 
    try
    {
        SvxEditViewForwarder& rCacheVF = mxTextParagraph->GetEditViewForwarder( true );
        return rCacheVF.SetSelection( MakeSelection(nStartPara, nStartIndex, nEndPara, nEndIndex) );
    }
    catch( const uno::RuntimeException& )
    {
        return false;
    }
}
 
bool AccessibleStaticTextBase::CopyText( sal_Int32 nStartPara, sal_Int32 nStartIndex,
                                                  sal_Int32 nEndPara, sal_Int32 nEndIndex )
{
 
    if( !mxTextParagraph.is() )
        return false;
 
    try
    {
        SvxEditViewForwarder& rCacheVF = mxTextParagraph->GetEditViewForwarder( true );
        mxTextParagraph->GetTextForwarder();    // MUST be after GetEditViewForwarder(), see method docs
        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 false;
    }
}
 
//the input argument is the index(including "\n" ) in the string.
//the function will calculate the actual index(not including "\n") in the string.
//and return true if the index is just at a "\n"
bool AccessibleStaticTextBase::RemoveLineBreakCount( sal_Int32& rIndex )
{
    // get the total char number inside the cell.
    sal_Int32 i, nCount, nParas;
    for( i=0, nCount=0, nParas=GetParagraphCount(); i<nParas; ++i )
        nCount += GetParagraph(i).getCharacterCount();
    nCount = nCount + (nParas-1);
    if( nCount == 0 &&  rIndex == 0) return false;
 
 
    sal_Int32 nCurrPara, nCurrCount;
    sal_Int32 nLineBreakPos = 0, nLineBreakCount = 0;
    sal_Int32 nParaCount = GetParagraphCount();
    for ( nCurrCount = 0, nCurrPara = 0; nCurrPara < nParaCount; nCurrPara++ )
    {
        nCurrCount += GetParagraph( nCurrPara ).getCharacterCount();
        nLineBreakPos = nCurrCount++;
        if ( rIndex == nLineBreakPos )
        {
            rIndex -= (++nLineBreakCount);//(++nLineBreakCount);
            if ( rIndex < 0)
            {
                rIndex = 0;
            }
            //if the index is at the last position of the last paragraph
            //there is no "\n" , so we should increase rIndex by 1 and return false.
            if ( (nCurrPara+1) == nParaCount )
            {
                rIndex++;
                return false;
            }
            else
            {
                return true;
            }
        }
        else if ( rIndex < nLineBreakPos )
        {
            rIndex -= nLineBreakCount;
            return false;
        }
        else
        {
            nLineBreakCount++;
        }
    }
    return false;
}
 
AccessibleStaticTextBase::AccessibleStaticTextBase(std::unique_ptr<SvxEditSource>&& pEditSource)
    // TODO: this is still somewhat of a hack, all the more since
    // now the maTextParagraph has an empty parent reference set
    : mxTextParagraph(new AccessibleEditableTextPara(nullptr))
{
    SolarMutexGuard aGuard;
 
    SetEditSource( std::move(pEditSource) );
}
 
AccessibleStaticTextBase::~AccessibleStaticTextBase()
{
}
 
void AccessibleStaticTextBase::SetEditSource( std::unique_ptr< SvxEditSource > && pEditSource )
{
    // precondition: solar mutex locked
    DBG_TESTSOLARMUTEX();
 
    maEditSource.SetEditSource(std::move(pEditSource));
    if (mxTextParagraph.is())
        mxTextParagraph->SetEditSource(&maEditSource);
}
 
void AccessibleStaticTextBase::SetOffset( const Point& rPoint )
{
    // precondition: solar mutex locked
    DBG_TESTSOLARMUTEX();
 
    if (mxTextParagraph.is())
        mxTextParagraph->SetEEOffset(rPoint);
}
 
void AccessibleStaticTextBase::Dispose()
{
    // we're the owner of the paragraph, so destroy it, too
    if (mxTextParagraph.is())
        mxTextParagraph->dispose();
 
    // drop reference
    mxTextParagraph.clear();
}
 
// XAccessibleContext
sal_Int64 AccessibleStaticTextBase::getAccessibleChildCount()
{
    // no children at all
    return 0;
}
 
uno::Reference< XAccessible > AccessibleStaticTextBase::getAccessibleChild( sal_Int64 /*i*/ )
{
    // no children at all
    return uno::Reference< XAccessible >();
}
 
uno::Reference< XAccessible > AccessibleStaticTextBase::getAccessibleAtPoint( const awt::Point& /*_aPoint*/ )
{
    // no children at all
    return uno::Reference< XAccessible >();
}
 
// XAccessibleText
sal_Int32 SAL_CALL AccessibleStaticTextBase::getCaretPosition()
{
    SolarMutexGuard aGuard;
 
    sal_Int32 i, nPos, nParas;
    for (i = 0, nPos = -1, nParas = GetParagraphCount(); i<nParas; ++i )
    {
        if ((nPos = GetParagraph(i).getCaretPosition()) != -1)
            return nPos;
    }
 
    return nPos;
}
 
sal_Bool SAL_CALL AccessibleStaticTextBase::setCaretPosition( sal_Int32 nIndex )
{
    return setSelection(nIndex, nIndex);
}
 
sal_Unicode SAL_CALL AccessibleStaticTextBase::getCharacter( sal_Int32 nIndex )
{
    SolarMutexGuard aGuard;
 
    EPaM aPos(Index2Internal(nIndex));
 
    return GetParagraph(aPos.nPara).getCharacter(aPos.nIndex);
}
 
uno::Sequence< beans::PropertyValue > SAL_CALL AccessibleStaticTextBase::getCharacterAttributes( sal_Int32 nIndex, const css::uno::Sequence< OUString >& aRequestedAttributes )
{
    SolarMutexGuard aGuard;
 
    //get the actual index without "\n"
    RemoveLineBreakCount(nIndex);
 
    EPaM aPos(Index2Internal(nIndex));
 
    return GetParagraph( aPos.nPara ).getCharacterAttributes( aPos.nIndex, aRequestedAttributes );
}
 
awt::Rectangle SAL_CALL AccessibleStaticTextBase::getCharacterBounds( sal_Int32 nIndex )
{
    SolarMutexGuard aGuard;
 
    // #108900# Allow ranges for nIndex, as one-past-the-end
    // values are now legal, too.
    EPaM aPos(Range2Internal(nIndex));
 
    // #i70916# Text in spread sheet cells return the wrong extents
    AccessibleEditableTextPara& rPara = 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()
{
    SolarMutexGuard aGuard;
 
    sal_Int32 i, nCount, nParas;
    for (i = 0, nCount = 0, nParas = GetParagraphCount(); i < nParas; ++i)
        nCount += GetParagraph(i).getCharacterCount();
    //count on the number of "\n" which equals number of paragraphs decrease 1.
    nCount = nCount + (nParas-1);
    return nCount;
}
 
sal_Int32 SAL_CALL AccessibleStaticTextBase::getIndexAtPoint( const awt::Point& rPoint )
{
    SolarMutexGuard aGuard;
 
    const sal_Int32 nParas(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 = 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 Internal2Index(EPaM(i, nIndex));
    }
 
    return -1;
}
 
OUString SAL_CALL AccessibleStaticTextBase::getSelectedText()
{
    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()
{
    SolarMutexGuard aGuard;
 
    sal_Int32 i, nPos, nParas;
    for (i = 0, nPos = -1, nParas = GetParagraphCount(); i < nParas; ++i)
    {
        if ((nPos=GetParagraph(i).getSelectionStart()) != -1)
            return nPos;
    }
 
    return nPos;
}
 
sal_Int32 SAL_CALL AccessibleStaticTextBase::getSelectionEnd()
{
    SolarMutexGuard aGuard;
 
    sal_Int32 i, nPos, nParas;
    for (i = 0, nPos = -1, nParas = GetParagraphCount(); i < nParas; ++i)
    {
        if ((nPos = GetParagraph(i).getSelectionEnd()) != -1)
            return nPos;
    }
 
    return nPos;
}
 
sal_Bool SAL_CALL AccessibleStaticTextBase::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
{
    SolarMutexGuard aGuard;
 
    EPaM aStartIndex(Range2Internal(nStartIndex));
    EPaM aEndIndex(Range2Internal(nEndIndex));
 
    return SetSelection(aStartIndex.nPara, aStartIndex.nIndex,
                        aEndIndex.nPara, aEndIndex.nIndex);
}
 
OUString SAL_CALL AccessibleStaticTextBase::getText()
{
    SolarMutexGuard aGuard;
 
    sal_Int32 i, nParas;
    OUStringBuffer aRes;
    for (i = 0, nParas = GetParagraphCount(); i < nParas; ++i)
        aRes.append(GetParagraph(i).getText());
 
    return aRes.makeStringAndClear();
}
 
OUString SAL_CALL AccessibleStaticTextBase::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
{
    SolarMutexGuard aGuard;
 
    if( nStartIndex > nEndIndex )
        std::swap(nStartIndex, nEndIndex);
    //if startindex equals endindex we will get nothing. So return an empty string directly.
    if ( nStartIndex == nEndIndex )
    {
        return OUString();
    }
    bool bStart = RemoveLineBreakCount(nStartIndex);
    //if the start index is just at a "\n", we need to begin from the next char
    if ( bStart )
    {
        nStartIndex++;
    }
    //we need to find out whether the previous position of the current endindex is at "\n" or not
    //if yes we need to mark it and add "\n" at the end of the result
    sal_Int32 nTemp = nEndIndex - 1;
    bool bEnd = RemoveLineBreakCount(nTemp);
    bool bTemp = RemoveLineBreakCount(nEndIndex);
    //if the below condition is true it indicates an empty paragraph with just a "\n"
    //so we need to set one "\n" flag to avoid duplication.
    if ( bStart && bEnd && ( nStartIndex == nEndIndex) )
    {
        bEnd = false;
    }
    //if the current endindex is at a "\n", we need to increase endindex by 1 to make sure
    //the char before "\n" is included. Because string returned by this function will not include
    //the char at the endindex.
    if ( bTemp )
    {
        nEndIndex++;
    }
    OUStringBuffer aRes;
    EPaM aStartIndex(Range2Internal(nStartIndex));
    EPaM aEndIndex(Range2Internal(nEndIndex));
 
    // #102170# Special case: start and end paragraph are identical
    if( aStartIndex.nPara == aEndIndex.nPara )
    {
        //we don't return the string directly now for that we have to do some further process for "\n"
        aRes = GetParagraph( aStartIndex.nPara ).getTextRange( aStartIndex.nIndex, aEndIndex.nIndex );
    }
    else
    {
        sal_Int32 i( aStartIndex.nPara );
        aRes = GetParagraph(i).getTextRange(aStartIndex.nIndex,
                                            GetParagraph(i).getCharacterCount()/*-1*/);
        ++i;
 
        // paragraphs inbetween are fully included
        for( ; i<aEndIndex.nPara; ++i )
        {
            aRes.append(OUStringChar(cNewLine) + GetParagraph(i).getText());
        }
 
        if( i<=aEndIndex.nPara )
        {
            //if the below condition is matched it means that endindex is at mid of the last paragraph
            //we need to add a "\n" before we add the last part of the string.
            if ( !bEnd && aEndIndex.nIndex )
            {
                aRes.append(cNewLine);
            }
            aRes.append(GetParagraph(i).getTextRange( 0, aEndIndex.nIndex ));
        }
    }
    //According to the flag we marked before, we have to add "\n" at the beginning
    //or at the end of the result string.
    if ( bStart )
    {
        aRes.insert(0, OUStringChar(cNewLine));
    }
    if ( bEnd )
    {
        aRes.append(OUStringChar(cNewLine));
    }
    return aRes.makeStringAndClear();
}
 
css::accessibility::TextSegment SAL_CALL AccessibleStaticTextBase::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType )
{
    SolarMutexGuard aGuard;
 
    bool bLineBreak = RemoveLineBreakCount(nIndex);
    EPaM aPos(Range2Internal(nIndex));
 
    css::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 = GetParagraph( aPos.nPara ).getText();
 
        // #112814# Adapt the start index with the paragraph offset
        aResult.SegmentStart = Internal2Index(EPaM(aPos.nPara, 0));
        aResult.SegmentEnd = aResult.SegmentStart + aResult.SegmentText.getLength();
    }
    else if ( AccessibleTextType::ATTRIBUTE_RUN == aTextType )
    {
        SvxAccessibleTextAdapter& rTextForwarder = GetParagraph( aPos.nIndex ).GetTextForwarder();
        sal_Int32 nStartIndex, nEndIndex;
        if ( rTextForwarder.GetAttributeRun( nStartIndex, nEndIndex, aPos.nPara, aPos.nIndex, true ) )
        {
            aResult.SegmentText = getTextRange( nStartIndex, nEndIndex );
            aResult.SegmentStart = nStartIndex;
            aResult.SegmentEnd = nEndIndex;
        }
    }
    else
    {
        // No special handling required, forward to wrapped class
        aResult = GetParagraph( aPos.nPara ).getTextAtIndex( aPos.nIndex, aTextType );
 
        // #112814# Adapt the start index with the paragraph offset
        CorrectTextSegment( aResult, aPos.nPara );
        if ( bLineBreak )
        {
            aResult.SegmentText = OUString(cNewLine);
        }
    }
 
    return aResult;
}
 
css::accessibility::TextSegment SAL_CALL AccessibleStaticTextBase::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType )
{
    SolarMutexGuard aGuard;
 
    sal_Int32 nOldIdx = nIndex;
    bool bLineBreak =  RemoveLineBreakCount(nIndex);
    EPaM aPos(Range2Internal(nIndex));
 
    css::accessibility::TextSegment aResult;
 
    if( AccessibleTextType::PARAGRAPH == aTextType )
    {
        if( aPos.nIndex == GetParagraph( aPos.nPara ).getCharacterCount() )
        {
            // #103589# Special casing one behind the last paragraph
            aResult.SegmentText = GetParagraph( aPos.nPara ).getText();
 
            // #112814# Adapt the start index with the paragraph offset
            aResult.SegmentStart = Internal2Index(EPaM(aPos.nPara, 0));
        }
        else if( aPos.nPara > 0 )
        {
            aResult.SegmentText = GetParagraph( aPos.nPara - 1 ).getText();
 
            // #112814# Adapt the start index with the paragraph offset
            aResult.SegmentStart = Internal2Index(EPaM(aPos.nPara - 1, 0));
        }
 
        aResult.SegmentEnd = aResult.SegmentStart + aResult.SegmentText.getLength();
    }
    else
    {
        // No special handling required, forward to wrapped class
        aResult = GetParagraph( aPos.nPara ).getTextBeforeIndex( aPos.nIndex, aTextType );
 
        // #112814# Adapt the start index with the paragraph offset
        CorrectTextSegment( aResult, aPos.nPara );
        if ( bLineBreak && (nOldIdx-1) >= 0)
        {
            aResult = getTextAtIndex( nOldIdx-1, aTextType );
        }
    }
 
    return aResult;
}
 
css::accessibility::TextSegment SAL_CALL AccessibleStaticTextBase::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType )
{
    SolarMutexGuard aGuard;
 
    sal_Int32 nTemp = nIndex+1;
    bool bLineBreak = RemoveLineBreakCount(nTemp);
    RemoveLineBreakCount(nIndex);
    EPaM aPos(Range2Internal(nIndex));
 
    css::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 < GetParagraphCount())
        {
            aResult.SegmentText = GetParagraph( aPos.nPara + 1 ).getText();
 
            // #112814# Adapt the start index with the paragraph offset
            aResult.SegmentStart = Internal2Index(EPaM(aPos.nPara + 1, 0));
            aResult.SegmentEnd = aResult.SegmentStart + aResult.SegmentText.getLength();
        }
    }
    else
    {
        // No special handling required, forward to wrapped class
        aResult = GetParagraph( aPos.nPara ).getTextBehindIndex( aPos.nIndex, aTextType );
 
        // #112814# Adapt the start index with the paragraph offset
        CorrectTextSegment( aResult, aPos.nPara );
        if ( bLineBreak )
        {
            aResult.SegmentText = OUStringChar(cNewLine) + aResult.SegmentText;
        }
   }
 
    return aResult;
}
 
sal_Bool SAL_CALL AccessibleStaticTextBase::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
{
    SolarMutexGuard aGuard;
 
    if( nStartIndex > nEndIndex )
        std::swap(nStartIndex, nEndIndex);
 
    EPaM aStartIndex(Range2Internal(nStartIndex));
    EPaM aEndIndex(Range2Internal(nEndIndex));
 
    return CopyText(aStartIndex.nPara, aStartIndex.nIndex, aEndIndex.nPara, aEndIndex.nIndex);
}
 
sal_Bool SAL_CALL AccessibleStaticTextBase::scrollSubstringTo( sal_Int32, sal_Int32, AccessibleScrollType )
{
    return false;
}
 
// XAccessibleTextAttributes
uno::Sequence< beans::PropertyValue > AccessibleStaticTextBase::getDefaultAttributes( const uno::Sequence< OUString >& RequestedAttributes )
{
    // get the intersection of the default attributes of all paragraphs
 
    SolarMutexGuard aGuard;
 
    PropertyValueVector aDefAttrVec(
            comphelper::sequenceToContainer<PropertyValueVector>(GetParagraph( 0 ).getDefaultAttributes( RequestedAttributes )) );
 
    const sal_Int32 nParaCount = GetParagraphCount();
    for ( sal_Int32 nPara = 1; nPara < nParaCount; ++nPara )
    {
        uno::Sequence< beans::PropertyValue > aSeq = GetParagraph( nPara ).getDefaultAttributes( RequestedAttributes );
        PropertyValueVector aIntersectionVec;
 
        for ( const auto& rDefAttr : aDefAttrVec )
        {
            auto it = std::find_if(aSeq.begin(), aSeq.end(), PropertyValueEqualFunctor(rDefAttr));
            if (it != aSeq.end())
                aIntersectionVec.push_back(*it);
        }
 
        aDefAttrVec.swap( aIntersectionVec );
 
        if ( aDefAttrVec.empty() )
        {
            break;
        }
    }
 
    return comphelper::containerToSequence(aDefAttrVec);
}
 
uno::Sequence< beans::PropertyValue > SAL_CALL AccessibleStaticTextBase::getRunAttributes( sal_Int32 nIndex, const uno::Sequence< OUString >& RequestedAttributes )
{
    // 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;
 
    EPaM aPos(Index2Internal(nIndex));
    AccessibleEditableTextPara& rPara = 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;
 
    for (auto& defAttr : aDefAttrSeq)
    {
        bool bNone = std::none_of(aIntersectionSeq.begin(), aIntersectionSeq.end(),
                                  PropertyValueEqualFunctor(defAttr));
        if (bNone && defAttr.Handle != 0)
        {
            aDiffVec.push_back(defAttr);
        }
    }
 
    return comphelper::concatSequences(aRunAttrSeq, aDiffVec);
}
 
tools::Rectangle AccessibleStaticTextBase::GetParagraphBoundingBox() const
{
    if (!mxTextParagraph.is())
        return tools::Rectangle();
 
    awt::Rectangle aAwtRect = mxTextParagraph->getBounds();
    return vcl::unohelper::ConvertToVCLRect(aAwtRect);
}
 
}  // end of namespace accessibility
 
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */