comphelper/source/misc/accessibletexthelper.cxx

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