/**************************************************************
*
* 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/pivotcachefragment.hxx"
#include "oox/helper/attributelist.hxx"
#include "oox/xls/addressconverter.hxx"
#include "oox/xls/biffinputstream.hxx"
#include "oox/xls/pivotcachebuffer.hxx"
namespace oox {
namespace xls {
// ============================================================================
using namespace ::com::sun::star::uno;
using namespace ::oox::core;
using ::rtl::OUString;
// ============================================================================
PivotCacheFieldContext::PivotCacheFieldContext( WorkbookFragmentBase& rFragment, PivotCacheField& rCacheField ) :
WorkbookContextBase( rFragment ),
mrCacheField( rCacheField )
{
}
ContextHandlerRef PivotCacheFieldContext::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
{
switch( getCurrentElement() )
{
case XLS_TOKEN( cacheField ):
if( nElement == XLS_TOKEN( sharedItems ) ) { mrCacheField.importSharedItems( rAttribs ); return this; }
if( nElement == XLS_TOKEN( fieldGroup ) ) { mrCacheField.importFieldGroup( rAttribs ); return this; }
break;
case XLS_TOKEN( fieldGroup ):
switch( nElement )
{
case XLS_TOKEN( rangePr ): mrCacheField.importRangePr( rAttribs ); break;
case XLS_TOKEN( discretePr ): return this;
case XLS_TOKEN( groupItems ): return this;
}
break;
case XLS_TOKEN( sharedItems ): mrCacheField.importSharedItem( nElement, rAttribs ); break;
case XLS_TOKEN( discretePr ): mrCacheField.importDiscretePrItem( nElement, rAttribs ); break;
case XLS_TOKEN( groupItems ): mrCacheField.importGroupItem( nElement, rAttribs ); break;
}
return 0;
}
void PivotCacheFieldContext::onStartElement( const AttributeList& rAttribs )
{
if( isRootElement() )
mrCacheField.importCacheField( rAttribs );
}
ContextHandlerRef PivotCacheFieldContext::onCreateRecordContext( sal_Int32 nRecId, SequenceInputStream& rStrm )
{
switch( getCurrentElement() )
{
case BIFF12_ID_PCDFIELD:
switch( nRecId )
{
case BIFF12_ID_PCDFSHAREDITEMS: mrCacheField.importPCDFSharedItems( rStrm ); return this;
case BIFF12_ID_PCDFIELDGROUP: mrCacheField.importPCDFieldGroup( rStrm ); return this;
}
break;
case BIFF12_ID_PCDFIELDGROUP:
switch( nRecId )
{
case BIFF12_ID_PCDFRANGEPR: mrCacheField.importPCDFRangePr( rStrm ); break;
case BIFF12_ID_PCDFDISCRETEPR: return this;
case BIFF12_ID_PCDFGROUPITEMS: return this;
}
break;
case BIFF12_ID_PCDFSHAREDITEMS: mrCacheField.importPCDFSharedItem( nRecId, rStrm ); break;
case BIFF12_ID_PCDFDISCRETEPR: mrCacheField.importPCDFDiscretePrItem( nRecId, rStrm ); break;
case BIFF12_ID_PCDFGROUPITEMS: mrCacheField.importPCDFGroupItem( nRecId, rStrm ); break;
}
return 0;
}
void PivotCacheFieldContext::onStartRecord( SequenceInputStream& rStrm )
{
if( isRootElement() )
mrCacheField.importPCDField( rStrm );
}
// ============================================================================
PivotCacheDefinitionFragment::PivotCacheDefinitionFragment(
const WorkbookHelper& rHelper, const OUString& rFragmentPath, PivotCache& rPivotCache ) :
WorkbookFragmentBase( rHelper, rFragmentPath ),
mrPivotCache( rPivotCache )
{
}
ContextHandlerRef PivotCacheDefinitionFragment::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
{
switch( getCurrentElement() )
{
case XML_ROOT_CONTEXT:
if( nElement == XLS_TOKEN( pivotCacheDefinition ) ) { mrPivotCache.importPivotCacheDefinition( rAttribs ); return this; }
break;
case XLS_TOKEN( pivotCacheDefinition ):
switch( nElement )
{
case XLS_TOKEN( cacheSource ): mrPivotCache.importCacheSource( rAttribs ); return this;
case XLS_TOKEN( cacheFields ): return this;
}
break;
case XLS_TOKEN( cacheSource ):
if( nElement == XLS_TOKEN( worksheetSource ) ) mrPivotCache.importWorksheetSource( rAttribs, getRelations() );
break;
case XLS_TOKEN( cacheFields ):
if( nElement == XLS_TOKEN( cacheField ) ) return new PivotCacheFieldContext( *this, mrPivotCache.createCacheField() );
break;
}
return 0;
}
ContextHandlerRef PivotCacheDefinitionFragment::onCreateRecordContext( sal_Int32 nRecId, SequenceInputStream& rStrm )
{
switch( getCurrentElement() )
{
case XML_ROOT_CONTEXT:
if( nRecId == BIFF12_ID_PCDEFINITION ) { mrPivotCache.importPCDefinition( rStrm ); return this; }
break;
case BIFF12_ID_PCDEFINITION:
switch( nRecId )
{
case BIFF12_ID_PCDSOURCE: mrPivotCache.importPCDSource( rStrm ); return this;
case BIFF12_ID_PCDFIELDS: return this;
}
break;
case BIFF12_ID_PCDSOURCE:
if( nRecId == BIFF12_ID_PCDSHEETSOURCE ) mrPivotCache.importPCDSheetSource( rStrm, getRelations() );
break;
case BIFF12_ID_PCDFIELDS:
if( nRecId == BIFF12_ID_PCDFIELD ) return new PivotCacheFieldContext( *this, mrPivotCache.createCacheField() );
break;
}
return 0;
}
const RecordInfo* PivotCacheDefinitionFragment::getRecordInfos() const
{
static const RecordInfo spRecInfos[] =
{
{ BIFF12_ID_PCDEFINITION, BIFF12_ID_PCDEFINITION + 1 },
{ BIFF12_ID_PCDFDISCRETEPR, BIFF12_ID_PCDFDISCRETEPR + 1 },
{ BIFF12_ID_PCDFGROUPITEMS, BIFF12_ID_PCDFGROUPITEMS + 1 },
{ BIFF12_ID_PCDFIELD, BIFF12_ID_PCDFIELD + 1 },
{ BIFF12_ID_PCDFIELDGROUP, BIFF12_ID_PCDFIELDGROUP + 1 },
{ BIFF12_ID_PCDFIELDS, BIFF12_ID_PCDFIELDS + 1 },
{ BIFF12_ID_PCDFRANGEPR, BIFF12_ID_PCDFRANGEPR + 1 },
{ BIFF12_ID_PCDFSHAREDITEMS, BIFF12_ID_PCDFSHAREDITEMS + 1 },
{ BIFF12_ID_PCITEM_ARRAY, BIFF12_ID_PCITEM_ARRAY + 1 },
{ BIFF12_ID_PCDSHEETSOURCE, BIFF12_ID_PCDSHEETSOURCE + 1 },
{ BIFF12_ID_PCDSOURCE, BIFF12_ID_PCDSOURCE + 1 },
{ -1, -1 }
};
return spRecInfos;
}
void PivotCacheDefinitionFragment::finalizeImport()
{
// finalize the cache (check source range etc.)
mrPivotCache.finalizeImport();
// load the cache records, if the cache is based on a deleted or an external worksheet
if( mrPivotCache.isValidDataSource() && mrPivotCache.isBasedOnDummySheet() )
{
OUString aRecFragmentPath = getRelations().getFragmentPathFromRelId( mrPivotCache.getRecordsRelId() );
if( aRecFragmentPath.getLength() > 0 )
{
sal_Int16 nSheet = mrPivotCache.getSourceRange().Sheet;
WorksheetGlobalsRef xSheetGlob = WorksheetHelper::constructGlobals( *this, ISegmentProgressBarRef(), SHEETTYPE_WORKSHEET, nSheet );
if( xSheetGlob.get() )
importOoxFragment( new PivotCacheRecordsFragment( *xSheetGlob, aRecFragmentPath, mrPivotCache ) );
}
}
}
// ============================================================================
PivotCacheRecordsFragment::PivotCacheRecordsFragment( const WorksheetHelper& rHelper,
const OUString& rFragmentPath, const PivotCache& rPivotCache ) :
WorksheetFragmentBase( rHelper, rFragmentPath ),
mrPivotCache( rPivotCache ),
mnColIdx( 0 ),
mnRowIdx( 0 ),
mbInRecord( false )
{
// prepare sheet: insert column header names into top row
rPivotCache.writeSourceHeaderCells( *this );
}
ContextHandlerRef PivotCacheRecordsFragment::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
{
switch( getCurrentElement() )
{
case XML_ROOT_CONTEXT:
if( nElement == XLS_TOKEN( pivotCacheRecords ) ) return this;
break;
case XLS_TOKEN( pivotCacheRecords ):
if( nElement == XLS_TOKEN( r ) ) { startCacheRecord(); return this; }
break;
case XLS_TOKEN( r ):
{
PivotCacheItem aItem;
switch( nElement )
{
case XLS_TOKEN( m ): break;
case XLS_TOKEN( s ): aItem.readString( rAttribs ); break;
case XLS_TOKEN( n ): aItem.readNumeric( rAttribs ); break;
case XLS_TOKEN( d ): aItem.readDate( rAttribs ); break;
case XLS_TOKEN( b ): aItem.readBool( rAttribs ); break;
case XLS_TOKEN( e ): aItem.readError( rAttribs, getUnitConverter() ); break;
case XLS_TOKEN( x ): aItem.readIndex( rAttribs ); break;
default: OSL_ENSURE( false, "PivotCacheRecordsFragment::onCreateContext - unexpected element" );
}
mrPivotCache.writeSourceDataCell( *this, mnColIdx, mnRowIdx, aItem );
++mnColIdx;
}
break;
}
return 0;
}
ContextHandlerRef PivotCacheRecordsFragment::onCreateRecordContext( sal_Int32 nRecId, SequenceInputStream& rStrm )
{
switch( getCurrentElement() )
{
case XML_ROOT_CONTEXT:
if( nRecId == BIFF12_ID_PCRECORDS ) return this;
break;
case BIFF12_ID_PCRECORDS:
switch( nRecId )
{
case BIFF12_ID_PCRECORD: importPCRecord( rStrm ); break;
case BIFF12_ID_PCRECORDDT: startCacheRecord(); break;
default: importPCRecordItem( nRecId, rStrm ); break;
}
break;
}
return 0;
}
const RecordInfo* PivotCacheRecordsFragment::getRecordInfos() const
{
static const RecordInfo spRecInfos[] =
{
{ BIFF12_ID_PCRECORDS, BIFF12_ID_PCRECORDS + 1 },
{ -1, -1 }
};
return spRecInfos;
}
// private --------------------------------------------------------------------
void PivotCacheRecordsFragment::startCacheRecord()
{
mnColIdx = 0;
++mnRowIdx;
mbInRecord = true;
}
void PivotCacheRecordsFragment::importPCRecord( SequenceInputStream& rStrm )
{
startCacheRecord();
mrPivotCache.importPCRecord( rStrm, *this, mnRowIdx );
mbInRecord = false;
}
void PivotCacheRecordsFragment::importPCRecordItem( sal_Int32 nRecId, SequenceInputStream& rStrm )
{
if( mbInRecord )
{
PivotCacheItem aItem;
switch( nRecId )
{
case BIFF12_ID_PCITEM_MISSING: break;
case BIFF12_ID_PCITEM_STRING: aItem.readString( rStrm ); break;
case BIFF12_ID_PCITEM_DOUBLE: aItem.readDouble( rStrm ); break;
case BIFF12_ID_PCITEM_DATE: aItem.readDate( rStrm ); break;
case BIFF12_ID_PCITEM_BOOL: aItem.readBool( rStrm ); break;
case BIFF12_ID_PCITEM_ERROR: aItem.readError( rStrm ); break;
case BIFF12_ID_PCITEM_INDEX: aItem.readIndex( rStrm ); break;
default: OSL_ENSURE( false, "PivotCacheRecordsFragment::importPCRecordItem - unexpected record" );
}
mrPivotCache.writeSourceDataCell( *this, mnColIdx, mnRowIdx, aItem );
++mnColIdx;
}
}
// ============================================================================
// ============================================================================
namespace {
bool lclSeekToPCDField( BiffInputStream& rStrm )
{
sal_Int64 nRecHandle = rStrm.getRecHandle();
while( rStrm.startNextRecord() )
if( rStrm.getRecId() == BIFF_ID_PCDFIELD )
return true;
rStrm.startRecordByHandle( nRecHandle );
return false;
}
} // namespace
// ----------------------------------------------------------------------------
BiffPivotCacheFragment::BiffPivotCacheFragment(
const WorkbookHelper& rHelper, const OUString& rStrmName, PivotCache& rPivotCache ) :
BiffWorkbookFragmentBase( rHelper, rStrmName, true ),
mrPivotCache( rPivotCache )
{
}
bool BiffPivotCacheFragment::importFragment()
{
BiffInputStream& rStrm = getInputStream();
if( rStrm.startNextRecord() && (rStrm.getRecId() == BIFF_ID_PCDEFINITION) )
{
// read PCDEFINITION and optional PCDEFINITION2 records
mrPivotCache.importPCDefinition( rStrm );
// read cache fields as long as another PCDFIELD record can be found
while( lclSeekToPCDField( rStrm ) )
mrPivotCache.createCacheField( true ).importPCDField( rStrm );
// finalize the cache (check source range etc.)
mrPivotCache.finalizeImport();
// load the cache records, if the cache is based on a deleted or an external worksheet
if( mrPivotCache.isValidDataSource() && mrPivotCache.isBasedOnDummySheet() )
{
/* Last call of lclSeekToPCDField() failed and kept stream position
unchanged. Stream should point to source data table now. */
sal_Int16 nSheet = mrPivotCache.getSourceRange().Sheet;
WorksheetGlobalsRef xSheetGlob = WorksheetHelper::constructGlobals( *this, ISegmentProgressBarRef(), SHEETTYPE_WORKSHEET, nSheet );
if( xSheetGlob.get() )
{
BiffPivotCacheRecordsContext aContext( *xSheetGlob, mrPivotCache );
while( rStrm.startNextRecord() && (rStrm.getRecId() != BIFF_ID_EOF) )
aContext.importRecord( rStrm );
}
}
}
return rStrm.getRecId() == BIFF_ID_EOF;
}
// ============================================================================
BiffPivotCacheRecordsContext::BiffPivotCacheRecordsContext( const WorksheetHelper& rHelper, const PivotCache& rPivotCache ) :
BiffWorksheetContextBase( rHelper ),
mrPivotCache( rPivotCache ),
mnColIdx( 0 ),
mnRowIdx( 0 ),
mbHasShared( false ),
mbInRow( false )
{
// prepare sheet: insert column header names into top row
mrPivotCache.writeSourceHeaderCells( *this );
// find all fields without shared items, remember column indexes in source data
for( sal_Int32 nFieldIdx = 0, nFieldCount = mrPivotCache.getCacheFieldCount(), nCol = 0; nFieldIdx < nFieldCount; ++nFieldIdx )
{
const PivotCacheField* pCacheField = mrPivotCache.getCacheField( nFieldIdx );
if( pCacheField && pCacheField->isDatabaseField() )
{
if( pCacheField->hasSharedItems() )
mbHasShared = true;
else
maUnsharedCols.push_back( nCol );
++nCol;
}
}
}
void BiffPivotCacheRecordsContext::importRecord( BiffInputStream& rStrm )
{
if( rStrm.getRecId() == BIFF_ID_PCITEM_INDEXLIST )
{
OSL_ENSURE( mbHasShared, "BiffPivotCacheRecordsContext::importRecord - unexpected PCITEM_INDEXLIST record" );
// PCITEM_INDEXLIST record always in front of a new data row
startNextRow();
mrPivotCache.importPCItemIndexList( rStrm, *this, mnRowIdx );
mbInRow = !maUnsharedCols.empty(); // mbInRow remains true, if unshared items are expected
return;
}
PivotCacheItem aItem;
switch( rStrm.getRecId() )
{
case BIFF_ID_PCITEM_MISSING: break;
case BIFF_ID_PCITEM_STRING: aItem.readString( rStrm, *this ); break;
case BIFF_ID_PCITEM_DOUBLE: aItem.readDouble( rStrm ); break;
case BIFF_ID_PCITEM_INTEGER: aItem.readInteger( rStrm ); break;
case BIFF_ID_PCITEM_DATE: aItem.readDate( rStrm ); break;
case BIFF_ID_PCITEM_BOOL: aItem.readBool( rStrm ); break;
case BIFF_ID_PCITEM_ERROR: aItem.readError( rStrm ); break;
default: return; // unknown record, ignore
}
// find next column index, might start new row if no fields with shared items exist
if( mbInRow && (mnColIdx == maUnsharedCols.size()) )
{
OSL_ENSURE( !mbHasShared, "BiffPivotCacheRecordsContext::importRecord - PCITEM_INDEXLIST record missing" );
mbInRow = mbHasShared; // do not leave current row if PCITEM_INDEXLIST is expected
}
// start next row on first call, or on row wrap without shared items
if( !mbInRow )
startNextRow();
// write the item data to the sheet cell
OSL_ENSURE( mnColIdx < maUnsharedCols.size(), "BiffPivotCacheRecordsContext::importRecord - invalid column index" );
if( mnColIdx < maUnsharedCols.size() )
mrPivotCache.writeSourceDataCell( *this, maUnsharedCols[ mnColIdx ], mnRowIdx, aItem );
++mnColIdx;
}
void BiffPivotCacheRecordsContext::startNextRow()
{
mnColIdx = 0;
++mnRowIdx;
mbInRow = true;
}
// ============================================================================
} // namespace xls
} // namespace oox