/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sc.hxx"

// System - Includes -----------------------------------------------------


#include "scitems.hxx"
#include <vcl/svapp.hxx>
#include <vcl/msgbox.hxx>
#include <vcl/waitobj.hxx>
#include <sfx2/app.hxx>
#include <sfx2/bindings.hxx>
#include <svl/smplhint.hxx>

// INCLUDE ---------------------------------------------------------------

#include "docsh.hxx"
#include "global.hxx"
#include "globstr.hrc"
#include "undodat.hxx"
#include "undotab.hxx"
#include "undoblk.hxx"
//#include "pivot.hxx"
#include "dpobject.hxx"
#include "dpshttab.hxx"
#include "dbdocfun.hxx"
#include "consoli.hxx"
#include "dbcolect.hxx"
#include "olinetab.hxx"
#include "patattr.hxx"
#include "attrib.hxx"
#include "docpool.hxx"
#include "uiitems.hxx"
#include "sc.hrc"
#include "waitoff.hxx"
#include "sizedev.hxx"
#include <basic/sbstar.hxx>
#include <basic/basmgr.hxx>

// defined in docfunc.cxx
void VBA_InsertModule( ScDocument& rDoc, SCTAB nTab, String& sModuleName, String& sModuleSource );

// ---------------------------------------------------------------------------

//
//	ehemalige viewfunc/dbfunc Methoden
//

void ScDocShell::ErrorMessage( sal_uInt16 nGlobStrId )
{
	//!	StopMarking an der (aktiven) View?

	Window* pParent = GetActiveDialogParent();
	ScWaitCursorOff aWaitOff( pParent );
	sal_Bool bFocus = pParent && pParent->HasFocus();

	if(nGlobStrId==STR_PROTECTIONERR)
	{
		if(IsReadOnly())
		{
			nGlobStrId=STR_READONLYERR;
		}
	}

	InfoBox aBox( pParent, ScGlobal::GetRscString( nGlobStrId ) );
	aBox.Execute();
	if (bFocus)
		pParent->GrabFocus();
}

sal_Bool ScDocShell::IsEditable() const
{
	// import into read-only document is possible - must be extended if other filters use api
	// #i108547# MSOOXML filter uses "IsChangeReadOnlyEnabled" property

	return !IsReadOnly() || aDocument.IsImportingXML() || aDocument.IsChangeReadOnlyEnabled();
}

void ScDocShell::DBAreaDeleted( SCTAB nTab, SCCOL nX1, SCROW nY1, SCCOL nX2, SCROW /* nY2 */ )
{
	ScDocShellModificator aModificator( *this );
	aDocument.RemoveFlagsTab( nX1, nY1, nX2, nY1, nTab, SC_MF_AUTO );
	PostPaint( nX1, nY1, nTab, nX2, nY1, nTab, PAINT_GRID );
    // No SetDocumentModified, as the unnamed database range might have to be restored later.
    // The UNO hint is broadcast directly instead, to keep UNO objects in valid state.
    aDocument.BroadcastUno( SfxSimpleHint( SFX_HINT_DATACHANGED ) );
}

ScDBData* lcl_GetDBNearCursor( ScDBCollection* pColl, SCCOL nCol, SCROW nRow, SCTAB nTab )
{
	//!	nach document/dbcolect verschieben

	if (!pColl)
		return NULL;

	ScDBData* pNoNameData = NULL;
	ScDBData* pNearData = NULL;
	sal_uInt16 nCount = pColl->GetCount();
	String aNoName = ScGlobal::GetRscString( STR_DB_NONAME );
	SCTAB nAreaTab;
	SCCOL nStartCol, nEndCol;
	SCROW nStartRow, nEndRow;
	for (sal_uInt16 i = 0; i < nCount; i++)
	{
		ScDBData* pDB = (*pColl)[i];
		pDB->GetArea( nAreaTab, nStartCol, nStartRow, nEndCol, nEndRow );
		if ( nTab == nAreaTab && nCol+1 >= nStartCol && nCol <= nEndCol+1 &&
								 nRow+1 >= nStartRow && nRow <= nEndRow+1 )
		{
			if ( pDB->GetName() == aNoName )
				pNoNameData = pDB;
			else if ( nCol < nStartCol || nCol > nEndCol || nRow < nStartRow || nRow > nEndRow )
			{
				if (!pNearData)
					pNearData = pDB;	// ersten angrenzenden Bereich merken
			}
			else
				return pDB;				// nicht "unbenannt" und Cursor steht wirklich drin
		}
	}
	if (pNearData)
		return pNearData;				// angrenzender, wenn nichts direkt getroffen
	return pNoNameData;					// "unbenannt" nur zurueck, wenn sonst nichts gefunden
}

ScDBData* ScDocShell::GetDBData( const ScRange& rMarked, ScGetDBMode eMode, ScGetDBSelection eSel )
{
    if ( eMode == SC_DB_MAKE_FILTER || eMode == SC_DB_MAKE_SORT || eMode == SC_DB_MAKE_SUBTOTAL || eMode == SC_DB_OLD_FILTER )
        return GetDBDataAdd(rMarked, eMode, eSel);
	SCCOL nCol = rMarked.aStart.Col();
	SCROW nRow = rMarked.aStart.Row();
	SCTAB nTab = rMarked.aStart.Tab();

	SCCOL nStartCol = nCol;
	SCROW nStartRow = nRow;
	SCTAB nStartTab = nTab;
	SCCOL nEndCol = rMarked.aEnd.Col();
	SCROW nEndRow = rMarked.aEnd.Row();
	SCTAB nEndTab = rMarked.aEnd.Tab();

	//	Wegen #49655# nicht einfach GetDBAtCursor: Der zusammenhaengende Datenbereich
	//	fuer "unbenannt" (GetDataArea) kann neben dem Cursor legen, also muss auch ein
	//	benannter DB-Bereich dort gesucht werden.

	ScDBData* pData = aDocument.GetDBAtArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow );
	if (!pData)
		pData = lcl_GetDBNearCursor( aDocument.GetDBCollection(), nCol, nRow, nTab );

	sal_Bool bSelected = ( eSel == SC_DBSEL_FORCE_MARK ||
            (rMarked.aStart != rMarked.aEnd && eSel != SC_DBSEL_ROW_DOWN) );
    bool bOnlyDown = (!bSelected && eSel == SC_DBSEL_ROW_DOWN && rMarked.aStart.Row() == rMarked.aEnd.Row());

	sal_Bool bUseThis = sal_False;
	if (pData)
	{
		//		Bereich nehmen, wenn nichts anderes markiert

		SCTAB nDummy;
		SCCOL nOldCol1;
		SCROW nOldRow1;
		SCCOL nOldCol2;
		SCROW nOldRow2;
		pData->GetArea( nDummy, nOldCol1,nOldRow1, nOldCol2,nOldRow2 );
//		sal_Bool bIsNoName = ( pData->GetName() == ScGlobal::GetRscString( STR_DB_NONAME ) );
		sal_Bool bIsNoName = pData->IsBuildin();

		if (!bSelected)
		{
			bUseThis = sal_True;
			if ( bIsNoName && eMode == SC_DB_MAKE )
			{
                // If nothing marked or only one row marked, adapt 
                // "unbenannt"/"unnamed" to contiguous area.
                nStartCol = nCol;
                nStartRow = nRow;
                if (bOnlyDown)
                {
                    nEndCol = rMarked.aEnd.Col();
                    nEndRow = rMarked.aEnd.Row();
                }
                else
                {
                    nEndCol = nStartCol;
                    nEndRow = nStartRow;
                }
				aDocument.GetDataArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow, sal_False, bOnlyDown );
				if ( nOldCol1 != nStartCol || nOldCol2 != nEndCol || nOldRow1 != nStartRow )
					bUseThis = sal_False;				// passt gar nicht
				else if ( nOldRow2 != nEndRow )
				{
					//	Bereich auf neue End-Zeile erweitern
					pData->SetArea( nTab, nOldCol1,nOldRow1, nOldCol2,nEndRow );
				}
			}
		}
		else
		{
			if ( nOldCol1 == nStartCol && nOldRow1 == nStartRow &&
				 nOldCol2 == nEndCol && nOldRow2 == nEndRow )				// genau markiert?
				bUseThis = sal_True;
			else
				bUseThis = sal_False;			// immer Markierung nehmen (Bug 11964)
		}

		//		fuer Import nie "unbenannt" nehmen

		if ( bUseThis && eMode == SC_DB_IMPORT && bIsNoName )
			bUseThis = sal_False;
	}

	if ( bUseThis )
	{
		pData->GetArea( nStartTab, nStartCol,nStartRow, nEndCol,nEndRow );
		nEndTab = nStartTab;
	}
	else if ( eMode == SC_DB_OLD )
	{
		pData = NULL;							// nichts gefunden
		nStartCol = nEndCol = nCol;
		nStartRow = nEndRow = nRow;
		nStartTab = nEndTab = nTab;
//		bMark = sal_False;							// nichts zu markieren
	}
	else
	{
		if ( bSelected )
		{
//			bMark = sal_False;
		}
		else
		{										// zusammenhaengender Bereich
			nStartCol = nCol;
			nStartRow = nRow;
            if (bOnlyDown)
            {
                nEndCol = rMarked.aEnd.Col();
                nEndRow = rMarked.aEnd.Row();
            }
            else
            {
                nEndCol = nStartCol;
                nEndRow = nStartRow;
            }
			aDocument.GetDataArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow, sal_False, bOnlyDown );
		}

		sal_Bool bHasHeader = aDocument.HasColHeader( nStartCol,nStartRow, nEndCol,nEndRow, nTab );

		ScDBData* pNoNameData;
		sal_uInt16 nNoNameIndex;
		ScDBCollection* pColl = aDocument.GetDBCollection();
		if ( eMode != SC_DB_IMPORT &&
				pColl->SearchName( ScGlobal::GetRscString( STR_DB_NONAME ), nNoNameIndex ) )
		{
			pNoNameData = (*pColl)[nNoNameIndex];

            if ( !pOldAutoDBRange )
            {
                // store the old unnamed database range with its settings for undo
                // (store at the first change, get the state before all changes)
                pOldAutoDBRange = new ScDBData( *pNoNameData );
            }

			SCCOL nOldX1;									// alten Bereich sauber wegnehmen
			SCROW nOldY1;									//! (UNDO ???)
			SCCOL nOldX2;
			SCROW nOldY2;
			SCTAB nOldTab;
			pNoNameData->GetArea( nOldTab, nOldX1, nOldY1, nOldX2, nOldY2 );
			DBAreaDeleted( nOldTab, nOldX1, nOldY1, nOldX2, nOldY2 );

			pNoNameData->SetSortParam( ScSortParam() ); 			// Parameter zuruecksetzen
			pNoNameData->SetQueryParam( ScQueryParam() );
			pNoNameData->SetSubTotalParam( ScSubTotalParam() );

			pNoNameData->SetArea( nTab, nStartCol,nStartRow, nEndCol,nEndRow ); 	// neu setzen
			pNoNameData->SetByRow( sal_True );
			pNoNameData->SetHeader( bHasHeader );
			pNoNameData->SetAutoFilter( sal_False );
		}
		else
		{
			ScDBCollection* pUndoColl = NULL;

			String aNewName;
			if (eMode==SC_DB_IMPORT)
			{
				aDocument.CompileDBFormula( sal_True );			// CreateFormulaString
				pUndoColl = new ScDBCollection( *pColl );	// Undo fuer Import1-Bereich

				String aImport = ScGlobal::GetRscString( STR_DBNAME_IMPORT );
				long nCount = 0;
				sal_uInt16 nDummy;
				do
				{
					++nCount;
					aNewName = aImport;
					aNewName += String::CreateFromInt32( nCount );
				}
				while (pColl->SearchName( aNewName, nDummy ));
			}
			else
				//aNewName = ScGlobal::GetRscString( STR_DB_NONAME );
				aNewName = pColl->GetNewDefaultDBName();

			pNoNameData = new ScDBData( aNewName, nTab,
								nStartCol,nStartRow, nEndCol,nEndRow,
								sal_True, bHasHeader );
			pColl->Insert( pNoNameData );

			if ( pUndoColl )
			{
				aDocument.CompileDBFormula( sal_False );		// CompileFormulaString

				ScDBCollection* pRedoColl = new ScDBCollection( *pColl );
				GetUndoManager()->AddUndoAction( new ScUndoDBData( this, pUndoColl, pRedoColl ) );
			}

			//	neuen Bereich am Sba anmelden nicht mehr noetig

			//	"Import1" etc am Navigator bekanntmachen
			if (eMode==SC_DB_IMPORT)
				SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) );
		}
		pData = pNoNameData;
	}

