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