chart2/source/tools/DataSeriesHelper.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 <DataSeriesHelper.hxx>
  21 #include <DataSource.hxx>
  22 #include <unonames.hxx>
  23
  24 #include <com/sun/star/beans/XPropertySet.hpp>
  25 #include <com/sun/star/chart2/DataPointLabel.hpp>
  26 #include <com/sun/star/chart2/data/XTextualDataSequence.hpp>
  27 #include <com/sun/star/chart2/StackingDirection.hpp>
  28 #include <com/sun/star/chart2/data/LabelOrigin.hpp>
  29 #include <com/sun/star/chart2/AxisType.hpp>
  30 #include <com/sun/star/chart2/SymbolStyle.hpp>
  31 #include <com/sun/star/chart2/Symbol.hpp>
  32 #include <com/sun/star/drawing/LineStyle.hpp>
  33
  34 #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
  35 #include <com/sun/star/chart2/XChartTypeContainer.hpp>
  36 #include <com/sun/star/chart2/XDataSeriesContainer.hpp>
  37 #include <comphelper/sequence.hxx>
  38 #include <rtl/ustrbuf.hxx>
  39 #include <tools/diagnose_ex.h>
  40 #include <sal/log.hxx>
  41
  42 #include <algorithm>
  43 #include <iterator>
  44 #include <vector>
  45 #include <set>
  46
  47 using namespace ::com::sun::star;
  48 using namespace ::com::sun::star::chart2;
  49
  50 using ::com::sun::star::uno::Reference;
  51 using ::com::sun::star::uno::Sequence;
  52
  53 namespace
  54 {
  55
  56 class lcl_MatchesRole
  57 {
  58 public:
  59     explicit lcl_MatchesRole( const OUString & aRole, bool bMatchPrefix ) :
  60             m_aRole( aRole ),
  61             m_bMatchPrefix( bMatchPrefix )
  62     {}
  63
  64     bool operator () ( const Reference< chart2::data::XLabeledDataSequence > & xSeq ) const
  65     {
  66         if(!xSeq.is())
  67             return false;
  68         Reference< beans::XPropertySet > xProp( xSeq->getValues(), uno::UNO_QUERY );
  69         OUString aRole;
  70
  71         if( m_bMatchPrefix )
  72             return ( xProp.is() &&
  73                      (xProp->getPropertyValue( "Role" ) >>= aRole ) &&
  74                      aRole.match( m_aRole ));
  75
  76         return ( xProp.is() &&
  77                  (xProp->getPropertyValue( "Role" ) >>= aRole ) &&
  78                  m_aRole == aRole );
  79     }
  80
  81 private:
  82     OUString m_aRole;
  83     bool     m_bMatchPrefix;
  84 };
  85
  86 Reference< chart2::data::XLabeledDataSequence > lcl_findLSequenceWithOnlyLabel(
  87     const Reference< chart2::data::XDataSource > & xDataSource )
  88 {
  89     Reference< chart2::data::XLabeledDataSequence > xResult;
  90     Sequence< Reference< chart2::data::XLabeledDataSequence > > aSequences( xDataSource->getDataSequences());
  91
  92     for( sal_Int32 i=0; i<aSequences.getLength(); ++i )
  93     {
  94         OSL_ENSURE( aSequences[i].is(), "empty LabeledDataSequence" );
  95         // no values are set but a label exists
  96         if( aSequences[i].is() &&
  97             ( ! aSequences[i]->getValues().is() &&
  98               aSequences[i]->getLabel().is()))
  99         {
 100             xResult.set( aSequences[i] );
 101             break;
 102         }
 103     }
 104
 105     return xResult;
 106 }
 107
 108 void lcl_getCooSysAndChartTypeOfSeries(
 109     const Reference< chart2::XDataSeries > & xSeries,
 110     const Reference< chart2::XDiagram > & xDiagram,
 111     Reference< chart2::XCoordinateSystem > & xOutCooSys,
 112     Reference< chart2::XChartType > & xOutChartType )
 113 {
 114     Reference< chart2::XCoordinateSystemContainer > xCooSysCnt( xDiagram, uno::UNO_QUERY );
 115     if( xCooSysCnt.is())
 116     {
 117         Sequence< Reference< chart2::XCoordinateSystem > > aCooSysSeq( xCooSysCnt->getCoordinateSystems());
 118         for( sal_Int32 nCooSysIdx=0; nCooSysIdx<aCooSysSeq.getLength(); ++nCooSysIdx )
 119         {
 120             Reference< chart2::XChartTypeContainer > xCTCnt( aCooSysSeq[nCooSysIdx], uno::UNO_QUERY_THROW );
 121             Sequence< Reference< chart2::XChartType > > aChartTypes( xCTCnt->getChartTypes());
 122             for( sal_Int32 nCTIdx=0; nCTIdx<aChartTypes.getLength(); ++nCTIdx )
 123             {
 124                 Reference< chart2::XDataSeriesContainer > xSeriesCnt( aChartTypes[nCTIdx], uno::UNO_QUERY );
 125                 if( xSeriesCnt.is())
 126                 {
 127                     Sequence< Reference< chart2::XDataSeries > > aSeries( xSeriesCnt->getDataSeries());
 128                     for( sal_Int32 nSeriesIdx=0; nSeriesIdx<aSeries.getLength(); ++nSeriesIdx )
 129                     {
 130                         if( aSeries[nSeriesIdx] == xSeries )
 131                         {
 132                             xOutCooSys.set( aCooSysSeq[nCooSysIdx] );
 133                             xOutChartType.set( aChartTypes[nCTIdx] );
 134                         }
 135                     }
 136                 }
 137             }
 138         }
 139     }
 140 }
 141
 142 void lcl_insertOrDeleteDataLabelsToSeriesAndAllPoints( const Reference< chart2::XDataSeries >& xSeries, bool bInsert )
 143 {
 144     try
 145     {
 146         Reference< beans::XPropertySet > xSeriesProperties( xSeries, uno::UNO_QUERY );
 147         if( xSeriesProperties.is() )
 148         {
 149             DataPointLabel aLabelAtSeries;
 150             xSeriesProperties->getPropertyValue(CHART_UNONAME_LABEL) >>= aLabelAtSeries;
 151             aLabelAtSeries.ShowNumber = bInsert;
 152             if( !bInsert )
 153             {
 154                 aLabelAtSeries.ShowNumberInPercent = false;
 155                 aLabelAtSeries.ShowCategoryName = false;
 156             }
 157             xSeriesProperties->setPropertyValue(CHART_UNONAME_LABEL, uno::Any(aLabelAtSeries));
 158             uno::Sequence< sal_Int32 > aAttributedDataPointIndexList;
 159             if( xSeriesProperties->getPropertyValue( "AttributedDataPoints" ) >>= aAttributedDataPointIndexList )
 160             {
 161                 for(sal_Int32 nN=aAttributedDataPointIndexList.getLength();nN--;)
 162                 {
 163                     Reference< beans::XPropertySet > xPointProp( xSeries->getDataPointByIndex(aAttributedDataPointIndexList[nN]) );
 164                     if( xPointProp.is() )
 165                     {
 166                         DataPointLabel aLabel;
 167                         xPointProp->getPropertyValue(CHART_UNONAME_LABEL) >>= aLabel;
 168                         aLabel.ShowNumber = bInsert;
 169                         if( !bInsert )
 170                         {
 171                             aLabel.ShowNumberInPercent = false;
 172                             aLabel.ShowCategoryName = false;
 173                         }
 174                         xPointProp->setPropertyValue(CHART_UNONAME_LABEL, uno::Any(aLabel));
 175                     }
 176                 }
 177             }
 178         }
 179     }
 180     catch(const uno::Exception &)
 181     {
 182         TOOLS_WARN_EXCEPTION("chart2", "" );
 183     }
 184 }
 185
 186 } // anonymous namespace
 187
 188 namespace chart
 189 {
 190
 191 namespace DataSeriesHelper
 192 {
 193
 194 OUString getRole( const uno::Reference< chart2::data::XLabeledDataSequence >& xLabeledDataSequence )
 195 {
 196     OUString aRet;
 197     if( xLabeledDataSequence.is() )
 198     {
 199         Reference< beans::XPropertySet > xProp( xLabeledDataSequence->getValues(), uno::UNO_QUERY );
 200         if( xProp.is() )
 201             xProp->getPropertyValue( "Role" ) >>= aRet;
 202     }
 203     return aRet;
 204 }
 205
 206 Reference< chart2::data::XLabeledDataSequence >
 207     getDataSequenceByRole(
 208         const Reference< chart2::data::XDataSource > & xSource,
 209         const OUString& aRole,
 210         bool bMatchPrefix /* = false */ )
 211 {
 212     Reference< chart2::data::XLabeledDataSequence > aNoResult;
 213     if( ! xSource.is())
 214         return aNoResult;
 215     Sequence< Reference< chart2::data::XLabeledDataSequence > > aLabeledSeq( xSource->getDataSequences());
 216
 217     const Reference< chart2::data::XLabeledDataSequence > * pBegin = aLabeledSeq.getConstArray();
 218     const Reference< chart2::data::XLabeledDataSequence > * pEnd = pBegin + aLabeledSeq.getLength();
 219     const Reference< chart2::data::XLabeledDataSequence > * pMatch =
 220         std::find_if( pBegin, pEnd, lcl_MatchesRole( aRole, bMatchPrefix ));
 221
 222     if( pMatch != pEnd )
 223         return *pMatch;
 224
 225     return aNoResult;
 226 }
 227
 228 std::vector< Reference< chart2::data::XLabeledDataSequence > >
 229     getAllDataSequencesByRole( const Sequence< Reference< chart2::data::XLabeledDataSequence > > & aDataSequences,
 230                                const OUString& aRole )
 231 {
 232     std::vector< Reference< chart2::data::XLabeledDataSequence > > aResultVec;
 233     std::copy_if( aDataSequences.begin(), aDataSequences.end(),
 234                            std::back_inserter( aResultVec ),
 235                            lcl_MatchesRole(aRole, /*bMatchPrefix*/true) );
 236     return aResultVec;
 237 }
 238
 239 std::vector<Reference<css::chart2::data::XLabeledDataSequence> >
 240 getAllDataSequences( const uno::Sequence<uno::Reference<chart2::XDataSeries> >& aSeries )
 241 {
 242     std::vector< Reference< chart2::data::XLabeledDataSequence > > aSeqVec;
 243
 244     for( sal_Int32 i = 0; i < aSeries.getLength(); ++i )
 245     {
 246         Reference< chart2::data::XDataSource > xSource( aSeries[ i ], uno::UNO_QUERY );
 247         if( xSource.is())
 248         {
 249             Sequence< Reference< chart2::data::XLabeledDataSequence > > aSeq( xSource->getDataSequences());
 250             std::copy( aSeq.begin(), aSeq.end(),
 251                          std::back_inserter( aSeqVec ));
 252         }
 253     }
 254
 255     return aSeqVec;
 256 }
 257
 258 Reference< chart2::data::XDataSource >
 259     getDataSource( const Sequence< Reference< chart2::XDataSeries > > & aSeries )
 260 {
 261     return Reference< chart2::data::XDataSource >(
 262         new DataSource(comphelper::containerToSequence(getAllDataSequences(aSeries))));
 263 }
 264
 265 namespace
 266 {
 267 OUString lcl_getDataSequenceLabel( const Reference< chart2::data::XDataSequence > & xSequence )
 268 {
 269     OUString aResult;
 270
 271     Reference< chart2::data::XTextualDataSequence > xTextSeq( xSequence, uno::UNO_QUERY );
 272     if( xTextSeq.is())
 273     {
 274         Sequence< OUString > aSeq( xTextSeq->getTextualData());
 275
 276         const sal_Int32 nMax = aSeq.getLength() - 1;
 277         OUStringBuffer aBuf;
 278
 279         for( sal_Int32 i = 0; i <= nMax; ++i )
 280         {
 281             aBuf.append( aSeq[i] );
 282             if( i < nMax )
 283                 aBuf.append( ' ');
 284         }
 285         aResult = aBuf.makeStringAndClear();
 286     }
 287     else if( xSequence.is())
 288     {
 289         Sequence< uno::Any > aSeq( xSequence->getData());
 290
 291         const sal_Int32 nMax = aSeq.getLength() - 1;
 292         OUString aVal;
 293         OUStringBuffer aBuf;
 294         double fNum = 0;
 295
 296         for( sal_Int32 i = 0; i <= nMax; ++i )
 297         {
 298             if( aSeq[i] >>= aVal )
 299             {
 300                 aBuf.append( aVal );
 301                 if( i < nMax )
 302                     aBuf.append(  ' ');
 303             }
 304             else if( aSeq[ i ] >>= fNum )
 305             {
 306                 aBuf.append( fNum );
 307                 if( i < nMax )
 308                     aBuf.append( ' ');
 309             }
 310         }
 311         aResult = aBuf.makeStringAndClear();
 312     }
 313
 314     return aResult;
 315 }
 316 }
 317
 318 OUString getLabelForLabeledDataSequence(
 319     const Reference< chart2::data::XLabeledDataSequence > & xLabeledSeq )
 320 {
 321     OUString aResult;
 322     if( xLabeledSeq.is())
 323     {
 324         Reference< chart2::data::XDataSequence > xSeq( xLabeledSeq->getLabel());
 325         if( xSeq.is() )
 326             aResult = lcl_getDataSequenceLabel( xSeq );
 327         if( !xSeq.is() || aResult.isEmpty() )
 328         {
 329             // no label set or label content is empty -> use auto-generated one
 330             Reference< chart2::data::XDataSequence > xValueSeq( xLabeledSeq->getValues() );
 331             if( xValueSeq.is() )
 332             {
 333                 Sequence< OUString > aLabels( xValueSeq->generateLabel(
 334                     chart2::data::LabelOrigin_SHORT_SIDE ) );
 335                 // no labels returned is interpreted as: auto-generation not
 336                 // supported by sequence
 337                 if( aLabels.hasElements() )
 338                     aResult=aLabels[0];
 339                 else
 340                 {
 341                     //todo?: maybe use the index of the series as name
 342                     //but as the index may change it would be better to have such a name persistent
 343                     //what is not possible at the moment
 344                     //--> maybe use the identifier as part of the name ...
 345                     aResult = lcl_getDataSequenceLabel( xValueSeq );
 346                 }
 347             }
 348         }
 349     }
 350     return aResult;
 351 }
 352
 353 OUString getDataSeriesLabel(
 354     const Reference< chart2::XDataSeries > & xSeries,
 355     const OUString & rLabelSequenceRole )
 356 {
 357     OUString aResult;
 358
 359     Reference< chart2::data::XDataSource > xSource( xSeries, uno::UNO_QUERY );
 360     if( xSource.is())
 361     {
 362         Reference< chart2::data::XLabeledDataSequence > xLabeledSeq(
 363             ::chart::DataSeriesHelper::getDataSequenceByRole( xSource, rLabelSequenceRole ));
 364         if( xLabeledSeq.is())
 365             aResult = getLabelForLabeledDataSequence( xLabeledSeq );
 366         else
 367         {
 368             // special case: labeled data series with only a label and no values may
 369             // serve as label
 370             xLabeledSeq.set( lcl_findLSequenceWithOnlyLabel( xSource ));
 371             if( xLabeledSeq.is())
 372             {
 373                 Reference< chart2::data::XDataSequence > xSeq( xLabeledSeq->getLabel());
 374                 if( xSeq.is())
 375                     aResult = lcl_getDataSequenceLabel( xSeq );
 376             }
 377         }
 378
 379     }
 380
 381     return aResult;
 382 }
 383
 384 void setStackModeAtSeries(
 385     const Sequence< Reference< chart2::XDataSeries > > & aSeries,
 386     const Reference< chart2::XCoordinateSystem > & xCorrespondingCoordinateSystem,
 387     StackMode eStackMode )
 388 {
 389     const uno::Any aPropValue(
 390         ( (eStackMode == StackMode::YStacked) ||
 391           (eStackMode == StackMode::YStackedPercent) )
 392         ? chart2::StackingDirection_Y_STACKING
 393         : (eStackMode == StackMode::ZStacked )
 394         ? chart2::StackingDirection_Z_STACKING
 395         : chart2::StackingDirection_NO_STACKING );
 396
 397     std::set< sal_Int32 > aAxisIndexSet;
 398     for( sal_Int32 i=0; i<aSeries.getLength(); ++i )
 399     {
 400         try
 401         {
 402             Reference< beans::XPropertySet > xProp( aSeries[i], uno::UNO_QUERY );
 403             if( xProp.is() )
 404             {
 405                 xProp->setPropertyValue( "StackingDirection", aPropValue );
 406
 407                 sal_Int32 nAxisIndex;
 408                 xProp->getPropertyValue( "AttachedAxisIndex" ) >>= nAxisIndex;
 409                 aAxisIndexSet.insert(nAxisIndex);
 410             }
 411         }
 412         catch( const uno::Exception & )
 413         {
 414             DBG_UNHANDLED_EXCEPTION("chart2");
 415         }
 416     }
 417
 418     if( xCorrespondingCoordinateSystem.is() &&
 419         1 < xCorrespondingCoordinateSystem->getDimension() )
 420     {
 421         if( aAxisIndexSet.empty() )
 422         {
 423             aAxisIndexSet.insert(0);
 424         }
 425
 426         for (auto const& axisIndex : aAxisIndexSet)
 427         {
 428             Reference< chart2::XAxis > xAxis(
 429                 xCorrespondingCoordinateSystem->getAxisByDimension(1, axisIndex));
 430             if( xAxis.is())
 431             {
 432                 bool bPercent = (eStackMode == StackMode::YStackedPercent);
 433                 chart2::ScaleData aScaleData = xAxis->getScaleData();
 434
 435                 if( bPercent != (aScaleData.AxisType==chart2::AxisType::PERCENT) )
 436                 {
 437                     if( bPercent )
 438                         aScaleData.AxisType = chart2::AxisType::PERCENT;
 439                     else
 440                         aScaleData.AxisType = chart2::AxisType::REALNUMBER;
 441                     xAxis->setScaleData( aScaleData );
 442                 }
 443             }
 444         }
 445     }
 446 }
 447
 448 sal_Int32 getAttachedAxisIndex( const Reference< chart2::XDataSeries > & xSeries )
 449 {
 450     sal_Int32 nRet = 0;
 451     try
 452     {
 453         Reference< beans::XPropertySet > xProp( xSeries, uno::UNO_QUERY );
 454         if( xProp.is() )
 455         {
 456             xProp->getPropertyValue( "AttachedAxisIndex" ) >>= nRet;
 457         }
 458     }
 459     catch( const uno::Exception & )
 460     {
 461         DBG_UNHANDLED_EXCEPTION("chart2");
 462     }
 463     return nRet;
 464 }
 465
 466 sal_Int32 getNumberFormatKeyFromAxis(
 467     const Reference< chart2::XDataSeries > & xSeries,
 468     const Reference< chart2::XCoordinateSystem > & xCorrespondingCoordinateSystem,
 469     sal_Int32 nDimensionIndex,
 470     sal_Int32 nAxisIndex /* = -1 */ )
 471 {
 472     sal_Int32 nResult =  0;
 473     if( nAxisIndex == -1 )
 474         nAxisIndex = getAttachedAxisIndex( xSeries );
 475     try
 476     {
 477         Reference< beans::XPropertySet > xAxisProp(
 478             xCorrespondingCoordinateSystem->getAxisByDimension( nDimensionIndex, nAxisIndex ), uno::UNO_QUERY );
 479         if( xAxisProp.is())
 480             xAxisProp->getPropertyValue(CHART_UNONAME_NUMFMT) >>= nResult;
 481     }
 482     catch( const uno::Exception & )
 483     {
 484         DBG_UNHANDLED_EXCEPTION("chart2");
 485     }
 486
 487     return nResult;
 488 }
 489
 490 Reference< chart2::XCoordinateSystem > getCoordinateSystemOfSeries(
 491     const Reference< chart2::XDataSeries > & xSeries,
 492     const Reference< chart2::XDiagram > & xDiagram )
 493 {
 494     Reference< chart2::XCoordinateSystem > xResult;
 495     Reference< chart2::XChartType > xDummy;
 496     lcl_getCooSysAndChartTypeOfSeries( xSeries, xDiagram, xResult, xDummy );
 497
 498     return xResult;
 499 }
 500
 501 Reference< chart2::XChartType > getChartTypeOfSeries(
 502     const Reference< chart2::XDataSeries > & xSeries,
 503     const Reference< chart2::XDiagram > & xDiagram )
 504 {
 505     Reference< chart2::XChartType > xResult;
 506     Reference< chart2::XCoordinateSystem > xDummy;
 507     lcl_getCooSysAndChartTypeOfSeries( xSeries, xDiagram, xDummy, xResult );
 508
 509     return xResult;
 510 }
 511
 512 void deleteSeries(
 513     const Reference< chart2::XDataSeries > & xSeries,
 514     const Reference< chart2::XChartType > & xChartType )
 515 {
 516     try
 517     {
 518         Reference< chart2::XDataSeriesContainer > xSeriesCnt( xChartType, uno::UNO_QUERY_THROW );
 519         auto aSeries(
 520             comphelper::sequenceToContainer<std::vector< Reference< chart2::XDataSeries > > >( xSeriesCnt->getDataSeries()));
 521         std::vector< Reference< chart2::XDataSeries > >::iterator aIt =
 522               std::find( aSeries.begin(), aSeries.end(), xSeries );
 523         if( aIt != aSeries.end())
 524         {
 525             aSeries.erase( aIt );
 526             xSeriesCnt->setDataSeries( comphelper::containerToSequence( aSeries ));
 527         }
 528     }
 529     catch( const uno::Exception & )
 530     {
 531         DBG_UNHANDLED_EXCEPTION("chart2");
 532     }
 533 }
 534
 535 void switchSymbolsOnOrOff( const Reference< beans::XPropertySet > & xSeriesProperties,
 536                     bool bSymbolsOn, sal_Int32 nSeriesIndex )
 537 {
 538     if( !xSeriesProperties.is() )
 539         return;
 540
 541     chart2::Symbol aSymbProp;
 542     if( xSeriesProperties->getPropertyValue( "Symbol") >>= aSymbProp )
 543     {
 544         if( !bSymbolsOn )
 545             aSymbProp.Style = chart2::SymbolStyle_NONE;
 546         else if( aSymbProp.Style == chart2::SymbolStyle_NONE )
 547         {
 548             aSymbProp.Style = chart2::SymbolStyle_STANDARD;
 549             aSymbProp.StandardSymbol = nSeriesIndex;
 550         }
 551         xSeriesProperties->setPropertyValue( "Symbol", uno::Any( aSymbProp ));
 552     }
 553     //todo: check attributed data points
 554 }
 555
 556 void switchLinesOnOrOff( const Reference< beans::XPropertySet > & xSeriesProperties, bool bLinesOn )
 557 {
 558     if( !xSeriesProperties.is() )
 559         return;
 560
 561     if( bLinesOn )
 562     {
 563         // keep line-styles that are not NONE
 564         drawing::LineStyle eLineStyle;
 565         if( (xSeriesProperties->getPropertyValue( "LineStyle") >>= eLineStyle ) &&
 566             eLineStyle == drawing::LineStyle_NONE )
 567         {
 568             xSeriesProperties->setPropertyValue( "LineStyle", uno::Any( drawing::LineStyle_SOLID ) );
 569         }
 570     }
 571     else
 572         xSeriesProperties->setPropertyValue( "LineStyle", uno::Any( drawing::LineStyle_NONE ) );
 573 }
 574
 575 void makeLinesThickOrThin( const Reference< beans::XPropertySet > & xSeriesProperties, bool bThick )
 576 {
 577     if( !xSeriesProperties.is() )
 578         return;
 579
 580     sal_Int32 nNewValue = bThick ? 80 : 0;
 581     sal_Int32 nOldValue = 0;
 582     if( (xSeriesProperties->getPropertyValue( "LineWidth") >>= nOldValue ) &&
 583         nOldValue != nNewValue )
 584     {
 585         if( !(bThick && nOldValue>0))
 586             xSeriesProperties->setPropertyValue( "LineWidth", uno::Any( nNewValue ) );
 587     }
 588 }
 589
 590 void setPropertyAlsoToAllAttributedDataPoints( const Reference< chart2::XDataSeries >& xSeries,
 591                                               const OUString& rPropertyName, const uno::Any& rPropertyValue )
 592 {
 593     Reference< beans::XPropertySet > xSeriesProperties( xSeries, uno::UNO_QUERY );
 594     if( !xSeriesProperties.is() )
 595         return;
 596
 597     xSeriesProperties->setPropertyValue( rPropertyName, rPropertyValue );
 598     uno::Sequence< sal_Int32 > aAttributedDataPointIndexList;
 599     if( xSeriesProperties->getPropertyValue( "AttributedDataPoints" ) >>= aAttributedDataPointIndexList )
 600     {
 601         for(sal_Int32 nN=aAttributedDataPointIndexList.getLength();nN--;)
 602         {
 603             Reference< beans::XPropertySet > xPointProp( xSeries->getDataPointByIndex(aAttributedDataPointIndexList[nN]) );
 604             if(!xPointProp.is())
 605                 continue;
 606             xPointProp->setPropertyValue( rPropertyName, rPropertyValue );
 607         }
 608     }
 609 }
 610
 611 bool hasAttributedDataPointDifferentValue( const Reference< chart2::XDataSeries >& xSeries,
 612                                               const OUString& rPropertyName, const uno::Any& rPropertyValue )
 613 {
 614     Reference< beans::XPropertySet > xSeriesProperties( xSeries, uno::UNO_QUERY );
 615     if( !xSeriesProperties.is() )
 616         return false;
 617
 618     uno::Sequence< sal_Int32 > aAttributedDataPointIndexList;
 619     if( xSeriesProperties->getPropertyValue( "AttributedDataPoints" ) >>= aAttributedDataPointIndexList )
 620     {
 621         for(sal_Int32 nN=aAttributedDataPointIndexList.getLength();nN--;)
 622         {
 623             Reference< beans::XPropertySet > xPointProp( xSeries->getDataPointByIndex(aAttributedDataPointIndexList[nN]) );
 624             if(!xPointProp.is())
 625                 continue;
 626             uno::Any aPointValue( xPointProp->getPropertyValue( rPropertyName ) );
 627             if( rPropertyValue != aPointValue )
 628                 return true;
 629         }
 630     }
 631     return false;
 632 }
 633
 634 namespace
 635 {
 636
 637 bool lcl_SequenceHasUnhiddenData( const uno::Reference< chart2::data::XDataSequence >& xDataSequence )
 638 {
 639     if( !xDataSequence.is() )
 640         return false;
 641     uno::Reference< beans::XPropertySet > xProp( xDataSequence, uno::UNO_QUERY );
 642     if( xProp.is() )
 643     {
 644         uno::Sequence< sal_Int32 > aHiddenValues;
 645         try
 646         {
 647             xProp->getPropertyValue( "HiddenValues" ) >>= aHiddenValues;
 648             if( !aHiddenValues.hasElements() )
 649                 return true;
 650         }
 651         catch( const uno::Exception& )
 652         {
 653             return true;
 654         }
 655     }
 656     return xDataSequence->getData().hasElements();
 657 }
 658
 659 }
 660
 661 bool hasUnhiddenData( const uno::Reference< chart2::XDataSeries >& xSeries )
 662 {
 663     uno::Reference< chart2::data::XDataSource > xDataSource( xSeries, uno::UNO_QUERY );
 664
 665     uno::Sequence< uno::Reference< chart2::data::XLabeledDataSequence > > aDataSequences = xDataSource->getDataSequences();
 666
 667     for(sal_Int32 nN = aDataSequences.getLength();nN--;)
 668     {
 669         if( !aDataSequences[nN].is() )
 670             continue;
 671         if( lcl_SequenceHasUnhiddenData( aDataSequences[nN]->getValues() ) )
 672             return true;
 673         if( lcl_SequenceHasUnhiddenData( aDataSequences[nN]->getLabel() ) )
 674             return true;
 675     }
 676     return false;
 677 }
 678
 679 sal_Int32 translateIndexFromHiddenToFullSequence( sal_Int32 nIndex, const Reference< chart2::data::XDataSequence >& xDataSequence, bool bTranslate )
 680 {
 681     if( !bTranslate )
 682         return nIndex;
 683
 684     try
 685     {
 686         uno::Reference<beans::XPropertySet> xProp( xDataSequence, uno::UNO_QUERY );
 687         if( xProp.is())
 688         {
 689             Sequence<sal_Int32> aHiddenIndicesSeq;
 690             xProp->getPropertyValue( "HiddenValues" ) >>= aHiddenIndicesSeq;
 691             if( aHiddenIndicesSeq.hasElements() )
 692             {
 693                 auto aHiddenIndices( comphelper::sequenceToContainer<std::vector< sal_Int32 >>( aHiddenIndicesSeq ) );
 694                 std::sort( aHiddenIndices.begin(), aHiddenIndices.end() );
 695
 696                 sal_Int32 nHiddenCount = static_cast<sal_Int32>(aHiddenIndices.size());
 697                 for( sal_Int32 nN = 0; nN < nHiddenCount; ++nN)
 698                 {
 699                     if( aHiddenIndices[nN] <= nIndex )
 700                         nIndex += 1;
 701                     else
 702                         break;
 703                 }
 704             }
 705         }
 706     }
 707     catch (const beans::UnknownPropertyException&)
 708     {
 709     }
 710     return nIndex;
 711 }
 712
 713 bool hasDataLabelsAtSeries( const Reference< chart2::XDataSeries >& xSeries )
 714 {
 715     bool bRet = false;
 716     try
 717     {
 718         Reference< beans::XPropertySet > xProp( xSeries, uno::UNO_QUERY );
 719         if( xProp.is() )
 720         {
 721             DataPointLabel aLabel;
 722             if( xProp->getPropertyValue(CHART_UNONAME_LABEL) >>= aLabel )
 723                 bRet = aLabel.ShowNumber || aLabel.ShowNumberInPercent || aLabel.ShowCategoryName;
 724         }
 725     }
 726     catch(const uno::Exception &)
 727     {
 728         TOOLS_WARN_EXCEPTION("chart2", "" );
 729     }
 730     return bRet;
 731 }
 732
 733 bool hasDataLabelsAtPoints( const Reference< chart2::XDataSeries >& xSeries )
 734 {
 735     bool bRet = false;
 736     try
 737     {
 738         Reference< beans::XPropertySet > xSeriesProperties( xSeries, uno::UNO_QUERY );
 739         if( xSeriesProperties.is() )
 740         {
 741             uno::Sequence< sal_Int32 > aAttributedDataPointIndexList;
 742             if( xSeriesProperties->getPropertyValue( "AttributedDataPoints" ) >>= aAttributedDataPointIndexList )
 743             {
 744                 for(sal_Int32 nN=aAttributedDataPointIndexList.getLength();nN--;)
 745                 {
 746                     Reference< beans::XPropertySet > xPointProp( xSeries->getDataPointByIndex(aAttributedDataPointIndexList[nN]) );
 747                     if( xPointProp.is() )
 748                     {
 749                         DataPointLabel aLabel;
 750                         if( xPointProp->getPropertyValue(CHART_UNONAME_LABEL) >>= aLabel )
 751                             bRet = aLabel.ShowNumber || aLabel.ShowNumberInPercent || aLabel.ShowCategoryName;
 752                         if( bRet )
 753                             break;
 754                     }
 755                 }
 756             }
 757         }
 758     }
 759     catch(const uno::Exception &)
 760     {
 761         TOOLS_WARN_EXCEPTION("chart2", "" );
 762     }
 763     return bRet;
 764 }
 765
 766 bool hasDataLabelAtPoint( const Reference< chart2::XDataSeries >& xSeries, sal_Int32 nPointIndex )
 767 {
 768     bool bRet = false;
 769     try
 770     {
 771         Reference< beans::XPropertySet > xProp;
 772         Reference< beans::XPropertySet > xSeriesProperties( xSeries, uno::UNO_QUERY );
 773         if( xSeriesProperties.is() )
 774         {
 775             uno::Sequence< sal_Int32 > aAttributedDataPointIndexList;
 776             if( xSeriesProperties->getPropertyValue( "AttributedDataPoints" ) >>= aAttributedDataPointIndexList )
 777             {
 778                 auto aIndices( comphelper::sequenceToContainer<std::vector< sal_Int32 >>( aAttributedDataPointIndexList ) );
 779                 std::vector< sal_Int32 >::iterator aIt = std::find( aIndices.begin(), aIndices.end(), nPointIndex );
 780                 if( aIt != aIndices.end())
 781                     xProp = xSeries->getDataPointByIndex(nPointIndex);
 782                 else
 783                     xProp = xSeriesProperties;
 784             }
 785             if( xProp.is() )
 786             {
 787                 DataPointLabel aLabel;
 788                 if( xProp->getPropertyValue(CHART_UNONAME_LABEL) >>= aLabel )
 789                     bRet = aLabel.ShowNumber || aLabel.ShowNumberInPercent || aLabel.ShowCategoryName;
 790             }
 791         }
 792     }
 793     catch(const uno::Exception &)
 794     {
 795         TOOLS_WARN_EXCEPTION("chart2", "" );
 796     }
 797     return bRet;
 798 }
 799
 800 void insertDataLabelsToSeriesAndAllPoints( const Reference< chart2::XDataSeries >& xSeries )
 801 {
 802     lcl_insertOrDeleteDataLabelsToSeriesAndAllPoints( xSeries, true /*bInsert*/ );
 803 }
 804
 805 void deleteDataLabelsFromSeriesAndAllPoints( const Reference< chart2::XDataSeries >& xSeries )
 806 {
 807     lcl_insertOrDeleteDataLabelsToSeriesAndAllPoints( xSeries, false /*bInsert*/ );
 808 }
 809
 810 void insertDataLabelToPoint( const Reference< beans::XPropertySet >& xPointProp )
 811 {
 812     try
 813     {
 814         if( xPointProp.is() )
 815         {
 816             DataPointLabel aLabel;
 817             xPointProp->getPropertyValue(CHART_UNONAME_LABEL) >>= aLabel;
 818             aLabel.ShowNumber = true;
 819             xPointProp->setPropertyValue(CHART_UNONAME_LABEL, uno::Any(aLabel));
 820         }
 821     }
 822     catch(const uno::Exception &)
 823     {
 824         TOOLS_WARN_EXCEPTION("chart2", "" );
 825     }
 826 }
 827
 828 void deleteDataLabelsFromPoint( const Reference< beans::XPropertySet >& xPointProp )
 829 {
 830     try
 831     {
 832         if( xPointProp.is() )
 833         {
 834             DataPointLabel aLabel;
 835             xPointProp->getPropertyValue(CHART_UNONAME_LABEL) >>= aLabel;
 836             aLabel.ShowNumber = false;
 837             aLabel.ShowNumberInPercent = false;
 838             aLabel.ShowCategoryName = false;
 839             xPointProp->setPropertyValue(CHART_UNONAME_LABEL, uno::Any(aLabel));
 840         }
 841     }
 842     catch(const uno::Exception &)
 843     {
 844         TOOLS_WARN_EXCEPTION("chart2", "" );
 845     }
 846 }
 847
 848 } //  namespace DataSeriesHelper
 849 } //  namespace chart
 850
 851 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */