sc/source/ui/docshell/externalrefmgr.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: externalrefmgr.cxx,v $
  10  * $Revision: 1.1.2.33 $
  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
  34
  35
  36 // INCLUDE ---------------------------------------------------------------
  37
  38 #include "externalrefmgr.hxx"
  39 #include "document.hxx"
  40 #include "token.hxx"
  41 #include "tokenarray.hxx"
  42 #include "address.hxx"
  43 #include "tablink.hxx"
  44 #include "docsh.hxx"
  45 #include "scextopt.hxx"
  46 #include "rangenam.hxx"
  47 #include "cell.hxx"
  48 #include "viewdata.hxx"
  49 #include "tabvwsh.hxx"
  50 #include "sc.hrc"
  51
  52 #include "sfx2/app.hxx"
  53 #include "sfx2/docfilt.hxx"
  54 #include "sfx2/docfile.hxx"
  55 #include "sfx2/fcontnr.hxx"
  56 #include "sfx2/sfxsids.hrc"
  57 #include "sfx2/objsh.hxx"
  58 #include "svtools/broadcast.hxx"
  59 #include "svtools/smplhint.hxx"
  60 #include "svtools/itemset.hxx"
  61 #include "svtools/stritem.hxx"
  62 #include "svtools/urihelper.hxx"
  63 #include "svtools/zformat.hxx"
  64 #include "svx/linkmgr.hxx"
  65 #include "tools/urlobj.hxx"
  66 #include "unotools/ucbhelper.hxx"
  67
  68 #include <memory>
  69 #include <algorithm>
  70
  71 using ::std::auto_ptr;
  72 using ::com::sun::star::uno::Any;
  73 using ::rtl::OUString;
  74 using ::std::vector;
  75 using ::std::find;
  76 using ::std::find_if;
  77 using ::std::distance;
  78 using ::std::pair;
  79 using ::std::list;
  80 using ::std::unary_function;
  81 using namespace formula;
  82
  83 #define SRCDOC_LIFE_SPAN     6000       // 1 minute (in 100th of a sec)
  84 #define SRCDOC_SCAN_INTERVAL 1000*5     // every 5 seconds (in msec)
  85
  86 namespace {
  87
  88 class TabNameSearchPredicate : public unary_function<bool, ScExternalRefCache::TableName>
  89 {
  90 public:
  91     explicit TabNameSearchPredicate(const String& rSearchName) :
  92         maSearchName(ScGlobal::pCharClass->upper(rSearchName))
  93     {
  94     }
  95
  96     bool operator()(const ScExternalRefCache::TableName& rTabNameSet) const
  97     {
  98         // Ok, I'm doing case insensitive search here.
  99         return rTabNameSet.maUpperName.Equals(maSearchName);
 100     }
 101
 102 private:
 103     String maSearchName;
 104 };
 105
 106 class FindSrcFileByName : public unary_function<ScExternalRefManager::SrcFileData, bool>
 107 {
 108 public:
 109     FindSrcFileByName(const String& rMatchName) :
 110         mrMatchName(rMatchName)
 111     {
 112     }
 113
 114     bool operator()(const ScExternalRefManager::SrcFileData& rSrcData) const
 115     {
 116         return rSrcData.maFileName.Equals(mrMatchName);
 117     }
 118
 119 private:
 120     const String& mrMatchName;
 121 };
 122
 123 class NotifyLinkListener : public unary_function<ScExternalRefManager::LinkListener*,  void>
 124 {
 125 public:
 126     NotifyLinkListener(sal_uInt16 nFileId, ScExternalRefManager::LinkUpdateType eType) :
 127         mnFileId(nFileId), meType(eType) {}
 128
 129     NotifyLinkListener(const NotifyLinkListener& r) :
 130         mnFileId(r.mnFileId), meType(r.meType) {}
 131
 132     void operator() (ScExternalRefManager::LinkListener* p) const
 133     {
 134         p->notify(mnFileId, meType);
 135     }
 136 private:
 137     sal_uInt16 mnFileId;
 138     ScExternalRefManager::LinkUpdateType meType;
 139 };
 140
 141 }
 142
 143 // ============================================================================
 144
 145 ScExternalRefCache::Table::Table()
 146     : meReferenced( REFERENCED_MARKED )
 147       // Prevent accidental data loss due to lack of knowledge.
 148 {
 149 }
 150
 151 ScExternalRefCache::Table::~Table()
 152 {
 153 }
 154
 155 void ScExternalRefCache::Table::setReferencedFlag( ScExternalRefCache::Table::ReferencedFlag eFlag )
 156 {
 157     meReferenced = eFlag;
 158 }
 159
 160 void ScExternalRefCache::Table::setReferenced( bool bReferenced )
 161 {
 162     if (meReferenced != REFERENCED_PERMANENT)
 163         meReferenced = (bReferenced ? REFERENCED_MARKED : UNREFERENCED);
 164 }
 165
 166 ScExternalRefCache::Table::ReferencedFlag ScExternalRefCache::Table::getReferencedFlag() const
 167 {
 168     return meReferenced;
 169 }
 170
 171 bool ScExternalRefCache::Table::isReferenced() const
 172 {
 173     return meReferenced != UNREFERENCED;
 174 }
 175
 176 void ScExternalRefCache::Table::setCell(SCCOL nCol, SCROW nRow, TokenRef pToken, sal_uInt32 nFmtIndex)
 177 {
 178     using ::std::pair;
 179     RowsDataType::iterator itrRow = maRows.find(nRow);
 180     if (itrRow == maRows.end())
 181     {
 182         // This row does not exist yet.
 183         pair<RowsDataType::iterator, bool> res = maRows.insert(
 184             RowsDataType::value_type(nRow, RowDataType()));
 185
 186         if (!res.second)
 187             return;
 188
 189         itrRow = res.first;
 190     }
 191
 192     // Insert this token into the specified column location.  I don't need to
 193     // check for existing data.  Just overwrite it.
 194     RowDataType& rRow = itrRow->second;
 195     ScExternalRefCache::Cell aCell;
 196     aCell.mxToken = pToken;
 197     aCell.mnFmtIndex = nFmtIndex;
 198     rRow.insert(RowDataType::value_type(nCol, aCell));
 199 }
 200
 201 ScExternalRefCache::TokenRef ScExternalRefCache::Table::getCell(SCCOL nCol, SCROW nRow, sal_uInt32* pnFmtIndex) const
 202 {
 203     RowsDataType::const_iterator itrTable = maRows.find(nRow);
 204     if (itrTable == maRows.end())
 205     {
 206         // this table doesn't have the specified row.
 207         return TokenRef();
 208     }
 209
 210     const RowDataType& rRowData = itrTable->second;
 211     RowDataType::const_iterator itrRow = rRowData.find(nCol);
 212     if (itrRow == rRowData.end())
 213     {
 214         // this row doesn't have the specified column.
 215         return TokenRef();
 216     }
 217
 218     const Cell& rCell = itrRow->second;
 219     if (pnFmtIndex)
 220         *pnFmtIndex = rCell.mnFmtIndex;
 221
 222     return rCell.mxToken;
 223 }
 224
 225 bool ScExternalRefCache::Table::hasRow( SCROW nRow ) const
 226 {
 227     RowsDataType::const_iterator itrRow = maRows.find(nRow);
 228     return itrRow != maRows.end();
 229 }
 230
 231 void ScExternalRefCache::Table::getAllRows(vector<SCROW>& rRows) const
 232 {
 233     vector<SCROW> aRows;
 234     aRows.reserve(maRows.size());
 235     RowsDataType::const_iterator itr = maRows.begin(), itrEnd = maRows.end();
 236     for (; itr != itrEnd; ++itr)
 237         aRows.push_back(itr->first);
 238
 239     // hash map is not ordered, so we need to explicitly sort it.
 240     ::std::sort(aRows.begin(), aRows.end());
 241     rRows.swap(aRows);
 242 }
 243
 244 void ScExternalRefCache::Table::getAllCols(SCROW nRow, vector<SCCOL>& rCols) const
 245 {
 246     RowsDataType::const_iterator itrRow = maRows.find(nRow);
 247     if (itrRow == maRows.end())
 248         // this table doesn't have the specified row.
 249         return;
 250
 251     const RowDataType& rRowData = itrRow->second;
 252     vector<SCCOL> aCols;
 253     aCols.reserve(rRowData.size());
 254     RowDataType::const_iterator itrCol = rRowData.begin(), itrColEnd = rRowData.end();
 255     for (; itrCol != itrColEnd; ++itrCol)
 256         aCols.push_back(itrCol->first);
 257
 258     // hash map is not ordered, so we need to explicitly sort it.
 259     ::std::sort(aCols.begin(), aCols.end());
 260     rCols.swap(aCols);
 261 }
 262
 263 void ScExternalRefCache::Table::getAllNumberFormats(vector<sal_uInt32>& rNumFmts) const
 264 {
 265     RowsDataType::const_iterator itrRow = maRows.begin(), itrRowEnd = maRows.end();
 266     for (; itrRow != itrRowEnd; ++itrRow)
 267     {
 268         const RowDataType& rRowData = itrRow->second;
 269         RowDataType::const_iterator itrCol = rRowData.begin(), itrColEnd = rRowData.end();
 270         for (; itrCol != itrColEnd; ++itrCol)
 271         {
 272             const Cell& rCell = itrCol->second;
 273             rNumFmts.push_back(rCell.mnFmtIndex);
 274         }
 275     }
 276 }
 277
 278 // ----------------------------------------------------------------------------
 279
 280 ScExternalRefCache::TableName::TableName(const String& rUpper, const String& rReal) :
 281     maUpperName(rUpper), maRealName(rReal)
 282 {
 283 }
 284
 285 // ----------------------------------------------------------------------------
 286
 287 ScExternalRefCache::CellFormat::CellFormat() :
 288     mbIsSet(false), mnType(NUMBERFORMAT_ALL), mnIndex(0)
 289 {
 290 }
 291
 292 // ----------------------------------------------------------------------------
 293
 294 ScExternalRefCache::ScExternalRefCache()
 295 {
 296 }
 297 ScExternalRefCache::~ScExternalRefCache()
 298 {
 299 }
 300
 301 const String* ScExternalRefCache::getRealTableName(sal_uInt16 nFileId, const String& rTabName) const
 302 {
 303     DocDataType::const_iterator itrDoc = maDocs.find(nFileId);
 304     if (itrDoc == maDocs.end())
 305     {
 306         // specified document is not cached.
 307         return NULL;
 308     }
 309
 310     const DocItem& rDoc = itrDoc->second;
 311     TableNameIndexMap::const_iterator itrTabId = rDoc.maTableNameIndex.find(
 312         ScGlobal::pCharClass->upper(rTabName));
 313     if (itrTabId == rDoc.maTableNameIndex.end())
 314     {
 315         // the specified table is not in cache.
 316         return NULL;
 317     }
 318
 319     return &rDoc.maTableNames[itrTabId->second].maRealName;
 320 }
 321
 322 const String* ScExternalRefCache::getRealRangeName(sal_uInt16 nFileId, const String& rRangeName) const
 323 {
 324     DocDataType::const_iterator itrDoc = maDocs.find(nFileId);
 325     if (itrDoc == maDocs.end())
 326     {
 327         // specified document is not cached.
 328         return NULL;
 329     }
 330
 331     const DocItem& rDoc = itrDoc->second;
 332     NamePairMap::const_iterator itr = rDoc.maRealRangeNameMap.find(
 333         ScGlobal::pCharClass->upper(rRangeName));
 334     if (itr == rDoc.maRealRangeNameMap.end())
 335         // range name not found.
 336         return NULL;
 337
 338     return &itr->second;
 339 }
 340
 341 ScExternalRefCache::TokenRef ScExternalRefCache::getCellData(
 342     sal_uInt16 nFileId, const String& rTabName, SCCOL nCol, SCROW nRow,
 343     bool bEmptyCellOnNull, bool bWriteEmpty, sal_uInt32* pnFmtIndex)
 344 {
 345     DocDataType::const_iterator itrDoc = maDocs.find(nFileId);
 346     if (itrDoc == maDocs.end())
 347     {
 348         // specified document is not cached.
 349         return TokenRef();
 350     }
 351
 352     const DocItem& rDoc = itrDoc->second;
 353     TableNameIndexMap::const_iterator itrTabId = rDoc.maTableNameIndex.find(
 354         ScGlobal::pCharClass->upper(rTabName));
 355     if (itrTabId == rDoc.maTableNameIndex.end())
 356     {
 357         // the specified table is not in cache.
 358         return TokenRef();
 359     }
 360
 361     const TableTypeRef& pTableData = rDoc.maTables[itrTabId->second];
 362     if (!pTableData.get())
 363     {
 364         // the table data is not instantiated yet.
 365         return TokenRef();
 366     }
 367
 368     TokenRef pToken = pTableData->getCell(nCol, nRow, pnFmtIndex);
 369     if (!pToken && bEmptyCellOnNull)
 370     {
 371         pToken.reset(new ScEmptyCellToken(false, false));
 372         if (bWriteEmpty)
 373             pTableData->setCell(nCol, nRow, pToken);
 374     }
 375     return pToken;
 376 }
 377
 378 ScExternalRefCache::TokenArrayRef ScExternalRefCache::getCellRangeData(
 379     sal_uInt16 nFileId, const String& rTabName, const ScRange& rRange, bool bEmptyCellOnNull, bool bWriteEmpty)
 380 {
 381     DocDataType::iterator itrDoc = maDocs.find(nFileId);
 382     if (itrDoc == maDocs.end())
 383         // specified document is not cached.
 384         return TokenArrayRef();
 385
 386     DocItem& rDoc = itrDoc->second;
 387     RangeArrayMap::const_iterator itrRange = rDoc.maRangeArrays.find(rRange);
 388     if (itrRange != rDoc.maRangeArrays.end())
 389     {
 390         return itrRange->second;
 391     }
 392
 393     TableNameIndexMap::iterator itrTabId = rDoc.maTableNameIndex.find(
 394         ScGlobal::pCharClass->upper(rTabName));
 395     if (itrTabId == rDoc.maTableNameIndex.end())
 396         // the specified table is not in cache.
 397         return TokenArrayRef();
 398
 399     const ScAddress& s = rRange.aStart;
 400     const ScAddress& e = rRange.aEnd;
 401
 402     SCTAB nTab1 = s.Tab(), nTab2 = e.Tab();
 403     SCCOL nCol1 = s.Col(), nCol2 = e.Col();
 404     SCROW nRow1 = s.Row(), nRow2 = e.Row();
 405
 406     // Make sure I have all the tables cached.
 407     size_t nTabFirstId = itrTabId->second;
 408     size_t nTabLastId  = nTabFirstId + nTab2 - nTab1;
 409     if (nTabLastId >= rDoc.maTables.size())
 410         // not all tables are cached.
 411         return TokenArrayRef();
 412
 413     TokenArrayRef pArray(new ScTokenArray);
 414     bool bFirstTab = true;
 415     for (size_t nTab = nTabFirstId; nTab <= nTabLastId; ++nTab)
 416     {
 417         TableTypeRef pTab = rDoc.maTables[nTab];
 418         if (!pTab.get())
 419             return TokenArrayRef();
 420
 421         ScMatrixRef xMat = new ScMatrix(
 422             static_cast<SCSIZE>(nCol2-nCol1+1), static_cast<SCSIZE>(nRow2-nRow1+1));
 423
 424         for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
 425         {
 426             for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
 427             {
 428                 TokenRef pToken = pTab->getCell(nCol, nRow);
 429                 if (!pToken)
 430                 {
 431                     if (bEmptyCellOnNull)
 432                     {
 433                         pToken.reset(new ScEmptyCellToken(false, false));
 434                         if (bWriteEmpty)
 435                             pTab->setCell(nCol, nRow, pToken);
 436                     }
 437                     else
 438                         return TokenArrayRef();
 439                 }
 440
 441                 SCSIZE nC = nCol - nCol1, nR = nRow - nRow1;
 442                 switch (pToken->GetType())
 443                 {
 444                     case svDouble:
 445                         xMat->PutDouble(pToken->GetDouble(), nC, nR);
 446                     break;
 447                     case svString:
 448                         xMat->PutString(pToken->GetString(), nC, nR);
 449                     break;
 450                     default:
 451                         xMat->PutEmpty(nC, nR);
 452                 }
 453             }
 454         }
 455
 456         if (!bFirstTab)
 457             pArray->AddOpCode(ocSep);
 458
 459         ScMatrix* pMat2 = xMat;
 460         ScMatrixToken aToken(pMat2);
 461         pArray->AddToken(aToken);
 462
 463         bFirstTab = false;
 464     }
 465     rDoc.maRangeArrays.insert(RangeArrayMap::value_type(rRange, pArray));
 466     return pArray;
 467 }
 468
 469 ScExternalRefCache::TokenArrayRef ScExternalRefCache::getRangeNameTokens(sal_uInt16 nFileId, const String& rName)
 470 {
 471     DocItem* pDoc = getDocItem(nFileId);
 472     if (!pDoc)
 473         return TokenArrayRef();
 474
 475     RangeNameMap& rMap = pDoc->maRangeNames;
 476     RangeNameMap::const_iterator itr = rMap.find(
 477         ScGlobal::pCharClass->upper(rName));
 478     if (itr == rMap.end())
 479         return TokenArrayRef();
 480
 481     return itr->second;
 482 }
 483
 484 void ScExternalRefCache::setRangeNameTokens(sal_uInt16 nFileId, const String& rName, TokenArrayRef pArray)
 485 {
 486     DocItem* pDoc = getDocItem(nFileId);
 487     if (!pDoc)
 488         return;
 489
 490     String aUpperName = ScGlobal::pCharClass->upper(rName);
 491     RangeNameMap& rMap = pDoc->maRangeNames;
 492     rMap.insert(RangeNameMap::value_type(aUpperName, pArray));
 493     pDoc->maRealRangeNameMap.insert(NamePairMap::value_type(aUpperName, rName));
 494 }
 495
 496 void ScExternalRefCache::setCellData(sal_uInt16 nFileId, const String& rTabName, SCROW nRow, SCCOL nCol,
 497                                      TokenRef pToken, sal_uInt32 nFmtIndex)
 498 {
 499     if (!isDocInitialized(nFileId))
 500         return;
 501
 502     using ::std::pair;
 503     DocItem* pDocItem = getDocItem(nFileId);
 504     if (!pDocItem)
 505         return;
 506
 507     DocItem& rDoc = *pDocItem;
 508
 509     // See if the table by this name already exists.
 510     TableNameIndexMap::iterator itrTabName = rDoc.maTableNameIndex.find(
 511         ScGlobal::pCharClass->upper(rTabName));
 512     if (itrTabName == rDoc.maTableNameIndex.end())
 513         // Table not found.  Maybe the table name or the file id is wrong ???
 514         return;
 515
 516     TableTypeRef& pTableData = rDoc.maTables[itrTabName->second];
 517     if (!pTableData.get())
 518         pTableData.reset(new Table);
 519
 520     pTableData->setCell(nCol, nRow, pToken, nFmtIndex);
 521 }
 522
 523 void ScExternalRefCache::setCellRangeData(sal_uInt16 nFileId, const ScRange& rRange, const vector<SingleRangeData>& rData,
 524                                           TokenArrayRef pArray)
 525 {
 526     using ::std::pair;
 527     if (rData.empty() || !isDocInitialized(nFileId))
 528         // nothing to cache
 529         return;
 530
 531     // First, get the document item for the given file ID.
 532     DocItem* pDocItem = getDocItem(nFileId);
 533     if (!pDocItem)
 534         return;
 535
 536     DocItem& rDoc = *pDocItem;
 537
 538     // Now, find the table position of the first table to cache.
 539     const String& rFirstTabName = rData.front().maTableName;
 540     TableNameIndexMap::iterator itrTabName = rDoc.maTableNameIndex.find(
 541         ScGlobal::pCharClass->upper(rFirstTabName));
 542     if (itrTabName == rDoc.maTableNameIndex.end())
 543     {
 544         // table index not found.
 545         return;
 546     }
 547
 548     size_t nTab1 = itrTabName->second;
 549     SCROW nRow1 = rRange.aStart.Row(), nRow2 = rRange.aEnd.Row();
 550     SCCOL nCol1 = rRange.aStart.Col(), nCol2 = rRange.aEnd.Col();
 551     vector<SingleRangeData>::const_iterator itrDataBeg = rData.begin(), itrDataEnd = rData.end();
 552     for (vector<SingleRangeData>::const_iterator itrData = itrDataBeg; itrData != itrDataEnd; ++itrData)
 553     {
 554         size_t i = nTab1 + ::std::distance(itrDataBeg, itrData);
 555         TableTypeRef& pTabData = rDoc.maTables[i];
 556         if (!pTabData.get())
 557             pTabData.reset(new Table);
 558
 559         for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
 560         {
 561             for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
 562             {
 563                 SCSIZE nC = nCol - nCol1, nR = nRow - nRow1;
 564                 TokenRef pToken;
 565                 const ScMatrixRef& pMat = itrData->mpRangeData;
 566                 if (pMat->IsValue(nC, nR))
 567                     pToken.reset(new formula::FormulaDoubleToken(pMat->GetDouble(nC, nR)));
 568                 else if (pMat->IsString(nC, nR))
 569                     pToken.reset(new formula::FormulaStringToken(pMat->GetString(nC, nR)));
 570                 else
 571                     pToken.reset(new ScEmptyCellToken(false, false));
 572
 573                 pTabData->setCell(nCol, nRow, pToken);
 574             }
 575         }
 576     }
 577
 578     rDoc.maRangeArrays.insert(RangeArrayMap::value_type(rRange, pArray));
 579 }
 580
 581 bool ScExternalRefCache::isDocInitialized(sal_uInt16 nFileId)
 582 {
 583     DocItem* pDoc = getDocItem(nFileId);
 584     if (!pDoc)
 585         return false;
 586
 587     return pDoc->mbInitFromSource;
 588 }
 589
 590 static bool lcl_getTableDataIndex(const ScExternalRefCache::TableNameIndexMap& rMap, const String& rName, size_t& rIndex)
 591 {
 592     ScExternalRefCache::TableNameIndexMap::const_iterator itr = rMap.find(rName);
 593     if (itr == rMap.end())
 594         return false;
 595
 596     rIndex = itr->second;
 597     return true;
 598 }
 599
 600 void ScExternalRefCache::initializeDoc(sal_uInt16 nFileId, const vector<String>& rTabNames)
 601 {
 602     DocItem* pDoc = getDocItem(nFileId);
 603     if (!pDoc)
 604         return;
 605
 606     size_t n = rTabNames.size();
 607
 608     // table name list - the list must include all table names in the source
 609     // document and only to be populated when loading the source document, not
 610     // when loading cached data from, say, Excel XCT/CRN records.
 611     vector<TableName> aNewTabNames;
 612     aNewTabNames.reserve(n);
 613     for (vector<String>::const_iterator itr = rTabNames.begin(), itrEnd = rTabNames.end();
 614           itr != itrEnd; ++itr)
 615     {
 616         TableName aNameItem(ScGlobal::pCharClass->upper(*itr), *itr);
 617         aNewTabNames.push_back(aNameItem);
 618     }
 619     pDoc->maTableNames.swap(aNewTabNames);
 620
 621     // data tables - preserve any existing data that may have been set during
 622     // file import.
 623     vector<TableTypeRef> aNewTables(n);
 624     for (size_t i = 0; i < n; ++i)
 625     {
 626         size_t nIndex;
 627         if (lcl_getTableDataIndex(pDoc->maTableNameIndex, pDoc->maTableNames[i].maUpperName, nIndex))
 628         {
 629             aNewTables[i] = pDoc->maTables[nIndex];
 630         }
 631     }
 632     pDoc->maTables.swap(aNewTables);
 633
 634     // name index map
 635     TableNameIndexMap aNewNameIndex;
 636     for (size_t i = 0; i < n; ++i)
 637         aNewNameIndex.insert(TableNameIndexMap::value_type(pDoc->maTableNames[i].maUpperName, i));
 638     pDoc->maTableNameIndex.swap(aNewNameIndex);
 639
 640     pDoc->mbInitFromSource = true;
 641 }
 642
 643 String ScExternalRefCache::getTableName(sal_uInt16 nFileId, size_t nCacheId) const
 644 {
 645     if( DocItem* pDoc = getDocItem( nFileId ) )
 646         if( nCacheId < pDoc->maTableNames.size() )
 647             return pDoc->maTableNames[ nCacheId ].maRealName;
 648     return EMPTY_STRING;
 649 }
 650
 651 void ScExternalRefCache::getAllTableNames(sal_uInt16 nFileId, vector<String>& rTabNames) const
 652 {
 653     rTabNames.clear();
 654     DocItem* pDoc = getDocItem(nFileId);
 655     if (!pDoc)
 656         return;
 657
 658     size_t n = pDoc->maTableNames.size();
 659     rTabNames.reserve(n);
 660     for (vector<TableName>::const_iterator itr = pDoc->maTableNames.begin(), itrEnd = pDoc->maTableNames.end();
 661           itr != itrEnd; ++itr)
 662         rTabNames.push_back(itr->maRealName);
 663 }
 664
 665 SCsTAB ScExternalRefCache::getTabSpan( sal_uInt16 nFileId, const String& rStartTabName, const String& rEndTabName ) const
 666 {
 667     DocItem* pDoc = getDocItem(nFileId);
 668     if (!pDoc)
 669         return -1;
 670
 671     vector<TableName>::const_iterator itrBeg = pDoc->maTableNames.begin();
 672     vector<TableName>::const_iterator itrEnd = pDoc->maTableNames.end();
 673
 674     vector<TableName>::const_iterator itrStartTab = ::std::find_if( itrBeg, itrEnd,
 675             TabNameSearchPredicate( rStartTabName));
 676     if (itrStartTab == itrEnd)
 677         return -1;
 678
 679     vector<TableName>::const_iterator itrEndTab = ::std::find_if( itrBeg, itrEnd,
 680             TabNameSearchPredicate( rEndTabName));
 681     if (itrEndTab == itrEnd)
 682         return 0;
 683
 684     size_t nStartDist = ::std::distance( itrBeg, itrStartTab);
 685     size_t nEndDist = ::std::distance( itrBeg, itrEndTab);
 686     return nStartDist <= nEndDist ? static_cast<SCsTAB>(nEndDist - nStartDist + 1) : -static_cast<SCsTAB>(nStartDist - nEndDist + 1);
 687 }
 688
 689 void ScExternalRefCache::getAllNumberFormats(vector<sal_uInt32>& rNumFmts) const
 690 {
 691     using ::std::sort;
 692     using ::std::unique;
 693
 694     vector<sal_uInt32> aNumFmts;
 695     for (DocDataType::const_iterator itrDoc = maDocs.begin(), itrDocEnd = maDocs.end();
 696           itrDoc != itrDocEnd; ++itrDoc)
 697     {
 698         const vector<TableTypeRef>& rTables = itrDoc->second.maTables;
 699         for (vector<TableTypeRef>::const_iterator itrTab = rTables.begin(), itrTabEnd = rTables.end();
 700               itrTab != itrTabEnd; ++itrTab)
 701         {
 702             TableTypeRef pTab = *itrTab;
 703             if (!pTab)
 704                 continue;
 705
 706             pTab->getAllNumberFormats(aNumFmts);
 707         }
 708     }
 709
 710     // remove duplicates.
 711     sort(aNumFmts.begin(), aNumFmts.end());
 712     aNumFmts.erase(unique(aNumFmts.begin(), aNumFmts.end()), aNumFmts.end());
 713     rNumFmts.swap(aNumFmts);
 714 }
 715
 716 bool ScExternalRefCache::hasCacheTable(sal_uInt16 nFileId, const String& rTabName) const
 717 {
 718     DocItem* pDoc = getDocItem(nFileId);
 719     if (!pDoc)
 720         return false;
 721
 722     String aUpperName = ScGlobal::pCharClass->upper(rTabName);
 723     vector<TableName>::const_iterator itrBeg = pDoc->maTableNames.begin(), itrEnd = pDoc->maTableNames.end();
 724     vector<TableName>::const_iterator itr = ::std::find_if(
 725         itrBeg, itrEnd, TabNameSearchPredicate(aUpperName));
 726
 727     return itr != itrEnd;
 728 }
 729
 730 size_t ScExternalRefCache::getCacheTableCount(sal_uInt16 nFileId) const
 731 {
 732     DocItem* pDoc = getDocItem(nFileId);
 733     return pDoc ? pDoc->maTables.size() : 0;
 734 }
 735
 736 bool ScExternalRefCache::setCacheDocReferenced( sal_uInt16 nFileId )
 737 {
 738     DocItem* pDocItem = getDocItem(nFileId);
 739     if (!pDocItem)
 740         return areAllCacheTablesReferenced();
 741
 742     for (::std::vector<TableTypeRef>::iterator itrTab = pDocItem->maTables.begin();
 743             itrTab != pDocItem->maTables.end(); ++itrTab)
 744     {
 745         if ((*itrTab).get())
 746             (*itrTab)->setReferenced( true);
 747     }
 748     addCacheDocToReferenced( nFileId);
 749     return areAllCacheTablesReferenced();
 750 }
 751
 752 bool ScExternalRefCache::setCacheTableReferenced( sal_uInt16 nFileId, const String& rTabName, size_t nSheets, bool bPermanent )
 753 {
 754     DocItem* pDoc = getDocItem(nFileId);
 755     if (pDoc)
 756     {
 757         size_t nIndex = 0;
 758         String aTabNameUpper = ScGlobal::pCharClass->upper( rTabName);
 759         if (lcl_getTableDataIndex( pDoc->maTableNameIndex, aTabNameUpper, nIndex))
 760         {
 761             size_t nStop = ::std::min( nIndex + nSheets, pDoc->maTables.size());
 762             for (size_t i = nIndex; i < nStop; ++i)
 763             {
 764                 TableTypeRef pTab = pDoc->maTables[i];
 765                 if (pTab.get())
 766                 {
 767                     Table::ReferencedFlag eNewFlag = (bPermanent ?
 768                             Table::REFERENCED_PERMANENT :
 769                             Table::REFERENCED_MARKED);
 770                     Table::ReferencedFlag eOldFlag = pTab->getReferencedFlag();
 771                     if (eOldFlag != Table::REFERENCED_PERMANENT && eNewFlag != eOldFlag)
 772                     {
 773                         pTab->setReferencedFlag( eNewFlag);
 774                         addCacheTableToReferenced( nFileId, i);
 775                     }
 776                 }
 777             }
 778         }
 779     }
 780     return areAllCacheTablesReferenced();
 781 }
 782
 783 void ScExternalRefCache::setCacheTableReferencedPermanently( sal_uInt16 nFileId, const String& rTabName, size_t nSheets )
 784 {
 785     DocItem* pDoc = getDocItem(nFileId);
 786     if (pDoc)
 787     {
 788         size_t nIndex = 0;
 789         String aTabNameUpper = ScGlobal::pCharClass->upper( rTabName);
 790         if (lcl_getTableDataIndex( pDoc->maTableNameIndex, aTabNameUpper, nIndex))
 791         {
 792             size_t nStop = ::std::min( nIndex + nSheets, pDoc->maTables.size());
 793             for (size_t i = nIndex; i < nStop; ++i)
 794             {
 795                 TableTypeRef pTab = pDoc->maTables[i];
 796                 if (pTab.get())
 797                     pTab->setReferencedFlag( Table::REFERENCED_PERMANENT);
 798             }
 799         }
 800     }
 801 }
 802
 803 void ScExternalRefCache::setAllCacheTableReferencedStati( bool bReferenced )
 804 {
 805     if (bReferenced)
 806     {
 807         maReferenced.reset(0);
 808         for (DocDataType::iterator itrDoc = maDocs.begin(); itrDoc != maDocs.end(); ++itrDoc)
 809         {
 810             ScExternalRefCache::DocItem& rDocItem = (*itrDoc).second;
 811             for (::std::vector<TableTypeRef>::iterator itrTab = rDocItem.maTables.begin();
 812                     itrTab != rDocItem.maTables.end(); ++itrTab)
 813             {
 814                 if ((*itrTab).get())
 815                     (*itrTab)->setReferenced( true);
 816             }
 817         }
 818     }
 819     else
 820     {
 821         size_t nDocs = 0;
 822         for (DocDataType::const_iterator itrDoc = maDocs.begin(); itrDoc != maDocs.end(); ++itrDoc)
 823         {
 824             if (nDocs <= (*itrDoc).first)
 825                 nDocs  = (*itrDoc).first + 1;
 826         }
 827         maReferenced.reset( nDocs);
 828
 829         for (DocDataType::iterator itrDoc = maDocs.begin(); itrDoc != maDocs.end(); ++itrDoc)
 830         {
 831             ScExternalRefCache::DocItem& rDocItem = (*itrDoc).second;
 832             sal_uInt16 nFileId = (*itrDoc).first;
 833             size_t nTables = rDocItem.maTables.size();
 834             ReferencedStatus::DocReferenced & rDocReferenced = maReferenced.maDocs[nFileId];
 835             // All referenced => non-existing tables evaluate as completed.
 836             rDocReferenced.maTables.resize( nTables, true);
 837             for (size_t i=0; i < nTables; ++i)
 838             {
 839                 TableTypeRef & xTab = rDocItem.maTables[i];
 840                 if (xTab.get())
 841                 {
 842                     if (xTab->getReferencedFlag() == Table::REFERENCED_PERMANENT)
 843                         addCacheTableToReferenced( nFileId, i);
 844                     else
 845                     {
 846                         xTab->setReferencedFlag( Table::UNREFERENCED);
 847                         rDocReferenced.maTables[i] = false;
 848                         rDocReferenced.mbAllTablesReferenced = false;
 849                         // An addCacheTableToReferenced() actually may have
 850                         // resulted in mbAllReferenced been set. Clear it.
 851                         maReferenced.mbAllReferenced = false;
 852                     }
 853                 }
 854             }
 855         }
 856     }
 857 }
 858
 859 void ScExternalRefCache::addCacheTableToReferenced( sal_uInt16 nFileId, size_t nIndex )
 860 {
 861     if (nFileId >= maReferenced.maDocs.size())
 862         return;
 863
 864     ::std::vector<bool> & rTables = maReferenced.maDocs[nFileId].maTables;
 865     size_t nTables = rTables.size();
 866     if (nIndex >= nTables)
 867         return;
 868
 869     if (!rTables[nIndex])
 870     {
 871         rTables[nIndex] = true;
 872         size_t i = 0;
 873         while (i < nTables && rTables[i])
 874             ++i;
 875         if (i == nTables)
 876         {
 877             maReferenced.maDocs[nFileId].mbAllTablesReferenced = true;
 878             maReferenced.checkAllDocs();
 879         }
 880     }
 881 }
 882
 883 void ScExternalRefCache::addCacheDocToReferenced( sal_uInt16 nFileId )
 884 {
 885     if (nFileId >= maReferenced.maDocs.size())
 886         return;
 887
 888     if (!maReferenced.maDocs[nFileId].mbAllTablesReferenced)
 889     {
 890         ::std::vector<bool> & rTables = maReferenced.maDocs[nFileId].maTables;
 891         size_t nSize = rTables.size();
 892         for (size_t i=0; i < nSize; ++i)
 893             rTables[i] = true;
 894         maReferenced.maDocs[nFileId].mbAllTablesReferenced = true;
 895         maReferenced.checkAllDocs();
 896     }
 897 }
 898
 899 bool ScExternalRefCache::areAllCacheTablesReferenced() const
 900 {
 901     return maReferenced.mbAllReferenced;
 902 }
 903
 904 ScExternalRefCache::ReferencedStatus::ReferencedStatus() :
 905     mbAllReferenced(false)
 906 {
 907     reset(0);
 908 }
 909
 910 ScExternalRefCache::ReferencedStatus::ReferencedStatus( size_t nDocs ) :
 911     mbAllReferenced(false)
 912 {
 913     reset( nDocs);
 914 }
 915
 916 void ScExternalRefCache::ReferencedStatus::reset( size_t nDocs )
 917 {
 918     if (nDocs)
 919     {
 920         mbAllReferenced = false;
 921         DocReferencedVec aRefs( nDocs);
 922         maDocs.swap( aRefs);
 923     }
 924     else
 925     {
 926         mbAllReferenced = true;
 927         DocReferencedVec aRefs;
 928         maDocs.swap( aRefs);
 929     }
 930 }
 931
 932 void ScExternalRefCache::ReferencedStatus::checkAllDocs()
 933 {
 934     for (DocReferencedVec::const_iterator itr = maDocs.begin(); itr != maDocs.end(); ++itr)
 935     {
 936         if (!(*itr).mbAllTablesReferenced)
 937             return;
 938     }
 939     mbAllReferenced = true;
 940 }
 941
 942 ScExternalRefCache::TableTypeRef ScExternalRefCache::getCacheTable(sal_uInt16 nFileId, size_t nTabIndex) const
 943 {
 944     DocItem* pDoc = getDocItem(nFileId);
 945     if (!pDoc || nTabIndex >= pDoc->maTables.size())
 946         return TableTypeRef();
 947
 948     return pDoc->maTables[nTabIndex];
 949 }
 950
 951 ScExternalRefCache::TableTypeRef ScExternalRefCache::getCacheTable(sal_uInt16 nFileId, const String& rTabName, bool bCreateNew, size_t* pnIndex)
 952 {
 953     DocItem* pDoc = getDocItem(nFileId);
 954     if (!pDoc)
 955         return TableTypeRef();
 956
 957     DocItem& rDoc = *pDoc;
 958
 959     size_t nIndex;
 960     String aTabNameUpper = ScGlobal::pCharClass->upper(rTabName);
 961     if (lcl_getTableDataIndex(rDoc.maTableNameIndex, aTabNameUpper, nIndex))
 962     {
 963         // specified table found.
 964         if( pnIndex ) *pnIndex = nIndex;
 965         return rDoc.maTables[nIndex];
 966     }
 967
 968     if (!bCreateNew)
 969         return TableTypeRef();
 970
 971     // Specified table doesn't exist yet.  Create one.
 972     nIndex = rDoc.maTables.size();
 973     if( pnIndex ) *pnIndex = nIndex;
 974     TableTypeRef pTab(new Table);
 975     rDoc.maTables.push_back(pTab);
 976     rDoc.maTableNames.push_back(TableName(aTabNameUpper, rTabName));
 977     rDoc.maTableNameIndex.insert(
 978         TableNameIndexMap::value_type(aTabNameUpper, nIndex));
 979     return pTab;
 980 }
 981
 982 void ScExternalRefCache::clearCache(sal_uInt16 nFileId)
 983 {
 984     maDocs.erase(nFileId);
 985 }
 986
 987 ScExternalRefCache::DocItem* ScExternalRefCache::getDocItem(sal_uInt16 nFileId) const
 988 {
 989     using ::std::pair;
 990     DocDataType::iterator itrDoc = maDocs.find(nFileId);
 991     if (itrDoc == maDocs.end())
 992     {
 993         // specified document is not cached.
 994         pair<DocDataType::iterator, bool> res = maDocs.insert(
 995                 DocDataType::value_type(nFileId, DocItem()));
 996
 997         if (!res.second)
 998             // insertion failed.
 999             return NULL;
1000
1001         itrDoc = res.first;
1002     }
1003
1004     return &itrDoc->second;
1005 }
1006
1007 // ============================================================================
1008
1009 ScExternalRefLink::ScExternalRefLink(ScDocument* pDoc, sal_uInt16 nFileId, const String& rFilter) :
1010     ::sfx2::SvBaseLink(::sfx2::LINKUPDATE_ONCALL, FORMAT_FILE),
1011     mnFileId(nFileId),
1012     maFilterName(rFilter),
1013     mpDoc(pDoc),
1014     mbDoRefresh(true)
1015 {
1016 }
1017
1018 ScExternalRefLink::~ScExternalRefLink()
1019 {
1020 }
1021
1022 void ScExternalRefLink::Closed()
1023 {
1024     ScExternalRefManager* pMgr = mpDoc->GetExternalRefManager();
1025     pMgr->breakLink(mnFileId);
1026 }
1027
1028 void ScExternalRefLink::DataChanged(const String& /*rMimeType*/, const Any& /*rValue*/)
1029 {
1030     if (!mbDoRefresh)
1031         return;
1032
1033     String aFile, aFilter;
1034     mpDoc->GetLinkManager()->GetDisplayNames(this, NULL, &aFile, NULL, &aFilter);
1035     ScExternalRefManager* pMgr = mpDoc->GetExternalRefManager();
1036     const String* pCurFile = pMgr->getExternalFileName(mnFileId);
1037     if (!pCurFile)
1038         return;
1039
1040     if (pCurFile->Equals(aFile))
1041     {
1042         // Refresh the current source document.
1043         pMgr->refreshNames(mnFileId);
1044     }
1045     else
1046     {
1047         // The source document has changed.
1048         ScDocShell* pDocShell = ScDocShell::GetViewData()->GetDocShell();
1049         ScDocShellModificator aMod(*pDocShell);
1050         pMgr->switchSrcFile(mnFileId, aFile);
1051         maFilterName = aFilter;
1052         aMod.SetDocumentModified();
1053     }
1054 }
1055
1056 void ScExternalRefLink::Edit(Window* pParent, const Link& /*rEndEditHdl*/)
1057 {
1058     SvBaseLink::Edit(pParent, LINK(this, ScExternalRefLink, ExternalRefEndEditHdl));
1059 }
1060
1061 void ScExternalRefLink::SetDoReferesh(bool b)
1062 {
1063     mbDoRefresh = b;
1064 }
1065
1066 IMPL_LINK( ScExternalRefLink, ExternalRefEndEditHdl, ::sfx2::SvBaseLink*, EMPTYARG )
1067 {
1068     return 0;
1069 }
1070
1071 // ============================================================================
1072
1073 static FormulaToken* lcl_convertToToken(ScBaseCell* pCell)
1074 {
1075     if (!pCell || pCell->HasEmptyData())
1076     {
1077         bool bInherited = (pCell && pCell->GetCellType() == CELLTYPE_FORMULA);
1078         return new ScEmptyCellToken( bInherited, false);
1079     }
1080
1081     switch (pCell->GetCellType())
1082     {
1083         case CELLTYPE_EDIT:
1084         {
1085             String aStr;
1086             static_cast<ScEditCell*>(pCell)->GetString(aStr);
1087             return new formula::FormulaStringToken(aStr);
1088         }
1089         //break;
1090         case CELLTYPE_STRING:
1091         {
1092             String aStr;
1093             static_cast<ScStringCell*>(pCell)->GetString(aStr);
1094             return new formula::FormulaStringToken(aStr);
1095         }
1096         //break;
1097         case CELLTYPE_VALUE:
1098         {
1099             double fVal = static_cast<ScValueCell*>(pCell)->GetValue();
1100             return new formula::FormulaDoubleToken(fVal);
1101         }
1102         //break;
1103         case CELLTYPE_FORMULA:
1104         {
1105             ScFormulaCell* pFCell = static_cast<ScFormulaCell*>(pCell);
1106             USHORT nError = pFCell->GetErrCode();
1107             if (nError)
1108                 return new FormulaErrorToken( nError);
1109             else if (pFCell->IsValue())
1110             {
1111                 double fVal = pFCell->GetValue();
1112                 return new formula::FormulaDoubleToken(fVal);
1113             }
1114             else
1115             {
1116                 String aStr;
1117                 pFCell->GetString(aStr);
1118                 return new formula::FormulaStringToken(aStr);
1119             }
1120         }
1121         //break;
1122         default:
1123             DBG_ERROR("attempted to convert an unknown cell type.");
1124     }
1125
1126     return NULL;
1127 }
1128
1129 static ScTokenArray* lcl_convertToTokenArray(ScDocument* pSrcDoc, const ScRange& rRange,
1130                                              vector<ScExternalRefCache::SingleRangeData>& rCacheData)
1131 {
1132     const ScAddress& s = rRange.aStart;
1133     const ScAddress& e = rRange.aEnd;
1134
1135     SCTAB nTab1 = s.Tab(), nTab2 = e.Tab();
1136     SCCOL nCol1 = s.Col(), nCol2 = e.Col();
1137     SCROW nRow1 = s.Row(), nRow2 = e.Row();
1138
1139     if (nTab2 != nTab1)
1140         // For now, we don't support multi-sheet ranges intentionally because
1141         // we don't have a way to express them in a single token.  In the
1142         // future we can introduce a new stack variable type svMatrixList with
1143         // a new token type that can store a 3D matrix value and convert a 3D
1144         // range to it.
1145         return NULL;
1146
1147     auto_ptr<ScTokenArray> pArray(new ScTokenArray);
1148     bool bFirstTab = true;
1149     vector<ScExternalRefCache::SingleRangeData>::iterator
1150         itrCache = rCacheData.begin(), itrCacheEnd = rCacheData.end();
1151     for (SCTAB nTab = nTab1; nTab <= nTab2 && itrCache != itrCacheEnd; ++nTab, ++itrCache)
1152     {
1153         ScMatrixRef xMat = new ScMatrix(
1154             static_cast<SCSIZE>(nCol2-nCol1+1),
1155             static_cast<SCSIZE>(nRow2-nRow1+1));
1156
1157         for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
1158         {
1159             for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
1160             {
1161                 SCSIZE nC = nCol - nCol1, nR = nRow - nRow1;
1162                 ScBaseCell* pCell;
1163                 pSrcDoc->GetCell(nCol, nRow, nTab, pCell);
1164                 if (!pCell || pCell->HasEmptyData())
1165                     xMat->PutEmpty(nC, nR);
1166                 else
1167                 {
1168                     switch (pCell->GetCellType())
1169                     {
1170                         case CELLTYPE_EDIT:
1171                         {
1172                             String aStr;
1173                             static_cast<ScEditCell*>(pCell)->GetString(aStr);
1174                             xMat->PutString(aStr, nC, nR);
1175                         }
1176                         break;
1177                         case CELLTYPE_STRING:
1178                         {
1179                             String aStr;
1180                             static_cast<ScStringCell*>(pCell)->GetString(aStr);
1181                             xMat->PutString(aStr, nC, nR);
1182                         }
1183                         break;
1184                         case CELLTYPE_VALUE:
1185                         {
1186                             double fVal = static_cast<ScValueCell*>(pCell)->GetValue();
1187                             xMat->PutDouble(fVal, nC, nR);
1188                         }
1189                         break;
1190                         case CELLTYPE_FORMULA:
1191                         {
1192                             ScFormulaCell* pFCell = static_cast<ScFormulaCell*>(pCell);
1193                             USHORT nError = pFCell->GetErrCode();
1194                             if (nError)
1195                                 xMat->PutDouble( CreateDoubleError( nError), nC, nR);
1196                             else if (pFCell->IsValue())
1197                             {
1198                                 double fVal = pFCell->GetValue();
1199                                 xMat->PutDouble(fVal, nC, nR);
1200                             }
1201                             else
1202                             {
1203                                 String aStr;
1204                                 pFCell->GetString(aStr);
1205                                 xMat->PutString(aStr, nC, nR);
1206                             }
1207                         }
1208                         break;
1209                         default:
1210                             DBG_ERROR("attempted to convert an unknown cell type.");
1211                     }
1212                 }
1213             }
1214         }
1215         if (!bFirstTab)
1216             pArray->AddOpCode(ocSep);
1217
1218         ScMatrix* pMat2 = xMat;
1219         ScMatrixToken aToken(pMat2);
1220         pArray->AddToken(aToken);
1221
1222         itrCache->mpRangeData = xMat;
1223
1224         bFirstTab = false;
1225     }
1226     return pArray.release();
1227 }
1228
1229 ScExternalRefManager::ScExternalRefManager(ScDocument* pDoc) :
1230     mpDoc(pDoc),
1231     bInReferenceMarking(false)
1232 {
1233     maSrcDocTimer.SetTimeoutHdl( LINK(this, ScExternalRefManager, TimeOutHdl) );
1234     maSrcDocTimer.SetTimeout(SRCDOC_SCAN_INTERVAL);
1235 }
1236
1237 ScExternalRefManager::~ScExternalRefManager()
1238 {
1239     clear();
1240 }
1241
1242 String ScExternalRefManager::getCacheTableName(sal_uInt16 nFileId, size_t nTabIndex) const
1243 {
1244     return maRefCache.getTableName(nFileId, nTabIndex);
1245 }
1246
1247 ScExternalRefCache::TableTypeRef ScExternalRefManager::getCacheTable(sal_uInt16 nFileId, size_t nTabIndex) const
1248 {
1249     return maRefCache.getCacheTable(nFileId, nTabIndex);
1250 }
1251
1252 ScExternalRefCache::TableTypeRef ScExternalRefManager::getCacheTable(sal_uInt16 nFileId, const String& rTabName, bool bCreateNew, size_t* pnIndex)
1253 {
1254     return maRefCache.getCacheTable(nFileId, rTabName, bCreateNew, pnIndex);
1255 }
1256
1257 // ============================================================================
1258
1259 ScExternalRefManager::RefCells::TabItem::TabItem(SCTAB nIndex) :
1260     mnIndex(nIndex)
1261 {
1262 }
1263
1264 ScExternalRefManager::RefCells::TabItem::TabItem(const TabItem& r) :
1265     mnIndex(r.mnIndex),
1266     maCols(r.maCols)
1267 {
1268 }
1269
1270 ScExternalRefManager::RefCells::RefCells()
1271 {
1272 }
1273
1274 ScExternalRefManager::RefCells::~RefCells()
1275 {
1276 }
1277
1278 list<ScExternalRefManager::RefCells::TabItemRef>::iterator ScExternalRefManager::RefCells::getTabPos(SCTAB nTab)
1279 {
1280     list<TabItemRef>::iterator itr = maTables.begin(), itrEnd = maTables.end();
1281     for (; itr != itrEnd; ++itr)
1282         if ((*itr)->mnIndex >= nTab)
1283             return itr;
1284     // Not found.  return the end position.
1285     return itrEnd;
1286 }
1287
1288 void ScExternalRefManager::RefCells::insertCell(const ScAddress& rAddr)
1289 {
1290     SCTAB nTab = rAddr.Tab();
1291     SCCOL nCol = rAddr.Col();
1292     SCROW nRow = rAddr.Row();
1293
1294     // Search by table index.
1295     list<TabItemRef>::iterator itrTab = getTabPos(nTab);
1296     TabItemRef xTabRef;
1297     if (itrTab == maTables.end())
1298     {
1299         // All previous tables come before the specificed table.
1300         xTabRef.reset(new TabItem(nTab));
1301         maTables.push_back(xTabRef);
1302     }
1303     else if ((*itrTab)->mnIndex > nTab)
1304     {
1305         // Insert at the current iterator position.
1306         xTabRef.reset(new TabItem(nTab));
1307         maTables.insert(itrTab, xTabRef);
1308     }
1309     else if ((*itrTab)->mnIndex == nTab)
1310     {
1311         // The table found.
1312         xTabRef = *itrTab;
1313     }
1314     ColSet& rCols = xTabRef->maCols;
1315
1316     // Then by column index.
1317     ColSet::iterator itrCol = rCols.find(nCol);
1318     if (itrCol == rCols.end())
1319     {
1320         RowSet aRows;
1321         pair<ColSet::iterator, bool> r = rCols.insert(ColSet::value_type(nCol, aRows));
1322         if (!r.second)
1323             // column insertion failed.
1324             return;
1325         itrCol = r.first;
1326     }
1327     RowSet& rRows = itrCol->second;
1328
1329     // Finally, insert the row index.
1330     rRows.insert(nRow);
1331 }
1332
1333 void ScExternalRefManager::RefCells::removeCell(const ScAddress& rAddr)
1334 {
1335     SCTAB nTab = rAddr.Tab();
1336     SCCOL nCol = rAddr.Col();
1337     SCROW nRow = rAddr.Row();
1338
1339     // Search by table index.
1340     list<TabItemRef>::iterator itrTab = getTabPos(nTab);
1341     if (itrTab == maTables.end() || (*itrTab)->mnIndex != nTab)
1342         // No such table.
1343         return;
1344
1345     ColSet& rCols = (*itrTab)->maCols;
1346
1347     // Then by column index.
1348     ColSet::iterator itrCol = rCols.find(nCol);
1349     if (itrCol == rCols.end())
1350         // No such column
1351         return;
1352
1353     RowSet& rRows = itrCol->second;
1354     rRows.erase(nRow);
1355 }
1356
1357 void ScExternalRefManager::RefCells::moveTable(SCTAB nOldTab, SCTAB nNewTab, bool bCopy)
1358 {
1359     if (nOldTab == nNewTab)
1360         // Nothing to do here.
1361         return;
1362
1363     list<TabItemRef>::iterator itrOld = getTabPos(nOldTab);
1364     if (itrOld == maTables.end() || (*itrOld)->mnIndex != nOldTab)
1365         // No table to move or copy.
1366         return;
1367
1368     list<TabItemRef>::iterator itrNew = getTabPos(nNewTab);
1369     if (bCopy)
1370     {
1371         // Simply make a duplicate of the original table, insert it at the
1372         // new tab position, and increment the table index for all tables
1373         // that come after that inserted table.
1374
1375         TabItemRef xNewTab(new TabItem(*(*itrOld)));
1376         xNewTab->mnIndex = nNewTab;
1377         maTables.insert(itrNew, xNewTab);
1378         list<TabItemRef>::iterator itr = itrNew, itrEnd = maTables.end();
1379         if (itr != itrEnd)  // #i99807# check that itr is not at end already
1380             for (++itr; itr != itrEnd; ++itr)
1381                 (*itr)->mnIndex += 1;
1382     }
1383     else
1384     {
1385         if (itrOld == itrNew)
1386         {
1387             // No need to move the table.  Just update the table index.
1388             (*itrOld)->mnIndex = nNewTab;
1389             return;
1390         }
1391
1392         if (nOldTab < nNewTab)
1393         {
1394             // Iterate from the old tab position to the new tab position (not
1395             // inclusive of the old tab itself), and decrement their tab
1396             // index by one.
1397             list<TabItemRef>::iterator itr = itrOld;
1398             for (++itr; itr != itrNew; ++itr)
1399                 (*itr)->mnIndex -= 1;
1400
1401             // Insert a duplicate of the original table.  This does not
1402             // invalidate the iterators.
1403             (*itrOld)->mnIndex = nNewTab - 1;
1404             if (itrNew == maTables.end())
1405                 maTables.push_back(*itrOld);
1406             else
1407                 maTables.insert(itrNew, *itrOld);
1408
1409             // Remove the original table.
1410             maTables.erase(itrOld);
1411         }
1412         else
1413         {
1414             // nNewTab < nOldTab
1415
1416             // Iterate from the new tab position to the one before the old tab
1417             // position, and increment their tab index by one.
1418             list<TabItemRef>::iterator itr = itrNew;
1419             for (++itr; itr != itrOld; ++itr)
1420                 (*itr)->mnIndex += 1;
1421
1422             (*itrOld)->mnIndex = nNewTab;
1423             maTables.insert(itrNew, *itrOld);
1424
1425             // Remove the original table.
1426             maTables.erase(itrOld);
1427         }
1428     }
1429 }
1430
1431 void ScExternalRefManager::RefCells::insertTable(SCTAB nPos)
1432 {
1433     TabItemRef xNewTab(new TabItem(nPos));
1434     list<TabItemRef>::iterator itr = getTabPos(nPos);
1435     if (itr == maTables.end())
1436         maTables.push_back(xNewTab);
1437     else
1438         maTables.insert(itr, xNewTab);
1439 }
1440
1441 void ScExternalRefManager::RefCells::removeTable(SCTAB nPos)
1442 {
1443     list<TabItemRef>::iterator itr = getTabPos(nPos);
1444     if (itr == maTables.end())
1445         // nothing to remove.
1446         return;
1447
1448     maTables.erase(itr);
1449 }
1450
1451 void ScExternalRefManager::RefCells::refreshAllCells(ScExternalRefManager& rRefMgr)
1452 {
1453     // Get ALL the cell positions for re-compilation.
1454     for (list<TabItemRef>::iterator itrTab = maTables.begin(), itrTabEnd = maTables.end();
1455           itrTab != itrTabEnd; ++itrTab)
1456     {
1457         SCTAB nTab = (*itrTab)->mnIndex;
1458         ColSet& rCols = (*itrTab)->maCols;
1459         for (ColSet::iterator itrCol = rCols.begin(), itrColEnd = rCols.end();
1460               itrCol != itrColEnd; ++itrCol)
1461         {
1462             SCCOL nCol = itrCol->first;
1463             RowSet& rRows = itrCol->second;
1464             RowSet aNewRows;
1465             for (RowSet::iterator itrRow = rRows.begin(), itrRowEnd = rRows.end();
1466                   itrRow != itrRowEnd; ++itrRow)
1467             {
1468                 SCROW nRow = *itrRow;
1469                 ScAddress aCell(nCol, nRow, nTab);
1470                 if (rRefMgr.compileTokensByCell(aCell))
1471                     // This cell still contains an external refernce.
1472                     aNewRows.insert(nRow);
1473             }
1474             // Update the rows so that cells with no external references are
1475             // no longer tracked.
1476             rRows.swap(aNewRows);
1477         }
1478     }
1479 }
1480
1481 // ----------------------------------------------------------------------------
1482
1483 ScExternalRefManager::LinkListener::LinkListener()
1484 {
1485 }
1486
1487 ScExternalRefManager::LinkListener::~LinkListener()
1488 {
1489 }
1490
1491 // ----------------------------------------------------------------------------
1492
1493 void ScExternalRefManager::getAllCachedTableNames(sal_uInt16 nFileId, vector<String>& rTabNames) const
1494 {
1495     maRefCache.getAllTableNames(nFileId, rTabNames);
1496 }
1497
1498 SCsTAB ScExternalRefManager::getCachedTabSpan( sal_uInt16 nFileId, const String& rStartTabName, const String& rEndTabName ) const
1499 {
1500     return maRefCache.getTabSpan( nFileId, rStartTabName, rEndTabName);
1501 }
1502
1503 void ScExternalRefManager::getAllCachedNumberFormats(vector<sal_uInt32>& rNumFmts) const
1504 {
1505     maRefCache.getAllNumberFormats(rNumFmts);
1506 }
1507
1508 bool ScExternalRefManager::hasCacheTable(sal_uInt16 nFileId, const String& rTabName) const
1509 {
1510     return maRefCache.hasCacheTable(nFileId, rTabName);
1511 }
1512
1513 size_t ScExternalRefManager::getCacheTableCount(sal_uInt16 nFileId) const
1514 {
1515     return maRefCache.getCacheTableCount(nFileId);
1516 }
1517
1518 sal_uInt16 ScExternalRefManager::getExternalFileCount() const
1519 {
1520     return static_cast< sal_uInt16 >( maSrcFiles.size() );
1521 }
1522
1523 bool ScExternalRefManager::markUsedByLinkListeners()
1524 {
1525     bool bAllMarked = false;
1526     for (LinkListenerMap::const_iterator itr = maLinkListeners.begin();
1527             itr != maLinkListeners.end() && !bAllMarked; ++itr)
1528     {
1529         if (!(*itr).second.empty())
1530             bAllMarked = maRefCache.setCacheDocReferenced( (*itr).first);
1531         /* TODO: LinkListeners should remember the table they're listening to.
1532          * As is, listening to one table will mark all tables of the document
1533          * being referenced. */
1534     }
1535     return bAllMarked;
1536 }
1537
1538 bool ScExternalRefManager::setCacheDocReferenced( sal_uInt16 nFileId )
1539 {
1540     return maRefCache.setCacheDocReferenced( nFileId);
1541 }
1542
1543 bool ScExternalRefManager::setCacheTableReferenced( sal_uInt16 nFileId, const String& rTabName, size_t nSheets )
1544 {
1545     return maRefCache.setCacheTableReferenced( nFileId, rTabName, nSheets, false);
1546 }
1547
1548 void ScExternalRefManager::setCacheTableReferencedPermanently( sal_uInt16 nFileId, const String& rTabName, size_t nSheets )
1549 {
1550     if (isInReferenceMarking())
1551         // Do all maintenance work.
1552         maRefCache.setCacheTableReferenced( nFileId, rTabName, nSheets, true);
1553     else
1554         // Set only the permanent flag.
1555         maRefCache.setCacheTableReferencedPermanently( nFileId, rTabName, nSheets);
1556 }
1557
1558 void ScExternalRefManager::setAllCacheTableReferencedStati( bool bReferenced )
1559 {
1560     bInReferenceMarking = !bReferenced;
1561     maRefCache.setAllCacheTableReferencedStati( bReferenced );
1562 }
1563
1564 void ScExternalRefManager::storeRangeNameTokens(sal_uInt16 nFileId, const String& rName, const ScTokenArray& rArray)
1565 {
1566     ScExternalRefCache::TokenArrayRef pArray(rArray.Clone());
1567     maRefCache.setRangeNameTokens(nFileId, rName, pArray);
1568 }
1569
1570 ScExternalRefCache::TokenRef ScExternalRefManager::getSingleRefToken(
1571     sal_uInt16 nFileId, const String& rTabName, const ScAddress& rCell,
1572     const ScAddress* pCurPos, SCTAB* pTab, ScExternalRefCache::CellFormat* pFmt)
1573 {
1574     if (pCurPos)
1575         insertRefCell(nFileId, *pCurPos);
1576
1577     maybeLinkExternalFile(nFileId);
1578
1579     if (pTab)
1580         *pTab = -1;
1581
1582     if (pFmt)
1583         pFmt->mbIsSet = false;
1584
1585     bool bLoading = mpDoc->IsImportingXML();
1586
1587     // Check if the given table name and the cell position is cached.
1588     // #i101304# When loading a file, the saved cache (hidden sheet)
1589     // is assumed to contain all data for the loaded formulas.
1590     // No cache entries are created from empty cells in the saved sheet,
1591     // so they have to be created here (bWriteEmpty parameter).
1592     // Otherwise, later interpretation of the loaded formulas would
1593     // load the source document even if the user didn't want to update.
1594     sal_uInt32 nFmtIndex = 0;
1595     ScExternalRefCache::TokenRef pToken = maRefCache.getCellData(
1596         nFileId, rTabName, rCell.Col(), rCell.Row(), bLoading, bLoading, &nFmtIndex);
1597     if (pToken)
1598     {
1599         if (pFmt)
1600         {
1601             short nFmtType = mpDoc->GetFormatTable()->GetType(nFmtIndex);
1602             if (nFmtType != NUMBERFORMAT_UNDEFINED)
1603             {
1604                 pFmt->mbIsSet = true;
1605                 pFmt->mnIndex = nFmtIndex;
1606                 pFmt->mnType = nFmtType;
1607             }
1608         }
1609         return pToken;
1610     }
1611
1612     // reference not cached.  read from the source document.
1613     ScDocument* pSrcDoc = getSrcDocument(nFileId);
1614     if (!pSrcDoc)
1615     {
1616         // Source document is not reachable.  Try to get data from the cache
1617         // once again, but this time treat a non-cached cell as an empty cell
1618         // as long as the table itself is cached.
1619         pToken = maRefCache.getCellData(
1620             nFileId, rTabName, rCell.Col(), rCell.Row(), true, false, &nFmtIndex);
1621         return pToken;
1622     }
1623
1624     ScBaseCell* pCell = NULL;
1625     SCTAB nTab;
1626     if (!pSrcDoc->GetTable(rTabName, nTab))
1627     {
1628         // specified table name doesn't exist in the source document.
1629         return ScExternalRefCache::TokenRef();
1630     }
1631
1632     if (pTab)
1633         *pTab = nTab;
1634
1635     pSrcDoc->GetCell(rCell.Col(), rCell.Row(), nTab, pCell);
1636     ScExternalRefCache::TokenRef pTok(lcl_convertToToken(pCell));
1637
1638     pSrcDoc->GetNumberFormat(rCell.Col(), rCell.Row(), nTab, nFmtIndex);
1639     nFmtIndex = getMappedNumberFormat(nFileId, nFmtIndex, pSrcDoc);
1640     if (pFmt)
1641     {
1642         short nFmtType = mpDoc->GetFormatTable()->GetType(nFmtIndex);
1643         if (nFmtType != NUMBERFORMAT_UNDEFINED)
1644         {
1645             pFmt->mbIsSet = true;
1646             pFmt->mnIndex = nFmtIndex;
1647             pFmt->mnType = nFmtType;
1648         }
1649     }
1650
1651     if (!pTok.get())
1652     {
1653         // Generate an error for unresolvable cells.
1654         pTok.reset( new FormulaErrorToken( errNoValue));
1655     }
1656
1657     // Now, insert the token into cache table.
1658     maRefCache.setCellData(nFileId, rTabName, rCell.Row(), rCell.Col(), pTok, nFmtIndex);
1659     return pTok;
1660 }
1661
1662 ScExternalRefCache::TokenArrayRef ScExternalRefManager::getDoubleRefTokens(sal_uInt16 nFileId, const String& rTabName, const ScRange& rRange, const ScAddress* pCurPos)
1663 {
1664     if (pCurPos)
1665         insertRefCell(nFileId, *pCurPos);
1666
1667     maybeLinkExternalFile(nFileId);
1668
1669     bool bLoading = mpDoc->IsImportingXML();
1670
1671     // Check if the given table name and the cell position is cached.
1672     // #i101304# When loading, put empty cells into cache, see getSingleRefToken.
1673     ScExternalRefCache::TokenArrayRef p = maRefCache.getCellRangeData(nFileId, rTabName, rRange, bLoading, bLoading);
1674     if (p.get())
1675         return p;
1676
1677     ScDocument* pSrcDoc = getSrcDocument(nFileId);
1678     if (!pSrcDoc)
1679     {
1680         // Source document is not reachable.  Try to get data from the cache
1681         // once again, but this time treat non-cached cells as empty cells as
1682         // long as the table itself is cached.
1683         return maRefCache.getCellRangeData(nFileId, rTabName, rRange, true, false);
1684     }
1685
1686     SCTAB nTab1;
1687     if (!pSrcDoc->GetTable(rTabName, nTab1))
1688         // specified table name doesn't exist in the source document.
1689         return ScExternalRefCache::TokenArrayRef();
1690
1691     ScRange aRange(rRange);
1692     SCTAB nTabSpan = aRange.aEnd.Tab() - aRange.aStart.Tab();
1693
1694     vector<ScExternalRefCache::SingleRangeData> aCacheData;
1695     aCacheData.reserve(nTabSpan+1);
1696     aCacheData.push_back(ScExternalRefCache::SingleRangeData());
1697     aCacheData.back().maTableName = ScGlobal::pCharClass->upper(rTabName);
1698
1699     for (SCTAB i = 1; i < nTabSpan + 1; ++i)
1700     {
1701         String aTabName;
1702         if (!pSrcDoc->GetName(nTab1 + 1, aTabName))
1703             // source document doesn't have any table by the specified name.
1704             break;
1705
1706         aCacheData.push_back(ScExternalRefCache::SingleRangeData());
1707         aCacheData.back().maTableName = ScGlobal::pCharClass->upper(aTabName);
1708     }
1709
1710     aRange.aStart.SetTab(nTab1);
1711     aRange.aEnd.SetTab(nTab1 + nTabSpan);
1712
1713     ScExternalRefCache::TokenArrayRef pArray;
1714     pArray.reset(lcl_convertToTokenArray(pSrcDoc, aRange, aCacheData));
1715
1716     if (pArray)
1717         // Cache these values.
1718         maRefCache.setCellRangeData(nFileId, rRange, aCacheData, pArray);
1719
1720     return pArray;
1721 }
1722
1723 ScExternalRefCache::TokenArrayRef ScExternalRefManager::getRangeNameTokens(sal_uInt16 nFileId, const String& rName, const ScAddress* pCurPos)
1724 {
1725     if (pCurPos)
1726         insertRefCell(nFileId, *pCurPos);
1727
1728     maybeLinkExternalFile(nFileId);
1729
1730     ScExternalRefCache::TokenArrayRef pArray = maRefCache.getRangeNameTokens(nFileId, rName);
1731     if (pArray.get())
1732         return pArray;
1733
1734     ScDocument* pSrcDoc = getSrcDocument(nFileId);
1735     if (!pSrcDoc)
1736         return ScExternalRefCache::TokenArrayRef();
1737
1738     ScRangeName* pExtNames = pSrcDoc->GetRangeName();
1739     String aUpperName = ScGlobal::pCharClass->upper(rName);
1740     USHORT n;
1741     bool bRes = pExtNames->SearchNameUpper(aUpperName, n);
1742     if (!bRes)
1743         return ScExternalRefCache::TokenArrayRef();
1744
1745     ScRangeData* pRangeData = (*pExtNames)[n];
1746     if (!pRangeData)
1747         return ScExternalRefCache::TokenArrayRef();
1748
1749     // Parse all tokens in this external range data, and replace each absolute
1750     // reference token with an external reference token, and cache them.  Also
1751     // register the source document with the link manager if it's a new
1752     // source.
1753
1754     ScExternalRefCache::TokenArrayRef pNew(new ScTokenArray);
1755
1756     ScTokenArray* pCode = pRangeData->GetCode();
1757     for (FormulaToken* pToken = pCode->First(); pToken; pToken = pCode->Next())
1758     {
1759         bool bTokenAdded = false;
1760         switch (pToken->GetType())
1761         {
1762             case svSingleRef:
1763             {
1764                 const ScSingleRefData& rRef = static_cast<ScToken*>(pToken)->GetSingleRef();
1765                 String aTabName;
1766                 pSrcDoc->GetName(rRef.nTab, aTabName);
1767                 ScExternalSingleRefToken aNewToken(nFileId, aTabName, static_cast<ScToken*>(pToken)->GetSingleRef());
1768                 pNew->AddToken(aNewToken);
1769                 bTokenAdded = true;
1770             }
1771             break;
1772             case svDoubleRef:
1773             {
1774                 const ScSingleRefData& rRef = static_cast<ScToken*>(pToken)->GetSingleRef();
1775                 String aTabName;
1776                 pSrcDoc->GetName(rRef.nTab, aTabName);
1777                 ScExternalDoubleRefToken aNewToken(nFileId, aTabName, static_cast<ScToken*>(pToken)->GetDoubleRef());
1778                 pNew->AddToken(aNewToken);
1779                 bTokenAdded = true;
1780             }
1781             break;
1782             default:
1783                 ;   // nothing
1784         }
1785
1786         if (!bTokenAdded)
1787             pNew->AddToken(*pToken);
1788     }
1789
1790     // Make sure to pass the correctly-cased range name here.
1791     maRefCache.setRangeNameTokens(nFileId, pRangeData->GetName(), pNew);
1792     return pNew;
1793 }
1794
1795 void ScExternalRefManager::refreshAllRefCells(sal_uInt16 nFileId)
1796 {
1797     RefCellMap::iterator itrFile = maRefCells.find(nFileId);
1798     if (itrFile == maRefCells.end())
1799         return;
1800
1801     RefCells& rRefCells = itrFile->second;
1802     rRefCells.refreshAllCells(*this);
1803
1804     ScViewData* pViewData = ScDocShell::GetViewData();
1805     if (!pViewData)
1806         return;
1807
1808     ScTabViewShell* pVShell = pViewData->GetViewShell();
1809     if (!pVShell)
1810         return;
1811
1812     // Repainting the grid also repaints the texts, but is there a better way
1813     // to refresh texts?
1814     pVShell->Invalidate(FID_REPAINT);
1815     pVShell->PaintGrid();
1816 }
1817
1818 void ScExternalRefManager::insertRefCell(sal_uInt16 nFileId, const ScAddress& rCell)
1819 {
1820     RefCellMap::iterator itr = maRefCells.find(nFileId);
1821     if (itr == maRefCells.end())
1822     {
1823         RefCells aRefCells;
1824         pair<RefCellMap::iterator, bool> r = maRefCells.insert(
1825             RefCellMap::value_type(nFileId, aRefCells));
1826         if (!r.second)
1827             // insertion failed.
1828             return;
1829
1830         itr = r.first;
1831     }
1832     itr->second.insertCell(rCell);
1833 }
1834
1835 ScDocument* ScExternalRefManager::getSrcDocument(sal_uInt16 nFileId)
1836 {
1837     if (!mpDoc->IsExecuteLinkEnabled())
1838         return NULL;
1839
1840     DocShellMap::iterator itrEnd = maDocShells.end();
1841     DocShellMap::iterator itr = maDocShells.find(nFileId);
1842
1843     if (itr != itrEnd)
1844     {
1845         SfxObjectShell* p = itr->second.maShell;
1846         itr->second.maLastAccess = Time();
1847         return static_cast<ScDocShell*>(p)->GetDocument();
1848     }
1849
1850     const String* pFile = getExternalFileName(nFileId);
1851     if (!pFile)
1852         // no file name associated with this ID.
1853         return NULL;
1854
1855     String aFilter;
1856     SrcShell aSrcDoc;
1857     aSrcDoc.maShell = loadSrcDocument(nFileId, aFilter);
1858     if (!aSrcDoc.maShell.Is())
1859     {
1860         // source document could not be loaded.
1861         return NULL;
1862     }
1863
1864     if (maDocShells.empty())
1865     {
1866         // If this is the first source document insertion, start up the timer.
1867         maSrcDocTimer.Start();
1868     }
1869
1870     maDocShells.insert(DocShellMap::value_type(nFileId, aSrcDoc));
1871     SfxObjectShell* p = aSrcDoc.maShell;
1872     ScDocument* pSrcDoc = static_cast<ScDocShell*>(p)->GetDocument();
1873
1874     SCTAB nTabCount = pSrcDoc->GetTableCount();
1875     if (!maRefCache.isDocInitialized(nFileId) && nTabCount)
1876     {
1877         // Populate the cache with all table names in the source document.
1878         vector<String> aTabNames;
1879         aTabNames.reserve(nTabCount);
1880         for (SCTAB i = 0; i < nTabCount; ++i)
1881         {
1882             String aName;
1883             pSrcDoc->GetName(i, aName);
1884             aTabNames.push_back(aName);
1885         }
1886         maRefCache.initializeDoc(nFileId, aTabNames);
1887     }
1888     return pSrcDoc;
1889 }
1890
1891 SfxObjectShellRef ScExternalRefManager::loadSrcDocument(sal_uInt16 nFileId, String& rFilter)
1892 {
1893     const SrcFileData* pFileData = getExternalFileData(nFileId);
1894     if (!pFileData)
1895         return NULL;
1896
1897     String aFile = pFileData->maFileName;
1898     if (!isFileLoadable(aFile))
1899     {
1900         // The original file path is not loadable.  Try the relative path.
1901         // Note that the path is relative to the content.xml substream which
1902         // is one-level higher than the file itself.
1903
1904         if (!pFileData->maRelativeName.Len())
1905             return NULL;
1906
1907         INetURLObject aBaseURL(getOwnDocumentName());
1908         aBaseURL.insertName(OUString::createFromAscii("content.xml"));
1909         bool bWasAbs = false;
1910         aFile = aBaseURL.smartRel2Abs(pFileData->maRelativeName, bWasAbs).GetMainURL(INetURLObject::NO_DECODE);
1911         if (!isFileLoadable(aFile))
1912             // Ok, I've tried both paths but no success.  Bail out.
1913             return NULL;
1914     }
1915
1916     String aOptions;
1917     ScDocumentLoader::GetFilterName(aFile, rFilter, aOptions, true, false);
1918     const SfxFilter* pFilter = ScDocShell::Factory().GetFilterContainer()->GetFilter4FilterName(rFilter);
1919
1920     if (!pFileData->maRelativeName.Len())
1921     {
1922         // Generate a relative file path.
1923         INetURLObject aBaseURL(getOwnDocumentName());
1924         aBaseURL.insertName(OUString::createFromAscii("content.xml"));
1925
1926         String aStr = URIHelper::simpleNormalizedMakeRelative(
1927             aBaseURL.GetMainURL(INetURLObject::NO_DECODE), aFile);
1928
1929         setRelativeFileName(nFileId, aStr);
1930     }
1931
1932     // Update the filter data now that we are loading it again.
1933     setFilterData(nFileId, rFilter, aOptions);
1934
1935     SfxItemSet* pSet = new SfxAllItemSet(SFX_APP()->GetPool());
1936     if (aOptions.Len())
1937         pSet->Put(SfxStringItem(SID_FILE_FILTEROPTIONS, aOptions));
1938
1939     auto_ptr<SfxMedium> pMedium(new SfxMedium(aFile, STREAM_STD_READ, false, pFilter, pSet));
1940     if (pMedium->GetError() != ERRCODE_NONE)
1941         return NULL;
1942
1943     pMedium->UseInteractionHandler(false);
1944
1945     ScDocShell* pNewShell = new ScDocShell(SFX_CREATE_MODE_INTERNAL);
1946     SfxObjectShellRef aRef = pNewShell;
1947
1948     // increment the recursive link count of the source document.
1949     ScExtDocOptions* pExtOpt = mpDoc->GetExtDocOptions();
1950     sal_uInt32 nLinkCount = pExtOpt ? pExtOpt->GetDocSettings().mnLinkCnt : 0;
1951     ScDocument* pSrcDoc = pNewShell->GetDocument();
1952     ScExtDocOptions* pExtOptNew = pSrcDoc->GetExtDocOptions();
1953     if (!pExtOptNew)
1954     {
1955         pExtOptNew = new ScExtDocOptions;
1956         pSrcDoc->SetExtDocOptions(pExtOptNew);
1957     }
1958     pExtOptNew->GetDocSettings().mnLinkCnt = nLinkCount + 1;
1959
1960     pNewShell->DoLoad(pMedium.release());
1961     return aRef;
1962 }
1963
1964 bool ScExternalRefManager::isFileLoadable(const String& rFile) const
1965 {
1966     if (isOwnDocument(rFile))
1967         return false;
1968
1969     if (utl::UCBContentHelper::IsFolder(rFile))
1970         return false;
1971
1972     return utl::UCBContentHelper::Exists(rFile);
1973 }
1974
1975 void ScExternalRefManager::maybeLinkExternalFile(sal_uInt16 nFileId)
1976 {
1977     if (maLinkedDocs.count(nFileId))
1978         // file alerady linked, or the link has been broken.
1979         return;
1980
1981     // Source document not linked yet.  Link it now.
1982     const String* pFileName = getExternalFileName(nFileId);
1983     if (!pFileName)
1984         return;
1985
1986     String aFilter, aOptions;
1987     ScDocumentLoader::GetFilterName(*pFileName, aFilter, aOptions, true, false);
1988     SvxLinkManager* pLinkMgr = mpDoc->GetLinkManager();
1989     ScExternalRefLink* pLink = new ScExternalRefLink(mpDoc, nFileId, aFilter);
1990     DBG_ASSERT(pFileName, "ScExternalRefManager::insertExternalFileLink: file name pointer is NULL");
1991     pLinkMgr->InsertFileLink(*pLink, OBJECT_CLIENT_FILE, *pFileName, &aFilter);
1992
1993     pLink->SetDoReferesh(false);
1994     pLink->Update();
1995     pLink->SetDoReferesh(true);
1996
1997     maLinkedDocs.insert(LinkedDocMap::value_type(nFileId, true));
1998 }
1999
2000 bool ScExternalRefManager::compileTokensByCell(const ScAddress& rCell)
2001 {
2002     ScBaseCell* pCell;
2003     mpDoc->GetCell(rCell.Col(), rCell.Row(), rCell.Tab(), pCell);
2004
2005     if (!pCell || pCell->GetCellType() != CELLTYPE_FORMULA)
2006         return false;
2007
2008     ScFormulaCell* pFC = static_cast<ScFormulaCell*>(pCell);
2009
2010     // Check to make sure the cell really contains ocExternalRef.
2011     // External names, external cell and range references all have a
2012     // ocExternalRef token.
2013     const ScTokenArray* pCode = pFC->GetCode();
2014     if (!pCode->HasOpCode( ocExternalRef))
2015         return false;
2016
2017     ScTokenArray* pArray = pFC->GetCode();
2018     if (pArray)
2019         // Clear the error code, or a cell with error won't get re-compiled.
2020         pArray->SetCodeError(0);
2021
2022     pFC->SetCompile(true);
2023     pFC->CompileTokenArray();
2024     pFC->SetDirty();
2025
2026     return true;
2027 }
2028
2029 const String& ScExternalRefManager::getOwnDocumentName() const
2030 {
2031     SfxObjectShell* pShell = mpDoc->GetDocumentShell();
2032     if (!pShell)
2033         // This should not happen!
2034         return EMPTY_STRING;
2035
2036     SfxMedium* pMed = pShell->GetMedium();
2037     if (!pMed)
2038         return EMPTY_STRING;
2039
2040     return pMed->GetName();
2041 }
2042
2043 bool ScExternalRefManager::isOwnDocument(const String& rFile) const
2044 {
2045     return getOwnDocumentName().Equals(rFile);
2046 }
2047
2048 void ScExternalRefManager::convertToAbsName(String& rFile) const
2049 {
2050     SfxObjectShell* pDocShell = mpDoc->GetDocumentShell();
2051     rFile = ScGlobal::GetAbsDocName(rFile, pDocShell);
2052 }
2053
2054 sal_uInt16 ScExternalRefManager::getExternalFileId(const String& rFile)
2055 {
2056     vector<SrcFileData>::const_iterator itrBeg = maSrcFiles.begin(), itrEnd = maSrcFiles.end();
2057     vector<SrcFileData>::const_iterator itr = find_if(itrBeg, itrEnd, FindSrcFileByName(rFile));
2058     if (itr != itrEnd)
2059     {
2060         size_t nId = distance(itrBeg, itr);
2061         return static_cast<sal_uInt16>(nId);
2062     }
2063
2064     SrcFileData aData;
2065     aData.maFileName = rFile;
2066     maSrcFiles.push_back(aData);
2067     return static_cast<sal_uInt16>(maSrcFiles.size() - 1);
2068 }
2069
2070 const String* ScExternalRefManager::getExternalFileName(sal_uInt16 nFileId) const
2071 {
2072     if (nFileId >= maSrcFiles.size())
2073         return NULL;
2074
2075     return &maSrcFiles[nFileId].maFileName;
2076 }
2077
2078 bool ScExternalRefManager::hasExternalFile(sal_uInt16 nFileId) const
2079 {
2080     return nFileId < maSrcFiles.size();
2081 }
2082
2083 bool ScExternalRefManager::hasExternalFile(const String& rFile) const
2084 {
2085     vector<SrcFileData>::const_iterator itrBeg = maSrcFiles.begin(), itrEnd = maSrcFiles.end();
2086     vector<SrcFileData>::const_iterator itr = find_if(itrBeg, itrEnd, FindSrcFileByName(rFile));
2087     return itr != itrEnd;
2088 }
2089
2090 const ScExternalRefManager::SrcFileData* ScExternalRefManager::getExternalFileData(sal_uInt16 nFileId) const
2091 {
2092     if (nFileId >= maSrcFiles.size())
2093         return NULL;
2094
2095     return &maSrcFiles[nFileId];
2096 }
2097
2098 const String* ScExternalRefManager::getRealTableName(sal_uInt16 nFileId, const String& rTabName) const
2099 {
2100     return maRefCache.getRealTableName(nFileId, rTabName);
2101 }
2102
2103 const String* ScExternalRefManager::getRealRangeName(sal_uInt16 nFileId, const String& rRangeName) const
2104 {
2105     return maRefCache.getRealRangeName(nFileId, rRangeName);
2106 }
2107
2108 template<typename MapContainer>
2109 void lcl_removeByFileId(sal_uInt16 nFileId, MapContainer& rMap)
2110 {
2111     typename MapContainer::iterator itr = rMap.find(nFileId);
2112     if (itr != rMap.end())
2113         rMap.erase(itr);
2114 }
2115
2116 void ScExternalRefManager::refreshNames(sal_uInt16 nFileId)
2117 {
2118     maRefCache.clearCache(nFileId);
2119     lcl_removeByFileId(nFileId, maDocShells);
2120
2121     if (maDocShells.empty())
2122         maSrcDocTimer.Stop();
2123
2124     // Update all cells containing names from this source document.
2125     refreshAllRefCells(nFileId);
2126
2127     notifyAllLinkListeners(nFileId, LINK_MODIFIED);
2128 }
2129
2130 void ScExternalRefManager::breakLink(sal_uInt16 nFileId)
2131 {
2132     lcl_removeByFileId(nFileId, maDocShells);
2133
2134     if (maDocShells.empty())
2135         maSrcDocTimer.Stop();
2136
2137     LinkedDocMap::iterator itr = maLinkedDocs.find(nFileId);
2138     if (itr != maLinkedDocs.end())
2139         itr->second = false;
2140
2141     notifyAllLinkListeners(nFileId, LINK_BROKEN);
2142 }
2143
2144 void ScExternalRefManager::switchSrcFile(sal_uInt16 nFileId, const String& rNewFile)
2145 {
2146     maSrcFiles[nFileId].maFileName = rNewFile;
2147     maSrcFiles[nFileId].maRelativeName.Erase();
2148     refreshNames(nFileId);
2149 }
2150
2151 void ScExternalRefManager::setRelativeFileName(sal_uInt16 nFileId, const String& rRelUrl)
2152 {
2153     if (nFileId >= maSrcFiles.size())
2154         return;
2155     maSrcFiles[nFileId].maRelativeName = rRelUrl;
2156 }
2157
2158 void ScExternalRefManager::setFilterData(sal_uInt16 nFileId, const String& rFilterName, const String& rOptions)
2159 {
2160     if (nFileId >= maSrcFiles.size())
2161         return;
2162     maSrcFiles[nFileId].maFilterName = rFilterName;
2163     maSrcFiles[nFileId].maFilterOptions = rOptions;
2164 }
2165
2166 void ScExternalRefManager::clear()
2167 {
2168     DocShellMap::iterator itrEnd = maDocShells.end();
2169     for (DocShellMap::iterator itr = maDocShells.begin(); itr != itrEnd; ++itr)
2170         itr->second.maShell->DoClose();
2171
2172     maDocShells.clear();
2173     maSrcDocTimer.Stop();
2174 }
2175
2176 bool ScExternalRefManager::hasExternalData() const
2177 {
2178     return !maSrcFiles.empty();
2179 }
2180
2181 void ScExternalRefManager::resetSrcFileData()
2182 {
2183     INetURLObject aBaseURL(getOwnDocumentName());
2184     aBaseURL.insertName(OUString::createFromAscii("content.xml"));
2185     String aBaseUrlStr = aBaseURL.GetMainURL(INetURLObject::NO_DECODE);
2186     for (vector<SrcFileData>::iterator itr = maSrcFiles.begin(), itrEnd = maSrcFiles.end();
2187           itr != itrEnd; ++itr)
2188     {
2189         if (!itr->maRelativeName.Len())
2190         {
2191             itr->maRelativeName = URIHelper::simpleNormalizedMakeRelative(
2192                 aBaseUrlStr, itr->maFileName);
2193         }
2194     }
2195 }
2196
2197 void ScExternalRefManager::updateRefCell(const ScAddress& rOldPos, const ScAddress& rNewPos, bool bCopy)
2198 {
2199     for (RefCellMap::iterator itr = maRefCells.begin(), itrEnd = maRefCells.end(); itr != itrEnd; ++itr)
2200     {
2201         if (!bCopy)
2202             itr->second.removeCell(rOldPos);
2203         itr->second.insertCell(rNewPos);
2204     }
2205 }
2206
2207 void ScExternalRefManager::updateRefMoveTable(SCTAB nOldTab, SCTAB nNewTab, bool bCopy)
2208 {
2209     for (RefCellMap::iterator itr = maRefCells.begin(), itrEnd = maRefCells.end(); itr != itrEnd; ++itr)
2210         itr->second.moveTable(nOldTab, nNewTab, bCopy);
2211 }
2212
2213 void ScExternalRefManager::updateRefInsertTable(SCTAB nPos)
2214 {
2215     for (RefCellMap::iterator itr = maRefCells.begin(), itrEnd = maRefCells.end(); itr != itrEnd; ++itr)
2216         itr->second.insertTable(nPos);
2217 }
2218
2219 void ScExternalRefManager::updateRefDeleteTable(SCTAB nPos)
2220 {
2221     for (RefCellMap::iterator itr = maRefCells.begin(), itrEnd = maRefCells.end(); itr != itrEnd; ++itr)
2222         itr->second.removeTable(nPos);
2223 }
2224
2225 void ScExternalRefManager::addLinkListener(sal_uInt16 nFileId, LinkListener* pListener)
2226 {
2227     LinkListenerMap::iterator itr = maLinkListeners.find(nFileId);
2228     if (itr == maLinkListeners.end())
2229     {
2230         pair<LinkListenerMap::iterator, bool> r = maLinkListeners.insert(
2231             LinkListenerMap::value_type(nFileId, LinkListeners()));
2232         if (!r.second)
2233         {
2234             DBG_ERROR("insertion of new link listener list failed");
2235             return;
2236         }
2237
2238         itr = r.first;
2239     }
2240
2241     LinkListeners& rList = itr->second;
2242     rList.insert(pListener);
2243 }
2244
2245 void ScExternalRefManager::removeLinkListener(sal_uInt16 nFileId, LinkListener* pListener)
2246 {
2247     LinkListenerMap::iterator itr = maLinkListeners.find(nFileId);
2248     if (itr == maLinkListeners.end())
2249         // no listeners for a specified file.
2250         return;
2251
2252     LinkListeners& rList = itr->second;
2253     rList.erase(pListener);
2254
2255     if (rList.empty())
2256         // No more listeners for this file.  Remove its entry.
2257         maLinkListeners.erase(itr);
2258 }
2259
2260 void ScExternalRefManager::removeLinkListener(LinkListener* pListener)
2261 {
2262     LinkListenerMap::iterator itr = maLinkListeners.begin(), itrEnd = maLinkListeners.end();
2263     for (; itr != itrEnd; ++itr)
2264         itr->second.erase(pListener);
2265 }
2266
2267 void ScExternalRefManager::notifyAllLinkListeners(sal_uInt16 nFileId, LinkUpdateType eType)
2268 {
2269     LinkListenerMap::iterator itr = maLinkListeners.find(nFileId);
2270     if (itr == maLinkListeners.end())
2271         // no listeners for a specified file.
2272         return;
2273
2274     LinkListeners& rList = itr->second;
2275     for_each(rList.begin(), rList.end(), NotifyLinkListener(nFileId, eType));
2276 }
2277
2278 void ScExternalRefManager::purgeStaleSrcDocument(sal_Int32 nTimeOut)
2279 {
2280     DocShellMap aNewDocShells;
2281     DocShellMap::iterator itr = maDocShells.begin(), itrEnd = maDocShells.end();
2282     for (; itr != itrEnd; ++itr)
2283     {
2284         // in 100th of a second.
2285         sal_Int32 nSinceLastAccess = (Time() - itr->second.maLastAccess).GetTime();
2286         if (nSinceLastAccess < nTimeOut)
2287             aNewDocShells.insert(*itr);
2288     }
2289     maDocShells.swap(aNewDocShells);
2290
2291     if (maDocShells.empty())
2292         maSrcDocTimer.Stop();
2293 }
2294
2295 sal_uInt32 ScExternalRefManager::getMappedNumberFormat(sal_uInt16 nFileId, sal_uInt32 nNumFmt, ScDocument* pSrcDoc)
2296 {
2297     NumFmtMap::iterator itr = maNumFormatMap.find(nFileId);
2298     if (itr == maNumFormatMap.end())
2299     {
2300         // Number formatter map is not initialized for this external document.
2301         pair<NumFmtMap::iterator, bool> r = maNumFormatMap.insert(
2302             NumFmtMap::value_type(nFileId, SvNumberFormatterMergeMap()));
2303
2304         if (!r.second)
2305             // insertion failed.
2306             return nNumFmt;
2307
2308         itr = r.first;
2309         mpDoc->GetFormatTable()->MergeFormatter( *pSrcDoc->GetFormatTable());
2310         SvNumberFormatterMergeMap aMap = mpDoc->GetFormatTable()->ConvertMergeTableToMap();
2311         itr->second.swap(aMap);
2312     }
2313     const SvNumberFormatterMergeMap& rMap = itr->second;
2314     SvNumberFormatterMergeMap::const_iterator itrNumFmt = rMap.find(nNumFmt);
2315     if (itrNumFmt != rMap.end())
2316         // mapped value found.
2317         return itrNumFmt->second;
2318
2319     return nNumFmt;
2320 }
2321
2322 IMPL_LINK(ScExternalRefManager, TimeOutHdl, AutoTimer*, pTimer)
2323 {
2324     if (pTimer == &maSrcDocTimer)
2325         purgeStaleSrcDocument(SRCDOC_LIFE_SPAN);
2326
2327     return 0;
2328 }
2329