xref: /AOO41X/main/comphelper/source/misc/accessibletexthelper.cxx (revision dde7d3faf6dcd9cbeb7b48ba6d0cea5ffcc883d0)

/**************************************************************
 *
 * 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_comphelper.hxx"

// includes --------------------------------------------------------------
#include <comphelper/accessibletexthelper.hxx>
#include <com/sun/star/accessibility/AccessibleTextType.hpp>
#include <com/sun/star/i18n/CharacterIteratorMode.hpp>
#ifndef _COM_SUN_STAR_TEXT_WORDTYPE_HPP_
#include <com/sun/star/i18n/WordType.hpp>
#endif
#include <com/sun/star/i18n/KCharacterType.hpp>
#include <comphelper/processfactory.hxx>
#include <com/sun/star/accessibility/TextSegment.hpp>

#include <algorithm>

//..............................................................................
namespace comphelper
{
//..............................................................................

	using namespace ::com::sun::star;
	using namespace ::com::sun::star::uno;
	using namespace ::com::sun::star::lang;
	using namespace ::com::sun::star::beans;
	using namespace ::com::sun::star::accessibility;

	//==============================================================================
	// OCommonAccessibleText
	//==============================================================================

	OCommonAccessibleText::OCommonAccessibleText()
	{
	}

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

	OCommonAccessibleText::~OCommonAccessibleText()
	{
	}

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

	Reference < i18n::XBreakIterator > OCommonAccessibleText::implGetBreakIterator()
	{
		if ( !m_xBreakIter.is() )
		{
			Reference< lang::XMultiServiceFactory > xMSF = ::comphelper::getProcessServiceFactory();
			if ( xMSF.is() )
			{
				m_xBreakIter = Reference< i18n::XBreakIterator >
					( xMSF->createInstance( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.i18n.BreakIterator" ) ) ), UNO_QUERY );
			}
		}

		return m_xBreakIter;
	}

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

	Reference < i18n::XCharacterClassification > OCommonAccessibleText::implGetCharacterClassification()
	{
		if ( !m_xCharClass.is() )
		{
			Reference< lang::XMultiServiceFactory > xMSF = ::comphelper::getProcessServiceFactory();
			if ( xMSF.is() )
			{
				m_xCharClass = Reference< i18n::XCharacterClassification >
					( xMSF->createInstance( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.i18n.CharacterClassification" ) ) ), UNO_QUERY );
			}
		}

		return m_xCharClass;
	}

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

	sal_Bool OCommonAccessibleText::implIsValidBoundary( i18n::Boundary& rBoundary, sal_Int32 nLength )
	{
		return ( rBoundary.startPos >= 0 ) && ( rBoundary.startPos < nLength ) && ( rBoundary.endPos >= 0 ) && ( rBoundary.endPos <= nLength );
	}

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

	sal_Bool OCommonAccessibleText::implIsValidIndex( sal_Int32 nIndex, sal_Int32 nLength )
	{
		return ( nIndex >= 0 ) && ( nIndex < nLength );
	}

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

	sal_Bool OCommonAccessibleText::implIsValidRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex, sal_Int32 nLength )
	{
		return ( nStartIndex >= 0 ) && ( nStartIndex <= nLength ) && ( nEndIndex >= 0 ) && ( nEndIndex <= nLength );
	}

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

	void OCommonAccessibleText::implGetGlyphBoundary( i18n::Boundary& rBoundary, sal_Int32 nIndex )
	{
		::rtl::OUString sText( implGetText() );

		if ( implIsValidIndex( nIndex, sText.getLength() ) )
		{
			Reference < i18n::XBreakIterator > xBreakIter = implGetBreakIterator();
			if ( xBreakIter.is() )
			{
				sal_Int32 nCount = 1;
				sal_Int32 nDone;
				sal_Int32 nStartIndex = xBreakIter->previousCharacters( sText, nIndex, implGetLocale(), i18n::CharacterIteratorMode::SKIPCELL, nCount, nDone );
				if ( nDone != 0 )
					nStartIndex = xBreakIter->nextCharacters( sText, nStartIndex, implGetLocale(), i18n::CharacterIteratorMode::SKIPCELL, nCount, nDone );
				sal_Int32 nEndIndex = xBreakIter->nextCharacters( sText, nStartIndex, implGetLocale(), i18n::CharacterIteratorMode::SKIPCELL, nCount, nDone );
				if ( nDone != 0 )
				{
					rBoundary.startPos = nStartIndex;
					rBoundary.endPos = nEndIndex;
				}
			}
		}
		else
		{
			rBoundary.startPos = nIndex;
			rBoundary.endPos = nIndex;
		}
	}

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

	sal_Bool OCommonAccessibleText::implGetWordBoundary( i18n::Boundary& rBoundary, sal_Int32 nIndex )
	{
		sal_Bool bWord = sal_False;
		::rtl::OUString sText( implGetText() );

		if ( implIsValidIndex( nIndex, sText.getLength() ) )
		{
			Reference < i18n::XBreakIterator > xBreakIter = implGetBreakIterator();
			if ( xBreakIter.is() )
			{
				rBoundary = xBreakIter->getWordBoundary( sText, nIndex, implGetLocale(), i18n::WordType::ANY_WORD, sal_True );

				// it's a word, if the first character is an alpha-numeric character
				Reference< i18n::XCharacterClassification >	xCharClass = implGetCharacterClassification();
				if ( xCharClass.is() )
				{
					sal_Int32 nType = xCharClass->getCharacterType( sText, rBoundary.startPos, implGetLocale() );
					if ( ( nType & ( i18n::KCharacterType::LETTER | i18n::KCharacterType::DIGIT ) ) != 0 )
						bWord = sal_True;
				}
			}
		}
		else
		{
			rBoundary.startPos = nIndex;
			rBoundary.endPos = nIndex;
		}

		return bWord;
	}

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

	void OCommonAccessibleText::implGetSentenceBoundary( i18n::Boundary& rBoundary, sal_Int32 nIndex )
	{
		::rtl::OUString sText( implGetText() );

		if ( implIsValidIndex( nIndex, sText.getLength() ) )
		{
			Locale aLocale = implGetLocale();
			Reference < i18n::XBreakIterator > xBreakIter = implGetBreakIterator();
			if ( xBreakIter.is() )
			{
				rBoundary.endPos = xBreakIter->endOfSentence( sText, nIndex, aLocale );
				rBoundary.startPos = xBreakIter->beginOfSentence( sText, rBoundary.endPos, aLocale );
			}
		}
		else
		{
			rBoundary.startPos = nIndex;
			rBoundary.endPos = nIndex;
		}
	}

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

	void OCommonAccessibleText::implGetParagraphBoundary( i18n::Boundary& rBoundary, sal_Int32 nIndex )
	{
		::rtl::OUString sText( implGetText() );

		if ( implIsValidIndex( nIndex, sText.getLength() ) )
		{
			rBoundary.startPos = 0;
			rBoundary.endPos = sText.getLength();

			sal_Int32 nFound = sText.lastIndexOf( (sal_Unicode)'\n', nIndex );
			if ( nFound != -1 )
				rBoundary.startPos = nFound + 1;

			nFound = sText.indexOf( (sal_Unicode)'\n', nIndex );
			if ( nFound != -1 )
				rBoundary.endPos = nFound + 1;
		}
		else
		{
			rBoundary.startPos = nIndex;
			rBoundary.endPos = nIndex;
		}
	}

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

	void OCommonAccessibleText::implGetLineBoundary( i18n::Boundary& rBoundary, sal_Int32 nIndex )
	{
		::rtl::OUString sText( implGetText() );
		sal_Int32 nLength = sText.getLength();

		if ( implIsValidIndex( nIndex, nLength ) || nIndex == nLength )
		{
			rBoundary.startPos = 0;
			rBoundary.endPos = nLength;
		}
		else
		{
			rBoundary.startPos = nIndex;
			rBoundary.endPos = nIndex;
		}
	}

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

	sal_Unicode OCommonAccessibleText::getCharacter( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
	{
		::rtl::OUString sText( implGetText() );

		if ( !implIsValidIndex( nIndex, sText.getLength() ) )
			throw IndexOutOfBoundsException();

		return sText.getStr()[nIndex];
	}

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

	sal_Int32 OCommonAccessibleText::getCharacterCount() throw (RuntimeException)
	{
		return implGetText().getLength();
	}

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

	::rtl::OUString OCommonAccessibleText::getSelectedText() throw (RuntimeException)
	{
		::rtl::OUString sText;
		sal_Int32 nStartIndex;
		sal_Int32 nEndIndex;

		implGetSelection( nStartIndex, nEndIndex );

		try
		{
			sText = getTextRange( nStartIndex, nEndIndex );
		}
		catch ( IndexOutOfBoundsException& )
		{
		}

		return sText;
	}

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

	sal_Int32 OCommonAccessibleText::getSelectionStart() throw (RuntimeException)
	{
		sal_Int32 nStartIndex;
		sal_Int32 nEndIndex;

		implGetSelection( nStartIndex, nEndIndex );

		return nStartIndex;
	}

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

	sal_Int32 OCommonAccessibleText::getSelectionEnd() throw (RuntimeException)
	{
		sal_Int32 nStartIndex;
		sal_Int32 nEndIndex;

		implGetSelection( nStartIndex, nEndIndex );

		return nEndIndex;
	}

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

	::rtl::OUString OCommonAccessibleText::getText() throw (RuntimeException)
	{
		return implGetText();
	}

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

	::rtl::OUString OCommonAccessibleText::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException)
	{
		::rtl::OUString sText( implGetText() );

		if ( !implIsValidRange( nStartIndex, nEndIndex, sText.getLength() ) )
			throw IndexOutOfBoundsException();

		sal_Int32 nMinIndex = ::std::min( nStartIndex, nEndIndex );
		sal_Int32 nMaxIndex = ::std::max( nStartIndex, nEndIndex );

		return sText.copy( nMinIndex, nMaxIndex - nMinIndex );
	}

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

    TextSegment OCommonAccessibleText::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (IndexOutOfBoundsException, IllegalArgumentException, RuntimeException)
	{
		::rtl::OUString sText( implGetText() );
		sal_Int32 nLength = sText.getLength();

		if ( !implIsValidIndex( nIndex, nLength ) && nIndex != nLength )
			throw IndexOutOfBoundsException();

		i18n::Boundary aBoundary;
		TextSegment aResult;
		aResult.SegmentStart = -1;
		aResult.SegmentEnd = -1;

		switch ( aTextType )
		{
			case AccessibleTextType::CHARACTER:
			{
				if ( implIsValidIndex( nIndex, nLength ) )
				{
					aResult.SegmentText = sText.copy( nIndex, 1 );
					aResult.SegmentStart = nIndex;
					aResult.SegmentEnd = nIndex+1;
				}
			}
			break;
			case AccessibleTextType::GLYPH:
			{
				// get glyph at index
				implGetGlyphBoundary( aBoundary, nIndex );
				if ( implIsValidBoundary( aBoundary, nLength ) )
			    {
					aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
					aResult.SegmentStart = aBoundary.startPos;
					aResult.SegmentEnd = aBoundary.endPos;
				}
			}
			break;
			case AccessibleTextType::WORD:
			{
				// get word at index
				sal_Bool bWord = implGetWordBoundary( aBoundary, nIndex );
				if ( bWord && implIsValidBoundary( aBoundary, nLength ) )
				{
					aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
					aResult.SegmentStart = aBoundary.startPos;
					aResult.SegmentEnd = aBoundary.endPos;
				}
			}
			break;
			case AccessibleTextType::SENTENCE:
			{
				// get sentence at index
				implGetSentenceBoundary( aBoundary, nIndex );
				if ( implIsValidBoundary( aBoundary, nLength ) )
				{
					aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
					aResult.SegmentStart = aBoundary.startPos;
					aResult.SegmentEnd = aBoundary.endPos;
				}
			}
			break;
			case AccessibleTextType::PARAGRAPH:
			{
				// get paragraph at index
				implGetParagraphBoundary( aBoundary, nIndex );
				if ( implIsValidBoundary( aBoundary, nLength ) )
				{
					aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
					aResult.SegmentStart = aBoundary.startPos;
					aResult.SegmentEnd = aBoundary.endPos;
				}
			}
			break;
			case AccessibleTextType::LINE:
			{
				// get line at index
				implGetLineBoundary( aBoundary, nIndex );
				if ( implIsValidBoundary( aBoundary, nLength ) )
				{
					aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
					aResult.SegmentStart = aBoundary.startPos;
					aResult.SegmentEnd = aBoundary.endPos;
				}
			}
			break;
            case AccessibleTextType::ATTRIBUTE_RUN:
            {
                // TODO: implGetAttributeRunBoundary() (incompatible!)

                aResult.SegmentText = sText;
                aResult.SegmentStart = 0;
                aResult.SegmentEnd = nLength;
            }
            break;
			default:
			{
				// unknown text type
			}
		}

		return aResult;
	}

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

    TextSegment OCommonAccessibleText::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (IndexOutOfBoundsException, IllegalArgumentException, RuntimeException)
	{
		::rtl::OUString sText( implGetText() );
		sal_Int32 nLength = sText.getLength();

		if ( !implIsValidIndex( nIndex, nLength ) && nIndex != nLength )
			throw IndexOutOfBoundsException();

		i18n::Boundary aBoundary;
		TextSegment aResult;
		aResult.SegmentStart = -1;
		aResult.SegmentEnd = -1;

		switch ( aTextType )
		{
			case AccessibleTextType::CHARACTER:
			{
				if ( implIsValidIndex( nIndex - 1, nLength ) )
				{
					aResult.SegmentText = sText.copy( nIndex - 1, 1 );
					aResult.SegmentStart = nIndex-1;
					aResult.SegmentEnd = nIndex;
				}
			}
			break;
			case AccessibleTextType::GLYPH:
			{
				// get glyph at index
				implGetGlyphBoundary( aBoundary, nIndex );
				// get previous glyph
				if ( aBoundary.startPos > 0 )
				{
					implGetGlyphBoundary( aBoundary, aBoundary.startPos - 1 );
					if ( implIsValidBoundary( aBoundary, nLength ) )
					{
						aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
    					aResult.SegmentStart = aBoundary.startPos;
    					aResult.SegmentEnd = aBoundary.endPos;
					}
				}
			}
			break;
			case AccessibleTextType::WORD:
			{
				// get word at index
				implGetWordBoundary( aBoundary, nIndex );
				// get previous word
				sal_Bool bWord = sal_False;
				while ( !bWord && aBoundary.startPos > 0 )
					bWord = implGetWordBoundary( aBoundary, aBoundary.startPos - 1 );
				if ( bWord && implIsValidBoundary( aBoundary, nLength ) )
				{
					aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
					aResult.SegmentStart = aBoundary.startPos;
					aResult.SegmentEnd = aBoundary.endPos;
				}
			}
			break;
			case AccessibleTextType::SENTENCE:
			{
				// get sentence at index
				implGetSentenceBoundary( aBoundary, nIndex );
				// get previous sentence
				if ( aBoundary.startPos > 0 )
				{
					implGetSentenceBoundary( aBoundary, aBoundary.startPos - 1 );
					if ( implIsValidBoundary( aBoundary, nLength ) )
					{
						aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
    					aResult.SegmentStart = aBoundary.startPos;
    					aResult.SegmentEnd = aBoundary.endPos;
					}
				}
			}
			break;
			case AccessibleTextType::PARAGRAPH:
			{
				// get paragraph at index
				implGetParagraphBoundary( aBoundary, nIndex );
				// get previous paragraph
				if ( aBoundary.startPos > 0 )
				{
					implGetParagraphBoundary( aBoundary, aBoundary.startPos - 1 );
					if ( implIsValidBoundary( aBoundary, nLength ) )
					{
						aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
    					aResult.SegmentStart = aBoundary.startPos;
    					aResult.SegmentEnd = aBoundary.endPos;
					}
				}
			}
			break;
			case AccessibleTextType::LINE:
			{
				// get line at index
				implGetLineBoundary( aBoundary, nIndex );
				// get previous line
				if ( aBoundary.startPos > 0 )
				{
					implGetLineBoundary( aBoundary, aBoundary.startPos - 1 );
					if ( implIsValidBoundary( aBoundary, nLength ) )
					{
						aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
    					aResult.SegmentStart = aBoundary.startPos;
    					aResult.SegmentEnd = aBoundary.endPos;
					}
				}
			}
			break;
            case AccessibleTextType::ATTRIBUTE_RUN:
            {
                // TODO: implGetAttributeRunBoundary() (incompatible!)
            }
            break;
			default:
			{
				// unknown text type
			}
		}

		return aResult;
	}

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

    TextSegment OCommonAccessibleText::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (IndexOutOfBoundsException, IllegalArgumentException, RuntimeException)
	{
		::rtl::OUString sText( implGetText() );
		sal_Int32 nLength = sText.getLength();

		if ( !implIsValidIndex( nIndex, nLength ) && nIndex != nLength )
			throw IndexOutOfBoundsException();

		i18n::Boundary aBoundary;
		TextSegment aResult;
		aResult.SegmentStart = -1;
		aResult.SegmentEnd = -1;

		switch ( aTextType )
		{
			case AccessibleTextType::CHARACTER:
			{
				if ( implIsValidIndex( nIndex + 1, nLength ) )
			    {
					aResult.SegmentText = sText.copy( nIndex + 1, 1 );
					aResult.SegmentStart = nIndex+1;
					aResult.SegmentEnd = nIndex+2;
				}
			}
			break;
			case AccessibleTextType::GLYPH:
			{
				// get glyph at index
				implGetGlyphBoundary( aBoundary, nIndex );
				// get next glyph
				if ( aBoundary.endPos < nLength )
				{
					implGetGlyphBoundary( aBoundary, aBoundary.endPos );
					if ( implIsValidBoundary( aBoundary, nLength ) )
					{
						aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
    					aResult.SegmentStart = aBoundary.startPos;
    					aResult.SegmentEnd = aBoundary.endPos;
					}
				}
			}
			break;
			case AccessibleTextType::WORD:
			{
				// get word at index
				implGetWordBoundary( aBoundary, nIndex );
				// get next word
				sal_Bool bWord = sal_False;
				while ( !bWord && aBoundary.endPos < nLength )
					bWord = implGetWordBoundary( aBoundary, aBoundary.endPos );
				if ( bWord && implIsValidBoundary( aBoundary, nLength ) )
				{
					aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
					aResult.SegmentStart = aBoundary.startPos;
					aResult.SegmentEnd = aBoundary.endPos;
				}
			}
			break;
			case AccessibleTextType::SENTENCE:
			{
				// get sentence at index
				implGetSentenceBoundary( aBoundary, nIndex );
				// get next sentence
				sal_Int32 nEnd = aBoundary.endPos;
				sal_Int32 nI = aBoundary.endPos;
				sal_Bool bFound = sal_False;
				while ( !bFound && ++nI < nLength )
				{
					implGetSentenceBoundary( aBoundary, nI );
					bFound = ( aBoundary.endPos > nEnd );
				}
				if ( bFound && implIsValidBoundary( aBoundary, nLength ) )
				{
					aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
					aResult.SegmentStart = aBoundary.startPos;
					aResult.SegmentEnd = aBoundary.endPos;
				}
			}
			break;
			case AccessibleTextType::PARAGRAPH:
			{
				// get paragraph at index
				implGetParagraphBoundary( aBoundary, nIndex );
				// get next paragraph
				if ( aBoundary.endPos < nLength )
				{
					implGetParagraphBoundary( aBoundary, aBoundary.endPos );
					if ( implIsValidBoundary( aBoundary, nLength ) )
					{
						aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
    					aResult.SegmentStart = aBoundary.startPos;
    					aResult.SegmentEnd = aBoundary.endPos;
					}
				}
			}
			break;
			case AccessibleTextType::LINE:
			{
				// get line at index
				implGetLineBoundary( aBoundary, nIndex );
				// get next line
				if ( aBoundary.endPos < nLength )
				{
					implGetLineBoundary( aBoundary, aBoundary.endPos );
					if ( implIsValidBoundary( aBoundary, nLength ) )
					{
						aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
    					aResult.SegmentStart = aBoundary.startPos;
    					aResult.SegmentEnd = aBoundary.endPos;
					}
				}
			}
			break;
            case AccessibleTextType::ATTRIBUTE_RUN:
            {
                // TODO: implGetAttributeRunBoundary() (incompatible!)
            }
            break;
			default:
			{
				// unknown text type
			}
		}

		return aResult;
	}

    // -----------------------------------------------------------------------------
    bool OCommonAccessibleText::implInitTextChangedEvent(
        const rtl::OUString& rOldString,
        const rtl::OUString& rNewString,
        ::com::sun::star::uno::Any& rDeleted,
        ::com::sun::star::uno::Any& rInserted) // throw()
    {
        sal_uInt32 nLenOld = rOldString.getLength();
        sal_uInt32 nLenNew = rNewString.getLength();

        // equal
        if ((0 == nLenOld) && (0 == nLenNew))
            return false;

        TextSegment aDeletedText;
        TextSegment aInsertedText;

        aDeletedText.SegmentStart = -1;
        aDeletedText.SegmentEnd = -1;
        aInsertedText.SegmentStart = -1;
        aInsertedText.SegmentEnd = -1;

        // insert only
        if ((0 == nLenOld) && (nLenNew > 0))
        {
            aInsertedText.SegmentStart = 0;
            aInsertedText.SegmentEnd = nLenNew;
            aInsertedText.SegmentText = rNewString.copy( aInsertedText.SegmentStart, aInsertedText.SegmentEnd - aInsertedText.SegmentStart );

            rInserted <<= aInsertedText;
            return true;
        }

        // delete only
        if ((nLenOld > 0) && (0 == nLenNew))
        {
            aDeletedText.SegmentStart = 0;
            aDeletedText.SegmentEnd = nLenOld;
            aDeletedText.SegmentText = rOldString.copy( aDeletedText.SegmentStart, aDeletedText.SegmentEnd - aDeletedText.SegmentStart );

            rDeleted <<= aDeletedText;
            return true;
        }

        const sal_Unicode* pFirstDiffOld = rOldString.getStr();
        const sal_Unicode* pLastDiffOld  = rOldString.getStr() + nLenOld;
        const sal_Unicode* pFirstDiffNew = rNewString.getStr();
        const sal_Unicode* pLastDiffNew  = rNewString.getStr() + nLenNew;

        // find first difference
        while ((*pFirstDiffOld == *pFirstDiffNew) &&
               (pFirstDiffOld  <  pLastDiffOld) &&
               (pFirstDiffNew  <  pLastDiffNew))
        {
            pFirstDiffOld++;
            pFirstDiffNew++;
        }

        // equality test
        if ((0 == *pFirstDiffOld) && (0 == *pFirstDiffNew))
            return false;

        // find last difference
        while ( ( pLastDiffOld > pFirstDiffOld) &&
                ( pLastDiffNew > pFirstDiffNew) &&
                (pLastDiffOld[-1]  == pLastDiffNew[-1]))
        {
            pLastDiffOld--;
            pLastDiffNew--;
        }

        if (pFirstDiffOld < pLastDiffOld)
        {
            aDeletedText.SegmentStart = pFirstDiffOld - rOldString.getStr();
            aDeletedText.SegmentEnd = pLastDiffOld  - rOldString.getStr();
            aDeletedText.SegmentText = rOldString.copy( aDeletedText.SegmentStart, aDeletedText.SegmentEnd - aDeletedText.SegmentStart );

            rDeleted <<= aDeletedText;
        }

        if (pFirstDiffNew < pLastDiffNew)
        {
            aInsertedText.SegmentStart = pFirstDiffNew - rNewString.getStr();
            aInsertedText.SegmentEnd = pLastDiffNew  - rNewString.getStr();
            aInsertedText.SegmentText = rNewString.copy( aInsertedText.SegmentStart, aInsertedText.SegmentEnd - aInsertedText.SegmentStart );

            rInserted <<= aInsertedText;
        }
        return true;
    }

	//==============================================================================
	// OAccessibleTextHelper
	//==============================================================================

	OAccessibleTextHelper::OAccessibleTextHelper()
	{
	}

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

	OAccessibleTextHelper::OAccessibleTextHelper( IMutex* _pExternalLock )
		:OAccessibleExtendedComponentHelper( _pExternalLock )
	{
	}

	// -----------------------------------------------------------------------------
	// XInterface
	// -----------------------------------------------------------------------------

	IMPLEMENT_FORWARD_XINTERFACE2( OAccessibleTextHelper, OAccessibleExtendedComponentHelper, OAccessibleTextHelper_Base )

	// -----------------------------------------------------------------------------
	// XTypeProvider
	// -----------------------------------------------------------------------------

	IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleTextHelper, OAccessibleExtendedComponentHelper, OAccessibleTextHelper_Base )

	// -----------------------------------------------------------------------------
	// XAccessibleText
	// -----------------------------------------------------------------------------

	sal_Unicode OAccessibleTextHelper::getCharacter( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
	{
		OExternalLockGuard aGuard( this );

		return OCommonAccessibleText::getCharacter( nIndex );
	}

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

	sal_Int32 OAccessibleTextHelper::getCharacterCount() throw (RuntimeException)
	{
		OExternalLockGuard aGuard( this );

		return OCommonAccessibleText::getCharacterCount();
	}

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

	::rtl::OUString OAccessibleTextHelper::getSelectedText() throw (RuntimeException)
	{
		OExternalLockGuard aGuard( this );

		return OCommonAccessibleText::getSelectedText();
	}

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

	sal_Int32 OAccessibleTextHelper::getSelectionStart() throw (RuntimeException)
	{
		OExternalLockGuard aGuard( this );

		return OCommonAccessibleText::getSelectionStart();
	}

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

	sal_Int32 OAccessibleTextHelper::getSelectionEnd() throw (RuntimeException)
	{
		OExternalLockGuard aGuard( this );

		return OCommonAccessibleText::getSelectionEnd();
	}

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

	::rtl::OUString OAccessibleTextHelper::getText() throw (RuntimeException)
	{
		OExternalLockGuard aGuard( this );

		return OCommonAccessibleText::getText();
	}

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

	::rtl::OUString OAccessibleTextHelper::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException)
	{
		OExternalLockGuard aGuard( this );

		return OCommonAccessibleText::getTextRange( nStartIndex, nEndIndex );
	}

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

    TextSegment OAccessibleTextHelper::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (IndexOutOfBoundsException, IllegalArgumentException, RuntimeException)
	{
		OExternalLockGuard aGuard( this );

		return OCommonAccessibleText::getTextAtIndex( nIndex, aTextType );
	}

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

    TextSegment OAccessibleTextHelper::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (IndexOutOfBoundsException, IllegalArgumentException, RuntimeException)
	{
		OExternalLockGuard aGuard( this );

		return OCommonAccessibleText::getTextBeforeIndex( nIndex, aTextType );
	}

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

    TextSegment OAccessibleTextHelper::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (IndexOutOfBoundsException, IllegalArgumentException, RuntimeException)
	{
		OExternalLockGuard aGuard( this );

		return OCommonAccessibleText::getTextBehindIndex( nIndex, aTextType );
	}

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

//..............................................................................
}	// namespace comphelper
//..............................................................................