sd/source/ui/unoidl/unosrch.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 <memory>
  21 #include <sal/config.h>
  22
  23 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  24 #include <vcl/svapp.hxx>
  25
  26 #include <svx/unoshape.hxx>
  27 #include <svx/svdpool.hxx>
  28 #include <svx/unoprov.hxx>
  29 #include <editeng/unotext.hxx>
  30 #include <tools/debug.hxx>
  31
  32 #include <unoprnms.hxx>
  33 #include <unosrch.hxx>
  34
  35 using namespace ::com::sun::star;
  36
  37 #define WID_SEARCH_BACKWARDS    0
  38 #define WID_SEARCH_CASE         1
  39 #define WID_SEARCH_WORDS        2
  40
  41 static const SfxItemPropertyMapEntry* ImplGetSearchPropertyMap()
  42 {
  43     static const SfxItemPropertyMapEntry aSearchPropertyMap_Impl[] =
  44     {
  45         { OUString(UNO_NAME_SEARCH_BACKWARDS),  WID_SEARCH_BACKWARDS,   cppu::UnoType<bool>::get(),    0,  0 },
  46         { OUString(UNO_NAME_SEARCH_CASE),       WID_SEARCH_CASE,        cppu::UnoType<bool>::get(),    0,  0 },
  47         { OUString(UNO_NAME_SEARCH_WORDS),      WID_SEARCH_WORDS,       cppu::UnoType<bool>::get(),    0,  0 },
  48         { OUString(), 0, css::uno::Type(), 0, 0 }
  49     };
  50
  51     return aSearchPropertyMap_Impl;
  52 }
  53
  54 class SearchContext_impl
  55 {
  56     uno::Reference< drawing::XShapes > mxShapes;
  57     sal_Int32 mnIndex;
  58
  59 public:
  60     SearchContext_impl(uno::Reference<drawing::XShapes> const& xShapes)
  61         : mxShapes( xShapes ), mnIndex( -1 ) {}
  62
  63     uno::Reference< drawing::XShape > firstShape()
  64     {
  65         mnIndex = -1;
  66         return nextShape();
  67     }
  68
  69     uno::Reference< drawing::XShape > nextShape()
  70     {
  71         uno::Reference< drawing::XShape >  xShape;
  72         mnIndex++;
  73         if( mxShapes.is() && mxShapes->getCount() > mnIndex )
  74         {
  75             mxShapes->getByIndex( mnIndex ) >>= xShape;
  76         }
  77         return xShape;
  78     }
  79 };
  80
  81 /* ================================================================= */
  82 /** this class implements a search or replace operation on a given
  83     page or a given sdrobj
  84   */
  85
  86 SdUnoSearchReplaceShape::SdUnoSearchReplaceShape( drawing::XDrawPage* pPage ) throw()
  87     : mpPage(pPage)
  88 {
  89 }
  90
  91 SdUnoSearchReplaceShape::~SdUnoSearchReplaceShape() throw()
  92 {
  93 }
  94
  95 // util::XReplaceable
  96 uno::Reference< util::XReplaceDescriptor > SAL_CALL SdUnoSearchReplaceShape::createReplaceDescriptor()
  97 {
  98     return new SdUnoSearchReplaceDescriptor;
  99 }
 100
 101 sal_Int32 SAL_CALL SdUnoSearchReplaceShape::replaceAll( const uno::Reference< util::XSearchDescriptor >& xDesc )
 102 {
 103     SdUnoSearchReplaceDescriptor* pDescr = SdUnoSearchReplaceDescriptor::getImplementation( xDesc );
 104     if( pDescr == nullptr )
 105         return 0;
 106
 107     sal_Int32 nFound    = 0;
 108
 109     uno::Reference< drawing::XShapes >  xShapes;
 110     uno::Reference< drawing::XShape >  xShape;
 111
 112     std::vector<SearchContext_impl> aContexts;
 113     if(mpPage)
 114     {
 115         uno::Reference< drawing::XDrawPage > xPage( mpPage );
 116
 117         xShapes.set( xPage, uno::UNO_QUERY );
 118
 119         if( xShapes.is() && (xShapes->getCount() > 0) )
 120         {
 121             aContexts.push_back(SearchContext_impl(xShapes));
 122             xShape = aContexts.back().firstShape();
 123         }
 124         else
 125         {
 126             xShapes = nullptr;
 127         }
 128     }
 129
 130     while( xShape.is() )
 131     {
 132         // replace in xShape
 133         uno::Reference< text::XText >  xText(xShape, uno::UNO_QUERY);
 134         uno::Reference< text::XTextRange >  xRange(xText, uno::UNO_QUERY);
 135         uno::Reference< text::XTextRange >  xFound;
 136
 137         while( xRange.is() )
 138         {
 139             xFound = Search( xRange, pDescr );
 140             if( !xFound.is() )
 141                 break;
 142
 143             xFound->setString( pDescr->getReplaceString() );
 144             xRange = xFound->getEnd();
 145             nFound++;
 146         }
 147         // done with xShape -> get next shape
 148
 149         // test if it's a group
 150         uno::Reference< drawing::XShapes > xGroupShape( xShape, uno::UNO_QUERY );
 151         if( xGroupShape.is() && ( xGroupShape->getCount() > 0 ) )
 152         {
 153             aContexts.push_back(SearchContext_impl(xGroupShape));
 154             xShape = aContexts.back().firstShape();
 155         }
 156         else
 157         {
 158             if (!aContexts.empty())
 159                 xShape = aContexts.back().nextShape();
 160             else
 161                 xShape = nullptr;
 162         }
 163
 164         // test parent contexts for next shape if none
 165         // is found in the current context
 166         while (!aContexts.empty() && !xShape.is())
 167         {
 168             aContexts.pop_back();
 169             if (!aContexts.empty())
 170                 xShape = aContexts.back().nextShape();
 171         }
 172     }
 173
 174     return nFound;
 175 }
 176
 177 // XSearchable
 178 uno::Reference< css::util::XSearchDescriptor > SAL_CALL SdUnoSearchReplaceShape::createSearchDescriptor(  )
 179 {
 180     return new SdUnoSearchReplaceDescriptor;
 181 }
 182
 183 uno::Reference< css::container::XIndexAccess > SAL_CALL SdUnoSearchReplaceShape::findAll( const css::uno::Reference< css::util::XSearchDescriptor >& xDesc )
 184 {
 185     SdUnoSearchReplaceDescriptor* pDescr = SdUnoSearchReplaceDescriptor::getImplementation( xDesc );
 186     if( pDescr == nullptr )
 187         return uno::Reference< container::XIndexAccess > ();
 188
 189     sal_Int32 nSequence = 32;
 190     sal_Int32 nFound    = 0;
 191
 192     uno::Sequence < uno::Reference< uno::XInterface >  > aSeq( nSequence );
 193
 194     uno::Reference< uno::XInterface > * pArray = aSeq.getArray();
 195
 196     uno::Reference< drawing::XShapes >  xShapes;
 197     uno::Reference< drawing::XShape >  xShape;
 198
 199     std::vector<SearchContext_impl> aContexts;
 200     if(mpPage)
 201     {
 202         uno::Reference< drawing::XDrawPage >  xPage( mpPage );
 203         xShapes.set( xPage, uno::UNO_QUERY );
 204
 205         if( xShapes.is() && xShapes->getCount() > 0 )
 206         {
 207             aContexts.push_back(SearchContext_impl(xShapes));
 208             xShape = aContexts.back().firstShape();
 209         }
 210         else
 211         {
 212             xShapes = nullptr;
 213         }
 214     }
 215
 216     while( xShape.is() )
 217     {
 218         // find in xShape
 219         uno::Reference< text::XText >  xText(xShape, uno::UNO_QUERY);
 220         uno::Reference< text::XTextRange >  xRange(xText, uno::UNO_QUERY);
 221         uno::Reference< text::XTextRange >  xFound;
 222
 223         while( xRange.is() )
 224         {
 225             xFound = Search( xRange, pDescr );
 226             if( !xFound.is() )
 227                 break;
 228
 229             if( nFound >= nSequence )
 230             {
 231                 nSequence += 32;
 232                 aSeq.realloc( nSequence );
 233                 pArray = aSeq.getArray();
 234             }
 235
 236             pArray[nFound++] = xFound;
 237
 238             xRange = xFound->getEnd();
 239         }
 240         // done with shape -> get next shape
 241
 242         // test if it's a group
 243         uno::Reference< drawing::XShapes >  xGroupShape;
 244         xGroupShape.set( xShape, uno::UNO_QUERY );
 245
 246         if( xGroupShape.is() && xGroupShape->getCount() > 0 )
 247         {
 248             aContexts.push_back(SearchContext_impl(xGroupShape));
 249             xShape = aContexts.back().firstShape();
 250         }
 251         else
 252         {
 253             if (!aContexts.empty())
 254                 xShape = aContexts.back().nextShape();
 255             else
 256                 xShape = nullptr;
 257         }
 258
 259         // test parent contexts for next shape if none
 260         // is found in the current context
 261         while (!aContexts.empty() && !xShape.is())
 262         {
 263             aContexts.pop_back();
 264             if (!aContexts.empty())
 265                 xShape = aContexts.back().nextShape();
 266         }
 267     }
 268
 269     if( nFound != nSequence )
 270         aSeq.realloc( nFound );
 271
 272     uno::Reference<css::container::XIndexAccess> xRet(new SdUnoFindAllAccess(aSeq));
 273     return xRet;
 274 }
 275
 276 uno::Reference< css::uno::XInterface > SAL_CALL SdUnoSearchReplaceShape::findFirst( const css::uno::Reference< css::util::XSearchDescriptor >& xDesc )
 277 {
 278     uno::Reference< text::XTextRange > xRange( GetCurrentShape(), uno::UNO_QUERY );
 279     if( xRange.is() )
 280         return findNext( xRange, xDesc );
 281
 282     return uno::Reference< uno::XInterface > ();
 283 }
 284
 285 uno::Reference< drawing::XShape >  SdUnoSearchReplaceShape::GetCurrentShape() const throw()
 286 {
 287     uno::Reference< drawing::XShape >  xShape;
 288
 289     if( mpPage )
 290     {
 291         uno::Reference< drawing::XDrawPage >  xPage( mpPage );
 292         uno::Reference< container::XIndexAccess >  xShapes( xPage, uno::UNO_QUERY );
 293         if( xShapes.is() )
 294         {
 295             if(xShapes->getCount() > 0)
 296             {
 297                 xShapes->getByIndex(0) >>= xShape;
 298             }
 299         }
 300     }
 301
 302     return xShape;
 303
 304 }
 305
 306 uno::Reference< css::uno::XInterface > SAL_CALL SdUnoSearchReplaceShape::findNext( const css::uno::Reference< css::uno::XInterface >& xStartAt, const css::uno::Reference< css::util::XSearchDescriptor >& xDesc )
 307 {
 308     SdUnoSearchReplaceDescriptor* pDescr = SdUnoSearchReplaceDescriptor::getImplementation( xDesc );
 309
 310     uno::Reference< uno::XInterface > xFound;
 311
 312     uno::Reference< text::XTextRange > xRange( xStartAt, uno::UNO_QUERY );
 313     if(pDescr && xRange.is() )
 314     {
 315
 316         uno::Reference< text::XTextRange > xCurrentRange( xStartAt, uno::UNO_QUERY );
 317
 318         uno::Reference< drawing::XShape > xCurrentShape( GetShape( xCurrentRange ) );
 319
 320         while(!xFound.is() && xRange.is())
 321         {
 322             xFound = Search( xRange, pDescr );
 323             if(!xFound.is())
 324             {
 325                 // we need a new starting range now
 326                 xRange = nullptr;
 327
 328                 if(mpPage)
 329                 {
 330                     uno::Reference< drawing::XDrawPage >  xPage( mpPage );
 331
 332                     // we do a page wide search, so skip to the next shape here
 333                     uno::Reference< container::XIndexAccess > xShapes( xPage, uno::UNO_QUERY );
 334
 335                     // get next shape on our page
 336                     if( xShapes.is() )
 337                     {
 338                         uno::Reference< drawing::XShape > xFound2( GetNextShape( xShapes, xCurrentShape ) );
 339                         if( xFound2.is() && (xFound2.get() != xCurrentShape.get()) )
 340                             xCurrentShape = xFound2;
 341                         else
 342                             xCurrentShape = nullptr;
 343
 344                         xRange.set( xCurrentShape, uno::UNO_QUERY );
 345                         if(!(xCurrentShape.is() && (xRange.is())))
 346                             xRange = nullptr;
 347                     }
 348                 }
 349                 else
 350                 {
 351                     // we search only in this shape, so end search if we have
 352                     // not found anything
 353                 }
 354             }
 355         }
 356     }
 357     return xFound;
 358 }
 359
 360 /** this method returns the shape that follows xCurrentShape in the shape collection xShapes.
 361     It steps recursive into groupshapes and returns the xCurrentShape if it is the last
 362     shape in this collection */
 363 uno::Reference< drawing::XShape >  SdUnoSearchReplaceShape::GetNextShape( const uno::Reference< container::XIndexAccess >&  xShapes, const uno::Reference< drawing::XShape >&  xCurrentShape ) throw()
 364 {
 365     uno::Reference< drawing::XShape >  xFound;
 366
 367     if(xShapes.is() && xCurrentShape.is())
 368     {
 369         const sal_Int32 nCount = xShapes->getCount();
 370         for( sal_Int32 i = 0; i < nCount; i++ )
 371         {
 372             uno::Reference< drawing::XShape > xSearchShape;
 373             xShapes->getByIndex(i) >>= xSearchShape;
 374
 375             if( xSearchShape.is() )
 376             {
 377                 uno::Reference< container::XIndexAccess > xGroup( xSearchShape, uno::UNO_QUERY );
 378
 379                 if( xCurrentShape.get() == xSearchShape.get() )
 380                 {
 381                     if( xGroup.is() && xGroup->getCount() > 0 )
 382                     {
 383                         xGroup->getByIndex( 0 ) >>= xFound;
 384                     }
 385                     else
 386                     {
 387                         i++;
 388                         if( i < nCount )
 389                             xShapes->getByIndex( i ) >>= xFound;
 390                         else
 391                             xFound = xCurrentShape;
 392                     }
 393
 394                     break;
 395                 }
 396                 else if( xGroup.is() )
 397                 {
 398                     xFound = GetNextShape( xGroup, xCurrentShape );
 399                     if( xFound.is() )
 400                     {
 401                         if( xFound.get() == xCurrentShape.get() )
 402                         {
 403                             // the current shape was found at the end of the group
 404                             i++;
 405                             if( i < nCount )
 406                             {
 407                                 xShapes->getByIndex(i) >>= xFound;
 408                             }
 409                         }
 410                         break;
 411                     }
 412                 }
 413             }
 414         }
 415     }
 416
 417     return xFound;
 418 }
 419
 420 uno::Reference< text::XTextRange >  SdUnoSearchReplaceShape::Search( const uno::Reference< text::XTextRange >&  xText, SdUnoSearchReplaceDescriptor* pDescr )
 421 {
 422     if(!xText.is())
 423         return uno::Reference< text::XTextRange > ();
 424
 425     uno::Reference< text::XText > xParent( xText->getText() );
 426
 427     if( !xParent.is() )
 428     {
 429         xParent.set( xText, uno::UNO_QUERY );
 430     }
 431
 432     const OUString aText( xParent->getString() );
 433
 434     const sal_Int32 nTextLen = aText.getLength();
 435
 436     std::unique_ptr<sal_Int32[]> pConvertPos( new sal_Int32[nTextLen+2] );
 437     std::unique_ptr<sal_Int32[]> pConvertPara( new sal_Int32[nTextLen+2] );
 438
 439     const sal_Unicode* pText = aText.getStr();
 440
 441     sal_Int32* pPos = pConvertPos.get();
 442     sal_Int32* pPara = pConvertPara.get();
 443
 444     sal_Int32 nLastPos = 0, nLastPara = 0;
 445
 446     uno::Reference< container::XEnumerationAccess > xEnumAccess( xParent, uno::UNO_QUERY );
 447
 448     // first we fill the arrays with the position and paragraph for every character
 449     // inside the text
 450     if( xEnumAccess.is() )
 451     {
 452         uno::Reference< container::XEnumeration >  xParaEnum( xEnumAccess->createEnumeration() );
 453
 454         while(xParaEnum->hasMoreElements())
 455         {
 456             int ndbg = 0;
 457             uno::Reference< text::XTextContent >  xParagraph( xParaEnum->nextElement(), uno::UNO_QUERY );
 458             if( xParagraph.is() )
 459                 xEnumAccess.set(xParagraph, css::uno::UNO_QUERY);
 460             else
 461                 xEnumAccess.clear();
 462
 463             if( xEnumAccess.is() )
 464             {
 465                  uno::Reference< container::XEnumeration >  xPortionEnum( xEnumAccess->createEnumeration() );
 466                  if( xPortionEnum.is() )
 467                  {
 468                     while(xPortionEnum->hasMoreElements())
 469                     {
 470                         uno::Reference< text::XTextRange >  xPortion( xPortionEnum->nextElement(), uno::UNO_QUERY );
 471                         if( xPortion.is() )
 472                         {
 473                             const OUString aPortion( xPortion->getString() );
 474                             const sal_Int32 nLen = aPortion.getLength();
 475
 476                             ESelection aStartSel( GetSelection( xPortion->getStart() ) );
 477                             ESelection aEndSel( GetSelection( xPortion->getEnd() ) );
 478
 479                             // special case for empty portions with content or length one portions with content (fields)
 480                             if( (aStartSel.nStartPos == aEndSel.nStartPos) || ( (aStartSel.nStartPos == (aEndSel.nStartPos - 1)) && (nLen > 1) ) )
 481                             {
 482                                 for( sal_Int32 i = 0; i < nLen; i++ )
 483                                 {
 484                                     if( ndbg < (nTextLen+2) )
 485                                     {
 486                                         *pPos++ = aStartSel.nStartPos;
 487                                         *pPara++ = aStartSel.nStartPara;
 488
 489                                         ndbg += 1;
 490                                         pText++;
 491                                     }
 492                                     else
 493                                     {
 494                                         OSL_FAIL( "array overflow while searching" );
 495                                     }
 496                                 }
 497
 498                                 nLastPos = aStartSel.nStartPos;
 499                             }
 500                             // normal case
 501                             else
 502                             {
 503                                 for( sal_Int32 i = 0; i < nLen; i++ )
 504                                 {
 505                                     if( ndbg < (nTextLen+2) )
 506                                     {
 507                                         *pPos++ = aStartSel.nStartPos++;
 508                                         *pPara++ = aStartSel.nStartPara;
 509
 510                                         ndbg += 1;
 511                                         pText++;
 512                                     }
 513                                     else
 514                                     {
 515                                         OSL_FAIL( "array overflow while searching" );
 516                                     }
 517                                 }
 518
 519                                 nLastPos = aStartSel.nStartPos - 1;
 520                                 DBG_ASSERT( aEndSel.nStartPos == aStartSel.nStartPos, "Search is not working" );
 521                             }
 522                             nLastPara = aStartSel.nStartPara;
 523                         }
 524                     }
 525                 }
 526             }
 527
 528             if( ndbg < (nTextLen+2) )
 529             {
 530                 *pPos++ = nLastPos + 1;
 531                 *pPara++ = nLastPara;
 532
 533                 pText++;
 534             }
 535             else
 536             {
 537                 OSL_FAIL( "array overflow while searching" );
 538             }
 539         }
 540     }
 541
 542     uno::Reference< text::XTextRange >  xFound;
 543     ESelection aSel;
 544
 545     uno::Reference< text::XTextRange > xRangeRef( xText, uno::UNO_QUERY );
 546     if( xRangeRef.is() )
 547         aSel = GetSelection( xRangeRef );
 548
 549     sal_Int32 nStartPos;
 550     sal_Int32 nEndPos   = 0;
 551     for( nStartPos = 0; nStartPos < nTextLen; nStartPos++ )
 552     {
 553         if( pConvertPara[nStartPos] == aSel.nStartPara && pConvertPos[nStartPos] == aSel.nStartPos )
 554             break;
 555     }
 556
 557     if( Search( aText, nStartPos, nEndPos, pDescr ) )
 558     {
 559         if( nStartPos <= nTextLen && nEndPos <= nTextLen )
 560         {
 561             ESelection aSelection( pConvertPara[nStartPos], pConvertPos[nStartPos],
 562                              pConvertPara[nEndPos], pConvertPos[nEndPos] );
 563             SvxUnoTextRange *pRange;
 564
 565             SvxUnoTextBase* pParent = SvxUnoTextBase::getImplementation( xParent );
 566
 567             if(pParent)
 568             {
 569                 pRange = new SvxUnoTextRange( *pParent );
 570                 xFound = pRange;
 571                 pRange->SetSelection(aSelection);
 572
 573             }
 574         }
 575         else
 576         {
 577             OSL_FAIL("Array overflow while searching!");
 578         }
 579     }
 580
 581     return xFound;
 582 }
 583
 584 bool SdUnoSearchReplaceShape::Search( const OUString& rText, sal_Int32& nStartPos, sal_Int32& nEndPos, SdUnoSearchReplaceDescriptor* pDescr ) throw()
 585 {
 586     OUString aSearchStr( pDescr->getSearchString() );
 587     OUString aText( rText );
 588
 589     if( !pDescr->IsCaseSensitive() )
 590     {
 591         aText = aText.toAsciiLowerCase();
 592         aSearchStr = aSearchStr.toAsciiLowerCase();
 593     }
 594
 595     sal_Int32 nFound = aText.indexOf( aSearchStr, nStartPos );
 596     if( nFound != -1 )
 597     {
 598         nStartPos = nFound;
 599         nEndPos   = nFound + aSearchStr.getLength();
 600
 601         if(pDescr->IsWords())
 602         {
 603             if( (nStartPos > 0 && aText[nStartPos-1] > ' ') ||
 604                 (nEndPos < aText.getLength() && aText[nEndPos] > ' ') )
 605             {
 606                 nStartPos++;
 607                 return Search( aText, nStartPos, nEndPos, pDescr );
 608             }
 609         }
 610
 611         return true;
 612     }
 613     else
 614         return false;
 615 }
 616
 617 ESelection SdUnoSearchReplaceShape::GetSelection( const uno::Reference< text::XTextRange >&  xTextRange ) throw()
 618 {
 619     ESelection aSel;
 620     SvxUnoTextRangeBase* pRange = SvxUnoTextRangeBase::getImplementation( xTextRange );
 621
 622     if(pRange)
 623         aSel = pRange->GetSelection();
 624
 625     return aSel;
 626 }
 627
 628 uno::Reference< drawing::XShape >  SdUnoSearchReplaceShape::GetShape( const uno::Reference< text::XTextRange >&  xTextRange ) throw()
 629 {
 630     uno::Reference< drawing::XShape >  xShape;
 631
 632     if(xTextRange.is())
 633     {
 634         uno::Reference< text::XText >  xText( xTextRange->getText() );
 635
 636         if(xText.is())
 637         {
 638             do
 639             {
 640                 xShape.set( xText, uno::UNO_QUERY );
 641                 if(!xShape.is())
 642                 {
 643                     uno::Reference< text::XText > xParent( xText->getText() );
 644                     if(!xParent.is() || xText.get() == xParent.get())
 645                         return xShape;
 646
 647                     xText = xParent;
 648                 }
 649             } while( !xShape.is() );
 650         }
 651     }
 652
 653     return xShape;
 654 }
 655
 656 /* ================================================================= */
 657 /** this class holds the parameters and status of a search or replace
 658     operation performed by class SdUnoSearchReplaceShape
 659   */
 660
 661 UNO3_GETIMPLEMENTATION_IMPL( SdUnoSearchReplaceDescriptor );
 662
 663 SdUnoSearchReplaceDescriptor::SdUnoSearchReplaceDescriptor()
 664 {
 665     mpPropSet.reset( new SvxItemPropertySet(ImplGetSearchPropertyMap(), SdrObject::GetGlobalDrawObjectItemPool()) );
 666
 667     mbBackwards = false;
 668     mbCaseSensitive = false;
 669     mbWords = false;
 670 }
 671
 672 SdUnoSearchReplaceDescriptor::~SdUnoSearchReplaceDescriptor() throw()
 673 {
 674 }
 675
 676 // XSearchDescriptor
 677 OUString SAL_CALL SdUnoSearchReplaceDescriptor::getSearchString()
 678 {
 679     return maSearchStr;
 680 }
 681
 682 void SAL_CALL SdUnoSearchReplaceDescriptor::setSearchString( const OUString& aString )
 683 {
 684     maSearchStr = aString;
 685 }
 686
 687 // XReplaceDescriptor
 688 OUString SAL_CALL SdUnoSearchReplaceDescriptor::getReplaceString()
 689 {
 690     return maReplaceStr;
 691 }
 692
 693 void SAL_CALL SdUnoSearchReplaceDescriptor::setReplaceString( const OUString& aReplaceString )
 694 {
 695     maReplaceStr = aReplaceString;
 696 }
 697
 698 // XPropertySet
 699 uno::Reference< css::beans::XPropertySetInfo > SAL_CALL SdUnoSearchReplaceDescriptor::getPropertySetInfo()
 700 {
 701     SolarMutexGuard aGuard;
 702     return mpPropSet->getPropertySetInfo();
 703 }
 704
 705 void SAL_CALL SdUnoSearchReplaceDescriptor::setPropertyValue( const OUString& aPropertyName, const css::uno::Any& aValue )
 706 {
 707     SolarMutexGuard aGuard;
 708
 709     const SfxItemPropertySimpleEntry* pEntry = mpPropSet->getPropertyMapEntry(aPropertyName);
 710
 711     bool bOk = false;
 712
 713     switch( pEntry ? pEntry->nWID : -1 )
 714     {
 715     case WID_SEARCH_BACKWARDS:
 716         bOk = (aValue >>= mbBackwards);
 717         break;
 718     case WID_SEARCH_CASE:
 719         bOk = (aValue >>= mbCaseSensitive);
 720         break;
 721     case WID_SEARCH_WORDS:
 722         bOk = (aValue >>= mbWords);
 723         break;
 724     default:
 725         throw beans::UnknownPropertyException( aPropertyName, static_cast<cppu::OWeakObject*>(this));
 726     }
 727
 728     if( !bOk )
 729         throw lang::IllegalArgumentException();
 730 }
 731
 732 uno::Any SAL_CALL SdUnoSearchReplaceDescriptor::getPropertyValue( const OUString& PropertyName )
 733 {
 734     SolarMutexGuard aGuard;
 735
 736     uno::Any aAny;
 737
 738     const SfxItemPropertySimpleEntry* pEntry = mpPropSet->getPropertyMapEntry(PropertyName);
 739
 740     switch( pEntry ? pEntry->nWID : -1 )
 741     {
 742     case WID_SEARCH_BACKWARDS:
 743         aAny <<= mbBackwards;
 744         break;
 745     case WID_SEARCH_CASE:
 746         aAny <<= mbCaseSensitive;
 747         break;
 748     case WID_SEARCH_WORDS:
 749         aAny <<= mbWords;
 750         break;
 751     default:
 752         throw beans::UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this));
 753     }
 754
 755     return aAny;
 756 }
 757
 758 void SAL_CALL SdUnoSearchReplaceDescriptor::addPropertyChangeListener( const OUString& , const css::uno::Reference< css::beans::XPropertyChangeListener >&  ) {}
 759 void SAL_CALL SdUnoSearchReplaceDescriptor::removePropertyChangeListener( const OUString& , const css::uno::Reference< css::beans::XPropertyChangeListener >&  ) {}
 760 void SAL_CALL SdUnoSearchReplaceDescriptor::addVetoableChangeListener( const OUString& , const css::uno::Reference< css::beans::XVetoableChangeListener >&  ) {}
 761 void SAL_CALL SdUnoSearchReplaceDescriptor::removeVetoableChangeListener( const OUString& , const css::uno::Reference< css::beans::XVetoableChangeListener >&  ) {}
 762
 763 /* ================================================================= */
 764
 765 SdUnoFindAllAccess::SdUnoFindAllAccess( uno::Sequence< uno::Reference< uno::XInterface >  > const & rSequence ) throw()
 766 :maSequence( rSequence )
 767 {
 768 }
 769
 770 SdUnoFindAllAccess::~SdUnoFindAllAccess() throw()
 771 {
 772 }
 773
 774 // XElementAccess
 775 uno::Type SAL_CALL SdUnoFindAllAccess::getElementType()
 776 {
 777     return cppu::UnoType<text::XTextRange>::get();
 778 }
 779
 780 sal_Bool SAL_CALL SdUnoFindAllAccess::hasElements()
 781 {
 782     return maSequence.hasElements();
 783 }
 784
 785 // XIndexAccess
 786 sal_Int32 SAL_CALL SdUnoFindAllAccess::getCount()
 787 {
 788     return maSequence.getLength();
 789 }
 790
 791 uno::Any SAL_CALL SdUnoFindAllAccess::getByIndex( sal_Int32 Index )
 792 {
 793     if( Index < 0 || Index >= getCount() )
 794         throw lang::IndexOutOfBoundsException();
 795
 796     uno::Any aAny;
 797     aAny <<= maSequence[Index];
 798     return aAny;
 799 }
 800
 801 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */