sc/inc/externalrefmgr.hxx

   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.hxx,v $
  10  * $Revision: 1.1.2.23 $
  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 #ifndef SC_EXTERNALREFMGR_HXX
  32 #define SC_EXTERNALREFMGR_HXX
  33
  34 #include "global.hxx"
  35 #include "address.hxx"
  36 #include "sfx2/objsh.hxx"
  37 #include "sfx2/lnkbase.hxx"
  38 #include "tools/time.hxx"
  39 #include "vcl/timer.hxx"
  40 #include "svtools/zforlist.hxx"
  41 #include "scmatrix.hxx"
  42
  43 #include <hash_map>
  44 #include <hash_set>
  45 #include <boost/shared_ptr.hpp>
  46 #include <vector>
  47 #include <list>
  48 #include <formula/ExternalReferenceHelper.hxx>
  49
  50 class ScDocument;
  51 namespace formula
  52 {
  53     class FormulaToken;
  54 }
  55 class ScToken;
  56 class ScMatrix;
  57 class ScTokenArray;
  58 class String;
  59 class SfxObjectShellRef;
  60 class Window;
  61
  62 class ScExternalRefCache;
  63
  64 class ScExternalRefLink : public ::sfx2::SvBaseLink
  65 {
  66 public:
  67     ScExternalRefLink(ScDocument* pDoc, sal_uInt16 nFileId, const String& rFilter);
  68     virtual ~ScExternalRefLink();
  69
  70     virtual void Closed();
  71     virtual void DataChanged(const String& rMimeType, const ::com::sun::star::uno::Any & rValue);
  72     virtual void Edit(Window* pParent, const Link& rEndEditHdl);
  73
  74     void SetDoReferesh(bool b);
  75
  76 private:
  77     ScExternalRefLink(); // disabled
  78     ScExternalRefLink(const ScExternalRefLink&); // disabled
  79
  80     DECL_LINK( ExternalRefEndEditHdl, ::sfx2::SvBaseLink* );
  81
  82     sal_uInt16  mnFileId;
  83     String      maFilterName;
  84     ScDocument* mpDoc;
  85     bool        mbDoRefresh;
  86 };
  87
  88 // ============================================================================
  89
  90 /**
  91  * Cache table for external reference data.
  92  */
  93 class ScExternalRefCache
  94 {
  95 public:
  96     typedef ::boost::shared_ptr< formula::FormulaToken>     TokenRef;
  97     typedef ::boost::shared_ptr<ScTokenArray>               TokenArrayRef;
  98
  99     struct TableName
 100     {
 101         String maUpperName;
 102         String maRealName;
 103
 104         explicit TableName(const String& rUppper, const String& rReal);
 105     };
 106
 107     struct CellFormat
 108     {
 109         bool        mbIsSet;
 110         short       mnType;
 111         sal_uInt32  mnIndex;
 112
 113         explicit CellFormat();
 114     };
 115
 116 private:
 117     /** individual cell within cached external ref table. */
 118     struct Cell
 119     {
 120         TokenRef    mxToken;
 121         sal_uInt32  mnFmtIndex;
 122     };
 123     typedef ::std::hash_map<SCCOL, Cell>            RowDataType;
 124     typedef ::std::hash_map<SCROW, RowDataType>     RowsDataType;
 125
 126 public:
 127     // SUNWS needs a forward declared friend, otherwise types and members
 128     // of the outer class are not accessible.
 129     class Table;
 130     friend class ScExternalRefCache::Table;
 131
 132     class Table
 133     {
 134     public:
 135
 136         enum ReferencedFlag
 137         {
 138             UNREFERENCED,
 139             REFERENCED_MARKED,      // marked as referenced during store to file
 140             REFERENCED_PERMANENT    // permanently marked, e.g. from within interpreter
 141         };
 142
 143         Table();
 144         ~Table();
 145
 146         SC_DLLPUBLIC void setCell(SCCOL nCol, SCROW nRow, TokenRef pToken, sal_uInt32 nFmtIndex = 0);
 147         TokenRef getCell(SCCOL nCol, SCROW nRow, sal_uInt32* pnFmtIndex = NULL) const;
 148         bool hasRow( SCROW nRow ) const;
 149         /** Set/clear referenced status flag only if current status is not
 150             REFERENCED_PERMANENT. */
 151         void setReferenced( bool bReferenced );
 152         /// Unconditionally set the reference status flag.
 153         void setReferencedFlag( ReferencedFlag eFlag );
 154         ReferencedFlag getReferencedFlag() const;
 155         bool isReferenced() const;
 156         /// Obtain a sorted vector of rows.
 157         void getAllRows(::std::vector<SCROW>& rRows) const;
 158         /// Obtain a sorted vector of columns.
 159         void getAllCols(SCROW nRow, ::std::vector<SCCOL>& rCols) const;
 160         void getAllNumberFormats(::std::vector<sal_uInt32>& rNumFmts) const;
 161
 162     private:
 163         RowsDataType   maRows;
 164         ReferencedFlag meReferenced;
 165     };
 166
 167     typedef ::boost::shared_ptr<Table>      TableTypeRef;
 168     typedef ::std::hash_map<String, size_t, ScStringHashCode>   TableNameIndexMap;
 169
 170     ScExternalRefCache();
 171     ~ScExternalRefCache();
 172
 173     const String* getRealTableName(sal_uInt16 nFileId, const String& rTabName) const;
 174     const String* getRealRangeName(sal_uInt16 nFileId, const String& rRangeName) const;
 175
 176     /**
 177      * Get a cached cell data at specified cell location.
 178      *
 179      * @param nFileId file ID of an external document
 180      * @param rTabName sheet name
 181      * @param nCol
 182      * @param nRow
 183      *
 184      * @return pointer to the token instance in the cache.
 185      */
 186     ScExternalRefCache::TokenRef getCellData(
 187         sal_uInt16 nFileId, const String& rTabName, SCCOL nCol, SCROW nRow,
 188         bool bEmptyCellOnNull, bool bWriteEmpty, sal_uInt32* pnFmtIndex);
 189
 190     /**
 191      * Get a cached cell range data.
 192      *
 193      * @return a new token array instance.  Note that <i>the caller must
 194      *         manage the life cycle of the returned instance</i>, which is
 195      *         guaranteed if the TokenArrayRef is properly used..
 196      */
 197     ScExternalRefCache::TokenArrayRef getCellRangeData(
 198         sal_uInt16 nFileId, const String& rTabName, const ScRange& rRange, bool bEmptyCellOnNull, bool bWriteEmpty);
 199
 200     ScExternalRefCache::TokenArrayRef getRangeNameTokens(sal_uInt16 nFileId, const String& rName);
 201     void setRangeNameTokens(sal_uInt16 nFileId, const String& rName, TokenArrayRef pArray);
 202
 203     void setCellData(sal_uInt16 nFileId, const String& rTabName, SCROW nRow, SCCOL nCol, TokenRef pToken, sal_uInt32 nFmtIndex);
 204
 205     struct SingleRangeData
 206     {
 207         /** This name must be in upper-case. */
 208         String      maTableName;
 209         ScMatrixRef mpRangeData;
 210     };
 211     void setCellRangeData(sal_uInt16 nFileId, const ScRange& rRange, const ::std::vector<SingleRangeData>& rData,
 212                           TokenArrayRef pArray);
 213
 214     bool isDocInitialized(sal_uInt16 nFileId);
 215     void initializeDoc(sal_uInt16 nFileId, const ::std::vector<String>& rTabNames);
 216     String getTableName(sal_uInt16 nFileId, size_t nCacheId) const;
 217     void getAllTableNames(sal_uInt16 nFileId, ::std::vector<String>& rTabNames) const;
 218     SCsTAB getTabSpan( sal_uInt16 nFileId, const String& rStartTabName, const String& rEndTabName ) const;
 219     void getAllNumberFormats(::std::vector<sal_uInt32>& rNumFmts) const;
 220     bool hasCacheTable(sal_uInt16 nFileId, const String& rTabName) const;
 221     size_t getCacheTableCount(sal_uInt16 nFileId) const;
 222
 223     /**
 224      * Set all tables of a document as referenced, used only during
 225      * store-to-file.
 226      * @returns <TRUE/> if ALL tables of ALL documents are marked.
 227      */
 228     bool setCacheDocReferenced( sal_uInt16 nFileId );
 229
 230     /**
 231      * Set a table as referenced, used only during store-to-file.
 232      * @returns <TRUE/> if ALL tables of ALL documents are marked.
 233      */
 234     bool setCacheTableReferenced( sal_uInt16 nFileId, const String& rTabName, size_t nSheets, bool bPermanent );
 235     void setAllCacheTableReferencedStati( bool bReferenced );
 236     bool areAllCacheTablesReferenced() const;
 237
 238     /**
 239      * Set a table as permanently referenced, to be called if not in
 240      * mark-during-store-to-file cycle.
 241      */
 242     void setCacheTableReferencedPermanently( sal_uInt16 nFileId, const String& rTabName, size_t nSheets );
 243
 244 private:
 245     struct ReferencedStatus
 246     {
 247         struct DocReferenced
 248         {
 249             ::std::vector<bool> maTables;
 250             bool                mbAllTablesReferenced;
 251             // Initially, documents have no tables but all referenced.
 252             DocReferenced() : mbAllTablesReferenced(true) {}
 253         };
 254         typedef ::std::vector<DocReferenced> DocReferencedVec;
 255
 256         DocReferencedVec maDocs;
 257         bool             mbAllReferenced;
 258
 259                     ReferencedStatus();
 260         explicit    ReferencedStatus( size_t nDocs );
 261         void        reset( size_t nDocs );
 262         void        checkAllDocs();
 263
 264     } maReferenced;
 265     void addCacheTableToReferenced( sal_uInt16 nFileId, size_t nIndex );
 266     void addCacheDocToReferenced( sal_uInt16 nFileId );
 267 public:
 268
 269     ScExternalRefCache::TableTypeRef getCacheTable(sal_uInt16 nFileId, size_t nTabIndex) const;
 270     ScExternalRefCache::TableTypeRef getCacheTable(sal_uInt16 nFileId, const String& rTabName, bool bCreateNew, size_t* pnIndex);
 271
 272     void clearCache(sal_uInt16 nFileId);
 273
 274 private:
 275     struct RangeHash
 276     {
 277         size_t operator()(const ScRange& rRange) const
 278         {
 279             const ScAddress& s = rRange.aStart;
 280             const ScAddress& e = rRange.aEnd;
 281             return s.Tab() + s.Col() + s.Row() + e.Tab() + e.Col() + e.Row();
 282         }
 283     };
 284
 285     typedef ::std::hash_map<String, TokenArrayRef, ScStringHashCode>    RangeNameMap;
 286     typedef ::std::hash_map<ScRange, TokenArrayRef, RangeHash>          RangeArrayMap;
 287     typedef ::std::hash_map<String, String, ScStringHashCode>           NamePairMap;
 288
 289     // SUNWS needs a forward declared friend, otherwise types and members
 290     // of the outer class are not accessible.
 291     struct DocItem;
 292     friend struct ScExternalRefCache::DocItem;
 293
 294     /** Represents data cached for a single external document. */
 295     struct DocItem
 296     {
 297         /** The raw cache tables. */
 298         ::std::vector<TableTypeRef> maTables;
 299         /** Table name list in correct order, in both upper- and real-case. */
 300         ::std::vector<TableName>    maTableNames;
 301         /** Table name to index map.  The names must be stored upper-case. */
 302         TableNameIndexMap           maTableNameIndex;
 303         /** Range name cache. */
 304         RangeNameMap                maRangeNames;
 305         /** Token array cache for cell ranges. */
 306         RangeArrayMap               maRangeArrays;
 307         /** Upper- to real-case mapping for range names. */
 308         NamePairMap                 maRealRangeNameMap;
 309
 310         bool mbInitFromSource;
 311
 312         DocItem() : mbInitFromSource(false) {}
 313     };
 314     typedef ::std::hash_map<sal_uInt16, DocItem>  DocDataType;
 315     DocItem* getDocItem(sal_uInt16 nFileId) const;
 316
 317 private:
 318     mutable DocDataType maDocs;
 319 };
 320
 321 // ============================================================================
 322
 323 class SC_DLLPUBLIC ScExternalRefManager : public formula::ExternalReferenceHelper
 324 {
 325 public:
 326
 327     // SUNWS needs a forward declared friend, otherwise types and members
 328     // of the outer class are not accessible.
 329     class RefCells;
 330     friend class ScExternalRefManager::RefCells;
 331
 332     /**
 333      *  Collection of cell addresses that contain external references. This
 334      *  data is used for link updates.
 335      */
 336     class RefCells
 337     {
 338     public:
 339         RefCells();
 340         ~RefCells();
 341
 342         void insertCell(const ScAddress& rAddr);
 343         void removeCell(const ScAddress& rAddr);
 344         void moveTable(SCTAB nOldTab, SCTAB nNewTab, bool bCopy);
 345         void insertTable(SCTAB nPos);
 346         void removeTable(SCTAB nPos);
 347         void refreshAllCells(ScExternalRefManager& rRefMgr);
 348     private:
 349
 350         typedef ::std::hash_set<SCROW>              RowSet;
 351         typedef ::std::hash_map<SCCOL, RowSet>      ColSet;
 352
 353         // SUNWS needs a forward declared friend, otherwise types and members
 354         // of the outer class are not accessible.
 355         struct TabItem;
 356         friend struct ScExternalRefManager::RefCells::TabItem;
 357
 358         struct TabItem
 359         {
 360             SCTAB       mnIndex;
 361             ColSet      maCols;
 362             explicit TabItem(SCTAB nIndex);
 363             explicit TabItem(const TabItem& r);
 364         };
 365         typedef ::boost::shared_ptr<TabItem>        TabItemRef;
 366
 367         /**
 368          * Return the position that points either to the specified table
 369          * position or to the position where a new table would be inserted in
 370          * case the specified table is not present.
 371          *
 372          * @param nTab index of the desired table
 373          */
 374         ::std::list<TabItemRef>::iterator getTabPos(SCTAB nTab);
 375
 376         // This list must be sorted by the table index at all times.
 377         ::std::list<TabItemRef> maTables;
 378     };
 379
 380     enum LinkUpdateType { LINK_MODIFIED, LINK_BROKEN };
 381
 382     /**
 383      * Base class for objects that need to listen to link updates.  When a
 384      * link to a certain external file is updated, the notify() method gets
 385      * called.
 386      */
 387     class LinkListener
 388     {
 389     public:
 390         LinkListener();
 391         virtual ~LinkListener() = 0;
 392         virtual void notify(sal_uInt16 nFileId, LinkUpdateType eType) = 0;
 393
 394         struct Hash
 395         {
 396             size_t operator() (const LinkListener* p) const
 397             {
 398                 return reinterpret_cast<size_t>(p);
 399             }
 400         };
 401     };
 402
 403 private:
 404     /** Shell instance for a source document. */
 405     struct SrcShell
 406     {
 407         SfxObjectShellRef   maShell;
 408         Time                maLastAccess;
 409     };
 410
 411     typedef ::std::hash_map<sal_uInt16, SrcShell>           DocShellMap;
 412     typedef ::std::hash_map<sal_uInt16, bool>               LinkedDocMap;
 413
 414     typedef ::std::hash_map<sal_uInt16, RefCells>           RefCellMap;
 415     typedef ::std::hash_map<sal_uInt16, SvNumberFormatterMergeMap> NumFmtMap;
 416
 417
 418     typedef ::std::hash_set<LinkListener*, LinkListener::Hash>  LinkListeners;
 419     typedef ::std::hash_map<sal_uInt16, LinkListeners>          LinkListenerMap;
 420
 421 public:
 422     /** Source document meta-data container. */
 423     struct SrcFileData
 424     {
 425         String maFileName;
 426         String maRelativeName;
 427         String maFilterName;
 428         String maFilterOptions;
 429     };
 430
 431 public:
 432     explicit ScExternalRefManager(ScDocument* pDoc);
 433     virtual ~ScExternalRefManager();
 434
 435     virtual String getCacheTableName(sal_uInt16 nFileId, size_t nTabIndex) const;
 436
 437     /**
 438      * Get a cache table instance for specified table and table index.  Unlike
 439      * the other method that takes a table name, this method does not create a
 440      * new table when a table is not available for specified index.
 441      *
 442      * @param nFileId file ID
 443      * @param nTabIndex cache table index
 444      *
 445      * @return shared_ptr to the cache table instance
 446      */
 447     ScExternalRefCache::TableTypeRef getCacheTable(sal_uInt16 nFileId, size_t nTabIndex) const;
 448
 449     /**
 450      * Get a cache table instance for specified file and table name.  If the
 451      * table instance is not already present, it'll instantiate a new one and
 452      * append it to the end of the table array.  <I>It's important to be
 453      * aware of this fact especially for multi-table ranges for which
 454      * table orders are critical.</I>
 455      *
 456      * Excel filter calls this method to populate the cache table from the
 457      * XCT/CRN records.
 458      *
 459      * @param nFileId file ID
 460      * @param rTabName table name
 461      * @param bCreateNew if true, create a new table instance if it's not
 462      *                   already present.  If false, it returns NULL if the
 463      *                   specified table's cache doesn't exist.
 464      * @param pnIndex if non-NULL pointer is passed, it stores the internal
 465      *                index of a cache table instance.
 466      *
 467      * @return shared_ptr to the cache table instance
 468      */
 469     ScExternalRefCache::TableTypeRef getCacheTable(sal_uInt16 nFileId, const String& rTabName, bool bCreateNew, size_t* pnIndex = 0);
 470     void getAllCachedTableNames(sal_uInt16 nFileId, ::std::vector<String>& rTabNames) const;
 471
 472     /**
 473      * Get the span (distance+sign(distance)) of two sheets of a specified
 474      * file.
 475      *
 476      * @param nFileId file ID
 477      * @param rStartTabName name of first sheet (sheet1)
 478      * @param rEndTabName name of second sheet (sheet2)
 479      *
 480      * @return span
 481      *         1 if sheet2 == sheet1
 482      *      >  1 if sheet2 > sheet1
 483      *      < -1 if sheet2 < sheet1
 484      *        -1 if nFileId or rStartTabName not found
 485      *         0 if rEndTabName not found
 486      */
 487     SCsTAB getCachedTabSpan( sal_uInt16 nFileId, const String& rStartTabName, const String& rEndTabName ) const;
 488
 489     /**
 490      * Get all unique number format indices that are used in the cache tables.
 491      * The retrieved indices are sorted in ascending order.
 492      *
 493      * @param rNumFmts (reference) all unique number format indices.
 494      */
 495     void getAllCachedNumberFormats(::std::vector<sal_uInt32>& rNumFmts) const;
 496
 497     bool hasCacheTable(sal_uInt16 nFileId, const String& rTabName) const;
 498     size_t getCacheTableCount(sal_uInt16 nFileId) const;
 499     sal_uInt16 getExternalFileCount() const;
 500
 501     /**
 502      * Mark all tables as referenced that are used by any LinkListener, used
 503      * only during store-to-file.
 504      * @returns <TRUE/> if ALL tables of ALL external documents are marked.
 505      */
 506     bool markUsedByLinkListeners();
 507
 508     /**
 509      * Set all tables of a document as referenced, used only during
 510      * store-to-file.
 511      * @returns <TRUE/> if ALL tables of ALL external documents are marked.
 512      */
 513     bool setCacheDocReferenced( sal_uInt16 nFileId );
 514
 515     /**
 516      * Set a table as referenced, used only during store-to-file.
 517      * @returns <TRUE/> if ALL tables of ALL external documents are marked.
 518      */
 519     bool setCacheTableReferenced( sal_uInt16 nFileId, const String& rTabName, size_t nSheets );
 520     void setAllCacheTableReferencedStati( bool bReferenced );
 521
 522     /**
 523      * Set a table as permanently referenced, to be called if not in
 524      * mark-during-store-to-file cycle.
 525      */
 526     void setCacheTableReferencedPermanently( sal_uInt16 nFileId, const String& rTabName, size_t nSheets );
 527
 528     /**
 529      * @returns <TRUE/> if setAllCacheTableReferencedStati(false) was called,
 530      * <FALSE/> if setAllCacheTableReferencedStati(true) was called.
 531      */
 532     bool isInReferenceMarking() const   { return bInReferenceMarking; }
 533
 534     void storeRangeNameTokens(sal_uInt16 nFileId, const String& rName, const ScTokenArray& rArray);
 535
 536     ScExternalRefCache::TokenRef getSingleRefToken(
 537         sal_uInt16 nFileId, const String& rTabName, const ScAddress& rCell,
 538         const ScAddress* pCurPos, SCTAB* pTab, ScExternalRefCache::CellFormat* pFmt = NULL);
 539
 540     /**
 541      * Get an array of tokens that consist of the specified external cell
 542      * range.
 543      *
 544      * @param nFileId file ID for an external document
 545      * @param rTabName referenced sheet name
 546      * @param rRange referenced cell range
 547      * @param pCurPos current cursor position to keep track of cells that
 548      *                reference an external data.
 549      *
 550      * @return shared_ptr to a token array instance.  <i>The caller must not
 551      *         delete the instance returned by this method.</i>
 552      */
 553     ScExternalRefCache::TokenArrayRef getDoubleRefTokens(sal_uInt16 nFileId, const String& rTabName, const ScRange& rRange, const ScAddress* pCurPos);
 554
 555     /**
 556      * Get an array of tokens corresponding with a specified name in a
 557      * specified file.
 558      *
 559      * @param pCurPos currnet cell address where this name token is used.
 560      *                This is purely to keep track of all cells containing
 561      *                external names for refreshing purposes.  If this is
 562      *                NULL, then the cell will not be added to the list.
 563      *
 564      * @return shared_ptr to array of tokens composing the name
 565      */
 566     ScExternalRefCache::TokenArrayRef getRangeNameTokens(sal_uInt16 nFileId, const String& rName, const ScAddress* pCurPos = NULL);
 567
 568     const String& getOwnDocumentName() const;
 569     bool isOwnDocument(const String& rFile) const;
 570
 571     /**
 572      * Takes a flat file name, and convert it to an absolute URL path.  An
 573      * absolute URL path begines with 'file:///.
 574      *
 575      * @param rFile file name to convert
 576      */
 577     void convertToAbsName(String& rFile) const;
 578     sal_uInt16 getExternalFileId(const String& rFile);
 579     const String* getExternalFileName(sal_uInt16 nFileId) const;
 580     bool hasExternalFile(sal_uInt16 nFileId) const;
 581     bool hasExternalFile(const String& rFile) const;
 582     const SrcFileData* getExternalFileData(sal_uInt16 nFileId) const;
 583
 584     const String* getRealTableName(sal_uInt16 nFileId, const String& rTabName) const;
 585     const String* getRealRangeName(sal_uInt16 nFileId, const String& rRangeName) const;
 586     void refreshNames(sal_uInt16 nFileId);
 587     void breakLink(sal_uInt16 nFileId);
 588     void switchSrcFile(sal_uInt16 nFileId, const String& rNewFile);
 589
 590     void setRelativeFileName(sal_uInt16 nFileId, const String& rRelUrl);
 591
 592     /**
 593      * Set the filter name and options if any for a given source document.
 594      * These values get reset when the source document ever gets reloaded.
 595      *
 596      * @param nFileId
 597      * @param rFilterName
 598      * @param rOptions
 599      */
 600     void setFilterData(sal_uInt16 nFileId, const String& rFilterName, const String& rOptions);
 601
 602     void clear();
 603
 604     bool hasExternalData() const;
 605
 606     /**
 607      * Re-generates relative names for all stored source files.  This is
 608      * necessary when exporting to an ods document, to ensure that all source
 609      * files have their respective relative names for xlink:href export.
 610      */
 611     void resetSrcFileData();
 612
 613     /**
 614      * Update a single referencing cell position.
 615      *
 616      * @param rOldPos old position
 617      * @param rNewPos new position
 618      */
 619     void updateRefCell(const ScAddress& rOldPos, const ScAddress& rNewPos, bool bCopy);
 620
 621     /**
 622      * Update referencing cells affected by sheet movement.
 623      *
 624      * @param nOldTab old sheet position
 625      * @param nNewTab new sheet position
 626      * @param bCopy whether this is a sheet move (false) or sheet copy (true)
 627      */
 628     void updateRefMoveTable(SCTAB nOldTab, SCTAB nNewTab, bool bCopy);
 629
 630     /**
 631      * Update referencing cells affected by sheet insertion.
 632      *
 633      * @param nPos sheet insertion position.  All sheets to the right
 634      *             including the one at the insertion poistion shift to the
 635      *             right by one.
 636      */
 637     void updateRefInsertTable(SCTAB nPos);
 638
 639     void updateRefDeleteTable(SCTAB nPos);
 640
 641     /**
 642      * Register a new link listener to a specified external document.  Note
 643      * that the caller is responsible for managing the life cycle of the
 644      * listener object.
 645      */
 646     void addLinkListener(sal_uInt16 nFileId, LinkListener* pListener);
 647
 648     /**
 649      * Remove an existing link listener.  Note that removing a listener
 650      * pointer here does not delete the listener object instance.
 651      */
 652     void removeLinkListener(sal_uInt16 nFileId, LinkListener* pListener);
 653
 654     void removeLinkListener(LinkListener* pListener);
 655
 656     /**
 657      * Notify all listeners that are listening to a specified external
 658      * document.
 659      *
 660      * @param nFileId file ID for an external document.
 661      */
 662     void notifyAllLinkListeners(sal_uInt16 nFileId, LinkUpdateType eType);
 663
 664 private:
 665     ScExternalRefManager();
 666     ScExternalRefManager(const ScExternalRefManager&);
 667
 668     void refreshAllRefCells(sal_uInt16 nFileId);
 669
 670     void insertRefCell(sal_uInt16 nFileId, const ScAddress& rCell);
 671
 672     ScDocument* getSrcDocument(sal_uInt16 nFileId);
 673     SfxObjectShellRef loadSrcDocument(sal_uInt16 nFileId, String& rFilter);
 674     bool isFileLoadable(const String& rFile) const;
 675
 676     void maybeLinkExternalFile(sal_uInt16 nFileId);
 677
 678     bool compileTokensByCell(const ScAddress& rCell);
 679
 680     /**
 681      * Purge those source document instances that have not been accessed for
 682      * the specified duration.
 683      *
 684      * @param nTimeOut time out value in 100th of a second
 685      */
 686     void purgeStaleSrcDocument(sal_Int32 nTimeOut);
 687
 688     sal_uInt32 getMappedNumberFormat(sal_uInt16 nFileId, sal_uInt32 nNumFmt, ScDocument* pSrcDoc);
 689
 690 private:
 691     /** cache of referenced ranges and names from source documents. */
 692     ScExternalRefCache maRefCache;
 693
 694     ScDocument* mpDoc;
 695
 696     /**
 697      * Source document cache.  This stores the original source document shell
 698      * instances.  They get purged after a certain period of time.
 699      */
 700     DocShellMap maDocShells;
 701
 702     /** list of source documents that are managed by the link manager. */
 703     LinkedDocMap maLinkedDocs;
 704
 705     /**
 706      * List of referencing cells that may contain external names.  There is
 707      * one list per source document.
 708      */
 709     RefCellMap maRefCells;
 710
 711     LinkListenerMap maLinkListeners;
 712
 713     NumFmtMap maNumFormatMap;
 714
 715     /** original source file index. */
 716     ::std::vector<SrcFileData> maSrcFiles;
 717
 718     /** Status whether in reference marking state. See isInReferenceMarking(). */
 719     bool bInReferenceMarking;
 720
 721     AutoTimer maSrcDocTimer;
 722     DECL_LINK(TimeOutHdl, AutoTimer*);
 723 };
 724
 725
 726 #endif