Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include "pivotcachefragment.hxx"
21 :
22 : #include <oox/helper/attributelist.hxx>
23 : #include "addressconverter.hxx"
24 : #include "biffinputstream.hxx"
25 : #include "pivotcachebuffer.hxx"
26 :
27 : namespace oox {
28 : namespace xls {
29 :
30 : using namespace ::com::sun::star::uno;
31 : using namespace ::oox::core;
32 :
33 48 : PivotCacheFieldContext::PivotCacheFieldContext( WorkbookFragmentBase& rFragment, PivotCacheField& rCacheField ) :
34 : WorkbookContextBase( rFragment ),
35 48 : mrCacheField( rCacheField )
36 : {
37 48 : }
38 :
39 146 : ContextHandlerRef PivotCacheFieldContext::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
40 : {
41 146 : switch( getCurrentElement() )
42 : {
43 : case XLS_TOKEN( cacheField ):
44 48 : if( nElement == XLS_TOKEN( sharedItems ) ) { mrCacheField.importSharedItems( rAttribs ); return this; }
45 0 : if( nElement == XLS_TOKEN( fieldGroup ) ) { mrCacheField.importFieldGroup( rAttribs ); return this; }
46 0 : break;
47 :
48 : case XLS_TOKEN( fieldGroup ):
49 0 : switch( nElement )
50 : {
51 0 : case XLS_TOKEN( rangePr ): mrCacheField.importRangePr( rAttribs ); break;
52 0 : case XLS_TOKEN( discretePr ): return this;
53 0 : case XLS_TOKEN( groupItems ): return this;
54 : }
55 0 : break;
56 :
57 98 : case XLS_TOKEN( sharedItems ): mrCacheField.importSharedItem( nElement, rAttribs ); break;
58 0 : case XLS_TOKEN( discretePr ): mrCacheField.importDiscretePrItem( nElement, rAttribs ); break;
59 0 : case XLS_TOKEN( groupItems ): mrCacheField.importGroupItem( nElement, rAttribs ); break;
60 : }
61 98 : return 0;
62 : }
63 :
64 96 : void PivotCacheFieldContext::onStartElement( const AttributeList& rAttribs )
65 : {
66 96 : if( isRootElement() )
67 48 : mrCacheField.importCacheField( rAttribs );
68 96 : }
69 :
70 0 : ContextHandlerRef PivotCacheFieldContext::onCreateRecordContext( sal_Int32 nRecId, SequenceInputStream& rStrm )
71 : {
72 0 : switch( getCurrentElement() )
73 : {
74 : case BIFF12_ID_PCDFIELD:
75 0 : switch( nRecId )
76 : {
77 0 : case BIFF12_ID_PCDFSHAREDITEMS: mrCacheField.importPCDFSharedItems( rStrm ); return this;
78 0 : case BIFF12_ID_PCDFIELDGROUP: mrCacheField.importPCDFieldGroup( rStrm ); return this;
79 : }
80 0 : break;
81 :
82 : case BIFF12_ID_PCDFIELDGROUP:
83 0 : switch( nRecId )
84 : {
85 0 : case BIFF12_ID_PCDFRANGEPR: mrCacheField.importPCDFRangePr( rStrm ); break;
86 0 : case BIFF12_ID_PCDFDISCRETEPR: return this;
87 0 : case BIFF12_ID_PCDFGROUPITEMS: return this;
88 : }
89 0 : break;
90 :
91 0 : case BIFF12_ID_PCDFSHAREDITEMS: mrCacheField.importPCDFSharedItem( nRecId, rStrm ); break;
92 0 : case BIFF12_ID_PCDFDISCRETEPR: mrCacheField.importPCDFDiscretePrItem( nRecId, rStrm ); break;
93 0 : case BIFF12_ID_PCDFGROUPITEMS: mrCacheField.importPCDFGroupItem( nRecId, rStrm ); break;
94 : }
95 0 : return 0;
96 : }
97 :
98 0 : void PivotCacheFieldContext::onStartRecord( SequenceInputStream& rStrm )
99 : {
100 0 : if( isRootElement() )
101 0 : mrCacheField.importPCDField( rStrm );
102 0 : }
103 :
104 8 : PivotCacheDefinitionFragment::PivotCacheDefinitionFragment(
105 : const WorkbookHelper& rHelper, const OUString& rFragmentPath, PivotCache& rPivotCache ) :
106 : WorkbookFragmentBase( rHelper, rFragmentPath ),
107 8 : mrPivotCache( rPivotCache )
108 : {
109 8 : }
110 :
111 84 : ContextHandlerRef PivotCacheDefinitionFragment::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
112 : {
113 84 : switch( getCurrentElement() )
114 : {
115 : case XML_ROOT_CONTEXT:
116 8 : if( nElement == XLS_TOKEN( pivotCacheDefinition ) ) { mrPivotCache.importPivotCacheDefinition( rAttribs ); return this; }
117 0 : break;
118 :
119 : case XLS_TOKEN( pivotCacheDefinition ):
120 20 : switch( nElement )
121 : {
122 8 : case XLS_TOKEN( cacheSource ): mrPivotCache.importCacheSource( rAttribs ); return this;
123 8 : case XLS_TOKEN( cacheFields ): return this;
124 : }
125 4 : break;
126 :
127 : case XLS_TOKEN( cacheSource ):
128 8 : if( nElement == XLS_TOKEN( worksheetSource ) ) mrPivotCache.importWorksheetSource( rAttribs, getRelations() );
129 8 : break;
130 :
131 : case XLS_TOKEN( cacheFields ):
132 48 : if( nElement == XLS_TOKEN( cacheField ) ) return new PivotCacheFieldContext( *this, mrPivotCache.createCacheField() );
133 0 : break;
134 : }
135 12 : return 0;
136 : }
137 :
138 0 : ContextHandlerRef PivotCacheDefinitionFragment::onCreateRecordContext( sal_Int32 nRecId, SequenceInputStream& rStrm )
139 : {
140 0 : switch( getCurrentElement() )
141 : {
142 : case XML_ROOT_CONTEXT:
143 0 : if( nRecId == BIFF12_ID_PCDEFINITION ) { mrPivotCache.importPCDefinition( rStrm ); return this; }
144 0 : break;
145 :
146 : case BIFF12_ID_PCDEFINITION:
147 0 : switch( nRecId )
148 : {
149 0 : case BIFF12_ID_PCDSOURCE: mrPivotCache.importPCDSource( rStrm ); return this;
150 0 : case BIFF12_ID_PCDFIELDS: return this;
151 : }
152 0 : break;
153 :
154 : case BIFF12_ID_PCDSOURCE:
155 0 : if( nRecId == BIFF12_ID_PCDSHEETSOURCE ) mrPivotCache.importPCDSheetSource( rStrm, getRelations() );
156 0 : break;
157 :
158 : case BIFF12_ID_PCDFIELDS:
159 0 : if( nRecId == BIFF12_ID_PCDFIELD ) return new PivotCacheFieldContext( *this, mrPivotCache.createCacheField() );
160 0 : break;
161 : }
162 0 : return 0;
163 : }
164 :
165 0 : const RecordInfo* PivotCacheDefinitionFragment::getRecordInfos() const
166 : {
167 : static const RecordInfo spRecInfos[] =
168 : {
169 : { BIFF12_ID_PCDEFINITION, BIFF12_ID_PCDEFINITION + 1 },
170 : { BIFF12_ID_PCDFDISCRETEPR, BIFF12_ID_PCDFDISCRETEPR + 1 },
171 : { BIFF12_ID_PCDFGROUPITEMS, BIFF12_ID_PCDFGROUPITEMS + 1 },
172 : { BIFF12_ID_PCDFIELD, BIFF12_ID_PCDFIELD + 1 },
173 : { BIFF12_ID_PCDFIELDGROUP, BIFF12_ID_PCDFIELDGROUP + 1 },
174 : { BIFF12_ID_PCDFIELDS, BIFF12_ID_PCDFIELDS + 1 },
175 : { BIFF12_ID_PCDFRANGEPR, BIFF12_ID_PCDFRANGEPR + 1 },
176 : { BIFF12_ID_PCDFSHAREDITEMS, BIFF12_ID_PCDFSHAREDITEMS + 1 },
177 : { BIFF12_ID_PCITEM_ARRAY, BIFF12_ID_PCITEM_ARRAY + 1 },
178 : { BIFF12_ID_PCDSHEETSOURCE, BIFF12_ID_PCDSHEETSOURCE + 1 },
179 : { BIFF12_ID_PCDSOURCE, BIFF12_ID_PCDSOURCE + 1 },
180 : { -1, -1 }
181 : };
182 0 : return spRecInfos;
183 : }
184 :
185 8 : void PivotCacheDefinitionFragment::finalizeImport()
186 : {
187 : // finalize the cache (check source range etc.)
188 8 : mrPivotCache.finalizeImport();
189 :
190 : // load the cache records, if the cache is based on a deleted or an external worksheet
191 8 : if( mrPivotCache.isValidDataSource() && mrPivotCache.isBasedOnDummySheet() )
192 : {
193 0 : OUString aRecFragmentPath = getRelations().getFragmentPathFromRelId( mrPivotCache.getRecordsRelId() );
194 0 : if( !aRecFragmentPath.isEmpty() )
195 : {
196 0 : sal_Int16 nSheet = mrPivotCache.getSourceRange().Sheet;
197 0 : WorksheetGlobalsRef xSheetGlob = WorksheetHelper::constructGlobals( *this, ISegmentProgressBarRef(), SHEETTYPE_WORKSHEET, nSheet );
198 0 : if( xSheetGlob.get() )
199 0 : importOoxFragment( new PivotCacheRecordsFragment( *xSheetGlob, aRecFragmentPath, mrPivotCache ) );
200 0 : }
201 : }
202 8 : }
203 :
204 0 : PivotCacheRecordsFragment::PivotCacheRecordsFragment( const WorksheetHelper& rHelper,
205 : const OUString& rFragmentPath, const PivotCache& rPivotCache ) :
206 : WorksheetFragmentBase( rHelper, rFragmentPath ),
207 : mrPivotCache( rPivotCache ),
208 : mnColIdx( 0 ),
209 : mnRowIdx( 0 ),
210 0 : mbInRecord( false )
211 : {
212 : // prepare sheet: insert column header names into top row
213 0 : rPivotCache.writeSourceHeaderCells( *this );
214 0 : }
215 :
216 0 : ContextHandlerRef PivotCacheRecordsFragment::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
217 : {
218 0 : switch( getCurrentElement() )
219 : {
220 : case XML_ROOT_CONTEXT:
221 0 : if( nElement == XLS_TOKEN( pivotCacheRecords ) ) return this;
222 0 : break;
223 :
224 : case XLS_TOKEN( pivotCacheRecords ):
225 0 : if( nElement == XLS_TOKEN( r ) ) { startCacheRecord(); return this; }
226 0 : break;
227 :
228 : case XLS_TOKEN( r ):
229 : {
230 0 : PivotCacheItem aItem;
231 0 : switch( nElement )
232 : {
233 0 : case XLS_TOKEN( m ): break;
234 0 : case XLS_TOKEN( s ): aItem.readString( rAttribs ); break;
235 0 : case XLS_TOKEN( n ): aItem.readNumeric( rAttribs ); break;
236 0 : case XLS_TOKEN( d ): aItem.readDate( rAttribs ); break;
237 0 : case XLS_TOKEN( b ): aItem.readBool( rAttribs ); break;
238 0 : case XLS_TOKEN( e ): aItem.readError( rAttribs, getUnitConverter() ); break;
239 0 : case XLS_TOKEN( x ): aItem.readIndex( rAttribs ); break;
240 : default: OSL_FAIL( "OoxPivotCacheRecordsFragment::onCreateContext - unexpected element" );
241 : }
242 0 : mrPivotCache.writeSourceDataCell( *this, mnColIdx, mnRowIdx, aItem );
243 0 : ++mnColIdx;
244 : }
245 0 : break;
246 : }
247 0 : return 0;
248 : }
249 :
250 0 : ContextHandlerRef PivotCacheRecordsFragment::onCreateRecordContext( sal_Int32 nRecId, SequenceInputStream& rStrm )
251 : {
252 0 : switch( getCurrentElement() )
253 : {
254 : case XML_ROOT_CONTEXT:
255 0 : if( nRecId == BIFF12_ID_PCRECORDS ) return this;
256 0 : break;
257 :
258 : case BIFF12_ID_PCRECORDS:
259 0 : switch( nRecId )
260 : {
261 0 : case BIFF12_ID_PCRECORD: importPCRecord( rStrm ); break;
262 0 : case BIFF12_ID_PCRECORDDT: startCacheRecord(); break;
263 0 : default: importPCRecordItem( nRecId, rStrm ); break;
264 : }
265 0 : break;
266 : }
267 0 : return 0;
268 : }
269 :
270 0 : const RecordInfo* PivotCacheRecordsFragment::getRecordInfos() const
271 : {
272 : static const RecordInfo spRecInfos[] =
273 : {
274 : { BIFF12_ID_PCRECORDS, BIFF12_ID_PCRECORDS + 1 },
275 : { -1, -1 }
276 : };
277 0 : return spRecInfos;
278 : }
279 :
280 : // private --------------------------------------------------------------------
281 :
282 0 : void PivotCacheRecordsFragment::startCacheRecord()
283 : {
284 0 : mnColIdx = 0;
285 0 : ++mnRowIdx;
286 0 : mbInRecord = true;
287 0 : }
288 :
289 0 : void PivotCacheRecordsFragment::importPCRecord( SequenceInputStream& rStrm )
290 : {
291 0 : startCacheRecord();
292 0 : mrPivotCache.importPCRecord( rStrm, *this, mnRowIdx );
293 0 : mbInRecord = false;
294 0 : }
295 :
296 0 : void PivotCacheRecordsFragment::importPCRecordItem( sal_Int32 nRecId, SequenceInputStream& rStrm )
297 : {
298 0 : if( mbInRecord )
299 : {
300 0 : PivotCacheItem aItem;
301 0 : switch( nRecId )
302 : {
303 0 : case BIFF12_ID_PCITEM_MISSING: break;
304 0 : case BIFF12_ID_PCITEM_STRING: aItem.readString( rStrm ); break;
305 0 : case BIFF12_ID_PCITEM_DOUBLE: aItem.readDouble( rStrm ); break;
306 0 : case BIFF12_ID_PCITEM_DATE: aItem.readDate( rStrm ); break;
307 0 : case BIFF12_ID_PCITEM_BOOL: aItem.readBool( rStrm ); break;
308 0 : case BIFF12_ID_PCITEM_ERROR: aItem.readError( rStrm ); break;
309 0 : case BIFF12_ID_PCITEM_INDEX: aItem.readIndex( rStrm ); break;
310 : default: OSL_FAIL( "OoxPivotCacheRecordsFragment::importPCRecordItem - unexpected record" );
311 : }
312 0 : mrPivotCache.writeSourceDataCell( *this, mnColIdx, mnRowIdx, aItem );
313 0 : ++mnColIdx;
314 : }
315 0 : }
316 :
317 : namespace {
318 :
319 0 : bool lclSeekToPCDField( BiffInputStream& rStrm )
320 : {
321 0 : sal_Int64 nRecHandle = rStrm.getRecHandle();
322 0 : while( rStrm.startNextRecord() )
323 0 : if( rStrm.getRecId() == BIFF_ID_PCDFIELD )
324 0 : return true;
325 0 : rStrm.startRecordByHandle( nRecHandle );
326 0 : return false;
327 : }
328 :
329 : } // namespace
330 :
331 0 : BiffPivotCacheFragment::BiffPivotCacheFragment(
332 : const WorkbookHelper& rHelper, const OUString& rStrmName, PivotCache& rPivotCache ) :
333 : BiffWorkbookFragmentBase( rHelper, rStrmName, true ),
334 0 : mrPivotCache( rPivotCache )
335 : {
336 0 : }
337 :
338 0 : bool BiffPivotCacheFragment::importFragment()
339 : {
340 0 : BiffInputStream& rStrm = getInputStream();
341 0 : if( rStrm.startNextRecord() && (rStrm.getRecId() == BIFF_ID_PCDEFINITION) )
342 : {
343 : // read PCDEFINITION and optional PCDEFINITION2 records
344 0 : mrPivotCache.importPCDefinition( rStrm );
345 :
346 : // read cache fields as long as another PCDFIELD record can be found
347 0 : while( lclSeekToPCDField( rStrm ) )
348 0 : mrPivotCache.createCacheField( true ).importPCDField( rStrm );
349 :
350 : // finalize the cache (check source range etc.)
351 0 : mrPivotCache.finalizeImport();
352 :
353 : // load the cache records, if the cache is based on a deleted or an external worksheet
354 0 : if( mrPivotCache.isValidDataSource() && mrPivotCache.isBasedOnDummySheet() )
355 : {
356 : /* Last call of lclSeekToPCDField() failed and kept stream position
357 : unchanged. Stream should point to source data table now. */
358 0 : sal_Int16 nSheet = mrPivotCache.getSourceRange().Sheet;
359 0 : WorksheetGlobalsRef xSheetGlob = WorksheetHelper::constructGlobals( *this, ISegmentProgressBarRef(), SHEETTYPE_WORKSHEET, nSheet );
360 0 : if( xSheetGlob.get() )
361 : {
362 0 : BiffPivotCacheRecordsContext aContext( *xSheetGlob, mrPivotCache );
363 0 : while( rStrm.startNextRecord() && (rStrm.getRecId() != BIFF_ID_EOF) )
364 0 : aContext.importRecord( rStrm );
365 0 : }
366 : }
367 : }
368 :
369 0 : return rStrm.getRecId() == BIFF_ID_EOF;
370 : }
371 :
372 0 : BiffPivotCacheRecordsContext::BiffPivotCacheRecordsContext( const WorksheetHelper& rHelper, const PivotCache& rPivotCache ) :
373 : BiffWorksheetContextBase( rHelper ),
374 : mrPivotCache( rPivotCache ),
375 : mnColIdx( 0 ),
376 : mnRowIdx( 0 ),
377 : mbHasShared( false ),
378 0 : mbInRow( false )
379 : {
380 : // prepare sheet: insert column header names into top row
381 0 : mrPivotCache.writeSourceHeaderCells( *this );
382 :
383 : // find all fields without shared items, remember column indexes in source data
384 0 : for( sal_Int32 nFieldIdx = 0, nFieldCount = mrPivotCache.getCacheFieldCount(), nCol = 0; nFieldIdx < nFieldCount; ++nFieldIdx )
385 : {
386 0 : const PivotCacheField* pCacheField = mrPivotCache.getCacheField( nFieldIdx );
387 0 : if( pCacheField && pCacheField->isDatabaseField() )
388 : {
389 0 : if( pCacheField->hasSharedItems() )
390 0 : mbHasShared = true;
391 : else
392 0 : maUnsharedCols.push_back( nCol );
393 0 : ++nCol;
394 : }
395 : }
396 0 : }
397 :
398 0 : void BiffPivotCacheRecordsContext::importRecord( BiffInputStream& rStrm )
399 : {
400 0 : if( rStrm.getRecId() == BIFF_ID_PCITEM_INDEXLIST )
401 : {
402 : OSL_ENSURE( mbHasShared, "BiffPivotCacheRecordsContext::importRecord - unexpected PCITEM_INDEXLIST record" );
403 : // PCITEM_INDEXLIST record always in front of a new data row
404 0 : startNextRow();
405 0 : mrPivotCache.importPCItemIndexList( rStrm, *this, mnRowIdx );
406 0 : mbInRow = !maUnsharedCols.empty(); // mbInRow remains true, if unshared items are expected
407 0 : return;
408 : }
409 :
410 0 : PivotCacheItem aItem;
411 0 : switch( rStrm.getRecId() )
412 : {
413 0 : case BIFF_ID_PCITEM_MISSING: break;
414 0 : case BIFF_ID_PCITEM_STRING: aItem.readString( rStrm, *this ); break;
415 0 : case BIFF_ID_PCITEM_DOUBLE: aItem.readDouble( rStrm ); break;
416 0 : case BIFF_ID_PCITEM_INTEGER: aItem.readInteger( rStrm ); break;
417 0 : case BIFF_ID_PCITEM_DATE: aItem.readDate( rStrm ); break;
418 0 : case BIFF_ID_PCITEM_BOOL: aItem.readBool( rStrm ); break;
419 0 : case BIFF_ID_PCITEM_ERROR: aItem.readError( rStrm ); break;
420 0 : default: return; // unknown record, ignore
421 : }
422 :
423 : // find next column index, might start new row if no fields with shared items exist
424 0 : if( mbInRow && (mnColIdx == maUnsharedCols.size()) )
425 : {
426 : OSL_ENSURE( !mbHasShared, "BiffPivotCacheRecordsContext::importRecord - PCITEM_INDEXLIST record missing" );
427 0 : mbInRow = mbHasShared; // do not leave current row if PCITEM_INDEXLIST is expected
428 : }
429 : // start next row on first call, or on row wrap without shared items
430 0 : if( !mbInRow )
431 0 : startNextRow();
432 :
433 : // write the item data to the sheet cell
434 : OSL_ENSURE( mnColIdx < maUnsharedCols.size(), "BiffPivotCacheRecordsContext::importRecord - invalid column index" );
435 0 : if( mnColIdx < maUnsharedCols.size() )
436 0 : mrPivotCache.writeSourceDataCell( *this, maUnsharedCols[ mnColIdx ], mnRowIdx, aItem );
437 0 : ++mnColIdx;
438 : }
439 :
440 0 : void BiffPivotCacheRecordsContext::startNextRow()
441 : {
442 0 : mnColIdx = 0;
443 0 : ++mnRowIdx;
444 0 : mbInRow = true;
445 0 : }
446 :
447 : } // namespace xls
448 48 : } // namespace oox
449 :
450 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
