LCOV - code coverage report
Current view: top level - sc/source/core/tool - rangeutl.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 182 506 36.0 %
Date: 2015-06-13 12:38:46 Functions: 21 37 56.8 %
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 "rangeutl.hxx"
      21             : #include "document.hxx"
      22             : #include "global.hxx"
      23             : #include "dbdata.hxx"
      24             : #include "rangenam.hxx"
      25             : #include "scresid.hxx"
      26             : #include "globstr.hrc"
      27             : #include "convuno.hxx"
      28             : #include "externalrefmgr.hxx"
      29             : #include "compiler.hxx"
      30             : 
      31             : using ::formula::FormulaGrammar;
      32             : using namespace ::com::sun::star;
      33             : 
      34           0 : bool ScRangeUtil::MakeArea( const OUString&   rAreaStr,
      35             :                             ScArea&         rArea,
      36             :                             ScDocument*     pDoc,
      37             :                             SCTAB           nTab,
      38             :                             ScAddress::Details const & rDetails )
      39             : {
      40             :     // Input in rAreaStr: "$Tabelle1.$A1:$D17"
      41             : 
      42             :     // BROKEN BROKEN BROKEN
      43             :     // but it is only used in the consolidate dialog.  Ignore for now.
      44             : 
      45           0 :     bool        nSuccess    = false;
      46           0 :     sal_Int32       nPointPos   = rAreaStr.indexOf('.');
      47           0 :     sal_Int32       nColonPos   = rAreaStr.indexOf(':');
      48           0 :     OUString      aStrArea( rAreaStr );
      49           0 :     ScRefAddress    startPos;
      50           0 :     ScRefAddress    endPos;
      51             : 
      52           0 :     if ( nColonPos == -1  && nPointPos != -1 )
      53             :     {
      54           0 :         aStrArea += ":";
      55           0 :         aStrArea += rAreaStr.copy( nPointPos+1 ); // do not include '.' in copy
      56             :     }
      57             : 
      58           0 :     nSuccess = ConvertDoubleRef( pDoc, aStrArea, nTab, startPos, endPos, rDetails );
      59             : 
      60           0 :     if ( nSuccess )
      61           0 :         rArea = ScArea( startPos.Tab(),
      62           0 :                         startPos.Col(), startPos.Row(),
      63           0 :                         endPos.Col(),   endPos.Row() );
      64             : 
      65           0 :     return nSuccess;
      66             : }
      67             : 
      68           0 : void ScRangeUtil::CutPosString( const OUString&   theAreaStr,
      69             :                                 OUString&         thePosStr )
      70             : {
      71           0 :     OUString  aPosStr;
      72             :     // BROKEN BROKEN BROKEN
      73             :     // but it is only used in the consolidate dialog.  Ignore for now.
      74             : 
      75           0 :     sal_Int32  nColonPos = theAreaStr.indexOf(':');
      76             : 
      77           0 :     if ( nColonPos != -1 )
      78           0 :         aPosStr = theAreaStr.copy( 0, nColonPos ); // do not include ':' in copy
      79             :     else
      80           0 :         aPosStr = theAreaStr;
      81             : 
      82           0 :     thePosStr = aPosStr;
      83           0 : }
      84             : 
      85           0 : bool ScRangeUtil::IsAbsTabArea( const OUString&   rAreaStr,
      86             :                                 ScDocument*     pDoc,
      87             :                                 ScArea***       pppAreas,
      88             :                                 sal_uInt16*         pAreaCount,
      89             :                                 bool            /* bAcceptCellRef */,
      90             :                                 ScAddress::Details const & rDetails )
      91             : {
      92             :     OSL_ENSURE( pDoc, "No document given!" );
      93           0 :     if ( !pDoc )
      94           0 :         return false;
      95             : 
      96             :     // BROKEN BROKEN BROKEN
      97             :     // but it is only used in the consolidate dialog.  Ignore for now.
      98             : 
      99             :     /*
     100             :      * Expects strings like:
     101             :      *      "$Tabelle1.$A$1:$Tabelle3.$D$17"
     102             :      * If bAcceptCellRef == sal_True then also accept strings like:
     103             :      *      "$Tabelle1.$A$1"
     104             :      *
     105             :      * as result a ScArea-Array is created,
     106             :      * which is published via ppAreas and also has to be deleted this route.
     107             :      */
     108             : 
     109           0 :     bool    bStrOk = false;
     110           0 :     OUString  aTempAreaStr(rAreaStr);
     111           0 :     OUString  aStartPosStr;
     112           0 :     OUString  aEndPosStr;
     113             : 
     114           0 :     if ( -1 == aTempAreaStr.indexOf(':') )
     115             :     {
     116           0 :         aTempAreaStr += ":";
     117           0 :         aTempAreaStr += rAreaStr;
     118             :     }
     119             : 
     120           0 :     sal_Int32   nColonPos = aTempAreaStr.indexOf(':');
     121             : 
     122           0 :     if (   -1 != nColonPos
     123           0 :         && -1 != aTempAreaStr.indexOf('.') )
     124             :     {
     125           0 :         ScRefAddress    aStartPos;
     126           0 :         ScRefAddress    aEndPos;
     127             : 
     128           0 :         aStartPosStr = aTempAreaStr.copy( 0,           nColonPos  );
     129           0 :         aEndPosStr   = aTempAreaStr.copy( nColonPos+1 );
     130             : 
     131           0 :         if ( ConvertSingleRef( pDoc, aStartPosStr, 0, aStartPos, rDetails ) )
     132             :         {
     133           0 :             if ( ConvertSingleRef( pDoc, aEndPosStr, aStartPos.Tab(), aEndPos, rDetails ) )
     134             :             {
     135           0 :                 aStartPos.SetRelCol( false );
     136           0 :                 aStartPos.SetRelRow( false );
     137           0 :                 aStartPos.SetRelTab( false );
     138           0 :                 aEndPos.SetRelCol( false );
     139           0 :                 aEndPos.SetRelRow( false );
     140           0 :                 aEndPos.SetRelTab( false );
     141             : 
     142           0 :                 bStrOk = true;
     143             : 
     144           0 :                 if ( pppAreas && pAreaCount ) // Array returned ?
     145             :                 {
     146           0 :                     SCTAB       nStartTab   = aStartPos.Tab();
     147           0 :                     SCTAB       nEndTab     = aEndPos.Tab();
     148           0 :                     sal_uInt16      nTabCount   = static_cast<sal_uInt16>(nEndTab-nStartTab+1);
     149           0 :                     ScArea**    theAreas    = new ScArea*[nTabCount];
     150           0 :                     SCTAB       nTab        = 0;
     151           0 :                     sal_uInt16      i           = 0;
     152           0 :                     ScArea      theArea( 0, aStartPos.Col(), aStartPos.Row(),
     153           0 :                                             aEndPos.Col(), aEndPos.Row() );
     154             : 
     155           0 :                     nTab = nStartTab;
     156           0 :                     for ( i=0; i<nTabCount; i++ )
     157             :                     {
     158           0 :                         theAreas[i] = new ScArea( theArea );
     159           0 :                         theAreas[i]->nTab = nTab;
     160           0 :                         nTab++;
     161             :                     }
     162           0 :                     *pppAreas   = theAreas;
     163           0 :                     *pAreaCount = nTabCount;
     164             :                 }
     165             :             }
     166             :         }
     167             :     }
     168             : 
     169           0 :     return bStrOk;
     170             : }
     171             : 
     172           0 : bool ScRangeUtil::IsAbsArea( const OUString&  rAreaStr,
     173             :                              ScDocument*    pDoc,
     174             :                              SCTAB          nTab,
     175             :                              OUString*      pCompleteStr,
     176             :                              ScRefAddress*  pStartPos,
     177             :                              ScRefAddress*  pEndPos,
     178             :                              ScAddress::Details const & rDetails )
     179             : {
     180           0 :     ScRefAddress    startPos;
     181           0 :     ScRefAddress    endPos;
     182             : 
     183           0 :     bool bIsAbsArea = ConvertDoubleRef( pDoc, rAreaStr, nTab, startPos, endPos, rDetails );
     184             : 
     185           0 :     if ( bIsAbsArea )
     186             :     {
     187           0 :         startPos.SetRelCol( false );
     188           0 :         startPos.SetRelRow( false );
     189           0 :         startPos.SetRelTab( false );
     190           0 :         endPos  .SetRelCol( false );
     191           0 :         endPos  .SetRelRow( false );
     192           0 :         endPos  .SetRelTab( false );
     193             : 
     194           0 :         if ( pCompleteStr )
     195             :         {
     196           0 :             *pCompleteStr  = startPos.GetRefString( pDoc, MAXTAB+1, rDetails );
     197           0 :             *pCompleteStr += ":";
     198           0 :             *pCompleteStr += endPos  .GetRefString( pDoc, nTab, rDetails );
     199             :         }
     200             : 
     201           0 :         if ( pStartPos && pEndPos )
     202             :         {
     203           0 :             *pStartPos = startPos;
     204           0 :             *pEndPos   = endPos;
     205             :         }
     206             :     }
     207             : 
     208           0 :     return bIsAbsArea;
     209             : }
     210             : 
     211           0 : bool ScRangeUtil::IsAbsPos( const OUString&   rPosStr,
     212             :                             ScDocument*     pDoc,
     213             :                             SCTAB           nTab,
     214             :                             OUString*       pCompleteStr,
     215             :                             ScRefAddress*   pPosTripel,
     216             :                             ScAddress::Details const & rDetails )
     217             : {
     218           0 :     ScRefAddress    thePos;
     219             : 
     220           0 :     bool bIsAbsPos = ConvertSingleRef( pDoc, rPosStr, nTab, thePos, rDetails );
     221           0 :     thePos.SetRelCol( false );
     222           0 :     thePos.SetRelRow( false );
     223           0 :     thePos.SetRelTab( false );
     224             : 
     225           0 :     if ( bIsAbsPos )
     226             :     {
     227           0 :         if ( pPosTripel )
     228           0 :             *pPosTripel = thePos;
     229           0 :         if ( pCompleteStr )
     230           0 :             *pCompleteStr = thePos.GetRefString( pDoc, MAXTAB+1, rDetails );
     231             :     }
     232             : 
     233           0 :     return bIsAbsPos;
     234             : }
     235             : 
     236           0 : bool ScRangeUtil::MakeRangeFromName (
     237             :     const OUString& rName,
     238             :     ScDocument*     pDoc,
     239             :     SCTAB           nCurTab,
     240             :     ScRange&        rRange,
     241             :     RutlNameScope   eScope,
     242             :     ScAddress::Details const & rDetails )
     243             : {
     244           0 :     bool bResult = false;
     245           0 :     ScRangeUtil     aRangeUtil;
     246           0 :     SCTAB nTab = 0;
     247           0 :     SCCOL nColStart = 0;
     248           0 :     SCCOL nColEnd = 0;
     249           0 :     SCROW nRowStart = 0;
     250           0 :     SCROW nRowEnd = 0;
     251             : 
     252           0 :     if( eScope==RUTL_NAMES )
     253             :     {
     254             :         //first handle ui names like local1 (Sheet1), which point to a local range name
     255           0 :         OUString aName(rName);
     256           0 :         sal_Int32 nEndPos = aName.lastIndexOf(')');
     257           0 :         sal_Int32 nStartPos = aName.lastIndexOf(" (");
     258           0 :         SCTAB nTable = nCurTab;
     259           0 :         if (nEndPos != -1 && nStartPos != -1)
     260             :         {
     261           0 :             OUString aSheetName = aName.copy(nStartPos+2, nEndPos-nStartPos-2);
     262           0 :             if (pDoc->GetTable(aSheetName, nTable))
     263             :             {
     264           0 :                 aName = aName.copy(0, nStartPos);
     265             :             }
     266             :             else
     267           0 :                 nTable = nCurTab;
     268             :         }
     269             :         //then check for local range names
     270           0 :         ScRangeName* pRangeNames = pDoc->GetRangeName( nTable );
     271           0 :         ScRangeData* pData = NULL;
     272           0 :         if ( pRangeNames )
     273           0 :             pData = pRangeNames->findByUpperName(ScGlobal::pCharClass->uppercase(aName));
     274           0 :         if (!pData)
     275           0 :             pData = pDoc->GetRangeName()->findByUpperName(ScGlobal::pCharClass->uppercase(aName));
     276           0 :         if (pData)
     277             :         {
     278           0 :             OUString         aStrArea;
     279           0 :             ScRefAddress     aStartPos;
     280           0 :             ScRefAddress     aEndPos;
     281             : 
     282           0 :             pData->GetSymbol( aStrArea );
     283             : 
     284           0 :             if ( IsAbsArea( aStrArea, pDoc, nTable,
     285           0 :                             NULL, &aStartPos, &aEndPos, rDetails ) )
     286             :             {
     287           0 :                 nTab       = aStartPos.Tab();
     288           0 :                 nColStart  = aStartPos.Col();
     289           0 :                 nRowStart  = aStartPos.Row();
     290           0 :                 nColEnd    = aEndPos.Col();
     291           0 :                 nRowEnd    = aEndPos.Row();
     292           0 :                 bResult    = true;
     293             :             }
     294             :             else
     295             :             {
     296           0 :                 CutPosString( aStrArea, aStrArea );
     297             : 
     298           0 :                 if ( IsAbsPos( aStrArea, pDoc, nTable,
     299           0 :                                           NULL, &aStartPos, rDetails ) )
     300             :                 {
     301           0 :                     nTab       = aStartPos.Tab();
     302           0 :                     nColStart  = nColEnd = aStartPos.Col();
     303           0 :                     nRowStart  = nRowEnd = aStartPos.Row();
     304           0 :                     bResult    = true;
     305             :                 }
     306           0 :             }
     307           0 :         }
     308             :     }
     309           0 :     else if( eScope==RUTL_DBASE )
     310             :     {
     311           0 :         ScDBCollection::NamedDBs& rDbNames = pDoc->GetDBCollection()->getNamedDBs();
     312           0 :         ScDBData* pData = rDbNames.findByUpperName(ScGlobal::pCharClass->uppercase(rName));
     313           0 :         if (pData)
     314             :         {
     315           0 :             pData->GetArea(nTab, nColStart, nRowStart, nColEnd, nRowEnd);
     316           0 :             bResult = true;
     317             :         }
     318             :     }
     319             :     else
     320             :     {
     321             :         OSL_FAIL( "ScRangeUtil::MakeRangeFromName" );
     322             :     }
     323             : 
     324           0 :     if( bResult )
     325             :     {
     326           0 :         rRange = ScRange( nColStart, nRowStart, nTab, nColEnd, nRowEnd, nTab );
     327             :     }
     328             : 
     329           0 :     return bResult;
     330             : }
     331             : 
     332          68 : void ScRangeStringConverter::AssignString(
     333             :         OUString& rString,
     334             :         const OUString& rNewStr,
     335             :         bool bAppendStr,
     336             :         sal_Unicode cSeparator)
     337             : {
     338          68 :     if( bAppendStr )
     339             :     {
     340          33 :         if( !rNewStr.isEmpty() )
     341             :         {
     342          33 :             if( !rString.isEmpty() )
     343           7 :                 rString += OUString(cSeparator);
     344          33 :             rString += rNewStr;
     345             :         }
     346             :     }
     347             :     else
     348          35 :         rString = rNewStr;
     349          68 : }
     350             : 
     351        3783 : sal_Int32 ScRangeStringConverter::IndexOf(
     352             :         const OUString& rString,
     353             :         sal_Unicode cSearchChar,
     354             :         sal_Int32 nOffset,
     355             :         sal_Unicode cQuote )
     356             : {
     357        3783 :     sal_Int32       nLength     = rString.getLength();
     358        3783 :     sal_Int32       nIndex      = nOffset;
     359        3783 :     bool            bQuoted     = false;
     360        3783 :     bool        bExitLoop   = false;
     361             : 
     362       66959 :     while( !bExitLoop && (nIndex >= 0 && nIndex < nLength) )
     363             :     {
     364       59393 :         sal_Unicode cCode = rString[ nIndex ];
     365       59393 :         bExitLoop = (cCode == cSearchChar) && !bQuoted;
     366       59393 :         bQuoted = (bQuoted != (cCode == cQuote));
     367       59393 :         if( !bExitLoop )
     368       58782 :             nIndex++;
     369             :     }
     370        3783 :     return (nIndex < nLength) ? nIndex : -1;
     371             : }
     372             : 
     373        3382 : sal_Int32 ScRangeStringConverter::IndexOfDifferent(
     374             :         const OUString& rString,
     375             :         sal_Unicode cSearchChar,
     376             :         sal_Int32 nOffset )
     377             : {
     378        3382 :     sal_Int32       nLength     = rString.getLength();
     379        3382 :     sal_Int32       nIndex      = nOffset;
     380        3382 :     bool        bExitLoop   = false;
     381             : 
     382        7184 :     while( !bExitLoop && (nIndex >= 0 && nIndex < nLength) )
     383             :     {
     384         420 :         bExitLoop = (rString[ nIndex ] != cSearchChar);
     385         420 :         if( !bExitLoop )
     386         210 :             nIndex++;
     387             :     }
     388        3382 :     return (nIndex < nLength) ? nIndex : -1;
     389             : }
     390             : 
     391        6362 : void ScRangeStringConverter::GetTokenByOffset(
     392             :         OUString& rToken,
     393             :         const OUString& rString,
     394             :         sal_Int32& nOffset,
     395             :         sal_Unicode cSeparator,
     396             :         sal_Unicode cQuote)
     397             : {
     398        6362 :     sal_Int32 nLength = rString.getLength();
     399        6362 :     if( nOffset == -1 || nOffset >= nLength )
     400             :     {
     401        2980 :         rToken.clear();
     402        2980 :         nOffset = -1;
     403             :     }
     404             :     else
     405             :     {
     406        3382 :         sal_Int32 nTokenEnd = IndexOf( rString, cSeparator, nOffset, cQuote );
     407        3382 :         if( nTokenEnd < 0 )
     408        3172 :             nTokenEnd = nLength;
     409        3382 :         rToken = rString.copy( nOffset, nTokenEnd - nOffset );
     410             : 
     411        3382 :         sal_Int32 nNextBegin = IndexOfDifferent( rString, cSeparator, nTokenEnd );
     412        3382 :         nOffset = (nNextBegin < 0) ? nLength : nNextBegin;
     413             :     }
     414        6362 : }
     415             : 
     416          59 : void ScRangeStringConverter::AppendTableName(OUStringBuffer& rBuf, const OUString& rTabName, sal_Unicode /* cQuote */)
     417             : {
     418             :     // quote character is always "'"
     419          59 :     OUString aQuotedTab(rTabName);
     420          59 :     ScCompiler::CheckTabQuotes(aQuotedTab, ::formula::FormulaGrammar::CONV_OOO);
     421          59 :     rBuf.append(aQuotedTab);
     422          59 : }
     423             : 
     424           0 : sal_Int32 ScRangeStringConverter::GetTokenCount( const OUString& rString, sal_Unicode cSeparator, sal_Unicode cQuote )
     425             : {
     426           0 :     OUString    sToken;
     427           0 :     sal_Int32   nCount = 0;
     428           0 :     sal_Int32   nOffset = 0;
     429           0 :     while( nOffset >= 0 )
     430             :     {
     431           0 :         GetTokenByOffset( sToken, rString, nOffset, cQuote, cSeparator );
     432           0 :         if( nOffset >= 0 )
     433           0 :             nCount++;
     434             :     }
     435           0 :     return nCount;
     436             : }
     437             : 
     438         177 : bool ScRangeStringConverter::GetAddressFromString(
     439             :         ScAddress& rAddress,
     440             :         const OUString& rAddressStr,
     441             :         const ScDocument* pDocument,
     442             :         FormulaGrammar::AddressConvention eConv,
     443             :         sal_Int32& nOffset,
     444             :         sal_Unicode cSeparator,
     445             :         sal_Unicode cQuote )
     446             : {
     447         177 :     OUString sToken;
     448         177 :     GetTokenByOffset( sToken, rAddressStr, nOffset, cSeparator, cQuote );
     449         177 :     if( nOffset >= 0 )
     450             :     {
     451         177 :         if ((rAddress.Parse( sToken, const_cast<ScDocument*>(pDocument), eConv ) & SCA_VALID) == SCA_VALID)
     452         177 :             return true;
     453           0 :         ::formula::FormulaGrammar::AddressConvention eConvUI = pDocument->GetAddressConvention();
     454           0 :         if (eConv != eConvUI)
     455           0 :             return ((rAddress.Parse(sToken, const_cast<ScDocument*>(pDocument), eConvUI) & SCA_VALID) == SCA_VALID);
     456             :     }
     457           0 :     return false;
     458             : }
     459             : 
     460         262 : bool ScRangeStringConverter::GetRangeFromString(
     461             :         ScRange& rRange,
     462             :         const OUString& rRangeStr,
     463             :         const ScDocument* pDocument,
     464             :         FormulaGrammar::AddressConvention eConv,
     465             :         sal_Int32& nOffset,
     466             :         sal_Unicode cSeparator,
     467             :         sal_Unicode cQuote )
     468             : {
     469         262 :     OUString sToken;
     470         262 :     bool bResult(false);
     471         262 :     GetTokenByOffset( sToken, rRangeStr, nOffset, cSeparator, cQuote );
     472         262 :     if( nOffset >= 0 )
     473             :     {
     474         151 :         sal_Int32 nIndex = IndexOf( sToken, ':', 0, cQuote );
     475         151 :         OUString aUIString(sToken);
     476             : 
     477         151 :         if( nIndex < 0 )
     478             :         {
     479           0 :             if ( aUIString[0] == '.' )
     480           0 :                 aUIString = aUIString.copy( 1 );
     481           0 :             bResult = ((rRange.aStart.Parse( aUIString, const_cast<ScDocument*> (pDocument), eConv) & SCA_VALID) == SCA_VALID);
     482           0 :             ::formula::FormulaGrammar::AddressConvention eConvUI = pDocument->GetAddressConvention();
     483           0 :             if (!bResult && eConv != eConvUI)
     484             :                 bResult = ((rRange.aStart.Parse(
     485           0 :                     aUIString, const_cast<ScDocument*>(pDocument), eConvUI) & SCA_VALID) == SCA_VALID);
     486           0 :             rRange.aEnd = rRange.aStart;
     487             :         }
     488             :         else
     489             :         {
     490         151 :             if ( aUIString[0] == '.' )
     491             :             {
     492           0 :                 aUIString = aUIString.copy( 1 );
     493           0 :                 --nIndex;
     494             :             }
     495             : 
     496         302 :             if ( nIndex < aUIString.getLength() - 1 &&
     497         151 :                     aUIString[ nIndex + 1 ] == '.' )
     498           0 :                 aUIString = aUIString.replaceAt( nIndex + 1, 1, "" );
     499             : 
     500         151 :             bResult = ((rRange.Parse(aUIString, const_cast<ScDocument*> (pDocument), eConv) & SCA_VALID) == SCA_VALID);
     501             : 
     502             :             // #i77703# chart ranges in the file format contain both sheet names, even for an external reference sheet.
     503             :             // This isn't parsed by ScRange, so try to parse the two Addresses then.
     504         151 :             if (!bResult)
     505             :             {
     506             :                 bResult = ((rRange.aStart.Parse( aUIString.copy(0, nIndex), const_cast<ScDocument*>(pDocument),
     507           0 :                                 eConv) & SCA_VALID) == SCA_VALID) &&
     508             :                           ((rRange.aEnd.Parse( aUIString.copy(nIndex+1), const_cast<ScDocument*>(pDocument),
     509           0 :                                 eConv) & SCA_VALID) == SCA_VALID);
     510             : 
     511           0 :                 ::formula::FormulaGrammar::AddressConvention eConvUI = pDocument->GetAddressConvention();
     512           0 :                 if (!bResult && eConv != eConvUI)
     513             :                 {
     514             :                     bResult = ((rRange.aStart.Parse( aUIString.copy(0, nIndex), const_cast<ScDocument*>(pDocument),
     515           0 :                                     eConvUI) & SCA_VALID) == SCA_VALID) &&
     516             :                               ((rRange.aEnd.Parse( aUIString.copy(nIndex+1), const_cast<ScDocument*>(pDocument),
     517           0 :                                     eConvUI) & SCA_VALID) == SCA_VALID);
     518             :                 }
     519             :             }
     520         151 :         }
     521             :     }
     522         262 :     return bResult;
     523             : }
     524             : 
     525         110 : bool ScRangeStringConverter::GetRangeListFromString(
     526             :         ScRangeList& rRangeList,
     527             :         const OUString& rRangeListStr,
     528             :         const ScDocument* pDocument,
     529             :         FormulaGrammar::AddressConvention eConv,
     530             :         sal_Unicode cSeparator,
     531             :         sal_Unicode cQuote )
     532             : {
     533         110 :     bool bRet = true;
     534             :     OSL_ENSURE( !rRangeListStr.isEmpty(), "ScXMLConverter::GetRangeListFromString - empty string!" );
     535         110 :     sal_Int32 nOffset = 0;
     536         440 :     while( nOffset >= 0 )
     537             :     {
     538         220 :         ScRange* pRange = new ScRange;
     539         220 :         if (
     540         330 :              GetRangeFromString( *pRange, rRangeListStr, pDocument, eConv, nOffset, cSeparator, cQuote ) &&
     541         110 :              (nOffset >= 0)
     542             :            )
     543             :         {
     544         110 :             rRangeList.push_back( pRange );
     545         110 :             pRange = NULL;
     546             :         }
     547         110 :         else if (nOffset > -1)
     548           0 :             bRet = false;
     549             :         //if ownership transferred to rRangeList pRange was NULLed, otherwwise
     550             :         //delete it
     551         220 :         delete pRange;
     552             :     }
     553         110 :     return bRet;
     554             : }
     555             : 
     556           0 : bool ScRangeStringConverter::GetAreaFromString(
     557             :         ScArea& rArea,
     558             :         const OUString& rRangeStr,
     559             :         const ScDocument* pDocument,
     560             :         FormulaGrammar::AddressConvention eConv,
     561             :         sal_Int32& nOffset,
     562             :         sal_Unicode cSeparator,
     563             :         sal_Unicode cQuote )
     564             : {
     565           0 :     ScRange aScRange;
     566           0 :     bool bResult(false);
     567           0 :     if( GetRangeFromString( aScRange, rRangeStr, pDocument, eConv, nOffset, cSeparator, cQuote ) && (nOffset >= 0) )
     568             :     {
     569           0 :         rArea.nTab = aScRange.aStart.Tab();
     570           0 :         rArea.nColStart = aScRange.aStart.Col();
     571           0 :         rArea.nRowStart = aScRange.aStart.Row();
     572           0 :         rArea.nColEnd = aScRange.aEnd.Col();
     573           0 :         rArea.nRowEnd = aScRange.aEnd.Row();
     574           0 :         bResult = true;
     575             :     }
     576           0 :     return bResult;
     577             : }
     578             : 
     579          57 : bool ScRangeStringConverter::GetAddressFromString(
     580             :         table::CellAddress& rAddress,
     581             :         const OUString& rAddressStr,
     582             :         const ScDocument* pDocument,
     583             :         FormulaGrammar::AddressConvention eConv,
     584             :         sal_Int32& nOffset,
     585             :         sal_Unicode cSeparator,
     586             :         sal_Unicode cQuote )
     587             : {
     588          57 :     ScAddress aScAddress;
     589          57 :     bool bResult(false);
     590          57 :     if( GetAddressFromString( aScAddress, rAddressStr, pDocument, eConv, nOffset, cSeparator, cQuote ) && (nOffset >= 0) )
     591             :     {
     592          57 :         ScUnoConversion::FillApiAddress( rAddress, aScAddress );
     593          57 :         bResult = true;
     594             :     }
     595          57 :     return bResult;
     596             : }
     597             : 
     598           0 : bool ScRangeStringConverter::GetRangeFromString(
     599             :         table::CellRangeAddress& rRange,
     600             :         const OUString& rRangeStr,
     601             :         const ScDocument* pDocument,
     602             :         FormulaGrammar::AddressConvention eConv,
     603             :         sal_Int32& nOffset,
     604             :         sal_Unicode cSeparator,
     605             :         sal_Unicode cQuote )
     606             : {
     607           0 :     ScRange aScRange;
     608           0 :     bool bResult(false);
     609           0 :     if( GetRangeFromString( aScRange, rRangeStr, pDocument, eConv, nOffset, cSeparator, cQuote ) && (nOffset >= 0) )
     610             :     {
     611           0 :         ScUnoConversion::FillApiRange( rRange, aScRange );
     612           0 :         bResult = true;
     613             :     }
     614           0 :     return bResult;
     615             : }
     616             : 
     617          35 : void ScRangeStringConverter::GetStringFromAddress(
     618             :         OUString& rString,
     619             :         const ScAddress& rAddress,
     620             :         const ScDocument* pDocument,
     621             :         FormulaGrammar::AddressConvention eConv,
     622             :         sal_Unicode cSeparator,
     623             :         bool bAppendStr,
     624             :         sal_uInt16 nFormatFlags )
     625             : {
     626          35 :     if (pDocument && pDocument->HasTable(rAddress.Tab()))
     627             :     {
     628          35 :         OUString sAddress(rAddress.Format(nFormatFlags, pDocument, eConv));
     629          35 :         AssignString( rString, sAddress, bAppendStr, cSeparator );
     630             :     }
     631          35 : }
     632             : 
     633          33 : void ScRangeStringConverter::GetStringFromRange(
     634             :         OUString& rString,
     635             :         const ScRange& rRange,
     636             :         const ScDocument* pDocument,
     637             :         FormulaGrammar::AddressConvention eConv,
     638             :         sal_Unicode cSeparator,
     639             :         bool bAppendStr,
     640             :         sal_uInt16 nFormatFlags )
     641             : {
     642          33 :     if (pDocument && pDocument->HasTable(rRange.aStart.Tab()))
     643             :     {
     644          33 :         ScAddress aStartAddress( rRange.aStart );
     645          33 :         ScAddress aEndAddress( rRange.aEnd );
     646          33 :         OUString sStartAddress(aStartAddress.Format(nFormatFlags, pDocument, eConv));
     647          66 :         OUString sEndAddress(aEndAddress.Format(nFormatFlags, pDocument, eConv));
     648          66 :         OUString sOUStartAddress( sStartAddress );
     649          33 :         sOUStartAddress += OUString(':');
     650          33 :         sOUStartAddress += OUString( sEndAddress );
     651          66 :         AssignString( rString, sOUStartAddress, bAppendStr, cSeparator );
     652             :     }
     653          33 : }
     654             : 
     655          26 : void ScRangeStringConverter::GetStringFromRangeList(
     656             :         OUString& rString,
     657             :         const ScRangeList* pRangeList,
     658             :         const ScDocument* pDocument,
     659             :         FormulaGrammar::AddressConvention eConv,
     660             :         sal_Unicode cSeparator,
     661             :         sal_uInt16 nFormatFlags )
     662             : {
     663          26 :     OUString sRangeListStr;
     664          26 :     if( pRangeList )
     665             :     {
     666          59 :         for( size_t nIndex = 0, nCount = pRangeList->size(); nIndex < nCount; nIndex++ )
     667             :         {
     668          33 :             const ScRange* pRange = (*pRangeList)[nIndex];
     669          33 :             if( pRange )
     670          33 :                 GetStringFromRange( sRangeListStr, *pRange, pDocument, eConv, cSeparator, true, nFormatFlags );
     671             :         }
     672             :     }
     673          26 :     rString = sRangeListStr;
     674          26 : }
     675             : 
     676           0 : void ScRangeStringConverter::GetStringFromArea(
     677             :         OUString& rString,
     678             :         const ScArea& rArea,
     679             :         const ScDocument* pDocument,
     680             :         FormulaGrammar::AddressConvention eConv,
     681             :         sal_Unicode cSeparator,
     682             :         bool bAppendStr,
     683             :         sal_uInt16 nFormatFlags )
     684             : {
     685           0 :     ScRange aRange( rArea.nColStart, rArea.nRowStart, rArea.nTab, rArea.nColEnd, rArea.nRowEnd, rArea.nTab );
     686           0 :     GetStringFromRange( rString, aRange, pDocument, eConv, cSeparator, bAppendStr, nFormatFlags );
     687           0 : }
     688             : 
     689          11 : void ScRangeStringConverter::GetStringFromAddress(
     690             :         OUString& rString,
     691             :         const table::CellAddress& rAddress,
     692             :         const ScDocument* pDocument,
     693             :         FormulaGrammar::AddressConvention eConv,
     694             :         sal_Unicode cSeparator,
     695             :         bool bAppendStr,
     696             :         sal_uInt16 nFormatFlags )
     697             : {
     698          11 :     ScAddress aScAddress( static_cast<SCCOL>(rAddress.Column), static_cast<SCROW>(rAddress.Row), rAddress.Sheet );
     699          11 :     GetStringFromAddress( rString, aScAddress, pDocument, eConv, cSeparator, bAppendStr, nFormatFlags );
     700          11 : }
     701             : 
     702           0 : void ScRangeStringConverter::GetStringFromRange(
     703             :         OUString& rString,
     704             :         const table::CellRangeAddress& rRange,
     705             :         const ScDocument* pDocument,
     706             :         FormulaGrammar::AddressConvention eConv,
     707             :         sal_Unicode cSeparator,
     708             :         bool bAppendStr,
     709             :         sal_uInt16 nFormatFlags )
     710             : {
     711             :     ScRange aScRange( static_cast<SCCOL>(rRange.StartColumn), static_cast<SCROW>(rRange.StartRow), rRange.Sheet,
     712           0 :         static_cast<SCCOL>(rRange.EndColumn), static_cast<SCROW>(rRange.EndRow), rRange.Sheet );
     713           0 :     GetStringFromRange( rString, aScRange, pDocument, eConv, cSeparator, bAppendStr, nFormatFlags );
     714           0 : }
     715             : 
     716          33 : void ScRangeStringConverter::GetStringFromRangeList(
     717             :         OUString& rString,
     718             :         const uno::Sequence< table::CellRangeAddress >& rRangeSeq,
     719             :         const ScDocument* pDocument,
     720             :         FormulaGrammar::AddressConvention eConv,
     721             :         sal_Unicode cSeparator,
     722             :         sal_uInt16 nFormatFlags )
     723             : {
     724          33 :     OUString sRangeListStr;
     725          33 :     sal_Int32 nCount = rRangeSeq.getLength();
     726          33 :     for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ )
     727             :     {
     728           0 :         const table::CellRangeAddress& rRange = rRangeSeq[ nIndex ];
     729           0 :         GetStringFromRange( sRangeListStr, rRange, pDocument, eConv, cSeparator, true, nFormatFlags );
     730             :     }
     731          33 :     rString = sRangeListStr;
     732          33 : }
     733             : 
     734           0 : static void lcl_appendCellAddress(
     735             :     OUStringBuffer& rBuf, ScDocument* pDoc, const ScAddress& rCell,
     736             :     const ScAddress::ExternalInfo& rExtInfo)
     737             : {
     738           0 :     if (rExtInfo.mbExternal)
     739             :     {
     740           0 :         ScExternalRefManager* pRefMgr = pDoc->GetExternalRefManager();
     741           0 :         const OUString* pFilePath = pRefMgr->getExternalFileName(rExtInfo.mnFileId, true);
     742           0 :         if (!pFilePath)
     743           0 :             return;
     744             : 
     745           0 :         sal_Unicode cQuote = '\'';
     746           0 :         rBuf.append(cQuote);
     747           0 :         rBuf.append(*pFilePath);
     748           0 :         rBuf.append(cQuote);
     749           0 :         rBuf.append('#');
     750           0 :         rBuf.append('$');
     751           0 :         ScRangeStringConverter::AppendTableName(rBuf, rExtInfo.maTabName);
     752           0 :         rBuf.append('.');
     753             : 
     754           0 :         OUString aAddr(rCell.Format(SCA_ABS, NULL, pDoc->GetAddressConvention()));
     755           0 :         rBuf.append(aAddr);
     756             :     }
     757             :     else
     758             :     {
     759           0 :         OUString aAddr(rCell.Format(SCA_ABS_3D, pDoc, pDoc->GetAddressConvention()));
     760           0 :         rBuf.append(aAddr);
     761             :     }
     762             : }
     763             : 
     764         250 : static void lcl_appendCellRangeAddress(
     765             :     OUStringBuffer& rBuf, ScDocument* pDoc, const ScAddress& rCell1, const ScAddress& rCell2,
     766             :     const ScAddress::ExternalInfo& rExtInfo1, const ScAddress::ExternalInfo& rExtInfo2)
     767             : {
     768         250 :     if (rExtInfo1.mbExternal)
     769             :     {
     770             :         OSL_ENSURE(rExtInfo2.mbExternal, "2nd address is not external!?");
     771             :         OSL_ENSURE(rExtInfo1.mnFileId == rExtInfo2.mnFileId, "File IDs do not match between 1st and 2nd addresses.");
     772             : 
     773           0 :         ScExternalRefManager* pRefMgr = pDoc->GetExternalRefManager();
     774           0 :         const OUString* pFilePath = pRefMgr->getExternalFileName(rExtInfo1.mnFileId, true);
     775           0 :         if (!pFilePath)
     776         250 :             return;
     777             : 
     778           0 :         sal_Unicode cQuote = '\'';
     779           0 :         rBuf.append(cQuote);
     780           0 :         rBuf.append(*pFilePath);
     781           0 :         rBuf.append(cQuote);
     782           0 :         rBuf.append('#');
     783           0 :         rBuf.append('$');
     784           0 :         ScRangeStringConverter::AppendTableName(rBuf, rExtInfo1.maTabName);
     785           0 :         rBuf.append('.');
     786             : 
     787           0 :         OUString aAddr(rCell1.Format(SCA_ABS, NULL, pDoc->GetAddressConvention()));
     788           0 :         rBuf.append(aAddr);
     789             : 
     790           0 :         rBuf.appendAscii(":");
     791             : 
     792           0 :         if (rExtInfo1.maTabName != rExtInfo2.maTabName)
     793             :         {
     794           0 :             rBuf.append('$');
     795           0 :             ScRangeStringConverter::AppendTableName(rBuf, rExtInfo2.maTabName);
     796           0 :             rBuf.append('.');
     797             :         }
     798             : 
     799           0 :         aAddr = rCell2.Format(SCA_ABS, NULL, pDoc->GetAddressConvention());
     800           0 :         rBuf.append(aAddr);
     801             :     }
     802             :     else
     803             :     {
     804         250 :         ScRange aRange;
     805         250 :         aRange.aStart = rCell1;
     806         250 :         aRange.aEnd   = rCell2;
     807         250 :         OUString aAddr(aRange.Format(SCR_ABS_3D, pDoc, pDoc->GetAddressConvention()));
     808         250 :         rBuf.append(aAddr);
     809             :     }
     810             : }
     811             : 
     812         178 : void ScRangeStringConverter::GetStringFromXMLRangeString( OUString& rString, const OUString& rXMLRange, ScDocument* pDoc )
     813             : {
     814         178 :     FormulaGrammar::AddressConvention eConv = pDoc->GetAddressConvention();
     815         178 :     const sal_Unicode cSep = ' ';
     816         178 :     const sal_Unicode cSepNew = ScCompiler::GetNativeSymbolChar(ocSep);
     817         178 :     const sal_Unicode cQuote = '\'';
     818             : 
     819         178 :     OUStringBuffer aRetStr;
     820         178 :     sal_Int32 nOffset = 0;
     821         178 :     bool bFirst = true;
     822             : 
     823         606 :     while (nOffset >= 0)
     824             :     {
     825         428 :         OUString aToken;
     826         428 :         GetTokenByOffset(aToken, rXMLRange, nOffset, cSep, cQuote);
     827         428 :         if (nOffset < 0)
     828         178 :             break;
     829             : 
     830         250 :         sal_Int32 nSepPos = IndexOf(aToken, ':', 0, cQuote);
     831         250 :         if (nSepPos >= 0)
     832             :         {
     833             :             // Cell range
     834         250 :             OUString aBeginCell = aToken.copy(0, nSepPos);
     835         500 :             OUString aEndCell   = aToken.copy(nSepPos+1);
     836             : 
     837         250 :             if (aBeginCell.isEmpty() || aEndCell.isEmpty())
     838             :                 // both cell addresses must exist for this to work.
     839           0 :                 continue;
     840             : 
     841         250 :             sal_Int32 nEndCellDotPos = aEndCell.indexOf('.');
     842         250 :             if (nEndCellDotPos <= 0)
     843             :             {
     844             :                 // initialize buffer with table name...
     845           0 :                 sal_Int32 nDotPos = IndexOf(aBeginCell, '.', 0, cQuote);
     846           0 :                 OUStringBuffer aBuf = aBeginCell.copy(0, nDotPos);
     847             : 
     848           0 :                 if (nEndCellDotPos == 0)
     849             :                 {
     850             :                     // workaround for old syntax (probably pre-chart2 age?)
     851             :                     // e.g. Sheet1.A1:.B2
     852           0 :                     aBuf.append(aEndCell);
     853             :                 }
     854           0 :                 else if (nEndCellDotPos < 0)
     855             :                 {
     856             :                     // sheet name in the end cell is omitted (e.g. Sheet2.A1:B2).
     857           0 :                     aBuf.append('.');
     858           0 :                     aBuf.append(aEndCell);
     859             :                 }
     860           0 :                 aEndCell = aBuf.makeStringAndClear();
     861             :             }
     862             : 
     863         500 :             ScAddress::ExternalInfo aExtInfo1, aExtInfo2;
     864         250 :             ScAddress aCell1, aCell2;
     865         250 :             sal_uInt16 nRet = aCell1.Parse(aBeginCell, pDoc, FormulaGrammar::CONV_OOO, &aExtInfo1);
     866         250 :             if ((nRet & SCA_VALID) != SCA_VALID)
     867             :             {
     868             :                 // first cell is invalid.
     869           0 :                 if (eConv == FormulaGrammar::CONV_OOO)
     870           0 :                     continue;
     871             : 
     872           0 :                 nRet = aCell1.Parse(aBeginCell, pDoc, eConv, &aExtInfo1);
     873           0 :                 if ((nRet & SCA_VALID) != SCA_VALID)
     874             :                     // first cell is really invalid.
     875           0 :                     continue;
     876             :             }
     877             : 
     878         250 :             nRet = aCell2.Parse(aEndCell, pDoc, FormulaGrammar::CONV_OOO, &aExtInfo2);
     879         250 :             if ((nRet & SCA_VALID) != SCA_VALID)
     880             :             {
     881             :                 // second cell is invalid.
     882           0 :                 if (eConv == FormulaGrammar::CONV_OOO)
     883           0 :                     continue;
     884             : 
     885           0 :                 nRet = aCell2.Parse(aEndCell, pDoc, eConv, &aExtInfo2);
     886           0 :                 if ((nRet & SCA_VALID) != SCA_VALID)
     887             :                     // second cell is really invalid.
     888           0 :                     continue;
     889             :             }
     890             : 
     891         250 :             if (aExtInfo1.mnFileId != aExtInfo2.mnFileId || aExtInfo1.mbExternal != aExtInfo2.mbExternal)
     892             :                 // external info inconsistency.
     893           0 :                 continue;
     894             : 
     895             :             // All looks good!
     896             : 
     897         250 :             if (bFirst)
     898         178 :                 bFirst = false;
     899             :             else
     900          72 :                 aRetStr.append(cSepNew);
     901             : 
     902         500 :             lcl_appendCellRangeAddress(aRetStr, pDoc, aCell1, aCell2, aExtInfo1, aExtInfo2);
     903             :         }
     904             :         else
     905             :         {
     906             :             // Chart always saves ranges using CONV_OOO convention.
     907           0 :             ScAddress::ExternalInfo aExtInfo;
     908           0 :             ScAddress aCell;
     909           0 :             sal_uInt16 nRet = aCell.Parse(aToken, pDoc, ::formula::FormulaGrammar::CONV_OOO, &aExtInfo);
     910           0 :             if ((nRet & SCA_VALID) != SCA_VALID)
     911             :             {
     912           0 :                 nRet = aCell.Parse(aToken, pDoc, eConv, &aExtInfo);
     913           0 :                 if ((nRet & SCA_VALID) != SCA_VALID)
     914           0 :                     continue;
     915             :             }
     916             : 
     917             :             // Looks good!
     918             : 
     919           0 :             if (bFirst)
     920           0 :                 bFirst = false;
     921             :             else
     922           0 :                 aRetStr.append(cSepNew);
     923             : 
     924           0 :             lcl_appendCellAddress(aRetStr, pDoc, aCell, aExtInfo);
     925             :         }
     926         250 :     }
     927             : 
     928         178 :     rString = aRetStr.makeStringAndClear();
     929         178 : }
     930             : 
     931           8 : ScRangeData* ScRangeStringConverter::GetRangeDataFromString(const OUString& rString, const SCTAB nTab, const ScDocument* pDoc)
     932             : {
     933           8 :     ScRangeName* pLocalRangeName = pDoc->GetRangeName(nTab);
     934           8 :     ScRangeData* pData = NULL;
     935           8 :     OUString aUpperName = ScGlobal::pCharClass->uppercase(rString);
     936           8 :     if(pLocalRangeName)
     937             :     {
     938           8 :         pData = pLocalRangeName->findByUpperName(aUpperName);
     939             :     }
     940           8 :     if (!pData)
     941             :     {
     942           8 :         ScRangeName* pGlobalRangeName = pDoc->GetRangeName();
     943           8 :         if (pGlobalRangeName)
     944             :         {
     945           8 :             pData = pGlobalRangeName->findByUpperName(aUpperName);
     946             :         }
     947             :     }
     948           8 :     return pData;
     949             : }
     950             : 
     951         349 : ScArea::ScArea( SCTAB tab,
     952             :                 SCCOL colStart, SCROW rowStart,
     953             :                 SCCOL colEnd,   SCROW rowEnd ) :
     954             :         nTab     ( tab ),
     955             :         nColStart( colStart ),  nRowStart( rowStart ),
     956         349 :         nColEnd  ( colEnd ),    nRowEnd  ( rowEnd )
     957             : {
     958         349 : }
     959             : 
     960           1 : ScArea::ScArea( const ScArea& r ) :
     961             :         nTab     ( r.nTab ),
     962             :         nColStart( r.nColStart ),   nRowStart( r.nRowStart ),
     963           1 :         nColEnd  ( r.nColEnd ),     nRowEnd  ( r.nRowEnd )
     964             : {
     965           1 : }
     966             : 
     967           0 : ScArea& ScArea::operator=( const ScArea& r )
     968             : {
     969           0 :     nTab        = r.nTab;
     970           0 :     nColStart   = r.nColStart;
     971           0 :     nRowStart   = r.nRowStart;
     972           0 :     nColEnd     = r.nColEnd;
     973           0 :     nRowEnd     = r.nRowEnd;
     974           0 :     return *this;
     975             : }
     976             : 
     977           0 : bool ScArea::operator==( const ScArea& r ) const
     978             : {
     979           0 :     return (   (nTab        == r.nTab)
     980           0 :             && (nColStart   == r.nColStart)
     981           0 :             && (nRowStart   == r.nRowStart)
     982           0 :             && (nColEnd     == r.nColEnd)
     983           0 :             && (nRowEnd     == r.nRowEnd) );
     984             : }
     985             : 
     986           0 : ScAreaNameIterator::ScAreaNameIterator( ScDocument* pDoc ) :
     987           0 :     pRangeName(pDoc->GetRangeName()),
     988           0 :     pDBCollection(pDoc->GetDBCollection()),
     989           0 :     bFirstPass(true)
     990             : {
     991           0 :     if (pRangeName)
     992             :     {
     993           0 :         maRNPos = pRangeName->begin();
     994           0 :         maRNEnd = pRangeName->end();
     995             :     }
     996           0 : }
     997             : 
     998           0 : bool ScAreaNameIterator::Next( OUString& rName, ScRange& rRange )
     999             : {
    1000             :     for (;;)
    1001             :     {
    1002           0 :         if ( bFirstPass )                                   // erst Bereichsnamen
    1003             :         {
    1004           0 :             if ( pRangeName && maRNPos != maRNEnd )
    1005             :             {
    1006           0 :                 const ScRangeData& rData = *maRNPos->second;
    1007           0 :                 ++maRNPos;
    1008           0 :                 bool bValid = rData.IsValidReference(rRange);
    1009           0 :                 if (bValid)
    1010             :                 {
    1011           0 :                     rName = rData.GetName();
    1012           0 :                     return true;                            // found
    1013             :                 }
    1014             :             }
    1015             :             else
    1016             :             {
    1017           0 :                 bFirstPass = false;
    1018           0 :                 if (pDBCollection)
    1019             :                 {
    1020           0 :                     const ScDBCollection::NamedDBs& rDBs = pDBCollection->getNamedDBs();
    1021           0 :                     maDBPos = rDBs.begin();
    1022           0 :                     maDBEnd = rDBs.end();
    1023             :                 }
    1024             :             }
    1025             :         }
    1026             : 
    1027           0 :         if ( !bFirstPass )                                  // dann DB-Bereiche
    1028             :         {
    1029           0 :             if (pDBCollection && maDBPos != maDBEnd)
    1030             :             {
    1031           0 :                 const ScDBData& rData = *maDBPos;
    1032           0 :                 ++maDBPos;
    1033           0 :                 rData.GetArea(rRange);
    1034           0 :                 rName = rData.GetName();
    1035           0 :                 return true;                                // found
    1036             :             }
    1037             :             else
    1038           0 :                 return false;                               // nothing left
    1039             :         }
    1040           0 :     }
    1041         156 : }
    1042             : 
    1043             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11