chart2/source/view/main/VDataSeries.cxx

   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 <limits>
  21 #include <memory>
  22 #include <VDataSeries.hxx>
  23 #include <ObjectIdentifier.hxx>
  24 #include <CommonConverters.hxx>
  25 #include <LabelPositionHelper.hxx>
  26 #include <ChartTypeHelper.hxx>
  27 #include <RegressionCurveHelper.hxx>
  28 #include <unonames.hxx>
  29
  30 #include <com/sun/star/chart/MissingValueTreatment.hpp>
  31 #include <com/sun/star/chart2/DataPointLabel.hpp>
  32 #include <com/sun/star/chart2/Symbol.hpp>
  33 #include <com/sun/star/chart2/XDataSeries.hpp>
  34 #include <com/sun/star/chart2/XRegressionCurveCalculator.hpp>
  35 #include <com/sun/star/chart2/RelativePosition.hpp>
  36
  37 #include <osl/diagnose.h>
  38 #include <tools/color.hxx>
  39 #include <tools/diagnose_ex.h>
  40 #include <com/sun/star/beans/XPropertySet.hpp>
  41 #include <com/sun/star/beans/XPropertyState.hpp>
  42 #include <com/sun/star/chart2/data/XDataSource.hpp>
  43
  44 namespace chart {
  45
  46 using namespace ::com::sun::star;
  47 using namespace ::com::sun::star::chart2;
  48 using ::com::sun::star::uno::Reference;
  49
  50 void VDataSequence::init( const uno::Reference< data::XDataSequence >& xModel )
  51 {
  52     Model = xModel;
  53     Doubles = DataSequenceToDoubleSequence( xModel );
  54 }
  55
  56 bool VDataSequence::is() const
  57 {
  58     return Model.is();
  59 }
  60 void VDataSequence::clear()
  61 {
  62     Model = nullptr;
  63     Doubles.realloc(0);
  64 }
  65
  66 double VDataSequence::getValue( sal_Int32 index ) const
  67 {
  68     if( 0<=index && index<Doubles.getLength() )
  69         return Doubles[index];
  70     return std::numeric_limits<double>::quiet_NaN();
  71 }
  72
  73 sal_Int32 VDataSequence::detectNumberFormatKey( sal_Int32 index ) const
  74 {
  75     sal_Int32 nNumberFormatKey = -1;
  76
  77     // -1 is allowed and means a key for the whole sequence
  78     if( -1<=index && index<Doubles.getLength() &&
  79         Model.is())
  80     {
  81         nNumberFormatKey = Model->getNumberFormatKeyByIndex( index );
  82     }
  83
  84     return nNumberFormatKey;
  85 }
  86
  87 sal_Int32 VDataSequence::getLength() const
  88 {
  89     return Doubles.getLength();
  90 }
  91
  92 namespace
  93 {
  94 struct lcl_LessXOfPoint
  95 {
  96     bool operator() ( const std::vector< double >& first,
  97                              const std::vector< double >& second )
  98     {
  99         if( !first.empty() && !second.empty() )
 100         {
 101             return first[0]<second[0];
 102         }
 103         return false;
 104     }
 105 };
 106
 107 void lcl_clearIfNoValuesButTextIsContained( VDataSequence& rData, const uno::Reference<data::XDataSequence>& xDataSequence )
 108 {
 109     //#i71686#, #i101968#, #i102428#
 110     sal_Int32 nCount = rData.Doubles.getLength();
 111     for( sal_Int32 i = 0; i < nCount; ++i )
 112     {
 113         if( !std::isnan( rData.Doubles[i] ) )
 114             return;
 115     }
 116     //no double value is contained
 117     //is there any text?
 118     uno::Sequence< OUString > aStrings( DataSequenceToStringSequence( xDataSequence ) );
 119     sal_Int32 nTextCount = aStrings.getLength();
 120     for( sal_Int32 j = 0; j < nTextCount; ++j )
 121     {
 122         if( !aStrings[j].isEmpty() )
 123         {
 124             rData.clear();
 125             return;
 126         }
 127     }
 128     //no content at all
 129 }
 130
 131 void lcl_maybeReplaceNanWithZero( double& rfValue, sal_Int32 nMissingValueTreatment )
 132 {
 133     if( nMissingValueTreatment == css::chart::MissingValueTreatment::USE_ZERO
 134         && (std::isnan(rfValue) || std::isinf(rfValue)) )
 135             rfValue = 0.0;
 136 }
 137
 138 }
 139
 140 VDataSeries::VDataSeries( const uno::Reference< XDataSeries >& xDataSeries )
 141     : m_nPolygonIndex(0)
 142     , m_fLogicMinX(0.0)
 143     , m_fLogicMaxX(0.0)
 144     , m_fLogicZPos(0.0)
 145     , m_xDataSeries(xDataSeries)
 146     , m_nPointCount(0)
 147     , m_pValueSequenceForDataLabelNumberFormatDetection(&m_aValues_Y)
 148     , m_fXMeanValue(std::numeric_limits<double>::quiet_NaN())
 149     , m_fYMeanValue(std::numeric_limits<double>::quiet_NaN())
 150     , m_eStackingDirection(StackingDirection_NO_STACKING)
 151     , m_nAxisIndex(0)
 152     , m_bConnectBars(false)
 153     , m_bGroupBarsPerAxis(true)
 154     , m_nStartingAngle(90)
 155     , m_nGlobalSeriesIndex(0)
 156     , m_nCurrentAttributedPoint(-1)
 157     , m_nMissingValueTreatment(css::chart::MissingValueTreatment::LEAVE_GAP)
 158     , m_bAllowPercentValueInDataLabel(false)
 159     , mpOldSeries(nullptr)
 160     , mnPercent(0.0)
 161 {
 162     uno::Reference<data::XDataSource> xDataSource( xDataSeries, uno::UNO_QUERY );
 163
 164     uno::Sequence< uno::Reference<
 165         chart2::data::XLabeledDataSequence > > aDataSequences =
 166             xDataSource->getDataSequences();
 167
 168     for(sal_Int32 nN = aDataSequences.getLength();nN--;)
 169     {
 170         if(!aDataSequences[nN].is())
 171             continue;
 172         uno::Reference<data::XDataSequence>  xDataSequence( aDataSequences[nN]->getValues());
 173         uno::Reference<beans::XPropertySet> xProp(xDataSequence, uno::UNO_QUERY );
 174         if( xProp.is())
 175         {
 176             try
 177             {
 178                 uno::Any aARole = xProp->getPropertyValue("Role");
 179                 OUString aRole;
 180                 aARole >>= aRole;
 181
 182                 if (aRole == "values-x")
 183                 {
 184                     m_aValues_X.init( xDataSequence );
 185                     lcl_clearIfNoValuesButTextIsContained( m_aValues_X, xDataSequence );
 186                 }
 187                 else if (aRole =="values-y")
 188                     m_aValues_Y.init( xDataSequence );
 189                 else if (aRole == "values-min")
 190                     m_aValues_Y_Min.init( xDataSequence );
 191                 else if (aRole == "values-max")
 192                     m_aValues_Y_Max.init( xDataSequence );
 193                 else if (aRole == "values-first")
 194                     m_aValues_Y_First.init( xDataSequence );
 195                 else if (aRole == "values-last")
 196                     m_aValues_Y_Last.init( xDataSequence );
 197                 else if (aRole == "values-size")
 198                     m_aValues_Bubble_Size.init( xDataSequence );
 199                 else
 200                 {
 201                     VDataSequence aSequence;
 202                     aSequence.init(xDataSequence);
 203                     m_PropertyMap.insert(std::make_pair(aRole, aSequence));
 204                 }
 205             }
 206             catch( const uno::Exception& )
 207             {
 208                 TOOLS_WARN_EXCEPTION("chart2", "" );
 209             }
 210         }
 211     }
 212
 213     //determine the point count
 214     m_nPointCount = m_aValues_Y.getLength();
 215     {
 216         if( m_nPointCount < m_aValues_Bubble_Size.getLength() )
 217             m_nPointCount = m_aValues_Bubble_Size.getLength();
 218         if( m_nPointCount < m_aValues_Y_Min.getLength() )
 219             m_nPointCount = m_aValues_Y_Min.getLength();
 220         if( m_nPointCount < m_aValues_Y_Max.getLength() )
 221             m_nPointCount = m_aValues_Y_Max.getLength();
 222         if( m_nPointCount < m_aValues_Y_First.getLength() )
 223             m_nPointCount = m_aValues_Y_First.getLength();
 224         if( m_nPointCount < m_aValues_Y_Last.getLength() )
 225             m_nPointCount = m_aValues_Y_Last.getLength();
 226     }
 227
 228     uno::Reference<beans::XPropertySet> xProp(xDataSeries, uno::UNO_QUERY );
 229     if( !xProp.is())
 230         return;
 231
 232     try
 233     {
 234         //get AttributedDataPoints
 235         xProp->getPropertyValue("AttributedDataPoints") >>= m_aAttributedDataPointIndexList;
 236
 237         xProp->getPropertyValue("StackingDirection") >>= m_eStackingDirection;
 238
 239         xProp->getPropertyValue("AttachedAxisIndex") >>= m_nAxisIndex;
 240         if(m_nAxisIndex<0)
 241             m_nAxisIndex=0;
 242     }
 243     catch( const uno::Exception& )
 244     {
 245         TOOLS_WARN_EXCEPTION("chart2", "" );
 246     }
 247 }
 248
 249 VDataSeries::~VDataSeries()
 250 {
 251 }
 252
 253 void VDataSeries::doSortByXValues()
 254 {
 255     if( !(m_aValues_X.is() && m_aValues_X.Doubles.hasElements()) )
 256         return;
 257
 258     //prepare a vector for sorting
 259     std::vector< std::vector< double > > aTmp;//outer vector are points, inner vector are the different values of the point
 260     sal_Int32 nPointIndex = 0;
 261     for( nPointIndex=0; nPointIndex < m_nPointCount; nPointIndex++ )
 262     {
 263         aTmp.push_back(
 264                         { ((nPointIndex < m_aValues_X.Doubles.getLength()) ? m_aValues_X.Doubles[nPointIndex]
 265                                                                            : std::numeric_limits<double>::quiet_NaN()),
 266                           ((nPointIndex < m_aValues_Y.Doubles.getLength()) ? m_aValues_Y.Doubles[nPointIndex]
 267                                                                            : std::numeric_limits<double>::quiet_NaN())
 268                         }
 269                       );
 270     }
 271
 272     //do sort
 273     std::stable_sort( aTmp.begin(), aTmp.end(), lcl_LessXOfPoint() );
 274
 275     //fill the sorted points back to the members
 276     m_aValues_X.Doubles.realloc( m_nPointCount );
 277     m_aValues_Y.Doubles.realloc( m_nPointCount );
 278
 279     for( nPointIndex=0; nPointIndex < m_nPointCount; nPointIndex++ )
 280     {
 281         m_aValues_X.Doubles[nPointIndex]=aTmp[nPointIndex][0];
 282         m_aValues_Y.Doubles[nPointIndex]=aTmp[nPointIndex][1];
 283     }
 284 }
 285
 286 void VDataSeries::releaseShapes()
 287 {
 288     m_xGroupShape.set(nullptr);
 289     m_xLabelsGroupShape.set(nullptr);
 290     m_xErrorXBarsGroupShape.set(nullptr);
 291     m_xErrorYBarsGroupShape.set(nullptr);
 292     m_xFrontSubGroupShape.set(nullptr);
 293     m_xBackSubGroupShape.set(nullptr);
 294
 295     m_aPolyPolygonShape3D.SequenceX.realloc(0);
 296     m_aPolyPolygonShape3D.SequenceY.realloc(0);
 297     m_aPolyPolygonShape3D.SequenceZ.realloc(0);
 298     m_nPolygonIndex = 0;
 299 }
 300
 301 const uno::Reference<css::chart2::XDataSeries>& VDataSeries::getModel() const
 302 {
 303     return m_xDataSeries;
 304 }
 305
 306 void VDataSeries::setCategoryXAxis()
 307 {
 308     m_aValues_X.clear();
 309     m_bAllowPercentValueInDataLabel = true;
 310 }
 311
 312 void VDataSeries::setXValues( const Reference< chart2::data::XDataSequence >& xValues )
 313 {
 314     m_aValues_X.clear();
 315     m_aValues_X.init( xValues );
 316     m_bAllowPercentValueInDataLabel = true;
 317 }
 318
 319 void VDataSeries::setXValuesIfNone( const Reference< chart2::data::XDataSequence >& xValues )
 320 {
 321     if( m_aValues_X.is() )
 322         return;
 323
 324     m_aValues_X.init( xValues );
 325     lcl_clearIfNoValuesButTextIsContained( m_aValues_X, xValues );
 326 }
 327
 328 void VDataSeries::setGlobalSeriesIndex( sal_Int32 nGlobalSeriesIndex )
 329 {
 330     m_nGlobalSeriesIndex = nGlobalSeriesIndex;
 331 }
 332
 333 void VDataSeries::setParticle( const OUString& rSeriesParticle )
 334 {
 335     m_aSeriesParticle = rSeriesParticle;
 336
 337     //get CID
 338     m_aCID = ObjectIdentifier::createClassifiedIdentifierForParticle( m_aSeriesParticle );
 339     m_aPointCID_Stub = ObjectIdentifier::createSeriesSubObjectStub( OBJECTTYPE_DATA_POINT, m_aSeriesParticle );
 340
 341     m_aLabelCID_Stub = ObjectIdentifier::createClassifiedIdentifierWithParent(
 342                         OBJECTTYPE_DATA_LABEL, u"", getLabelsCID() );
 343 }
 344 OUString VDataSeries::getErrorBarsCID(bool bYError) const
 345 {
 346     OUString aChildParticle( ObjectIdentifier::getStringForType(
 347                                       bYError ? OBJECTTYPE_DATA_ERRORS_Y : OBJECTTYPE_DATA_ERRORS_X )
 348                              + "=" );
 349
 350     return ObjectIdentifier::createClassifiedIdentifierForParticles(
 351             m_aSeriesParticle, aChildParticle );
 352 }
 353 OUString VDataSeries::getLabelsCID() const
 354 {
 355     OUString aChildParticle( ObjectIdentifier::getStringForType( OBJECTTYPE_DATA_LABELS ) + "=" );
 356
 357     return ObjectIdentifier::createClassifiedIdentifierForParticles(
 358             m_aSeriesParticle, aChildParticle );
 359 }
 360 OUString VDataSeries::getDataCurveCID( sal_Int32 nCurveIndex, bool bAverageLine ) const
 361 {
 362     return ObjectIdentifier::createDataCurveCID( m_aSeriesParticle, nCurveIndex, bAverageLine );
 363 }
 364
 365 OUString VDataSeries::getDataCurveEquationCID( sal_Int32 nCurveIndex ) const
 366 {
 367     return ObjectIdentifier::createDataCurveEquationCID( m_aSeriesParticle, nCurveIndex );
 368 }
 369 void VDataSeries::setPageReferenceSize( const awt::Size & rPageRefSize )
 370 {
 371     m_aReferenceSize = rPageRefSize;
 372 }
 373
 374 void VDataSeries::setConnectBars( bool bConnectBars )
 375 {
 376     m_bConnectBars = bConnectBars;
 377 }
 378
 379 bool VDataSeries::getConnectBars() const
 380 {
 381     return m_bConnectBars;
 382 }
 383
 384 void VDataSeries::setGroupBarsPerAxis( bool bGroupBarsPerAxis )
 385 {
 386     m_bGroupBarsPerAxis = bGroupBarsPerAxis;
 387 }
 388
 389 bool VDataSeries::getGroupBarsPerAxis() const
 390 {
 391     return m_bGroupBarsPerAxis;
 392 }
 393
 394 void VDataSeries::setStartingAngle( sal_Int32 nStartingAngle )
 395 {
 396     m_nStartingAngle = nStartingAngle;
 397 }
 398
 399 sal_Int32 VDataSeries::getStartingAngle() const
 400 {
 401     return m_nStartingAngle;
 402 }
 403
 404 chart2::StackingDirection VDataSeries::getStackingDirection() const
 405 {
 406     return m_eStackingDirection;
 407 }
 408
 409 sal_Int32 VDataSeries::getAttachedAxisIndex() const
 410 {
 411     return m_nAxisIndex;
 412 }
 413
 414 void VDataSeries::setAttachedAxisIndex( sal_Int32 nAttachedAxisIndex )
 415 {
 416     if( nAttachedAxisIndex < 0 )
 417         nAttachedAxisIndex = 0;
 418     m_nAxisIndex = nAttachedAxisIndex;
 419 }
 420
 421 double VDataSeries::getXValue( sal_Int32 index ) const
 422 {
 423     double fRet = std::numeric_limits<double>::quiet_NaN();
 424     if(m_aValues_X.is())
 425     {
 426         if( 0<=index && index<m_aValues_X.getLength() )
 427         {
 428             fRet = m_aValues_X.Doubles[index];
 429             if(mpOldSeries && index < mpOldSeries->m_aValues_X.getLength())
 430             {
 431                 double nOldVal = mpOldSeries->m_aValues_X.Doubles[index];
 432                 fRet = nOldVal + (fRet - nOldVal) * mnPercent;
 433             }
 434         }
 435     }
 436     else
 437     {
 438         // #i70133# always return correct X position - needed for short data series
 439         if( 0<=index /*&& index < m_nPointCount*/ )
 440             fRet = index+1;//first category (index 0) matches with real number 1.0
 441     }
 442     lcl_maybeReplaceNanWithZero( fRet, getMissingValueTreatment() );
 443     return fRet;
 444 }
 445
 446 double VDataSeries::getYValue( sal_Int32 index ) const
 447 {
 448     double fRet = std::numeric_limits<double>::quiet_NaN();
 449     if(m_aValues_Y.is())
 450     {
 451         if( 0<=index && index<m_aValues_Y.getLength() )
 452         {
 453             fRet = m_aValues_Y.Doubles[index];
 454             if(mpOldSeries && index < mpOldSeries->m_aValues_Y.getLength())
 455             {
 456                 double nOldVal = mpOldSeries->m_aValues_Y.Doubles[index];
 457                 fRet = nOldVal + (fRet - nOldVal) * mnPercent;
 458             }
 459         }
 460     }
 461     else
 462     {
 463         // #i70133# always return correct X position - needed for short data series
 464         if( 0<=index /*&& index < m_nPointCount*/ )
 465             fRet = index+1;//first category (index 0) matches with real number 1.0
 466     }
 467     lcl_maybeReplaceNanWithZero( fRet, getMissingValueTreatment() );
 468     return fRet;
 469 }
 470
 471 void VDataSeries::getMinMaxXValue(double& fMin, double& fMax) const
 472 {
 473     fMax = std::numeric_limits<double>::quiet_NaN();
 474     fMin = std::numeric_limits<double>::quiet_NaN();
 475
 476     uno::Sequence< double > aValuesX = getAllX();
 477
 478     if(!aValuesX.hasElements())
 479         return;
 480
 481     sal_Int32 i = 0;
 482     while ( i < aValuesX.getLength() && std::isnan(aValuesX[i]) )
 483         i++;
 484     if ( i < aValuesX.getLength() )
 485         fMax = fMin = aValuesX[i++];
 486
 487     for ( ; i < aValuesX.getLength(); i++)
 488     {
 489         const double aValue = aValuesX[i];
 490         if ( aValue > fMax)
 491         {
 492             fMax = aValue;
 493         }
 494         else if ( aValue < fMin)
 495         {
 496             fMin = aValue;
 497         }
 498     }
 499 }
 500 double VDataSeries::getY_Min( sal_Int32 index ) const
 501 {
 502     return m_aValues_Y_Min.getValue( index );
 503 }
 504 double VDataSeries::getY_Max( sal_Int32 index ) const
 505 {
 506     return m_aValues_Y_Max.getValue( index );
 507 }
 508 double VDataSeries::getY_First( sal_Int32 index ) const
 509 {
 510     return m_aValues_Y_First.getValue( index );
 511 }
 512 double VDataSeries::getY_Last( sal_Int32 index ) const
 513 {
 514     return m_aValues_Y_Last.getValue( index );
 515 }
 516 double VDataSeries::getBubble_Size( sal_Int32 index ) const
 517 {
 518     double nNewVal = m_aValues_Bubble_Size.getValue( index );
 519     if(mpOldSeries && index < mpOldSeries->m_aValues_Bubble_Size.getLength())
 520     {
 521         double nOldVal = mpOldSeries->m_aValues_Bubble_Size.getValue( index );
 522         nNewVal = nOldVal + (nNewVal - nOldVal) * mnPercent;
 523     }
 524
 525     return nNewVal;
 526 }
 527
 528 bool VDataSeries::hasExplicitNumberFormat( sal_Int32 nPointIndex, bool bForPercentage ) const
 529 {
 530     OUString aPropName = bForPercentage ? OUString("PercentageNumberFormat") : OUString(CHART_UNONAME_NUMFMT);
 531     bool bHasNumberFormat = false;
 532     bool bLinkToSource = true;
 533     uno::Reference< beans::XPropertySet > xPointProp( getPropertiesOfPoint( nPointIndex ));
 534     if( xPointProp.is() && (xPointProp->getPropertyValue(CHART_UNONAME_LINK_TO_SRC_NUMFMT) >>= bLinkToSource))
 535     {
 536         sal_Int32 nNumberFormat = -1;
 537         if( !bLinkToSource && (xPointProp->getPropertyValue(aPropName) >>= nNumberFormat))
 538             bHasNumberFormat = true;
 539     }
 540     return bHasNumberFormat;
 541 }
 542 sal_Int32 VDataSeries::getExplicitNumberFormat( sal_Int32 nPointIndex, bool bForPercentage ) const
 543 {
 544     OUString aPropName = bForPercentage ? OUString("PercentageNumberFormat") : OUString(CHART_UNONAME_NUMFMT);
 545     sal_Int32 nNumberFormat = -1;
 546     uno::Reference< beans::XPropertySet > xPointProp( getPropertiesOfPoint( nPointIndex ));
 547     if( xPointProp.is() )
 548         xPointProp->getPropertyValue(aPropName) >>= nNumberFormat;
 549     return nNumberFormat;
 550 }
 551 void VDataSeries::setRoleOfSequenceForDataLabelNumberFormatDetection( std::u16string_view rRole )
 552 {
 553     if (rRole == u"values-y")
 554         m_pValueSequenceForDataLabelNumberFormatDetection = &m_aValues_Y;
 555     else if (rRole == u"values-size")
 556         m_pValueSequenceForDataLabelNumberFormatDetection = &m_aValues_Bubble_Size;
 557     else if (rRole == u"values-min")
 558         m_pValueSequenceForDataLabelNumberFormatDetection = &m_aValues_Y_Min;
 559     else if (rRole == u"values-max")
 560         m_pValueSequenceForDataLabelNumberFormatDetection = &m_aValues_Y_Max;
 561     else if (rRole == u"values-first")
 562         m_pValueSequenceForDataLabelNumberFormatDetection = &m_aValues_Y_First;
 563     else if (rRole == u"values-last")
 564         m_pValueSequenceForDataLabelNumberFormatDetection = &m_aValues_Y_Last;
 565     else if (rRole == u"values-x")
 566         m_pValueSequenceForDataLabelNumberFormatDetection = &m_aValues_X;
 567 }
 568 sal_Int32 VDataSeries::detectNumberFormatKey( sal_Int32 index ) const
 569 {
 570     sal_Int32 nRet = 0;
 571     if( m_pValueSequenceForDataLabelNumberFormatDetection )
 572         nRet = m_pValueSequenceForDataLabelNumberFormatDetection->detectNumberFormatKey( index );
 573     return nRet;
 574 }
 575
 576 sal_Int32 VDataSeries::getLabelPlacement( sal_Int32 nPointIndex, const uno::Reference< chart2::XChartType >& xChartType, bool bSwapXAndY ) const
 577 {
 578     sal_Int32 nLabelPlacement=0;
 579     try
 580     {
 581         uno::Reference< beans::XPropertySet > xPointProps( getPropertiesOfPoint( nPointIndex ) );
 582         if( xPointProps.is() )
 583             xPointProps->getPropertyValue("LabelPlacement") >>= nLabelPlacement;
 584
 585         const uno::Sequence < sal_Int32 > aAvailablePlacements( ChartTypeHelper::getSupportedLabelPlacements(
 586                 xChartType, bSwapXAndY, m_xDataSeries ) );
 587
 588         for( sal_Int32 n : aAvailablePlacements )
 589             if( n == nLabelPlacement )
 590                 return nLabelPlacement; //ok
 591
 592         //otherwise use the first supported one
 593         if( aAvailablePlacements.hasElements() )
 594         {
 595             nLabelPlacement = aAvailablePlacements[0];
 596             if( xPointProps.is() )
 597                 xPointProps->setPropertyValue("LabelPlacement", uno::Any(nLabelPlacement));
 598             return nLabelPlacement;
 599         }
 600
 601         OSL_FAIL("no label placement supported");
 602     }
 603     catch( const uno::Exception& )
 604     {
 605         TOOLS_WARN_EXCEPTION("chart2", "" );
 606     }
 607     return nLabelPlacement;
 608 }
 609
 610 awt::Point VDataSeries::getLabelPosition( awt::Point aTextShapePos, sal_Int32 nPointIndex ) const
 611 {
 612     awt::Point aPos(-1, -1);
 613     try
 614     {
 615         RelativePosition aCustomLabelPosition;
 616         uno::Reference< beans::XPropertySet > xPointProps(getPropertiesOfPoint(nPointIndex));
 617         if( xPointProps.is() && (xPointProps->getPropertyValue("CustomLabelPosition") >>= aCustomLabelPosition))
 618         {
 619             aPos.X = static_cast<sal_Int32>(aCustomLabelPosition.Primary * m_aReferenceSize.Width) + aTextShapePos.X;
 620             aPos.Y = static_cast<sal_Int32>(aCustomLabelPosition.Secondary * m_aReferenceSize.Height) + aTextShapePos.Y;
 621         }
 622     }
 623     catch (const uno::Exception&)
 624     {
 625         TOOLS_WARN_EXCEPTION("chart2", "");
 626     }
 627     return aPos;
 628 }
 629
 630 bool VDataSeries::isLabelCustomPos(sal_Int32 nPointIndex) const
 631 {
 632     bool bCustom = false;
 633     try
 634     {
 635         if( isAttributedDataPoint(nPointIndex) )
 636         {
 637             uno::Reference< beans::XPropertySet > xPointProps(m_xDataSeries->getDataPointByIndex(nPointIndex));
 638             RelativePosition aCustomLabelPosition;
 639             if( xPointProps.is() && (xPointProps->getPropertyValue("CustomLabelPosition") >>= aCustomLabelPosition) )
 640                 bCustom = true;
 641         }
 642     }
 643     catch (const uno::Exception&)
 644     {
 645         TOOLS_WARN_EXCEPTION("chart2", "");
 646     }
 647     return bCustom;
 648 }
 649
 650 double VDataSeries::getMinimumofAllDifferentYValues( sal_Int32 index ) const
 651 {
 652     double fMin = std::numeric_limits<double>::infinity();
 653
 654     if( !m_aValues_Y.is() &&
 655         (m_aValues_Y_Min.is() || m_aValues_Y_Max.is()
 656         || m_aValues_Y_First.is() || m_aValues_Y_Last.is() ) )
 657     {
 658         double fY_Min = getY_Min( index );
 659         double fY_Max = getY_Max( index );
 660         double fY_First = getY_First( index );
 661         double fY_Last = getY_Last( index );
 662
 663         if(fMin>fY_First)
 664             fMin=fY_First;
 665         if(fMin>fY_Last)
 666             fMin=fY_Last;
 667         if(fMin>fY_Min)
 668             fMin=fY_Min;
 669         if(fMin>fY_Max)
 670             fMin=fY_Max;
 671     }
 672     else
 673     {
 674         double fY = getYValue( index );
 675         if(fMin>fY)
 676             fMin=fY;
 677     }
 678
 679     if( std::isinf(fMin) )
 680         return std::numeric_limits<double>::quiet_NaN();
 681
 682     return fMin;
 683 }
 684
 685 double VDataSeries::getMaximumofAllDifferentYValues( sal_Int32 index ) const
 686 {
 687     double fMax = -std::numeric_limits<double>::infinity();
 688
 689     if( !m_aValues_Y.is() &&
 690         (m_aValues_Y_Min.is() || m_aValues_Y_Max.is()
 691         || m_aValues_Y_First.is() || m_aValues_Y_Last.is() ) )
 692     {
 693         double fY_Min = getY_Min( index );
 694         double fY_Max = getY_Max( index );
 695         double fY_First = getY_First( index );
 696         double fY_Last = getY_Last( index );
 697
 698         if(fMax<fY_First)
 699             fMax=fY_First;
 700         if(fMax<fY_Last)
 701             fMax=fY_Last;
 702         if(fMax<fY_Min)
 703             fMax=fY_Min;
 704         if(fMax<fY_Max)
 705             fMax=fY_Max;
 706     }
 707     else
 708     {
 709         double fY = getYValue( index );
 710         if(fMax<fY)
 711             fMax=fY;
 712     }
 713
 714     if( std::isinf(fMax) )
 715         return std::numeric_limits<double>::quiet_NaN();
 716
 717     return fMax;
 718 }
 719
 720 uno::Sequence< double > const & VDataSeries::getAllX() const
 721 {
 722     if(!m_aValues_X.is() && !m_aValues_X.getLength() && m_nPointCount)
 723     {
 724         //init x values from category indexes
 725         //first category (index 0) matches with real number 1.0
 726         m_aValues_X.Doubles.realloc( m_nPointCount );
 727         for(sal_Int32 nN=m_aValues_X.getLength();nN--;)
 728             m_aValues_X.Doubles[nN] = nN+1;
 729     }
 730     return m_aValues_X.Doubles;
 731 }
 732
 733 uno::Sequence< double > const & VDataSeries::getAllY() const
 734 {
 735     if(!m_aValues_Y.is() && !m_aValues_Y.getLength() && m_nPointCount)
 736     {
 737         //init y values from indexes
 738         //first y-value (index 0) matches with real number 1.0
 739         m_aValues_Y.Doubles.realloc( m_nPointCount );
 740         for(sal_Int32 nN=m_aValues_Y.getLength();nN--;)
 741             m_aValues_Y.Doubles[nN] = nN+1;
 742     }
 743     return m_aValues_Y.Doubles;
 744 }
 745
 746 double VDataSeries::getXMeanValue() const
 747 {
 748     if( std::isnan( m_fXMeanValue ) )
 749     {
 750         uno::Reference< XRegressionCurveCalculator > xCalculator( RegressionCurveHelper::createRegressionCurveCalculatorByServiceName( u"com.sun.star.chart2.MeanValueRegressionCurve" ) );
 751         uno::Sequence< double > aXValuesDummy;
 752         xCalculator->recalculateRegression( aXValuesDummy, getAllX() );
 753         m_fXMeanValue = xCalculator->getCurveValue( 1.0 );
 754     }
 755     return m_fXMeanValue;
 756 }
 757
 758 double VDataSeries::getYMeanValue() const
 759 {
 760     if( std::isnan( m_fYMeanValue ) )
 761     {
 762         uno::Reference< XRegressionCurveCalculator > xCalculator(
 763             RegressionCurveHelper::createRegressionCurveCalculatorByServiceName(u"com.sun.star.chart2.MeanValueRegressionCurve"));
 764         uno::Sequence< double > aXValuesDummy;
 765         xCalculator->recalculateRegression( aXValuesDummy, getAllY() );
 766         m_fYMeanValue = xCalculator->getCurveValue( 1.0 );
 767     }
 768     return m_fYMeanValue;
 769 }
 770
 771 static std::unique_ptr<Symbol> getSymbolPropertiesFromPropertySet( const uno::Reference< beans::XPropertySet >& xProp )
 772 {
 773     std::unique_ptr< Symbol > apSymbolProps( new Symbol() );
 774     try
 775     {
 776         if( xProp->getPropertyValue("Symbol") >>= *apSymbolProps )
 777         {
 778             //use main color to fill symbols
 779             xProp->getPropertyValue("Color") >>= apSymbolProps->FillColor;
 780             // border of symbols always same as fill color
 781             apSymbolProps->BorderColor = apSymbolProps->FillColor;
 782         }
 783         else
 784             apSymbolProps.reset();
 785     }
 786     catch(const uno::Exception &)
 787     {
 788         TOOLS_WARN_EXCEPTION("chart2", "" );
 789     }
 790     return apSymbolProps;
 791 }
 792
 793 Symbol* VDataSeries::getSymbolProperties( sal_Int32 index ) const
 794 {
 795     Symbol* pRet=nullptr;
 796     if( isAttributedDataPoint( index ) )
 797     {
 798         adaptPointCache( index );
 799         if (!m_apSymbolProperties_AttributedPoint)
 800             m_apSymbolProperties_AttributedPoint
 801                 = getSymbolPropertiesFromPropertySet(getPropertiesOfPoint(index));
 802         pRet = m_apSymbolProperties_AttributedPoint.get();
 803         //if a single data point does not have symbols but the dataseries itself has symbols
 804         //we create an invisible symbol shape to enable selection of that point
 805         if( !pRet || pRet->Style == SymbolStyle_NONE )
 806         {
 807             if (!m_apSymbolProperties_Series)
 808                 m_apSymbolProperties_Series
 809                     = getSymbolPropertiesFromPropertySet(getPropertiesOfSeries());
 810             if( m_apSymbolProperties_Series && m_apSymbolProperties_Series->Style != SymbolStyle_NONE )
 811             {
 812                 if (!m_apSymbolProperties_InvisibleSymbolForSelection)
 813                 {
 814                     m_apSymbolProperties_InvisibleSymbolForSelection.reset(new Symbol);
 815                     m_apSymbolProperties_InvisibleSymbolForSelection->Style = SymbolStyle_STANDARD;
 816                     m_apSymbolProperties_InvisibleSymbolForSelection->StandardSymbol = 0;//square
 817                     m_apSymbolProperties_InvisibleSymbolForSelection->Size = com::sun::star::awt::Size(0, 0);//tdf#126033
 818                     m_apSymbolProperties_InvisibleSymbolForSelection->BorderColor = 0xff000000;//invisible
 819                     m_apSymbolProperties_InvisibleSymbolForSelection->FillColor = 0xff000000;//invisible
 820                 }
 821                 pRet = m_apSymbolProperties_InvisibleSymbolForSelection.get();
 822             }
 823         }
 824     }
 825     else
 826     {
 827         if (!m_apSymbolProperties_Series)
 828             m_apSymbolProperties_Series
 829                 = getSymbolPropertiesFromPropertySet(getPropertiesOfSeries());
 830         pRet = m_apSymbolProperties_Series.get();
 831     }
 832
 833     if( pRet && pRet->Style == SymbolStyle_AUTO )
 834     {
 835         pRet->Style = SymbolStyle_STANDARD;
 836
 837         sal_Int32 nIndex = m_nGlobalSeriesIndex;
 838         if(m_aValues_X.is())
 839             nIndex++;
 840         pRet->StandardSymbol = nIndex;
 841     }
 842
 843     return pRet;
 844 }
 845
 846 uno::Reference< beans::XPropertySet > VDataSeries::getXErrorBarProperties( sal_Int32 index ) const
 847 {
 848     uno::Reference< beans::XPropertySet > xErrorBarProp;
 849
 850     uno::Reference< beans::XPropertySet > xPointProp( getPropertiesOfPoint( index ));
 851     if( xPointProp.is() )
 852         xPointProp->getPropertyValue(CHART_UNONAME_ERRORBAR_X) >>= xErrorBarProp;
 853     return xErrorBarProp;
 854 }
 855
 856 uno::Reference< beans::XPropertySet > VDataSeries::getYErrorBarProperties( sal_Int32 index ) const
 857 {
 858     uno::Reference< beans::XPropertySet > xErrorBarProp;
 859
 860     uno::Reference< beans::XPropertySet > xPointProp( getPropertiesOfPoint( index ));
 861     if( xPointProp.is() )
 862         xPointProp->getPropertyValue(CHART_UNONAME_ERRORBAR_Y) >>= xErrorBarProp;
 863     return xErrorBarProp;
 864 }
 865
 866 bool VDataSeries::hasPointOwnColor( sal_Int32 index ) const
 867 {
 868     if( !isAttributedDataPoint(index) )
 869         return false;
 870
 871     try
 872     {
 873         uno::Reference< beans::XPropertyState > xPointState( getPropertiesOfPoint(index), uno::UNO_QUERY_THROW );
 874         return (xPointState->getPropertyState("Color") != beans::PropertyState_DEFAULT_VALUE );
 875     }
 876     catch(const uno::Exception&)
 877     {
 878         TOOLS_WARN_EXCEPTION("chart2", "" );
 879     }
 880     return false;
 881 }
 882
 883 bool VDataSeries::isAttributedDataPoint( sal_Int32 index ) const
 884 {
 885     //returns true if the data point assigned by the given index has set its own properties
 886     if( index>=m_nPointCount || m_nPointCount==0)
 887         return false;
 888     for(sal_Int32 n : m_aAttributedDataPointIndexList)
 889     {
 890         if(index == n)
 891             return true;
 892     }
 893     return false;
 894 }
 895
 896 bool VDataSeries::isVaryColorsByPoint() const
 897 {
 898     bool bVaryColorsByPoint = false;
 899     Reference< beans::XPropertySet > xSeriesProp( getPropertiesOfSeries() );
 900     if( xSeriesProp.is() )
 901         xSeriesProp->getPropertyValue("VaryColorsByPoint") >>= bVaryColorsByPoint;
 902     return bVaryColorsByPoint;
 903 }
 904
 905 uno::Reference< beans::XPropertySet > VDataSeries::getPropertiesOfPoint( sal_Int32 index ) const
 906 {
 907     if( isAttributedDataPoint( index ) )
 908         return m_xDataSeries->getDataPointByIndex(index);
 909     return getPropertiesOfSeries();
 910 }
 911
 912 uno::Reference<beans::XPropertySet> VDataSeries::getPropertiesOfSeries() const
 913 {
 914     return uno::Reference<css::beans::XPropertySet>(m_xDataSeries, css::uno::UNO_QUERY);
 915 }
 916
 917 static std::unique_ptr<DataPointLabel> getDataPointLabelFromPropertySet( const uno::Reference< beans::XPropertySet >& xProp )
 918 {
 919     std::unique_ptr< DataPointLabel > apLabel( new DataPointLabel() );
 920     try
 921     {
 922         if( !(xProp->getPropertyValue(CHART_UNONAME_LABEL) >>= *apLabel) )
 923             apLabel.reset();
 924     }
 925     catch(const uno::Exception &)
 926     {
 927         TOOLS_WARN_EXCEPTION("chart2", "" );
 928     }
 929     return apLabel;
 930 }
 931
 932 void VDataSeries::adaptPointCache( sal_Int32 nNewPointIndex ) const
 933 {
 934     if( m_nCurrentAttributedPoint != nNewPointIndex )
 935     {
 936         m_apLabel_AttributedPoint.reset();
 937         m_apLabelPropNames_AttributedPoint.reset();
 938         m_apLabelPropValues_AttributedPoint.reset();
 939         m_apSymbolProperties_AttributedPoint.reset();
 940         m_nCurrentAttributedPoint = nNewPointIndex;
 941     }
 942 }
 943
 944 DataPointLabel* VDataSeries::getDataPointLabel( sal_Int32 index ) const
 945 {
 946     DataPointLabel* pRet = nullptr;
 947     if( isAttributedDataPoint( index ) )
 948     {
 949         adaptPointCache( index );
 950         if (!m_apLabel_AttributedPoint)
 951             m_apLabel_AttributedPoint
 952                 = getDataPointLabelFromPropertySet(getPropertiesOfPoint(index));
 953         pRet = m_apLabel_AttributedPoint.get();
 954     }
 955     else
 956     {
 957         if (!m_apLabel_Series)
 958             m_apLabel_Series
 959                 = getDataPointLabelFromPropertySet(getPropertiesOfPoint(index));
 960         pRet = m_apLabel_Series.get();
 961     }
 962     if( !m_bAllowPercentValueInDataLabel )
 963     {
 964         if( pRet )
 965             pRet->ShowNumberInPercent = false;
 966     }
 967     return pRet;
 968 }
 969
 970 DataPointLabel* VDataSeries::getDataPointLabelIfLabel( sal_Int32 index ) const
 971 {
 972     DataPointLabel* pLabel = getDataPointLabel( index );
 973     if( !pLabel || (!pLabel->ShowNumber && !pLabel->ShowNumberInPercent
 974         && !pLabel->ShowCategoryName && !pLabel->ShowCustomLabel && !pLabel->ShowSeriesName ) )
 975         return nullptr;
 976     return pLabel;
 977 }
 978
 979 bool VDataSeries::getTextLabelMultiPropertyLists( sal_Int32 index
 980     , tNameSequence*& pPropNames
 981     , tAnySequence*& pPropValues ) const
 982 {
 983     pPropNames = nullptr; pPropValues = nullptr;
 984     uno::Reference< beans::XPropertySet > xTextProp;
 985     bool bDoDynamicFontResize = false;
 986     if( isAttributedDataPoint( index ) )
 987     {
 988         adaptPointCache( index );
 989         if (!m_apLabelPropValues_AttributedPoint)
 990         {
 991             // Cache these properties for this point.
 992             m_apLabelPropNames_AttributedPoint.reset(new tNameSequence);
 993             m_apLabelPropValues_AttributedPoint.reset(new tAnySequence);
 994             xTextProp.set( getPropertiesOfPoint( index ));
 995             PropertyMapper::getTextLabelMultiPropertyLists(
 996                 xTextProp, *m_apLabelPropNames_AttributedPoint, *m_apLabelPropValues_AttributedPoint);
 997             bDoDynamicFontResize = true;
 998         }
 999         pPropNames = m_apLabelPropNames_AttributedPoint.get();
1000         pPropValues = m_apLabelPropValues_AttributedPoint.get();
1001     }
1002     else
1003     {
1004         if (!m_apLabelPropValues_Series)
1005         {
1006             // Cache these properties for the whole series.
1007             m_apLabelPropNames_Series.reset(new tNameSequence);
1008             m_apLabelPropValues_Series.reset(new tAnySequence);
1009             xTextProp.set( getPropertiesOfPoint( index ));
1010             PropertyMapper::getTextLabelMultiPropertyLists(
1011                 xTextProp, *m_apLabelPropNames_Series, *m_apLabelPropValues_Series);
1012             bDoDynamicFontResize = true;
1013         }
1014         pPropNames = m_apLabelPropNames_Series.get();
1015         pPropValues = m_apLabelPropValues_Series.get();
1016     }
1017
1018     if( bDoDynamicFontResize &&
1019         pPropNames && pPropValues &&
1020         xTextProp.is())
1021     {
1022         LabelPositionHelper::doDynamicFontResize( *pPropValues, *pPropNames, xTextProp, m_aReferenceSize );
1023     }
1024
1025     return (pPropNames && pPropValues);
1026 }
1027
1028 void VDataSeries::setMissingValueTreatment( sal_Int32 nMissingValueTreatment )
1029 {
1030     m_nMissingValueTreatment = nMissingValueTreatment;
1031 }
1032
1033 sal_Int32 VDataSeries::getMissingValueTreatment() const
1034 {
1035     return m_nMissingValueTreatment;
1036 }
1037
1038 VDataSeries::VDataSeries()
1039     : m_nPolygonIndex(0)
1040     , m_fLogicMinX(0)
1041     , m_fLogicMaxX(0)
1042     , m_fLogicZPos(0)
1043     , m_nPointCount(0)
1044     , m_pValueSequenceForDataLabelNumberFormatDetection(nullptr)
1045     , m_fXMeanValue(0)
1046     , m_fYMeanValue(0)
1047     , m_eStackingDirection(chart2::StackingDirection_NO_STACKING)
1048     , m_nAxisIndex(0)
1049     , m_bConnectBars(false)
1050     , m_bGroupBarsPerAxis(false)
1051     , m_nStartingAngle(0)
1052     , m_nGlobalSeriesIndex(0)
1053     , m_nCurrentAttributedPoint(0)
1054     , m_nMissingValueTreatment(0)
1055     , m_bAllowPercentValueInDataLabel(false)
1056     , mpOldSeries(nullptr)
1057     , mnPercent(0)
1058 {
1059 }
1060
1061 void VDataSeries::setOldTimeBased( VDataSeries* pOldSeries, double nPercent )
1062 {
1063     mnPercent = nPercent;
1064     mpOldSeries = pOldSeries;
1065     mpOldSeries->mpOldSeries = nullptr;
1066 }
1067
1068 VDataSeries* VDataSeries::createCopyForTimeBased() const
1069 {
1070     VDataSeries* pNew = new VDataSeries();
1071     pNew->m_aValues_X = m_aValues_X;
1072     pNew->m_aValues_Y = m_aValues_Y;
1073     pNew->m_aValues_Z = m_aValues_Z;
1074     pNew->m_aValues_Y_Min = m_aValues_Y_Min;
1075     pNew->m_aValues_Y_Max = m_aValues_Y_Max;
1076     pNew->m_aValues_Y_First = m_aValues_Y_First;
1077     pNew->m_aValues_Y_Last = m_aValues_Y_Last;
1078     pNew->m_aValues_Bubble_Size = m_aValues_Bubble_Size;
1079     pNew->m_PropertyMap = m_PropertyMap;
1080
1081     pNew->m_nPointCount = m_nPointCount;
1082
1083     return pNew;
1084 }
1085
1086 double VDataSeries::getValueByProperty( sal_Int32 nIndex, const OUString& rPropName ) const
1087 {
1088     auto const itr = m_PropertyMap.find(rPropName);
1089     if (itr == m_PropertyMap.end())
1090         return std::numeric_limits<double>::quiet_NaN();
1091
1092     const VDataSequence* pData = &itr->second;
1093     double fValue = pData->getValue(nIndex);
1094     if(mpOldSeries && mpOldSeries->hasPropertyMapping(rPropName))
1095     {
1096         double fOldValue = mpOldSeries->getValueByProperty( nIndex, rPropName );
1097         if(rPropName.endsWith("Color"))
1098         {
1099             //optimized interpolation for color values
1100             Color aColor(ColorTransparency, static_cast<sal_uInt32>(fValue));
1101             Color aOldColor(ColorTransparency, static_cast<sal_uInt32>(fOldValue));
1102             sal_uInt8 r = aOldColor.GetRed() + (aColor.GetRed() - aOldColor.GetRed()) * mnPercent;
1103             sal_uInt8 g = aOldColor.GetGreen() + (aColor.GetGreen() - aOldColor.GetGreen()) * mnPercent;
1104             sal_uInt8 b = aOldColor.GetBlue() + (aColor.GetBlue() - aOldColor.GetBlue()) * mnPercent;
1105             sal_uInt8 a = aOldColor.GetAlpha() + (aColor.GetAlpha() - aOldColor.GetAlpha()) * mnPercent;
1106             Color aRet(ColorAlpha, a, r, g, b);
1107             return sal_uInt32(aRet);
1108         }
1109         return fOldValue + (fValue - fOldValue) * mnPercent;
1110     }
1111     return fValue;
1112 }
1113
1114 bool VDataSeries::hasPropertyMapping(const OUString& rPropName ) const
1115 {
1116     return m_PropertyMap.find(rPropName) != m_PropertyMap.end();
1117 }
1118
1119 } //namespace chart
1120
1121 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */