a28db0efd2
... instead of 6 Change-Id: I27585734069f76d7d535c01760d0bd2085f51051 Reviewed-on: https://gerrit.libreoffice.org/c/core/+/183707 Tested-by: Jenkins Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
832 lines
26 KiB
C++
832 lines
26 KiB
C++
/* -*- 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/editdata.hxx>
|
|
#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: */
|