/**************************************************************
*
* 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.
*
*************************************************************/
#include "oox/xls/sheetdatabuffer.hxx"
#include <algorithm>
#include <com/sun/star/sheet/XArrayFormulaTokens.hpp>
#include <com/sun/star/sheet/XCellRangeData.hpp>
#include <com/sun/star/sheet/XFormulaTokens.hpp>
#include <com/sun/star/sheet/XMultipleOperation.hpp>
#include <com/sun/star/sheet/XNamedRange2.hpp>
#include <com/sun/star/table/XCell.hpp>
#include <com/sun/star/text/XText.hpp>
#include <com/sun/star/util/DateTime.hpp>
#include <com/sun/star/util/NumberFormat.hpp>
#include <com/sun/star/util/XMergeable.hpp>
#include <com/sun/star/util/XNumberFormatTypes.hpp>
#include <com/sun/star/util/XNumberFormatsSupplier.hpp>
#include <rtl/ustrbuf.hxx>
#include "oox/helper/containerhelper.hxx"
#include "oox/helper/propertymap.hxx"
#include "oox/helper/propertyset.hxx"
#include "oox/token/tokens.hxx"
#include "oox/xls/addressconverter.hxx"
#include "oox/xls/biffinputstream.hxx"
#include "oox/xls/formulaparser.hxx"
#include "oox/xls/sharedstringsbuffer.hxx"
#include "oox/xls/unitconverter.hxx"
namespace oox {
namespace xls {
// ============================================================================
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::sheet;
using namespace ::com::sun::star::table;
using namespace ::com::sun::star::text;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::util;
using ::rtl::OUString;
using ::rtl::OUStringBuffer;
// ============================================================================
CellModel::CellModel() :
mnCellType( XML_TOKEN_INVALID ),
mnXfId( -1 ),
mbShowPhonetic( false )
{
}
// ----------------------------------------------------------------------------
CellFormulaModel::CellFormulaModel() :
mnFormulaType( XML_TOKEN_INVALID ),
mnSharedId( -1 )
{
}
bool CellFormulaModel::isValidArrayRef( const CellAddress& rCellAddr )
{
return
(maFormulaRef.Sheet == rCellAddr.Sheet) &&
(maFormulaRef.StartColumn == rCellAddr.Column) &&
(maFormulaRef.StartRow == rCellAddr.Row);
}
bool CellFormulaModel::isValidSharedRef( const CellAddress& rCellAddr )
{
return
(maFormulaRef.Sheet == rCellAddr.Sheet) &&
(maFormulaRef.StartColumn <= rCellAddr.Column) && (rCellAddr.Column <= maFormulaRef.EndColumn) &&
(maFormulaRef.StartRow <= rCellAddr.Row) && (rCellAddr.Row <= maFormulaRef.EndRow);
}
// ----------------------------------------------------------------------------
DataTableModel::DataTableModel() :
mb2dTable( false ),
mbRowTable( false ),
mbRef1Deleted( false ),
mbRef2Deleted( false )
{
}
// ============================================================================
namespace {
const sal_Int32 CELLBLOCK_MAXROWS = 16; /// Number of rows in a cell block.
} // namespace
CellBlock::CellBlock( const WorksheetHelper& rHelper, const ValueRange& rColSpan, sal_Int32 nRow ) :
WorksheetHelper( rHelper ),
maRange( rHelper.getSheetIndex(), rColSpan.mnFirst, nRow, rColSpan.mnLast, nRow ),
mnRowLength( rColSpan.mnLast - rColSpan.mnFirst + 1 ),
mnFirstFreeIndex( 0 )
{
maCellArray.realloc( 1 );
maCellArray[ 0 ].realloc( mnRowLength );
mpCurrCellRow = maCellArray[ 0 ].getArray();
}
bool CellBlock::isExpandable( const ValueRange& rColSpan ) const
{
return (maRange.StartColumn == rColSpan.mnFirst) && (maRange.EndColumn == rColSpan.mnLast);
}
bool CellBlock::isBefore( const ValueRange& rColSpan ) const
{
return (maRange.EndColumn < rColSpan.mnLast) ||
((maRange.EndColumn == rColSpan.mnLast) && (maRange.StartColumn != rColSpan.mnFirst));
}
bool CellBlock::contains( sal_Int32 nCol ) const
{
return (maRange.StartColumn <= nCol) && (nCol <= maRange.EndColumn);
}
void CellBlock::insertRichString( const CellAddress& rAddress, const RichStringRef& rxString, const Font* pFirstPortionFont )
{
maRichStrings.push_back( RichStringCell( rAddress, rxString, pFirstPortionFont ) );
}
void CellBlock::startNextRow()
{
// fill last cells in current row with empty strings (placeholder for empty cells)
fillUnusedCells( mnRowLength );
// flush if the cell block reaches maximum size
if( maCellArray.getLength() == CELLBLOCK_MAXROWS )
{
finalizeImport();
maRange.StartRow = ++maRange.EndRow;
maCellArray.realloc( 1 );
mpCurrCellRow = maCellArray[ 0 ].getArray();
}
else
{
// prepare next row
++maRange.EndRow;
sal_Int32 nRowCount = maCellArray.getLength();
maCellArray.realloc( nRowCount + 1 );
maCellArray[ nRowCount ].realloc( mnRowLength );
mpCurrCellRow = maCellArray[ nRowCount ].getArray();
}
mnFirstFreeIndex = 0;
}
Any& CellBlock::getCellAny( sal_Int32 nCol )
{
OSL_ENSURE( contains( nCol ), "CellBlock::getCellAny - invalid column" );
// fill cells before passed column with empty strings (the placeholder for empty cells)
sal_Int32 nIndex = nCol - maRange.StartColumn;
fillUnusedCells( nIndex );
mnFirstFreeIndex = nIndex + 1;
return mpCurrCellRow[ nIndex ];
}
void CellBlock::finalizeImport()
{
// fill last cells in last row with empty strings (placeholder for empty cells)
fillUnusedCells( mnRowLength );
// insert all buffered cells into the Calc sheet
try
{
Reference< XCellRangeData > xRangeData( getCellRange( maRange ), UNO_QUERY_THROW );
xRangeData->setDataArray( maCellArray );
}
catch( Exception& )
{
}
// insert uncacheable cells separately
for( RichStringCellList::const_iterator aIt = maRichStrings.begin(), aEnd = maRichStrings.end(); aIt != aEnd; ++aIt )
putRichString( aIt->maCellAddr, *aIt->mxString, aIt->mpFirstPortionFont );
}
// private --------------------------------------------------------------------
CellBlock::RichStringCell::RichStringCell( const CellAddress& rCellAddr, const RichStringRef& rxString, const Font* pFirstPortionFont ) :
maCellAddr( rCellAddr ),
mxString( rxString ),
mpFirstPortionFont( pFirstPortionFont )
{
}
void CellBlock::fillUnusedCells( sal_Int32 nIndex )
{
if( mnFirstFreeIndex < nIndex )
{
Any* pCellEnd = mpCurrCellRow + nIndex;
for( Any* pCell = mpCurrCellRow + mnFirstFreeIndex; pCell < pCellEnd; ++pCell )
*pCell <<= OUString();
}
}
// ============================================================================
CellBlockBuffer::CellBlockBuffer( const WorksheetHelper& rHelper ) :
WorksheetHelper( rHelper ),
mnCurrRow( -1 )
{
maCellBlockIt = maCellBlocks.end();
}
void CellBlockBuffer::setColSpans( sal_Int32 nRow, const ValueRangeSet& rColSpans )
{
OSL_ENSURE( maColSpans.count( nRow ) == 0, "CellBlockBuffer::setColSpans - multiple column spans for the same row" );
OSL_ENSURE( (mnCurrRow < nRow) && (maColSpans.empty() || (maColSpans.rbegin()->first < nRow)), "CellBlockBuffer::setColSpans - rows are unsorted" );
if( (mnCurrRow < nRow) && (maColSpans.count( nRow ) == 0) )
maColSpans[ nRow ] = rColSpans.getRanges();
}
CellBlock* CellBlockBuffer::getCellBlock( const CellAddress& rCellAddr )
{
OSL_ENSURE( rCellAddr.Row >= mnCurrRow, "CellBlockBuffer::getCellBlock - passed row out of order" );
// prepare cell blocks, if row changes
if( rCellAddr.Row != mnCurrRow )
{
// find colspans for the new row
ColSpanVectorMap::iterator aIt = maColSpans.find( rCellAddr.Row );
/* Gap between rows, or rows out of order, or no colspan
information for the new row found: flush all open cell blocks. */
if( (aIt == maColSpans.end()) || (rCellAddr.Row != mnCurrRow + 1) )
{
finalizeImport();
maCellBlocks.clear();
maCellBlockIt = maCellBlocks.end();
}
/* Prepare matching cell blocks, create new cell blocks, finalize
unmatching cell blocks, if colspan information is available. */
if( aIt != maColSpans.end() )
{
/* The colspan vector aIt points to is sorted by columns, as well
as the cell block map. In the folloing, this vector and the
list of cell blocks can be iterated simultanously. */
CellBlockMap::iterator aMIt = maCellBlocks.begin();
const ValueRangeVector& rColRanges = aIt->second;
for( ValueRangeVector::const_iterator aVIt = rColRanges.begin(), aVEnd = rColRanges.end(); aVIt != aVEnd; ++aVIt, ++aMIt )
{
const ValueRange& rColSpan = *aVIt;
/* Finalize and remove all cell blocks up to end of the column
range (cell blocks are keyed by end column index).
CellBlock::isBefore() returns true, if the end index of the
passed colspan is greater than the column end index of the
cell block, or if the passed range has the same end index
but the start indexes do not match. */
while( (aMIt != maCellBlocks.end()) && aMIt->second->isBefore( rColSpan ) )
{
aMIt->second->finalizeImport();
maCellBlocks.erase( aMIt++ );
}
/* If the current cell block (aMIt) fits to the colspan, start
a new row there, otherwise create and insert a new cell block. */
if( (aMIt != maCellBlocks.end()) && aMIt->second->isExpandable( rColSpan ) )
aMIt->second->startNextRow();
else
aMIt = maCellBlocks.insert( aMIt, CellBlockMap::value_type( rColSpan.mnLast,
CellBlockMap::mapped_type( new CellBlock( *this, rColSpan, rCellAddr.Row ) ) ) );
}
// finalize and remove all remaining cell blocks
CellBlockMap::iterator aMEnd = maCellBlocks.end();
for( CellBlockMap::iterator aMIt2 = aMIt; aMIt2 != aMEnd; ++aMIt2 )
aMIt2->second->finalizeImport();
maCellBlocks.erase( aMIt, aMEnd );
// remove cached colspan information (including current one aIt points to)
maColSpans.erase( maColSpans.begin(), ++aIt );
}
maCellBlockIt = maCellBlocks.begin();
mnCurrRow = rCellAddr.Row;
}
// try to find a valid cell block (update maCellBlockIt)
if( ((maCellBlockIt != maCellBlocks.end()) && maCellBlockIt->second->contains( rCellAddr.Column )) ||
(((maCellBlockIt = maCellBlocks.lower_bound( rCellAddr.Column )) != maCellBlocks.end()) && maCellBlockIt->second->contains( rCellAddr.Column )) )
{
// maCellBlockIt points to valid cell block
return maCellBlockIt->second.get();
}
// no valid cell block found
return 0;
}
void CellBlockBuffer::finalizeImport()
{
maCellBlocks.forEachMem( &CellBlock::finalizeImport );
}
// ============================================================================
SheetDataBuffer::SheetDataBuffer( const WorksheetHelper& rHelper ) :
WorksheetHelper( rHelper ),
maCellBlocks( rHelper ),
mbPendingSharedFmla( false )
{
}
void SheetDataBuffer::setColSpans( sal_Int32 nRow, const ValueRangeSet& rColSpans )
{
maCellBlocks.setColSpans( nRow, rColSpans );
}
void SheetDataBuffer::setBlankCell( const CellModel& rModel )
{
setCellFormat( rModel );
}
void SheetDataBuffer::setValueCell( const CellModel& rModel, double fValue )
{
if( CellBlock* pCellBlock = maCellBlocks.getCellBlock( rModel.maCellAddr ) )
pCellBlock->getCellAny( rModel.maCellAddr.Column ) <<= fValue;
else
putValue( rModel.maCellAddr, fValue );
setCellFormat( rModel );
}
void SheetDataBuffer::setStringCell( const CellModel& rModel, const OUString& rText )
{
if( CellBlock* pCellBlock = maCellBlocks.getCellBlock( rModel.maCellAddr ) )
pCellBlock->getCellAny( rModel.maCellAddr.Column ) <<= rText;
else
putString( rModel.maCellAddr, rText );
setCellFormat( rModel );
}
void SheetDataBuffer::setStringCell( const CellModel& rModel, const RichStringRef& rxString )
{
OSL_ENSURE( rxString.get(), "SheetDataBuffer::setStringCell - missing rich string object" );
const Font* pFirstPortionFont = getStyles().getFontFromCellXf( rModel.mnXfId ).get();
OUString aText;
if( rxString->extractPlainString( aText, pFirstPortionFont ) )
{
setStringCell( rModel, aText );
}
else
{
if( CellBlock* pCellBlock = maCellBlocks.getCellBlock( rModel.maCellAddr ) )
pCellBlock->insertRichString( rModel.maCellAddr, rxString, pFirstPortionFont );
else
putRichString( rModel.maCellAddr, *rxString, pFirstPortionFont );
setCellFormat( rModel );
}
}
void SheetDataBuffer::setStringCell( const CellModel& rModel, sal_Int32 nStringId )
{
RichStringRef xString = getSharedStrings().getString( nStringId );
if( xString.get() )
setStringCell( rModel, xString );
else
setBlankCell( rModel );
}
void SheetDataBuffer::setDateTimeCell( const CellModel& rModel, const DateTime& rDateTime )
{
// write serial date/time value into the cell
double fSerial = getUnitConverter().calcSerialFromDateTime( rDateTime );
setValueCell( rModel, fSerial );
// set appropriate number format
using namespace ::com::sun::star::util::NumberFormat;
sal_Int16 nStdFmt = (fSerial < 1.0) ? TIME : (((rDateTime.Hours > 0) || (rDateTime.Minutes > 0) || (rDateTime.Seconds > 0)) ? DATETIME : DATE);
setStandardNumFmt( rModel.maCellAddr, nStdFmt );
}
void SheetDataBuffer::setBooleanCell( const CellModel& rModel, bool bValue )
{
setCellFormula( rModel.maCellAddr, getFormulaParser().convertBoolToFormula( bValue ) );
// #108770# set 'Standard' number format for all Boolean cells
setCellFormat( rModel, 0 );
}
void SheetDataBuffer::setErrorCell( const CellModel& rModel, const OUString& rErrorCode )
{
setErrorCell( rModel, getUnitConverter().calcBiffErrorCode( rErrorCode ) );
}
void SheetDataBuffer::setErrorCell( const CellModel& rModel, sal_uInt8 nErrorCode )
{
setCellFormula( rModel.maCellAddr, getFormulaParser().convertErrorToFormula( nErrorCode ) );
setCellFormat( rModel );
}
void SheetDataBuffer::setFormulaCell( const CellModel& rModel, const ApiTokenSequence& rTokens )
{
mbPendingSharedFmla = false;
ApiTokenSequence aTokens;
/* Detect special token passed as placeholder for array formulas, shared
formulas, and table operations. In BIFF, these formulas are represented
by a single tExp resp. tTbl token. If the formula parser finds these
tokens, it puts a single OPCODE_BAD token with the base address and
formula type into the token sequence. This information will be
extracted here, and in case of a shared formula, the shared formula
buffer will generate the resulting formula token array. */
ApiSpecialTokenInfo aTokenInfo;
if( rTokens.hasElements() && getFormulaParser().extractSpecialTokenInfo( aTokenInfo, rTokens ) )
{
/* The second member of the token info is set to true, if the formula
represents a table operation, which will be skipped. In BIFF12 it
is not possible to distinguish array and shared formulas
(BIFF5/BIFF8 provide this information with a special flag in the
FORMULA record). */
if( !aTokenInfo.Second )
{
/* Construct the token array representing the shared formula. If
the returned sequence is empty, the definition of the shared
formula has not been loaded yet, or the cell is part of an
array formula. In this case, the cell will be remembered. After
reading the formula definition it will be retried to insert the
formula via retryPendingSharedFormulaCell(). */
BinAddress aBaseAddr( aTokenInfo.First );
aTokens = resolveSharedFormula( aBaseAddr );
if( !aTokens.hasElements() )
{
maSharedFmlaAddr = rModel.maCellAddr;
maSharedBaseAddr = aBaseAddr;
mbPendingSharedFmla = true;
}
}
}
else
{
// simple formula, use the passed token array
aTokens = rTokens;
}
setCellFormula( rModel.maCellAddr, aTokens );
setCellFormat( rModel );
}
void SheetDataBuffer::setFormulaCell( const CellModel& rModel, sal_Int32 nSharedId )
{
setCellFormula( rModel.maCellAddr, resolveSharedFormula( BinAddress( nSharedId, 0 ) ) );
setCellFormat( rModel );
}
void SheetDataBuffer::createArrayFormula( const CellRangeAddress& rRange, const ApiTokenSequence& rTokens )
{
/* Array formulas will be inserted later in finalizeImport(). This is
needed to not disturb collecting all the cells, which will be put into
the sheet in large blocks to increase performance. */
maArrayFormulas.push_back( ArrayFormula( rRange, rTokens ) );
}
void SheetDataBuffer::createTableOperation( const CellRangeAddress& rRange, const DataTableModel& rModel )
{
/* Table operations will be inserted later in finalizeImport(). This is
needed to not disturb collecting all the cells, which will be put into
the sheet in large blocks to increase performance. */
maTableOperations.push_back( TableOperation( rRange, rModel ) );
}
void SheetDataBuffer::createSharedFormula( sal_Int32 nSharedId, const ApiTokenSequence& rTokens )
{
createSharedFormula( BinAddress( nSharedId, 0 ), rTokens );
}
void SheetDataBuffer::createSharedFormula( const CellAddress& rCellAddr, const ApiTokenSequence& rTokens )
{
createSharedFormula( BinAddress( rCellAddr ), rTokens );
}
void SheetDataBuffer::setRowFormat( sal_Int32 nRow, sal_Int32 nXfId, bool bCustomFormat )
{
// set row formatting
if( bCustomFormat )
{
// try to expand cached row range, if formatting is equal
if( (maXfIdRowRange.maRowRange.mnLast < 0) || !maXfIdRowRange.tryExpand( nRow, nXfId ) )
{
writeXfIdRowRangeProperties( maXfIdRowRange );
maXfIdRowRange.set( nRow, nXfId );
}
}
else if( maXfIdRowRange.maRowRange.mnLast >= 0 )
{
// finish last cached row range
writeXfIdRowRangeProperties( maXfIdRowRange );
maXfIdRowRange.set( -1, -1 );
}
}
void SheetDataBuffer::setMergedRange( const CellRangeAddress& rRange )
{
maMergedRanges.push_back( MergedRange( rRange ) );
}
void SheetDataBuffer::setStandardNumFmt( const CellAddress& rCellAddr, sal_Int16 nStdNumFmt )
{
try
{
Reference< XNumberFormatsSupplier > xNumFmtsSupp( getDocument(), UNO_QUERY_THROW );
Reference< XNumberFormatTypes > xNumFmtTypes( xNumFmtsSupp->getNumberFormats(), UNO_QUERY_THROW );
sal_Int32 nIndex = xNumFmtTypes->getStandardFormat( nStdNumFmt, Locale() );
PropertySet aPropSet( getCell( rCellAddr ) );
aPropSet.setProperty( PROP_NumberFormat, nIndex );
}
catch( Exception& )
{
}
}
void SheetDataBuffer::finalizeImport()
{
// insert all cells of all open cell blocks
maCellBlocks.finalizeImport();
// create all array formulas
for( ArrayFormulaList::iterator aIt = maArrayFormulas.begin(), aEnd = maArrayFormulas.end(); aIt != aEnd; ++aIt )
finalizeArrayFormula( aIt->first, aIt->second );
// create all table operations
for( TableOperationList::iterator aIt = maTableOperations.begin(), aEnd = maTableOperations.end(); aIt != aEnd; ++aIt )
finalizeTableOperation( aIt->first, aIt->second );
// write default formatting of remaining row range
writeXfIdRowRangeProperties( maXfIdRowRange );
// try to merge remaining inserted ranges
mergeXfIdRanges();
// write all formatting
for( XfIdRangeMap::const_iterator aIt = maXfIdRanges.begin(), aEnd = maXfIdRanges.end(); aIt != aEnd; ++aIt )
writeXfIdRangeProperties( aIt->second );
// merge all cached merged ranges and update right/bottom cell borders
for( MergedRangeList::iterator aIt = maMergedRanges.begin(), aEnd = maMergedRanges.end(); aIt != aEnd; ++aIt )
finalizeMergedRange( aIt->maRange );
for( MergedRangeList::iterator aIt = maCenterFillRanges.begin(), aEnd = maCenterFillRanges.end(); aIt != aEnd; ++aIt )
finalizeMergedRange( aIt->maRange );
}
// private --------------------------------------------------------------------
SheetDataBuffer::XfIdRowRange::XfIdRowRange() :
maRowRange( -1 ),
mnXfId( -1 )
{
}
bool SheetDataBuffer::XfIdRowRange::intersects( const CellRangeAddress& rRange ) const
{
return (rRange.StartRow <= maRowRange.mnLast) && (maRowRange.mnFirst <= rRange.EndRow);
}
void SheetDataBuffer::XfIdRowRange::set( sal_Int32 nRow, sal_Int32 nXfId )
{
maRowRange = ValueRange( nRow );
mnXfId = nXfId;
}
bool SheetDataBuffer::XfIdRowRange::tryExpand( sal_Int32 nRow, sal_Int32 nXfId )
{
if( mnXfId == nXfId )
{
if( maRowRange.mnLast + 1 == nRow )
{
++maRowRange.mnLast;
return true;
}
if( maRowRange.mnFirst == nRow + 1 )
{
--maRowRange.mnFirst;
return true;
}
}
return false;
}
void SheetDataBuffer::XfIdRange::set( const CellAddress& rCellAddr, sal_Int32 nXfId, sal_Int32 nNumFmtId )
{
maRange.Sheet = rCellAddr.Sheet;
maRange.StartColumn = maRange.EndColumn = rCellAddr.Column;
maRange.StartRow = maRange.EndRow = rCellAddr.Row;
mnXfId = nXfId;
mnNumFmtId = nNumFmtId;
}
bool SheetDataBuffer::XfIdRange::tryExpand( const CellAddress& rCellAddr, sal_Int32 nXfId, sal_Int32 nNumFmtId )
{
if( (mnXfId == nXfId) && (mnNumFmtId == nNumFmtId) &&
(maRange.StartRow == rCellAddr.Row) &&
(maRange.EndRow == rCellAddr.Row) &&
(maRange.EndColumn + 1 == rCellAddr.Column) )
{
++maRange.EndColumn;
return true;
}
return false;
}
bool SheetDataBuffer::XfIdRange::tryMerge( const XfIdRange& rXfIdRange )
{
if( (mnXfId == rXfIdRange.mnXfId) &&
(mnNumFmtId == rXfIdRange.mnNumFmtId) &&
(maRange.EndRow + 1 == rXfIdRange.maRange.StartRow) &&
(maRange.StartColumn == rXfIdRange.maRange.StartColumn) &&
(maRange.EndColumn == rXfIdRange.maRange.EndColumn) )
{
maRange.EndRow = rXfIdRange.maRange.EndRow;
return true;
}
return false;
}
SheetDataBuffer::MergedRange::MergedRange( const CellRangeAddress& rRange ) :
maRange( rRange ),
mnHorAlign( XML_TOKEN_INVALID )
{
}
SheetDataBuffer::MergedRange::MergedRange( const CellAddress& rAddress, sal_Int32 nHorAlign ) :
maRange( rAddress.Sheet, rAddress.Column, rAddress.Row, rAddress.Column, rAddress.Row ),
mnHorAlign( nHorAlign )
{
}
bool SheetDataBuffer::MergedRange::tryExpand( const CellAddress& rAddress, sal_Int32 nHorAlign )
{
if( (mnHorAlign == nHorAlign) && (maRange.StartRow == rAddress.Row) &&
(maRange.EndRow == rAddress.Row) && (maRange.EndColumn + 1 == rAddress.Column) )
{
++maRange.EndColumn;
return true;
}
return false;
}
// ----------------------------------------------------------------------------
void SheetDataBuffer::setCellFormula( const CellAddress& rCellAddr, const ApiTokenSequence& rTokens )
{
if( rTokens.hasElements() )
{
if( CellBlock* pCellBlock = maCellBlocks.getCellBlock( rCellAddr ) )
pCellBlock->getCellAny( rCellAddr.Column ) <<= rTokens;
else
putFormulaTokens( rCellAddr, rTokens );
}
}
void SheetDataBuffer::createSharedFormula( const BinAddress& rMapKey, const ApiTokenSequence& rTokens )
{
// create the defined name that will represent the shared formula
OUString aName = OUStringBuffer().appendAscii( RTL_CONSTASCII_STRINGPARAM( "__shared_" ) ).
append( static_cast< sal_Int32 >( getSheetIndex() + 1 ) ).
append( sal_Unicode( '_' ) ).append( rMapKey.mnRow ).
append( sal_Unicode( '_' ) ).append( rMapKey.mnCol ).makeStringAndClear();
Reference< XNamedRange2 > xNamedRange = createNamedRangeObject( aName );
OSL_ENSURE( xNamedRange.is(), "SheetDataBuffer::createSharedFormula - cannot create shared formula" );
PropertySet aNameProps( xNamedRange );
aNameProps.setProperty( PROP_IsSharedFormula, true );
// get and store the token index of the defined name
OSL_ENSURE( maSharedFormulas.count( rMapKey ) == 0, "SheetDataBuffer::createSharedFormula - shared formula exists already" );
sal_Int32 nTokenIndex = 0;
if( aNameProps.getProperty( nTokenIndex, PROP_TokenIndex ) && (nTokenIndex >= 0) ) try
{
// store the token index in the map
maSharedFormulas[ rMapKey ] = nTokenIndex;
// set the formula definition
Reference< XFormulaTokens > xTokens( xNamedRange, UNO_QUERY_THROW );
xTokens->setTokens( rTokens );
// retry to insert a pending shared formula cell
if( mbPendingSharedFmla )
setCellFormula( maSharedFmlaAddr, resolveSharedFormula( maSharedBaseAddr ) );
}
catch( Exception& )
{
}
mbPendingSharedFmla = false;
}
ApiTokenSequence SheetDataBuffer::resolveSharedFormula( const BinAddress& rMapKey ) const
{
sal_Int32 nTokenIndex = ContainerHelper::getMapElement( maSharedFormulas, rMapKey, -1 );
return (nTokenIndex >= 0) ? getFormulaParser().convertNameToFormula( nTokenIndex ) : ApiTokenSequence();
}
void SheetDataBuffer::finalizeArrayFormula( const CellRangeAddress& rRange, const ApiTokenSequence& rTokens ) const
{
Reference< XArrayFormulaTokens > xTokens( getCellRange( rRange ), UNO_QUERY );
OSL_ENSURE( xTokens.is(), "SheetDataBuffer::finalizeArrayFormula - missing formula token interface" );
if( xTokens.is() )
xTokens->setArrayTokens( rTokens );
}
void SheetDataBuffer::finalizeTableOperation( const CellRangeAddress& rRange, const DataTableModel& rModel ) const
{
sal_Int16 nSheet = getSheetIndex();
bool bOk = false;
if( !rModel.mbRef1Deleted && (rModel.maRef1.getLength() > 0) && (rRange.StartColumn > 0) && (rRange.StartRow > 0) )
{
CellRangeAddress aOpRange = rRange;
CellAddress aRef1;
if( getAddressConverter().convertToCellAddress( aRef1, rModel.maRef1, nSheet, true ) ) try
{
if( rModel.mb2dTable )
{
CellAddress aRef2;
if( !rModel.mbRef2Deleted && getAddressConverter().convertToCellAddress( aRef2, rModel.maRef2, nSheet, true ) )
{
// API call expects input values inside operation range
--aOpRange.StartColumn;
--aOpRange.StartRow;
// formula range is top-left cell of operation range
CellRangeAddress aFormulaRange( nSheet, aOpRange.StartColumn, aOpRange.StartRow, aOpRange.StartColumn, aOpRange.StartRow );
// set multiple operation
Reference< XMultipleOperation > xMultOp( getCellRange( aOpRange ), UNO_QUERY_THROW );
xMultOp->setTableOperation( aFormulaRange, TableOperationMode_BOTH, aRef2, aRef1 );
bOk = true;
}
}
else if( rModel.mbRowTable )
{
// formula range is column to the left of operation range
CellRangeAddress aFormulaRange( nSheet, aOpRange.StartColumn - 1, aOpRange.StartRow, aOpRange.StartColumn - 1, aOpRange.EndRow );
// API call expects input values (top row) inside operation range
--aOpRange.StartRow;
// set multiple operation
Reference< XMultipleOperation > xMultOp( getCellRange( aOpRange ), UNO_QUERY_THROW );
xMultOp->setTableOperation( aFormulaRange, TableOperationMode_ROW, aRef1, aRef1 );
bOk = true;
}
else
{
// formula range is row above operation range
CellRangeAddress aFormulaRange( nSheet, aOpRange.StartColumn, aOpRange.StartRow - 1, aOpRange.EndColumn, aOpRange.StartRow - 1 );
// API call expects input values (left column) inside operation range
--aOpRange.StartColumn;
// set multiple operation
Reference< XMultipleOperation > xMultOp( getCellRange( aOpRange ), UNO_QUERY_THROW );
xMultOp->setTableOperation( aFormulaRange, TableOperationMode_COLUMN, aRef1, aRef1 );
bOk = true;
}
}
catch( Exception& )
{
}
}
// on error: fill cell range with #REF! error codes
if( !bOk ) try
{
Reference< XCellRangeData > xCellRangeData( getCellRange( rRange ), UNO_QUERY_THROW );
size_t nWidth = static_cast< size_t >( rRange.EndColumn - rRange.StartColumn + 1 );
size_t nHeight = static_cast< size_t >( rRange.EndRow - rRange.StartRow + 1 );
Matrix< Any > aErrorCells( nWidth, nHeight, Any( getFormulaParser().convertErrorToFormula( BIFF_ERR_REF ) ) );
xCellRangeData->setDataArray( ContainerHelper::matrixToSequenceSequence( aErrorCells ) );
}
catch( Exception& )
{
}
}
void SheetDataBuffer::setCellFormat( const CellModel& rModel, sal_Int32 nNumFmtId )
{
if( (rModel.mnXfId >= 0) || (nNumFmtId >= 0) )
{
// try to merge existing ranges and to write some formatting properties
if( !maXfIdRanges.empty() )
{
// get row index of last inserted cell
sal_Int32 nLastRow = maXfIdRanges.rbegin()->second.maRange.StartRow;
// row changed - try to merge ranges of last row with existing ranges
if( rModel.maCellAddr.Row != nLastRow )
{
mergeXfIdRanges();
// write format properties of all ranges above last row and remove them
XfIdRangeMap::iterator aIt = maXfIdRanges.begin(), aEnd = maXfIdRanges.end();
while( aIt != aEnd )
{
// check that range cannot be merged with current row, and that range is not in cached row range
if( (aIt->second.maRange.EndRow < nLastRow) && !maXfIdRowRange.intersects( aIt->second.maRange ) )
{
writeXfIdRangeProperties( aIt->second );
maXfIdRanges.erase( aIt++ );
}
else
++aIt;
}
}
}
// try to expand last existing range, or create new range entry
if( maXfIdRanges.empty() || !maXfIdRanges.rbegin()->second.tryExpand( rModel.maCellAddr, rModel.mnXfId, nNumFmtId ) )
maXfIdRanges[ BinAddress( rModel.maCellAddr ) ].set( rModel.maCellAddr, rModel.mnXfId, nNumFmtId );
// update merged ranges for 'center across selection' and 'fill'
if( const Xf* pXf = getStyles().getCellXf( rModel.mnXfId ).get() )
{
sal_Int32 nHorAlign = pXf->getAlignment().getModel().mnHorAlign;
if( (nHorAlign == XML_centerContinuous) || (nHorAlign == XML_fill) )
{
/* start new merged range, if cell is not empty (#108781#),
or try to expand last range with empty cell */
if( rModel.mnCellType != XML_TOKEN_INVALID )
maCenterFillRanges.push_back( MergedRange( rModel.maCellAddr, nHorAlign ) );
else if( !maCenterFillRanges.empty() )
maCenterFillRanges.rbegin()->tryExpand( rModel.maCellAddr, nHorAlign );
}
}
}
}
void SheetDataBuffer::writeXfIdRowRangeProperties( const XfIdRowRange& rXfIdRowRange ) const
{
if( (rXfIdRowRange.maRowRange.mnLast >= 0) && (rXfIdRowRange.mnXfId >= 0) )
{
AddressConverter& rAddrConv = getAddressConverter();
CellRangeAddress aRange( getSheetIndex(), 0, rXfIdRowRange.maRowRange.mnFirst, rAddrConv.getMaxApiAddress().Column, rXfIdRowRange.maRowRange.mnLast );
if( rAddrConv.validateCellRange( aRange, true, false ) )
{
PropertySet aPropSet( getCellRange( aRange ) );
getStyles().writeCellXfToPropertySet( aPropSet, rXfIdRowRange.mnXfId );
}
}
}
void SheetDataBuffer::writeXfIdRangeProperties( const XfIdRange& rXfIdRange ) const
{
StylesBuffer& rStyles = getStyles();
PropertyMap aPropMap;
if( rXfIdRange.mnXfId >= 0 )
rStyles.writeCellXfToPropertyMap( aPropMap, rXfIdRange.mnXfId );
if( rXfIdRange.mnNumFmtId >= 0 )
rStyles.writeNumFmtToPropertyMap( aPropMap, rXfIdRange.mnNumFmtId );
PropertySet aPropSet( getCellRange( rXfIdRange.maRange ) );
aPropSet.setProperties( aPropMap );
}
void SheetDataBuffer::mergeXfIdRanges()
{
if( !maXfIdRanges.empty() )
{
// get row index of last range
sal_Int32 nLastRow = maXfIdRanges.rbegin()->second.maRange.StartRow;
// process all ranges located in the same row of the last range
XfIdRangeMap::iterator aMergeIt = maXfIdRanges.end();
while( (aMergeIt != maXfIdRanges.begin()) && ((--aMergeIt)->second.maRange.StartRow == nLastRow) )
{
const XfIdRange& rMergeXfIdRange = aMergeIt->second;
// try to find a range that can be merged with rMergeRange
bool bFound = false;
for( XfIdRangeMap::iterator aIt = maXfIdRanges.begin(); !bFound && (aIt != aMergeIt); ++aIt )
if( (bFound = aIt->second.tryMerge( rMergeXfIdRange )) == true )
maXfIdRanges.erase( aMergeIt++ );
}
}
}
void SheetDataBuffer::finalizeMergedRange( const CellRangeAddress& rRange )
{
bool bMultiCol = rRange.StartColumn < rRange.EndColumn;
bool bMultiRow = rRange.StartRow < rRange.EndRow;
if( bMultiCol || bMultiRow ) try
{
// merge the cell range
Reference< XMergeable > xMerge( getCellRange( rRange ), UNO_QUERY_THROW );
xMerge->merge( sal_True );
// if merging this range worked (no overlapping merged ranges), update cell borders
Reference< XCell > xTopLeft( getCell( CellAddress( getSheetIndex(), rRange.StartColumn, rRange.StartRow ) ), UNO_SET_THROW );
PropertySet aTopLeftProp( xTopLeft );
// copy right border of top-right cell to right border of top-left cell
if( bMultiCol )
{
PropertySet aTopRightProp( getCell( CellAddress( getSheetIndex(), rRange.EndColumn, rRange.StartRow ) ) );
BorderLine aLine;
if( aTopRightProp.getProperty( aLine, PROP_RightBorder ) )
aTopLeftProp.setProperty( PROP_RightBorder, aLine );
}
// copy bottom border of bottom-left cell to bottom border of top-left cell
if( bMultiRow )
{
PropertySet aBottomLeftProp( getCell( CellAddress( getSheetIndex(), rRange.StartColumn, rRange.EndRow ) ) );
BorderLine aLine;
if( aBottomLeftProp.getProperty( aLine, PROP_BottomBorder ) )
aTopLeftProp.setProperty( PROP_BottomBorder, aLine );
}
// #i93609# merged range in a single row: test if manual row height is needed
if( !bMultiRow )
{
bool bTextWrap = aTopLeftProp.getBoolProperty( PROP_IsTextWrapped );
if( !bTextWrap && (xTopLeft->getType() == CellContentType_TEXT) )
{
Reference< XText > xText( xTopLeft, UNO_QUERY );
bTextWrap = xText.is() && (xText->getString().indexOf( '\x0A' ) >= 0);
}
if( bTextWrap )
setManualRowHeight( rRange.StartRow );
}
}
catch( Exception& )
{
}
}
// ============================================================================
} // namespace xls
} // namespace oox