LCOV - code coverage report
Current view: top level - sc/source/core/data - documen2.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 704 0.0 %
Date: 2014-04-14 Functions: 0 62 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10