?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 5.2.6.1, tag libreoffice-5.2.6.1
[LibreOffice.git] / sc / source / filter / excel / xechart.cxx
blob6e98086408b7ec4e1e0c02d16f2b9e98a5eb94df
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 "xechart.hxx"
21
22 #include <com/sun/star/i18n/XBreakIterator.hpp>
23 #include <com/sun/star/i18n/ScriptType.hpp>
24 #include <com/sun/star/drawing/FillStyle.hpp>
25 #include <com/sun/star/drawing/XShapes.hpp>
26 #include <com/sun/star/chart/XChartDocument.hpp>
27 #include <com/sun/star/chart/ChartAxisLabelPosition.hpp>
28 #include <com/sun/star/chart/ChartAxisPosition.hpp>
29 #include <com/sun/star/chart/ChartLegendExpansion.hpp>
30 #include <com/sun/star/chart/DataLabelPlacement.hpp>
31 #include <com/sun/star/chart/ErrorBarStyle.hpp>
32 #include <com/sun/star/chart/MissingValueTreatment.hpp>
33 #include <com/sun/star/chart/TimeInterval.hpp>
34 #include <com/sun/star/chart/TimeUnit.hpp>
35 #include <com/sun/star/chart/XAxisSupplier.hpp>
36 #include <com/sun/star/chart/XDiagramPositioning.hpp>
37 #include <com/sun/star/chart2/XChartDocument.hpp>
38 #include <com/sun/star/chart2/XDiagram.hpp>
39 #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
40 #include <com/sun/star/chart2/XChartTypeContainer.hpp>
41 #include <com/sun/star/chart2/XDataSeriesContainer.hpp>
42 #include <com/sun/star/chart2/XRegressionCurveContainer.hpp>
43 #include <com/sun/star/chart2/XTitled.hpp>
44 #include <com/sun/star/chart2/XColorScheme.hpp>
45 #include <com/sun/star/chart2/data/XDataSource.hpp>
46 #include <com/sun/star/chart2/AxisType.hpp>
47 #include <com/sun/star/chart2/CurveStyle.hpp>
48 #include <com/sun/star/chart2/DataPointGeometry3D.hpp>
49 #include <com/sun/star/chart2/DataPointLabel.hpp>
50 #include <com/sun/star/chart2/LegendPosition.hpp>
51 #include <com/sun/star/chart2/RelativePosition.hpp>
52 #include <com/sun/star/chart2/RelativeSize.hpp>
53 #include <com/sun/star/chart2/StackingDirection.hpp>
54 #include <com/sun/star/chart2/TickmarkStyle.hpp>
55
56 #include <o3tl/make_unique.hxx>
57
58 #include <tools/gen.hxx>
59 #include <vcl/outdev.hxx>
60 #include <filter/msfilter/escherex.hxx>
61
62 #include "document.hxx"
63 #include "rangelst.hxx"
64 #include "rangeutl.hxx"
65 #include "compiler.hxx"
66 #include "tokenarray.hxx"
67 #include "token.hxx"
68 #include "xeescher.hxx"
69 #include "xeformula.hxx"
70 #include "xehelper.hxx"
71 #include "xepage.hxx"
72 #include "xestyle.hxx"
73
74 #include <memory>
75
76 using ::com::sun::star::uno::Any;
77 using ::com::sun::star::uno::Reference;
78 using ::com::sun::star::uno::Sequence;
79 using ::com::sun::star::uno::UNO_QUERY;
80 using ::com::sun::star::uno::UNO_QUERY_THROW;
81 using ::com::sun::star::uno::UNO_SET_THROW;
82 using ::com::sun::star::uno::Exception;
83 using ::com::sun::star::beans::XPropertySet;
84 using ::com::sun::star::i18n::XBreakIterator;
85 using ::com::sun::star::frame::XModel;
86 using ::com::sun::star::drawing::XShape;
87 using ::com::sun::star::drawing::XShapes;
88
89 using ::com::sun::star::chart2::IncrementData;
90 using ::com::sun::star::chart2::RelativePosition;
91 using ::com::sun::star::chart2::RelativeSize;
92 using ::com::sun::star::chart2::ScaleData;
93 using ::com::sun::star::chart2::SubIncrement;
94 using ::com::sun::star::chart2::XAxis;
95 using ::com::sun::star::chart2::XChartDocument;
96 using ::com::sun::star::chart2::XChartTypeContainer;
97 using ::com::sun::star::chart2::XColorScheme;
98 using ::com::sun::star::chart2::XCoordinateSystem;
99 using ::com::sun::star::chart2::XCoordinateSystemContainer;
100 using ::com::sun::star::chart2::XChartType;
101 using ::com::sun::star::chart2::XDataSeries;
102 using ::com::sun::star::chart2::XDataSeriesContainer;
103 using ::com::sun::star::chart2::XDiagram;
104 using ::com::sun::star::chart2::XFormattedString;
105 using ::com::sun::star::chart2::XLegend;
106 using ::com::sun::star::chart2::XRegressionCurve;
107 using ::com::sun::star::chart2::XRegressionCurveContainer;
108 using ::com::sun::star::chart2::XTitle;
109 using ::com::sun::star::chart2::XTitled;
110
111 using ::com::sun::star::chart2::data::XDataSequence;
112 using ::com::sun::star::chart2::data::XDataSource;
113 using ::com::sun::star::chart2::data::XLabeledDataSequence;
114
115 using ::formula::FormulaToken;
116
117 namespace cssc = ::com::sun::star::chart;
118 namespace cssc2 = ::com::sun::star::chart2;
119
120 // Helpers ====================================================================
121
122 namespace {
123
124 XclExpStream& operator<<( XclExpStream& rStrm, const XclChRectangle& rRect )
125 {
126 return rStrm << rRect.mnX << rRect.mnY << rRect.mnWidth << rRect.mnHeight;
127 }
128
129 inline void lclSaveRecord( XclExpStream& rStrm, XclExpRecordRef xRec )
130 {
131 if( xRec )
132 xRec->Save( rStrm );
133 }
134
135 /** Saves the passed record (group) together with a leading value record. */
136 template< typename Type >
137 void lclSaveRecord( XclExpStream& rStrm, XclExpRecordRef xRec, sal_uInt16 nRecId, Type nValue )
138 {
139 if( xRec )
140 {
141 XclExpValueRecord< Type >( nRecId, nValue ).Save( rStrm );
142 xRec->Save( rStrm );
143 }
144 }
145
146 template<typename ValueType, typename KeyType>
147 void lclSaveRecord(XclExpStream& rStrm, ValueType* pRec, sal_uInt16 nRecId, KeyType nValue)
148 {
149 if (pRec)
150 {
151 XclExpValueRecord<KeyType>(nRecId, nValue).Save(rStrm);
152 pRec->Save(rStrm);
153 }
154 }
155
156 void lclWriteChFrBlockRecord( XclExpStream& rStrm, const XclChFrBlock& rFrBlock, bool bBegin )
157 {
158 sal_uInt16 nRecId = bBegin ? EXC_ID_CHFRBLOCKBEGIN : EXC_ID_CHFRBLOCKEND;
159 rStrm.StartRecord( nRecId, 12 );
160 rStrm << nRecId << EXC_FUTUREREC_EMPTYFLAGS << rFrBlock.mnType << rFrBlock.mnContext << rFrBlock.mnValue1 << rFrBlock.mnValue2;
161 rStrm.EndRecord();
162 }
163
164 template< typename Type >
165 inline bool lclIsAutoAnyOrGetValue( Type& rValue, const Any& rAny )
166 {
167 return !rAny.hasValue() || !(rAny >>= rValue);
168 }
169
170 bool lclIsAutoAnyOrGetScaledValue( double& rfValue, const Any& rAny, bool bLogScale )
171 {
172 bool bIsAuto = lclIsAutoAnyOrGetValue( rfValue, rAny );
173 if( !bIsAuto && bLogScale )
174 rfValue = log( rfValue ) / log( 10.0 );
175 return bIsAuto;
176 }
177
178 sal_uInt16 lclGetTimeValue( const XclExpRoot& rRoot, double fSerialDate, sal_uInt16 nTimeUnit )
179 {
180 DateTime aDateTime = rRoot.GetDateTimeFromDouble( fSerialDate );
181 switch( nTimeUnit )
182 {
183 case EXC_CHDATERANGE_DAYS:
184 return ::limit_cast< sal_uInt16, double >( fSerialDate, 0, SAL_MAX_UINT16 );
185 case EXC_CHDATERANGE_MONTHS:
186 return ::limit_cast< sal_uInt16, sal_uInt16 >( 12 * (aDateTime.GetYear() - rRoot.GetBaseYear()) + aDateTime.GetMonth() - 1, 0, SAL_MAX_INT16 );
187 case EXC_CHDATERANGE_YEARS:
188 return ::limit_cast< sal_uInt16, sal_uInt16 >( aDateTime.GetYear() - rRoot.GetBaseYear(), 0, SAL_MAX_INT16 );
189 default:
190 OSL_ENSURE( false, "lclGetTimeValue - unexpected time unit" );
191 }
192 return ::limit_cast< sal_uInt16, double >( fSerialDate, 0, SAL_MAX_UINT16 );
193 }
194
195 bool lclConvertTimeValue( const XclExpRoot& rRoot, sal_uInt16& rnValue, const Any& rAny, sal_uInt16 nTimeUnit )
196 {
197 double fSerialDate = 0;
198 bool bAuto = lclIsAutoAnyOrGetValue( fSerialDate, rAny );
199 if( !bAuto )
200 rnValue = lclGetTimeValue( rRoot, fSerialDate, nTimeUnit );
201 return bAuto;
202 }
203
204 sal_uInt16 lclGetTimeUnit( sal_Int32 nApiTimeUnit )
205 {
206 switch( nApiTimeUnit )
207 {
208 case cssc::TimeUnit::DAY: return EXC_CHDATERANGE_DAYS;
209 case cssc::TimeUnit::MONTH: return EXC_CHDATERANGE_MONTHS;
210 case cssc::TimeUnit::YEAR: return EXC_CHDATERANGE_YEARS;
211 default: OSL_ENSURE( false, "lclGetTimeUnit - unexpected time unit" );
212 }
213 return EXC_CHDATERANGE_DAYS;
214 }
215
216 bool lclConvertTimeInterval( sal_uInt16& rnValue, sal_uInt16& rnTimeUnit, const Any& rAny )
217 {
218 cssc::TimeInterval aInterval;
219 bool bAuto = lclIsAutoAnyOrGetValue( aInterval, rAny );
220 if( !bAuto )
221 {
222 rnValue = ::limit_cast< sal_uInt16, sal_Int32 >( aInterval.Number, 1, SAL_MAX_UINT16 );
223 rnTimeUnit = lclGetTimeUnit( aInterval.TimeUnit );
224 }
225 return bAuto;
226 }
227
228 } // namespace
229
230 // Common =====================================================================
231
232 /** Stores global data needed in various classes of the Chart export filter. */
233 struct XclExpChRootData : public XclChRootData
234 {
235 typedef ::std::vector< XclChFrBlock > XclChFrBlockVector;
236
237 XclExpChChart& mrChartData; /// The chart data object.
238 XclChFrBlockVector maWrittenFrBlocks; /// Stack of future record levels already written out.
239 XclChFrBlockVector maUnwrittenFrBlocks; /// Stack of future record levels not yet written out.
240
241 inline explicit XclExpChRootData( XclExpChChart& rChartData ) : mrChartData( rChartData ) {}
242
243 /** Registers a new future record level. */
244 void RegisterFutureRecBlock( const XclChFrBlock& rFrBlock );
245 /** Initializes the current future record level (writes all unwritten CHFRBLOCKBEGIN records). */
246 void InitializeFutureRecBlock( XclExpStream& rStrm );
247 /** Finalizes the current future record level (writes CHFRBLOCKEND record if needed). */
248 void FinalizeFutureRecBlock( XclExpStream& rStrm );
249 };
250
251 void XclExpChRootData::RegisterFutureRecBlock( const XclChFrBlock& rFrBlock )
252 {
253 maUnwrittenFrBlocks.push_back( rFrBlock );
254 }
255
256 void XclExpChRootData::InitializeFutureRecBlock( XclExpStream& rStrm )
257 {
258 // first call from a future record writes all missing CHFRBLOCKBEGIN records
259 if( !maUnwrittenFrBlocks.empty() )
260 {
261 // write the leading CHFRINFO record
262 if( maWrittenFrBlocks.empty() )
263 {
264 rStrm.StartRecord( EXC_ID_CHFRINFO, 20 );
265 rStrm << EXC_ID_CHFRINFO << EXC_FUTUREREC_EMPTYFLAGS << EXC_CHFRINFO_EXCELXP2003 << EXC_CHFRINFO_EXCELXP2003 << sal_uInt16( 3 );
266 rStrm << sal_uInt16( 0x0850 ) << sal_uInt16( 0x085A ) << sal_uInt16( 0x0861 ) << sal_uInt16( 0x0861 ) << sal_uInt16( 0x086A ) << sal_uInt16( 0x086B );
267 rStrm.EndRecord();
268 }
269 // write all unwritten CHFRBLOCKBEGIN records
270 for( XclChFrBlockVector::const_iterator aIt = maUnwrittenFrBlocks.begin(), aEnd = maUnwrittenFrBlocks.end(); aIt != aEnd; ++aIt )
271 {
272 OSL_ENSURE( aIt->mnType != EXC_CHFRBLOCK_TYPE_UNKNOWN, "XclExpChRootData::InitializeFutureRecBlock - unknown future record block type" );
273 lclWriteChFrBlockRecord( rStrm, *aIt, true );
274 }
275 // move all record infos to vector of written blocks
276 maWrittenFrBlocks.insert( maWrittenFrBlocks.end(), maUnwrittenFrBlocks.begin(), maUnwrittenFrBlocks.end() );
277 maUnwrittenFrBlocks.clear();
278 }
279 }
280
281 void XclExpChRootData::FinalizeFutureRecBlock( XclExpStream& rStrm )
282 {
283 OSL_ENSURE( !maUnwrittenFrBlocks.empty() || !maWrittenFrBlocks.empty(), "XclExpChRootData::FinalizeFutureRecBlock - no future record level found" );
284 if( !maUnwrittenFrBlocks.empty() )
285 {
286 // no future record has been written, just forget the topmost level
287 maUnwrittenFrBlocks.pop_back();
288 }
289 else if( !maWrittenFrBlocks.empty() )
290 {
291 // write the CHFRBLOCKEND record for the topmost block and delete it
292 lclWriteChFrBlockRecord( rStrm, maWrittenFrBlocks.back(), false );
293 maWrittenFrBlocks.pop_back();
294 }
295 }
296
297 XclExpChRoot::XclExpChRoot( const XclExpRoot& rRoot, XclExpChChart& rChartData ) :
298 XclExpRoot( rRoot ),
299 mxChData( new XclExpChRootData( rChartData ) )
300 {
301 }
302
303 XclExpChRoot::~XclExpChRoot()
304 {
305 }
306
307 Reference< XChartDocument > XclExpChRoot::GetChartDocument() const
308 {
309 return mxChData->mxChartDoc;
310 }
311
312 XclExpChChart& XclExpChRoot::GetChartData() const
313 {
314 return mxChData->mrChartData;
315 }
316
317 const XclChTypeInfo& XclExpChRoot::GetChartTypeInfo( XclChTypeId eType ) const
318 {
319 return mxChData->mxTypeInfoProv->GetTypeInfo( eType );
320 }
321
322 const XclChTypeInfo& XclExpChRoot::GetChartTypeInfo( const OUString& rServiceName ) const
323 {
324 return mxChData->mxTypeInfoProv->GetTypeInfoFromService( rServiceName );
325 }
326
327 const XclChFormatInfo& XclExpChRoot::GetFormatInfo( XclChObjectType eObjType ) const
328 {
329 return mxChData->mxFmtInfoProv->GetFormatInfo( eObjType );
330 }
331
332 void XclExpChRoot::InitConversion( css::uno::Reference< css::chart2::XChartDocument > xChartDoc, const Rectangle& rChartRect ) const
333 {
334 mxChData->InitConversion( GetRoot(), xChartDoc, rChartRect );
335 }
336
337 void XclExpChRoot::FinishConversion() const
338 {
339 mxChData->FinishConversion();
340 }
341
342 bool XclExpChRoot::IsSystemColor( const Color& rColor, sal_uInt16 nSysColorIdx ) const
343 {
344 XclExpPalette& rPal = GetPalette();
345 return rPal.IsSystemColor( nSysColorIdx ) && (rColor == rPal.GetDefColor( nSysColorIdx ));
346 }
347
348 void XclExpChRoot::SetSystemColor( Color& rColor, sal_uInt32& rnColorId, sal_uInt16 nSysColorIdx ) const
349 {
350 OSL_ENSURE( GetPalette().IsSystemColor( nSysColorIdx ), "XclExpChRoot::SetSystemColor - invalid color index" );
351 rColor = GetPalette().GetDefColor( nSysColorIdx );
352 rnColorId = XclExpPalette::GetColorIdFromIndex( nSysColorIdx );
353 }
354
355 sal_Int32 XclExpChRoot::CalcChartXFromHmm( sal_Int32 nPosX ) const
356 {
357 return ::limit_cast< sal_Int32, double >( (nPosX - mxChData->mnBorderGapX) / mxChData->mfUnitSizeX, 0, EXC_CHART_TOTALUNITS );
358 }
359
360 sal_Int32 XclExpChRoot::CalcChartYFromHmm( sal_Int32 nPosY ) const
361 {
362 return ::limit_cast< sal_Int32, double >( (nPosY - mxChData->mnBorderGapY) / mxChData->mfUnitSizeY, 0, EXC_CHART_TOTALUNITS );
363 }
364
365 XclChRectangle XclExpChRoot::CalcChartRectFromHmm( const css::awt::Rectangle& rRect ) const
366 {
367 XclChRectangle aRect;
368 aRect.mnX = CalcChartXFromHmm( rRect.X );
369 aRect.mnY = CalcChartYFromHmm( rRect.Y );
370 aRect.mnWidth = CalcChartXFromHmm( rRect.Width );
371 aRect.mnHeight = CalcChartYFromHmm( rRect.Height );
372 return aRect;
373 }
374
375 void XclExpChRoot::ConvertLineFormat( XclChLineFormat& rLineFmt,
376 const ScfPropertySet& rPropSet, XclChPropertyMode ePropMode ) const
377 {
378 GetChartPropSetHelper().ReadLineProperties(
379 rLineFmt, *mxChData->mxLineDashTable, rPropSet, ePropMode );
380 }
381
382 bool XclExpChRoot::ConvertAreaFormat( XclChAreaFormat& rAreaFmt,
383 const ScfPropertySet& rPropSet, XclChPropertyMode ePropMode ) const
384 {
385 return GetChartPropSetHelper().ReadAreaProperties( rAreaFmt, rPropSet, ePropMode );
386 }
387
388 void XclExpChRoot::ConvertEscherFormat(
389 XclChEscherFormat& rEscherFmt, XclChPicFormat& rPicFmt,
390 const ScfPropertySet& rPropSet, XclChPropertyMode ePropMode ) const
391 {
392 GetChartPropSetHelper().ReadEscherProperties( rEscherFmt, rPicFmt,
393 *mxChData->mxGradientTable, *mxChData->mxHatchTable, *mxChData->mxBitmapTable, rPropSet, ePropMode );
394 }
395
396 sal_uInt16 XclExpChRoot::ConvertFont( const ScfPropertySet& rPropSet, sal_Int16 nScript ) const
397 {
398 XclFontData aFontData;
399 GetFontPropSetHelper().ReadFontProperties( aFontData, rPropSet, EXC_FONTPROPSET_CHART, nScript );
400 return GetFontBuffer().Insert( aFontData, EXC_COLOR_CHARTTEXT );
401 }
402
403 sal_uInt16 XclExpChRoot::ConvertPieRotation( const ScfPropertySet& rPropSet )
404 {
405 sal_Int32 nApiRot = 0;
406 rPropSet.GetProperty( nApiRot, EXC_CHPROP_STARTINGANGLE );
407 return static_cast< sal_uInt16 >( (450 - (nApiRot % 360)) % 360 );
408 }
409
410 void XclExpChRoot::RegisterFutureRecBlock( const XclChFrBlock& rFrBlock )
411 {
412 mxChData->RegisterFutureRecBlock( rFrBlock );
413 }
414
415 void XclExpChRoot::InitializeFutureRecBlock( XclExpStream& rStrm )
416 {
417 mxChData->InitializeFutureRecBlock( rStrm );
418 }
419
420 void XclExpChRoot::FinalizeFutureRecBlock( XclExpStream& rStrm )
421 {
422 mxChData->FinalizeFutureRecBlock( rStrm );
423 }
424
425 XclExpChGroupBase::XclExpChGroupBase( const XclExpChRoot& rRoot,
426 sal_uInt16 nFrType, sal_uInt16 nRecId, sal_Size nRecSize ) :
427 XclExpRecord( nRecId, nRecSize ),
428 XclExpChRoot( rRoot ),
429 maFrBlock( nFrType )
430 {
431 }
432
433 XclExpChGroupBase::~XclExpChGroupBase()
434 {
435 }
436
437 void XclExpChGroupBase::Save( XclExpStream& rStrm )
438 {
439 // header record
440 XclExpRecord::Save( rStrm );
441 // group records
442 if( HasSubRecords() )
443 {
444 // register the future record context corresponding to this record group
445 RegisterFutureRecBlock( maFrBlock );
446 // CHBEGIN record
447 XclExpEmptyRecord( EXC_ID_CHBEGIN ).Save( rStrm );
448 // embedded records
449 WriteSubRecords( rStrm );
450 // finalize the future records, must be done before the closing CHEND
451 FinalizeFutureRecBlock( rStrm );
452 // CHEND record
453 XclExpEmptyRecord( EXC_ID_CHEND ).Save( rStrm );
454 }
455 }
456
457 bool XclExpChGroupBase::HasSubRecords() const
458 {
459 return true;
460 }
461
462 void XclExpChGroupBase::SetFutureRecordContext( sal_uInt16 nFrContext, sal_uInt16 nFrValue1, sal_uInt16 nFrValue2 )
463 {
464 maFrBlock.mnContext = nFrContext;
465 maFrBlock.mnValue1 = nFrValue1;
466 maFrBlock.mnValue2 = nFrValue2;
467 }
468
469 XclExpChFutureRecordBase::XclExpChFutureRecordBase( const XclExpChRoot& rRoot,
470 XclFutureRecType eRecType, sal_uInt16 nRecId, sal_Size nRecSize ) :
471 XclExpFutureRecord( eRecType, nRecId, nRecSize ),
472 XclExpChRoot( rRoot )
473 {
474 }
475
476 void XclExpChFutureRecordBase::Save( XclExpStream& rStrm )
477 {
478 InitializeFutureRecBlock( rStrm );
479 XclExpFutureRecord::Save( rStrm );
480 }
481
482 // Frame formatting ===========================================================
483
484 XclExpChFramePos::XclExpChFramePos( sal_uInt16 nTLMode, sal_uInt16 nBRMode ) :
485 XclExpRecord( EXC_ID_CHFRAMEPOS, 20 )
486 {
487 maData.mnTLMode = nTLMode;
488 maData.mnBRMode = nBRMode;
489 }
490
491 void XclExpChFramePos::WriteBody( XclExpStream& rStrm )
492 {
493 rStrm << maData.mnTLMode << maData.mnBRMode << maData.maRect;
494 }
495
496 XclExpChLineFormat::XclExpChLineFormat( const XclExpChRoot& rRoot ) :
497 XclExpRecord( EXC_ID_CHLINEFORMAT, (rRoot.GetBiff() == EXC_BIFF8) ? 12 : 10 ),
498 mnColorId( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWTEXT ) )
499 {
500 }
501
502 void XclExpChLineFormat::SetDefault( XclChFrameType eDefFrameType )
503 {
504 switch( eDefFrameType )
505 {
506 case EXC_CHFRAMETYPE_AUTO:
507 SetAuto( true );
508 break;
509 case EXC_CHFRAMETYPE_INVISIBLE:
510 SetAuto( false );
511 maData.mnPattern = EXC_CHLINEFORMAT_NONE;
512 break;
513 default:
514 OSL_FAIL( "XclExpChLineFormat::SetDefault - unknown frame type" );
515 }
516 }
517
518 void XclExpChLineFormat::Convert( const XclExpChRoot& rRoot,
519 const ScfPropertySet& rPropSet, XclChObjectType eObjType )
520 {
521 const XclChFormatInfo& rFmtInfo = rRoot.GetFormatInfo( eObjType );
522 rRoot.ConvertLineFormat( maData, rPropSet, rFmtInfo.mePropMode );
523 if( HasLine() )
524 {
525 // detect system color, set color identifier (TODO: detect automatic series line)
526 if( (eObjType != EXC_CHOBJTYPE_LINEARSERIES) && rRoot.IsSystemColor( maData.maColor, rFmtInfo.mnAutoLineColorIdx ) )
527 {
528 // store color index from automatic format data
529 mnColorId = XclExpPalette::GetColorIdFromIndex( rFmtInfo.mnAutoLineColorIdx );
530 // try to set automatic mode
531 bool bAuto = (maData.mnPattern == EXC_CHLINEFORMAT_SOLID) && (maData.mnWeight == rFmtInfo.mnAutoLineWeight);
532 ::set_flag( maData.mnFlags, EXC_CHLINEFORMAT_AUTO, bAuto );
533 }
534 else
535 {
536 // user defined color - register in palette
537 mnColorId = rRoot.GetPalette().InsertColor( maData.maColor, EXC_COLOR_CHARTLINE );
538 }
539 }
540 else
541 {
542 // no line - set default system color
543 rRoot.SetSystemColor( maData.maColor, mnColorId, EXC_COLOR_CHWINDOWTEXT );
544 }
545 }
546
547 bool XclExpChLineFormat::IsDefault( XclChFrameType eDefFrameType ) const
548 {
549 return
550 ((eDefFrameType == EXC_CHFRAMETYPE_INVISIBLE) && !HasLine()) ||
551 ((eDefFrameType == EXC_CHFRAMETYPE_AUTO) && IsAuto());
552 }
553
554 void XclExpChLineFormat::WriteBody( XclExpStream& rStrm )
555 {
556 rStrm << maData.maColor << maData.mnPattern << maData.mnWeight << maData.mnFlags;
557 if( rStrm.GetRoot().GetBiff() == EXC_BIFF8 )
558 rStrm << rStrm.GetRoot().GetPalette().GetColorIndex( mnColorId );
559 }
560
561 namespace {
562
563 /** Creates a CHLINEFORMAT record from the passed property set. */
564 XclExpChLineFormatRef lclCreateLineFormat( const XclExpChRoot& rRoot,
565 const ScfPropertySet& rPropSet, XclChObjectType eObjType )
566 {
567 XclExpChLineFormatRef xLineFmt( new XclExpChLineFormat( rRoot ) );
568 xLineFmt->Convert( rRoot, rPropSet, eObjType );
569 const XclChFormatInfo& rFmtInfo = rRoot.GetFormatInfo( eObjType );
570 if( rFmtInfo.mbDeleteDefFrame && xLineFmt->IsDefault( rFmtInfo.meDefFrameType ) )
571 xLineFmt.reset();
572 return xLineFmt;
573 }
574
575 } // namespace
576
577 XclExpChAreaFormat::XclExpChAreaFormat( const XclExpChRoot& rRoot ) :
578 XclExpRecord( EXC_ID_CHAREAFORMAT, (rRoot.GetBiff() == EXC_BIFF8) ? 16 : 12 ),
579 mnPattColorId( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWBACK ) ),
580 mnBackColorId( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWTEXT ) )
581 {
582 }
583
584 bool XclExpChAreaFormat::Convert( const XclExpChRoot& rRoot,
585 const ScfPropertySet& rPropSet, XclChObjectType eObjType )
586 {
587 const XclChFormatInfo& rFmtInfo = rRoot.GetFormatInfo( eObjType );
588 bool bComplexFill = rRoot.ConvertAreaFormat( maData, rPropSet, rFmtInfo.mePropMode );
589 if( HasArea() )
590 {
591 bool bSolid = maData.mnPattern == EXC_PATT_SOLID;
592 // detect system color, set color identifier (TODO: detect automatic series area)
593 if( (eObjType != EXC_CHOBJTYPE_FILLEDSERIES) && rRoot.IsSystemColor( maData.maPattColor, rFmtInfo.mnAutoPattColorIdx ) )
594 {
595 // store color index from automatic format data
596 mnPattColorId = XclExpPalette::GetColorIdFromIndex( rFmtInfo.mnAutoPattColorIdx );
597 // set automatic mode
598 ::set_flag( maData.mnFlags, EXC_CHAREAFORMAT_AUTO, bSolid );
599 }
600 else
601 {
602 // user defined color - register color in palette
603 mnPattColorId = rRoot.GetPalette().InsertColor( maData.maPattColor, EXC_COLOR_CHARTAREA );
604 }
605 // background color (default system color for solid fills)
606 if( bSolid )
607 rRoot.SetSystemColor( maData.maBackColor, mnBackColorId, EXC_COLOR_CHWINDOWTEXT );
608 else
609 mnBackColorId = rRoot.GetPalette().InsertColor( maData.maBackColor, EXC_COLOR_CHARTAREA );
610 }
611 else
612 {
613 // no area - set default system colors
614 rRoot.SetSystemColor( maData.maPattColor, mnPattColorId, EXC_COLOR_CHWINDOWBACK );
615 rRoot.SetSystemColor( maData.maBackColor, mnBackColorId, EXC_COLOR_CHWINDOWTEXT );
616 }
617 return bComplexFill;
618 }
619
620 void XclExpChAreaFormat::SetDefault( XclChFrameType eDefFrameType )
621 {
622 switch( eDefFrameType )
623 {
624 case EXC_CHFRAMETYPE_AUTO:
625 SetAuto( true );
626 break;
627 case EXC_CHFRAMETYPE_INVISIBLE:
628 SetAuto( false );
629 maData.mnPattern = EXC_PATT_NONE;
630 break;
631 default:
632 OSL_FAIL( "XclExpChAreaFormat::SetDefault - unknown frame type" );
633 }
634 }
635
636 bool XclExpChAreaFormat::IsDefault( XclChFrameType eDefFrameType ) const
637 {
638 return
639 ((eDefFrameType == EXC_CHFRAMETYPE_INVISIBLE) && !HasArea()) ||
640 ((eDefFrameType == EXC_CHFRAMETYPE_AUTO) && IsAuto());
641 }
642
643 void XclExpChAreaFormat::WriteBody( XclExpStream& rStrm )
644 {
645 rStrm << maData.maPattColor << maData.maBackColor << maData.mnPattern << maData.mnFlags;
646 if( rStrm.GetRoot().GetBiff() == EXC_BIFF8 )
647 {
648 const XclExpPalette& rPal = rStrm.GetRoot().GetPalette();
649 rStrm << rPal.GetColorIndex( mnPattColorId ) << rPal.GetColorIndex( mnBackColorId );
650 }
651 }
652
653 XclExpChEscherFormat::XclExpChEscherFormat( const XclExpChRoot& rRoot ) :
654 XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_UNKNOWN, EXC_ID_CHESCHERFORMAT ),
655 mnColor1Id( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWBACK ) ),
656 mnColor2Id( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWBACK ) )
657 {
658 OSL_ENSURE_BIFF( GetBiff() == EXC_BIFF8 );
659 }
660
661 void XclExpChEscherFormat::Convert( const ScfPropertySet& rPropSet, XclChObjectType eObjType )
662 {
663 const XclChFormatInfo& rFmtInfo = GetFormatInfo( eObjType );
664 ConvertEscherFormat( maData, maPicFmt, rPropSet, rFmtInfo.mePropMode );
665 // register colors in palette
666 mnColor1Id = RegisterColor( ESCHER_Prop_fillColor );
667 mnColor2Id = RegisterColor( ESCHER_Prop_fillBackColor );
668 }
669
670 bool XclExpChEscherFormat::IsValid() const
671 {
672 return static_cast< bool >(maData.mxEscherSet);
673 }
674
675 void XclExpChEscherFormat::Save( XclExpStream& rStrm )
676 {
677 if( maData.mxEscherSet )
678 {
679 // replace RGB colors with palette indexes in the Escher container
680 const XclExpPalette& rPal = GetPalette();
681 maData.mxEscherSet->AddOpt( ESCHER_Prop_fillColor, 0x08000000 | rPal.GetColorIndex( mnColor1Id ) );
682 maData.mxEscherSet->AddOpt( ESCHER_Prop_fillBackColor, 0x08000000 | rPal.GetColorIndex( mnColor2Id ) );
683
684 // save the record group
685 XclExpChGroupBase::Save( rStrm );
686 }
687 }
688
689 bool XclExpChEscherFormat::HasSubRecords() const
690 {
691 // no subrecords for gradients
692 return maPicFmt.mnBmpMode != EXC_CHPICFORMAT_NONE;
693 }
694
695 void XclExpChEscherFormat::WriteSubRecords( XclExpStream& rStrm )
696 {
697 rStrm.StartRecord( EXC_ID_CHPICFORMAT, 14 );
698 rStrm << maPicFmt.mnBmpMode << sal_uInt16( 0 ) << maPicFmt.mnFlags << maPicFmt.mfScale;
699 rStrm.EndRecord();
700 }
701
702 sal_uInt32 XclExpChEscherFormat::RegisterColor( sal_uInt16 nPropId )
703 {
704 sal_uInt32 nBGRValue;
705 if( maData.mxEscherSet && maData.mxEscherSet->GetOpt( nPropId, nBGRValue ) )
706 {
707 // swap red and blue
708 Color aColor( RGB_COLORDATA(
709 COLORDATA_BLUE( nBGRValue ),
710 COLORDATA_GREEN( nBGRValue ),
711 COLORDATA_RED( nBGRValue ) ) );
712 return GetPalette().InsertColor( aColor, EXC_COLOR_CHARTAREA );
713 }
714 return XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWBACK );
715 }
716
717 void XclExpChEscherFormat::WriteBody( XclExpStream& rStrm )
718 {
719 OSL_ENSURE( maData.mxEscherSet, "XclExpChEscherFormat::WriteBody - missing property container" );
720 // write Escher property container via temporary memory stream
721 SvMemoryStream aMemStrm;
722 maData.mxEscherSet->Commit( aMemStrm );
723 aMemStrm.Flush();
724 aMemStrm.Seek( STREAM_SEEK_TO_BEGIN );
725 rStrm.CopyFromStream( aMemStrm );
726 }
727
728 XclExpChFrameBase::XclExpChFrameBase()
729 {
730 }
731
732 XclExpChFrameBase::~XclExpChFrameBase()
733 {
734 }
735
736 void XclExpChFrameBase::ConvertFrameBase( const XclExpChRoot& rRoot,
737 const ScfPropertySet& rPropSet, XclChObjectType eObjType )
738 {
739 // line format
740 mxLineFmt.reset( new XclExpChLineFormat( rRoot ) );
741 mxLineFmt->Convert( rRoot, rPropSet, eObjType );
742 // area format (only for frame objects)
743 if( rRoot.GetFormatInfo( eObjType ).mbIsFrame )
744 {
745 mxAreaFmt.reset( new XclExpChAreaFormat( rRoot ) );
746 bool bComplexFill = mxAreaFmt->Convert( rRoot, rPropSet, eObjType );
747 if( (rRoot.GetBiff() == EXC_BIFF8) && bComplexFill )
748 {
749 mxEscherFmt.reset( new XclExpChEscherFormat( rRoot ) );
750 mxEscherFmt->Convert( rPropSet, eObjType );
751 if( mxEscherFmt->IsValid() )
752 mxAreaFmt->SetAuto( false );
753 else
754 mxEscherFmt.reset();
755 }
756 }
757 }
758
759 void XclExpChFrameBase::SetDefaultFrameBase( const XclExpChRoot& rRoot,
760 XclChFrameType eDefFrameType, bool bIsFrame )
761 {
762 // line format
763 mxLineFmt.reset( new XclExpChLineFormat( rRoot ) );
764 mxLineFmt->SetDefault( eDefFrameType );
765 // area format (only for frame objects)
766 if( bIsFrame )
767 {
768 mxAreaFmt.reset( new XclExpChAreaFormat( rRoot ) );
769 mxAreaFmt->SetDefault( eDefFrameType );
770 mxEscherFmt.reset();
771 }
772 }
773
774 bool XclExpChFrameBase::IsDefaultFrameBase( XclChFrameType eDefFrameType ) const
775 {
776 return
777 (!mxLineFmt || mxLineFmt->IsDefault( eDefFrameType )) &&
778 (!mxAreaFmt || mxAreaFmt->IsDefault( eDefFrameType ));
779 }
780
781 void XclExpChFrameBase::WriteFrameRecords( XclExpStream& rStrm )
782 {
783 lclSaveRecord( rStrm, mxLineFmt );
784 lclSaveRecord( rStrm, mxAreaFmt );
785 lclSaveRecord( rStrm, mxEscherFmt );
786 }
787
788 XclExpChFrame::XclExpChFrame( const XclExpChRoot& rRoot, XclChObjectType eObjType ) :
789 XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_FRAME, EXC_ID_CHFRAME, 4 ),
790 meObjType( eObjType )
791 {
792 }
793
794 void XclExpChFrame::Convert( const ScfPropertySet& rPropSet )
795 {
796 ConvertFrameBase( GetChRoot(), rPropSet, meObjType );
797 }
798
799 void XclExpChFrame::SetAutoFlags( bool bAutoPos, bool bAutoSize )
800 {
801 ::set_flag( maData.mnFlags, EXC_CHFRAME_AUTOPOS, bAutoPos );
802 ::set_flag( maData.mnFlags, EXC_CHFRAME_AUTOSIZE, bAutoSize );
803 }
804
805 bool XclExpChFrame::IsDefault() const
806 {
807 return IsDefaultFrameBase( GetFormatInfo( meObjType ).meDefFrameType );
808 }
809
810 bool XclExpChFrame::IsDeleteable() const
811 {
812 return IsDefault() && GetFormatInfo( meObjType ).mbDeleteDefFrame;
813 }
814
815 void XclExpChFrame::Save( XclExpStream& rStrm )
816 {
817 switch( meObjType )
818 {
819 // wall/floor frame without CHFRAME header record
820 case EXC_CHOBJTYPE_WALL3D:
821 case EXC_CHOBJTYPE_FLOOR3D:
822 WriteFrameRecords( rStrm );
823 break;
824 default:
825 XclExpChGroupBase::Save( rStrm );
826 }
827 }
828
829 void XclExpChFrame::WriteSubRecords( XclExpStream& rStrm )
830 {
831 WriteFrameRecords( rStrm );
832 }
833
834 void XclExpChFrame::WriteBody( XclExpStream& rStrm )
835 {
836 rStrm << maData.mnFormat << maData.mnFlags;
837 }
838
839 namespace {
840
841 /** Creates a CHFRAME record from the passed property set. */
842 XclExpChFrameRef lclCreateFrame( const XclExpChRoot& rRoot,
843 const ScfPropertySet& rPropSet, XclChObjectType eObjType )
844 {
845 XclExpChFrameRef xFrame( new XclExpChFrame( rRoot, eObjType ) );
846 xFrame->Convert( rPropSet );
847 if( xFrame->IsDeleteable() )
848 xFrame.reset();
849 return xFrame;
850 }
851
852 } // namespace
853
854 // Source links ===============================================================
855
856 namespace {
857
858 void lclAddDoubleRefData(
859 ScTokenArray& orArray, const FormulaToken& rToken,
860 SCsTAB nScTab1, SCsCOL nScCol1, SCsROW nScRow1,
861 SCsTAB nScTab2, SCsCOL nScCol2, SCsROW nScRow2 )
862 {
863 ScComplexRefData aComplexRef;
864 aComplexRef.InitRange(ScRange(nScCol1,nScRow1,nScTab1,nScCol2,nScRow2,nScTab2));
865 aComplexRef.Ref1.SetFlag3D( true );
866
867 if( orArray.GetLen() > 0 )
868 orArray.AddOpCode( ocUnion );
869
870 OSL_ENSURE( (rToken.GetType() == ::formula::svDoubleRef) || (rToken.GetType() == ::formula::svExternalDoubleRef),
871 "lclAddDoubleRefData - double reference token expected");
872 if( rToken.GetType() == ::formula::svExternalDoubleRef )
873 orArray.AddExternalDoubleReference(
874 rToken.GetIndex(), rToken.GetString().getString(), aComplexRef);
875 else
876 orArray.AddDoubleReference( aComplexRef );
877 }
878
879 } // namespace
880
881 XclExpChSourceLink::XclExpChSourceLink( const XclExpChRoot& rRoot, sal_uInt8 nDestType ) :
882 XclExpRecord( EXC_ID_CHSOURCELINK ),
883 XclExpChRoot( rRoot )
884 {
885 maData.mnDestType = nDestType;
886 maData.mnLinkType = EXC_CHSRCLINK_DIRECTLY;
887 }
888
889 sal_uInt16 XclExpChSourceLink::ConvertDataSequence( Reference< XDataSequence > xDataSeq, bool bSplitToColumns, sal_uInt16 nDefCount )
890 {
891 mxLinkFmla.reset();
892 maData.mnLinkType = EXC_CHSRCLINK_DEFAULT;
893
894 if( !xDataSeq.is() )
895 return nDefCount;
896
897 // Compile the range representation string into token array. Note that the
898 // source range text depends on the current grammar.
899 OUString aRangeRepr = xDataSeq->getSourceRangeRepresentation();
900 ScCompiler aComp( &GetDocRef(), ScAddress() );
901 aComp.SetGrammar( GetDocRef().GetGrammar() );
902 std::unique_ptr<ScTokenArray> pArray(aComp.CompileString(aRangeRepr));
903 if( !pArray )
904 return nDefCount;
905
906 ScTokenArray aArray;
907 sal_uInt32 nValueCount = 0;
908 pArray->Reset();
909 for( const FormulaToken* pToken = pArray->First(); pToken; pToken = pArray->Next() )
910 {
911 switch( pToken->GetType() )
912 {
913 case ::formula::svSingleRef:
914 case ::formula::svExternalSingleRef:
915 // for a single ref token, just add it to the new token array as is
916 if( aArray.GetLen() > 0 )
917 aArray.AddOpCode( ocUnion );
918 aArray.AddToken( *pToken );
919 ++nValueCount;
920 break;
921
922 case ::formula::svDoubleRef:
923 case ::formula::svExternalDoubleRef:
924 {
925 // split 3-dimensional ranges into single sheets
926 const ScComplexRefData& rComplexRef = *pToken->GetDoubleRef();
927 ScAddress aAbs1 = rComplexRef.Ref1.toAbs(ScAddress());
928 ScAddress aAbs2 = rComplexRef.Ref2.toAbs(ScAddress());
929 for (SCsTAB nScTab = aAbs1.Tab(); nScTab <= aAbs2.Tab(); ++nScTab)
930 {
931 // split 2-dimensional ranges into single columns
932 if (bSplitToColumns && (aAbs1.Col() < aAbs2.Col()) && (aAbs1.Row() < aAbs2.Row()))
933 for (SCCOL nScCol = aAbs1.Col(); nScCol <= aAbs2.Col(); ++nScCol)
934 lclAddDoubleRefData(aArray, *pToken, nScTab, nScCol, aAbs1.Row(), nScTab, nScCol, aAbs2.Row());
935 else
936 lclAddDoubleRefData(aArray, *pToken, nScTab, aAbs1.Col(), aAbs1.Row(), nScTab, aAbs2.Col(), aAbs2.Row());
937 }
938 sal_uInt32 nTabs = static_cast<sal_uInt32>(aAbs2.Tab() - aAbs1.Tab() + 1);
939 sal_uInt32 nCols = static_cast<sal_uInt32>(aAbs2.Col() - aAbs1.Col() + 1);
940 sal_uInt32 nRows = static_cast<sal_uInt32>(aAbs2.Row() - aAbs1.Row() + 1);
941 nValueCount += nCols * nRows * nTabs;
942 }
943 break;
944
945 default:;
946 }
947 }
948
949 const ScAddress aBaseCell;
950 mxLinkFmla = GetFormulaCompiler().CreateFormula( EXC_FMLATYPE_CHART, aArray, &aBaseCell );
951 maData.mnLinkType = EXC_CHSRCLINK_WORKSHEET;
952 return ulimit_cast< sal_uInt16 >( nValueCount, EXC_CHDATAFORMAT_MAXPOINTCOUNT );
953 }
954
955 void XclExpChSourceLink::ConvertString( const OUString& aString )
956 {
957 mxString = XclExpStringHelper::CreateString( GetRoot(), aString, EXC_STR_FORCEUNICODE | EXC_STR_8BITLENGTH | EXC_STR_SEPARATEFORMATS );
958 }
959
960 sal_uInt16 XclExpChSourceLink::ConvertStringSequence( const Sequence< Reference< XFormattedString > >& rStringSeq )
961 {
962 mxString.reset();
963 sal_uInt16 nFontIdx = EXC_FONT_APP;
964 if( rStringSeq.hasElements() )
965 {
966 mxString = XclExpStringHelper::CreateString( GetRoot(), OUString(), EXC_STR_FORCEUNICODE | EXC_STR_8BITLENGTH | EXC_STR_SEPARATEFORMATS );
967 Reference< XBreakIterator > xBreakIt = GetDoc().GetBreakIterator();
968 namespace ApiScriptType = ::com::sun::star::i18n::ScriptType;
969
970 // convert all formatted string entries from the sequence
971 const Reference< XFormattedString >* pBeg = rStringSeq.getConstArray();
972 const Reference< XFormattedString >* pEnd = pBeg + rStringSeq.getLength();
973 for( const Reference< XFormattedString >* pIt = pBeg; pIt != pEnd; ++pIt )
974 {
975 if( pIt->is() )
976 {
977 sal_uInt16 nWstrnFontIdx = EXC_FONT_NOTFOUND;
978 sal_uInt16 nAsianFontIdx = EXC_FONT_NOTFOUND;
979 sal_uInt16 nCmplxFontIdx = EXC_FONT_NOTFOUND;
980 OUString aText = (*pIt)->getString();
981 ScfPropertySet aStrProp( *pIt );
982
983 // #i63255# get script type for leading weak characters
984 sal_Int16 nLastScript = XclExpStringHelper::GetLeadingScriptType( GetRoot(), aText );
985
986 // process all script portions
987 sal_Int32 nPortionPos = 0;
988 sal_Int32 nTextLen = aText.getLength();
989 while( nPortionPos < nTextLen )
990 {
991 // get script type and end position of next script portion
992 sal_Int16 nScript = xBreakIt->getScriptType( aText, nPortionPos );
993 sal_Int32 nPortionEnd = xBreakIt->endOfScript( aText, nPortionPos, nScript );
994
995 // reuse previous script for following weak portions
996 if( nScript == ApiScriptType::WEAK )
997 nScript = nLastScript;
998
999 // Excel start position of this portion
1000 sal_uInt16 nXclPortionStart = mxString->Len();
1001 // add portion text to Excel string
1002 XclExpStringHelper::AppendString( *mxString, GetRoot(), aText.copy( nPortionPos, nPortionEnd - nPortionPos ) );
1003 if( nXclPortionStart < mxString->Len() )
1004 {
1005 // find font index variable dependent on script type
1006 sal_uInt16& rnFontIdx = (nScript == ApiScriptType::COMPLEX) ? nCmplxFontIdx :
1007 ((nScript == ApiScriptType::ASIAN) ? nAsianFontIdx : nWstrnFontIdx);
1008
1009 // insert font into buffer (if not yet done)
1010 if( rnFontIdx == EXC_FONT_NOTFOUND )
1011 rnFontIdx = ConvertFont( aStrProp, nScript );
1012
1013 // insert font index into format run vector
1014 mxString->AppendFormat( nXclPortionStart, rnFontIdx );
1015 }
1016
1017 // go to next script portion
1018 nLastScript = nScript;
1019 nPortionPos = nPortionEnd;
1020 }
1021 }
1022 }
1023 if( !mxString->IsEmpty() )
1024 {
1025 // get leading font index
1026 const XclFormatRunVec& rFormats = mxString->GetFormats();
1027 OSL_ENSURE( !rFormats.empty() && (rFormats.front().mnChar == 0),
1028 "XclExpChSourceLink::ConvertStringSequenc - missing leading format" );
1029 // remove leading format run, if entire string is equally formatted
1030 if( rFormats.size() == 1 )
1031 nFontIdx = mxString->RemoveLeadingFont();
1032 else if( !rFormats.empty() )
1033 nFontIdx = rFormats.front().mnFontIdx;
1034 // add trailing format run, if string is rich-formatted
1035 if( mxString->IsRich() )
1036 mxString->AppendTrailingFormat( EXC_FONT_APP );
1037 }
1038 }
1039 return nFontIdx;
1040 }
1041
1042 void XclExpChSourceLink::ConvertNumFmt( const ScfPropertySet& rPropSet, bool bPercent )
1043 {
1044 sal_Int32 nApiNumFmt = 0;
1045 if( bPercent ? rPropSet.GetProperty( nApiNumFmt, EXC_CHPROP_PERCENTAGENUMFMT ) : rPropSet.GetProperty( nApiNumFmt, EXC_CHPROP_NUMBERFORMAT ) )
1046 {
1047 ::set_flag( maData.mnFlags, EXC_CHSRCLINK_NUMFMT );
1048 maData.mnNumFmtIdx = GetNumFmtBuffer().Insert( static_cast< sal_uInt32 >( nApiNumFmt ) );
1049 }
1050 }
1051
1052 void XclExpChSourceLink::AppendString( const OUString& rStr )
1053 {
1054 if (!mxString)
1055 return;
1056 XclExpStringHelper::AppendString( *mxString, GetRoot(), rStr );
1057 }
1058
1059 void XclExpChSourceLink::Save( XclExpStream& rStrm )
1060 {
1061 // CHFORMATRUNS record
1062 if( mxString && mxString->IsRich() )
1063 {
1064 sal_Size nRecSize = (1 + mxString->GetFormatsCount()) * ((GetBiff() == EXC_BIFF8) ? 2 : 1);
1065 rStrm.StartRecord( EXC_ID_CHFORMATRUNS, nRecSize );
1066 mxString->WriteFormats( rStrm, true );
1067 rStrm.EndRecord();
1068 }
1069 // CHSOURCELINK record
1070 XclExpRecord::Save( rStrm );
1071 // CHSTRING record
1072 if( mxString && !mxString->IsEmpty() )
1073 {
1074 rStrm.StartRecord( EXC_ID_CHSTRING, 2 + mxString->GetSize() );
1075 rStrm << sal_uInt16( 0 ) << *mxString;
1076 rStrm.EndRecord();
1077 }
1078 }
1079
1080 void XclExpChSourceLink::WriteBody( XclExpStream& rStrm )
1081 {
1082 rStrm << maData.mnDestType
1083 << maData.mnLinkType
1084 << maData.mnFlags
1085 << maData.mnNumFmtIdx
1086 << mxLinkFmla;
1087 }
1088
1089 // Text =======================================================================
1090
1091 XclExpChFont::XclExpChFont( sal_uInt16 nFontIdx ) :
1092 XclExpUInt16Record( EXC_ID_CHFONT, nFontIdx )
1093 {
1094 }
1095
1096 XclExpChObjectLink::XclExpChObjectLink( sal_uInt16 nLinkTarget, const XclChDataPointPos& rPointPos ) :
1097 XclExpRecord( EXC_ID_CHOBJECTLINK, 6 )
1098 {
1099 maData.mnTarget = nLinkTarget;
1100 maData.maPointPos = rPointPos;
1101 }
1102
1103 void XclExpChObjectLink::WriteBody( XclExpStream& rStrm )
1104 {
1105 rStrm << maData.mnTarget << maData.maPointPos.mnSeriesIdx << maData.maPointPos.mnPointIdx;
1106 }
1107
1108 XclExpChFrLabelProps::XclExpChFrLabelProps( const XclExpChRoot& rRoot ) :
1109 XclExpChFutureRecordBase( rRoot, EXC_FUTUREREC_UNUSEDREF, EXC_ID_CHFRLABELPROPS, 4 )
1110 {
1111 }
1112
1113 void XclExpChFrLabelProps::Convert( const ScfPropertySet& rPropSet,
1114 bool bShowCateg, bool bShowValue, bool bShowPercent, bool bShowBubble )
1115 {
1116 // label value flags
1117 ::set_flag( maData.mnFlags, EXC_CHFRLABELPROPS_SHOWSERIES, false );
1118 ::set_flag( maData.mnFlags, EXC_CHFRLABELPROPS_SHOWCATEG, bShowCateg );
1119 ::set_flag( maData.mnFlags, EXC_CHFRLABELPROPS_SHOWVALUE, bShowValue );
1120 ::set_flag( maData.mnFlags, EXC_CHFRLABELPROPS_SHOWPERCENT, bShowPercent );
1121 ::set_flag( maData.mnFlags, EXC_CHFRLABELPROPS_SHOWBUBBLE, bShowBubble );
1122
1123 // label value separator
1124 maData.maSeparator = rPropSet.GetStringProperty( EXC_CHPROP_LABELSEPARATOR );
1125 if( maData.maSeparator.isEmpty() )
1126 maData.maSeparator = " ";
1127 }
1128
1129 void XclExpChFrLabelProps::WriteBody( XclExpStream& rStrm )
1130 {
1131 XclExpString aXclSep( maData.maSeparator, EXC_STR_FORCEUNICODE | EXC_STR_SMARTFLAGS );
1132 rStrm << maData.mnFlags << aXclSep;
1133 }
1134
1135 XclExpChFontBase::~XclExpChFontBase()
1136 {
1137 }
1138
1139 void XclExpChFontBase::ConvertFontBase( const XclExpChRoot& rRoot, sal_uInt16 nFontIdx )
1140 {
1141 if( const XclExpFont* pFont = rRoot.GetFontBuffer().GetFont( nFontIdx ) )
1142 {
1143 XclExpChFontRef xFont( new XclExpChFont( nFontIdx ) );
1144 SetFont( xFont, pFont->GetFontData().maColor, pFont->GetFontColorId() );
1145 }
1146 }
1147
1148 void XclExpChFontBase::ConvertFontBase( const XclExpChRoot& rRoot, const ScfPropertySet& rPropSet )
1149 {
1150 ConvertFontBase( rRoot, rRoot.ConvertFont( rPropSet, rRoot.GetDefApiScript() ) );
1151 }
1152
1153 void XclExpChFontBase::ConvertRotationBase(const ScfPropertySet& rPropSet, bool bSupportsStacked )
1154 {
1155 sal_uInt16 nRotation = XclChPropSetHelper::ReadRotationProperties( rPropSet, bSupportsStacked );
1156 SetRotation( nRotation );
1157 }
1158
1159 XclExpChText::XclExpChText( const XclExpChRoot& rRoot ) :
1160 XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_TEXT, EXC_ID_CHTEXT, (rRoot.GetBiff() == EXC_BIFF8) ? 32 : 26 ),
1161 mnTextColorId( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWTEXT ) )
1162 {
1163 }
1164
1165 void XclExpChText::SetFont( XclExpChFontRef xFont, const Color& rColor, sal_uInt32 nColorId )
1166 {
1167 mxFont = xFont;
1168 maData.maTextColor = rColor;
1169 ::set_flag( maData.mnFlags, EXC_CHTEXT_AUTOCOLOR, rColor == COL_AUTO );
1170 mnTextColorId = nColorId;
1171 }
1172
1173 void XclExpChText::SetRotation( sal_uInt16 nRotation )
1174 {
1175 maData.mnRotation = nRotation;
1176 ::insert_value( maData.mnFlags, XclTools::GetXclOrientFromRot( nRotation ), 8, 3 );
1177 }
1178
1179 void XclExpChText::ConvertTitle( Reference< XTitle > xTitle, sal_uInt16 nTarget, const OUString* pSubTitle )
1180 {
1181 switch( nTarget )
1182 {
1183 case EXC_CHOBJLINK_TITLE: SetFutureRecordContext( EXC_CHFRBLOCK_TEXT_TITLE ); break;
1184 case EXC_CHOBJLINK_YAXIS: SetFutureRecordContext( EXC_CHFRBLOCK_TEXT_AXISTITLE, 1 ); break;
1185 case EXC_CHOBJLINK_XAXIS: SetFutureRecordContext( EXC_CHFRBLOCK_TEXT_AXISTITLE ); break;
1186 case EXC_CHOBJLINK_ZAXIS: SetFutureRecordContext( EXC_CHFRBLOCK_TEXT_AXISTITLE, 2 ); break;
1187 }
1188
1189 mxSrcLink.reset();
1190 mxObjLink.reset( new XclExpChObjectLink( nTarget, XclChDataPointPos( 0, 0 ) ) );
1191
1192 if( xTitle.is() )
1193 {
1194 // title frame formatting
1195 ScfPropertySet aTitleProp( xTitle );
1196 mxFrame = lclCreateFrame( GetChRoot(), aTitleProp, EXC_CHOBJTYPE_TEXT );
1197
1198 // string sequence
1199 mxSrcLink.reset( new XclExpChSourceLink( GetChRoot(), EXC_CHSRCLINK_TITLE ) );
1200 sal_uInt16 nFontIdx = mxSrcLink->ConvertStringSequence( xTitle->getText() );
1201 if (pSubTitle)
1202 {
1203 // append subtitle as the 2nd line of the title.
1204 OUString aSubTitle("\n");
1205 aSubTitle += *pSubTitle;
1206 mxSrcLink->AppendString(aSubTitle);
1207 }
1208
1209 ConvertFontBase( GetChRoot(), nFontIdx );
1210
1211 // rotation
1212 ConvertRotationBase( aTitleProp, true );
1213
1214 // manual text position - only for main title
1215 mxFramePos.reset( new XclExpChFramePos( EXC_CHFRAMEPOS_PARENT, EXC_CHFRAMEPOS_PARENT ) );
1216 if( nTarget == EXC_CHOBJLINK_TITLE )
1217 {
1218 Any aRelPos;
1219 if( aTitleProp.GetAnyProperty( aRelPos, EXC_CHPROP_RELATIVEPOSITION ) && aRelPos.has< RelativePosition >() ) try
1220 {
1221 // calculate absolute position for CHTEXT record
1222 Reference< cssc::XChartDocument > xChart1Doc( GetChartDocument(), UNO_QUERY_THROW );
1223 Reference< XShape > xTitleShape( xChart1Doc->getTitle(), UNO_SET_THROW );
1224 css::awt::Point aPos = xTitleShape->getPosition();
1225 css::awt::Size aSize = xTitleShape->getSize();
1226 css::awt::Rectangle aRect( aPos.X, aPos.Y, aSize.Width, aSize.Height );
1227 maData.maRect = CalcChartRectFromHmm( aRect );
1228 ::insert_value( maData.mnFlags2, EXC_CHTEXT_POS_MOVED, 0, 4 );
1229 // manual title position implies manual plot area
1230 GetChartData().SetManualPlotArea();
1231 // calculate the default title position in chart units
1232 sal_Int32 nDefPosX = ::std::max< sal_Int32 >( (EXC_CHART_TOTALUNITS - maData.maRect.mnWidth) / 2, 0 );
1233 sal_Int32 nDefPosY = 85;
1234 // set the position relative to the standard position
1235 XclChRectangle& rFrameRect = mxFramePos->GetFramePosData().maRect;
1236 rFrameRect.mnX = maData.maRect.mnX - nDefPosX;
1237 rFrameRect.mnY = maData.maRect.mnY - nDefPosY;
1238 }
1239 catch( Exception& )
1240 {
1241 }
1242 }
1243 }
1244 else
1245 {
1246 ::set_flag( maData.mnFlags, EXC_CHTEXT_DELETED );
1247 }
1248 }
1249
1250 void XclExpChText::ConvertLegend( const ScfPropertySet& rPropSet )
1251 {
1252 ::set_flag( maData.mnFlags, EXC_CHTEXT_AUTOTEXT );
1253 ::set_flag( maData.mnFlags, EXC_CHTEXT_AUTOGEN );
1254 ConvertFontBase( GetChRoot(), rPropSet );
1255 }
1256
1257 bool XclExpChText::ConvertDataLabel( const ScfPropertySet& rPropSet,
1258 const XclChTypeInfo& rTypeInfo, const XclChDataPointPos& rPointPos )
1259 {
1260 SetFutureRecordContext( EXC_CHFRBLOCK_TEXT_DATALABEL, rPointPos.mnPointIdx, rPointPos.mnSeriesIdx );
1261
1262 cssc2::DataPointLabel aPointLabel;
1263 if( !rPropSet.GetProperty( aPointLabel, EXC_CHPROP_LABEL ) )
1264 return false;
1265
1266 // percentage only allowed in pie and donut charts
1267 bool bIsPie = rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_PIE;
1268 // bubble sizes only allowed in bubble charts
1269 bool bIsBubble = rTypeInfo.meTypeId == EXC_CHTYPEID_BUBBLES;
1270 OSL_ENSURE( (GetBiff() == EXC_BIFF8) || !bIsBubble, "XclExpChText::ConvertDataLabel - bubble charts only in BIFF8" );
1271
1272 // raw show flags
1273 bool bShowValue = !bIsBubble && aPointLabel.ShowNumber; // Chart2 uses 'ShowNumber' for bubble size
1274 bool bShowPercent = bIsPie && aPointLabel.ShowNumberInPercent; // percentage only in pie/donut charts
1275 bool bShowCateg = aPointLabel.ShowCategoryName;
1276 bool bShowBubble = bIsBubble && aPointLabel.ShowNumber; // Chart2 uses 'ShowNumber' for bubble size
1277 bool bShowAny = bShowValue || bShowPercent || bShowCateg || bShowBubble;
1278
1279 // create the CHFRLABELPROPS record for extended settings in BIFF8
1280 if( bShowAny && (GetBiff() == EXC_BIFF8) )
1281 {
1282 mxLabelProps.reset( new XclExpChFrLabelProps( GetChRoot() ) );
1283 mxLabelProps->Convert( rPropSet, bShowCateg, bShowValue, bShowPercent, bShowBubble );
1284 }
1285
1286 // restrict to combinations allowed in CHTEXT
1287 if( bShowPercent ) bShowValue = false; // percent wins over value
1288 if( bShowValue ) bShowCateg = false; // value wins over category
1289 if( bShowValue || bShowCateg ) bShowBubble = false; // value or category wins over bubble size
1290
1291 // set all flags
1292 ::set_flag( maData.mnFlags, EXC_CHTEXT_AUTOTEXT );
1293 ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWVALUE, bShowValue );
1294 ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWPERCENT, bShowPercent );
1295 ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWCATEG, bShowCateg );
1296 ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWCATEGPERC, bShowPercent && bShowCateg );
1297 ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWBUBBLE, bShowBubble );
1298 ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWSYMBOL, bShowAny && aPointLabel.ShowLegendSymbol );
1299 ::set_flag( maData.mnFlags, EXC_CHTEXT_DELETED, !bShowAny );
1300
1301 if( bShowAny )
1302 {
1303 // font settings
1304 ConvertFontBase( GetChRoot(), rPropSet );
1305 ConvertRotationBase( rPropSet, false );
1306 // label placement
1307 sal_Int32 nPlacement = 0;
1308 sal_uInt16 nLabelPos = EXC_CHTEXT_POS_AUTO;
1309 if( rPropSet.GetProperty( nPlacement, EXC_CHPROP_LABELPLACEMENT ) )
1310 {
1311 using namespace cssc::DataLabelPlacement;
1312 if( nPlacement == rTypeInfo.mnDefaultLabelPos )
1313 {
1314 nLabelPos = EXC_CHTEXT_POS_DEFAULT;
1315 }
1316 else switch( nPlacement )
1317 {
1318 case AVOID_OVERLAP: nLabelPos = EXC_CHTEXT_POS_AUTO; break;
1319 case CENTER: nLabelPos = EXC_CHTEXT_POS_CENTER; break;
1320 case TOP: nLabelPos = EXC_CHTEXT_POS_ABOVE; break;
1321 case TOP_LEFT: nLabelPos = EXC_CHTEXT_POS_LEFT; break;
1322 case LEFT: nLabelPos = EXC_CHTEXT_POS_LEFT; break;
1323 case BOTTOM_LEFT: nLabelPos = EXC_CHTEXT_POS_LEFT; break;
1324 case BOTTOM: nLabelPos = EXC_CHTEXT_POS_BELOW; break;
1325 case BOTTOM_RIGHT: nLabelPos = EXC_CHTEXT_POS_RIGHT; break;
1326 case RIGHT: nLabelPos = EXC_CHTEXT_POS_RIGHT; break;
1327 case TOP_RIGHT: nLabelPos = EXC_CHTEXT_POS_RIGHT; break;
1328 case INSIDE: nLabelPos = EXC_CHTEXT_POS_INSIDE; break;
1329 case OUTSIDE: nLabelPos = EXC_CHTEXT_POS_OUTSIDE; break;
1330 case NEAR_ORIGIN: nLabelPos = EXC_CHTEXT_POS_AXIS; break;
1331 default: OSL_FAIL( "XclExpChText::ConvertDataLabel - unknown label placement type" );
1332 }
1333 }
1334 ::insert_value( maData.mnFlags2, nLabelPos, 0, 4 );
1335 // source link (contains number format)
1336 mxSrcLink.reset( new XclExpChSourceLink( GetChRoot(), EXC_CHSRCLINK_TITLE ) );
1337 if( bShowValue || bShowPercent )
1338 // percentage format wins over value format
1339 mxSrcLink->ConvertNumFmt( rPropSet, bShowPercent );
1340 // object link
1341 mxObjLink.reset( new XclExpChObjectLink( EXC_CHOBJLINK_DATA, rPointPos ) );
1342 }
1343
1344 /* Return true to indicate valid label settings:
1345 - for existing labels at entire series
1346 - for any settings at single data point (to be able to delete a point label) */
1347 return bShowAny || (rPointPos.mnPointIdx != EXC_CHDATAFORMAT_ALLPOINTS);
1348 }
1349
1350 void XclExpChText::ConvertTrendLineEquation( const ScfPropertySet& rPropSet, const XclChDataPointPos& rPointPos )
1351 {
1352 // required flags
1353 ::set_flag( maData.mnFlags, EXC_CHTEXT_AUTOTEXT );
1354 if( GetBiff() == EXC_BIFF8 )
1355 ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWCATEG ); // must set this to make equation visible in Excel
1356 // frame formatting
1357 mxFrame = lclCreateFrame( GetChRoot(), rPropSet, EXC_CHOBJTYPE_TEXT );
1358 // font settings
1359 maData.mnHAlign = EXC_CHTEXT_ALIGN_TOPLEFT;
1360 maData.mnVAlign = EXC_CHTEXT_ALIGN_TOPLEFT;
1361 ConvertFontBase( GetChRoot(), rPropSet );
1362 // source link (contains number format)
1363 mxSrcLink.reset( new XclExpChSourceLink( GetChRoot(), EXC_CHSRCLINK_TITLE ) );
1364 mxSrcLink->ConvertNumFmt( rPropSet, false );
1365 // object link
1366 mxObjLink.reset( new XclExpChObjectLink( EXC_CHOBJLINK_DATA, rPointPos ) );
1367 }
1368
1369 sal_uInt16 XclExpChText::GetAttLabelFlags() const
1370 {
1371 sal_uInt16 nFlags = 0;
1372 ::set_flag( nFlags, EXC_CHATTLABEL_SHOWVALUE, ::get_flag( maData.mnFlags, EXC_CHTEXT_SHOWVALUE ) );
1373 ::set_flag( nFlags, EXC_CHATTLABEL_SHOWPERCENT, ::get_flag( maData.mnFlags, EXC_CHTEXT_SHOWPERCENT ) );
1374 ::set_flag( nFlags, EXC_CHATTLABEL_SHOWCATEGPERC, ::get_flag( maData.mnFlags, EXC_CHTEXT_SHOWCATEGPERC ) );
1375 ::set_flag( nFlags, EXC_CHATTLABEL_SHOWCATEG, ::get_flag( maData.mnFlags, EXC_CHTEXT_SHOWCATEG ) );
1376 return nFlags;
1377 }
1378
1379 void XclExpChText::WriteSubRecords( XclExpStream& rStrm )
1380 {
1381 // CHFRAMEPOS record
1382 lclSaveRecord( rStrm, mxFramePos );
1383 // CHFONT record
1384 lclSaveRecord( rStrm, mxFont );
1385 // CHSOURCELINK group
1386 lclSaveRecord( rStrm, mxSrcLink );
1387 // CHFRAME group
1388 lclSaveRecord( rStrm, mxFrame );
1389 // CHOBJECTLINK record
1390 lclSaveRecord( rStrm, mxObjLink );
1391 // CHFRLABELPROPS record
1392 lclSaveRecord( rStrm, mxLabelProps );
1393 }
1394
1395 void XclExpChText::WriteBody( XclExpStream& rStrm )
1396 {
1397 rStrm << maData.mnHAlign
1398 << maData.mnVAlign
1399 << maData.mnBackMode
1400 << maData.maTextColor
1401 << maData.maRect
1402 << maData.mnFlags;
1403
1404 if( GetBiff() == EXC_BIFF8 )
1405 {
1406 rStrm << GetPalette().GetColorIndex( mnTextColorId )
1407 << maData.mnFlags2
1408 << maData.mnRotation;
1409 }
1410 }
1411
1412 namespace {
1413
1414 /** Creates and returns an Excel text object from the passed title. */
1415 XclExpChTextRef lclCreateTitle( const XclExpChRoot& rRoot, Reference< XTitled > xTitled, sal_uInt16 nTarget,
1416 const OUString* pSubTitle = nullptr )
1417 {
1418 Reference< XTitle > xTitle;
1419 if( xTitled.is() )
1420 xTitle = xTitled->getTitleObject();
1421
1422 XclExpChTextRef xText( new XclExpChText( rRoot ) );
1423 xText->ConvertTitle( xTitle, nTarget, pSubTitle );
1424 /* Do not delete the CHTEXT group for the main title. A missing CHTEXT
1425 will be interpreted as auto-generated title showing the series title in
1426 charts that contain exactly one data series. */
1427 if( (nTarget != EXC_CHOBJLINK_TITLE) && !xText->HasString() )
1428 xText.reset();
1429
1430 return xText;
1431 }
1432
1433 }
1434
1435 // Data series ================================================================
1436
1437 XclExpChMarkerFormat::XclExpChMarkerFormat( const XclExpChRoot& rRoot ) :
1438 XclExpRecord( EXC_ID_CHMARKERFORMAT, (rRoot.GetBiff() == EXC_BIFF8) ? 20 : 12 ),
1439 mnLineColorId( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWTEXT ) ),
1440 mnFillColorId( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWBACK ) )
1441 {
1442 }
1443
1444 void XclExpChMarkerFormat::Convert( const XclExpChRoot& rRoot,
1445 const ScfPropertySet& rPropSet, sal_uInt16 nFormatIdx )
1446 {
1447 XclChPropSetHelper::ReadMarkerProperties( maData, rPropSet, nFormatIdx );
1448 /* Set marker line/fill color to series line color.
1449 TODO: remove this if OOChart supports own colors in markers. */
1450 Color aLineColor;
1451 if( rPropSet.GetColorProperty( aLineColor, EXC_CHPROP_COLOR ) )
1452 maData.maLineColor = maData.maFillColor = aLineColor;
1453 // register colors in palette
1454 RegisterColors( rRoot );
1455 }
1456
1457 void XclExpChMarkerFormat::ConvertStockSymbol( const XclExpChRoot& rRoot,
1458 const ScfPropertySet& rPropSet, bool bCloseSymbol )
1459 {
1460 // clear the automatic flag
1461 ::set_flag( maData.mnFlags, EXC_CHMARKERFORMAT_AUTO, false );
1462 // symbol type and color
1463 if( bCloseSymbol )
1464 {
1465 // set symbol type for the 'close' data series
1466 maData.mnMarkerType = EXC_CHMARKERFORMAT_DOWJ;
1467 maData.mnMarkerSize = EXC_CHMARKERFORMAT_DOUBLESIZE;
1468 // set symbol line/fill color to series line color
1469 Color aLineColor;
1470 if( rPropSet.GetColorProperty( aLineColor, EXC_CHPROP_COLOR ) )
1471 {
1472 maData.maLineColor = maData.maFillColor = aLineColor;
1473 RegisterColors( rRoot );
1474 }
1475 }
1476 else
1477 {
1478 // set invisible symbol
1479 maData.mnMarkerType = EXC_CHMARKERFORMAT_NOSYMBOL;
1480 }
1481 }
1482
1483 void XclExpChMarkerFormat::RegisterColors( const XclExpChRoot& rRoot )
1484 {
1485 if( HasMarker() )
1486 {
1487 if( HasLineColor() )
1488 mnLineColorId = rRoot.GetPalette().InsertColor( maData.maLineColor, EXC_COLOR_CHARTLINE );
1489 if( HasFillColor() )
1490 mnFillColorId = rRoot.GetPalette().InsertColor( maData.maFillColor, EXC_COLOR_CHARTAREA );
1491 }
1492 }
1493
1494 void XclExpChMarkerFormat::WriteBody( XclExpStream& rStrm )
1495 {
1496 rStrm << maData.maLineColor << maData.maFillColor << maData.mnMarkerType << maData.mnFlags;
1497 if( rStrm.GetRoot().GetBiff() == EXC_BIFF8 )
1498 {
1499 const XclExpPalette& rPal = rStrm.GetRoot().GetPalette();
1500 rStrm << rPal.GetColorIndex( mnLineColorId ) << rPal.GetColorIndex( mnFillColorId ) << maData.mnMarkerSize;
1501 }
1502 }
1503
1504 XclExpChPieFormat::XclExpChPieFormat() :
1505 XclExpUInt16Record( EXC_ID_CHPIEFORMAT, 0 )
1506 {
1507 }
1508
1509 void XclExpChPieFormat::Convert( const ScfPropertySet& rPropSet )
1510 {
1511 double fApiDist(0.0);
1512 if( rPropSet.GetProperty( fApiDist, EXC_CHPROP_OFFSET ) )
1513 SetValue( limit_cast< sal_uInt16 >( fApiDist * 100.0, 0, 100 ) );
1514 }
1515
1516 XclExpCh3dDataFormat::XclExpCh3dDataFormat() :
1517 XclExpRecord( EXC_ID_CH3DDATAFORMAT, 2 )
1518 {
1519 }
1520
1521 void XclExpCh3dDataFormat::Convert( const ScfPropertySet& rPropSet )
1522 {
1523 sal_Int32 nApiType(0);
1524 if( rPropSet.GetProperty( nApiType, EXC_CHPROP_GEOMETRY3D ) )
1525 {
1526 using namespace cssc2::DataPointGeometry3D;
1527 switch( nApiType )
1528 {
1529 case CUBOID:
1530 maData.mnBase = EXC_CH3DDATAFORMAT_RECT;
1531 maData.mnTop = EXC_CH3DDATAFORMAT_STRAIGHT;
1532 break;
1533 case PYRAMID:
1534 maData.mnBase = EXC_CH3DDATAFORMAT_RECT;
1535 maData.mnTop = EXC_CH3DDATAFORMAT_SHARP;
1536 break;
1537 case CYLINDER:
1538 maData.mnBase = EXC_CH3DDATAFORMAT_CIRC;
1539 maData.mnTop = EXC_CH3DDATAFORMAT_STRAIGHT;
1540 break;
1541 case CONE:
1542 maData.mnBase = EXC_CH3DDATAFORMAT_CIRC;
1543 maData.mnTop = EXC_CH3DDATAFORMAT_SHARP;
1544 break;
1545 default:
1546 OSL_FAIL( "XclExpCh3dDataFormat::Convert - unknown 3D bar format" );
1547 }
1548 }
1549 }
1550
1551 void XclExpCh3dDataFormat::WriteBody( XclExpStream& rStrm )
1552 {
1553 rStrm << maData.mnBase << maData.mnTop;
1554 }
1555
1556 XclExpChAttachedLabel::XclExpChAttachedLabel( sal_uInt16 nFlags ) :
1557 XclExpUInt16Record( EXC_ID_CHATTACHEDLABEL, nFlags )
1558 {
1559 }
1560
1561 XclExpChDataFormat::XclExpChDataFormat( const XclExpChRoot& rRoot,
1562 const XclChDataPointPos& rPointPos, sal_uInt16 nFormatIdx ) :
1563 XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_DATAFORMAT, EXC_ID_CHDATAFORMAT, 8 )
1564 {
1565 maData.maPointPos = rPointPos;
1566 maData.mnFormatIdx = nFormatIdx;
1567 }
1568
1569 void XclExpChDataFormat::ConvertDataSeries( const ScfPropertySet& rPropSet, const XclChExtTypeInfo& rTypeInfo )
1570 {
1571 // line and area formatting
1572 ConvertFrameBase( GetChRoot(), rPropSet, rTypeInfo.GetSeriesObjectType() );
1573
1574 // data point symbols
1575 bool bIsFrame = rTypeInfo.IsSeriesFrameFormat();
1576 if( !bIsFrame )
1577 {
1578 mxMarkerFmt.reset( new XclExpChMarkerFormat( GetChRoot() ) );
1579 mxMarkerFmt->Convert( GetChRoot(), rPropSet, maData.mnFormatIdx );
1580 }
1581
1582 // pie segments
1583 if( rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_PIE )
1584 {
1585 mxPieFmt.reset( new XclExpChPieFormat );
1586 mxPieFmt->Convert( rPropSet );
1587 }
1588
1589 // 3D bars (only allowed for entire series in BIFF8)
1590 if( IsSeriesFormat() && (GetBiff() == EXC_BIFF8) && rTypeInfo.mb3dChart && (rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_BAR) )
1591 {
1592 mx3dDataFmt.reset( new XclExpCh3dDataFormat );
1593 mx3dDataFmt->Convert( rPropSet );
1594 }
1595
1596 // spline
1597 if( IsSeriesFormat() && rTypeInfo.mbSpline && !bIsFrame )
1598 mxSeriesFmt.reset( new XclExpUInt16Record( EXC_ID_CHSERIESFORMAT, EXC_CHSERIESFORMAT_SMOOTHED ) );
1599
1600 // data point labels
1601 XclExpChTextRef xLabel( new XclExpChText( GetChRoot() ) );
1602 if( xLabel->ConvertDataLabel( rPropSet, rTypeInfo, maData.maPointPos ) )
1603 {
1604 // CHTEXT groups for data labels are stored in global CHCHART group
1605 GetChartData().SetDataLabel( xLabel );
1606 mxAttLabel.reset( new XclExpChAttachedLabel( xLabel->GetAttLabelFlags() ) );
1607 }
1608 }
1609
1610 void XclExpChDataFormat::ConvertStockSeries( const ScfPropertySet& rPropSet, bool bCloseSymbol )
1611 {
1612 // set line format to invisible
1613 SetDefaultFrameBase( GetChRoot(), EXC_CHFRAMETYPE_INVISIBLE, false );
1614 // set symbols to invisible or to 'close' series symbol
1615 mxMarkerFmt.reset( new XclExpChMarkerFormat( GetChRoot() ) );
1616 mxMarkerFmt->ConvertStockSymbol( GetChRoot(), rPropSet, bCloseSymbol );
1617 }
1618
1619 void XclExpChDataFormat::ConvertLine( const ScfPropertySet& rPropSet, XclChObjectType eObjType )
1620 {
1621 ConvertFrameBase( GetChRoot(), rPropSet, eObjType );
1622 }
1623
1624 void XclExpChDataFormat::WriteSubRecords( XclExpStream& rStrm )
1625 {
1626 lclSaveRecord( rStrm, mx3dDataFmt );
1627 WriteFrameRecords( rStrm );
1628 lclSaveRecord( rStrm, mxPieFmt );
1629 lclSaveRecord( rStrm, mxMarkerFmt );
1630 lclSaveRecord( rStrm, mxSeriesFmt );
1631 lclSaveRecord( rStrm, mxAttLabel );
1632 }
1633
1634 void XclExpChDataFormat::WriteBody( XclExpStream& rStrm )
1635 {
1636 rStrm << maData.maPointPos.mnPointIdx
1637 << maData.maPointPos.mnSeriesIdx
1638 << maData.mnFormatIdx
1639 << maData.mnFlags;
1640 }
1641
1642 XclExpChSerTrendLine::XclExpChSerTrendLine( const XclExpChRoot& rRoot ) :
1643 XclExpRecord( EXC_ID_CHSERTRENDLINE, 28 ),
1644 XclExpChRoot( rRoot )
1645 {
1646 }
1647
1648 bool XclExpChSerTrendLine::Convert( Reference< XRegressionCurve > xRegCurve, sal_uInt16 nSeriesIdx )
1649 {
1650 if( !xRegCurve.is() )
1651 return false;
1652
1653 // trend line type
1654 ScfPropertySet aCurveProp( xRegCurve );
1655
1656 OUString aService = aCurveProp.GetServiceName();
1657 if( aService == "com.sun.star.chart2.LinearRegressionCurve" )
1658 {
1659 maData.mnLineType = EXC_CHSERTREND_POLYNOMIAL;
1660 maData.mnOrder = 1;
1661 }
1662 else if( aService == "com.sun.star.chart2.ExponentialRegressionCurve" )
1663 {
1664 maData.mnLineType = EXC_CHSERTREND_EXPONENTIAL;
1665 }
1666 else if( aService == "com.sun.star.chart2.LogarithmicRegressionCurve" )
1667 {
1668 maData.mnLineType = EXC_CHSERTREND_LOGARITHMIC;
1669 }
1670 else if( aService == "com.sun.star.chart2.PotentialRegressionCurve" )
1671 {
1672 maData.mnLineType = EXC_CHSERTREND_POWER;
1673 }
1674 else if( aService == "com.sun.star.chart2.PolynomialRegressionCurve" )
1675 {
1676 maData.mnLineType = EXC_CHSERTREND_POLYNOMIAL;
1677 sal_Int32 aDegree;
1678 aCurveProp.GetProperty(aDegree, EXC_CHPROP_POLYNOMIAL_DEGREE);
1679 maData.mnOrder = static_cast<sal_uInt8> (aDegree);
1680 }
1681 else if( aService == "com.sun.star.chart2.MovingAverageRegressionCurve" )
1682 {
1683 maData.mnLineType = EXC_CHSERTREND_MOVING_AVG;
1684 sal_Int32 aPeriod;
1685 aCurveProp.GetProperty(aPeriod, EXC_CHPROP_MOVING_AVERAGE_PERIOD);
1686 maData.mnOrder = static_cast<sal_uInt8> (aPeriod);
1687 }
1688 else
1689 {
1690 return false;
1691 }
1692
1693 aCurveProp.GetProperty(maData.mfForecastFor, EXC_CHPROP_EXTRAPOLATE_FORWARD);
1694 aCurveProp.GetProperty(maData.mfForecastBack, EXC_CHPROP_EXTRAPOLATE_BACKWARD);
1695 bool bIsForceIntercept = false;
1696 aCurveProp.GetProperty(bIsForceIntercept, EXC_CHPROP_FORCE_INTERCEPT);
1697 if (bIsForceIntercept)
1698 aCurveProp.GetProperty(maData.mfIntercept, EXC_CHPROP_INTERCEPT_VALUE);
1699
1700 // line formatting
1701 XclChDataPointPos aPointPos( nSeriesIdx );
1702 mxDataFmt.reset( new XclExpChDataFormat( GetChRoot(), aPointPos, 0 ) );
1703 mxDataFmt->ConvertLine( aCurveProp, EXC_CHOBJTYPE_TRENDLINE );
1704
1705 // #i83100# show equation and correlation coefficient
1706 ScfPropertySet aEquationProp( xRegCurve->getEquationProperties() );
1707 maData.mnShowEquation = aEquationProp.GetBoolProperty( EXC_CHPROP_SHOWEQUATION ) ? 1 : 0;
1708 maData.mnShowRSquared = aEquationProp.GetBoolProperty( EXC_CHPROP_SHOWCORRELATION ) ? 1 : 0;
1709
1710 // #i83100# formatting of the equation text box
1711 if( (maData.mnShowEquation != 0) || (maData.mnShowRSquared != 0) )
1712 {
1713 mxLabel.reset( new XclExpChText( GetChRoot() ) );
1714 mxLabel->ConvertTrendLineEquation( aEquationProp, aPointPos );
1715 }
1716
1717 // missing features
1718 // #i5085# manual trend line size
1719 // #i34093# manual crossing point
1720 return true;
1721 }
1722
1723 void XclExpChSerTrendLine::WriteBody( XclExpStream& rStrm )
1724 {
1725 rStrm << maData.mnLineType
1726 << maData.mnOrder
1727 << maData.mfIntercept
1728 << maData.mnShowEquation
1729 << maData.mnShowRSquared
1730 << maData.mfForecastFor
1731 << maData.mfForecastBack;
1732 }
1733
1734 XclExpChSerErrorBar::XclExpChSerErrorBar( const XclExpChRoot& rRoot, sal_uInt8 nBarType ) :
1735 XclExpRecord( EXC_ID_CHSERERRORBAR, 14 ),
1736 XclExpChRoot( rRoot )
1737 {
1738 maData.mnBarType = nBarType;
1739 }
1740
1741 bool XclExpChSerErrorBar::Convert( XclExpChSourceLink& rValueLink, sal_uInt16& rnValueCount, const ScfPropertySet& rPropSet )
1742 {
1743 sal_Int32 nBarStyle = 0;
1744 bool bOk = rPropSet.GetProperty( nBarStyle, EXC_CHPROP_ERRORBARSTYLE );
1745 if( bOk )
1746 {
1747 switch( nBarStyle )
1748 {
1749 case cssc::ErrorBarStyle::ABSOLUTE:
1750 maData.mnSourceType = EXC_CHSERERR_FIXED;
1751 rPropSet.GetProperty( maData.mfValue, EXC_CHPROP_POSITIVEERROR );
1752 break;
1753 case cssc::ErrorBarStyle::RELATIVE:
1754 maData.mnSourceType = EXC_CHSERERR_PERCENT;
1755 rPropSet.GetProperty( maData.mfValue, EXC_CHPROP_POSITIVEERROR );
1756 break;
1757 case cssc::ErrorBarStyle::STANDARD_DEVIATION:
1758 maData.mnSourceType = EXC_CHSERERR_STDDEV;
1759 rPropSet.GetProperty( maData.mfValue, EXC_CHPROP_WEIGHT );
1760 break;
1761 case cssc::ErrorBarStyle::STANDARD_ERROR:
1762 maData.mnSourceType = EXC_CHSERERR_STDERR;
1763 break;
1764 case cssc::ErrorBarStyle::FROM_DATA:
1765 {
1766 bOk = false;
1767 maData.mnSourceType = EXC_CHSERERR_CUSTOM;
1768 Reference< XDataSource > xDataSource( rPropSet.GetApiPropertySet(), UNO_QUERY );
1769 if( xDataSource.is() )
1770 {
1771 // find first sequence with current role
1772 OUString aRole = XclChartHelper::GetErrorBarValuesRole( maData.mnBarType );
1773 Reference< XDataSequence > xValueSeq;
1774
1775 Sequence< Reference< XLabeledDataSequence > > aLabeledSeqVec = xDataSource->getDataSequences();
1776 const Reference< XLabeledDataSequence >* pBeg = aLabeledSeqVec.getConstArray();
1777 const Reference< XLabeledDataSequence >* pEnd = pBeg + aLabeledSeqVec.getLength();
1778 for( const Reference< XLabeledDataSequence >* pIt = pBeg; !xValueSeq.is() && (pIt != pEnd); ++pIt )
1779 {
1780 Reference< XDataSequence > xTmpValueSeq = (*pIt)->getValues();
1781 ScfPropertySet aValueProp( xTmpValueSeq );
1782 OUString aCurrRole;
1783 if( aValueProp.GetProperty( aCurrRole, EXC_CHPROP_ROLE ) && (aCurrRole == aRole) )
1784 xValueSeq = xTmpValueSeq;
1785 }
1786 if( xValueSeq.is() )
1787 {
1788 // #i86465# pass value count back to series
1789 rnValueCount = maData.mnValueCount = rValueLink.ConvertDataSequence( xValueSeq, true );
1790 bOk = maData.mnValueCount > 0;
1791 }
1792 }
1793 }
1794 break;
1795 default:
1796 bOk = false;
1797 }
1798 }
1799 return bOk;
1800 }
1801
1802 void XclExpChSerErrorBar::WriteBody( XclExpStream& rStrm )
1803 {
1804 rStrm << maData.mnBarType
1805 << maData.mnSourceType
1806 << maData.mnLineEnd
1807 << sal_uInt8( 1 ) // must be 1 to make line visible
1808 << maData.mfValue
1809 << maData.mnValueCount;
1810 }
1811
1812 namespace {
1813
1814 /** Returns the property set of the specified data point. */
1815 ScfPropertySet lclGetPointPropSet( Reference< XDataSeries > xDataSeries, sal_Int32 nPointIdx )
1816 {
1817 ScfPropertySet aPropSet;
1818 try
1819 {
1820 aPropSet.Set( xDataSeries->getDataPointByIndex( nPointIdx ) );
1821 }
1822 catch( Exception& )
1823 {
1824 OSL_FAIL( "lclGetPointPropSet - no data point property set" );
1825 }
1826 return aPropSet;
1827 }
1828
1829 } // namespace
1830
1831 XclExpChSeries::XclExpChSeries( const XclExpChRoot& rRoot, sal_uInt16 nSeriesIdx ) :
1832 XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_SERIES, EXC_ID_CHSERIES, (rRoot.GetBiff() == EXC_BIFF8) ? 12 : 8 ),
1833 mnGroupIdx( EXC_CHSERGROUP_NONE ),
1834 mnSeriesIdx( nSeriesIdx ),
1835 mnParentIdx( EXC_CHSERIES_INVALID )
1836 {
1837 // CHSOURCELINK records are always required, even if unused
1838 mxTitleLink.reset( new XclExpChSourceLink( GetChRoot(), EXC_CHSRCLINK_TITLE ) );
1839 mxValueLink.reset( new XclExpChSourceLink( GetChRoot(), EXC_CHSRCLINK_VALUES ) );
1840 mxCategLink.reset( new XclExpChSourceLink( GetChRoot(), EXC_CHSRCLINK_CATEGORY ) );
1841 if( GetBiff() == EXC_BIFF8 )
1842 mxBubbleLink.reset( new XclExpChSourceLink( GetChRoot(), EXC_CHSRCLINK_BUBBLES ) );
1843 }
1844
1845 bool XclExpChSeries::ConvertDataSeries(
1846 Reference< XDiagram > xDiagram, Reference< XDataSeries > xDataSeries,
1847 const XclChExtTypeInfo& rTypeInfo, sal_uInt16 nGroupIdx, sal_uInt16 nFormatIdx )
1848 {
1849 bool bOk = false;
1850 Reference< XDataSource > xDataSource( xDataSeries, UNO_QUERY );
1851 if( xDataSource.is() )
1852 {
1853 Reference< XDataSequence > xYValueSeq, xTitleSeq, xXValueSeq, xBubbleSeq;
1854
1855 // find first sequence with role 'values-y'
1856 Sequence< Reference< XLabeledDataSequence > > aLabeledSeqVec = xDataSource->getDataSequences();
1857 const Reference< XLabeledDataSequence >* pBeg = aLabeledSeqVec.getConstArray();
1858 const Reference< XLabeledDataSequence >* pEnd = pBeg + aLabeledSeqVec.getLength();
1859 for( const Reference< XLabeledDataSequence >* pIt = pBeg; pIt != pEnd; ++pIt )
1860 {
1861 Reference< XDataSequence > xTmpValueSeq = (*pIt)->getValues();
1862 ScfPropertySet aValueProp( xTmpValueSeq );
1863 OUString aRole;
1864 if( aValueProp.GetProperty( aRole, EXC_CHPROP_ROLE ) )
1865 {
1866 if( !xYValueSeq.is() && (aRole == EXC_CHPROP_ROLE_YVALUES) )
1867 {
1868 xYValueSeq = xTmpValueSeq;
1869 if( !xTitleSeq.is() )
1870 xTitleSeq = (*pIt)->getLabel(); // ignore role of label sequence
1871 }
1872 else if( !xXValueSeq.is() && !rTypeInfo.mbCategoryAxis && (aRole == EXC_CHPROP_ROLE_XVALUES) )
1873 {
1874 xXValueSeq = xTmpValueSeq;
1875 }
1876 else if( !xBubbleSeq.is() && (rTypeInfo.meTypeId == EXC_CHTYPEID_BUBBLES) && (aRole == EXC_CHPROP_ROLE_SIZEVALUES) )
1877 {
1878 xBubbleSeq = xTmpValueSeq;
1879 xTitleSeq = (*pIt)->getLabel(); // ignore role of label sequence
1880 }
1881 }
1882 }
1883
1884 bOk = xYValueSeq.is();
1885 if( bOk )
1886 {
1887 // chart type group index
1888 mnGroupIdx = nGroupIdx;
1889
1890 // convert source links
1891 maData.mnValueCount = mxValueLink->ConvertDataSequence( xYValueSeq, true );
1892 mxTitleLink->ConvertDataSequence( xTitleSeq, true );
1893
1894 // X values of XY charts
1895 maData.mnCategCount = mxCategLink->ConvertDataSequence( xXValueSeq, false, maData.mnValueCount );
1896
1897 // size values of bubble charts
1898 if( mxBubbleLink )
1899 mxBubbleLink->ConvertDataSequence( xBubbleSeq, false, maData.mnValueCount );
1900
1901 // series formatting
1902 XclChDataPointPos aPointPos( mnSeriesIdx );
1903 ScfPropertySet aSeriesProp( xDataSeries );
1904 mxSeriesFmt.reset( new XclExpChDataFormat( GetChRoot(), aPointPos, nFormatIdx ) );
1905 mxSeriesFmt->ConvertDataSeries( aSeriesProp, rTypeInfo );
1906
1907 // trend lines
1908 CreateTrendLines( xDataSeries );
1909
1910 // error bars
1911 CreateErrorBars( aSeriesProp, EXC_CHPROP_ERRORBARX, EXC_CHSERERR_XPLUS, EXC_CHSERERR_XMINUS );
1912 CreateErrorBars( aSeriesProp, EXC_CHPROP_ERRORBARY, EXC_CHSERERR_YPLUS, EXC_CHSERERR_YMINUS );
1913
1914 if( maData.mnValueCount > 0 )
1915 {
1916 const sal_Int32 nMaxPointCount = maData.mnValueCount;
1917
1918 /* #i91063# Create missing fill properties in pie/doughnut charts.
1919 If freshly created (never saved to ODF), these charts show
1920 varying point colors but do not return these points via API. */
1921 if( xDiagram.is() && (rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_PIE) )
1922 {
1923 Reference< XColorScheme > xColorScheme = xDiagram->getDefaultColorScheme();
1924 if( xColorScheme.is() )
1925 {
1926 const OUString aFillStyleName = "FillStyle";
1927 const OUString aColorName = "Color";
1928 namespace cssd = ::com::sun::star::drawing;
1929 for( sal_Int32 nPointIdx = 0; nPointIdx < nMaxPointCount; ++nPointIdx )
1930 {
1931 aPointPos.mnPointIdx = static_cast< sal_uInt16 >( nPointIdx );
1932 ScfPropertySet aPointProp = lclGetPointPropSet( xDataSeries, nPointIdx );
1933 // test that the point fill style is solid, but no color is set
1934 cssd::FillStyle eFillStyle = cssd::FillStyle_NONE;
1935 if( aPointProp.GetProperty( eFillStyle, aFillStyleName ) &&
1936 (eFillStyle == cssd::FillStyle_SOLID) &&
1937 !aPointProp.HasProperty( aColorName ) )
1938 {
1939 aPointProp.SetProperty( aColorName, xColorScheme->getColorByIndex( nPointIdx ) );
1940 }
1941 }
1942 }
1943 }
1944
1945 // data point formatting
1946 Sequence< sal_Int32 > aPointIndexes;
1947 if( aSeriesProp.GetProperty( aPointIndexes, EXC_CHPROP_ATTRIBDATAPOINTS ) && aPointIndexes.hasElements() )
1948 {
1949 const sal_Int32* pnBeg = aPointIndexes.getConstArray();
1950 const sal_Int32* pnEnd = pnBeg + aPointIndexes.getLength();
1951 for( const sal_Int32* pnIt = pnBeg; (pnIt != pnEnd) && (*pnIt < nMaxPointCount); ++pnIt )
1952 {
1953 aPointPos.mnPointIdx = static_cast< sal_uInt16 >( *pnIt );
1954 ScfPropertySet aPointProp = lclGetPointPropSet( xDataSeries, *pnIt );
1955 XclExpChDataFormatRef xPointFmt( new XclExpChDataFormat( GetChRoot(), aPointPos, nFormatIdx ) );
1956 xPointFmt->ConvertDataSeries( aPointProp, rTypeInfo );
1957 maPointFmts.AppendRecord( xPointFmt );
1958 }
1959 }
1960 }
1961 }
1962 }
1963 return bOk;
1964 }
1965
1966 bool XclExpChSeries::ConvertStockSeries( css::uno::Reference< css::chart2::XDataSeries > xDataSeries,
1967 const OUString& rValueRole, sal_uInt16 nGroupIdx, sal_uInt16 nFormatIdx, bool bCloseSymbol )
1968 {
1969 bool bOk = false;
1970 Reference< XDataSource > xDataSource( xDataSeries, UNO_QUERY );
1971 if( xDataSource.is() )
1972 {
1973 Reference< XDataSequence > xYValueSeq, xTitleSeq;
1974
1975 // find first sequence with passed role
1976 Sequence< Reference< XLabeledDataSequence > > aLabeledSeqVec = xDataSource->getDataSequences();
1977 const Reference< XLabeledDataSequence >* pBeg = aLabeledSeqVec.getConstArray();
1978 const Reference< XLabeledDataSequence >* pEnd = pBeg + aLabeledSeqVec.getLength();
1979 for( const Reference< XLabeledDataSequence >* pIt = pBeg; !xYValueSeq.is() && (pIt != pEnd); ++pIt )
1980 {
1981 Reference< XDataSequence > xTmpValueSeq = (*pIt)->getValues();
1982 ScfPropertySet aValueProp( xTmpValueSeq );
1983 OUString aRole;
1984 if( aValueProp.GetProperty( aRole, EXC_CHPROP_ROLE ) && (aRole == rValueRole) )
1985 {
1986 xYValueSeq = xTmpValueSeq;
1987 xTitleSeq = (*pIt)->getLabel(); // ignore role of label sequence
1988 }
1989 }
1990
1991 bOk = xYValueSeq.is();
1992 if( bOk )
1993 {
1994 // chart type group index
1995 mnGroupIdx = nGroupIdx;
1996 // convert source links
1997 maData.mnValueCount = mxValueLink->ConvertDataSequence( xYValueSeq, true );
1998 mxTitleLink->ConvertDataSequence( xTitleSeq, true );
1999 // series formatting
2000 ScfPropertySet aSeriesProp( xDataSeries );
2001 mxSeriesFmt.reset( new XclExpChDataFormat( GetChRoot(), XclChDataPointPos( mnSeriesIdx ), nFormatIdx ) );
2002 mxSeriesFmt->ConvertStockSeries( aSeriesProp, bCloseSymbol );
2003 }
2004 }
2005 return bOk;
2006 }
2007
2008 bool XclExpChSeries::ConvertTrendLine( const XclExpChSeries& rParent, Reference< XRegressionCurve > xRegCurve )
2009 {
2010 InitFromParent( rParent );
2011
2012 mxTrendLine.reset( new XclExpChSerTrendLine( GetChRoot() ) );
2013 bool bOk = mxTrendLine->Convert( xRegCurve, mnSeriesIdx );
2014 if( bOk )
2015 {
2016 OUString aName;
2017 ScfPropertySet aProperties( xRegCurve );
2018 aProperties.GetProperty(aName, EXC_CHPROP_CURVENAME);
2019 mxTitleLink->ConvertString(aName);
2020
2021 mxSeriesFmt = mxTrendLine->GetDataFormat();
2022 GetChartData().SetDataLabel( mxTrendLine->GetDataLabel() );
2023 }
2024 return bOk;
2025 }
2026
2027 bool XclExpChSeries::ConvertErrorBar( const XclExpChSeries& rParent, const ScfPropertySet& rPropSet, sal_uInt8 nBarId )
2028 {
2029 InitFromParent( rParent );
2030 // error bar settings
2031 mxErrorBar.reset( new XclExpChSerErrorBar( GetChRoot(), nBarId ) );
2032 bool bOk = mxErrorBar->Convert( *mxValueLink, maData.mnValueCount, rPropSet );
2033 if( bOk )
2034 {
2035 // error bar formatting
2036 mxSeriesFmt.reset( new XclExpChDataFormat( GetChRoot(), XclChDataPointPos( mnSeriesIdx ), 0 ) );
2037 mxSeriesFmt->ConvertLine( rPropSet, EXC_CHOBJTYPE_ERRORBAR );
2038 }
2039 return bOk;
2040 }
2041
2042 void XclExpChSeries::ConvertCategSequence( Reference< XLabeledDataSequence > xCategSeq )
2043 {
2044 if( xCategSeq.is() )
2045 maData.mnCategCount = mxCategLink->ConvertDataSequence( xCategSeq->getValues(), false );
2046 }
2047
2048 void XclExpChSeries::WriteSubRecords( XclExpStream& rStrm )
2049 {
2050 lclSaveRecord( rStrm, mxTitleLink );
2051 lclSaveRecord( rStrm, mxValueLink );
2052 lclSaveRecord( rStrm, mxCategLink );
2053 lclSaveRecord( rStrm, mxBubbleLink );
2054 lclSaveRecord( rStrm, mxSeriesFmt );
2055 maPointFmts.Save( rStrm );
2056 if( mnGroupIdx != EXC_CHSERGROUP_NONE )
2057 XclExpUInt16Record( EXC_ID_CHSERGROUP, mnGroupIdx ).Save( rStrm );
2058 if( mnParentIdx != EXC_CHSERIES_INVALID )
2059 XclExpUInt16Record( EXC_ID_CHSERPARENT, mnParentIdx ).Save( rStrm );
2060 lclSaveRecord( rStrm, mxTrendLine );
2061 lclSaveRecord( rStrm, mxErrorBar );
2062 }
2063
2064 void XclExpChSeries::InitFromParent( const XclExpChSeries& rParent )
2065 {
2066 // index to parent series is stored 1-based
2067 mnParentIdx = rParent.mnSeriesIdx + 1;
2068 /* #i86465# MSO2007 SP1 expects correct point counts in child series
2069 (there was no problem in Excel2003 or Excel2007 without SP1...) */
2070 maData.mnCategCount = rParent.maData.mnCategCount;
2071 maData.mnValueCount = rParent.maData.mnValueCount;
2072 }
2073
2074 void XclExpChSeries::CreateTrendLines( css::uno::Reference< css::chart2::XDataSeries > xDataSeries )
2075 {
2076 Reference< XRegressionCurveContainer > xRegCurveCont( xDataSeries, UNO_QUERY );
2077 if( xRegCurveCont.is() )
2078 {
2079 Sequence< Reference< XRegressionCurve > > aRegCurveSeq = xRegCurveCont->getRegressionCurves();
2080 const Reference< XRegressionCurve >* pBeg = aRegCurveSeq.getConstArray();
2081 const Reference< XRegressionCurve >* pEnd = pBeg + aRegCurveSeq.getLength();
2082 for( const Reference< XRegressionCurve >* pIt = pBeg; pIt != pEnd; ++pIt )
2083 {
2084 XclExpChSeriesRef xSeries = GetChartData().CreateSeries();
2085 if( xSeries && !xSeries->ConvertTrendLine( *this, *pIt ) )
2086 GetChartData().RemoveLastSeries();
2087 }
2088 }
2089 }
2090
2091 void XclExpChSeries::CreateErrorBars( const ScfPropertySet& rPropSet,
2092 const OUString& rBarPropName, sal_uInt8 nPosBarId, sal_uInt8 nNegBarId )
2093 {
2094 Reference< XPropertySet > xErrorBar;
2095 if( rPropSet.GetProperty( xErrorBar, rBarPropName ) && xErrorBar.is() )
2096 {
2097 ScfPropertySet aErrorProp( xErrorBar );
2098 CreateErrorBar( aErrorProp, EXC_CHPROP_SHOWPOSITIVEERROR, nPosBarId );
2099 CreateErrorBar( aErrorProp, EXC_CHPROP_SHOWNEGATIVEERROR, nNegBarId );
2100 }
2101 }
2102
2103 void XclExpChSeries::CreateErrorBar( const ScfPropertySet& rPropSet,
2104 const OUString& rShowPropName, sal_uInt8 nBarId )
2105 {
2106 if( rPropSet.GetBoolProperty( rShowPropName ) )
2107 {
2108 XclExpChSeriesRef xSeries = GetChartData().CreateSeries();
2109 if( xSeries && !xSeries->ConvertErrorBar( *this, rPropSet, nBarId ) )
2110 GetChartData().RemoveLastSeries();
2111 }
2112 }
2113
2114 void XclExpChSeries::WriteBody( XclExpStream& rStrm )
2115 {
2116 rStrm << maData.mnCategType << maData.mnValueType << maData.mnCategCount << maData.mnValueCount;
2117 if( GetBiff() == EXC_BIFF8 )
2118 rStrm << maData.mnBubbleType << maData.mnBubbleCount;
2119 }
2120
2121 // Chart type groups ==========================================================
2122
2123 XclExpChType::XclExpChType( const XclExpChRoot& rRoot ) :
2124 XclExpRecord( EXC_ID_CHUNKNOWN ),
2125 XclExpChRoot( rRoot ),
2126 maTypeInfo( rRoot.GetChartTypeInfo( EXC_CHTYPEID_UNKNOWN ) )
2127 {
2128 }
2129
2130 void XclExpChType::Convert( Reference< XDiagram > xDiagram, Reference< XChartType > xChartType,
2131 sal_Int32 nApiAxesSetIdx, bool bSwappedAxesSet, bool bHasXLabels )
2132 {
2133 if( xChartType.is() )
2134 {
2135 maTypeInfo = GetChartTypeInfo( xChartType->getChartType() );
2136 // special handling for some chart types
2137 switch( maTypeInfo.meTypeCateg )
2138 {
2139 case EXC_CHTYPECATEG_BAR:
2140 {
2141 maTypeInfo = GetChartTypeInfo( bSwappedAxesSet ? EXC_CHTYPEID_HORBAR : EXC_CHTYPEID_BAR );
2142 ::set_flag( maData.mnFlags, EXC_CHBAR_HORIZONTAL, bSwappedAxesSet );
2143 ScfPropertySet aTypeProp( xChartType );
2144 Sequence< sal_Int32 > aInt32Seq;
2145 maData.mnOverlap = 0;
2146 if( aTypeProp.GetProperty( aInt32Seq, EXC_CHPROP_OVERLAPSEQ ) && (nApiAxesSetIdx < aInt32Seq.getLength()) )
2147 maData.mnOverlap = limit_cast< sal_Int16 >( -aInt32Seq[ nApiAxesSetIdx ], -100, 100 );
2148 maData.mnGap = 150;
2149 if( aTypeProp.GetProperty( aInt32Seq, EXC_CHPROP_GAPWIDTHSEQ ) && (nApiAxesSetIdx < aInt32Seq.getLength()) )
2150 maData.mnGap = limit_cast< sal_uInt16 >( aInt32Seq[ nApiAxesSetIdx ], 0, 500 );
2151 }
2152 break;
2153 case EXC_CHTYPECATEG_RADAR:
2154 ::set_flag( maData.mnFlags, EXC_CHRADAR_AXISLABELS, bHasXLabels );
2155 break;
2156 case EXC_CHTYPECATEG_PIE:
2157 {
2158 ScfPropertySet aTypeProp( xChartType );
2159 bool bDonut = aTypeProp.GetBoolProperty( EXC_CHPROP_USERINGS );
2160 maTypeInfo = GetChartTypeInfo( bDonut ? EXC_CHTYPEID_DONUT : EXC_CHTYPEID_PIE );
2161 maData.mnPieHole = bDonut ? 50 : 0;
2162 // #i85166# starting angle of first pie slice
2163 ScfPropertySet aDiaProp( xDiagram );
2164 maData.mnRotation = XclExpChRoot::ConvertPieRotation( aDiaProp );
2165 }
2166 break;
2167 case EXC_CHTYPECATEG_SCATTER:
2168 if( GetBiff() == EXC_BIFF8 )
2169 ::set_flag( maData.mnFlags, EXC_CHSCATTER_BUBBLES, maTypeInfo.meTypeId == EXC_CHTYPEID_BUBBLES );
2170 break;
2171 default:;
2172 }
2173 SetRecId( maTypeInfo.mnRecId );
2174 }
2175 }
2176
2177 void XclExpChType::SetStacked( bool bPercent )
2178 {
2179 switch( maTypeInfo.meTypeCateg )
2180 {
2181 case EXC_CHTYPECATEG_LINE:
2182 ::set_flag( maData.mnFlags, EXC_CHLINE_STACKED );
2183 ::set_flag( maData.mnFlags, EXC_CHLINE_PERCENT, bPercent );
2184 break;
2185 case EXC_CHTYPECATEG_BAR:
2186 ::set_flag( maData.mnFlags, EXC_CHBAR_STACKED );
2187 ::set_flag( maData.mnFlags, EXC_CHBAR_PERCENT, bPercent );
2188 maData.mnOverlap = -100;
2189 break;
2190 default:;
2191 }
2192 }
2193
2194 void XclExpChType::WriteBody( XclExpStream& rStrm )
2195 {
2196 switch( GetRecId() )
2197 {
2198 case EXC_ID_CHBAR:
2199 rStrm << maData.mnOverlap << maData.mnGap << maData.mnFlags;
2200 break;
2201
2202 case EXC_ID_CHLINE:
2203 case EXC_ID_CHAREA:
2204 case EXC_ID_CHRADARLINE:
2205 case EXC_ID_CHRADARAREA:
2206 rStrm << maData.mnFlags;
2207 break;
2208
2209 case EXC_ID_CHPIE:
2210 rStrm << maData.mnRotation << maData.mnPieHole;
2211 if( GetBiff() == EXC_BIFF8 )
2212 rStrm << maData.mnFlags;
2213 break;
2214
2215 case EXC_ID_CHSCATTER:
2216 if( GetBiff() == EXC_BIFF8 )
2217 rStrm << maData.mnBubbleSize << maData.mnBubbleType << maData.mnFlags;
2218 break;
2219
2220 default:
2221 OSL_FAIL( "XclExpChType::WriteBody - unknown chart type" );
2222 }
2223 }
2224
2225 XclExpChChart3d::XclExpChChart3d() :
2226 XclExpRecord( EXC_ID_CHCHART3D, 14 )
2227 {
2228 }
2229
2230 void XclExpChChart3d::Convert( const ScfPropertySet& rPropSet, bool b3dWallChart )
2231 {
2232 sal_Int32 nRotationY = 0;
2233 rPropSet.GetProperty( nRotationY, EXC_CHPROP_ROTATIONVERTICAL );
2234 sal_Int32 nRotationX = 0;
2235 rPropSet.GetProperty( nRotationX, EXC_CHPROP_ROTATIONHORIZONTAL );
2236 sal_Int32 nPerspective = 15;
2237 rPropSet.GetProperty( nPerspective, EXC_CHPROP_PERSPECTIVE );
2238
2239 if( b3dWallChart )
2240 {
2241 // Y rotation (Excel [0..359], Chart2 [-179,180])
2242 if( nRotationY < 0 ) nRotationY += 360;
2243 maData.mnRotation = static_cast< sal_uInt16 >( nRotationY );
2244 // X rotation a.k.a. elevation (Excel [-90..90], Chart2 [-179,180])
2245 maData.mnElevation = limit_cast< sal_Int16 >( nRotationX, -90, 90 );
2246 // perspective (Excel and Chart2 [0,100])
2247 maData.mnEyeDist = limit_cast< sal_uInt16 >( nPerspective, 0, 100 );
2248 // flags
2249 maData.mnFlags = 0;
2250 ::set_flag( maData.mnFlags, EXC_CHCHART3D_REAL3D, !rPropSet.GetBoolProperty( EXC_CHPROP_RIGHTANGLEDAXES ) );
2251 ::set_flag( maData.mnFlags, EXC_CHCHART3D_AUTOHEIGHT );
2252 ::set_flag( maData.mnFlags, EXC_CHCHART3D_HASWALLS );
2253 }
2254 else
2255 {
2256 // Y rotation not used in pie charts, but 'first pie slice angle'
2257 maData.mnRotation = XclExpChRoot::ConvertPieRotation( rPropSet );
2258 // X rotation a.k.a. elevation (map Chart2 [-80,-10] to Excel [10..80])
2259 maData.mnElevation = limit_cast< sal_Int16 >( (nRotationX + 270) % 180, 10, 80 );
2260 // perspective (Excel and Chart2 [0,100])
2261 maData.mnEyeDist = limit_cast< sal_uInt16 >( nPerspective, 0, 100 );
2262 // flags
2263 maData.mnFlags = 0;
2264 }
2265 }
2266
2267 void XclExpChChart3d::WriteBody( XclExpStream& rStrm )
2268 {
2269 rStrm << maData.mnRotation
2270 << maData.mnElevation
2271 << maData.mnEyeDist
2272 << maData.mnRelHeight
2273 << maData.mnRelDepth
2274 << maData.mnDepthGap
2275 << maData.mnFlags;
2276 }
2277
2278 XclExpChLegend::XclExpChLegend( const XclExpChRoot& rRoot ) :
2279 XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_LEGEND, EXC_ID_CHLEGEND, 20 )
2280 {
2281 }
2282
2283 void XclExpChLegend::Convert( const ScfPropertySet& rPropSet )
2284 {
2285 // frame properties
2286 mxFrame = lclCreateFrame( GetChRoot(), rPropSet, EXC_CHOBJTYPE_LEGEND );
2287 // text properties
2288 mxText.reset( new XclExpChText( GetChRoot() ) );
2289 mxText->ConvertLegend( rPropSet );
2290
2291 // legend position and size
2292 Any aRelPosAny, aRelSizeAny;
2293 rPropSet.GetAnyProperty( aRelPosAny, EXC_CHPROP_RELATIVEPOSITION );
2294 rPropSet.GetAnyProperty( aRelSizeAny, EXC_CHPROP_RELATIVESIZE );
2295 cssc::ChartLegendExpansion eApiExpand = cssc::ChartLegendExpansion_CUSTOM;
2296 rPropSet.GetProperty( eApiExpand, EXC_CHPROP_EXPANSION );
2297 if( aRelPosAny.has< RelativePosition >() || ((eApiExpand == cssc::ChartLegendExpansion_CUSTOM) && aRelSizeAny.has< RelativeSize >()) )
2298 {
2299 try
2300 {
2301 /* The 'RelativePosition' or 'RelativeSize' properties are used as
2302 indicator of manually changed legend position/size, but due to
2303 the different anchor modes used by this property (in the
2304 RelativePosition.Anchor member) it cannot be used to calculate
2305 the position easily. For this, the Chart1 API will be used
2306 instead. */
2307 Reference< cssc::XChartDocument > xChart1Doc( GetChartDocument(), UNO_QUERY_THROW );
2308 Reference< XShape > xChart1Legend( xChart1Doc->getLegend(), UNO_SET_THROW );
2309 // coordinates in CHLEGEND record written but not used by Excel
2310 mxFramePos.reset( new XclExpChFramePos( EXC_CHFRAMEPOS_CHARTSIZE, EXC_CHFRAMEPOS_PARENT ) );
2311 XclChFramePos& rFramePos = mxFramePos->GetFramePosData();
2312 rFramePos.mnTLMode = EXC_CHFRAMEPOS_CHARTSIZE;
2313 css::awt::Point aLegendPos = xChart1Legend->getPosition();
2314 rFramePos.maRect.mnX = maData.maRect.mnX = CalcChartXFromHmm( aLegendPos.X );
2315 rFramePos.maRect.mnY = maData.maRect.mnY = CalcChartYFromHmm( aLegendPos.Y );
2316 // legend size, Excel expects points in CHFRAMEPOS record
2317 rFramePos.mnBRMode = EXC_CHFRAMEPOS_ABSSIZE_POINTS;
2318 css::awt::Size aLegendSize = xChart1Legend->getSize();
2319 rFramePos.maRect.mnWidth = static_cast< sal_uInt16 >( aLegendSize.Width * EXC_POINTS_PER_HMM + 0.5 );
2320 rFramePos.maRect.mnHeight = static_cast< sal_uInt16 >( aLegendSize.Height * EXC_POINTS_PER_HMM + 0.5 );
2321 maData.maRect.mnWidth = CalcChartXFromHmm( aLegendSize.Width );
2322 maData.maRect.mnHeight = CalcChartYFromHmm( aLegendSize.Height );
2323 eApiExpand = cssc::ChartLegendExpansion_CUSTOM;
2324 // manual legend position implies manual plot area
2325 GetChartData().SetManualPlotArea();
2326 maData.mnDockMode = EXC_CHLEGEND_NOTDOCKED;
2327 // a CHFRAME record with cleared auto flags is needed
2328 if( !mxFrame )
2329 mxFrame.reset( new XclExpChFrame( GetChRoot(), EXC_CHOBJTYPE_LEGEND ) );
2330 mxFrame->SetAutoFlags( false, false );
2331 }
2332 catch( Exception& )
2333 {
2334 OSL_FAIL( "XclExpChLegend::Convert - cannot get legend shape" );
2335 maData.mnDockMode = EXC_CHLEGEND_RIGHT;
2336 eApiExpand = cssc::ChartLegendExpansion_HIGH;
2337 }
2338 }
2339 else
2340 {
2341 cssc2::LegendPosition eApiPos = cssc2::LegendPosition_CUSTOM;
2342 rPropSet.GetProperty( eApiPos, EXC_CHPROP_ANCHORPOSITION );
2343 switch( eApiPos )
2344 {
2345 case cssc2::LegendPosition_LINE_START: maData.mnDockMode = EXC_CHLEGEND_LEFT; break;
2346 case cssc2::LegendPosition_LINE_END: maData.mnDockMode = EXC_CHLEGEND_RIGHT; break;
2347 case cssc2::LegendPosition_PAGE_START: maData.mnDockMode = EXC_CHLEGEND_TOP; break;
2348 case cssc2::LegendPosition_PAGE_END: maData.mnDockMode = EXC_CHLEGEND_BOTTOM; break;
2349 default:
2350 OSL_FAIL( "XclExpChLegend::Convert - unrecognized legend position" );
2351 maData.mnDockMode = EXC_CHLEGEND_RIGHT;
2352 eApiExpand = cssc::ChartLegendExpansion_HIGH;
2353 }
2354 }
2355 ::set_flag( maData.mnFlags, EXC_CHLEGEND_STACKED, eApiExpand == cssc::ChartLegendExpansion_HIGH );
2356
2357 // other flags
2358 ::set_flag( maData.mnFlags, EXC_CHLEGEND_AUTOSERIES );
2359 const sal_uInt16 nAutoFlags = EXC_CHLEGEND_DOCKED | EXC_CHLEGEND_AUTOPOSX | EXC_CHLEGEND_AUTOPOSY;
2360 ::set_flag( maData.mnFlags, nAutoFlags, maData.mnDockMode != EXC_CHLEGEND_NOTDOCKED );
2361 }
2362
2363 void XclExpChLegend::WriteSubRecords( XclExpStream& rStrm )
2364 {
2365 lclSaveRecord( rStrm, mxFramePos );
2366 lclSaveRecord( rStrm, mxText );
2367 lclSaveRecord( rStrm, mxFrame );
2368 }
2369
2370 void XclExpChLegend::WriteBody( XclExpStream& rStrm )
2371 {
2372 rStrm << maData.maRect << maData.mnDockMode << maData.mnSpacing << maData.mnFlags;
2373 }
2374
2375 XclExpChDropBar::XclExpChDropBar( const XclExpChRoot& rRoot, XclChObjectType eObjType ) :
2376 XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_DROPBAR, EXC_ID_CHDROPBAR, 2 ),
2377 meObjType( eObjType ),
2378 mnBarDist( 100 )
2379 {
2380 }
2381
2382 void XclExpChDropBar::Convert( const ScfPropertySet& rPropSet )
2383 {
2384 if( rPropSet.Is() )
2385 ConvertFrameBase( GetChRoot(), rPropSet, meObjType );
2386 else
2387 SetDefaultFrameBase( GetChRoot(), EXC_CHFRAMETYPE_INVISIBLE, true );
2388 }
2389
2390 void XclExpChDropBar::WriteSubRecords( XclExpStream& rStrm )
2391 {
2392 WriteFrameRecords( rStrm );
2393 }
2394
2395 void XclExpChDropBar::WriteBody( XclExpStream& rStrm )
2396 {
2397 rStrm << mnBarDist;
2398 }
2399
2400 XclExpChTypeGroup::XclExpChTypeGroup( const XclExpChRoot& rRoot, sal_uInt16 nGroupIdx ) :
2401 XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_TYPEGROUP, EXC_ID_CHTYPEGROUP, 20 ),
2402 maType( rRoot ),
2403 maTypeInfo( maType.GetTypeInfo() )
2404 {
2405 maData.mnGroupIdx = nGroupIdx;
2406 }
2407
2408 void XclExpChTypeGroup::ConvertType(
2409 Reference< XDiagram > xDiagram, Reference< XChartType > xChartType,
2410 sal_Int32 nApiAxesSetIdx, bool b3dChart, bool bSwappedAxesSet, bool bHasXLabels )
2411 {
2412 // chart type settings
2413 maType.Convert( xDiagram, xChartType, nApiAxesSetIdx, bSwappedAxesSet, bHasXLabels );
2414
2415 // spline - TODO: get from single series (#i66858#)
2416 ScfPropertySet aTypeProp( xChartType );
2417 cssc2::CurveStyle eCurveStyle;
2418 bool bSpline = aTypeProp.GetProperty( eCurveStyle, EXC_CHPROP_CURVESTYLE ) &&
2419 (eCurveStyle != cssc2::CurveStyle_LINES);
2420
2421 // extended type info
2422 maTypeInfo.Set( maType.GetTypeInfo(), b3dChart, bSpline );
2423
2424 // 3d chart settings
2425 if( maTypeInfo.mb3dChart ) // only true, if Excel chart supports 3d mode
2426 {
2427 mxChart3d.reset( new XclExpChChart3d );
2428 ScfPropertySet aDiaProp( xDiagram );
2429 mxChart3d->Convert( aDiaProp, Is3dWallChart() );
2430 }
2431 }
2432
2433 void XclExpChTypeGroup::ConvertSeries(
2434 Reference< XDiagram > xDiagram, Reference< XChartType > xChartType,
2435 sal_Int32 nGroupAxesSetIdx, bool bPercent, bool bConnectBars )
2436 {
2437 Reference< XDataSeriesContainer > xSeriesCont( xChartType, UNO_QUERY );
2438 if( xSeriesCont.is() )
2439 {
2440 typedef ::std::vector< Reference< XDataSeries > > XDataSeriesVec;
2441 XDataSeriesVec aSeriesVec;
2442
2443 // copy data series attached to the current axes set to the vector
2444 Sequence< Reference< XDataSeries > > aSeriesSeq = xSeriesCont->getDataSeries();
2445 const Reference< XDataSeries >* pBeg = aSeriesSeq.getConstArray();
2446 const Reference< XDataSeries >* pEnd = pBeg + aSeriesSeq.getLength();
2447 for( const Reference< XDataSeries >* pIt = pBeg; pIt != pEnd; ++pIt )
2448 {
2449 ScfPropertySet aSeriesProp( *pIt );
2450 sal_Int32 nSeriesAxesSetIdx(0);
2451 if( aSeriesProp.GetProperty( nSeriesAxesSetIdx, EXC_CHPROP_ATTAXISINDEX ) && (nSeriesAxesSetIdx == nGroupAxesSetIdx) )
2452 aSeriesVec.push_back( *pIt );
2453 }
2454
2455 // Are there any series in the current axes set?
2456 if( !aSeriesVec.empty() )
2457 {
2458 // stacking direction (stacked/percent/deep 3d) from first series
2459 ScfPropertySet aSeriesProp( aSeriesVec.front() );
2460 cssc2::StackingDirection eStacking;
2461 if( !aSeriesProp.GetProperty( eStacking, EXC_CHPROP_STACKINGDIR ) )
2462 eStacking = cssc2::StackingDirection_NO_STACKING;
2463
2464 // stacked or percent chart
2465 if( maTypeInfo.mbSupportsStacking && (eStacking == cssc2::StackingDirection_Y_STACKING) )
2466 {
2467 // percent overrides simple stacking
2468 maType.SetStacked( bPercent );
2469
2470 // connected data points (only in stacked bar charts)
2471 if (bConnectBars && (maTypeInfo.meTypeCateg == EXC_CHTYPECATEG_BAR))
2472 {
2473 sal_uInt16 nKey = EXC_CHCHARTLINE_CONNECT;
2474 m_ChartLines.insert(std::make_pair(nKey, o3tl::make_unique<XclExpChLineFormat>(GetChRoot())));
2475 }
2476 }
2477 else
2478 {
2479 // reverse series order for some unstacked 2D chart types
2480 if( maTypeInfo.mbReverseSeries && !Is3dChart() )
2481 ::std::reverse( aSeriesVec.begin(), aSeriesVec.end() );
2482 }
2483
2484 // deep 3d chart or clustered 3d chart (stacked is not clustered)
2485 if( (eStacking == cssc2::StackingDirection_NO_STACKING) && Is3dWallChart() )
2486 mxChart3d->SetClustered();
2487
2488 // varied point colors
2489 ::set_flag( maData.mnFlags, EXC_CHTYPEGROUP_VARIEDCOLORS, aSeriesProp.GetBoolProperty( EXC_CHPROP_VARYCOLORSBY ) );
2490
2491 // process all series
2492 for( XDataSeriesVec::const_iterator aIt = aSeriesVec.begin(), aEnd = aSeriesVec.end(); aIt != aEnd; ++aIt )
2493 {
2494 // create Excel series object, stock charts need special processing
2495 if( maTypeInfo.meTypeId == EXC_CHTYPEID_STOCK )
2496 CreateAllStockSeries( xChartType, *aIt );
2497 else
2498 CreateDataSeries( xDiagram, *aIt );
2499 }
2500 }
2501 }
2502 }
2503
2504 void XclExpChTypeGroup::ConvertCategSequence( Reference< XLabeledDataSequence > xCategSeq )
2505 {
2506 for( size_t nIdx = 0, nSize = maSeries.GetSize(); nIdx < nSize; ++nIdx )
2507 maSeries.GetRecord( nIdx )->ConvertCategSequence( xCategSeq );
2508 }
2509
2510 void XclExpChTypeGroup::ConvertLegend( const ScfPropertySet& rPropSet )
2511 {
2512 if( rPropSet.GetBoolProperty( EXC_CHPROP_SHOW ) )
2513 {
2514 mxLegend.reset( new XclExpChLegend( GetChRoot() ) );
2515 mxLegend->Convert( rPropSet );
2516 }
2517 }
2518
2519 void XclExpChTypeGroup::WriteSubRecords( XclExpStream& rStrm )
2520 {
2521 maType.Save( rStrm );
2522 lclSaveRecord( rStrm, mxChart3d );
2523 lclSaveRecord( rStrm, mxLegend );
2524 lclSaveRecord( rStrm, mxUpBar );
2525 lclSaveRecord( rStrm, mxDownBar );
2526 for (auto const& it : m_ChartLines)
2527 {
2528 lclSaveRecord( rStrm, it.second.get(), EXC_ID_CHCHARTLINE, it.first );
2529 }
2530 }
2531
2532 sal_uInt16 XclExpChTypeGroup::GetFreeFormatIdx() const
2533 {
2534 return static_cast< sal_uInt16 >( maSeries.GetSize() );
2535 }
2536
2537 void XclExpChTypeGroup::CreateDataSeries(
2538 Reference< XDiagram > xDiagram, Reference< XDataSeries > xDataSeries )
2539 {
2540 // let chart create series object with correct series index
2541 XclExpChSeriesRef xSeries = GetChartData().CreateSeries();
2542 if( xSeries )
2543 {
2544 if( xSeries->ConvertDataSeries( xDiagram, xDataSeries, maTypeInfo, GetGroupIdx(), GetFreeFormatIdx() ) )
2545 maSeries.AppendRecord( xSeries );
2546 else
2547 GetChartData().RemoveLastSeries();
2548 }
2549 }
2550
2551 void XclExpChTypeGroup::CreateAllStockSeries(
2552 Reference< XChartType > xChartType, Reference< XDataSeries > xDataSeries )
2553 {
2554 // create existing series objects
2555 bool bHasOpen = CreateStockSeries( xDataSeries, EXC_CHPROP_ROLE_OPENVALUES, false );
2556 bool bHasHigh = CreateStockSeries( xDataSeries, EXC_CHPROP_ROLE_HIGHVALUES, false );
2557 bool bHasLow = CreateStockSeries( xDataSeries, EXC_CHPROP_ROLE_LOWVALUES, false );
2558 bool bHasClose = CreateStockSeries( xDataSeries, EXC_CHPROP_ROLE_CLOSEVALUES, !bHasOpen );
2559
2560 // formatting of special stock chart elements
2561 ScfPropertySet aTypeProp( xChartType );
2562 // hi-lo lines
2563 if( bHasHigh && bHasLow && aTypeProp.GetBoolProperty( EXC_CHPROP_SHOWHIGHLOW ) )
2564 {
2565 ScfPropertySet aSeriesProp( xDataSeries );
2566 XclExpChLineFormatRef xLineFmt( new XclExpChLineFormat( GetChRoot() ) );
2567 xLineFmt->Convert( GetChRoot(), aSeriesProp, EXC_CHOBJTYPE_HILOLINE );
2568 sal_uInt16 nKey = EXC_CHCHARTLINE_HILO;
2569 m_ChartLines.insert(std::make_pair(nKey, o3tl::make_unique<XclExpChLineFormat>(GetChRoot())));
2570 }
2571 // dropbars
2572 if( bHasOpen && bHasClose )
2573 {
2574 // dropbar type is dependent on position in the file - always create both
2575 Reference< XPropertySet > xWhitePropSet, xBlackPropSet;
2576 // white dropbar format
2577 aTypeProp.GetProperty( xWhitePropSet, EXC_CHPROP_WHITEDAY );
2578 ScfPropertySet aWhiteProp( xWhitePropSet );
2579 mxUpBar.reset( new XclExpChDropBar( GetChRoot(), EXC_CHOBJTYPE_WHITEDROPBAR ) );
2580 mxUpBar->Convert( aWhiteProp );
2581 // black dropbar format
2582 aTypeProp.GetProperty( xBlackPropSet, EXC_CHPROP_BLACKDAY );
2583 ScfPropertySet aBlackProp( xBlackPropSet );
2584 mxDownBar.reset( new XclExpChDropBar( GetChRoot(), EXC_CHOBJTYPE_BLACKDROPBAR ) );
2585 mxDownBar->Convert( aBlackProp );
2586 }
2587 }
2588
2589 bool XclExpChTypeGroup::CreateStockSeries( Reference< XDataSeries > xDataSeries,
2590 const OUString& rValueRole, bool bCloseSymbol )
2591 {
2592 bool bOk = false;
2593 // let chart create series object with correct series index
2594 XclExpChSeriesRef xSeries = GetChartData().CreateSeries();
2595 if( xSeries )
2596 {
2597 bOk = xSeries->ConvertStockSeries( xDataSeries,
2598 rValueRole, GetGroupIdx(), GetFreeFormatIdx(), bCloseSymbol );
2599 if( bOk )
2600 maSeries.AppendRecord( xSeries );
2601 else
2602 GetChartData().RemoveLastSeries();
2603 }
2604 return bOk;
2605 }
2606
2607 void XclExpChTypeGroup::WriteBody( XclExpStream& rStrm )
2608 {
2609 rStrm.WriteZeroBytes( 16 );
2610 rStrm << maData.mnFlags << maData.mnGroupIdx;
2611 }
2612
2613 // Axes =======================================================================
2614
2615 XclExpChLabelRange::XclExpChLabelRange( const XclExpChRoot& rRoot ) :
2616 XclExpRecord( EXC_ID_CHLABELRANGE, 8 ),
2617 XclExpChRoot( rRoot )
2618 {
2619 }
2620
2621 void XclExpChLabelRange::Convert( const ScaleData& rScaleData, const ScfPropertySet& rChart1Axis, bool bMirrorOrient )
2622 {
2623 /* Base time unit (using the property 'ExplicitTimeIncrement' from the old
2624 chart API allows to detect axis type (date axis, if property exists),
2625 and to receive the base time unit currently used in case the base time
2626 unit is set to 'automatic'. */
2627 cssc::TimeIncrement aTimeIncrement;
2628 if( rChart1Axis.GetProperty( aTimeIncrement, EXC_CHPROP_EXPTIMEINCREMENT ) )
2629 {
2630 // property exists -> this is a date axis currently
2631 ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_DATEAXIS );
2632
2633 // automatic base time unit, if the UNO Any 'rScaleData.TimeIncrement.TimeResolution' does not contain a valid value...
2634 bool bAutoBase = !rScaleData.TimeIncrement.TimeResolution.has< cssc::TimeIncrement >();
2635 ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOBASE, bAutoBase );
2636
2637 // ...but get the current base time unit from the property of the old chart API
2638 sal_Int32 nApiTimeUnit = 0;
2639 bool bValidBaseUnit = aTimeIncrement.TimeResolution >>= nApiTimeUnit;
2640 OSL_ENSURE( bValidBaseUnit, "XclExpChLabelRange::Convert - cannot get base time unit" );
2641 maDateData.mnBaseUnit = bValidBaseUnit ? lclGetTimeUnit( nApiTimeUnit ) : EXC_CHDATERANGE_DAYS;
2642
2643 /* Min/max values depend on base time unit, they specify the number of
2644 days, months, or years starting from null date. */
2645 bool bAutoMin = lclConvertTimeValue( GetRoot(), maDateData.mnMinDate, rScaleData.Minimum, maDateData.mnBaseUnit );
2646 ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOMIN, bAutoMin );
2647 bool bAutoMax = lclConvertTimeValue( GetRoot(), maDateData.mnMaxDate, rScaleData.Maximum, maDateData.mnBaseUnit );
2648 ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOMAX, bAutoMax );
2649 }
2650
2651 // automatic axis type detection
2652 ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTODATE, rScaleData.AutoDateAxis );
2653
2654 // increment
2655 bool bAutoMajor = lclConvertTimeInterval( maDateData.mnMajorStep, maDateData.mnMajorUnit, rScaleData.TimeIncrement.MajorTimeInterval );
2656 ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOMAJOR, bAutoMajor );
2657 bool bAutoMinor = lclConvertTimeInterval( maDateData.mnMinorStep, maDateData.mnMinorUnit, rScaleData.TimeIncrement.MinorTimeInterval );
2658 ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOMINOR, bAutoMinor );
2659
2660 // origin
2661 double fOrigin = 0.0;
2662 if( !lclIsAutoAnyOrGetValue( fOrigin, rScaleData.Origin ) )
2663 maLabelData.mnCross = limit_cast< sal_uInt16 >( fOrigin, 1, 31999 );
2664
2665 // reverse order
2666 if( (rScaleData.Orientation == cssc2::AxisOrientation_REVERSE) != bMirrorOrient )
2667 ::set_flag( maLabelData.mnFlags, EXC_CHLABELRANGE_REVERSE );
2668 }
2669
2670 void XclExpChLabelRange::ConvertAxisPosition( const ScfPropertySet& rPropSet )
2671 {
2672 cssc::ChartAxisPosition eAxisPos = cssc::ChartAxisPosition_VALUE;
2673 rPropSet.GetProperty( eAxisPos, EXC_CHPROP_CROSSOVERPOSITION );
2674 double fCrossingPos = 1.0;
2675 rPropSet.GetProperty( fCrossingPos, EXC_CHPROP_CROSSOVERVALUE );
2676
2677 bool bDateAxis = ::get_flag( maDateData.mnFlags, EXC_CHDATERANGE_DATEAXIS );
2678 switch( eAxisPos )
2679 {
2680 case cssc::ChartAxisPosition_ZERO:
2681 case cssc::ChartAxisPosition_START:
2682 maLabelData.mnCross = 1;
2683 ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOCROSS );
2684 break;
2685 case cssc::ChartAxisPosition_END:
2686 ::set_flag( maLabelData.mnFlags, EXC_CHLABELRANGE_MAXCROSS );
2687 break;
2688 case cssc::ChartAxisPosition_VALUE:
2689 maLabelData.mnCross = limit_cast< sal_uInt16 >( fCrossingPos, 1, 31999 );
2690 ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOCROSS, false );
2691 if( bDateAxis )
2692 maDateData.mnCross = lclGetTimeValue( GetRoot(), fCrossingPos, maDateData.mnBaseUnit );
2693 break;
2694 default:
2695 maLabelData.mnCross = 1;
2696 ::set_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOCROSS );
2697 }
2698 }
2699
2700 void XclExpChLabelRange::Save( XclExpStream& rStrm )
2701 {
2702 // the CHLABELRANGE record
2703 XclExpRecord::Save( rStrm );
2704
2705 // the CHDATERANGE record with date axis settings (BIFF8 only)
2706 if( GetBiff() == EXC_BIFF8 )
2707 {
2708 rStrm.StartRecord( EXC_ID_CHDATERANGE, 18 );
2709 rStrm << maDateData.mnMinDate
2710 << maDateData.mnMaxDate
2711 << maDateData.mnMajorStep
2712 << maDateData.mnMajorUnit
2713 << maDateData.mnMinorStep
2714 << maDateData.mnMinorUnit
2715 << maDateData.mnBaseUnit
2716 << maDateData.mnCross
2717 << maDateData.mnFlags;
2718 rStrm.EndRecord();
2719 }
2720 }
2721
2722 void XclExpChLabelRange::WriteBody( XclExpStream& rStrm )
2723 {
2724 rStrm << maLabelData.mnCross << maLabelData.mnLabelFreq << maLabelData.mnTickFreq << maLabelData.mnFlags;
2725 }
2726
2727 XclExpChValueRange::XclExpChValueRange( const XclExpChRoot& rRoot ) :
2728 XclExpRecord( EXC_ID_CHVALUERANGE, 42 ),
2729 XclExpChRoot( rRoot )
2730 {
2731 }
2732
2733 void XclExpChValueRange::Convert( const ScaleData& rScaleData )
2734 {
2735 // scaling algorithm
2736 bool bLogScale = ScfApiHelper::GetServiceName( rScaleData.Scaling ) == "com.sun.star.chart2.LogarithmicScaling";
2737 ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_LOGSCALE, bLogScale );
2738
2739 // min/max
2740 bool bAutoMin = lclIsAutoAnyOrGetScaledValue( maData.mfMin, rScaleData.Minimum, bLogScale );
2741 ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOMIN, bAutoMin );
2742 bool bAutoMax = lclIsAutoAnyOrGetScaledValue( maData.mfMax, rScaleData.Maximum, bLogScale );
2743 ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOMAX, bAutoMax );
2744
2745 // origin
2746 bool bAutoCross = lclIsAutoAnyOrGetScaledValue( maData.mfCross, rScaleData.Origin, bLogScale );
2747 ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOCROSS, bAutoCross );
2748
2749 // major increment
2750 const IncrementData& rIncrementData = rScaleData.IncrementData;
2751 bool bAutoMajor = lclIsAutoAnyOrGetValue( maData.mfMajorStep, rIncrementData.Distance ) || (maData.mfMajorStep <= 0.0);
2752 ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOMAJOR, bAutoMajor );
2753 // minor increment
2754 const Sequence< SubIncrement >& rSubIncrementSeq = rIncrementData.SubIncrements;
2755 sal_Int32 nCount = 0;
2756 bool bAutoMinor = bLogScale || bAutoMajor || (rSubIncrementSeq.getLength() < 1) ||
2757 lclIsAutoAnyOrGetValue( nCount, rSubIncrementSeq[ 0 ].IntervalCount ) || (nCount < 1);
2758 if( !bAutoMinor )
2759 maData.mfMinorStep = maData.mfMajorStep / nCount;
2760 ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOMINOR, bAutoMinor );
2761
2762 // reverse order
2763 ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_REVERSE, rScaleData.Orientation == cssc2::AxisOrientation_REVERSE );
2764 }
2765
2766 void XclExpChValueRange::ConvertAxisPosition( const ScfPropertySet& rPropSet )
2767 {
2768 cssc::ChartAxisPosition eAxisPos = cssc::ChartAxisPosition_VALUE;
2769 double fCrossingPos = 0.0;
2770 if( rPropSet.GetProperty( eAxisPos, EXC_CHPROP_CROSSOVERPOSITION ) && rPropSet.GetProperty( fCrossingPos, EXC_CHPROP_CROSSOVERVALUE ) )
2771 {
2772 switch( eAxisPos )
2773 {
2774 case cssc::ChartAxisPosition_ZERO:
2775 case cssc::ChartAxisPosition_START:
2776 ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOCROSS );
2777 break;
2778 case cssc::ChartAxisPosition_END:
2779 ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_MAXCROSS );
2780 break;
2781 case cssc::ChartAxisPosition_VALUE:
2782 ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOCROSS, false );
2783 maData.mfCross = ::get_flagvalue< double >( maData.mnFlags, EXC_CHVALUERANGE_LOGSCALE, log( fCrossingPos ) / log( 10.0 ), fCrossingPos );
2784 break;
2785 default:
2786 ::set_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOCROSS );
2787 }
2788 }
2789 }
2790
2791 void XclExpChValueRange::WriteBody( XclExpStream& rStrm )
2792 {
2793 rStrm << maData.mfMin
2794 << maData.mfMax
2795 << maData.mfMajorStep
2796 << maData.mfMinorStep
2797 << maData.mfCross
2798 << maData.mnFlags;
2799 }
2800
2801 namespace {
2802
2803 sal_uInt8 lclGetXclTickPos( sal_Int32 nApiTickmarks )
2804 {
2805 using namespace cssc2::TickmarkStyle;
2806 sal_uInt8 nXclTickPos = 0;
2807 ::set_flag( nXclTickPos, EXC_CHTICK_INSIDE, ::get_flag( nApiTickmarks, INNER ) );
2808 ::set_flag( nXclTickPos, EXC_CHTICK_OUTSIDE, ::get_flag( nApiTickmarks, OUTER ) );
2809 return nXclTickPos;
2810 }
2811
2812 } // namespace
2813
2814 XclExpChTick::XclExpChTick( const XclExpChRoot& rRoot ) :
2815 XclExpRecord( EXC_ID_CHTICK, (rRoot.GetBiff() == EXC_BIFF8) ? 30 : 26 ),
2816 XclExpChRoot( rRoot ),
2817 mnTextColorId( XclExpPalette::GetColorIdFromIndex( EXC_COLOR_CHWINDOWTEXT ) )
2818 {
2819 }
2820
2821 void XclExpChTick::Convert( const ScfPropertySet& rPropSet, const XclChExtTypeInfo& rTypeInfo, sal_uInt16 nAxisType )
2822 {
2823 // tick mark style
2824 sal_Int32 nApiTickmarks = 0;
2825 if( rPropSet.GetProperty( nApiTickmarks, EXC_CHPROP_MAJORTICKS ) )
2826 maData.mnMajor = lclGetXclTickPos( nApiTickmarks );
2827 if( rPropSet.GetProperty( nApiTickmarks, EXC_CHPROP_MINORTICKS ) )
2828 maData.mnMinor = lclGetXclTickPos( nApiTickmarks );
2829
2830 // axis labels
2831 if( (rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_RADAR) && (nAxisType == EXC_CHAXIS_X) )
2832 {
2833 /* Radar charts disable their category labels via chart type, not via
2834 axis, and axis labels are always 'near axis'. */
2835 maData.mnLabelPos = EXC_CHTICK_NEXT;
2836 }
2837 else if( !rPropSet.GetBoolProperty( EXC_CHPROP_DISPLAYLABELS ) )
2838 {
2839 // no labels
2840 maData.mnLabelPos = EXC_CHTICK_NOLABEL;
2841 }
2842 else if( rTypeInfo.mb3dChart && (nAxisType == EXC_CHAXIS_Y) )
2843 {
2844 // Excel expects 'near axis' at Y axes in 3D charts
2845 maData.mnLabelPos = EXC_CHTICK_NEXT;
2846 }
2847 else
2848 {
2849 cssc::ChartAxisLabelPosition eApiLabelPos = cssc::ChartAxisLabelPosition_NEAR_AXIS;
2850 rPropSet.GetProperty( eApiLabelPos, EXC_CHPROP_LABELPOSITION );
2851 switch( eApiLabelPos )
2852 {
2853 case cssc::ChartAxisLabelPosition_NEAR_AXIS:
2854 case cssc::ChartAxisLabelPosition_NEAR_AXIS_OTHER_SIDE: maData.mnLabelPos = EXC_CHTICK_NEXT; break;
2855 case cssc::ChartAxisLabelPosition_OUTSIDE_START: maData.mnLabelPos = EXC_CHTICK_LOW; break;
2856 case cssc::ChartAxisLabelPosition_OUTSIDE_END: maData.mnLabelPos = EXC_CHTICK_HIGH; break;
2857 default: maData.mnLabelPos = EXC_CHTICK_NEXT;
2858 }
2859 }
2860 }
2861
2862 void XclExpChTick::SetFontColor( const Color& rColor, sal_uInt32 nColorId )
2863 {
2864 maData.maTextColor = rColor;
2865 ::set_flag( maData.mnFlags, EXC_CHTICK_AUTOCOLOR, rColor == COL_AUTO );
2866 mnTextColorId = nColorId;
2867 }
2868
2869 void XclExpChTick::SetRotation( sal_uInt16 nRotation )
2870 {
2871 maData.mnRotation = nRotation;
2872 ::set_flag( maData.mnFlags, EXC_CHTICK_AUTOROT, false );
2873 ::insert_value( maData.mnFlags, XclTools::GetXclOrientFromRot( nRotation ), 2, 3 );
2874 }
2875
2876 void XclExpChTick::WriteBody( XclExpStream& rStrm )
2877 {
2878 rStrm << maData.mnMajor
2879 << maData.mnMinor
2880 << maData.mnLabelPos
2881 << maData.mnBackMode;
2882 rStrm.WriteZeroBytes( 16 );
2883 rStrm << maData.maTextColor
2884 << maData.mnFlags;
2885 if( GetBiff() == EXC_BIFF8 )
2886 rStrm << GetPalette().GetColorIndex( mnTextColorId ) << maData.mnRotation;
2887 }
2888
2889 namespace {
2890
2891 /** Returns an API axis object from the passed coordinate system. */
2892 Reference< XAxis > lclGetApiAxis( Reference< XCoordinateSystem > xCoordSystem,
2893 sal_Int32 nApiAxisDim, sal_Int32 nApiAxesSetIdx )
2894 {
2895 Reference< XAxis > xAxis;
2896 if( (nApiAxisDim >= 0) && xCoordSystem.is() ) try
2897 {
2898 xAxis = xCoordSystem->getAxisByDimension( nApiAxisDim, nApiAxesSetIdx );
2899 }
2900 catch( Exception& )
2901 {
2902 }
2903 return xAxis;
2904 }
2905
2906 Reference< cssc::XAxis > lclGetApiChart1Axis( Reference< XChartDocument > xChartDoc,
2907 sal_Int32 nApiAxisDim, sal_Int32 nApiAxesSetIdx )
2908 {
2909 Reference< cssc::XAxis > xChart1Axis;
2910 try
2911 {
2912 Reference< cssc::XChartDocument > xChart1Doc( xChartDoc, UNO_QUERY_THROW );
2913 Reference< cssc::XAxisSupplier > xChart1AxisSupp( xChart1Doc->getDiagram(), UNO_QUERY_THROW );
2914 switch( nApiAxesSetIdx )
2915 {
2916 case EXC_CHART_AXESSET_PRIMARY:
2917 xChart1Axis = xChart1AxisSupp->getAxis( nApiAxisDim );
2918 break;
2919 case EXC_CHART_AXESSET_SECONDARY:
2920 xChart1Axis = xChart1AxisSupp->getSecondaryAxis( nApiAxisDim );
2921 break;
2922 }
2923 }
2924 catch( Exception& )
2925 {
2926 }
2927 return xChart1Axis;
2928 }
2929
2930 } // namespace
2931
2932 XclExpChAxis::XclExpChAxis( const XclExpChRoot& rRoot, sal_uInt16 nAxisType ) :
2933 XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_AXIS, EXC_ID_CHAXIS, 18 ),
2934 mnNumFmtIdx( EXC_FORMAT_NOTFOUND )
2935 {
2936 maData.mnType = nAxisType;
2937 }
2938
2939 void XclExpChAxis::SetFont( XclExpChFontRef xFont, const Color& rColor, sal_uInt32 nColorId )
2940 {
2941 mxFont = xFont;
2942 if( mxTick )
2943 mxTick->SetFontColor( rColor, nColorId );
2944 }
2945
2946 void XclExpChAxis::SetRotation( sal_uInt16 nRotation )
2947 {
2948 if( mxTick )
2949 mxTick->SetRotation( nRotation );
2950 }
2951
2952 void XclExpChAxis::Convert( Reference< XAxis > xAxis, Reference< XAxis > xCrossingAxis,
2953 Reference< cssc::XAxis > xChart1Axis, const XclChExtTypeInfo& rTypeInfo )
2954 {
2955 ScfPropertySet aAxisProp( xAxis );
2956 bool bCategoryAxis = ((GetAxisType() == EXC_CHAXIS_X) && rTypeInfo.mbCategoryAxis) || (GetAxisType() == EXC_CHAXIS_Z);
2957
2958 // axis line format -------------------------------------------------------
2959
2960 mxAxisLine.reset( new XclExpChLineFormat( GetChRoot() ) );
2961 mxAxisLine->Convert( GetChRoot(), aAxisProp, EXC_CHOBJTYPE_AXISLINE );
2962 // #i58688# axis enabled
2963 mxAxisLine->SetShowAxis( aAxisProp.GetBoolProperty( EXC_CHPROP_SHOW ) );
2964
2965 // axis scaling and increment ---------------------------------------------
2966
2967 ScfPropertySet aCrossingProp( xCrossingAxis );
2968 if( bCategoryAxis )
2969 {
2970 mxLabelRange.reset( new XclExpChLabelRange( GetChRoot() ) );
2971 mxLabelRange->SetTicksBetweenCateg( rTypeInfo.mbTicksBetweenCateg );
2972 if( xAxis.is() )
2973 {
2974 ScfPropertySet aChart1AxisProp( xChart1Axis );
2975 // #i71684# radar charts have reversed rotation direction
2976 mxLabelRange->Convert( xAxis->getScaleData(), aChart1AxisProp, (GetAxisType() == EXC_CHAXIS_X) && (rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_RADAR) );
2977 }
2978 // get position of crossing axis on this axis from passed axis object
2979 if( aCrossingProp.Is() )
2980 mxLabelRange->ConvertAxisPosition( aCrossingProp );
2981 }
2982 else
2983 {
2984 mxValueRange.reset( new XclExpChValueRange( GetChRoot() ) );
2985 if( xAxis.is() )
2986 mxValueRange->Convert( xAxis->getScaleData() );
2987 // get position of crossing axis on this axis from passed axis object
2988 if( aCrossingProp.Is() )
2989 mxValueRange->ConvertAxisPosition( aCrossingProp );
2990 }
2991
2992 // axis caption text ------------------------------------------------------
2993
2994 // axis ticks properties
2995 mxTick.reset( new XclExpChTick( GetChRoot() ) );
2996 mxTick->Convert( aAxisProp, rTypeInfo, GetAxisType() );
2997
2998 // axis label formatting and rotation
2999 ConvertFontBase( GetChRoot(), aAxisProp );
3000 ConvertRotationBase( aAxisProp, true );
3001
3002 // axis number format
3003 sal_Int32 nApiNumFmt = 0;
3004 if( !bCategoryAxis && aAxisProp.GetProperty( nApiNumFmt, EXC_CHPROP_NUMBERFORMAT ) )
3005 mnNumFmtIdx = GetNumFmtBuffer().Insert( static_cast< sal_uInt32 >( nApiNumFmt ) );
3006
3007 // grid -------------------------------------------------------------------
3008
3009 if( xAxis.is() )
3010 {
3011 // main grid
3012 ScfPropertySet aGridProp( xAxis->getGridProperties() );
3013 if( aGridProp.GetBoolProperty( EXC_CHPROP_SHOW ) )
3014 mxMajorGrid = lclCreateLineFormat( GetChRoot(), aGridProp, EXC_CHOBJTYPE_GRIDLINE );
3015 // sub grid
3016 Sequence< Reference< XPropertySet > > aSubGridPropSeq = xAxis->getSubGridProperties();
3017 if( aSubGridPropSeq.hasElements() )
3018 {
3019 ScfPropertySet aSubGridProp( aSubGridPropSeq[ 0 ] );
3020 if( aSubGridProp.GetBoolProperty( EXC_CHPROP_SHOW ) )
3021 mxMinorGrid = lclCreateLineFormat( GetChRoot(), aSubGridProp, EXC_CHOBJTYPE_GRIDLINE );
3022 }
3023 }
3024 }
3025
3026 void XclExpChAxis::ConvertWall( css::uno::Reference< css::chart2::XDiagram > xDiagram )
3027 {
3028 if( xDiagram.is() ) switch( GetAxisType() )
3029 {
3030 case EXC_CHAXIS_X:
3031 {
3032 ScfPropertySet aWallProp( xDiagram->getWall() );
3033 mxWallFrame = lclCreateFrame( GetChRoot(), aWallProp, EXC_CHOBJTYPE_WALL3D );
3034 }
3035 break;
3036 case EXC_CHAXIS_Y:
3037 {
3038 ScfPropertySet aFloorProp( xDiagram->getFloor() );
3039 mxWallFrame = lclCreateFrame( GetChRoot(), aFloorProp, EXC_CHOBJTYPE_FLOOR3D );
3040 }
3041 break;
3042 default:
3043 mxWallFrame.reset();
3044 }
3045 }
3046
3047 void XclExpChAxis::WriteSubRecords( XclExpStream& rStrm )
3048 {
3049 lclSaveRecord( rStrm, mxLabelRange );
3050 lclSaveRecord( rStrm, mxValueRange );
3051 if( mnNumFmtIdx != EXC_FORMAT_NOTFOUND )
3052 XclExpUInt16Record( EXC_ID_CHFORMAT, mnNumFmtIdx ).Save( rStrm );
3053 lclSaveRecord( rStrm, mxTick );
3054 lclSaveRecord( rStrm, mxFont );
3055 lclSaveRecord( rStrm, mxAxisLine, EXC_ID_CHAXISLINE, EXC_CHAXISLINE_AXISLINE );
3056 lclSaveRecord( rStrm, mxMajorGrid, EXC_ID_CHAXISLINE, EXC_CHAXISLINE_MAJORGRID );
3057 lclSaveRecord( rStrm, mxMinorGrid, EXC_ID_CHAXISLINE, EXC_CHAXISLINE_MINORGRID );
3058 lclSaveRecord( rStrm, mxWallFrame, EXC_ID_CHAXISLINE, EXC_CHAXISLINE_WALLS );
3059 }
3060
3061 void XclExpChAxis::WriteBody( XclExpStream& rStrm )
3062 {
3063 rStrm << maData.mnType;
3064 rStrm.WriteZeroBytes( 16 );
3065 }
3066
3067 XclExpChAxesSet::XclExpChAxesSet( const XclExpChRoot& rRoot, sal_uInt16 nAxesSetId ) :
3068 XclExpChGroupBase( rRoot, EXC_CHFRBLOCK_TYPE_AXESSET, EXC_ID_CHAXESSET, 18 )
3069 {
3070 maData.mnAxesSetId = nAxesSetId;
3071 SetFutureRecordContext( 0, nAxesSetId );
3072
3073 /* Need to set a reasonable size for the plot area, otherwise Excel will
3074 move away embedded shapes while auto-sizing the plot area. This is just
3075 a wild guess, but will be fixed with implementing manual positioning of
3076 chart elements. */
3077 maData.maRect.mnX = 262;
3078 maData.maRect.mnY = 626;
3079 maData.maRect.mnWidth = 3187;
3080 maData.maRect.mnHeight = 2633;
3081 }
3082
3083 sal_uInt16 XclExpChAxesSet::Convert( Reference< XDiagram > xDiagram, sal_uInt16 nFirstGroupIdx )
3084 {
3085 /* First unused chart type group index is passed to be able to continue
3086 counting of chart type groups for secondary axes set. */
3087 sal_uInt16 nGroupIdx = nFirstGroupIdx;
3088 Reference< XCoordinateSystemContainer > xCoordSysCont( xDiagram, UNO_QUERY );
3089 if( xCoordSysCont.is() )
3090 {
3091 Sequence< Reference< XCoordinateSystem > > aCoordSysSeq = xCoordSysCont->getCoordinateSystems();
3092 if( aCoordSysSeq.getLength() > 0 )
3093 {
3094 /* Process first coordinate system only. Import filter puts all
3095 chart types into one coordinate system. */
3096 Reference< XCoordinateSystem > xCoordSystem = aCoordSysSeq[ 0 ];
3097 sal_Int32 nApiAxesSetIdx = GetApiAxesSetIndex();
3098
3099 // 3d mode
3100 bool b3dChart = xCoordSystem.is() && (xCoordSystem->getDimension() == 3);
3101
3102 // percent charts
3103 namespace ApiAxisType = cssc2::AxisType;
3104 Reference< XAxis > xApiYAxis = lclGetApiAxis( xCoordSystem, EXC_CHART_AXIS_Y, nApiAxesSetIdx );
3105 bool bPercent = xApiYAxis.is() && (xApiYAxis->getScaleData().AxisType == ApiAxisType::PERCENT);
3106
3107 // connector lines in bar charts
3108 ScfPropertySet aDiaProp( xDiagram );
3109 bool bConnectBars = aDiaProp.GetBoolProperty( EXC_CHPROP_CONNECTBARS );
3110
3111 // swapped axes sets
3112 ScfPropertySet aCoordSysProp( xCoordSystem );
3113 bool bSwappedAxesSet = aCoordSysProp.GetBoolProperty( EXC_CHPROP_SWAPXANDYAXIS );
3114
3115 // X axis for later use
3116 Reference< XAxis > xApiXAxis = lclGetApiAxis( xCoordSystem, EXC_CHART_AXIS_X, nApiAxesSetIdx );
3117 // X axis labels
3118 ScfPropertySet aXAxisProp( xApiXAxis );
3119 bool bHasXLabels = aXAxisProp.GetBoolProperty( EXC_CHPROP_DISPLAYLABELS );
3120
3121 // process chart types
3122 Reference< XChartTypeContainer > xChartTypeCont( xCoordSystem, UNO_QUERY );
3123 if( xChartTypeCont.is() )
3124 {
3125 Sequence< Reference< XChartType > > aChartTypeSeq = xChartTypeCont->getChartTypes();
3126 const Reference< XChartType >* pBeg = aChartTypeSeq.getConstArray();
3127 const Reference< XChartType >* pEnd = pBeg + aChartTypeSeq.getLength();
3128 for( const Reference< XChartType >* pIt = pBeg; pIt != pEnd; ++pIt )
3129 {
3130 XclExpChTypeGroupRef xTypeGroup( new XclExpChTypeGroup( GetChRoot(), nGroupIdx ) );
3131 xTypeGroup->ConvertType( xDiagram, *pIt, nApiAxesSetIdx, b3dChart, bSwappedAxesSet, bHasXLabels );
3132 /* If new chart type group cannot be inserted into a combination
3133 chart with existing type groups, insert all series into last
3134 contained chart type group instead of creating a new group. */
3135 XclExpChTypeGroupRef xLastGroup = GetLastTypeGroup();
3136 if( xLastGroup && !(xTypeGroup->IsCombinable2d() && xLastGroup->IsCombinable2d()) )
3137 {
3138 xLastGroup->ConvertSeries( xDiagram, *pIt, nApiAxesSetIdx, bPercent, bConnectBars );
3139 }
3140 else
3141 {
3142 xTypeGroup->ConvertSeries( xDiagram, *pIt, nApiAxesSetIdx, bPercent, bConnectBars );
3143 if( xTypeGroup->IsValidGroup() )
3144 {
3145 maTypeGroups.AppendRecord( xTypeGroup );
3146 ++nGroupIdx;
3147 }
3148 }
3149 }
3150 }
3151
3152 if( XclExpChTypeGroup* pGroup = GetFirstTypeGroup().get() )
3153 {
3154 const XclChExtTypeInfo& rTypeInfo = pGroup->GetTypeInfo();
3155
3156 // create axes according to chart type (no axes for pie and donut charts)
3157 if( rTypeInfo.meTypeCateg != EXC_CHTYPECATEG_PIE )
3158 {
3159 ConvertAxis( mxXAxis, EXC_CHAXIS_X, mxXAxisTitle, EXC_CHOBJLINK_XAXIS, xCoordSystem, rTypeInfo, EXC_CHART_AXIS_Y );
3160 ConvertAxis( mxYAxis, EXC_CHAXIS_Y, mxYAxisTitle, EXC_CHOBJLINK_YAXIS, xCoordSystem, rTypeInfo, EXC_CHART_AXIS_X );
3161 if( pGroup->Is3dDeepChart() )
3162 ConvertAxis( mxZAxis, EXC_CHAXIS_Z, mxZAxisTitle, EXC_CHOBJLINK_ZAXIS, xCoordSystem, rTypeInfo, EXC_CHART_AXIS_NONE );
3163 }
3164
3165 // X axis category ranges
3166 if( rTypeInfo.mbCategoryAxis && xApiXAxis.is() )
3167 {
3168 const ScaleData aScaleData = xApiXAxis->getScaleData();
3169 for( size_t nIdx = 0, nSize = maTypeGroups.GetSize(); nIdx < nSize; ++nIdx )
3170 maTypeGroups.GetRecord( nIdx )->ConvertCategSequence( aScaleData.Categories );
3171 }
3172
3173 // legend
3174 if( xDiagram.is() && (GetAxesSetId() == EXC_CHAXESSET_PRIMARY) )
3175 {
3176 Reference< XLegend > xLegend = xDiagram->getLegend();
3177 if( xLegend.is() )
3178 {
3179 ScfPropertySet aLegendProp( xLegend );
3180 pGroup->ConvertLegend( aLegendProp );
3181 }
3182 }
3183 }
3184 }
3185 }
3186
3187 // wall/floor/diagram frame formatting
3188 if( xDiagram.is() && (GetAxesSetId() == EXC_CHAXESSET_PRIMARY) )
3189 {
3190 XclExpChTypeGroupRef xTypeGroup = GetFirstTypeGroup();
3191 if( xTypeGroup && xTypeGroup->Is3dWallChart() )
3192 {
3193 // wall/floor formatting (3D charts)
3194 if( mxXAxis )
3195 mxXAxis->ConvertWall( xDiagram );
3196 if( mxYAxis )
3197 mxYAxis->ConvertWall( xDiagram );
3198 }
3199 else
3200 {
3201 // diagram background formatting
3202 ScfPropertySet aWallProp( xDiagram->getWall() );
3203 mxPlotFrame = lclCreateFrame( GetChRoot(), aWallProp, EXC_CHOBJTYPE_PLOTFRAME );
3204 }
3205 }
3206
3207 // inner and outer plot area position and size
3208 try
3209 {
3210 Reference< cssc::XChartDocument > xChart1Doc( GetChartDocument(), UNO_QUERY_THROW );
3211 Reference< cssc::XDiagramPositioning > xPositioning( xChart1Doc->getDiagram(), UNO_QUERY_THROW );
3212 // set manual flag in chart data
3213 if( !xPositioning->isAutomaticDiagramPositioning() )
3214 GetChartData().SetManualPlotArea();
3215 // the CHAXESSET record contains the inner plot area
3216 maData.maRect = CalcChartRectFromHmm( xPositioning->calculateDiagramPositionExcludingAxes() );
3217 // the embedded CHFRAMEPOS record contains the outer plot area
3218 mxFramePos.reset( new XclExpChFramePos( EXC_CHFRAMEPOS_PARENT, EXC_CHFRAMEPOS_PARENT ) );
3219 // for pie charts, always use inner plot area size to exclude the data labels as Excel does
3220 const XclExpChTypeGroup* pFirstTypeGroup = GetFirstTypeGroup().get();
3221 bool bPieChart = pFirstTypeGroup && (pFirstTypeGroup->GetTypeInfo().meTypeCateg == EXC_CHTYPECATEG_PIE);
3222 mxFramePos->GetFramePosData().maRect = bPieChart ? maData.maRect :
3223 CalcChartRectFromHmm( xPositioning->calculateDiagramPositionIncludingAxes() );
3224 }
3225 catch( Exception& )
3226 {
3227 }
3228
3229 // return first unused chart type group index for next axes set
3230 return nGroupIdx;
3231 }
3232
3233 bool XclExpChAxesSet::Is3dChart() const
3234 {
3235 XclExpChTypeGroupRef xTypeGroup = GetFirstTypeGroup();
3236 return xTypeGroup && xTypeGroup->Is3dChart();
3237 }
3238
3239 void XclExpChAxesSet::WriteSubRecords( XclExpStream& rStrm )
3240 {
3241 lclSaveRecord( rStrm, mxFramePos );
3242 lclSaveRecord( rStrm, mxXAxis );
3243 lclSaveRecord( rStrm, mxYAxis );
3244 lclSaveRecord( rStrm, mxZAxis );
3245 lclSaveRecord( rStrm, mxXAxisTitle );
3246 lclSaveRecord( rStrm, mxYAxisTitle );
3247 lclSaveRecord( rStrm, mxZAxisTitle );
3248 if( mxPlotFrame )
3249 {
3250 XclExpEmptyRecord( EXC_ID_CHPLOTFRAME ).Save( rStrm );
3251 mxPlotFrame->Save( rStrm );
3252 }
3253 maTypeGroups.Save( rStrm );
3254 }
3255
3256 XclExpChTypeGroupRef XclExpChAxesSet::GetFirstTypeGroup() const
3257 {
3258 return maTypeGroups.GetFirstRecord();
3259 }
3260
3261 XclExpChTypeGroupRef XclExpChAxesSet::GetLastTypeGroup() const
3262 {
3263 return maTypeGroups.GetLastRecord();
3264 }
3265
3266 void XclExpChAxesSet::ConvertAxis(
3267 XclExpChAxisRef& rxChAxis, sal_uInt16 nAxisType,
3268 XclExpChTextRef& rxChAxisTitle, sal_uInt16 nTitleTarget,
3269 Reference< XCoordinateSystem > xCoordSystem, const XclChExtTypeInfo& rTypeInfo,
3270 sal_Int32 nCrossingAxisDim )
3271 {
3272 // create and convert axis object
3273 rxChAxis.reset( new XclExpChAxis( GetChRoot(), nAxisType ) );
3274 sal_Int32 nApiAxisDim = rxChAxis->GetApiAxisDimension();
3275 sal_Int32 nApiAxesSetIdx = GetApiAxesSetIndex();
3276 Reference< XAxis > xAxis = lclGetApiAxis( xCoordSystem, nApiAxisDim, nApiAxesSetIdx );
3277 Reference< XAxis > xCrossingAxis = lclGetApiAxis( xCoordSystem, nCrossingAxisDim, nApiAxesSetIdx );
3278 Reference< cssc::XAxis > xChart1Axis = lclGetApiChart1Axis( GetChartDocument(), nApiAxisDim, nApiAxesSetIdx );
3279 rxChAxis->Convert( xAxis, xCrossingAxis, xChart1Axis, rTypeInfo );
3280
3281 // create and convert axis title
3282 Reference< XTitled > xTitled( xAxis, UNO_QUERY );
3283 rxChAxisTitle = lclCreateTitle( GetChRoot(), xTitled, nTitleTarget );
3284 }
3285
3286 void XclExpChAxesSet::WriteBody( XclExpStream& rStrm )
3287 {
3288 rStrm << maData.mnAxesSetId << maData.maRect;
3289 }
3290
3291 // The chart object ===========================================================
3292
3293 static void lcl_getChartSubTitle(const Reference<XChartDocument>& xChartDoc,
3294 OUString& rSubTitle)
3295 {
3296 Reference< css::chart::XChartDocument > xChartDoc1(xChartDoc, UNO_QUERY);
3297 if (!xChartDoc1.is())
3298 return;
3299
3300 Reference< XPropertySet > xProp(xChartDoc1->getSubTitle(), UNO_QUERY);
3301 if (!xProp.is())
3302 return;
3303
3304 OUString aTitle;
3305 Any any = xProp->getPropertyValue("String");
3306 if (any >>= aTitle)
3307 rSubTitle = aTitle;
3308 }
3309
3310 XclExpChChart::XclExpChChart( const XclExpRoot& rRoot,
3311 Reference< XChartDocument > xChartDoc, const Rectangle& rChartRect ) :
3312 XclExpChGroupBase( XclExpChRoot( rRoot, *this ), EXC_CHFRBLOCK_TYPE_CHART, EXC_ID_CHCHART, 16 )
3313 {
3314 Size aPtSize = OutputDevice::LogicToLogic( rChartRect.GetSize(), MapMode( MAP_100TH_MM ), MapMode( MAP_POINT ) );
3315 // rectangle is stored in 16.16 fixed-point format
3316 maRect.mnX = maRect.mnY = 0;
3317 maRect.mnWidth = static_cast< sal_Int32 >( aPtSize.Width() << 16 );
3318 maRect.mnHeight = static_cast< sal_Int32 >( aPtSize.Height() << 16 );
3319
3320 // global chart properties (default values)
3321 ::set_flag( maProps.mnFlags, EXC_CHPROPS_SHOWVISIBLEONLY, false );
3322 ::set_flag( maProps.mnFlags, EXC_CHPROPS_MANPLOTAREA );
3323 maProps.mnEmptyMode = EXC_CHPROPS_EMPTY_SKIP;
3324
3325 // always create both axes set objects
3326 mxPrimAxesSet.reset( new XclExpChAxesSet( GetChRoot(), EXC_CHAXESSET_PRIMARY ) );
3327 mxSecnAxesSet.reset( new XclExpChAxesSet( GetChRoot(), EXC_CHAXESSET_SECONDARY ) );
3328
3329 if( xChartDoc.is() )
3330 {
3331 Reference< XDiagram > xDiagram = xChartDoc->getFirstDiagram();
3332
3333 // global chart properties (only 'include hidden cells' attribute for now)
3334 ScfPropertySet aDiagramProp( xDiagram );
3335 bool bIncludeHidden = aDiagramProp.GetBoolProperty( EXC_CHPROP_INCLUDEHIDDENCELLS );
3336 ::set_flag( maProps.mnFlags, EXC_CHPROPS_SHOWVISIBLEONLY, !bIncludeHidden );
3337
3338 // initialize API conversion (remembers xChartDoc and rChartRect internally)
3339 InitConversion( xChartDoc, rChartRect );
3340
3341 // chart frame
3342 ScfPropertySet aFrameProp( xChartDoc->getPageBackground() );
3343 mxFrame = lclCreateFrame( GetChRoot(), aFrameProp, EXC_CHOBJTYPE_BACKGROUND );
3344
3345 // chart title
3346 Reference< XTitled > xTitled( xChartDoc, UNO_QUERY );
3347 OUString aSubTitle;
3348 lcl_getChartSubTitle(xChartDoc, aSubTitle);
3349 mxTitle = lclCreateTitle( GetChRoot(), xTitled, EXC_CHOBJLINK_TITLE,
3350 !aSubTitle.isEmpty() ? &aSubTitle : nullptr );
3351
3352 // diagrams (axes sets)
3353 sal_uInt16 nFreeGroupIdx = mxPrimAxesSet->Convert( xDiagram, 0 );
3354 if( !mxPrimAxesSet->Is3dChart() )
3355 mxSecnAxesSet->Convert( xDiagram, nFreeGroupIdx );
3356
3357 // treatment of missing values
3358 ScfPropertySet aDiaProp( xDiagram );
3359 sal_Int32 nMissingValues = 0;
3360 if( aDiaProp.GetProperty( nMissingValues, EXC_CHPROP_MISSINGVALUETREATMENT ) )
3361 {
3362 using namespace cssc::MissingValueTreatment;
3363 switch( nMissingValues )
3364 {
3365 case LEAVE_GAP: maProps.mnEmptyMode = EXC_CHPROPS_EMPTY_SKIP; break;
3366 case USE_ZERO: maProps.mnEmptyMode = EXC_CHPROPS_EMPTY_ZERO; break;
3367 case CONTINUE: maProps.mnEmptyMode = EXC_CHPROPS_EMPTY_INTERPOLATE; break;
3368 }
3369 }
3370
3371 // finish API conversion
3372 FinishConversion();
3373 }
3374 }
3375
3376 XclExpChSeriesRef XclExpChChart::CreateSeries()
3377 {
3378 XclExpChSeriesRef xSeries;
3379 sal_uInt16 nSeriesIdx = static_cast< sal_uInt16 >( maSeries.GetSize() );
3380 if( nSeriesIdx <= EXC_CHSERIES_MAXSERIES )
3381 {
3382 xSeries.reset( new XclExpChSeries( GetChRoot(), nSeriesIdx ) );
3383 maSeries.AppendRecord( xSeries );
3384 }
3385 return xSeries;
3386 }
3387
3388 void XclExpChChart::RemoveLastSeries()
3389 {
3390 if( !maSeries.IsEmpty() )
3391 maSeries.RemoveRecord( maSeries.GetSize() - 1 );
3392 }
3393
3394 void XclExpChChart::SetDataLabel( XclExpChTextRef xText )
3395 {
3396 if( xText )
3397 maLabels.AppendRecord( xText );
3398 }
3399
3400 void XclExpChChart::SetManualPlotArea()
3401 {
3402 // this flag does not exist in BIFF5
3403 if( GetBiff() == EXC_BIFF8 )
3404 ::set_flag( maProps.mnFlags, EXC_CHPROPS_USEMANPLOTAREA );
3405 }
3406
3407 void XclExpChChart::WriteSubRecords( XclExpStream& rStrm )
3408 {
3409 // background format
3410 lclSaveRecord( rStrm, mxFrame );
3411
3412 // data series
3413 maSeries.Save( rStrm );
3414
3415 // CHPROPERTIES record
3416 rStrm.StartRecord( EXC_ID_CHPROPERTIES, 4 );
3417 rStrm << maProps.mnFlags << maProps.mnEmptyMode << sal_uInt8( 0 );
3418 rStrm.EndRecord();
3419
3420 // axes sets (always save primary axes set)
3421 sal_uInt16 nUsedAxesSets = mxSecnAxesSet->IsValidAxesSet() ? 2 : 1;
3422 XclExpUInt16Record( EXC_ID_CHUSEDAXESSETS, nUsedAxesSets ).Save( rStrm );
3423 mxPrimAxesSet->Save( rStrm );
3424 if( mxSecnAxesSet->IsValidAxesSet() )
3425 mxSecnAxesSet->Save( rStrm );
3426
3427 // chart title and data labels
3428 lclSaveRecord( rStrm, mxTitle );
3429 maLabels.Save( rStrm );
3430 }
3431
3432 void XclExpChChart::WriteBody( XclExpStream& rStrm )
3433 {
3434 rStrm << maRect;
3435 }
3436
3437 XclExpChartDrawing::XclExpChartDrawing( const XclExpRoot& rRoot,
3438 const Reference< XModel >& rxModel, const Size& rChartSize ) :
3439 XclExpRoot( rRoot )
3440 {
3441 if( (rChartSize.Width() > 0) && (rChartSize.Height() > 0) )
3442 {
3443 ScfPropertySet aPropSet( rxModel );
3444 Reference< XShapes > xShapes;
3445 if( aPropSet.GetProperty( xShapes, EXC_CHPROP_ADDITIONALSHAPES ) && xShapes.is() && (xShapes->getCount() > 0) )
3446 {
3447 /* Create a new independent object manager with own DFF stream for the
3448 DGCONTAINER, pass global manager as parent for shared usage of
3449 global DFF data (picture container etc.). */
3450 mxObjMgr.reset( new XclExpEmbeddedObjectManager( GetObjectManager(), rChartSize, EXC_CHART_TOTALUNITS, EXC_CHART_TOTALUNITS ) );
3451 // initialize the drawing object list
3452 mxObjMgr->StartSheet();
3453 // process the draw page (convert all shapes)
3454 mxObjRecs = mxObjMgr->ProcessDrawing( xShapes );
3455 // finalize the DFF stream
3456 mxObjMgr->EndDocument();
3457 }
3458 }
3459 }
3460
3461 XclExpChartDrawing::~XclExpChartDrawing()
3462 {
3463 }
3464
3465 void XclExpChartDrawing::Save( XclExpStream& rStrm )
3466 {
3467 if( mxObjRecs )
3468 mxObjRecs->Save( rStrm );
3469 }
3470
3471 XclExpChart::XclExpChart( const XclExpRoot& rRoot, Reference< XModel > xModel, const Rectangle& rChartRect ) :
3472 XclExpSubStream( EXC_BOF_CHART ),
3473 XclExpRoot( rRoot )
3474 {
3475 AppendNewRecord( new XclExpChartPageSettings( rRoot ) );
3476 AppendNewRecord( new XclExpBoolRecord( EXC_ID_PROTECT, false ) );
3477 AppendNewRecord( new XclExpChartDrawing( rRoot, xModel, rChartRect.GetSize() ) );
3478 AppendNewRecord( new XclExpUInt16Record( EXC_ID_CHUNITS, EXC_CHUNITS_TWIPS ) );
3479
3480 Reference< XChartDocument > xChartDoc( xModel, UNO_QUERY );
3481 AppendNewRecord( new XclExpChChart( rRoot, xChartDoc, rChartRect ) );
3482 }
3483
3484 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE