sc/source/core/data/documen2.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "scitems.hxx"
  21 #include <editeng/eeitem.hxx>
  22
  23 #include <editeng/editeng.hxx>
  24 #include <editeng/forbiddencharacterstable.hxx>
  25 #include <osl/thread.h>
  26 #include <svx/xtable.hxx>
  27 #include <sfx2/linkmgr.hxx>
  28 #include <svx/svdpool.hxx>
  29 #include <svx/svdobj.hxx>
  30 #include <sfx2/bindings.hxx>
  31 #include <sfx2/objsh.hxx>
  32 #include <sfx2/docfile.hxx>
  33 #include <sfx2/printer.hxx>
  34 #include <svl/zforlist.hxx>
  35 #include <svl/zformat.hxx>
  36 #include <vcl/virdev.hxx>
  37 #include <comphelper/processfactory.hxx>
  38 #include <svl/PasswordHelper.hxx>
  39 #include "svl/sharedstringpool.hxx"
  40 #include <tools/tenccvt.hxx>
  41 #include <tools/urlobj.hxx>
  42 #include <rtl/crc.h>
  43 #include <basic/basmgr.hxx>
  44
  45 #include "document.hxx"
  46 #include "table.hxx"
  47 #include "attrib.hxx"
  48 #include "patattr.hxx"
  49 #include "rangenam.hxx"
  50 #include "dbdata.hxx"
  51 #include "pivot.hxx"
  52 #include "docpool.hxx"
  53 #include "stlpool.hxx"
  54 #include "stlsheet.hxx"
  55 #include "globstr.hrc"
  56 #include "chartarr.hxx"
  57 #include "chartlock.hxx"
  58 #include "rechead.hxx"
  59 #include "global.hxx"
  60 #include "brdcst.hxx"
  61 #include "bcaslot.hxx"
  62 #include "adiasync.hxx"
  63 #include "addinlis.hxx"
  64 #include "chartlis.hxx"
  65 #include "markdata.hxx"
  66 #include "conditio.hxx"
  67 #include "colorscale.hxx"
  68 #include "validat.hxx"
  69 #include "progress.hxx"
  70 #include "detdata.hxx"
  71 #include "sc.hrc"
  72 #include "ddelink.hxx"
  73 #include "chgtrack.hxx"
  74 #include "chgviset.hxx"
  75 #include "editutil.hxx"
  76 #include "hints.hxx"
  77 #include "dpobject.hxx"
  78 #include "scrdata.hxx"
  79 #include "poolhelp.hxx"
  80 #include "unoreflist.hxx"
  81 #include "listenercalls.hxx"
  82 #include "recursionhelper.hxx"
  83 #include "lookupcache.hxx"
  84 #include "externalrefmgr.hxx"
  85 #include "tabprotection.hxx"
  86 #include "formulaparserpool.hxx"
  87 #include "clipparam.hxx"
  88 #include "macromgr.hxx"
  89 #include "formulacell.hxx"
  90 #include "clipcontext.hxx"
  91 #include "refupdatecontext.hxx"
  92 #include "refreshtimerprotector.hxx"
  93 #include "scopetools.hxx"
  94 #include "formulagroup.hxx"
  95 #include "documentlinkmgr.hxx"
  96
  97 using namespace com::sun::star;
  98
  99 // pImpl because including lookupcache.hxx in document.hxx isn't wanted, and
 100 // dtor plus helpers are convenient.
 101 struct ScLookupCacheMapImpl
 102 {
 103     ScLookupCacheMap aCacheMap;
 104     ~ScLookupCacheMapImpl()
 105     {
 106         freeCaches();
 107     }
 108     void clear()
 109     {
 110         freeCaches();
 111         // Zap map.
 112         ScLookupCacheMap aTmp;
 113         aCacheMap.swap( aTmp);
 114     }
 115 private:
 116     void freeCaches()
 117     {
 118         for (ScLookupCacheMap::iterator it( aCacheMap.begin()); it != aCacheMap.end(); ++it)
 119             delete (*it).second;
 120     }
 121 };
 122
 123 // STATIC DATA -----------------------------------------------------------
 124
 125 ScDocument::ScDocument( ScDocumentMode eMode, SfxObjectShell* pDocShell ) :
 126         mpCellStringPool(new svl::SharedStringPool(ScGlobal::pCharClass)),
 127         mpFormulaGroupCxt(NULL),
 128         mpUndoManager( NULL ),
 129         pEditEngine( NULL ),
 130         pNoteEngine( NULL ),
 131         pShell( pDocShell ),
 132         pPrinter( NULL ),
 133         pVirtualDevice_100th_mm( NULL ),
 134         pDrawLayer( NULL ),
 135         pValidationList( NULL ),
 136         pFormatExchangeList( NULL ),
 137         pRangeName(NULL),
 138         pDPCollection( NULL ),
 139         pLinkManager( NULL ),
 140         pFormulaTree( NULL ),
 141         pEOFormulaTree( NULL ),
 142         pFormulaTrack( NULL ),
 143         pEOFormulaTrack( NULL ),
 144         pClipData( NULL ),
 145         pDetOpList(NULL),
 146         pChangeTrack( NULL ),
 147         pUnoBroadcaster( NULL ),
 148         pUnoListenerCalls( NULL ),
 149         pUnoRefUndoList( NULL ),
 150         pChangeViewSettings( NULL ),
 151         pScriptTypeData( NULL ),
 152         pCacheFieldEditEngine( NULL ),
 153         pDocProtection( NULL ),
 154         mpClipParam( NULL),
 155         pExternalRefMgr( NULL ),
 156         mpMacroMgr( NULL ),
 157         pViewOptions( NULL ),
 158         pDocOptions( NULL ),
 159         pExtDocOptions( NULL ),
 160         pConsolidateDlgData( NULL ),
 161         pRecursionHelper( NULL ),
 162         pAutoNameCache( NULL ),
 163         pLookupCacheMapImpl( NULL ),
 164         pPreviewFont( NULL ),
 165         pPreviewCellStyle( NULL ),
 166         nUnoObjectId( 0 ),
 167         nRangeOverflowType( 0 ),
 168         aCurTextWidthCalcPos(MAXCOL,0,0),
 169         aTableOpList( 0 ),
 170         nFormulaCodeInTree(0),
 171         nXMLImportedFormulaCount( 0 ),
 172         nInterpretLevel(0),
 173         nMacroInterpretLevel(0),
 174         nInterpreterTableOpLevel(0),
 175         nSrcVer( SC_CURRENT_VERSION ),
 176         nSrcMaxRow( MAXROW ),
 177         nFormulaTrackCount(0),
 178         bHardRecalcState(false),
 179         nVisibleTab( 0 ),
 180         eLinkMode(LM_UNKNOWN),
 181         bAutoCalc( eMode == SCDOCMODE_DOCUMENT ),
 182         bAutoCalcShellDisabled( false ),
 183         bForcedFormulaPending( false ),
 184         bCalculatingFormulaTree( false ),
 185         bIsClip( eMode == SCDOCMODE_CLIP ),
 186         bIsUndo( eMode == SCDOCMODE_UNDO ),
 187         bIsVisible( false ),
 188         bIsEmbedded( false ),
 189         bInsertingFromOtherDoc( false ),
 190         bLoadingMedium( false ),
 191         bImportingXML( false ),
 192         bXMLFromWrapper( false ),
 193         bCalcingAfterLoad( false ),
 194         bNoListening( false ),
 195         mbIdleEnabled(true),
 196         bInLinkUpdate( false ),
 197         bChartListenerCollectionNeedsUpdate( false ),
 198         bHasForcedFormulas( false ),
 199         bInDtorClear( false ),
 200         bExpandRefs( false ),
 201         bDetectiveDirty( false ),
 202         nMacroCallMode( SC_MACROCALL_ALLOWED ),
 203         bHasMacroFunc( false ),
 204         nVisSpellState( 0 ),
 205         nAsianCompression(SC_ASIANCOMPRESSION_INVALID),
 206         nAsianKerning(SC_ASIANKERNING_INVALID),
 207         bPastingDrawFromOtherDoc( false ),
 208         nInDdeLinkUpdate( 0 ),
 209         bInUnoBroadcast( false ),
 210         bInUnoListenerCall( false ),
 211         eGrammar( formula::FormulaGrammar::GRAM_NATIVE ),
 212         bStyleSheetUsageInvalid( true ),
 213         mbUndoEnabled( true ),
 214         mbAdjustHeightEnabled( true ),
 215         mbExecuteLinkEnabled( true ),
 216         mbChangeReadOnlyEnabled( false ),
 217         mbStreamValidLocked( false ),
 218         mbUserInteractionEnabled(true),
 219         mnNamedRangesLockCount(0),
 220         mbUseEmbedFonts(false)
 221 {
 222     SetStorageGrammar( formula::FormulaGrammar::GRAM_STORAGE_DEFAULT);
 223
 224     eSrcSet = osl_getThreadTextEncoding();
 225
 226     if ( eMode == SCDOCMODE_DOCUMENT )
 227     {
 228         if ( pDocShell )
 229             pLinkManager = new sfx2::LinkManager( pDocShell );
 230
 231         xPoolHelper = new ScPoolHelper( this );
 232
 233         pBASM = new ScBroadcastAreaSlotMachine( this );
 234         pChartListenerCollection = new ScChartListenerCollection( this );
 235         pRefreshTimerControl = new ScRefreshTimerControl;
 236     }
 237     else
 238     {
 239         pBASM       = NULL;
 240         pChartListenerCollection = NULL;
 241         pRefreshTimerControl = NULL;
 242     }
 243     pDBCollection = new ScDBCollection(this);
 244     pSelectionAttr = NULL;
 245     pChartCollection = new ScChartCollection;
 246     apTemporaryChartLock.reset( new ScTemporaryChartLock(this) );
 247     xColNameRanges = new ScRangePairList;
 248     xRowNameRanges = new ScRangePairList;
 249     ImplCreateOptions();
 250     // languages for a visible document are set by docshell later (from options)
 251     SetLanguage( ScGlobal::eLnge, ScGlobal::eLnge, ScGlobal::eLnge );
 252
 253     aTrackTimer.SetTimeoutHdl( LINK( this, ScDocument, TrackTimeHdl ) );
 254     aTrackTimer.SetTimeout( 100 );
 255 }
 256
 257 sfx2::LinkManager*  ScDocument::GetLinkManager()  const
 258 {
 259     if ( bAutoCalc && !pLinkManager && pShell)
 260     {
 261         pLinkManager = new sfx2::LinkManager( pShell );
 262     }
 263     return pLinkManager;
 264 }
 265
 266 sc::DocumentLinkManager& ScDocument::GetDocLinkManager()
 267 {
 268     if (!mpDocLinkMgr)
 269         mpDocLinkMgr.reset(new sc::DocumentLinkManager);
 270     return *mpDocLinkMgr;
 271 }
 272
 273 const sc::DocumentLinkManager& ScDocument::GetDocLinkManager() const
 274 {
 275     if (!mpDocLinkMgr)
 276         mpDocLinkMgr.reset(new sc::DocumentLinkManager);
 277     return *mpDocLinkMgr;
 278 }
 279
 280 void ScDocument::SetStorageGrammar( formula::FormulaGrammar::Grammar eGram )
 281 {
 282     OSL_PRECOND(
 283         eGram == formula::FormulaGrammar::GRAM_ODFF ||
 284             eGram == formula::FormulaGrammar::GRAM_PODF,
 285             "ScDocument::SetStorageGrammar: wrong storage grammar");
 286
 287     eStorageGrammar = eGram;
 288
 289     // FIXME: the XML import shouldn't strip brackets, the compiler should
 290     // digest them instead, which could also speedup reference recognition
 291     // during import.
 292
 293     eXmlImportGrammar = formula::FormulaGrammar::mergeToGrammar( eGram,
 294             formula::FormulaGrammar::CONV_OOO);
 295 }
 296
 297
 298 void ScDocument::SetDocVisible( bool bSet )
 299 {
 300     //  called from view ctor - only for a visible document,
 301     //  each new sheet's RTL flag is initialized from the locale
 302     bIsVisible = bSet;
 303 }
 304
 305
 306 sal_uInt32 ScDocument::GetDocumentID() const
 307 {
 308     const ScDocument* pThis = this;
 309     sal_uInt32 nCrc = rtl_crc32( 0, &pThis, sizeof(ScDocument*) );
 310     // the this pointer only might not be sufficient
 311     nCrc = rtl_crc32( nCrc, &pShell, sizeof(SfxObjectShell*) );
 312     return nCrc;
 313 }
 314
 315
 316 void ScDocument::StartChangeTracking()
 317 {
 318     if (!pChangeTrack)
 319         pChangeTrack = new ScChangeTrack( this );
 320 }
 321
 322 void ScDocument::EndChangeTracking()
 323 {
 324     delete pChangeTrack;
 325     pChangeTrack = NULL;
 326 }
 327
 328 void ScDocument::SetChangeTrack( ScChangeTrack* pTrack )
 329 {
 330     OSL_ENSURE( pTrack->GetDocument() == this, "SetChangeTrack: different documents" );
 331     if ( !pTrack || pTrack == pChangeTrack || pTrack->GetDocument() != this )
 332         return ;
 333     EndChangeTracking();
 334     pChangeTrack = pTrack;
 335 }
 336
 337
 338 IMPL_LINK_NOARG(ScDocument, TrackTimeHdl)
 339 {
 340     if ( ScDdeLink::IsInUpdate() )      // nicht verschachteln
 341     {
 342         aTrackTimer.Start();            // spaeter nochmal versuchen
 343     }
 344     else if (pShell)                    // ausfuehren
 345     {
 346         TrackFormulas();
 347         pShell->Broadcast( SfxSimpleHint( FID_DATACHANGED ) );
 348
 349             //  modified...
 350
 351         if (!pShell->IsModified())
 352         {
 353             pShell->SetModified( true );
 354             SfxBindings* pBindings = GetViewBindings();
 355             if (pBindings)
 356             {
 357                 pBindings->Invalidate( SID_SAVEDOC );
 358                 pBindings->Invalidate( SID_DOC_MODIFIED );
 359             }
 360         }
 361     }
 362
 363     return 0;
 364 }
 365
 366 void ScDocument::StartTrackTimer()
 367 {
 368     if (!aTrackTimer.IsActive())        // nicht ewig aufschieben
 369         aTrackTimer.Start();
 370 }
 371
 372 ScDocument::~ScDocument()
 373 {
 374     OSL_PRECOND( !bInLinkUpdate, "bInLinkUpdate in dtor" );
 375
 376     bInDtorClear = true;
 377
 378     // first of all disable all refresh timers by deleting the control
 379     if ( pRefreshTimerControl )
 380     {   // To be sure there isn't anything running do it with a protector,
 381         // this ensures also that nothing needs the control anymore.
 382         ScRefreshTimerProtector aProt( GetRefreshTimerControlAddress() );
 383         delete pRefreshTimerControl, pRefreshTimerControl = NULL;
 384     }
 385
 386     // Links aufrauemen
 387
 388     if ( GetLinkManager() )
 389     {
 390         // BaseLinks freigeben
 391         ::sfx2::SvLinkSources aTemp(pLinkManager->GetServers());
 392         for( ::sfx2::SvLinkSources::const_iterator it = aTemp.begin(); it != aTemp.end(); ++it )
 393             (*it)->Closed();
 394
 395         if ( pLinkManager->GetLinks().size() )
 396             pLinkManager->Remove( 0, pLinkManager->GetLinks().size() );
 397     }
 398
 399     mxFormulaParserPool.reset();
 400     // Destroy the external ref mgr instance here because it has a timer
 401     // which needs to be stopped before the app closes.
 402     pExternalRefMgr.reset();
 403
 404     ScAddInAsync::RemoveDocument( this );
 405     ScAddInListener::RemoveDocument( this );
 406     DELETEZ( pChartListenerCollection);   // vor pBASM wg. evtl. Listener!
 407     DELETEZ( pLookupCacheMapImpl);  // before pBASM because of listeners
 408     // BroadcastAreas vor allen Zellen zerstoeren um unnoetige
 409     // Einzel-EndListenings der Formelzellen zu vermeiden
 410     delete pBASM;       // BroadcastAreaSlotMachine
 411     pBASM = NULL;
 412
 413     delete pUnoBroadcaster;     // broadcasted nochmal SFX_HINT_DYING
 414     pUnoBroadcaster = NULL;
 415
 416     delete pUnoRefUndoList;
 417     delete pUnoListenerCalls;
 418
 419     Clear( true );              // true = from destructor (needed for SdrModel::ClearModel)
 420
 421     if (pValidationList)
 422     {
 423         for( ScValidationDataList::iterator it = pValidationList->begin(); it != pValidationList->end(); ++it )
 424             delete *it;
 425         pValidationList->clear();
 426         DELETEZ(pValidationList);
 427     }
 428     delete pRangeName;
 429     delete pDBCollection;
 430     delete pSelectionAttr;
 431     apTemporaryChartLock.reset();
 432     delete pChartCollection;
 433     DeleteDrawLayer();
 434     delete pFormatExchangeList;
 435     delete pPrinter;
 436     ImplDeleteOptions();
 437     delete pConsolidateDlgData;
 438     delete pLinkManager;
 439     delete pClipData;
 440     delete pDetOpList;                  // loescht auch die Eintraege
 441     delete pChangeTrack;
 442     delete pEditEngine;
 443     delete pNoteEngine;
 444     delete pChangeViewSettings;         // und weg damit
 445     delete pVirtualDevice_100th_mm;
 446
 447     delete pDPCollection;
 448
 449     // delete the EditEngine before destroying the xPoolHelper
 450     delete pCacheFieldEditEngine;
 451
 452     if ( xPoolHelper.is() && !bIsClip )
 453         xPoolHelper->SourceDocumentGone();
 454     xPoolHelper.clear();
 455
 456     delete pScriptTypeData;
 457     delete pRecursionHelper;
 458
 459     delete pPreviewFont;
 460     OSL_POSTCOND( !pAutoNameCache, "AutoNameCache still set in dtor" );
 461
 462     mpFormulaGroupCxt.reset();
 463     mpCellStringPool.reset();
 464 }
 465
 466 void ScDocument::InitClipPtrs( ScDocument* pSourceDoc )
 467 {
 468     OSL_ENSURE(bIsClip, "InitClipPtrs and not bIsClip");
 469
 470     if (pValidationList)
 471     {
 472         for(ScValidationDataList::iterator it = pValidationList->begin(); it != pValidationList->end(); ++it )
 473             delete *it;
 474         pValidationList->clear();
 475         DELETEZ(pValidationList);
 476     }
 477
 478     Clear();
 479
 480     xPoolHelper = pSourceDoc->xPoolHelper;
 481
 482     //  bedingte Formate / Gueltigkeiten
 483     //! Vorlagen kopieren?
 484     const ScValidationDataList* pSourceValid = pSourceDoc->pValidationList;
 485     if ( pSourceValid )
 486         pValidationList = new ScValidationDataList(this, *pSourceValid);
 487
 488                         // Links in Stream speichern
 489     delete pClipData;
 490     if (pSourceDoc->HasDdeLinks())
 491     {
 492         pClipData = new SvMemoryStream;
 493         pSourceDoc->SaveDdeLinks(*pClipData);
 494     }
 495     else
 496         pClipData = NULL;
 497
 498     // Options pointers exist (ImplCreateOptions) for any document.
 499     // Must be copied for correct results in OLE objects (#i42666#).
 500     SetDocOptions( pSourceDoc->GetDocOptions() );
 501     SetViewOptions( pSourceDoc->GetViewOptions() );
 502 }
 503
 504 SvNumberFormatter* ScDocument::GetFormatTable() const
 505 {
 506     return xPoolHelper->GetFormTable();
 507 }
 508
 509 SvNumberFormatter* ScDocument::CreateFormatTable() const
 510 {
 511     return xPoolHelper->CreateNumberFormatter();
 512 }
 513
 514 SfxItemPool* ScDocument::GetEditPool() const
 515 {
 516     return xPoolHelper->GetEditPool();
 517 }
 518
 519 SfxItemPool* ScDocument::GetEnginePool() const
 520 {
 521     return xPoolHelper->GetEnginePool();
 522 }
 523
 524 ScFieldEditEngine& ScDocument::GetEditEngine()
 525 {
 526     if ( !pEditEngine )
 527     {
 528         pEditEngine = new ScFieldEditEngine(this, GetEnginePool(), GetEditPool());
 529         pEditEngine->SetUpdateMode( false );
 530         pEditEngine->EnableUndo( false );
 531         pEditEngine->SetRefMapMode( MAP_100TH_MM );
 532         ApplyAsianEditSettings( *pEditEngine );
 533     }
 534     return *pEditEngine;
 535 }
 536
 537 ScNoteEditEngine& ScDocument::GetNoteEngine()
 538 {
 539     if ( !pNoteEngine )
 540     {
 541         pNoteEngine = new ScNoteEditEngine( GetEnginePool(), GetEditPool() );
 542         pNoteEngine->SetUpdateMode( false );
 543         pNoteEngine->EnableUndo( false );
 544         pNoteEngine->SetRefMapMode( MAP_100TH_MM );
 545         ApplyAsianEditSettings( *pNoteEngine );
 546         const SfxItemSet& rItemSet = GetDefPattern()->GetItemSet();
 547         SfxItemSet* pEEItemSet = new SfxItemSet( pNoteEngine->GetEmptyItemSet() );
 548         ScPatternAttr::FillToEditItemSet( *pEEItemSet, rItemSet );
 549         pNoteEngine->SetDefaults( pEEItemSet );      // edit engine takes ownership
 550     }
 551     return *pNoteEngine;
 552 }
 553
 554
 555 void ScDocument::ResetClip( ScDocument* pSourceDoc, const ScMarkData* pMarks )
 556 {
 557     if (bIsClip)
 558     {
 559         InitClipPtrs(pSourceDoc);
 560
 561         for (SCTAB i = 0; i < static_cast<SCTAB>(pSourceDoc->maTabs.size()); i++)
 562             if (pSourceDoc->maTabs[i])
 563                 if (!pMarks || pMarks->GetTableSelect(i))
 564                 {
 565                     OUString aString;
 566                     pSourceDoc->maTabs[i]->GetName(aString);
 567                     if ( i < static_cast<SCTAB>(maTabs.size()) )
 568                     {
 569                         maTabs[i] = new ScTable(this, i, aString);
 570
 571                     }
 572                     else
 573                     {
 574                         if( i > static_cast<SCTAB>(maTabs.size()) )
 575                         {
 576                             maTabs.resize(i, NULL );
 577                         }
 578                         maTabs.push_back(new ScTable(this, i, aString));
 579                     }
 580                     maTabs[i]->SetLayoutRTL( pSourceDoc->maTabs[i]->IsLayoutRTL() );
 581                 }
 582     }
 583     else
 584     {
 585         OSL_FAIL("ResetClip");
 586     }
 587 }
 588
 589 void ScDocument::ResetClip( ScDocument* pSourceDoc, SCTAB nTab )
 590 {
 591     if (bIsClip)
 592     {
 593         InitClipPtrs(pSourceDoc);
 594         if (nTab >= static_cast<SCTAB>(maTabs.size()))
 595         {
 596             maTabs.resize(nTab+1, NULL );
 597         }
 598         maTabs[nTab] = new ScTable(this, nTab,
 599                             OUString("baeh"));
 600         if (nTab < static_cast<SCTAB>(pSourceDoc->maTabs.size()) && pSourceDoc->maTabs[nTab])
 601             maTabs[nTab]->SetLayoutRTL( pSourceDoc->maTabs[nTab]->IsLayoutRTL() );
 602     }
 603     else
 604     {
 605         OSL_FAIL("ResetClip");
 606     }
 607 }
 608
 609 void ScDocument::EnsureTable( SCTAB nTab )
 610 {
 611     bool bExtras = !bIsUndo;        // Spaltenbreiten, Zeilenhoehen, Flags
 612     if (static_cast<size_t>(nTab) >= maTabs.size())
 613         maTabs.resize(nTab+1, NULL);
 614
 615     if (!maTabs[nTab])
 616         maTabs[nTab] = new ScTable(this, nTab, "temp", bExtras, bExtras);
 617 }
 618
 619 ScRefCellValue ScDocument::GetRefCellValue( const ScAddress& rPos )
 620 {
 621     if (!TableExists(rPos.Tab()))
 622         return ScRefCellValue(); // empty
 623
 624     return maTabs[rPos.Tab()]->GetRefCellValue(rPos.Col(), rPos.Row());
 625 }
 626
 627 svl::SharedStringPool& ScDocument::GetSharedStringPool()
 628 {
 629     return *mpCellStringPool;
 630 }
 631
 632 const svl::SharedStringPool& ScDocument::GetSharedStringPool() const
 633 {
 634     return *mpCellStringPool;
 635 }
 636
 637 bool ScDocument::GetPrintArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow,
 638                                 bool bNotes ) const
 639 {
 640     if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
 641     {
 642         bool bAny = maTabs[nTab]->GetPrintArea( rEndCol, rEndRow, bNotes );
 643         if (pDrawLayer)
 644         {
 645             ScRange aDrawRange(0,0,nTab, MAXCOL,MAXROW,nTab);
 646             if (DrawGetPrintArea( aDrawRange, true, true ))
 647             {
 648                 if (aDrawRange.aEnd.Col()>rEndCol) rEndCol=aDrawRange.aEnd.Col();
 649                 if (aDrawRange.aEnd.Row()>rEndRow) rEndRow=aDrawRange.aEnd.Row();
 650                 bAny = true;
 651             }
 652         }
 653         return bAny;
 654     }
 655
 656     rEndCol = 0;
 657     rEndRow = 0;
 658     return false;
 659 }
 660
 661 bool ScDocument::GetPrintAreaHor( SCTAB nTab, SCROW nStartRow, SCROW nEndRow,
 662                                         SCCOL& rEndCol, bool bNotes ) const
 663 {
 664     if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
 665     {
 666         bool bAny = maTabs[nTab]->GetPrintAreaHor( nStartRow, nEndRow, rEndCol, bNotes );
 667         if (pDrawLayer)
 668         {
 669             ScRange aDrawRange(0,nStartRow,nTab, MAXCOL,nEndRow,nTab);
 670             if (DrawGetPrintArea( aDrawRange, true, false ))
 671             {
 672                 if (aDrawRange.aEnd.Col()>rEndCol) rEndCol=aDrawRange.aEnd.Col();
 673                 bAny = true;
 674             }
 675         }
 676         return bAny;
 677     }
 678
 679     rEndCol = 0;
 680     return false;
 681 }
 682
 683 bool ScDocument::GetPrintAreaVer( SCTAB nTab, SCCOL nStartCol, SCCOL nEndCol,
 684                                         SCROW& rEndRow, bool bNotes ) const
 685 {
 686     if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
 687     {
 688         bool bAny = maTabs[nTab]->GetPrintAreaVer( nStartCol, nEndCol, rEndRow, bNotes );
 689         if (pDrawLayer)
 690         {
 691             ScRange aDrawRange(nStartCol,0,nTab, nEndCol,MAXROW,nTab);
 692             if (DrawGetPrintArea( aDrawRange, false, true ))
 693             {
 694                 if (aDrawRange.aEnd.Row()>rEndRow) rEndRow=aDrawRange.aEnd.Row();
 695                 bAny = true;
 696             }
 697         }
 698         return bAny;
 699     }
 700
 701     rEndRow = 0;
 702     return false;
 703 }
 704
 705 bool ScDocument::GetDataStart( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow ) const
 706 {
 707     if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
 708     {
 709         bool bAny = maTabs[nTab]->GetDataStart( rStartCol, rStartRow );
 710         if (pDrawLayer)
 711         {
 712             ScRange aDrawRange(0,0,nTab, MAXCOL,MAXROW,nTab);
 713             if (DrawGetPrintArea( aDrawRange, true, true ))
 714             {
 715                 if (aDrawRange.aStart.Col()<rStartCol) rStartCol=aDrawRange.aStart.Col();
 716                 if (aDrawRange.aStart.Row()<rStartRow) rStartRow=aDrawRange.aStart.Row();
 717                 bAny = true;
 718             }
 719         }
 720         return bAny;
 721     }
 722
 723     rStartCol = 0;
 724     rStartRow = 0;
 725     return false;
 726 }
 727
 728 bool ScDocument::MoveTab( SCTAB nOldPos, SCTAB nNewPos, ScProgress* pProgress )
 729 {
 730     if (nOldPos == nNewPos)
 731         return false;
 732
 733     SCTAB nTabCount = static_cast<SCTAB>(maTabs.size());
 734     if(nTabCount < 2)
 735         return false;
 736
 737     bool bValid = false;
 738     if (ValidTab(nOldPos) && nOldPos < nTabCount )
 739     {
 740         if (maTabs[nOldPos])
 741         {
 742             sc::AutoCalcSwitch aACSwitch(*this, false);
 743
 744             SetNoListening( true );
 745             if (nNewPos == SC_TAB_APPEND || nNewPos >= nTabCount)
 746                 nNewPos = nTabCount-1;
 747
 748             //  Referenz-Updaterei
 749             //! mit UpdateReference zusammenfassen!
 750
 751             sc::RefUpdateMoveTabContext aCxt(nOldPos, nNewPos);
 752
 753             SCsTAB nDz = ((SCsTAB)nNewPos) - (SCsTAB)nOldPos;
 754             ScRange aSourceRange( 0,0,nOldPos, MAXCOL,MAXROW,nOldPos );
 755             if (pRangeName)
 756                 pRangeName->UpdateMoveTab(aCxt);
 757
 758             pDBCollection->UpdateMoveTab( nOldPos, nNewPos );
 759             xColNameRanges->UpdateReference( URM_REORDER, this, aSourceRange, 0,0,nDz );
 760             xRowNameRanges->UpdateReference( URM_REORDER, this, aSourceRange, 0,0,nDz );
 761             if (pDPCollection)
 762                 pDPCollection->UpdateReference( URM_REORDER, aSourceRange, 0,0,nDz );
 763             if (pDetOpList)
 764                 pDetOpList->UpdateReference( this, URM_REORDER, aSourceRange, 0,0,nDz );
 765             UpdateChartRef( URM_REORDER,
 766                     0,0,nOldPos, MAXCOL,MAXROW,nOldPos, 0,0,nDz );
 767             UpdateRefAreaLinks( URM_REORDER, aSourceRange, 0,0,nDz );
 768             if ( pValidationList )
 769                 pValidationList->UpdateMoveTab(aCxt);
 770             if ( pUnoBroadcaster )
 771                 pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_REORDER,
 772                             aSourceRange, 0,0,nDz ) );
 773
 774             ScTable* pSaveTab = maTabs[nOldPos];
 775             maTabs.erase(maTabs.begin()+nOldPos);
 776             maTabs.insert(maTabs.begin()+nNewPos, pSaveTab);
 777             TableContainer::iterator it = maTabs.begin();
 778             for (SCTAB i = 0; i < nTabCount; i++)
 779                 if (maTabs[i])
 780                     maTabs[i]->UpdateMoveTab(aCxt, i, pProgress);
 781             it = maTabs.begin();
 782             for (; it != maTabs.end(); ++it)
 783                 if (*it)
 784                     (*it)->UpdateCompile();
 785             SetNoListening( false );
 786             it = maTabs.begin();
 787             for (; it != maTabs.end(); ++it)
 788                 if (*it)
 789                     (*it)->StartAllListeners();
 790             // sheet names of references may not be valid until sheet is moved
 791             pChartListenerCollection->UpdateScheduledSeriesRanges();
 792             SetDirty();
 793
 794             if (pDrawLayer)
 795                 DrawMovePage( static_cast<sal_uInt16>(nOldPos), static_cast<sal_uInt16>(nNewPos) );
 796
 797             bValid = true;
 798         }
 799     }
 800     return bValid;
 801 }
 802
 803 bool ScDocument::CopyTab( SCTAB nOldPos, SCTAB nNewPos, const ScMarkData* pOnlyMarked )
 804 {
 805     if (SC_TAB_APPEND == nNewPos  || nNewPos >= static_cast<SCTAB>(maTabs.size()))
 806         nNewPos = static_cast<SCTAB>(maTabs.size());
 807     OUString aName;
 808     GetName(nOldPos, aName);
 809
 810     //  vorneweg testen, ob der Prefix als gueltig erkannt wird
 811     //  wenn nicht, nur doppelte vermeiden
 812     bool bPrefix = ValidTabName( aName );
 813     OSL_ENSURE(bPrefix, "invalid table name");
 814     SCTAB nDummy;
 815
 816     CreateValidTabName(aName);
 817
 818     bool bValid;
 819     if (bPrefix)
 820         bValid = ValidNewTabName(aName);
 821     else
 822         bValid = !GetTable( aName, nDummy );
 823
 824     sc::AutoCalcSwitch aACSwitch(*this, false);
 825     sc::RefUpdateInsertTabContext aCxt(nNewPos, 1);
 826
 827     if (bValid)
 828     {
 829         if (nNewPos >= static_cast<SCTAB>(maTabs.size()))
 830         {
 831             nNewPos = static_cast<SCTAB>(maTabs.size());
 832             maTabs.push_back(new ScTable(this, nNewPos, aName));
 833         }
 834         else
 835         {
 836             if (ValidTab(nNewPos) && (nNewPos < static_cast<SCTAB>(maTabs.size())))
 837             {
 838                 SetNoListening( true );
 839
 840                 ScRange aRange( 0,0,nNewPos, MAXCOL,MAXROW,MAXTAB );
 841                 xColNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,1 );
 842                 xRowNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,1 );
 843                 if (pRangeName)
 844                     pRangeName->UpdateInsertTab(aCxt);
 845
 846                 pDBCollection->UpdateReference(
 847                                     URM_INSDEL, 0,0,nNewPos, MAXCOL,MAXROW,MAXTAB, 0,0,1 );
 848                 if (pDPCollection)
 849                     pDPCollection->UpdateReference( URM_INSDEL, aRange, 0,0,1 );
 850                 if (pDetOpList)
 851                     pDetOpList->UpdateReference( this, URM_INSDEL, aRange, 0,0,1 );
 852                 UpdateChartRef( URM_INSDEL, 0,0,nNewPos, MAXCOL,MAXROW,MAXTAB, 0,0,1 );
 853                 UpdateRefAreaLinks( URM_INSDEL, aRange, 0,0,1 );
 854                 if ( pUnoBroadcaster )
 855                     pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_INSDEL, aRange, 0,0,1 ) );
 856
 857                 SCTAB i;
 858                 for (TableContainer::iterator it = maTabs.begin(); it != maTabs.end(); ++it)
 859                     if (*it && it != (maTabs.begin() + nOldPos))
 860                         (*it)->UpdateInsertTab(aCxt);
 861                 maTabs.push_back(NULL);
 862                 for (i = static_cast<SCTAB>(maTabs.size())-1; i > nNewPos; i--)
 863                     maTabs[i] = maTabs[i - 1];
 864                 if (nNewPos <= nOldPos)
 865                     nOldPos++;
 866                 maTabs[nNewPos] = new ScTable(this, nNewPos, aName);
 867                 bValid = true;
 868                 for (TableContainer::iterator it = maTabs.begin(); it != maTabs.end(); ++it)
 869                     if (*it && it != maTabs.begin()+nOldPos && it != maTabs.begin() + nNewPos)
 870                         (*it)->UpdateCompile();
 871                 SetNoListening( false );
 872                 for (TableContainer::iterator it = maTabs.begin(); it != maTabs.end(); ++it)
 873                     if (*it && it != maTabs.begin()+nOldPos && it != maTabs.begin()+nNewPos)
 874                         (*it)->StartAllListeners();
 875
 876                 if (pValidationList)
 877                     pValidationList->UpdateInsertTab(aCxt);
 878
 879                 // sheet names of references may not be valid until sheet is copied
 880                 pChartListenerCollection->UpdateScheduledSeriesRanges();
 881             }
 882             else
 883                 bValid = false;
 884         }
 885     }
 886
 887     if (bValid)
 888     {
 889         SetNoListening( true );     // noch nicht bei CopyToTable/Insert
 890         sc::CopyToDocContext aCopyDocCxt(*this);
 891         maTabs[nOldPos]->CopyToTable(aCopyDocCxt, 0, 0, MAXCOL, MAXROW, IDF_ALL, (pOnlyMarked != NULL),
 892                                         maTabs[nNewPos], pOnlyMarked );
 893         maTabs[nNewPos]->SetTabBgColor(maTabs[nOldPos]->GetTabBgColor());
 894
 895         SCTAB nDz = nNewPos - nOldPos;
 896         sc::RefUpdateContext aRefCxt(*this);
 897         aRefCxt.meMode = URM_COPY;
 898         aRefCxt.maRange = ScRange(0, 0, nNewPos, MAXCOL, MAXROW, nNewPos);
 899         aRefCxt.mnTabDelta = nDz;
 900         maTabs[nNewPos]->UpdateReference(aRefCxt, NULL);
 901
 902         sc::RefUpdateInsertTabContext aInsTabCxt(nNewPos, 1);
 903         maTabs[nNewPos]->UpdateInsertTabAbs(nNewPos); // alle abs. um eins hoch!!
 904         maTabs[nOldPos]->UpdateInsertTab(aInsTabCxt);
 905
 906         maTabs[nOldPos]->UpdateCompile();
 907         maTabs[nNewPos]->UpdateCompile( true ); //  maybe already compiled in Clone, but used names need recompilation
 908         SetNoListening( false );
 909         maTabs[nOldPos]->StartAllListeners();
 910         maTabs[nNewPos]->StartAllListeners();
 911
 912         ScConditionalFormatList* pNewList = new ScConditionalFormatList(*maTabs[nOldPos]->GetCondFormList());
 913         pNewList->UpdateReference(aRefCxt);
 914         maTabs[nNewPos]->SetCondFormList( pNewList );
 915
 916         SetDirty();
 917
 918         if (pDrawLayer)
 919             DrawCopyPage( static_cast<sal_uInt16>(nOldPos), static_cast<sal_uInt16>(nNewPos) );
 920
 921         if (pDPCollection)
 922             pDPCollection->CopyToTab(nOldPos, nNewPos);
 923
 924         maTabs[nNewPos]->SetPageStyle( maTabs[nOldPos]->GetPageStyle() );
 925         maTabs[nNewPos]->SetPendingRowHeights( maTabs[nOldPos]->IsPendingRowHeights() );
 926
 927         // Copy the custom print range if exists.
 928         maTabs[nNewPos]->CopyPrintRange(*maTabs[nOldPos]);
 929
 930         // Copy the RTL settings
 931         maTabs[nNewPos]->SetLayoutRTL(maTabs[nOldPos]->IsLayoutRTL());
 932         maTabs[nNewPos]->SetLoadingRTL(maTabs[nOldPos]->IsLoadingRTL());
 933     }
 934
 935     return bValid;
 936 }
 937
 938 void VBA_InsertModule( ScDocument& rDoc, SCTAB nTab, const OUString& sModuleName, const OUString& sModuleSource );
 939
 940 sal_uLong ScDocument::TransferTab( ScDocument* pSrcDoc, SCTAB nSrcPos,
 941                                 SCTAB nDestPos, bool bInsertNew,
 942                                 bool bResultsOnly )
 943 {
 944     sal_uLong nRetVal = 1;                      // 0 => Fehler 1 = ok
 945                                             // 3 => NameBox
 946                                             // 4 => beides
 947
 948     if (pSrcDoc->pShell->GetMedium())
 949     {
 950         pSrcDoc->maFileURL = pSrcDoc->pShell->GetMedium()->GetURLObject().GetMainURL(INetURLObject::DECODE_TO_IURI);
 951         // for unsaved files use the title name and adjust during save of file
 952         if (pSrcDoc->maFileURL.isEmpty())
 953             pSrcDoc->maFileURL = pSrcDoc->pShell->GetName();
 954     }
 955     else
 956     {
 957         pSrcDoc->maFileURL = pSrcDoc->pShell->GetName();
 958     }
 959
 960     bool bValid = true;
 961     if (bInsertNew)             // neu einfuegen
 962     {
 963         OUString aName;
 964         pSrcDoc->GetName(nSrcPos, aName);
 965         CreateValidTabName(aName);
 966         bValid = InsertTab(nDestPos, aName);
 967
 968         // Copy the RTL settings
 969         maTabs[nDestPos]->SetLayoutRTL(pSrcDoc->maTabs[nSrcPos]->IsLayoutRTL());
 970         maTabs[nDestPos]->SetLoadingRTL(pSrcDoc->maTabs[nSrcPos]->IsLoadingRTL());
 971     }
 972     else                        // bestehende Tabelle ersetzen
 973     {
 974         if (ValidTab(nDestPos) && nDestPos < static_cast<SCTAB>(maTabs.size()) && maTabs[nDestPos])
 975         {
 976             maTabs[nDestPos]->DeleteArea( 0,0, MAXCOL,MAXROW, IDF_ALL );
 977         }
 978         else
 979             bValid = false;
 980     }
 981
 982     if (bValid)
 983     {
 984         bool bOldAutoCalcSrc = false;
 985         bool bOldAutoCalc = GetAutoCalc();
 986         SetAutoCalc( false );   // Mehrfachberechnungen vermeiden
 987         SetNoListening( true );
 988         if ( bResultsOnly )
 989         {
 990             bOldAutoCalcSrc = pSrcDoc->GetAutoCalc();
 991             pSrcDoc->SetAutoCalc( true );   // falls was berechnet werden muss
 992         }
 993
 994         {
 995             NumFmtMergeHandler aNumFmtMergeHdl(this, pSrcDoc);
 996
 997             sc::CopyToDocContext aCxt(*this);
 998             nDestPos = std::min(nDestPos, (SCTAB)(GetTableCount() - 1));
 999             {   // scope for bulk broadcast
1000                 ScBulkBroadcast aBulkBroadcast( pBASM);
1001                 pSrcDoc->maTabs[nSrcPos]->CopyToTable(aCxt, 0, 0, MAXCOL, MAXROW,
1002                         ( bResultsOnly ? IDF_ALL & ~IDF_FORMULA : IDF_ALL),
1003                         false, maTabs[nDestPos] );
1004                 maTabs[nDestPos]->CopyConditionalFormat(0, 0, MAXCOL, MAXROW,
1005                             0, 0, pSrcDoc->maTabs[nSrcPos]);
1006             }
1007         }
1008         maTabs[nDestPos]->SetTabNo(nDestPos);
1009         maTabs[nDestPos]->SetTabBgColor(pSrcDoc->maTabs[nSrcPos]->GetTabBgColor());
1010
1011         if ( !bResultsOnly )
1012         {
1013             sc::RefUpdateContext aRefCxt(*this);
1014             aRefCxt.meMode = URM_COPY;
1015             aRefCxt.maRange = ScRange(0, 0, nDestPos, MAXCOL, MAXROW, nDestPos);
1016             aRefCxt.mnTabDelta = nDestPos - nSrcPos;
1017             maTabs[nDestPos]->UpdateReference(aRefCxt, NULL);
1018
1019             // Readjust self-contained absolute references to this sheet
1020             maTabs[nDestPos]->TestTabRefAbs(nSrcPos);
1021             maTabs[nDestPos]->CompileAll();
1022         }
1023
1024         SetNoListening( false );
1025         if ( !bResultsOnly )
1026             maTabs[nDestPos]->StartAllListeners();
1027         SetDirty( ScRange( 0, 0, nDestPos, MAXCOL, MAXROW, nDestPos));
1028
1029         if ( bResultsOnly )
1030             pSrcDoc->SetAutoCalc( bOldAutoCalcSrc );
1031         SetAutoCalc( bOldAutoCalc );
1032
1033         //  Drawing kopieren
1034
1035         if (bInsertNew)
1036             TransferDrawPage( pSrcDoc, nSrcPos, nDestPos );
1037
1038         maTabs[nDestPos]->SetPendingRowHeights( pSrcDoc->maTabs[nSrcPos]->IsPendingRowHeights() );
1039     }
1040     if (!bValid)
1041         nRetVal = 0;
1042     bool bVbaEnabled = IsInVBAMode();
1043
1044     if ( bVbaEnabled  )
1045     {
1046         SfxObjectShell* pSrcShell = pSrcDoc ? pSrcDoc->GetDocumentShell() : NULL;
1047         if ( pSrcShell )
1048         {
1049             OUString aLibName("Standard");
1050             const BasicManager *pBasicManager = pSrcShell->GetBasicManager();
1051             if (pBasicManager && !pBasicManager->GetName().isEmpty())
1052             {
1053                 aLibName = pSrcShell->GetBasicManager()->GetName();
1054             }
1055             OUString sCodeName;
1056             OUString sSource;
1057             uno::Reference< script::XLibraryContainer > xLibContainer = pSrcShell->GetBasicContainer();
1058             uno::Reference< container::XNameContainer > xLib;
1059             if( xLibContainer.is() )
1060             {
1061                 uno::Any aLibAny = xLibContainer->getByName(aLibName);
1062                 aLibAny >>= xLib;
1063             }
1064
1065             if( xLib.is() )
1066             {
1067                 OUString sSrcCodeName;
1068                 pSrcDoc->GetCodeName( nSrcPos, sSrcCodeName );
1069                 OUString sRTLSource;
1070                 xLib->getByName( sSrcCodeName ) >>= sRTLSource;
1071                 sSource = sRTLSource;
1072             }
1073             VBA_InsertModule( *this, nDestPos, sCodeName, sSource );
1074         }
1075     }
1076
1077     return nRetVal;
1078 }
1079
1080 void ScDocument::SetError( SCCOL nCol, SCROW nRow, SCTAB nTab, const sal_uInt16 nError)
1081 {
1082     if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
1083         if (maTabs[nTab])
1084             maTabs[nTab]->SetError( nCol, nRow, nError );
1085 }
1086
1087 void ScDocument::SetFormula(
1088     const ScAddress& rPos, const ScTokenArray& rArray, formula::FormulaGrammar::Grammar eGram )
1089 {
1090     if (!TableExists(rPos.Tab()))
1091         return;
1092
1093     maTabs[rPos.Tab()]->SetFormula(rPos.Col(), rPos.Row(), rArray, eGram);
1094 }
1095
1096 void ScDocument::SetFormula(
1097     const ScAddress& rPos, const OUString& rFormula, formula::FormulaGrammar::Grammar eGram )
1098 {
1099     if (!TableExists(rPos.Tab()))
1100         return;
1101
1102     maTabs[rPos.Tab()]->SetFormula(rPos.Col(), rPos.Row(), rFormula, eGram);
1103 }
1104
1105 ScFormulaCell* ScDocument::SetFormulaCell( const ScAddress& rPos, ScFormulaCell* pCell )
1106 {
1107     if (!TableExists(rPos.Tab()))
1108     {
1109         delete pCell;
1110         return NULL;
1111     }
1112
1113     return maTabs[rPos.Tab()]->SetFormulaCell(rPos.Col(), rPos.Row(), pCell);
1114 }
1115
1116 void ScDocument::SetConsolidateDlgData( const ScConsolidateParam* pData )
1117 {
1118     delete pConsolidateDlgData;
1119
1120     if ( pData )
1121         pConsolidateDlgData = new ScConsolidateParam( *pData );
1122     else
1123         pConsolidateDlgData = NULL;
1124 }
1125
1126 void ScDocument::SetChangeViewSettings(const ScChangeViewSettings& rNew)
1127 {
1128     if (pChangeViewSettings==NULL)
1129         pChangeViewSettings = new ScChangeViewSettings;
1130
1131     OSL_ENSURE( pChangeViewSettings, "Oops. No ChangeViewSettings :-( by!" );
1132
1133     *pChangeViewSettings=rNew;
1134 }
1135
1136 //  ----------------------------------------------------------------------------
1137
1138 ScFieldEditEngine* ScDocument::CreateFieldEditEngine()
1139 {
1140     ScFieldEditEngine* pNewEditEngine = NULL;
1141     if (!pCacheFieldEditEngine)
1142     {
1143         pNewEditEngine = new ScFieldEditEngine(
1144             this, GetEnginePool(), GetEditPool(), false);
1145     }
1146     else
1147     {
1148         if ( !bImportingXML )
1149         {
1150             // #i66209# previous use might not have restored update mode,
1151             // ensure same state as for a new EditEngine (UpdateMode = true)
1152             if ( !pCacheFieldEditEngine->GetUpdateMode() )
1153                 pCacheFieldEditEngine->SetUpdateMode(true);
1154         }
1155
1156         pNewEditEngine = pCacheFieldEditEngine;
1157         pCacheFieldEditEngine = NULL;
1158     }
1159     return pNewEditEngine;
1160 }
1161
1162 void ScDocument::DisposeFieldEditEngine(ScFieldEditEngine*& rpEditEngine)
1163 {
1164     if (!pCacheFieldEditEngine && rpEditEngine)
1165     {
1166         pCacheFieldEditEngine = rpEditEngine;
1167         pCacheFieldEditEngine->Clear();
1168     }
1169     else
1170         delete rpEditEngine;
1171     rpEditEngine = NULL;
1172 }
1173
1174 //  ----------------------------------------------------------------------------
1175
1176 ScRecursionHelper* ScDocument::CreateRecursionHelperInstance()
1177 {
1178     return new ScRecursionHelper;
1179 }
1180
1181 //  ----------------------------------------------------------------------------
1182
1183 ScLookupCache & ScDocument::GetLookupCache( const ScRange & rRange )
1184 {
1185     ScLookupCache* pCache = 0;
1186     if (!pLookupCacheMapImpl)
1187         pLookupCacheMapImpl = new ScLookupCacheMapImpl;
1188     ScLookupCacheMap::iterator it( pLookupCacheMapImpl->aCacheMap.find( rRange));
1189     if (it == pLookupCacheMapImpl->aCacheMap.end())
1190     {
1191         pCache = new ScLookupCache( this, rRange);
1192         AddLookupCache( *pCache);
1193     }
1194     else
1195         pCache = (*it).second;
1196     return *pCache;
1197 }
1198
1199 void ScDocument::AddLookupCache( ScLookupCache & rCache )
1200 {
1201     if (!pLookupCacheMapImpl->aCacheMap.insert( ::std::pair< const ScRange,
1202                 ScLookupCache*>( rCache.getRange(), &rCache)).second)
1203     {
1204         OSL_FAIL( "ScDocument::AddLookupCache: couldn't add to hash map");
1205     }
1206     else
1207         StartListeningArea( rCache.getRange(), &rCache);
1208 }
1209
1210 void ScDocument::RemoveLookupCache( ScLookupCache & rCache )
1211 {
1212     ScLookupCacheMap::iterator it( pLookupCacheMapImpl->aCacheMap.find(
1213                 rCache.getRange()));
1214     if (it == pLookupCacheMapImpl->aCacheMap.end())
1215     {
1216         OSL_FAIL( "ScDocument::RemoveLookupCache: range not found in hash map");
1217     }
1218     else
1219     {
1220         ScLookupCache* pCache = (*it).second;
1221         pLookupCacheMapImpl->aCacheMap.erase( it);
1222         EndListeningArea( pCache->getRange(), &rCache);
1223     }
1224 }
1225
1226 void ScDocument::ClearLookupCaches()
1227 {
1228     if( pLookupCacheMapImpl )
1229         pLookupCacheMapImpl->clear();
1230 }
1231
1232 void ScDocument::SetPreviewFont( SfxItemSet* pFont )
1233 {
1234     delete pPreviewFont;
1235     pPreviewFont = pFont;
1236 }
1237
1238 const ScMarkData ScDocument::GetPreviewSelection()
1239 {
1240     return maPreviewSelection;
1241 }
1242
1243 void  ScDocument::SetPreviewSelection( ScMarkData& rSel )
1244 {
1245     maPreviewSelection = rSel;
1246 }
1247
1248 SfxItemSet* ScDocument::GetPreviewFont( SCCOL nCol, SCROW nRow, SCTAB nTab )
1249 {
1250     SfxItemSet* pRet = NULL;
1251     if ( pPreviewFont )
1252     {
1253         ScMarkData aSel = GetPreviewSelection();
1254         if ( aSel.IsCellMarked( nCol, nRow ) && aSel.GetFirstSelected() == nTab )
1255             pRet = pPreviewFont;
1256     }
1257     return pRet;
1258 }
1259
1260 ScStyleSheet* ScDocument::GetPreviewCellStyle( SCCOL nCol, SCROW nRow, SCTAB nTab )
1261 {
1262     ScStyleSheet* pRet = NULL;
1263     ScMarkData aSel = GetPreviewSelection();
1264     if ( pPreviewCellStyle && aSel.IsCellMarked( nCol, nRow ) && aSel.GetFirstSelected() == nTab  )
1265         pRet = pPreviewCellStyle;
1266     return pRet;
1267 }
1268 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */