/**************************************************************
 * 
 * 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"



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

#include <comphelper/processfactory.hxx>
#include <comphelper/types.hxx>
#include <vcl/msgbox.hxx>
#include <tools/debug.hxx>
#include <svx/dataaccessdescriptor.hxx>
#include <sfx2/viewfrm.hxx>

#include <com/sun/star/sdb/CommandType.hpp>
#include <com/sun/star/sdb/XCompletedExecution.hpp>
#include <com/sun/star/sdbc/XRow.hpp>
#include <com/sun/star/sdbc/XRowSet.hpp>
#include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp>
#include <com/sun/star/sdbcx/XRowLocate.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/frame/XDispatchProvider.hpp>
#include <com/sun/star/frame/FrameSearchFlag.hpp>
#include <com/sun/star/view/XSelectionSupplier.hpp>


#include "dbdocfun.hxx"
#include "docsh.hxx"
#include "globstr.hrc"
#include "scerrors.hxx"
#include "dbcolect.hxx"
#include "markdata.hxx"
#include "undodat.hxx"
#include "progress.hxx"
#include "patattr.hxx"
#include "docpool.hxx"
#include "attrib.hxx"
#include "dbdocutl.hxx"
#include "editable.hxx"
#include "hints.hxx"
#include "miscuno.hxx"

using namespace com::sun::star;

#define SC_SERVICE_ROWSET			"com.sun.star.sdb.RowSet"
#define SC_SERVICE_INTHANDLER		"com.sun.star.task.InteractionHandler"

//!	move to a header file?
#define SC_DBPROP_DATASOURCENAME	"DataSourceName"
#define SC_DBPROP_COMMAND			"Command"
#define SC_DBPROP_COMMANDTYPE		"CommandType"
#define SC_DBPROP_SELECTION			"Selection"
#define SC_DBPROP_CURSOR			"Cursor"

// static
void ScDBDocFunc::ShowInBeamer( const ScImportParam& rParam, SfxViewFrame* pFrame )
{
	//	called after opening the database beamer

	if ( !pFrame || !rParam.bImport )
		return;

	uno::Reference<frame::XFrame> xFrame = pFrame->GetFrame().GetFrameInterface();
	uno::Reference<frame::XDispatchProvider> xDP(xFrame, uno::UNO_QUERY);

	uno::Reference<frame::XFrame> xBeamerFrame = xFrame->findFrame(
										rtl::OUString::createFromAscii("_beamer"),
										frame::FrameSearchFlag::CHILDREN);
	if (xBeamerFrame.is())
	{
		uno::Reference<frame::XController> xController = xBeamerFrame->getController();
		uno::Reference<view::XSelectionSupplier> xControllerSelection(xController, uno::UNO_QUERY);
		if (xControllerSelection.is())
		{
			sal_Int32 nType = rParam.bSql ? sdb::CommandType::COMMAND :
						( (rParam.nType == ScDbQuery) ? sdb::CommandType::QUERY :
														sdb::CommandType::TABLE );

            ::svx::ODataAccessDescriptor aSelection;
            aSelection.setDataSource(rtl::OUString( rParam.aDBName ));
            aSelection[svx::daCommand]      <<= rtl::OUString( rParam.aStatement );
            aSelection[svx::daCommandType]  <<= nType;

			xControllerSelection->select(uno::makeAny(aSelection.createPropertyValueSequence()));
		}
		else
		{
			DBG_ERROR("no selection supplier in the beamer!");
		}
	}
}

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

sal_Bool ScDBDocFunc::DoImportUno( const ScAddress& rPos,
								const uno::Sequence<beans::PropertyValue>& aArgs )
{
    svx::ODataAccessDescriptor aDesc( aArgs );      // includes selection and result set

    //  create database range
	ScDBData* pDBData = rDocShell.GetDBData( ScRange(rPos), SC_DB_IMPORT, SC_DBSEL_KEEP );
	DBG_ASSERT(pDBData, "can't create DB data");
	String sTarget = pDBData->GetName();

    UpdateImport( sTarget, aDesc );

	return sal_True;
}

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

sal_Bool ScDBDocFunc::DoImport( SCTAB nTab, const ScImportParam& rParam,
        const svx::ODataAccessDescriptor* pDescriptor, sal_Bool bRecord, sal_Bool bAddrInsert )
{
	ScDocument* pDoc = rDocShell.GetDocument();

	if (bRecord && !pDoc->IsUndoEnabled())
		bRecord = sal_False;

	ScDBData* pDBData = 0;
	if ( !bAddrInsert )
	{
		pDBData = pDoc->GetDBAtArea( nTab, rParam.nCol1, rParam.nRow1,
											rParam.nCol2, rParam.nRow2 );
		if (!pDBData)
		{
			DBG_ERROR( "DoImport: no DBData" );
			return sal_False;
		}
	}

	Window* pWaitWin = rDocShell.GetActiveDialogParent();
	if (pWaitWin)
		pWaitWin->EnterWait();
	ScDocShellModificator aModificator( rDocShell );

	sal_Bool bSuccess = sal_False;
	sal_Bool bApi = sal_False;						//! pass as argument
	sal_Bool bTruncated = sal_False;				// for warning
	sal_uInt16 nErrStringId = 0;
	String aErrorMessage;

	SCCOL nCol = rParam.nCol1;
	SCROW nRow = rParam.nRow1;
	SCCOL nEndCol = nCol;					// end of resulting database area
	SCROW nEndRow = nRow;
	long i;

	sal_Bool bDoSelection = sal_False;
	sal_Bool bRealSelection = sal_False;			// sal_True if not everything is selected
    sal_Bool bBookmarkSelection = sal_False;
    sal_Int32 nListPos = 0;
    sal_Int32 nRowsRead = 0;
    sal_Int32 nListCount = 0;

    uno::Sequence<uno::Any> aSelection;
    if ( pDescriptor && pDescriptor->has(svx::daSelection) )
    {
        (*pDescriptor)[svx::daSelection] >>= aSelection;
        nListCount = aSelection.getLength();
        if ( nListCount > 0 )
        {
            bDoSelection = sal_True;
            if ( pDescriptor->has(svx::daBookmarkSelection) )
                bBookmarkSelection = ScUnoHelpFunctions::GetBoolFromAny( (*pDescriptor)[svx::daBookmarkSelection] );
            if ( bBookmarkSelection )
            {
                // From bookmarks, there's no way to detect if all records are selected.
                // Rely on base to pass no selection in that case.
                bRealSelection = sal_True;
            }
        }
    }

    uno::Reference<sdbc::XResultSet> xResultSet;
    if ( pDescriptor && pDescriptor->has(svx::daCursor) )
        xResultSet.set((*pDescriptor)[svx::daCursor], uno::UNO_QUERY);

	// ImportDoc - also used for Redo
	ScDocument* pImportDoc = new ScDocument( SCDOCMODE_UNDO );
	pImportDoc->InitUndo( pDoc, nTab, nTab );
	ScColumn::bDoubleAlloc = sal_True;

	//
	//	get data from database into import document
	//

	try
	{
		//	progress bar
		//	only text (title is still needed, for the cancel button)
		ScProgress aProgress( &rDocShell, ScGlobal::GetRscString(STR_UNDO_IMPORTDATA), 0 );
		sal_uInt16 nInserted = 0;

        uno::Reference<sdbc::XRowSet> xRowSet = uno::Reference<sdbc::XRowSet>(
                xResultSet, uno::UNO_QUERY );
        sal_Bool bDispose = sal_False;
        if ( !xRowSet.is() )
        {
            bDispose = sal_True;
            xRowSet = uno::Reference<sdbc::XRowSet>(
                    comphelper::getProcessServiceFactory()->createInstance(
                        rtl::OUString::createFromAscii( SC_SERVICE_ROWSET ) ),
                    uno::UNO_QUERY);
            uno::Reference<beans::XPropertySet> xRowProp( xRowSet, uno::UNO_QUERY );
            DBG_ASSERT( xRowProp.is(), "can't get RowSet" );
            if ( xRowProp.is() )
            {
                //
                //	set source parameters
                //

                sal_Int32 nType = rParam.bSql ? sdb::CommandType::COMMAND :
                            ( (rParam.nType == ScDbQuery) ? sdb::CommandType::QUERY :
                                                            sdb::CommandType::TABLE );
                uno::Any aAny;

                aAny <<= rtl::OUString( rParam.aDBName );
                xRowProp->setPropertyValue(
                            rtl::OUString::createFromAscii(SC_DBPROP_DATASOURCENAME), aAny );

                aAny <<= rtl::OUString( rParam.aStatement );
                xRowProp->setPropertyValue(
                            rtl::OUString::createFromAscii(SC_DBPROP_COMMAND), aAny );

                aAny <<= nType;
                xRowProp->setPropertyValue(
                            rtl::OUString::createFromAscii(SC_DBPROP_COMMANDTYPE), aAny );

                uno::Reference<sdb::XCompletedExecution> xExecute( xRowSet, uno::UNO_QUERY );
                if ( xExecute.is() )
                {
                    uno::Reference<task::XInteractionHandler> xHandler(
                            comphelper::getProcessServiceFactory()->createInstance(
                                rtl::OUString::createFromAscii( SC_SERVICE_INTHANDLER ) ),
                            uno::UNO_QUERY);
                    xExecute->executeWithCompletion( xHandler );
                }
                else
                    xRowSet->execute();
            }
        }
        if ( xRowSet.is() )
        {
			//
			//	get column descriptions
			//

			long nColCount = 0;
			uno::Reference<sdbc::XResultSetMetaData> xMeta;
			uno::Reference<sdbc::XResultSetMetaDataSupplier> xMetaSupp( xRowSet, uno::UNO_QUERY );
			if ( xMetaSupp.is() )
				xMeta = xMetaSupp->getMetaData();
			if ( xMeta.is() )
				nColCount = xMeta->getColumnCount();	// this is the number of real columns

			if ( rParam.nCol1 + nColCount - 1 > MAXCOL )
			{
				nColCount = 0;
				//!	error message
			}

            uno::Reference<sdbcx::XRowLocate> xLocate;
            if ( bBookmarkSelection )
            {
                xLocate.set( xRowSet, uno::UNO_QUERY );
                if ( !xLocate.is() )
                {
                    DBG_ERRORFILE("can't get XRowLocate");
                    bDoSelection = bRealSelection = bBookmarkSelection = sal_False;
                }
            }

			uno::Reference<sdbc::XRow> xRow( xRowSet, uno::UNO_QUERY );
			if ( nColCount > 0 && xRow.is() )
			{
				nEndCol = (SCCOL)( rParam.nCol1 + nColCount - 1 );

				uno::Sequence<sal_Int32> aColTypes( nColCount );	// column types
				uno::Sequence<sal_Bool> aColCurr( nColCount );		// currency flag is not in types
				sal_Int32* pTypeArr = aColTypes.getArray();
				sal_Bool* pCurrArr = aColCurr.getArray();
				for (i=0; i<nColCount; i++)
				{
					pTypeArr[i] = xMeta->getColumnType( i+1 );
					pCurrArr[i] = xMeta->isCurrency( i+1 );
				}

				if ( !bAddrInsert )					// read column names
				{
					nCol = rParam.nCol1;
					for (i=0; i<nColCount; i++)
					{
						pImportDoc->SetString( nCol, nRow, nTab,
												xMeta->getColumnLabel( i+1 ) );
						++nCol;
					}
					++nRow;
				}

				sal_Bool bEnd = sal_False;
				if ( !bDoSelection )
					xRowSet->beforeFirst();
				while ( !bEnd )
				{
					//	skip rows that are not selected
					if ( !bDoSelection )
					{
                        if ( (bEnd = !xRowSet->next()) == sal_False )
							++nRowsRead;
					}
					else
					{
						if (nListPos < nListCount)
						{
                            if ( bBookmarkSelection )
                            {
                                bEnd = !xLocate->moveToBookmark(aSelection[nListPos]);
                            }
                            else    // use record numbers
                            {
                                sal_Int32 nNextRow = 0;
                                aSelection[nListPos] >>= nNextRow;
                                if ( nRowsRead+1 < nNextRow )
                                    bRealSelection = sal_True;
                                bEnd = !xRowSet->absolute(nRowsRead = nNextRow);
                            }
                            ++nListPos;
						}
						else
						{
                            if ( !bBookmarkSelection && xRowSet->next() )
                                bRealSelection = sal_True;                      // more data available but not used
                            bEnd = sal_True;
						}
					}

					if ( !bEnd )
					{
						if ( ValidRow(nRow) )
						{
							nCol = rParam.nCol1;
							for (i=0; i<nColCount; i++)
							{
								ScDatabaseDocUtil::PutData( pImportDoc, nCol, nRow, nTab,
												xRow, i+1, pTypeArr[i], pCurrArr[i] );
								++nCol;
							}
							nEndRow = nRow;
							++nRow;

							//	progress bar

							++nInserted;
							if (!(nInserted & 15))
							{
								String aPict = ScGlobal::GetRscString( STR_PROGRESS_IMPORT );
								String aText = aPict.GetToken(0,'#');
								aText += String::CreateFromInt32( nInserted );
								aText += aPict.GetToken(1,'#');

								if (!aProgress.SetStateText( 0, aText ))	// stopped by user?
								{
									bEnd = sal_True;
									bSuccess = sal_False;
									nErrStringId = STR_DATABASE_ABORTED;
								}
							}
						}
						else		// past the end of the spreadsheet
						{
							bEnd = sal_True;			// don't continue
							bTruncated = sal_True;		// warning flag
						}
					}
				}

				bSuccess = sal_True;
			}

            if ( bDispose )
                ::comphelper::disposeComponent( xRowSet );
		}
	}
	catch ( sdbc::SQLException& rError )
	{
		aErrorMessage = rError.Message;
	}
	catch ( uno::Exception& )
	{
		DBG_ERROR("Unexpected exception in database");
	}

	ScColumn::bDoubleAlloc = sal_False;
	pImportDoc->DoColResize( nTab, rParam.nCol1,nEndCol, 0 );

	//
	//	test for cell protection
	//

	sal_Bool bKeepFormat = !bAddrInsert && pDBData->IsKeepFmt();
	sal_Bool bMoveCells = !bAddrInsert && pDBData->IsDoSize();
	SCCOL nFormulaCols = 0;	// columns to be filled with formulas
	if (bMoveCells && nEndCol == rParam.nCol2)
	{
		//	if column count changes, formulas would become invalid anyway
		//	-> only set nFormulaCols for unchanged column count

		SCCOL nTestCol = rParam.nCol2 + 1;		// right of the data
		SCROW nTestRow = rParam.nRow1 + 1;		// below the title row
		while ( nTestCol <= MAXCOL &&
				pDoc->GetCellType(ScAddress( nTestCol, nTestRow, nTab )) == CELLTYPE_FORMULA )
			++nTestCol, ++nFormulaCols;
	}

	if (bSuccess)
	{
		//	old and new range editable?
		ScEditableTester aTester;
		aTester.TestBlock( pDoc, nTab, rParam.nCol1,rParam.nRow1,rParam.nCol2,rParam.nRow2 );
		aTester.TestBlock( pDoc, nTab, rParam.nCol1,rParam.nRow1,nEndCol,nEndRow );
		if ( !aTester.IsEditable() )
		{
			nErrStringId = aTester.GetMessageId();
			bSuccess = sal_False;
		}
		else if ( pDoc->GetChangeTrack() != NULL )
		{
			nErrStringId = STR_PROTECTIONERR;
			bSuccess = sal_False;
		}
	}

	if ( bSuccess && bMoveCells )
	{
		ScRange aOld( rParam.nCol1, rParam.nRow1, nTab,
						rParam.nCol2+nFormulaCols, rParam.nRow2, nTab );
		ScRange aNew( rParam.nCol1, rParam.nRow1, nTab,
						nEndCol+nFormulaCols, nEndRow, nTab );
		if (!pDoc->CanFitBlock( aOld, aNew ))
		{
			nErrStringId = STR_MSSG_DOSUBTOTALS_2;		// can't insert cells
			bSuccess = sal_False;
		}
	}

	//
	//	copy data from import doc into real document
	//

	if ( bSuccess )
	{
		if (bKeepFormat)
		{
			//	keep formatting of title and first data row from the document
			//	CopyToDocument also copies styles, Apply... needs separate calls

			SCCOL nMinEndCol = Min( rParam.nCol2, nEndCol );	// not too much
            nMinEndCol = sal::static_int_cast<SCCOL>( nMinEndCol + nFormulaCols );  // only if column count unchanged
			pImportDoc->DeleteAreaTab( 0,0, MAXCOL,MAXROW, nTab, IDF_ATTRIB );
			pDoc->CopyToDocument( rParam.nCol1, rParam.nRow1, nTab,
									nMinEndCol, rParam.nRow1, nTab,
									IDF_ATTRIB, sal_False, pImportDoc );

			SCROW nDataStartRow = rParam.nRow1+1;
			for (SCCOL nCopyCol=rParam.nCol1; nCopyCol<=nMinEndCol; nCopyCol++)
			{
				const ScPatternAttr* pSrcPattern = pDoc->GetPattern(
													nCopyCol, nDataStartRow, nTab );
				pImportDoc->ApplyPatternAreaTab( nCopyCol, nDataStartRow, nCopyCol, nEndRow,
													nTab, *pSrcPattern );
				const ScStyleSheet* pStyle = pSrcPattern->GetStyleSheet();
				if (pStyle)
					pImportDoc->ApplyStyleAreaTab( nCopyCol, nDataStartRow, nCopyCol, nEndRow,
													nTab, *pStyle );
			}
		}

		//	don't set cell protection attribute if table is protected
		if (pDoc->IsTabProtected(nTab))
		{
			ScPatternAttr aPattern(pImportDoc->GetPool());
			aPattern.GetItemSet().Put( ScProtectionAttr( sal_False,sal_False,sal_False,sal_False ) );
			pImportDoc->ApplyPatternAreaTab( 0,0,MAXCOL,MAXROW, nTab, aPattern );
		}

		//
		//	copy old data for undo
		//

		SCCOL nUndoEndCol = Max( nEndCol, rParam.nCol2 );		// rParam = old end
		SCROW nUndoEndRow = Max( nEndRow, rParam.nRow2 );

		ScDocument* pUndoDoc = NULL;
		ScDBData* pUndoDBData = NULL;
		if ( bRecord )
		{
			pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
			pUndoDoc->InitUndo( pDoc, nTab, nTab );

			if ( !bAddrInsert )
				pUndoDBData = new ScDBData( *pDBData );
		}

		ScMarkData aNewMark;
		aNewMark.SelectOneTable( nTab );

		if (bRecord)
		{
            // do not touch notes (ScUndoImportData does not support drawing undo)
            sal_uInt16 nCopyFlags = IDF_ALL & ~IDF_NOTE;

			//	nFormulaCols is set only if column count is unchanged
			pDoc->CopyToDocument( rParam.nCol1, rParam.nRow1, nTab,
									nEndCol+nFormulaCols, nEndRow, nTab,
                                    nCopyFlags, sal_False, pUndoDoc );
			if ( rParam.nCol2 > nEndCol )
				pDoc->CopyToDocument( nEndCol+1, rParam.nRow1, nTab,
										nUndoEndCol, nUndoEndRow, nTab,
                                        nCopyFlags, sal_False, pUndoDoc );
			if ( rParam.nRow2 > nEndRow )
				pDoc->CopyToDocument( rParam.nCol1, nEndRow+1, nTab,
										nUndoEndCol+nFormulaCols, nUndoEndRow, nTab,
                                        nCopyFlags, sal_False, pUndoDoc );
		}

		//
		//	move new data
		//

		if (bMoveCells)
		{
			//	clear only the range without the formulas,
			//	so the formula title and first row are preserved

			ScRange aDelRange( rParam.nCol1, rParam.nRow1, nTab,
								rParam.nCol2, rParam.nRow2, nTab );
            pDoc->DeleteAreaTab( aDelRange, IDF_ALL & ~IDF_NOTE );  // ohne die Formeln

			ScRange aOld( rParam.nCol1, rParam.nRow1, nTab,
							rParam.nCol2+nFormulaCols, rParam.nRow2, nTab );
			ScRange aNew( rParam.nCol1, rParam.nRow1, nTab,
							nEndCol+nFormulaCols, nEndRow, nTab );
			pDoc->FitBlock( aOld, aNew, sal_False );		// Formeln nicht loeschen
		}
		else if ( nEndCol < rParam.nCol2 )		// DeleteArea calls PutInOrder
			pDoc->DeleteArea( nEndCol+1, rParam.nRow1, rParam.nCol2, rParam.nRow2,
                                aNewMark, IDF_CONTENTS & ~IDF_NOTE );

		//	CopyToDocument doesn't remove contents
        pDoc->DeleteAreaTab( rParam.nCol1, rParam.nRow1, nEndCol, nEndRow, nTab, IDF_CONTENTS & ~IDF_NOTE );

		//	#41216# remove each column from ImportDoc after copying to reduce memory usage
		sal_Bool bOldAutoCalc = pDoc->GetAutoCalc();
		pDoc->SetAutoCalc( sal_False );				// outside of the loop
		for (SCCOL nCopyCol = rParam.nCol1; nCopyCol <= nEndCol; nCopyCol++)
		{
			pImportDoc->CopyToDocument( nCopyCol, rParam.nRow1, nTab, nCopyCol, nEndRow, nTab,
										IDF_ALL, sal_False, pDoc );
			pImportDoc->DeleteAreaTab( nCopyCol, rParam.nRow1, nCopyCol, nEndRow, nTab, IDF_CONTENTS );
			pImportDoc->DoColResize( nTab, nCopyCol, nCopyCol, 0 );
		}
		pDoc->SetAutoCalc( bOldAutoCalc );

		if (nFormulaCols > 0)				// copy formulas
		{
			if (bKeepFormat)			// formats for formulas
				pImportDoc->CopyToDocument( nEndCol+1, rParam.nRow1, nTab,
											nEndCol+nFormulaCols, nEndRow, nTab,
											IDF_ATTRIB, sal_False, pDoc );
			// fill formulas
			ScMarkData aMark;
			aMark.SelectOneTable(nTab);
			pDoc->Fill( nEndCol+1, rParam.nRow1+1, nEndCol+nFormulaCols, rParam.nRow1+1,
							aMark, nEndRow-rParam.nRow1-1, FILL_TO_BOTTOM, FILL_SIMPLE );
		}

		//	if new range is smaller, clear old contents

		if (!bMoveCells)		// move has happened above
		{
			if ( rParam.nCol2 > nEndCol )
				pDoc->DeleteArea( nEndCol+1, rParam.nRow1, rParam.nCol2, rParam.nRow2,
									aNewMark, IDF_CONTENTS );
			if ( rParam.nRow2 > nEndRow )
				pDoc->DeleteArea( rParam.nCol1, nEndRow+1, rParam.nCol2, rParam.nRow2,
									aNewMark, IDF_CONTENTS );
		}

		if( !bAddrInsert )		// update database range
		{
			pDBData->SetImportParam( rParam );
			pDBData->SetHeader( sal_True );
			pDBData->SetByRow( sal_True );
			pDBData->SetArea( nTab, rParam.nCol1,rParam.nRow1, nEndCol,nEndRow );
			pDBData->SetImportSelection( bRealSelection );
			pDoc->CompileDBFormula();
		}

		if (bRecord)
		{
			ScDocument* pRedoDoc = pImportDoc;
			pImportDoc = NULL;

			if (nFormulaCols > 0)					// include filled formulas for redo
				pDoc->CopyToDocument( rParam.nCol1, rParam.nRow1, nTab,
										nEndCol+nFormulaCols, nEndRow, nTab,
                                        IDF_ALL & ~IDF_NOTE, sal_False, pRedoDoc );

			ScDBData* pRedoDBData = pDBData ? new ScDBData( *pDBData ) : NULL;

			rDocShell.GetUndoManager()->AddUndoAction(
				new ScUndoImportData( &rDocShell, nTab,
										rParam, nUndoEndCol, nUndoEndRow,
										nFormulaCols,
										pUndoDoc, pRedoDoc, pUndoDBData, pRedoDBData ) );
		}

		pDoc->SetDirty();
		rDocShell.PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );
		aModificator.SetDocumentModified();

	    ScDBRangeRefreshedHint aHint( rParam );
	    pDoc->BroadcastUno( aHint );

		if (pWaitWin)
			pWaitWin->LeaveWait();

		if ( bTruncated && !bApi )			// show warning
			ErrorHandler::HandleError(SCWARN_IMPORT_RANGE_OVERFLOW);
	}
	else if ( !bApi )
	{
		if (pWaitWin)
			pWaitWin->LeaveWait();

		if (!aErrorMessage.Len())
		{
			if (!nErrStringId)
				nErrStringId = STR_MSSG_IMPORTDATA_0;
			aErrorMessage = ScGlobal::GetRscString( nErrStringId );
		}
		InfoBox aInfoBox( rDocShell.GetActiveDialogParent(), aErrorMessage );
		aInfoBox.Execute();
	}

	delete pImportDoc;

	return bSuccess;
}