LCOV - code coverage report
Current view: top level - chart2/source/tools - DataSeriesHelper.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 441 0.0 %
Date: 2014-04-14 Functions: 0 37 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10