sc/source/filter/excel/xilink.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: xilink.cxx,v $
  10  * $Revision: 1.25.46.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33 #include "xilink.hxx"
  34 #include "document.hxx"
  35 #include "cell.hxx"
  36 #include "scextopt.hxx"
  37 #include "tablink.hxx"
  38 #include "xistream.hxx"
  39 #include "xihelper.hxx"
  40 #include "xiname.hxx"
  41 #include "excform.hxx"
  42 #include "tokenarray.hxx"
  43 #include "externalrefmgr.hxx"
  44
  45 #include <vector>
  46
  47 using ::std::vector;
  48
  49 // ============================================================================
  50 // *** Helper classes ***
  51 // ============================================================================
  52
  53 // Cached external cells ======================================================
  54
  55 /** Contains the address and value of an external referenced cell. */
  56 class XclImpCrn : public XclImpCachedValue
  57 {
  58 public:
  59     /** Reads a cached value and stores it with its cell address. */
  60     explicit            XclImpCrn( XclImpStream& rStrm, const XclAddress& rXclPos );
  61
  62     const XclAddress&   GetAddress() const;
  63
  64 private:
  65     XclAddress          maXclPos;       /// Excel position of the cached cell.
  66 };
  67
  68 // Sheet in an external document ==============================================
  69
  70 /** Contains the name and sheet index of one sheet in an external document. */
  71 class XclImpSupbookTab
  72 {
  73 public:
  74     /** Stores the sheet name and marks the sheet index as invalid.
  75         The sheet index is set while creating the Calc sheet with CreateTable(). */
  76     explicit            XclImpSupbookTab( const String& rTabName );
  77                         ~XclImpSupbookTab();
  78
  79     inline const String& GetTabName() const { return maTabName; }
  80
  81     /** Reads a CRN record (external referenced cell) at the specified address. */
  82     void                ReadCrn( XclImpStream& rStrm, const XclAddress& rXclPos );
  83
  84     void                LoadCachedValues(ScExternalRefCache::TableTypeRef pCacheTable);
  85
  86 private:
  87     typedef ScfDelList< XclImpCrn > XclImpCrnList;
  88
  89     XclImpCrnList       maCrnList;      /// List of CRN records (cached cell values).
  90     String              maTabName;      /// Name of the external sheet.
  91     SCTAB               mnScTab;        /// New sheet index in Calc document.
  92 };
  93
  94 // External document (SUPBOOK) ================================================
  95
  96 /** This class represents an external linked document (record SUPBOOK).
  97     @descr  Contains a list of all referenced sheets in the document. */
  98 class XclImpSupbook : protected XclImpRoot
  99 {
 100 public:
 101     /** Reads the SUPBOOK record from stream. */
 102     explicit            XclImpSupbook( XclImpStream& rStrm );
 103
 104     /** Reads an XCT record (count of following CRNs and current sheet). */
 105     void                ReadXct( XclImpStream& rStrm );
 106     /** Reads a CRN record (external referenced cell). */
 107     void                ReadCrn( XclImpStream& rStrm );
 108     /** Reads an EXTERNNAME record. */
 109     void                ReadExternname( XclImpStream& rStrm, ExcelToSc* pFormulaConv = NULL );
 110
 111     /** Returns the SUPBOOK record type. */
 112     inline XclSupbookType GetType() const { return meType; }
 113
 114     /** Returns the URL of the external document. */
 115     inline const String& GetXclUrl() const { return maXclUrl; }
 116
 117     /** Returns the external name specified by an index from the Excel document (one-based). */
 118     const XclImpExtName* GetExternName( sal_uInt16 nXclIndex ) const;
 119     /** Tries to decode the URL to OLE or DDE link components.
 120         @descr  For DDE links: Decodes to application name and topic.
 121         For OLE object links: Decodes to class name and document URL.
 122         @return  true = decoding was successful, returned strings are valid (not empty). */
 123     bool                GetLinkData( String& rApplic, String& rDoc ) const;
 124     /** Returns the specified macro name (1-based) or an empty string on error. */
 125     const String&       GetMacroName( sal_uInt16 nXclNameIdx ) const;
 126
 127     const String&       GetTabName( sal_uInt16 nXtiTab ) const;
 128
 129     sal_uInt16          GetTabCount() const;
 130
 131     void                LoadCachedValues();
 132
 133 private:
 134     typedef ScfDelList< XclImpSupbookTab >  XclImpSupbookTabList;
 135     typedef ScfDelList< XclImpExtName >     XclImpExtNameList;
 136
 137     XclImpSupbookTabList maSupbTabList;     /// All sheet names of the document.
 138     XclImpExtNameList   maExtNameList;      /// All external names of the document.
 139     String              maXclUrl;           /// URL of the external document (Excel mode).
 140     String              maFilterName;       /// Detected filer name.
 141     String              maFilterOpt;        /// Detected filer options.
 142     XclSupbookType      meType;             /// Type of the supbook record.
 143     sal_uInt16          mnSBTab;            /// Current Excel sheet index from SUPBOOK for XCT/CRN records.
 144 };
 145
 146 // Import link manager ========================================================
 147
 148 /** Contains the SUPBOOK index and sheet indexes of an external link.
 149     @descr  It is possible to enter a formula like =SUM(Sheet1:Sheet3!A1),
 150     therefore here occurs a sheet range. */
 151 struct XclImpXti
 152 {
 153     sal_uInt16          mnSupbook;      /// Index to SUPBOOK record.
 154     sal_uInt16          mnSBTabFirst;   /// Index to the first sheet of the range in the SUPBOOK.
 155     sal_uInt16          mnSBTabLast;    /// Index to the last sheet of the range in the SUPBOOK.
 156 };
 157
 158 inline XclImpStream& operator>>( XclImpStream& rStrm, XclImpXti& rXti )
 159 {
 160     return rStrm >> rXti.mnSupbook >> rXti.mnSBTabFirst >> rXti.mnSBTabLast;
 161 }
 162
 163 // ----------------------------------------------------------------------------
 164
 165 /** Implementation of the link manager. */
 166 class XclImpLinkManagerImpl : protected XclImpRoot
 167 {
 168 public:
 169     explicit            XclImpLinkManagerImpl( const XclImpRoot& rRoot );
 170
 171     /** Reads the EXTERNSHEET record. */
 172     void                ReadExternsheet( XclImpStream& rStrm );
 173     /** Reads a SUPBOOK record. */
 174     void                ReadSupbook( XclImpStream& rStrm );
 175     /** Reads an XCT record and appends it to the current SUPBOOK. */
 176     void                ReadXct( XclImpStream& rStrm );
 177     /** Reads a CRN record and appends it to the current SUPBOOK. */
 178     void                ReadCrn( XclImpStream& rStrm );
 179     /** Reads an EXTERNNAME record and appends it to the current SUPBOOK. */
 180     void                ReadExternname( XclImpStream& rStrm, ExcelToSc* pFormulaConv = NULL );
 181
 182     /** Returns true, if the specified XTI entry contains an internal reference. */
 183     bool                IsSelfRef( sal_uInt16 nXtiIndex ) const;
 184     /** Returns the Calc sheet index range of the specified XTI entry.
 185         @return  true = XTI data found, returned sheet index range is valid. */
 186     bool                GetScTabRange(
 187                             SCTAB& rnFirstScTab, SCTAB& rnLastScTab,
 188                             sal_uInt16 nXtiIndex ) const;
 189     /** Returns the specified external name or 0 on error. */
 190     const XclImpExtName* GetExternName( sal_uInt16 nXtiIndex, sal_uInt16 nExtName ) const;
 191
 192     /** Returns the absolute file URL of a supporting workbook specified by
 193         the index. */
 194     const String*       GetSupbookUrl( sal_uInt16 nXtiIndex ) const;
 195
 196     const String&       GetSupbookTabName( sal_uInt16 nXti, sal_uInt16 nXtiTab ) const;
 197
 198     /** Tries to decode the URL of the specified XTI entry to OLE or DDE link components.
 199         @descr  For DDE links: Decodes to application name and topic.
 200         For OLE object links: Decodes to class name and document URL.
 201         @return  true = decoding was successful, returned strings are valid (not empty). */
 202     bool                GetLinkData( String& rApplic, String& rTopic, sal_uInt16 nXtiIndex ) const;
 203     /** Returns the specified macro name or an empty string on error. */
 204     const String&       GetMacroName( sal_uInt16 nExtSheet, sal_uInt16 nExtName ) const;
 205
 206 private:
 207     /** Returns the specified SUPBOOK (external document). */
 208     const XclImpSupbook* GetSupbook( sal_uInt32 nXtiIndex ) const;
 209 //UNUSED2009-05 /** Returns the SUPBOOK (external workbook) specified by its URL. */
 210 //UNUSED2009-05 const XclImpSupbook* GetSupbook( const String& rUrl ) const;
 211
 212     void                LoadCachedValues();
 213
 214 //UNUSED2009-05 /** Finds the largest range of sheet indexes in a SUPBOOK after a start sheet index.
 215 //UNUSED2009-05     @param rnSBTabFirst  (out-param) The first sheet index of the range in SUPBOOK is returned here.
 216 //UNUSED2009-05     @param rnSBTabLast  (out-param) The last sheet index of the range in SUPBOOK is returned here (inclusive).
 217 //UNUSED2009-05     @param nSupbook  The list index of the SUPBOOK.
 218 //UNUSED2009-05     @param nSBTabStart  The first allowed sheet index. Sheet ranges with an earlier start index are ignored.
 219 //UNUSED2009-05     @return  true = the return values are valid; false = nothing found. */
 220 //UNUSED2009-05 bool                FindNextTabRange(
 221 //UNUSED2009-05                         sal_uInt16& rnSBTabFirst, sal_uInt16& rnSBTabLast,
 222 //UNUSED2009-05                         sal_uInt16 nSupbook, sal_uInt16 nSBTabStart ) const;
 223
 224 private:
 225     typedef ScfDelList< XclImpXti >     XclImpXtiList;
 226     typedef ScfDelList< XclImpSupbook > XclImpSupbookList;
 227
 228     XclImpXtiList       maXtiList;          /// List of all XTI structures.
 229     XclImpSupbookList   maSupbookList;      /// List of external documents.
 230     bool                mbCreated;          /// true = Calc sheets already created.
 231 };
 232
 233 // ============================================================================
 234 // *** Implementation ***
 235 // ============================================================================
 236
 237 // Excel sheet indexes ========================================================
 238
 239 // original Excel sheet names -------------------------------------------------
 240
 241 void XclImpTabInfo::AppendXclTabName( const String& rXclTabName, SCTAB nScTab )
 242 {
 243     maTabNames[ rXclTabName ] = nScTab;
 244 }
 245
 246 void XclImpTabInfo::InsertScTab( SCTAB nScTab )
 247 {
 248     for( XclTabNameMap::iterator aIt = maTabNames.begin(), aEnd = maTabNames.end(); aIt != aEnd; ++aIt )
 249         if( aIt->second >= nScTab )
 250             ++aIt->second;
 251 }
 252
 253 SCTAB XclImpTabInfo::GetScTabFromXclName( const String& rXclTabName ) const
 254 {
 255     XclTabNameMap::const_iterator aIt = maTabNames.find( rXclTabName );
 256     return (aIt != maTabNames.end()) ? aIt->second : SCTAB_INVALID;
 257 }
 258
 259 // record creation order - TABID record ---------------------------------------
 260
 261 void XclImpTabInfo::ReadTabid( XclImpStream& rStrm )
 262 {
 263     DBG_ASSERT_BIFF( rStrm.GetRoot().GetBiff() == EXC_BIFF8 );
 264     if( rStrm.GetRoot().GetBiff() == EXC_BIFF8 )
 265     {
 266         rStrm.EnableDecryption();
 267         sal_Size nReadCount = rStrm.GetRecLeft() / 2;
 268         DBG_ASSERT( nReadCount <= 0xFFFF, "XclImpTabInfo::ReadTabid - record too long" );
 269         maTabIdVec.clear();
 270         maTabIdVec.reserve( nReadCount );
 271         for( sal_Size nIndex = 0; rStrm.IsValid() && (nIndex < nReadCount); ++nIndex )
 272             // #93471# zero index is not allowed in BIFF8, but it seems that it occurs in real life
 273             maTabIdVec.push_back( rStrm.ReaduInt16() );
 274     }
 275 }
 276
 277 sal_uInt16 XclImpTabInfo::GetCurrentIndex( sal_uInt16 nCreatedId, sal_uInt16 nMaxTabId ) const
 278 {
 279     sal_uInt16 nReturn = 0;
 280     for( ScfUInt16Vec::const_iterator aIt = maTabIdVec.begin(), aEnd = maTabIdVec.end(); aIt != aEnd; ++aIt )
 281     {
 282         sal_uInt16 nValue = *aIt;
 283         if( nValue == nCreatedId )
 284             return nReturn;
 285         if( nValue <= nMaxTabId )
 286             ++nReturn;
 287     }
 288     return 0;
 289 }
 290
 291 // External names =============================================================
 292
 293 XclImpExtName::XclImpExtName( const XclImpSupbook& rSupbook, XclImpStream& rStrm, XclSupbookType eSubType, ExcelToSc* pFormulaConv )
 294 {
 295     sal_uInt16 nFlags;
 296     sal_uInt8 nLen;
 297
 298     rStrm >> nFlags >> mnStorageId >> nLen ;
 299     maName = rStrm.ReadUniString( nLen );
 300     if( ::get_flag( nFlags, EXC_EXTN_BUILTIN ) || !::get_flag( nFlags, EXC_EXTN_OLE_OR_DDE ) )
 301     {
 302         if( eSubType == EXC_SBTYPE_ADDIN )
 303         {
 304             meType = xlExtAddIn;
 305             maName = rStrm.GetRoot().GetScAddInName( maName );
 306         }
 307         else if ( (eSubType == EXC_SBTYPE_EUROTOOL) &&
 308                 maName.EqualsIgnoreCaseAscii( "EUROCONVERT" ) )
 309             meType = xlExtEuroConvert;
 310         else
 311         {
 312             meType = xlExtName;
 313             ScfTools::ConvertToScDefinedName( maName );
 314         }
 315     }
 316     else
 317     {
 318         meType = ::get_flagvalue( nFlags, EXC_EXTN_OLE, xlExtOLE, xlExtDDE );
 319     }
 320
 321     if( (meType == xlExtDDE) && (rStrm.GetRecLeft() > 1) )
 322         mxDdeMatrix.reset( new XclImpCachedMatrix( rStrm ) );
 323
 324     if (meType == xlExtName)
 325     {
 326         // TODO: For now, only global external names are supported.  In future
 327         // we should extend this to supporting per-sheet external names.
 328         if (mnStorageId == 0)
 329         {
 330             if (pFormulaConv)
 331             {
 332                 const ScTokenArray* pArray = NULL;
 333                 sal_uInt16 nFmlaLen;
 334                 rStrm >> nFmlaLen;
 335                 vector<String> aTabNames;
 336                 sal_uInt16 nCount = rSupbook.GetTabCount();
 337                 aTabNames.reserve(nCount);
 338                 for (sal_uInt16 i = 0; i < nCount; ++i)
 339                     aTabNames.push_back(rSupbook.GetTabName(i));
 340
 341                 pFormulaConv->ConvertExternName(pArray, rStrm, nFmlaLen, rSupbook.GetXclUrl(), aTabNames);
 342                 if (pArray)
 343                     mxArray.reset(pArray->Clone());
 344             }
 345         }
 346     }
 347 }
 348
 349 XclImpExtName::~XclImpExtName()
 350 {
 351 }
 352
 353 void XclImpExtName::CreateDdeData( ScDocument& rDoc, const String& rApplic, const String& rTopic ) const
 354 {
 355     ScMatrixRef xResults;
 356     if( mxDdeMatrix.get() )
 357         xResults = mxDdeMatrix->CreateScMatrix();
 358     rDoc.CreateDdeLink( rApplic, rTopic, maName, SC_DDE_DEFAULT, xResults );
 359 }
 360
 361 void XclImpExtName::CreateExtNameData( ScDocument& rDoc, sal_uInt16 nFileId ) const
 362 {
 363     if (!mxArray.get())
 364         return;
 365
 366     ScExternalRefManager* pRefMgr = rDoc.GetExternalRefManager();
 367     pRefMgr->storeRangeNameTokens(nFileId, maName, *mxArray);
 368 }
 369
 370 bool XclImpExtName::HasFormulaTokens() const
 371 {
 372     return (mxArray.get() != NULL);
 373 }
 374
 375 // Cached external cells ======================================================
 376
 377 XclImpCrn::XclImpCrn( XclImpStream& rStrm, const XclAddress& rXclPos ) :
 378     XclImpCachedValue( rStrm ),
 379     maXclPos( rXclPos )
 380 {
 381 }
 382
 383 const XclAddress& XclImpCrn::GetAddress() const
 384 {
 385     return maXclPos;
 386 }
 387
 388 // Sheet in an external document ==============================================
 389
 390 XclImpSupbookTab::XclImpSupbookTab( const String& rTabName ) :
 391     maTabName( rTabName ),
 392     mnScTab( SCTAB_INVALID )
 393 {
 394 }
 395
 396 XclImpSupbookTab::~XclImpSupbookTab()
 397 {
 398 }
 399
 400 void XclImpSupbookTab::ReadCrn( XclImpStream& rStrm, const XclAddress& rXclPos )
 401 {
 402     maCrnList.Append( new XclImpCrn( rStrm, rXclPos ) );
 403 }
 404
 405 void XclImpSupbookTab::LoadCachedValues(ScExternalRefCache::TableTypeRef pCacheTable)
 406 {
 407     if (maCrnList.Empty())
 408         return;
 409
 410     for (XclImpCrn* p = maCrnList.First(); p; p = maCrnList.Next())
 411     {
 412         const XclAddress& rAddr = p->GetAddress();
 413         switch (p->GetType())
 414         {
 415             case EXC_CACHEDVAL_BOOL:
 416             break;
 417             case EXC_CACHEDVAL_DOUBLE:
 418             {
 419                 double f = p->GetValue();
 420                 ScExternalRefCache::TokenRef pToken(new formula::FormulaDoubleToken(f));
 421                 pCacheTable->setCell(rAddr.mnCol, rAddr.mnRow, pToken);
 422             }
 423             break;
 424             case EXC_CACHEDVAL_EMPTY:
 425             break;
 426             case EXC_CACHEDVAL_ERROR:
 427             break;
 428             case EXC_CACHEDVAL_STRING:
 429             {
 430                 const String& rStr = p->GetString();
 431                 ScExternalRefCache::TokenRef pToken(new formula::FormulaStringToken(rStr));
 432                 pCacheTable->setCell(rAddr.mnCol, rAddr.mnRow, pToken);
 433             }
 434             break;
 435             default:
 436                 ;
 437         }
 438     }
 439 }
 440
 441 // External document (SUPBOOK) ================================================
 442
 443 XclImpSupbook::XclImpSupbook( XclImpStream& rStrm ) :
 444     XclImpRoot( rStrm.GetRoot() ),
 445     meType( EXC_SBTYPE_UNKNOWN ),
 446     mnSBTab( EXC_TAB_DELETED )
 447 {
 448     sal_uInt16 nSBTabCnt;
 449     rStrm >> nSBTabCnt;
 450
 451     if( rStrm.GetRecLeft() == 2 )
 452     {
 453         switch( rStrm.ReaduInt16() )
 454         {
 455             case EXC_SUPB_SELF:     meType = EXC_SBTYPE_SELF;   break;
 456             case EXC_SUPB_ADDIN:    meType = EXC_SBTYPE_ADDIN;  break;
 457             default:    DBG_ERRORFILE( "XclImpSupbook::XclImpSupbook - unknown special SUPBOOK type" );
 458         }
 459         return;
 460     }
 461
 462     String aEncUrl( rStrm.ReadUniString() );
 463     bool bSelf = false;
 464     XclImpUrlHelper::DecodeUrl( maXclUrl, bSelf, GetRoot(), aEncUrl );
 465
 466     if( maXclUrl.EqualsIgnoreCaseAscii( "\010EUROTOOL.XLA" ) )
 467     {
 468         meType = EXC_SBTYPE_EUROTOOL;
 469         maSupbTabList.Append( new XclImpSupbookTab( maXclUrl ) );
 470     }
 471     else if( nSBTabCnt )
 472     {
 473         meType = EXC_SBTYPE_EXTERN;
 474         for( sal_uInt16 nSBTab = 0; nSBTab < nSBTabCnt; ++nSBTab )
 475         {
 476             String aTabName( rStrm.ReadUniString() );
 477             maSupbTabList.Append( new XclImpSupbookTab( aTabName ) );
 478         }
 479     }
 480     else
 481     {
 482         meType = EXC_SBTYPE_SPECIAL;
 483         // create dummy list entry
 484         maSupbTabList.Append( new XclImpSupbookTab( maXclUrl ) );
 485     }
 486 }
 487
 488 void XclImpSupbook::ReadXct( XclImpStream& rStrm )
 489 {
 490     rStrm.Ignore( 2 );
 491     rStrm >> mnSBTab;
 492 }
 493
 494 void XclImpSupbook::ReadCrn( XclImpStream& rStrm )
 495 {
 496     if( XclImpSupbookTab* pSBTab = maSupbTabList.GetObject( mnSBTab ) )
 497     {
 498         sal_uInt8 nXclColLast, nXclColFirst;
 499         sal_uInt16 nXclRow;
 500         rStrm >> nXclColLast >> nXclColFirst >> nXclRow;
 501
 502         for( sal_uInt8 nXclCol = nXclColFirst; (nXclCol <= nXclColLast) && (rStrm.GetRecLeft() > 1); ++nXclCol )
 503             pSBTab->ReadCrn( rStrm, XclAddress( nXclCol, nXclRow ) );
 504     }
 505 }
 506
 507 void XclImpSupbook::ReadExternname( XclImpStream& rStrm, ExcelToSc* pFormulaConv )
 508 {
 509     maExtNameList.Append( new XclImpExtName( *this, rStrm, meType, pFormulaConv ) );
 510 }
 511
 512 const XclImpExtName* XclImpSupbook::GetExternName( sal_uInt16 nXclIndex ) const
 513 {
 514     DBG_ASSERT( nXclIndex > 0, "XclImpSupbook::GetExternName - index must be >0" );
 515     return (meType == EXC_SBTYPE_SELF) ? 0 : maExtNameList.GetObject( nXclIndex - 1 );
 516 }
 517
 518 bool XclImpSupbook::GetLinkData( String& rApplic, String& rTopic ) const
 519 {
 520     return (meType == EXC_SBTYPE_SPECIAL) && XclImpUrlHelper::DecodeLink( rApplic, rTopic, maXclUrl );
 521 }
 522
 523 const String& XclImpSupbook::GetMacroName( sal_uInt16 nXclNameIdx ) const
 524 {
 525     DBG_ASSERT( nXclNameIdx > 0, "XclImpSupbook::GetMacroName - index must be >0" );
 526     const XclImpName* pName = (meType == EXC_SBTYPE_SELF) ? GetNameManager().GetName( nXclNameIdx ) : 0;
 527     return (pName && pName->IsVBName()) ? pName->GetScName() : EMPTY_STRING;
 528 }
 529
 530 const String& XclImpSupbook::GetTabName( sal_uInt16 nXtiTab ) const
 531 {
 532     if (maSupbTabList.Empty())
 533         return EMPTY_STRING;
 534
 535     sal_uInt16 i = 0;
 536     for (XclImpSupbookTab* p = maSupbTabList.First(); p; p = maSupbTabList.Next(), ++i)
 537     {
 538         if (i == nXtiTab)
 539             return p->GetTabName();
 540     }
 541
 542     return EMPTY_STRING;
 543 }
 544
 545 sal_uInt16 XclImpSupbook::GetTabCount() const
 546 {
 547     return ulimit_cast<sal_uInt16>(maSupbTabList.Count());
 548 }
 549
 550 void XclImpSupbook::LoadCachedValues()
 551 {
 552     if (meType != EXC_SBTYPE_EXTERN || GetExtDocOptions().GetDocSettings().mnLinkCnt > 0 || !GetDocShell())
 553         return;
 554
 555     String aAbsUrl( ScGlobal::GetAbsDocName(maXclUrl, GetDocShell()) );
 556
 557     ScExternalRefManager* pRefMgr = GetRoot().GetDoc().GetExternalRefManager();
 558     sal_uInt16 nFileId = pRefMgr->getExternalFileId(aAbsUrl);
 559
 560     sal_uInt16 nCount = static_cast< sal_uInt16 >( maSupbTabList.Count() );
 561     for (sal_uInt16 i = 0; i < nCount; ++i)
 562     {
 563         XclImpSupbookTab* pTab = maSupbTabList.GetObject(i);
 564         if (!pTab)
 565             return;
 566
 567         const String& rTabName = pTab->GetTabName();
 568         ScExternalRefCache::TableTypeRef pCacheTable = pRefMgr->getCacheTable(nFileId, rTabName, true);
 569         pTab->LoadCachedValues(pCacheTable);
 570     }
 571 }
 572
 573 // Import link manager ========================================================
 574
 575 XclImpLinkManagerImpl::XclImpLinkManagerImpl( const XclImpRoot& rRoot ) :
 576     XclImpRoot( rRoot ),
 577     mbCreated( false )
 578 {
 579 }
 580
 581 void XclImpLinkManagerImpl::ReadExternsheet( XclImpStream& rStrm )
 582 {
 583     sal_uInt16 nXtiCount;
 584     rStrm >> nXtiCount;
 585
 586     XclImpXti* pXti;
 587     while( nXtiCount )
 588     {
 589         pXti = new XclImpXti;
 590         rStrm >> *pXti;
 591         maXtiList.Append( pXti );
 592         --nXtiCount;
 593     }
 594
 595     LoadCachedValues();
 596 }
 597
 598 void XclImpLinkManagerImpl::ReadSupbook( XclImpStream& rStrm )
 599 {
 600     maSupbookList.Append( new XclImpSupbook( rStrm ) );
 601 }
 602
 603 void XclImpLinkManagerImpl::ReadXct( XclImpStream& rStrm )
 604 {
 605     if( XclImpSupbook* pSupbook = maSupbookList.Last() )
 606         pSupbook->ReadXct( rStrm );
 607 }
 608
 609 void XclImpLinkManagerImpl::ReadCrn( XclImpStream& rStrm )
 610 {
 611     if( XclImpSupbook* pSupbook = maSupbookList.Last() )
 612         pSupbook->ReadCrn( rStrm );
 613 }
 614
 615 void XclImpLinkManagerImpl::ReadExternname( XclImpStream& rStrm, ExcelToSc* pFormulaConv )
 616 {
 617     if( XclImpSupbook* pSupbook = maSupbookList.Last() )
 618         pSupbook->ReadExternname( rStrm, pFormulaConv );
 619 }
 620
 621 bool XclImpLinkManagerImpl::IsSelfRef( sal_uInt16 nXtiIndex ) const
 622 {
 623     const XclImpSupbook* pSupbook = GetSupbook( nXtiIndex );
 624     return pSupbook && (pSupbook->GetType() == EXC_SBTYPE_SELF);
 625 }
 626
 627 bool XclImpLinkManagerImpl::GetScTabRange(
 628         SCTAB& rnFirstScTab, SCTAB& rnLastScTab, sal_uInt16 nXtiIndex ) const
 629 {
 630     if( const XclImpXti* pXti = maXtiList.GetObject( nXtiIndex ) )
 631     {
 632         if (maSupbookList.GetObject(pXti->mnSupbook))
 633         {
 634             rnFirstScTab = pXti->mnSBTabFirst;
 635             rnLastScTab  = pXti->mnSBTabLast;
 636             return true;
 637         }
 638     }
 639     return false;
 640 }
 641
 642 const XclImpExtName* XclImpLinkManagerImpl::GetExternName( sal_uInt16 nXtiIndex, sal_uInt16 nExtName ) const
 643 {
 644     const XclImpSupbook* pSupbook = GetSupbook( nXtiIndex );
 645     return pSupbook ? pSupbook->GetExternName( nExtName ) : 0;
 646 }
 647
 648 const String* XclImpLinkManagerImpl::GetSupbookUrl( sal_uInt16 nXtiIndex ) const
 649 {
 650     const XclImpSupbook* p = GetSupbook( nXtiIndex );
 651     if (!p)
 652         return NULL;
 653     return &p->GetXclUrl();
 654 }
 655
 656 const String& XclImpLinkManagerImpl::GetSupbookTabName( sal_uInt16 nXti, sal_uInt16 nXtiTab ) const
 657 {
 658     const XclImpSupbook* p = GetSupbook(nXti);
 659     return p ? p->GetTabName(nXtiTab) : EMPTY_STRING;
 660 }
 661
 662 bool XclImpLinkManagerImpl::GetLinkData( String& rApplic, String& rTopic, sal_uInt16 nXtiIndex ) const
 663 {
 664     const XclImpSupbook* pSupbook = GetSupbook( nXtiIndex );
 665     return pSupbook && pSupbook->GetLinkData( rApplic, rTopic );
 666 }
 667
 668 const String& XclImpLinkManagerImpl::GetMacroName( sal_uInt16 nExtSheet, sal_uInt16 nExtName ) const
 669 {
 670     const XclImpSupbook* pSupbook = GetSupbook( nExtSheet );
 671     return pSupbook ? pSupbook->GetMacroName( nExtName ) : EMPTY_STRING;
 672 }
 673
 674 const XclImpSupbook* XclImpLinkManagerImpl::GetSupbook( sal_uInt32 nXtiIndex ) const
 675 {
 676     const XclImpXti* pXti = maXtiList.GetObject( nXtiIndex );
 677     return pXti ? maSupbookList.GetObject( pXti->mnSupbook ) : 0;
 678 }
 679
 680 //UNUSED2009-05 const XclImpSupbook* XclImpLinkManagerImpl::GetSupbook( const String& rUrl ) const
 681 //UNUSED2009-05 {
 682 //UNUSED2009-05     for( const XclImpSupbook* pSupbook = maSupbookList.First(); pSupbook; pSupbook = maSupbookList.Next() )
 683 //UNUSED2009-05         if( pSupbook->GetXclUrl() == rUrl )
 684 //UNUSED2009-05             return pSupbook;
 685 //UNUSED2009-05     return 0;
 686 //UNUSED2009-05 }
 687
 688 void XclImpLinkManagerImpl::LoadCachedValues()
 689 {
 690     // Read all CRN records which can be accessed via XclImpSupbook, and store
 691     // the cached values to the external reference manager.
 692
 693     sal_uInt32 nCount = maSupbookList.Count();
 694     for (sal_uInt16 nSupbook = 0; nSupbook < nCount; ++nSupbook)
 695     {
 696         XclImpSupbook* pSupbook = maSupbookList.GetObject(nSupbook);
 697         pSupbook->LoadCachedValues();
 698     }
 699 }
 700
 701 //UNUSED2009-05 bool XclImpLinkManagerImpl::FindNextTabRange(
 702 //UNUSED2009-05         sal_uInt16& rnSBTabFirst, sal_uInt16& rnSBTabLast,
 703 //UNUSED2009-05         sal_uInt16 nSupbook, sal_uInt16 nSBTabStart ) const
 704 //UNUSED2009-05 {
 705 //UNUSED2009-05     rnSBTabFirst = rnSBTabLast = EXC_NOTAB;
 706 //UNUSED2009-05     for( const XclImpXti* pXti = maXtiList.First(); pXti; pXti = maXtiList.Next() )
 707 //UNUSED2009-05     {
 708 //UNUSED2009-05         if( (nSupbook == pXti->mnSupbook) && (nSBTabStart <= pXti->mnSBTabLast) && (pXti->mnSBTabFirst < rnSBTabFirst) )
 709 //UNUSED2009-05         {
 710 //UNUSED2009-05             rnSBTabFirst = ::std::max( nSBTabStart, pXti->mnSBTabFirst );
 711 //UNUSED2009-05             rnSBTabLast = pXti->mnSBTabLast;
 712 //UNUSED2009-05         }
 713 //UNUSED2009-05     }
 714 //UNUSED2009-05     return rnSBTabFirst != EXC_NOTAB;
 715 //UNUSED2009-05 }
 716
 717 // ============================================================================
 718
 719 XclImpLinkManager::XclImpLinkManager( const XclImpRoot& rRoot ) :
 720     XclImpRoot( rRoot ),
 721     mxImpl( new XclImpLinkManagerImpl( rRoot ) )
 722 {
 723 }
 724
 725 XclImpLinkManager::~XclImpLinkManager()
 726 {
 727 }
 728
 729 void XclImpLinkManager::ReadExternsheet( XclImpStream& rStrm )
 730 {
 731     mxImpl->ReadExternsheet( rStrm );
 732 }
 733
 734 void XclImpLinkManager::ReadSupbook( XclImpStream& rStrm )
 735 {
 736     mxImpl->ReadSupbook( rStrm );
 737 }
 738
 739 void XclImpLinkManager::ReadXct( XclImpStream& rStrm )
 740 {
 741     mxImpl->ReadXct( rStrm );
 742 }
 743
 744 void XclImpLinkManager::ReadCrn( XclImpStream& rStrm )
 745 {
 746     mxImpl->ReadCrn( rStrm );
 747 }
 748
 749 void XclImpLinkManager::ReadExternname( XclImpStream& rStrm, ExcelToSc* pFormulaConv )
 750 {
 751     mxImpl->ReadExternname( rStrm, pFormulaConv );
 752 }
 753
 754 bool XclImpLinkManager::IsSelfRef( sal_uInt16 nXtiIndex ) const
 755 {
 756     return mxImpl->IsSelfRef( nXtiIndex );
 757 }
 758
 759 bool XclImpLinkManager::GetScTabRange(
 760         SCTAB& rnFirstScTab, SCTAB& rnLastScTab, sal_uInt16 nXtiIndex ) const
 761 {
 762     return mxImpl->GetScTabRange( rnFirstScTab, rnLastScTab, nXtiIndex );
 763 }
 764
 765 const XclImpExtName* XclImpLinkManager::GetExternName( sal_uInt16 nXtiIndex, sal_uInt16 nExtName ) const
 766 {
 767     return mxImpl->GetExternName( nXtiIndex, nExtName );
 768 }
 769
 770 const String* XclImpLinkManager::GetSupbookUrl( sal_uInt16 nXtiIndex ) const
 771 {
 772     return mxImpl->GetSupbookUrl(nXtiIndex);
 773 }
 774
 775 const String& XclImpLinkManager::GetSupbookTabName( sal_uInt16 nXti,  sal_uInt16 nXtiTab ) const
 776 {
 777     return mxImpl->GetSupbookTabName(nXti, nXtiTab);
 778 }
 779
 780 bool XclImpLinkManager::GetLinkData( String& rApplic, String& rTopic, sal_uInt16 nXtiIndex ) const
 781 {
 782     return mxImpl->GetLinkData( rApplic, rTopic, nXtiIndex );
 783 }
 784
 785 const String& XclImpLinkManager::GetMacroName( sal_uInt16 nExtSheet, sal_uInt16 nExtName ) const
 786 {
 787     return mxImpl->GetMacroName( nExtSheet, nExtName );
 788 }
 789
 790 // ============================================================================
 791