LCOV - code coverage report
Current view: top level - sc/source/ui/docshell - docsh5.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 190 518 36.7 %
Date: 2015-06-13 12:38:46 Functions: 12 22 54.5 %
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 <sal/config.h>
      21             : 
      22             : #include <cassert>
      23             : 
      24             : #include "scitems.hxx"
      25             : #include <vcl/msgbox.hxx>
      26             : #include <vcl/waitobj.hxx>
      27             : #include <sfx2/app.hxx>
      28             : #include <sfx2/bindings.hxx>
      29             : 
      30             : #include <com/sun/star/script/vba/XVBACompatibility.hpp>
      31             : 
      32             : #include "docsh.hxx"
      33             : #include "global.hxx"
      34             : #include "globstr.hrc"
      35             : #include "globalnames.hxx"
      36             : #include "undodat.hxx"
      37             : #include "undotab.hxx"
      38             : #include "undoblk.hxx"
      39             : #include "dpobject.hxx"
      40             : #include "dpshttab.hxx"
      41             : #include "dbdocfun.hxx"
      42             : #include "consoli.hxx"
      43             : #include "dbdata.hxx"
      44             : #include "progress.hxx"
      45             : #include "olinetab.hxx"
      46             : #include "patattr.hxx"
      47             : #include "attrib.hxx"
      48             : #include "docpool.hxx"
      49             : #include "uiitems.hxx"
      50             : #include "sc.hrc"
      51             : #include "waitoff.hxx"
      52             : #include "sizedev.hxx"
      53             : #include "clipparam.hxx"
      54             : #include <rowheightcontext.hxx>
      55             : #include <refupdatecontext.hxx>
      56             : 
      57             : using com::sun::star::script::XLibraryContainer;
      58             : using com::sun::star::script::vba::XVBACompatibility;
      59             : using com::sun::star::container::XNameContainer;
      60             : using com::sun::star::uno::Reference;
      61             : using com::sun::star::uno::UNO_QUERY;
      62             : 
      63             : using ::std::unique_ptr;
      64             : using ::std::vector;
      65             : 
      66             : //  former viewfunc/dbfunc methods
      67             : 
      68           0 : void ScDocShell::ErrorMessage( sal_uInt16 nGlobStrId )
      69             : {
      70             :     //! StopMarking an der (aktiven) View?
      71             : 
      72           0 :     vcl::Window* pParent = GetActiveDialogParent();
      73           0 :     ScWaitCursorOff aWaitOff( pParent );
      74           0 :     bool bFocus = pParent && pParent->HasFocus();
      75             : 
      76           0 :     if(nGlobStrId==STR_PROTECTIONERR)
      77             :     {
      78           0 :         if(IsReadOnly())
      79             :         {
      80           0 :             nGlobStrId=STR_READONLYERR;
      81             :         }
      82             :     }
      83             : 
      84           0 :     ScopedVclPtrInstance< InfoBox > aBox( pParent, ScGlobal::GetRscString( nGlobStrId ) );
      85           0 :     aBox->Execute();
      86           0 :     if (bFocus)
      87           0 :         pParent->GrabFocus();
      88           0 : }
      89             : 
      90        2748 : bool ScDocShell::IsEditable() const
      91             : {
      92             :     // import into read-only document is possible - must be extended if other filters use api
      93             :     // #i108547# MSOOXML filter uses "IsChangeReadOnlyEnabled" property
      94             : 
      95        2748 :     return !IsReadOnly() || aDocument.IsImportingXML() || aDocument.IsChangeReadOnlyEnabled();
      96             : }
      97             : 
      98           2 : void ScDocShell::DBAreaDeleted( SCTAB nTab, SCCOL nX1, SCROW nY1, SCCOL nX2, SCROW /* nY2 */ )
      99             : {
     100           2 :     ScDocShellModificator aModificator( *this );
     101           2 :     aDocument.RemoveFlagsTab( nX1, nY1, nX2, nY1, nTab, SC_MF_AUTO );
     102           2 :     PostPaint( nX1, nY1, nTab, nX2, nY1, nTab, PAINT_GRID );
     103             :     // No SetDocumentModified, as the unnamed database range might have to be restored later.
     104             :     // The UNO hint is broadcast directly instead, to keep UNO objects in valid state.
     105           2 :     aDocument.BroadcastUno( SfxSimpleHint( SFX_HINT_DATACHANGED ) );
     106           2 : }
     107             : 
     108          20 : ScDBData* ScDocShell::GetDBData( const ScRange& rMarked, ScGetDBMode eMode, ScGetDBSelection eSel )
     109             : {
     110          20 :     SCCOL nCol = rMarked.aStart.Col();
     111          20 :     SCROW nRow = rMarked.aStart.Row();
     112          20 :     SCTAB nTab = rMarked.aStart.Tab();
     113             : 
     114          20 :     SCCOL nStartCol = nCol;
     115          20 :     SCROW nStartRow = nRow;
     116          20 :     SCTAB nStartTab = nTab;
     117          20 :     SCCOL nEndCol = rMarked.aEnd.Col();
     118          20 :     SCROW nEndRow = rMarked.aEnd.Row();
     119          20 :     SCTAB nEndTab = rMarked.aEnd.Tab();
     120             :     //  Nicht einfach GetDBAtCursor: Der zusammenhaengende Datenbereich
     121             :     //  fuer "unbenannt" (GetDataArea) kann neben dem Cursor legen, also muss auch ein
     122             :     //  benannter DB-Bereich dort gesucht werden.
     123          20 :     ScDBCollection* pColl = aDocument.GetDBCollection();
     124          20 :     ScDBData* pData = aDocument.GetDBAtArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow );
     125          20 :     if (!pData)
     126          13 :         pData = pColl->GetDBNearCursor(nCol, nRow, nTab );
     127             : 
     128          40 :     bool bSelected = ( eSel == SC_DBSEL_FORCE_MARK ||
     129          20 :             (rMarked.aStart != rMarked.aEnd && eSel != SC_DBSEL_ROW_DOWN) );
     130          20 :     bool bOnlyDown = (!bSelected && eSel == SC_DBSEL_ROW_DOWN && rMarked.aStart.Row() == rMarked.aEnd.Row());
     131             : 
     132          20 :     bool bUseThis = false;
     133          20 :     if (pData)
     134             :     {
     135             :         //      Bereich nehmen, wenn nichts anderes markiert
     136             : 
     137             :         SCTAB nDummy;
     138             :         SCCOL nOldCol1;
     139             :         SCROW nOldRow1;
     140             :         SCCOL nOldCol2;
     141             :         SCROW nOldRow2;
     142          10 :         pData->GetArea( nDummy, nOldCol1,nOldRow1, nOldCol2,nOldRow2 );
     143          10 :         bool bIsNoName = ( pData->GetName() == STR_DB_LOCAL_NONAME );
     144             : 
     145          10 :         if (!bSelected)
     146             :         {
     147           0 :             bUseThis = true;
     148           0 :             if ( bIsNoName && eMode == SC_DB_MAKE )
     149             :             {
     150             :                 // If nothing marked or only one row marked, adapt
     151             :                 // "unbenannt"/"unnamed" to contiguous area.
     152           0 :                 nStartCol = nCol;
     153           0 :                 nStartRow = nRow;
     154           0 :                 if (bOnlyDown)
     155             :                 {
     156           0 :                     nEndCol = rMarked.aEnd.Col();
     157           0 :                     nEndRow = rMarked.aEnd.Row();
     158             :                 }
     159             :                 else
     160             :                 {
     161           0 :                     nEndCol = nStartCol;
     162           0 :                     nEndRow = nStartRow;
     163             :                 }
     164           0 :                 aDocument.GetDataArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow, false, bOnlyDown );
     165           0 :                 if ( nOldCol1 != nStartCol || nOldCol2 != nEndCol || nOldRow1 != nStartRow )
     166           0 :                     bUseThis = false;               // passt gar nicht
     167           0 :                 else if ( nOldRow2 != nEndRow )
     168             :                 {
     169             :                     //  Bereich auf neue End-Zeile erweitern
     170           0 :                     pData->SetArea( nTab, nOldCol1,nOldRow1, nOldCol2,nEndRow );
     171             :                 }
     172             :             }
     173             :         }
     174             :         else
     175             :         {
     176          20 :             if ( nOldCol1 == nStartCol && nOldRow1 == nStartRow &&
     177          19 :                  nOldCol2 == nEndCol && nOldRow2 == nEndRow )               // genau markiert?
     178           7 :                 bUseThis = true;
     179             :             else
     180           3 :                 bUseThis = false;           // immer Markierung nehmen (Bug 11964)
     181             :         }
     182             : 
     183             :         //      fuer Import nie "unbenannt" nehmen
     184             : 
     185          10 :         if ( bUseThis && eMode == SC_DB_IMPORT && bIsNoName )
     186           0 :             bUseThis = false;
     187             :     }
     188             : 
     189          20 :     if ( bUseThis )
     190             :     {
     191           7 :         pData->GetArea( nStartTab, nStartCol,nStartRow, nEndCol,nEndRow );
     192           7 :         nEndTab = nStartTab;
     193             :     }
     194          13 :     else if ( eMode == SC_DB_OLD )
     195             :     {
     196           5 :         pData = NULL;                           // nichts gefunden
     197           5 :         nStartCol = nEndCol = nCol;
     198           5 :         nStartRow = nEndRow = nRow;
     199           5 :         nStartTab = nEndTab = nTab;
     200             :     }
     201             :     else
     202             :     {
     203           8 :         if ( !bSelected )
     204             :         {                                       // zusammenhaengender Bereich
     205           0 :             nStartCol = nCol;
     206           0 :             nStartRow = nRow;
     207           0 :             if (bOnlyDown)
     208             :             {
     209           0 :                 nEndCol = rMarked.aEnd.Col();
     210           0 :                 nEndRow = rMarked.aEnd.Row();
     211             :             }
     212             :             else
     213             :             {
     214           0 :                 nEndCol = nStartCol;
     215           0 :                 nEndRow = nStartRow;
     216             :             }
     217           0 :             aDocument.GetDataArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow, false, bOnlyDown );
     218             :         }
     219             : 
     220           8 :         bool bHasHeader = aDocument.HasColHeader( nStartCol,nStartRow, nEndCol,nEndRow, nTab );
     221             : 
     222           8 :         ScDBData* pNoNameData = aDocument.GetAnonymousDBData(nTab);
     223           8 :         if ( eMode != SC_DB_IMPORT && pNoNameData)
     224             :         {
     225             : 
     226           2 :             if ( !pOldAutoDBRange )
     227             :             {
     228             :                 // store the old unnamed database range with its settings for undo
     229             :                 // (store at the first change, get the state before all changes)
     230           2 :                 pOldAutoDBRange = new ScDBData( *pNoNameData );
     231             :             }
     232             : 
     233             :             SCCOL nOldX1;                                   // alten Bereich sauber wegnehmen
     234             :             SCROW nOldY1;                                   //! (UNDO ???)
     235             :             SCCOL nOldX2;
     236             :             SCROW nOldY2;
     237             :             SCTAB nOldTab;
     238           2 :             pNoNameData->GetArea( nOldTab, nOldX1, nOldY1, nOldX2, nOldY2 );
     239           2 :             DBAreaDeleted( nOldTab, nOldX1, nOldY1, nOldX2, nOldY2 );
     240             : 
     241           2 :             pNoNameData->SetSortParam( ScSortParam() );             // Parameter zuruecksetzen
     242           2 :             pNoNameData->SetQueryParam( ScQueryParam() );
     243           2 :             pNoNameData->SetSubTotalParam( ScSubTotalParam() );
     244             : 
     245           2 :             pNoNameData->SetArea( nTab, nStartCol,nStartRow, nEndCol,nEndRow );     // neu setzen
     246           2 :             pNoNameData->SetByRow( true );
     247           2 :             pNoNameData->SetHeader( bHasHeader );
     248           2 :             pNoNameData->SetAutoFilter( false );
     249             :         }
     250             :         else
     251             :         {
     252           6 :             ScDBCollection* pUndoColl = NULL;
     253             : 
     254           6 :             OUString aNewName;
     255           6 :             if (eMode==SC_DB_IMPORT)
     256             :             {
     257           0 :                 aDocument.PreprocessDBDataUpdate();
     258           0 :                 pUndoColl = new ScDBCollection( *pColl );   // Undo fuer Import1-Bereich
     259             : 
     260           0 :                 OUString aImport = ScGlobal::GetRscString( STR_DBNAME_IMPORT );
     261           0 :                 long nCount = 0;
     262           0 :                 const ScDBData* pDummy = NULL;
     263           0 :                 ScDBCollection::NamedDBs& rDBs = pColl->getNamedDBs();
     264           0 :                 do
     265             :                 {
     266           0 :                     ++nCount;
     267           0 :                     aNewName = aImport;
     268           0 :                     aNewName += OUString::number( nCount );
     269           0 :                     pDummy = rDBs.findByUpperName(ScGlobal::pCharClass->uppercase(aNewName));
     270             :                 }
     271             :                 while (pDummy);
     272             :                 pNoNameData = new ScDBData( aNewName, nTab,
     273             :                                 nStartCol,nStartRow, nEndCol,nEndRow,
     274           0 :                                 true, bHasHeader );
     275           0 :                 bool ins = rDBs.insert(pNoNameData);
     276           0 :                 assert(ins); (void)ins;
     277             :             }
     278             :             else
     279             :             {
     280           6 :                 aNewName = STR_DB_LOCAL_NONAME;
     281             :                 pNoNameData = new ScDBData(aNewName , nTab,
     282             :                                 nStartCol,nStartRow, nEndCol,nEndRow,
     283           6 :                                 true, bHasHeader );
     284           6 :                 aDocument.SetAnonymousDBData(nTab, pNoNameData);
     285             :             }
     286             : 
     287           6 :             if ( pUndoColl )
     288             :             {
     289           0 :                 aDocument.CompileHybridFormula();
     290             : 
     291           0 :                 ScDBCollection* pRedoColl = new ScDBCollection( *pColl );
     292           0 :                 GetUndoManager()->AddUndoAction( new ScUndoDBData( this, pUndoColl, pRedoColl ) );
     293             :             }
     294             : 
     295             :             //  neuen Bereich am Sba anmelden nicht mehr noetig
     296             : 
     297             :             //  "Import1" etc am Navigator bekanntmachen
     298           6 :             if (eMode==SC_DB_IMPORT)
     299           0 :                 SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) );
     300             :         }
     301           8 :         pData = pNoNameData;
     302             :     }
     303             : 
     304          20 :     return pData;
     305             : }
     306             : 
     307           0 : ScDBData* ScDocShell::GetAnonymousDBData(const ScRange& rRange)
     308             : {
     309             :     bool bHasHeader = aDocument.HasColHeader(
     310           0 :         rRange.aStart.Col(), rRange.aStart.Row(), rRange.aEnd.Col(), rRange.aEnd.Row(), rRange.aStart.Tab());
     311             : 
     312           0 :     ScDBCollection* pColl = aDocument.GetDBCollection();
     313           0 :     if (!pColl)
     314           0 :         return NULL;
     315             : 
     316           0 :     ScDBData* pData = pColl->getAnonDBs().getByRange(rRange);
     317           0 :     if (!pData)
     318           0 :         return NULL;
     319             : 
     320           0 :     pData->SetHeader(bHasHeader);
     321           0 :     return pData;
     322             : }
     323             : 
     324           6 : ScDBData* ScDocShell::GetOldAutoDBRange()
     325             : {
     326           6 :     ScDBData* pRet = pOldAutoDBRange;
     327           6 :     pOldAutoDBRange = NULL;
     328           6 :     return pRet;                    // has to be deleted by caller!
     329             : }
     330             : 
     331           0 : void ScDocShell::CancelAutoDBRange()
     332             : {
     333             :     // called when dialog is cancelled
     334             : //moggi:TODO
     335           0 :     if ( pOldAutoDBRange )
     336             :     {
     337           0 :         SCTAB nTab = GetCurTab();
     338           0 :         ScDBData* pDBData = aDocument.GetAnonymousDBData(nTab);
     339           0 :         if ( pDBData )
     340             :         {
     341             :             SCCOL nRangeX1;
     342             :             SCROW nRangeY1;
     343             :             SCCOL nRangeX2;
     344             :             SCROW nRangeY2;
     345             :             SCTAB nRangeTab;
     346           0 :             pDBData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
     347           0 :             DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
     348             : 
     349           0 :             *pDBData = *pOldAutoDBRange;    // restore old settings
     350             : 
     351           0 :             if ( pOldAutoDBRange->HasAutoFilter() )
     352             :             {
     353             :                 // restore AutoFilter buttons
     354           0 :                 pOldAutoDBRange->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
     355           0 :                 aDocument.ApplyFlagsTab( nRangeX1, nRangeY1, nRangeX2, nRangeY1, nRangeTab, SC_MF_AUTO );
     356           0 :                 PostPaint( nRangeX1, nRangeY1, nRangeTab, nRangeX2, nRangeY1, nRangeTab, PAINT_GRID );
     357             :             }
     358             :         }
     359             : 
     360           0 :         delete pOldAutoDBRange;
     361           0 :         pOldAutoDBRange = NULL;
     362             :     }
     363           0 : }
     364             : 
     365             :         //  Hoehen anpassen
     366             :         //! mit docfunc zusammenfassen
     367             : 
     368          57 : bool ScDocShell::AdjustRowHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab )
     369             : {
     370          57 :     ScSizeDeviceProvider aProv(this);
     371         114 :     Fraction aZoom(1,1);
     372         114 :     sc::RowHeightContext aCxt(aProv.GetPPTX(), aProv.GetPPTY(), aZoom, aZoom, aProv.GetDevice());
     373          57 :     bool bChange = aDocument.SetOptimalHeight(aCxt, nStartRow,nEndRow, nTab);
     374             : 
     375          57 :     if (bChange)
     376          12 :         PostPaint( 0,nStartRow,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID|PAINT_LEFT );
     377             : 
     378         114 :     return bChange;
     379             : }
     380             : 
     381           5 : void ScDocShell::UpdateAllRowHeights( const ScMarkData* pTabMark )
     382             : {
     383             :     // update automatic row heights
     384             : 
     385           5 :     ScSizeDeviceProvider aProv(this);
     386          10 :     Fraction aZoom(1,1);
     387          10 :     sc::RowHeightContext aCxt(aProv.GetPPTX(), aProv.GetPPTY(), aZoom, aZoom, aProv.GetDevice());
     388          10 :     aDocument.UpdateAllRowHeights(aCxt, pTabMark);
     389           5 : }
     390             : 
     391       10438 : void ScDocShell::UpdatePendingRowHeights( SCTAB nUpdateTab, bool bBefore )
     392             : {
     393       10438 :     bool bIsUndoEnabled = aDocument.IsUndoEnabled();
     394       10438 :     aDocument.EnableUndo( false );
     395       10438 :     aDocument.LockStreamValid( true );      // ignore draw page size (but not formula results)
     396       10438 :     if ( bBefore )          // check all sheets up to nUpdateTab
     397             :     {
     398          16 :         SCTAB nTabCount = aDocument.GetTableCount();
     399          16 :         if ( nUpdateTab >= nTabCount )
     400           0 :             nUpdateTab = nTabCount-1;     // nUpdateTab is inclusive
     401             : 
     402          16 :         ScMarkData aUpdateSheets;
     403             :         SCTAB nTab;
     404          32 :         for (nTab=0; nTab<=nUpdateTab; ++nTab)
     405          16 :             if ( aDocument.IsPendingRowHeights( nTab ) )
     406           0 :                 aUpdateSheets.SelectTable( nTab, true );
     407             : 
     408          16 :         if (aUpdateSheets.GetSelectCount())
     409           0 :             UpdateAllRowHeights(&aUpdateSheets);        // update with a single progress bar
     410             : 
     411          32 :         for (nTab=0; nTab<=nUpdateTab; ++nTab)
     412          16 :             if ( aUpdateSheets.GetTableSelect( nTab ) )
     413             :             {
     414           0 :                 aDocument.UpdatePageBreaks( nTab );
     415           0 :                 aDocument.SetPendingRowHeights( nTab, false );
     416          16 :             }
     417             :     }
     418             :     else                    // only nUpdateTab
     419             :     {
     420       10422 :         if ( aDocument.IsPendingRowHeights( nUpdateTab ) )
     421             :         {
     422           0 :             AdjustRowHeight( 0, MAXROW, nUpdateTab );
     423           0 :             aDocument.UpdatePageBreaks( nUpdateTab );
     424           0 :             aDocument.SetPendingRowHeights( nUpdateTab, false );
     425             :         }
     426             :     }
     427       10438 :     aDocument.LockStreamValid( false );
     428       10438 :     aDocument.EnableUndo( bIsUndoEnabled );
     429       10438 : }
     430             : 
     431           0 : void ScDocShell::RefreshPivotTables( const ScRange& rSource )
     432             : {
     433           0 :     ScDPCollection* pColl = aDocument.GetDPCollection();
     434           0 :     if (!pColl)
     435           0 :         return;
     436             : 
     437           0 :     ScDBDocFunc aFunc(*this);
     438           0 :     for (size_t i = 0, n = pColl->GetCount(); i < n; ++i)
     439             :     {
     440           0 :         ScDPObject* pOld = (*pColl)[i];
     441           0 :         if (!pOld)
     442           0 :             continue;
     443             : 
     444           0 :         const ScSheetSourceDesc* pSheetDesc = pOld->GetSheetDesc();
     445           0 :         if (pSheetDesc && pSheetDesc->GetSourceRange().Intersects(rSource))
     446           0 :             aFunc.UpdatePivotTable(*pOld, true, false);
     447           0 :     }
     448             : }
     449             : 
     450           0 : static OUString lcl_GetAreaName( ScDocument* pDoc, ScArea* pArea )
     451             : {
     452           0 :     OUString aName;
     453           0 :     bool bOk = false;
     454             :     ScDBData* pData = pDoc->GetDBAtArea( pArea->nTab, pArea->nColStart, pArea->nRowStart,
     455           0 :                                                         pArea->nColEnd, pArea->nRowEnd );
     456           0 :     if (pData)
     457             :     {
     458           0 :         aName = pData->GetName();
     459           0 :         bOk = true;
     460             :     }
     461             : 
     462           0 :     if (!bOk)
     463           0 :         pDoc->GetName( pArea->nTab, aName );
     464             : 
     465           0 :     return aName;
     466             : }
     467             : 
     468           1 : void ScDocShell::DoConsolidate( const ScConsolidateParam& rParam, bool bRecord )
     469             : {
     470           1 :     ScConsData aData;
     471             : 
     472             :     sal_uInt16 nPos;
     473           1 :     SCCOL nColSize = 0;
     474           1 :     SCROW nRowSize = 0;
     475           1 :     bool bErr = false;
     476           1 :     for (nPos=0; nPos<rParam.nDataAreaCount; nPos++)
     477             :     {
     478           0 :         ScArea* pArea = rParam.ppDataAreas[nPos];
     479           0 :         nColSize = std::max( nColSize, SCCOL( pArea->nColEnd - pArea->nColStart + 1 ) );
     480           0 :         nRowSize = std::max( nRowSize, SCROW( pArea->nRowEnd - pArea->nRowStart + 1 ) );
     481             : 
     482             :                                         // Test, ob Quelldaten verschoben wuerden
     483           0 :         if (rParam.bReferenceData)
     484           0 :             if (pArea->nTab == rParam.nTab && pArea->nRowEnd >= rParam.nRow)
     485           0 :                 bErr = true;
     486             :     }
     487             : 
     488           1 :     if (bErr)
     489             :     {
     490           0 :         ScopedVclPtrInstance<InfoBox> aBox( GetActiveDialogParent(),
     491           0 :                 ScGlobal::GetRscString( STR_CONSOLIDATE_ERR1 ) );
     492           0 :         aBox->Execute();
     493           1 :         return;
     494             :     }
     495             : 
     496             :     //      ausfuehren
     497             : 
     498           2 :     WaitObject aWait( GetActiveDialogParent() );
     499           2 :     ScDocShellModificator aModificator( *this );
     500             : 
     501           1 :     ScRange aOldDest;
     502           1 :     ScDBData* pDestData = aDocument.GetDBAtCursor( rParam.nCol, rParam.nRow, rParam.nTab, true );
     503           1 :     if (pDestData)
     504           0 :         pDestData->GetArea(aOldDest);
     505             : 
     506           1 :     aData.SetSize( nColSize, nRowSize );
     507           1 :     aData.SetFlags( rParam.eFunction, rParam.bByCol, rParam.bByRow, rParam.bReferenceData );
     508           1 :     if ( rParam.bByCol || rParam.bByRow )
     509           0 :         for (nPos=0; nPos<rParam.nDataAreaCount; nPos++)
     510             :         {
     511           0 :             ScArea* pArea = rParam.ppDataAreas[nPos];
     512             :             aData.AddFields( &aDocument, pArea->nTab, pArea->nColStart, pArea->nRowStart,
     513           0 :                                                         pArea->nColEnd, pArea->nRowEnd );
     514             :         }
     515           1 :     aData.DoneFields();
     516           1 :     for (nPos=0; nPos<rParam.nDataAreaCount; nPos++)
     517             :     {
     518           0 :         ScArea* pArea = rParam.ppDataAreas[nPos];
     519             :         aData.AddData( &aDocument, pArea->nTab, pArea->nColStart, pArea->nRowStart,
     520           0 :                                                     pArea->nColEnd, pArea->nRowEnd );
     521           0 :         aData.AddName( lcl_GetAreaName(&aDocument,pArea) );
     522             :     }
     523             : 
     524           1 :     aData.GetSize( nColSize, nRowSize );
     525           1 :     if (bRecord && nColSize > 0 && nRowSize > 0)
     526             :     {
     527           0 :         ScDBData* pUndoData = pDestData ? new ScDBData(*pDestData) : NULL;
     528             : 
     529           0 :         SCTAB nDestTab = rParam.nTab;
     530             :         ScArea aDestArea( rParam.nTab, rParam.nCol, rParam.nRow,
     531           0 :                             rParam.nCol+nColSize-1, rParam.nRow+nRowSize-1 );
     532           0 :         if (rParam.bByCol) ++aDestArea.nColEnd;
     533           0 :         if (rParam.bByRow) ++aDestArea.nRowEnd;
     534             : 
     535           0 :         if (rParam.bReferenceData)
     536             :         {
     537           0 :             SCTAB nTabCount = aDocument.GetTableCount();
     538           0 :             SCROW nInsertCount = aData.GetInsertCount();
     539             : 
     540             :             // alte Outlines
     541           0 :             ScOutlineTable* pTable = aDocument.GetOutlineTable( nDestTab );
     542           0 :             ScOutlineTable* pUndoTab = pTable ? new ScOutlineTable( *pTable ) : NULL;
     543             : 
     544           0 :             ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
     545           0 :             pUndoDoc->InitUndo( &aDocument, 0, nTabCount-1, false, true );
     546             : 
     547             :             // Zeilenstatus
     548             :             aDocument.CopyToDocument( 0,0,nDestTab, MAXCOL,MAXROW,nDestTab,
     549           0 :                                     IDF_NONE, false, pUndoDoc );
     550             : 
     551             :             // alle Formeln
     552             :             aDocument.CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTabCount-1,
     553           0 :                                         IDF_FORMULA, false, pUndoDoc );
     554             : 
     555             :             // komplette Ausgangszeilen
     556             :             aDocument.CopyToDocument( 0,aDestArea.nRowStart,nDestTab,
     557             :                                     MAXCOL,aDestArea.nRowEnd,nDestTab,
     558           0 :                                     IDF_ALL, false, pUndoDoc );
     559             : 
     560             :             // alten Ausgabebereich
     561           0 :             if (pDestData)
     562           0 :                 aDocument.CopyToDocument( aOldDest, IDF_ALL, false, pUndoDoc );
     563             : 
     564           0 :             GetUndoManager()->AddUndoAction(
     565             :                     new ScUndoConsolidate( this, aDestArea, rParam, pUndoDoc,
     566           0 :                                             true, nInsertCount, pUndoTab, pUndoData ) );
     567             :         }
     568             :         else
     569             :         {
     570           0 :             ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
     571           0 :             pUndoDoc->InitUndo( &aDocument, aDestArea.nTab, aDestArea.nTab );
     572             : 
     573             :             aDocument.CopyToDocument( aDestArea.nColStart, aDestArea.nRowStart, aDestArea.nTab,
     574             :                                     aDestArea.nColEnd, aDestArea.nRowEnd, aDestArea.nTab,
     575           0 :                                     IDF_ALL, false, pUndoDoc );
     576             : 
     577             :             // alten Ausgabebereich
     578           0 :             if (pDestData)
     579           0 :                 aDocument.CopyToDocument( aOldDest, IDF_ALL, false, pUndoDoc );
     580             : 
     581           0 :             GetUndoManager()->AddUndoAction(
     582             :                     new ScUndoConsolidate( this, aDestArea, rParam, pUndoDoc,
     583           0 :                                             false, 0, NULL, pUndoData ) );
     584             :         }
     585             :     }
     586             : 
     587           1 :     if (pDestData)                                      // Zielbereich loeschen / anpassen
     588             :     {
     589           0 :         aDocument.DeleteAreaTab(aOldDest, IDF_CONTENTS);
     590             :         pDestData->SetArea( rParam.nTab, rParam.nCol, rParam.nRow,
     591           0 :                             rParam.nCol + nColSize - 1, rParam.nRow + nRowSize - 1 );
     592           0 :         pDestData->SetHeader( rParam.bByRow );
     593             :     }
     594             : 
     595           1 :     aData.OutputToDocument( &aDocument, rParam.nCol, rParam.nRow, rParam.nTab );
     596             : 
     597           1 :     SCCOL nPaintStartCol = rParam.nCol;
     598           1 :     SCROW nPaintStartRow = rParam.nRow;
     599           1 :     SCCOL nPaintEndCol = nPaintStartCol + nColSize - 1;
     600           1 :     SCROW nPaintEndRow = nPaintStartRow + nRowSize - 1;
     601           1 :     sal_uInt16 nPaintFlags = PAINT_GRID;
     602           1 :     if (rParam.bByCol)
     603           0 :         ++nPaintEndRow;
     604           1 :     if (rParam.bByRow)
     605           0 :         ++nPaintEndCol;
     606           1 :     if (rParam.bReferenceData)
     607             :     {
     608           0 :         nPaintStartCol = 0;
     609           0 :         nPaintEndCol = MAXCOL;
     610           0 :         nPaintEndRow = MAXROW;
     611           0 :         nPaintFlags |= PAINT_LEFT | PAINT_SIZE;
     612             :     }
     613           1 :     if (pDestData)
     614             :     {
     615           0 :         if ( aOldDest.aEnd.Col() > nPaintEndCol )
     616           0 :             nPaintEndCol = aOldDest.aEnd.Col();
     617           0 :         if ( aOldDest.aEnd.Row() > nPaintEndRow )
     618           0 :             nPaintEndRow = aOldDest.aEnd.Row();
     619             :     }
     620             :     PostPaint( nPaintStartCol, nPaintStartRow, rParam.nTab,
     621           1 :                 nPaintEndCol, nPaintEndRow, rParam.nTab, nPaintFlags );
     622           2 :     aModificator.SetDocumentModified();
     623             : }
     624             : 
     625           0 : void ScDocShell::UseScenario( SCTAB nTab, const OUString& rName, bool bRecord )
     626             : {
     627           0 :     if (!aDocument.IsScenario(nTab))
     628             :     {
     629           0 :         SCTAB   nTabCount = aDocument.GetTableCount();
     630           0 :         SCTAB   nSrcTab = SCTAB_MAX;
     631           0 :         SCTAB   nEndTab = nTab;
     632           0 :         OUString aCompare;
     633           0 :         while ( nEndTab+1 < nTabCount && aDocument.IsScenario(nEndTab+1) )
     634             :         {
     635           0 :             ++nEndTab;
     636           0 :             if (nSrcTab > MAXTAB)           // noch auf der Suche nach dem Szenario?
     637             :             {
     638           0 :                 aDocument.GetName( nEndTab, aCompare );
     639           0 :                 if (aCompare.equals(rName))
     640           0 :                     nSrcTab = nEndTab;      // gefunden
     641             :             }
     642             :         }
     643           0 :         if (ValidTab(nSrcTab))
     644             :         {
     645           0 :             if ( aDocument.TestCopyScenario( nSrcTab, nTab ) )          // Zellschutz testen
     646             :             {
     647           0 :                 ScDocShellModificator aModificator( *this );
     648           0 :                 ScMarkData aScenMark;
     649           0 :                 aDocument.MarkScenario( nSrcTab, nTab, aScenMark );
     650           0 :                 ScRange aMultiRange;
     651           0 :                 aScenMark.GetMultiMarkArea( aMultiRange );
     652           0 :                 SCCOL nStartCol = aMultiRange.aStart.Col();
     653           0 :                 SCROW nStartRow = aMultiRange.aStart.Row();
     654           0 :                 SCCOL nEndCol = aMultiRange.aEnd.Col();
     655           0 :                 SCROW nEndRow = aMultiRange.aEnd.Row();
     656             : 
     657           0 :                 if (bRecord)
     658             :                 {
     659           0 :                     ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
     660           0 :                     pUndoDoc->InitUndo( &aDocument, nTab,nEndTab );             // auch alle Szenarien
     661             :                     //  angezeigte Tabelle:
     662             :                     aDocument.CopyToDocument( nStartCol,nStartRow,nTab,
     663           0 :                                     nEndCol,nEndRow,nTab, IDF_ALL,true, pUndoDoc, &aScenMark );
     664             :                     //  Szenarien
     665           0 :                     for (SCTAB i=nTab+1; i<=nEndTab; i++)
     666             :                     {
     667           0 :                         pUndoDoc->SetScenario( i, true );
     668           0 :                         OUString aComment;
     669           0 :                         Color  aColor;
     670             :                         sal_uInt16 nScenFlags;
     671           0 :                         aDocument.GetScenarioData( i, aComment, aColor, nScenFlags );
     672           0 :                         pUndoDoc->SetScenarioData( i, aComment, aColor, nScenFlags );
     673           0 :                         bool bActive = aDocument.IsActiveScenario( i );
     674           0 :                         pUndoDoc->SetActiveScenario( i, bActive );
     675             :                         //  Bei Zurueckkopier-Szenarios auch Inhalte
     676           0 :                         if ( nScenFlags & SC_SCENARIO_TWOWAY )
     677             :                             aDocument.CopyToDocument( 0,0,i, MAXCOL,MAXROW,i,
     678           0 :                                                         IDF_ALL,false, pUndoDoc );
     679           0 :                     }
     680             : 
     681           0 :                     GetUndoManager()->AddUndoAction(
     682             :                         new ScUndoUseScenario( this, aScenMark,
     683             :                                         ScArea( nTab,nStartCol,nStartRow,nEndCol,nEndRow ),
     684           0 :                                         pUndoDoc, rName ) );
     685             :                 }
     686             : 
     687           0 :                 aDocument.CopyScenario( nSrcTab, nTab );
     688             : 
     689           0 :                 sc::SetFormulaDirtyContext aCxt;
     690           0 :                 aDocument.SetAllFormulasDirty(aCxt);
     691             : 
     692             :                 //  alles painten, weil in anderen Bereichen das aktive Szenario
     693             :                 //  geaendert sein kann
     694             :                 //! nur, wenn sichtbare Rahmen vorhanden?
     695           0 :                 PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );
     696           0 :                 aModificator.SetDocumentModified();
     697             :             }
     698             :             else
     699             :             {
     700           0 :                 ScopedVclPtrInstance<InfoBox> aBox( GetActiveDialogParent(),
     701           0 :                     ScGlobal::GetRscString( STR_PROTECTIONERR ) );
     702           0 :                 aBox->Execute();
     703             :             }
     704             :         }
     705             :         else
     706             :         {
     707           0 :             ScopedVclPtrInstance<InfoBox> aBox(GetActiveDialogParent(),
     708           0 :                 ScGlobal::GetRscString( STR_SCENARIO_NOTFOUND ) );
     709           0 :             aBox->Execute();
     710           0 :         }
     711             :     }
     712             :     else
     713             :     {
     714             :         OSL_FAIL( "UseScenario auf Szenario-Blatt" );
     715             :     }
     716           0 : }
     717             : 
     718           0 : void ScDocShell::ModifyScenario( SCTAB nTab, const OUString& rName, const OUString& rComment,
     719             :                                     const Color& rColor, sal_uInt16 nFlags )
     720             : {
     721             :     //  Undo
     722           0 :     OUString aOldName;
     723           0 :     aDocument.GetName( nTab, aOldName );
     724           0 :     OUString aOldComment;
     725           0 :     Color aOldColor;
     726             :     sal_uInt16 nOldFlags;
     727           0 :     aDocument.GetScenarioData( nTab, aOldComment, aOldColor, nOldFlags );
     728           0 :     GetUndoManager()->AddUndoAction(
     729             :         new ScUndoScenarioFlags( this, nTab,
     730             :                 aOldName, rName, aOldComment, rComment,
     731           0 :                 aOldColor, rColor, nOldFlags, nFlags ) );
     732             : 
     733             :     //  ausfuehren
     734           0 :     ScDocShellModificator aModificator( *this );
     735           0 :     aDocument.RenameTab( nTab, rName );
     736           0 :     aDocument.SetScenarioData( nTab, rComment, rColor, nFlags );
     737           0 :     PostPaintGridAll();
     738           0 :     aModificator.SetDocumentModified();
     739             : 
     740           0 :     if (!aOldName.equals(rName))
     741           0 :         SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
     742             : 
     743           0 :     SfxBindings* pBindings = GetViewBindings();
     744           0 :     if (pBindings)
     745           0 :         pBindings->Invalidate( SID_SELECT_SCENARIO );
     746           0 : }
     747             : 
     748           1 : SCTAB ScDocShell::MakeScenario( SCTAB nTab, const OUString& rName, const OUString& rComment,
     749             :                                     const Color& rColor, sal_uInt16 nFlags,
     750             :                                     ScMarkData& rMark, bool bRecord )
     751             : {
     752           1 :     rMark.MarkToMulti();
     753           1 :     if (rMark.IsMultiMarked())
     754             :     {
     755           1 :         SCTAB nNewTab = nTab + 1;
     756           2 :         while (aDocument.IsScenario(nNewTab))
     757           0 :             ++nNewTab;
     758             : 
     759           1 :         bool bCopyAll = ( (nFlags & SC_SCENARIO_COPYALL) != 0 );
     760           1 :         const ScMarkData* pCopyMark = NULL;
     761           1 :         if (!bCopyAll)
     762           1 :             pCopyMark = &rMark;
     763             : 
     764           1 :         ScDocShellModificator aModificator( *this );
     765             : 
     766           1 :         if (bRecord)
     767           1 :             aDocument.BeginDrawUndo();      // drawing layer must do its own undo actions
     768             : 
     769           1 :         if (aDocument.CopyTab( nTab, nNewTab, pCopyMark ))
     770             :         {
     771           1 :             if (bRecord)
     772             :             {
     773           1 :                 GetUndoManager()->AddUndoAction(
     774             :                         new ScUndoMakeScenario( this, nTab, nNewTab,
     775           1 :                                                 rName, rComment, rColor, nFlags, rMark ));
     776             :             }
     777             : 
     778           1 :             aDocument.RenameTab( nNewTab, rName, false );           // ohne Formel-Update
     779           1 :             aDocument.SetScenario( nNewTab, true );
     780           1 :             aDocument.SetScenarioData( nNewTab, rComment, rColor, nFlags );
     781             : 
     782           1 :             ScMarkData aDestMark = rMark;
     783           1 :             aDestMark.SelectOneTable( nNewTab );
     784             : 
     785             :             //!     auf Filter / Buttons / Merging testen !
     786             : 
     787           2 :             ScPatternAttr aProtPattern( aDocument.GetPool() );
     788           1 :             aProtPattern.GetItemSet().Put( ScProtectionAttr( true ) );
     789           1 :             aDocument.ApplyPatternAreaTab( 0,0, MAXCOL,MAXROW, nNewTab, aProtPattern );
     790             : 
     791           2 :             ScPatternAttr aPattern( aDocument.GetPool() );
     792           1 :             aPattern.GetItemSet().Put( ScMergeFlagAttr( SC_MF_SCENARIO ) );
     793           1 :             aPattern.GetItemSet().Put( ScProtectionAttr( true ) );
     794           1 :             aDocument.ApplySelectionPattern( aPattern, aDestMark );
     795             : 
     796           1 :             if (!bCopyAll)
     797           1 :                 aDocument.SetVisible( nNewTab, false );
     798             : 
     799             :             //  dies ist dann das aktive Szenario
     800           1 :             aDocument.CopyScenario( nNewTab, nTab, true );  // sal_True - nicht aus Szenario kopieren
     801             : 
     802           1 :             if (nFlags & SC_SCENARIO_SHOWFRAME)
     803           1 :                 PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );  // Rahmen painten
     804           1 :             PostPaintExtras();                                          // Tabellenreiter
     805           1 :             aModificator.SetDocumentModified();
     806             : 
     807           1 :             SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
     808             : 
     809           2 :             return nNewTab;
     810           0 :         }
     811             :     }
     812           0 :     return nTab;
     813             : }
     814             : 
     815          10 : sal_uLong ScDocShell::TransferTab( ScDocShell& rSrcDocShell, SCTAB nSrcPos,
     816             :                                 SCTAB nDestPos, bool bInsertNew,
     817             :                                 bool bNotifyAndPaint )
     818             : {
     819          10 :     ScDocument& rSrcDoc = rSrcDocShell.GetDocument();
     820             : 
     821             :     // set the transferred area to the copyparam to make adjusting formulas possible
     822          10 :     ScClipParam aParam;
     823          10 :     ScRange aRange(0, 0, nSrcPos, MAXCOL, MAXROW, nSrcPos);
     824          10 :     aParam.maRanges.Append(aRange);
     825          10 :     rSrcDoc.SetClipParam(aParam);
     826             : 
     827             :     sal_uLong nErrVal =  aDocument.TransferTab( &rSrcDoc, nSrcPos, nDestPos,
     828          10 :                     bInsertNew );       // no insert
     829             : 
     830             :     // TransferTab doesn't copy drawing objects with bInsertNew=FALSE
     831          10 :     if ( nErrVal > 0 && !bInsertNew)
     832           0 :         aDocument.TransferDrawPage( &rSrcDoc, nSrcPos, nDestPos );
     833             : 
     834          10 :     if(nErrVal>0 && rSrcDoc.IsScenario( nSrcPos ))
     835             :     {
     836           0 :         OUString aComment;
     837           0 :         Color  aColor;
     838             :         sal_uInt16 nFlags;
     839             : 
     840           0 :         rSrcDoc.GetScenarioData( nSrcPos, aComment,aColor, nFlags);
     841           0 :         aDocument.SetScenario(nDestPos,true);
     842           0 :         aDocument.SetScenarioData(nDestPos,aComment,aColor,nFlags);
     843           0 :         bool bActive = rSrcDoc.IsActiveScenario(nSrcPos);
     844           0 :         aDocument.SetActiveScenario(nDestPos, bActive );
     845             : 
     846           0 :         bool bVisible = rSrcDoc.IsVisible(nSrcPos);
     847           0 :         aDocument.SetVisible(nDestPos,bVisible );
     848             : 
     849             :     }
     850             : 
     851          10 :     if ( nErrVal > 0 && rSrcDoc.IsTabProtected( nSrcPos ) )
     852           0 :         aDocument.SetTabProtection(nDestPos, rSrcDoc.GetTabProtection(nSrcPos));
     853          10 :     if ( bNotifyAndPaint )
     854             :     {
     855          10 :             Broadcast( ScTablesHint( SC_TAB_INSERTED, nDestPos ) );
     856          10 :             PostPaintExtras();
     857          10 :             PostPaintGridAll();
     858             :     }
     859          10 :     return nErrVal;
     860             : }
     861             : 
     862           0 : bool ScDocShell::MoveTable( SCTAB nSrcTab, SCTAB nDestTab, bool bCopy, bool bRecord )
     863             : {
     864           0 :     ScDocShellModificator aModificator( *this );
     865             : 
     866             :     // #i92477# be consistent with ScDocFunc::InsertTable: any index past the last sheet means "append"
     867             :     // #i101139# nDestTab must be the target position, not APPEND (for CopyTabProtection etc.)
     868           0 :     if ( nDestTab >= aDocument.GetTableCount() )
     869           0 :         nDestTab = aDocument.GetTableCount();
     870             : 
     871           0 :     if (bCopy)
     872             :     {
     873           0 :         if (bRecord)
     874           0 :             aDocument.BeginDrawUndo();          // drawing layer must do its own undo actions
     875             : 
     876           0 :         OUString sSrcCodeName;
     877           0 :         aDocument.GetCodeName( nSrcTab, sSrcCodeName );
     878           0 :         if (!aDocument.CopyTab( nSrcTab, nDestTab ))
     879             :         {
     880             :             //! EndDrawUndo?
     881           0 :             return false;
     882             :         }
     883             :         else
     884             :         {
     885           0 :             SCTAB nAdjSource = nSrcTab;
     886           0 :             if ( nDestTab <= nSrcTab )
     887           0 :                 ++nAdjSource;               // new position of source table after CopyTab
     888             : 
     889           0 :             if ( aDocument.IsTabProtected( nAdjSource ) )
     890           0 :                 aDocument.CopyTabProtection(nAdjSource, nDestTab);
     891             : 
     892           0 :             if (bRecord)
     893             :             {
     894           0 :                 unique_ptr< vector<SCTAB> > pSrcList(new vector<SCTAB>(1, nSrcTab));
     895           0 :                 unique_ptr< vector<SCTAB> > pDestList(new vector<SCTAB>(1, nDestTab));
     896           0 :                 GetUndoManager()->AddUndoAction(
     897           0 :                         new ScUndoCopyTab(this, pSrcList.release(), pDestList.release()));
     898             :             }
     899             : 
     900           0 :             bool bVbaEnabled = aDocument.IsInVBAMode();
     901           0 :             if ( bVbaEnabled )
     902             :             {
     903           0 :                 OUString aLibName( "Standard" );
     904           0 :                 Reference< XLibraryContainer > xLibContainer = GetBasicContainer();
     905           0 :                 Reference< XVBACompatibility > xVBACompat( xLibContainer, UNO_QUERY );
     906             : 
     907           0 :                 if ( xVBACompat.is() )
     908             :                 {
     909           0 :                     aLibName = xVBACompat->getProjectName();
     910             :                 }
     911             : 
     912           0 :                 SCTAB nTabToUse = nDestTab;
     913           0 :                 if ( nDestTab == SC_TAB_APPEND )
     914           0 :                     nTabToUse = aDocument.GetMaxTableNumber() - 1;
     915           0 :                 OUString sCodeName;
     916           0 :                 OUString sSource;
     917             :                 try
     918             :                 {
     919           0 :                     Reference< XNameContainer > xLib;
     920           0 :                     if( xLibContainer.is() )
     921             :                     {
     922           0 :                         com::sun::star::uno::Any aLibAny = xLibContainer->getByName( aLibName );
     923           0 :                         aLibAny >>= xLib;
     924             :                     }
     925           0 :                     if( xLib.is() )
     926             :                     {
     927           0 :                         xLib->getByName( sSrcCodeName ) >>= sSource;
     928           0 :                     }
     929             :                 }
     930           0 :                 catch ( const com::sun::star::uno::Exception& )
     931             :                 {
     932             :                 }
     933           0 :                 VBA_InsertModule( aDocument, nTabToUse, sCodeName, sSource );
     934             :             }
     935             :         }
     936           0 :         Broadcast( ScTablesHint( SC_TAB_COPIED, nSrcTab, nDestTab ) );
     937             :     }
     938             :     else
     939             :     {
     940           0 :         if ( aDocument.GetChangeTrack() )
     941           0 :             return false;
     942             : 
     943           0 :         if ( nSrcTab<nDestTab && nDestTab!=SC_TAB_APPEND )
     944           0 :             nDestTab--;
     945             : 
     946           0 :         if ( nSrcTab == nDestTab )
     947             :         {
     948             :             //! allow only for api calls?
     949           0 :             return true;    // nothing to do, but valid
     950             :         }
     951             : 
     952             :         ScProgress* pProgress = new ScProgress(this, ScGlobal::GetRscString(STR_UNDO_MOVE_TAB),
     953           0 :                                                 aDocument.GetCodeCount());
     954           0 :         bool bDone = aDocument.MoveTab( nSrcTab, nDestTab, pProgress );
     955           0 :         delete pProgress;
     956           0 :         if (!bDone)
     957             :         {
     958           0 :             return false;
     959             :         }
     960           0 :         else if (bRecord)
     961             :         {
     962           0 :             unique_ptr< vector<SCTAB> > pSrcList(new vector<SCTAB>(1, nSrcTab));
     963           0 :             unique_ptr< vector<SCTAB> > pDestList(new vector<SCTAB>(1, nDestTab));
     964           0 :             GetUndoManager()->AddUndoAction(
     965           0 :                     new ScUndoMoveTab(this, pSrcList.release(), pDestList.release()));
     966             :         }
     967             : 
     968           0 :         Broadcast( ScTablesHint( SC_TAB_MOVED, nSrcTab, nDestTab ) );
     969             :     }
     970             : 
     971           0 :     PostPaintGridAll();
     972           0 :     PostPaintExtras();
     973           0 :     aModificator.SetDocumentModified();
     974           0 :     SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
     975             : 
     976           0 :     return true;
     977             : }
     978             : 
     979           0 : IMPL_LINK_TYPED( ScDocShell, RefreshDBDataHdl, Timer*, pRefreshTimer, void )
     980             : {
     981           0 :     ScDBDocFunc aFunc(*this);
     982             : 
     983           0 :     ScDBData* pDBData = static_cast<ScDBData*>(pRefreshTimer);
     984           0 :     ScImportParam aImportParam;
     985           0 :     pDBData->GetImportParam( aImportParam );
     986           0 :     if (aImportParam.bImport && !pDBData->HasImportSelection())
     987             :     {
     988           0 :         ScRange aRange;
     989           0 :         pDBData->GetArea( aRange );
     990           0 :         bool bContinue = aFunc.DoImport( aRange.aStart.Tab(), aImportParam, NULL, true, false ); //! Api-Flag as parameter
     991             :         // internal operations (sort, query, subtotal) only if no error
     992           0 :         if (bContinue)
     993             :         {
     994           0 :             aFunc.RepeatDB( pDBData->GetName(), true, true );
     995           0 :             RefreshPivotTables(aRange);
     996             :         }
     997           0 :     }
     998         156 : }
     999             : 
    1000             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11