mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
0cc79b39452cf534a249102ac56c40a114db1f3d
libreoffice/sc/source/ui/docshell/dbdocimp.cxx

717 lines
26 KiB
C++
Raw Normal View History

initial import
2000-09-18 16:07:07 +00:00
/*************************************************************************
*
* $RCSfile: dbdocimp.cxx,v $
*
* $Revision: 1.1.1.1 $
*
* last change: $Author: hr $ $Date: 2000-09-18 16:44:55 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (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.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#ifdef PCH
#include "ui_pch.hxx"
#endif
#pragma hdrstop
// INCLUDE ---------------------------------------------------------
#include <unotools/processfactory.hxx>
#include <vcl/msgbox.hxx>
#include <sdb/sdbstat.hxx> // DBObject enum values
#include <tools/debug.hxx>
#include <svtools/zforlist.hxx>
#include <offmgr/sbaitems.hxx> // SbaSelectionList
#include <com/sun/star/sdb/CommandType.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/sdbc/DataType.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include "dbdocfun.hxx"
#include "docsh.hxx"
#include "globstr.hrc"
#include "scerrors.hxx"
#include "cell.hxx"
#include "compiler.hxx"
#include "dbcolect.hxx"
#include "markdata.hxx"
#include "undodat.hxx"
#include "progress.hxx"
#include "patattr.hxx"
#include "docpool.hxx"
#include "attrib.hxx"
using namespace com::sun::star;
#define SC_SERVICE_ROWSET "com.sun.star.sdb.RowSet"
//! move to a header file?
#define SC_DBPROP_DATASOURCENAME "DataSourceName"
#define SC_DBPROP_COMMAND "Command"
#define SC_DBPROP_COMMANDTYPE "CommandType"
#define D_TIMEFACTOR 86400.0
// -----------------------------------------------------------------
void lcl_PutData( ScDocument* pDoc, USHORT nCol, USHORT nRow, USHORT nTab,
const uno::Reference<sdbc::XRow>& xRow, long nRowPos,
long nType, BOOL bCurrency )
{
String aString;
double nVal = 0.0;
BOOL bValue = FALSE;
BOOL bEmptyFlag = FALSE;
BOOL bError = FALSE;
ULONG nFormatIndex = 0;
//! wasNull calls only if null value was found?
try
{
switch ( nType )
{
case sdbc::DataType::BIT:
//! use language from doc (here, date/time and currency)?
nFormatIndex = pDoc->GetFormatTable()->GetStandardFormat(
NUMBERFORMAT_LOGICAL, ScGlobal::eLnge );
nVal = (xRow->getBoolean(nRowPos) ? 1 : 0);
bEmptyFlag = ( nVal == 0.0 ) && xRow->wasNull();
bValue = TRUE;
break;
case sdbc::DataType::TINYINT:
case sdbc::DataType::SMALLINT:
case sdbc::DataType::INTEGER:
case sdbc::DataType::BIGINT:
case sdbc::DataType::FLOAT:
case sdbc::DataType::REAL:
case sdbc::DataType::DOUBLE:
case sdbc::DataType::NUMERIC:
case sdbc::DataType::DECIMAL:
//! do the conversion here?
nVal = xRow->getDouble(nRowPos);
bEmptyFlag = ( nVal == 0.0 ) && xRow->wasNull();
bValue = TRUE;
break;
case sdbc::DataType::CHAR:
case sdbc::DataType::VARCHAR:
case sdbc::DataType::LONGVARCHAR:
aString = xRow->getString(nRowPos);
bEmptyFlag = ( aString.Len() == 0 ) && xRow->wasNull();
break;
case sdbc::DataType::DATE:
{
SvNumberFormatter* pFormTable = pDoc->GetFormatTable();
nFormatIndex = pFormTable->GetStandardFormat(
NUMBERFORMAT_DATE, ScGlobal::eLnge );
util::Date aDate = xRow->getDate(nRowPos);
nVal = Date( aDate.Day, aDate.Month, aDate.Year ) -
*pFormTable->GetNullDate();
bEmptyFlag = xRow->wasNull();
bValue = TRUE;
}
break;
case sdbc::DataType::TIME:
{
SvNumberFormatter* pFormTable = pDoc->GetFormatTable();
nFormatIndex = pFormTable->GetStandardFormat(
NUMBERFORMAT_TIME, ScGlobal::eLnge );
util::Time aTime = xRow->getTime(nRowPos);
nVal = ( aTime.Hours * 3600 + aTime.Minutes * 60 +
aTime.Seconds + aTime.HundredthSeconds / 100.0 ) / D_TIMEFACTOR;
bEmptyFlag = xRow->wasNull();
bValue = TRUE;
}
break;
case sdbc::DataType::TIMESTAMP:
{
SvNumberFormatter* pFormTable = pDoc->GetFormatTable();
nFormatIndex = pFormTable->GetStandardFormat(
NUMBERFORMAT_DATETIME, ScGlobal::eLnge );
util::DateTime aStamp = xRow->getTimestamp(nRowPos);
nVal = ( Date( aStamp.Day, aStamp.Month, aStamp.Year ) -
*pFormTable->GetNullDate() ) +
( aStamp.Hours * 3600 + aStamp.Minutes * 60 +
aStamp.Seconds + aStamp.HundredthSeconds / 100.0 ) / D_TIMEFACTOR;
bEmptyFlag = xRow->wasNull();
bValue = TRUE;
}
break;
case sdbc::DataType::SQLNULL:
bEmptyFlag = TRUE;
break;
case sdbc::DataType::BINARY:
case sdbc::DataType::VARBINARY:
case sdbc::DataType::LONGVARBINARY:
default:
bError = TRUE; // unknown type
}
}
catch ( uno::Exception& )
{
bError = TRUE;
}
if ( bValue && bCurrency )
nFormatIndex = pDoc->GetFormatTable()->GetStandardFormat(
NUMBERFORMAT_CURRENCY, ScGlobal::eLnge );
ScBaseCell* pCell;
if (bEmptyFlag)
{
pCell = NULL;
pDoc->PutCell( nCol, nRow, nTab, pCell );
}
else if (bError)
{
pDoc->SetError( nCol, nRow, nTab, NOVALUE );
}
else if (bValue)
{
pCell = new ScValueCell( nVal );
if (nFormatIndex == 0)
pDoc->PutCell( nCol, nRow, nTab, pCell );
else
pDoc->PutCell( nCol, nRow, nTab, pCell, nFormatIndex );
}
else
{
pCell = ScBaseCell::CreateTextCell( aString, pDoc );
// if ( pSimpleFlag && pCell->GetCellType() == CELLTYPE_EDIT )
// *pSimpleFlag = FALSE;
pDoc->PutCell( nCol, nRow, nTab, pCell );
}
}
// -----------------------------------------------------------------
BOOL ScDBDocFunc::DoImport( USHORT nTab, const ScImportParam& rParam,
const SbaSelectionList* pSelection,
BOOL bRecord, BOOL bAddrInsert )
{
ScDocument* pDoc = rDocShell.GetDocument();
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 FALSE;
}
}
Window* pWaitWin = rDocShell.GetDialogParent();
if (pWaitWin)
pWaitWin->EnterWait();
ScDocShellModificator aModificator( rDocShell );
BOOL bSuccess = FALSE;
BOOL bApi = FALSE; //! pass as argument
BOOL bTruncated = FALSE; // for warning
USHORT nErrStringId = 0;
String aErrorMessage;
USHORT nCol = rParam.nCol1;
USHORT nRow = rParam.nRow1;
USHORT nEndCol = nCol; // end of resulting database area
USHORT nEndRow = nRow;
long i;
BOOL bDoSelection = FALSE;
BOOL bRealSelection = FALSE; // TRUE if not everything is selected
ULONG nListPos = 0;
ULONG nRowsRead = 0;
ULONG nListCount = 0;
// -1 is special
if ( pSelection && pSelection->Count() && (long)pSelection->GetObject(0) != -1L )
{
bDoSelection = TRUE;
nListCount = pSelection->Count();
}
// ImportDoc - also used for Redo
ScDocument* pImportDoc = new ScDocument( SCDOCMODE_UNDO );
pImportDoc->InitUndo( pDoc, nTab, nTab );
ScColumn::bDoubleAlloc = 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 );
USHORT nInserted = 0;
uno::Reference<sdbc::XRowSet> xRowSet(
utl::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 == dbQuery) ? 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 );
xRowSet->execute();
//
// 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<sdbc::XRow> xRow( xRowSet, uno::UNO_QUERY );
if ( nColCount > 0 && xRow.is() )
{
nEndCol = (USHORT)( 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;
}
BOOL bEnd = FALSE;
while ( !bEnd && xRowSet->next() )
{
// skip rows that are not selected
if (bDoSelection)
{
if (nListPos < nListCount)
{
ULONG nNextRow = (ULONG) pSelection->GetObject(nListPos);
while (nRowsRead+1 < nNextRow && !bEnd)
{
bRealSelection = TRUE;
if ( !xRowSet->next() )
bEnd = TRUE;
++nRowsRead;
}
++nListPos;
}
else
{
bRealSelection = TRUE; // more data available but not used
bEnd = TRUE;
}
}
if ( nRow <= MAXROW )
{
nCol = rParam.nCol1;
for (i=0; i<nColCount; i++)
{
lcl_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 = TRUE;
bSuccess = FALSE;
nErrStringId = STR_DATABASE_ABORTED;
}
}
}
else // past the end of the spreadsheet
{
bEnd = TRUE; // don't continue
bTruncated = TRUE; // warning flag
}
}
bSuccess = TRUE;
}
}
}
catch ( sdbc::SQLException& rError )
{
aErrorMessage = rError.Message;
}
catch ( uno::Exception& )
{
DBG_ERROR("Unexpected exception in database");
}
ScColumn::bDoubleAlloc = FALSE;
pImportDoc->DoColResize( nTab, rParam.nCol1,nEndCol, 0 );
//
// test for cell protection
//
BOOL bKeepFormat = !bAddrInsert && pDBData->IsKeepFmt();
BOOL bMoveCells = !bAddrInsert && pDBData->IsDoSize();
USHORT 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
USHORT nTestCol = rParam.nCol2 + 1; // right of the data
USHORT 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?
if ( !pDoc->IsBlockEditable(nTab, rParam.nCol1,rParam.nRow1,rParam.nCol2,rParam.nRow2) ||
!pDoc->IsBlockEditable(nTab, rParam.nCol1,rParam.nRow1,nEndCol,nEndRow) )
{
nErrStringId = STR_PROTECTIONERR;
bSuccess = 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 = 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
USHORT nMinEndCol = Min( rParam.nCol2, nEndCol ); // not too much
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, FALSE, pImportDoc );
USHORT nDataStartRow = rParam.nRow1+1;
for (USHORT 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( FALSE,FALSE,FALSE,FALSE ) );
pImportDoc->ApplyPatternAreaTab( 0,0,MAXCOL,MAXROW, nTab, aPattern );
}
//
// copy old data for undo
//
USHORT nUndoEndCol = Max( nEndCol, rParam.nCol2 ); // rParam = old end
USHORT 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)
{
// nFormulaCols is set only if column count is unchanged
pDoc->CopyToDocument( rParam.nCol1, rParam.nRow1, nTab,
nEndCol+nFormulaCols, nEndRow, nTab,
IDF_ALL, FALSE, pUndoDoc );
if ( rParam.nCol2 > nEndCol )
pDoc->CopyToDocument( nEndCol+1, rParam.nRow1, nTab,
nUndoEndCol, nUndoEndRow, nTab,
IDF_ALL, FALSE, pUndoDoc );
if ( rParam.nRow2 > nEndRow )
pDoc->CopyToDocument( rParam.nCol1, nEndRow+1, nTab,
nUndoEndCol+nFormulaCols, nUndoEndRow, nTab,
IDF_ALL, 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 ); // 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, 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 );
// CopyToDocument doesn't remove contents
pDoc->DeleteAreaTab( rParam.nCol1, rParam.nRow1, nEndCol, nEndRow, nTab, IDF_CONTENTS );
// #41216# remove each column from ImportDoc after copying to reduce memory usage
BOOL bOldAutoCalc = pDoc->GetAutoCalc();
pDoc->SetAutoCalc( FALSE ); // outside of the loop
for (USHORT nCopyCol = rParam.nCol1; nCopyCol <= nEndCol; nCopyCol++)
{
pImportDoc->CopyToDocument( nCopyCol, rParam.nRow1, nTab, nCopyCol, nEndRow, nTab,
IDF_ALL, FALSE, pDoc );
pImportDoc->DeleteAreaTab( nCopyCol, rParam.nRow1, nCopyCol, nEndRow, nTab, IDF_CONTENTS );
pImportDoc->DoColResize( nTab, nCopyCol, nCopyCol, 0 );
}
pDoc->SetAutoCalc( bOldAutoCalc );
if (nFormulaCols) // copy formulas
{
if (bKeepFormat) // formats for formulas
pImportDoc->CopyToDocument( nEndCol+1, rParam.nRow1, nTab,
nEndCol+nFormulaCols, nEndRow, nTab,
IDF_ATTRIB, 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( TRUE );
pDBData->SetByRow( TRUE );
pDBData->SetArea( nTab, rParam.nCol1,rParam.nRow1, nEndCol,nEndRow );
pDBData->SetImportSelection( bRealSelection );
pDoc->CompileDBFormula();
}
if (bRecord)
{
ScDocument* pRedoDoc = pImportDoc;
pImportDoc = NULL;
if (nFormulaCols) // include filled formulas for redo
pDoc->CopyToDocument( rParam.nCol1, rParam.nRow1, nTab,
nEndCol+nFormulaCols, nEndRow, nTab,
IDF_ALL, 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();
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.GetDialogParent(), aErrorMessage );
aInfoBox.Execute();
}
delete pImportDoc;
return bSuccess;
}
Reference in New Issue Copy Permalink