?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tdf#94235 Add support for series name in data series labels
[LibreOffice.git] / chart2 / source / view / charttypes / VSeriesPlotter.cxx
blobc235148a204541c7ff7d1edd94665a633108c1fc
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <memory>
21 #include <VSeriesPlotter.hxx>
22 #include <BaseGFXHelper.hxx>
23 #include <VLineProperties.hxx>
24 #include <ShapeFactory.hxx>
25
26 #include <CommonConverters.hxx>
27 #include <ExplicitCategoriesProvider.hxx>
28 #include <ObjectIdentifier.hxx>
29 #include <StatisticsHelper.hxx>
30 #include <PlottingPositionHelper.hxx>
31 #include <LabelPositionHelper.hxx>
32 #include <ChartTypeHelper.hxx>
33 #include <Clipping.hxx>
34 #include <servicenames_charttypes.hxx>
35 #include <NumberFormatterWrapper.hxx>
36 #include <DataSeriesHelper.hxx>
37 #include <RegressionCurveHelper.hxx>
38 #include <VLegendSymbolFactory.hxx>
39 #include <FormattedStringHelper.hxx>
40 #include <RelativePositionHelper.hxx>
41 #include <DateHelper.hxx>
42 #include <DiagramHelper.hxx>
43 #include <defines.hxx>
44 #include <ChartModel.hxx>
45
46 //only for creation: @todo remove if all plotter are uno components and instantiated via servicefactory
47 #include "BarChart.hxx"
48 #include "PieChart.hxx"
49 #include "AreaChart.hxx"
50 #include "CandleStickChart.hxx"
51 #include "BubbleChart.hxx"
52 #include "NetChart.hxx"
53 #include <unonames.hxx>
54 #include <SpecialCharacters.hxx>
55
56 #include <com/sun/star/chart2/DataPointLabel.hpp>
57 #include <com/sun/star/chart/ErrorBarStyle.hpp>
58 #include <com/sun/star/chart/TimeUnit.hpp>
59 #include <com/sun/star/chart2/XDataPointCustomLabelField.hpp>
60 #include <com/sun/star/chart2/XRegressionCurveContainer.hpp>
61 #include <com/sun/star/container/XChild.hpp>
62 #include <com/sun/star/chart2/RelativePosition.hpp>
63 #include <tools/color.hxx>
64 #include <tools/UnitConversion.hxx>
65 #include <rtl/ustrbuf.hxx>
66 #include <rtl/math.hxx>
67 #include <basegfx/vector/b2dvector.hxx>
68 #include <com/sun/star/drawing/LineStyle.hpp>
69 #include <com/sun/star/util/XCloneable.hpp>
70 #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
71
72 #include <com/sun/star/drawing/XShapes.hpp>
73
74 #include <unotools/localedatawrapper.hxx>
75 #include <comphelper/sequence.hxx>
76 #include <vcl/svapp.hxx>
77 #include <vcl/settings.hxx>
78 #include <tools/diagnose_ex.h>
79 #include <sal/log.hxx>
80
81 #include <functional>
82 #include <map>
83 #include <unordered_map>
84
85
86 namespace chart {
87
88 using namespace ::com::sun::star;
89 using namespace ::com::sun::star::chart;
90 using namespace ::com::sun::star::chart2;
91 using ::com::sun::star::uno::Reference;
92 using ::com::sun::star::uno::Sequence;
93
94 VDataSeriesGroup::CachedYValues::CachedYValues()
95 : m_bValuesDirty(true)
96 , m_fMinimumY(0.0)
97 , m_fMaximumY(0.0)
98 {
99 }
100
101 VDataSeriesGroup::VDataSeriesGroup( std::unique_ptr<VDataSeries> pSeries )
102 : m_aSeriesVector(1)
103 , m_bMaxPointCountDirty(true)
104 , m_nMaxPointCount(0)
105 , m_aListOfCachedYValues()
106 {
107 m_aSeriesVector[0] = std::move(pSeries);
108 }
109
110 VDataSeriesGroup::VDataSeriesGroup(VDataSeriesGroup&& other) noexcept
111 : m_aSeriesVector( std::move(other.m_aSeriesVector) )
112 , m_bMaxPointCountDirty( other.m_bMaxPointCountDirty )
113 , m_nMaxPointCount( other.m_nMaxPointCount )
114 , m_aListOfCachedYValues( std::move(other.m_aListOfCachedYValues) )
115 {
116 }
117
118 VDataSeriesGroup::~VDataSeriesGroup()
119 {
120 }
121
122 void VDataSeriesGroup::deleteSeries()
123 {
124 //delete all data series help objects:
125 m_aSeriesVector.clear();
126 }
127
128 void VDataSeriesGroup::addSeries( std::unique_ptr<VDataSeries> pSeries )
129 {
130 m_aSeriesVector.push_back(std::move(pSeries));
131 m_bMaxPointCountDirty=true;
132 }
133
134 sal_Int32 VDataSeriesGroup::getSeriesCount() const
135 {
136 return m_aSeriesVector.size();
137 }
138
139 VSeriesPlotter::VSeriesPlotter( const uno::Reference<XChartType>& xChartTypeModel
140 , sal_Int32 nDimensionCount, bool bCategoryXAxis )
141 : PlotterBase( nDimensionCount )
142 , m_pMainPosHelper( nullptr )
143 , m_xChartTypeModel(xChartTypeModel)
144 , m_xChartTypeModelProps( uno::Reference< beans::XPropertySet >::query( xChartTypeModel ))
145 , m_aZSlots()
146 , m_bCategoryXAxis(bCategoryXAxis)
147 , m_nTimeResolution(css::chart::TimeUnit::DAY)
148 , m_aNullDate(30,12,1899)
149 , m_xColorScheme()
150 , m_pExplicitCategoriesProvider(nullptr)
151 , m_bPointsWereSkipped(false)
152 , m_bPieLabelsAllowToMove(false)
153 , m_aAvailableOuterRect(0, 0, 0, 0)
154 {
155 SAL_WARN_IF(!m_xChartTypeModel.is(),"chart2","no XChartType available in view, fallback to default values may be wrong");
156 }
157
158 VSeriesPlotter::~VSeriesPlotter()
159 {
160 //delete all data series help objects:
161 for (std::vector<VDataSeriesGroup> & rGroupVector : m_aZSlots)
162 {
163 for (VDataSeriesGroup & rGroup : rGroupVector)
164 {
165 rGroup.deleteSeries();
166 }
167 rGroupVector.clear();
168 }
169 m_aZSlots.clear();
170
171 m_aSecondaryPosHelperMap.clear();
172
173 m_aSecondaryValueScales.clear();
174 }
175
176 void VSeriesPlotter::addSeries( std::unique_ptr<VDataSeries> pSeries, sal_Int32 zSlot, sal_Int32 xSlot, sal_Int32 ySlot )
177 {
178 //take ownership of pSeries
179
180 OSL_PRECOND( pSeries, "series to add is NULL" );
181 if(!pSeries)
182 return;
183
184 if(m_bCategoryXAxis)
185 {
186 if( m_pExplicitCategoriesProvider && m_pExplicitCategoriesProvider->isDateAxis() )
187 pSeries->setXValues( m_pExplicitCategoriesProvider->getOriginalCategories() );
188 else
189 pSeries->setCategoryXAxis();
190 }
191 else
192 {
193 if( m_pExplicitCategoriesProvider )
194 pSeries->setXValuesIfNone( m_pExplicitCategoriesProvider->getOriginalCategories() );
195 }
196
197 if(zSlot<0 || zSlot>=static_cast<sal_Int32>(m_aZSlots.size()))
198 {
199 //new z slot
200 std::vector< VDataSeriesGroup > aZSlot;
201 aZSlot.emplace_back( std::move(pSeries) );
202 m_aZSlots.push_back( std::move(aZSlot) );
203 }
204 else
205 {
206 //existing zslot
207 std::vector< VDataSeriesGroup >& rXSlots = m_aZSlots[zSlot];
208
209 if(xSlot<0 || xSlot>=static_cast<sal_Int32>(rXSlots.size()))
210 {
211 //append the series to already existing x series
212 rXSlots.emplace_back( std::move(pSeries) );
213 }
214 else
215 {
216 //x slot is already occupied
217 //y slot decides what to do:
218
219 VDataSeriesGroup& rYSlots = rXSlots[xSlot];
220 sal_Int32 nYSlotCount = rYSlots.getSeriesCount();
221
222 if( ySlot < -1 )
223 {
224 //move all existing series in the xSlot to next slot
225 //@todo
226 OSL_FAIL( "Not implemented yet");
227 }
228 else if( ySlot == -1 || ySlot >= nYSlotCount)
229 {
230 //append the series to already existing y series
231 rYSlots.addSeries( std::move(pSeries) );
232 }
233 else
234 {
235 //y slot is already occupied
236 //insert at given y and x position
237
238 //@todo
239 OSL_FAIL( "Not implemented yet");
240 }
241 }
242 }
243 }
244
245 drawing::Direction3D VSeriesPlotter::getPreferredDiagramAspectRatio() const
246 {
247 drawing::Direction3D aRet(1.0,1.0,1.0);
248 if (!m_pPosHelper)
249 return aRet;
250
251 drawing::Direction3D aScale( m_pPosHelper->getScaledLogicWidth() );
252 aRet.DirectionZ = aScale.DirectionZ*0.2;
253 if(aRet.DirectionZ>1.0)
254 aRet.DirectionZ=1.0;
255 if(aRet.DirectionZ>10)
256 aRet.DirectionZ=10;
257 return aRet;
258 }
259
260 void VSeriesPlotter::releaseShapes()
261 {
262 for (std::vector<VDataSeriesGroup> const & rGroupVector : m_aZSlots)
263 {
264 for (VDataSeriesGroup const & rGroup : rGroupVector)
265 {
266 //iterate through all series in this x slot
267 for (std::unique_ptr<VDataSeries> const & pSeries : rGroup.m_aSeriesVector)
268 {
269 pSeries->releaseShapes();
270 }
271 }
272 }
273 }
274
275 uno::Reference< drawing::XShapes > VSeriesPlotter::getSeriesGroupShape( VDataSeries* pDataSeries
276 , const uno::Reference< drawing::XShapes >& xTarget )
277 {
278 uno::Reference< drawing::XShapes > xShapes( pDataSeries->m_xGroupShape );
279 if( !xShapes.is() )
280 {
281 //create a group shape for this series and add to logic target:
282 xShapes = createGroupShape( xTarget,pDataSeries->getCID() );
283 pDataSeries->m_xGroupShape = xShapes;
284 }
285 return xShapes;
286 }
287
288 uno::Reference< drawing::XShapes > VSeriesPlotter::getSeriesGroupShapeFrontChild( VDataSeries* pDataSeries
289 , const uno::Reference< drawing::XShapes >& xTarget )
290 {
291 uno::Reference< drawing::XShapes > xShapes( pDataSeries->m_xFrontSubGroupShape );
292 if(!xShapes.is())
293 {
294 //ensure that the series group shape is already created
295 uno::Reference< drawing::XShapes > xSeriesShapes( getSeriesGroupShape( pDataSeries, xTarget ) );
296 //ensure that the back child is created first
297 getSeriesGroupShapeBackChild( pDataSeries, xTarget );
298 //use series group shape as parent for the new created front group shape
299 xShapes = createGroupShape( xSeriesShapes );
300 pDataSeries->m_xFrontSubGroupShape = xShapes;
301 }
302 return xShapes;
303 }
304
305 uno::Reference< drawing::XShapes > VSeriesPlotter::getSeriesGroupShapeBackChild( VDataSeries* pDataSeries
306 , const uno::Reference< drawing::XShapes >& xTarget )
307 {
308 uno::Reference< drawing::XShapes > xShapes( pDataSeries->m_xBackSubGroupShape );
309 if(!xShapes.is())
310 {
311 //ensure that the series group shape is already created
312 uno::Reference< drawing::XShapes > xSeriesShapes( getSeriesGroupShape( pDataSeries, xTarget ) );
313 //use series group shape as parent for the new created back group shape
314 xShapes = createGroupShape( xSeriesShapes );
315 pDataSeries->m_xBackSubGroupShape = xShapes;
316 }
317 return xShapes;
318 }
319
320 uno::Reference< drawing::XShapes > VSeriesPlotter::getLabelsGroupShape( VDataSeries& rDataSeries
321 , const uno::Reference< drawing::XShapes >& xTextTarget )
322 {
323 //xTextTarget needs to be a 2D shape container always!
324
325 uno::Reference< drawing::XShapes > xShapes( rDataSeries.m_xLabelsGroupShape );
326 if(!xShapes.is())
327 {
328 //create a 2D group shape for texts of this series and add to text target:
329 xShapes = m_pShapeFactory->createGroup2D( xTextTarget, rDataSeries.getLabelsCID() );
330 rDataSeries.m_xLabelsGroupShape = xShapes;
331 }
332 return xShapes;
333 }
334
335 uno::Reference< drawing::XShapes > VSeriesPlotter::getErrorBarsGroupShape( VDataSeries& rDataSeries
336 , const uno::Reference< drawing::XShapes >& xTarget
337 , bool bYError )
338 {
339 uno::Reference< css::drawing::XShapes > &rShapeGroup =
340 bYError ? rDataSeries.m_xErrorYBarsGroupShape : rDataSeries.m_xErrorXBarsGroupShape;
341
342 uno::Reference< drawing::XShapes > xShapes( rShapeGroup );
343 if(!xShapes.is())
344 {
345 //create a group shape for this series and add to logic target:
346 xShapes = createGroupShape( xTarget,rDataSeries.getErrorBarsCID(bYError) );
347 rShapeGroup = xShapes;
348 }
349 return xShapes;
350
351 }
352
353 OUString VSeriesPlotter::getLabelTextForValue( VDataSeries const & rDataSeries
354 , sal_Int32 nPointIndex
355 , double fValue
356 , bool bAsPercentage )
357 {
358 OUString aNumber;
359
360 if (m_apNumberFormatterWrapper)
361 {
362 sal_Int32 nNumberFormatKey = 0;
363 if( rDataSeries.hasExplicitNumberFormat(nPointIndex,bAsPercentage) )
364 nNumberFormatKey = rDataSeries.getExplicitNumberFormat(nPointIndex,bAsPercentage);
365 else if( bAsPercentage )
366 {
367 sal_Int32 nPercentFormat = DiagramHelper::getPercentNumberFormat( m_apNumberFormatterWrapper->getNumberFormatsSupplier() );
368 if( nPercentFormat != -1 )
369 nNumberFormatKey = nPercentFormat;
370 }
371 else
372 {
373 nNumberFormatKey = rDataSeries.detectNumberFormatKey( nPointIndex );
374 }
375 if(nNumberFormatKey<0)
376 nNumberFormatKey=0;
377
378 Color nLabelCol;
379 bool bColChanged;
380 aNumber = m_apNumberFormatterWrapper->getFormattedString(
381 nNumberFormatKey, fValue, nLabelCol, bColChanged );
382 //@todo: change color of label if bColChanged is true
383 }
384 else
385 {
386 const LocaleDataWrapper& rLocaleDataWrapper = Application::GetSettings().GetLocaleDataWrapper();
387 const OUString& aNumDecimalSep = rLocaleDataWrapper.getNumDecimalSep();
388 assert(aNumDecimalSep.getLength() > 0);
389 sal_Unicode cDecSeparator = aNumDecimalSep[0];
390 aNumber = ::rtl::math::doubleToUString( fValue, rtl_math_StringFormat_G /*rtl_math_StringFormat*/
391 , 3/*DecPlaces*/ , cDecSeparator );
392 }
393 return aNumber;
394 }
395
396 uno::Reference< drawing::XShape > VSeriesPlotter::createDataLabel( const uno::Reference< drawing::XShapes >& xTarget
397 , VDataSeries& rDataSeries
398 , sal_Int32 nPointIndex
399 , double fValue
400 , double fSumValue
401 , const awt::Point& rScreenPosition2D
402 , LabelAlignment eAlignment
403 , sal_Int32 nOffset
404 , sal_Int32 nTextWidth )
405 {
406 uno::Reference< drawing::XShape > xTextShape;
407 Sequence<uno::Reference<XDataPointCustomLabelField>> aCustomLabels;
408
409 try
410 {
411 const uno::Reference< css::beans::XPropertySet >& xPropertySet(
412 rDataSeries.getPropertiesOfPoint( nPointIndex ) );
413 if( xPropertySet.is() )
414 {
415 uno::Any aAny = xPropertySet->getPropertyValue( CHART_UNONAME_CUSTOM_LABEL_FIELDS );
416 if( aAny.hasValue() )
417 {
418 aAny >>= aCustomLabels;
419 }
420 }
421
422 awt::Point aScreenPosition2D(rScreenPosition2D);
423 if(eAlignment==LABEL_ALIGN_LEFT)
424 aScreenPosition2D.X -= nOffset;
425 else if(eAlignment==LABEL_ALIGN_RIGHT)
426 aScreenPosition2D.X += nOffset;
427 else if(eAlignment==LABEL_ALIGN_TOP)
428 aScreenPosition2D.Y -= nOffset;
429 else if(eAlignment==LABEL_ALIGN_BOTTOM)
430 aScreenPosition2D.Y += nOffset;
431
432 uno::Reference< drawing::XShapes > xTarget_ =
433 m_pShapeFactory->createGroup2D(
434 getLabelsGroupShape(rDataSeries, xTarget),
435 ObjectIdentifier::createPointCID( rDataSeries.getLabelCID_Stub(), nPointIndex));
436
437 //check whether the label needs to be created and how:
438 DataPointLabel* pLabel = rDataSeries.getDataPointLabelIfLabel( nPointIndex );
439
440 if( !pLabel )
441 return xTextShape;
442
443 //prepare legend symbol
444
445 // get the font size for the label through the "CharHeight" property
446 // attached to the passed data series entry.
447 // (By tracing font height values it results that for pie chart the
448 // font size is not the same for all labels, but here no font size
449 // modification occurs).
450 float fViewFontSize( 10.0 );
451 {
452 uno::Reference< beans::XPropertySet > xProps( rDataSeries.getPropertiesOfPoint( nPointIndex ) );
453 if( xProps.is() )
454 xProps->getPropertyValue( "CharHeight") >>= fViewFontSize;
455 fViewFontSize = convertPointToMm100(fViewFontSize);
456 }
457
458 // the font height is used for computing the size of an optional legend
459 // symbol to be prepended to the text label.
460 Reference< drawing::XShape > xSymbol;
461 if(pLabel->ShowLegendSymbol)
462 {
463 sal_Int32 nSymbolHeight = static_cast< sal_Int32 >( fViewFontSize * 0.6 );
464 awt::Size aCurrentRatio = getPreferredLegendKeyAspectRatio();
465 sal_Int32 nSymbolWidth = aCurrentRatio.Width;
466 if( aCurrentRatio.Height > 0 )
467 {
468 nSymbolWidth = nSymbolHeight* aCurrentRatio.Width/aCurrentRatio.Height;
469 }
470 awt::Size aMaxSymbolExtent( nSymbolWidth, nSymbolHeight );
471
472 if( rDataSeries.isVaryColorsByPoint() )
473 xSymbol.set( VSeriesPlotter::createLegendSymbolForPoint( aMaxSymbolExtent, rDataSeries, nPointIndex, xTarget_, m_xShapeFactory ) );
474 else
475 xSymbol.set( VSeriesPlotter::createLegendSymbolForSeries( aMaxSymbolExtent, rDataSeries, xTarget_, m_xShapeFactory ) );
476 }
477
478 //prepare text
479 bool bTextWrap = false;
480 OUString aSeparator(" ");
481 double fRotationDegrees = 0.0;
482 try
483 {
484 uno::Reference< beans::XPropertySet > xPointProps( rDataSeries.getPropertiesOfPoint( nPointIndex ) );
485 if(xPointProps.is())
486 {
487 xPointProps->getPropertyValue( "TextWordWrap" ) >>= bTextWrap;
488 xPointProps->getPropertyValue( "LabelSeparator" ) >>= aSeparator;
489 // Extract the optional text rotation through the
490 // "TextRotation" property attached to the passed data point.
491 xPointProps->getPropertyValue( "TextRotation" ) >>= fRotationDegrees;
492 }
493 }
494 catch( const uno::Exception& )
495 {
496 TOOLS_WARN_EXCEPTION("chart2", "" );
497 }
498
499 sal_Int32 nLineCountForSymbolsize = 0;
500 sal_uInt32 nTextListLength = 4;
501 sal_uInt32 nCustomLabelsCount = aCustomLabels.getLength();
502 Sequence< OUString > aTextList( nTextListLength );
503
504 bool bUseCustomLabel = nCustomLabelsCount > 0;
505 if( bUseCustomLabel )
506 {
507 nTextListLength = ( nCustomLabelsCount > 3 ) ? nCustomLabelsCount : 3;
508 aSeparator = "";
509 aTextList = Sequence< OUString >( nTextListLength );
510 for( sal_uInt32 i = 0; i < nCustomLabelsCount; ++i )
511 {
512 switch( aCustomLabels[i]->getFieldType() )
513 {
514 case DataPointCustomLabelFieldType_VALUE:
515 {
516 aTextList[i] = getLabelTextForValue( rDataSeries, nPointIndex, fValue, false );
517 break;
518 }
519 case DataPointCustomLabelFieldType_CATEGORYNAME:
520 {
521 aTextList[i] = getCategoryName( nPointIndex );
522 break;
523 }
524 case DataPointCustomLabelFieldType_SERIESNAME:
525 {
526 OUString aRole;
527 if ( m_xChartTypeModel )
528 aRole = m_xChartTypeModel->getRoleOfSequenceForSeriesLabel();
529 const uno::Reference< XDataSeries >& xSeries( rDataSeries.getModel() );
530 aTextList[i] = DataSeriesHelper::getDataSeriesLabel( xSeries, aRole );
531 break;
532 }
533 case DataPointCustomLabelFieldType_PERCENTAGE:
534 {
535 if(fSumValue == 0.0)
536 fSumValue = 1.0;
537 fValue /= fSumValue;
538 if(fValue < 0)
539 fValue *= -1.0;
540
541 aTextList[i] = getLabelTextForValue(rDataSeries, nPointIndex, fValue, true);
542 break;
543 }
544 case DataPointCustomLabelFieldType_CELLREF:
545 case DataPointCustomLabelFieldType_CELLRANGE:
546 {
547 // TODO: for now doesn't show placeholder
548 aTextList[i] = OUString();
549 break;
550 }
551 case DataPointCustomLabelFieldType_TEXT:
552 {
553 aTextList[i] = aCustomLabels[i]->getString();
554 break;
555 }
556 case DataPointCustomLabelFieldType_NEWLINE:
557 {
558 aTextList[i] = "\n";
559 break;
560 }
561 default:
562 break;
563 }
564 aCustomLabels[i]->setString( aTextList[i] );
565 }
566 }
567 else
568 {
569 if( pLabel->ShowCategoryName )
570 {
571 aTextList[0] = getCategoryName( nPointIndex );
572 }
573
574 if( pLabel->ShowSeriesName )
575 {
576 OUString aRole;
577 if ( m_xChartTypeModel )
578 aRole = m_xChartTypeModel->getRoleOfSequenceForSeriesLabel();
579 const uno::Reference< XDataSeries >& xSeries( rDataSeries.getModel() );
580 aTextList[1] = DataSeriesHelper::getDataSeriesLabel( xSeries, aRole );
581 }
582
583 if( pLabel->ShowNumber )
584 {
585 aTextList[2] = getLabelTextForValue(rDataSeries, nPointIndex, fValue, false);
586 }
587
588 if( pLabel->ShowNumberInPercent )
589 {
590 if(fSumValue==0.0)
591 fSumValue=1.0;
592 fValue /= fSumValue;
593 if( fValue < 0 )
594 fValue*=-1.0;
595
596 aTextList[3] = getLabelTextForValue(rDataSeries, nPointIndex, fValue, true);
597 }
598 }
599
600 for( auto const & line : std::as_const(aTextList) )
601 {
602 if( !line.isEmpty() )
603 {
604 ++nLineCountForSymbolsize;
605 }
606 }
607
608 //prepare properties for multipropertyset-interface of shape
609 tNameSequence* pPropNames;
610 tAnySequence* pPropValues;
611 if( !rDataSeries.getTextLabelMultiPropertyLists( nPointIndex, pPropNames, pPropValues ) )
612 return xTextShape;
613
614 // set text alignment for the text shape to be created.
615 LabelPositionHelper::changeTextAdjustment( *pPropValues, *pPropNames, eAlignment );
616
617 // check if data series entry percent value and absolute value have to
618 // be appended to the text label, and what should be the separator
619 // character (comma, space, new line). In case it is a new line we get
620 // a multi-line label.
621 bool bMultiLineLabel = ( aSeparator == "\n" );
622
623 if( bUseCustomLabel )
624 {
625 Sequence< uno::Reference< XFormattedString > > aFormattedLabels( aCustomLabels.getLength() );
626 for( int i = 0; i < aFormattedLabels.getLength(); i++ )
627 {
628 aFormattedLabels[i] = aCustomLabels[i];
629 }
630
631 // create text shape
632 xTextShape = ShapeFactory::getOrCreateShapeFactory( m_xShapeFactory )->
633 createText( xTarget_, aFormattedLabels, *pPropNames, *pPropValues,
634 ShapeFactory::makeTransformation( aScreenPosition2D ) );
635 }
636 else
637 {
638 // join text list elements
639 OUStringBuffer aText;
640 for( sal_uInt32 nN = 0; nN < nTextListLength; ++nN)
641 {
642 if( !aTextList[nN].isEmpty() )
643 {
644 if( !aText.isEmpty() )
645 {
646 aText.append(aSeparator);
647 }
648 aText.append( aTextList[nN] );
649 }
650 }
651
652 //create text shape
653 xTextShape = ShapeFactory::getOrCreateShapeFactory(m_xShapeFactory)->
654 createText( xTarget_, aText.makeStringAndClear(), *pPropNames, *pPropValues,
655 ShapeFactory::makeTransformation( aScreenPosition2D ) );
656 }
657
658 if( !xTextShape.is() )
659 return xTextShape;
660
661 // we need to use a default value for the maximum width property ?
662 if( nTextWidth == 0 && bTextWrap )
663 {
664 sal_Int32 nMinSize =
665 (m_aPageReferenceSize.Height < m_aPageReferenceSize.Width)
666 ? m_aPageReferenceSize.Height
667 : m_aPageReferenceSize.Width;
668 nTextWidth = nMinSize / 3;
669 }
670
671 // in case text must be wrapped set the maximum width property
672 // for the text shape
673 if( nTextWidth != 0 && bTextWrap )
674 {
675 uno::Reference< beans::XPropertySet > xProp( xTextShape, uno::UNO_QUERY );
676 if( xProp.is() )
677 {
678 // compute the height of a line of text
679 if( !bMultiLineLabel || nLineCountForSymbolsize <= 0 )
680 {
681 nLineCountForSymbolsize = 1;
682 }
683 awt::Size aTextSize = xTextShape->getSize();
684 sal_Int32 aTextLineHeight = aTextSize.Height / nLineCountForSymbolsize;
685
686 // set maximum text width
687 uno::Any aTextMaximumFrameWidth( nTextWidth );
688 xProp->setPropertyValue( "TextMaximumFrameWidth", aTextMaximumFrameWidth );
689
690 // compute the total lines of text
691 aTextSize = xTextShape->getSize();
692 nLineCountForSymbolsize = aTextSize.Height / aTextLineHeight;
693 }
694 }
695
696 // in case text is rotated, the transformation property of the text
697 // shape is modified.
698 if( fRotationDegrees != 0.0 )
699 {
700 const double fDegreesPi( -basegfx::deg2rad(fRotationDegrees) );
701 uno::Reference< beans::XPropertySet > xProp( xTextShape, uno::UNO_QUERY );
702 if( xProp.is() )
703 xProp->setPropertyValue( "Transformation", ShapeFactory::makeTransformation( aScreenPosition2D, fDegreesPi ) );
704 LabelPositionHelper::correctPositionForRotation( xTextShape, eAlignment, fRotationDegrees, true /*bRotateAroundCenter*/ );
705 }
706
707 awt::Point aTextShapePos(xTextShape->getPosition());
708 if( m_bPieLabelsAllowToMove && rDataSeries.isLabelCustomPos(nPointIndex) )
709 {
710 awt::Point aRelPos = rDataSeries.getLabelPosition(aTextShapePos, nPointIndex);
711 if( aRelPos.X != -1 )
712 {
713 xTextShape->setPosition(aRelPos);
714 if( !m_xChartTypeModel->getChartType().equalsIgnoreAsciiCase(CHART2_SERVICE_NAME_CHARTTYPE_PIE) &&
715 rDataSeries.getPropertiesOfSeries()->getPropertyValue( "ShowCustomLeaderLines" ).get<sal_Bool>())
716 {
717 sal_Int32 nX1 = rScreenPosition2D.X;
718 sal_Int32 nY1 = rScreenPosition2D.Y;
719 sal_Int32 nX2 = nX1;
720 sal_Int32 nY2 = nY1;
721 ::basegfx::B2IRectangle aRect(BaseGFXHelper::makeRectangle(aRelPos, xTextShape->getSize()));
722 if (nX1 < aRelPos.X)
723 nX2 = aRelPos.X;
724 else if (nX1 > aRect.getMaxX())
725 nX2 = aRect.getMaxX();
726
727 if (nY1 < aRect.getMinY())
728 nY2 = aRect.getMinY();
729 else if (nY1 > aRect.getMaxY())
730 nY2 = aRect.getMaxY();
731
732 //when the line is very short compared to the page size don't create one
733 ::basegfx::B2DVector aLength(nX1 - nX2, nY1 - nY2);
734 double fPageDiagonaleLength = sqrt(double(m_aPageReferenceSize.Width)*double(m_aPageReferenceSize.Width) + double(m_aPageReferenceSize.Height)*double(m_aPageReferenceSize.Height));
735 if ((aLength.getLength() / fPageDiagonaleLength) >= 0.01)
736 {
737 drawing::PointSequenceSequence aPoints(1);
738 aPoints[0].realloc(2);
739 aPoints[0][0].X = nX1;
740 aPoints[0][0].Y = nY1;
741 aPoints[0][1].X = nX2;
742 aPoints[0][1].Y = nY2;
743
744 VLineProperties aVLineProperties;
745 m_pShapeFactory->createLine2D(xTarget, aPoints, &aVLineProperties);
746 }
747 }
748 }
749 }
750
751 // in case legend symbol has to be displayed, text shape position is
752 // slightly changed.
753 const awt::Point aUnrotatedTextPos(xTextShape->getPosition());
754 if( xSymbol.is() )
755 {
756 const awt::Point aOldTextPos( xTextShape->getPosition() );
757 awt::Point aNewTextPos( aOldTextPos );
758
759 awt::Point aSymbolPosition( aUnrotatedTextPos );
760 awt::Size aSymbolSize( xSymbol->getSize() );
761 awt::Size aTextSize = xTextShape->getSize();
762
763 sal_Int32 nXDiff = aSymbolSize.Width + static_cast< sal_Int32 >( std::max( 100.0, fViewFontSize * 0.22 ) );//minimum 1mm
764 if( !bMultiLineLabel || nLineCountForSymbolsize <= 0 )
765 nLineCountForSymbolsize = 1;
766 aSymbolPosition.Y += ((aTextSize.Height/nLineCountForSymbolsize)/4);
767
768 if(eAlignment==LABEL_ALIGN_LEFT
769 || eAlignment==LABEL_ALIGN_LEFT_TOP
770 || eAlignment==LABEL_ALIGN_LEFT_BOTTOM)
771 {
772 aSymbolPosition.X -= nXDiff;
773 }
774 else if(eAlignment==LABEL_ALIGN_RIGHT
775 || eAlignment==LABEL_ALIGN_RIGHT_TOP
776 || eAlignment==LABEL_ALIGN_RIGHT_BOTTOM )
777 {
778 aNewTextPos.X += nXDiff;
779 }
780 else if(eAlignment==LABEL_ALIGN_TOP
781 || eAlignment==LABEL_ALIGN_BOTTOM
782 || eAlignment==LABEL_ALIGN_CENTER )
783 {
784 aSymbolPosition.X -= nXDiff/2;
785 aNewTextPos.X += nXDiff/2;
786 }
787
788 xSymbol->setPosition( aSymbolPosition );
789 xTextShape->setPosition( aNewTextPos );
790 }
791 }
792 catch( const uno::Exception& )
793 {
794 TOOLS_WARN_EXCEPTION("chart2", "" );
795 }
796
797 return xTextShape;
798 }
799
800 namespace
801 {
802 double lcl_getErrorBarLogicLength(
803 const uno::Sequence< double > & rData,
804 const uno::Reference< beans::XPropertySet >& xProp,
805 sal_Int32 nErrorBarStyle,
806 sal_Int32 nIndex,
807 bool bPositive,
808 bool bYError )
809 {
810 double fResult;
811 ::rtl::math::setNan( & fResult );
812 try
813 {
814 switch( nErrorBarStyle )
815 {
816 case css::chart::ErrorBarStyle::NONE:
817 break;
818 case css::chart::ErrorBarStyle::VARIANCE:
819 fResult = StatisticsHelper::getVariance( rData );
820 break;
821 case css::chart::ErrorBarStyle::STANDARD_DEVIATION:
822 fResult = StatisticsHelper::getStandardDeviation( rData );
823 break;
824 case css::chart::ErrorBarStyle::RELATIVE:
825 {
826 double fPercent = 0;
827 if( xProp->getPropertyValue( bPositive
828 ? OUString("PositiveError")
829 : OUString("NegativeError") ) >>= fPercent )
830 {
831 if( nIndex >=0 && nIndex < rData.getLength() &&
832 ! std::isnan( rData[nIndex] ) &&
833 ! std::isnan( fPercent ))
834 {
835 fResult = rData[nIndex] * fPercent / 100.0;
836 }
837 }
838 }
839 break;
840 case css::chart::ErrorBarStyle::ABSOLUTE:
841 xProp->getPropertyValue( bPositive
842 ? OUString("PositiveError")
843 : OUString("NegativeError") ) >>= fResult;
844 break;
845 case css::chart::ErrorBarStyle::ERROR_MARGIN:
846 {
847 // todo: check if this is really what's called error-margin
848 double fPercent = 0;
849 if( xProp->getPropertyValue( bPositive
850 ? OUString("PositiveError")
851 : OUString("NegativeError") ) >>= fPercent )
852 {
853 double fMaxValue;
854 ::rtl::math::setInf(&fMaxValue, true);
855 for(double d : rData)
856 {
857 if(fMaxValue < d)
858 fMaxValue = d;
859 }
860 if( std::isfinite( fMaxValue ) &&
861 std::isfinite( fPercent ))
862 {
863 fResult = fMaxValue * fPercent / 100.0;
864 }
865 }
866 }
867 break;
868 case css::chart::ErrorBarStyle::STANDARD_ERROR:
869 fResult = StatisticsHelper::getStandardError( rData );
870 break;
871 case css::chart::ErrorBarStyle::FROM_DATA:
872 {
873 uno::Reference< chart2::data::XDataSource > xErrorBarData( xProp, uno::UNO_QUERY );
874 if( xErrorBarData.is())
875 fResult = StatisticsHelper::getErrorFromDataSource(
876 xErrorBarData, nIndex, bPositive, bYError);
877 }
878 break;
879 }
880 }
881 catch( const uno::Exception & )
882 {
883 TOOLS_WARN_EXCEPTION("chart2", "" );
884 }
885
886 return fResult;
887 }
888
889 void lcl_AddErrorBottomLine( const drawing::Position3D& rPosition, ::basegfx::B2DVector aMainDirection
890 , drawing::PolyPolygonShape3D& rPoly, sal_Int32 nSequenceIndex )
891 {
892 double fFixedWidth = 200.0;
893
894 aMainDirection.normalize();
895 ::basegfx::B2DVector aOrthoDirection(-aMainDirection.getY(),aMainDirection.getX());
896 aOrthoDirection.normalize();
897
898 ::basegfx::B2DVector aAnchor( rPosition.PositionX, rPosition.PositionY );
899 ::basegfx::B2DVector aStart = aAnchor + aOrthoDirection*fFixedWidth/2.0;
900 ::basegfx::B2DVector aEnd = aAnchor - aOrthoDirection*fFixedWidth/2.0;
901
902 AddPointToPoly( rPoly, drawing::Position3D( aStart.getX(), aStart.getY(), rPosition.PositionZ), nSequenceIndex );
903 AddPointToPoly( rPoly, drawing::Position3D( aEnd.getX(), aEnd.getY(), rPosition.PositionZ), nSequenceIndex );
904 }
905
906 ::basegfx::B2DVector lcl_getErrorBarMainDirection(
907 const drawing::Position3D& rStart
908 , const drawing::Position3D& rBottomEnd
909 , PlottingPositionHelper const * pPosHelper
910 , const drawing::Position3D& rUnscaledLogicPosition
911 , bool bYError )
912 {
913 ::basegfx::B2DVector aMainDirection( rStart.PositionX - rBottomEnd.PositionX
914 , rStart.PositionY - rBottomEnd.PositionY );
915 if( !aMainDirection.getLength() )
916 {
917 //get logic clip values:
918 double MinX = pPosHelper->getLogicMinX();
919 double MinY = pPosHelper->getLogicMinY();
920 double MaxX = pPosHelper->getLogicMaxX();
921 double MaxY = pPosHelper->getLogicMaxY();
922 double fZ = pPosHelper->getLogicMinZ();
923
924 if( bYError )
925 {
926 //main direction has constant x value
927 MinX = rUnscaledLogicPosition.PositionX;
928 MaxX = rUnscaledLogicPosition.PositionX;
929 }
930 else
931 {
932 //main direction has constant y value
933 MinY = rUnscaledLogicPosition.PositionY;
934 MaxY = rUnscaledLogicPosition.PositionY;
935 }
936
937 drawing::Position3D aStart = pPosHelper->transformLogicToScene( MinX, MinY, fZ, false );
938 drawing::Position3D aEnd = pPosHelper->transformLogicToScene( MaxX, MaxY, fZ, false );
939
940 aMainDirection = ::basegfx::B2DVector( aStart.PositionX - aEnd.PositionX
941 , aStart.PositionY - aEnd.PositionY );
942 }
943 if( !aMainDirection.getLength() )
944 {
945 //@todo
946 }
947 return aMainDirection;
948 }
949
950 drawing::Position3D lcl_transformMixedToScene( PlottingPositionHelper const * pPosHelper
951 , double fX /*scaled*/, double fY /*unscaled*/, double fZ /*unscaled*/ )
952 {
953 if(!pPosHelper)
954 return drawing::Position3D(0,0,0);
955 pPosHelper->doLogicScaling( nullptr,&fY,&fZ );
956 pPosHelper->clipScaledLogicValues( &fX,&fY,&fZ );
957 return pPosHelper->transformScaledLogicToScene( fX, fY, fZ, false );
958 }
959
960 } // anonymous namespace
961
962 void VSeriesPlotter::createErrorBar(
963 const uno::Reference< drawing::XShapes >& xTarget
964 , const drawing::Position3D& rUnscaledLogicPosition
965 , const uno::Reference< beans::XPropertySet > & xErrorBarProperties
966 , const VDataSeries& rVDataSeries
967 , sal_Int32 nIndex
968 , bool bYError /* = true */
969 , const double* pfScaledLogicX
970 )
971 {
972 if( !ChartTypeHelper::isSupportingStatisticProperties( m_xChartTypeModel, m_nDimension ) )
973 return;
974
975 if( ! xErrorBarProperties.is())
976 return;
977
978 try
979 {
980 bool bShowPositive = false;
981 bool bShowNegative = false;
982 sal_Int32 nErrorBarStyle = css::chart::ErrorBarStyle::VARIANCE;
983
984 xErrorBarProperties->getPropertyValue( "ShowPositiveError") >>= bShowPositive;
985 xErrorBarProperties->getPropertyValue( "ShowNegativeError") >>= bShowNegative;
986 xErrorBarProperties->getPropertyValue( "ErrorBarStyle") >>= nErrorBarStyle;
987
988 if(!bShowPositive && !bShowNegative)
989 return;
990
991 if(nErrorBarStyle==css::chart::ErrorBarStyle::NONE)
992 return;
993
994 if (!m_pPosHelper)
995 return;
996
997 drawing::Position3D aUnscaledLogicPosition(rUnscaledLogicPosition);
998 if(nErrorBarStyle==css::chart::ErrorBarStyle::STANDARD_DEVIATION)
999 {
1000 if (bYError)
1001 aUnscaledLogicPosition.PositionY = rVDataSeries.getYMeanValue();
1002 else
1003 aUnscaledLogicPosition.PositionX = rVDataSeries.getXMeanValue();
1004 }
1005
1006 bool bCreateNegativeBorder = false;//make a vertical line at the negative end of the error bar
1007 bool bCreatePositiveBorder = false;//make a vertical line at the positive end of the error bar
1008 drawing::Position3D aMiddle(aUnscaledLogicPosition);
1009 const double fX = aUnscaledLogicPosition.PositionX;
1010 const double fY = aUnscaledLogicPosition.PositionY;
1011 const double fZ = aUnscaledLogicPosition.PositionZ;
1012 double fScaledX = fX;
1013 if( pfScaledLogicX )
1014 fScaledX = *pfScaledLogicX;
1015 else
1016 m_pPosHelper->doLogicScaling( &fScaledX, nullptr, nullptr );
1017
1018 aMiddle = lcl_transformMixedToScene( m_pPosHelper, fScaledX, fY, fZ );
1019
1020 drawing::Position3D aNegative(aMiddle);
1021 drawing::Position3D aPositive(aMiddle);
1022
1023 uno::Sequence< double > aData( bYError ? rVDataSeries.getAllY() : rVDataSeries.getAllX() );
1024
1025 if( bShowPositive )
1026 {
1027 double fLength = lcl_getErrorBarLogicLength( aData, xErrorBarProperties, nErrorBarStyle, nIndex, true, bYError );
1028 if( std::isfinite( fLength ) )
1029 {
1030 double fLocalX = fX;
1031 double fLocalY = fY;
1032 if( bYError )
1033 {
1034 fLocalY+=fLength;
1035 aPositive = lcl_transformMixedToScene( m_pPosHelper, fScaledX, fLocalY, fZ );
1036 }
1037 else
1038 {
1039 fLocalX+=fLength;
1040 aPositive = m_pPosHelper->transformLogicToScene( fLocalX, fLocalY, fZ, true );
1041 }
1042 bCreatePositiveBorder = m_pPosHelper->isLogicVisible(fLocalX, fLocalY, fZ);
1043 }
1044 else
1045 bShowPositive = false;
1046 }
1047
1048 if( bShowNegative )
1049 {
1050 double fLength = lcl_getErrorBarLogicLength( aData, xErrorBarProperties, nErrorBarStyle, nIndex, false, bYError );
1051 if( std::isfinite( fLength ) )
1052 {
1053 double fLocalX = fX;
1054 double fLocalY = fY;
1055 if( bYError )
1056 {
1057 fLocalY-=fLength;
1058 aNegative = lcl_transformMixedToScene( m_pPosHelper, fScaledX, fLocalY, fZ );
1059 }
1060 else
1061 {
1062 fLocalX-=fLength;
1063 aNegative = m_pPosHelper->transformLogicToScene( fLocalX, fLocalY, fZ, true );
1064 }
1065 bCreateNegativeBorder = m_pPosHelper->isLogicVisible( fLocalX, fLocalY, fZ);
1066 }
1067 else
1068 bShowNegative = false;
1069 }
1070
1071 if(!bShowPositive && !bShowNegative)
1072 return;
1073
1074 drawing::PolyPolygonShape3D aPoly;
1075
1076 sal_Int32 nSequenceIndex=0;
1077 if( bShowNegative )
1078 AddPointToPoly( aPoly, aNegative, nSequenceIndex );
1079 AddPointToPoly( aPoly, aMiddle, nSequenceIndex );
1080 if( bShowPositive )
1081 AddPointToPoly( aPoly, aPositive, nSequenceIndex );
1082
1083 if( bShowNegative && bCreateNegativeBorder )
1084 {
1085 ::basegfx::B2DVector aMainDirection = lcl_getErrorBarMainDirection( aMiddle, aNegative, m_pPosHelper, aUnscaledLogicPosition, bYError );
1086 nSequenceIndex++;
1087 lcl_AddErrorBottomLine( aNegative, aMainDirection, aPoly, nSequenceIndex );
1088 }
1089 if( bShowPositive && bCreatePositiveBorder )
1090 {
1091 ::basegfx::B2DVector aMainDirection = lcl_getErrorBarMainDirection( aMiddle, aPositive, m_pPosHelper, aUnscaledLogicPosition, bYError );
1092 nSequenceIndex++;
1093 lcl_AddErrorBottomLine( aPositive, aMainDirection, aPoly, nSequenceIndex );
1094 }
1095
1096 uno::Reference< drawing::XShape > xShape = m_pShapeFactory->createLine2D( xTarget, PolyToPointSequence( aPoly) );
1097 setMappedProperties( xShape, xErrorBarProperties, PropertyMapper::getPropertyNameMapForLineProperties() );
1098 }
1099 catch( const uno::Exception & )
1100 {
1101 TOOLS_WARN_EXCEPTION("chart2", "" );
1102 }
1103
1104 }
1105
1106 void VSeriesPlotter::addErrorBorder(
1107 const drawing::Position3D& rPos0
1108 ,const drawing::Position3D& rPos1
1109 ,const uno::Reference< drawing::XShapes >& rTarget
1110 ,const uno::Reference< beans::XPropertySet >& rErrorBorderProp )
1111 {
1112 drawing::PolyPolygonShape3D aPoly;
1113 sal_Int32 nSequenceIndex = 0;
1114 AddPointToPoly( aPoly, rPos0, nSequenceIndex );
1115 AddPointToPoly( aPoly, rPos1, nSequenceIndex );
1116 uno::Reference< drawing::XShape > xShape = m_pShapeFactory->createLine2D(
1117 rTarget, PolyToPointSequence( aPoly) );
1118 setMappedProperties( xShape, rErrorBorderProp,
1119 PropertyMapper::getPropertyNameMapForLineProperties() );
1120 }
1121
1122 void VSeriesPlotter::createErrorRectangle(
1123 const drawing::Position3D& rUnscaledLogicPosition
1124 ,VDataSeries& rVDataSeries
1125 ,sal_Int32 nIndex
1126 ,const uno::Reference< drawing::XShapes >& rTarget
1127 ,bool bUseXErrorData
1128 ,bool bUseYErrorData )
1129 {
1130 if ( m_nDimension != 2 )
1131 return;
1132
1133 // error border properties
1134 Reference< beans::XPropertySet > xErrorBorderPropX, xErrorBorderPropY;
1135 if ( bUseXErrorData )
1136 {
1137 xErrorBorderPropX = rVDataSeries.getXErrorBarProperties( nIndex );
1138 if ( !xErrorBorderPropX.is() )
1139 return;
1140 }
1141 uno::Reference< drawing::XShapes > xErrorBorder_ShapesX(
1142 getErrorBarsGroupShape( rVDataSeries, rTarget, false ) );
1143
1144 if ( bUseYErrorData )
1145 {
1146 xErrorBorderPropY = rVDataSeries.getYErrorBarProperties( nIndex );
1147 if ( !xErrorBorderPropY.is() )
1148 return;
1149 }
1150 uno::Reference< drawing::XShapes > xErrorBorder_ShapesY(
1151 getErrorBarsGroupShape( rVDataSeries, rTarget, true ) );
1152
1153 if( !ChartTypeHelper::isSupportingStatisticProperties( m_xChartTypeModel, m_nDimension ) )
1154 return;
1155
1156 try
1157 {
1158 bool bShowXPositive = false;
1159 bool bShowXNegative = false;
1160 bool bShowYPositive = false;
1161 bool bShowYNegative = false;
1162
1163 sal_Int32 nErrorBorderStyleX = css::chart::ErrorBarStyle::VARIANCE;
1164 sal_Int32 nErrorBorderStyleY = css::chart::ErrorBarStyle::VARIANCE;
1165
1166 if ( bUseXErrorData )
1167 {
1168 xErrorBorderPropX->getPropertyValue( "ErrorBarStyle" ) >>= nErrorBorderStyleX;
1169 xErrorBorderPropX->getPropertyValue( "ShowPositiveError") >>= bShowXPositive;
1170 xErrorBorderPropX->getPropertyValue( "ShowNegativeError") >>= bShowXNegative;
1171 }
1172 if ( bUseYErrorData )
1173 {
1174 xErrorBorderPropY->getPropertyValue( "ErrorBarStyle" ) >>= nErrorBorderStyleY;
1175 xErrorBorderPropY->getPropertyValue( "ShowPositiveError") >>= bShowYPositive;
1176 xErrorBorderPropY->getPropertyValue( "ShowNegativeError") >>= bShowYNegative;
1177 }
1178
1179 if ( bUseXErrorData && nErrorBorderStyleX == css::chart::ErrorBarStyle::NONE )
1180 bUseXErrorData = false;
1181 if ( bUseYErrorData && nErrorBorderStyleY == css::chart::ErrorBarStyle::NONE )
1182 bUseYErrorData = false;
1183
1184 if ( !bShowXPositive && !bShowXNegative && !bShowYPositive && !bShowYNegative )
1185 return;
1186
1187 if ( !m_pPosHelper )
1188 return;
1189
1190 drawing::Position3D aUnscaledLogicPosition( rUnscaledLogicPosition );
1191 if ( bUseXErrorData && nErrorBorderStyleX == css::chart::ErrorBarStyle::STANDARD_DEVIATION )
1192 aUnscaledLogicPosition.PositionX = rVDataSeries.getXMeanValue();
1193 if ( bUseYErrorData && nErrorBorderStyleY == css::chart::ErrorBarStyle::STANDARD_DEVIATION )
1194 aUnscaledLogicPosition.PositionY = rVDataSeries.getYMeanValue();
1195
1196 const double fX = aUnscaledLogicPosition.PositionX;
1197 const double fY = aUnscaledLogicPosition.PositionY;
1198 const double fZ = aUnscaledLogicPosition.PositionZ;
1199 double fScaledX = fX;
1200 m_pPosHelper->doLogicScaling( &fScaledX, nullptr, nullptr );
1201
1202 uno::Sequence< double > aDataX( rVDataSeries.getAllX() );
1203 uno::Sequence< double > aDataY( rVDataSeries.getAllY() );
1204
1205 double fPosX = 0.0;
1206 double fPosY = 0.0;
1207 double fNegX = 0.0;
1208 double fNegY = 0.0;
1209 if ( bUseXErrorData )
1210 {
1211 if ( bShowXPositive )
1212 fPosX = lcl_getErrorBarLogicLength( aDataX, xErrorBorderPropX,
1213 nErrorBorderStyleX, nIndex, true, false );
1214 if ( bShowXNegative )
1215 fNegX = lcl_getErrorBarLogicLength( aDataX, xErrorBorderPropX,
1216 nErrorBorderStyleX, nIndex, false, false );
1217 }
1218
1219 if ( bUseYErrorData )
1220 {
1221 if ( bShowYPositive )
1222 fPosY = lcl_getErrorBarLogicLength( aDataY, xErrorBorderPropY,
1223 nErrorBorderStyleY, nIndex, true, true );
1224 if ( bShowYNegative )
1225 fNegY = lcl_getErrorBarLogicLength( aDataY, xErrorBorderPropY,
1226 nErrorBorderStyleY, nIndex, false, true );
1227 }
1228
1229 if ( !( std::isfinite( fPosX ) &&
1230 std::isfinite( fPosY ) &&
1231 std::isfinite( fNegX ) &&
1232 std::isfinite( fNegY ) ) )
1233 return;
1234
1235 drawing::Position3D aBottomLeft( lcl_transformMixedToScene( m_pPosHelper,
1236 fX - fNegX, fY - fNegY, fZ ) );
1237 drawing::Position3D aTopLeft( lcl_transformMixedToScene( m_pPosHelper,
1238 fX - fNegX, fY + fPosY, fZ ) );
1239 drawing::Position3D aTopRight( lcl_transformMixedToScene( m_pPosHelper,
1240 fX + fPosX, fY + fPosY, fZ ) );
1241 drawing::Position3D aBottomRight( lcl_transformMixedToScene( m_pPosHelper,
1242 fX + fPosX, fY - fNegY, fZ ) );
1243 if ( bUseXErrorData )
1244 {
1245 // top border
1246 addErrorBorder( aTopLeft, aTopRight, xErrorBorder_ShapesX, xErrorBorderPropX );
1247
1248 // bottom border
1249 addErrorBorder( aBottomRight, aBottomLeft, xErrorBorder_ShapesX, xErrorBorderPropX );
1250 }
1251
1252 if ( bUseYErrorData )
1253 {
1254 // left border
1255 addErrorBorder( aBottomLeft, aTopLeft, xErrorBorder_ShapesY, xErrorBorderPropY );
1256
1257 // right border
1258 addErrorBorder( aTopRight, aBottomRight, xErrorBorder_ShapesY, xErrorBorderPropY );
1259 }
1260 }
1261 catch( const uno::Exception & )
1262 {
1263 DBG_UNHANDLED_EXCEPTION("chart2", "Exception in createErrorRectangle(). ");
1264 }
1265 }
1266
1267 void VSeriesPlotter::createErrorBar_X( const drawing::Position3D& rUnscaledLogicPosition
1268 , VDataSeries& rVDataSeries, sal_Int32 nPointIndex
1269 , const uno::Reference< drawing::XShapes >& xTarget )
1270 {
1271 if(m_nDimension!=2)
1272 return;
1273 // error bars
1274 uno::Reference< beans::XPropertySet > xErrorBarProp(rVDataSeries.getXErrorBarProperties(nPointIndex));
1275 if( xErrorBarProp.is())
1276 {
1277 uno::Reference< drawing::XShapes > xErrorBarsGroup_Shapes(
1278 getErrorBarsGroupShape(rVDataSeries, xTarget, false) );
1279
1280 createErrorBar( xErrorBarsGroup_Shapes
1281 , rUnscaledLogicPosition, xErrorBarProp
1282 , rVDataSeries, nPointIndex
1283 , false /* bYError */
1284 , nullptr );
1285 }
1286 }
1287
1288 void VSeriesPlotter::createErrorBar_Y( const drawing::Position3D& rUnscaledLogicPosition
1289 , VDataSeries& rVDataSeries, sal_Int32 nPointIndex
1290 , const uno::Reference< drawing::XShapes >& xTarget
1291 , double const * pfScaledLogicX )
1292 {
1293 if(m_nDimension!=2)
1294 return;
1295 // error bars
1296 uno::Reference< beans::XPropertySet > xErrorBarProp(rVDataSeries.getYErrorBarProperties(nPointIndex));
1297 if( xErrorBarProp.is())
1298 {
1299 uno::Reference< drawing::XShapes > xErrorBarsGroup_Shapes(
1300 getErrorBarsGroupShape(rVDataSeries, xTarget, true) );
1301
1302 createErrorBar( xErrorBarsGroup_Shapes
1303 , rUnscaledLogicPosition, xErrorBarProp
1304 , rVDataSeries, nPointIndex
1305 , true /* bYError */
1306 , pfScaledLogicX );
1307 }
1308 }
1309
1310 void VSeriesPlotter::createRegressionCurvesShapes( VDataSeries const & rVDataSeries,
1311 const uno::Reference< drawing::XShapes >& xTarget,
1312 const uno::Reference< drawing::XShapes >& xEquationTarget,
1313 bool bMaySkipPoints )
1314 {
1315 if(m_nDimension!=2)
1316 return;
1317 uno::Reference< XRegressionCurveContainer > xContainer( rVDataSeries.getModel(), uno::UNO_QUERY );
1318 if(!xContainer.is())
1319 return;
1320
1321 if (!m_pPosHelper)
1322 return;
1323
1324 uno::Sequence< uno::Reference< XRegressionCurve > > aCurveList = xContainer->getRegressionCurves();
1325
1326 for(sal_Int32 nN=0; nN<aCurveList.getLength(); nN++)
1327 {
1328 uno::Reference< XRegressionCurveCalculator > xCalculator( aCurveList[nN]->getCalculator() );
1329 if( !xCalculator.is())
1330 continue;
1331
1332 uno::Reference< beans::XPropertySet > xProperties( aCurveList[nN], uno::UNO_QUERY );
1333
1334 bool bAverageLine = RegressionCurveHelper::isMeanValueLine( aCurveList[nN] );
1335
1336 sal_Int32 aDegree = 2;
1337 sal_Int32 aPeriod = 2;
1338 double aExtrapolateForward = 0.0;
1339 double aExtrapolateBackward = 0.0;
1340 bool bForceIntercept = false;
1341 double aInterceptValue = 0.0;
1342
1343 if ( xProperties.is() && !bAverageLine )
1344 {
1345 xProperties->getPropertyValue( "PolynomialDegree") >>= aDegree;
1346 xProperties->getPropertyValue( "MovingAveragePeriod") >>= aPeriod;
1347 xProperties->getPropertyValue( "ExtrapolateForward") >>= aExtrapolateForward;
1348 xProperties->getPropertyValue( "ExtrapolateBackward") >>= aExtrapolateBackward;
1349 xProperties->getPropertyValue( "ForceIntercept") >>= bForceIntercept;
1350 if (bForceIntercept)
1351 xProperties->getPropertyValue( "InterceptValue") >>= aInterceptValue;
1352 }
1353
1354 double fChartMinX = m_pPosHelper->getLogicMinX();
1355 double fChartMaxX = m_pPosHelper->getLogicMaxX();
1356
1357 double fMinX = fChartMinX;
1358 double fMaxX = fChartMaxX;
1359
1360 double fPointScale = 1.0;
1361
1362 if( !bAverageLine )
1363 {
1364 rVDataSeries.getMinMaxXValue(fMinX, fMaxX);
1365 fMaxX += aExtrapolateForward;
1366 fMinX -= aExtrapolateBackward;
1367
1368 fPointScale = (fMaxX - fMinX) / (fChartMaxX - fChartMinX);
1369 // sanitize the value, tdf#119922
1370 fPointScale = std::min(fPointScale, 1000.0);
1371 }
1372
1373 xCalculator->setRegressionProperties(aDegree, bForceIntercept, aInterceptValue, aPeriod);
1374 xCalculator->recalculateRegression( rVDataSeries.getAllX(), rVDataSeries.getAllY() );
1375 sal_Int32 nPointCount = 100 * fPointScale;
1376
1377 if ( nPointCount < 2 )
1378 nPointCount = 2;
1379
1380 std::vector< ExplicitScaleData > aScales( m_pPosHelper->getScales());
1381 uno::Reference< chart2::XScaling > xScalingX;
1382 uno::Reference< chart2::XScaling > xScalingY;
1383 if( aScales.size() >= 2 )
1384 {
1385 xScalingX.set( aScales[0].Scaling );
1386 xScalingY.set( aScales[1].Scaling );
1387 }
1388
1389 const uno::Sequence< geometry::RealPoint2D > aCalculatedPoints(
1390 xCalculator->getCurveValues(
1391 fMinX, fMaxX, nPointCount,
1392 xScalingX, xScalingY, bMaySkipPoints ));
1393
1394 nPointCount = aCalculatedPoints.getLength();
1395
1396 drawing::PolyPolygonShape3D aRegressionPoly;
1397 aRegressionPoly.SequenceX.realloc(1);
1398 aRegressionPoly.SequenceY.realloc(1);
1399 aRegressionPoly.SequenceZ.realloc(1);
1400 aRegressionPoly.SequenceX[0].realloc(nPointCount);
1401 aRegressionPoly.SequenceY[0].realloc(nPointCount);
1402 aRegressionPoly.SequenceZ[0].realloc(nPointCount);
1403
1404 sal_Int32 nRealPointCount = 0;
1405
1406 for(geometry::RealPoint2D const & p : aCalculatedPoints)
1407 {
1408 double fLogicX = p.X;
1409 double fLogicY = p.Y;
1410 double fLogicZ = 0.0; //dummy
1411
1412 // fdo#51656: don't scale mean value lines
1413 if(!bAverageLine)
1414 m_pPosHelper->doLogicScaling( &fLogicX, &fLogicY, &fLogicZ );
1415
1416 if(!std::isnan(fLogicX) && !std::isinf(fLogicX) &&
1417 !std::isnan(fLogicY) && !std::isinf(fLogicY) &&
1418 !std::isnan(fLogicZ) && !std::isinf(fLogicZ) )
1419 {
1420 aRegressionPoly.SequenceX[0][nRealPointCount] = fLogicX;
1421 aRegressionPoly.SequenceY[0][nRealPointCount] = fLogicY;
1422 nRealPointCount++;
1423 }
1424 }
1425 aRegressionPoly.SequenceX[0].realloc(nRealPointCount);
1426 aRegressionPoly.SequenceY[0].realloc(nRealPointCount);
1427 aRegressionPoly.SequenceZ[0].realloc(nRealPointCount);
1428
1429 drawing::PolyPolygonShape3D aClippedPoly;
1430 Clipping::clipPolygonAtRectangle( aRegressionPoly, m_pPosHelper->getScaledLogicClipDoubleRect(), aClippedPoly );
1431 aRegressionPoly = aClippedPoly;
1432 m_pPosHelper->transformScaledLogicToScene( aRegressionPoly );
1433
1434 awt::Point aDefaultPos;
1435 if( aRegressionPoly.SequenceX.hasElements() && aRegressionPoly.SequenceX[0].hasElements() )
1436 {
1437 VLineProperties aVLineProperties;
1438 aVLineProperties.initFromPropertySet( xProperties );
1439
1440 //create an extra group shape for each curve for selection handling
1441 uno::Reference< drawing::XShapes > xRegressionGroupShapes =
1442 createGroupShape( xTarget, rVDataSeries.getDataCurveCID( nN, bAverageLine ) );
1443 uno::Reference< drawing::XShape > xShape = m_pShapeFactory->createLine2D(
1444 xRegressionGroupShapes, PolyToPointSequence( aRegressionPoly ), &aVLineProperties );
1445 ShapeFactory::setShapeName( xShape, "MarkHandles" );
1446 aDefaultPos = xShape->getPosition();
1447 }
1448
1449 // curve equation and correlation coefficient
1450 uno::Reference< beans::XPropertySet > xEquationProperties( aCurveList[nN]->getEquationProperties());
1451 if( xEquationProperties.is())
1452 {
1453 createRegressionCurveEquationShapes(
1454 rVDataSeries.getDataCurveEquationCID( nN ),
1455 xEquationProperties, xEquationTarget, xCalculator,
1456 aDefaultPos );
1457 }
1458 }
1459 }
1460
1461 static sal_Int32 lcl_getOUStringMaxLineLength ( OUStringBuffer const & aString )
1462 {
1463 const sal_Int32 nStringLength = aString.getLength();
1464 sal_Int32 nMaxLineLength = 0;
1465
1466 for ( sal_Int32 i=0; i<nStringLength; i++ )
1467 {
1468 sal_Int32 indexSep = aString.indexOf( "\n", i );
1469 if ( indexSep < 0 )
1470 indexSep = nStringLength;
1471 sal_Int32 nLineLength = indexSep - i;
1472 if ( nLineLength > nMaxLineLength )
1473 nMaxLineLength = nLineLength;
1474 i = indexSep;
1475 }
1476
1477 return nMaxLineLength;
1478 }
1479
1480 void VSeriesPlotter::createRegressionCurveEquationShapes(
1481 const OUString & rEquationCID,
1482 const uno::Reference< beans::XPropertySet > & xEquationProperties,
1483 const uno::Reference< drawing::XShapes >& xEquationTarget,
1484 const uno::Reference< chart2::XRegressionCurveCalculator > & xRegressionCurveCalculator,
1485 awt::Point aDefaultPos )
1486 {
1487 OSL_ASSERT( xEquationProperties.is());
1488 if( !xEquationProperties.is())
1489 return;
1490
1491 bool bShowEquation = false;
1492 bool bShowCorrCoeff = false;
1493 if(!(( xEquationProperties->getPropertyValue( "ShowEquation") >>= bShowEquation ) &&
1494 ( xEquationProperties->getPropertyValue( "ShowCorrelationCoefficient") >>= bShowCorrCoeff )))
1495 return;
1496
1497 if( ! (bShowEquation || bShowCorrCoeff))
1498 return;
1499
1500 OUStringBuffer aFormula;
1501 sal_Int32 nNumberFormatKey = 0;
1502 sal_Int32 nFormulaWidth = 0;
1503 xEquationProperties->getPropertyValue(CHART_UNONAME_NUMFMT) >>= nNumberFormatKey;
1504 bool bResizeEquation = true;
1505 sal_Int32 nMaxIteration = 2;
1506 if ( bShowEquation )
1507 {
1508 OUString aXName, aYName;
1509 if ( !(xEquationProperties->getPropertyValue( "XName" ) >>= aXName) )
1510 aXName = OUString( "x" );
1511 if ( !(xEquationProperties->getPropertyValue( "YName" ) >>= aYName) )
1512 aYName = OUString( "f(x)" );
1513 xRegressionCurveCalculator->setXYNames( aXName, aYName );
1514 }
1515
1516 for ( sal_Int32 nCountIteration = 0; bResizeEquation && nCountIteration < nMaxIteration ; nCountIteration++ )
1517 {
1518 bResizeEquation = false;
1519 if( bShowEquation )
1520 {
1521 if (m_apNumberFormatterWrapper)
1522 { // iteration 0: default representation (no wrap)
1523 // iteration 1: expected width (nFormulaWidth) is calculated
1524 aFormula = xRegressionCurveCalculator->getFormattedRepresentation(
1525 m_apNumberFormatterWrapper->getNumberFormatsSupplier(),
1526 nNumberFormatKey, nFormulaWidth );
1527 nFormulaWidth = lcl_getOUStringMaxLineLength( aFormula );
1528 }
1529 else
1530 {
1531 aFormula = xRegressionCurveCalculator->getRepresentation();
1532 }
1533
1534 if( bShowCorrCoeff )
1535 {
1536 aFormula.append( "\n" );
1537 }
1538 }
1539 if( bShowCorrCoeff )
1540 {
1541 aFormula.append( "R" ).append( OUStringChar( aSuperscriptFigures[2] ) ).append( " = " );
1542 double fR( xRegressionCurveCalculator->getCorrelationCoefficient());
1543 if (m_apNumberFormatterWrapper)
1544 {
1545 Color nLabelCol;
1546 bool bColChanged;
1547 aFormula.append(
1548 m_apNumberFormatterWrapper->getFormattedString(
1549 nNumberFormatKey, fR*fR, nLabelCol, bColChanged ));
1550 //@todo: change color of label if bColChanged is true
1551 }
1552 else
1553 {
1554 const LocaleDataWrapper& rLocaleDataWrapper = Application::GetSettings().GetLocaleDataWrapper();
1555 const OUString& aNumDecimalSep = rLocaleDataWrapper.getNumDecimalSep();
1556 sal_Unicode aDecimalSep = aNumDecimalSep[0];
1557 aFormula.append( ::rtl::math::doubleToUString(
1558 fR*fR, rtl_math_StringFormat_G, 4, aDecimalSep, true ));
1559 }
1560 }
1561
1562 awt::Point aScreenPosition2D;
1563 chart2::RelativePosition aRelativePosition;
1564 if( xEquationProperties->getPropertyValue( "RelativePosition") >>= aRelativePosition )
1565 {
1566 //@todo decide whether x is primary or secondary
1567 double fX = aRelativePosition.Primary*m_aPageReferenceSize.Width;
1568 double fY = aRelativePosition.Secondary*m_aPageReferenceSize.Height;
1569 aScreenPosition2D.X = static_cast< sal_Int32 >( ::rtl::math::round( fX ));
1570 aScreenPosition2D.Y = static_cast< sal_Int32 >( ::rtl::math::round( fY ));
1571 }
1572 else
1573 aScreenPosition2D = aDefaultPos;
1574
1575 if( !aFormula.isEmpty())
1576 {
1577 // set fill and line properties on creation
1578 tNameSequence aNames;
1579 tAnySequence aValues;
1580 PropertyMapper::getPreparedTextShapePropertyLists( xEquationProperties, aNames, aValues );
1581
1582 uno::Reference< drawing::XShape > xTextShape = m_pShapeFactory->createText(
1583 xEquationTarget, aFormula.makeStringAndClear(),
1584 aNames, aValues, ShapeFactory::makeTransformation( aScreenPosition2D ));
1585
1586 OSL_ASSERT( xTextShape.is());
1587 if( xTextShape.is())
1588 {
1589 ShapeFactory::setShapeName( xTextShape, rEquationCID );
1590 awt::Size aSize( xTextShape->getSize() );
1591 awt::Point aPos( RelativePositionHelper::getUpperLeftCornerOfAnchoredObject(
1592 aScreenPosition2D, aSize, aRelativePosition.Anchor ) );
1593 //ensure that the equation is fully placed within the page (if possible)
1594 if( (aPos.X + aSize.Width) > m_aPageReferenceSize.Width )
1595 aPos.X = m_aPageReferenceSize.Width - aSize.Width;
1596 if( aPos.X < 0 )
1597 {
1598 aPos.X = 0;
1599 if ( nFormulaWidth > 0 )
1600 {
1601 bResizeEquation = true;
1602 if ( nCountIteration < nMaxIteration-1 )
1603 xEquationTarget->remove( xTextShape ); // remove equation
1604 nFormulaWidth *= m_aPageReferenceSize.Width / static_cast< double >(aSize.Width);
1605 nFormulaWidth -= nCountIteration;
1606 if ( nFormulaWidth < 0 )
1607 nFormulaWidth = 0;
1608 }
1609 }
1610 if( (aPos.Y + aSize.Height) > m_aPageReferenceSize.Height )
1611 aPos.Y = m_aPageReferenceSize.Height - aSize.Height;
1612 if( aPos.Y < 0 )
1613 aPos.Y = 0;
1614 if ( !bResizeEquation || nCountIteration == nMaxIteration-1 )
1615 xTextShape->setPosition(aPos); // if equation was not removed
1616 }
1617 }
1618 }
1619 }
1620
1621 void VSeriesPlotter::setMappedProperties(
1622 const uno::Reference< drawing::XShape >& xTargetShape
1623 , const uno::Reference< beans::XPropertySet >& xSource
1624 , const tPropertyNameMap& rMap
1625 , tPropertyNameValueMap const * pOverwriteMap )
1626 {
1627 uno::Reference< beans::XPropertySet > xTargetProp( xTargetShape, uno::UNO_QUERY );
1628 PropertyMapper::setMappedProperties(xTargetProp,xSource,rMap,pOverwriteMap);
1629 }
1630
1631 void VSeriesPlotter::setTimeResolutionOnXAxis( tools::Long TimeResolution, const Date& rNullDate )
1632 {
1633 m_nTimeResolution = TimeResolution;
1634 m_aNullDate = rNullDate;
1635 }
1636
1637 // MinimumAndMaximumSupplier
1638 tools::Long VSeriesPlotter::calculateTimeResolutionOnXAxis()
1639 {
1640 tools::Long nRet = css::chart::TimeUnit::YEAR;
1641 if (!m_pExplicitCategoriesProvider)
1642 return nRet;
1643
1644 const std::vector<double>& rDateCategories = m_pExplicitCategoriesProvider->getDateCategories();
1645 if (rDateCategories.empty())
1646 return nRet;
1647
1648 std::vector<double>::const_iterator aIt = rDateCategories.begin(), aEnd = rDateCategories.end();
1649
1650 aIt = std::find_if(aIt, aEnd, [](const double& rDateCategory) { return !std::isnan(rDateCategory); });
1651 if (aIt == aEnd)
1652 return nRet;
1653
1654 Date aNullDate(30,12,1899);
1655 if (m_apNumberFormatterWrapper)
1656 aNullDate = m_apNumberFormatterWrapper->getNullDate();
1657
1658 Date aPrevious(aNullDate); aPrevious.AddDays(rtl::math::approxFloor(*aIt));
1659 ++aIt;
1660 for(;aIt!=aEnd;++aIt)
1661 {
1662 if (std::isnan(*aIt))
1663 continue;
1664
1665 Date aCurrent(aNullDate); aCurrent.AddDays(rtl::math::approxFloor(*aIt));
1666 if( nRet == css::chart::TimeUnit::YEAR )
1667 {
1668 if( DateHelper::IsInSameYear( aPrevious, aCurrent ) )
1669 nRet = css::chart::TimeUnit::MONTH;
1670 }
1671 if( nRet == css::chart::TimeUnit::MONTH )
1672 {
1673 if( DateHelper::IsInSameMonth( aPrevious, aCurrent ) )
1674 nRet = css::chart::TimeUnit::DAY;
1675 }
1676 if( nRet == css::chart::TimeUnit::DAY )
1677 break;
1678 aPrevious=aCurrent;
1679 }
1680
1681 return nRet;
1682 }
1683 double VSeriesPlotter::getMinimumX()
1684 {
1685 double fMinimum, fMaximum;
1686 getMinimumAndMaximumX( fMinimum, fMaximum );
1687 return fMinimum;
1688 }
1689 double VSeriesPlotter::getMaximumX()
1690 {
1691 double fMinimum, fMaximum;
1692 getMinimumAndMaximumX( fMinimum, fMaximum );
1693 return fMaximum;
1694 }
1695
1696 double VSeriesPlotter::getMinimumYInRange( double fMinimumX, double fMaximumX, sal_Int32 nAxisIndex )
1697 {
1698 if( !m_bCategoryXAxis || ( m_pExplicitCategoriesProvider && m_pExplicitCategoriesProvider->isDateAxis() ) )
1699 {
1700 double fMinY, fMaxY;
1701 getMinimumAndMaximumYInContinuousXRange( fMinY, fMaxY, fMinimumX, fMaximumX, nAxisIndex );
1702 return fMinY;
1703 }
1704
1705 double fMinimum, fMaximum;
1706 ::rtl::math::setInf(&fMinimum, false);
1707 ::rtl::math::setInf(&fMaximum, true);
1708 for(std::vector<VDataSeriesGroup> & rXSlots : m_aZSlots)
1709 {
1710 for(VDataSeriesGroup & rXSlot : rXSlots)
1711 {
1712 double fLocalMinimum, fLocalMaximum;
1713 rXSlot.calculateYMinAndMaxForCategoryRange(
1714 static_cast<sal_Int32>(fMinimumX-1.0) //first category (index 0) matches with real number 1.0
1715 , static_cast<sal_Int32>(fMaximumX-1.0) //first category (index 0) matches with real number 1.0
1716 , isSeparateStackingForDifferentSigns( 1 )
1717 , fLocalMinimum, fLocalMaximum, nAxisIndex );
1718 if(fMaximum<fLocalMaximum)
1719 fMaximum=fLocalMaximum;
1720 if(fMinimum>fLocalMinimum)
1721 fMinimum=fLocalMinimum;
1722 }
1723 }
1724 if(std::isinf(fMinimum))
1725 ::rtl::math::setNan(&fMinimum);
1726 return fMinimum;
1727 }
1728
1729 double VSeriesPlotter::getMaximumYInRange( double fMinimumX, double fMaximumX, sal_Int32 nAxisIndex )
1730 {
1731 if( !m_bCategoryXAxis || ( m_pExplicitCategoriesProvider && m_pExplicitCategoriesProvider->isDateAxis() ) )
1732 {
1733 double fMinY, fMaxY;
1734 getMinimumAndMaximumYInContinuousXRange( fMinY, fMaxY, fMinimumX, fMaximumX, nAxisIndex );
1735 return fMaxY;
1736 }
1737
1738 double fMinimum, fMaximum;
1739 ::rtl::math::setInf(&fMinimum, false);
1740 ::rtl::math::setInf(&fMaximum, true);
1741 for( std::vector< VDataSeriesGroup > & rXSlots : m_aZSlots)
1742 {
1743 for(VDataSeriesGroup & rXSlot : rXSlots)
1744 {
1745 double fLocalMinimum, fLocalMaximum;
1746 rXSlot.calculateYMinAndMaxForCategoryRange(
1747 static_cast<sal_Int32>(fMinimumX-1.0) //first category (index 0) matches with real number 1.0
1748 , static_cast<sal_Int32>(fMaximumX-1.0) //first category (index 0) matches with real number 1.0
1749 , isSeparateStackingForDifferentSigns( 1 )
1750 , fLocalMinimum, fLocalMaximum, nAxisIndex );
1751 if(fMaximum<fLocalMaximum)
1752 fMaximum=fLocalMaximum;
1753 if(fMinimum>fLocalMinimum)
1754 fMinimum=fLocalMinimum;
1755 }
1756 }
1757 if(std::isinf(fMaximum))
1758 ::rtl::math::setNan(&fMaximum);
1759 return fMaximum;
1760 }
1761
1762 double VSeriesPlotter::getMinimumZ()
1763 {
1764 //this is the default for all charts without a meaningful z axis
1765 return 1.0;
1766 }
1767 double VSeriesPlotter::getMaximumZ()
1768 {
1769 if( m_nDimension!=3 || m_aZSlots.empty() )
1770 return getMinimumZ()+1;
1771 return m_aZSlots.size();
1772 }
1773
1774 namespace
1775 {
1776 bool lcl_isValueAxis( sal_Int32 nDimensionIndex, bool bCategoryXAxis )
1777 {
1778 // default implementation: true for Y axes, and for value X axis
1779 if( nDimensionIndex == 0 )
1780 return !bCategoryXAxis;
1781 return nDimensionIndex == 1;
1782 }
1783 }
1784
1785 bool VSeriesPlotter::isExpandBorderToIncrementRhythm( sal_Int32 nDimensionIndex )
1786 {
1787 return lcl_isValueAxis( nDimensionIndex, m_bCategoryXAxis );
1788 }
1789
1790 bool VSeriesPlotter::isExpandIfValuesCloseToBorder( sal_Int32 nDimensionIndex )
1791 {
1792 // do not expand axes in 3D charts
1793 return (m_nDimension < 3) && lcl_isValueAxis( nDimensionIndex, m_bCategoryXAxis );
1794 }
1795
1796 bool VSeriesPlotter::isExpandWideValuesToZero( sal_Int32 nDimensionIndex )
1797 {
1798 // default implementation: only for Y axis
1799 return nDimensionIndex == 1;
1800 }
1801
1802 bool VSeriesPlotter::isExpandNarrowValuesTowardZero( sal_Int32 nDimensionIndex )
1803 {
1804 // default implementation: only for Y axis
1805 return nDimensionIndex == 1;
1806 }
1807
1808 bool VSeriesPlotter::isSeparateStackingForDifferentSigns( sal_Int32 nDimensionIndex )
1809 {
1810 // default implementation: only for Y axis
1811 return nDimensionIndex == 1;
1812 }
1813
1814 void VSeriesPlotter::getMinimumAndMaximumX( double& rfMinimum, double& rfMaximum ) const
1815 {
1816 ::rtl::math::setInf(&rfMinimum, false);
1817 ::rtl::math::setInf(&rfMaximum, true);
1818
1819 for (auto const& ZSlot : m_aZSlots)
1820 {
1821 for (auto const& XSlot : ZSlot)
1822 {
1823 double fLocalMinimum, fLocalMaximum;
1824 XSlot.getMinimumAndMaximumX( fLocalMinimum, fLocalMaximum );
1825 if( !std::isnan(fLocalMinimum) && fLocalMinimum< rfMinimum )
1826 rfMinimum = fLocalMinimum;
1827 if( !std::isnan(fLocalMaximum) && fLocalMaximum> rfMaximum )
1828 rfMaximum = fLocalMaximum;
1829 }
1830 }
1831 if(std::isinf(rfMinimum))
1832 ::rtl::math::setNan(&rfMinimum);
1833 if(std::isinf(rfMaximum))
1834 ::rtl::math::setNan(&rfMaximum);
1835 }
1836
1837 void VSeriesPlotter::getMinimumAndMaximumYInContinuousXRange( double& rfMinY, double& rfMaxY, double fMinX, double fMaxX, sal_Int32 nAxisIndex ) const
1838 {
1839 ::rtl::math::setInf(&rfMinY, false);
1840 ::rtl::math::setInf(&rfMaxY, true);
1841
1842 for (auto const& ZSlot : m_aZSlots)
1843 {
1844 for (auto const& XSlot : ZSlot)
1845 {
1846 double fLocalMinimum, fLocalMaximum;
1847 XSlot.getMinimumAndMaximumYInContinuousXRange( fLocalMinimum, fLocalMaximum, fMinX, fMaxX, nAxisIndex );
1848 if( !std::isnan(fLocalMinimum) && fLocalMinimum< rfMinY )
1849 rfMinY = fLocalMinimum;
1850 if( !std::isnan(fLocalMaximum) && fLocalMaximum> rfMaxY )
1851 rfMaxY = fLocalMaximum;
1852 }
1853 }
1854 if(std::isinf(rfMinY))
1855 ::rtl::math::setNan(&rfMinY);
1856 if(std::isinf(rfMaxY))
1857 ::rtl::math::setNan(&rfMaxY);
1858 }
1859
1860 sal_Int32 VSeriesPlotter::getPointCount() const
1861 {
1862 sal_Int32 nRet = 0;
1863
1864 for (auto const& ZSlot : m_aZSlots)
1865 {
1866 for (auto const& XSlot : ZSlot)
1867 {
1868 sal_Int32 nPointCount = XSlot.getPointCount();
1869 if( nPointCount>nRet )
1870 nRet = nPointCount;
1871 }
1872 }
1873 return nRet;
1874 }
1875
1876 void VSeriesPlotter::setNumberFormatsSupplier(
1877 const uno::Reference< util::XNumberFormatsSupplier > & xNumFmtSupplier )
1878 {
1879 m_apNumberFormatterWrapper.reset( new NumberFormatterWrapper( xNumFmtSupplier ));
1880 }
1881
1882 void VSeriesPlotter::setColorScheme( const uno::Reference< XColorScheme >& xColorScheme )
1883 {
1884 m_xColorScheme = xColorScheme;
1885 }
1886
1887 void VSeriesPlotter::setExplicitCategoriesProvider( ExplicitCategoriesProvider* pExplicitCategoriesProvider )
1888 {
1889 m_pExplicitCategoriesProvider = pExplicitCategoriesProvider;
1890 }
1891
1892 sal_Int32 VDataSeriesGroup::getPointCount() const
1893 {
1894 if(!m_bMaxPointCountDirty)
1895 return m_nMaxPointCount;
1896
1897 sal_Int32 nRet = 0;
1898
1899 for (std::unique_ptr<VDataSeries> const & pSeries : m_aSeriesVector)
1900 {
1901 sal_Int32 nPointCount = pSeries->getTotalPointCount();
1902 if( nPointCount>nRet )
1903 nRet = nPointCount;
1904 }
1905 m_nMaxPointCount=nRet;
1906 m_aListOfCachedYValues.clear();
1907 m_aListOfCachedYValues.resize(m_nMaxPointCount);
1908 m_bMaxPointCountDirty=false;
1909 return nRet;
1910 }
1911
1912 sal_Int32 VDataSeriesGroup::getAttachedAxisIndexForFirstSeries() const
1913 {
1914 sal_Int32 nRet = 0;
1915
1916 if (!m_aSeriesVector.empty())
1917 nRet = m_aSeriesVector[0]->getAttachedAxisIndex();
1918
1919 return nRet;
1920 }
1921
1922 void VDataSeriesGroup::getMinimumAndMaximumX( double& rfMinimum, double& rfMaximum ) const
1923 {
1924
1925 ::rtl::math::setInf(&rfMinimum, false);
1926 ::rtl::math::setInf(&rfMaximum, true);
1927
1928 for (std::unique_ptr<VDataSeries> const & pSeries : m_aSeriesVector)
1929 {
1930 sal_Int32 nPointCount = pSeries->getTotalPointCount();
1931 for(sal_Int32 nN=0;nN<nPointCount;nN++)
1932 {
1933 double fX = pSeries->getXValue( nN );
1934 if( std::isnan(fX) )
1935 continue;
1936 if(rfMaximum<fX)
1937 rfMaximum=fX;
1938 if(rfMinimum>fX)
1939 rfMinimum=fX;
1940 }
1941 }
1942 if(std::isinf(rfMinimum))
1943 ::rtl::math::setNan(&rfMinimum);
1944 if(std::isinf(rfMaximum))
1945 ::rtl::math::setNan(&rfMaximum);
1946 }
1947
1948 namespace {
1949
1950 /**
1951 * Keep track of minimum and maximum Y values for one or more data series.
1952 * When multiple data series exist, that indicates that the data series are
1953 * stacked.
1954 *
1955 * <p>For each X value, we calculate separate Y value ranges for each data
1956 * series in the first pass. In the second pass, we calculate the minimum Y
1957 * value by taking the absolute minimum value of all data series, whereas
1958 * the maximum Y value is the sum of all the series maximum Y values.</p>
1959 *
1960 * <p>Once that's done for all X values, the final min / max Y values get
1961 * calculated by taking the absolute min / max Y values across all the X
1962 * values.</p>
1963 */
1964 class PerXMinMaxCalculator
1965 {
1966 typedef std::pair<double, double> MinMaxType;
1967 typedef std::map<size_t, MinMaxType> SeriesMinMaxType;
1968 typedef std::map<double, std::unique_ptr<SeriesMinMaxType>> GroupMinMaxType;
1969 typedef std::unordered_map<double, MinMaxType> TotalStoreType;
1970 GroupMinMaxType m_SeriesGroup;
1971 size_t mnCurSeries;
1972
1973 public:
1974 PerXMinMaxCalculator() : mnCurSeries(0) {}
1975
1976 void nextSeries() { ++mnCurSeries; }
1977
1978 void setValue(double fX, double fY)
1979 {
1980 SeriesMinMaxType* pStore = getByXValue(fX); // get storage for given X value.
1981 if (!pStore)
1982 // This shouldn't happen!
1983 return;
1984
1985 SeriesMinMaxType::iterator it = pStore->lower_bound(mnCurSeries);
1986 if (it != pStore->end() && !pStore->key_comp()(mnCurSeries, it->first))
1987 {
1988 MinMaxType& r = it->second;
1989 // A min-max pair already exists for this series. Update it.
1990 if (fY < r.first)
1991 r.first = fY;
1992 if (r.second < fY)
1993 r.second = fY;
1994 }
1995 else
1996 {
1997 // No existing pair. Insert a new one.
1998 pStore->insert(
1999 it, SeriesMinMaxType::value_type(
2000 mnCurSeries, MinMaxType(fY,fY)));
2001 }
2002 }
2003
2004 void getTotalRange(double& rfMin, double& rfMax) const
2005 {
2006 rtl::math::setNan(&rfMin);
2007 rtl::math::setNan(&rfMax);
2008
2009 TotalStoreType aStore;
2010 getTotalStore(aStore);
2011
2012 if (aStore.empty())
2013 return;
2014
2015 TotalStoreType::const_iterator it = aStore.begin(), itEnd = aStore.end();
2016 rfMin = it->second.first;
2017 rfMax = it->second.second;
2018 for (++it; it != itEnd; ++it)
2019 {
2020 if (rfMin > it->second.first)
2021 rfMin = it->second.first;
2022 if (rfMax < it->second.second)
2023 rfMax = it->second.second;
2024 }
2025 }
2026
2027 private:
2028 /**
2029 * Parse all data and reduce them into a set of global Y value ranges per
2030 * X value.
2031 */
2032 void getTotalStore(TotalStoreType& rStore) const
2033 {
2034 TotalStoreType aStore;
2035 for (auto const& it : m_SeriesGroup)
2036 {
2037 double fX = it.first;
2038
2039 const SeriesMinMaxType& rSeries = *it.second;
2040 for (auto const& series : rSeries)
2041 {
2042 double fYMin = series.second.first, fYMax = series.second.second;
2043 TotalStoreType::iterator itr = aStore.find(fX);
2044 if (itr == aStore.end())
2045 // New min-max pair for give X value.
2046 aStore.emplace(fX, std::pair<double,double>(fYMin,fYMax));
2047 else
2048 {
2049 MinMaxType& r = itr->second;
2050 if (fYMin < r.first)
2051 r.first = fYMin; // min y-value
2052
2053 r.second += fYMax; // accumulative max y-value.
2054 }
2055 }
2056 }
2057 rStore.swap(aStore);
2058 }
2059
2060 SeriesMinMaxType* getByXValue(double fX)
2061 {
2062 GroupMinMaxType::iterator it = m_SeriesGroup.find(fX);
2063 if (it == m_SeriesGroup.end())
2064 {
2065 std::pair<GroupMinMaxType::iterator,bool> r =
2066 m_SeriesGroup.insert(std::make_pair(fX, std::make_unique<SeriesMinMaxType>()));
2067
2068 if (!r.second)
2069 // insertion failed.
2070 return nullptr;
2071
2072 it = r.first;
2073 }
2074
2075 return it->second.get();
2076 }
2077 };
2078
2079 }
2080
2081 void VDataSeriesGroup::getMinimumAndMaximumYInContinuousXRange(
2082 double& rfMinY, double& rfMaxY, double fMinX, double fMaxX, sal_Int32 nAxisIndex ) const
2083 {
2084 ::rtl::math::setNan(&rfMinY);
2085 ::rtl::math::setNan(&rfMaxY);
2086
2087 if (m_aSeriesVector.empty())
2088 // No data series. Bail out.
2089 return;
2090
2091 PerXMinMaxCalculator aRangeCalc;
2092 for (const std::unique_ptr<VDataSeries> & pSeries : m_aSeriesVector)
2093 {
2094 if (!pSeries)
2095 continue;
2096
2097 for (sal_Int32 i = 0, n = pSeries->getTotalPointCount(); i < n; ++i)
2098 {
2099 if (nAxisIndex != pSeries->getAttachedAxisIndex())
2100 continue;
2101
2102 double fX = pSeries->getXValue(i);
2103 if (std::isnan(fX))
2104 continue;
2105
2106 if (fX < fMinX || fX > fMaxX)
2107 // Outside specified X range. Skip it.
2108 continue;
2109
2110 double fY = pSeries->getYValue(i);
2111 if (std::isnan(fY))
2112 continue;
2113
2114 aRangeCalc.setValue(fX, fY);
2115 }
2116 aRangeCalc.nextSeries();
2117 }
2118
2119 aRangeCalc.getTotalRange(rfMinY, rfMaxY);
2120 }
2121
2122 void VDataSeriesGroup::calculateYMinAndMaxForCategory( sal_Int32 nCategoryIndex
2123 , bool bSeparateStackingForDifferentSigns
2124 , double& rfMinimumY, double& rfMaximumY, sal_Int32 nAxisIndex )
2125 {
2126 assert(nCategoryIndex >= 0);
2127 assert(nCategoryIndex < getPointCount());
2128
2129 ::rtl::math::setInf(&rfMinimumY, false);
2130 ::rtl::math::setInf(&rfMaximumY, true);
2131
2132 if(m_aSeriesVector.empty())
2133 return;
2134
2135 CachedYValues aCachedYValues = m_aListOfCachedYValues[nCategoryIndex][nAxisIndex];
2136 if( !aCachedYValues.m_bValuesDirty )
2137 {
2138 //return cached values
2139 rfMinimumY = aCachedYValues.m_fMinimumY;
2140 rfMaximumY = aCachedYValues.m_fMaximumY;
2141 return;
2142 }
2143
2144 double fTotalSum, fPositiveSum, fNegativeSum, fFirstPositiveY, fFirstNegativeY;
2145 ::rtl::math::setNan( &fTotalSum );
2146 ::rtl::math::setNan( &fPositiveSum );
2147 ::rtl::math::setNan( &fNegativeSum );
2148 ::rtl::math::setNan( &fFirstPositiveY );
2149 ::rtl::math::setNan( &fFirstNegativeY );
2150
2151 if( bSeparateStackingForDifferentSigns )
2152 {
2153 for (const std::unique_ptr<VDataSeries> & pSeries: m_aSeriesVector)
2154 {
2155 if( nAxisIndex != pSeries->getAttachedAxisIndex() )
2156 continue;
2157
2158 double fValueMinY = pSeries->getMinimumofAllDifferentYValues( nCategoryIndex );
2159 double fValueMaxY = pSeries->getMaximumofAllDifferentYValues( nCategoryIndex );
2160
2161 if( fValueMaxY >= 0 )
2162 {
2163 if( std::isnan( fPositiveSum ) )
2164 fPositiveSum = fFirstPositiveY = fValueMaxY;
2165 else
2166 fPositiveSum += fValueMaxY;
2167 }
2168 if( fValueMinY < 0 )
2169 {
2170 if(std::isnan( fNegativeSum ))
2171 fNegativeSum = fFirstNegativeY = fValueMinY;
2172 else
2173 fNegativeSum += fValueMinY;
2174 }
2175 }
2176 rfMinimumY = std::isnan( fNegativeSum ) ? fFirstPositiveY : fNegativeSum;
2177 rfMaximumY = std::isnan( fPositiveSum ) ? fFirstNegativeY : fPositiveSum;
2178 }
2179 else
2180 {
2181 for (const std::unique_ptr<VDataSeries> & pSeries: m_aSeriesVector)
2182 {
2183 if( nAxisIndex != pSeries->getAttachedAxisIndex() )
2184 continue;
2185
2186 double fValueMinY = pSeries->getMinimumofAllDifferentYValues( nCategoryIndex );
2187 double fValueMaxY = pSeries->getMaximumofAllDifferentYValues( nCategoryIndex );
2188
2189 if( std::isnan( fTotalSum ) )
2190 {
2191 rfMinimumY = fValueMinY;
2192 rfMaximumY = fTotalSum = fValueMaxY;
2193 }
2194 else
2195 {
2196 fTotalSum += fValueMaxY;
2197 if( rfMinimumY > fTotalSum )
2198 rfMinimumY = fTotalSum;
2199 if( rfMaximumY < fTotalSum )
2200 rfMaximumY = fTotalSum;
2201 }
2202 }
2203 }
2204
2205 aCachedYValues.m_fMinimumY = rfMinimumY;
2206 aCachedYValues.m_fMaximumY = rfMaximumY;
2207 aCachedYValues.m_bValuesDirty = false;
2208 m_aListOfCachedYValues[nCategoryIndex][nAxisIndex]=aCachedYValues;
2209 }
2210
2211 void VDataSeriesGroup::calculateYMinAndMaxForCategoryRange(
2212 sal_Int32 nStartCategoryIndex, sal_Int32 nEndCategoryIndex
2213 , bool bSeparateStackingForDifferentSigns
2214 , double& rfMinimumY, double& rfMaximumY, sal_Int32 nAxisIndex )
2215 {
2216 //@todo maybe cache these values
2217 ::rtl::math::setInf(&rfMinimumY, false);
2218 ::rtl::math::setInf(&rfMaximumY, true);
2219
2220 //iterate through the given categories
2221 if(nStartCategoryIndex<0)
2222 nStartCategoryIndex=0;
2223 const sal_Int32 nPointCount = getPointCount();//necessary to create m_aListOfCachedYValues
2224 if(nPointCount <= 0)
2225 return;
2226 if (nEndCategoryIndex >= nPointCount)
2227 nEndCategoryIndex = nPointCount - 1;
2228 if(nEndCategoryIndex<0)
2229 nEndCategoryIndex=0;
2230 for( sal_Int32 nCatIndex = nStartCategoryIndex; nCatIndex <= nEndCategoryIndex; nCatIndex++ )
2231 {
2232 double fMinimumY; ::rtl::math::setNan(&fMinimumY);
2233 double fMaximumY; ::rtl::math::setNan(&fMaximumY);
2234
2235 calculateYMinAndMaxForCategory( nCatIndex
2236 , bSeparateStackingForDifferentSigns, fMinimumY, fMaximumY, nAxisIndex );
2237
2238 if(rfMinimumY > fMinimumY)
2239 rfMinimumY = fMinimumY;
2240 if(rfMaximumY < fMaximumY)
2241 rfMaximumY = fMaximumY;
2242 }
2243 }
2244
2245 double VSeriesPlotter::getTransformedDepth() const
2246 {
2247 double MinZ = m_pMainPosHelper->getLogicMinZ();
2248 double MaxZ = m_pMainPosHelper->getLogicMaxZ();
2249 m_pMainPosHelper->doLogicScaling( nullptr, nullptr, &MinZ );
2250 m_pMainPosHelper->doLogicScaling( nullptr, nullptr, &MaxZ );
2251 return FIXED_SIZE_FOR_3D_CHART_VOLUME/(MaxZ-MinZ);
2252 }
2253
2254 void VSeriesPlotter::addSecondaryValueScale( const ExplicitScaleData& rScale, sal_Int32 nAxisIndex )
2255 {
2256 if( nAxisIndex<1 )
2257 return;
2258
2259 m_aSecondaryValueScales[nAxisIndex]=rScale;
2260 }
2261
2262 PlottingPositionHelper& VSeriesPlotter::getPlottingPositionHelper( sal_Int32 nAxisIndex ) const
2263 {
2264 PlottingPositionHelper* pRet = nullptr;
2265 if(nAxisIndex>0)
2266 {
2267 tSecondaryPosHelperMap::const_iterator aPosIt = m_aSecondaryPosHelperMap.find( nAxisIndex );
2268 if( aPosIt != m_aSecondaryPosHelperMap.end() )
2269 {
2270 pRet = aPosIt->second.get();
2271 }
2272 else if (m_pPosHelper)
2273 {
2274 tSecondaryValueScales::const_iterator aScaleIt = m_aSecondaryValueScales.find( nAxisIndex );
2275 if( aScaleIt != m_aSecondaryValueScales.end() )
2276 {
2277 m_aSecondaryPosHelperMap[nAxisIndex] = m_pPosHelper->createSecondaryPosHelper( aScaleIt->second );
2278 pRet = m_aSecondaryPosHelperMap[nAxisIndex].get();
2279 }
2280 }
2281 }
2282 if( !pRet )
2283 pRet = m_pMainPosHelper;
2284 if(pRet)
2285 pRet->setTimeResolution( m_nTimeResolution, m_aNullDate );
2286 return *pRet;
2287 }
2288
2289 void VSeriesPlotter::rearrangeLabelToAvoidOverlapIfRequested( const awt::Size& /*rPageSize*/ )
2290 {
2291 }
2292
2293 VDataSeries* VSeriesPlotter::getFirstSeries() const
2294 {
2295 for (std::vector<VDataSeriesGroup> const & rGroup : m_aZSlots)
2296 {
2297 if (!rGroup.empty())
2298 {
2299 if (!rGroup[0].m_aSeriesVector.empty())
2300 {
2301 VDataSeries* pSeries = rGroup[0].m_aSeriesVector[0].get();
2302 if (pSeries)
2303 return pSeries;
2304 }
2305 }
2306 }
2307 return nullptr;
2308 }
2309
2310 OUString VSeriesPlotter::getCategoryName( sal_Int32 nPointIndex ) const
2311 {
2312 if (m_pExplicitCategoriesProvider)
2313 {
2314 Sequence< OUString > aCategories(m_pExplicitCategoriesProvider->getSimpleCategories());
2315 if (nPointIndex >= 0 && nPointIndex < aCategories.getLength())
2316 {
2317 return aCategories[nPointIndex];
2318 }
2319 }
2320 return OUString();
2321 }
2322
2323 uno::Sequence< OUString > VSeriesPlotter::getSeriesNames() const
2324 {
2325 std::vector<OUString> aRetVector;
2326
2327 OUString aRole;
2328 if( m_xChartTypeModel.is() )
2329 aRole = m_xChartTypeModel->getRoleOfSequenceForSeriesLabel();
2330
2331 for (auto const& rGroup : m_aZSlots)
2332 {
2333 if (!rGroup.empty())
2334 {
2335 VDataSeriesGroup const & rSeriesGroup(rGroup[0]);
2336 if (!rSeriesGroup.m_aSeriesVector.empty())
2337 {
2338 VDataSeries const * pSeries = rSeriesGroup.m_aSeriesVector[0].get();
2339 uno::Reference< XDataSeries > xSeries( pSeries ? pSeries->getModel() : nullptr );
2340 if( xSeries.is() )
2341 {
2342 OUString aSeriesName( DataSeriesHelper::getDataSeriesLabel( xSeries, aRole ) );
2343 aRetVector.push_back( aSeriesName );
2344 }
2345 }
2346 }
2347 }
2348 return comphelper::containerToSequence( aRetVector );
2349 }
2350
2351 void VSeriesPlotter::setPageReferenceSize( const css::awt::Size & rPageRefSize )
2352 {
2353 m_aPageReferenceSize = rPageRefSize;
2354
2355 // set reference size also at all data series
2356
2357 for (auto const & outer : m_aZSlots)
2358 for (VDataSeriesGroup const & rGroup : outer)
2359 {
2360 for (std::unique_ptr<VDataSeries> const & pSeries : rGroup.m_aSeriesVector)
2361 {
2362 pSeries->setPageReferenceSize(m_aPageReferenceSize);
2363 }
2364 }
2365 }
2366
2367 //better performance for big data
2368 void VSeriesPlotter::setCoordinateSystemResolution( const Sequence< sal_Int32 >& rCoordinateSystemResolution )
2369 {
2370 m_aCoordinateSystemResolution = rCoordinateSystemResolution;
2371 }
2372
2373 bool VSeriesPlotter::WantToPlotInFrontOfAxisLine()
2374 {
2375 return ChartTypeHelper::isSeriesInFrontOfAxisLine( m_xChartTypeModel );
2376 }
2377
2378 bool VSeriesPlotter::shouldSnapRectToUsedArea()
2379 {
2380 return m_nDimension != 3;
2381 }
2382
2383 std::vector< ViewLegendEntry > VSeriesPlotter::createLegendEntries(
2384 const awt::Size& rEntryKeyAspectRatio
2385 , LegendPosition eLegendPosition
2386 , const Reference< beans::XPropertySet >& xTextProperties
2387 , const Reference< drawing::XShapes >& xTarget
2388 , const Reference< lang::XMultiServiceFactory >& xShapeFactory
2389 , const Reference< uno::XComponentContext >& xContext
2390 , ChartModel& rModel
2391 )
2392 {
2393 std::vector< ViewLegendEntry > aResult;
2394
2395 if( xTarget.is() )
2396 {
2397 uno::Reference< XCoordinateSystemContainer > xCooSysCnt( rModel.getFirstDiagram(), uno::UNO_QUERY );
2398 Reference< chart2::XCoordinateSystem > xCooSys(xCooSysCnt->getCoordinateSystems()[0]);
2399 Reference< beans::XPropertySet > xProp( xCooSys, uno::UNO_QUERY );
2400 bool bSwapXAndY = false;
2401
2402 if( xProp.is()) try
2403 {
2404 xProp->getPropertyValue( "SwapXAndYAxis" ) >>= bSwapXAndY;
2405 }
2406 catch( const uno::Exception& )
2407 {
2408 }
2409
2410 //iterate through all series
2411 bool bBreak = false;
2412 bool bFirstSeries = true;
2413
2414
2415 for (std::vector<VDataSeriesGroup> const & rGroupVector : m_aZSlots)
2416 {
2417 for (VDataSeriesGroup const & rGroup : rGroupVector)
2418 {
2419 for (std::unique_ptr<VDataSeries> const & pSeries : rGroup.m_aSeriesVector)
2420 {
2421 if (!pSeries)
2422 continue;
2423
2424 if (!pSeries->getPropertiesOfSeries()->getPropertyValue("ShowLegendEntry").get<sal_Bool>())
2425 {
2426 continue;
2427 }
2428
2429 std::vector<ViewLegendEntry> aSeriesEntries(
2430 createLegendEntriesForSeries(
2431 rEntryKeyAspectRatio, *pSeries, xTextProperties,
2432 xTarget, xShapeFactory, xContext));
2433
2434 //add series entries to the result now
2435
2436 // use only the first series if VaryColorsByPoint is set for the first series
2437 if (bFirstSeries && pSeries->isVaryColorsByPoint())
2438 bBreak = true;
2439 bFirstSeries = false;
2440
2441 // add entries reverse if chart is stacked in y-direction and the legend position is right or left.
2442 // If the legend is top or bottom and we have a stacked bar-chart the normal order
2443 // is the correct one, unless the chart type is horizontal bar-chart.
2444 bool bReverse = false;
2445 if ( bSwapXAndY )
2446 {
2447 StackingDirection eStackingDirection( pSeries->getStackingDirection() );
2448 bReverse = ( eStackingDirection != StackingDirection_Y_STACKING );
2449 }
2450 else if ( eLegendPosition == LegendPosition_LINE_START || eLegendPosition == LegendPosition_LINE_END )
2451 {
2452 StackingDirection eStackingDirection( pSeries->getStackingDirection() );
2453 bReverse = ( eStackingDirection == StackingDirection_Y_STACKING );
2454 }
2455
2456 if (bReverse)
2457 aResult.insert( aResult.begin(), aSeriesEntries.begin(), aSeriesEntries.end() );
2458 else
2459 aResult.insert( aResult.end(), aSeriesEntries.begin(), aSeriesEntries.end() );
2460 }
2461 if (bBreak)
2462 return aResult;
2463 }
2464 }
2465 }
2466
2467 return aResult;
2468 }
2469
2470 std::vector<VDataSeries*> VSeriesPlotter::getAllSeries()
2471 {
2472 std::vector<VDataSeries*> aAllSeries;
2473 for (std::vector<VDataSeriesGroup> const & rXSlot : m_aZSlots)
2474 {
2475 for(VDataSeriesGroup const & rGroup : rXSlot)
2476 {
2477 for (std::unique_ptr<VDataSeries> const & p : rGroup.m_aSeriesVector)
2478 aAllSeries.push_back(p.get());
2479 }
2480 }
2481 return aAllSeries;
2482 }
2483
2484 namespace
2485 {
2486 bool lcl_HasVisibleLine( const uno::Reference< beans::XPropertySet >& xProps, bool& rbHasDashedLine )
2487 {
2488 bool bHasVisibleLine = false;
2489 rbHasDashedLine = false;
2490 drawing::LineStyle aLineStyle = drawing::LineStyle_NONE;
2491 if( xProps.is() && ( xProps->getPropertyValue( "LineStyle") >>= aLineStyle ) )
2492 {
2493 if( aLineStyle != drawing::LineStyle_NONE )
2494 bHasVisibleLine = true;
2495 if( aLineStyle == drawing::LineStyle_DASH )
2496 rbHasDashedLine = true;
2497 }
2498 return bHasVisibleLine;
2499 }
2500
2501 bool lcl_HasRegressionCurves( const VDataSeries& rSeries, bool& rbHasDashedLine )
2502 {
2503 bool bHasRegressionCurves = false;
2504 Reference< XRegressionCurveContainer > xRegrCont( rSeries.getModel(), uno::UNO_QUERY );
2505 if( xRegrCont.is())
2506 {
2507 Sequence< Reference< XRegressionCurve > > aCurves( xRegrCont->getRegressionCurves() );
2508 sal_Int32 i = 0, nCount = aCurves.getLength();
2509 for( i=0; i<nCount; ++i )
2510 {
2511 if( aCurves[i].is() )
2512 {
2513 bHasRegressionCurves = true;
2514 lcl_HasVisibleLine( uno::Reference< beans::XPropertySet >( aCurves[i], uno::UNO_QUERY ), rbHasDashedLine );
2515 }
2516 }
2517 }
2518 return bHasRegressionCurves;
2519 }
2520 }
2521 LegendSymbolStyle VSeriesPlotter::getLegendSymbolStyle()
2522 {
2523 return LegendSymbolStyle::Box;
2524 }
2525
2526 awt::Size VSeriesPlotter::getPreferredLegendKeyAspectRatio()
2527 {
2528 awt::Size aRet(1000,1000);
2529 if( m_nDimension==3 )
2530 return aRet;
2531
2532 bool bSeriesAllowsLines = (getLegendSymbolStyle() == LegendSymbolStyle::Line);
2533 bool bHasLines = false;
2534 bool bHasDashedLines = false;
2535 //iterate through all series
2536 for (VDataSeries* pSeries : getAllSeries())
2537 {
2538 if( bSeriesAllowsLines )
2539 {
2540 bool bCurrentDashed = false;
2541 if( lcl_HasVisibleLine( pSeries->getPropertiesOfSeries(), bCurrentDashed ) )
2542 {
2543 bHasLines = true;
2544 if( bCurrentDashed )
2545 {
2546 bHasDashedLines = true;
2547 break;
2548 }
2549 }
2550 }
2551 bool bRegressionHasDashedLines=false;
2552 if( lcl_HasRegressionCurves( *pSeries, bRegressionHasDashedLines ) )
2553 {
2554 bHasLines = true;
2555 if( bRegressionHasDashedLines )
2556 {
2557 bHasDashedLines = true;
2558 break;
2559 }
2560 }
2561 }
2562 if( bHasLines )
2563 {
2564 if( bHasDashedLines )
2565 aRet = awt::Size(1600,-1);
2566 else
2567 aRet = awt::Size(800,-1);
2568 }
2569 return aRet;
2570 }
2571
2572 uno::Any VSeriesPlotter::getExplicitSymbol( const VDataSeries& /*rSeries*/, sal_Int32 /*nPointIndex*/ )
2573 {
2574 return uno::Any();
2575 }
2576
2577 Reference< drawing::XShape > VSeriesPlotter::createLegendSymbolForSeries(
2578 const awt::Size& rEntryKeyAspectRatio
2579 , const VDataSeries& rSeries
2580 , const Reference< drawing::XShapes >& xTarget
2581 , const Reference< lang::XMultiServiceFactory >& xShapeFactory )
2582 {
2583
2584 LegendSymbolStyle eLegendSymbolStyle = getLegendSymbolStyle();
2585 uno::Any aExplicitSymbol( getExplicitSymbol( rSeries, -1 ) );
2586
2587 VLegendSymbolFactory::PropertyType ePropType =
2588 VLegendSymbolFactory::PropertyType::FilledSeries;
2589
2590 // todo: maybe the property-style does not solely depend on the
2591 // legend-symbol type
2592 switch( eLegendSymbolStyle )
2593 {
2594 case LegendSymbolStyle::Line:
2595 ePropType = VLegendSymbolFactory::PropertyType::LineSeries;
2596 break;
2597 default:
2598 break;
2599 }
2600 Reference< drawing::XShape > xShape( VLegendSymbolFactory::createSymbol( rEntryKeyAspectRatio,
2601 xTarget, eLegendSymbolStyle, xShapeFactory
2602 , rSeries.getPropertiesOfSeries(), ePropType, aExplicitSymbol ));
2603
2604 return xShape;
2605 }
2606
2607 Reference< drawing::XShape > VSeriesPlotter::createLegendSymbolForPoint(
2608 const awt::Size& rEntryKeyAspectRatio
2609 , const VDataSeries& rSeries
2610 , sal_Int32 nPointIndex
2611 , const Reference< drawing::XShapes >& xTarget
2612 , const Reference< lang::XMultiServiceFactory >& xShapeFactory )
2613 {
2614
2615 LegendSymbolStyle eLegendSymbolStyle = getLegendSymbolStyle();
2616 uno::Any aExplicitSymbol( getExplicitSymbol(rSeries,nPointIndex) );
2617
2618 VLegendSymbolFactory::PropertyType ePropType =
2619 VLegendSymbolFactory::PropertyType::FilledSeries;
2620
2621 // todo: maybe the property-style does not solely depend on the
2622 // legend-symbol type
2623 switch( eLegendSymbolStyle )
2624 {
2625 case LegendSymbolStyle::Line:
2626 ePropType = VLegendSymbolFactory::PropertyType::LineSeries;
2627 break;
2628 default:
2629 break;
2630 }
2631
2632 // the default properties for the data point are the data series properties.
2633 // If a data point has own attributes overwrite them
2634 Reference< beans::XPropertySet > xSeriesProps( rSeries.getPropertiesOfSeries() );
2635 Reference< beans::XPropertySet > xPointSet( xSeriesProps );
2636 if( rSeries.isAttributedDataPoint( nPointIndex ) )
2637 xPointSet.set( rSeries.getPropertiesOfPoint( nPointIndex ));
2638
2639 // if a data point has no own color use a color from the diagram's color scheme
2640 if( ! rSeries.hasPointOwnColor( nPointIndex ))
2641 {
2642 Reference< util::XCloneable > xCloneable( xPointSet,uno::UNO_QUERY );
2643 if( xCloneable.is() && m_xColorScheme.is() )
2644 {
2645 xPointSet.set( xCloneable->createClone(), uno::UNO_QUERY );
2646 Reference< container::XChild > xChild( xPointSet, uno::UNO_QUERY );
2647 if( xChild.is())
2648 xChild->setParent( xSeriesProps );
2649
2650 OSL_ASSERT( xPointSet.is());
2651 xPointSet->setPropertyValue(
2652 "Color", uno::Any( m_xColorScheme->getColorByIndex( nPointIndex )));
2653 }
2654 }
2655
2656 Reference< drawing::XShape > xShape( VLegendSymbolFactory::createSymbol( rEntryKeyAspectRatio,
2657 xTarget, eLegendSymbolStyle, xShapeFactory, xPointSet, ePropType, aExplicitSymbol ));
2658
2659 return xShape;
2660 }
2661
2662 std::vector< ViewLegendEntry > VSeriesPlotter::createLegendEntriesForSeries(
2663 const awt::Size& rEntryKeyAspectRatio
2664 , const VDataSeries& rSeries
2665 , const Reference< beans::XPropertySet >& xTextProperties
2666 , const Reference< drawing::XShapes >& xTarget
2667 , const Reference< lang::XMultiServiceFactory >& xShapeFactory
2668 , const Reference< uno::XComponentContext >& xContext
2669 )
2670 {
2671 std::vector< ViewLegendEntry > aResult;
2672
2673 if( ! ( xShapeFactory.is() && xTarget.is() && xContext.is() ) )
2674 return aResult;
2675
2676 try
2677 {
2678 ViewLegendEntry aEntry;
2679 OUString aLabelText;
2680 bool bVaryColorsByPoint = rSeries.isVaryColorsByPoint();
2681 bool bIsPie = m_xChartTypeModel->getChartType().equalsIgnoreAsciiCase(
2682 CHART2_SERVICE_NAME_CHARTTYPE_PIE);
2683 try
2684 {
2685 if (bIsPie && m_xChartTypeModelProps.is())
2686 {
2687 bool bDonut = false;
2688 if ((m_xChartTypeModelProps->getPropertyValue("UseRings") >>= bDonut) && bDonut)
2689 bIsPie = false;
2690 }
2691 }
2692 catch (const uno::Exception&)
2693 {
2694 }
2695
2696 if (bVaryColorsByPoint || bIsPie)
2697 {
2698 Sequence< OUString > aCategoryNames;
2699 if( m_pExplicitCategoriesProvider )
2700 aCategoryNames = m_pExplicitCategoriesProvider->getSimpleCategories();
2701 Sequence<sal_Int32> deletedLegendEntries;
2702 try
2703 {
2704 rSeries.getPropertiesOfSeries()->getPropertyValue("DeletedLegendEntries") >>= deletedLegendEntries;
2705 }
2706 catch (const uno::Exception&)
2707 {
2708 }
2709 for( sal_Int32 nIdx=0; nIdx<aCategoryNames.getLength(); ++nIdx )
2710 {
2711 bool deletedLegendEntry = false;
2712 for (auto& deletedLegendEntryIdx : deletedLegendEntries)
2713 {
2714 if (nIdx == deletedLegendEntryIdx)
2715 {
2716 deletedLegendEntry = true;
2717 break;
2718 }
2719 }
2720 if (deletedLegendEntry)
2721 continue;
2722
2723 // symbol
2724 uno::Reference< drawing::XShapes > xSymbolGroup( ShapeFactory::getOrCreateShapeFactory(xShapeFactory)->createGroup2D( xTarget ));
2725
2726 // create the symbol
2727 Reference< drawing::XShape > xShape( createLegendSymbolForPoint( rEntryKeyAspectRatio,
2728 rSeries, nIdx, xSymbolGroup, xShapeFactory ) );
2729
2730 // set CID to symbol for selection
2731 if( xShape.is() )
2732 {
2733 aEntry.aSymbol.set( xSymbolGroup, uno::UNO_QUERY );
2734
2735 OUString aChildParticle( ObjectIdentifier::createChildParticleWithIndex( OBJECTTYPE_DATA_POINT, nIdx ) );
2736 aChildParticle = ObjectIdentifier::addChildParticle( aChildParticle, ObjectIdentifier::createChildParticleWithIndex( OBJECTTYPE_LEGEND_ENTRY, 0 ) );
2737 OUString aCID = ObjectIdentifier::createClassifiedIdentifierForParticles( rSeries.getSeriesParticle(), aChildParticle );
2738 ShapeFactory::setShapeName( xShape, aCID );
2739 }
2740
2741 // label
2742 aLabelText = aCategoryNames[nIdx];
2743 if( xShape.is() || !aLabelText.isEmpty() )
2744 {
2745 aEntry.aLabel = FormattedStringHelper::createFormattedStringSequence( xContext, aLabelText, xTextProperties );
2746 aResult.push_back(aEntry);
2747 }
2748 }
2749 }
2750 else
2751 {
2752 // symbol
2753 uno::Reference< drawing::XShapes > xSymbolGroup( ShapeFactory::getOrCreateShapeFactory(xShapeFactory)->createGroup2D( xTarget ));
2754
2755 // create the symbol
2756 Reference< drawing::XShape > xShape( createLegendSymbolForSeries(
2757 rEntryKeyAspectRatio, rSeries, xSymbolGroup, xShapeFactory ) );
2758
2759 // set CID to symbol for selection
2760 if( xShape.is())
2761 {
2762 aEntry.aSymbol.set( xSymbolGroup, uno::UNO_QUERY );
2763
2764 OUString aChildParticle( ObjectIdentifier::createChildParticleWithIndex( OBJECTTYPE_LEGEND_ENTRY, 0 ) );
2765 OUString aCID = ObjectIdentifier::createClassifiedIdentifierForParticles( rSeries.getSeriesParticle(), aChildParticle );
2766 ShapeFactory::setShapeName( xShape, aCID );
2767 }
2768
2769 // label
2770 aLabelText = DataSeriesHelper::getDataSeriesLabel( rSeries.getModel(), m_xChartTypeModel.is() ? m_xChartTypeModel->getRoleOfSequenceForSeriesLabel() : "values-y");
2771 aEntry.aLabel = FormattedStringHelper::createFormattedStringSequence( xContext, aLabelText, xTextProperties );
2772
2773 aResult.push_back(aEntry);
2774 }
2775
2776 // don't show legend entry of regression curve & friends if this type of chart
2777 // doesn't support statistics #i63016#, fdo#37197
2778 if (!ChartTypeHelper::isSupportingStatisticProperties( m_xChartTypeModel, m_nDimension ))
2779 return aResult;
2780
2781 Reference< XRegressionCurveContainer > xRegrCont( rSeries.getModel(), uno::UNO_QUERY );
2782 if( xRegrCont.is())
2783 {
2784 Sequence< Reference< XRegressionCurve > > aCurves( xRegrCont->getRegressionCurves());
2785 sal_Int32 i = 0, nCount = aCurves.getLength();
2786 for( i=0; i<nCount; ++i )
2787 {
2788 if( aCurves[i].is() )
2789 {
2790 //label
2791 OUString aResStr( RegressionCurveHelper::getUINameForRegressionCurve( aCurves[i] ) );
2792 replaceParamterInString( aResStr, "%SERIESNAME", aLabelText );
2793 aEntry.aLabel = FormattedStringHelper::createFormattedStringSequence( xContext, aResStr, xTextProperties );
2794
2795 // symbol
2796 uno::Reference< drawing::XShapes > xSymbolGroup( ShapeFactory::getOrCreateShapeFactory(xShapeFactory)->createGroup2D( xTarget ));
2797
2798 // create the symbol
2799 Reference< drawing::XShape > xShape( VLegendSymbolFactory::createSymbol( rEntryKeyAspectRatio,
2800 xSymbolGroup, LegendSymbolStyle::Line, xShapeFactory,
2801 Reference< beans::XPropertySet >( aCurves[i], uno::UNO_QUERY ),
2802 VLegendSymbolFactory::PropertyType::Line, uno::Any() ));
2803
2804 // set CID to symbol for selection
2805 if( xShape.is())
2806 {
2807 aEntry.aSymbol.set( xSymbolGroup, uno::UNO_QUERY );
2808
2809 bool bAverageLine = RegressionCurveHelper::isMeanValueLine( aCurves[i] );
2810 ObjectType eObjectType = bAverageLine ? OBJECTTYPE_DATA_AVERAGE_LINE : OBJECTTYPE_DATA_CURVE;
2811 OUString aChildParticle( ObjectIdentifier::createChildParticleWithIndex( eObjectType, i ) );
2812 aChildParticle = ObjectIdentifier::addChildParticle( aChildParticle, ObjectIdentifier::createChildParticleWithIndex( OBJECTTYPE_LEGEND_ENTRY, 0 ) );
2813 OUString aCID = ObjectIdentifier::createClassifiedIdentifierForParticles( rSeries.getSeriesParticle(), aChildParticle );
2814 ShapeFactory::setShapeName( xShape, aCID );
2815 }
2816
2817 aResult.push_back(aEntry);
2818 }
2819 }
2820 }
2821 }
2822 catch( const uno::Exception & )
2823 {
2824 DBG_UNHANDLED_EXCEPTION("chart2" );
2825 }
2826 return aResult;
2827 }
2828
2829 VSeriesPlotter* VSeriesPlotter::createSeriesPlotter(
2830 const uno::Reference<XChartType>& xChartTypeModel
2831 , sal_Int32 nDimensionCount
2832 , bool bExcludingPositioning )
2833 {
2834 if (!xChartTypeModel.is())
2835 return nullptr;
2836
2837 OUString aChartType = xChartTypeModel->getChartType();
2838
2839 VSeriesPlotter* pRet=nullptr;
2840 if( aChartType.equalsIgnoreAsciiCase( CHART2_SERVICE_NAME_CHARTTYPE_COLUMN ) )
2841 pRet = new BarChart(xChartTypeModel,nDimensionCount);
2842 else if( aChartType.equalsIgnoreAsciiCase( CHART2_SERVICE_NAME_CHARTTYPE_BAR ) )
2843 pRet = new BarChart(xChartTypeModel,nDimensionCount);
2844 else if( aChartType.equalsIgnoreAsciiCase( CHART2_SERVICE_NAME_CHARTTYPE_AREA ) )
2845 pRet = new AreaChart(xChartTypeModel,nDimensionCount,true);
2846 else if( aChartType.equalsIgnoreAsciiCase( CHART2_SERVICE_NAME_CHARTTYPE_LINE ) )
2847 pRet = new AreaChart(xChartTypeModel,nDimensionCount,true,true);
2848 else if( aChartType.equalsIgnoreAsciiCase(CHART2_SERVICE_NAME_CHARTTYPE_SCATTER) )
2849 pRet = new AreaChart(xChartTypeModel,nDimensionCount,false,true);
2850 else if( aChartType.equalsIgnoreAsciiCase(CHART2_SERVICE_NAME_CHARTTYPE_BUBBLE) )
2851 pRet = new BubbleChart(xChartTypeModel,nDimensionCount);
2852 else if( aChartType.equalsIgnoreAsciiCase(CHART2_SERVICE_NAME_CHARTTYPE_PIE) )
2853 pRet = new PieChart(xChartTypeModel,nDimensionCount, bExcludingPositioning );
2854 else if( aChartType.equalsIgnoreAsciiCase(CHART2_SERVICE_NAME_CHARTTYPE_NET) )
2855 pRet = new NetChart(xChartTypeModel,nDimensionCount,true,std::make_unique<PolarPlottingPositionHelper>());
2856 else if( aChartType.equalsIgnoreAsciiCase(CHART2_SERVICE_NAME_CHARTTYPE_FILLED_NET) )
2857 pRet = new NetChart(xChartTypeModel,nDimensionCount,false,std::make_unique<PolarPlottingPositionHelper>());
2858 else if( aChartType.equalsIgnoreAsciiCase(CHART2_SERVICE_NAME_CHARTTYPE_CANDLESTICK) )
2859 pRet = new CandleStickChart(xChartTypeModel,nDimensionCount);
2860 else
2861 pRet = new AreaChart(xChartTypeModel,nDimensionCount,false,true);
2862 return pRet;
2863 }
2864
2865 } //namespace chart
2866
2867 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE