xref: /aoo41x/main/sc/source/filter/excel/xichart.cxx (revision 0e620359)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sc.hxx"
26 
27 #include "xichart.hxx"
28 
29 #include <algorithm>
30 #include <memory>
31 
32 #include <com/sun/star/frame/XModel.hpp>
33 #include <com/sun/star/drawing/Direction3D.hpp>
34 #include <com/sun/star/drawing/ProjectionMode.hpp>
35 #include <com/sun/star/drawing/ShadeMode.hpp>
36 #include <com/sun/star/drawing/XShape.hpp>
37 #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
38 #include <com/sun/star/chart/ChartAxisArrangeOrderType.hpp>
39 #include <com/sun/star/chart/ChartAxisLabelPosition.hpp>
40 #include <com/sun/star/chart/ChartAxisMarkPosition.hpp>
41 #include <com/sun/star/chart/ChartAxisPosition.hpp>
42 #include <com/sun/star/chart/ChartLegendExpansion.hpp>
43 #include <com/sun/star/chart/TimeInterval.hpp>
44 #include <com/sun/star/chart/TimeUnit.hpp>
45 #include <com/sun/star/chart/XChartDocument.hpp>
46 #include <com/sun/star/chart/XDiagramPositioning.hpp>
47 #include <com/sun/star/chart2/XChartDocument.hpp>
48 #include <com/sun/star/chart2/XDiagram.hpp>
49 #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
50 #include <com/sun/star/chart2/XChartTypeContainer.hpp>
51 #include <com/sun/star/chart2/XDataSeriesContainer.hpp>
52 #include <com/sun/star/chart2/XRegressionCurveContainer.hpp>
53 #include <com/sun/star/chart2/XTitled.hpp>
54 #include <com/sun/star/chart2/data/XDataProvider.hpp>
55 #include <com/sun/star/chart2/data/XDataReceiver.hpp>
56 #include <com/sun/star/chart2/data/XDataSink.hpp>
57 #include <com/sun/star/chart2/AxisType.hpp>
58 #include <com/sun/star/chart2/CurveStyle.hpp>
59 #include <com/sun/star/chart2/DataPointGeometry3D.hpp>
60 #include <com/sun/star/chart2/DataPointLabel.hpp>
61 #include <com/sun/star/chart2/LegendPosition.hpp>
62 #include <com/sun/star/chart2/StackingDirection.hpp>
63 #include <com/sun/star/chart2/TickmarkStyle.hpp>
64 #include <com/sun/star/chart2/RelativePosition.hpp>
65 #include <com/sun/star/chart2/RelativeSize.hpp>
66 #include <com/sun/star/chart/DataLabelPlacement.hpp>
67 #include <com/sun/star/chart/ErrorBarStyle.hpp>
68 #include <com/sun/star/chart/MissingValueTreatment.hpp>
69 
70 #include <sfx2/objsh.hxx>
71 #include <svx/svdpage.hxx>
72 #include <svx/unoapi.hxx>
73 
74 #include "document.hxx"
75 #include "drwlayer.hxx"
76 #include "rangeutl.hxx"
77 #include "tokenarray.hxx"
78 #include "token.hxx"
79 #include "compiler.hxx"
80 #include "reftokenhelper.hxx"
81 #include "chartlis.hxx"
82 #include "fprogressbar.hxx"
83 #include "xltracer.hxx"
84 #include "xistream.hxx"
85 #include "xiformula.hxx"
86 #include "xistyle.hxx"
87 #include "xipage.hxx"
88 #include "xiview.hxx"
89 
90 using ::rtl::OUString;
91 using ::rtl::OUStringBuffer;
92 using ::com::sun::star::uno::Any;
93 using ::com::sun::star::uno::Reference;
94 using ::com::sun::star::uno::Sequence;
95 using ::com::sun::star::uno::UNO_QUERY;
96 using ::com::sun::star::uno::UNO_QUERY_THROW;
97 using ::com::sun::star::uno::UNO_SET_THROW;
98 using ::com::sun::star::uno::Exception;
99 using ::com::sun::star::beans::XPropertySet;
100 using ::com::sun::star::lang::XMultiServiceFactory;
101 using ::com::sun::star::frame::XModel;
102 using ::com::sun::star::util::XNumberFormatsSupplier;
103 using ::com::sun::star::drawing::XDrawPage;
104 using ::com::sun::star::drawing::XDrawPageSupplier;
105 using ::com::sun::star::drawing::XShape;
106 
107 using ::com::sun::star::chart2::IncrementData;
108 using ::com::sun::star::chart2::RelativePosition;
109 using ::com::sun::star::chart2::RelativeSize;
110 using ::com::sun::star::chart2::ScaleData;
111 using ::com::sun::star::chart2::SubIncrement;
112 using ::com::sun::star::chart2::XAxis;
113 using ::com::sun::star::chart2::XChartDocument;
114 using ::com::sun::star::chart2::XChartType;
115 using ::com::sun::star::chart2::XChartTypeContainer;
116 using ::com::sun::star::chart2::XCoordinateSystem;
117 using ::com::sun::star::chart2::XCoordinateSystemContainer;
118 using ::com::sun::star::chart2::XDataSeries;
119 using ::com::sun::star::chart2::XDataSeriesContainer;
120 using ::com::sun::star::chart2::XDiagram;
121 using ::com::sun::star::chart2::XFormattedString;
122 using ::com::sun::star::chart2::XLegend;
123 using ::com::sun::star::chart2::XRegressionCurve;
124 using ::com::sun::star::chart2::XRegressionCurveContainer;
125 using ::com::sun::star::chart2::XScaling;
126 using ::com::sun::star::chart2::XTitle;
127 using ::com::sun::star::chart2::XTitled;
128 
129 using ::com::sun::star::chart2::data::XDataProvider;
130 using ::com::sun::star::chart2::data::XDataReceiver;
131 using ::com::sun::star::chart2::data::XDataSequence;
132 using ::com::sun::star::chart2::data::XDataSink;
133 using ::com::sun::star::chart2::data::XLabeledDataSequence;
134 
135 using ::formula::FormulaToken;
136 using ::formula::StackVar;
137 
138 namespace cssc = ::com::sun::star::chart;
139 namespace cssc2 = ::com::sun::star::chart2;
140 
141 // Helpers ====================================================================
142 
143 namespace {
144 
operator >>(XclImpStream & rStrm,XclChRectangle & rRect)145 XclImpStream& operator>>( XclImpStream& rStrm, XclChRectangle& rRect )
146 {
147     return rStrm >> rRect.mnX >> rRect.mnY >> rRect.mnWidth >> rRect.mnHeight;
148 }
149 
lclSetValueOrClearAny(Any & rAny,double fValue,bool bClear)150 inline void lclSetValueOrClearAny( Any& rAny, double fValue, bool bClear )
151 {
152     if( bClear )
153         rAny.clear();
154     else
155         rAny <<= fValue;
156 }
157 
lclSetExpValueOrClearAny(Any & rAny,double fValue,bool bLogScale,bool bClear)158 void lclSetExpValueOrClearAny( Any& rAny, double fValue, bool bLogScale, bool bClear )
159 {
160     if( !bClear && bLogScale )
161         fValue = pow( 10.0, fValue );
162     lclSetValueOrClearAny( rAny, fValue, bClear );
163 }
164 
lclGetSerialDay(const XclImpRoot & rRoot,sal_uInt16 nValue,sal_uInt16 nTimeUnit)165 double lclGetSerialDay( const XclImpRoot& rRoot, sal_uInt16 nValue, sal_uInt16 nTimeUnit )
166 {
167     switch( nTimeUnit )
168     {
169         case EXC_CHDATERANGE_DAYS:
170             return nValue;
171         case EXC_CHDATERANGE_MONTHS:
172             return rRoot.GetDoubleFromDateTime( Date( 1, static_cast< sal_uInt16 >( 1 + nValue % 12 ), static_cast< sal_uInt16 >( rRoot.GetBaseYear() + nValue / 12 ) ) );
173         case EXC_CHDATERANGE_YEARS:
174             return rRoot.GetDoubleFromDateTime( Date( 1, 1, static_cast< sal_uInt16 >( rRoot.GetBaseYear() + nValue ) ) );
175         default:
176             OSL_ENSURE( false, "lclGetSerialDay - unexpected time unit" );
177     }
178     return nValue;
179 }
180 
lclConvertTimeValue(const XclImpRoot & rRoot,Any & rAny,sal_uInt16 nValue,bool bAuto,sal_uInt16 nTimeUnit)181 void lclConvertTimeValue( const XclImpRoot& rRoot, Any& rAny, sal_uInt16 nValue, bool bAuto, sal_uInt16 nTimeUnit )
182 {
183     if( bAuto )
184         rAny.clear();
185     else
186         rAny <<= lclGetSerialDay( rRoot, nValue, nTimeUnit );
187 }
188 
lclGetApiTimeUnit(sal_uInt16 nTimeUnit)189 sal_Int32 lclGetApiTimeUnit( sal_uInt16 nTimeUnit )
190 {
191     switch( nTimeUnit )
192     {
193         case EXC_CHDATERANGE_DAYS:      return cssc::TimeUnit::DAY;
194         case EXC_CHDATERANGE_MONTHS:    return cssc::TimeUnit::MONTH;
195         case EXC_CHDATERANGE_YEARS:     return cssc::TimeUnit::YEAR;
196         default:                        OSL_ENSURE( false, "lclGetApiTimeUnit - unexpected time unit" );
197     }
198     return cssc::TimeUnit::DAY;
199 }
200 
lclConvertTimeInterval(Any & rInterval,sal_uInt16 nValue,bool bAuto,sal_uInt16 nTimeUnit)201 void lclConvertTimeInterval( Any& rInterval, sal_uInt16 nValue, bool bAuto, sal_uInt16 nTimeUnit )
202 {
203     if( bAuto || (nValue == 0) )
204         rInterval.clear();
205     else
206         rInterval <<= cssc::TimeInterval( nValue, lclGetApiTimeUnit( nTimeUnit ) );
207 }
208 
209 } // namespace
210 
211 // Common =====================================================================
212 
213 /** Stores global data needed in various classes of the Chart import filter. */
214 struct XclImpChRootData : public XclChRootData
215 {
216     XclImpChChart&      mrChartData;            /// The chart data object.
217 
XclImpChRootDataXclImpChRootData218     inline explicit     XclImpChRootData( XclImpChChart& rChartData ) : mrChartData( rChartData ) {}
219 };
220 
221 // ----------------------------------------------------------------------------
222 
XclImpChRoot(const XclImpRoot & rRoot,XclImpChChart & rChartData)223 XclImpChRoot::XclImpChRoot( const XclImpRoot& rRoot, XclImpChChart& rChartData ) :
224     XclImpRoot( rRoot ),
225     mxChData( new XclImpChRootData( rChartData ) )
226 {
227 }
228 
~XclImpChRoot()229 XclImpChRoot::~XclImpChRoot()
230 {
231 }
232 
GetChartData() const233 XclImpChChart& XclImpChRoot::GetChartData() const
234 {
235     return mxChData->mrChartData;
236 }
237 
GetChartTypeInfo(XclChTypeId eType) const238 const XclChTypeInfo& XclImpChRoot::GetChartTypeInfo( XclChTypeId eType ) const
239 {
240     return mxChData->mxTypeInfoProv->GetTypeInfo( eType );
241 }
242 
GetChartTypeInfo(sal_uInt16 nRecId) const243 const XclChTypeInfo& XclImpChRoot::GetChartTypeInfo( sal_uInt16 nRecId ) const
244 {
245     return mxChData->mxTypeInfoProv->GetTypeInfoFromRecId( nRecId );
246 }
247 
GetFormatInfo(XclChObjectType eObjType) const248 const XclChFormatInfo& XclImpChRoot::GetFormatInfo( XclChObjectType eObjType ) const
249 {
250     return mxChData->mxFmtInfoProv->GetFormatInfo( eObjType );
251 }
252 
GetFontAutoColor() const253 Color XclImpChRoot::GetFontAutoColor() const
254 {
255     return GetPalette().GetColor( EXC_COLOR_CHWINDOWTEXT );
256 }
257 
GetSeriesLineAutoColor(sal_uInt16 nFormatIdx) const258 Color XclImpChRoot::GetSeriesLineAutoColor( sal_uInt16 nFormatIdx ) const
259 {
260     return GetPalette().GetColor( XclChartHelper::GetSeriesLineAutoColorIdx( nFormatIdx ) );
261 }
262 
GetSeriesFillAutoColor(sal_uInt16 nFormatIdx) const263 Color XclImpChRoot::GetSeriesFillAutoColor( sal_uInt16 nFormatIdx ) const
264 {
265     const XclImpPalette& rPal = GetPalette();
266     Color aColor = rPal.GetColor( XclChartHelper::GetSeriesFillAutoColorIdx( nFormatIdx ) );
267     sal_uInt8 nTrans = XclChartHelper::GetSeriesFillAutoTransp( nFormatIdx );
268     return ScfTools::GetMixedColor( aColor, rPal.GetColor( EXC_COLOR_CHWINDOWBACK ), nTrans );
269 }
270 
InitConversion(Reference<XChartDocument> xChartDoc,const Rectangle & rChartRect) const271 void XclImpChRoot::InitConversion( Reference< XChartDocument > xChartDoc, const Rectangle& rChartRect ) const
272 {
273     // create formatting object tables
274     mxChData->InitConversion( GetRoot(), xChartDoc, rChartRect );
275 
276     // lock the model to suppress any internal updates
277     Reference< XModel > xModel( xChartDoc, UNO_QUERY );
278     if( xModel.is() )
279         xModel->lockControllers();
280 
281     SfxObjectShell* pDocShell = GetDocShell();
282     Reference< XDataReceiver > xDataRec( xChartDoc, UNO_QUERY );
283     if( pDocShell && xDataRec.is() )
284     {
285         // create and register a data provider
286         Reference< XDataProvider > xDataProv(
287             ScfApiHelper::CreateInstance( pDocShell, SERVICE_CHART2_DATAPROVIDER ), UNO_QUERY );
288         if( xDataProv.is() )
289             xDataRec->attachDataProvider( xDataProv );
290         // attach the number formatter
291         Reference< XNumberFormatsSupplier > xNumFmtSupp( pDocShell->GetModel(), UNO_QUERY );
292         if( xNumFmtSupp.is() )
293             xDataRec->attachNumberFormatsSupplier( xNumFmtSupp );
294     }
295 }
296 
FinishConversion(XclImpDffConverter & rDffConv) const297 void XclImpChRoot::FinishConversion( XclImpDffConverter& rDffConv ) const
298 {
299     rDffConv.Progress( EXC_CHART_PROGRESS_SIZE );
300     // unlock the model
301     Reference< XModel > xModel( mxChData->mxChartDoc, UNO_QUERY );
302     if( xModel.is() )
303         xModel->unlockControllers();
304     rDffConv.Progress( EXC_CHART_PROGRESS_SIZE );
305 
306     mxChData->FinishConversion();
307 }
308 
GetDataProvider() const309 Reference< XDataProvider > XclImpChRoot::GetDataProvider() const
310 {
311     return mxChData->mxChartDoc->getDataProvider();
312 }
313 
GetTitleShape(const XclChTextKey & rTitleKey) const314 Reference< XShape > XclImpChRoot::GetTitleShape( const XclChTextKey& rTitleKey ) const
315 {
316     return mxChData->GetTitleShape( rTitleKey );
317 }
318 
CalcHmmFromChartX(sal_Int32 nPosX) const319 sal_Int32 XclImpChRoot::CalcHmmFromChartX( sal_Int32 nPosX ) const
320 {
321     return static_cast< sal_Int32 >( mxChData->mfUnitSizeX * nPosX + mxChData->mnBorderGapX + 0.5 );
322 }
323 
CalcHmmFromChartY(sal_Int32 nPosY) const324 sal_Int32 XclImpChRoot::CalcHmmFromChartY( sal_Int32 nPosY ) const
325 {
326     return static_cast< sal_Int32 >( mxChData->mfUnitSizeY * nPosY + mxChData->mnBorderGapY + 0.5 );
327 }
328 
CalcHmmFromChartRect(const XclChRectangle & rRect) const329 ::com::sun::star::awt::Rectangle XclImpChRoot::CalcHmmFromChartRect( const XclChRectangle& rRect ) const
330 {
331     return ::com::sun::star::awt::Rectangle(
332         CalcHmmFromChartX( rRect.mnX ),
333         CalcHmmFromChartY( rRect.mnY ),
334         CalcHmmFromChartX( rRect.mnWidth ),
335         CalcHmmFromChartY( rRect.mnHeight ) );
336 }
337 
CalcRelativeFromHmmX(sal_Int32 nPosX) const338 double XclImpChRoot::CalcRelativeFromHmmX( sal_Int32 nPosX ) const
339 {
340     return static_cast< double >( nPosX ) / mxChData->maChartRect.GetWidth();
341 }
342 
CalcRelativeFromHmmY(sal_Int32 nPosY) const343 double XclImpChRoot::CalcRelativeFromHmmY( sal_Int32 nPosY ) const
344 {
345     return static_cast< double >( nPosY ) / mxChData->maChartRect.GetHeight();
346 }
347 
CalcRelativeFromChartX(sal_Int32 nPosX) const348 double XclImpChRoot::CalcRelativeFromChartX( sal_Int32 nPosX ) const
349 {
350     return CalcRelativeFromHmmX( CalcHmmFromChartX( nPosX ) );
351 }
352 
CalcRelativeFromChartY(sal_Int32 nPosY) const353 double XclImpChRoot::CalcRelativeFromChartY( sal_Int32 nPosY ) const
354 {
355     return CalcRelativeFromHmmY( CalcHmmFromChartY( nPosY ) );
356 }
357 
ConvertLineFormat(ScfPropertySet & rPropSet,const XclChLineFormat & rLineFmt,XclChPropertyMode ePropMode) const358 void XclImpChRoot::ConvertLineFormat( ScfPropertySet& rPropSet,
359         const XclChLineFormat& rLineFmt, XclChPropertyMode ePropMode ) const
360 {
361     GetChartPropSetHelper().WriteLineProperties(
362         rPropSet, *mxChData->mxLineDashTable, rLineFmt, ePropMode );
363 }
364 
ConvertAreaFormat(ScfPropertySet & rPropSet,const XclChAreaFormat & rAreaFmt,XclChPropertyMode ePropMode) const365 void XclImpChRoot::ConvertAreaFormat( ScfPropertySet& rPropSet,
366         const XclChAreaFormat& rAreaFmt, XclChPropertyMode ePropMode ) const
367 {
368     GetChartPropSetHelper().WriteAreaProperties( rPropSet, rAreaFmt, ePropMode );
369 }
370 
ConvertEscherFormat(ScfPropertySet & rPropSet,const XclChEscherFormat & rEscherFmt,const XclChPicFormat * pPicFmt,sal_uInt32 nDffFillType,XclChPropertyMode ePropMode) const371 void XclImpChRoot::ConvertEscherFormat( ScfPropertySet& rPropSet,
372         const XclChEscherFormat& rEscherFmt, const XclChPicFormat* pPicFmt,
373         sal_uInt32 nDffFillType, XclChPropertyMode ePropMode ) const
374 {
375     GetChartPropSetHelper().WriteEscherProperties( rPropSet,
376         *mxChData->mxGradientTable, *mxChData->mxHatchTable, *mxChData->mxBitmapTable,
377         rEscherFmt, pPicFmt, nDffFillType, ePropMode );
378 }
379 
ConvertFont(ScfPropertySet & rPropSet,sal_uInt16 nFontIdx,const Color * pFontColor) const380 void XclImpChRoot::ConvertFont( ScfPropertySet& rPropSet,
381         sal_uInt16 nFontIdx, const Color* pFontColor ) const
382 {
383     GetFontBuffer().WriteFontProperties( rPropSet, EXC_FONTPROPSET_CHART, nFontIdx, pFontColor );
384 }
385 
ConvertPieRotation(ScfPropertySet & rPropSet,sal_uInt16 nAngle)386 void XclImpChRoot::ConvertPieRotation( ScfPropertySet& rPropSet, sal_uInt16 nAngle )
387 {
388     sal_Int32 nApiRot = (450 - (nAngle % 360)) % 360;
389     rPropSet.SetProperty( EXC_CHPROP_STARTINGANGLE, nApiRot );
390 }
391 
392 // ----------------------------------------------------------------------------
393 
~XclImpChGroupBase()394 XclImpChGroupBase::~XclImpChGroupBase()
395 {
396 }
397 
ReadRecordGroup(XclImpStream & rStrm)398 void XclImpChGroupBase::ReadRecordGroup( XclImpStream& rStrm )
399 {
400     // read contents of the header record
401     ReadHeaderRecord( rStrm );
402 
403     // only read sub records, if the next record is a CHBEGIN
404     if( rStrm.GetNextRecId() == EXC_ID_CHBEGIN )
405     {
406         // read the CHBEGIN record, may be used for special initial processing
407         rStrm.StartNextRecord();
408         ReadSubRecord( rStrm );
409 
410         // read the nested records
411         bool bLoop = true;
412         while( bLoop && rStrm.StartNextRecord() )
413         {
414             sal_uInt16 nRecId = rStrm.GetRecId();
415             bLoop = nRecId != EXC_ID_CHEND;
416             // skip unsupported nested blocks
417             if( nRecId == EXC_ID_CHBEGIN )
418                 SkipBlock( rStrm );
419             else
420                 ReadSubRecord( rStrm );
421         }
422     }
423     /*  Returns with current CHEND record or unchanged stream, if no record
424         group present. In every case another call to StartNextRecord() will go
425         to next record of interest. */
426 }
427 
SkipBlock(XclImpStream & rStrm)428 void XclImpChGroupBase::SkipBlock( XclImpStream& rStrm )
429 {
430     DBG_ASSERT( rStrm.GetRecId() == EXC_ID_CHBEGIN, "XclImpChGroupBase::SkipBlock - no CHBEGIN record" );
431     // do nothing if current record is not CHBEGIN
432     bool bLoop = rStrm.GetRecId() == EXC_ID_CHBEGIN;
433     while( bLoop && rStrm.StartNextRecord() )
434     {
435         sal_uInt16 nRecId = rStrm.GetRecId();
436         bLoop = nRecId != EXC_ID_CHEND;
437         // skip nested record groups
438         if( nRecId == EXC_ID_CHBEGIN )
439             SkipBlock( rStrm );
440     }
441 }
442 
443 // Frame formatting ===========================================================
444 
ReadChFramePos(XclImpStream & rStrm)445 void XclImpChFramePos::ReadChFramePos( XclImpStream& rStrm )
446 {
447     rStrm >> maData.mnTLMode >> maData.mnBRMode;
448     /*  According to the spec, the upper 16 bits of all members in the
449         rectangle are unused and may contain garbage. */
450     maData.maRect.mnX = rStrm.ReadInt16(); rStrm.Ignore( 2 );
451     maData.maRect.mnY = rStrm.ReadInt16(); rStrm.Ignore( 2 );
452     maData.maRect.mnWidth = rStrm.ReadInt16(); rStrm.Ignore( 2 );
453     maData.maRect.mnHeight = rStrm.ReadInt16(); rStrm.Ignore( 2 );
454 }
455 
456 // ----------------------------------------------------------------------------
457 
ReadChLineFormat(XclImpStream & rStrm)458 void XclImpChLineFormat::ReadChLineFormat( XclImpStream& rStrm )
459 {
460     rStrm >> maData.maColor >> maData.mnPattern >> maData.mnWeight >> maData.mnFlags;
461 
462     const XclImpRoot& rRoot = rStrm.GetRoot();
463     if( rRoot.GetBiff() == EXC_BIFF8 )
464         // #116397# BIFF8: index into palette used instead of RGB data
465         maData.maColor = rRoot.GetPalette().GetColor( rStrm.ReaduInt16() );
466 }
467 
Convert(const XclImpChRoot & rRoot,ScfPropertySet & rPropSet,XclChObjectType eObjType,sal_uInt16 nFormatIdx) const468 void XclImpChLineFormat::Convert( const XclImpChRoot& rRoot,
469         ScfPropertySet& rPropSet, XclChObjectType eObjType, sal_uInt16 nFormatIdx ) const
470 {
471     const XclChFormatInfo& rFmtInfo = rRoot.GetFormatInfo( eObjType );
472     if( IsAuto() )
473     {
474         XclChLineFormat aLineFmt;
475         aLineFmt.maColor = (eObjType == EXC_CHOBJTYPE_LINEARSERIES) ?
476             rRoot.GetSeriesLineAutoColor( nFormatIdx ) :
477             rRoot.GetPalette().GetColor( rFmtInfo.mnAutoLineColorIdx );
478         aLineFmt.mnPattern = EXC_CHLINEFORMAT_SOLID;
479         aLineFmt.mnWeight = rFmtInfo.mnAutoLineWeight;
480         rRoot.ConvertLineFormat( rPropSet, aLineFmt, rFmtInfo.mePropMode );
481     }
482     else
483     {
484         rRoot.ConvertLineFormat( rPropSet, maData, rFmtInfo.mePropMode );
485     }
486 }
487 
488 // ----------------------------------------------------------------------------
489 
ReadChAreaFormat(XclImpStream & rStrm)490 void XclImpChAreaFormat::ReadChAreaFormat( XclImpStream& rStrm )
491 {
492     rStrm >> maData.maPattColor >> maData.maBackColor >> maData.mnPattern >> maData.mnFlags;
493 
494     const XclImpRoot& rRoot = rStrm.GetRoot();
495     if( rRoot.GetBiff() == EXC_BIFF8 )
496     {
497         // #116397# BIFF8: index into palette used instead of RGB data
498         const XclImpPalette& rPal = rRoot.GetPalette();
499         maData.maPattColor = rPal.GetColor( rStrm.ReaduInt16() );
500         maData.maBackColor = rPal.GetColor( rStrm.ReaduInt16());
501     }
502 }
503 
Convert(const XclImpChRoot & rRoot,ScfPropertySet & rPropSet,XclChObjectType eObjType,sal_uInt16 nFormatIdx) const504 void XclImpChAreaFormat::Convert( const XclImpChRoot& rRoot,
505         ScfPropertySet& rPropSet, XclChObjectType eObjType, sal_uInt16 nFormatIdx ) const
506 {
507     const XclChFormatInfo& rFmtInfo = rRoot.GetFormatInfo( eObjType );
508     if( IsAuto() )
509     {
510         XclChAreaFormat aAreaFmt;
511         aAreaFmt.maPattColor = (eObjType == EXC_CHOBJTYPE_FILLEDSERIES) ?
512             rRoot.GetSeriesFillAutoColor( nFormatIdx ) :
513             rRoot.GetPalette().GetColor( rFmtInfo.mnAutoPattColorIdx );
514         aAreaFmt.mnPattern = EXC_PATT_SOLID;
515         rRoot.ConvertAreaFormat( rPropSet, aAreaFmt, rFmtInfo.mePropMode );
516     }
517     else
518     {
519         rRoot.ConvertAreaFormat( rPropSet, maData, rFmtInfo.mePropMode );
520     }
521 }
522 
523 // ----------------------------------------------------------------------------
524 
XclImpChEscherFormat(const XclImpRoot & rRoot)525 XclImpChEscherFormat::XclImpChEscherFormat( const XclImpRoot& rRoot ) :
526     mnDffFillType( mso_fillSolid )
527 {
528     maData.mxItemSet.reset(
529         new SfxItemSet( rRoot.GetDoc().GetDrawLayer()->GetItemPool() ) );
530 }
531 
ReadHeaderRecord(XclImpStream & rStrm)532 void XclImpChEscherFormat::ReadHeaderRecord( XclImpStream& rStrm )
533 {
534     // read from stream - CHESCHERFORMAT uses own ID for record continuation
535     XclImpDffPropSet aPropSet( rStrm.GetRoot() );
536     rStrm.ResetRecord( true, rStrm.GetRecId() );
537     rStrm >> aPropSet;
538     // get the data
539     aPropSet.FillToItemSet( *maData.mxItemSet );
540     // get fill type from DFF property set
541     mnDffFillType = aPropSet.GetPropertyValue( DFF_Prop_fillType, mso_fillSolid );
542 }
543 
ReadSubRecord(XclImpStream & rStrm)544 void XclImpChEscherFormat::ReadSubRecord( XclImpStream& rStrm )
545 {
546     switch( rStrm.GetRecId() )
547     {
548         case EXC_ID_CHPICFORMAT:
549             rStrm >> maPicFmt.mnBmpMode;
550             rStrm.Ignore( 2 );
551             rStrm >> maPicFmt.mnFlags >> maPicFmt.mfScale;
552         break;
553     }
554 }
555 
Convert(const XclImpChRoot & rRoot,ScfPropertySet & rPropSet,XclChObjectType eObjType,bool bUsePicFmt) const556 void XclImpChEscherFormat::Convert( const XclImpChRoot& rRoot,
557         ScfPropertySet& rPropSet, XclChObjectType eObjType, bool bUsePicFmt ) const
558 {
559     const XclChFormatInfo& rFmtInfo = rRoot.GetFormatInfo( eObjType );
560     rRoot.ConvertEscherFormat( rPropSet, maData, bUsePicFmt ? &maPicFmt : 0, mnDffFillType, rFmtInfo.mePropMode );
561 }
562 
563 // ----------------------------------------------------------------------------
564 
XclImpChFrameBase(const XclChFormatInfo & rFmtInfo)565 XclImpChFrameBase::XclImpChFrameBase( const XclChFormatInfo& rFmtInfo )
566 {
567     if( rFmtInfo.mbCreateDefFrame ) switch( rFmtInfo.meDefFrameType )
568     {
569         case EXC_CHFRAMETYPE_AUTO:
570             mxLineFmt.reset( new XclImpChLineFormat );
571             if( rFmtInfo.mbIsFrame )
572                 mxAreaFmt.reset( new XclImpChAreaFormat );
573         break;
574         case EXC_CHFRAMETYPE_INVISIBLE:
575         {
576             XclChLineFormat aLineFmt;
577             ::set_flag( aLineFmt.mnFlags, EXC_CHLINEFORMAT_AUTO, false );
578             aLineFmt.mnPattern = EXC_CHLINEFORMAT_NONE;
579             mxLineFmt.reset( new XclImpChLineFormat( aLineFmt ) );
580             if( rFmtInfo.mbIsFrame )
581             {
582                 XclChAreaFormat aAreaFmt;
583                 ::set_flag( aAreaFmt.mnFlags, EXC_CHAREAFORMAT_AUTO, false );
584                 aAreaFmt.mnPattern = EXC_PATT_NONE;
585                 mxAreaFmt.reset( new XclImpChAreaFormat( aAreaFmt ) );
586             }
587         }
588         break;
589         default:
590             DBG_ERRORFILE( "XclImpChFrameBase::XclImpChFrameBase - unknown frame type" );
591     }
592 }
593 
ReadSubRecord(XclImpStream & rStrm)594 void XclImpChFrameBase::ReadSubRecord( XclImpStream& rStrm )
595 {
596     switch( rStrm.GetRecId() )
597     {
598         case EXC_ID_CHLINEFORMAT:
599             mxLineFmt.reset( new XclImpChLineFormat );
600             mxLineFmt->ReadChLineFormat( rStrm );
601         break;
602         case EXC_ID_CHAREAFORMAT:
603             mxAreaFmt.reset( new XclImpChAreaFormat );
604             mxAreaFmt->ReadChAreaFormat( rStrm );
605         break;
606         case EXC_ID_CHESCHERFORMAT:
607             mxEscherFmt.reset( new XclImpChEscherFormat( rStrm.GetRoot() ) );
608             mxEscherFmt->ReadRecordGroup( rStrm );
609         break;
610     }
611 }
612 
ConvertLineBase(const XclImpChRoot & rRoot,ScfPropertySet & rPropSet,XclChObjectType eObjType,sal_uInt16 nFormatIdx) const613 void XclImpChFrameBase::ConvertLineBase( const XclImpChRoot& rRoot,
614         ScfPropertySet& rPropSet, XclChObjectType eObjType, sal_uInt16 nFormatIdx ) const
615 {
616     if( mxLineFmt.is() )
617         mxLineFmt->Convert( rRoot, rPropSet, eObjType, nFormatIdx );
618 }
619 
ConvertAreaBase(const XclImpChRoot & rRoot,ScfPropertySet & rPropSet,XclChObjectType eObjType,sal_uInt16 nFormatIdx,bool bUsePicFmt) const620 void XclImpChFrameBase::ConvertAreaBase( const XclImpChRoot& rRoot,
621         ScfPropertySet& rPropSet, XclChObjectType eObjType, sal_uInt16 nFormatIdx, bool bUsePicFmt ) const
622 {
623     if( rRoot.GetFormatInfo( eObjType ).mbIsFrame )
624     {
625         // CHESCHERFORMAT overrides CHAREAFORMAT (even if it is auto)
626         if( mxEscherFmt.is() )
627             mxEscherFmt->Convert( rRoot, rPropSet, eObjType, bUsePicFmt );
628         else if( mxAreaFmt.is() )
629             mxAreaFmt->Convert( rRoot, rPropSet, eObjType, nFormatIdx );
630     }
631 }
632 
ConvertFrameBase(const XclImpChRoot & rRoot,ScfPropertySet & rPropSet,XclChObjectType eObjType,sal_uInt16 nFormatIdx,bool bUsePicFmt) const633 void XclImpChFrameBase::ConvertFrameBase( const XclImpChRoot& rRoot,
634         ScfPropertySet& rPropSet, XclChObjectType eObjType, sal_uInt16 nFormatIdx, bool bUsePicFmt ) const
635 {
636     ConvertLineBase( rRoot, rPropSet, eObjType, nFormatIdx );
637     ConvertAreaBase( rRoot, rPropSet, eObjType, nFormatIdx, bUsePicFmt );
638 }
639 
640 // ----------------------------------------------------------------------------
641 
XclImpChFrame(const XclImpChRoot & rRoot,XclChObjectType eObjType)642 XclImpChFrame::XclImpChFrame( const XclImpChRoot& rRoot, XclChObjectType eObjType ) :
643     XclImpChFrameBase( rRoot.GetFormatInfo( eObjType ) ),
644     XclImpChRoot( rRoot ),
645     meObjType( eObjType )
646 {
647 }
648 
ReadHeaderRecord(XclImpStream & rStrm)649 void XclImpChFrame::ReadHeaderRecord( XclImpStream& rStrm )
650 {
651     rStrm >> maData.mnFormat >> maData.mnFlags;
652 }
653 
UpdateObjFrame(const XclObjLineData & rLineData,const XclObjFillData & rFillData)654 void XclImpChFrame::UpdateObjFrame( const XclObjLineData& rLineData, const XclObjFillData& rFillData )
655 {
656     const XclImpPalette& rPal = GetPalette();
657 
658     if( rLineData.IsVisible() && (!mxLineFmt || !mxLineFmt->HasLine()) )
659     {
660         // line formatting
661         XclChLineFormat aLineFmt;
662         aLineFmt.maColor = rPal.GetColor( rLineData.mnColorIdx );
663         switch( rLineData.mnStyle )
664         {
665             case EXC_OBJ_LINE_SOLID:        aLineFmt.mnPattern = EXC_CHLINEFORMAT_SOLID;        break;
666             case EXC_OBJ_LINE_DASH:         aLineFmt.mnPattern = EXC_CHLINEFORMAT_DASH;         break;
667             case EXC_OBJ_LINE_DOT:          aLineFmt.mnPattern = EXC_CHLINEFORMAT_DOT;          break;
668             case EXC_OBJ_LINE_DASHDOT:      aLineFmt.mnPattern = EXC_CHLINEFORMAT_DASHDOT;      break;
669             case EXC_OBJ_LINE_DASHDOTDOT:   aLineFmt.mnPattern = EXC_CHLINEFORMAT_DASHDOTDOT;   break;
670             case EXC_OBJ_LINE_MEDTRANS:     aLineFmt.mnPattern = EXC_CHLINEFORMAT_MEDTRANS;     break;
671             case EXC_OBJ_LINE_DARKTRANS:    aLineFmt.mnPattern = EXC_CHLINEFORMAT_DARKTRANS;    break;
672             case EXC_OBJ_LINE_LIGHTTRANS:   aLineFmt.mnPattern = EXC_CHLINEFORMAT_LIGHTTRANS;   break;
673             case EXC_OBJ_LINE_NONE:         aLineFmt.mnPattern = EXC_CHLINEFORMAT_NONE;         break;
674             default:                        aLineFmt.mnPattern = EXC_CHLINEFORMAT_SOLID;
675         }
676         switch( rLineData.mnWidth )
677         {
678             case EXC_OBJ_LINE_HAIR:     aLineFmt.mnWeight = EXC_CHLINEFORMAT_HAIR;      break;
679             case EXC_OBJ_LINE_THIN:     aLineFmt.mnWeight = EXC_CHLINEFORMAT_SINGLE;    break;
680             case EXC_OBJ_LINE_MEDIUM:   aLineFmt.mnWeight = EXC_CHLINEFORMAT_DOUBLE;    break;
681             case EXC_OBJ_LINE_THICK:    aLineFmt.mnWeight = EXC_CHLINEFORMAT_TRIPLE;    break;
682             default:                    aLineFmt.mnWeight = EXC_CHLINEFORMAT_HAIR;
683         }
684         ::set_flag( aLineFmt.mnFlags, EXC_CHLINEFORMAT_AUTO, rLineData.IsAuto() );
685         mxLineFmt.reset( new XclImpChLineFormat( aLineFmt ) );
686     }
687 
688     if( rFillData.IsFilled() && (!mxAreaFmt || !mxAreaFmt->HasArea()) && !mxEscherFmt )
689     {
690         // area formatting
691         XclChAreaFormat aAreaFmt;
692         aAreaFmt.maPattColor = rPal.GetColor( rFillData.mnPattColorIdx );
693         aAreaFmt.maBackColor = rPal.GetColor( rFillData.mnBackColorIdx );
694         aAreaFmt.mnPattern = rFillData.mnPattern;
695         ::set_flag( aAreaFmt.mnFlags, EXC_CHAREAFORMAT_AUTO, rFillData.IsAuto() );
696         mxAreaFmt.reset( new XclImpChAreaFormat( aAreaFmt ) );
697     }
698 }
699 
Convert(ScfPropertySet & rPropSet,bool bUsePicFmt) const700 void XclImpChFrame::Convert( ScfPropertySet& rPropSet, bool bUsePicFmt ) const
701 {
702     ConvertFrameBase( GetChRoot(), rPropSet, meObjType, EXC_CHDATAFORMAT_UNKNOWN, bUsePicFmt );
703 }
704 
705 // Source links ===============================================================
706 
707 namespace {
708 
709 /** Creates a labeled data sequence object, adds link for series title if present. */
lclCreateLabeledDataSequence(XclImpChSourceLinkRef xValueLink,const OUString & rValueRole,const XclImpChSourceLink * pTitleLink=0)710 Reference< XLabeledDataSequence > lclCreateLabeledDataSequence(
711         XclImpChSourceLinkRef xValueLink, const OUString& rValueRole,
712         const XclImpChSourceLink* pTitleLink = 0 )
713 {
714     // create data sequence for values and title
715     Reference< XDataSequence > xValueSeq;
716     if( xValueLink.is() )
717         xValueSeq = xValueLink->CreateDataSequence( rValueRole );
718     Reference< XDataSequence > xTitleSeq;
719     if( pTitleLink )
720         xTitleSeq = pTitleLink->CreateDataSequence( EXC_CHPROP_ROLE_LABEL );
721 
722     // create the labeled data sequence, if values or title are present
723     Reference< XLabeledDataSequence > xLabeledSeq;
724     if( xValueSeq.is() || xTitleSeq.is() )
725         xLabeledSeq.set( ScfApiHelper::CreateInstance( SERVICE_CHART2_LABELEDDATASEQ ), UNO_QUERY );
726     if( xLabeledSeq.is() )
727     {
728         if( xValueSeq.is() )
729             xLabeledSeq->setValues( xValueSeq );
730         if( xTitleSeq.is() )
731             xLabeledSeq->setLabel( xTitleSeq );
732     }
733     return xLabeledSeq;
734 }
735 
736 } // namespace
737 
738 // ----------------------------------------------------------------------------
739 
XclImpChSourceLink(const XclImpChRoot & rRoot)740 XclImpChSourceLink::XclImpChSourceLink( const XclImpChRoot& rRoot ) :
741     XclImpChRoot( rRoot )
742 {
743 }
744 
~XclImpChSourceLink()745 XclImpChSourceLink::~XclImpChSourceLink()
746 {
747 }
748 
ReadChSourceLink(XclImpStream & rStrm)749 void XclImpChSourceLink::ReadChSourceLink( XclImpStream& rStrm )
750 {
751     rStrm   >> maData.mnDestType
752             >> maData.mnLinkType
753             >> maData.mnFlags
754             >> maData.mnNumFmtIdx;
755 
756     mxTokenArray.reset();
757     if( GetLinkType() == EXC_CHSRCLINK_WORKSHEET )
758     {
759         // read token array
760         XclTokenArray aXclTokArr;
761         rStrm >> aXclTokArr;
762 
763         // convert BIFF formula tokens to Calc token array
764         if( const ScTokenArray* pTokens = GetFormulaCompiler().CreateFormula( EXC_FMLATYPE_CHART, aXclTokArr ) )
765             mxTokenArray.reset( pTokens->Clone() );
766     }
767 
768     // try to read a following CHSTRING record
769     if( (rStrm.GetNextRecId() == EXC_ID_CHSTRING) && rStrm.StartNextRecord() )
770     {
771         mxString.reset( new XclImpString );
772         rStrm.Ignore( 2 );
773         mxString->Read( rStrm, EXC_STR_8BITLENGTH | EXC_STR_SEPARATEFORMATS );
774     }
775 }
776 
SetString(const String & rString)777 void XclImpChSourceLink::SetString( const String& rString )
778 {
779     if( !mxString )
780         mxString.reset( new XclImpString );
781     mxString->SetText( rString );
782 }
783 
SetTextFormats(const XclFormatRunVec & rFormats)784 void XclImpChSourceLink::SetTextFormats( const XclFormatRunVec& rFormats )
785 {
786     if( mxString.is() )
787         mxString->SetFormats( rFormats );
788 }
789 
GetCellCount() const790 sal_uInt16 XclImpChSourceLink::GetCellCount() const
791 {
792     sal_uInt32 nCellCount = 0;
793     if( mxTokenArray.is() )
794     {
795         mxTokenArray->Reset();
796         for( const FormulaToken* pToken = mxTokenArray->First(); pToken; pToken = mxTokenArray->Next() )
797         {
798             switch( pToken->GetType() )
799             {
800                 case ::formula::svSingleRef:
801                 case ::formula::svExternalSingleRef:
802                     // single cell
803                     ++nCellCount;
804                 break;
805                 case ::formula::svDoubleRef:
806                 case ::formula::svExternalDoubleRef:
807                 {
808                     // cell range
809                     const ScComplexRefData& rComplexRef = static_cast< const ScToken* >( pToken )->GetDoubleRef();
810                     const ScSingleRefData& rRef1 = rComplexRef.Ref1;
811                     const ScSingleRefData& rRef2 = rComplexRef.Ref2;
812                     sal_uInt32 nTabs = static_cast< sal_uInt32 >( rRef2.nTab - rRef1.nTab + 1 );
813                     sal_uInt32 nCols = static_cast< sal_uInt32 >( rRef2.nCol - rRef1.nCol + 1 );
814                     sal_uInt32 nRows = static_cast< sal_uInt32 >( rRef2.nRow - rRef1.nRow + 1 );
815                     nCellCount += nCols * nRows * nTabs;
816                 }
817                 break;
818                 default: ;
819             }
820         }
821     }
822     return limit_cast< sal_uInt16 >( nCellCount );
823 }
824 
ConvertNumFmt(ScfPropertySet & rPropSet,bool bPercent) const825 void XclImpChSourceLink::ConvertNumFmt( ScfPropertySet& rPropSet, bool bPercent ) const
826 {
827     bool bLinkToSource = ::get_flag( maData.mnFlags, EXC_CHSRCLINK_NUMFMT );
828     sal_uInt32 nScNumFmt = bLinkToSource ? GetNumFmtBuffer().GetScFormat( maData.mnNumFmtIdx ) : NUMBERFORMAT_ENTRY_NOT_FOUND;
829     OUString aPropName = bPercent ? EXC_CHPROP_PERCENTAGENUMFMT : EXC_CHPROP_NUMBERFORMAT;
830     if( nScNumFmt != NUMBERFORMAT_ENTRY_NOT_FOUND )
831         rPropSet.SetProperty( aPropName, static_cast< sal_Int32 >( nScNumFmt ) );
832     else
833         // restore 'link to source' at data point (series may contain manual number format)
834         rPropSet.SetAnyProperty( aPropName, Any() );
835 }
836 
CreateDataSequence(const OUString & rRole) const837 Reference< XDataSequence > XclImpChSourceLink::CreateDataSequence( const OUString& rRole ) const
838 {
839     Reference< XDataSequence > xDataSeq;
840     Reference< XDataProvider > xDataProv = GetDataProvider();
841     if( xDataProv.is() && mxTokenArray.is() )
842     {
843         ScCompiler aComp( GetDocPtr(), ScAddress(), *mxTokenArray );
844         aComp.SetGrammar( ::formula::FormulaGrammar::GRAM_ENGLISH );
845         OUStringBuffer aRangeRep;
846         aComp.CreateStringFromTokenArray( aRangeRep );
847         try
848         {
849             xDataSeq = xDataProv->createDataSequenceByRangeRepresentation( aRangeRep.makeStringAndClear() );
850             // set sequence role
851             ScfPropertySet aSeqProp( xDataSeq );
852             aSeqProp.SetProperty( EXC_CHPROP_ROLE, rRole );
853         }
854         catch( Exception& )
855         {
856 //            DBG_ERRORFILE( "XclImpChSourceLink::CreateDataSequence - cannot create data sequence" );
857         }
858     }
859     return xDataSeq;
860 }
861 
CreateStringSequence(const XclImpChRoot & rRoot,sal_uInt16 nLeadFontIdx,const Color & rLeadFontColor) const862 Sequence< Reference< XFormattedString > > XclImpChSourceLink::CreateStringSequence(
863         const XclImpChRoot& rRoot, sal_uInt16 nLeadFontIdx, const Color& rLeadFontColor ) const
864 {
865     ::std::vector< Reference< XFormattedString > > aStringVec;
866     if( mxString.is() )
867     {
868         for( XclImpStringIterator aIt( *mxString ); aIt.Is(); ++aIt )
869         {
870             Reference< XFormattedString > xFmtStr(
871                 ScfApiHelper::CreateInstance( SERVICE_CHART2_FORMATTEDSTRING ), UNO_QUERY );
872             if( xFmtStr.is() )
873             {
874                 // set text data
875                 xFmtStr->setString( aIt.GetPortionText() );
876 
877                 // set font formatting and font color
878                 ScfPropertySet aStringProp( xFmtStr );
879                 sal_uInt16 nFontIdx = aIt.GetPortionFont();
880                 if( (nFontIdx == EXC_FONT_NOTFOUND) && (aIt.GetPortionIndex() == 0) )
881                     // leading unformatted portion - use passed font settings
882                     rRoot.ConvertFont( aStringProp, nLeadFontIdx, &rLeadFontColor );
883                 else
884                     rRoot.ConvertFont( aStringProp, nFontIdx );
885 
886                 // add string to vector of strings
887                 aStringVec.push_back( xFmtStr );
888             }
889         }
890     }
891     return ScfApiHelper::VectorToSequence( aStringVec );
892 }
893 
FillSourceLink(::std::vector<ScSharedTokenRef> & rTokens) const894 void XclImpChSourceLink::FillSourceLink( ::std::vector< ScSharedTokenRef >& rTokens ) const
895 {
896     if( !mxTokenArray.is() )
897         // no links to fill.
898         return;
899 
900     mxTokenArray->Reset();
901     for (FormulaToken* p = mxTokenArray->First(); p; p = mxTokenArray->Next())
902     {
903         ScSharedTokenRef pToken(static_cast<ScToken*>(p->Clone()));
904         if (ScRefTokenHelper::isRef(pToken))
905             // This is a reference token.  Store it.
906             ScRefTokenHelper::join(rTokens, pToken);
907     }
908 }
909 
910 // Text =======================================================================
911 
~XclImpChFontBase()912 XclImpChFontBase::~XclImpChFontBase()
913 {
914 }
915 
ConvertFontBase(const XclImpChRoot & rRoot,ScfPropertySet & rPropSet) const916 void XclImpChFontBase::ConvertFontBase( const XclImpChRoot& rRoot, ScfPropertySet& rPropSet ) const
917 {
918     Color aFontColor = GetFontColor();
919     rRoot.ConvertFont( rPropSet, GetFontIndex(), &aFontColor );
920 }
921 
ConvertRotationBase(const XclImpChRoot & rRoot,ScfPropertySet & rPropSet,bool bSupportsStacked) const922 void XclImpChFontBase::ConvertRotationBase( const XclImpChRoot& rRoot, ScfPropertySet& rPropSet, bool bSupportsStacked ) const
923 {
924     rRoot.GetChartPropSetHelper().WriteRotationProperties( rPropSet, GetRotation(), bSupportsStacked );
925 }
926 
927 // ----------------------------------------------------------------------------
928 
XclImpChFont()929 XclImpChFont::XclImpChFont() :
930     mnFontIdx( EXC_FONT_NOTFOUND )
931 {
932 }
933 
ReadChFont(XclImpStream & rStrm)934 void XclImpChFont::ReadChFont( XclImpStream& rStrm )
935 {
936     rStrm >> mnFontIdx;
937 }
938 
939 // ----------------------------------------------------------------------------
940 
XclImpChText(const XclImpChRoot & rRoot)941 XclImpChText::XclImpChText( const XclImpChRoot& rRoot ) :
942     XclImpChRoot( rRoot )
943 {
944 }
945 
ReadHeaderRecord(XclImpStream & rStrm)946 void XclImpChText::ReadHeaderRecord( XclImpStream& rStrm )
947 {
948     rStrm   >> maData.mnHAlign
949             >> maData.mnVAlign
950             >> maData.mnBackMode
951             >> maData.maTextColor
952             >> maData.maRect
953             >> maData.mnFlags;
954 
955     if( GetBiff() == EXC_BIFF8 )
956     {
957         // #116397# BIFF8: index into palette used instead of RGB data
958         maData.maTextColor = GetPalette().GetColor( rStrm.ReaduInt16() );
959         // placement and rotation
960         rStrm >> maData.mnFlags2 >> maData.mnRotation;
961     }
962     else
963     {
964         // BIFF2-BIFF7: get rotation from text orientation
965         sal_uInt8 nOrient = ::extract_value< sal_uInt8 >( maData.mnFlags, 8, 3 );
966         maData.mnRotation = XclTools::GetXclRotFromOrient( nOrient );
967     }
968 }
969 
ReadSubRecord(XclImpStream & rStrm)970 void XclImpChText::ReadSubRecord( XclImpStream& rStrm )
971 {
972     switch( rStrm.GetRecId() )
973     {
974         case EXC_ID_CHFRAMEPOS:
975             mxFramePos.reset( new XclImpChFramePos );
976             mxFramePos->ReadChFramePos( rStrm );
977         break;
978         case EXC_ID_CHFONT:
979             mxFont.reset( new XclImpChFont );
980             mxFont->ReadChFont( rStrm );
981         break;
982         case EXC_ID_CHFORMATRUNS:
983             if( GetBiff() == EXC_BIFF8 )
984                 XclImpString::ReadFormats( rStrm, maFormats );
985         break;
986         case EXC_ID_CHSOURCELINK:
987             mxSrcLink.reset( new XclImpChSourceLink( GetChRoot() ) );
988             mxSrcLink->ReadChSourceLink( rStrm );
989         break;
990         case EXC_ID_CHFRAME:
991             mxFrame.reset( new XclImpChFrame( GetChRoot(), EXC_CHOBJTYPE_TEXT ) );
992             mxFrame->ReadRecordGroup( rStrm );
993         break;
994         case EXC_ID_CHOBJECTLINK:
995             rStrm >> maObjLink.mnTarget >> maObjLink.maPointPos.mnSeriesIdx >> maObjLink.maPointPos.mnPointIdx;
996         break;
997         case EXC_ID_CHFRLABELPROPS:
998             ReadChFrLabelProps( rStrm );
999         break;
1000         case EXC_ID_CHEND:
1001             if( mxSrcLink.is() && !maFormats.empty() )
1002                 mxSrcLink->SetTextFormats( maFormats );
1003         break;
1004     }
1005 }
1006 
GetFontIndex() const1007 sal_uInt16 XclImpChText::GetFontIndex() const
1008 {
1009     return mxFont.is() ? mxFont->GetFontIndex() : EXC_FONT_NOTFOUND;
1010 }
1011 
GetFontColor() const1012 Color XclImpChText::GetFontColor() const
1013 {
1014     return ::get_flag( maData.mnFlags, EXC_CHTEXT_AUTOCOLOR ) ? GetFontAutoColor() : maData.maTextColor;
1015 }
1016 
GetRotation() const1017 sal_uInt16 XclImpChText::GetRotation() const
1018 {
1019     return maData.mnRotation;
1020 }
1021 
SetString(const String & rString)1022 void XclImpChText::SetString( const String& rString )
1023 {
1024     if( !mxSrcLink )
1025         mxSrcLink.reset( new XclImpChSourceLink( GetChRoot() ) );
1026     mxSrcLink->SetString( rString );
1027 }
1028 
UpdateText(const XclImpChText * pParentText)1029 void XclImpChText::UpdateText( const XclImpChText* pParentText )
1030 {
1031     if( pParentText )
1032     {
1033         // update missing members
1034         if( !mxFrame )
1035             mxFrame = pParentText->mxFrame;
1036         if( !mxFont )
1037         {
1038             mxFont = pParentText->mxFont;
1039             // text color is taken from CHTEXT record, not from font in CHFONT
1040             ::set_flag( maData.mnFlags, EXC_CHTEXT_AUTOCOLOR, ::get_flag( pParentText->maData.mnFlags, EXC_CHTEXT_AUTOCOLOR ) );
1041             maData.maTextColor = pParentText->maData.maTextColor;
1042         }
1043     }
1044 }
1045 
UpdateDataLabel(bool bCateg,bool bValue,bool bPercent)1046 void XclImpChText::UpdateDataLabel( bool bCateg, bool bValue, bool bPercent )
1047 {
1048     ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWCATEG,     bCateg );
1049     ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWVALUE,     bValue );
1050     ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWPERCENT,   bPercent );
1051     ::set_flag( maData.mnFlags, EXC_CHTEXT_SHOWCATEGPERC, bCateg && bPercent );
1052     ::set_flag( maData.mnFlags, EXC_CHTEXT_DELETED,       !bCateg && !bValue && !bPercent );
1053 }
1054 
ConvertFont(ScfPropertySet & rPropSet) const1055 void XclImpChText::ConvertFont( ScfPropertySet& rPropSet ) const
1056 {
1057     ConvertFontBase( GetChRoot(), rPropSet );
1058 }
1059 
ConvertRotation(ScfPropertySet & rPropSet,bool bSupportsStacked) const1060 void XclImpChText::ConvertRotation( ScfPropertySet& rPropSet, bool bSupportsStacked ) const
1061 {
1062     ConvertRotationBase( GetChRoot(), rPropSet, bSupportsStacked );
1063 }
1064 
ConvertFrame(ScfPropertySet & rPropSet) const1065 void XclImpChText::ConvertFrame( ScfPropertySet& rPropSet ) const
1066 {
1067     if( mxFrame.is() )
1068         mxFrame->Convert( rPropSet );
1069 }
1070 
ConvertNumFmt(ScfPropertySet & rPropSet,bool bPercent) const1071 void XclImpChText::ConvertNumFmt( ScfPropertySet& rPropSet, bool bPercent ) const
1072 {
1073     if( mxSrcLink.is() )
1074         mxSrcLink->ConvertNumFmt( rPropSet, bPercent );
1075 }
1076 
ConvertDataLabel(ScfPropertySet & rPropSet,const XclChTypeInfo & rTypeInfo) const1077 void XclImpChText::ConvertDataLabel( ScfPropertySet& rPropSet, const XclChTypeInfo& rTypeInfo ) const
1078 {
1079     // existing CHFRLABELPROPS record wins over flags from CHTEXT
1080     sal_uInt16 nShowFlags = mxLabelProps.is() ? mxLabelProps->mnFlags : maData.mnFlags;
1081     sal_uInt16 SHOWANYCATEG   = mxLabelProps.is() ? EXC_CHFRLABELPROPS_SHOWCATEG : (EXC_CHTEXT_SHOWCATEGPERC | EXC_CHTEXT_SHOWCATEG);
1082     sal_uInt16 SHOWANYVALUE   = mxLabelProps.is() ? EXC_CHFRLABELPROPS_SHOWVALUE : EXC_CHTEXT_SHOWVALUE;
1083     sal_uInt16 SHOWANYPERCENT = mxLabelProps.is() ? EXC_CHFRLABELPROPS_SHOWPERCENT : (EXC_CHTEXT_SHOWPERCENT | EXC_CHTEXT_SHOWCATEGPERC);
1084     sal_uInt16 SHOWANYBUBBLE  = mxLabelProps.is() ? EXC_CHFRLABELPROPS_SHOWBUBBLE : EXC_CHTEXT_SHOWBUBBLE;
1085 
1086     // get raw flags for label values
1087     bool bShowNone    = IsDeleted();
1088     bool bShowCateg   = !bShowNone && ::get_flag( nShowFlags, SHOWANYCATEG );
1089     bool bShowPercent = !bShowNone && ::get_flag( nShowFlags, SHOWANYPERCENT );
1090     bool bShowValue   = !bShowNone && ::get_flag( nShowFlags, SHOWANYVALUE );
1091     bool bShowBubble  = !bShowNone && ::get_flag( nShowFlags, SHOWANYBUBBLE );
1092 
1093     // adjust to Chart2 behaviour
1094     if( rTypeInfo.meTypeId == EXC_CHTYPEID_BUBBLES )
1095          bShowValue = bShowBubble;  // Chart2 bubble charts show bubble size if 'ShowValue' is set
1096 
1097     // other flags
1098     bool bShowAny = bShowValue || bShowPercent || bShowCateg;
1099     bool bShowSymbol = bShowAny && ::get_flag( maData.mnFlags, EXC_CHTEXT_SHOWSYMBOL );
1100 
1101     // create API struct for label values, set API label separator
1102     cssc2::DataPointLabel aPointLabel( bShowValue, bShowPercent, bShowCateg, bShowSymbol );
1103     rPropSet.SetProperty( EXC_CHPROP_LABEL, aPointLabel );
1104     String aSep = mxLabelProps.is() ? mxLabelProps->maSeparator : String( sal_Unicode( '\n' ) );
1105     if( aSep.Len() == 0 )
1106         aSep = CREATE_STRING( "; " );
1107     rPropSet.SetStringProperty( EXC_CHPROP_LABELSEPARATOR, aSep );
1108 
1109     // text properties of attached label
1110     if( bShowAny )
1111     {
1112         ConvertFont( rPropSet );
1113         ConvertRotation( rPropSet, false );
1114         // label placement
1115         using namespace cssc::DataLabelPlacement;
1116         sal_Int32 nPlacement = rTypeInfo.mnDefaultLabelPos;
1117         switch( ::extract_value< sal_uInt16 >( maData.mnFlags2, 0, 4 ) )
1118         {
1119             case EXC_CHTEXT_POS_DEFAULT:    nPlacement = rTypeInfo.mnDefaultLabelPos;   break;
1120             case EXC_CHTEXT_POS_OUTSIDE:    nPlacement = OUTSIDE;                       break;
1121             case EXC_CHTEXT_POS_INSIDE:     nPlacement = INSIDE;                        break;
1122             case EXC_CHTEXT_POS_CENTER:     nPlacement = CENTER;                        break;
1123             case EXC_CHTEXT_POS_AXIS:       nPlacement = NEAR_ORIGIN;                   break;
1124             case EXC_CHTEXT_POS_ABOVE:      nPlacement = TOP;                           break;
1125             case EXC_CHTEXT_POS_BELOW:      nPlacement = BOTTOM;                        break;
1126             case EXC_CHTEXT_POS_LEFT:       nPlacement = LEFT;                          break;
1127             case EXC_CHTEXT_POS_RIGHT:      nPlacement = RIGHT;                         break;
1128             case EXC_CHTEXT_POS_AUTO:       nPlacement = AVOID_OVERLAP;                 break;
1129         }
1130         rPropSet.SetProperty( EXC_CHPROP_LABELPLACEMENT, nPlacement );
1131         // label number format (percentage format wins over value format)
1132         if( bShowPercent || bShowValue )
1133             ConvertNumFmt( rPropSet, bShowPercent );
1134     }
1135 }
1136 
CreateTitle() const1137 Reference< XTitle > XclImpChText::CreateTitle() const
1138 {
1139     Reference< XTitle > xTitle;
1140     if( mxSrcLink.is() && mxSrcLink->HasString() )
1141     {
1142         // create the formatted strings
1143         Sequence< Reference< XFormattedString > > aStringSeq(
1144             mxSrcLink->CreateStringSequence( GetChRoot(), GetFontIndex(), GetFontColor() ) );
1145         if( aStringSeq.hasElements() )
1146         {
1147             // create the title object
1148             xTitle.set( ScfApiHelper::CreateInstance( SERVICE_CHART2_TITLE ), UNO_QUERY );
1149             if( xTitle.is() )
1150             {
1151                 // set the formatted strings
1152                 xTitle->setText( aStringSeq );
1153                 // more title formatting properties
1154                 ScfPropertySet aTitleProp( xTitle );
1155                 ConvertFrame( aTitleProp );
1156                 ConvertRotation( aTitleProp, true );
1157             }
1158         }
1159     }
1160     return xTitle;
1161 }
1162 
ConvertTitlePosition(const XclChTextKey & rTitleKey) const1163 void XclImpChText::ConvertTitlePosition( const XclChTextKey& rTitleKey ) const
1164 {
1165     if( !mxFramePos ) return;
1166 
1167     const XclChFramePos& rPosData = mxFramePos->GetFramePosData();
1168     OSL_ENSURE( (rPosData.mnTLMode == EXC_CHFRAMEPOS_PARENT) && (rPosData.mnBRMode == EXC_CHFRAMEPOS_PARENT),
1169         "XclImpChText::ConvertTitlePosition - unexpected frame position mode" );
1170 
1171     /*  Check if title is moved manually. To get the actual position of the
1172         title, we do some kind of hack and use the values from the CHTEXT
1173         record, effectively ignoring the contents of the CHFRAMEPOS record
1174         which contains the position relative to the default title position
1175         (according to the spec, the CHFRAMEPOS supersedes the CHTEXT record).
1176         Especially when it comes to axis titles, things would become very
1177         complicated here, because the relative title position is stored in a
1178         measurement unit that is dependent on the size of the inner plot area,
1179         the interpretation of the X and Y coordinate is dependent on the
1180         direction of the axis, and in 3D charts, and the title default
1181         positions are dependent on the 3D view settings (rotation, elevation,
1182         and perspective). Thus, it is easier to assume that the creator has
1183         written out the correct absolute position and size of the title in the
1184         CHTEXT record. This is assured by checking that the shape size stored
1185         in the CHTEXT record is non-zero. */
1186     if( (rPosData.mnTLMode == EXC_CHFRAMEPOS_PARENT) &&
1187         ((rPosData.maRect.mnX != 0) || (rPosData.maRect.mnY != 0)) &&
1188         (maData.maRect.mnWidth > 0) && (maData.maRect.mnHeight > 0) ) try
1189     {
1190         Reference< XShape > xTitleShape( GetTitleShape( rTitleKey ), UNO_SET_THROW );
1191         // the call to XShape.getSize() may recalc the chart view
1192         ::com::sun::star::awt::Size aTitleSize = xTitleShape->getSize();
1193         // rotated titles need special handling...
1194         sal_Int32 nScRot = XclTools::GetScRotation( GetRotation(), 0 );
1195         double fRad = nScRot * F_PI18000;
1196         double fSin = fabs( sin( fRad ) );
1197         double fCos = fabs( cos( fRad ) );
1198         ::com::sun::star::awt::Size aBoundSize(
1199             static_cast< sal_Int32 >( fCos * aTitleSize.Width + fSin * aTitleSize.Height + 0.5 ),
1200             static_cast< sal_Int32 >( fSin * aTitleSize.Width + fCos * aTitleSize.Height + 0.5 ) );
1201         // calculate the title position from the values in the CHTEXT record
1202         ::com::sun::star::awt::Point aTitlePos(
1203             CalcHmmFromChartX( maData.maRect.mnX ),
1204             CalcHmmFromChartY( maData.maRect.mnY ) );
1205         // add part of height to X direction, if title is rotated down (clockwise)
1206         if( nScRot > 18000 )
1207             aTitlePos.X += static_cast< sal_Int32 >( fSin * aTitleSize.Height + 0.5 );
1208         // add part of width to Y direction, if title is rotated up (counterclockwise)
1209         else if( nScRot > 0 )
1210             aTitlePos.Y += static_cast< sal_Int32 >( fSin * aTitleSize.Width + 0.5 );
1211         // set the resulting position at the title shape
1212         xTitleShape->setPosition( aTitlePos );
1213     }
1214     catch( Exception& )
1215     {
1216     }
1217 }
1218 
ReadChFrLabelProps(XclImpStream & rStrm)1219 void XclImpChText::ReadChFrLabelProps( XclImpStream& rStrm )
1220 {
1221     if( GetBiff() == EXC_BIFF8 )
1222     {
1223         mxLabelProps.reset( new XclChFrLabelProps );
1224         sal_uInt16 nSepLen;
1225         rStrm.Ignore( 12 );
1226         rStrm >> mxLabelProps->mnFlags >> nSepLen;
1227         if( nSepLen > 0 )
1228             mxLabelProps->maSeparator = rStrm.ReadUniString( nSepLen );
1229     }
1230 }
1231 
1232 namespace {
1233 
lclUpdateText(XclImpChTextRef & rxText,XclImpChTextRef xDefText)1234 void lclUpdateText( XclImpChTextRef& rxText, XclImpChTextRef xDefText )
1235 {
1236     if( rxText.is() )
1237         rxText->UpdateText( xDefText.get() );
1238     else
1239         rxText = xDefText;
1240 }
1241 
lclFinalizeTitle(XclImpChTextRef & rxTitle,XclImpChTextRef xDefText,const String & rAutoTitle)1242 void lclFinalizeTitle( XclImpChTextRef& rxTitle, XclImpChTextRef xDefText, const String& rAutoTitle )
1243 {
1244     /*  Do not update a title, if it is not visible (if rxTitle is null).
1245         Existing reference indicates enabled title. */
1246     if( rxTitle.is() )
1247     {
1248         if( !rxTitle->HasString() )
1249             rxTitle->SetString( rAutoTitle );
1250         if( rxTitle->HasString() )
1251             rxTitle->UpdateText( xDefText.get() );
1252         else
1253             rxTitle.reset();
1254     }
1255 }
1256 
1257 } // namespace
1258 
1259 // Data series ================================================================
1260 
ReadChMarkerFormat(XclImpStream & rStrm)1261 void XclImpChMarkerFormat::ReadChMarkerFormat( XclImpStream& rStrm )
1262 {
1263     rStrm >> maData.maLineColor >> maData.maFillColor >> maData.mnMarkerType >> maData.mnFlags;
1264 
1265     const XclImpRoot& rRoot = rStrm.GetRoot();
1266     if( rRoot.GetBiff() == EXC_BIFF8 )
1267     {
1268         // #116397# BIFF8: index into palette used instead of RGB data
1269         const XclImpPalette& rPal = rRoot.GetPalette();
1270         maData.maLineColor = rPal.GetColor( rStrm.ReaduInt16() );
1271         maData.maFillColor = rPal.GetColor( rStrm.ReaduInt16() );
1272         // marker size
1273         rStrm >> maData.mnMarkerSize;
1274     }
1275 }
1276 
Convert(const XclImpChRoot & rRoot,ScfPropertySet & rPropSet,sal_uInt16 nFormatIdx,sal_Int16 nLineWeight) const1277 void XclImpChMarkerFormat::Convert( const XclImpChRoot& rRoot,
1278         ScfPropertySet& rPropSet, sal_uInt16 nFormatIdx, sal_Int16 nLineWeight ) const
1279 {
1280     if( IsAuto() )
1281     {
1282         XclChMarkerFormat aMarkerFmt;
1283         // line and fill color of the symbol are equal to series line color
1284         //! TODO: Excel sets no fill color for specific symbols (e.g. cross)
1285         aMarkerFmt.maLineColor = aMarkerFmt.maFillColor = rRoot.GetSeriesLineAutoColor( nFormatIdx );
1286         switch( nLineWeight )
1287         {
1288             case EXC_CHLINEFORMAT_HAIR:     aMarkerFmt.mnMarkerSize = EXC_CHMARKERFORMAT_HAIRSIZE;      break;
1289             case EXC_CHLINEFORMAT_SINGLE:   aMarkerFmt.mnMarkerSize = EXC_CHMARKERFORMAT_SINGLESIZE;    break;
1290             case EXC_CHLINEFORMAT_DOUBLE:   aMarkerFmt.mnMarkerSize = EXC_CHMARKERFORMAT_DOUBLESIZE;    break;
1291             case EXC_CHLINEFORMAT_TRIPLE:   aMarkerFmt.mnMarkerSize = EXC_CHMARKERFORMAT_TRIPLESIZE;    break;
1292             default:                        aMarkerFmt.mnMarkerSize = EXC_CHMARKERFORMAT_SINGLESIZE;
1293         }
1294         aMarkerFmt.mnMarkerType = XclChartHelper::GetAutoMarkerType( nFormatIdx );
1295         rRoot.GetChartPropSetHelper().WriteMarkerProperties( rPropSet, aMarkerFmt );
1296     }
1297     else
1298     {
1299         rRoot.GetChartPropSetHelper().WriteMarkerProperties( rPropSet, maData );
1300     }
1301 }
1302 
ConvertColor(const XclImpChRoot & rRoot,ScfPropertySet & rPropSet,sal_uInt16 nFormatIdx) const1303 void XclImpChMarkerFormat::ConvertColor( const XclImpChRoot& rRoot,
1304         ScfPropertySet& rPropSet, sal_uInt16 nFormatIdx ) const
1305 {
1306     Color aLineColor = IsAuto() ? rRoot.GetSeriesLineAutoColor( nFormatIdx ) : maData.maFillColor;
1307     rPropSet.SetColorProperty( EXC_CHPROP_COLOR, aLineColor );
1308 }
1309 
1310 // ----------------------------------------------------------------------------
1311 
XclImpChPieFormat()1312 XclImpChPieFormat::XclImpChPieFormat() :
1313     mnPieDist( 0 )
1314 {
1315 }
1316 
ReadChPieFormat(XclImpStream & rStrm)1317 void XclImpChPieFormat::ReadChPieFormat( XclImpStream& rStrm )
1318 {
1319     rStrm >> mnPieDist;
1320 }
1321 
Convert(ScfPropertySet & rPropSet) const1322 void XclImpChPieFormat::Convert( ScfPropertySet& rPropSet ) const
1323 {
1324     double fApiDist = ::std::min< double >( mnPieDist / 100.0, 1.0 );
1325     rPropSet.SetProperty( EXC_CHPROP_OFFSET, fApiDist );
1326 }
1327 
1328 // ----------------------------------------------------------------------------
1329 
XclImpChSeriesFormat()1330 XclImpChSeriesFormat::XclImpChSeriesFormat() :
1331     mnFlags( 0 )
1332 {
1333 }
1334 
ReadChSeriesFormat(XclImpStream & rStrm)1335 void XclImpChSeriesFormat::ReadChSeriesFormat( XclImpStream& rStrm )
1336 {
1337     rStrm >> mnFlags;
1338 }
1339 
1340 // ----------------------------------------------------------------------------
1341 
ReadCh3dDataFormat(XclImpStream & rStrm)1342 void XclImpCh3dDataFormat::ReadCh3dDataFormat( XclImpStream& rStrm )
1343 {
1344     rStrm >> maData.mnBase >> maData.mnTop;
1345 }
1346 
Convert(ScfPropertySet & rPropSet) const1347 void XclImpCh3dDataFormat::Convert( ScfPropertySet& rPropSet ) const
1348 {
1349     using namespace ::com::sun::star::chart2::DataPointGeometry3D;
1350     sal_Int32 nApiType = (maData.mnBase == EXC_CH3DDATAFORMAT_RECT) ?
1351         ((maData.mnTop == EXC_CH3DDATAFORMAT_STRAIGHT) ? CUBOID : PYRAMID) :
1352         ((maData.mnTop == EXC_CH3DDATAFORMAT_STRAIGHT) ? CYLINDER : CONE);
1353     rPropSet.SetProperty( EXC_CHPROP_GEOMETRY3D, nApiType );
1354 }
1355 
1356 // ----------------------------------------------------------------------------
1357 
XclImpChAttachedLabel(const XclImpChRoot & rRoot)1358 XclImpChAttachedLabel::XclImpChAttachedLabel( const XclImpChRoot& rRoot ) :
1359     XclImpChRoot( rRoot ),
1360     mnFlags( 0 )
1361 {
1362 }
1363 
ReadChAttachedLabel(XclImpStream & rStrm)1364 void XclImpChAttachedLabel::ReadChAttachedLabel( XclImpStream& rStrm )
1365 {
1366     rStrm >> mnFlags;
1367 }
1368 
CreateDataLabel(XclImpChTextRef xParent) const1369 XclImpChTextRef XclImpChAttachedLabel::CreateDataLabel( XclImpChTextRef xParent ) const
1370 {
1371     const sal_uInt16 EXC_CHATTLABEL_SHOWANYVALUE = EXC_CHATTLABEL_SHOWVALUE;
1372     const sal_uInt16 EXC_CHATTLABEL_SHOWANYPERCENT = EXC_CHATTLABEL_SHOWPERCENT | EXC_CHATTLABEL_SHOWCATEGPERC;
1373     const sal_uInt16 EXC_CHATTLABEL_SHOWANYCATEG = EXC_CHATTLABEL_SHOWCATEG | EXC_CHATTLABEL_SHOWCATEGPERC;
1374 
1375     XclImpChTextRef xLabel( xParent.is() ? new XclImpChText( *xParent ) : new XclImpChText( GetChRoot() ) );
1376     xLabel->UpdateDataLabel(
1377         ::get_flag( mnFlags, EXC_CHATTLABEL_SHOWANYCATEG ),
1378         ::get_flag( mnFlags, EXC_CHATTLABEL_SHOWANYVALUE ),
1379         ::get_flag( mnFlags, EXC_CHATTLABEL_SHOWANYPERCENT ) );
1380     return xLabel;
1381 }
1382 
1383 // ----------------------------------------------------------------------------
1384 
XclImpChDataFormat(const XclImpChRoot & rRoot)1385 XclImpChDataFormat::XclImpChDataFormat( const XclImpChRoot& rRoot ) :
1386     XclImpChRoot( rRoot )
1387 {
1388 }
1389 
ReadHeaderRecord(XclImpStream & rStrm)1390 void XclImpChDataFormat::ReadHeaderRecord( XclImpStream& rStrm )
1391 {
1392     rStrm   >> maData.maPointPos.mnPointIdx
1393             >> maData.maPointPos.mnSeriesIdx
1394             >> maData.mnFormatIdx
1395             >> maData.mnFlags;
1396 }
1397 
ReadSubRecord(XclImpStream & rStrm)1398 void XclImpChDataFormat::ReadSubRecord( XclImpStream& rStrm )
1399 {
1400     switch( rStrm.GetRecId() )
1401     {
1402         case EXC_ID_CHMARKERFORMAT:
1403             mxMarkerFmt.reset( new XclImpChMarkerFormat );
1404             mxMarkerFmt->ReadChMarkerFormat( rStrm );
1405         break;
1406         case EXC_ID_CHPIEFORMAT:
1407             mxPieFmt.reset( new XclImpChPieFormat );
1408             mxPieFmt->ReadChPieFormat( rStrm );
1409         break;
1410         case EXC_ID_CHSERIESFORMAT:
1411             mxSeriesFmt.reset( new XclImpChSeriesFormat );
1412             mxSeriesFmt->ReadChSeriesFormat( rStrm );
1413         break;
1414         case EXC_ID_CH3DDATAFORMAT:
1415             mx3dDataFmt.reset( new XclImpCh3dDataFormat );
1416             mx3dDataFmt->ReadCh3dDataFormat( rStrm );
1417         break;
1418         case EXC_ID_CHATTACHEDLABEL:
1419             mxAttLabel.reset( new XclImpChAttachedLabel( GetChRoot() ) );
1420             mxAttLabel->ReadChAttachedLabel( rStrm );
1421         break;
1422         default:
1423             XclImpChFrameBase::ReadSubRecord( rStrm );
1424     }
1425 }
1426 
SetPointPos(const XclChDataPointPos & rPointPos,sal_uInt16 nFormatIdx)1427 void XclImpChDataFormat::SetPointPos( const XclChDataPointPos& rPointPos, sal_uInt16 nFormatIdx )
1428 {
1429     maData.maPointPos = rPointPos;
1430     maData.mnFormatIdx = nFormatIdx;
1431 }
1432 
UpdateGroupFormat(const XclChExtTypeInfo & rTypeInfo)1433 void XclImpChDataFormat::UpdateGroupFormat( const XclChExtTypeInfo& rTypeInfo )
1434 {
1435     // remove formats not used for the current chart type
1436     RemoveUnusedFormats( rTypeInfo );
1437 }
1438 
UpdateSeriesFormat(const XclChExtTypeInfo & rTypeInfo,const XclImpChDataFormat * pGroupFmt)1439 void XclImpChDataFormat::UpdateSeriesFormat( const XclChExtTypeInfo& rTypeInfo, const XclImpChDataFormat* pGroupFmt )
1440 {
1441     // update missing formats from passed chart type group format
1442     if( pGroupFmt )
1443     {
1444         if( !mxLineFmt )
1445             mxLineFmt = pGroupFmt->mxLineFmt;
1446         if( !mxAreaFmt && !mxEscherFmt )
1447         {
1448             mxAreaFmt = pGroupFmt->mxAreaFmt;
1449             mxEscherFmt = pGroupFmt->mxEscherFmt;
1450         }
1451         if( !mxMarkerFmt )
1452             mxMarkerFmt = pGroupFmt->mxMarkerFmt;
1453         if( !mxPieFmt )
1454             mxPieFmt = pGroupFmt->mxPieFmt;
1455         if( !mxSeriesFmt )
1456             mxSeriesFmt = pGroupFmt->mxSeriesFmt;
1457         if( !mx3dDataFmt )
1458             mx3dDataFmt = pGroupFmt->mx3dDataFmt;
1459         if( !mxAttLabel )
1460             mxAttLabel = pGroupFmt->mxAttLabel;
1461     }
1462 
1463     /*  Create missing but required formats. Existing line, area, and marker
1464         format objects are needed to create automatic series formatting. */
1465     if( !mxLineFmt )
1466         mxLineFmt.reset( new XclImpChLineFormat );
1467     if( !mxAreaFmt && !mxEscherFmt )
1468         mxAreaFmt.reset( new XclImpChAreaFormat );
1469     if( !mxMarkerFmt )
1470         mxMarkerFmt.reset( new XclImpChMarkerFormat );
1471 
1472     // remove formats not used for the current chart type
1473     RemoveUnusedFormats( rTypeInfo );
1474     // update data label
1475     UpdateDataLabel( pGroupFmt );
1476 }
1477 
UpdatePointFormat(const XclChExtTypeInfo & rTypeInfo,const XclImpChDataFormat * pSeriesFmt)1478 void XclImpChDataFormat::UpdatePointFormat( const XclChExtTypeInfo& rTypeInfo, const XclImpChDataFormat* pSeriesFmt )
1479 {
1480     // remove formats if they are automatic in this and in the passed series format
1481     if( pSeriesFmt )
1482     {
1483         if( IsAutoLine() && pSeriesFmt->IsAutoLine() )
1484             mxLineFmt.reset();
1485         if( IsAutoArea() && pSeriesFmt->IsAutoArea() )
1486             mxAreaFmt.reset();
1487         if( IsAutoMarker() && pSeriesFmt->IsAutoMarker() )
1488             mxMarkerFmt.reset();
1489         mxSeriesFmt.reset();
1490     }
1491 
1492     // Excel ignores 3D bar format for single data points
1493     mx3dDataFmt.reset();
1494     // remove point line formats for linear chart types, TODO: implement in OOChart
1495     if( !rTypeInfo.IsSeriesFrameFormat() )
1496         mxLineFmt.reset();
1497 
1498     // remove formats not used for the current chart type
1499     RemoveUnusedFormats( rTypeInfo );
1500     // update data label
1501     UpdateDataLabel( pSeriesFmt );
1502 }
1503 
UpdateTrendLineFormat()1504 void XclImpChDataFormat::UpdateTrendLineFormat()
1505 {
1506     if( !mxLineFmt )
1507         mxLineFmt.reset( new XclImpChLineFormat );
1508     mxAreaFmt.reset();
1509     mxEscherFmt.reset();
1510     mxMarkerFmt.reset();
1511     mxPieFmt.reset();
1512     mxSeriesFmt.reset();
1513     mx3dDataFmt.reset();
1514     mxAttLabel.reset();
1515     // update data label
1516     UpdateDataLabel( 0 );
1517 }
1518 
Convert(ScfPropertySet & rPropSet,const XclChExtTypeInfo & rTypeInfo) const1519 void XclImpChDataFormat::Convert( ScfPropertySet& rPropSet, const XclChExtTypeInfo& rTypeInfo ) const
1520 {
1521     /*  Line and area format.
1522         #i71810# If the data points are filled with bitmaps, textures, or
1523         patterns, then only bar charts will use the CHPICFORMAT record to
1524         determine stacking/streching mode. All other chart types ignore this
1525         record and always use the property 'fill-type' from the DFF property
1526         set (streched for bitmaps, and stacked for textures and patterns). */
1527     bool bUsePicFmt = rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_BAR;
1528     ConvertFrameBase( GetChRoot(), rPropSet, rTypeInfo.GetSeriesObjectType(), maData.mnFormatIdx, bUsePicFmt );
1529 
1530 #if EXC_CHART2_3DBAR_HAIRLINES_ONLY
1531     // #i83151# only hair lines in 3D charts with filled data points
1532     if( rTypeInfo.mb3dChart && rTypeInfo.IsSeriesFrameFormat() && mxLineFmt.is() && mxLineFmt->HasLine() )
1533         rPropSet.SetProperty< sal_Int32 >( CREATE_OUSTRING( "BorderWidth" ), 0 );
1534 #endif
1535 
1536     // other formatting
1537     if( mxMarkerFmt.is() )
1538         mxMarkerFmt->Convert( GetChRoot(), rPropSet, maData.mnFormatIdx, GetLineWeight() );
1539     if( mxPieFmt.is() )
1540         mxPieFmt->Convert( rPropSet );
1541     if( mx3dDataFmt.is() )
1542         mx3dDataFmt->Convert( rPropSet );
1543     if( mxLabel.is() )
1544         mxLabel->ConvertDataLabel( rPropSet, rTypeInfo );
1545 
1546     // 3D settings
1547     rPropSet.SetProperty< sal_Int16 >( EXC_CHPROP_PERCENTDIAGONAL, 0 );
1548 
1549     /*  Special case: set marker color as line color, if series line is not
1550         visible. This makes the color visible in the marker area.
1551         TODO: remove this if OOChart supports own colors in markers. */
1552     if( !rTypeInfo.IsSeriesFrameFormat() && !HasLine() && mxMarkerFmt.is() )
1553         mxMarkerFmt->ConvertColor( GetChRoot(), rPropSet, maData.mnFormatIdx );
1554 }
1555 
ConvertLine(ScfPropertySet & rPropSet,XclChObjectType eObjType) const1556 void XclImpChDataFormat::ConvertLine( ScfPropertySet& rPropSet, XclChObjectType eObjType ) const
1557 {
1558     ConvertLineBase( GetChRoot(), rPropSet, eObjType );
1559 }
1560 
ConvertArea(ScfPropertySet & rPropSet,sal_uInt16 nFormatIdx,bool bUsePicFmt) const1561 void XclImpChDataFormat::ConvertArea( ScfPropertySet& rPropSet, sal_uInt16 nFormatIdx, bool bUsePicFmt ) const
1562 {
1563     ConvertAreaBase( GetChRoot(), rPropSet, EXC_CHOBJTYPE_FILLEDSERIES, nFormatIdx, bUsePicFmt );
1564 }
1565 
RemoveUnusedFormats(const XclChExtTypeInfo & rTypeInfo)1566 void XclImpChDataFormat::RemoveUnusedFormats( const XclChExtTypeInfo& rTypeInfo )
1567 {
1568     // data point marker only in linear 2D charts
1569     if( rTypeInfo.IsSeriesFrameFormat() )
1570         mxMarkerFmt.reset();
1571     // pie format only in pie/donut charts
1572     if( rTypeInfo.meTypeCateg != EXC_CHTYPECATEG_PIE )
1573         mxPieFmt.reset();
1574     // 3D format only in 3D bar charts
1575     if( !rTypeInfo.mb3dChart || (rTypeInfo.meTypeCateg != EXC_CHTYPECATEG_BAR) )
1576         mx3dDataFmt.reset();
1577 }
1578 
UpdateDataLabel(const XclImpChDataFormat * pParentFmt)1579 void XclImpChDataFormat::UpdateDataLabel( const XclImpChDataFormat* pParentFmt )
1580 {
1581     /*  CHTEXT groups linked to data labels override existing CHATTACHEDLABEL
1582         records. Only if there is a CHATTACHEDLABEL record without a CHTEXT
1583         group, the contents of the CHATTACHEDLABEL record are used. In this
1584         case a new CHTEXT group is created and filled with the settings from
1585         the CHATTACHEDLABEL record. */
1586     XclImpChTextRef xDefText;
1587     if( pParentFmt )
1588         xDefText = pParentFmt->GetDataLabel();
1589     if( !xDefText )
1590         xDefText = GetChartData().GetDefaultText( EXC_CHTEXTTYPE_DATALABEL );
1591     if( mxLabel.is() )
1592         mxLabel->UpdateText( xDefText.get() );
1593     else if( mxAttLabel.is() )
1594         mxLabel = mxAttLabel->CreateDataLabel( xDefText );
1595 }
1596 
1597 // ----------------------------------------------------------------------------
1598 
XclImpChSerTrendLine(const XclImpChRoot & rRoot)1599 XclImpChSerTrendLine::XclImpChSerTrendLine( const XclImpChRoot& rRoot ) :
1600     XclImpChRoot( rRoot )
1601 {
1602 }
1603 
ReadChSerTrendLine(XclImpStream & rStrm)1604 void XclImpChSerTrendLine::ReadChSerTrendLine( XclImpStream& rStrm )
1605 {
1606     rStrm   >> maData.mnLineType
1607             >> maData.mnOrder
1608             >> maData.mfIntercept
1609             >> maData.mnShowEquation
1610             >> maData.mnShowRSquared
1611             >> maData.mfForecastFor
1612             >> maData.mfForecastBack;
1613 }
1614 
CreateRegressionCurve() const1615 Reference< XRegressionCurve > XclImpChSerTrendLine::CreateRegressionCurve() const
1616 {
1617     // trend line type
1618     OUString aService;
1619     switch( maData.mnLineType )
1620     {
1621         case EXC_CHSERTREND_POLYNOMIAL:
1622             // TODO: only linear trend lines are supported by OOChart (#i20819#)
1623             if( maData.mnOrder == 1 )
1624                 aService = SERVICE_CHART2_LINEARREGCURVE;
1625         break;
1626         case EXC_CHSERTREND_EXPONENTIAL:
1627             aService = SERVICE_CHART2_EXPREGCURVE;
1628         break;
1629         case EXC_CHSERTREND_LOGARITHMIC:
1630             aService = SERVICE_CHART2_LOGREGCURVE;
1631         break;
1632         case EXC_CHSERTREND_POWER:
1633             aService = SERVICE_CHART2_POTREGCURVE;
1634         break;
1635     }
1636     Reference< XRegressionCurve > xRegCurve;
1637     if( aService.getLength() > 0 )
1638         xRegCurve.set( ScfApiHelper::CreateInstance( aService ), UNO_QUERY );
1639 
1640     // trend line formatting
1641     if( xRegCurve.is() && mxDataFmt.is() )
1642     {
1643         ScfPropertySet aPropSet( xRegCurve );
1644         mxDataFmt->ConvertLine( aPropSet, EXC_CHOBJTYPE_TRENDLINE );
1645 
1646         // #i83100# show equation and correlation coefficient
1647         ScfPropertySet aLabelProp( xRegCurve->getEquationProperties() );
1648         aLabelProp.SetBoolProperty( EXC_CHPROP_SHOWEQUATION, maData.mnShowEquation != 0 );
1649         aLabelProp.SetBoolProperty( EXC_CHPROP_SHOWCORRELATION, maData.mnShowRSquared != 0 );
1650 
1651         // #i83100# formatting of the equation text box
1652         if( const XclImpChText* pLabel = mxDataFmt->GetDataLabel().get() )
1653         {
1654             pLabel->ConvertFont( aLabelProp );
1655             pLabel->ConvertFrame( aLabelProp );
1656             pLabel->ConvertNumFmt( aLabelProp, false );
1657         }
1658     }
1659 
1660     // missing features
1661     // #i20819# polynomial trend lines
1662     // #i66819# moving average trend lines
1663     // #i5085# manual trend line size
1664     // #i34093# manual crossing point
1665 
1666     return xRegCurve;
1667 }
1668 
1669 // ----------------------------------------------------------------------------
1670 
XclImpChSerErrorBar(const XclImpChRoot & rRoot)1671 XclImpChSerErrorBar::XclImpChSerErrorBar( const XclImpChRoot& rRoot ) :
1672     XclImpChRoot( rRoot )
1673 {
1674 }
1675 
ReadChSerErrorBar(XclImpStream & rStrm)1676 void XclImpChSerErrorBar::ReadChSerErrorBar( XclImpStream& rStrm )
1677 {
1678     rStrm >> maData.mnBarType >> maData.mnSourceType >> maData.mnLineEnd;
1679     rStrm.Ignore( 1 );
1680     rStrm >> maData.mfValue >> maData.mnValueCount;
1681 }
1682 
SetSeriesData(XclImpChSourceLinkRef xValueLink,XclImpChDataFormatRef xDataFmt)1683 void XclImpChSerErrorBar::SetSeriesData( XclImpChSourceLinkRef xValueLink, XclImpChDataFormatRef xDataFmt )
1684 {
1685     mxValueLink = xValueLink;
1686     mxDataFmt = xDataFmt;
1687 }
1688 
CreateValueSequence() const1689 Reference< XLabeledDataSequence > XclImpChSerErrorBar::CreateValueSequence() const
1690 {
1691     return lclCreateLabeledDataSequence( mxValueLink, XclChartHelper::GetErrorBarValuesRole( maData.mnBarType ) );
1692 }
1693 
CreateErrorBar(const XclImpChSerErrorBar * pPosBar,const XclImpChSerErrorBar * pNegBar)1694 Reference< XPropertySet > XclImpChSerErrorBar::CreateErrorBar( const XclImpChSerErrorBar* pPosBar, const XclImpChSerErrorBar* pNegBar )
1695 {
1696     Reference< XPropertySet > xErrorBar;
1697 
1698     if( const XclImpChSerErrorBar* pPrimaryBar = pPosBar ? pPosBar : pNegBar )
1699     {
1700         xErrorBar.set( ScfApiHelper::CreateInstance( SERVICE_CHART2_ERRORBAR ), UNO_QUERY );
1701         ScfPropertySet aBarProp( xErrorBar );
1702 
1703         // plus/minus bars visible?
1704         aBarProp.SetBoolProperty( EXC_CHPROP_SHOWPOSITIVEERROR, pPosBar != 0 );
1705         aBarProp.SetBoolProperty( EXC_CHPROP_SHOWNEGATIVEERROR, pNegBar != 0 );
1706 
1707         // type of displayed error
1708         switch( pPrimaryBar->maData.mnSourceType )
1709         {
1710             case EXC_CHSERERR_PERCENT:
1711                 aBarProp.SetProperty( EXC_CHPROP_ERRORBARSTYLE, cssc::ErrorBarStyle::RELATIVE );
1712                 aBarProp.SetProperty( EXC_CHPROP_POSITIVEERROR, pPrimaryBar->maData.mfValue );
1713                 aBarProp.SetProperty( EXC_CHPROP_NEGATIVEERROR, pPrimaryBar->maData.mfValue );
1714             break;
1715             case EXC_CHSERERR_FIXED:
1716                 aBarProp.SetProperty( EXC_CHPROP_ERRORBARSTYLE, cssc::ErrorBarStyle::ABSOLUTE );
1717                 aBarProp.SetProperty( EXC_CHPROP_POSITIVEERROR, pPrimaryBar->maData.mfValue );
1718                 aBarProp.SetProperty( EXC_CHPROP_NEGATIVEERROR, pPrimaryBar->maData.mfValue );
1719             break;
1720             case EXC_CHSERERR_STDDEV:
1721                 aBarProp.SetProperty( EXC_CHPROP_ERRORBARSTYLE, cssc::ErrorBarStyle::STANDARD_DEVIATION );
1722                 aBarProp.SetProperty( EXC_CHPROP_WEIGHT, pPrimaryBar->maData.mfValue );
1723             break;
1724             case EXC_CHSERERR_STDERR:
1725                 aBarProp.SetProperty( EXC_CHPROP_ERRORBARSTYLE, cssc::ErrorBarStyle::STANDARD_ERROR );
1726             break;
1727             case EXC_CHSERERR_CUSTOM:
1728             {
1729                 aBarProp.SetProperty( EXC_CHPROP_ERRORBARSTYLE, cssc::ErrorBarStyle::FROM_DATA );
1730                 // attach data sequences to erorr bar
1731                 Reference< XDataSink > xDataSink( xErrorBar, UNO_QUERY );
1732                 if( xDataSink.is() )
1733                 {
1734                     // create vector of all value sequences
1735                     ::std::vector< Reference< XLabeledDataSequence > > aLabeledSeqVec;
1736                     // add positive values
1737                     if( pPosBar )
1738                     {
1739                         Reference< XLabeledDataSequence > xValueSeq = pPosBar->CreateValueSequence();
1740                         if( xValueSeq.is() )
1741                             aLabeledSeqVec.push_back( xValueSeq );
1742                     }
1743                     // add negative values
1744                     if( pNegBar )
1745                     {
1746                         Reference< XLabeledDataSequence > xValueSeq = pNegBar->CreateValueSequence();
1747                         if( xValueSeq.is() )
1748                             aLabeledSeqVec.push_back( xValueSeq );
1749                     }
1750                     // attach labeled data sequences to series
1751                     if( aLabeledSeqVec.empty() )
1752                         xErrorBar.clear();
1753                     else
1754                         xDataSink->setData( ScfApiHelper::VectorToSequence( aLabeledSeqVec ) );
1755                 }
1756             }
1757             break;
1758             default:
1759                 xErrorBar.clear();
1760         }
1761 
1762         // error bar formatting
1763         if( pPrimaryBar->mxDataFmt.is() && xErrorBar.is() )
1764             pPrimaryBar->mxDataFmt->ConvertLine( aBarProp, EXC_CHOBJTYPE_ERRORBAR );
1765     }
1766 
1767     return xErrorBar;
1768 }
1769 
1770 // ----------------------------------------------------------------------------
1771 
XclImpChSeries(const XclImpChRoot & rRoot,sal_uInt16 nSeriesIdx)1772 XclImpChSeries::XclImpChSeries( const XclImpChRoot& rRoot, sal_uInt16 nSeriesIdx ) :
1773     XclImpChRoot( rRoot ),
1774     mnGroupIdx( EXC_CHSERGROUP_NONE ),
1775     mnSeriesIdx( nSeriesIdx ),
1776     mnParentIdx( EXC_CHSERIES_INVALID )
1777 {
1778 }
1779 
ReadHeaderRecord(XclImpStream & rStrm)1780 void XclImpChSeries::ReadHeaderRecord( XclImpStream& rStrm )
1781 {
1782     rStrm >> maData.mnCategType >> maData.mnValueType >> maData.mnCategCount >> maData.mnValueCount;
1783     if( GetBiff() == EXC_BIFF8 )
1784         rStrm >> maData.mnBubbleType >> maData.mnBubbleCount;
1785 }
1786 
ReadSubRecord(XclImpStream & rStrm)1787 void XclImpChSeries::ReadSubRecord( XclImpStream& rStrm )
1788 {
1789     switch( rStrm.GetRecId() )
1790     {
1791         case EXC_ID_CHSOURCELINK:
1792             ReadChSourceLink( rStrm );
1793         break;
1794         case EXC_ID_CHDATAFORMAT:
1795             ReadChDataFormat( rStrm );
1796         break;
1797         case EXC_ID_CHSERGROUP:
1798             rStrm >> mnGroupIdx;
1799         break;
1800         case EXC_ID_CHSERPARENT:
1801             ReadChSerParent( rStrm );
1802         break;
1803         case EXC_ID_CHSERTRENDLINE:
1804             ReadChSerTrendLine( rStrm );
1805         break;
1806         case EXC_ID_CHSERERRORBAR:
1807             ReadChSerErrorBar( rStrm );
1808         break;
1809     }
1810 }
1811 
SetDataFormat(XclImpChDataFormatRef xDataFmt)1812 void XclImpChSeries::SetDataFormat( XclImpChDataFormatRef xDataFmt )
1813 {
1814     if( xDataFmt.is() )
1815     {
1816         XclImpChDataFormatRef* pxDataFmt = GetDataFormatRef( xDataFmt->GetPointPos().mnPointIdx );
1817         // do not overwrite existing data format
1818         if( pxDataFmt && !*pxDataFmt )
1819         {
1820             *pxDataFmt = xDataFmt;
1821             // #i51639# register series format index at chart type group
1822             if( (pxDataFmt == &mxSeriesFmt) && !HasParentSeries() )
1823                 if( XclImpChTypeGroup* pTypeGroup = GetChartData().GetTypeGroup( mnGroupIdx ).get() )
1824                     pTypeGroup->SetUsedFormatIndex( xDataFmt->GetFormatIdx() );
1825         }
1826     }
1827 }
1828 
SetDataLabel(XclImpChTextRef xLabel)1829 void XclImpChSeries::SetDataLabel( XclImpChTextRef xLabel )
1830 {
1831     if( xLabel.is() )
1832     {
1833         XclImpChTextRef* pxLabel = GetDataLabelRef( xLabel->GetPointPos().mnPointIdx );
1834         if( pxLabel && !*pxLabel )
1835             *pxLabel = xLabel;
1836     }
1837 }
1838 
AddChildSeries(const XclImpChSeries & rSeries)1839 void XclImpChSeries::AddChildSeries( const XclImpChSeries& rSeries )
1840 {
1841     DBG_ASSERT( !HasParentSeries(), "XclImpChSeries::AddChildSeries - not allowed for child series" );
1842 
1843     /*  In Excel, trend lines and error bars are stored as own series. In Calc,
1844         these are properties of the parent series. This function adds the
1845         settings of the passed series to this series. */
1846     maTrendLines.insert( maTrendLines.end(), rSeries.maTrendLines.begin(), rSeries.maTrendLines.end() );
1847     maErrorBars.insert( rSeries.maErrorBars.begin(), rSeries.maErrorBars.end() );
1848 }
1849 
FinalizeDataFormats()1850 void XclImpChSeries::FinalizeDataFormats()
1851 {
1852     if( HasParentSeries() )
1853     {
1854         // *** series is a child series, e.g. trend line or error bar ***
1855 
1856         // create missing series format
1857         if( !mxSeriesFmt )
1858             mxSeriesFmt = CreateDataFormat( EXC_CHDATAFORMAT_ALLPOINTS, 0 );
1859 
1860         if( mxSeriesFmt.is() )
1861         {
1862             // #i83100# set text label format, e.g. for trend line equations
1863             mxSeriesFmt->SetDataLabel( maLabels.get( EXC_CHDATAFORMAT_ALLPOINTS ) );
1864             // create missing automatic formats
1865             mxSeriesFmt->UpdateTrendLineFormat();
1866         }
1867 
1868         // copy series formatting to child objects
1869         for( XclImpChSerTrendLineList::iterator aLIt = maTrendLines.begin(), aLEnd = maTrendLines.end(); aLIt != aLEnd; ++aLIt )
1870             (*aLIt)->SetDataFormat( mxSeriesFmt );
1871         for( XclImpChSerErrorBarMap::iterator aMIt = maErrorBars.begin(), aMEnd = maErrorBars.end(); aMIt != aMEnd; ++aMIt )
1872             aMIt->second->SetSeriesData( mxValueLink, mxSeriesFmt );
1873     }
1874     else if( XclImpChTypeGroup* pTypeGroup = GetChartData().GetTypeGroup( mnGroupIdx ).get() )
1875     {
1876         // *** series is a regular data series ***
1877 
1878         // create missing series format
1879         if( !mxSeriesFmt )
1880         {
1881             // #i51639# use a new unused format index to create series default format
1882             sal_uInt16 nFormatIdx = pTypeGroup->PopUnusedFormatIndex();
1883             mxSeriesFmt = CreateDataFormat( EXC_CHDATAFORMAT_ALLPOINTS, nFormatIdx );
1884         }
1885 
1886         // set text labels to data formats
1887         for( XclImpChTextMap::iterator aTIt = maLabels.begin(), aTEnd = maLabels.end(); aTIt != aTEnd; ++aTIt )
1888         {
1889             if( XclImpChDataFormatRef* pxDataFmt = GetDataFormatRef( aTIt->first ) )
1890             {
1891                 if( !*pxDataFmt )
1892                     *pxDataFmt = CreateDataFormat( aTIt->first, EXC_CHDATAFORMAT_DEFAULT );
1893                 (*pxDataFmt)->SetDataLabel( aTIt->second );
1894             }
1895         }
1896 
1897         // update series format (copy missing formatting from group default format)
1898         if( mxSeriesFmt.is() )
1899             mxSeriesFmt->UpdateSeriesFormat( pTypeGroup->GetTypeInfo(), pTypeGroup->GetGroupFormat().get() );
1900 
1901         // update data point formats (removes unchanged automatic formatting)
1902         for( XclImpChDataFormatMap::iterator aFIt = maPointFmts.begin(), aFEnd = maPointFmts.end(); aFIt != aFEnd; ++aFIt )
1903             aFIt->second->UpdatePointFormat( pTypeGroup->GetTypeInfo(), mxSeriesFmt.get() );
1904     }
1905 }
1906 
1907 namespace {
1908 
1909 /** Returns the property set of the specified data point. */
lclGetPointPropSet(Reference<XDataSeries> xDataSeries,sal_uInt16 nPointIdx)1910 ScfPropertySet lclGetPointPropSet( Reference< XDataSeries > xDataSeries, sal_uInt16 nPointIdx )
1911 {
1912     ScfPropertySet aPropSet;
1913     try
1914     {
1915         aPropSet.Set( xDataSeries->getDataPointByIndex( static_cast< sal_Int32 >( nPointIdx ) ) );
1916     }
1917     catch( Exception& )
1918     {
1919         DBG_ERRORFILE( "lclGetPointPropSet - no data point property set" );
1920     }
1921     return aPropSet;
1922 }
1923 
1924 } // namespace
1925 
CreateValueSequence(const OUString & rValueRole) const1926 Reference< XLabeledDataSequence > XclImpChSeries::CreateValueSequence( const OUString& rValueRole ) const
1927 {
1928     return lclCreateLabeledDataSequence( mxValueLink, rValueRole, mxTitleLink.get() );
1929 }
1930 
CreateCategSequence(const OUString & rCategRole) const1931 Reference< XLabeledDataSequence > XclImpChSeries::CreateCategSequence( const OUString& rCategRole ) const
1932 {
1933     return lclCreateLabeledDataSequence( mxCategLink, rCategRole );
1934 }
1935 
CreateDataSeries() const1936 Reference< XDataSeries > XclImpChSeries::CreateDataSeries() const
1937 {
1938     Reference< XDataSeries > xDataSeries;
1939     if( const XclImpChTypeGroup* pTypeGroup = GetChartData().GetTypeGroup( mnGroupIdx ).get() )
1940     {
1941         const XclChExtTypeInfo& rTypeInfo = pTypeGroup->GetTypeInfo();
1942 
1943         // create the data series object
1944         xDataSeries.set( ScfApiHelper::CreateInstance( SERVICE_CHART2_DATASERIES ), UNO_QUERY );
1945 
1946         // attach data and title sequences to series
1947         Reference< XDataSink > xDataSink( xDataSeries, UNO_QUERY );
1948         if( xDataSink.is() )
1949         {
1950             // create vector of all value sequences
1951             ::std::vector< Reference< XLabeledDataSequence > > aLabeledSeqVec;
1952             // add Y values
1953             Reference< XLabeledDataSequence > xYValueSeq =
1954                 CreateValueSequence( EXC_CHPROP_ROLE_YVALUES );
1955             if( xYValueSeq.is() )
1956                 aLabeledSeqVec.push_back( xYValueSeq );
1957             // add X values
1958             if( !rTypeInfo.mbCategoryAxis )
1959             {
1960                 Reference< XLabeledDataSequence > xXValueSeq =
1961                     CreateCategSequence( EXC_CHPROP_ROLE_XVALUES );
1962                 if( xXValueSeq.is() )
1963                     aLabeledSeqVec.push_back( xXValueSeq );
1964                 // add size values of bubble charts
1965                 if( rTypeInfo.meTypeId == EXC_CHTYPEID_BUBBLES )
1966                 {
1967                     Reference< XLabeledDataSequence > xSizeValueSeq =
1968                         lclCreateLabeledDataSequence( mxBubbleLink, EXC_CHPROP_ROLE_SIZEVALUES, mxTitleLink.get() );
1969                     if( xSizeValueSeq.is() )
1970                         aLabeledSeqVec.push_back( xSizeValueSeq );
1971                 }
1972             }
1973             // attach labeled data sequences to series
1974             if( !aLabeledSeqVec.empty() )
1975                 xDataSink->setData( ScfApiHelper::VectorToSequence( aLabeledSeqVec ) );
1976         }
1977 
1978         // series formatting
1979         ScfPropertySet aSeriesProp( xDataSeries );
1980         if( mxSeriesFmt.is() )
1981             mxSeriesFmt->Convert( aSeriesProp, rTypeInfo );
1982 
1983         // trend lines
1984         ConvertTrendLines( xDataSeries );
1985 
1986         // error bars
1987         Reference< XPropertySet > xErrorBarX = CreateErrorBar( EXC_CHSERERR_XPLUS, EXC_CHSERERR_XMINUS );
1988         if( xErrorBarX.is() )
1989             aSeriesProp.SetProperty( EXC_CHPROP_ERRORBARX, xErrorBarX );
1990         Reference< XPropertySet > xErrorBarY = CreateErrorBar( EXC_CHSERERR_YPLUS, EXC_CHSERERR_YMINUS );
1991         if( xErrorBarY.is() )
1992             aSeriesProp.SetProperty( EXC_CHPROP_ERRORBARY, xErrorBarY );
1993 
1994         // own area formatting for every data point (TODO: varying line color not supported)
1995         bool bVarPointFmt = pTypeGroup->HasVarPointFormat() && rTypeInfo.IsSeriesFrameFormat();
1996 #if EXC_CHART2_VARYCOLORSBY_PROP
1997         aSeriesProp.SetBoolProperty( EXC_CHPROP_VARYCOLORSBY, bVarPointFmt );
1998 #else
1999         aSeriesProp.SetBoolProperty( EXC_CHPROP_VARYCOLORSBY, rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_PIE );
2000 #endif
2001         // #i91271# always set area formatting for every point in pie/doughnut charts
2002         if( mxSeriesFmt.is() && ((bVarPointFmt && mxSeriesFmt->IsAutoArea()) || (rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_PIE)) )
2003         {
2004             for( sal_uInt16 nPointIdx = 0, nPointCount = mxValueLink->GetCellCount(); nPointIdx < nPointCount; ++nPointIdx )
2005             {
2006                 ScfPropertySet aPointProp = lclGetPointPropSet( xDataSeries, nPointIdx );
2007                 mxSeriesFmt->ConvertArea( aPointProp, bVarPointFmt ? nPointIdx : mnSeriesIdx, false );
2008             }
2009         }
2010 
2011         // data point formatting
2012         for( XclImpChDataFormatMap::const_iterator aIt = maPointFmts.begin(), aEnd = maPointFmts.end(); aIt != aEnd; ++aIt )
2013         {
2014             ScfPropertySet aPointProp = lclGetPointPropSet( xDataSeries, aIt->first );
2015             aIt->second->Convert( aPointProp, rTypeInfo );
2016         }
2017     }
2018     return xDataSeries;
2019 }
2020 
FillAllSourceLinks(::std::vector<ScSharedTokenRef> & rTokens) const2021 void XclImpChSeries::FillAllSourceLinks( ::std::vector< ScSharedTokenRef >& rTokens ) const
2022 {
2023     if( mxValueLink.is() )
2024         mxValueLink->FillSourceLink( rTokens );
2025     if( mxCategLink.is() )
2026         mxCategLink->FillSourceLink( rTokens );
2027     if( mxTitleLink.is() )
2028         mxTitleLink->FillSourceLink( rTokens );
2029     if( mxBubbleLink.is() )
2030         mxBubbleLink->FillSourceLink( rTokens );
2031 }
2032 
ReadChSourceLink(XclImpStream & rStrm)2033 void XclImpChSeries::ReadChSourceLink( XclImpStream& rStrm )
2034 {
2035     XclImpChSourceLinkRef xSrcLink( new XclImpChSourceLink( GetChRoot() ) );
2036     xSrcLink->ReadChSourceLink( rStrm );
2037     switch( xSrcLink->GetDestType() )
2038     {
2039         case EXC_CHSRCLINK_TITLE:       mxTitleLink = xSrcLink;     break;
2040         case EXC_CHSRCLINK_VALUES:      mxValueLink = xSrcLink;     break;
2041         case EXC_CHSRCLINK_CATEGORY:    mxCategLink = xSrcLink;     break;
2042         case EXC_CHSRCLINK_BUBBLES:     mxBubbleLink = xSrcLink;    break;
2043     }
2044 }
2045 
ReadChDataFormat(XclImpStream & rStrm)2046 void XclImpChSeries::ReadChDataFormat( XclImpStream& rStrm )
2047 {
2048     // #i51639# chart stores all data formats and assigns them later to the series
2049     GetChartData().ReadChDataFormat( rStrm );
2050 }
2051 
ReadChSerParent(XclImpStream & rStrm)2052 void XclImpChSeries::ReadChSerParent( XclImpStream& rStrm )
2053 {
2054     rStrm >> mnParentIdx;
2055     // index to parent series is 1-based, convert it to 0-based
2056     if( mnParentIdx > 0 )
2057         --mnParentIdx;
2058     else
2059         mnParentIdx = EXC_CHSERIES_INVALID;
2060 }
2061 
ReadChSerTrendLine(XclImpStream & rStrm)2062 void XclImpChSeries::ReadChSerTrendLine( XclImpStream& rStrm )
2063 {
2064     XclImpChSerTrendLineRef xTrendLine( new XclImpChSerTrendLine( GetChRoot() ) );
2065     xTrendLine->ReadChSerTrendLine( rStrm );
2066     maTrendLines.push_back( xTrendLine );
2067 }
2068 
ReadChSerErrorBar(XclImpStream & rStrm)2069 void XclImpChSeries::ReadChSerErrorBar( XclImpStream& rStrm )
2070 {
2071     XclImpChSerErrorBarRef xErrorBar( new XclImpChSerErrorBar( GetChRoot() ) );
2072     xErrorBar->ReadChSerErrorBar( rStrm );
2073     maErrorBars[ xErrorBar->GetBarType() ] = xErrorBar;
2074 }
2075 
CreateDataFormat(sal_uInt16 nPointIdx,sal_uInt16 nFormatIdx)2076 XclImpChDataFormatRef XclImpChSeries::CreateDataFormat( sal_uInt16 nPointIdx, sal_uInt16 nFormatIdx )
2077 {
2078     XclImpChDataFormatRef xDataFmt( new XclImpChDataFormat( GetChRoot() ) );
2079     xDataFmt->SetPointPos( XclChDataPointPos( mnSeriesIdx, nPointIdx ), nFormatIdx );
2080     return xDataFmt;
2081 }
2082 
GetDataFormatRef(sal_uInt16 nPointIdx)2083 XclImpChDataFormatRef* XclImpChSeries::GetDataFormatRef( sal_uInt16 nPointIdx )
2084 {
2085     if( nPointIdx == EXC_CHDATAFORMAT_ALLPOINTS )
2086         return &mxSeriesFmt;
2087     if( nPointIdx < EXC_CHDATAFORMAT_MAXPOINTCOUNT )
2088         return &maPointFmts[ nPointIdx ];
2089     return 0;
2090 }
2091 
GetDataLabelRef(sal_uInt16 nPointIdx)2092 XclImpChTextRef* XclImpChSeries::GetDataLabelRef( sal_uInt16 nPointIdx )
2093 {
2094     if( (nPointIdx == EXC_CHDATAFORMAT_ALLPOINTS) || (nPointIdx < EXC_CHDATAFORMAT_MAXPOINTCOUNT) )
2095         return &maLabels[ nPointIdx ];
2096     return 0;
2097 }
2098 
ConvertTrendLines(Reference<XDataSeries> xDataSeries) const2099 void XclImpChSeries::ConvertTrendLines( Reference< XDataSeries > xDataSeries ) const
2100 {
2101     Reference< XRegressionCurveContainer > xRegCurveCont( xDataSeries, UNO_QUERY );
2102     if( xRegCurveCont.is() )
2103     {
2104         for( XclImpChSerTrendLineList::const_iterator aIt = maTrendLines.begin(), aEnd = maTrendLines.end(); aIt != aEnd; ++aIt )
2105         {
2106             try
2107             {
2108                 Reference< XRegressionCurve > xRegCurve = (*aIt)->CreateRegressionCurve();
2109                 if( xRegCurve.is() )
2110                     xRegCurveCont->addRegressionCurve( xRegCurve );
2111             }
2112             catch( Exception& )
2113             {
2114                 DBG_ERRORFILE( "XclImpChSeries::ConvertTrendLines - cannot add regression curve" );
2115             }
2116         }
2117     }
2118 }
2119 
CreateErrorBar(sal_uInt8 nPosBarId,sal_uInt8 nNegBarId) const2120 Reference< XPropertySet > XclImpChSeries::CreateErrorBar( sal_uInt8 nPosBarId, sal_uInt8 nNegBarId ) const
2121 {
2122     return XclImpChSerErrorBar::CreateErrorBar( maErrorBars.get( nPosBarId ).get(), maErrorBars.get( nNegBarId ).get() );
2123 }
2124 
2125 // Chart type groups ==========================================================
2126 
XclImpChType(const XclImpChRoot & rRoot)2127 XclImpChType::XclImpChType( const XclImpChRoot& rRoot ) :
2128     XclImpChRoot( rRoot ),
2129     mnRecId( EXC_ID_CHUNKNOWN ),
2130     maTypeInfo( rRoot.GetChartTypeInfo( EXC_CHTYPEID_UNKNOWN ) )
2131 {
2132 }
2133 
ReadChType(XclImpStream & rStrm)2134 void XclImpChType::ReadChType( XclImpStream& rStrm )
2135 {
2136     sal_uInt16 nRecId = rStrm.GetRecId();
2137     bool bKnownType = true;
2138 
2139     switch( nRecId )
2140     {
2141         case EXC_ID_CHBAR:
2142             rStrm >> maData.mnOverlap >> maData.mnGap >> maData.mnFlags;
2143         break;
2144 
2145         case EXC_ID_CHLINE:
2146         case EXC_ID_CHAREA:
2147         case EXC_ID_CHRADARLINE:
2148         case EXC_ID_CHRADARAREA:
2149             rStrm >> maData.mnFlags;
2150         break;
2151 
2152         case EXC_ID_CHPIE:
2153             rStrm >> maData.mnRotation >> maData.mnPieHole;
2154             if( GetBiff() == EXC_BIFF8 )
2155                 rStrm >> maData.mnFlags;
2156             else
2157                 maData.mnFlags = 0;
2158         break;
2159 
2160         case EXC_ID_CHPIEEXT:
2161             maData.mnRotation = 0;
2162             maData.mnPieHole = 0;
2163             maData.mnFlags = 0;
2164         break;
2165 
2166         case EXC_ID_CHSCATTER:
2167             if( GetBiff() == EXC_BIFF8 )
2168                 rStrm >> maData.mnBubbleSize >> maData.mnBubbleType >> maData.mnFlags;
2169             else
2170                 maData.mnFlags = 0;
2171         break;
2172 
2173         case EXC_ID_CHSURFACE:
2174             rStrm >> maData.mnFlags;
2175         break;
2176 
2177         default:
2178             bKnownType = false;
2179     }
2180 
2181     if( bKnownType )
2182         mnRecId = nRecId;
2183 }
2184 
Finalize(bool bStockChart)2185 void XclImpChType::Finalize( bool bStockChart )
2186 {
2187     switch( mnRecId )
2188     {
2189         case EXC_ID_CHLINE:
2190             maTypeInfo = GetChartTypeInfo( bStockChart ?
2191                 EXC_CHTYPEID_STOCK : EXC_CHTYPEID_LINE );
2192         break;
2193         case EXC_ID_CHBAR:
2194             maTypeInfo = GetChartTypeInfo( ::get_flagvalue(
2195                 maData.mnFlags, EXC_CHBAR_HORIZONTAL,
2196                 EXC_CHTYPEID_HORBAR, EXC_CHTYPEID_BAR ) );
2197         break;
2198         case EXC_ID_CHPIE:
2199             maTypeInfo = GetChartTypeInfo( (maData.mnPieHole > 0) ?
2200                 EXC_CHTYPEID_DONUT : EXC_CHTYPEID_PIE );
2201         break;
2202         case EXC_ID_CHSCATTER:
2203             maTypeInfo = GetChartTypeInfo( ::get_flagvalue(
2204                 maData.mnFlags, EXC_CHSCATTER_BUBBLES,
2205                 EXC_CHTYPEID_BUBBLES, EXC_CHTYPEID_SCATTER ) );
2206         break;
2207         default:
2208             maTypeInfo = GetChartTypeInfo( mnRecId );
2209     }
2210 
2211     switch( maTypeInfo.meTypeId )
2212     {
2213         case EXC_CHTYPEID_PIEEXT:
2214         case EXC_CHTYPEID_BUBBLES:
2215         case EXC_CHTYPEID_SURFACE:
2216         case EXC_CHTYPEID_UNKNOWN:
2217             GetTracer().TraceChartUnKnownType();
2218         break;
2219         default:;
2220     }
2221 }
2222 
IsStacked() const2223 bool XclImpChType::IsStacked() const
2224 {
2225     bool bStacked = false;
2226     if( maTypeInfo.mbSupportsStacking ) switch( maTypeInfo.meTypeCateg )
2227     {
2228         case EXC_CHTYPECATEG_LINE:
2229             bStacked =
2230                 ::get_flag( maData.mnFlags, EXC_CHLINE_STACKED ) &&
2231                 !::get_flag( maData.mnFlags, EXC_CHLINE_PERCENT );
2232         break;
2233         case EXC_CHTYPECATEG_BAR:
2234             bStacked =
2235                 ::get_flag( maData.mnFlags, EXC_CHBAR_STACKED ) &&
2236                 !::get_flag( maData.mnFlags, EXC_CHBAR_PERCENT );
2237         break;
2238         default:;
2239     }
2240     return bStacked;
2241 }
2242 
IsPercent() const2243 bool XclImpChType::IsPercent() const
2244 {
2245     bool bPercent = false;
2246     if( maTypeInfo.mbSupportsStacking ) switch( maTypeInfo.meTypeCateg )
2247     {
2248         case EXC_CHTYPECATEG_LINE:
2249             bPercent =
2250                 ::get_flag( maData.mnFlags, EXC_CHLINE_STACKED ) &&
2251                 ::get_flag( maData.mnFlags, EXC_CHLINE_PERCENT );
2252         break;
2253         case EXC_CHTYPECATEG_BAR:
2254             bPercent =
2255                 ::get_flag( maData.mnFlags, EXC_CHBAR_STACKED ) &&
2256                 ::get_flag( maData.mnFlags, EXC_CHBAR_PERCENT );
2257         break;
2258         default:;
2259     }
2260     return bPercent;
2261 }
2262 
HasCategoryLabels() const2263 bool XclImpChType::HasCategoryLabels() const
2264 {
2265     // radar charts disable category labels in chart type, not in CHTICK of X axis
2266     return (maTypeInfo.meTypeCateg != EXC_CHTYPECATEG_RADAR) || ::get_flag( maData.mnFlags, EXC_CHRADAR_AXISLABELS );
2267 }
2268 
CreateCoordSystem(bool b3dChart) const2269 Reference< XCoordinateSystem > XclImpChType::CreateCoordSystem( bool b3dChart ) const
2270 {
2271     // service name
2272     OUString aCoordSysService;
2273     if( maTypeInfo.mbPolarCoordSystem )
2274     {
2275         if( b3dChart )
2276             aCoordSysService = SERVICE_CHART2_POLARCOORDSYS3D;
2277         else
2278             aCoordSysService = SERVICE_CHART2_POLARCOORDSYS2D;
2279     }
2280     else
2281     {
2282         if( b3dChart )
2283             aCoordSysService = SERVICE_CHART2_CARTESIANCOORDSYS3D;
2284         else
2285             aCoordSysService = SERVICE_CHART2_CARTESIANCOORDSYS2D;
2286     }
2287 
2288     // create the coordinate system object
2289     Reference< XCoordinateSystem > xCoordSystem( ScfApiHelper::CreateInstance( aCoordSysService ), UNO_QUERY );
2290 
2291     // swap X and Y axis
2292     if( maTypeInfo.mbSwappedAxesSet )
2293     {
2294         ScfPropertySet aCoordSysProp( xCoordSystem );
2295         aCoordSysProp.SetBoolProperty( EXC_CHPROP_SWAPXANDYAXIS, true );
2296     }
2297 
2298     return xCoordSystem;
2299 }
2300 
CreateChartType(Reference<XDiagram> xDiagram,bool b3dChart) const2301 Reference< XChartType > XclImpChType::CreateChartType( Reference< XDiagram > xDiagram, bool b3dChart ) const
2302 {
2303     OUString aService = OUString::createFromAscii( maTypeInfo.mpcServiceName );
2304     Reference< XChartType > xChartType( ScfApiHelper::CreateInstance( aService ), UNO_QUERY );
2305 
2306     // additional properties
2307     switch( maTypeInfo.meTypeCateg )
2308     {
2309         case EXC_CHTYPECATEG_BAR:
2310         {
2311             ScfPropertySet aTypeProp( xChartType );
2312             Sequence< sal_Int32 > aInt32Seq( 2 );
2313             aInt32Seq[ 0 ] = aInt32Seq[ 1 ] = -maData.mnOverlap;
2314             aTypeProp.SetProperty( EXC_CHPROP_OVERLAPSEQ, aInt32Seq );
2315             aInt32Seq[ 0 ] = aInt32Seq[ 1 ] = maData.mnGap;
2316             aTypeProp.SetProperty( EXC_CHPROP_GAPWIDTHSEQ, aInt32Seq );
2317         }
2318         break;
2319         case EXC_CHTYPECATEG_PIE:
2320         {
2321             ScfPropertySet aTypeProp( xChartType );
2322             aTypeProp.SetBoolProperty( EXC_CHPROP_USERINGS, maTypeInfo.meTypeId == EXC_CHTYPEID_DONUT );
2323             /*  #i85166# starting angle of first pie slice. 3D pie charts use Y
2324                 rotation setting in view3D element. Of-pie charts do not
2325                 support pie rotation. */
2326             if( !b3dChart && (maTypeInfo.meTypeId != EXC_CHTYPEID_PIEEXT) )
2327             {
2328                 ScfPropertySet aDiaProp( xDiagram );
2329                 XclImpChRoot::ConvertPieRotation( aDiaProp, maData.mnRotation );
2330             }
2331         }
2332         break;
2333         default:;
2334     }
2335 
2336     return xChartType;
2337 }
2338 
2339 // ----------------------------------------------------------------------------
2340 
ReadChChart3d(XclImpStream & rStrm)2341 void XclImpChChart3d::ReadChChart3d( XclImpStream& rStrm )
2342 {
2343     rStrm   >> maData.mnRotation
2344             >> maData.mnElevation
2345             >> maData.mnEyeDist
2346             >> maData.mnRelHeight
2347             >> maData.mnRelDepth
2348             >> maData.mnDepthGap
2349             >> maData.mnFlags;
2350 }
2351 
Convert(ScfPropertySet & rPropSet,bool b3dWallChart) const2352 void XclImpChChart3d::Convert( ScfPropertySet& rPropSet, bool b3dWallChart ) const
2353 {
2354     namespace cssd = ::com::sun::star::drawing;
2355 
2356 //    #i104057# do not assert this, written by broken external generators
2357 //    DBG_ASSERT( ::get_flag( maData.mnFlags, EXC_CHCHART3D_HASWALLS ) == b3dWallChart, "XclImpChChart3d::Convert - wrong wall flag" );
2358 
2359     sal_Int32 nRotationY = 0;
2360     sal_Int32 nRotationX = 0;
2361     sal_Int32 nPerspective = 15;
2362     bool bRightAngled = false;
2363     cssd::ProjectionMode eProjMode = cssd::ProjectionMode_PERSPECTIVE;
2364     Color aAmbientColor, aLightColor;
2365 
2366     if( b3dWallChart )
2367     {
2368         // Y rotation (Excel [0..359], Chart2 [-179,180])
2369         nRotationY = maData.mnRotation % 360;
2370         if( nRotationY > 180 ) nRotationY -= 360;
2371         // X rotation a.k.a. elevation (Excel [-90..90], Chart2 [-179,180])
2372         nRotationX = limit_cast< sal_Int32, sal_Int32 >( maData.mnElevation, -90, 90 );
2373         // perspective (Excel and Chart2 [0,100])
2374         nPerspective = limit_cast< sal_Int32, sal_Int32 >( maData.mnEyeDist, 0, 100 );
2375         // right-angled axes
2376         bRightAngled = !::get_flag( maData.mnFlags, EXC_CHCHART3D_REAL3D );
2377         // projection mode (parallel axes, if right-angled, #i90360# or if perspective is at 0%)
2378         bool bParallel = bRightAngled || (nPerspective == 0);
2379         eProjMode = bParallel ? cssd::ProjectionMode_PARALLEL : cssd::ProjectionMode_PERSPECTIVE;
2380         // ambient color (Gray 20%)
2381         aAmbientColor.SetColor( RGB_COLORDATA( 204, 204, 204 ) );
2382         // light color (Gray 60%)
2383         aLightColor.SetColor( RGB_COLORDATA( 102, 102, 102 ) );
2384     }
2385     else
2386     {
2387         // Y rotation not used in pie charts, but 'first pie slice angle'
2388         nRotationY = 0;
2389         XclImpChRoot::ConvertPieRotation( rPropSet, maData.mnRotation );
2390         // X rotation a.k.a. elevation (map Excel [10..80] to Chart2 [-80,-10])
2391         nRotationX = limit_cast< sal_Int32, sal_Int32 >( maData.mnElevation, 10, 80 ) - 90;
2392         // perspective (Excel and Chart2 [0,100])
2393         nPerspective = limit_cast< sal_Int32, sal_Int32 >( maData.mnEyeDist, 0, 100 );
2394         // no right-angled axes in pie charts, but parallel projection
2395         bRightAngled = false;
2396         eProjMode = cssd::ProjectionMode_PARALLEL;
2397         // ambient color (Gray 30%)
2398         aAmbientColor.SetColor( RGB_COLORDATA( 179, 179, 179 ) );
2399         // light color (Gray 70%)
2400         aLightColor.SetColor( RGB_COLORDATA( 76, 76, 76 ) );
2401     }
2402 
2403     // properties
2404     rPropSet.SetProperty( EXC_CHPROP_3DRELATIVEHEIGHT, (sal_Int32)(maData.mnRelHeight / 2)); // seems to be 200%, cange to 100%
2405     rPropSet.SetProperty( EXC_CHPROP_ROTATIONVERTICAL, nRotationY );
2406     rPropSet.SetProperty( EXC_CHPROP_ROTATIONHORIZONTAL, nRotationX );
2407     rPropSet.SetProperty( EXC_CHPROP_PERSPECTIVE, nPerspective );
2408     rPropSet.SetBoolProperty( EXC_CHPROP_RIGHTANGLEDAXES, bRightAngled );
2409     rPropSet.SetProperty( EXC_CHPROP_D3DSCENEPERSPECTIVE, eProjMode );
2410 
2411     // light settings
2412     rPropSet.SetProperty( EXC_CHPROP_D3DSCENESHADEMODE, cssd::ShadeMode_FLAT );
2413     rPropSet.SetColorProperty( EXC_CHPROP_D3DSCENEAMBIENTCOLOR, aAmbientColor );
2414     rPropSet.SetBoolProperty( EXC_CHPROP_D3DSCENELIGHTON1, false );
2415     rPropSet.SetBoolProperty( EXC_CHPROP_D3DSCENELIGHTON2, true );
2416     rPropSet.SetColorProperty( EXC_CHPROP_D3DSCENELIGHTCOLOR2, aLightColor );
2417     rPropSet.SetProperty( EXC_CHPROP_D3DSCENELIGHTDIR2, cssd::Direction3D( 0.2, 0.4, 1.0 ) );
2418 }
2419 
2420 // ----------------------------------------------------------------------------
2421 
XclImpChLegend(const XclImpChRoot & rRoot)2422 XclImpChLegend::XclImpChLegend( const XclImpChRoot& rRoot ) :
2423     XclImpChRoot( rRoot )
2424 {
2425 }
2426 
ReadHeaderRecord(XclImpStream & rStrm)2427 void XclImpChLegend::ReadHeaderRecord( XclImpStream& rStrm )
2428 {
2429     rStrm >> maData.maRect >> maData.mnDockMode >> maData.mnSpacing >> maData.mnFlags;
2430 
2431     // trace unsupported features
2432     if( GetTracer().IsEnabled() )
2433     {
2434         if( maData.mnDockMode == EXC_CHLEGEND_NOTDOCKED )
2435             GetTracer().TraceChartLegendPosition();
2436         if( ::get_flag( maData.mnFlags, EXC_CHLEGEND_DATATABLE ) )
2437             GetTracer().TraceChartDataTable();
2438     }
2439 }
2440 
ReadSubRecord(XclImpStream & rStrm)2441 void XclImpChLegend::ReadSubRecord( XclImpStream& rStrm )
2442 {
2443     switch( rStrm.GetRecId() )
2444     {
2445         case EXC_ID_CHFRAMEPOS:
2446             mxFramePos.reset( new XclImpChFramePos );
2447             mxFramePos->ReadChFramePos( rStrm );
2448         break;
2449         case EXC_ID_CHTEXT:
2450             mxText.reset( new XclImpChText( GetChRoot() ) );
2451             mxText->ReadRecordGroup( rStrm );
2452         break;
2453         case EXC_ID_CHFRAME:
2454             mxFrame.reset( new XclImpChFrame( GetChRoot(), EXC_CHOBJTYPE_LEGEND ) );
2455             mxFrame->ReadRecordGroup( rStrm );
2456         break;
2457     }
2458 }
2459 
Finalize()2460 void XclImpChLegend::Finalize()
2461 {
2462     // legend default formatting differs in OOChart and Excel, missing frame means automatic
2463     if( !mxFrame )
2464         mxFrame.reset( new XclImpChFrame( GetChRoot(), EXC_CHOBJTYPE_LEGEND ) );
2465     // Update text formatting. If mxText is empty, the passed default text is used.
2466     lclUpdateText( mxText, GetChartData().GetDefaultText( EXC_CHTEXTTYPE_LEGEND ) );
2467 }
2468 
CreateLegend() const2469 Reference< XLegend > XclImpChLegend::CreateLegend() const
2470 {
2471     Reference< XLegend > xLegend( ScfApiHelper::CreateInstance( SERVICE_CHART2_LEGEND ), UNO_QUERY );
2472     if( xLegend.is() )
2473     {
2474         ScfPropertySet aLegendProp( xLegend );
2475         aLegendProp.SetBoolProperty( EXC_CHPROP_SHOW, true );
2476 
2477         // frame properties
2478         if( mxFrame.is() )
2479             mxFrame->Convert( aLegendProp );
2480         // text properties
2481         if( mxText.is() )
2482             mxText->ConvertFont( aLegendProp );
2483 
2484         /*  Legend position and size. Default positions are used only if the
2485             plot area is positioned automatically (Excel sets the plot area to
2486             manual mode, if the legend is moved or resized). With manual plot
2487             areas, Excel ignores the value in maData.mnDockMode completely. */
2488         cssc2::LegendPosition eApiPos = cssc2::LegendPosition_CUSTOM;
2489         cssc::ChartLegendExpansion eApiExpand = cssc::ChartLegendExpansion_CUSTOM;
2490         if( !GetChartData().IsManualPlotArea() ) switch( maData.mnDockMode )
2491         {
2492             case EXC_CHLEGEND_LEFT:
2493                 eApiPos = cssc2::LegendPosition_LINE_START;
2494                 eApiExpand = cssc::ChartLegendExpansion_HIGH;
2495             break;
2496             case EXC_CHLEGEND_RIGHT:
2497             // top-right not supported
2498             case EXC_CHLEGEND_CORNER:
2499                 eApiPos = cssc2::LegendPosition_LINE_END;
2500                 eApiExpand = cssc::ChartLegendExpansion_HIGH;
2501             break;
2502             case EXC_CHLEGEND_TOP:
2503                 eApiPos = cssc2::LegendPosition_PAGE_START;
2504                 eApiExpand = cssc::ChartLegendExpansion_WIDE;
2505             break;
2506             case EXC_CHLEGEND_BOTTOM:
2507                 eApiPos = cssc2::LegendPosition_PAGE_END;
2508                 eApiExpand = cssc::ChartLegendExpansion_WIDE;
2509             break;
2510         }
2511 
2512         // no automatic position/size: try to find the correct position and size
2513         if( eApiPos == cssc2::LegendPosition_CUSTOM )
2514         {
2515             const XclChFramePos* pFramePos = mxFramePos.is() ? &mxFramePos->GetFramePosData() : 0;
2516 
2517             /*  Legend position. Only the settings from the CHFRAMEPOS record
2518                 are used by Excel, the position in the CHLEGEND record will be
2519                 ignored. */
2520             if( pFramePos )
2521             {
2522                 RelativePosition aRelPos(
2523                     CalcRelativeFromChartX( pFramePos->maRect.mnX ),
2524                     CalcRelativeFromChartY( pFramePos->maRect.mnY ),
2525                     ::com::sun::star::drawing::Alignment_TOP_LEFT );
2526                 aLegendProp.SetProperty( EXC_CHPROP_RELATIVEPOSITION, aRelPos );
2527             }
2528             else
2529             {
2530                 // no manual position/size found, just go for the default
2531                 eApiPos = cssc2::LegendPosition_LINE_END;
2532             }
2533 
2534             /*  Legend size. The member mnBRMode specifies whether size is
2535                 automatic or changes manually. Manual size is given in points,
2536                 not in chart units. */
2537             if( pFramePos && (pFramePos->mnBRMode == EXC_CHFRAMEPOS_ABSSIZE_POINTS) &&
2538                 (pFramePos->maRect.mnWidth > 0) && (pFramePos->maRect.mnHeight > 0) )
2539             {
2540                 eApiExpand = cssc::ChartLegendExpansion_CUSTOM;
2541                 sal_Int32 nWidthHmm = static_cast< sal_Int32 >( pFramePos->maRect.mnWidth / EXC_POINTS_PER_HMM );
2542                 sal_Int32 nHeightHmm = static_cast< sal_Int32 >( pFramePos->maRect.mnHeight / EXC_POINTS_PER_HMM );
2543                 RelativeSize aRelSize( CalcRelativeFromHmmX( nWidthHmm ), CalcRelativeFromHmmY( nHeightHmm ) );
2544                 aLegendProp.SetProperty( EXC_CHPROP_RELATIVESIZE, aRelSize );
2545             }
2546             else
2547             {
2548                 // automatic size: determine entry direction from flags
2549                 eApiExpand = ::get_flagvalue( maData.mnFlags, EXC_CHLEGEND_STACKED,
2550                     cssc::ChartLegendExpansion_HIGH, cssc::ChartLegendExpansion_WIDE );
2551             }
2552         }
2553         aLegendProp.SetProperty( EXC_CHPROP_ANCHORPOSITION, eApiPos );
2554         aLegendProp.SetProperty( EXC_CHPROP_EXPANSION, eApiExpand );
2555     }
2556     return xLegend;
2557 }
2558 
2559 // ----------------------------------------------------------------------------
2560 
XclImpChDropBar(sal_uInt16 nDropBar)2561 XclImpChDropBar::XclImpChDropBar( sal_uInt16 nDropBar ) :
2562     mnDropBar( nDropBar ),
2563     mnBarDist( 0 )
2564 {
2565 }
2566 
ReadHeaderRecord(XclImpStream & rStrm)2567 void XclImpChDropBar::ReadHeaderRecord( XclImpStream& rStrm )
2568 {
2569     rStrm >> mnBarDist;
2570 }
2571 
Convert(const XclImpChRoot & rRoot,ScfPropertySet & rPropSet) const2572 void XclImpChDropBar::Convert( const XclImpChRoot& rRoot, ScfPropertySet& rPropSet ) const
2573 {
2574     XclChObjectType eObjType = EXC_CHOBJTYPE_BACKGROUND;
2575     switch( mnDropBar )
2576     {
2577         case EXC_CHDROPBAR_UP:      eObjType = EXC_CHOBJTYPE_WHITEDROPBAR;  break;
2578         case EXC_CHDROPBAR_DOWN:    eObjType = EXC_CHOBJTYPE_BLACKDROPBAR;  break;
2579     }
2580     ConvertFrameBase( rRoot, rPropSet, eObjType );
2581 }
2582 
2583 // ----------------------------------------------------------------------------
2584 
XclImpChTypeGroup(const XclImpChRoot & rRoot)2585 XclImpChTypeGroup::XclImpChTypeGroup( const XclImpChRoot& rRoot ) :
2586     XclImpChRoot( rRoot ),
2587     maType( rRoot ),
2588     maTypeInfo( maType.GetTypeInfo() )
2589 {
2590     // Initialize unused format indexes set. At this time, all formats are unused.
2591     for( sal_uInt16 nFormatIdx = 0; nFormatIdx <= EXC_CHSERIES_MAXSERIES; ++nFormatIdx )
2592         maUnusedFormats.insert( maUnusedFormats.end(), nFormatIdx );
2593 }
2594 
ReadHeaderRecord(XclImpStream & rStrm)2595 void XclImpChTypeGroup::ReadHeaderRecord( XclImpStream& rStrm )
2596 {
2597     rStrm.Ignore( 16 );
2598     rStrm >> maData.mnFlags >> maData.mnGroupIdx;
2599 }
2600 
ReadSubRecord(XclImpStream & rStrm)2601 void XclImpChTypeGroup::ReadSubRecord( XclImpStream& rStrm )
2602 {
2603     switch( rStrm.GetRecId() )
2604     {
2605         case EXC_ID_CHCHART3D:
2606             mxChart3d.reset( new XclImpChChart3d );
2607             mxChart3d->ReadChChart3d( rStrm );
2608         break;
2609         case EXC_ID_CHLEGEND:
2610             mxLegend.reset( new XclImpChLegend( GetChRoot() ) );
2611             mxLegend->ReadRecordGroup( rStrm );
2612         break;
2613         case EXC_ID_CHDEFAULTTEXT:
2614             GetChartData().ReadChDefaultText( rStrm );
2615         break;
2616         case EXC_ID_CHDROPBAR:
2617             ReadChDropBar( rStrm );
2618         break;
2619         case EXC_ID_CHCHARTLINE:
2620             ReadChChartLine( rStrm );
2621         break;
2622         case EXC_ID_CHDATAFORMAT:
2623             ReadChDataFormat( rStrm );
2624         break;
2625         default:
2626             maType.ReadChType( rStrm );
2627     }
2628 }
2629 
Finalize()2630 void XclImpChTypeGroup::Finalize()
2631 {
2632     // check and set valid chart type
2633     bool bStockChart =
2634         (maType.GetRecId() == EXC_ID_CHLINE) &&         // must be a line chart
2635         !mxChart3d &&                                   // must be a 2d chart
2636         HasHiLoLine() &&                                // must contain hi-lo lines
2637         (maSeries.size() == static_cast<XclImpChSeriesVec::size_type>(HasDropBars() ? 4 : 3));   // correct series count
2638     maType.Finalize( bStockChart );
2639 
2640     // extended type info
2641     maTypeInfo.Set( maType.GetTypeInfo(), mxChart3d.is(), false );
2642 
2643     // reverse series order for some unstacked 2D chart types
2644     if( maTypeInfo.mbReverseSeries && !Is3dChart() && !maType.IsStacked() && !maType.IsPercent() )
2645         ::std::reverse( maSeries.begin(), maSeries.end() );
2646 
2647     // update chart type group format, may depend on chart type finalized above
2648     if( mxGroupFmt.is() )
2649         mxGroupFmt->UpdateGroupFormat( maTypeInfo );
2650 }
2651 
AddSeries(XclImpChSeriesRef xSeries)2652 void XclImpChTypeGroup::AddSeries( XclImpChSeriesRef xSeries )
2653 {
2654     if( xSeries.is() )
2655         maSeries.push_back( xSeries );
2656     // store first inserted series separately, series order may be reversed later
2657     if( !mxFirstSeries )
2658         mxFirstSeries = xSeries;
2659 }
2660 
SetUsedFormatIndex(sal_uInt16 nFormatIdx)2661 void XclImpChTypeGroup::SetUsedFormatIndex( sal_uInt16 nFormatIdx )
2662 {
2663     maUnusedFormats.erase( nFormatIdx );
2664 }
2665 
PopUnusedFormatIndex()2666 sal_uInt16 XclImpChTypeGroup::PopUnusedFormatIndex()
2667 {
2668     DBG_ASSERT( !maUnusedFormats.empty(), "XclImpChTypeGroup::PopUnusedFormatIndex - no more format indexes available" );
2669     sal_uInt16 nFormatIdx = maUnusedFormats.empty() ? 0 : *maUnusedFormats.begin();
2670     SetUsedFormatIndex( nFormatIdx );
2671     return nFormatIdx;
2672 }
2673 
HasVarPointFormat() const2674 bool XclImpChTypeGroup::HasVarPointFormat() const
2675 {
2676     return ::get_flag( maData.mnFlags, EXC_CHTYPEGROUP_VARIEDCOLORS ) &&
2677         ((maTypeInfo.meVarPointMode == EXC_CHVARPOINT_MULTI) ||         // multiple series allowed
2678             ((maTypeInfo.meVarPointMode == EXC_CHVARPOINT_SINGLE) &&    // or exactly 1 series?
2679                 (maSeries.size() == 1)));
2680 }
2681 
HasConnectorLines() const2682 bool XclImpChTypeGroup::HasConnectorLines() const
2683 {
2684     // existence of connector lines (only in stacked bar charts)
2685     bool bAnyStacked = maType.IsStacked() || maType.IsPercent();
2686     XclImpChLineFormatRef xConnLine = maChartLines.get( EXC_CHCHARTLINE_CONNECT );
2687     return bAnyStacked && (maTypeInfo.meTypeCateg == EXC_CHTYPECATEG_BAR) && xConnLine.is() && xConnLine->HasLine();
2688 }
2689 
GetSingleSeriesTitle() const2690 const String& XclImpChTypeGroup::GetSingleSeriesTitle() const
2691 {
2692     // no automatic title for series with trendlines or error bars
2693     // pie charts always show an automatic title, even if more series exist
2694     return (mxFirstSeries.is() && !mxFirstSeries->HasChildSeries() && (maTypeInfo.mbSingleSeriesVis || (maSeries.size() == 1))) ?
2695         mxFirstSeries->GetTitle() : String::EmptyString();
2696 }
2697 
ConvertChart3d(ScfPropertySet & rPropSet) const2698 void XclImpChTypeGroup::ConvertChart3d( ScfPropertySet& rPropSet ) const
2699 {
2700     if( mxChart3d.is() )
2701         mxChart3d->Convert( rPropSet, Is3dWallChart() );
2702 }
2703 
CreateCoordSystem() const2704 Reference< XCoordinateSystem > XclImpChTypeGroup::CreateCoordSystem() const
2705 {
2706     return maType.CreateCoordSystem( Is3dChart() );
2707 }
2708 
CreateChartType(Reference<XDiagram> xDiagram,sal_Int32 nApiAxesSetIdx) const2709 Reference< XChartType > XclImpChTypeGroup::CreateChartType( Reference< XDiagram > xDiagram, sal_Int32 nApiAxesSetIdx ) const
2710 {
2711     DBG_ASSERT( IsValidGroup(), "XclImpChTypeGroup::CreateChartType - type group without series" );
2712 
2713     // create the chart type object
2714     Reference< XChartType > xChartType = maType.CreateChartType( xDiagram, Is3dChart() );
2715 
2716     // bar chart connector lines
2717     if( HasConnectorLines() )
2718     {
2719         ScfPropertySet aDiaProp( xDiagram );
2720         aDiaProp.SetBoolProperty( EXC_CHPROP_CONNECTBARS, true );
2721     }
2722 
2723     /*  Stock chart needs special processing. Create one 'big' series with
2724         data sequences of different roles. */
2725     if( maTypeInfo.meTypeId == EXC_CHTYPEID_STOCK )
2726         CreateStockSeries( xChartType, nApiAxesSetIdx );
2727     else
2728         CreateDataSeries( xChartType, nApiAxesSetIdx );
2729 
2730     return xChartType;
2731 }
2732 
CreateCategSequence() const2733 Reference< XLabeledDataSequence > XclImpChTypeGroup::CreateCategSequence() const
2734 {
2735     Reference< XLabeledDataSequence > xLabeledSeq;
2736     // create category sequence from first visible series
2737     if( mxFirstSeries.is() )
2738         xLabeledSeq = mxFirstSeries->CreateCategSequence( EXC_CHPROP_ROLE_CATEG );
2739     return xLabeledSeq;
2740 }
2741 
ReadChDropBar(XclImpStream & rStrm)2742 void XclImpChTypeGroup::ReadChDropBar( XclImpStream& rStrm )
2743 {
2744     sal_uInt16 nDropBar = EXC_CHDROPBAR_NONE;
2745     if( !maDropBars.has( EXC_CHDROPBAR_UP ) )
2746         nDropBar = EXC_CHDROPBAR_UP;
2747     else if( !maDropBars.has( EXC_CHDROPBAR_DOWN ) )
2748         nDropBar = EXC_CHDROPBAR_DOWN;
2749 
2750     if( nDropBar != EXC_CHDROPBAR_NONE )
2751     {
2752         XclImpChDropBarRef xDropBar( new XclImpChDropBar( nDropBar ) );
2753         xDropBar->ReadRecordGroup( rStrm );
2754         maDropBars[ nDropBar ] = xDropBar;
2755     }
2756 }
2757 
ReadChChartLine(XclImpStream & rStrm)2758 void XclImpChTypeGroup::ReadChChartLine( XclImpStream& rStrm )
2759 {
2760     sal_uInt16 nLineId = rStrm.ReaduInt16();
2761     if( (rStrm.GetNextRecId() == EXC_ID_CHLINEFORMAT) && rStrm.StartNextRecord() )
2762     {
2763         XclImpChLineFormatRef xLineFmt( new XclImpChLineFormat );
2764         xLineFmt->ReadChLineFormat( rStrm );
2765         maChartLines[ nLineId ] = xLineFmt;
2766     }
2767 }
2768 
ReadChDataFormat(XclImpStream & rStrm)2769 void XclImpChTypeGroup::ReadChDataFormat( XclImpStream& rStrm )
2770 {
2771     // global series and data point format
2772     XclImpChDataFormatRef xDataFmt( new XclImpChDataFormat( GetChRoot() ) );
2773     xDataFmt->ReadRecordGroup( rStrm );
2774     const XclChDataPointPos& rPos = xDataFmt->GetPointPos();
2775     if( (rPos.mnSeriesIdx == 0) && (rPos.mnPointIdx == 0) &&
2776             (xDataFmt->GetFormatIdx() == EXC_CHDATAFORMAT_DEFAULT) )
2777         mxGroupFmt = xDataFmt;
2778 }
2779 
2780 
InsertDataSeries(Reference<XChartType> xChartType,Reference<XDataSeries> xSeries,sal_Int32 nApiAxesSetIdx) const2781 void XclImpChTypeGroup::InsertDataSeries( Reference< XChartType > xChartType,
2782         Reference< XDataSeries > xSeries, sal_Int32 nApiAxesSetIdx ) const
2783 {
2784     Reference< XDataSeriesContainer > xSeriesCont( xChartType, UNO_QUERY );
2785     if( xSeriesCont.is() && xSeries.is() )
2786     {
2787         // series stacking mode
2788         cssc2::StackingDirection eStacking = cssc2::StackingDirection_NO_STACKING;
2789         // stacked overrides deep-3d
2790         if( maType.IsStacked() || maType.IsPercent() )
2791             eStacking = cssc2::StackingDirection_Y_STACKING;
2792         else if( Is3dDeepChart() )
2793             eStacking = cssc2::StackingDirection_Z_STACKING;
2794 
2795         // additional series properties
2796         ScfPropertySet aSeriesProp( xSeries );
2797         aSeriesProp.SetProperty( EXC_CHPROP_STACKINGDIR, eStacking );
2798         aSeriesProp.SetProperty( EXC_CHPROP_ATTAXISINDEX, nApiAxesSetIdx );
2799 
2800         // insert series into container
2801         try
2802         {
2803             xSeriesCont->addDataSeries( xSeries );
2804         }
2805         catch( Exception& )
2806         {
2807             DBG_ERRORFILE( "XclImpChTypeGroup::InsertDataSeries - cannot add data series" );
2808         }
2809     }
2810 }
2811 
CreateDataSeries(Reference<XChartType> xChartType,sal_Int32 nApiAxesSetIdx) const2812 void XclImpChTypeGroup::CreateDataSeries( Reference< XChartType > xChartType, sal_Int32 nApiAxesSetIdx ) const
2813 {
2814     bool bSpline = false;
2815     for( XclImpChSeriesVec::const_iterator aIt = maSeries.begin(), aEnd = maSeries.end(); aIt != aEnd; ++aIt )
2816     {
2817         Reference< XDataSeries > xDataSeries = (*aIt)->CreateDataSeries();
2818         InsertDataSeries( xChartType, xDataSeries, nApiAxesSetIdx );
2819         bSpline |= (*aIt)->HasSpline();
2820     }
2821     // spline - TODO: set at single series (#i66858#)
2822     if( bSpline && !maTypeInfo.IsSeriesFrameFormat() && (maTypeInfo.meTypeCateg != EXC_CHTYPECATEG_RADAR) )
2823     {
2824         ScfPropertySet aTypeProp( xChartType );
2825         aTypeProp.SetProperty( EXC_CHPROP_CURVESTYLE, ::com::sun::star::chart2::CurveStyle_CUBIC_SPLINES );
2826     }
2827 }
2828 
CreateStockSeries(Reference<XChartType> xChartType,sal_Int32 nApiAxesSetIdx) const2829 void XclImpChTypeGroup::CreateStockSeries( Reference< XChartType > xChartType, sal_Int32 nApiAxesSetIdx ) const
2830 {
2831     // create the data series object
2832     Reference< XDataSeries > xDataSeries( ScfApiHelper::CreateInstance( SERVICE_CHART2_DATASERIES ), UNO_QUERY );
2833     Reference< XDataSink > xDataSink( xDataSeries, UNO_QUERY );
2834     if( xDataSink.is() )
2835     {
2836         // create a list of data sequences from all series
2837         ::std::vector< Reference< XLabeledDataSequence > > aLabeledSeqVec;
2838         DBG_ASSERT( maSeries.size() >= 3, "XclImpChTypeGroup::CreateChartType - missing stock series" );
2839         int nRoleIdx = (maSeries.size() == 3) ? 1 : 0;
2840         for( XclImpChSeriesVec::const_iterator aIt = maSeries.begin(), aEnd = maSeries.end();
2841                 (nRoleIdx < 4) && (aIt != aEnd); ++nRoleIdx, ++aIt )
2842         {
2843             // create a data sequence with a specific role
2844             OUString aRole;
2845             switch( nRoleIdx )
2846             {
2847                 case 0: aRole = EXC_CHPROP_ROLE_OPENVALUES;     break;
2848                 case 1: aRole = EXC_CHPROP_ROLE_HIGHVALUES;     break;
2849                 case 2: aRole = EXC_CHPROP_ROLE_LOWVALUES;      break;
2850                 case 3: aRole = EXC_CHPROP_ROLE_CLOSEVALUES;    break;
2851             }
2852             Reference< XLabeledDataSequence > xDataSeq = (*aIt)->CreateValueSequence( aRole );
2853             if( xDataSeq.is() )
2854                 aLabeledSeqVec.push_back( xDataSeq );
2855         }
2856 
2857         // attach labeled data sequences to series and insert series into chart type
2858         xDataSink->setData( ScfApiHelper::VectorToSequence( aLabeledSeqVec ) );
2859 
2860         // formatting of special stock chart elements
2861         ScfPropertySet aTypeProp( xChartType );
2862         aTypeProp.SetBoolProperty( EXC_CHPROP_JAPANESE, HasDropBars() );
2863         aTypeProp.SetBoolProperty( EXC_CHPROP_SHOWFIRST, HasDropBars() );
2864         aTypeProp.SetBoolProperty( EXC_CHPROP_SHOWHIGHLOW, true );
2865         // hi-lo line format
2866         XclImpChLineFormatRef xHiLoLine = maChartLines.get( EXC_CHCHARTLINE_HILO );
2867         if( xHiLoLine.is() )
2868         {
2869             ScfPropertySet aSeriesProp( xDataSeries );
2870             xHiLoLine->Convert( GetChRoot(), aSeriesProp, EXC_CHOBJTYPE_HILOLINE );
2871         }
2872         // white dropbar format
2873         XclImpChDropBarRef xUpBar = maDropBars.get( EXC_CHDROPBAR_UP );
2874         Reference< XPropertySet > xWhitePropSet;
2875         if( xUpBar.is() && aTypeProp.GetProperty( xWhitePropSet, EXC_CHPROP_WHITEDAY ) )
2876         {
2877             ScfPropertySet aBarProp( xWhitePropSet );
2878             xUpBar->Convert( GetChRoot(), aBarProp );
2879         }
2880         // black dropbar format
2881         XclImpChDropBarRef xDownBar = maDropBars.get( EXC_CHDROPBAR_DOWN );
2882         Reference< XPropertySet > xBlackPropSet;
2883         if( xDownBar.is() && aTypeProp.GetProperty( xBlackPropSet, EXC_CHPROP_BLACKDAY ) )
2884         {
2885             ScfPropertySet aBarProp( xBlackPropSet );
2886             xDownBar->Convert( GetChRoot(), aBarProp );
2887         }
2888 
2889         // insert the series into the chart type object
2890         InsertDataSeries( xChartType, xDataSeries, nApiAxesSetIdx );
2891     }
2892 }
2893 
2894 // Axes =======================================================================
2895 
XclImpChLabelRange(const XclImpChRoot & rRoot)2896 XclImpChLabelRange::XclImpChLabelRange( const XclImpChRoot& rRoot ) :
2897     XclImpChRoot( rRoot )
2898 {
2899 }
2900 
ReadChLabelRange(XclImpStream & rStrm)2901 void XclImpChLabelRange::ReadChLabelRange( XclImpStream& rStrm )
2902 {
2903     rStrm >> maLabelData.mnCross >> maLabelData.mnLabelFreq >> maLabelData.mnTickFreq >> maLabelData.mnFlags;
2904 }
2905 
ReadChDateRange(XclImpStream & rStrm)2906 void XclImpChLabelRange::ReadChDateRange( XclImpStream& rStrm )
2907 {
2908     rStrm   >> maDateData.mnMinDate
2909             >> maDateData.mnMaxDate
2910             >> maDateData.mnMajorStep
2911             >> maDateData.mnMajorUnit
2912             >> maDateData.mnMinorStep
2913             >> maDateData.mnMinorUnit
2914             >> maDateData.mnBaseUnit
2915             >> maDateData.mnCross
2916             >> maDateData.mnFlags;
2917 }
2918 
Convert(ScfPropertySet & rPropSet,ScaleData & rScaleData,bool bMirrorOrient) const2919 void XclImpChLabelRange::Convert( ScfPropertySet& rPropSet, ScaleData& rScaleData, bool bMirrorOrient ) const
2920 {
2921     // automatic axis type detection
2922     rScaleData.AutoDateAxis = ::get_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTODATE );
2923 
2924     // the flag EXC_CHDATERANGE_DATEAXIS specifies whether this is a date axis
2925     if( ::get_flag( maDateData.mnFlags, EXC_CHDATERANGE_DATEAXIS ) )
2926     {
2927         /*  Chart2 requires axis type CATEGORY for automatic category/date axis
2928             (even if it is a date axis currently). */
2929         rScaleData.AxisType = rScaleData.AutoDateAxis ? cssc2::AxisType::CATEGORY : cssc2::AxisType::DATE;
2930         rScaleData.Scaling.set( ScfApiHelper::CreateInstance( SERVICE_CHART2_LINEARSCALING ), UNO_QUERY );
2931         /*  Min/max values depend on base time unit, they specify the number of
2932             days, months, or years starting from null date. */
2933         lclConvertTimeValue( GetRoot(), rScaleData.Minimum, maDateData.mnMinDate, ::get_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOMIN ), maDateData.mnBaseUnit );
2934         lclConvertTimeValue( GetRoot(), rScaleData.Maximum, maDateData.mnMaxDate, ::get_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOMAX ), maDateData.mnBaseUnit );
2935         // increment
2936         cssc::TimeIncrement& rTimeIncrement = rScaleData.TimeIncrement;
2937         lclConvertTimeInterval( rTimeIncrement.MajorTimeInterval, maDateData.mnMajorStep, ::get_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOMAJOR ), maDateData.mnMajorUnit );
2938         lclConvertTimeInterval( rTimeIncrement.MinorTimeInterval, maDateData.mnMinorStep, ::get_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOMINOR ), maDateData.mnMinorUnit );
2939         // base unit
2940         if( ::get_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOBASE ) )
2941             rTimeIncrement.TimeResolution.clear();
2942         else
2943             rTimeIncrement.TimeResolution <<= lclGetApiTimeUnit( maDateData.mnBaseUnit );
2944     }
2945     else
2946     {
2947         // do not overlap text unless all labels are visible
2948         rPropSet.SetBoolProperty( EXC_CHPROP_TEXTOVERLAP, maLabelData.mnLabelFreq == 1 );
2949         // do not break text into several lines unless all labels are visible
2950         rPropSet.SetBoolProperty( EXC_CHPROP_TEXTBREAK, maLabelData.mnLabelFreq == 1 );
2951         // do not stagger labels in two lines
2952         rPropSet.SetProperty( EXC_CHPROP_ARRANGEORDER, cssc::ChartAxisArrangeOrderType_SIDE_BY_SIDE );
2953     }
2954 
2955     // reverse order
2956     bool bReverse = ::get_flag( maLabelData.mnFlags, EXC_CHLABELRANGE_REVERSE ) != bMirrorOrient;
2957     rScaleData.Orientation = bReverse ? cssc2::AxisOrientation_REVERSE : cssc2::AxisOrientation_MATHEMATICAL;
2958 
2959     //! TODO #i58731# show n-th category
2960 }
2961 
ConvertAxisPosition(ScfPropertySet & rPropSet,bool b3dChart) const2962 void XclImpChLabelRange::ConvertAxisPosition( ScfPropertySet& rPropSet, bool b3dChart ) const
2963 {
2964     /*  Crossing mode (max-cross flag overrides other crossing settings). Excel
2965         does not move the Y axis in 3D charts, regardless of actual settings.
2966         But: the Y axis has to be moved to "end", if the X axis is mirrored,
2967         to keep it at the left end of the chart. */
2968     bool bMaxCross = ::get_flag( maLabelData.mnFlags, b3dChart ? EXC_CHLABELRANGE_REVERSE : EXC_CHLABELRANGE_MAXCROSS );
2969     cssc::ChartAxisPosition eAxisPos = bMaxCross ? cssc::ChartAxisPosition_END : cssc::ChartAxisPosition_VALUE;
2970     rPropSet.SetProperty( EXC_CHPROP_CROSSOVERPOSITION, eAxisPos );
2971 
2972     // crossing position (depending on axis type text/date)
2973     if( ::get_flag( maDateData.mnFlags, EXC_CHDATERANGE_DATEAXIS ) )
2974     {
2975         bool bAutoCross = ::get_flag( maDateData.mnFlags, EXC_CHDATERANGE_AUTOCROSS );
2976         /*  Crossing position value depends on base time unit, it specifies the
2977             number of days, months, or years from null date. Note that Excel
2978             2007/2010 write broken BIFF8 files, they always stores the number
2979             of days cregardless of the base time unit (and they are reading it
2980             the same way, thus wrongly displaying files written by Excel
2981             97-2003). This filter sticks to the correct behaviour of Excel
2982             97-2003. */
2983         double fCrossingPos = bAutoCross ? 1.0 : lclGetSerialDay( GetRoot(), maDateData.mnCross, maDateData.mnBaseUnit );
2984         rPropSet.SetProperty( EXC_CHPROP_CROSSOVERVALUE, fCrossingPos );
2985     }
2986     else
2987     {
2988         double fCrossingPos = b3dChart ? 1.0 : maLabelData.mnCross;
2989         rPropSet.SetProperty( EXC_CHPROP_CROSSOVERVALUE, fCrossingPos );
2990     }
2991 }
2992 
2993 // ----------------------------------------------------------------------------
2994 
XclImpChValueRange(const XclImpChRoot & rRoot)2995 XclImpChValueRange::XclImpChValueRange( const XclImpChRoot& rRoot ) :
2996     XclImpChRoot( rRoot )
2997 {
2998 }
2999 
ReadChValueRange(XclImpStream & rStrm)3000 void XclImpChValueRange::ReadChValueRange( XclImpStream& rStrm )
3001 {
3002     rStrm   >> maData.mfMin
3003             >> maData.mfMax
3004             >> maData.mfMajorStep
3005             >> maData.mfMinorStep
3006             >> maData.mfCross
3007             >> maData.mnFlags;
3008 }
3009 
Convert(ScaleData & rScaleData,bool bMirrorOrient) const3010 void XclImpChValueRange::Convert( ScaleData& rScaleData, bool bMirrorOrient ) const
3011 {
3012     // scaling algorithm
3013     bool bLogScale = ::get_flag( maData.mnFlags, EXC_CHVALUERANGE_LOGSCALE );
3014     OUString aScalingService = bLogScale ? SERVICE_CHART2_LOGSCALING : SERVICE_CHART2_LINEARSCALING;
3015     rScaleData.Scaling.set( ScfApiHelper::CreateInstance( aScalingService ), UNO_QUERY );
3016 
3017     // min/max
3018     lclSetExpValueOrClearAny( rScaleData.Minimum, maData.mfMin, bLogScale, ::get_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOMIN ) );
3019     lclSetExpValueOrClearAny( rScaleData.Maximum, maData.mfMax, bLogScale, ::get_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOMAX ) );
3020 
3021     // increment
3022     bool bAutoMajor = ::get_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOMAJOR );
3023     bool bAutoMinor = ::get_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOMINOR );
3024     // major increment
3025     IncrementData& rIncrementData = rScaleData.IncrementData;
3026     lclSetValueOrClearAny( rIncrementData.Distance, maData.mfMajorStep, bAutoMajor );
3027     // minor increment
3028     Sequence< SubIncrement >& rSubIncrementSeq = rIncrementData.SubIncrements;
3029     rSubIncrementSeq.realloc( 1 );
3030     Any& rIntervalCount = rSubIncrementSeq[ 0 ].IntervalCount;
3031     rIntervalCount.clear();
3032     if( bLogScale )
3033     {
3034         if( !bAutoMinor )
3035             rIntervalCount <<= sal_Int32( 9 );
3036     }
3037     else
3038     {
3039         if( !bAutoMajor && !bAutoMinor && (0.0 < maData.mfMinorStep) && (maData.mfMinorStep <= maData.mfMajorStep) )
3040         {
3041             double fCount = maData.mfMajorStep / maData.mfMinorStep + 0.5;
3042             if( (1.0 <= fCount) && (fCount < 1001.0) )
3043                 rIntervalCount <<= static_cast< sal_Int32 >( fCount );
3044         }
3045     }
3046 
3047     // reverse order
3048     bool bReverse = ::get_flag( maData.mnFlags, EXC_CHVALUERANGE_REVERSE ) != bMirrorOrient;
3049     rScaleData.Orientation = bReverse ? cssc2::AxisOrientation_REVERSE : cssc2::AxisOrientation_MATHEMATICAL;
3050 }
3051 
ConvertAxisPosition(ScfPropertySet & rPropSet) const3052 void XclImpChValueRange::ConvertAxisPosition( ScfPropertySet& rPropSet ) const
3053 {
3054     bool bMaxCross = ::get_flag( maData.mnFlags, EXC_CHVALUERANGE_MAXCROSS );
3055     bool bAutoCross = ::get_flag( maData.mnFlags, EXC_CHVALUERANGE_AUTOCROSS );
3056     bool bLogScale = ::get_flag( maData.mnFlags, EXC_CHVALUERANGE_LOGSCALE );
3057 
3058     // crossing mode (max-cross flag overrides other crossing settings)
3059     cssc::ChartAxisPosition eAxisPos = bMaxCross ? cssc::ChartAxisPosition_END : cssc::ChartAxisPosition_VALUE;
3060     rPropSet.SetProperty( EXC_CHPROP_CROSSOVERPOSITION, eAxisPos );
3061 
3062     // crossing position
3063     double fCrossingPos = bAutoCross ? 0.0 : maData.mfCross;
3064     if( bLogScale ) fCrossingPos = pow( 10.0, fCrossingPos );
3065     rPropSet.SetProperty( EXC_CHPROP_CROSSOVERVALUE, fCrossingPos );
3066 }
3067 
3068 // ----------------------------------------------------------------------------
3069 
3070 namespace {
3071 
lclGetApiTickmarks(sal_uInt8 nXclTickPos)3072 sal_Int32 lclGetApiTickmarks( sal_uInt8 nXclTickPos )
3073 {
3074     using namespace ::com::sun::star::chart2::TickmarkStyle;
3075     sal_Int32 nApiTickmarks = NONE;
3076     ::set_flag( nApiTickmarks, INNER, ::get_flag( nXclTickPos, EXC_CHTICK_INSIDE ) );
3077     ::set_flag( nApiTickmarks, OUTER, ::get_flag( nXclTickPos, EXC_CHTICK_OUTSIDE ) );
3078     return nApiTickmarks;
3079 }
3080 
lclGetApiLabelPosition(sal_Int8 nXclLabelPos)3081 cssc::ChartAxisLabelPosition lclGetApiLabelPosition( sal_Int8 nXclLabelPos )
3082 {
3083     using namespace ::com::sun::star::chart;
3084     switch( nXclLabelPos )
3085     {
3086         case EXC_CHTICK_LOW:    return ChartAxisLabelPosition_OUTSIDE_START;
3087         case EXC_CHTICK_HIGH:   return ChartAxisLabelPosition_OUTSIDE_END;
3088         case EXC_CHTICK_NEXT:   return ChartAxisLabelPosition_NEAR_AXIS;
3089     }
3090     return ChartAxisLabelPosition_NEAR_AXIS;
3091 }
3092 
3093 } // namespace
3094 
XclImpChTick(const XclImpChRoot & rRoot)3095 XclImpChTick::XclImpChTick( const XclImpChRoot& rRoot ) :
3096     XclImpChRoot( rRoot )
3097 {
3098 }
3099 
ReadChTick(XclImpStream & rStrm)3100 void XclImpChTick::ReadChTick( XclImpStream& rStrm )
3101 {
3102     rStrm   >> maData.mnMajor
3103             >> maData.mnMinor
3104             >> maData.mnLabelPos
3105             >> maData.mnBackMode;
3106     rStrm.Ignore( 16 );
3107     rStrm   >> maData.maTextColor
3108             >> maData.mnFlags;
3109 
3110     if( GetBiff() == EXC_BIFF8 )
3111     {
3112         // #116397# BIFF8: index into palette used instead of RGB data
3113         maData.maTextColor = GetPalette().GetColor( rStrm.ReaduInt16() );
3114         // rotation
3115         rStrm >> maData.mnRotation;
3116     }
3117     else
3118     {
3119         // BIFF2-BIFF7: get rotation from text orientation
3120         sal_uInt8 nOrient = ::extract_value< sal_uInt8 >( maData.mnFlags, 2, 3 );
3121         maData.mnRotation = XclTools::GetXclRotFromOrient( nOrient );
3122     }
3123 }
3124 
GetFontColor() const3125 Color XclImpChTick::GetFontColor() const
3126 {
3127     return ::get_flag( maData.mnFlags, EXC_CHTICK_AUTOCOLOR ) ? GetFontAutoColor() : maData.maTextColor;
3128 }
3129 
GetRotation() const3130 sal_uInt16 XclImpChTick::GetRotation() const
3131 {
3132     return ::get_flag( maData.mnFlags, EXC_CHTICK_AUTOROT ) ? EXC_CHART_AUTOROTATION : maData.mnRotation;
3133 }
3134 
Convert(ScfPropertySet & rPropSet) const3135 void XclImpChTick::Convert( ScfPropertySet& rPropSet ) const
3136 {
3137     rPropSet.SetProperty( EXC_CHPROP_MAJORTICKS, lclGetApiTickmarks( maData.mnMajor ) );
3138     rPropSet.SetProperty( EXC_CHPROP_MINORTICKS, lclGetApiTickmarks( maData.mnMinor ) );
3139     rPropSet.SetProperty( EXC_CHPROP_LABELPOSITION, lclGetApiLabelPosition( maData.mnLabelPos ) );
3140     rPropSet.SetProperty( EXC_CHPROP_MARKPOSITION, cssc::ChartAxisMarkPosition_AT_AXIS );
3141 }
3142 
3143 // ----------------------------------------------------------------------------
3144 
XclImpChAxis(const XclImpChRoot & rRoot,sal_uInt16 nAxisType)3145 XclImpChAxis::XclImpChAxis( const XclImpChRoot& rRoot, sal_uInt16 nAxisType ) :
3146     XclImpChRoot( rRoot ),
3147     mnNumFmtIdx( EXC_FORMAT_NOTFOUND )
3148 {
3149     maData.mnType = nAxisType;
3150 }
3151 
ReadHeaderRecord(XclImpStream & rStrm)3152 void XclImpChAxis::ReadHeaderRecord( XclImpStream& rStrm )
3153 {
3154     rStrm >> maData.mnType;
3155 }
3156 
ReadSubRecord(XclImpStream & rStrm)3157 void XclImpChAxis::ReadSubRecord( XclImpStream& rStrm )
3158 {
3159     switch( rStrm.GetRecId() )
3160     {
3161         case EXC_ID_CHLABELRANGE:
3162             mxLabelRange.reset( new XclImpChLabelRange( GetChRoot() ) );
3163             mxLabelRange->ReadChLabelRange( rStrm );
3164         break;
3165         case EXC_ID_CHDATERANGE:
3166             if( !mxLabelRange )
3167                 mxLabelRange.reset( new XclImpChLabelRange( GetChRoot() ) );
3168             mxLabelRange->ReadChDateRange( rStrm );
3169         break;
3170         case EXC_ID_CHVALUERANGE:
3171             mxValueRange.reset( new XclImpChValueRange( GetChRoot() ) );
3172             mxValueRange->ReadChValueRange( rStrm );
3173         break;
3174         case EXC_ID_CHFORMAT:
3175             rStrm >> mnNumFmtIdx;
3176         break;
3177         case EXC_ID_CHTICK:
3178             mxTick.reset( new XclImpChTick( GetChRoot() ) );
3179             mxTick->ReadChTick( rStrm );
3180         break;
3181         case EXC_ID_CHFONT:
3182             mxFont.reset( new XclImpChFont );
3183             mxFont->ReadChFont( rStrm );
3184         break;
3185         case EXC_ID_CHAXISLINE:
3186             ReadChAxisLine( rStrm );
3187         break;
3188     }
3189 }
3190 
Finalize()3191 void XclImpChAxis::Finalize()
3192 {
3193     // add default scaling, needed e.g. to adjust rotation direction of pie and radar charts
3194     if( !mxLabelRange )
3195         mxLabelRange.reset( new XclImpChLabelRange( GetChRoot() ) );
3196     if( !mxValueRange )
3197         mxValueRange.reset( new XclImpChValueRange( GetChRoot() ) );
3198     // remove invisible grid lines completely
3199     if( mxMajorGrid.is() && !mxMajorGrid->HasLine() )
3200         mxMajorGrid.reset();
3201     if( mxMinorGrid.is() && !mxMinorGrid->HasLine() )
3202         mxMinorGrid.reset();
3203     // default tick settings different in OOChart and Excel
3204     if( !mxTick )
3205         mxTick.reset( new XclImpChTick( GetChRoot() ) );
3206     // #i4140# different default axis line color
3207     if( !mxAxisLine )
3208     {
3209         XclChLineFormat aLineFmt;
3210         // set "show axis" flag, default if line format record is missing
3211         ::set_flag( aLineFmt.mnFlags, EXC_CHLINEFORMAT_SHOWAXIS );
3212         mxAxisLine.reset( new XclImpChLineFormat( aLineFmt ) );
3213     }
3214     // add wall/floor frame for 3d charts
3215     if( !mxWallFrame )
3216         CreateWallFrame();
3217 }
3218 
GetFontIndex() const3219 sal_uInt16 XclImpChAxis::GetFontIndex() const
3220 {
3221     return mxFont.is() ? mxFont->GetFontIndex() : EXC_FONT_NOTFOUND;
3222 }
3223 
GetFontColor() const3224 Color XclImpChAxis::GetFontColor() const
3225 {
3226     return mxTick.is() ? mxTick->GetFontColor() : GetFontAutoColor();
3227 }
3228 
GetRotation() const3229 sal_uInt16 XclImpChAxis::GetRotation() const
3230 {
3231     return mxTick.is() ? mxTick->GetRotation() : EXC_CHART_AUTOROTATION;
3232 }
3233 
CreateAxis(const XclImpChTypeGroup & rTypeGroup,const XclImpChAxis * pCrossingAxis) const3234 Reference< XAxis > XclImpChAxis::CreateAxis( const XclImpChTypeGroup& rTypeGroup, const XclImpChAxis* pCrossingAxis ) const
3235 {
3236     // create the axis object (always)
3237     Reference< XAxis > xAxis( ScfApiHelper::CreateInstance( SERVICE_CHART2_AXIS ), UNO_QUERY );
3238     if( xAxis.is() )
3239     {
3240         ScfPropertySet aAxisProp( xAxis );
3241         // #i58688# axis enabled
3242         aAxisProp.SetBoolProperty( EXC_CHPROP_SHOW, IsActivated() );
3243 
3244         // axis line properties
3245         if( mxAxisLine.is() )
3246             mxAxisLine->Convert( GetChRoot(), aAxisProp, EXC_CHOBJTYPE_AXISLINE );
3247         // axis ticks properties
3248         if( mxTick.is() )
3249             mxTick->Convert( aAxisProp );
3250 
3251         // axis caption text --------------------------------------------------
3252 
3253         // radar charts disable their category labels via chart type, not via axis
3254         bool bHasLabels = HasLabels() &&
3255             ((GetAxisType() != EXC_CHAXIS_X) || rTypeGroup.HasCategoryLabels());
3256         aAxisProp.SetBoolProperty( EXC_CHPROP_DISPLAYLABELS, bHasLabels );
3257         if( bHasLabels )
3258         {
3259             // font settings from CHFONT record or from default text
3260             if( mxFont.is() )
3261                 ConvertFontBase( GetChRoot(), aAxisProp );
3262             else if( const XclImpChText* pDefText = GetChartData().GetDefaultText( EXC_CHTEXTTYPE_AXISLABEL ).get() )
3263                 pDefText->ConvertFont( aAxisProp );
3264             // label text rotation
3265             ConvertRotationBase( GetChRoot(), aAxisProp, true );
3266             // number format
3267             sal_uInt32 nScNumFmt = GetNumFmtBuffer().GetScFormat( mnNumFmtIdx );
3268             if( nScNumFmt != NUMBERFORMAT_ENTRY_NOT_FOUND )
3269                 aAxisProp.SetProperty( EXC_CHPROP_NUMBERFORMAT, static_cast< sal_Int32 >( nScNumFmt ) );
3270         }
3271 
3272         // axis scaling and increment -----------------------------------------
3273 
3274         const XclChExtTypeInfo& rTypeInfo = rTypeGroup.GetTypeInfo();
3275         ScaleData aScaleData = xAxis->getScaleData();
3276         // set axis type
3277         switch( GetAxisType() )
3278         {
3279             case EXC_CHAXIS_X:
3280                 if( rTypeInfo.mbCategoryAxis )
3281                 {
3282                     aScaleData.AxisType = cssc2::AxisType::CATEGORY;
3283                     aScaleData.Categories = rTypeGroup.CreateCategSequence();
3284                 }
3285                 else
3286                     aScaleData.AxisType = cssc2::AxisType::REALNUMBER;
3287             break;
3288             case EXC_CHAXIS_Y:
3289                 aScaleData.AxisType = rTypeGroup.IsPercent() ?
3290                     cssc2::AxisType::PERCENT : cssc2::AxisType::REALNUMBER;
3291             break;
3292             case EXC_CHAXIS_Z:
3293                 aScaleData.AxisType = cssc2::AxisType::SERIES;
3294             break;
3295         }
3296         // axis scaling settings, dependent on axis type
3297         switch( aScaleData.AxisType )
3298         {
3299             case cssc2::AxisType::CATEGORY:
3300             case cssc2::AxisType::SERIES:
3301                 // #i71684# radar charts have reversed rotation direction
3302                 mxLabelRange->Convert( aAxisProp, aScaleData, rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_RADAR );
3303             break;
3304             case cssc2::AxisType::REALNUMBER:
3305             case cssc2::AxisType::PERCENT:
3306                 // #i85167# pie/donut charts have reversed rotation direction (at Y axis!)
3307                 mxValueRange->Convert( aScaleData, rTypeInfo.meTypeCateg == EXC_CHTYPECATEG_PIE );
3308             break;
3309             default:
3310                 DBG_ERRORFILE( "XclImpChAxis::CreateAxis - unknown axis type" );
3311         }
3312 
3313         /*  Do not set a value to the Origin member anymore (will be done via
3314             new axis properties 'CrossoverPosition' and 'CrossoverValue'). */
3315         aScaleData.Origin.clear();
3316 
3317         // write back
3318         xAxis->setScaleData( aScaleData );
3319 
3320         // grid ---------------------------------------------------------------
3321 
3322         // main grid
3323         ScfPropertySet aGridProp( xAxis->getGridProperties() );
3324         aGridProp.SetBoolProperty( EXC_CHPROP_SHOW, HasMajorGrid() );
3325         if( mxMajorGrid.is() )
3326             mxMajorGrid->Convert( GetChRoot(), aGridProp, EXC_CHOBJTYPE_GRIDLINE );
3327         // sub grid
3328         Sequence< Reference< XPropertySet > > aSubGridPropSeq = xAxis->getSubGridProperties();
3329         if( aSubGridPropSeq.hasElements() )
3330         {
3331             ScfPropertySet aSubGridProp( aSubGridPropSeq[ 0 ] );
3332             aSubGridProp.SetBoolProperty( EXC_CHPROP_SHOW, HasMinorGrid() );
3333             if( mxMinorGrid.is() )
3334                 mxMinorGrid->Convert( GetChRoot(), aSubGridProp, EXC_CHOBJTYPE_GRIDLINE );
3335         }
3336 
3337         // position of crossing axis ------------------------------------------
3338 
3339         if( pCrossingAxis )
3340             pCrossingAxis->ConvertAxisPosition( aAxisProp, rTypeGroup );
3341     }
3342     return xAxis;
3343 }
3344 
ConvertWall(ScfPropertySet & rPropSet) const3345 void XclImpChAxis::ConvertWall( ScfPropertySet& rPropSet ) const
3346 {
3347     // #i71810# walls and floor in 3D charts use the CHPICFORMAT record for bitmap mode
3348     if( mxWallFrame.is() )
3349         mxWallFrame->Convert( rPropSet, true );
3350 }
3351 
ConvertAxisPosition(ScfPropertySet & rPropSet,const XclImpChTypeGroup & rTypeGroup) const3352 void XclImpChAxis::ConvertAxisPosition( ScfPropertySet& rPropSet, const XclImpChTypeGroup& rTypeGroup ) const
3353 {
3354     if( ((GetAxisType() == EXC_CHAXIS_X) && rTypeGroup.GetTypeInfo().mbCategoryAxis) || (GetAxisType() == EXC_CHAXIS_Z) )
3355         mxLabelRange->ConvertAxisPosition( rPropSet, rTypeGroup.Is3dChart() );
3356     else
3357         mxValueRange->ConvertAxisPosition( rPropSet );
3358 }
3359 
ReadChAxisLine(XclImpStream & rStrm)3360 void XclImpChAxis::ReadChAxisLine( XclImpStream& rStrm )
3361 {
3362     XclImpChLineFormatRef* pxLineFmt = 0;
3363     bool bWallFrame = false;
3364     switch( rStrm.ReaduInt16() )
3365     {
3366         case EXC_CHAXISLINE_AXISLINE:   pxLineFmt = &mxAxisLine;    break;
3367         case EXC_CHAXISLINE_MAJORGRID:  pxLineFmt = &mxMajorGrid;   break;
3368         case EXC_CHAXISLINE_MINORGRID:  pxLineFmt = &mxMinorGrid;   break;
3369         case EXC_CHAXISLINE_WALLS:      bWallFrame = true;          break;
3370     }
3371     if( bWallFrame )
3372         CreateWallFrame();
3373 
3374     bool bLoop = pxLineFmt || bWallFrame;
3375     while( bLoop )
3376     {
3377         sal_uInt16 nRecId = rStrm.GetNextRecId();
3378         bLoop = ((nRecId == EXC_ID_CHLINEFORMAT) ||
3379                  (nRecId == EXC_ID_CHAREAFORMAT) ||
3380                  (nRecId == EXC_ID_CHESCHERFORMAT))
3381                  && rStrm.StartNextRecord();
3382         if( bLoop )
3383         {
3384             if( pxLineFmt && (nRecId == EXC_ID_CHLINEFORMAT) )
3385             {
3386                 pxLineFmt->reset( new XclImpChLineFormat );
3387                 (*pxLineFmt)->ReadChLineFormat( rStrm );
3388             }
3389             else if( bWallFrame && mxWallFrame.is() )
3390             {
3391                 mxWallFrame->ReadSubRecord( rStrm );
3392             }
3393         }
3394     }
3395 }
3396 
CreateWallFrame()3397 void XclImpChAxis::CreateWallFrame()
3398 {
3399     switch( GetAxisType() )
3400     {
3401         case EXC_CHAXIS_X:
3402             mxWallFrame.reset( new XclImpChFrame( GetChRoot(), EXC_CHOBJTYPE_WALL3D ) );
3403         break;
3404         case EXC_CHAXIS_Y:
3405             mxWallFrame.reset( new XclImpChFrame( GetChRoot(), EXC_CHOBJTYPE_FLOOR3D ) );
3406         break;
3407         default:
3408             mxWallFrame.reset();
3409     }
3410 }
3411 
3412 // ----------------------------------------------------------------------------
3413 
XclImpChAxesSet(const XclImpChRoot & rRoot,sal_uInt16 nAxesSetId)3414 XclImpChAxesSet::XclImpChAxesSet( const XclImpChRoot& rRoot, sal_uInt16 nAxesSetId ) :
3415     XclImpChRoot( rRoot )
3416 {
3417     maData.mnAxesSetId = nAxesSetId;
3418 }
3419 
ReadHeaderRecord(XclImpStream & rStrm)3420 void XclImpChAxesSet::ReadHeaderRecord( XclImpStream& rStrm )
3421 {
3422     rStrm >> maData.mnAxesSetId >> maData.maRect;
3423 }
3424 
ReadSubRecord(XclImpStream & rStrm)3425 void XclImpChAxesSet::ReadSubRecord( XclImpStream& rStrm )
3426 {
3427     switch( rStrm.GetRecId() )
3428     {
3429         case EXC_ID_CHFRAMEPOS:
3430             mxFramePos.reset( new XclImpChFramePos );
3431             mxFramePos->ReadChFramePos( rStrm );
3432         break;
3433         case EXC_ID_CHAXIS:
3434             ReadChAxis( rStrm );
3435         break;
3436         case EXC_ID_CHTEXT:
3437             ReadChText( rStrm );
3438         break;
3439         case EXC_ID_CHPLOTFRAME:
3440             ReadChPlotFrame( rStrm );
3441         break;
3442         case EXC_ID_CHTYPEGROUP:
3443             ReadChTypeGroup( rStrm );
3444         break;
3445     }
3446 }
3447 
Finalize()3448 void XclImpChAxesSet::Finalize()
3449 {
3450     if( IsValidAxesSet() )
3451     {
3452         // finalize chart type groups, erase empty groups without series
3453         XclImpChTypeGroupMap aValidGroups;
3454         for( XclImpChTypeGroupMap::const_iterator aIt = maTypeGroups.begin(), aEnd = maTypeGroups.end(); aIt != aEnd; ++aIt )
3455         {
3456             XclImpChTypeGroupRef xTypeGroup = aIt->second;
3457             xTypeGroup->Finalize();
3458             if( xTypeGroup->IsValidGroup() )
3459                 aValidGroups[ aIt->first ] = xTypeGroup;
3460         }
3461         maTypeGroups.swap( aValidGroups );
3462     }
3463 
3464     // invalid chart type groups are deleted now, check again with IsValidAxesSet()
3465     if( IsValidAxesSet() )
3466     {
3467         // always create missing axis objects
3468         if( !mxXAxis )
3469             mxXAxis.reset( new XclImpChAxis( GetChRoot(), EXC_CHAXIS_X ) );
3470         if( !mxYAxis )
3471             mxYAxis.reset( new XclImpChAxis( GetChRoot(), EXC_CHAXIS_Y ) );
3472         if( !mxZAxis && GetFirstTypeGroup()->Is3dDeepChart() )
3473             mxZAxis.reset( new XclImpChAxis( GetChRoot(), EXC_CHAXIS_Z ) );
3474 
3475         // finalize axes
3476         if( mxXAxis.is() ) mxXAxis->Finalize();
3477         if( mxYAxis.is() ) mxYAxis->Finalize();
3478         if( mxZAxis.is() ) mxZAxis->Finalize();
3479 
3480         // finalize axis titles
3481         XclImpChTextRef xDefText = GetChartData().GetDefaultText( EXC_CHTEXTTYPE_AXISTITLE );
3482         String aAutoTitle = CREATE_STRING( "Axis Title" );
3483         lclFinalizeTitle( mxXAxisTitle, xDefText, aAutoTitle );
3484         lclFinalizeTitle( mxYAxisTitle, xDefText, aAutoTitle );
3485         lclFinalizeTitle( mxZAxisTitle, xDefText, aAutoTitle );
3486 
3487         // #i47745# missing plot frame -> invisible border and area
3488         if( !mxPlotFrame )
3489             mxPlotFrame.reset( new XclImpChFrame( GetChRoot(), EXC_CHOBJTYPE_PLOTFRAME ) );
3490     }
3491 }
3492 
GetFirstTypeGroup() const3493 XclImpChTypeGroupRef XclImpChAxesSet::GetFirstTypeGroup() const
3494 {
3495     XclImpChTypeGroupRef xTypeGroup;
3496     if( !maTypeGroups.empty() )
3497         xTypeGroup = maTypeGroups.begin()->second;
3498     return xTypeGroup;
3499 }
3500 
GetLegend() const3501 XclImpChLegendRef XclImpChAxesSet::GetLegend() const
3502 {
3503     XclImpChLegendRef xLegend;
3504     for( XclImpChTypeGroupMap::const_iterator aIt = maTypeGroups.begin(), aEnd = maTypeGroups.end(); !xLegend && (aIt != aEnd); ++aIt )
3505         xLegend = aIt->second->GetLegend();
3506     return xLegend;
3507 }
3508 
GetSingleSeriesTitle() const3509 const String& XclImpChAxesSet::GetSingleSeriesTitle() const
3510 {
3511     return (maTypeGroups.size() == 1) ? maTypeGroups.begin()->second->GetSingleSeriesTitle() : String::EmptyString();
3512 }
3513 
Convert(Reference<XDiagram> xDiagram) const3514 void XclImpChAxesSet::Convert( Reference< XDiagram > xDiagram ) const
3515 {
3516     if( IsValidAxesSet() && xDiagram.is() )
3517     {
3518         // diagram background formatting
3519         if( GetAxesSetId() == EXC_CHAXESSET_PRIMARY )
3520             ConvertBackground( xDiagram );
3521 
3522         // create the coordinate system, this inserts all chart types and series
3523         Reference< XCoordinateSystem > xCoordSystem = CreateCoordSystem( xDiagram );
3524         if( xCoordSystem.is() )
3525         {
3526             // insert coordinate system, if not already done
3527             try
3528             {
3529                 Reference< XCoordinateSystemContainer > xCoordSystemCont( xDiagram, UNO_QUERY_THROW );
3530                 Sequence< Reference< XCoordinateSystem > > aCoordSystems = xCoordSystemCont->getCoordinateSystems();
3531                 if( aCoordSystems.getLength() == 0 )
3532                     xCoordSystemCont->addCoordinateSystem( xCoordSystem );
3533             }
3534             catch( Exception& )
3535             {
3536                 DBG_ERRORFILE( "XclImpChAxesSet::Convert - cannot insert coordinate system" );
3537             }
3538 
3539             // create the axes with grids and axis titles and insert them into the diagram
3540             ConvertAxis( mxXAxis, mxXAxisTitle, xCoordSystem, mxYAxis.get() );
3541             ConvertAxis( mxYAxis, mxYAxisTitle, xCoordSystem, mxXAxis.get() );
3542             ConvertAxis( mxZAxis, mxZAxisTitle, xCoordSystem, 0 );
3543         }
3544     }
3545 }
3546 
ConvertTitlePositions() const3547 void XclImpChAxesSet::ConvertTitlePositions() const
3548 {
3549     if( mxXAxisTitle.is() )
3550         mxXAxisTitle->ConvertTitlePosition( XclChTextKey( EXC_CHTEXTTYPE_AXISTITLE, maData.mnAxesSetId, EXC_CHAXIS_X ) );
3551     if( mxYAxisTitle.is() )
3552         mxYAxisTitle->ConvertTitlePosition( XclChTextKey( EXC_CHTEXTTYPE_AXISTITLE, maData.mnAxesSetId, EXC_CHAXIS_Y ) );
3553     if( mxZAxisTitle.is() )
3554         mxZAxisTitle->ConvertTitlePosition( XclChTextKey( EXC_CHTEXTTYPE_AXISTITLE, maData.mnAxesSetId, EXC_CHAXIS_Z ) );
3555 }
3556 
ReadChAxis(XclImpStream & rStrm)3557 void XclImpChAxesSet::ReadChAxis( XclImpStream& rStrm )
3558 {
3559     XclImpChAxisRef xAxis( new XclImpChAxis( GetChRoot() ) );
3560     xAxis->ReadRecordGroup( rStrm );
3561 
3562     switch( xAxis->GetAxisType() )
3563     {
3564         case EXC_CHAXIS_X:  mxXAxis = xAxis;    break;
3565         case EXC_CHAXIS_Y:  mxYAxis = xAxis;    break;
3566         case EXC_CHAXIS_Z:  mxZAxis = xAxis;    break;
3567     }
3568 }
3569 
ReadChText(XclImpStream & rStrm)3570 void XclImpChAxesSet::ReadChText( XclImpStream& rStrm )
3571 {
3572     XclImpChTextRef xText( new XclImpChText( GetChRoot() ) );
3573     xText->ReadRecordGroup( rStrm );
3574 
3575     switch( xText->GetLinkTarget() )
3576     {
3577         case EXC_CHOBJLINK_XAXIS:   mxXAxisTitle = xText;   break;
3578         case EXC_CHOBJLINK_YAXIS:   mxYAxisTitle = xText;   break;
3579         case EXC_CHOBJLINK_ZAXIS:   mxZAxisTitle = xText;   break;
3580     }
3581 }
3582 
ReadChPlotFrame(XclImpStream & rStrm)3583 void XclImpChAxesSet::ReadChPlotFrame( XclImpStream& rStrm )
3584 {
3585     if( (rStrm.GetNextRecId() == EXC_ID_CHFRAME) && rStrm.StartNextRecord() )
3586     {
3587         mxPlotFrame.reset( new XclImpChFrame( GetChRoot(), EXC_CHOBJTYPE_PLOTFRAME ) );
3588         mxPlotFrame->ReadRecordGroup( rStrm );
3589     }
3590 }
3591 
ReadChTypeGroup(XclImpStream & rStrm)3592 void XclImpChAxesSet::ReadChTypeGroup( XclImpStream& rStrm )
3593 {
3594     XclImpChTypeGroupRef xTypeGroup( new XclImpChTypeGroup( GetChRoot() ) );
3595     xTypeGroup->ReadRecordGroup( rStrm );
3596     maTypeGroups[ xTypeGroup->GetGroupIdx() ] = xTypeGroup;
3597 }
3598 
CreateCoordSystem(Reference<XDiagram> xDiagram) const3599 Reference< XCoordinateSystem > XclImpChAxesSet::CreateCoordSystem( Reference< XDiagram > xDiagram ) const
3600 {
3601     Reference< XCoordinateSystem > xCoordSystem;
3602 
3603     /*  Try to get existing ccordinate system. For now, all series from primary
3604         and secondary axes sets are inserted into one coordinate system. Later,
3605         this should be changed to use one coordinate system for each axes set. */
3606     Reference< XCoordinateSystemContainer > xCoordSystemCont( xDiagram, UNO_QUERY );
3607     if( xCoordSystemCont.is() )
3608     {
3609         Sequence< Reference< XCoordinateSystem > > aCoordSystems = xCoordSystemCont->getCoordinateSystems();
3610         DBG_ASSERT( aCoordSystems.getLength() <= 1, "XclImpChAxesSet::CreateCoordSystem - too many existing coordinate systems" );
3611         if( aCoordSystems.getLength() > 0 )
3612             xCoordSystem = aCoordSystems[ 0 ];
3613     }
3614 
3615     // create the coordinate system according to the first chart type
3616     if( !xCoordSystem.is() )
3617     {
3618         XclImpChTypeGroupRef xTypeGroup = GetFirstTypeGroup();
3619         if( xTypeGroup.is() )
3620         {
3621             xCoordSystem = xTypeGroup->CreateCoordSystem();
3622             // convert 3d chart settings
3623             ScfPropertySet aDiaProp( xDiagram );
3624             xTypeGroup->ConvertChart3d( aDiaProp );
3625         }
3626     }
3627 
3628     /*  Create XChartType objects for all chart type groups. Each group will
3629         add its series to the data provider attached to the chart document. */
3630     Reference< XChartTypeContainer > xChartTypeCont( xCoordSystem, UNO_QUERY );
3631     if( xChartTypeCont.is() )
3632     {
3633         sal_Int32 nApiAxesSetIdx = GetApiAxesSetIndex();
3634         for( XclImpChTypeGroupMap::const_iterator aIt = maTypeGroups.begin(), aEnd = maTypeGroups.end(); aIt != aEnd; ++aIt )
3635         {
3636             try
3637             {
3638                 Reference< XChartType > xChartType = aIt->second->CreateChartType( xDiagram, nApiAxesSetIdx );
3639                 if( xChartType.is() )
3640                     xChartTypeCont->addChartType( xChartType );
3641             }
3642             catch( Exception& )
3643             {
3644                 DBG_ERRORFILE( "XclImpChAxesSet::CreateCoordSystem - cannot add chart type" );
3645             }
3646         }
3647     }
3648 
3649     return xCoordSystem;
3650 }
3651 
ConvertAxis(XclImpChAxisRef xChAxis,XclImpChTextRef xChAxisTitle,Reference<XCoordinateSystem> xCoordSystem,const XclImpChAxis * pCrossingAxis) const3652 void XclImpChAxesSet::ConvertAxis(
3653         XclImpChAxisRef xChAxis, XclImpChTextRef xChAxisTitle,
3654         Reference< XCoordinateSystem > xCoordSystem, const XclImpChAxis* pCrossingAxis ) const
3655 {
3656     if( xChAxis.is() )
3657     {
3658         // create and attach the axis object
3659         Reference< XAxis > xAxis = CreateAxis( *xChAxis, pCrossingAxis );
3660         if( xAxis.is() )
3661         {
3662             // create and attach the axis title
3663             if( xChAxisTitle.is() ) try
3664             {
3665                 Reference< XTitled > xTitled( xAxis, UNO_QUERY_THROW );
3666                 Reference< XTitle > xTitle( xChAxisTitle->CreateTitle(), UNO_SET_THROW );
3667                 xTitled->setTitleObject( xTitle );
3668             }
3669             catch( Exception& )
3670             {
3671                 DBG_ERRORFILE( "XclImpChAxesSet::ConvertAxis - cannot set axis title" );
3672             }
3673 
3674             // insert axis into coordinate system
3675             try
3676             {
3677                 sal_Int32 nApiAxisDim = xChAxis->GetApiAxisDimension();
3678                 sal_Int32 nApiAxesSetIdx = GetApiAxesSetIndex();
3679                 xCoordSystem->setAxisByDimension( nApiAxisDim, xAxis, nApiAxesSetIdx );
3680             }
3681             catch( Exception& )
3682             {
3683                 DBG_ERRORFILE( "XclImpChAxesSet::ConvertAxis - cannot set axis" );
3684             }
3685         }
3686     }
3687 }
3688 
CreateAxis(const XclImpChAxis & rChAxis,const XclImpChAxis * pCrossingAxis) const3689 Reference< XAxis > XclImpChAxesSet::CreateAxis( const XclImpChAxis& rChAxis, const XclImpChAxis* pCrossingAxis ) const
3690 {
3691     Reference< XAxis > xAxis;
3692     if( const XclImpChTypeGroup* pTypeGroup = GetFirstTypeGroup().get() )
3693         xAxis = rChAxis.CreateAxis( *pTypeGroup, pCrossingAxis );
3694     return xAxis;
3695 }
3696 
ConvertBackground(Reference<XDiagram> xDiagram) const3697 void XclImpChAxesSet::ConvertBackground( Reference< XDiagram > xDiagram ) const
3698 {
3699     XclImpChTypeGroupRef xTypeGroup = GetFirstTypeGroup();
3700     if( xTypeGroup.is() && xTypeGroup->Is3dWallChart() )
3701     {
3702         // wall/floor formatting (3D charts)
3703         if( mxXAxis.is() )
3704         {
3705             ScfPropertySet aWallProp( xDiagram->getWall() );
3706             mxXAxis->ConvertWall( aWallProp );
3707         }
3708         if( mxYAxis.is() )
3709         {
3710             ScfPropertySet aFloorProp( xDiagram->getFloor() );
3711             mxYAxis->ConvertWall( aFloorProp );
3712         }
3713     }
3714     else if( mxPlotFrame.is() )
3715     {
3716         // diagram background formatting
3717         ScfPropertySet aWallProp( xDiagram->getWall() );
3718         mxPlotFrame->Convert( aWallProp );
3719     }
3720 }
3721 
3722 // The chart object ===========================================================
3723 
XclImpChChart(const XclImpRoot & rRoot)3724 XclImpChChart::XclImpChChart( const XclImpRoot& rRoot ) :
3725     XclImpChRoot( rRoot, *this )
3726 {
3727     mxPrimAxesSet.reset( new XclImpChAxesSet( GetChRoot(), EXC_CHAXESSET_PRIMARY ) );
3728     mxSecnAxesSet.reset( new XclImpChAxesSet( GetChRoot(), EXC_CHAXESSET_SECONDARY ) );
3729 }
3730 
~XclImpChChart()3731 XclImpChChart::~XclImpChChart()
3732 {
3733 }
3734 
ReadHeaderRecord(XclImpStream & rStrm)3735 void XclImpChChart::ReadHeaderRecord( XclImpStream& rStrm )
3736 {
3737     // coordinates are stored as 16.16 fixed point
3738     rStrm >> maRect;
3739 }
3740 
ReadSubRecord(XclImpStream & rStrm)3741 void XclImpChChart::ReadSubRecord( XclImpStream& rStrm )
3742 {
3743     switch( rStrm.GetRecId() )
3744     {
3745         case EXC_ID_CHFRAME:
3746             mxFrame.reset( new XclImpChFrame( GetChRoot(), EXC_CHOBJTYPE_BACKGROUND ) );
3747             mxFrame->ReadRecordGroup( rStrm );
3748         break;
3749         case EXC_ID_CHSERIES:
3750             ReadChSeries( rStrm );
3751         break;
3752         case EXC_ID_CHPROPERTIES:
3753             ReadChProperties( rStrm );
3754         break;
3755         case EXC_ID_CHDEFAULTTEXT:
3756             ReadChDefaultText( rStrm );
3757         break;
3758         case EXC_ID_CHAXESSET:
3759             ReadChAxesSet( rStrm );
3760         break;
3761         case EXC_ID_CHTEXT:
3762             ReadChText( rStrm );
3763         break;
3764         case EXC_ID_CHEND:
3765             Finalize();     // finalize the entire chart object
3766         break;
3767     }
3768 }
3769 
ReadChDefaultText(XclImpStream & rStrm)3770 void XclImpChChart::ReadChDefaultText( XclImpStream& rStrm )
3771 {
3772     sal_uInt16 nTextId = rStrm.ReaduInt16();
3773     if( (rStrm.GetNextRecId() == EXC_ID_CHTEXT) && rStrm.StartNextRecord() )
3774     {
3775         XclImpChTextRef xText( new XclImpChText( GetChRoot() ) );
3776         xText->ReadRecordGroup( rStrm );
3777         maDefTexts[ nTextId ] = xText;
3778     }
3779 }
3780 
ReadChDataFormat(XclImpStream & rStrm)3781 void XclImpChChart::ReadChDataFormat( XclImpStream& rStrm )
3782 {
3783     XclImpChDataFormatRef xDataFmt( new XclImpChDataFormat( GetChRoot() ) );
3784     xDataFmt->ReadRecordGroup( rStrm );
3785     if( xDataFmt->GetPointPos().mnSeriesIdx <= EXC_CHSERIES_MAXSERIES )
3786     {
3787         XclImpChDataFormatRef& rxMapFmt = maDataFmts[ xDataFmt->GetPointPos() ];
3788         /*  Do not overwrite existing data format group, Excel always uses the
3789             first data format group occuring in any CHSERIES group. */
3790         if( !rxMapFmt )
3791             rxMapFmt = xDataFmt;
3792     }
3793 }
3794 
UpdateObjFrame(const XclObjLineData & rLineData,const XclObjFillData & rFillData)3795 void XclImpChChart::UpdateObjFrame( const XclObjLineData& rLineData, const XclObjFillData& rFillData )
3796 {
3797     if( !mxFrame )
3798         mxFrame.reset( new XclImpChFrame( GetChRoot(), EXC_CHOBJTYPE_BACKGROUND ) );
3799     mxFrame->UpdateObjFrame( rLineData, rFillData );
3800 }
3801 
GetTypeGroup(sal_uInt16 nGroupIdx) const3802 XclImpChTypeGroupRef XclImpChChart::GetTypeGroup( sal_uInt16 nGroupIdx ) const
3803 {
3804     XclImpChTypeGroupRef xTypeGroup = mxPrimAxesSet->GetTypeGroup( nGroupIdx );
3805     if( !xTypeGroup ) xTypeGroup = mxSecnAxesSet->GetTypeGroup( nGroupIdx );
3806     if( !xTypeGroup ) xTypeGroup = mxPrimAxesSet->GetFirstTypeGroup();
3807     return xTypeGroup;
3808 }
3809 
GetDefaultText(XclChTextType eTextType) const3810 XclImpChTextRef XclImpChChart::GetDefaultText( XclChTextType eTextType ) const
3811 {
3812     sal_uInt16 nDefTextId = EXC_CHDEFTEXT_GLOBAL;
3813     bool bBiff8 = GetBiff() == EXC_BIFF8;
3814     switch( eTextType )
3815     {
3816         case EXC_CHTEXTTYPE_TITLE:      nDefTextId = EXC_CHDEFTEXT_GLOBAL;                                  break;
3817         case EXC_CHTEXTTYPE_LEGEND:     nDefTextId = EXC_CHDEFTEXT_GLOBAL;                                  break;
3818         case EXC_CHTEXTTYPE_AXISTITLE:  nDefTextId = bBiff8 ? EXC_CHDEFTEXT_AXESSET : EXC_CHDEFTEXT_GLOBAL; break;
3819         case EXC_CHTEXTTYPE_AXISLABEL:  nDefTextId = bBiff8 ? EXC_CHDEFTEXT_AXESSET : EXC_CHDEFTEXT_GLOBAL; break;
3820         case EXC_CHTEXTTYPE_DATALABEL:  nDefTextId = bBiff8 ? EXC_CHDEFTEXT_AXESSET : EXC_CHDEFTEXT_GLOBAL; break;
3821     }
3822     return maDefTexts.get( nDefTextId );
3823 }
3824 
IsManualPlotArea() const3825 bool XclImpChChart::IsManualPlotArea() const
3826 {
3827     // there is no real automatic mode in BIFF5 charts
3828     return (GetBiff() <= EXC_BIFF5) || ::get_flag( maProps.mnFlags, EXC_CHPROPS_USEMANPLOTAREA );
3829 }
3830 
Convert(Reference<XChartDocument> xChartDoc,XclImpDffConverter & rDffConv,const OUString & rObjName,const Rectangle & rChartRect) const3831 void XclImpChChart::Convert( Reference< XChartDocument > xChartDoc,
3832         XclImpDffConverter& rDffConv, const OUString& rObjName, const Rectangle& rChartRect ) const
3833 {
3834     // initialize conversion (locks the model to suppress any internal updates)
3835     InitConversion( xChartDoc, rChartRect );
3836 
3837     // chart frame formatting
3838     if( mxFrame.is() )
3839     {
3840         ScfPropertySet aFrameProp( xChartDoc->getPageBackground() );
3841         mxFrame->Convert( aFrameProp );
3842     }
3843 
3844     // chart title
3845     if( mxTitle.is() ) try
3846     {
3847         Reference< XTitled > xTitled( xChartDoc, UNO_QUERY_THROW );
3848         Reference< XTitle > xTitle( mxTitle->CreateTitle(), UNO_SET_THROW );
3849         xTitled->setTitleObject( xTitle );
3850     }
3851     catch( Exception& )
3852     {
3853     }
3854 
3855     /*  Create the diagram object and attach it to the chart document. Currently,
3856         one diagram is used to carry all coordinate systems and data series. */
3857     Reference< XDiagram > xDiagram = CreateDiagram();
3858     xChartDoc->setFirstDiagram( xDiagram );
3859 
3860     // coordinate systems and chart types, convert axis settings
3861     mxPrimAxesSet->Convert( xDiagram );
3862     mxSecnAxesSet->Convert( xDiagram );
3863 
3864     // legend
3865     if( xDiagram.is() && mxLegend.is() )
3866         xDiagram->setLegend( mxLegend->CreateLegend() );
3867 
3868     /*  Following all conversions needing the old Chart1 API that involves full
3869         initialization of the chart view. */
3870     Reference< cssc::XChartDocument > xChart1Doc( xChartDoc, UNO_QUERY );
3871     if( xChart1Doc.is() )
3872     {
3873         Reference< cssc::XDiagram > xDiagram1 = xChart1Doc->getDiagram();
3874 
3875         /*  Set the 'IncludeHiddenCells' property via the old API as only this
3876             ensures that the data provider and all created sequences get this
3877             flag correctly. */
3878         ScfPropertySet aDiaProp( xDiagram1 );
3879         bool bShowVisCells = ::get_flag( maProps.mnFlags, EXC_CHPROPS_SHOWVISIBLEONLY );
3880         aDiaProp.SetBoolProperty( EXC_CHPROP_INCLUDEHIDDENCELLS, !bShowVisCells );
3881 
3882         // plot area position and size (there is no real automatic mode in BIFF5 charts)
3883         XclImpChFramePosRef xPlotAreaPos = mxPrimAxesSet->GetPlotAreaFramePos();
3884         if( IsManualPlotArea() && xPlotAreaPos.is() ) try
3885         {
3886             const XclChFramePos& rFramePos = xPlotAreaPos->GetFramePosData();
3887             if( (rFramePos.mnTLMode == EXC_CHFRAMEPOS_PARENT) && (rFramePos.mnBRMode == EXC_CHFRAMEPOS_PARENT) )
3888             {
3889                 Reference< cssc::XDiagramPositioning > xPositioning( xDiagram1, UNO_QUERY_THROW );
3890                 ::com::sun::star::awt::Rectangle aDiagramRect = CalcHmmFromChartRect( rFramePos.maRect );
3891                 // for pie charts, always set inner plot area size to exclude the data labels as Excel does
3892                 const XclImpChTypeGroup* pFirstTypeGroup = mxPrimAxesSet->GetFirstTypeGroup().get();
3893                 if( pFirstTypeGroup && (pFirstTypeGroup->GetTypeInfo().meTypeCateg == EXC_CHTYPECATEG_PIE) )
3894                     xPositioning->setDiagramPositionExcludingAxes( aDiagramRect );
3895                 else if( pFirstTypeGroup && pFirstTypeGroup->Is3dChart() )
3896                     xPositioning->setDiagramPositionIncludingAxesAndAxisTitles( aDiagramRect );
3897                 else
3898                     xPositioning->setDiagramPositionIncludingAxes( aDiagramRect );
3899             }
3900         }
3901         catch( Exception& )
3902         {
3903         }
3904 
3905         // positions of all title objects
3906         if( mxTitle.is() )
3907             mxTitle->ConvertTitlePosition( XclChTextKey( EXC_CHTEXTTYPE_TITLE ) );
3908         mxPrimAxesSet->ConvertTitlePositions();
3909         mxSecnAxesSet->ConvertTitlePositions();
3910     }
3911 
3912     // unlock the model
3913     FinishConversion( rDffConv );
3914 
3915     // start listening to this chart
3916     ScDocument& rDoc = GetRoot().GetDoc();
3917     if( ScChartListenerCollection* pChartCollection = rDoc.GetChartListenerCollection() )
3918     {
3919         ::std::auto_ptr< ::std::vector< ScSharedTokenRef > > xRefTokens( new ::std::vector< ScSharedTokenRef > );
3920         for( XclImpChSeriesVec::const_iterator aIt = maSeries.begin(), aEnd = maSeries.end(); aIt != aEnd; ++aIt )
3921             (*aIt)->FillAllSourceLinks( *xRefTokens );
3922         if( !xRefTokens->empty() )
3923         {
3924             ::std::auto_ptr< ScChartListener > xListener( new ScChartListener( rObjName, &rDoc, xRefTokens.release() ) );
3925             xListener->SetUsed( true );
3926             xListener->StartListeningTo();
3927             pChartCollection->Insert( xListener.release() );
3928         }
3929     }
3930 }
3931 
ReadChSeries(XclImpStream & rStrm)3932 void XclImpChChart::ReadChSeries( XclImpStream& rStrm )
3933 {
3934     sal_uInt16 nNewSeriesIdx = static_cast< sal_uInt16 >( maSeries.size() );
3935     XclImpChSeriesRef xSeries( new XclImpChSeries( GetChRoot(), nNewSeriesIdx ) );
3936     xSeries->ReadRecordGroup( rStrm );
3937     maSeries.push_back( xSeries );
3938 }
3939 
ReadChProperties(XclImpStream & rStrm)3940 void XclImpChChart::ReadChProperties( XclImpStream& rStrm )
3941 {
3942     rStrm >> maProps.mnFlags >> maProps.mnEmptyMode;
3943 }
3944 
ReadChAxesSet(XclImpStream & rStrm)3945 void XclImpChChart::ReadChAxesSet( XclImpStream& rStrm )
3946 {
3947     XclImpChAxesSetRef xAxesSet( new XclImpChAxesSet( GetChRoot(), EXC_CHAXESSET_NONE ) );
3948     xAxesSet->ReadRecordGroup( rStrm );
3949     switch( xAxesSet->GetAxesSetId() )
3950     {
3951         case EXC_CHAXESSET_PRIMARY:     mxPrimAxesSet = xAxesSet;   break;
3952         case EXC_CHAXESSET_SECONDARY:   mxSecnAxesSet = xAxesSet;   break;
3953     }
3954 }
3955 
ReadChText(XclImpStream & rStrm)3956 void XclImpChChart::ReadChText( XclImpStream& rStrm )
3957 {
3958     XclImpChTextRef xText( new XclImpChText( GetChRoot() ) );
3959     xText->ReadRecordGroup( rStrm );
3960     switch( xText->GetLinkTarget() )
3961     {
3962         case EXC_CHOBJLINK_TITLE:
3963             mxTitle = xText;
3964         break;
3965         case EXC_CHOBJLINK_DATA:
3966         {
3967             sal_uInt16 nSeriesIdx = xText->GetPointPos().mnSeriesIdx;
3968             if( nSeriesIdx < maSeries.size() )
3969                 maSeries[ nSeriesIdx ]->SetDataLabel( xText );
3970         }
3971         break;
3972     }
3973 }
3974 
Finalize()3975 void XclImpChChart::Finalize()
3976 {
3977     // finalize series (must be done first)
3978     FinalizeSeries();
3979     // #i49218# legend may be attached to primary or secondary axes set
3980     mxLegend = mxPrimAxesSet->GetLegend();
3981     if( !mxLegend )
3982         mxLegend = mxSecnAxesSet->GetLegend();
3983     if( mxLegend.is() )
3984         mxLegend->Finalize();
3985     // axes sets, updates chart type group default formats -> must be called before FinalizeDataFormats()
3986     mxPrimAxesSet->Finalize();
3987     mxSecnAxesSet->Finalize();
3988     // formatting of all series
3989     FinalizeDataFormats();
3990     // #i47745# missing frame -> invisible border and area
3991     if( !mxFrame )
3992         mxFrame.reset( new XclImpChFrame( GetChRoot(), EXC_CHOBJTYPE_BACKGROUND ) );
3993     // chart title
3994     FinalizeTitle();
3995 }
3996 
FinalizeSeries()3997 void XclImpChChart::FinalizeSeries()
3998 {
3999     for( XclImpChSeriesVec::iterator aSIt = maSeries.begin(), aSEnd = maSeries.end(); aSIt != aSEnd; ++aSIt )
4000     {
4001         XclImpChSeriesRef xSeries = *aSIt;
4002         if( xSeries->HasParentSeries() )
4003         {
4004             /*  Process child series (trend lines and error bars). Data of
4005                 child series will be set at the connected parent series. */
4006             if( xSeries->GetParentIdx() < maSeries.size() )
4007                 maSeries[ xSeries->GetParentIdx() ]->AddChildSeries( *xSeries );
4008         }
4009         else
4010         {
4011             // insert the series into the related chart type group
4012             if( XclImpChTypeGroup* pTypeGroup = GetTypeGroup( xSeries->GetGroupIdx() ).get() )
4013                 pTypeGroup->AddSeries( xSeries );
4014         }
4015     }
4016 }
4017 
FinalizeDataFormats()4018 void XclImpChChart::FinalizeDataFormats()
4019 {
4020     /*  #i51639# (part 1): CHDATAFORMAT groups are part of CHSERIES groups.
4021         Each CHDATAFORMAT group specifies the series and data point it is
4022         assigned to. This makes it possible to have a data format that is
4023         related to another series, e.g. a CHDATAFORMAT group for series 2 is
4024         part of a CHSERIES group that describes series 1. Therefore the chart
4025         itself has collected all CHDATAFORMAT groups to be able to store data
4026         format groups for series that have not been imported at that time. This
4027         loop finally assigns these groups to the related series. */
4028     for( XclImpChDataFormatMap::const_iterator aMIt = maDataFmts.begin(), aMEnd = maDataFmts.end(); aMIt != aMEnd; ++aMIt )
4029     {
4030         sal_uInt16 nSeriesIdx = aMIt->first.mnSeriesIdx;
4031         if( nSeriesIdx < maSeries.size() )
4032             maSeries[ nSeriesIdx ]->SetDataFormat( aMIt->second );
4033     }
4034 
4035     /*  #i51639# (part 2): Finalize data formats of all series. This adds for
4036         example missing CHDATAFORMAT groups for entire series that are needed
4037         for automatic colors of lines and areas. */
4038     for( XclImpChSeriesVec::iterator aVIt = maSeries.begin(), aVEnd = maSeries.end(); aVIt != aVEnd; ++aVIt )
4039         (*aVIt)->FinalizeDataFormats();
4040 }
4041 
FinalizeTitle()4042 void XclImpChChart::FinalizeTitle()
4043 {
4044     // special handling for auto-generated title
4045     String aAutoTitle;
4046     if( !mxTitle || (!mxTitle->IsDeleted() && !mxTitle->HasString()) )
4047     {
4048         // automatic title from first series name (if there are no series on secondary axes set)
4049         if( !mxSecnAxesSet->IsValidAxesSet() )
4050             aAutoTitle = mxPrimAxesSet->GetSingleSeriesTitle();
4051         if( mxTitle.is() || (aAutoTitle.Len() > 0) )
4052         {
4053             if( !mxTitle )
4054                 mxTitle.reset( new XclImpChText( GetChRoot() ) );
4055             if( aAutoTitle.Len() == 0 )
4056                 aAutoTitle = CREATE_STRING( "Chart Title" );
4057         }
4058     }
4059 
4060     // will reset mxTitle, if it does not contain a string and no auto title exists
4061     lclFinalizeTitle( mxTitle, GetDefaultText( EXC_CHTEXTTYPE_TITLE ), aAutoTitle );
4062 }
4063 
CreateDiagram() const4064 Reference< XDiagram > XclImpChChart::CreateDiagram() const
4065 {
4066     // create a diagram object
4067     Reference< XDiagram > xDiagram( ScfApiHelper::CreateInstance( SERVICE_CHART2_DIAGRAM ), UNO_QUERY );
4068 
4069     // convert global chart settings
4070     ScfPropertySet aDiaProp( xDiagram );
4071 
4072     // treatment of missing values
4073     using namespace cssc::MissingValueTreatment;
4074     sal_Int32 nMissingValues = LEAVE_GAP;
4075     switch( maProps.mnEmptyMode )
4076     {
4077         case EXC_CHPROPS_EMPTY_SKIP:        nMissingValues = LEAVE_GAP; break;
4078         case EXC_CHPROPS_EMPTY_ZERO:        nMissingValues = USE_ZERO;  break;
4079         case EXC_CHPROPS_EMPTY_INTERPOLATE: nMissingValues = CONTINUE;  break;
4080     }
4081     aDiaProp.SetProperty( EXC_CHPROP_MISSINGVALUETREATMENT, nMissingValues );
4082 
4083     return xDiagram;
4084 }
4085 
4086 // ----------------------------------------------------------------------------
4087 
XclImpChartDrawing(const XclImpRoot & rRoot,bool bOwnTab)4088 XclImpChartDrawing::XclImpChartDrawing( const XclImpRoot& rRoot, bool bOwnTab ) :
4089     XclImpDrawing( rRoot, bOwnTab ), // sheet charts may contain OLE objects
4090     mnScTab( rRoot.GetCurrScTab() ),
4091     mbOwnTab( bOwnTab )
4092 {
4093 }
4094 
ConvertObjects(XclImpDffConverter & rDffConv,const Reference<XModel> & rxModel,const Rectangle & rChartRect)4095 void XclImpChartDrawing::ConvertObjects( XclImpDffConverter& rDffConv,
4096         const Reference< XModel >& rxModel, const Rectangle& rChartRect )
4097 {
4098     maChartRect = rChartRect;   // needed in CalcAnchorRect() callback
4099 
4100     SdrModel* pSdrModel = 0;
4101     SdrPage* pSdrPage = 0;
4102     if( mbOwnTab )
4103     {
4104         // chart sheet: insert all shapes into the sheet, not into the chart object
4105         pSdrModel = GetDoc().GetDrawLayer();
4106         pSdrPage = GetSdrPage( mnScTab );
4107     }
4108     else
4109     {
4110         // embedded chart object: insert all shapes into the chart
4111         try
4112         {
4113             Reference< XDrawPageSupplier > xDrawPageSupp( rxModel, UNO_QUERY_THROW );
4114             Reference< XDrawPage > xDrawPage( xDrawPageSupp->getDrawPage(), UNO_SET_THROW );
4115             pSdrPage = ::GetSdrPageFromXDrawPage( xDrawPage );
4116             pSdrModel = pSdrPage ? pSdrPage->GetModel() : 0;
4117         }
4118         catch( Exception& )
4119         {
4120         }
4121     }
4122 
4123     if( pSdrModel && pSdrPage )
4124         ImplConvertObjects( rDffConv, *pSdrModel, *pSdrPage );
4125 }
4126 
CalcAnchorRect(const XclObjAnchor & rAnchor,bool bDffAnchor) const4127 Rectangle XclImpChartDrawing::CalcAnchorRect( const XclObjAnchor& rAnchor, bool bDffAnchor ) const
4128 {
4129     /*  In objects with DFF client anchor, the position of the shape is stored
4130         in the cell address components of the client anchor. In old BIFF3-BIFF5
4131         objects, the position is stored in the offset components of the anchor. */
4132     Rectangle aRect(
4133         static_cast< long >( static_cast< double >( bDffAnchor ? rAnchor.maFirst.mnCol : rAnchor.mnLX ) / EXC_CHART_TOTALUNITS * maChartRect.GetWidth()  + 0.5 ),
4134         static_cast< long >( static_cast< double >( bDffAnchor ? rAnchor.maFirst.mnRow : rAnchor.mnTY ) / EXC_CHART_TOTALUNITS * maChartRect.GetHeight() + 0.5 ),
4135         static_cast< long >( static_cast< double >( bDffAnchor ? rAnchor.maLast.mnCol  : rAnchor.mnRX ) / EXC_CHART_TOTALUNITS * maChartRect.GetWidth()  + 0.5 ),
4136         static_cast< long >( static_cast< double >( bDffAnchor ? rAnchor.maLast.mnRow  : rAnchor.mnBY ) / EXC_CHART_TOTALUNITS * maChartRect.GetHeight() + 0.5 ) );
4137     aRect.Justify();
4138     // move shapes into chart area for sheet charts
4139     if( mbOwnTab )
4140         aRect.Move( maChartRect.Left(), maChartRect.Top() );
4141     return aRect;
4142 }
4143 
OnObjectInserted(const XclImpDrawObjBase &)4144 void XclImpChartDrawing::OnObjectInserted( const XclImpDrawObjBase& )
4145 {
4146 }
4147 
4148 // ----------------------------------------------------------------------------
4149 
XclImpChart(const XclImpRoot & rRoot,bool bOwnTab)4150 XclImpChart::XclImpChart( const XclImpRoot& rRoot, bool bOwnTab ) :
4151     XclImpRoot( rRoot ),
4152     mbOwnTab( bOwnTab ),
4153     mbIsPivotChart( false )
4154 {
4155 }
4156 
~XclImpChart()4157 XclImpChart::~XclImpChart()
4158 {
4159 }
4160 
ReadChartSubStream(XclImpStream & rStrm)4161 void XclImpChart::ReadChartSubStream( XclImpStream& rStrm )
4162 {
4163     XclImpPageSettings& rPageSett = GetPageSettings();
4164     XclImpTabViewSettings& rTabViewSett = GetTabViewSettings();
4165 
4166     bool bLoop = true;
4167     while( bLoop && rStrm.StartNextRecord() )
4168     {
4169         // page settings - only for charts in entire sheet
4170         if( mbOwnTab ) switch( rStrm.GetRecId() )
4171         {
4172             case EXC_ID_HORPAGEBREAKS:
4173             case EXC_ID_VERPAGEBREAKS:  rPageSett.ReadPageBreaks( rStrm );      break;
4174             case EXC_ID_HEADER:
4175             case EXC_ID_FOOTER:         rPageSett.ReadHeaderFooter( rStrm );    break;
4176             case EXC_ID_LEFTMARGIN:
4177             case EXC_ID_RIGHTMARGIN:
4178             case EXC_ID_TOPMARGIN:
4179             case EXC_ID_BOTTOMMARGIN:   rPageSett.ReadMargin( rStrm );          break;
4180             case EXC_ID_PRINTHEADERS:   rPageSett.ReadPrintHeaders( rStrm );    break;
4181             case EXC_ID_PRINTGRIDLINES: rPageSett.ReadPrintGridLines( rStrm );  break;
4182             case EXC_ID_HCENTER:
4183             case EXC_ID_VCENTER:        rPageSett.ReadCenter( rStrm );          break;
4184             case EXC_ID_SETUP:          rPageSett.ReadSetup( rStrm );           break;
4185             case EXC_ID8_IMGDATA:       rPageSett.ReadImgData( rStrm );         break;
4186 
4187             case EXC_ID_WINDOW2:        rTabViewSett.ReadWindow2( rStrm, true );break;
4188             case EXC_ID_SCL:            rTabViewSett.ReadScl( rStrm );          break;
4189 
4190             case EXC_ID_SHEETEXT: //0x0862
4191             {
4192                 // FIXME: do not need to pass palette, XclImpTabVieSettings is derived from root
4193                 XclImpPalette& rPal = GetPalette();
4194                 rTabViewSett.ReadTabBgColor( rStrm,  rPal);
4195             }
4196             break;
4197 
4198             case EXC_ID_CODENAME:       ReadCodeName( rStrm, false );           break;
4199         }
4200 
4201         // common records
4202         switch( rStrm.GetRecId() )
4203         {
4204             case EXC_ID_EOF:            bLoop = false;                          break;
4205 
4206             // #i31882# ignore embedded chart objects
4207             case EXC_ID2_BOF:
4208             case EXC_ID3_BOF:
4209             case EXC_ID4_BOF:
4210             case EXC_ID5_BOF:           XclTools::SkipSubStream( rStrm );       break;
4211 
4212             case EXC_ID_CHCHART:        ReadChChart( rStrm );                   break;
4213 
4214             case EXC_ID8_CHPIVOTREF:
4215                 GetTracer().TracePivotChartExists();
4216                 mbIsPivotChart = true;
4217             break;
4218 
4219             // BIFF specific records
4220             default: switch( GetBiff() )
4221             {
4222                 case EXC_BIFF5: switch( rStrm.GetRecId() )
4223                 {
4224                     case EXC_ID_OBJ:        GetChartDrawing().ReadObj( rStrm );         break;
4225                 }
4226                 break;
4227                 case EXC_BIFF8: switch( rStrm.GetRecId() )
4228                 {
4229                     case EXC_ID_MSODRAWING: GetChartDrawing().ReadMsoDrawing( rStrm );  break;
4230                     // #i61786# weird documents: OBJ without MSODRAWING -> read in BIFF5 format
4231                     case EXC_ID_OBJ:        GetChartDrawing().ReadObj( rStrm );         break;
4232                 }
4233                 break;
4234                 default:;
4235             }
4236         }
4237     }
4238 }
4239 
UpdateObjFrame(const XclObjLineData & rLineData,const XclObjFillData & rFillData)4240 void XclImpChart::UpdateObjFrame( const XclObjLineData& rLineData, const XclObjFillData& rFillData )
4241 {
4242     if( !mxChartData )
4243         mxChartData.reset( new XclImpChChart( GetRoot() ) );
4244     mxChartData->UpdateObjFrame( rLineData, rFillData );
4245 }
4246 
GetProgressSize() const4247 sal_Size XclImpChart::GetProgressSize() const
4248 {
4249     return
4250         (mxChartData.is() ? mxChartData->GetProgressSize() : 0) +
4251         (mxChartDrawing.is() ? mxChartDrawing->GetProgressSize() : 0);
4252 }
4253 
Convert(Reference<XModel> xModel,XclImpDffConverter & rDffConv,const OUString & rObjName,const Rectangle & rChartRect) const4254 void XclImpChart::Convert( Reference< XModel > xModel, XclImpDffConverter& rDffConv, const OUString& rObjName, const Rectangle& rChartRect ) const
4255 {
4256     Reference< XChartDocument > xChartDoc( xModel, UNO_QUERY );
4257     if( xChartDoc.is() )
4258     {
4259         if( mxChartData.is() )
4260             mxChartData->Convert( xChartDoc, rDffConv, rObjName, rChartRect );
4261         if( mxChartDrawing.is() )
4262             mxChartDrawing->ConvertObjects( rDffConv, xModel, rChartRect );
4263     }
4264 }
4265 
GetChartDrawing()4266 XclImpChartDrawing& XclImpChart::GetChartDrawing()
4267 {
4268     if( !mxChartDrawing )
4269         mxChartDrawing.reset( new XclImpChartDrawing( GetRoot(), mbOwnTab ) );
4270     return *mxChartDrawing;
4271 }
4272 
ReadChChart(XclImpStream & rStrm)4273 void XclImpChart::ReadChChart( XclImpStream& rStrm )
4274 {
4275     mxChartData.reset( new XclImpChChart( GetRoot() ) );
4276     mxChartData->ReadRecordGroup( rStrm );
4277 }
4278 
4279 // ============================================================================
4280 
4281