//	if (bMark)
//		MarkRange( ScRange( nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab ), sal_False );

	return pData;
}

ScDBData* ScDocShell::GetDBDataAdd( const ScRange& rMarked, ScGetDBMode eMode, ScGetDBSelection eSel )
{
    SCCOL nCol = rMarked.aStart.Col();
    SCROW nRow = rMarked.aStart.Row();
    SCTAB nTab = rMarked.aStart.Tab();

    SCCOL nStartCol = nCol;
    SCROW nStartRow = nRow;
    SCCOL nEndCol = rMarked.aEnd.Col();
    SCROW nEndRow = rMarked.aEnd.Row();

    ScDBData* pData = NULL;
    ScDBData* pCursorData;
    pCursorData = aDocument.GetDBAtArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow );
    if ( !pCursorData )
        pCursorData = aDocument.GetDBAtCursor( nStartCol, nStartRow, nTab );

    //Get DBData at current table
    ScDBData* pTableData = aDocument.GetDBAtTable( nTab, eMode );

    if ( eMode == SC_DB_OLD_FILTER )
        return pTableData;

    sal_Bool bSelected = ( eSel == SC_DBSEL_FORCE_MARK || rMarked.aStart != rMarked.aEnd ); 
    bool bOnlyDown = (!bSelected && eSel == SC_DBSEL_ROW_DOWN && rMarked.aStart.Row() == rMarked.aEnd.Row());

	sal_Bool bUseThis = sal_False;
    if (pCursorData)
    {
        SCTAB nDummy;
        SCCOL nOldCol1;
        SCROW nOldRow1;
        SCCOL nOldCol2;
        SCROW nOldRow2;
        pCursorData->GetArea( nDummy, nOldCol1,nOldRow1, nOldCol2,nOldRow2 );
        if ( !bSelected )
        {    
              ScRange tmpRange;
              if ( !pCursorData->IsBuildin() && pCursorData->GetAdvancedQuerySource(tmpRange))	 
                   bUseThis = sal_True;			   
              else
             {  
                 nStartCol = nCol;
                 nStartRow = nRow;
                 nEndCol = nStartCol;
                 nEndRow = nStartRow;
				aDocument.GetDataArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow, sal_False, bOnlyDown );
                 if ( nOldCol1 != nStartCol || nOldCol2 != nEndCol || nOldRow1 != nStartRow )
                     bUseThis = sal_False;
                 else
                 {
                     bUseThis = sal_True;
                     if ( nOldRow2 != nEndRow )// Range of new end-line expand
                     pCursorData->SetArea( nTab, nOldCol1,nOldRow1, nOldCol2,nEndRow );
                 }
            }

        }
        else
        {
            if ( nOldCol1 == nStartCol && nOldRow1 == nStartRow && nOldCol2 == nEndCol && nOldRow2 == nEndRow )
				bUseThis = sal_True;
            else
				bUseThis = sal_False;			// Always take mark (Bug 11964)
        }
    }

    if ( bUseThis )
    {
        pData = pCursorData;
        if ( pTableData && eMode == SC_DB_MAKE_FILTER && !(*pTableData == *pCursorData ) )
        {
            if ( !pOldAutoDBRange )
                pOldAutoDBRange = new ScDBData(*pTableData);
            SCCOL nOldX1;
            SCROW nOldY1;
            SCCOL nOldX2;
            SCROW nOldY2;
            SCTAB nOldTab;
            pTableData->GetArea( nOldTab, nOldX1, nOldY1, nOldX2, nOldY2 );

            if (pTableData->HasQueryParam())
            {
                ScQueryParam    aParam;
                pTableData->GetQueryParam(aParam);
                SCSIZE nEC = aParam.GetEntryCount();
                for (SCSIZE i=0; i<nEC; i++)
                    aParam.GetEntry(i).bDoQuery = sal_False;
                aParam.bDuplicate = sal_True;
                ScDBDocFunc aDBDocFunc( *this );
                aDBDocFunc.Query( nTab, aParam, NULL, sal_False, sal_False );
            }

            DBAreaDeleted( nOldTab, nOldX1, nOldY1, nOldX2, nOldY2 );
            pTableData->SetQueryParam( ScQueryParam() );
            pTableData->SetAutoFilter( sal_False );
        }

    }
    else
    {
        if ( bSelected )
        {
//			bMark = sal_False;
        }
        else
        {
            nStartCol = nCol;
            nStartRow = nRow;
            nEndCol = nStartCol;
            nEndRow = nStartRow;
			aDocument.GetDataArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow, sal_False, bOnlyDown );
        }
        sal_Bool bHasHeader = aDocument.HasColHeader( nStartCol,nStartRow, nEndCol,nEndRow, nTab );
        ScDBCollection* pColl = aDocument.GetDBCollection();
        if ( pTableData )
        {
            if ( !pOldAutoDBRange )
                pOldAutoDBRange = new ScDBData(*pTableData);
            SCCOL nOldX1;
            SCROW nOldY1;
            SCCOL nOldX2;
            SCROW nOldY2;
            SCTAB nOldTab;
            pTableData->GetArea( nOldTab, nOldX1, nOldY1, nOldX2, nOldY2 );

            if (pTableData->HasQueryParam())
            {
                ScQueryParam    aParam;
                pTableData->GetQueryParam(aParam);
                SCSIZE nEC = aParam.GetEntryCount();
                for (SCSIZE i=0; i<nEC; i++)
                    aParam.GetEntry(i).bDoQuery = sal_False;
                aParam.bDuplicate = sal_True;
                ScDBDocFunc aDBDocFunc( *this );
                aDBDocFunc.Query( nTab, aParam, NULL, sal_False, sal_False );
            }

                DBAreaDeleted( nOldTab, nOldX1, nOldY1, nOldX2, nOldY2 );

            pTableData->SetSortParam( ScSortParam() );
            pTableData->SetQueryParam( ScQueryParam() );
            pTableData->SetSubTotalParam( ScSubTotalParam() );

            pTableData->SetArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow );
            pTableData->SetByRow( sal_True );
            pTableData->SetHeader( bHasHeader );
            pTableData->SetAutoFilter( sal_False );
        }
        else
        {
            String aNewName = pColl->GetNewDefaultDBName();
            pTableData = new ScDBData( aNewName, nTab, nStartCol,nStartRow, nEndCol,nEndRow, sal_True, bHasHeader );
            pColl->Insert( pTableData );
        }
        pData = pTableData;
    }

    return pData;
}


