winaccessibility/source/UAccCOM/AccTextBase.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
  21 // AccTextBase.cpp: implementation of the CAccTextBase class.
  22
  23 #include "stdafx.h"
  24 #include <string>
  25
  26 #include "AccTextBase.h"
  27
  28 #include <vcl/svapp.hxx>
  29
  30 #include <com/sun/star/accessibility/AccessibleTextType.hpp>
  31 #include <com/sun/star/accessibility/XAccessible.hpp>
  32 #include <com/sun/star/accessibility/XAccessibleContext.hpp>
  33 #include <com/sun/star/accessibility/XAccessibleComponent.hpp>
  34 #include <com/sun/star/accessibility/XAccessibleTextSelection.hpp>
  35 #include "MAccessible.h"
  36
  37 using namespace com::sun::star::accessibility;
  38 using namespace com::sun::star::uno;
  39
  40
  41 // Construction/Destruction
  42
  43
  44 static OUString ReplaceFourChar(OUString oldOUString);
  45
  46 CAccTextBase::CAccTextBase()
  47 {}
  48
  49 CAccTextBase::~CAccTextBase()
  50 {}
  51
  52
  53 /**
  54    * Get special selection.
  55    * @param startOffset Start selection offset.
  56    * @param endOffset   End selection offset.
  57    * @param success     Variant to accept the result of if the method call is successful.
  58    * @return Result.
  59 */
  60 STDMETHODIMP CAccTextBase::get_addSelection(long startOffset, long endOffset)
  61 {
  62     SolarMutexGuard g;
  63
  64     ENTER_PROTECTED_BLOCK
  65
  66     // #CHECK XInterface#
  67     if(pUNOInterface == NULL)
  68         return E_FAIL;
  69
  70     Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext();
  71
  72     Reference< XAccessibleTextSelection > pRExtension(pRContext,UNO_QUERY);
  73
  74     if( pRExtension.is() )
  75     {
  76         pRExtension->addSelection(0, startOffset, endOffset);
  77         return S_OK;
  78     }
  79     else
  80     {
  81         GetXInterface()->setSelection(startOffset, endOffset);
  82         return S_OK;
  83     }
  84
  85     LEAVE_PROTECTED_BLOCK
  86 }
  87
  88 /**
  89    * Get special attributes.
  90    * @param offset Offset.
  91    * @param startOffset Variant to accept start offset.
  92    * @param endOffset   Variant to accept end offset.
  93    * @param textAttributes     Variant to accept attributes.
  94    * @return Result.
  95 */
  96 STDMETHODIMP CAccTextBase::get_attributes(long offset, long * startOffset, long * endOffset, BSTR * textAttributes)
  97 {
  98     SolarMutexGuard g;
  99
 100     ENTER_PROTECTED_BLOCK
 101
 102     if (startOffset == NULL || endOffset == NULL || textAttributes == NULL)
 103         return E_INVALIDARG;
 104     // #CHECK XInterface#
 105     if(!pRXText.is())
 106     {
 107         return E_FAIL;
 108     }
 109
 110     if( offset < 0 || offset > GetXInterface()->getCharacterCount() )
 111         return E_FAIL;
 112
 113     std::wstring strAttrs;
 114
 115     strAttrs += L"Version:1;";
 116
 117     Sequence< ::com::sun::star::beans::PropertyValue > pValues = GetXInterface()->getCharacterAttributes(offset, Sequence< rtl::OUString >());
 118     int nCount = pValues.getLength();
 119
 120     short numberingLevel = 0;
 121     OUString numberingPrefix;
 122     Any anyNumRule;
 123     bool bHaveNumberingPrefixAttr = false;
 124     bool bHaveNumberingLevel = false;
 125     bool bHaveNumberingRules = false;
 126     for(int i =0; i<nCount; i++)
 127     {
 128
 129         ::com::sun::star::beans::PropertyValue &pValue = pValues[i];
 130         if(pValue.Name == "NumberingLevel")
 131         {
 132             if (pValue.Value != Any())
 133                 pValue.Value >>= numberingLevel;
 134             else
 135                 numberingLevel = -1;
 136             bHaveNumberingLevel = true;
 137             continue;
 138         }
 139         if(pValue.Name == "NumberingPrefix")
 140         {
 141             pValue.Value >>=numberingPrefix;
 142             bHaveNumberingPrefixAttr = true;
 143             continue;
 144         }
 145         if(pValue.Name == "NumberingRules")
 146         {
 147             bHaveNumberingRules = true;
 148             anyNumRule = pValue.Value;
 149             continue;
 150         }
 151         if (bHaveNumberingLevel && bHaveNumberingRules && bHaveNumberingPrefixAttr)
 152         {
 153             OLECHAR numProps[512] = {0};
 154             strAttrs+=L";";
 155             numberingPrefix = ReplaceFourChar(numberingPrefix);
 156             CMAccessible::get_OLECHAR4Numbering(anyNumRule,numberingLevel,numberingPrefix,numProps);
 157             strAttrs += numProps;
 158             bHaveNumberingLevel = 0;
 159             bHaveNumberingRules = 0;
 160         }
 161         if( (bHaveNumberingPrefixAttr && i > 1 ) ||
 162             (!bHaveNumberingPrefixAttr && i > 0 ) ) //element 0 is NumberingPrefix, not write alone
 163         {
 164             strAttrs+=L";";
 165         }
 166         strAttrs += pValue.Name.getStr();
 167         strAttrs += L":";
 168
 169         OLECHAR pTemp[2048] = {0};
 170
 171         if (pValue.Name == "CharBackColor" ||
 172                 pValue.Name == "CharColor" ||
 173                 pValue.Name == "CharUnderlineColor" )
 174         {
 175             unsigned long nColor;
 176             pValue.Value >>= nColor;
 177             OLECHAR pBuf[64];
 178             swprintf( pBuf, L"%08X", nColor );
 179             pTemp[0]=L'#';
 180             wcscat( pTemp, pBuf );
 181
 182         }
 183         else
 184         {
 185             CMAccessible::get_OLECHARFromAny(pValue.Value,pTemp);
 186         }
 187
 188         strAttrs +=pTemp;
 189     }
 190     strAttrs +=L";";
 191     // #CHECK#
 192     if(*textAttributes)
 193         SysFreeString(*textAttributes);
 194     *textAttributes = SysAllocString(strAttrs.c_str());
 195
 196     if( offset < GetXInterface()->getCharacterCount() )
 197     {
 198         TextSegment textSeg = GetXInterface()->getTextAtIndex(offset, AccessibleTextType::ATTRIBUTE_RUN);
 199         *startOffset = textSeg.SegmentStart;
 200         *endOffset = textSeg.SegmentEnd;
 201     }
 202     else
 203     {
 204         *startOffset = offset;
 205         *endOffset = offset;
 206     }
 207
 208     return S_OK;
 209
 210     LEAVE_PROTECTED_BLOCK
 211 }
 212
 213 /**
 214    * Get caret position.
 215    * @param offset     Variant to accept caret offset.
 216    * @return Result.
 217 */
 218 STDMETHODIMP CAccTextBase::get_caretOffset(long * offset)
 219 {
 220     SolarMutexGuard g;
 221
 222     ENTER_PROTECTED_BLOCK
 223
 224     if (offset == NULL)
 225         return E_INVALIDARG;
 226     // #CHECK XInterface#
 227     if(!pRXText.is())
 228     {
 229         *offset = 0;
 230         return S_OK;
 231     }
 232
 233     *offset = GetXInterface()->getCaretPosition();
 234     return S_OK;
 235
 236     LEAVE_PROTECTED_BLOCK
 237 }
 238
 239 /**
 240    * Get character count.
 241    * @param nCharacters  Variant to accept character count.
 242    * @return Result.
 243 */
 244 STDMETHODIMP CAccTextBase::get_characterCount(long * nCharacters)
 245 {
 246     SolarMutexGuard g;
 247
 248     ENTER_PROTECTED_BLOCK
 249
 250     if (nCharacters == NULL)
 251         return E_INVALIDARG;
 252     // #CHECK XInterface#
 253     if(!pRXText.is())
 254     {
 255         *nCharacters = 0;
 256         return S_OK;
 257     }
 258
 259     *nCharacters = GetXInterface()->getCharacterCount();
 260     return S_OK;
 261
 262     LEAVE_PROTECTED_BLOCK
 263 }
 264
 265 /**
 266    * Get character extents.
 267    * @param offset  Offset.
 268    * @param x Variant to accept x position.
 269    * @param y Variant to accept y position.
 270    * @param width Variant to accept width.
 271    * @param Height Variant to accept height.
 272    * @return Result.
 273 */
 274 STDMETHODIMP CAccTextBase::get_characterExtents(long offset, IA2CoordinateType coordType, long * x, long * y, long * width, long * height)
 275 {
 276     SolarMutexGuard g;
 277
 278     ENTER_PROTECTED_BLOCK
 279
 280     if (x == NULL || height == NULL || y == NULL || width == NULL)
 281         return E_INVALIDARG;
 282     // #CHECK XInterface#
 283     if(!pRXText.is())
 284         return E_FAIL;
 285
 286     if(offset < 0 || offset > GetXInterface()->getCharacterCount() )
 287         return E_FAIL;
 288
 289     com::sun::star::awt::Rectangle rectangle;
 290     rectangle = GetXInterface()->getCharacterBounds(offset);
 291
 292     //IA2Point aPoint;
 293     com::sun::star::awt::Point aPoint;
 294
 295     Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext();
 296     if( !pRContext.is() )
 297     {
 298         return E_FAIL;
 299     }
 300     Reference<XAccessibleComponent> pRComp(pRContext,UNO_QUERY);
 301     if( pRComp.is() )
 302     {
 303         if(coordType == IA2_COORDTYPE_SCREEN_RELATIVE)
 304         {
 305             ::com::sun::star::awt::Point pt = pRComp->getLocationOnScreen();
 306             aPoint.X = pt.X;
 307             aPoint.Y = pt.Y;
 308         }
 309         else if(coordType == IA2_COORDTYPE_PARENT_RELATIVE)
 310         {
 311             ::com::sun::star::awt::Point pt = pRComp->getLocation();
 312             aPoint.X = pt.X;
 313             aPoint.Y = pt.Y;
 314         }
 315     }
 316     rectangle.X = rectangle.X + aPoint.X;
 317     rectangle.Y = rectangle.Y + aPoint.Y;
 318
 319     *x = rectangle.X;
 320     *y = rectangle.Y;
 321
 322     // GetXInterface()->getCharacterBounds() have different implement in different acc component
 323     // But we need return the width/height == 1 for every component when offset == text length.
 324     // So we ignore the return result of GetXInterface()->getCharacterBounds() when offset == text length.
 325     if( offset == GetXInterface()->getCharacterCount() )
 326     {
 327         *width = 1;
 328         *height = 1;
 329     }
 330     else
 331     {
 332         *width = rectangle.Width;
 333         *height = rectangle.Height;
 334     }
 335
 336     return S_OK;
 337
 338     LEAVE_PROTECTED_BLOCK
 339 }
 340
 341 /**
 342    * Get selections count.
 343    * @param nSelections Variant to accept selections count.
 344    * @return Result.
 345 */
 346 STDMETHODIMP CAccTextBase::get_nSelections(long * nSelections)
 347 {
 348     SolarMutexGuard g;
 349
 350     ENTER_PROTECTED_BLOCK
 351
 352     if (nSelections == NULL)
 353         return E_INVALIDARG;
 354     // #CHECK XInterface#
 355     if(pUNOInterface == NULL)
 356     {
 357         *nSelections = 0;
 358         return S_OK;
 359     }
 360
 361     Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext();
 362
 363     Reference< XAccessibleTextSelection > pRExtension(pRContext,UNO_QUERY);
 364
 365     if( pRExtension.is() )
 366     {
 367         *nSelections = pRExtension->getSelectedPortionCount();
 368         return S_OK;
 369     }
 370
 371     long iLength = GetXInterface()->getSelectedText().getLength();
 372     if( iLength> 0)
 373     {
 374         *nSelections = 1;
 375         return S_OK;
 376     }
 377
 378     *nSelections = 0;
 379     return S_OK;
 380
 381     LEAVE_PROTECTED_BLOCK
 382 }
 383
 384 /**
 385    * Get offset of some special point.
 386    * @param x X position of one point.
 387    * @param x Y position of one point.
 388    * @param coordType Type.
 389    * @param offset Variant to accept offset.
 390    * @return Result.
 391 */
 392 STDMETHODIMP CAccTextBase::get_offsetAtPoint(long x, long y, IA2CoordinateType, long * offset)
 393 {
 394     SolarMutexGuard g;
 395
 396     ENTER_PROTECTED_BLOCK
 397
 398     if (offset == NULL)
 399         return E_INVALIDARG;
 400     // #CHECK XInterface#
 401     if(!pRXText.is())
 402         return E_FAIL;
 403
 404     com::sun::star::awt::Point point;
 405     point.X = x;
 406     point.Y = y;
 407     *offset = GetXInterface()->getIndexAtPoint(point);
 408     return S_OK;
 409
 410     LEAVE_PROTECTED_BLOCK
 411 }
 412
 413 /**
 414    * Get selection range.
 415    * @param selection selection count.
 416    * @param startOffset Variant to accept the start offset of special selection.
 417    * @param endOffset Variant to accept the end offset of special selection.
 418    * @return Result.
 419 */
 420
 421 STDMETHODIMP CAccTextBase::get_selection(long selectionIndex, long * startOffset, long * endOffset)
 422 {
 423     SolarMutexGuard g;
 424
 425     ENTER_PROTECTED_BLOCK
 426
 427     if (startOffset == NULL || endOffset == NULL )
 428         return E_INVALIDARG;
 429     // #CHECK XInterface#
 430     if(pUNOInterface == NULL )
 431         return E_FAIL;
 432
 433     long nSelection = 0;
 434     get_nSelections(&nSelection);
 435
 436     if(selectionIndex >= nSelection || selectionIndex < 0 )
 437         return E_FAIL;
 438
 439     Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext();
 440
 441     Reference< XAccessibleTextSelection > pRExtension(pRContext,UNO_QUERY);
 442
 443     if( pRExtension.is() )
 444     {
 445         *startOffset = pRExtension->getSeletedPositionStart(selectionIndex);
 446         *endOffset = pRExtension->getSeletedPositionEnd(selectionIndex);
 447         return S_OK;
 448     }
 449     else if(GetXInterface()->getSelectionEnd() > -1)
 450     {
 451         *startOffset = GetXInterface()->getSelectionStart();
 452         *endOffset = GetXInterface()->getSelectionEnd();
 453         return S_OK;
 454     }
 455
 456     *startOffset = 0;
 457     *endOffset = 0;
 458     return E_FAIL;
 459
 460     LEAVE_PROTECTED_BLOCK
 461 }
 462
 463 /**
 464    * Get special text.
 465    * @param startOffset Start position of special range.
 466    * @param endOffset   End position of special range.
 467    * @param text        Variant to accept the text of special range.
 468    * @return Result.
 469 */
 470 STDMETHODIMP CAccTextBase::get_text(long startOffset, long endOffset, BSTR * text)
 471 {
 472     SolarMutexGuard g;
 473
 474     ENTER_PROTECTED_BLOCK
 475
 476     if (text == NULL)
 477         return E_INVALIDARG;
 478     // #CHECK XInterface#
 479     if(!pRXText.is())
 480         return E_FAIL;
 481
 482     if (endOffset < -1 || endOffset < startOffset )
 483     {
 484         return E_FAIL;
 485     }
 486
 487     ::rtl::OUString ouStr;
 488     if (endOffset == -1 )
 489     {
 490         long nLen=0;
 491         if(SUCCEEDED(get_characterCount(&nLen)))
 492         {
 493             ouStr = GetXInterface()->getTextRange( 0, nLen );
 494         }
 495     }
 496     else
 497     {
 498         ouStr = GetXInterface()->getTextRange( startOffset, endOffset );
 499     }
 500
 501     SysFreeString(*text);
 502     *text = SysAllocString((OLECHAR*)ouStr.getStr());
 503     return S_OK;
 504
 505     LEAVE_PROTECTED_BLOCK
 506 }
 507
 508 /**
 509    * Get special text before some position.
 510    * @param offset Special position.
 511    * @param boundaryType Boundary type.
 512    * @param startOffset Variant to accept the start offset.
 513    * @param endOffset   Variant to accept the end offset.
 514    * @param text        Variant to accept the special text.
 515    * @return Result.
 516 */
 517 STDMETHODIMP CAccTextBase::get_textBeforeOffset(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text)
 518 {
 519     SolarMutexGuard g;
 520
 521     ENTER_PROTECTED_BLOCK
 522
 523     // #CHECK#
 524     if (startOffset == NULL || endOffset == NULL || text == NULL)
 525         return E_INVALIDARG;
 526     // #CHECK XInterface#
 527     if(!pRXText.is())
 528         return E_FAIL;
 529
 530     // In New UNO IAccessibleText.idl these constant values are defined as follows:
 531
 532     //  const long TEXT_BOUNDARY_CHAR = -1;
 533     //  const long TEXT_BOUNDARY_TO_CURSOR_POS = -2;
 534     //  const long TEXT_BOUNDARY_START_OF_WORD = -3;
 535     //  const long TEXT_BOUNDARY_END_OF_WORD = -4;
 536     //  const long TEXT_BOUNDARY_START_OF_SENTENCE = -5;
 537     //  const long TEXT_BOUNDARY_END_OF_SENTENCE = -6;
 538     //  const long TEXT_BOUNDARY_START_OF_LINE = -7;
 539     //  const long TEXT_BOUNDARY_END_OF_LINE = -8;
 540
 541     // In UNO, the corresponding values are as follows:
 542
 543     //  const short CHARACTER = 1;
 544     //  const short WORD = 2;
 545     //  const short SENTENCE = 3;
 546     //  const short PARAGRAPH = 4;
 547     //  const short LINE = 5;
 548     //  const short GLYPH = 6;
 549     //  const short ATTRIBUTE_RUN = 7;
 550
 551
 552     long            lUnoBoundaryType;
 553
 554     switch(boundaryType)
 555     {
 556     case IA2_TEXT_BOUNDARY_CHAR:
 557         lUnoBoundaryType = 1; // CHARACTER;
 558         break;
 559     case IA2_TEXT_BOUNDARY_WORD:
 560         lUnoBoundaryType = 2; // WORD;
 561         break;
 562     case IA2_TEXT_BOUNDARY_SENTENCE:
 563         lUnoBoundaryType = 3; // SENTENCE;
 564         break;
 565     case IA2_TEXT_BOUNDARY_LINE:
 566         lUnoBoundaryType = 5; // LINE;
 567         break;
 568     case IA2_TEXT_BOUNDARY_PARAGRAPH:
 569         lUnoBoundaryType = 4;
 570         break;
 571     case IA2_TEXT_BOUNDARY_ALL:
 572         {
 573             long nChar;
 574             get_nCharacters( &nChar );
 575             *startOffset = 0;
 576             *endOffset = nChar;
 577             return get_text(0, nChar, text);
 578         }
 579         break;
 580     default:
 581         return E_FAIL;
 582     }
 583
 584     TextSegment segment = GetXInterface()->getTextBeforeIndex( offset, sal_Int16(lUnoBoundaryType));
 585     ::rtl::OUString ouStr = segment.SegmentText;
 586     SysFreeString(*text);
 587     *text = SysAllocString((OLECHAR*)ouStr.getStr());
 588     *startOffset = segment.SegmentStart;
 589     *endOffset = segment.SegmentEnd;
 590
 591     return S_OK;
 592
 593     LEAVE_PROTECTED_BLOCK
 594 }
 595
 596 /**
 597    * Get special text after some position.
 598    * @param offset Special position.
 599    * @param boundaryType Boundary type.
 600    * @param startOffset Variant to accept the start offset.
 601    * @param endOffset   Variant to accept the end offset.
 602    * @param text        Variant to accept the special text.
 603    * @return Result.
 604 */
 605 STDMETHODIMP CAccTextBase::get_textAfterOffset(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text)
 606 {
 607     SolarMutexGuard g;
 608
 609     ENTER_PROTECTED_BLOCK
 610
 611     if (startOffset == NULL || endOffset == NULL || text == NULL)
 612         return E_INVALIDARG;
 613     // #CHECK XInterface#
 614     if(!pRXText.is())
 615         return E_FAIL;
 616
 617     // In New UNO IAccessibleText.idl these constant values are defined as follows:
 618
 619     //  const long TEXT_BOUNDARY_CHAR = -1;
 620     //  const long TEXT_BOUNDARY_TO_CURSOR_POS = -2;
 621     //  const long TEXT_BOUNDARY_START_OF_WORD = -3;
 622     //  const long TEXT_BOUNDARY_END_OF_WORD = -4;
 623     //  const long TEXT_BOUNDARY_START_OF_SENTENCE = -5;
 624     //  const long TEXT_BOUNDARY_END_OF_SENTENCE = -6;
 625     //  const long TEXT_BOUNDARY_START_OF_LINE = -7;
 626     //  const long TEXT_BOUNDARY_END_OF_LINE = -8;
 627
 628     // In UNO, the corresponding values are as follows:
 629
 630     //  const short CHARACTER = 1;
 631     //  const short WORD = 2;
 632     //  const short SENTENCE = 3;
 633     //  const short PARAGRAPH = 4;
 634     //  const short LINE = 5;
 635     //  const short GLYPH = 6;
 636     //  const short ATTRIBUTE_RUN = 7;
 637
 638
 639     long            lUnoBoundaryType;
 640     switch(boundaryType)
 641     {
 642     case IA2_TEXT_BOUNDARY_CHAR:
 643         lUnoBoundaryType = 1; // CHARACTER;
 644         break;
 645     case IA2_TEXT_BOUNDARY_WORD:
 646         lUnoBoundaryType = 2; // WORD;
 647         break;
 648     case IA2_TEXT_BOUNDARY_SENTENCE:
 649         lUnoBoundaryType = 3; // SENTENCE;
 650         break;
 651     case IA2_TEXT_BOUNDARY_LINE:
 652         lUnoBoundaryType = 5; // LINE;
 653         break;
 654     case IA2_TEXT_BOUNDARY_PARAGRAPH:
 655         lUnoBoundaryType = 4;
 656         break;
 657     case IA2_TEXT_BOUNDARY_ALL:
 658         {
 659             long nChar;
 660             get_nCharacters( &nChar );
 661             *startOffset = 0;
 662             *endOffset = nChar;
 663             return get_text(0, nChar, text);
 664         }
 665         break;
 666     default:
 667         return E_FAIL;
 668     }
 669
 670     TextSegment segment = GetXInterface()->getTextBehindIndex( offset, sal_Int16(lUnoBoundaryType));
 671     ::rtl::OUString ouStr = segment.SegmentText;
 672     SysFreeString(*text);
 673     *text = SysAllocString((OLECHAR*)ouStr.getStr());
 674     *startOffset = segment.SegmentStart;
 675     *endOffset = segment.SegmentEnd;
 676
 677     return S_OK;
 678
 679     LEAVE_PROTECTED_BLOCK
 680 }
 681
 682 /**
 683    * Get special text at some position.
 684    * @param offset Special position.
 685    * @param boundaryType Boundary type.
 686    * @param startOffset Variant to accept the start offset.
 687    * @param endOffset   Variant to accept the end offset.
 688    * @param text        Variant to accept the special text.
 689    * @return Result.
 690 */
 691 STDMETHODIMP CAccTextBase::get_textAtOffset(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text)
 692 {
 693     SolarMutexGuard g;
 694
 695     ENTER_PROTECTED_BLOCK
 696
 697     if (startOffset == NULL || text == NULL ||endOffset == NULL)
 698         return E_INVALIDARG;
 699     // #CHECK XInterface#
 700     if(!pRXText.is())
 701         return E_FAIL;
 702
 703     // In New UNO IAccessibleText.idl these constant values are defined as follows:
 704
 705     //  const long TEXT_BOUNDARY_CHAR = -1;
 706     //  const long TEXT_BOUNDARY_TO_CURSOR_POS = -2;
 707     //  const long TEXT_BOUNDARY_START_OF_WORD = -3;
 708     //  const long TEXT_BOUNDARY_END_OF_WORD = -4;
 709     //  const long TEXT_BOUNDARY_START_OF_SENTENCE = -5;
 710     //  const long TEXT_BOUNDARY_END_OF_SENTENCE = -6;
 711     //  const long TEXT_BOUNDARY_START_OF_LINE = -7;
 712     //  const long TEXT_BOUNDARY_END_OF_LINE = -8;
 713
 714     // In UNO, the corresponding values are as follows:
 715
 716     //  const short CHARACTER = 1;
 717     //  const short WORD = 2;
 718     //  const short SENTENCE = 3;
 719     //  const short PARAGRAPH = 4;
 720     //  const short LINE = 5;
 721     //  const short GLYPH = 6;
 722     //  const short ATTRIBUTE_RUN = 7;
 723
 724
 725     long            lUnoBoundaryType;
 726
 727     switch(boundaryType)
 728     {
 729     case IA2_TEXT_BOUNDARY_CHAR:
 730         lUnoBoundaryType = 1; // CHARACTER;
 731         break;
 732     case IA2_TEXT_BOUNDARY_WORD:
 733         lUnoBoundaryType = 2; // WORD;
 734         break;
 735     case IA2_TEXT_BOUNDARY_SENTENCE:
 736         lUnoBoundaryType = 3; // SENTENCE;
 737         break;
 738     case IA2_TEXT_BOUNDARY_LINE:
 739         lUnoBoundaryType = 5; // LINE;
 740         break;
 741     case IA2_TEXT_BOUNDARY_PARAGRAPH:
 742         lUnoBoundaryType = 4;
 743         break;
 744     case IA2_TEXT_BOUNDARY_ALL:
 745         {
 746             long nChar;
 747             get_nCharacters( &nChar );
 748             *startOffset = 0;
 749             *endOffset = nChar;
 750             return get_text(0, nChar, text);
 751         }
 752         break;
 753     default:
 754         return E_FAIL;
 755     }
 756
 757     TextSegment segment = GetXInterface()->getTextAtIndex( offset, sal_Int16(lUnoBoundaryType));
 758     ::rtl::OUString ouStr = segment.SegmentText;
 759     SysFreeString(*text);
 760     *text = SysAllocString((OLECHAR*)ouStr.getStr());
 761     *startOffset = segment.SegmentStart;
 762     *endOffset = segment.SegmentEnd;
 763
 764     return S_OK;
 765
 766     LEAVE_PROTECTED_BLOCK
 767 }
 768
 769 /**
 770    * Remove selection.
 771    * @param selectionIndex Special selection index
 772    * @param success Variant to accept the memthod called result.
 773    * @return Result.
 774 */
 775 STDMETHODIMP CAccTextBase::removeSelection(long selectionIndex)
 776 {
 777     SolarMutexGuard g;
 778
 779     ENTER_PROTECTED_BLOCK
 780
 781     // #CHECK XInterface#
 782     if(pUNOInterface == NULL)
 783     {
 784         return E_FAIL;
 785     }
 786
 787     Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext();
 788
 789     Reference< XAccessibleTextSelection > pRExtension(pRContext,UNO_QUERY);
 790
 791     if( pRExtension.is() )
 792     {
 793         pRExtension->removeSelection(selectionIndex);
 794         return S_OK;
 795     }
 796     else
 797     {
 798         GetXInterface()->setSelection(0, 0);
 799         return S_OK;
 800     }
 801
 802     LEAVE_PROTECTED_BLOCK
 803 }
 804
 805 /**
 806    * Set caret position.
 807    * @param offset Special position.
 808    * @param success Variant to accept the memthod called result.
 809    * @return Result.
 810 */
 811 STDMETHODIMP CAccTextBase::setCaretOffset(long offset)
 812 {
 813     SolarMutexGuard g;
 814
 815     ENTER_PROTECTED_BLOCK
 816
 817     // #CHECK XInterface#
 818     if(!pRXText.is())
 819         return E_FAIL;
 820
 821     GetXInterface()->setCaretPosition( offset);
 822
 823     return S_OK;
 824
 825     LEAVE_PROTECTED_BLOCK
 826 }
 827
 828 /**
 829    * Set special selection.
 830    * @param selectionIndex Special selection index.
 831    * @param startOffset start position.
 832    * @param endOffset end position.
 833    * @param success Variant to accept the memthod called result.
 834    * @return Result.
 835 */
 836 STDMETHODIMP CAccTextBase::setSelection(long, long startOffset, long endOffset)
 837 {
 838     SolarMutexGuard g;
 839
 840     ENTER_PROTECTED_BLOCK
 841
 842     // #CHECK XInterface#
 843     if(!pRXText.is())
 844     {
 845         return E_FAIL;
 846     }
 847
 848     GetXInterface()->setSelection( startOffset, endOffset );
 849
 850     return S_OK;
 851
 852     LEAVE_PROTECTED_BLOCK
 853 }
 854
 855 /**
 856    * Get characters count.
 857    * @param nCharacters Variant to accept the characters count.
 858    * @return Result.
 859 */
 860 STDMETHODIMP CAccTextBase::get_nCharacters(long * nCharacters)
 861 {
 862     SolarMutexGuard g;
 863
 864     ENTER_PROTECTED_BLOCK
 865
 866     if (nCharacters == NULL)
 867         return E_INVALIDARG;
 868     // #CHECK XInterface#
 869     if(!pRXText.is())
 870     {
 871         *nCharacters = 0;
 872         return S_OK;
 873     }
 874
 875     *nCharacters = GetXInterface()->getCharacterCount();
 876
 877     return S_OK;
 878
 879     LEAVE_PROTECTED_BLOCK
 880 }
 881
 882 // added by qiuhd, 2006/07/03, for direver 07/11
 883 STDMETHODIMP CAccTextBase::get_newText( IA2TextSegment *)
 884 {
 885     return E_NOTIMPL;
 886 }
 887
 888 STDMETHODIMP CAccTextBase::get_oldText( IA2TextSegment *)
 889 {
 890     return E_NOTIMPL;
 891 }
 892
 893 /**
 894    * Scroll to special sub-string .
 895    * @param startIndex Start index of sub string.
 896    * @param endIndex   End index of sub string.
 897    * @return Result.
 898 */
 899 STDMETHODIMP CAccTextBase::scrollSubstringToPoint(long, long, IA2CoordinateType, long, long )
 900 {
 901     return E_NOTIMPL;
 902 }
 903
 904 STDMETHODIMP CAccTextBase::scrollSubstringTo(long, long, IA2ScrollType)
 905 {
 906     return E_NOTIMPL;
 907 }
 908
 909 /**
 910    * Put UNO interface.
 911    * @param pXInterface UNO interface.
 912    * @return Result.
 913 */
 914 STDMETHODIMP CAccTextBase::put_XInterface(hyper pXInterface)
 915 {
 916     // internal IUNOXWrapper - no mutex meeded
 917
 918     ENTER_PROTECTED_BLOCK
 919
 920     CUNOXWrapper::put_XInterface(pXInterface);
 921     //special query.
 922     if(pUNOInterface == NULL)
 923         return E_FAIL;
 924     Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext();
 925     if( !pRContext.is() )
 926     {
 927         return E_FAIL;
 928     }
 929     Reference<XAccessibleText> pRXI(pRContext,UNO_QUERY);
 930     if( !pRXI.is() )
 931         pRXText = NULL;
 932     else
 933         pRXText = pRXI;
 934     return S_OK;
 935
 936     LEAVE_PROTECTED_BLOCK
 937 }
 938
 939 static OUString ReplaceOneChar(OUString oldOUString, OUString replacedChar, OUString replaceStr)
 940 {
 941     int iReplace = -1;
 942     iReplace = oldOUString.lastIndexOf(replacedChar);
 943     if (iReplace > -1)
 944     {
 945         for(;iReplace>-1;)
 946         {
 947             oldOUString = oldOUString.replaceAt(iReplace,1, replaceStr);
 948             iReplace=oldOUString.lastIndexOf(replacedChar,iReplace);
 949         }
 950     }
 951     return oldOUString;
 952 }
 953
 954 static OUString ReplaceFourChar(OUString oldOUString)
 955 {
 956     oldOUString = ReplaceOneChar(oldOUString, OUString("\\"), OUString("\\\\"));
 957     oldOUString = ReplaceOneChar(oldOUString, OUString(";"), OUString("\\;"));
 958     oldOUString = ReplaceOneChar(oldOUString, OUString("="), OUString("\\="));
 959     oldOUString = ReplaceOneChar(oldOUString, OUString(","), OUString("\\,"));
 960     oldOUString = ReplaceOneChar(oldOUString, OUString(":"), OUString("\\:"));
 961     return oldOUString;
 962 }
 963
 964 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */