| /************************************************************** | |
| * | |
| * 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 <tools/urlobj.hxx> | |
| #include <svx/dataaccessdescriptor.hxx> | |
| #include <sfx2/viewfrm.hxx> | |
| #include <com/sun/star/document/XLinkAuthorizer.hpp> | |
| #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(); | |
| INetURLObject aURL( rParam.aDBName ); | |
| if ( aURL.GetProtocol() != INET_PROT_NOT_VALID ) { | |
| ::com::sun::star::uno::Reference< ::com::sun::star::document::XLinkAuthorizer > xLinkAuthorizer( pDoc->GetDocumentShell()->GetModel(), ::com::sun::star::uno::UNO_QUERY ); | |
| if ( xLinkAuthorizer.is() && ! xLinkAuthorizer->authorizeLinks( rParam.aDBName ) ) { | |
| return sal_False; | |
| } | |
| } | |
| 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; | |
| } |