sc/source/ui/unoobj/funcuno.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sfx2/app.hxx>
  21 #include <svl/itemprop.hxx>
  22
  23 #include "scitems.hxx"
  24 #include "funcuno.hxx"
  25 #include "miscuno.hxx"
  26 #include "cellsuno.hxx"
  27 #include "scdll.hxx"
  28 #include "document.hxx"
  29 #include "compiler.hxx"
  30 #include "formula/errorcodes.hxx"
  31 #include "callform.hxx"
  32 #include "addincol.hxx"
  33 #include "rangeseq.hxx"
  34 #include "formulacell.hxx"
  35 #include "docoptio.hxx"
  36 #include "optuno.hxx"
  37 #include <docuno.hxx>
  38 // for lcl_CopyData:
  39 #include "markdata.hxx"
  40 #include "patattr.hxx"
  41 #include "docpool.hxx"
  42 #include "attrib.hxx"
  43 #include "clipparam.hxx"
  44 #include "dociter.hxx"
  45 #include "stringutil.hxx"
  46 #include "tokenarray.hxx"
  47
  48 using namespace com::sun::star;
  49
  50 //------------------------------------------------------------------------
  51
  52 //  registered as implementation for service FunctionAccess,
  53 //  also supports service SpreadsheetDocumentSettings (to set null date etc.)
  54
  55 #define SCFUNCTIONACCESS_SERVICE    "com.sun.star.sheet.FunctionAccess"
  56 #define SCDOCSETTINGS_SERVICE       "com.sun.star.sheet.SpreadsheetDocumentSettings"
  57
  58 //------------------------------------------------------------------------
  59
  60 // helper to use cached document if not in use, temporary document otherwise
  61
  62 class ScTempDocSource
  63 {
  64 private:
  65     ScTempDocCache& rCache;
  66     ScDocument*     pTempDoc;
  67
  68     static ScDocument*  CreateDocument();       // create and initialize doc
  69
  70 public:
  71                 ScTempDocSource( ScTempDocCache& rDocCache );
  72                 ~ScTempDocSource();
  73
  74     ScDocument*     GetDocument();
  75 };
  76
  77 //------------------------------------------------------------------------
  78
  79 ScDocument* ScTempDocSource::CreateDocument()
  80 {
  81     ScDocument* pDoc = new ScDocument;                  // SCDOCMODE_DOCUMENT
  82     pDoc->MakeTable( 0 );
  83     return pDoc;
  84 }
  85
  86 ScTempDocSource::ScTempDocSource( ScTempDocCache& rDocCache ) :
  87     rCache( rDocCache ),
  88     pTempDoc( NULL )
  89 {
  90     if ( rCache.IsInUse() )
  91         pTempDoc = CreateDocument();
  92     else
  93     {
  94         rCache.SetInUse( sal_True );
  95         if ( !rCache.GetDocument() )
  96             rCache.SetDocument( CreateDocument() );
  97     }
  98 }
  99
 100 ScTempDocSource::~ScTempDocSource()
 101 {
 102     if ( pTempDoc )
 103         delete pTempDoc;
 104     else
 105         rCache.SetInUse( false );
 106 }
 107
 108 ScDocument* ScTempDocSource::GetDocument()
 109 {
 110     if ( pTempDoc )
 111         return pTempDoc;
 112     else
 113         return rCache.GetDocument();
 114 }
 115
 116 //------------------------------------------------------------------------
 117
 118 ScTempDocCache::ScTempDocCache() :
 119     pDoc( NULL ),
 120     bInUse( false )
 121 {
 122 }
 123
 124 ScTempDocCache::~ScTempDocCache()
 125 {
 126     OSL_ENSURE( !bInUse, "ScTempDocCache dtor: bInUse" );
 127     delete pDoc;
 128 }
 129
 130 void ScTempDocCache::SetDocument( ScDocument* pNew )
 131 {
 132     OSL_ENSURE( !pDoc, "ScTempDocCache::SetDocument: already set" );
 133     pDoc = pNew;
 134 }
 135
 136 void ScTempDocCache::Clear()
 137 {
 138     OSL_ENSURE( !bInUse, "ScTempDocCache::Clear: bInUse" );
 139     delete pDoc;
 140     pDoc = NULL;
 141 }
 142
 143 //------------------------------------------------------------------------
 144
 145 //  copy results from one document into another
 146 //! merge this with ScAreaLink::Refresh
 147 //! copy directly without a clipboard document?
 148
 149 static sal_Bool lcl_CopyData( ScDocument* pSrcDoc, const ScRange& rSrcRange,
 150                     ScDocument* pDestDoc, const ScAddress& rDestPos )
 151 {
 152     SCTAB nSrcTab = rSrcRange.aStart.Tab();
 153     SCTAB nDestTab = rDestPos.Tab();
 154
 155     ScRange aNewRange( rDestPos, ScAddress(
 156                 rSrcRange.aEnd.Col() - rSrcRange.aStart.Col() + rDestPos.Col(),
 157                 rSrcRange.aEnd.Row() - rSrcRange.aStart.Row() + rDestPos.Row(),
 158                 nDestTab ) );
 159
 160     ScDocument* pClipDoc = new ScDocument( SCDOCMODE_CLIP );
 161     ScMarkData aSourceMark;
 162     aSourceMark.SelectOneTable( nSrcTab );      // for CopyToClip
 163     aSourceMark.SetMarkArea( rSrcRange );
 164     ScClipParam aClipParam(rSrcRange, false);
 165     pSrcDoc->CopyToClip(aClipParam, pClipDoc, &aSourceMark, false);
 166
 167     if ( pClipDoc->HasAttrib( 0,0,nSrcTab, MAXCOL,MAXROW,nSrcTab,
 168                                 HASATTR_MERGED | HASATTR_OVERLAPPED ) )
 169     {
 170         ScPatternAttr aPattern( pSrcDoc->GetPool() );
 171         aPattern.GetItemSet().Put( ScMergeAttr() );             // Defaults
 172         aPattern.GetItemSet().Put( ScMergeFlagAttr() );
 173         pClipDoc->ApplyPatternAreaTab( 0,0, MAXCOL,MAXROW, nSrcTab, aPattern );
 174     }
 175
 176     ScMarkData aDestMark;
 177     aDestMark.SelectOneTable( nDestTab );
 178     aDestMark.SetMarkArea( aNewRange );
 179     pDestDoc->CopyFromClip( aNewRange, aDestMark, IDF_ALL & ~IDF_FORMULA, NULL, pClipDoc, false );
 180
 181     delete pClipDoc;
 182     return sal_True;
 183 }
 184
 185 //------------------------------------------------------------------------
 186
 187 ScFunctionAccess::ScFunctionAccess() :
 188     pOptions( NULL ),
 189     aPropertyMap( ScDocOptionsHelper::GetPropertyMap() ),
 190     mbArray( true ),    // default according to behaviour of older Office versions
 191     mbValid( true )
 192 {
 193     StartListening( *SFX_APP() );       // for SFX_HINT_DEINITIALIZING
 194 }
 195
 196 ScFunctionAccess::~ScFunctionAccess()
 197 {
 198     delete pOptions;
 199 }
 200
 201 void ScFunctionAccess::Notify( SfxBroadcaster&, const SfxHint& rHint )
 202 {
 203     if ( rHint.ISA(SfxSimpleHint) &&
 204         ((SfxSimpleHint&)rHint).GetId() == SFX_HINT_DEINITIALIZING )
 205     {
 206         //  document must not be used anymore
 207         aDocCache.Clear();
 208         mbValid = false;
 209     }
 210 }
 211
 212 // stuff for exService_...
 213
 214 uno::Reference<uno::XInterface> SAL_CALL ScFunctionAccess_CreateInstance(
 215                         const uno::Reference<lang::XMultiServiceFactory>& )
 216 {
 217     SolarMutexGuard aGuard;
 218     ScDLL::Init();
 219     static uno::Reference< uno::XInterface > xInst((::cppu::OWeakObject*) new ScFunctionAccess);
 220     return xInst;
 221 }
 222
 223 OUString ScFunctionAccess::getImplementationName_Static()
 224 {
 225     return OUString( "stardiv.StarCalc.ScFunctionAccess" );
 226 }
 227
 228 uno::Sequence<OUString> ScFunctionAccess::getSupportedServiceNames_Static()
 229 {
 230     uno::Sequence<OUString> aRet(1);
 231     OUString* pArray = aRet.getArray();
 232     pArray[0] = OUString( SCFUNCTIONACCESS_SERVICE );
 233     return aRet;
 234 }
 235
 236 // XServiceInfo
 237
 238 OUString SAL_CALL ScFunctionAccess::getImplementationName() throw(uno::RuntimeException)
 239 {
 240     return OUString( "ScFunctionAccess");
 241 }
 242
 243 sal_Bool SAL_CALL ScFunctionAccess::supportsService( const OUString& rServiceName )
 244                                                     throw(uno::RuntimeException)
 245 {
 246     String aServiceStr(rServiceName);
 247     return aServiceStr.EqualsAscii( SCFUNCTIONACCESS_SERVICE ) ||
 248            aServiceStr.EqualsAscii( SCDOCSETTINGS_SERVICE );
 249 }
 250
 251 uno::Sequence<OUString> SAL_CALL ScFunctionAccess::getSupportedServiceNames()
 252                                                     throw(uno::RuntimeException)
 253 {
 254     uno::Sequence<OUString> aRet(2);
 255     OUString* pArray = aRet.getArray();
 256     pArray[0] = OUString( SCFUNCTIONACCESS_SERVICE );
 257     pArray[1] = OUString( SCDOCSETTINGS_SERVICE );
 258     return aRet;
 259 }
 260
 261 // XPropertySet (document settings)
 262
 263 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScFunctionAccess::getPropertySetInfo()
 264                                                         throw(uno::RuntimeException)
 265 {
 266     SolarMutexGuard aGuard;
 267     static uno::Reference<beans::XPropertySetInfo> aRef(
 268         new SfxItemPropertySetInfo( aPropertyMap ));
 269     return aRef;
 270 }
 271
 272 void SAL_CALL ScFunctionAccess::setPropertyValue(
 273                         const OUString& aPropertyName, const uno::Any& aValue )
 274                 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
 275                         lang::IllegalArgumentException, lang::WrappedTargetException,
 276                         uno::RuntimeException)
 277 {
 278     SolarMutexGuard aGuard;
 279
 280     if ( aPropertyName == "IsArrayFunction" )
 281     {
 282         if( !(aValue >>= mbArray) )
 283             throw lang::IllegalArgumentException();
 284     }
 285     else
 286     {
 287         if ( !pOptions )
 288             pOptions = new ScDocOptions();
 289
 290         // options aren't initialized from configuration - always get the same default behaviour
 291
 292         sal_Bool bDone = ScDocOptionsHelper::setPropertyValue( *pOptions, aPropertyMap, aPropertyName, aValue );
 293         if (!bDone)
 294             throw beans::UnknownPropertyException();
 295     }
 296 }
 297
 298 uno::Any SAL_CALL ScFunctionAccess::getPropertyValue( const OUString& aPropertyName )
 299                 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
 300                         uno::RuntimeException)
 301 {
 302     SolarMutexGuard aGuard;
 303
 304     if ( aPropertyName == "IsArrayFunction" )
 305         return uno::Any( mbArray );
 306
 307     if ( !pOptions )
 308         pOptions = new ScDocOptions();
 309
 310     // options aren't initialized from configuration - always get the same default behaviour
 311
 312     return ScDocOptionsHelper::getPropertyValue( *pOptions, aPropertyMap, aPropertyName );
 313 }
 314
 315 SC_IMPL_DUMMY_PROPERTY_LISTENER( ScFunctionAccess )
 316
 317 // XFunctionAccess
 318
 319 static sal_Bool lcl_AddFunctionToken( ScTokenArray& rArray, const OUString& rName,const ScCompiler& rCompiler )
 320 {
 321     // function names are always case-insensitive
 322     OUString aUpper = ScGlobal::pCharClass->uppercase(rName);
 323
 324     // same options as in ScCompiler::IsOpCode:
 325     // 1. built-in function name
 326
 327     OpCode eOp = rCompiler.GetEnglishOpCode( aUpper );
 328     if ( eOp != ocNone )
 329     {
 330         rArray.AddOpCode( eOp );
 331         return true;
 332     }
 333
 334     // 2. old add in functions
 335
 336     if (ScGlobal::GetFuncCollection()->findByName(aUpper))
 337     {
 338         rArray.AddExternal(aUpper.getStr());
 339         return true;
 340     }
 341
 342     // 3. new (uno) add in functions
 343
 344     OUString aIntName =
 345         ScGlobal::GetAddInCollection()->FindFunction(aUpper, false);
 346     if (!aIntName.isEmpty())
 347     {
 348         rArray.AddExternal(aIntName.getStr());     // international name
 349         return true;
 350     }
 351
 352     return false;       // no valid function name
 353 }
 354
 355 static void lcl_AddRef( ScTokenArray& rArray, long nStartRow, long nColCount, long nRowCount )
 356 {
 357     ScComplexRefData aRef;
 358     aRef.InitFlags();
 359     aRef.Ref1.nTab = 0;
 360     aRef.Ref2.nTab = 0;
 361     aRef.Ref1.nCol = 0;
 362     aRef.Ref1.nRow = (SCROW) nStartRow;
 363     aRef.Ref2.nCol = (SCCOL) (nColCount - 1);
 364     aRef.Ref2.nRow = (SCROW) (nStartRow + nRowCount - 1);
 365     rArray.AddDoubleReference(aRef);
 366 }
 367
 368 class SimpleVisitor
 369 {
 370 protected:
 371     bool mbArgError;
 372     ScDocument* mpDoc;
 373 public:
 374     SimpleVisitor( ScDocument* pDoc ) : mbArgError( false ), mpDoc( pDoc ) {}
 375     // could possibly just get away with JUST the following overload
 376     // 1) virtual void visitElem( long& nCol, long& nRow, const double& elem )
 377     // 2) virtual void visitElem( long& nCol, long& nRow, const OUString& elem )
 378     // 3) virtual void visitElem( long& nCol, long& nRow, const uno::Any& elem )
 379     // the other types methods are here just to reflect the orig code and for
 380     // completeness.
 381
 382     void visitElem( long nCol, long nRow, const sal_Int16& elem )
 383     {
 384         mpDoc->SetValue( (SCCOL) nCol, (SCROW) nRow, 0, elem );
 385     }
 386     void visitElem( long nCol, long nRow, const sal_Int32& elem )
 387     {
 388         mpDoc->SetValue( (SCCOL) nCol, (SCROW) nRow, 0, elem );
 389     }
 390     void visitElem( long nCol, long nRow, const double& elem )
 391     {
 392         mpDoc->SetValue( (SCCOL) nCol, (SCROW) nRow, 0, elem );
 393     }
 394     void visitElem( long nCol, long nRow, const OUString& elem )
 395     {
 396         if (!elem.isEmpty())
 397         {
 398             ScSetStringParam aParam;
 399             aParam.setTextInput();
 400             mpDoc->SetString(ScAddress(nCol,nRow,0), elem, &aParam);
 401         }
 402     }
 403     void visitElem( long nCol, long nRow, const uno::Any& rElement )
 404     {
 405         uno::TypeClass eElemClass = rElement.getValueTypeClass();
 406         if ( eElemClass == uno::TypeClass_VOID )
 407         {
 408             // leave empty
 409         }
 410         else if ( eElemClass == uno::TypeClass_BYTE ||
 411                     eElemClass == uno::TypeClass_SHORT ||
 412                     eElemClass == uno::TypeClass_UNSIGNED_SHORT ||
 413                     eElemClass == uno::TypeClass_LONG ||
 414                     eElemClass == uno::TypeClass_UNSIGNED_LONG ||
 415                     eElemClass == uno::TypeClass_FLOAT ||
 416                     eElemClass == uno::TypeClass_DOUBLE )
 417         {
 418             //  accept integer types because Basic passes a floating point
 419             //  variable as byte, short or long if it's an integer number.
 420             double fVal(0.0);
 421             rElement >>= fVal;
 422             visitElem( nCol, nRow, fVal );
 423         }
 424         else if ( eElemClass == uno::TypeClass_STRING )
 425         {
 426             OUString aUStr;
 427             rElement >>= aUStr;
 428             visitElem( nCol, nRow, aUStr );
 429         }
 430         else
 431             mbArgError = true;
 432     }
 433     bool hasArgError() const { return mbArgError; }
 434 };
 435
 436 template< class seq >
 437 class SequencesContainer
 438 {
 439     uno::Sequence< uno::Sequence< seq > > maSeq;
 440
 441     long& mrDocRow;
 442     bool mbOverflow;
 443     bool mbArgError;
 444     ScDocument* mpDoc;
 445     ScTokenArray& mrTokenArr;
 446
 447 public:
 448     SequencesContainer( const uno::Any& rArg, ScTokenArray& rTokenArr, long& rDocRow, ScDocument* pDoc ) :
 449         mrDocRow( rDocRow ), mbOverflow(false), mbArgError(false), mpDoc( pDoc ), mrTokenArr( rTokenArr )
 450     {
 451         rArg >>= maSeq;
 452     }
 453
 454     void process()
 455     {
 456         SimpleVisitor aVisitor(mpDoc);
 457         long nStartRow = mrDocRow;
 458         long nRowCount = maSeq.getLength();
 459         long nMaxColCount = 0;
 460         const uno::Sequence< seq >* pRowArr = maSeq.getConstArray();
 461         for ( long nRow=0; nRow<nRowCount; nRow++ )
 462         {
 463             long nColCount = pRowArr[nRow].getLength();
 464             if ( nColCount > nMaxColCount )
 465                 nMaxColCount = nColCount;
 466             const seq* pColArr = pRowArr[nRow].getConstArray();
 467             for (long nCol=0; nCol<nColCount; nCol++)
 468                 if ( nCol <= MAXCOL && mrDocRow <= MAXROW )
 469                     aVisitor.visitElem( nCol, mrDocRow, pColArr[ nCol ] );
 470                 else
 471                     mbOverflow=true;
 472             mrDocRow++;
 473         }
 474         mbArgError = aVisitor.hasArgError();
 475         if ( nRowCount && nMaxColCount && !mbOverflow )
 476             lcl_AddRef( mrTokenArr, nStartRow, nMaxColCount, nRowCount );
 477     }
 478     bool getOverflow() const { return mbOverflow; }
 479     bool getArgError() const { return mbArgError; }
 480 };
 481
 482 template <class T>
 483 class ArrayOfArrayProc
 484 {
 485 public:
 486 static void processSequences( ScDocument* pDoc, const uno::Any& rArg, ScTokenArray& rTokenArr,
 487                                 long& rDocRow, sal_Bool& rArgErr, sal_Bool& rOverflow )
 488 {
 489     SequencesContainer< T > aContainer( rArg, rTokenArr, rDocRow, pDoc );
 490     aContainer.process();
 491     rArgErr = aContainer.getArgError();
 492     rOverflow = aContainer.getOverflow();
 493 }
 494 };
 495
 496 uno::Any SAL_CALL ScFunctionAccess::callFunction( const OUString& aName,
 497                             const uno::Sequence<uno::Any>& aArguments )
 498                 throw(container::NoSuchElementException, lang::IllegalArgumentException,
 499                         uno::RuntimeException)
 500 {
 501     SolarMutexGuard aGuard;
 502
 503     if (!mbValid)
 504         throw uno::RuntimeException();
 505
 506     // use cached document if not in use, temporary document otherwise
 507     //  (deleted in ScTempDocSource dtor)
 508     ScTempDocSource aSource( aDocCache );
 509     ScDocument* pDoc = aSource.GetDocument();
 510     const static SCTAB nTempSheet = 1;
 511     // Create an extra tab to contain the Function Cell
 512     // this will allow full rows to be used.
 513     if ( !pDoc->HasTable( nTempSheet ) )
 514         pDoc->MakeTable( nTempSheet );
 515
 516     /// TODO: check
 517     ScAddress aAdr;
 518     ScCompiler aCompiler(pDoc,aAdr);
 519     aCompiler.SetGrammar(pDoc->GetGrammar());
 520
 521     //
 522     //  find function
 523     //
 524
 525     ScTokenArray aTokenArr;
 526     if ( !lcl_AddFunctionToken( aTokenArr, aName,aCompiler ) )
 527     {
 528         // function not found
 529         throw container::NoSuchElementException();
 530     }
 531
 532     //
 533     //  set options (null date, etc.)
 534     //
 535
 536     if ( pOptions )
 537         pDoc->SetDocOptions( *pOptions );
 538
 539     //
 540     //  add arguments to token array
 541     //
 542
 543     sal_Bool bArgErr = false;
 544     sal_Bool bOverflow = false;
 545     long nDocRow = 0;
 546     long nArgCount = aArguments.getLength();
 547     const uno::Any* pArgArr = aArguments.getConstArray();
 548
 549     aTokenArr.AddOpCode(ocOpen);
 550     for (long nPos=0; nPos<nArgCount; nPos++)
 551     {
 552         if ( nPos > 0 )
 553             aTokenArr.AddOpCode(ocSep);
 554
 555         const uno::Any& rArg = pArgArr[nPos];
 556
 557         uno::TypeClass eClass = rArg.getValueTypeClass();
 558         uno::Type aType = rArg.getValueType();
 559         if ( eClass == uno::TypeClass_BYTE ||
 560              eClass == uno::TypeClass_BOOLEAN ||
 561              eClass == uno::TypeClass_SHORT ||
 562              eClass == uno::TypeClass_UNSIGNED_SHORT ||
 563              eClass == uno::TypeClass_LONG ||
 564              eClass == uno::TypeClass_UNSIGNED_LONG ||
 565              eClass == uno::TypeClass_FLOAT ||
 566              eClass == uno::TypeClass_DOUBLE )
 567         {
 568             //  accept integer types because Basic passes a floating point
 569             //  variable as byte, short or long if it's an integer number.
 570             double fVal = 0;
 571             rArg >>= fVal;
 572             aTokenArr.AddDouble( fVal );
 573         }
 574         else if ( eClass == uno::TypeClass_STRING )
 575         {
 576             OUString aUStr;
 577             rArg >>= aUStr;
 578             String aStr( aUStr );
 579             aTokenArr.AddString( aStr.GetBuffer() );
 580         }
 581         else if ( aType.equals( getCppuType( (uno::Sequence< uno::Sequence<sal_Int16> > *)0 ) ) )
 582         {
 583             ArrayOfArrayProc<sal_Int16>::processSequences( pDoc, rArg, aTokenArr, nDocRow, bArgErr, bOverflow );
 584         }
 585         else if ( aType.equals( getCppuType( (uno::Sequence< uno::Sequence<sal_Int32> > *)0 ) ) )
 586         {
 587             ArrayOfArrayProc<sal_Int32>::processSequences( pDoc, rArg, aTokenArr, nDocRow, bArgErr, bOverflow );
 588         }
 589         else if ( aType.equals( getCppuType( (uno::Sequence< uno::Sequence<double> > *)0 ) ) )
 590         {
 591             ArrayOfArrayProc<double>::processSequences( pDoc, rArg, aTokenArr, nDocRow, bArgErr, bOverflow );
 592         }
 593         else if ( aType.equals( getCppuType( (uno::Sequence< uno::Sequence<OUString> > *)0 ) ) )
 594         {
 595             ArrayOfArrayProc<OUString>::processSequences( pDoc, rArg, aTokenArr, nDocRow, bArgErr, bOverflow );
 596         }
 597         else if ( aType.equals( getCppuType( (uno::Sequence< uno::Sequence<uno::Any> > *)0 ) ) )
 598         {
 599             ArrayOfArrayProc<uno::Any>::processSequences( pDoc, rArg, aTokenArr, nDocRow, bArgErr, bOverflow );
 600         }
 601         else if ( aType.equals( getCppuType( (uno::Reference<table::XCellRange>*)0 ) ) )
 602         {
 603             // currently, only our own cell ranges are supported
 604
 605             uno::Reference<table::XCellRange> xRange(rArg, uno::UNO_QUERY);
 606             ScCellRangesBase* pImpl = ScCellRangesBase::getImplementation( xRange );
 607             if ( pImpl )
 608             {
 609                 ScDocument* pSrcDoc = pImpl->GetDocument();
 610                 const ScRangeList& rRanges = pImpl->GetRangeList();
 611                 if ( pSrcDoc && rRanges.size() == 1 )
 612                 {
 613                     ScRange aSrcRange = *rRanges[ 0 ];
 614
 615                     long nStartRow = nDocRow;
 616                     long nColCount = aSrcRange.aEnd.Col() - aSrcRange.aStart.Col() + 1;
 617                     long nRowCount = aSrcRange.aEnd.Row() - aSrcRange.aStart.Row() + 1;
 618
 619                     if ( nStartRow + nRowCount > MAXROWCOUNT )
 620                         bOverflow = sal_True;
 621                     else
 622                     {
 623                         // copy data
 624                         if ( !lcl_CopyData( pSrcDoc, aSrcRange, pDoc, ScAddress( 0, (SCROW)nDocRow, 0 ) ) )
 625                             bOverflow = sal_True;
 626                     }
 627
 628                     nDocRow += nRowCount;
 629                     if ( !bOverflow )
 630                         lcl_AddRef( aTokenArr, nStartRow, nColCount, nRowCount );
 631                 }
 632                 else
 633                     bArgErr = sal_True;
 634             }
 635             else
 636                 bArgErr = sal_True;
 637         }
 638         else
 639             bArgErr = sal_True;                 // invalid type
 640     }
 641     aTokenArr.AddOpCode(ocClose);
 642     aTokenArr.AddOpCode(ocStop);
 643
 644     //
 645     //  execute formula
 646     //
 647
 648     uno::Any aRet;
 649     if ( !bArgErr && !bOverflow && nDocRow <= MAXROWCOUNT )
 650     {
 651         ScAddress aFormulaPos( 0, 0, nTempSheet );
 652         // GRAM_PODF_A1 doesn't really matter for the token array but fits with
 653         // other API compatibility grammars.
 654         ScFormulaCell* pFormula = new ScFormulaCell( pDoc, aFormulaPos,
 655                 &aTokenArr, formula::FormulaGrammar::GRAM_PODF_A1, (sal_uInt8)(mbArray ? MM_FORMULA : MM_NONE) );
 656         pDoc->SetFormulaCell(aFormulaPos, pFormula);
 657
 658         //  call GetMatrix before GetErrCode because GetMatrix always recalculates
 659         //  if there is no matrix result
 660
 661         const ScMatrix* pMat = mbArray ? pFormula->GetMatrix() : 0;
 662         sal_uInt16 nErrCode = pFormula->GetErrCode();
 663         if ( nErrCode == 0 )
 664         {
 665             if ( pMat )
 666             {
 667                 // array result
 668                 ScRangeToSequence::FillMixedArray( aRet, pMat );
 669             }
 670             else if ( pFormula->IsValue() )
 671             {
 672                 // numeric value
 673                 aRet <<= (double) pFormula->GetValue();
 674             }
 675             else
 676             {
 677                 // string result
 678                 OUString aStrVal = pFormula->GetString();
 679                 aRet <<= aStrVal;
 680             }
 681         }
 682         else if ( nErrCode == NOTAVAILABLE )
 683         {
 684             // #N/A: leave result empty, no exception
 685         }
 686         else
 687         {
 688             //  any other error: IllegalArgumentException
 689             bArgErr = sal_True;
 690         }
 691
 692         pDoc->DeleteAreaTab( 0, 0, MAXCOL, MAXROW, 0, IDF_ALL );
 693         pDoc->DeleteAreaTab( 0, 0, 0, 0, nTempSheet, IDF_ALL );
 694     }
 695
 696     if (bOverflow)
 697         throw uno::RuntimeException();
 698
 699     if (bArgErr)
 700         throw lang::IllegalArgumentException();
 701
 702     return aRet;
 703 }
 704
 705
 706 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */