?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
use insert function instead of for loop
[LibreOffice.git] / sc / source / filter / excel / xlpivot.cxx
blobd18ab7416aba811ed2bd8a7c1e54d092ed39b75d
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 <dpsave.hxx>
21 #include <xestream.hxx>
22 #include <xistream.hxx>
23 #include <xestring.hxx>
24 #include <xlpivot.hxx>
25 #include <generalfunction.hxx>
26 #include <osl/diagnose.h>
27 #include <sal/log.hxx>
28 #include <com/sun/star/sheet/DataPilotFieldGroupBy.hpp>
29 #include <com/sun/star/sheet/DataPilotFieldSortMode.hpp>
30 #include <com/sun/star/sheet/DataPilotFieldShowItemsMode.hpp>
31 #include <com/sun/star/sheet/DataPilotFieldLayoutMode.hpp>
32 #include <com/sun/star/sheet/DataPilotFieldReferenceType.hpp>
33 #include <com/sun/star/sheet/DataPilotFieldReferenceItemType.hpp>
34
35 using ::com::sun::star::sheet::DataPilotFieldOrientation;
36
37 namespace ScDPSortMode = ::com::sun::star::sheet::DataPilotFieldSortMode;
38 namespace ScDPShowItemsMode = ::com::sun::star::sheet::DataPilotFieldShowItemsMode;
39 namespace ScDPLayoutMode = ::com::sun::star::sheet::DataPilotFieldLayoutMode;
40 namespace ScDPRefItemType = ::com::sun::star::sheet::DataPilotFieldReferenceItemType;
41 namespace ScDPGroupBy = ::com::sun::star::sheet::DataPilotFieldGroupBy;
42
43 // Pivot cache
44
45 XclPCItem::XclPCItem() :
46 meType( EXC_PCITEM_INVALID ),
47 maDateTime( DateTime::EMPTY )
48 {
49 }
50
51 XclPCItem::~XclPCItem()
52 {
53 }
54
55 void XclPCItem::SetEmpty()
56 {
57 meType = EXC_PCITEM_EMPTY;
58 maText.clear();
59 }
60
61 void XclPCItem::SetText( const OUString& rText )
62 {
63 meType = EXC_PCITEM_TEXT;
64 maText = rText;
65 }
66
67 void XclPCItem::SetDouble( double fValue, const OUString& rText )
68 {
69 meType = EXC_PCITEM_DOUBLE;
70 maText = rText;
71 mfValue = fValue;
72 }
73
74 void XclPCItem::SetDateTime( const DateTime& rDateTime, const OUString& rText )
75 {
76 meType = EXC_PCITEM_DATETIME;
77 maText = rText;
78 maDateTime = rDateTime;
79 }
80
81 void XclPCItem::SetInteger( sal_Int16 nValue )
82 {
83 meType = EXC_PCITEM_INTEGER;
84 maText = OUString::number(nValue);
85 mnValue = nValue;
86 }
87
88 void XclPCItem::SetError( sal_uInt16 nError )
89 {
90 meType = EXC_PCITEM_ERROR;
91 maText.clear();
92 mnError = nError;
93 switch( nError )
94 {
95 case 0x00: maText = "#nullptr!"; break;
96 case 0x07: maText = "#DIV/0!"; break;
97 case 0x0F: maText = "#VALUE!"; break;
98 case 0x17: maText = "#REF!"; break;
99 case 0x1D: maText = "#NAME?"; break;
100 case 0x24: maText = "#NUM!"; break;
101 case 0x2A: maText = "#N/A"; break;
102 default: break;
103 }
104 }
105
106 void XclPCItem::SetBool( bool bValue, const OUString& rText )
107 {
108 meType = EXC_PCITEM_BOOL;
109 maText = rText;
110 mbValue = bValue;
111 }
112
113 bool XclPCItem::IsEqual( const XclPCItem& rItem ) const
114 {
115 if( meType == rItem.meType ) switch( meType )
116 {
117 case EXC_PCITEM_INVALID: return true;
118 case EXC_PCITEM_EMPTY: return true;
119 case EXC_PCITEM_TEXT: return maText == rItem.maText;
120 case EXC_PCITEM_DOUBLE: return mfValue == rItem.mfValue;
121 case EXC_PCITEM_DATETIME: return maDateTime == rItem.maDateTime;
122 case EXC_PCITEM_INTEGER: return mnValue == rItem.mnValue;
123 case EXC_PCITEM_BOOL: return mbValue == rItem.mbValue;
124 case EXC_PCITEM_ERROR: return mnError == rItem.mnError;
125 default: OSL_FAIL( "XclPCItem::IsEqual - unknown pivot cache item type" );
126 }
127 return false;
128 }
129
130 bool XclPCItem::IsEmpty() const
131 {
132 return meType == EXC_PCITEM_EMPTY;
133 }
134
135 const OUString* XclPCItem::GetText() const
136 {
137 return (meType == EXC_PCITEM_TEXT || meType == EXC_PCITEM_ERROR) ? &maText : nullptr;
138 }
139
140 const double* XclPCItem::GetDouble() const
141 {
142 return (meType == EXC_PCITEM_DOUBLE) ? &mfValue : nullptr;
143 }
144
145 const DateTime* XclPCItem::GetDateTime() const
146 {
147 return (meType == EXC_PCITEM_DATETIME) ? &maDateTime : nullptr;
148 }
149
150 const sal_Int16* XclPCItem::GetInteger() const
151 {
152 return (meType == EXC_PCITEM_INTEGER) ? &mnValue : nullptr;
153 }
154
155 const sal_uInt16* XclPCItem::GetError() const
156 {
157 return (meType == EXC_PCITEM_ERROR) ? &mnError : nullptr;
158 }
159
160 const bool* XclPCItem::GetBool() const
161 {
162 return (meType == EXC_PCITEM_BOOL) ? &mbValue : nullptr;
163 }
164
165 XclPCItemType XclPCItem::GetType() const
166 {
167 return meType;
168 }
169
170 // Field settings =============================================================
171
172 XclPCFieldInfo::XclPCFieldInfo() :
173 mnFlags( 0 ),
174 mnGroupChild( 0 ),
175 mnGroupBase( 0 ),
176 mnVisItems( 0 ),
177 mnGroupItems( 0 ),
178 mnBaseItems( 0 ),
179 mnOrigItems( 0 )
180 {
181 }
182
183 XclImpStream& operator>>( XclImpStream& rStrm, XclPCFieldInfo& rInfo )
184 {
185 rInfo.mnFlags = rStrm.ReaduInt16();
186 rInfo.mnGroupChild = rStrm.ReaduInt16();
187 rInfo.mnGroupBase = rStrm.ReaduInt16();
188 rInfo.mnVisItems = rStrm.ReaduInt16();
189 rInfo.mnGroupItems = rStrm.ReaduInt16();
190 rInfo.mnBaseItems = rStrm.ReaduInt16();
191 rInfo.mnOrigItems = rStrm.ReaduInt16();
192 if( rStrm.GetRecLeft() >= 3 )
193 rInfo.maName = rStrm.ReadUniString();
194 else
195 rInfo.maName.clear();
196 return rStrm;
197 }
198
199 XclExpStream& operator<<( XclExpStream& rStrm, const XclPCFieldInfo& rInfo )
200 {
201 return rStrm
202 << rInfo.mnFlags
203 << rInfo.mnGroupChild
204 << rInfo.mnGroupBase
205 << rInfo.mnVisItems
206 << rInfo.mnGroupItems
207 << rInfo.mnBaseItems
208 << rInfo.mnOrigItems
209 << XclExpString( rInfo.maName );
210 }
211
212 // Numeric grouping field settings ============================================
213
214 XclPCNumGroupInfo::XclPCNumGroupInfo() :
215 mnFlags( EXC_SXNUMGROUP_AUTOMIN | EXC_SXNUMGROUP_AUTOMAX )
216 {
217 SetNumType();
218 }
219
220 void XclPCNumGroupInfo::SetNumType()
221 {
222 SetXclDataType( EXC_SXNUMGROUP_TYPE_NUM );
223 }
224
225 sal_Int32 XclPCNumGroupInfo::GetScDateType() const
226 {
227 sal_Int32 nScType = 0;
228 switch( GetXclDataType() )
229 {
230 case EXC_SXNUMGROUP_TYPE_SEC: nScType = ScDPGroupBy::SECONDS; break;
231 case EXC_SXNUMGROUP_TYPE_MIN: nScType = ScDPGroupBy::MINUTES; break;
232 case EXC_SXNUMGROUP_TYPE_HOUR: nScType = ScDPGroupBy::HOURS; break;
233 case EXC_SXNUMGROUP_TYPE_DAY: nScType = ScDPGroupBy::DAYS; break;
234 case EXC_SXNUMGROUP_TYPE_MONTH: nScType = ScDPGroupBy::MONTHS; break;
235 case EXC_SXNUMGROUP_TYPE_QUART: nScType = ScDPGroupBy::QUARTERS; break;
236 case EXC_SXNUMGROUP_TYPE_YEAR: nScType = ScDPGroupBy::YEARS; break;
237 default: SAL_WARN("sc.filter", "XclPCNumGroupInfo::GetScDateType - unexpected date type " << GetXclDataType() );
238 }
239 return nScType;
240 }
241
242 void XclPCNumGroupInfo::SetScDateType( sal_Int32 nScType )
243 {
244 sal_uInt16 nXclType = EXC_SXNUMGROUP_TYPE_NUM;
245 switch( nScType )
246 {
247 case ScDPGroupBy::SECONDS: nXclType = EXC_SXNUMGROUP_TYPE_SEC; break;
248 case ScDPGroupBy::MINUTES: nXclType = EXC_SXNUMGROUP_TYPE_MIN; break;
249 case ScDPGroupBy::HOURS: nXclType = EXC_SXNUMGROUP_TYPE_HOUR; break;
250 case ScDPGroupBy::DAYS: nXclType = EXC_SXNUMGROUP_TYPE_DAY; break;
251 case ScDPGroupBy::MONTHS: nXclType = EXC_SXNUMGROUP_TYPE_MONTH; break;
252 case ScDPGroupBy::QUARTERS: nXclType = EXC_SXNUMGROUP_TYPE_QUART; break;
253 case ScDPGroupBy::YEARS: nXclType = EXC_SXNUMGROUP_TYPE_YEAR; break;
254 default:
255 SAL_INFO("sc.filter", "unexpected date type " << nScType);
256 }
257 SetXclDataType( nXclType );
258 }
259
260 sal_uInt16 XclPCNumGroupInfo::GetXclDataType() const
261 {
262 return ::extract_value< sal_uInt16 >( mnFlags, 2, 4 );
263 }
264
265 void XclPCNumGroupInfo::SetXclDataType( sal_uInt16 nXclType )
266 {
267 ::insert_value( mnFlags, nXclType, 2, 4 );
268 }
269
270 XclImpStream& operator>>( XclImpStream& rStrm, XclPCNumGroupInfo& rInfo )
271 {
272 rInfo.mnFlags = rStrm.ReaduInt16();
273 return rStrm;
274 }
275
276 XclExpStream& operator<<( XclExpStream& rStrm, const XclPCNumGroupInfo& rInfo )
277 {
278 return rStrm << rInfo.mnFlags;
279 }
280
281 // Base class for pivot cache fields ==========================================
282
283 XclPCField::XclPCField( XclPCFieldType eFieldType, sal_uInt16 nFieldIdx ) :
284 meFieldType( eFieldType ),
285 mnFieldIdx( nFieldIdx )
286 {
287 }
288
289 XclPCField::~XclPCField()
290 {
291 }
292
293 bool XclPCField::IsSupportedField() const
294 {
295 return (meFieldType != EXC_PCFIELD_CALCED) && (meFieldType != EXC_PCFIELD_UNKNOWN);
296 }
297
298 bool XclPCField::IsStandardField() const
299 {
300 return meFieldType == EXC_PCFIELD_STANDARD;
301 }
302
303 bool XclPCField::IsStdGroupField() const
304 {
305 return meFieldType == EXC_PCFIELD_STDGROUP;
306 }
307
308 bool XclPCField::IsNumGroupField() const
309 {
310 return meFieldType == EXC_PCFIELD_NUMGROUP;
311 }
312
313 bool XclPCField::IsDateGroupField() const
314 {
315 return (meFieldType == EXC_PCFIELD_DATEGROUP) || (meFieldType == EXC_PCFIELD_DATECHILD);
316 }
317
318 bool XclPCField::IsGroupField() const
319 {
320 return IsStdGroupField() || IsNumGroupField() || IsDateGroupField();
321 }
322
323 bool XclPCField::IsGroupBaseField() const
324 {
325 return ::get_flag( maFieldInfo.mnFlags, EXC_SXFIELD_HASCHILD );
326 }
327
328 bool XclPCField::IsGroupChildField() const
329 {
330 return (meFieldType == EXC_PCFIELD_STDGROUP) || (meFieldType == EXC_PCFIELD_DATECHILD);
331 }
332
333 bool XclPCField::HasOrigItems() const
334 {
335 return IsSupportedField() && ((maFieldInfo.mnOrigItems > 0) || HasPostponedItems());
336 }
337
338 bool XclPCField::HasInlineItems() const
339 {
340 return (IsStandardField() || IsGroupField()) && ((maFieldInfo.mnGroupItems > 0) || (maFieldInfo.mnOrigItems > 0));
341 }
342
343 bool XclPCField::HasPostponedItems() const
344 {
345 return IsStandardField() && ::get_flag( maFieldInfo.mnFlags, EXC_SXFIELD_POSTPONE );
346 }
347
348 bool XclPCField::Has16BitIndexes() const
349 {
350 return IsStandardField() && ::get_flag( maFieldInfo.mnFlags, EXC_SXFIELD_16BIT );
351 }
352
353 // Pivot cache settings =======================================================
354
355 /** Contains data for a pivot cache (SXDB record). */
356 XclPCInfo::XclPCInfo() :
357 mnSrcRecs( 0 ),
358 mnStrmId( 0xFFFF ),
359 mnFlags( EXC_SXDB_DEFAULTFLAGS ),
360 mnBlockRecs( EXC_SXDB_BLOCKRECS ),
361 mnStdFields( 0 ),
362 mnTotalFields( 0 ),
363 mnSrcType( EXC_SXDB_SRC_SHEET )
364 {
365 }
366
367 XclImpStream& operator>>( XclImpStream& rStrm, XclPCInfo& rInfo )
368 {
369 rInfo.mnSrcRecs = rStrm.ReaduInt32();
370 rInfo.mnStrmId = rStrm.ReaduInt16();
371 rInfo.mnFlags = rStrm.ReaduInt16();
372 rInfo.mnBlockRecs = rStrm.ReaduInt16();
373 rInfo.mnStdFields = rStrm.ReaduInt16();
374 rInfo.mnTotalFields = rStrm.ReaduInt16();
375 rStrm.Ignore( 2 );
376 rInfo.mnSrcType = rStrm.ReaduInt16();
377 rInfo.maUserName = rStrm.ReadUniString();
378 return rStrm;
379 }
380
381 XclExpStream& operator<<( XclExpStream& rStrm, const XclPCInfo& rInfo )
382 {
383 return rStrm
384 << rInfo.mnSrcRecs
385 << rInfo.mnStrmId
386 << rInfo.mnFlags
387 << rInfo.mnBlockRecs
388 << rInfo.mnStdFields
389 << rInfo.mnTotalFields
390 << sal_uInt16( 0 )
391 << rInfo.mnSrcType
392 << XclExpString( rInfo.maUserName );
393 }
394
395 // Pivot table
396
397 // cached name ================================================================
398
399 XclImpStream& operator>>( XclImpStream& rStrm, XclPTCachedName& rCachedName )
400 {
401 sal_uInt16 nStrLen;
402 nStrLen = rStrm.ReaduInt16();
403 rCachedName.mbUseCache = nStrLen == EXC_PT_NOSTRING;
404 if( rCachedName.mbUseCache )
405 rCachedName.maName.clear();
406 else
407 rCachedName.maName = rStrm.ReadUniString( nStrLen );
408 return rStrm;
409 }
410
411 XclExpStream& operator<<( XclExpStream& rStrm, const XclPTCachedName& rCachedName )
412 {
413 if( rCachedName.mbUseCache )
414 rStrm << EXC_PT_NOSTRING;
415 else
416 rStrm << XclExpString( rCachedName.maName, XclStrFlags::NONE, EXC_PT_MAXSTRLEN );
417 return rStrm;
418 }
419
420 const OUString* XclPTVisNameInfo::GetVisName() const
421 {
422 return HasVisName() ? &maVisName.maName : nullptr;
423 }
424
425 void XclPTVisNameInfo::SetVisName( const OUString& rName )
426 {
427 maVisName.maName = rName;
428 maVisName.mbUseCache = rName.isEmpty();
429 }
430
431 // Field item settings ========================================================
432
433 XclPTItemInfo::XclPTItemInfo() :
434 mnType( EXC_SXVI_TYPE_DATA ),
435 mnFlags( EXC_SXVI_DEFAULTFLAGS ),
436 mnCacheIdx( EXC_SXVI_DEFAULT_CACHE )
437 {
438 }
439
440 XclImpStream& operator>>( XclImpStream& rStrm, XclPTItemInfo& rInfo )
441 {
442 rInfo.mnType = rStrm.ReaduInt16();
443 rInfo.mnFlags = rStrm.ReaduInt16();
444 rInfo.mnCacheIdx = rStrm.ReaduInt16();
445 rStrm >> rInfo.maVisName;
446 return rStrm;
447 }
448
449 XclExpStream& operator<<( XclExpStream& rStrm, const XclPTItemInfo& rInfo )
450 {
451 return rStrm
452 << rInfo.mnType
453 << rInfo.mnFlags
454 << rInfo.mnCacheIdx
455 << rInfo.maVisName;
456 }
457
458 // General field settings =====================================================
459
460 XclPTFieldInfo::XclPTFieldInfo() :
461 mnAxes( EXC_SXVD_AXIS_NONE ),
462 mnSubtCount( 1 ),
463 mnSubtotals( EXC_SXVD_SUBT_DEFAULT ),
464 mnItemCount( 0 ),
465 mnCacheIdx( EXC_SXVD_DEFAULT_CACHE )
466 {
467 }
468
469 DataPilotFieldOrientation XclPTFieldInfo::GetApiOrient( sal_uInt16 nMask ) const
470 {
471 using namespace ::com::sun::star::sheet;
472 DataPilotFieldOrientation eOrient = DataPilotFieldOrientation_HIDDEN;
473 sal_uInt16 nUsedAxes = mnAxes & nMask;
474 if( nUsedAxes & EXC_SXVD_AXIS_ROW )
475 eOrient = DataPilotFieldOrientation_ROW;
476 else if( nUsedAxes & EXC_SXVD_AXIS_COL )
477 eOrient = DataPilotFieldOrientation_COLUMN;
478 else if( nUsedAxes & EXC_SXVD_AXIS_PAGE )
479 eOrient = DataPilotFieldOrientation_PAGE;
480 else if( nUsedAxes & EXC_SXVD_AXIS_DATA )
481 eOrient = DataPilotFieldOrientation_DATA;
482 return eOrient;
483 }
484
485 void XclPTFieldInfo::AddApiOrient( DataPilotFieldOrientation eOrient )
486 {
487 using namespace ::com::sun::star::sheet;
488 switch( eOrient )
489 {
490 case DataPilotFieldOrientation_ROW: mnAxes |= EXC_SXVD_AXIS_ROW; break;
491 case DataPilotFieldOrientation_COLUMN: mnAxes |= EXC_SXVD_AXIS_COL; break;
492 case DataPilotFieldOrientation_PAGE: mnAxes |= EXC_SXVD_AXIS_PAGE; break;
493 case DataPilotFieldOrientation_DATA: mnAxes |= EXC_SXVD_AXIS_DATA; break;
494 default:;
495 }
496 }
497
498 //TODO: should be a Sequence<GeneralFunction> in ScDPSaveData
499 void XclPTFieldInfo::GetSubtotals( XclPTSubtotalVec& rSubtotals ) const
500 {
501 rSubtotals.clear();
502 rSubtotals.reserve( 16 );
503
504 if( mnSubtotals & EXC_SXVD_SUBT_DEFAULT ) rSubtotals.push_back( ScGeneralFunction::AUTO );
505 if( mnSubtotals & EXC_SXVD_SUBT_SUM ) rSubtotals.push_back( ScGeneralFunction::SUM );
506 if( mnSubtotals & EXC_SXVD_SUBT_COUNT ) rSubtotals.push_back( ScGeneralFunction::COUNT );
507 if( mnSubtotals & EXC_SXVD_SUBT_AVERAGE ) rSubtotals.push_back( ScGeneralFunction::AVERAGE );
508 if( mnSubtotals & EXC_SXVD_SUBT_MAX ) rSubtotals.push_back( ScGeneralFunction::MAX );
509 if( mnSubtotals & EXC_SXVD_SUBT_MIN ) rSubtotals.push_back( ScGeneralFunction::MIN );
510 if( mnSubtotals & EXC_SXVD_SUBT_PROD ) rSubtotals.push_back( ScGeneralFunction::PRODUCT );
511 if( mnSubtotals & EXC_SXVD_SUBT_COUNTNUM ) rSubtotals.push_back( ScGeneralFunction::COUNTNUMS );
512 if( mnSubtotals & EXC_SXVD_SUBT_STDDEV ) rSubtotals.push_back( ScGeneralFunction::STDEV );
513 if( mnSubtotals & EXC_SXVD_SUBT_STDDEVP ) rSubtotals.push_back( ScGeneralFunction::STDEVP );
514 if( mnSubtotals & EXC_SXVD_SUBT_VAR ) rSubtotals.push_back( ScGeneralFunction::VAR );
515 if( mnSubtotals & EXC_SXVD_SUBT_VARP ) rSubtotals.push_back( ScGeneralFunction::VARP );
516 }
517
518 void XclPTFieldInfo::SetSubtotals( const XclPTSubtotalVec& rSubtotals )
519 {
520 mnSubtotals = EXC_SXVD_SUBT_NONE;
521 for( const auto& rSubtotal : rSubtotals )
522 {
523 switch( rSubtotal )
524 {
525 case ScGeneralFunction::AUTO: mnSubtotals |= EXC_SXVD_SUBT_DEFAULT; break;
526 case ScGeneralFunction::SUM: mnSubtotals |= EXC_SXVD_SUBT_SUM; break;
527 case ScGeneralFunction::COUNT: mnSubtotals |= EXC_SXVD_SUBT_COUNT; break;
528 case ScGeneralFunction::AVERAGE: mnSubtotals |= EXC_SXVD_SUBT_AVERAGE; break;
529 case ScGeneralFunction::MAX: mnSubtotals |= EXC_SXVD_SUBT_MAX; break;
530 case ScGeneralFunction::MIN: mnSubtotals |= EXC_SXVD_SUBT_MIN; break;
531 case ScGeneralFunction::PRODUCT: mnSubtotals |= EXC_SXVD_SUBT_PROD; break;
532 case ScGeneralFunction::COUNTNUMS: mnSubtotals |= EXC_SXVD_SUBT_COUNTNUM; break;
533 case ScGeneralFunction::STDEV: mnSubtotals |= EXC_SXVD_SUBT_STDDEV; break;
534 case ScGeneralFunction::STDEVP: mnSubtotals |= EXC_SXVD_SUBT_STDDEVP; break;
535 case ScGeneralFunction::VAR: mnSubtotals |= EXC_SXVD_SUBT_VAR; break;
536 case ScGeneralFunction::VARP: mnSubtotals |= EXC_SXVD_SUBT_VARP; break;
537 default: break;
538 }
539 }
540
541 mnSubtCount = 0;
542 for( sal_uInt16 nMask = 0x8000; nMask; nMask >>= 1 )
543 if( mnSubtotals & nMask )
544 ++mnSubtCount;
545 }
546
547 XclImpStream& operator>>( XclImpStream& rStrm, XclPTFieldInfo& rInfo )
548 {
549 // rInfo.mnCacheIdx is not part of the SXVD record
550 rInfo.mnAxes = rStrm.ReaduInt16();
551 rInfo.mnSubtCount = rStrm.ReaduInt16();
552 rInfo.mnSubtotals = rStrm.ReaduInt16();
553 rInfo.mnItemCount = rStrm.ReaduInt16();
554 rStrm >> rInfo.maVisName;
555 return rStrm;
556 }
557
558 XclExpStream& operator<<( XclExpStream& rStrm, const XclPTFieldInfo& rInfo )
559 {
560 // rInfo.mnCacheIdx is not part of the SXVD record
561 return rStrm
562 << rInfo.mnAxes
563 << rInfo.mnSubtCount
564 << rInfo.mnSubtotals
565 << rInfo.mnItemCount
566 << rInfo.maVisName;
567 }
568
569 // Extended field settings ====================================================
570
571 XclPTFieldExtInfo::XclPTFieldExtInfo() :
572 mnFlags( EXC_SXVDEX_DEFAULTFLAGS ),
573 mnSortField( EXC_SXVDEX_SORT_OWN ),
574 mnShowField( EXC_SXVDEX_SHOW_NONE ),
575 mnNumFmt(0)
576 {
577 }
578
579 sal_Int32 XclPTFieldExtInfo::GetApiSortMode() const
580 {
581 sal_Int32 nSortMode = ScDPSortMode::MANUAL;
582 if( ::get_flag( mnFlags, EXC_SXVDEX_SORT ) )
583 nSortMode = (mnSortField == EXC_SXVDEX_SORT_OWN) ? ScDPSortMode::NAME : ScDPSortMode::DATA;
584 return nSortMode;
585 }
586
587 void XclPTFieldExtInfo::SetApiSortMode( sal_Int32 nSortMode )
588 {
589 bool bSort = (nSortMode == ScDPSortMode::NAME) || (nSortMode == ScDPSortMode::DATA);
590 ::set_flag( mnFlags, EXC_SXVDEX_SORT, bSort );
591 if( nSortMode == ScDPSortMode::NAME )
592 mnSortField = EXC_SXVDEX_SORT_OWN; // otherwise sort field has to be set by caller
593 }
594
595 sal_Int32 XclPTFieldExtInfo::GetApiAutoShowMode() const
596 {
597 return ::get_flagvalue( mnFlags, EXC_SXVDEX_AUTOSHOW_ASC,
598 ScDPShowItemsMode::FROM_TOP, ScDPShowItemsMode::FROM_BOTTOM );
599 }
600
601 void XclPTFieldExtInfo::SetApiAutoShowMode( sal_Int32 nShowMode )
602 {
603 ::set_flag( mnFlags, EXC_SXVDEX_AUTOSHOW_ASC, nShowMode == ScDPShowItemsMode::FROM_TOP );
604 }
605
606 sal_Int32 XclPTFieldExtInfo::GetApiAutoShowCount() const
607 {
608 return ::extract_value< sal_Int32 >( mnFlags, 24, 8 );
609 }
610
611 void XclPTFieldExtInfo::SetApiAutoShowCount( sal_Int32 nShowCount )
612 {
613 ::insert_value( mnFlags, limit_cast< sal_uInt8 >( nShowCount ), 24, 8 );
614 }
615
616 sal_Int32 XclPTFieldExtInfo::GetApiLayoutMode() const
617 {
618 sal_Int32 nLayoutMode = ScDPLayoutMode::TABULAR_LAYOUT;
619 if( ::get_flag( mnFlags, EXC_SXVDEX_LAYOUT_REPORT ) )
620 nLayoutMode = ::get_flag( mnFlags, EXC_SXVDEX_LAYOUT_TOP ) ?
621 ScDPLayoutMode::OUTLINE_SUBTOTALS_TOP : ScDPLayoutMode::OUTLINE_SUBTOTALS_BOTTOM;
622 return nLayoutMode;
623 }
624
625 void XclPTFieldExtInfo::SetApiLayoutMode( sal_Int32 nLayoutMode )
626 {
627 ::set_flag( mnFlags, EXC_SXVDEX_LAYOUT_REPORT, nLayoutMode != ScDPLayoutMode::TABULAR_LAYOUT );
628 ::set_flag( mnFlags, EXC_SXVDEX_LAYOUT_TOP, nLayoutMode == ScDPLayoutMode::OUTLINE_SUBTOTALS_TOP );
629 }
630
631 XclImpStream& operator>>( XclImpStream& rStrm, XclPTFieldExtInfo& rInfo )
632 {
633 sal_uInt8 nNameLen = 0;
634 rInfo.mnFlags = rStrm.ReaduInt32();
635 rInfo.mnSortField = rStrm.ReaduInt16();
636 rInfo.mnShowField = rStrm.ReaduInt16();
637 rInfo.mnNumFmt = rStrm.ReaduInt16();
638 nNameLen = rStrm.ReaduInt8();
639
640 rStrm.Ignore(10);
641 if (nNameLen != 0xFF)
642 // Custom field total name is used. Pick it up.
643 rInfo.mpFieldTotalName = rStrm.ReadUniString(nNameLen, 0);
644
645 return rStrm;
646 }
647
648 XclExpStream& operator<<( XclExpStream& rStrm, const XclPTFieldExtInfo& rInfo )
649 {
650 rStrm << rInfo.mnFlags
651 << rInfo.mnSortField
652 << rInfo.mnShowField
653 << EXC_SXVDEX_FORMAT_NONE;
654
655 if (rInfo.mpFieldTotalName && !rInfo.mpFieldTotalName->isEmpty())
656 {
657 OUString aFinalName = *rInfo.mpFieldTotalName;
658 if (aFinalName.getLength() >= 254)
659 aFinalName = aFinalName.copy(0, 254);
660 sal_uInt8 nNameLen = static_cast<sal_uInt8>(aFinalName.getLength());
661 rStrm << nNameLen;
662 rStrm.WriteZeroBytes(10);
663 rStrm << XclExpString(aFinalName, XclStrFlags::NoHeader);
664 }
665 else
666 {
667 rStrm << sal_uInt16(0xFFFF);
668 rStrm.WriteZeroBytes(8);
669 }
670 return rStrm;
671 }
672
673 // Page field settings ========================================================
674
675 XclPTPageFieldInfo::XclPTPageFieldInfo() :
676 mnField( 0 ),
677 mnSelItem( EXC_SXPI_ALLITEMS ),
678 mnObjId( 0xFFFF )
679 {
680 }
681
682 XclImpStream& operator>>( XclImpStream& rStrm, XclPTPageFieldInfo& rInfo )
683 {
684 rInfo.mnField = rStrm.ReaduInt16();
685 rInfo.mnSelItem = rStrm.ReaduInt16();
686 rInfo.mnObjId = rStrm.ReaduInt16();
687 return rStrm;
688 }
689
690 XclExpStream& operator<<( XclExpStream& rStrm, const XclPTPageFieldInfo& rInfo )
691 {
692 return rStrm
693 << rInfo.mnField
694 << rInfo.mnSelItem
695 << rInfo.mnObjId;
696 }
697
698 // Data field settings ========================================================
699
700 XclPTDataFieldInfo::XclPTDataFieldInfo() :
701 mnField( 0 ),
702 mnAggFunc( EXC_SXDI_FUNC_SUM ),
703 mnRefType( EXC_SXDI_REF_NORMAL ),
704 mnRefField( 0 ),
705 mnRefItem( 0 ),
706 mnNumFmt( 0 )
707 {
708 }
709
710 ScGeneralFunction XclPTDataFieldInfo::GetApiAggFunc() const
711 {
712 ScGeneralFunction eAggFunc;
713 switch( mnAggFunc )
714 {
715 case EXC_SXDI_FUNC_SUM: eAggFunc = ScGeneralFunction::SUM; break;
716 case EXC_SXDI_FUNC_COUNT: eAggFunc = ScGeneralFunction::COUNT; break;
717 case EXC_SXDI_FUNC_AVERAGE: eAggFunc = ScGeneralFunction::AVERAGE; break;
718 case EXC_SXDI_FUNC_MAX: eAggFunc = ScGeneralFunction::MAX; break;
719 case EXC_SXDI_FUNC_MIN: eAggFunc = ScGeneralFunction::MIN; break;
720 case EXC_SXDI_FUNC_PRODUCT: eAggFunc = ScGeneralFunction::PRODUCT; break;
721 case EXC_SXDI_FUNC_COUNTNUM: eAggFunc = ScGeneralFunction::COUNTNUMS; break;
722 case EXC_SXDI_FUNC_STDDEV: eAggFunc = ScGeneralFunction::STDEV; break;
723 case EXC_SXDI_FUNC_STDDEVP: eAggFunc = ScGeneralFunction::STDEVP; break;
724 case EXC_SXDI_FUNC_VAR: eAggFunc = ScGeneralFunction::VAR; break;
725 case EXC_SXDI_FUNC_VARP: eAggFunc = ScGeneralFunction::VARP; break;
726 default: eAggFunc = ScGeneralFunction::SUM;
727 }
728 return eAggFunc;
729 }
730
731 void XclPTDataFieldInfo::SetApiAggFunc( ScGeneralFunction eAggFunc )
732 {
733 switch( eAggFunc )
734 {
735 case ScGeneralFunction::SUM: mnAggFunc = EXC_SXDI_FUNC_SUM; break;
736 case ScGeneralFunction::COUNT: mnAggFunc = EXC_SXDI_FUNC_COUNT; break;
737 case ScGeneralFunction::AVERAGE: mnAggFunc = EXC_SXDI_FUNC_AVERAGE; break;
738 case ScGeneralFunction::MAX: mnAggFunc = EXC_SXDI_FUNC_MAX; break;
739 case ScGeneralFunction::MIN: mnAggFunc = EXC_SXDI_FUNC_MIN; break;
740 case ScGeneralFunction::PRODUCT: mnAggFunc = EXC_SXDI_FUNC_PRODUCT; break;
741 case ScGeneralFunction::COUNTNUMS: mnAggFunc = EXC_SXDI_FUNC_COUNTNUM; break;
742 case ScGeneralFunction::STDEV: mnAggFunc = EXC_SXDI_FUNC_STDDEV; break;
743 case ScGeneralFunction::STDEVP: mnAggFunc = EXC_SXDI_FUNC_STDDEVP; break;
744 case ScGeneralFunction::VAR: mnAggFunc = EXC_SXDI_FUNC_VAR; break;
745 case ScGeneralFunction::VARP: mnAggFunc = EXC_SXDI_FUNC_VARP; break;
746 default: mnAggFunc = EXC_SXDI_FUNC_SUM;
747 }
748 }
749
750 sal_Int32 XclPTDataFieldInfo::GetApiRefType() const
751 {
752 namespace ScDPRefType = ::com::sun::star::sheet::DataPilotFieldReferenceType;
753 sal_Int32 nRefType;
754 switch( mnRefType )
755 {
756 case EXC_SXDI_REF_DIFF: nRefType = ScDPRefType::ITEM_DIFFERENCE; break;
757 case EXC_SXDI_REF_PERC: nRefType = ScDPRefType::ITEM_PERCENTAGE; break;
758 case EXC_SXDI_REF_PERC_DIFF: nRefType = ScDPRefType::ITEM_PERCENTAGE_DIFFERENCE; break;
759 case EXC_SXDI_REF_RUN_TOTAL: nRefType = ScDPRefType::RUNNING_TOTAL; break;
760 case EXC_SXDI_REF_PERC_ROW: nRefType = ScDPRefType::ROW_PERCENTAGE; break;
761 case EXC_SXDI_REF_PERC_COL: nRefType = ScDPRefType::COLUMN_PERCENTAGE; break;
762 case EXC_SXDI_REF_PERC_TOTAL: nRefType = ScDPRefType::TOTAL_PERCENTAGE; break;
763 case EXC_SXDI_REF_INDEX: nRefType = ScDPRefType::INDEX; break;
764 default: nRefType = ScDPRefType::NONE;
765 }
766 return nRefType;
767 }
768
769 void XclPTDataFieldInfo::SetApiRefType( sal_Int32 nRefType )
770 {
771 namespace ScDPRefType = ::com::sun::star::sheet::DataPilotFieldReferenceType;
772 switch( nRefType )
773 {
774 case ScDPRefType::ITEM_DIFFERENCE: mnRefType = EXC_SXDI_REF_DIFF; break;
775 case ScDPRefType::ITEM_PERCENTAGE: mnRefType = EXC_SXDI_REF_PERC; break;
776 case ScDPRefType::ITEM_PERCENTAGE_DIFFERENCE: mnRefType = EXC_SXDI_REF_PERC_DIFF; break;
777 case ScDPRefType::RUNNING_TOTAL: mnRefType = EXC_SXDI_REF_RUN_TOTAL; break;
778 case ScDPRefType::ROW_PERCENTAGE: mnRefType = EXC_SXDI_REF_PERC_ROW; break;
779 case ScDPRefType::COLUMN_PERCENTAGE: mnRefType = EXC_SXDI_REF_PERC_COL; break;
780 case ScDPRefType::TOTAL_PERCENTAGE: mnRefType = EXC_SXDI_REF_PERC_TOTAL;break;
781 case ScDPRefType::INDEX: mnRefType = EXC_SXDI_REF_INDEX; break;
782 default: mnRefType = EXC_SXDI_REF_NORMAL;
783 }
784 }
785
786 sal_Int32 XclPTDataFieldInfo::GetApiRefItemType() const
787 {
788 sal_Int32 nRefItemType;
789 switch( mnRefItem )
790 {
791 case EXC_SXDI_PREVITEM: nRefItemType = ScDPRefItemType::PREVIOUS; break;
792 case EXC_SXDI_NEXTITEM: nRefItemType = ScDPRefItemType::NEXT; break;
793 default: nRefItemType = ScDPRefItemType::NAMED;
794 }
795 return nRefItemType;
796 }
797
798 void XclPTDataFieldInfo::SetApiRefItemType( sal_Int32 nRefItemType )
799 {
800 switch( nRefItemType )
801 {
802 case ScDPRefItemType::PREVIOUS: mnRefItem = EXC_SXDI_PREVITEM; break;
803 case ScDPRefItemType::NEXT: mnRefItem = EXC_SXDI_NEXTITEM; break;
804 // nothing for named item reference
805 }
806 }
807
808 XclImpStream& operator>>( XclImpStream& rStrm, XclPTDataFieldInfo& rInfo )
809 {
810 rInfo.mnField = rStrm.ReaduInt16();
811 rInfo.mnAggFunc = rStrm.ReaduInt16();
812 rInfo.mnRefType = rStrm.ReaduInt16();
813 rInfo.mnRefField = rStrm.ReaduInt16();
814 rInfo.mnRefItem = rStrm.ReaduInt16();
815 rInfo.mnNumFmt = rStrm.ReaduInt16();
816 rStrm >> rInfo.maVisName;
817 return rStrm;
818 }
819
820 XclExpStream& operator<<( XclExpStream& rStrm, const XclPTDataFieldInfo& rInfo )
821 {
822 return rStrm
823 << rInfo.mnField
824 << rInfo.mnAggFunc
825 << rInfo.mnRefType
826 << rInfo.mnRefField
827 << rInfo.mnRefItem
828 << rInfo.mnNumFmt
829 << rInfo.maVisName;
830 }
831
832 // Pivot table settings =======================================================
833
834 XclPTInfo::XclPTInfo() :
835 mnFirstHeadRow( 0 ),
836 mnCacheIdx( 0xFFFF ),
837 mnDataAxis( EXC_SXVD_AXIS_NONE ),
838 mnDataPos( EXC_SXVIEW_DATALAST ),
839 mnFields( 0 ),
840 mnRowFields( 0 ),
841 mnColFields( 0 ),
842 mnPageFields( 0 ),
843 mnDataFields( 0 ),
844 mnDataRows( 0 ),
845 mnDataCols( 0 ),
846 mnFlags( EXC_SXVIEW_DEFAULTFLAGS ),
847 mnAutoFmtIdx( EXC_SXVIEW_AUTOFMT )
848 {
849 }
850
851 XclImpStream& operator>>( XclImpStream& rStrm, XclPTInfo& rInfo )
852 {
853 sal_uInt16 nTabLen, nDataLen;
854
855 rStrm >> rInfo.maOutXclRange;
856 rInfo.mnFirstHeadRow = rStrm.ReaduInt16();
857 rStrm >> rInfo.maDataXclPos;
858 rInfo.mnCacheIdx = rStrm.ReaduInt16();
859 rStrm.Ignore( 2 );
860 rInfo.mnDataAxis = rStrm.ReaduInt16();
861 rInfo.mnDataPos = rStrm.ReaduInt16();
862 rInfo.mnFields = rStrm.ReaduInt16();
863 rInfo.mnRowFields = rStrm.ReaduInt16();
864 rInfo.mnColFields = rStrm.ReaduInt16();
865 rInfo.mnPageFields = rStrm.ReaduInt16();
866 rInfo.mnDataFields = rStrm.ReaduInt16();
867 rInfo.mnDataRows = rStrm.ReaduInt16();
868 rInfo.mnDataCols = rStrm.ReaduInt16();
869 rInfo.mnFlags = rStrm.ReaduInt16();
870 rInfo.mnAutoFmtIdx = rStrm.ReaduInt16();
871 nTabLen = rStrm.ReaduInt16();
872 nDataLen = rStrm.ReaduInt16();
873 rInfo.maTableName = rStrm.ReadUniString( nTabLen );
874 rInfo.maDataName = rStrm.ReadUniString( nDataLen );
875 return rStrm;
876 }
877
878 XclExpStream& operator<<( XclExpStream& rStrm, const XclPTInfo& rInfo )
879 {
880 XclExpString aXclTableName( rInfo.maTableName );
881 XclExpString aXclDataName( rInfo.maDataName );
882
883 rStrm << rInfo.maOutXclRange
884 << rInfo.mnFirstHeadRow
885 << rInfo.maDataXclPos
886 << rInfo.mnCacheIdx
887 << sal_uInt16( 0 )
888 << rInfo.mnDataAxis << rInfo.mnDataPos
889 << rInfo.mnFields
890 << rInfo.mnRowFields << rInfo.mnColFields
891 << rInfo.mnPageFields << rInfo.mnDataFields
892 << rInfo.mnDataRows << rInfo.mnDataCols
893 << rInfo.mnFlags
894 << rInfo.mnAutoFmtIdx
895 << aXclTableName.Len() << aXclDataName.Len();
896 aXclTableName.WriteFlagField( rStrm );
897 aXclTableName.WriteBuffer( rStrm );
898 aXclDataName.WriteFlagField( rStrm );
899 aXclDataName.WriteBuffer( rStrm );
900 return rStrm;
901 }
902
903 // Extended pivot table settings ==============================================
904
905 XclPTExtInfo::XclPTExtInfo() :
906 mnSxformulaRecs( 0 ),
907 mnSxselectRecs( 0 ),
908 mnPagePerRow( 0 ),
909 mnPagePerCol( 0 ),
910 mnFlags( EXC_SXEX_DEFAULTFLAGS )
911 {
912 }
913
914 XclImpStream& operator>>( XclImpStream& rStrm, XclPTExtInfo& rInfo )
915 {
916 rInfo.mnSxformulaRecs = rStrm.ReaduInt16();
917 rStrm.Ignore( 6 );
918 rInfo.mnSxselectRecs = rStrm.ReaduInt16();
919 rInfo.mnPagePerRow = rStrm.ReaduInt16();
920 rInfo.mnPagePerCol = rStrm.ReaduInt16();
921 rInfo.mnFlags = rStrm.ReaduInt32();
922 return rStrm;
923 }
924
925 XclExpStream& operator<<( XclExpStream& rStrm, const XclPTExtInfo& rInfo )
926 {
927 return rStrm
928 << rInfo.mnSxformulaRecs
929 << EXC_PT_NOSTRING // length of alt. error text
930 << EXC_PT_NOSTRING // length of alt. empty text
931 << EXC_PT_NOSTRING // length of tag
932 << rInfo.mnSxselectRecs
933 << rInfo.mnPagePerRow
934 << rInfo.mnPagePerCol
935 << rInfo.mnFlags
936 << EXC_PT_NOSTRING // length of page field style name
937 << EXC_PT_NOSTRING // length of table style name
938 << EXC_PT_NOSTRING; // length of vacate style name
939 }
940
941 // Pivot table autoformat settings ============================================
942
943 /**
944 classic : 10 08 00 00 00 00 00 00 20 00 00 00 01 00 00 00 00
945 default : 10 08 00 00 00 00 00 00 20 00 00 00 01 00 00 00 00
946 report01 : 10 08 02 00 00 00 00 00 20 00 00 00 00 10 00 00 00
947 report02 : 10 08 02 00 00 00 00 00 20 00 00 00 01 10 00 00 00
948 report03 : 10 08 02 00 00 00 00 00 20 00 00 00 02 10 00 00 00
949 report04 : 10 08 02 00 00 00 00 00 20 00 00 00 03 10 00 00 00
950 report05 : 10 08 02 00 00 00 00 00 20 00 00 00 04 10 00 00 00
951 report06 : 10 08 02 00 00 00 00 00 20 00 00 00 05 10 00 00 00
952 report07 : 10 08 02 00 00 00 00 00 20 00 00 00 06 10 00 00 00
953 report08 : 10 08 02 00 00 00 00 00 20 00 00 00 07 10 00 00 00
954 report09 : 10 08 02 00 00 00 00 00 20 00 00 00 08 10 00 00 00
955 report10 : 10 08 02 00 00 00 00 00 20 00 00 00 09 10 00 00 00
956 table01 : 10 08 00 00 00 00 00 00 20 00 00 00 0a 10 00 00 00
957 table02 : 10 08 00 00 00 00 00 00 20 00 00 00 0b 10 00 00 00
958 table03 : 10 08 00 00 00 00 00 00 20 00 00 00 0c 10 00 00 00
959 table04 : 10 08 00 00 00 00 00 00 20 00 00 00 0d 10 00 00 00
960 table05 : 10 08 00 00 00 00 00 00 20 00 00 00 0e 10 00 00 00
961 table06 : 10 08 00 00 00 00 00 00 20 00 00 00 0f 10 00 00 00
962 table07 : 10 08 00 00 00 00 00 00 20 00 00 00 10 10 00 00 00
963 table08 : 10 08 00 00 00 00 00 00 20 00 00 00 11 10 00 00 00
964 table09 : 10 08 00 00 00 00 00 00 20 00 00 00 12 10 00 00 00
965 table10 : 10 08 00 00 00 00 00 00 20 00 00 00 13 10 00 00 00
966 none : 10 08 00 00 00 00 00 00 20 00 00 00 15 10 00 00 00
967 **/
968
969 XclPTViewEx9Info::XclPTViewEx9Info() :
970 mbReport( 0 ),
971 mnAutoFormat( 0 ),
972 mnGridLayout( 0x10 )
973 {
974 }
975
976 void XclPTViewEx9Info::Init( const ScDPObject& rDPObj )
977 {
978 if( rDPObj.GetHeaderLayout() )
979 {
980 mbReport = 0;
981 mnAutoFormat = 1;
982 mnGridLayout = 0;
983 }
984 else
985 {
986 // Report1 for now
987 // TODO : sync with autoformat indices
988 mbReport = 2;
989 mnAutoFormat = 1;
990 mnGridLayout = 0x10;
991 }
992
993 const ScDPSaveData* pData = rDPObj.GetSaveData();
994 if (pData)
995 {
996 const std::optional<OUString> & pGrandTotal = pData->GetGrandTotalName();
997 if (pGrandTotal)
998 maGrandTotalName = *pGrandTotal;
999 }
1000 }
1001
1002 XclImpStream& operator>>( XclImpStream& rStrm, XclPTViewEx9Info& rInfo )
1003 {
1004 rStrm.Ignore( 2 );
1005 rInfo.mbReport = rStrm.ReaduInt32(); /// 2 for report* fmts ?
1006 rStrm.Ignore( 6 );
1007 rInfo.mnAutoFormat = rStrm.ReaduInt8();
1008 rInfo.mnGridLayout = rStrm.ReaduInt8();
1009 rInfo.maGrandTotalName = rStrm.ReadUniString();
1010 return rStrm;
1011 }
1012
1013 XclExpStream& operator<<( XclExpStream& rStrm, const XclPTViewEx9Info& rInfo )
1014 {
1015 return rStrm
1016 << EXC_PT_AUTOFMT_HEADER
1017 << rInfo.mbReport
1018 << EXC_PT_AUTOFMT_ZERO
1019 << EXC_PT_AUTOFMT_FLAGS
1020 << rInfo.mnAutoFormat
1021 << rInfo.mnGridLayout
1022 << XclExpString(rInfo.maGrandTotalName, XclStrFlags::NONE, EXC_PT_MAXSTRLEN);
1023 }
1024
1025 XclPTAddl::XclPTAddl() :
1026 mbCompactMode(false)
1027 {
1028 }
1029
1030 XclImpStream& operator>>(XclImpStream& rStrm, XclPTAddl& rInfo)
1031 {
1032 rStrm.Ignore(4);
1033 sal_uInt8 sxc = rStrm.ReaduInt8();
1034 sal_uInt8 sxd = rStrm.ReaduInt8();
1035 if(sxc == 0x00 && sxd == 0x19) // SxcView / sxdVer12Info
1036 {
1037 sal_uInt32 nFlags = rStrm.ReaduInt32();
1038 rInfo.mbCompactMode = ((nFlags & 0x00000008) != 0);
1039 }
1040 return rStrm;
1041 }
1042
1043 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE