comphelper/source/misc/accessibletexthelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: accessibletexthelper.cxx,v $
  10  * $Revision: 1.9 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_comphelper.hxx"
  33
  34 // includes --------------------------------------------------------------
  35 #include <comphelper/accessibletexthelper.hxx>
  36 #include <com/sun/star/accessibility/AccessibleTextType.hpp>
  37 #include <com/sun/star/i18n/CharacterIteratorMode.hpp>
  38 #ifndef _COM_SUN_STAR_TEXT_WORDTYPE_HPP_
  39 #include <com/sun/star/i18n/WordType.hpp>
  40 #endif
  41 #include <com/sun/star/i18n/KCharacterType.hpp>
  42 #include <comphelper/processfactory.hxx>
  43 #include <com/sun/star/accessibility/TextSegment.hpp>
  44
  45 #include <algorithm>
  46
  47 //..............................................................................
  48 namespace comphelper
  49 {
  50 //..............................................................................
  51
  52     using namespace ::com::sun::star;
  53     using namespace ::com::sun::star::uno;
  54     using namespace ::com::sun::star::lang;
  55     using namespace ::com::sun::star::beans;
  56     using namespace ::com::sun::star::accessibility;
  57
  58     //==============================================================================
  59     // OCommonAccessibleText
  60     //==============================================================================
  61
  62     OCommonAccessibleText::OCommonAccessibleText()
  63     {
  64     }
  65
  66     // -----------------------------------------------------------------------------
  67
  68     OCommonAccessibleText::~OCommonAccessibleText()
  69     {
  70     }
  71
  72     // -----------------------------------------------------------------------------
  73
  74     Reference < i18n::XBreakIterator > OCommonAccessibleText::implGetBreakIterator()
  75     {
  76         if ( !m_xBreakIter.is() )
  77         {
  78             Reference< lang::XMultiServiceFactory > xMSF = ::comphelper::getProcessServiceFactory();
  79             if ( xMSF.is() )
  80             {
  81                 m_xBreakIter = Reference< i18n::XBreakIterator >
  82                     ( xMSF->createInstance( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.i18n.BreakIterator" ) ) ), UNO_QUERY );
  83             }
  84         }
  85
  86         return m_xBreakIter;
  87     }
  88
  89     // -----------------------------------------------------------------------------
  90
  91     Reference < i18n::XCharacterClassification > OCommonAccessibleText::implGetCharacterClassification()
  92     {
  93         if ( !m_xCharClass.is() )
  94         {
  95             Reference< lang::XMultiServiceFactory > xMSF = ::comphelper::getProcessServiceFactory();
  96             if ( xMSF.is() )
  97             {
  98                 m_xCharClass = Reference< i18n::XCharacterClassification >
  99                     ( xMSF->createInstance( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.i18n.CharacterClassification" ) ) ), UNO_QUERY );
 100             }
 101         }
 102
 103         return m_xCharClass;
 104     }
 105
 106     // -----------------------------------------------------------------------------
 107
 108     sal_Bool OCommonAccessibleText::implIsValidBoundary( i18n::Boundary& rBoundary, sal_Int32 nLength )
 109     {
 110         return ( rBoundary.startPos >= 0 ) && ( rBoundary.startPos < nLength ) && ( rBoundary.endPos >= 0 ) && ( rBoundary.endPos <= nLength );
 111     }
 112
 113     // -----------------------------------------------------------------------------
 114
 115     sal_Bool OCommonAccessibleText::implIsValidIndex( sal_Int32 nIndex, sal_Int32 nLength )
 116     {
 117         return ( nIndex >= 0 ) && ( nIndex < nLength );
 118     }
 119
 120     // -----------------------------------------------------------------------------
 121
 122     sal_Bool OCommonAccessibleText::implIsValidRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex, sal_Int32 nLength )
 123     {
 124         return ( nStartIndex >= 0 ) && ( nStartIndex <= nLength ) && ( nEndIndex >= 0 ) && ( nEndIndex <= nLength );
 125     }
 126
 127     // -----------------------------------------------------------------------------
 128
 129     void OCommonAccessibleText::implGetGlyphBoundary( i18n::Boundary& rBoundary, sal_Int32 nIndex )
 130     {
 131         ::rtl::OUString sText( implGetText() );
 132
 133         if ( implIsValidIndex( nIndex, sText.getLength() ) )
 134         {
 135             Reference < i18n::XBreakIterator > xBreakIter = implGetBreakIterator();
 136             if ( xBreakIter.is() )
 137             {
 138                 sal_Int32 nCount = 1;
 139                 sal_Int32 nDone;
 140                 sal_Int32 nStartIndex = xBreakIter->previousCharacters( sText, nIndex, implGetLocale(), i18n::CharacterIteratorMode::SKIPCELL, nCount, nDone );
 141                 if ( nDone != 0 )
 142                     nStartIndex = xBreakIter->nextCharacters( sText, nStartIndex, implGetLocale(), i18n::CharacterIteratorMode::SKIPCELL, nCount, nDone );
 143                 sal_Int32 nEndIndex = xBreakIter->nextCharacters( sText, nStartIndex, implGetLocale(), i18n::CharacterIteratorMode::SKIPCELL, nCount, nDone );
 144                 if ( nDone != 0 )
 145                 {
 146                     rBoundary.startPos = nStartIndex;
 147                     rBoundary.endPos = nEndIndex;
 148                 }
 149             }
 150         }
 151         else
 152         {
 153             rBoundary.startPos = nIndex;
 154             rBoundary.endPos = nIndex;
 155         }
 156     }
 157
 158     // -----------------------------------------------------------------------------
 159
 160     sal_Bool OCommonAccessibleText::implGetWordBoundary( i18n::Boundary& rBoundary, sal_Int32 nIndex )
 161     {
 162         sal_Bool bWord = sal_False;
 163         ::rtl::OUString sText( implGetText() );
 164
 165         if ( implIsValidIndex( nIndex, sText.getLength() ) )
 166         {
 167             Reference < i18n::XBreakIterator > xBreakIter = implGetBreakIterator();
 168             if ( xBreakIter.is() )
 169             {
 170                 rBoundary = xBreakIter->getWordBoundary( sText, nIndex, implGetLocale(), i18n::WordType::ANY_WORD, sal_True );
 171
 172                 // it's a word, if the first character is an alpha-numeric character
 173                 Reference< i18n::XCharacterClassification >     xCharClass = implGetCharacterClassification();
 174                 if ( xCharClass.is() )
 175                 {
 176                     sal_Int32 nType = xCharClass->getCharacterType( sText, rBoundary.startPos, implGetLocale() );
 177                     if ( ( nType & ( i18n::KCharacterType::LETTER | i18n::KCharacterType::DIGIT ) ) != 0 )
 178                         bWord = sal_True;
 179                 }
 180             }
 181         }
 182         else
 183         {
 184             rBoundary.startPos = nIndex;
 185             rBoundary.endPos = nIndex;
 186         }
 187
 188         return bWord;
 189     }
 190
 191     // -----------------------------------------------------------------------------
 192
 193     void OCommonAccessibleText::implGetSentenceBoundary( i18n::Boundary& rBoundary, sal_Int32 nIndex )
 194     {
 195         ::rtl::OUString sText( implGetText() );
 196
 197         if ( implIsValidIndex( nIndex, sText.getLength() ) )
 198         {
 199             Locale aLocale = implGetLocale();
 200             Reference < i18n::XBreakIterator > xBreakIter = implGetBreakIterator();
 201             if ( xBreakIter.is() )
 202             {
 203                 rBoundary.endPos = xBreakIter->endOfSentence( sText, nIndex, aLocale );
 204                 rBoundary.startPos = xBreakIter->beginOfSentence( sText, rBoundary.endPos, aLocale );
 205             }
 206         }
 207         else
 208         {
 209             rBoundary.startPos = nIndex;
 210             rBoundary.endPos = nIndex;
 211         }
 212     }
 213
 214     // -----------------------------------------------------------------------------
 215
 216     void OCommonAccessibleText::implGetParagraphBoundary( i18n::Boundary& rBoundary, sal_Int32 nIndex )
 217     {
 218         ::rtl::OUString sText( implGetText() );
 219
 220         if ( implIsValidIndex( nIndex, sText.getLength() ) )
 221         {
 222             rBoundary.startPos = 0;
 223             rBoundary.endPos = sText.getLength();
 224
 225             sal_Int32 nFound = sText.lastIndexOf( (sal_Unicode)'\n', nIndex );
 226             if ( nFound != -1 )
 227                 rBoundary.startPos = nFound + 1;
 228
 229             nFound = sText.indexOf( (sal_Unicode)'\n', nIndex );
 230             if ( nFound != -1 )
 231                 rBoundary.endPos = nFound + 1;
 232         }
 233         else
 234         {
 235             rBoundary.startPos = nIndex;
 236             rBoundary.endPos = nIndex;
 237         }
 238     }
 239
 240     // -----------------------------------------------------------------------------
 241
 242     void OCommonAccessibleText::implGetLineBoundary( i18n::Boundary& rBoundary, sal_Int32 nIndex )
 243     {
 244         ::rtl::OUString sText( implGetText() );
 245         sal_Int32 nLength = sText.getLength();
 246
 247         if ( implIsValidIndex( nIndex, nLength ) || nIndex == nLength )
 248         {
 249             rBoundary.startPos = 0;
 250             rBoundary.endPos = nLength;
 251         }
 252         else
 253         {
 254             rBoundary.startPos = nIndex;
 255             rBoundary.endPos = nIndex;
 256         }
 257     }
 258
 259     // -----------------------------------------------------------------------------
 260
 261     sal_Unicode OCommonAccessibleText::getCharacter( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 262     {
 263         ::rtl::OUString sText( implGetText() );
 264
 265         if ( !implIsValidIndex( nIndex, sText.getLength() ) )
 266             throw IndexOutOfBoundsException();
 267
 268         return sText.getStr()[nIndex];
 269     }
 270
 271     // -----------------------------------------------------------------------------
 272
 273     sal_Int32 OCommonAccessibleText::getCharacterCount() throw (RuntimeException)
 274     {
 275         return implGetText().getLength();
 276     }
 277
 278     // -----------------------------------------------------------------------------
 279
 280     ::rtl::OUString OCommonAccessibleText::getSelectedText() throw (RuntimeException)
 281     {
 282         ::rtl::OUString sText;
 283         sal_Int32 nStartIndex;
 284         sal_Int32 nEndIndex;
 285
 286         implGetSelection( nStartIndex, nEndIndex );
 287
 288         try
 289         {
 290             sText = getTextRange( nStartIndex, nEndIndex );
 291         }
 292         catch ( IndexOutOfBoundsException& )
 293         {
 294         }
 295
 296         return sText;
 297     }
 298
 299     // -----------------------------------------------------------------------------
 300
 301     sal_Int32 OCommonAccessibleText::getSelectionStart() throw (RuntimeException)
 302     {
 303         sal_Int32 nStartIndex;
 304         sal_Int32 nEndIndex;
 305
 306         implGetSelection( nStartIndex, nEndIndex );
 307
 308         return nStartIndex;
 309     }
 310
 311     // -----------------------------------------------------------------------------
 312
 313     sal_Int32 OCommonAccessibleText::getSelectionEnd() throw (RuntimeException)
 314     {
 315         sal_Int32 nStartIndex;
 316         sal_Int32 nEndIndex;
 317
 318         implGetSelection( nStartIndex, nEndIndex );
 319
 320         return nEndIndex;
 321     }
 322
 323     // -----------------------------------------------------------------------------
 324
 325     ::rtl::OUString OCommonAccessibleText::getText() throw (RuntimeException)
 326     {
 327         return implGetText();
 328     }
 329
 330     // -----------------------------------------------------------------------------
 331
 332     ::rtl::OUString OCommonAccessibleText::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 333     {
 334         ::rtl::OUString sText( implGetText() );
 335
 336         if ( !implIsValidRange( nStartIndex, nEndIndex, sText.getLength() ) )
 337             throw IndexOutOfBoundsException();
 338
 339         sal_Int32 nMinIndex = ::std::min( nStartIndex, nEndIndex );
 340         sal_Int32 nMaxIndex = ::std::max( nStartIndex, nEndIndex );
 341
 342         return sText.copy( nMinIndex, nMaxIndex - nMinIndex );
 343     }
 344
 345     // -----------------------------------------------------------------------------
 346
 347     TextSegment OCommonAccessibleText::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (IndexOutOfBoundsException, IllegalArgumentException, RuntimeException)
 348     {
 349         ::rtl::OUString sText( implGetText() );
 350         sal_Int32 nLength = sText.getLength();
 351
 352         if ( !implIsValidIndex( nIndex, nLength ) && nIndex != nLength )
 353             throw IndexOutOfBoundsException();
 354
 355         i18n::Boundary aBoundary;
 356         TextSegment aResult;
 357         aResult.SegmentStart = -1;
 358         aResult.SegmentEnd = -1;
 359
 360         switch ( aTextType )
 361         {
 362             case AccessibleTextType::CHARACTER:
 363             {
 364                 if ( implIsValidIndex( nIndex, nLength ) )
 365                 {
 366                     aResult.SegmentText = sText.copy( nIndex, 1 );
 367                     aResult.SegmentStart = nIndex;
 368                     aResult.SegmentEnd = nIndex+1;
 369                 }
 370             }
 371             break;
 372             case AccessibleTextType::GLYPH:
 373             {
 374                 // get glyph at index
 375                 implGetGlyphBoundary( aBoundary, nIndex );
 376                 if ( implIsValidBoundary( aBoundary, nLength ) )
 377                 {
 378                     aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
 379                     aResult.SegmentStart = aBoundary.startPos;
 380                     aResult.SegmentEnd = aBoundary.endPos;
 381                 }
 382             }
 383             break;
 384             case AccessibleTextType::WORD:
 385             {
 386                 // get word at index
 387                 sal_Bool bWord = implGetWordBoundary( aBoundary, nIndex );
 388                 if ( bWord && implIsValidBoundary( aBoundary, nLength ) )
 389                 {
 390                     aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
 391                     aResult.SegmentStart = aBoundary.startPos;
 392                     aResult.SegmentEnd = aBoundary.endPos;
 393                 }
 394             }
 395             break;
 396             case AccessibleTextType::SENTENCE:
 397             {
 398                 // get sentence at index
 399                 implGetSentenceBoundary( aBoundary, nIndex );
 400                 if ( implIsValidBoundary( aBoundary, nLength ) )
 401                 {
 402                     aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
 403                     aResult.SegmentStart = aBoundary.startPos;
 404                     aResult.SegmentEnd = aBoundary.endPos;
 405                 }
 406             }
 407             break;
 408             case AccessibleTextType::PARAGRAPH:
 409             {
 410                 // get paragraph at index
 411                 implGetParagraphBoundary( aBoundary, nIndex );
 412                 if ( implIsValidBoundary( aBoundary, nLength ) )
 413                 {
 414                     aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
 415                     aResult.SegmentStart = aBoundary.startPos;
 416                     aResult.SegmentEnd = aBoundary.endPos;
 417                 }
 418             }
 419             break;
 420             case AccessibleTextType::LINE:
 421             {
 422                 // get line at index
 423                 implGetLineBoundary( aBoundary, nIndex );
 424                 if ( implIsValidBoundary( aBoundary, nLength ) )
 425                 {
 426                     aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
 427                     aResult.SegmentStart = aBoundary.startPos;
 428                     aResult.SegmentEnd = aBoundary.endPos;
 429                 }
 430             }
 431             break;
 432             case AccessibleTextType::ATTRIBUTE_RUN:
 433             {
 434                 // TODO: implGetAttributeRunBoundary() (incompatible!)
 435
 436                 aResult.SegmentText = sText;
 437                 aResult.SegmentStart = 0;
 438                 aResult.SegmentEnd = nLength;
 439             }
 440             break;
 441             default:
 442             {
 443                 // unknown text type
 444             }
 445         }
 446
 447         return aResult;
 448     }
 449
 450     // -----------------------------------------------------------------------------
 451
 452     TextSegment OCommonAccessibleText::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (IndexOutOfBoundsException, IllegalArgumentException, RuntimeException)
 453     {
 454         ::rtl::OUString sText( implGetText() );
 455         sal_Int32 nLength = sText.getLength();
 456
 457         if ( !implIsValidIndex( nIndex, nLength ) && nIndex != nLength )
 458             throw IndexOutOfBoundsException();
 459
 460         i18n::Boundary aBoundary;
 461         TextSegment aResult;
 462         aResult.SegmentStart = -1;
 463         aResult.SegmentEnd = -1;
 464
 465         switch ( aTextType )
 466         {
 467             case AccessibleTextType::CHARACTER:
 468             {
 469                 if ( implIsValidIndex( nIndex - 1, nLength ) )
 470                 {
 471                     aResult.SegmentText = sText.copy( nIndex - 1, 1 );
 472                     aResult.SegmentStart = nIndex-1;
 473                     aResult.SegmentEnd = nIndex;
 474                 }
 475             }
 476             break;
 477             case AccessibleTextType::GLYPH:
 478             {
 479                 // get glyph at index
 480                 implGetGlyphBoundary( aBoundary, nIndex );
 481                 // get previous glyph
 482                 if ( aBoundary.startPos > 0 )
 483                 {
 484                     implGetGlyphBoundary( aBoundary, aBoundary.startPos - 1 );
 485                     if ( implIsValidBoundary( aBoundary, nLength ) )
 486                     {
 487                         aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
 488                         aResult.SegmentStart = aBoundary.startPos;
 489                         aResult.SegmentEnd = aBoundary.endPos;
 490                     }
 491                 }
 492             }
 493             break;
 494             case AccessibleTextType::WORD:
 495             {
 496                 // get word at index
 497                 implGetWordBoundary( aBoundary, nIndex );
 498                 // get previous word
 499                 sal_Bool bWord = sal_False;
 500                 while ( !bWord && aBoundary.startPos > 0 )
 501                     bWord = implGetWordBoundary( aBoundary, aBoundary.startPos - 1 );
 502                 if ( bWord && implIsValidBoundary( aBoundary, nLength ) )
 503                 {
 504                     aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
 505                     aResult.SegmentStart = aBoundary.startPos;
 506                     aResult.SegmentEnd = aBoundary.endPos;
 507                 }
 508             }
 509             break;
 510             case AccessibleTextType::SENTENCE:
 511             {
 512                 // get sentence at index
 513                 implGetSentenceBoundary( aBoundary, nIndex );
 514                 // get previous sentence
 515                 if ( aBoundary.startPos > 0 )
 516                 {
 517                     implGetSentenceBoundary( aBoundary, aBoundary.startPos - 1 );
 518                     if ( implIsValidBoundary( aBoundary, nLength ) )
 519                     {
 520                         aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
 521                         aResult.SegmentStart = aBoundary.startPos;
 522                         aResult.SegmentEnd = aBoundary.endPos;
 523                     }
 524                 }
 525             }
 526             break;
 527             case AccessibleTextType::PARAGRAPH:
 528             {
 529                 // get paragraph at index
 530                 implGetParagraphBoundary( aBoundary, nIndex );
 531                 // get previous paragraph
 532                 if ( aBoundary.startPos > 0 )
 533                 {
 534                     implGetParagraphBoundary( aBoundary, aBoundary.startPos - 1 );
 535                     if ( implIsValidBoundary( aBoundary, nLength ) )
 536                     {
 537                         aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
 538                         aResult.SegmentStart = aBoundary.startPos;
 539                         aResult.SegmentEnd = aBoundary.endPos;
 540                     }
 541                 }
 542             }
 543             break;
 544             case AccessibleTextType::LINE:
 545             {
 546                 // get line at index
 547                 implGetLineBoundary( aBoundary, nIndex );
 548                 // get previous line
 549                 if ( aBoundary.startPos > 0 )
 550                 {
 551                     implGetLineBoundary( aBoundary, aBoundary.startPos - 1 );
 552                     if ( implIsValidBoundary( aBoundary, nLength ) )
 553                     {
 554                         aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
 555                         aResult.SegmentStart = aBoundary.startPos;
 556                         aResult.SegmentEnd = aBoundary.endPos;
 557                     }
 558                 }
 559             }
 560             break;
 561             case AccessibleTextType::ATTRIBUTE_RUN:
 562             {
 563                 // TODO: implGetAttributeRunBoundary() (incompatible!)
 564             }
 565             break;
 566             default:
 567             {
 568                 // unknown text type
 569             }
 570         }
 571
 572         return aResult;
 573     }
 574
 575     // -----------------------------------------------------------------------------
 576
 577     TextSegment OCommonAccessibleText::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (IndexOutOfBoundsException, IllegalArgumentException, RuntimeException)
 578     {
 579         ::rtl::OUString sText( implGetText() );
 580         sal_Int32 nLength = sText.getLength();
 581
 582         if ( !implIsValidIndex( nIndex, nLength ) && nIndex != nLength )
 583             throw IndexOutOfBoundsException();
 584
 585         i18n::Boundary aBoundary;
 586         TextSegment aResult;
 587         aResult.SegmentStart = -1;
 588         aResult.SegmentEnd = -1;
 589
 590         switch ( aTextType )
 591         {
 592             case AccessibleTextType::CHARACTER:
 593             {
 594                 if ( implIsValidIndex( nIndex + 1, nLength ) )
 595                 {
 596                     aResult.SegmentText = sText.copy( nIndex + 1, 1 );
 597                     aResult.SegmentStart = nIndex+1;
 598                     aResult.SegmentEnd = nIndex+2;
 599                 }
 600             }
 601             break;
 602             case AccessibleTextType::GLYPH:
 603             {
 604                 // get glyph at index
 605                 implGetGlyphBoundary( aBoundary, nIndex );
 606                 // get next glyph
 607                 if ( aBoundary.endPos < nLength )
 608                 {
 609                     implGetGlyphBoundary( aBoundary, aBoundary.endPos );
 610                     if ( implIsValidBoundary( aBoundary, nLength ) )
 611                     {
 612                         aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
 613                         aResult.SegmentStart = aBoundary.startPos;
 614                         aResult.SegmentEnd = aBoundary.endPos;
 615                     }
 616                 }
 617             }
 618             break;
 619             case AccessibleTextType::WORD:
 620             {
 621                 // get word at index
 622                 implGetWordBoundary( aBoundary, nIndex );
 623                 // get next word
 624                 sal_Bool bWord = sal_False;
 625                 while ( !bWord && aBoundary.endPos < nLength )
 626                     bWord = implGetWordBoundary( aBoundary, aBoundary.endPos );
 627                 if ( bWord && implIsValidBoundary( aBoundary, nLength ) )
 628                 {
 629                     aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
 630                     aResult.SegmentStart = aBoundary.startPos;
 631                     aResult.SegmentEnd = aBoundary.endPos;
 632                 }
 633             }
 634             break;
 635             case AccessibleTextType::SENTENCE:
 636             {
 637                 // get sentence at index
 638                 implGetSentenceBoundary( aBoundary, nIndex );
 639                 // get next sentence
 640                 sal_Int32 nEnd = aBoundary.endPos;
 641                 sal_Int32 nI = aBoundary.endPos;
 642                 sal_Bool bFound = sal_False;
 643                 while ( !bFound && ++nI < nLength )
 644                 {
 645                     implGetSentenceBoundary( aBoundary, nI );
 646                     bFound = ( aBoundary.endPos > nEnd );
 647                 }
 648                 if ( bFound && implIsValidBoundary( aBoundary, nLength ) )
 649                 {
 650                     aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
 651                     aResult.SegmentStart = aBoundary.startPos;
 652                     aResult.SegmentEnd = aBoundary.endPos;
 653                 }
 654             }
 655             break;
 656             case AccessibleTextType::PARAGRAPH:
 657             {
 658                 // get paragraph at index
 659                 implGetParagraphBoundary( aBoundary, nIndex );
 660                 // get next paragraph
 661                 if ( aBoundary.endPos < nLength )
 662                 {
 663                     implGetParagraphBoundary( aBoundary, aBoundary.endPos );
 664                     if ( implIsValidBoundary( aBoundary, nLength ) )
 665                     {
 666                         aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
 667                         aResult.SegmentStart = aBoundary.startPos;
 668                         aResult.SegmentEnd = aBoundary.endPos;
 669                     }
 670                 }
 671             }
 672             break;
 673             case AccessibleTextType::LINE:
 674             {
 675                 // get line at index
 676                 implGetLineBoundary( aBoundary, nIndex );
 677                 // get next line
 678                 if ( aBoundary.endPos < nLength )
 679                 {
 680                     implGetLineBoundary( aBoundary, aBoundary.endPos );
 681                     if ( implIsValidBoundary( aBoundary, nLength ) )
 682                     {
 683                         aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
 684                         aResult.SegmentStart = aBoundary.startPos;
 685                         aResult.SegmentEnd = aBoundary.endPos;
 686                     }
 687                 }
 688             }
 689             break;
 690             case AccessibleTextType::ATTRIBUTE_RUN:
 691             {
 692                 // TODO: implGetAttributeRunBoundary() (incompatible!)
 693             }
 694             break;
 695             default:
 696             {
 697                 // unknown text type
 698             }
 699         }
 700
 701         return aResult;
 702     }
 703
 704     // -----------------------------------------------------------------------------
 705     bool OCommonAccessibleText::implInitTextChangedEvent(
 706         const rtl::OUString& rOldString,
 707         const rtl::OUString& rNewString,
 708         ::com::sun::star::uno::Any& rDeleted,
 709         ::com::sun::star::uno::Any& rInserted) // throw()
 710     {
 711         sal_uInt32 nLenOld = rOldString.getLength();
 712         sal_uInt32 nLenNew = rNewString.getLength();
 713
 714         // equal
 715         if ((0 == nLenOld) && (0 == nLenNew))
 716             return false;
 717
 718         TextSegment aDeletedText;
 719         TextSegment aInsertedText;
 720
 721         aDeletedText.SegmentStart = -1;
 722         aDeletedText.SegmentEnd = -1;
 723         aInsertedText.SegmentStart = -1;
 724         aInsertedText.SegmentEnd = -1;
 725
 726         // insert only
 727         if ((0 == nLenOld) && (nLenNew > 0))
 728         {
 729             aInsertedText.SegmentStart = 0;
 730             aInsertedText.SegmentEnd = nLenNew;
 731             aInsertedText.SegmentText = rNewString.copy( aInsertedText.SegmentStart, aInsertedText.SegmentEnd - aInsertedText.SegmentStart );
 732
 733             rInserted <<= aInsertedText;
 734             return true;
 735         }
 736
 737         // delete only
 738         if ((nLenOld > 0) && (0 == nLenNew))
 739         {
 740             aDeletedText.SegmentStart = 0;
 741             aDeletedText.SegmentEnd = nLenOld;
 742             aDeletedText.SegmentText = rOldString.copy( aDeletedText.SegmentStart, aDeletedText.SegmentEnd - aDeletedText.SegmentStart );
 743
 744             rDeleted <<= aDeletedText;
 745             return true;
 746         }
 747
 748         const sal_Unicode* pFirstDiffOld = rOldString.getStr();
 749         const sal_Unicode* pLastDiffOld  = rOldString.getStr() + nLenOld;
 750         const sal_Unicode* pFirstDiffNew = rNewString.getStr();
 751         const sal_Unicode* pLastDiffNew  = rNewString.getStr() + nLenNew;
 752
 753         // find first difference
 754         while ((*pFirstDiffOld == *pFirstDiffNew) &&
 755                (pFirstDiffOld  <  pLastDiffOld) &&
 756                (pFirstDiffNew  <  pLastDiffNew))
 757         {
 758             pFirstDiffOld++;
 759             pFirstDiffNew++;
 760         }
 761
 762         // equality test
 763         if ((0 == *pFirstDiffOld) && (0 == *pFirstDiffNew))
 764             return false;
 765
 766         // find last difference
 767         while ( ( pLastDiffOld > pFirstDiffOld) &&
 768                 ( pLastDiffNew > pFirstDiffNew) &&
 769                 (pLastDiffOld[-1]  == pLastDiffNew[-1]))
 770         {
 771             pLastDiffOld--;
 772             pLastDiffNew--;
 773         }
 774
 775         if (pFirstDiffOld < pLastDiffOld)
 776         {
 777             aDeletedText.SegmentStart = pFirstDiffOld - rOldString.getStr();
 778             aDeletedText.SegmentEnd = pLastDiffOld  - rOldString.getStr();
 779             aDeletedText.SegmentText = rOldString.copy( aDeletedText.SegmentStart, aDeletedText.SegmentEnd - aDeletedText.SegmentStart );
 780
 781             rDeleted <<= aDeletedText;
 782         }
 783
 784         if (pFirstDiffNew < pLastDiffNew)
 785         {
 786             aInsertedText.SegmentStart = pFirstDiffNew - rNewString.getStr();
 787             aInsertedText.SegmentEnd = pLastDiffNew  - rNewString.getStr();
 788             aInsertedText.SegmentText = rNewString.copy( aInsertedText.SegmentStart, aInsertedText.SegmentEnd - aInsertedText.SegmentStart );
 789
 790             rInserted <<= aInsertedText;
 791         }
 792         return true;
 793     }
 794
 795     //==============================================================================
 796     // OAccessibleTextHelper
 797     //==============================================================================
 798
 799     OAccessibleTextHelper::OAccessibleTextHelper()
 800     {
 801     }
 802
 803     // -----------------------------------------------------------------------------
 804
 805     OAccessibleTextHelper::OAccessibleTextHelper( IMutex* _pExternalLock )
 806         :OAccessibleExtendedComponentHelper( _pExternalLock )
 807     {
 808     }
 809
 810     // -----------------------------------------------------------------------------
 811     // XInterface
 812     // -----------------------------------------------------------------------------
 813
 814     IMPLEMENT_FORWARD_XINTERFACE2( OAccessibleTextHelper, OAccessibleExtendedComponentHelper, OAccessibleTextHelper_Base )
 815
 816     // -----------------------------------------------------------------------------
 817     // XTypeProvider
 818     // -----------------------------------------------------------------------------
 819
 820     IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleTextHelper, OAccessibleExtendedComponentHelper, OAccessibleTextHelper_Base )
 821
 822     // -----------------------------------------------------------------------------
 823     // XAccessibleText
 824     // -----------------------------------------------------------------------------
 825
 826     sal_Unicode OAccessibleTextHelper::getCharacter( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 827     {
 828         OExternalLockGuard aGuard( this );
 829
 830         return OCommonAccessibleText::getCharacter( nIndex );
 831     }
 832
 833     // -----------------------------------------------------------------------------
 834
 835     sal_Int32 OAccessibleTextHelper::getCharacterCount() throw (RuntimeException)
 836     {
 837         OExternalLockGuard aGuard( this );
 838
 839         return OCommonAccessibleText::getCharacterCount();
 840     }
 841
 842     // -----------------------------------------------------------------------------
 843
 844     ::rtl::OUString OAccessibleTextHelper::getSelectedText() throw (RuntimeException)
 845     {
 846         OExternalLockGuard aGuard( this );
 847
 848         return OCommonAccessibleText::getSelectedText();
 849     }
 850
 851     // -----------------------------------------------------------------------------
 852
 853     sal_Int32 OAccessibleTextHelper::getSelectionStart() throw (RuntimeException)
 854     {
 855         OExternalLockGuard aGuard( this );
 856
 857         return OCommonAccessibleText::getSelectionStart();
 858     }
 859
 860     // -----------------------------------------------------------------------------
 861
 862     sal_Int32 OAccessibleTextHelper::getSelectionEnd() throw (RuntimeException)
 863     {
 864         OExternalLockGuard aGuard( this );
 865
 866         return OCommonAccessibleText::getSelectionEnd();
 867     }
 868
 869     // -----------------------------------------------------------------------------
 870
 871     ::rtl::OUString OAccessibleTextHelper::getText() throw (RuntimeException)
 872     {
 873         OExternalLockGuard aGuard( this );
 874
 875         return OCommonAccessibleText::getText();
 876     }
 877
 878     // -----------------------------------------------------------------------------
 879
 880     ::rtl::OUString OAccessibleTextHelper::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 881     {
 882         OExternalLockGuard aGuard( this );
 883
 884         return OCommonAccessibleText::getTextRange( nStartIndex, nEndIndex );
 885     }
 886
 887     // -----------------------------------------------------------------------------
 888
 889     TextSegment OAccessibleTextHelper::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (IndexOutOfBoundsException, IllegalArgumentException, RuntimeException)
 890     {
 891         OExternalLockGuard aGuard( this );
 892
 893         return OCommonAccessibleText::getTextAtIndex( nIndex, aTextType );
 894     }
 895
 896     // -----------------------------------------------------------------------------
 897
 898     TextSegment OAccessibleTextHelper::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (IndexOutOfBoundsException, IllegalArgumentException, RuntimeException)
 899     {
 900         OExternalLockGuard aGuard( this );
 901
 902         return OCommonAccessibleText::getTextBeforeIndex( nIndex, aTextType );
 903     }
 904
 905     // -----------------------------------------------------------------------------
 906
 907     TextSegment OAccessibleTextHelper::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (IndexOutOfBoundsException, IllegalArgumentException, RuntimeException)
 908     {
 909         OExternalLockGuard aGuard( this );
 910
 911         return OCommonAccessibleText::getTextBehindIndex( nIndex, aTextType );
 912     }
 913
 914     // -----------------------------------------------------------------------------
 915
 916 //..............................................................................
 917 }       // namespace comphelper
 918 //..............................................................................