ScDBData* ScDocShell::GetOldAutoDBRange()
{
    ScDBData* pRet = pOldAutoDBRange;
    pOldAutoDBRange = NULL;
    return pRet;                    // has to be deleted by caller!
}

void ScDocShell::CancelAutoDBRange()
{
    // called when dialog is cancelled
    if ( pOldAutoDBRange )
    {
        sal_uInt16 nNoNameIndex;
        ScDBCollection* pColl = aDocument.GetDBCollection();
        if ( pColl->SearchName( ScGlobal::GetRscString( STR_DB_NONAME ), nNoNameIndex ) )
        {
            ScDBData* pNoNameData = (*pColl)[nNoNameIndex];

            SCCOL nRangeX1;
            SCROW nRangeY1;
            SCCOL nRangeX2;
            SCROW nRangeY2;
            SCTAB nRangeTab;
            pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
            DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );

            *pNoNameData = *pOldAutoDBRange;    // restore old settings

            if ( pOldAutoDBRange->HasAutoFilter() )
            {
                // restore AutoFilter buttons
                pOldAutoDBRange->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
                aDocument.ApplyFlagsTab( nRangeX1, nRangeY1, nRangeX2, nRangeY1, nRangeTab, SC_MF_AUTO );
                PostPaint( nRangeX1, nRangeY1, nRangeTab, nRangeX2, nRangeY1, nRangeTab, PAINT_GRID );
            }
        }

        delete pOldAutoDBRange;
        pOldAutoDBRange = NULL;
    }
}


		//	Hoehen anpassen
		//!	mit docfunc zusammenfassen

sal_Bool ScDocShell::AdjustRowHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab )
{
	ScSizeDeviceProvider aProv(this);
	Fraction aZoom(1,1);
	sal_Bool bChange = aDocument.SetOptimalHeight( nStartRow,nEndRow, nTab, 0, aProv.GetDevice(),
												aProv.GetPPTX(),aProv.GetPPTY(), aZoom,aZoom, sal_False );
	if (bChange)
		PostPaint( 0,nStartRow,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID|PAINT_LEFT );

	return bChange;
}

void ScDocShell::UpdateAllRowHeights( const ScMarkData* pTabMark )
{
	// update automatic row heights

	ScSizeDeviceProvider aProv(this);
	Fraction aZoom(1,1);
    aDocument.UpdateAllRowHeights( aProv.GetDevice(), aProv.GetPPTX(), aProv.GetPPTY(), aZoom, aZoom, pTabMark );
}

void ScDocShell::UpdatePendingRowHeights( SCTAB nUpdateTab, bool bBefore )
{
    sal_Bool bIsUndoEnabled = aDocument.IsUndoEnabled();
    aDocument.EnableUndo( sal_False );
    aDocument.LockStreamValid( true );      // ignore draw page size (but not formula results)
    if ( bBefore )          // check all sheets up to nUpdateTab
    {
        SCTAB nTabCount = aDocument.GetTableCount();
        if ( nUpdateTab >= nTabCount )
            nUpdateTab = nTabCount-1;     // nUpdateTab is inclusive

        ScMarkData aUpdateSheets;
        SCTAB nTab;
        for (nTab=0; nTab<=nUpdateTab; ++nTab)
            if ( aDocument.IsPendingRowHeights( nTab ) )
                aUpdateSheets.SelectTable( nTab, sal_True );

        if (aUpdateSheets.GetSelectCount())
            UpdateAllRowHeights(&aUpdateSheets);        // update with a single progress bar

        for (nTab=0; nTab<=nUpdateTab; ++nTab)
            if ( aUpdateSheets.GetTableSelect( nTab ) )
            {
                aDocument.UpdatePageBreaks( nTab );
                aDocument.SetPendingRowHeights( nTab, sal_False );
            }
    }
    else                    // only nUpdateTab
    {
        if ( aDocument.IsPendingRowHeights( nUpdateTab ) )
        {
            AdjustRowHeight( 0, MAXROW, nUpdateTab );
            aDocument.UpdatePageBreaks( nUpdateTab );
            aDocument.SetPendingRowHeights( nUpdateTab, sal_False );
        }
    }
    aDocument.LockStreamValid( false );
    aDocument.EnableUndo( bIsUndoEnabled );
}

void ScDocShell::RefreshPivotTables( const ScRange& rSource )
{
	//!	rename to RefreshDataPilotTables?

	ScDPCollection* pColl = aDocument.GetDPCollection();
	if ( pColl )
	{
		//	DataPilotUpdate doesn't modify the collection order like PivotUpdate did,
		//	so a simple loop can be used.

		sal_uInt16 nCount = pColl->GetCount();
		for ( sal_uInt16 i=0; i<nCount; i++ )
		{
			ScDPObject* pOld = (*pColl)[i];
			if ( pOld )
			{
				const ScSheetSourceDesc* pSheetDesc = pOld->GetSheetDesc();
				if ( pSheetDesc && pSheetDesc->aSourceRange.Intersects( rSource ) )
				{
					ScDPObject* pNew = new ScDPObject( *pOld );
					ScDBDocFunc aFunc( *this );
					aFunc.DataPilotUpdate( pOld, pNew, sal_True, sal_False );
					delete pNew;	// DataPilotUpdate copies settings from "new" object
				}
			}
		}
	}
}

String lcl_GetAreaName( ScDocument* pDoc, ScArea* pArea )
{
	String aName;
	sal_Bool bOk = sal_False;
	ScDBData* pData = pDoc->GetDBAtArea( pArea->nTab, pArea->nColStart, pArea->nRowStart,
														pArea->nColEnd, pArea->nRowEnd );
	if (pData)
	{
		pData->GetName( aName );
		if ( aName != ScGlobal::GetRscString( STR_DB_NONAME ) )
			bOk = sal_True;
	}

	if (!bOk)
		pDoc->GetName( pArea->nTab, aName );

	return aName;
}

void ScDocShell::DoConsolidate( const ScConsolidateParam& rParam, sal_Bool bRecord )
{
	ScConsData aData;

	sal_uInt16 nPos;
	SCCOL nColSize = 0;
	SCROW nRowSize = 0;
	sal_Bool bErr = sal_False;
	for (nPos=0; nPos<rParam.nDataAreaCount; nPos++)
	{
		ScArea* pArea = rParam.ppDataAreas[nPos];
		nColSize = Max( nColSize, SCCOL( pArea->nColEnd - pArea->nColStart + 1 ) );
		nRowSize = Max( nRowSize, SCROW( pArea->nRowEnd - pArea->nRowStart + 1 ) );

										// Test, ob Quelldaten verschoben wuerden
		if (rParam.bReferenceData)
			if (pArea->nTab == rParam.nTab && pArea->nRowEnd >= rParam.nRow)
				bErr = sal_True;
	}

	if (bErr)
	{
		InfoBox aBox( GetActiveDialogParent(),
				ScGlobal::GetRscString( STR_CONSOLIDATE_ERR1 ) );
		aBox.Execute();
		return;
	}

	//		ausfuehren

	WaitObject aWait( GetActiveDialogParent() );
	ScDocShellModificator aModificator( *this );

	ScRange aOldDest;
	ScDBData* pDestData = aDocument.GetDBAtCursor( rParam.nCol, rParam.nRow, rParam.nTab, sal_True );
	if (pDestData)
		pDestData->GetArea(aOldDest);

	aData.SetSize( nColSize, nRowSize );
	aData.SetFlags( rParam.eFunction, rParam.bByCol, rParam.bByRow, rParam.bReferenceData );
	if ( rParam.bByCol || rParam.bByRow )
		for (nPos=0; nPos<rParam.nDataAreaCount; nPos++)
		{
			ScArea* pArea = rParam.ppDataAreas[nPos];
			aData.AddFields( &aDocument, pArea->nTab, pArea->nColStart, pArea->nRowStart,
														pArea->nColEnd, pArea->nRowEnd );
		}
	aData.DoneFields();
	for (nPos=0; nPos<rParam.nDataAreaCount; nPos++)
	{
		ScArea* pArea = rParam.ppDataAreas[nPos];
		aData.AddData( &aDocument, pArea->nTab, pArea->nColStart, pArea->nRowStart,
													pArea->nColEnd, pArea->nRowEnd );
		aData.AddName( lcl_GetAreaName(&aDocument,pArea) );
	}

	aData.GetSize( nColSize, nRowSize );
	if (bRecord && nColSize > 0 && nRowSize > 0)
	{
		ScDBData* pUndoData = pDestData ? new ScDBData(*pDestData) : NULL;

		SCTAB nDestTab = rParam.nTab;
		ScArea aDestArea( rParam.nTab, rParam.nCol, rParam.nRow,
							rParam.nCol+nColSize-1, rParam.nRow+nRowSize-1 );
		if (rParam.bByCol) ++aDestArea.nColEnd;
		if (rParam.bByRow) ++aDestArea.nRowEnd;

		if (rParam.bReferenceData)
		{
			SCTAB nTabCount = aDocument.GetTableCount();
			SCROW nInsertCount = aData.GetInsertCount();

			// alte Outlines
			ScOutlineTable* pTable = aDocument.GetOutlineTable( nDestTab );
			ScOutlineTable* pUndoTab = pTable ? new ScOutlineTable( *pTable ) : NULL;

			ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
			pUndoDoc->InitUndo( &aDocument, 0, nTabCount-1, sal_False, sal_True );

			// Zeilenstatus
			aDocument.CopyToDocument( 0,0,nDestTab, MAXCOL,MAXROW,nDestTab,
									IDF_NONE, sal_False, pUndoDoc );

			// alle Formeln
			aDocument.CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTabCount-1,
										IDF_FORMULA, sal_False, pUndoDoc );

			// komplette Ausgangszeilen
			aDocument.CopyToDocument( 0,aDestArea.nRowStart,nDestTab,
									MAXCOL,aDestArea.nRowEnd,nDestTab,
									IDF_ALL, sal_False, pUndoDoc );

			// alten Ausgabebereich
			if (pDestData)
				aDocument.CopyToDocument( aOldDest, IDF_ALL, sal_False, pUndoDoc );

			GetUndoManager()->AddUndoAction(
					new ScUndoConsolidate( this, aDestArea, rParam, pUndoDoc,
											sal_True, nInsertCount, pUndoTab, pUndoData ) );
		}
		else
		{
			ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
			pUndoDoc->InitUndo( &aDocument, aDestArea.nTab, aDestArea.nTab );

			aDocument.CopyToDocument( aDestArea.nColStart, aDestArea.nRowStart, aDestArea.nTab,
									aDestArea.nColEnd, aDestArea.nRowEnd, aDestArea.nTab,
									IDF_ALL, sal_False, pUndoDoc );

			// alten Ausgabebereich
			if (pDestData)
				aDocument.CopyToDocument( aOldDest, IDF_ALL, sal_False, pUndoDoc );

			GetUndoManager()->AddUndoAction(
					new ScUndoConsolidate( this, aDestArea, rParam, pUndoDoc,
											sal_False, 0, NULL, pUndoData ) );
		}
	}

	if (pDestData)										// Zielbereich loeschen / anpassen
	{
		aDocument.DeleteAreaTab(aOldDest, IDF_CONTENTS);
		pDestData->SetArea( rParam.nTab, rParam.nCol, rParam.nRow,
							rParam.nCol + nColSize - 1, rParam.nRow + nRowSize - 1 );
		pDestData->SetHeader( rParam.bByRow );
	}

	aData.OutputToDocument( &aDocument, rParam.nCol, rParam.nRow, rParam.nTab );

	SCCOL nPaintStartCol = rParam.nCol;
	SCROW nPaintStartRow = rParam.nRow;
	SCCOL nPaintEndCol = nPaintStartCol + nColSize - 1;
	SCROW nPaintEndRow = nPaintStartRow + nRowSize - 1;
	sal_uInt16 nPaintFlags = PAINT_GRID;
	if (rParam.bByCol)
		++nPaintEndRow;
	if (rParam.bByRow)
		++nPaintEndCol;
	if (rParam.bReferenceData)
	{
		nPaintStartCol = 0;
		nPaintEndCol = MAXCOL;
		nPaintEndRow = MAXROW;
		nPaintFlags |= PAINT_LEFT | PAINT_SIZE;
	}
	if (pDestData)
	{
		if ( aOldDest.aEnd.Col() > nPaintEndCol )
			nPaintEndCol = aOldDest.aEnd.Col();
		if ( aOldDest.aEnd.Row() > nPaintEndRow )
			nPaintEndRow = aOldDest.aEnd.Row();
	}
	PostPaint( nPaintStartCol, nPaintStartRow, rParam.nTab,
				nPaintEndCol, nPaintEndRow, rParam.nTab, nPaintFlags );
	aModificator.SetDocumentModified();
}

void ScDocShell::UseScenario( SCTAB nTab, const String& rName, sal_Bool bRecord )
{
	if (!aDocument.IsScenario(nTab))
	{
		SCTAB	nTabCount = aDocument.GetTableCount();
		SCTAB	nSrcTab = SCTAB_MAX;
		SCTAB	nEndTab = nTab;
		String aCompare;
		while ( nEndTab+1 < nTabCount && aDocument.IsScenario(nEndTab+1) )
		{
			++nEndTab;
			if (nSrcTab > MAXTAB)			// noch auf der Suche nach dem Szenario?
			{
				aDocument.GetName( nEndTab, aCompare );
				if (aCompare == rName)
					nSrcTab = nEndTab;		// gefunden
			}
		}
		if (ValidTab(nSrcTab))
		{
			if ( aDocument.TestCopyScenario( nSrcTab, nTab ) )			// Zellschutz testen
			{
				ScDocShellModificator aModificator( *this );
				ScMarkData aScenMark;
				aDocument.MarkScenario( nSrcTab, nTab, aScenMark );
				ScRange aMultiRange;
				aScenMark.GetMultiMarkArea( aMultiRange );
				SCCOL nStartCol = aMultiRange.aStart.Col();
				SCROW nStartRow = aMultiRange.aStart.Row();
				SCCOL nEndCol = aMultiRange.aEnd.Col();
				SCROW nEndRow = aMultiRange.aEnd.Row();

				if (bRecord)
				{
					ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
					pUndoDoc->InitUndo( &aDocument, nTab,nEndTab );				// auch alle Szenarien
					//	angezeigte Tabelle:
					aDocument.CopyToDocument( nStartCol,nStartRow,nTab,
									nEndCol,nEndRow,nTab, IDF_ALL,sal_True, pUndoDoc, &aScenMark );
					//	Szenarien
					for (SCTAB i=nTab+1; i<=nEndTab; i++)
					{
						pUndoDoc->SetScenario( i, sal_True );
						String aComment;
						Color  aColor;
						sal_uInt16 nScenFlags;
						aDocument.GetScenarioData( i, aComment, aColor, nScenFlags );
						pUndoDoc->SetScenarioData( i, aComment, aColor, nScenFlags );
						sal_Bool bActive = aDocument.IsActiveScenario( i );
						pUndoDoc->SetActiveScenario( i, bActive );
						//	Bei Zurueckkopier-Szenarios auch Inhalte
						if ( nScenFlags & SC_SCENARIO_TWOWAY )
							aDocument.CopyToDocument( 0,0,i, MAXCOL,MAXROW,i,
														IDF_ALL,sal_False, pUndoDoc );
					}

					GetUndoManager()->AddUndoAction(
						new ScUndoUseScenario( this, aScenMark,
										ScArea( nTab,nStartCol,nStartRow,nEndCol,nEndRow ),
										pUndoDoc, rName ) );
				}

				aDocument.CopyScenario( nSrcTab, nTab );
				aDocument.SetDirty();

				//	alles painten, weil in anderen Bereichen das aktive Szenario
				//	geaendert sein kann
				//!	nur, wenn sichtbare Rahmen vorhanden?
				PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );
				aModificator.SetDocumentModified();
			}
			else
			{
				InfoBox aBox(GetActiveDialogParent(),
					ScGlobal::GetRscString( STR_PROTECTIONERR ) );
				aBox.Execute();
			}
		}
		else
		{
			InfoBox aBox(GetActiveDialogParent(),
				ScGlobal::GetRscString( STR_SCENARIO_NOTFOUND ) );
			aBox.Execute();
		}
	}
	else
	{
		DBG_ERROR( "UseScenario auf Szenario-Blatt" );
	}
}

void ScDocShell::ModifyScenario( SCTAB nTab, const String& rName, const String& rComment,
									const Color& rColor, sal_uInt16 nFlags )
{
	//	Undo
	String aOldName;
	aDocument.GetName( nTab, aOldName );
	String aOldComment;
	Color aOldColor;
	sal_uInt16 nOldFlags;
	aDocument.GetScenarioData( nTab, aOldComment, aOldColor, nOldFlags );
	GetUndoManager()->AddUndoAction(
		new ScUndoScenarioFlags( this, nTab,
				aOldName, rName, aOldComment, rComment,
				aOldColor, rColor, nOldFlags, nFlags ) );

	//	ausfuehren
	ScDocShellModificator aModificator( *this );
	aDocument.RenameTab( nTab, rName );
	aDocument.SetScenarioData( nTab, rComment, rColor, nFlags );
	PostPaintGridAll();
	aModificator.SetDocumentModified();

	if ( rName != aOldName )
		SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );

	SfxBindings* pBindings = GetViewBindings();
	if (pBindings)
		pBindings->Invalidate( SID_SELECT_SCENARIO );
}

SCTAB ScDocShell::MakeScenario( SCTAB nTab, const String& rName, const String& rComment,
									const Color& rColor, sal_uInt16 nFlags,
									ScMarkData& rMark, sal_Bool bRecord )
{
	rMark.MarkToMulti();
	if (rMark.IsMultiMarked())
	{
		SCTAB nNewTab = nTab + 1;
		while (aDocument.IsScenario(nNewTab))
			++nNewTab;

		sal_Bool bCopyAll = ( (nFlags & SC_SCENARIO_COPYALL) != 0 );
		const ScMarkData* pCopyMark = NULL;
		if (!bCopyAll)
			pCopyMark = &rMark;

		ScDocShellModificator aModificator( *this );

        if (bRecord)
            aDocument.BeginDrawUndo();      // drawing layer must do its own undo actions

		if (aDocument.CopyTab( nTab, nNewTab, pCopyMark ))
		{
			if (bRecord)
			{
				GetUndoManager()->AddUndoAction(
                        new ScUndoMakeScenario( this, nTab, nNewTab,
												rName, rComment, rColor, nFlags, rMark ));
			}

			aDocument.RenameTab( nNewTab, rName, sal_False );			// ohne Formel-Update
			aDocument.SetScenario( nNewTab, sal_True );
			aDocument.SetScenarioData( nNewTab, rComment, rColor, nFlags );

			ScMarkData aDestMark = rMark;
			aDestMark.SelectOneTable( nNewTab );

			//!		auf Filter / Buttons / Merging testen !

			ScPatternAttr aProtPattern( aDocument.GetPool() );
			aProtPattern.GetItemSet().Put( ScProtectionAttr( sal_True ) );
			aDocument.ApplyPatternAreaTab( 0,0, MAXCOL,MAXROW, nNewTab, aProtPattern );

			ScPatternAttr aPattern( aDocument.GetPool() );
			aPattern.GetItemSet().Put( ScMergeFlagAttr( SC_MF_SCENARIO ) );
			aPattern.GetItemSet().Put( ScProtectionAttr( sal_True ) );
			aDocument.ApplySelectionPattern( aPattern, aDestMark );

			if (!bCopyAll)
				aDocument.SetVisible( nNewTab, sal_False );

			//	dies ist dann das aktive Szenario
			aDocument.CopyScenario( nNewTab, nTab, sal_True );	// sal_True - nicht aus Szenario kopieren

			if (nFlags & SC_SCENARIO_SHOWFRAME)
				PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );	// Rahmen painten
			PostPaintExtras();											// Tabellenreiter
			aModificator.SetDocumentModified();

			SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );

			return nNewTab;
		}
	}
	return nTab;
}

sal_Bool ScDocShell::MoveTable( SCTAB nSrcTab, SCTAB nDestTab, sal_Bool bCopy, sal_Bool bRecord )
{
	ScDocShellModificator aModificator( *this );

    // #i92477# be consistent with ScDocFunc::InsertTable: any index past the last sheet means "append"
    // #i101139# nDestTab must be the target position, not APPEND (for CopyTabProtection etc.)
    if ( nDestTab >= aDocument.GetTableCount() )
        nDestTab = aDocument.GetTableCount();

	if (bCopy)
	{
		if (bRecord)
			aDocument.BeginDrawUndo();			// drawing layer must do its own undo actions

        String sSrcCodeName;
        aDocument.GetCodeName( nSrcTab, sSrcCodeName );
		if (!aDocument.CopyTab( nSrcTab, nDestTab ))
		{
			//!	EndDrawUndo?
			return sal_False;
		}
		else
		{
			SCTAB nAdjSource = nSrcTab;
			if ( nDestTab <= nSrcTab )
				++nAdjSource;				// new position of source table after CopyTab

			if ( aDocument.IsTabProtected( nAdjSource ) )
                aDocument.CopyTabProtection(nAdjSource, nDestTab);

			if (bRecord)
			{
				SvShorts aSrcList;
				SvShorts aDestList;
				aSrcList.push_front(nSrcTab);
				aDestList.push_front(nDestTab);
				GetUndoManager()->AddUndoAction(
						new ScUndoCopyTab( this, aSrcList, aDestList ) );
			}
			
			sal_Bool bVbaEnabled = aDocument.IsInVBAMode();
                        if ( bVbaEnabled )
                        {
			    StarBASIC* pStarBASIC = GetBasic();
                            String aLibName( RTL_CONSTASCII_USTRINGPARAM( "Standard" ) );
                            if ( GetBasicManager()->GetName().Len() > 0 )
                            {
                                aLibName = GetBasicManager()->GetName();
                                pStarBASIC = GetBasicManager()->GetLib( aLibName );
                            }
                            SCTAB nTabToUse = nDestTab; 
                            if ( nDestTab == SC_TAB_APPEND )
                                nTabToUse = aDocument.GetMaxTableNumber() - 1;
                            String sCodeName;
                            String sSource;
                            com::sun::star::uno::Reference< com::sun::star::script::XLibraryContainer > xLibContainer = GetBasicContainer();
                            com::sun::star::uno::Reference< com::sun::star::container::XNameContainer > xLib;
                            if( xLibContainer.is() )
                            {
                                com::sun::star::uno::Any aLibAny = xLibContainer->getByName( aLibName );
                                aLibAny >>= xLib;
                            }
                            if( xLib.is() )
                            {
                                rtl::OUString sRTLSource;
                                xLib->getByName( sSrcCodeName ) >>= sRTLSource;
                                sSource = sRTLSource;
                            } 
                            VBA_InsertModule( aDocument, nTabToUse, sCodeName, sSource );
                        }
                }
		Broadcast( ScTablesHint( SC_TAB_COPIED, nSrcTab, nDestTab ) );
	}
	else
	{
		if ( aDocument.GetChangeTrack() )
			return sal_False;

		if ( nSrcTab<nDestTab && nDestTab!=SC_TAB_APPEND )
			nDestTab--;

		if ( nSrcTab == nDestTab )
		{
			//!	allow only for api calls?
			return sal_True;	// nothing to do, but valid
		}

		if (!aDocument.MoveTab( nSrcTab, nDestTab ))
			return sal_False;
		else if (bRecord)
		{
			SvShorts aSrcList;
			SvShorts aDestList;
			aSrcList.push_front(nSrcTab);
			aDestList.push_front(nDestTab);
			GetUndoManager()->AddUndoAction(
					new ScUndoMoveTab( this, aSrcList, aDestList ) );
		}

		Broadcast( ScTablesHint( SC_TAB_MOVED, nSrcTab, nDestTab ) );
	}

	PostPaintGridAll();
	PostPaintExtras();
	aModificator.SetDocumentModified();
	SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );

	return sal_True;
}


IMPL_LINK( ScDocShell, RefreshDBDataHdl, ScRefreshTimer*, pRefreshTimer )
{
	ScDBDocFunc aFunc(*this);

	sal_Bool bContinue = sal_True;
    ScDBData* pDBData = static_cast<ScDBData*>(pRefreshTimer);
	ScImportParam aImportParam;
	pDBData->GetImportParam( aImportParam );
	if (aImportParam.bImport && !pDBData->HasImportSelection())
	{
		ScRange aRange;
		pDBData->GetArea( aRange );
        bContinue = aFunc.DoImport( aRange.aStart.Tab(), aImportParam, NULL, sal_True, sal_False ); //! Api-Flag as parameter
		// internal operations (sort, query, subtotal) only if no error
		if (bContinue)
		{
			aFunc.RepeatDB( pDBData->GetName(), sal_True, sal_True );
			RefreshPivotTables(aRange);
		}
	}

	return bContinue != 0;
}