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