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/drawing/XShapes.hpp>
  24 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  25 #include <vcl/svapp.hxx>
  26
  27 #include <svx/svdobj.hxx>
  28 #include <svx/svdpool.hxx>
  29 #include <editeng/unoipset.hxx>
  30 #include <editeng/unotext.hxx>
  31 #include <tools/debug.hxx>
  32
  33 #include <unoprnms.hxx>
  34 #include <unosrch.hxx>
  35
  36 using namespace ::com::sun::star;
  37
  38 #define WID_SEARCH_BACKWARDS    0
  39 #define WID_SEARCH_CASE         1
  40 #define WID_SEARCH_WORDS        2
  41
  42 static const SfxItemPropertyMapEntry* ImplGetSearchPropertyMap()
  43 {
  44     static const SfxItemPropertyMapEntry aSearchPropertyMap_Impl[] =
  45     {
  46         { OUString(UNO_NAME_SEARCH_BACKWARDS),  WID_SEARCH_BACKWARDS,   cppu::UnoType<bool>::get(),    0,  0 },
  47         { OUString(UNO_NAME_SEARCH_CASE),       WID_SEARCH_CASE,        cppu::UnoType<bool>::get(),    0,  0 },
  48         { OUString(UNO_NAME_SEARCH_WORDS),      WID_SEARCH_WORDS,       cppu::UnoType<bool>::get(),    0,  0 },
  49         { OUString(), 0, css::uno::Type(), 0, 0 }
  50     };
  51
  52     return aSearchPropertyMap_Impl;
  53 }
  54
  55 class SearchContext_impl
  56 {
  57     uno::Reference< drawing::XShapes > mxShapes;
  58     sal_Int32 mnIndex;
  59
  60 public:
  61     SearchContext_impl(uno::Reference<drawing::XShapes> const& xShapes)
  62         : mxShapes( xShapes ), mnIndex( -1 ) {}
  63
  64     uno::Reference< drawing::XShape > firstShape()
  65     {
  66         mnIndex = -1;
  67         return nextShape();
  68     }
  69
  70     uno::Reference< drawing::XShape > nextShape()
  71     {
  72         uno::Reference< drawing::XShape >  xShape;
  73         mnIndex++;
  74         if( mxShapes.is() && mxShapes->getCount() > mnIndex )
  75         {
  76             mxShapes->getByIndex( mnIndex ) >>= xShape;
  77         }
  78         return xShape;
  79     }
  80 };
  81
  82 /* ================================================================= */
  83 /** this class implements a search or replace operation on a given
  84     page or a given sdrobj
  85   */
  86
  87 SdUnoSearchReplaceShape::SdUnoSearchReplaceShape( drawing::XDrawPage* pPage ) throw()
  88     : mpPage(pPage)
  89 {
  90 }
  91
  92 SdUnoSearchReplaceShape::~SdUnoSearchReplaceShape() throw()
  93 {
  94 }
  95
  96 // util::XReplaceable
  97 uno::Reference< util::XReplaceDescriptor > SAL_CALL SdUnoSearchReplaceShape::createReplaceDescriptor()
  98 {
  99     return new SdUnoSearchReplaceDescriptor;
 100 }
 101
 102 sal_Int32 SAL_CALL SdUnoSearchReplaceShape::replaceAll( const uno::Reference< util::XSearchDescriptor >& xDesc )
 103 {
 104     SdUnoSearchReplaceDescriptor* pDescr = comphelper::getUnoTunnelImplementation<SdUnoSearchReplaceDescriptor>( xDesc );
 105     if( pDescr == nullptr )
 106         return 0;
 107
 108     sal_Int32 nFound    = 0;
 109
 110     uno::Reference< drawing::XShapes >  xShapes;
 111     uno::Reference< drawing::XShape >  xShape;
 112
 113     std::vector<SearchContext_impl> aContexts;
 114     if(mpPage)
 115     {
 116         uno::Reference< drawing::XDrawPage > xPage( mpPage );
 117
 118         xShapes.set( xPage, uno::UNO_QUERY );
 119
 120         if( xShapes.is() && (xShapes->getCount() > 0) )
 121         {
 122             aContexts.push_back(SearchContext_impl(xShapes));
 123             xShape = aContexts.back().firstShape();
 124         }
 125         else
 126         {
 127             xShapes = nullptr;
 128         }
 129     }
 130
 131     while( xShape.is() )
 132     {
 133         // replace in xShape
 134         uno::Reference< text::XText >  xText(xShape, uno::UNO_QUERY);
 135         uno::Reference< text::XTextRange >  xRange = xText;
 136         uno::Reference< text::XTextRange >  xFound;
 137
 138         while( xRange.is() )
 139         {
 140             xFound = Search( xRange, pDescr );
 141             if( !xFound.is() )
 142                 break;
 143
 144             xFound->setString( pDescr->getReplaceString() );
 145             xRange = xFound->getEnd();
 146             nFound++;
 147         }
 148         // done with xShape -> get next shape
 149
 150         // test if it's a group
 151         uno::Reference< drawing::XShapes > xGroupShape( xShape, uno::UNO_QUERY );
 152         if( xGroupShape.is() && ( xGroupShape->getCount() > 0 ) )
 153         {
 154             aContexts.push_back(SearchContext_impl(xGroupShape));
 155             xShape = aContexts.back().firstShape();
 156         }
 157         else
 158         {
 159             if (!aContexts.empty())
 160                 xShape = aContexts.back().nextShape();
 161             else
 162                 xShape = nullptr;
 163         }
 164
 165         // test parent contexts for next shape if none
 166         // is found in the current context
 167         while (!aContexts.empty() && !xShape.is())
 168         {
 169             aContexts.pop_back();
 170             if (!aContexts.empty())
 171                 xShape = aContexts.back().nextShape();
 172         }
 173     }
 174
 175     return nFound;
 176 }
 177
 178 // XSearchable
 179 uno::Reference< css::util::XSearchDescriptor > SAL_CALL SdUnoSearchReplaceShape::createSearchDescriptor(  )
 180 {
 181     return new SdUnoSearchReplaceDescriptor;
 182 }
 183
 184 uno::Reference< css::container::XIndexAccess > SAL_CALL SdUnoSearchReplaceShape::findAll( const css::uno::Reference< css::util::XSearchDescriptor >& xDesc )
 185 {
 186     SdUnoSearchReplaceDescriptor* pDescr = comphelper::getUnoTunnelImplementation<SdUnoSearchReplaceDescriptor>( xDesc );
 187     if( pDescr == nullptr )
 188         return uno::Reference< container::XIndexAccess > ();
 189
 190     sal_Int32 nSequence = 32;
 191     sal_Int32 nFound    = 0;
 192
 193     uno::Sequence < uno::Reference< uno::XInterface >  > aSeq( nSequence );
 194
 195     uno::Reference< uno::XInterface > * pArray = aSeq.getArray();
 196
 197     uno::Reference< drawing::XShapes >  xShapes;
 198     uno::Reference< drawing::XShape >  xShape;
 199
 200     std::vector<SearchContext_impl> aContexts;
 201     if(mpPage)
 202     {
 203         uno::Reference< drawing::XDrawPage >  xPage( mpPage );
 204         xShapes.set( xPage, uno::UNO_QUERY );
 205
 206         if( xShapes.is() && xShapes->getCount() > 0 )
 207         {
 208             aContexts.push_back(SearchContext_impl(xShapes));
 209             xShape = aContexts.back().firstShape();
 210         }
 211         else
 212         {
 213             xShapes = nullptr;
 214         }
 215     }
 216
 217     while( xShape.is() )
 218     {
 219         // find in xShape
 220         uno::Reference< text::XText >  xText(xShape, uno::UNO_QUERY);
 221         uno::Reference< text::XTextRange >  xRange = xText;
 222         uno::Reference< text::XTextRange >  xFound;
 223
 224         while( xRange.is() )
 225         {
 226             xFound = Search( xRange, pDescr );
 227             if( !xFound.is() )
 228                 break;
 229
 230             if( nFound >= nSequence )
 231             {
 232                 nSequence += 32;
 233                 aSeq.realloc( nSequence );
 234                 pArray = aSeq.getArray();
 235             }
 236
 237             pArray[nFound++] = xFound;
 238
 239             xRange = xFound->getEnd();
 240         }
 241         // done with shape -> get next shape
 242
 243         // test if it's a group
 244         uno::Reference< drawing::XShapes >  xGroupShape;
 245         xGroupShape.set( xShape, uno::UNO_QUERY );
 246
 247         if( xGroupShape.is() && xGroupShape->getCount() > 0 )
 248         {
 249             aContexts.push_back(SearchContext_impl(xGroupShape));
 250             xShape = aContexts.back().firstShape();
 251         }
 252         else
 253         {
 254             if (!aContexts.empty())
 255                 xShape = aContexts.back().nextShape();
 256             else
 257                 xShape = nullptr;
 258         }
 259
 260         // test parent contexts for next shape if none
 261         // is found in the current context
 262         while (!aContexts.empty() && !xShape.is())
 263         {
 264             aContexts.pop_back();
 265             if (!aContexts.empty())
 266                 xShape = aContexts.back().nextShape();
 267         }
 268     }
 269
 270     if( nFound != nSequence )
 271         aSeq.realloc( nFound );
 272
 273     uno::Reference<css::container::XIndexAccess> xRet(new SdUnoFindAllAccess(aSeq));
 274     return xRet;
 275 }
 276
 277 uno::Reference< css::uno::XInterface > SAL_CALL SdUnoSearchReplaceShape::findFirst( const css::uno::Reference< css::util::XSearchDescriptor >& xDesc )
 278 {
 279     uno::Reference< text::XTextRange > xRange( GetCurrentShape(), uno::UNO_QUERY );
 280     if( xRange.is() )
 281         return findNext( xRange, xDesc );
 282
 283     return uno::Reference< uno::XInterface > ();
 284 }
 285
 286 uno::Reference< drawing::XShape >  SdUnoSearchReplaceShape::GetCurrentShape() const throw()
 287 {
 288     uno::Reference< drawing::XShape >  xShape;
 289
 290     if( mpPage )
 291     {
 292         uno::Reference< drawing::XDrawPage >  xPage( mpPage );
 293         uno::Reference< container::XIndexAccess >  xShapes( xPage, uno::UNO_QUERY );
 294         if( xShapes.is() )
 295         {
 296             if(xShapes->getCount() > 0)
 297             {
 298                 xShapes->getByIndex(0) >>= xShape;
 299             }
 300         }
 301     }
 302
 303     return xShape;
 304
 305 }
 306
 307 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 )
 308 {
 309     SdUnoSearchReplaceDescriptor* pDescr = comphelper::getUnoTunnelImplementation<SdUnoSearchReplaceDescriptor>( xDesc );
 310
 311     uno::Reference< uno::XInterface > xFound;
 312
 313     uno::Reference< text::XTextRange > xRange( xStartAt, uno::UNO_QUERY );
 314     if(pDescr && xRange.is() )
 315     {
 316
 317         uno::Reference< text::XTextRange > xCurrentRange( xStartAt, uno::UNO_QUERY );
 318
 319         uno::Reference< drawing::XShape > xCurrentShape( GetShape( xCurrentRange ) );
 320
 321         while(!xFound.is() && xRange.is())
 322         {
 323             xFound = Search( xRange, pDescr );
 324             if(!xFound.is())
 325             {
 326                 // we need a new starting range now
 327                 xRange = nullptr;
 328
 329                 if(mpPage)
 330                 {
 331                     uno::Reference< drawing::XDrawPage >  xPage( mpPage );
 332
 333                     // we do a page wide search, so skip to the next shape here
 334                     uno::Reference< container::XIndexAccess > xShapes( xPage, uno::UNO_QUERY );
 335
 336                     // get next shape on our page
 337                     if( xShapes.is() )
 338                     {
 339                         uno::Reference< drawing::XShape > xFound2( GetNextShape( xShapes, xCurrentShape ) );
 340                         if( xFound2.is() && (xFound2.get() != xCurrentShape.get()) )
 341                             xCurrentShape = xFound2;
 342                         else
 343                             xCurrentShape = nullptr;
 344
 345                         xRange.set( xCurrentShape, uno::UNO_QUERY );
 346                         if(!(xCurrentShape.is() && (xRange.is())))
 347                             xRange = nullptr;
 348                     }
 349                 }
 350                 else
 351                 {
 352                     // we search only in this shape, so end search if we have
 353                     // not found anything
 354                 }
 355             }
 356         }
 357     }
 358     return xFound;
 359 }
 360
 361 /** this method returns the shape that follows xCurrentShape in the shape collection xShapes.
 362     It steps recursive into groupshapes and returns the xCurrentShape if it is the last
 363     shape in this collection */
 364 uno::Reference< drawing::XShape >  SdUnoSearchReplaceShape::GetNextShape( const uno::Reference< container::XIndexAccess >&  xShapes, const uno::Reference< drawing::XShape >&  xCurrentShape ) throw()
 365 {
 366     uno::Reference< drawing::XShape >  xFound;
 367
 368     if(xShapes.is() && xCurrentShape.is())
 369     {
 370         const sal_Int32 nCount = xShapes->getCount();
 371         for( sal_Int32 i = 0; i < nCount; i++ )
 372         {
 373             uno::Reference< drawing::XShape > xSearchShape;
 374             xShapes->getByIndex(i) >>= xSearchShape;
 375
 376             if( xSearchShape.is() )
 377             {
 378                 uno::Reference< container::XIndexAccess > xGroup( xSearchShape, uno::UNO_QUERY );
 379
 380                 if( xCurrentShape.get() == xSearchShape.get() )
 381                 {
 382                     if( xGroup.is() && xGroup->getCount() > 0 )
 383                     {
 384                         xGroup->getByIndex( 0 ) >>= xFound;
 385                     }
 386                     else
 387                     {
 388                         i++;
 389                         if( i < nCount )
 390                             xShapes->getByIndex( i ) >>= xFound;
 391                         else
 392                             xFound = xCurrentShape;
 393                     }
 394
 395                     break;
 396                 }
 397                 else if( xGroup.is() )
 398                 {
 399                     xFound = GetNextShape( xGroup, xCurrentShape );
 400                     if( xFound.is() )
 401                     {
 402                         if( xFound.get() == xCurrentShape.get() )
 403                         {
 404                             // the current shape was found at the end of the group
 405                             i++;
 406                             if( i < nCount )
 407                             {
 408                                 xShapes->getByIndex(i) >>= xFound;
 409                             }
 410                         }
 411                         break;
 412                     }
 413                 }
 414             }
 415         }
 416     }
 417
 418     return xFound;
 419 }
 420
 421 uno::Reference< text::XTextRange >  SdUnoSearchReplaceShape::Search( const uno::Reference< text::XTextRange >&  xText, SdUnoSearchReplaceDescriptor* pDescr )
 422 {
 423     if(!xText.is())
 424         return uno::Reference< text::XTextRange > ();
 425
 426     uno::Reference< text::XText > xParent( xText->getText() );
 427
 428     if( !xParent.is() )
 429     {
 430         xParent.set( xText, uno::UNO_QUERY );
 431     }
 432
 433     const OUString aText( xParent->getString() );
 434
 435     const sal_Int32 nTextLen = aText.getLength();
 436
 437     std::unique_ptr<sal_Int32[]> pConvertPos( new sal_Int32[nTextLen+2] );
 438     std::unique_ptr<sal_Int32[]> pConvertPara( new sal_Int32[nTextLen+2] );
 439
 440     const sal_Unicode* pText = aText.getStr();
 441
 442     sal_Int32* pPos = pConvertPos.get();
 443     sal_Int32* pPara = pConvertPara.get();
 444
 445     sal_Int32 nLastPos = 0, nLastPara = 0;
 446
 447     uno::Reference< container::XEnumerationAccess > xEnumAccess( xParent, uno::UNO_QUERY );
 448
 449     // first we fill the arrays with the position and paragraph for every character
 450     // inside the text
 451     if( xEnumAccess.is() )
 452     {
 453         uno::Reference< container::XEnumeration >  xParaEnum( xEnumAccess->createEnumeration() );
 454
 455         while(xParaEnum->hasMoreElements())
 456         {
 457             int ndbg = 0;
 458             uno::Reference< text::XTextContent >  xParagraph( xParaEnum->nextElement(), uno::UNO_QUERY );
 459             if( xParagraph.is() )
 460                 xEnumAccess.set(xParagraph, css::uno::UNO_QUERY);
 461             else
 462                 xEnumAccess.clear();
 463
 464             if( xEnumAccess.is() )
 465             {
 466                  uno::Reference< container::XEnumeration >  xPortionEnum( xEnumAccess->createEnumeration() );
 467                  if( xPortionEnum.is() )
 468                  {
 469                     while(xPortionEnum->hasMoreElements())
 470                     {
 471                         uno::Reference< text::XTextRange >  xPortion( xPortionEnum->nextElement(), uno::UNO_QUERY );
 472                         if( xPortion.is() )
 473                         {
 474                             const OUString aPortion( xPortion->getString() );
 475                             const sal_Int32 nLen = aPortion.getLength();
 476
 477                             ESelection aStartSel( GetSelection( xPortion->getStart() ) );
 478                             ESelection aEndSel( GetSelection( xPortion->getEnd() ) );
 479
 480                             // special case for empty portions with content or length one portions with content (fields)
 481                             if( (aStartSel.nStartPos == aEndSel.nStartPos) || ( (aStartSel.nStartPos == (aEndSel.nStartPos - 1)) && (nLen > 1) ) )
 482                             {
 483                                 for( sal_Int32 i = 0; i < nLen; i++ )
 484                                 {
 485                                     if( ndbg < (nTextLen+2) )
 486                                     {
 487                                         *pPos++ = aStartSel.nStartPos;
 488                                         *pPara++ = aStartSel.nStartPara;
 489
 490                                         ndbg += 1;
 491                                         pText++;
 492                                     }
 493                                     else
 494                                     {
 495                                         OSL_FAIL( "array overflow while searching" );
 496                                     }
 497                                 }
 498
 499                                 nLastPos = aStartSel.nStartPos;
 500                             }
 501                             // normal case
 502                             else
 503                             {
 504                                 for( sal_Int32 i = 0; i < nLen; i++ )
 505                                 {
 506                                     if( ndbg < (nTextLen+2) )
 507                                     {
 508                                         *pPos++ = aStartSel.nStartPos++;
 509                                         *pPara++ = aStartSel.nStartPara;
 510
 511                                         ndbg += 1;
 512                                         pText++;
 513                                     }
 514                                     else
 515                                     {
 516                                         OSL_FAIL( "array overflow while searching" );
 517                                     }
 518                                 }
 519
 520                                 nLastPos = aStartSel.nStartPos - 1;
 521                                 DBG_ASSERT( aEndSel.nStartPos == aStartSel.nStartPos, "Search is not working" );
 522                             }
 523                             nLastPara = aStartSel.nStartPara;
 524                         }
 525                     }
 526                 }
 527             }
 528
 529             if( ndbg < (nTextLen+2) )
 530             {
 531                 *pPos++ = nLastPos + 1;
 532                 *pPara++ = nLastPara;
 533
 534                 pText++;
 535             }
 536             else
 537             {
 538                 OSL_FAIL( "array overflow while searching" );
 539             }
 540         }
 541     }
 542
 543     uno::Reference< text::XTextRange >  xFound;
 544     ESelection aSel;
 545
 546     if( xText.is() )
 547         aSel = GetSelection( xText );
 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 = comphelper::getUnoTunnelImplementation<SvxUnoTextBase>( 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 = comphelper::getUnoTunnelImplementation<SvxUnoTextRangeBase>( 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: */