LCOV - code coverage report
Current view: top level - sd/source/ui/unoidl - unosrch.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 6 391 1.5 %
Date: 2014-11-03 Functions: 4 48 8.3 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10